tutti/packages/connector/runtime/release_installer_test.go

package runtime

import (
	"archive/zip"
	"bytes"
	"context"
	"crypto/sha256"
	"encoding/hex"
	"errors"
	"io"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"

	market "github.com/tutti-os/tutti/packages/connector/daemon/core"
	connectorartifact "github.com/tutti-os/tutti/packages/connector/runtime/artifact"
)

type releaseArtifactStub struct {
	prepared         market.PreparedArtifactReceipt
	releaseRemoves   int
	connectorRemoves int
}

func (stub *releaseArtifactStub) Prepare(_ context.Context, request market.PrepareArtifactRequest) (market.PreparedArtifactReceipt, error) {
	receipt := stub.prepared
	receipt.OperationID = request.OperationID
	return receipt, nil
}

func (stub *releaseArtifactStub) ResolvePrepared(_ context.Context, release market.Release) (market.PreparedArtifactReceipt, error) {
	receipt := stub.prepared
	receipt.ConnectorKey = release.ConnectorKey
	receipt.Version = release.Version
	receipt.ReleaseDigest = release.ReleaseDigest
	receipt.ArtifactSHA256 = release.Artifact.SHA256
	return receipt, nil
}

func (stub *releaseArtifactStub) Remove(context.Context, market.RemoveArtifactRequest) error {
	stub.releaseRemoves++
	return nil
}

func (stub *releaseArtifactStub) RemoveConnector(context.Context, market.RemoveConnectorInstallationRequest) error {
	stub.connectorRemoves++
	return nil
}

func TestReleaseInstallerDoesNotActivateRuntime(t *testing.T) {
	release := runtimeTestRelease()
	artifacts := &releaseArtifactStub{prepared: market.PreparedArtifactReceipt{
		ConnectorKey: release.ConnectorKey, Version: release.Version, ReleaseDigest: release.ReleaseDigest,
		ArtifactSHA256: release.Artifact.SHA256,
	}}
	installer, err := NewReleaseInstaller(artifacts, nil)
	if err != nil {
		t.Fatal(err)
	}
	receipt, err := installer.InstallRelease(context.Background(), market.InstallReleaseRequest{
		OperationID: "install-1", Release: release,
	})
	if err != nil {
		t.Fatal(err)
	}
	if receipt.ReleaseDigest != release.ReleaseDigest || receipt.CLIInstallation != nil {
		t.Fatalf("receipt = %#v", receipt)
	}
}

func TestReleaseInstallerUninstallRemovesPreparedArtifact(t *testing.T) {
	release := runtimeTestRelease()
	artifacts := &releaseArtifactStub{}
	installer, err := NewReleaseInstaller(artifacts, nil)
	if err != nil {
		t.Fatal(err)
	}
	if err := installer.UninstallRelease(context.Background(), market.UninstallReleaseRequest{
		OperationID: "uninstall-1",
		Release:     release,
	}); err != nil {
		t.Fatal(err)
	}
	if artifacts.connectorRemoves != 1 || artifacts.releaseRemoves != 0 {
		t.Fatalf("artifact connector/release removes = %d/%d, want 1/0", artifacts.connectorRemoves, artifacts.releaseRemoves)
	}
}

func TestReleaseInstallerUninstallRemovesReleaseWithObsoleteIcon(t *testing.T) {
	release := runtimeTestRelease()
	release.Manifest.IconURL = "data:image/png;base64,iVBORw0KGgo="
	artifacts := &releaseArtifactStub{}
	installer, err := NewReleaseInstaller(artifacts, nil)
	if err != nil {
		t.Fatal(err)
	}
	if err := installer.UninstallRelease(context.Background(), market.UninstallReleaseRequest{
		OperationID: "uninstall-obsolete-icon",
		Release:     release,
	}); err != nil {
		t.Fatal(err)
	}
	if artifacts.connectorRemoves != 1 {
		t.Fatalf("artifact connector removes = %d, want 1", artifacts.connectorRemoves)
	}
}

