@stigmer/cli 3.35.0 → 3.37.0

package/src/resources/reference.test.ts

@@ -1,107 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  hasResourceIdPrefix,
-  isAgentId,
-  isSessionId,
-  isWorkflowId,
-  parseReference,
-  validateResourceId,
-} from "./reference.js";
-
-// A syntactically valid 26-char ULID body for building complete IDs in tests.
-const ULID = "01arz3ndektsv4rrffq69g5fav";
-
-describe("parseReference", () => {
-  it("parses an org/slug pair", () => {
-    expect(parseReference("acme/my-agent", "default-org", "agt")).toEqual({
-      kind: "ref",
-      org: "acme",
-      slug: "my-agent",
-    });
-  });
-
-  it("treats a bare id-prefixed token as an ID", () => {
-    expect(parseReference("agt_abc123", "acme", "agt")).toEqual({ kind: "id", id: "agt_abc123" });
-  });
-
-  it("treats a bare token without the id prefix as a slug in the default org", () => {
-    expect(parseReference("my-agent", "acme", "agt")).toEqual({
-      kind: "ref",
-      org: "acme",
-      slug: "my-agent",
-    });
-  });
-
-  it("does not mistake a slug that merely contains the prefix for an ID", () => {
-    // "agent-foo" starts with "agt"? no — prefix match requires "agt_".
-    expect(parseReference("agent-foo", "acme", "agt")).toEqual({
-      kind: "ref",
-      org: "acme",
-      slug: "agent-foo",
-    });
-  });
-
-  it("trims surrounding whitespace", () => {
-    expect(parseReference("  acme/release  ", "default", "wkf")).toEqual({
-      kind: "ref",
-      org: "acme",
-      slug: "release",
-    });
-  });
-
-  it("falls back to a slug when no id prefix is configured", () => {
-    expect(parseReference("something", "acme", "")).toEqual({
-      kind: "ref",
-      org: "acme",
-      slug: "something",
-    });
-  });
-});
-
-describe("resource-ID classification", () => {
-  it("detects kind prefixes with either separator", () => {
-    expect(isAgentId(`agt_${ULID}`)).toBe(true);
-    expect(isAgentId(`agt-${ULID}`)).toBe(true);
-    expect(isSessionId(`ses_${ULID}`)).toBe(true);
-    expect(isWorkflowId(`wfl_${ULID}`)).toBe(true);
-  });
-
-  it("does not classify cross-kind prefixes", () => {
-    expect(isAgentId(`ses_${ULID}`)).toBe(false);
-    expect(isSessionId(`agt_${ULID}`)).toBe(false);
-    expect(isWorkflowId(`agt_${ULID}`)).toBe(false);
-  });
-
-  it("does not mistake a slug that merely starts with a prefix for an ID", () => {
-    // "agent-foo" begins with "agt"? No — the separator must immediately follow.
-    expect(isAgentId("agent-foo")).toBe(false);
-    expect(hasResourceIdPrefix("agent-foo")).toBe(false);
-  });
-
-  it("is case-sensitive (uppercase prefixes are not IDs)", () => {
-    expect(isAgentId(`AGT_${ULID}`)).toBe(false);
-  });
-
-  it("recognizes any known prefix via hasResourceIdPrefix (length-agnostic)", () => {
-    expect(hasResourceIdPrefix("agt_short")).toBe(true);
-    expect(hasResourceIdPrefix("wex_anything")).toBe(true);
-    expect(hasResourceIdPrefix("mcp-x")).toBe(true);
-    expect(hasResourceIdPrefix("plain-slug")).toBe(false);
-  });
-
-  it("validates a complete ID (prefix + 26-char ULID)", () => {
-    expect(validateResourceId(`agt_${ULID}`)).toBeNull();
-    expect(validateResourceId(`ses-${ULID}`)).toBeNull();
-  });
-
-  it("reports an incomplete ID when the prefix matches but the body is wrong", () => {
-    expect(validateResourceId("agt_tooshort")).toMatch(/incomplete/);
-    expect(validateResourceId(`agt_${ULID}extra`)).toMatch(/incomplete/);
-  });
-
-  it("accepts a legacy UUID and rejects unrelated tokens", () => {
-    expect(validateResourceId("123e4567-e89b-12d3-a456-426614174000")).toBeNull();
-    expect(hasResourceIdPrefix("123e4567-e89b-12d3-a456-426614174000")).toBe(true);
-    expect(validateResourceId("just-a-slug")).toMatch(/not a recognized/);
-  });
-});

