@stigmer/runner 3.1.4 → 3.1.6

package/src/shared/workspace/__tests__/git-identity.test.ts

@@ -0,0 +1,124 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { execFile } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  AGENT_GIT_AUTHOR_NAME,
+  AGENT_GIT_AUTHOR_EMAIL,
+  AGENT_GIT_IDENTITY_FLAGS,
+  gitCommitAsAgent,
+} from "../git-identity.js";
+
+/**
+ * Environment that approximates the cloud sandbox: no global/system gitconfig,
+ * no GIT_AUTHOR / GIT_COMMITTER variables. In the real sandbox a bare
+ * `git commit` here fails with "Author identity unknown" (hostname-based
+ * auto-detection yields an invalid ident inside the pod); on a developer
+ * machine git may still auto-detect from username + hostname, so these tests
+ * assert the fix's guarantee — the pinned identity always wins — rather than
+ * the environment-dependent failure mode.
+ */
+function identitylessEnv(): NodeJS.ProcessEnv {
+  const env = { ...process.env };
+  delete env.GIT_AUTHOR_NAME;
+  delete env.GIT_AUTHOR_EMAIL;
+  delete env.GIT_COMMITTER_NAME;
+  delete env.GIT_COMMITTER_EMAIL;
+  env.GIT_CONFIG_GLOBAL = "/dev/null";
+  env.GIT_CONFIG_SYSTEM = "/dev/null";
+  return env;
+}
+
+function sh(
+  cwd: string,
+  command: string,
+  envOverrides: Record<string, string> = {},
+): Promise<string> {
+  return new Promise((resolve, reject) => {
+    execFile(
+      "sh",
+      ["-c", command],
+      { cwd, env: { ...identitylessEnv(), ...envOverrides } },
+      (err, stdout, stderr) => {
+        if (err) reject(new Error(`Command failed: ${command}\n${stderr || err.message}`));
+        else resolve(stdout);
+      },
+    );
+  });
+}
+
+describe("gitCommitAsAgent (real repo, no ambient identity)", () => {
+  let repo: string;
+
+  beforeEach(async () => {
+    repo = mkdtempSync(join(tmpdir(), "git-identity-test-"));
+    await sh(repo, "git init -q");
+    writeFileSync(join(repo, "notes.md"), "# Project Notes\n");
+    await sh(repo, "git add -A");
+  });
+
+  afterEach(() => {
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  /**
+   * `user.useConfigOnly=true` (injected via git's config env) forbids the
+   * username+hostname auto-detection that a developer machine would otherwise
+   * fall back to — deterministically reproducing the sandbox condition where
+   * git has no usable identity.
+   */
+  const NO_AUTODETECT_ENV = {
+    GIT_CONFIG_COUNT: "1",
+    GIT_CONFIG_KEY_0: "user.useConfigOnly",
+    GIT_CONFIG_VALUE_0: "true",
+  };
+
+  it("reproduces the cloud failure: a bare commit has no identity", async () => {
+    await expect(
+      sh(repo, 'git commit -m "agent changes (1)"', NO_AUTODETECT_ENV),
+    ).rejects.toThrow(/user\.email|user\.name|Author identity unknown|empty ident/);
+  });
+
+  it("the agent identity satisfies git even when auto-detection is forbidden", async () => {
+    await sh(repo, gitCommitAsAgent("agent changes (1)"), NO_AUTODETECT_ENV);
+
+    const author = await sh(repo, "git log -1 --format='%an <%ae>'");
+    expect(author.trim()).toBe(
+      `${AGENT_GIT_AUTHOR_NAME} <${AGENT_GIT_AUTHOR_EMAIL}>`,
+    );
+  });
+
+  it("commits successfully with the agent identity", async () => {
+    await sh(repo, gitCommitAsAgent("agent changes (1)"));
+
+    const author = await sh(repo, "git log -1 --format='%an <%ae>'");
+    expect(author.trim()).toBe(
+      `${AGENT_GIT_AUTHOR_NAME} <${AGENT_GIT_AUTHOR_EMAIL}>`,
+    );
+
+    const committer = await sh(repo, "git log -1 --format='%cn <%ce>'");
+    expect(committer.trim()).toBe(
+      `${AGENT_GIT_AUTHOR_NAME} <${AGENT_GIT_AUTHOR_EMAIL}>`,
+    );
+
+    const message = await sh(repo, "git log -1 --format=%s");
+    expect(message.trim()).toBe("agent changes (1)");
+  });
+
+  it("never mutates the repository's git config", async () => {
+    await sh(repo, gitCommitAsAgent("agent changes (1)"));
+
+    // `git config --local` exits non-zero when the key is unset.
+    await expect(sh(repo, "git config --local user.name")).rejects.toThrow();
+    await expect(sh(repo, "git config --local user.email")).rejects.toThrow();
+  });
+});
+
+describe("AGENT_GIT_IDENTITY_FLAGS", () => {
+  it("pins both name and email via per-command -c flags", () => {
+    expect(AGENT_GIT_IDENTITY_FLAGS).toBe(
+      `-c user.name='${AGENT_GIT_AUTHOR_NAME}' -c user.email='${AGENT_GIT_AUTHOR_EMAIL}'`,
+    );
+  });
+});

package/src/shared/workspace/__tests__/stigmer-link.test.ts

@@ -0,0 +1,173 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, mkdir, rm, writeFile, readFile, lstat, readlink } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { FilesystemBackend } from "deepagents";
+
+import {
+  ensureStigmerSymlink,
+  removeStigmerSymlink,
+  STIGMER_LOCAL_STATE_DIR,
+} from "../stigmer-link.js";
+import { LocalWorkspaceBackend } from "../local-backend.js";
+import { injectAttachments } from "../../../activities/execute-deep-agent/attachment-injector.js";
+
+/**
+ * The `.stigmer` symlink is the bridge that makes platform-mounted content
+ * (approved plan, skills, attachment inputs) readable by the agent's file
+ * tools in BOTH harnesses. The lifecycle tests pin the ownership contract
+ * (ensure replaces, remove is symlink-only); the convergence tests pin the
+ * end-to-end physics the native harness depends on: content written through
+ * the platform-routing LocalWorkspaceBackend must be readable at the same
+ * `.stigmer/…` path through a stock deepagents FilesystemBackend rooted at
+ * the workspace — which is exactly what broke when the native harness had no
+ * symlink (the "plan file doesn't exist" bug).
+ */
+describe("stigmer-link", () => {
+  let workspaceDir: string;
+  let platformDir: string;
+
+  beforeEach(async () => {
+    workspaceDir = await mkdtemp(join(tmpdir(), "stigmer-link-ws-"));
+    platformDir = await mkdtemp(join(tmpdir(), "stigmer-link-platform-"));
+  });
+
+  afterEach(async () => {
+    await rm(workspaceDir, { recursive: true, force: true });
+    await rm(platformDir, { recursive: true, force: true });
+  });
+
+  const linkPath = () => join(workspaceDir, STIGMER_LOCAL_STATE_DIR);
+
+  describe("ensureStigmerSymlink", () => {
+    it("creates the workspace symlink pointing at the platform dir", async () => {
+      await ensureStigmerSymlink(workspaceDir, platformDir);
+
+      expect((await lstat(linkPath())).isSymbolicLink()).toBe(true);
+      expect(await readlink(linkPath())).toBe(platformDir);
+    });
+
+    it("is idempotent for a correct existing link", async () => {
+      await ensureStigmerSymlink(workspaceDir, platformDir);
+      await ensureStigmerSymlink(workspaceDir, platformDir);
+
+      expect(await readlink(linkPath())).toBe(platformDir);
+    });
+
+    it("re-points a stale link at the current platform dir", async () => {
+      const stalePlatform = await mkdtemp(join(tmpdir(), "stigmer-link-stale-"));
+      try {
+        await ensureStigmerSymlink(workspaceDir, stalePlatform);
+        await ensureStigmerSymlink(workspaceDir, platformDir);
+
+        expect(await readlink(linkPath())).toBe(platformDir);
+      } finally {
+        await rm(stalePlatform, { recursive: true, force: true });
+      }
+    });
+
+    it("replaces a real .stigmer directory (platform owns the name)", async () => {
+      // The ownership sharp edge, pinned deliberately: a non-symlink
+      // `.stigmer` (left behind by an older runner) must never shadow the
+      // platform mount. See the module header for why this is safe.
+      await mkdir(join(linkPath(), "old"), { recursive: true });
+      await writeFile(join(linkPath(), "old", "stale.txt"), "stale");
+
+      await ensureStigmerSymlink(workspaceDir, platformDir);
+
+      expect((await lstat(linkPath())).isSymbolicLink()).toBe(true);
+      expect(await readlink(linkPath())).toBe(platformDir);
+    });
+  });
+
+  describe("removeStigmerSymlink", () => {
+    it("removes the symlink and leaves the platform dir intact", async () => {
+      await writeFile(join(platformDir, "keep.txt"), "keep");
+      await ensureStigmerSymlink(workspaceDir, platformDir);
+
+      await removeStigmerSymlink(workspaceDir);
+
+      await expect(lstat(linkPath())).rejects.toMatchObject({ code: "ENOENT" });
+      expect(await readFile(join(platformDir, "keep.txt"), "utf-8")).toBe("keep");
+    });
+
+    it("leaves a real .stigmer directory untouched (symlink-only removal)", async () => {
+      await mkdir(linkPath(), { recursive: true });
+      await writeFile(join(linkPath(), "user-owned.txt"), "mine");
+
+      await removeStigmerSymlink(workspaceDir);
+
+      expect(await readFile(join(linkPath(), "user-owned.txt"), "utf-8")).toBe("mine");
+    });
+
+    it("is a no-op when no link exists", async () => {
+      await expect(removeStigmerSymlink(workspaceDir)).resolves.toBeUndefined();
+    });
+  });
+
+  // ── Write/read convergence (the native-harness bug, pinned) ─────────
+
+  describe("platform write / agent read convergence", () => {
+    /** Read through the agent's actual file-tool backend. */
+    function agentRead(path: string): Promise<{ content?: string; error?: string }> {
+      const agentBackend = new FilesystemBackend({ rootDir: workspaceDir });
+      return agentBackend.read(path) as Promise<{ content?: string; error?: string }>;
+    }
+
+    it("approved plan injected via injectAttachments is readable by the deepagents backend", async () => {
+      const planFileName = "notes_ab12cd34.plan.md";
+      const planText = "# The Approved Plan\n\nStep 1: do the thing.\n";
+      const uploadPath = join(platformDir, "upload-src.md");
+      await writeFile(uploadPath, planText);
+
+      // Write path: exactly what the build turn does — the attachment is
+      // materialized through the platform-routing backend at the mount path
+      // the implement-plan directive will tell the model to read.
+      const workspaceBackend = new LocalWorkspaceBackend(workspaceDir, platformDir);
+      const injected = await injectAttachments({
+        backend: workspaceBackend,
+        attachments: [{
+          filename: planFileName,
+          storageKey: "",
+          mountPath: `.stigmer/inputs/${planFileName}`,
+          contentType: "text/markdown",
+          extract: false,
+          localPath: uploadPath,
+          $typeName: "ai.stigmer.agentic.agentexecution.v1.Attachment",
+        } as any],
+        storage: undefined,
+        isLocalMode: true,
+      });
+      expect(injected.map((f) => f.path)).toEqual([`.stigmer/inputs/${planFileName}`]);
+
+      // Without the symlink the agent cannot see the plan — the bug this
+      // module fixes for the native harness. Pinned so the link stays
+      // load-bearing in reviewers' and agents' mental models.
+      const before = await agentRead(`.stigmer/inputs/${planFileName}`);
+      expect(before.content ?? "").not.toContain("The Approved Plan");
+
+      await ensureStigmerSymlink(workspaceDir, platformDir);
+
+      const after = await agentRead(`.stigmer/inputs/${planFileName}`);
+      expect(after.error).toBeUndefined();
+      expect(after.content).toContain("The Approved Plan");
+    });
+
+    it("skill written through the platform-routing backend is readable at its prompt location", async () => {
+      // Same physical write the skill-writer performs for
+      // `.stigmer/skills/{name}/SKILL.md` — the path the system prompt tells
+      // the model to read to activate the skill.
+      const workspaceBackend = new LocalWorkspaceBackend(workspaceDir, platformDir);
+      await workspaceBackend.writeFile(
+        ".stigmer/skills/my-skill/SKILL.md",
+        "# My Skill\n\nDo skillful things.\n",
+      );
+
+      await ensureStigmerSymlink(workspaceDir, platformDir);
+
+      const result = await agentRead(".stigmer/skills/my-skill/SKILL.md");
+      expect(result.error).toBeUndefined();
+      expect(result.content).toContain("My Skill");
+    });
+  });
+});

package/src/shared/workspace/__tests__/writeback-coordinator.integration.test.ts

@@ -0,0 +1,230 @@
+/**
+ * Real-git integration tests for the session-scoped write-back lifecycle.
+ *
+ * A hermetic origin (local bare repo) and a working clone stand in for
+ * GitHub + the session workspace; only the PR API is mocked. These prove the
+ * behaviors the mocked unit suite cannot: that `ensureBranch`'s checkout
+ * cases and the always-`-u` push compose correctly against real git across
+ * SEQUENTIAL COORDINATOR INSTANCES (turn 1 and turn 2 of one session), and
+ * that only the tree's content at finalize — the post-reconcile, approved
+ * content — reaches the session branch.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { create } from "@bufbuild/protobuf";
+import { AgentExecutionStatusSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import { WorkspaceWriteBackPhase } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/writeback_pb";
+import { GitWriteBackMode } from "@stigmer/protos/ai/stigmer/agentic/session/v1/enum_pb";
+import { WriteBackCoordinator } from "../writeback-coordinator.js";
+import { LocalWorkspaceBackend } from "../local-backend.js";
+import { statusProtoWriter, type ExecutionStatusWriter } from "../../execution-status-writer.js";
+import type { ProvisionResult } from "../types.js";
+import { SourceType } from "../types.js";
+import { AGENT_GIT_AUTHOR_EMAIL } from "../git-identity.js";
+
+const SESSION_ID = "ses-int-01";
+const SESSION_BRANCH = `stigmer/${SESSION_ID}`;
+
+// Real git spawns (init/clone/commit/push, ~a dozen per test) are slow under
+// full-suite parallel load — observed >40s wall clock at ~4s of actual work.
+const GIT_TEST_TIMEOUT_MS = 120_000;
+
+let tmpRoot: string;
+let originDir: string;
+let workDir: string;
+
+function git(cwd: string, args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    encoding: "utf-8",
+    env: {
+      ...process.env,
+      GIT_AUTHOR_NAME: "human",
+      GIT_AUTHOR_EMAIL: "human@example.com",
+      GIT_COMMITTER_NAME: "human",
+      GIT_COMMITTER_EMAIL: "human@example.com",
+    },
+  });
+}
+
+function makeCoordinator(
+  executionId: string,
+  writer: ExecutionStatusWriter,
+): WriteBackCoordinator {
+  const provisionResult: ProvisionResult = {
+    rootDir: workDir,
+    sourceType: SourceType.GIT_REPO,
+    consumedKeys: [],
+    workspaceDescription: "integration",
+    entryName: "repo",
+    gitMetadata: {
+      repoUrl: "https://github.com/acme/repo.git",
+      branch: "main",
+      baseCommit: git(workDir, ["rev-parse", "main"]).trim(),
+      gitCredentialsConfigured: true,
+    },
+  };
+  return new WriteBackCoordinator({
+    statusWriter: writer,
+    executionId,
+    sessionId: SESSION_ID,
+    githubToken: "ghp_test",
+    provisionResults: [provisionResult],
+    workspaceEntries: [
+      {
+        name: "repo",
+        source: {
+          source: {
+            case: "gitRepo" as const,
+            value: { writeBackMode: GitWriteBackMode.GIT_WRITE_BACK_BRANCH_AND_PR },
+          },
+        },
+      } as any,
+    ],
+    workspaceBackend: new LocalWorkspaceBackend(workDir),
+  });
+}
+
+/** The PR API mock: no open PR on first list, then created; adopted after. */
+function mockGithubApi(): Array<{ method: string; url: string }> {
+  const calls: Array<{ method: string; url: string }> = [];
+  let created = false;
+  globalThis.fetch = vi.fn(async (url: any, init?: any) => {
+    const method = init?.method ?? "GET";
+    calls.push({ method, url: String(url) });
+    if (method === "GET") {
+      const body = created
+        ? [{ html_url: "https://github.com/acme/repo/pull/5", number: 5 }]
+        : [];
+      return new Response(JSON.stringify(body), { status: 200 });
+    }
+    created = true;
+    return new Response(
+      JSON.stringify({ html_url: "https://github.com/acme/repo/pull/5", number: 5 }),
+      { status: 201 },
+    );
+  }) as typeof fetch;
+  return calls;
+}
+
+const originalFetch = globalThis.fetch;
+
+beforeEach(() => {
+  tmpRoot = mkdtempSync(join(tmpdir(), "wb-int-"));
+  originDir = join(tmpRoot, "origin.git");
+  workDir = join(tmpRoot, "work");
+
+  execFileSync("git", ["init", "--bare", "-b", "main", originDir], { stdio: "pipe" });
+  execFileSync("git", ["clone", originDir, workDir], { stdio: "pipe" });
+  writeFileSync(join(workDir, "README.md"), "# seed\n");
+  git(workDir, ["add", "-A"]);
+  git(workDir, ["commit", "-m", "seed"]);
+  git(workDir, ["push", "-u", "origin", "main"]);
+});
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+  rmSync(tmpRoot, { recursive: true, force: true });
+});
+
+describe("WriteBackCoordinator against real git", () => {
+  it(
+    "pushes turn 1 to the session branch, then turn 2 (new instance) appends to it and adopts the PR",
+    async () => {
+      const apiCalls = mockGithubApi();
+
+      // ── Turn 1: the agent created a file; the review kept it. ──
+      writeFileSync(join(workDir, "notes.md"), "approved content\n");
+      const status1 = create(AgentExecutionStatusSchema, {});
+      const coord1 = makeCoordinator("exec-turn-1", statusProtoWriter(status1));
+      await coord1.finalize();
+
+      const wb1 = status1.workspaceWriteBacks[0];
+      expect(wb1.phase).toBe(WorkspaceWriteBackPhase.WORKSPACE_WRITE_BACK_PR_CREATED);
+      expect(wb1.branchName).toBe(SESSION_BRANCH);
+      expect(wb1.pullRequestNumber).toBe(5);
+
+      // The commit is on origin's session branch, authored as the agent, and
+      // main is untouched.
+      const tip1 = git(originDir, ["rev-parse", SESSION_BRANCH]).trim();
+      expect(git(originDir, ["show", `${tip1}:notes.md`])).toBe("approved content\n");
+      expect(git(originDir, ["log", "-1", "--format=%ae", SESSION_BRANCH]).trim())
+        .toBe(AGENT_GIT_AUTHOR_EMAIL);
+      expect(() => git(originDir, ["show", "main:notes.md"])).toThrow();
+
+      // ── Turn 2: a NEW coordinator (new execution, same session). The agent
+      // edited two files; the review discarded one — the reconcile snapped it
+      // back BEFORE finalize, so only the kept edit is in the tree. ──
+      writeFileSync(join(workDir, "notes.md"), "approved content\nkept edit\n");
+      writeFileSync(join(workDir, "rejected.md"), "discarded content\n");
+      rmSync(join(workDir, "rejected.md")); // the reconcile's snap-back
+
+      const status2 = create(AgentExecutionStatusSchema, {});
+      const coord2 = makeCoordinator("exec-turn-2", statusProtoWriter(status2));
+      await coord2.finalize();
+
+      const wb2 = status2.workspaceWriteBacks[0];
+      expect(wb2.phase).toBe(WorkspaceWriteBackPhase.WORKSPACE_WRITE_BACK_PR_CREATED);
+      expect(wb2.branchName, "same session branch across executions").toBe(SESSION_BRANCH);
+      expect(wb2.pullRequestNumber, "adopted, not re-created").toBe(5);
+      expect(apiCalls.filter((c) => c.method === "POST"), "exactly one PR ever created")
+        .toHaveLength(1);
+
+      // Both turns' commits are on the ONE session branch; the discarded file
+      // never reached the remote.
+      const tip2 = git(originDir, ["rev-parse", SESSION_BRANCH]).trim();
+      expect(git(originDir, ["show", `${tip2}:notes.md`])).toBe("approved content\nkept edit\n");
+      expect(() => git(originDir, ["show", `${tip2}:rejected.md`])).toThrow();
+      expect(
+        git(originDir, ["rev-list", "--count", `main..${SESSION_BRANCH}`]).trim(),
+        "one commit per approved turn",
+      ).toBe("2");
+
+      // Each commit message carries its execution id for traceability.
+      const messages = git(originDir, ["log", "--format=%s", SESSION_BRANCH]);
+      expect(messages).toContain("agent changes (exec-turn-1)");
+      expect(messages).toContain("agent changes (exec-turn-2)");
+    },
+    GIT_TEST_TIMEOUT_MS,
+  );
+
+  it(
+    "recovers the session branch from the remote after a workspace re-provision",
+    async () => {
+      mockGithubApi();
+
+      // Turn 1 establishes the branch on origin.
+      writeFileSync(join(workDir, "notes.md"), "turn one\n");
+      const coord1 = makeCoordinator(
+        "exec-a",
+        statusProtoWriter(create(AgentExecutionStatusSchema, {})),
+      );
+      await coord1.finalize();
+
+      // The sandbox is torn down; a fresh clone knows nothing of the local
+      // branch (only origin has it).
+      rmSync(workDir, { recursive: true, force: true });
+      execFileSync("git", ["clone", originDir, workDir], { stdio: "pipe" });
+      expect(git(workDir, ["branch", "--show-current"]).trim()).toBe("main");
+
+      // Turn 2 in the fresh clone must continue the SAME branch, not fork a
+      // new one from main (which would orphan turn 1's commit).
+      writeFileSync(join(workDir, "more.md"), "turn two\n");
+      const status2 = create(AgentExecutionStatusSchema, {});
+      const coord2 = makeCoordinator("exec-b", statusProtoWriter(status2));
+      await coord2.finalize();
+
+      expect(status2.workspaceWriteBacks[0].branchName).toBe(SESSION_BRANCH);
+      const tip = git(originDir, ["rev-parse", SESSION_BRANCH]).trim();
+      expect(git(originDir, ["show", `${tip}:notes.md`]), "turn 1's commit is an ancestor")
+        .toBe("turn one\n");
+      expect(git(originDir, ["show", `${tip}:more.md`])).toBe("turn two\n");
+      expect(git(originDir, ["rev-list", "--count", `main..${SESSION_BRANCH}`]).trim())
+        .toBe("2");
+    },
+    GIT_TEST_TIMEOUT_MS,
+  );
+});