@stigmer/cli 3.35.0 → 3.37.0

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

@@ -1,336 +0,0 @@
-// Unit tests for run-path resource creation: full-proto field mapping, the
-// message default, ExecutionConfig presence/contents, runtime-env conversion,
-// the one-call session_spec bootstrap, and the workflow shape. The controller
-// is faked to capture the exact proto sent to the RPC.
-
-import { describe, expect, it } from "vitest";
-import { InteractionMode, ServiceTier, ThinkingMode } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
-import { create } from "@bufbuild/protobuf";
-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 ControllerFn, createAgentExecution, createWorkflowExecution } from "./create.js";
-
-// Returns a controller whose every RPC echoes the request back, and records the
-// last message sent. `create` is the only RPC the run path calls.
-function fakeController(): { fn: ControllerFn; last: () => unknown } {
-  let captured: unknown;
-  const fn = (() =>
-    ({
-      create: async (msg: unknown) => {
-        captured = msg;
-        return msg;
-      },
-    })) as unknown as ControllerFn;
-  return { fn, last: () => captured };
-}
-
-describe("createAgentExecution", () => {
-  it("maps the full spec and defaults an empty message to 'execute'", async () => {
-    const { fn } = fakeController();
-    const exec = await createAgentExecution(fn, {
-      agentId: "agt_1",
-      orgId: "acme",
-      message: "",
-      runtimeEnv: { FOO: { value: "bar", isSecret: false }, TOKEN: { value: "s", isSecret: true } },
-      attachments: [],
-      workspaceFileRefs: ["src/a.ts"],
-      workspaceEntries: [],
-      model: "claude",
-      mode: "plan",
-      serviceTier: "",
-      thinking: "",
-      autoApproveAll: true,
-      harness: "",
-    });
-
-    expect(exec.kind).toBe("AgentExecution");
-    expect(exec.metadata?.org).toBe("acme");
-    expect(exec.spec?.message).toBe("execute");
-    expect(exec.spec?.agentId).toBe("agt_1");
-    expect(exec.spec?.autoApproveAll).toBe(true);
-    expect(exec.spec?.workspaceFileRefs).toEqual(["src/a.ts"]);
-    expect(exec.spec?.runtimeEnv.FOO).toMatchObject({ value: "bar", isSecret: false });
-    expect(exec.spec?.runtimeEnv.TOKEN).toMatchObject({ value: "s", isSecret: true });
-    expect(exec.spec?.executionConfig?.modelName).toBe("claude");
-    expect(exec.spec?.executionConfig?.interactionMode).toBe(InteractionMode.PLAN);
-  });
-
-  it("omits ExecutionConfig when neither model nor mode is set", async () => {
-    const { fn } = fakeController();
-    const exec = await createAgentExecution(fn, {
-      agentId: "agt_1",
-      orgId: "acme",
-      message: "hi",
-      runtimeEnv: {},
-      attachments: [],
-      workspaceFileRefs: [],
-      workspaceEntries: [],
-      model: "",
-      mode: "",
-      serviceTier: "",
-      thinking: "",
-      autoApproveAll: false,
-      harness: "",
-    });
-    expect(exec.spec?.message).toBe("hi");
-    expect(exec.spec?.executionConfig).toBeUndefined();
-  });
-
-  it("maps --service-tier fast to the enum (#357)", async () => {
-    const { fn } = fakeController();
-    const exec = await createAgentExecution(fn, {
-      agentId: "agt_1",
-      orgId: "acme",
-      message: "x",
-      runtimeEnv: {},
-      attachments: [],
-      workspaceFileRefs: [],
-      workspaceEntries: [],
-      model: "composer-2.5",
-      mode: "",
-      serviceTier: "fast",
-      thinking: "",
-      autoApproveAll: false,
-      harness: "",
-    });
-    expect(exec.spec?.executionConfig?.serviceTier).toBe(ServiceTier.FAST);
-  });
-
-  it("maps an explicit --service-tier standard to STANDARD, not UNSPECIFIED", async () => {
-    // Unspecified-vs-explicit-standard is a load-bearing ledger
-    // distinction (#357): an explicit choice must survive to the proto.
-    const { fn } = fakeController();
-    const exec = await createAgentExecution(fn, {
-      agentId: "agt_1",
-      orgId: "acme",
-      message: "x",
-      runtimeEnv: {},
-      attachments: [],
-      workspaceFileRefs: [],
-      workspaceEntries: [],
-      model: "",
-      mode: "",
-      serviceTier: "standard",
-      thinking: "",
-      autoApproveAll: false,
-      harness: "",
-    });
-    expect(exec.spec?.executionConfig?.serviceTier).toBe(ServiceTier.STANDARD);
-  });
-
-  it("maps --thinking enabled to the enum (#772)", async () => {
-    const { fn } = fakeController();
-    const exec = await createAgentExecution(fn, {
-      agentId: "agt_1",
-      orgId: "acme",
-      message: "x",
-      runtimeEnv: {},
-      attachments: [],
-      workspaceFileRefs: [],
-      workspaceEntries: [],
-      model: "claude-haiku-4-5",
-      mode: "",
-      serviceTier: "",
-      thinking: "enabled",
-      autoApproveAll: false,
-      harness: "",
-    });
-    expect(exec.spec?.executionConfig?.thinkingMode).toBe(ThinkingMode.ENABLED);
-  });
-
-  it("maps an explicit --thinking disabled to DISABLED, not UNSPECIFIED", async () => {
-    // The tier's #772 twin: unspecified-vs-explicit-disabled is the same
-    // load-bearing ledger distinction.
-    const { fn } = fakeController();
-    const exec = await createAgentExecution(fn, {
-      agentId: "agt_1",
-      orgId: "acme",
-      message: "x",
-      runtimeEnv: {},
-      attachments: [],
-      workspaceFileRefs: [],
-      workspaceEntries: [],
-      model: "",
-      mode: "",
-      serviceTier: "",
-      thinking: "disabled",
-      autoApproveAll: false,
-      harness: "",
-    });
-    expect(exec.spec?.executionConfig?.thinkingMode).toBe(ThinkingMode.DISABLED);
-  });
-
-  it("leaves InteractionMode unspecified for agent mode", async () => {
-    const { fn } = fakeController();
-    const exec = await createAgentExecution(fn, {
-      sessionId: "ses_1",
-      orgId: "acme",
-      message: "x",
-      runtimeEnv: {},
-      attachments: [],
-      workspaceFileRefs: [],
-      workspaceEntries: [],
-      model: "m",
-      mode: "agent",
-      serviceTier: "",
-      thinking: "",
-      autoApproveAll: false,
-      harness: "",
-    });
-    expect(exec.spec?.sessionId).toBe("ses_1");
-    expect(exec.spec?.executionConfig?.interactionMode).toBe(InteractionMode.UNSPECIFIED);
-  });
-
-  it("embeds workspace entries as session_spec (one-call bootstrap) with an empty subject", async () => {
-    const entry = create(WorkspaceEntrySchema, {
-      name: "repo",
-      source: create(WorkspaceSourceSchema, {
-        source: { case: "localPath", value: create(LocalPathSourceSchema, { path: "/home/user/repo" }) },
-      }),
-    });
-
-    const { fn } = fakeController();
-    const exec = await createAgentExecution(fn, {
-      agentId: "agt_1",
-      orgId: "acme",
-      message: "hi",
-      runtimeEnv: {},
-      attachments: [],
-      workspaceFileRefs: [],
-      workspaceEntries: [entry],
-      model: "",
-      mode: "",
-      serviceTier: "",
-      thinking: "",
-      autoApproveAll: false,
-      harness: "",
-    });
-
-    expect(exec.spec?.sessionId).toBe("");
-    expect(exec.spec?.sessionSpec?.workspaceEntries).toEqual([entry]);
-    // Subject stays empty so the server defaults its sentinel and the async
-    // title activity generates a real one.
-    expect(exec.spec?.sessionSpec?.subject).toBe("");
-    // No harness opinion: the field stays UNSPECIFIED so the server default
-    // (native) applies — a workspace-only run is byte-identical to before
-    // the --harness flag existed.
-    expect(exec.spec?.sessionSpec?.harness).toBe(Harness.UNSPECIFIED);
-  });
-
-  it("omits session_spec when there are no workspace entries and no harness (wire-shape regression pin)", async () => {
-    // The pre---harness wire shape for a plain run: NO embedded session_spec
-    // at all. If this pin fails, plain runs have started carrying a spec they
-    // never carried before — a silent contract change, not a feature.
-    const { fn } = fakeController();
-    const exec = await createAgentExecution(fn, {
-      agentId: "agt_1",
-      orgId: "acme",
-      message: "hi",
-      runtimeEnv: {},
-      attachments: [],
-      workspaceFileRefs: [],
-      workspaceEntries: [],
-      model: "",
-      mode: "",
-      serviceTier: "",
-      thinking: "",
-      autoApproveAll: false,
-      harness: "",
-    });
-    expect(exec.spec?.sessionSpec).toBeUndefined();
-  });
-
-  it("stamps cursor harness on a session_spec created just for it (oss#293)", async () => {
-    const { fn } = fakeController();
-    const exec = await createAgentExecution(fn, {
-      agentId: "agt_1",
-      orgId: "acme",
-      message: "hi",
-      runtimeEnv: {},
-      attachments: [],
-      workspaceFileRefs: [],
-      workspaceEntries: [],
-      model: "",
-      mode: "",
-      serviceTier: "",
-      thinking: "",
-      autoApproveAll: false,
-      harness: "cursor",
-    });
-    // Harness alone justifies the embedded spec: the server clones it onto
-    // the auto-created session (the one-call bootstrap contract).
-    expect(exec.spec?.sessionSpec?.harness).toBe(Harness.CURSOR);
-    expect(exec.spec?.sessionSpec?.workspaceEntries).toEqual([]);
-  });
-
-  it("stamps an explicit native harness rather than leaving it unspecified", async () => {
-    // "native" may be a deliberate per-run escape from the account's
-    // default_harness preference — it must survive on the wire so it beats
-    // any future change to the server-side default (D3).
-    const { fn } = fakeController();
-    const exec = await createAgentExecution(fn, {
-      agentId: "agt_1",
-      orgId: "acme",
-      message: "hi",
-      runtimeEnv: {},
-      attachments: [],
-      workspaceFileRefs: [],
-      workspaceEntries: [],
-      model: "",
-      mode: "",
-      serviceTier: "",
-      thinking: "",
-      autoApproveAll: false,
-      harness: "native",
-    });
-    expect(exec.spec?.sessionSpec?.harness).toBe(Harness.NATIVE);
-  });
-
-  it("carries harness and workspace entries together on one session_spec", async () => {
-    const entry = create(WorkspaceEntrySchema, {
-      name: "repo",
-      source: create(WorkspaceSourceSchema, {
-        source: { case: "localPath", value: create(LocalPathSourceSchema, { path: "/home/user/repo" }) },
-      }),
-    });
-
-    const { fn } = fakeController();
-    const exec = await createAgentExecution(fn, {
-      agentId: "agt_1",
-      orgId: "acme",
-      message: "hi",
-      runtimeEnv: {},
-      attachments: [],
-      workspaceFileRefs: [],
-      workspaceEntries: [entry],
-      model: "",
-      mode: "",
-      serviceTier: "",
-      thinking: "",
-      autoApproveAll: false,
-      harness: "cursor",
-    });
-    expect(exec.spec?.sessionSpec?.harness).toBe(Harness.CURSOR);
-    expect(exec.spec?.sessionSpec?.workspaceEntries).toEqual([entry]);
-  });
-});
-
-describe("createWorkflowExecution", () => {
-  it("builds a workflow execution with the trigger message", async () => {
-    const { fn } = fakeController();
-    const exec = await createWorkflowExecution(fn, {
-      workflowId: "wfl_1",
-      orgId: "acme",
-      message: "",
-      runtimeEnv: { K: { value: "v", isSecret: false } },
-    });
-    expect(exec.kind).toBe("WorkflowExecution");
-    expect(exec.spec?.workflowId).toBe("wfl_1");
-    expect(exec.spec?.triggerMessage).toBe("execute");
-    expect(exec.spec?.runtimeEnv.K).toMatchObject({ value: "v", isSecret: false });
-  });
-});

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