package/src/resources/run/agent-exec.test.ts

@@ -1,179 +0,0 @@
-// Orchestration tests for executeResolvedAgent: the one-call bootstrap
-// contract (stigmer/stigmer#249). A workspace-bearing run must issue exactly
-// one create RPC — the AgentExecution carrying session_spec — instead of the
-// old session.create + agentExecution.create pair, and the flow must read the
-// canonical session id back from the returned execution spec. The built-in
-// assistant rides the same flow with no agent at all. Runs use detach mode
-// so no streaming machinery is exercised.
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { create } from "@bufbuild/protobuf";
-import type { Agent } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
-import { AgentSchema } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
-import type { AgentExecution } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
-import { ApprovalAction } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
-import { Harness } from "@stigmer/protos/ai/stigmer/agentic/session/v1/enum_pb";
-import {
-  LocalPathSourceSchema,
-  WorkspaceEntrySchema,
-  WorkspaceSourceSchema,
-} from "@stigmer/protos/ai/stigmer/agentic/session/v1/workspace_pb";
-import type { BackendClient } from "../../client/index.js";
-import { executeResolvedAgent } from "./agent-exec.js";
-import type { PreparedRun } from "./prepare.js";
-
-const WORKSPACE_ENTRY = create(WorkspaceEntrySchema, {
-  name: "repo",
-  source: create(WorkspaceSourceSchema, {
-    source: { case: "localPath", value: create(LocalPathSourceSchema, { path: "/home/user/repo" }) },
-  }),
-});
-
-function makeAgent(): Agent {
-  return create(AgentSchema, {
-    metadata: { id: "agt_1", name: "helper" },
-  });
-}
-
-function makePrepared(overrides: Partial<PreparedRun> = {}): PreparedRun {
-  return {
-    defaultAction: ApprovalAction.UNSPECIFIED,
-    workspaceEntries: [],
-    runtimeEnv: {},
-    attachments: [],
-    workspaceFileRefs: [],
-    message: "hi",
-    detach: true,
-    verbose: false,
-    model: "",
-    autoApproveAll: false,
-    mode: "",
-    serviceTier: "",
-    thinking: "",
-    harness: "",
-    ...overrides,
-  };
-}
-
-// A BackendClient double whose controller records every create call and
-// emulates the server stamping the bootstrapped session id onto the returned
-// execution spec.
-function fakeBackend(): { client: BackendClient; creates: () => AgentExecution[] } {
-  const captured: AgentExecution[] = [];
-  const controller = () => ({
-    create: async (msg: AgentExecution) => {
-      captured.push(msg);
-      // Echo with the server-owned session id filled in, like the real backend.
-      return {
-        ...msg,
-        spec: msg.spec === undefined ? undefined : { ...msg.spec, sessionId: "ses_srv" },
-      };
-    },
-  });
-  const client = { controller } as unknown as BackendClient;
-  return { client, creates: () => captured };
-}
-
-// Captured stderr lines (the header + re-attach hint in detach mode).
-let stderrLines: string[];
-
-beforeEach(() => {
-  stderrLines = [];
-  vi.spyOn(process.stderr, "write").mockImplementation((chunk) => {
-    stderrLines.push(String(chunk));
-    return true;
-  });
-});
-
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-describe("executeResolvedAgent", () => {
-  it("issues exactly one create carrying session_spec for a workspace run", async () => {
-    const { client, creates } = fakeBackend();
-
-    await executeResolvedAgent({
-      agent: makeAgent(),
-      prepared: makePrepared({ workspaceEntries: [WORKSPACE_ENTRY] }),
-      org: "acme",
-      downloadDir: "",
-      outputMode: "inline",
-      client,
-    });
-
-    const sent = creates();
-    expect(sent, "a workspace run is a single AgentExecution create").toHaveLength(1);
-    expect(sent[0]?.spec?.agentId).toBe("agt_1");
-    expect(sent[0]?.spec?.sessionId, "no client-created session id").toBe("");
-    expect(sent[0]?.spec?.sessionSpec?.workspaceEntries).toEqual([WORKSPACE_ENTRY]);
-
-    // The canonical session id comes back on the execution spec and drives the
-    // re-attach hint.
-    expect(stderrLines.join("")).toContain("stigmer resume ses_srv");
-  });
-
-  it("issues one create with no session_spec when there is no workspace", async () => {
-    const { client, creates } = fakeBackend();
-
-    await executeResolvedAgent({
-      agent: makeAgent(),
-      prepared: makePrepared(),
-      org: "acme",
-      downloadDir: "",
-      outputMode: "inline",
-      client,
-    });
-
-    const sent = creates();
-    expect(sent).toHaveLength(1);
-    expect(sent[0]?.spec?.sessionSpec).toBeUndefined();
-    expect(sent[0]?.spec?.agentId).toBe("agt_1");
-  });
-
-  it("runs the built-in assistant with no agent: an all-empty target and the assistant's name in the header", async () => {
-    const { client, creates } = fakeBackend();
-
-    await executeResolvedAgent({
-      agent: undefined,
-      prepared: makePrepared({ detach: true }),
-      org: "acme",
-      downloadDir: "",
-      outputMode: "inline",
-      client,
-    });
-
-    const sent = creates();
-    expect(sent).toHaveLength(1);
-    // Neither an agent nor a session nor a session_spec instance: the backend
-    // creates a session with no agent and the runner answers as the assistant.
-    expect(sent[0]?.spec?.agentId).toBe("");
-    expect(sent[0]?.spec?.sessionId).toBe("");
-    expect(sent[0]?.spec?.sessionSpec?.agentInstanceId ?? "").toBe("");
-    expect(stderrLines.join("")).toContain("Assistant");
-    expect(stderrLines.join("")).toContain("stigmer resume ses_srv");
-  });
-
-  it("threads the resolved harness onto the wire and surfaces it in the header (oss#293)", async () => {
-    // The revert-detection seam: if the prepared→create threading is ever
-    // dropped, this wire assertion fails — not just a flag-parsing test.
-    const { client, creates } = fakeBackend();
-
-    await executeResolvedAgent({
-      agent: makeAgent(),
-      prepared: makePrepared({ harness: "cursor" }),
-      org: "acme",
-      downloadDir: "",
-      outputMode: "inline",
-      client,
-    });
-
-    const sent = creates();
-    expect(sent).toHaveLength(1);
-    expect(sent[0]?.spec?.sessionSpec?.harness).toBe(Harness.CURSOR);
-    // D2 visibility: a cursor session must announce itself before streaming —
-    // whether the flag or the account preference selected it.
-    expect(stderrLines.join("")).toContain("Harness:");
-    expect(stderrLines.join("")).toContain("Cursor");
-  });
-});