func TestReleaseInstallerUninstallRemovesEveryConnectorRelease(t *testing.T) {
	runtimeRoot := t.TempDir()
	nodePath := filepath.Join(runtimeRoot, "node", "bin", "node")
	corepackPath := filepath.Join(runtimeRoot, "node", "lib", "node_modules", "corepack", "dist", "corepack.js")
	for _, path := range []string{nodePath, corepackPath} {
		if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
			t.Fatal(err)
		}
		if err := os.WriteFile(path, []byte("managed"), 0o700); err != nil {
			t.Fatal(err)
		}
	}
	manifest := []byte(`{"schemaVersion":"1","connectorKey":"lark"}`)
	firstArchive := releaseInstallerTestZIP(t, manifest, "v1")
	secondArchive := releaseInstallerTestZIP(t, manifest, "v2")
	first := releaseInstallerNodeRelease("1.0.0", strings.Repeat("1", 64), firstArchive, manifest)
	second := releaseInstallerNodeRelease("2.0.0", strings.Repeat("2", 64), secondArchive, manifest)
	stateRoot := t.TempDir()
	artifacts, err := connectorartifact.NewPreparer(connectorartifact.Config{
		RootDir: filepath.Join(stateRoot, "artifacts"),
		Fetcher: releaseInstallerFetcher{archives: map[string][]byte{
			first.ReleaseDigest: firstArchive, second.ReleaseDigest: secondArchive,
		}},
	})
	if err != nil {
		t.Fatal(err)
	}
	cliRoot := filepath.Join(stateRoot, "node-packages")
	cli, err := NewNodePackageInstaller(NodePackageInstallerConfig{
		RootDir: cliRoot,
		Runtimes: nodePackageRuntimeStub{root: runtimeRoot, node: ConnectorExecutable{
			Path: nodePath, SHA256: strings.Repeat("a", 64), SizeBytes: 7,
		}},
		Processes: &nodePackageProcessStub{},
	})
	if err != nil {
		t.Fatal(err)
	}
	installer, err := NewReleaseInstaller(artifacts, cli)
	if err != nil {
		t.Fatal(err)
	}
	firstReceipt, err := installer.InstallRelease(context.Background(), market.InstallReleaseRequest{
		OperationID: "install-v1", Release: first,
	})
	if err != nil {
		t.Fatal(err)
	}
	secondReceipt, err := installer.InstallRelease(context.Background(), market.InstallReleaseRequest{
		OperationID: "install-v2", Release: second,
	})
	if err != nil {
		t.Fatal(err)
	}
	for _, path := range []string{
		firstReceipt.Artifact.PreparedPath,
		firstReceipt.CLIInstallation.InstallRoot,
		secondReceipt.Artifact.PreparedPath,
		secondReceipt.CLIInstallation.InstallRoot,
	} {
		if _, err := os.Stat(path); err != nil {
			t.Fatalf("installed release path %q is unavailable: %v", path, err)
		}
	}
	sharedMarker := filepath.Join(cliRoot, "shared", "pnpm-store", "shared-marker")
	if err := os.WriteFile(sharedMarker, []byte("shared"), 0o600); err != nil {
		t.Fatal(err)
	}
	if err := installer.UninstallRelease(context.Background(), market.UninstallReleaseRequest{
		OperationID: "uninstall", Release: second,
	}); err != nil {
		t.Fatal(err)
	}
	for _, path := range []string{
		filepath.Join(stateRoot, "artifacts", "prepared", first.ConnectorKey),
		filepath.Join(cliRoot, "packages", first.ConnectorKey),
		filepath.Join(stateRoot, "artifacts", "cache", first.ConnectorKey),
	} {
		if _, err := os.Stat(path); !errors.Is(err, os.ErrNotExist) {
			t.Fatalf("Connector uninstall retained %q: %v", path, err)
		}
	}
	if content, err := os.ReadFile(sharedMarker); err != nil || string(content) != "shared" {
		t.Fatalf("Connector uninstall changed shared package storage: %q, %v", content, err)
	}
}

type releaseInstallerFetcher struct{ archives map[string][]byte }

func (fetcher releaseInstallerFetcher) Fetch(_ context.Context, request connectorartifact.FetchRequest) (connectorartifact.FetchResponse, error) {
	archive := fetcher.archives[request.Release.ReleaseDigest]
	return connectorartifact.FetchResponse{
		Body: io.NopCloser(bytes.NewReader(archive)), ContentLength: int64(len(archive)), MediaType: "application/zip",
	}, nil
}

func releaseInstallerTestZIP(t *testing.T, manifest []byte, version string) []byte {
	t.Helper()
	var output bytes.Buffer
	writer := zip.NewWriter(&output)
	for path, content := range map[string][]byte{
		"connector-manifest.json": manifest,
		"connector.js":            []byte("// " + version),
	} {
		entry, err := writer.Create(path)
		if err != nil {
			t.Fatal(err)
		}
		if _, err := entry.Write(content); err != nil {
			t.Fatal(err)
		}
	}
	if err := writer.Close(); err != nil {
		t.Fatal(err)
	}
	return output.Bytes()
}

func releaseInstallerNodeRelease(version, releaseDigest string, archive, manifest []byte) market.Release {
	release := testNodePackageRelease("lark", releaseDigest)
	artifactDigest := sha256.Sum256(archive)
	manifestDigest := sha256.Sum256(manifest)
	release.ReleaseID = release.ConnectorKey + "@" + version
	release.Version = version
	release.ManifestDigest = hex.EncodeToString(manifestDigest[:])
	release.Artifact = market.Artifact{Key: release.ReleaseID + ".zip", SHA256: hex.EncodeToString(artifactDigest[:]),
		SizeBytes: int64(len(archive)), MediaType: "application/zip"}
	return release
}

func runtimeTestRelease() market.Release {
	return market.Release{
		SchemaVersion: "1", ReleaseID: "example@1.0.0", ConnectorKey: "example", Version: "1.0.0",
		ReleaseDigest:  "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
		ManifestDigest: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
		Manifest: market.Manifest{SchemaVersion: "1", DisplayName: "Example",
			IconURL: "https://cdn.example.test/tutti/connector-market/example/1.0.0/example-1.0.0-icon.svg", AuthorizationKind: "none",
			Implementation: market.Implementation{Kind: market.ImplementationKindManagedStdio,
				ManagedStdio: &market.ManagedStdioImplementation{
					Runtime: market.RuntimeRequirement{Language: "node", Profile: "connector-node-static", ABI: "node24-linux-arm64"},
					MCP:     &market.ManagedMCPInterface{Entrypoint: "connector.js"},
				}},
		},
		Artifact: market.Artifact{Key: "example.zip", SHA256: "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
			SizeBytes: 1, MediaType: "application/zip"},
		PublishedAt: time.Date(2026, 8, 7, 0, 0, 0, 0, time.UTC), Status: market.ReleaseStatusAvailable,
	}
}