@@ -1,131 +0,0 @@
-// Unit tests for runtime-env assembly: dotenv parsing, flag parsing, precedence,
-// and quote/escape handling. The precedence ordering is a wire-parity contract
-// with the Go CLI, so it gets dedicated coverage.
-
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { loadAndMergeEnv } from "./env.js";
-
-let dir: string;
-beforeEach(() => {
-  dir = mkdtempSync(join(tmpdir(), "env-test-"));
-});
-afterEach(() => {
-  rmSync(dir, { recursive: true, force: true });
-});
-
-function writeFile(name: string, contents: string): string {
-  const path = join(dir, name);
-  writeFileSync(path, contents);
-  return path;
-}
-
-const NONE = { envFlags: [], secretFlags: [], envFiles: [], secretFiles: [] };
-
-describe("loadAndMergeEnv flags", () => {
-  it("parses plain KEY=VALUE env flags as non-secrets", () => {
-    expect(loadAndMergeEnv({ ...NONE, envFlags: ["FOO=bar", "BAZ=qux"] })).toEqual({
-      FOO: { value: "bar", isSecret: false },
-      BAZ: { value: "qux", isSecret: false },
-    });
-  });
-
-  it("parses secret flags as secrets", () => {
-    expect(loadAndMergeEnv({ ...NONE, secretFlags: ["TOKEN=abc"] })).toEqual({
-      TOKEN: { value: "abc", isSecret: true },
-    });
-  });
-
-  it("rejects a flag without '='", () => {
-    expect(() => loadAndMergeEnv({ ...NONE, envFlags: ["NOEQUALS"] })).toThrow(/missing '=' separator/);
-  });
-
-  it("rejects an invalid key", () => {
-    expect(() => loadAndMergeEnv({ ...NONE, envFlags: ["1BAD=x"] })).toThrow(/invalid key/);
-  });
-
-  it("keeps everything after the first '=' as the value", () => {
-    expect(loadAndMergeEnv({ ...NONE, envFlags: ["URL=https://a.b/c?d=e"] })).toEqual({
-      URL: { value: "https://a.b/c?d=e", isSecret: false },
-    });
-  });
-});
-
-describe("loadAndMergeEnv files", () => {
-  it("parses comments, blanks, export prefix, and quoted values", () => {
-    const path = writeFile(
-      ".env",
-      ["# comment", "", "export FOO=bar", 'QUOTED="hello world"', "SINGLE='single'"].join("\n"),
-    );
-    expect(loadAndMergeEnv({ ...NONE, envFiles: [path] })).toEqual({
-      FOO: { value: "bar", isSecret: false },
-      QUOTED: { value: "hello world", isSecret: false },
-      SINGLE: { value: "single", isSecret: false },
-    });
-  });
-
-  it("treats secret files as all-secret", () => {
-    const path = writeFile("secrets.env", "API_KEY=xyz\n");
-    expect(loadAndMergeEnv({ ...NONE, secretFiles: [path] })).toEqual({
-      API_KEY: { value: "xyz", isSecret: true },
-    });
-  });
-
-  it("reports the file and line on a parse error", () => {
-    const path = writeFile(".env", "GOOD=1\nBADLINE\n");
-    expect(() => loadAndMergeEnv({ ...NONE, envFiles: [path] })).toThrow(/:2:/);
-  });
-
-  it("errors clearly when a file is missing", () => {
-    expect(() => loadAndMergeEnv({ ...NONE, envFiles: [join(dir, "nope.env")] })).toThrow(
-      /failed to open environment file/,
-    );
-  });
-});
-
-describe("loadAndMergeEnv precedence (later wins)", () => {
-  it("layers env-files < secret-files < --env < --secret", () => {
-    const envFile = writeFile("a.env", "K=from-env-file\n");
-    const secretFile = writeFile("b.env", "K=from-secret-file\n");
-    // secret-file beats env-file:
-    expect(loadAndMergeEnv({ ...NONE, envFiles: [envFile], secretFiles: [secretFile] })).toEqual({
-      K: { value: "from-secret-file", isSecret: true },
-    });
-    // --env beats secret-file:
-    expect(
-      loadAndMergeEnv({ ...NONE, secretFiles: [secretFile], envFlags: ["K=from-env-flag"] }),
-    ).toEqual({ K: { value: "from-env-flag", isSecret: false } });
-    // --secret beats --env:
-    expect(loadAndMergeEnv({ ...NONE, envFlags: ["K=from-env"], secretFlags: ["K=from-secret"] })).toEqual({
-      K: { value: "from-secret", isSecret: true },
-    });
-  });
-
-  it("applies later files within the same tier last", () => {
-    const first = writeFile("first.env", "K=first\n");
-    const second = writeFile("second.env", "K=second\n");
-    expect(loadAndMergeEnv({ ...NONE, envFiles: [first, second] })).toEqual({
-      K: { value: "second", isSecret: false },
-    });
-  });
-});
-
-describe("escape handling matches Go's single-pass replacer", () => {
-  it("does not double-process a literal backslash-n", () => {
-    // "\\n" in the file is backslash + backslash + n; Go yields backslash + n,
-    // NOT a newline. A naive chained replace would wrongly produce a newline.
-    const path = writeFile(".env", 'K="\\\\n"\n');
-    expect(loadAndMergeEnv({ ...NONE, envFiles: [path] })).toEqual({
-      K: { value: "\\n", isSecret: false },
-    });
-  });
-
-  it("unescapes real escape sequences", () => {
-    const path = writeFile(".env", 'K="a\\tb\\nc"\n');
-    expect(loadAndMergeEnv({ ...NONE, envFiles: [path] })).toEqual({
-      K: { value: "a\tb\nc", isSecret: false },
-    });
-  });
-});

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