package/src/resources/run/attachments.test.ts

@@ -1,135 +0,0 @@
-// Unit tests for attachment processing: workspace-relative classification vs
-// upload, directory zipping, MIME detection, and the size cap. The uploader is
-// faked so no network is required.
-
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { create } from "@bufbuild/protobuf";
-import { unzipSync } from "fflate";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import {
-  type UploadAttachmentRequest,
-  UploadAttachmentResponseSchema,
-} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/io_pb";
-import { type AttachmentUploader, processAttachments } from "./attachments.js";
-
-// Records each upload and returns a deterministic storage key.
-class FakeUploader implements AttachmentUploader {
-  readonly uploads: UploadAttachmentRequest[] = [];
-  async uploadAttachment(req: UploadAttachmentRequest) {
-    this.uploads.push(req);
-    return create(UploadAttachmentResponseSchema, { storageKey: `attachments/key/${req.filename}` });
-  }
-}
-
-let dir: string;
-let uploader: FakeUploader;
-beforeEach(() => {
-  dir = mkdtempSync(join(tmpdir(), "attach-test-"));
-  uploader = new FakeUploader();
-});
-afterEach(() => {
-  rmSync(dir, { recursive: true, force: true });
-});
-
-describe("workspace-relative classification", () => {
-  it("records a file inside a workspace root as a relative ref (no upload)", async () => {
-    const root = join(dir, "repo");
-    mkdirSync(join(root, "src"), { recursive: true });
-    const file = join(root, "src", "main.ts");
-    writeFileSync(file, "x");
-
-    const result = await processAttachments(uploader, [file], [root]);
-    expect(result.workspaceFileRefs).toEqual(["src/main.ts"]);
-    expect(result.attachments).toHaveLength(0);
-    expect(uploader.uploads).toHaveLength(0);
-  });
-
-  it("uploads a file outside every workspace root", async () => {
-    const root = join(dir, "repo");
-    mkdirSync(root, { recursive: true });
-    const outside = join(dir, "outside.txt");
-    writeFileSync(outside, "data");
-
-    const result = await processAttachments(uploader, [outside], [root]);
-    expect(result.workspaceFileRefs).toHaveLength(0);
-    expect(result.attachments).toHaveLength(1);
-    expect(result.attachments[0].filename).toBe("outside.txt");
-    expect(result.attachments[0].contentType).toBe("text/plain");
-    expect(result.attachments[0].storageKey).toBe("attachments/key/outside.txt");
-    expect(result.attachments[0].localPath).toBe(outside);
-  });
-});
-
-describe("file upload", () => {
-  it("uploads with no workspace roots configured", async () => {
-    const file = join(dir, "config.yaml");
-    writeFileSync(file, "a: 1\n");
-    const result = await processAttachments(uploader, [file], []);
-    expect(result.attachments).toHaveLength(1);
-    expect(result.attachments[0].contentType).toBe("application/x-yaml");
-    expect(uploader.uploads[0].filename).toBe("config.yaml");
-  });
-
-  it("falls back to octet-stream for unknown extensions", async () => {
-    const file = join(dir, "blob.unknownext");
-    writeFileSync(file, "x");
-    const result = await processAttachments(uploader, [file], []);
-    expect(result.attachments[0].contentType).toBe("application/octet-stream");
-  });
-
-  it("errors on a missing file", async () => {
-    await expect(processAttachments(uploader, [join(dir, "nope.txt")], [])).rejects.toThrow(/file not found/);
-  });
-});
-
-describe("directory zipping", () => {
-  it("zips a directory, marks extract, and sets the mount path", async () => {
-    const subdir = join(dir, "bundle");
-    mkdirSync(join(subdir, "nested"), { recursive: true });
-    writeFileSync(join(subdir, "a.txt"), "aaa");
-    writeFileSync(join(subdir, "nested", "b.txt"), "bbb");
-    writeFileSync(join(subdir, ".hidden"), "secret"); // skipped
-
-    const result = await processAttachments(uploader, [subdir], []);
-    expect(result.attachments).toHaveLength(1);
-    const att = result.attachments[0];
-    expect(att.filename).toBe("bundle.zip");
-    expect(att.extract).toBe(true);
-    expect(att.mountPath).toBe("inputs/bundle/");
-    expect(att.contentType).toBe("application/zip");
-
-    const entries = Object.keys(unzipSync(uploader.uploads[0].content)).sort();
-    expect(entries).toEqual(["a.txt", "nested/b.txt"]);
-  });
-
-  it("errors when a directory has no attachable files", async () => {
-    const empty = join(dir, "empty");
-    mkdirSync(empty);
-    writeFileSync(join(empty, ".hidden"), "x"); // only hidden -> nothing attachable
-    await expect(processAttachments(uploader, [empty], [])).rejects.toThrow(/no attachable files/);
-  });
-
-  it("uniquifies duplicate directory basenames so mount paths never contradict (issue #364)", async () => {
-    // Two dirs named `data` from different parents would otherwise derive the
-    // SAME explicit mount path, which the runner rejects as a contradiction.
-    const dirA = join(dir, "a", "data");
-    const dirB = join(dir, "b", "data");
-    mkdirSync(dirA, { recursive: true });
-    mkdirSync(dirB, { recursive: true });
-    writeFileSync(join(dirA, "one.txt"), "1");
-    writeFileSync(join(dirB, "two.txt"), "2");
-
-    const progress: string[] = [];
-    const result = await processAttachments(uploader, [dirA, dirB], [], (l) => progress.push(l));
-
-    expect(result.attachments).toHaveLength(2);
-    expect(result.attachments[0].filename).toBe("data.zip");
-    expect(result.attachments[0].mountPath).toBe("inputs/data/");
-    expect(result.attachments[1].filename).toBe("data-2.zip");
-    expect(result.attachments[1].mountPath).toBe("inputs/data-2/");
-    // The rename is disclosed to the user on the progress sink.
-    expect(progress.some((l) => l.includes("'data/'") && l.includes("'data-2/'"))).toBe(true);
-  });
-});