@stigmer/cli 3.35.0 → 3.37.0

package/src/resources/plugin.test.ts

@@ -1,379 +0,0 @@
-// Pins the plugin directory walker: detection by any of the four manifests,
-// sorted sized entries, the ignore matcher applied (defaults, .gitignore,
-// .stigmerignore), symlinks never followed, and the JSON projection that
-// reduces overlay documents to their paths; then the prepared push (the
-// deterministic archive and its SHA-256, the server's own digest), the
-// install summary renderer (only the kinds installed are counted; the Next
-// section says what each server still needs), and `readNextSteps` against an
-// in-memory backend: a sign-in for an OAuth server without a grant, "signed
-// in" with one, the variables an API-key server wants and where they are
-// asked, the agent an MCP-only plugin still needs, and no line for a server
-// the CLI cannot read.
-
-import {
-  mkdirSync,
-  mkdtempSync,
-  rmSync,
-  symlinkSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { readPluginPackage } from "@stigmer/plugin-package";
-import {
-  describePlugin,
-  isPluginDirectory,
-  readPluginDirectory,
-} from "./plugin.js";
-
-let root: string;
-
-function write(rel: string, content: string): void {
-  const full = join(root, rel);
-  mkdirSync(join(full, ".."), { recursive: true });
-  writeFileSync(full, content);
-}
-
-beforeAll(() => {
-  root = mkdtempSync(join(tmpdir(), "stigmer-plugin-walk-"));
-  write(
-    ".cursor-plugin/plugin.json",
-    JSON.stringify({
-      name: "walker",
-      skills: "./skills/",
-      mcpServers: "./mcp.json",
-      variables: {
-        type: "object",
-        properties: { TOKEN: { type: "string" } },
-        required: ["TOKEN"],
-      },
-    }),
-  );
-  write(
-    "mcp.json",
-    JSON.stringify({
-      mcpServers: {
-        api: {
-          type: "http",
-          url: "https://api.example.com/mcp",
-          headers: { Authorization: "Bearer ${TOKEN}" },
-        },
-      },
-    }),
-  );
-  write(
-    "skills/greet/SKILL.md",
-    "---\nname: greet\ndescription: Says hello.\n---\nSay hello.\n",
-  );
-  write("skills/greet/scripts/hello.sh", "echo hello");
-  write("skills/greet/secrets.yaml", "never: included");
-  write("skills/greet/.env", "SECRET=1");
-  write("node_modules/dep/index.js", "module.exports = 1");
-  write("ai.stigmer/agent.yaml", "kind: Agent\n");
-  write(".gitignore", "*.log\n");
-  write("debug.log", "ignored by .gitignore");
-  write(".stigmerignore", "drafts/\n");
-  write("drafts/idea.md", "ignored by .stigmerignore");
-  symlinkSync(join(root, "mcp.json"), join(root, "mcp-link.json"));
-});
-
-afterAll(() => {
-  rmSync(root, { recursive: true, force: true });
-});
-
-describe("isPluginDirectory", () => {
-  it("is true for a directory holding any of the four manifests and false otherwise", () => {
-    expect(isPluginDirectory(root)).toBe(true);
-    expect(isPluginDirectory(join(root, "skills"))).toBe(false);
-    expect(isPluginDirectory(join(root, "mcp.json"))).toBe(false);
-    expect(isPluginDirectory(join(root, "does-not-exist"))).toBe(false);
-  });
-});
-
-describe("readPluginDirectory", () => {
-  it("lists sorted, sized, contained entries and applies every ignore source", () => {
-    const { files, stats } = readPluginDirectory(root);
-    expect(files.entries.map((e) => e.path)).toEqual([
-      ".cursor-plugin/plugin.json",
-      ".gitignore",
-      ".stigmerignore",
-      "ai.stigmer/agent.yaml",
-      "mcp.json",
-      "skills/greet/SKILL.md",
-      "skills/greet/scripts/hello.sh",
-    ]);
-    expect(
-      files.entries.find((e) => e.path === "skills/greet/scripts/hello.sh")
-        ?.size,
-    ).toBe("echo hello".length);
-    // .env and secrets.yaml (security defaults), debug.log (.gitignore); the
-    // symlink is neither a file nor a directory and is skipped uncounted.
-    expect(stats).toMatchObject({
-      filesIncluded: 7,
-      filesIgnored: 3,
-      dirsSkipped: 2,
-    });
-  });
-
-  it("reads exactly the listed bytes", () => {
-    const { files } = readPluginDirectory(root);
-    expect(new TextDecoder().decode(files.read("ai.stigmer/agent.yaml"))).toBe(
-      "kind: Agent\n",
-    );
-  });
-
-  it("feeds the reader a plugin it accepts", () => {
-    const { files, stats } = readPluginDirectory(root);
-    const outcome = readPluginPackage(files);
-    expect(outcome.ok).toBe(true);
-    if (!outcome.ok) return;
-    const description = describePlugin(outcome.plugin, outcome.warnings, stats);
-    expect(description.plugin.overlay).toEqual({
-      agent: "ai.stigmer/agent.yaml",
-      workflows: [],
-      mcpServers: [],
-    });
-    expect(description.excludedFiles).toBe(3);
-    expect(JSON.stringify(description)).not.toContain("bytes");
-  });
-});
-
-describe("the archive of a walked directory", () => {
-  it("is deterministic and round-trips through the library's own reader", async () => {
-    const { archivePlugin } = await import("@stigmer/plugin-package/client");
-    const { unzipSync } = await import("fflate");
-    const directory = readPluginDirectory(root);
-    const first = archivePlugin(directory.files);
-    const second = archivePlugin(directory.files);
-    expect(Buffer.from(first).equals(Buffer.from(second))).toBe(true);
-    const entries = Object.keys(unzipSync(first)).sort();
-    expect(entries).toEqual(directory.files.entries.map((e) => e.path));
-    expect(entries).not.toContain("debug.log");
-    expect(entries).not.toContain("mcp-link.json");
-  });
-});
-
-describe("preparePluginPush", () => {
-  it("carries the walked archive and its SHA-256, the identity the server records", async () => {
-    const { createHash } = await import("node:crypto");
-    const { preparePluginPush } = await import("./plugin.js");
-    const { archivePlugin } = await import("@stigmer/plugin-package/client");
-    const prepared = await preparePluginPush(root);
-    expect(prepared.plugin.name).toBe("walker");
-    expect(prepared.dir).toBe(root);
-    expect(prepared.stats.filesIgnored).toBe(3);
-    const bytes = archivePlugin(readPluginDirectory(root).files);
-    expect(Buffer.from(prepared.archive).equals(Buffer.from(bytes))).toBe(true);
-    expect(prepared.digest).toBe(createHash("sha256").update(bytes).digest("hex"));
-    expect(prepared.digest).toMatch(/^[a-f0-9]{64}$/);
-  });
-
-  it("refuses offline with the same sentences validate prints", async () => {
-    const { preparePluginPush } = await import("./plugin.js");
-    const broken = mkdtempSync(join(tmpdir(), "stigmer-plugin-broken-"));
-    try {
-      writeFileSync(join(broken, "plugin.json"), JSON.stringify({ name: "Not Valid!" }));
-      await expect(preparePluginPush(broken)).rejects.toThrow(/plugin cannot be installed/);
-    } finally {
-      rmSync(broken, { recursive: true, force: true });
-    }
-  });
-});
-
-describe("renderPushOutcome", () => {
-  it("summarises the install by kind, lists members and carries warnings", async () => {
-    const { renderPushOutcome } = await import("./plugin.js");
-    const { create } = await import("@bufbuild/protobuf");
-    const { PluginSchema } =
-      await import("@stigmer/protos/ai/stigmer/agentic/plugin/v1/api_pb");
-    const { PluginMemberSchema } =
-      await import("@stigmer/protos/ai/stigmer/agentic/plugin/v1/io_pb");
-    const { PluginDialect } =
-      await import("@stigmer/protos/ai/stigmer/agentic/plugin/v1/spec_pb");
-    const { PluginState } =
-      await import("@stigmer/protos/ai/stigmer/agentic/plugin/v1/status_pb");
-    const { ApiResourceKind } =
-      await import("@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb");
-    const { renderResult } = await import("../output/command-result.js");
-
-    const plugin = create(PluginSchema, {
-      metadata: { id: "plg_1", slug: "thermos" },
-      spec: {
-        name: "thermos",
-        version: "1.2.0",
-        dialect: PluginDialect.CURSOR,
-      },
-      status: {
-        digest: "a".repeat(64),
-        state: PluginState.READY,
-        materialized: { skills: 2, mcpServers: 1, agents: 1, workflows: 0 },
-        warnings: [
-          {
-            kind: "model-hint-unresolved",
-            message:
-              "sub-agent 'reviewer' names model 'sonnet'; it runs on the session's model",
-          },
-        ],
-      },
-    });
-    const members = [
-      create(PluginMemberSchema, {
-        kind: ApiResourceKind.skill,
-        id: "skl_1",
-        slug: "review",
-        name: "review",
-      }),
-      create(PluginMemberSchema, {
-        kind: ApiResourceKind.skill,
-        id: "skl_2",
-        slug: "triage",
-        name: "triage",
-      }),
-      create(PluginMemberSchema, {
-        kind: ApiResourceKind.mcp_server,
-        id: "mcp_1",
-        slug: "github",
-        name: "github",
-      }),
-      create(PluginMemberSchema, {
-        kind: ApiResourceKind.agent,
-        id: "agt_1",
-        slug: "thermos",
-        name: "thermos",
-      }),
-    ];
-    const result = renderPushOutcome({ plugin, members, archiveBytes: 2048 });
-    const lines: string[] = [];
-    const original = process.stderr.write.bind(process.stderr);
-    process.stderr.write = ((chunk: string | Uint8Array) => {
-      lines.push(String(chunk));
-      return true;
-    }) as typeof process.stderr.write;
-    try {
-      renderResult(result, "human");
-    } finally {
-      process.stderr.write = original;
-    }
-    const text = lines.join("");
-    expect(text).toContain(
-      "Installed plugin 'thermos' (2 skills, 1 MCP server, 1 agent) with 1 warning",
-    );
-    expect(text).toContain("Skills");
-    expect(text).toContain("review, triage");
-    expect(text).toContain("Cursor plugin");
-    expect(text).toContain("runs on the session's model");
-  });
-});
-
-describe("readNextSteps", () => {
-  it("reads what each server still needs, best-effort, and names the agent an MCP-only plugin lacks", async () => {
-    const { readNextSteps, renderPushOutcome } = await import("./plugin.js");
-    const { create } = await import("@bufbuild/protobuf");
-    const { Code, ConnectError, createRouterTransport } =
-      await import("@connectrpc/connect");
-    const { Stigmer } = await import("@stigmer/sdk");
-    const { McpServerQueryController } =
-      await import("@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/query_pb");
-    const { McpServerSchema } =
-      await import("@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb");
-    const { GetOAuthGrantStatusOutputSchema, OAuthConnectionHealth } =
-      await import("@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/io_pb");
-    const { McpServerAuthSchema, McpServerSpecSchema } =
-      await import("@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/spec_pb");
-    const { EnvVarDeclarationSchema } =
-      await import("@stigmer/protos/ai/stigmer/agentic/environment/v1/spec_pb");
-    const { PluginSchema } =
-      await import("@stigmer/protos/ai/stigmer/agentic/plugin/v1/api_pb");
-    const { PluginMemberSchema } =
-      await import("@stigmer/protos/ai/stigmer/agentic/plugin/v1/io_pb");
-    const { ApiResourceKind } =
-      await import("@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb");
-    const { renderResult } = await import("../output/command-result.js");
-
-    const shapes: Record<string, "oauth" | "oauth-granted" | "api-key" | "open" | "missing"> = {
-      linear: "oauth",
-      notion: "oauth-granted",
-      warmth: "api-key",
-      weather: "open",
-      ghost: "missing",
-    };
-    const transport = createRouterTransport(({ service }) => {
-      service(McpServerQueryController, {
-        getByReference: (ref) => {
-          const shape = shapes[ref.slug];
-          if (shape === undefined || shape === "missing")
-            throw new ConnectError("no server", Code.NotFound);
-          const spec = create(McpServerSpecSchema);
-          if (shape === "oauth" || shape === "oauth-granted") {
-            spec.auth = create(McpServerAuthSchema, { targetEnvVar: "TOKEN", oauthOnly: true });
-            spec.env = { TOKEN: create(EnvVarDeclarationSchema, { isSecret: true }) };
-          }
-          if (shape === "api-key") spec.env = { API_TOKEN: create(EnvVarDeclarationSchema, { isSecret: true }) };
-          return create(McpServerSchema, { metadata: { id: `mcp_${ref.slug}`, org: "acme", slug: ref.slug }, spec });
-        },
-        getOAuthGrantStatus: (input) => {
-          const granted = input.resourceId === "mcp_notion";
-          return create(GetOAuthGrantStatusOutputSchema, {
-            connected: granted,
-            connectionHealth: granted
-              ? OAuthConnectionHealth.OAUTH_CONNECTION_HEALTH_HEALTHY
-              : OAuthConnectionHealth.OAUTH_CONNECTION_HEALTH_NO_GRANT,
-          });
-        },
-      });
-    });
-    const client = new Stigmer({ baseUrl: "/", getAccessToken: () => "t", customTransport: transport });
-    const member = (slug: string) =>
-      create(PluginMemberSchema, { kind: ApiResourceKind.mcp_server, id: `mcp_${slug}`, slug, name: slug });
-
-    const next = await readNextSteps(client, "acme", Object.keys(shapes).map(member));
-    expect(next).toEqual([
-      { kind: "sign-in", server: "linear", command: "stigmer connect mcp-server linear" },
-      { kind: "signed-in", server: "notion" },
-      {
-        kind: "api-key",
-        server: "warmth",
-        variables: ["API_TOKEN"],
-        askedAt: "connect",
-        command: "stigmer connect mcp-server warmth --env API_TOKEN=...",
-      },
-      { kind: "add-to-agent", servers: ["linear", "notion", "warmth", "weather", "ghost"] },
-    ]);
-
-    // With an agent, the variables are the agent's to ask and no agent is missing.
-    const withAgent = await readNextSteps(client, "acme", [
-      member("warmth"),
-      create(PluginMemberSchema, { kind: ApiResourceKind.agent, id: "agt_1", slug: "thermos", name: "thermos" }),
-    ]);
-    expect(withAgent).toEqual([
-      { kind: "api-key", server: "warmth", variables: ["API_TOKEN"], askedAt: "agent" },
-    ]);
-
-    // The renderer names only the kinds installed and prints the Next section.
-    const plugin = create(PluginSchema, {
-      metadata: { id: "plg_1", slug: "linear" },
-      status: { materialized: { skills: 0, mcpServers: 1, agents: 0, workflows: 0 } },
-    });
-    const result = renderPushOutcome(
-      { plugin, members: [member("linear")], archiveBytes: 10 },
-      { next: next.slice(0, 1) },
-    );
-    const lines: string[] = [];
-    const original = process.stderr.write.bind(process.stderr);
-    process.stderr.write = ((chunk: string | Uint8Array) => {
-      lines.push(String(chunk));
-      return true;
-    }) as typeof process.stderr.write;
-    try {
-      renderResult(result, "human");
-    } finally {
-      process.stderr.write = original;
-    }
-    const text = lines.join("");
-    expect(text).toContain("Installed plugin 'linear' (1 MCP server)");
-    expect(text).not.toContain("0 skills");
-    expect(text).toContain("Next");
-    expect(text).toContain("Sign in to linear:  stigmer connect mcp-server linear");
-  });
-});

package/src/resources/push-download.integration.test.ts

@@ -1,175 +0,0 @@
-// In-process integration test for `push skill` and `download execution`.
-//
-// Stands up a Connect backend (skill push + execution query/artifact-URL) plus a
-// plain HTTP server standing in for object storage, then drives the resource
-// layer end to end: pushSkill zips a temp dir and uploads it (asserting the
-// server receives a valid ZIP), and downloadExecutionArtifacts streams a
-// presigned URL to disk (asserting partial-failure tolerance).
-
-import { createServer as createHttpServer, type Server as HttpServer } from "node:http";
-import { createServer as createHttp2Server, type Http2Server, type ServerHttp2Session } from "node:http2";
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import type { AddressInfo } from "node:net";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { create } from "@bufbuild/protobuf";
-import { Code, ConnectError, type ConnectRouter } from "@connectrpc/connect";
-import { connectNodeAdapter } from "@connectrpc/connect-node";
-import { AgentExecutionSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
-import { ExecutionPhase } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
-import { GetArtifactDownloadUrlResponseSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/io_pb";
-import { AgentExecutionQueryController } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/query_pb";
-import { SkillSchema } from "@stigmer/protos/ai/stigmer/agentic/skill/v1/api_pb";
-import { SkillCommandController } from "@stigmer/protos/ai/stigmer/agentic/skill/v1/command_pb";
-import { createNodeClient, normalizeEndpoint } from "@stigmer/sdk/node";
-import type { Stigmer } from "@stigmer/sdk";
-import { unzipSync } from "fflate";
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
-import { downloadExecutionArtifacts } from "./download.js";
-import { pushSkill } from "./skill.js";
-
-const SKILL_MD = ["---", "name: my-skill", "---", "# My Skill"].join("\n");
-const ARTIFACT_BODY = "hello artifact contents";
-
-let backend: Http2Server;
-let storage: HttpServer;
-let storageUrl: string;
-let client: Stigmer;
-const openSessions = new Set<ServerHttp2Session>();
-
-let pushedArtifacts: Uint8Array[] = [];
-let pushedTags: string[] = [];
-
-beforeEach(() => {
-  pushedArtifacts = [];
-  pushedTags = [];
-});
-
-const execution = create(AgentExecutionSchema, {
-  metadata: { id: "aex_done" },
-  status: {
-    phase: ExecutionPhase.EXECUTION_COMPLETED,
-    artifacts: [
-      { name: "report.txt", storageKey: "store/report.txt", sizeBytes: 23n },
-      { name: "broken.txt", storageKey: "store/missing.txt", sizeBytes: 5n },
-    ],
-  },
-});
-
-beforeAll(async () => {
-  // Object-storage stand-in: serves the good key, 404s anything else.
-  storage = createHttpServer((req, res) => {
-    if (req.url === "/store/report.txt") {
-      res.writeHead(200, { "content-type": "text/plain" });
-      res.end(ARTIFACT_BODY);
-      return;
-    }
-    res.writeHead(404);
-    res.end("not found");
-  });
-  await new Promise<void>((resolve) => storage.listen(0, "127.0.0.1", resolve));
-  storageUrl = `http://127.0.0.1:${(storage.address() as AddressInfo).port}`;
-
-  const routes = (router: ConnectRouter) => {
-    router.service(SkillCommandController, {
-      push: (req) => {
-        pushedArtifacts.push(req.artifact);
-        pushedTags.push(req.tag);
-        return create(SkillSchema, {
-          metadata: { id: "skl_1", slug: "my-skill", version: { id: "v2", previousVersionId: "v1" } },
-          spec: { tag: req.tag },
-          status: { versionHash: "abcdef1234567890" },
-        });
-      },
-    });
-    router.service(AgentExecutionQueryController, {
-      get: (req) => {
-        if (req.value !== "aex_done") throw new ConnectError("not found", Code.NotFound);
-        return execution;
-      },
-      getArtifactDownloadUrl: (req) =>
-        create(GetArtifactDownloadUrlResponseSchema, { downloadUrl: `${storageUrl}/${req.storageKey}` }),
-    });
-  };
-
-  backend = createHttp2Server(connectNodeAdapter({ routes }));
-  backend.on("session", (session) => {
-    openSessions.add(session);
-    session.on("close", () => openSessions.delete(session));
-  });
-  await new Promise<void>((resolve) => backend.listen(0, "127.0.0.1", resolve));
-  const port = (backend.address() as AddressInfo).port;
-  client = createNodeClient({ baseUrl: normalizeEndpoint(`127.0.0.1:${port}`) });
-});
-
-afterAll(async () => {
-  for (const session of openSessions) session.destroy();
-  await new Promise<void>((resolve) => backend.close(() => resolve()));
-  await new Promise<void>((resolve) => storage.close(() => resolve()));
-});
-
-describe("pushSkill", () => {
-  it("zips a directory and uploads a valid artifact", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "push-it-"));
-    try {
-      writeFileSync(join(dir, "SKILL.md"), SKILL_MD);
-      writeFileSync(join(dir, "tool.py"), "print('x')\n");
-      writeFileSync(join(dir, ".env"), "SECRET=1\n"); // must be excluded
-
-      const result = await pushSkill(client, dir, "acme", "v1.2.3", "first push", {
-        respectGitignore: true,
-        extraIgnore: [],
-        extraInclude: [],
-      });
-
-      expect(result.skillName).toBe("my-skill");
-      expect(result.slug).toBe("my-skill");
-      expect(result.tag).toBe("v1.2.3");
-      expect(result.versionChanged).toBe(true);
-      expect(result.isNewResource).toBe(false);
-      expect(pushedTags).toEqual(["v1.2.3"]);
-
-      const entries = Object.keys(unzipSync(pushedArtifacts[0])).sort();
-      expect(entries).toEqual(["SKILL.md", "tool.py"]);
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  it("defaults an empty tag to 'latest'", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "push-it-"));
-    try {
-      writeFileSync(join(dir, "SKILL.md"), SKILL_MD);
-      await pushSkill(client, dir, "acme", "", "", { respectGitignore: true, extraIgnore: [], extraInclude: [] });
-      expect(pushedTags).toEqual(["latest"]);
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-});
-
-describe("downloadExecutionArtifacts", () => {
-  it("downloads available artifacts and tolerates partial failures", async () => {
-    const out = mkdtempSync(join(tmpdir(), "dl-it-"));
-    try {
-      const outcome = await downloadExecutionArtifacts(client, "aex_done", { artifactName: "", outputDir: out });
-      expect(outcome.total).toBe(2);
-      expect(outcome.downloaded).toBe(1); // broken.txt 404s, report.txt succeeds
-      expect(outcome.noArtifacts).toBe(false);
-      expect(readFileSync(join(out, "report.txt"), "utf8")).toBe(ARTIFACT_BODY);
-    } finally {
-      rmSync(out, { recursive: true, force: true });
-    }
-  });
-
-  it("filters to a named artifact", async () => {
-    const out = mkdtempSync(join(tmpdir(), "dl-it-"));
-    try {
-      const outcome = await downloadExecutionArtifacts(client, "aex_done", { artifactName: "report.txt", outputDir: out });
-      expect(outcome.total).toBe(1);
-      expect(outcome.downloaded).toBe(1);
-    } finally {
-      rmSync(out, { recursive: true, force: true });
-    }
-  });
-});