@@ -1,79 +0,0 @@
-import { create } from "@bufbuild/protobuf";
-import {
-  WorkspaceEntrySchema,
-} from "@stigmer/protos/ai/stigmer/agentic/session/v1/workspace_pb";
-import { describe, expect, it } from "vitest";
-import { renderSessionHeader, workspaceNames } from "./header.js";
-
-function capture(): { out: { write(c: string): void; isTTY: boolean }; text: () => string } {
-  let buf = "";
-  return {
-    out: { write: (c: string) => void (buf += c), isTTY: false },
-    text: () => buf,
-  };
-}
-
-describe("renderSessionHeader", () => {
-  it("omits empty fields and aligns labels", () => {
-    const { out, text } = capture();
-    renderSessionHeader(out, { agentName: "Reviewer", sessionId: "ses_abc", model: "", mode: "", workspaces: [] });
-    expect(text()).toBe("Agent:      Reviewer\nSession:    ses_abc\n\n");
-  });
-
-  it("surfaces plan mode but not agent/default", () => {
-    const plan = capture();
-    renderSessionHeader(plan.out, { agentName: "", sessionId: "", model: "", mode: "plan", workspaces: [] });
-    expect(plan.text()).toContain("Mode:");
-    expect(plan.text()).toContain("Plan (read-only)");
-
-    const agent = capture();
-    renderSessionHeader(agent.out, { agentName: "", sessionId: "s", model: "", mode: "agent", workspaces: [] });
-    expect(agent.text()).not.toContain("Mode:");
-  });
-
-  it("surfaces the cursor harness but not native/default (oss#293 D2 visibility)", () => {
-    // A cursor session may have been selected by the account preference, not
-    // a flag — the header is the CLI's only pre-stream channel to say so.
-    const cursor = capture();
-    renderSessionHeader(cursor.out, { agentName: "", sessionId: "s", model: "", mode: "", harness: "cursor", workspaces: [] });
-    expect(cursor.text()).toContain("Harness:");
-    expect(cursor.text()).toContain("Cursor");
-
-    // Native (explicit or defaulted) stays implicit, like agent mode.
-    const native = capture();
-    renderSessionHeader(native.out, { agentName: "", sessionId: "s", model: "", mode: "", harness: "native", workspaces: [] });
-    expect(native.text()).not.toContain("Harness:");
-
-    const unset = capture();
-    renderSessionHeader(unset.out, { agentName: "", sessionId: "s", model: "", mode: "", workspaces: [] });
-    expect(unset.text()).not.toContain("Harness:");
-  });
-
-  it("indents extra workspaces under the first", () => {
-    const { out, text } = capture();
-    renderSessionHeader(out, {
-      agentName: "",
-      sessionId: "",
-      model: "",
-      mode: "",
-      workspaces: ["app", "infra"],
-    });
-    expect(text()).toBe("Workspaces: app\n            infra\n\n");
-  });
-
-  it("prints nothing when every field is empty", () => {
-    const { out, text } = capture();
-    renderSessionHeader(out, { agentName: "", sessionId: "", model: "", mode: "", workspaces: [] });
-    expect(text()).toBe("");
-  });
-});
-
-describe("workspaceNames", () => {
-  it("extracts the derived name from each entry", () => {
-    const entries = [
-      create(WorkspaceEntrySchema, { name: "app" }),
-      create(WorkspaceEntrySchema, { name: "infra" }),
-    ];
-    expect(workspaceNames(entries)).toEqual(["app", "infra"]);
-  });
-});