mirror of
https://github.com/paperclipai/paperclip.git
synced 2026-11-08 01:57:31 +01:00
DottaandPaperclip
ab15aff390
## Thinking Path > - Paperclip is the open source app people use to manage AI agents for work. > - Conversations must use the same tasks, controls, and execution history. > - Users need an ongoing chat with an agent without managing task properties. > - Agents should clarify and plan work, then hand execution to assigned project tasks. > - This pull request combines the reviewed Agent Chat stack for one squash merge. > - The benefit is persistent conversation with normal task governance and shared UI. ## Linked Issues or Issue Description **Subsystem affected** Task lifecycle, agent runtime tools, shared task UI, and browser/paid runner tests. **Problem or motivation** Users need one persistent conversation with each agent. A separate chat store or renderer would duplicate task behavior and bypass existing controls. **Proposed solution** Use a task-backed chat per company, user, and agent. Reuse the task composer and transcript. Clarify and plan in chat, then create assigned project tasks with the relevant plan. Keep Agent Chat behind its own disabled-by-default experimental setting. **Roadmap alignment** This implements the task-backed direction in [CEO Chat](https://github.com/paperclipai/paperclip/blob/master/ROADMAP.md#-ceo-chat). Related proposals: #2504 and #9693. Related request: #7981. The maintainer requested one squash merge of the complete stack. Consolidates the reviewed runtime [#13281](https://github.com/paperclipai/paperclip/pull/13281), backend [#13282](https://github.com/paperclipai/paperclip/pull/13282), and UI [#13283](https://github.com/paperclipai/paperclip/pull/13283) layers with this PR's E2E coverage. All four layers passed CI and received Greptile 5/5 before consolidation. This PR targets master and includes the complete feature. ## What Changed - Add personal canonical chat tasks with ordinary company visibility, immutable identity, idempotent first sends, and an idle waiting state. - Process `/new` in queue order. Preserve history, release a chat pause, and fence old provider context and delayed writes. - Keep chat lifecycle rules across recovery, finalization, assignment, task lists, and rollups. - Support research and plan revision in chat. Hand plans to ordinary assigned project tasks before execution starts. Reject new chat subtasks. - Add repository-aware project creation and discovery tools, including multiple repository IDs and GitHub URLs, authorization, idempotency, and durable project-created cards. - Reuse task UI components for chat, with starred/recent agent navigation and a separate `enableAgentChat` experimental flag. - Add deterministic browser tests and 24 paid chat cells across four Codex/Claude profiles, with validated reports and screenshots. - Integrate current master recovery, controller lease, queued-message, and task UI changes. Gate chat interruption and deferred promotion on ownership/feature policy. Guarantee lease renewal and active controls are stopped even if teardown fails. - Preserve master's migration 0273 and generate chat migration 0274 with idempotent replay for development databases. ## Verification - Prior exact heads of all four PRs passed Linux CI, including build, typecheck, general/serialized tests, and browser E2E. Each had Greptile 5/5 and no unresolved findings. - Integrated local verification passed: full repository typecheck and production build, Storybook build, token gates, 340 focused UI tests, all 20 deterministic chat browser tests, two migration replay tests, 88 focused chat/queue/native/controller tests, and provider/session regressions including real lease expiry. These include the three lifecycle regressions for the final admission/teardown fixes; server typecheck also passes. Current head `1268eda16cc2af892055917e7292f068820be135` has Greptile 5/5 with no unresolved findings and passing security scans. All final-head CI gates passed: build, full Runner verification, typecheck/release registry, canary, all general/serialized test shards, and all browser E2E shards ([CI run](https://github.com/paperclipai/paperclip/actions/runs/34696739927)). Local PostgreSQL startup contention required serialized retries; skipped fixtures do not count as passing coverage. - The earlier paid campaign passed all 24 chat cells and retained 32 screenshots: [report](https://d1p6rlowie26tp.cloudfront.net/runner-e2e/campaigns/gha-34648511170-1/index.html?report=agent-chat#suite-agent-chat). It tested `abacbdfd2f660709ec37312cdb758284c8399d04`; it is prior evidence, not a paid run of this integrated head. - Manual check: enable Agent Chat in Experimental settings, open an agent, clarify and revise a plan, then hand off to an assigned project task. Stop a reply, send `/new`, and verify fresh context with retained history. Disable the setting and verify agent shortcuts/new chat turns are blocked. ## Risks - Queue/session integration can affect retries and delayed writes. Tests cover ownership, cancellation, reset boundaries, idle recovery, and ordinary task behavior. - Migration 0274 adds conversation fields and constraints. Replay is idempotent and preserves existing development chat history. - This combines the previously reviewed stack at the maintainer's request. Agent Chat remains off by default and is separate from Conference Room. ## Model Used OpenAI Codex, GPT-6 Astra (`gpt-6-astra`), with reasoning, code execution, browser tools, and parallel review. The exact context-window size is not exposed in this session. Codex and Claude also ran as test subjects in the linked paid campaign. ## Checklist - [x] I have included a thinking path that traces from project context to this change - [x] I have specified the model used (with version and capability details) - [x] I have checked ROADMAP.md and confirmed this PR does not duplicate planned core work - [x] I have searched GitHub for duplicate or related PRs and linked them above - [x] I have either (a) linked existing issues with `Fixes: #` / `Closes #` / `Refs #` OR (b) described the issue in-PR following the relevant issue template - [x] I have not referenced internal/instance-local Paperclip issues or links (only public GitHub `#NNN` / `github.com/paperclipai/paperclip` URLs) - [x] My branch name describes the change (e.g. `docs/...`, `fix/...`) and contains no internal Paperclip ticket id or instance-derived details - [x] I have run tests locally and they pass - [x] I have added or updated tests where applicable - [x] I have updated relevant documentation to reflect my changes - [x] I have considered and documented any risks above - [x] All Paperclip CI gates are green - [x] Greptile is 5/5 with no open P2s, recommendations, or follow-ups - [x] I will address all Greptile and reviewer comments before requesting merge --------- Co-authored-by: Paperclip <noreply@paperclip.ing>
1648 lines
65 KiB
TypeScript
1648 lines
65 KiB
TypeScript
import { afterEach, describe, expect, it, vi } from "vitest";
|
|
import fs from "node:fs/promises";
|
|
import os from "node:os";
|
|
import path from "node:path";
|
|
import { runChildProcess } from "@paperclipai/adapter-utils/server-utils";
|
|
import { execute } from "@paperclipai/adapter-codex-local/server";
|
|
import { buildPaperclipTaskMarkdown } from "../services/heartbeat.js";
|
|
import { AGENT_CHAT_DIRECTIVE } from "../services/agent-conversations.js";
|
|
|
|
async function writeFakeCodexCommand(commandPath: string): Promise<void> {
|
|
const script = `#!/usr/bin/env node
|
|
const fs = require("node:fs");
|
|
|
|
const capturePath = process.env.PAPERCLIP_TEST_CAPTURE_PATH;
|
|
const payload = {
|
|
argv: process.argv.slice(2),
|
|
prompt: fs.readFileSync(0, "utf8"),
|
|
codexHome: process.env.CODEX_HOME || null,
|
|
codexConfigContents: process.env.CODEX_HOME && fs.existsSync(process.env.CODEX_HOME + "/config.toml")
|
|
? fs.readFileSync(process.env.CODEX_HOME + "/config.toml", "utf8")
|
|
: null,
|
|
paperclipWakePayloadJson: process.env.PAPERCLIP_WAKE_PAYLOAD_JSON || null,
|
|
paperclipApiUrl: process.env.PAPERCLIP_API_URL || null,
|
|
paperclipApiKey: process.env.PAPERCLIP_API_KEY || null,
|
|
paperclipApiBridgeMode: process.env.PAPERCLIP_API_BRIDGE_MODE || null,
|
|
paperclipEnvKeys: Object.keys(process.env)
|
|
.filter((key) => key.startsWith("PAPERCLIP_"))
|
|
.sort(),
|
|
};
|
|
if (capturePath) {
|
|
fs.writeFileSync(capturePath, JSON.stringify(payload), "utf8");
|
|
}
|
|
console.log(JSON.stringify({ type: "thread.started", thread_id: "codex-session-1" }));
|
|
console.log(JSON.stringify({ type: "item.completed", item: { type: "agent_message", text: "hello" } }));
|
|
console.log(JSON.stringify({ type: "turn.completed", usage: { input_tokens: 1, cached_input_tokens: 0, output_tokens: 1 } }));
|
|
`;
|
|
await fs.writeFile(commandPath, script, "utf8");
|
|
await fs.chmod(commandPath, 0o755);
|
|
}
|
|
|
|
async function writeFailingCodexCommand(commandPath: string, errorMessage: string): Promise<void> {
|
|
const script = `#!/usr/bin/env node
|
|
console.log(JSON.stringify({ type: "error", message: ${JSON.stringify(errorMessage)} }));
|
|
process.exit(1);
|
|
`;
|
|
await fs.writeFile(commandPath, script, "utf8");
|
|
await fs.chmod(commandPath, 0o755);
|
|
}
|
|
|
|
type CapturePayload = {
|
|
argv: string[];
|
|
prompt: string;
|
|
codexHome: string | null;
|
|
codexConfigContents?: string | null;
|
|
paperclipWakePayloadJson: string | null;
|
|
paperclipApiUrl?: string | null;
|
|
paperclipApiKey?: string | null;
|
|
paperclipApiBridgeMode?: string | null;
|
|
paperclipEnvKeys: string[];
|
|
};
|
|
|
|
type LogEntry = {
|
|
stream: "stdout" | "stderr";
|
|
chunk: string;
|
|
};
|
|
|
|
const fakeCodexAuthJson = JSON.stringify({ OPENAI_API_KEY: "sk-test-codex-local" });
|
|
|
|
const codexHomeOverrides: Array<string | undefined> = [];
|
|
|
|
afterEach(() => {
|
|
while (codexHomeOverrides.length > 0) {
|
|
const previous = codexHomeOverrides.pop();
|
|
if (previous === undefined) delete process.env.CODEX_HOME;
|
|
else process.env.CODEX_HOME = previous;
|
|
}
|
|
});
|
|
|
|
async function seedSharedCodexAuth(homeRoot: string): Promise<void> {
|
|
const sharedCodexHome = path.join(homeRoot, ".codex");
|
|
codexHomeOverrides.push(process.env.CODEX_HOME);
|
|
process.env.CODEX_HOME = sharedCodexHome;
|
|
await fs.mkdir(sharedCodexHome, { recursive: true });
|
|
await fs.writeFile(path.join(sharedCodexHome, "auth.json"), `${fakeCodexAuthJson}\n`, "utf8");
|
|
}
|
|
|
|
function createLocalSandboxRunner() {
|
|
let counter = 0;
|
|
return {
|
|
execute: async (input: {
|
|
command: string;
|
|
args?: string[];
|
|
cwd?: string;
|
|
env?: Record<string, string>;
|
|
stdin?: string;
|
|
timeoutMs?: number;
|
|
onLog?: (stream: "stdout" | "stderr", chunk: string) => Promise<void>;
|
|
onSpawn?: (meta: { pid: number; startedAt: string }) => Promise<void>;
|
|
}) => {
|
|
counter += 1;
|
|
return runChildProcess(
|
|
`sandbox-run-${counter}`,
|
|
input.command,
|
|
input.args ?? [],
|
|
{
|
|
cwd: input.cwd ?? process.cwd(),
|
|
env: input.env ?? {},
|
|
stdin: input.stdin,
|
|
timeoutSec: Math.max(1, Math.ceil((input.timeoutMs ?? 30_000) / 1000)),
|
|
graceSec: 5,
|
|
onLog: input.onLog ?? (async () => {}),
|
|
onSpawn: input.onSpawn
|
|
? async (meta) => input.onSpawn?.({ pid: meta.pid, startedAt: meta.startedAt })
|
|
: undefined,
|
|
},
|
|
);
|
|
},
|
|
};
|
|
}
|
|
|
|
describe("codex execute", () => {
|
|
it("uses a Paperclip-managed CODEX_HOME outside worktree mode while preserving shared auth and config", async () => {
|
|
const root = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-codex-execute-default-"));
|
|
const workspace = path.join(root, "workspace");
|
|
const commandPath = path.join(root, "codex");
|
|
const capturePath = path.join(root, "capture.json");
|
|
const sharedCodexHome = path.join(root, "shared-codex-home");
|
|
const paperclipHome = path.join(root, "paperclip-home");
|
|
const managedCodexHome = path.join(
|
|
paperclipHome,
|
|
"instances",
|
|
"default",
|
|
"companies",
|
|
"company-1",
|
|
"codex-home",
|
|
);
|
|
await fs.mkdir(workspace, { recursive: true });
|
|
await fs.mkdir(sharedCodexHome, { recursive: true });
|
|
await fs.writeFile(path.join(sharedCodexHome, "auth.json"), `${fakeCodexAuthJson}\n`, "utf8");
|
|
await fs.writeFile(path.join(sharedCodexHome, "config.toml"), 'model = "codex-mini-latest"\n', "utf8");
|
|
await writeFakeCodexCommand(commandPath);
|
|
|
|
const previousHome = process.env.HOME;
|
|
const previousPaperclipHome = process.env.PAPERCLIP_HOME;
|
|
const previousPaperclipInstanceId = process.env.PAPERCLIP_INSTANCE_ID;
|
|
const previousPaperclipInWorktree = process.env.PAPERCLIP_IN_WORKTREE;
|
|
const previousCodexHome = process.env.CODEX_HOME;
|
|
process.env.HOME = root;
|
|
process.env.PAPERCLIP_HOME = paperclipHome;
|
|
delete process.env.PAPERCLIP_INSTANCE_ID;
|
|
delete process.env.PAPERCLIP_IN_WORKTREE;
|
|
process.env.CODEX_HOME = sharedCodexHome;
|
|
|
|
try {
|
|
const logs: LogEntry[] = [];
|
|
const result = await execute({
|
|
runId: "run-default",
|
|
agent: {
|
|
id: "agent-1",
|
|
companyId: "company-1",
|
|
name: "Codex Coder",
|
|
adapterType: "codex_local",
|
|
adapterConfig: { engine: "cli" },
|
|
},
|
|
runtime: {
|
|
sessionId: null,
|
|
sessionParams: null,
|
|
sessionDisplayId: null,
|
|
taskKey: null,
|
|
},
|
|
config: {
|
|
engine: "cli",
|
|
command: commandPath,
|
|
cwd: workspace,
|
|
env: {
|
|
PAPERCLIP_TEST_CAPTURE_PATH: capturePath,
|
|
},
|
|
promptTemplate: "Follow the paperclip heartbeat.",
|
|
},
|
|
context: {},
|
|
authToken: "run-jwt-token",
|
|
onLog: async (stream, chunk) => {
|
|
logs.push({ stream, chunk });
|
|
},
|
|
});
|
|
|
|
expect(result.exitCode).toBe(0);
|
|
expect(result.errorMessage).toBeNull();
|
|
expect(result.usage).toEqual({ inputTokens: 1, cachedInputTokens: 0, outputTokens: 1 });
|
|
expect(result.usageBasis).toBe("per_run");
|
|
expect(result.costUsd).toBeNull();
|
|
|
|
const capture = JSON.parse(await fs.readFile(capturePath, "utf8")) as CapturePayload;
|
|
expect(capture.codexHome).toBe(managedCodexHome);
|
|
|
|
const managedAuth = path.join(managedCodexHome, "auth.json");
|
|
const managedConfig = path.join(managedCodexHome, "config.toml");
|
|
expect((await fs.lstat(managedAuth)).isSymbolicLink()).toBe(true);
|
|
expect(await fs.realpath(managedAuth)).toBe(await fs.realpath(path.join(sharedCodexHome, "auth.json")));
|
|
expect((await fs.lstat(managedConfig)).isFile()).toBe(true);
|
|
expect(await fs.readFile(managedConfig, "utf8")).toBe('model = "codex-mini-latest"\n');
|
|
await expect(fs.lstat(path.join(sharedCodexHome, "companies", "company-1"))).rejects.toThrow();
|
|
expect(logs).toContainEqual(
|
|
expect.objectContaining({
|
|
stream: "stdout",
|
|
chunk: expect.stringContaining("Using Paperclip-managed Codex home"),
|
|
}),
|
|
);
|
|
} finally {
|
|
if (previousHome === undefined) delete process.env.HOME;
|
|
else process.env.HOME = previousHome;
|
|
if (previousPaperclipHome === undefined) delete process.env.PAPERCLIP_HOME;
|
|
else process.env.PAPERCLIP_HOME = previousPaperclipHome;
|
|
if (previousPaperclipInstanceId === undefined) delete process.env.PAPERCLIP_INSTANCE_ID;
|
|
else process.env.PAPERCLIP_INSTANCE_ID = previousPaperclipInstanceId;
|
|
if (previousPaperclipInWorktree === undefined) delete process.env.PAPERCLIP_IN_WORKTREE;
|
|
else process.env.PAPERCLIP_IN_WORKTREE = previousPaperclipInWorktree;
|
|
if (previousCodexHome === undefined) delete process.env.CODEX_HOME;
|
|
else process.env.CODEX_HOME = previousCodexHome;
|
|
await fs.rm(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it("writes managed MCP gateways into Codex config and warns on overlapping direct entries without logging tokens", async () => {
|
|
const root = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-codex-managed-mcp-"));
|
|
const workspace = path.join(root, "workspace");
|
|
const commandPath = path.join(root, "codex");
|
|
const capturePath = path.join(root, "capture.json");
|
|
const sharedCodexHome = path.join(root, "shared-codex-home");
|
|
const paperclipHome = path.join(root, "paperclip-home");
|
|
const managedCodexHome = path.join(
|
|
paperclipHome,
|
|
"instances",
|
|
"default",
|
|
"companies",
|
|
"company-1",
|
|
"codex-home",
|
|
);
|
|
await fs.mkdir(workspace, { recursive: true });
|
|
await fs.mkdir(sharedCodexHome, { recursive: true });
|
|
await fs.writeFile(path.join(sharedCodexHome, "auth.json"), `${fakeCodexAuthJson}\n`, "utf8");
|
|
await fs.writeFile(
|
|
path.join(sharedCodexHome, "config.toml"),
|
|
[
|
|
'model = "codex-mini-latest"',
|
|
"",
|
|
'[mcp_servers.github]',
|
|
'url = "https://raw.example/mcp"',
|
|
"",
|
|
].join("\n"),
|
|
"utf8",
|
|
);
|
|
await writeFakeCodexCommand(commandPath);
|
|
|
|
const previousHome = process.env.HOME;
|
|
const previousPaperclipHome = process.env.PAPERCLIP_HOME;
|
|
const previousPaperclipApiUrl = process.env.PAPERCLIP_API_URL;
|
|
const previousPaperclipRuntimeApiUrl = process.env.PAPERCLIP_RUNTIME_API_URL;
|
|
const previousCodexHome = process.env.CODEX_HOME;
|
|
process.env.HOME = root;
|
|
process.env.PAPERCLIP_HOME = paperclipHome;
|
|
process.env.PAPERCLIP_API_URL = "http://paperclip.local:3100";
|
|
process.env.PAPERCLIP_RUNTIME_API_URL = "http://paperclip.local:3100";
|
|
process.env.CODEX_HOME = sharedCodexHome;
|
|
|
|
try {
|
|
const logs: LogEntry[] = [];
|
|
const result = await execute({
|
|
runId: "run-managed-mcp",
|
|
agent: {
|
|
id: "agent-1",
|
|
companyId: "company-1",
|
|
name: "Codex Coder",
|
|
adapterType: "codex_local",
|
|
adapterConfig: {},
|
|
},
|
|
runtime: {
|
|
sessionId: null,
|
|
sessionParams: null,
|
|
sessionDisplayId: null,
|
|
taskKey: null,
|
|
},
|
|
config: {
|
|
engine: "cli",
|
|
command: commandPath,
|
|
cwd: workspace,
|
|
env: {
|
|
PAPERCLIP_TEST_CAPTURE_PATH: capturePath,
|
|
},
|
|
promptTemplate: "Follow the paperclip heartbeat.",
|
|
},
|
|
runtimeMcp: {
|
|
getServers: () => [
|
|
{
|
|
name: "github",
|
|
url: "http://paperclip.local:3100/api/tool-gateway/gateways/gateway-1/mcp",
|
|
token: "pcgw_secret-managed-token",
|
|
connectionId: "connection-github",
|
|
},
|
|
],
|
|
},
|
|
context: {},
|
|
authToken: "run-jwt-token",
|
|
onLog: async (stream, chunk) => {
|
|
logs.push({ stream, chunk });
|
|
},
|
|
});
|
|
|
|
expect(result.exitCode).toBe(0);
|
|
expect(result.errorMessage).toBeNull();
|
|
const capture = JSON.parse(await fs.readFile(capturePath, "utf8")) as CapturePayload;
|
|
const configText = capture.codexConfigContents ?? "";
|
|
expect(configText).toContain("[mcp_servers.github]");
|
|
expect(configText).toContain("[mcp_servers.\"paperclip-github\"]");
|
|
expect(configText).toContain('url = "http://paperclip.local:3100/api/tool-gateway/gateways/gateway-1/mcp"');
|
|
expect(configText).toContain('Authorization = "Bearer pcgw_secret-managed-token"');
|
|
expect(logs).toEqual(
|
|
expect.arrayContaining([
|
|
expect.objectContaining({
|
|
stream: "stderr",
|
|
chunk: expect.stringContaining("Paperclip cannot enforce policies for that direct entry"),
|
|
}),
|
|
]),
|
|
);
|
|
expect(JSON.stringify(logs)).not.toContain("pcgw_secret-managed-token");
|
|
} finally {
|
|
if (previousHome === undefined) delete process.env.HOME;
|
|
else process.env.HOME = previousHome;
|
|
if (previousPaperclipHome === undefined) delete process.env.PAPERCLIP_HOME;
|
|
else process.env.PAPERCLIP_HOME = previousPaperclipHome;
|
|
if (previousPaperclipApiUrl === undefined) delete process.env.PAPERCLIP_API_URL;
|
|
else process.env.PAPERCLIP_API_URL = previousPaperclipApiUrl;
|
|
if (previousPaperclipRuntimeApiUrl === undefined) delete process.env.PAPERCLIP_RUNTIME_API_URL;
|
|
else process.env.PAPERCLIP_RUNTIME_API_URL = previousPaperclipRuntimeApiUrl;
|
|
if (previousCodexHome === undefined) delete process.env.CODEX_HOME;
|
|
else process.env.CODEX_HOME = previousCodexHome;
|
|
await fs.rm(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it("emits a command note that Codex auto-applies repo-scoped AGENTS.md files", async () => {
|
|
const root = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-codex-execute-notes-"));
|
|
const workspace = path.join(root, "workspace");
|
|
const commandPath = path.join(root, "codex");
|
|
const capturePath = path.join(root, "capture.json");
|
|
await fs.mkdir(workspace, { recursive: true });
|
|
await writeFakeCodexCommand(commandPath);
|
|
|
|
const previousHome = process.env.HOME;
|
|
process.env.HOME = root;
|
|
await seedSharedCodexAuth(root);
|
|
|
|
let commandNotes: string[] = [];
|
|
try {
|
|
const result = await execute({
|
|
runId: "run-notes",
|
|
agent: {
|
|
id: "agent-1",
|
|
companyId: "company-1",
|
|
name: "Codex Coder",
|
|
adapterType: "codex_local",
|
|
adapterConfig: { engine: "cli" },
|
|
},
|
|
runtime: {
|
|
sessionId: null,
|
|
sessionParams: null,
|
|
sessionDisplayId: null,
|
|
taskKey: null,
|
|
},
|
|
config: {
|
|
engine: "cli",
|
|
command: commandPath,
|
|
cwd: workspace,
|
|
env: {
|
|
PAPERCLIP_TEST_CAPTURE_PATH: capturePath,
|
|
},
|
|
promptTemplate: "Follow the paperclip heartbeat.",
|
|
},
|
|
context: {},
|
|
authToken: "run-jwt-token",
|
|
onLog: async () => {},
|
|
onMeta: async (meta) => {
|
|
commandNotes = Array.isArray(meta.commandNotes) ? meta.commandNotes : [];
|
|
},
|
|
});
|
|
|
|
expect(result.exitCode).toBe(0);
|
|
expect(result.errorMessage).toBeNull();
|
|
expect(commandNotes).toContain(
|
|
"Codex exec automatically applies repo-scoped AGENTS.md instructions from the current workspace; Paperclip does not currently suppress that discovery.",
|
|
);
|
|
} finally {
|
|
if (previousHome === undefined) delete process.env.HOME;
|
|
else process.env.HOME = previousHome;
|
|
await fs.rm(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it("logs HOME and the resolved executable path in invocation metadata", async () => {
|
|
const root = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-codex-execute-meta-"));
|
|
const workspace = path.join(root, "workspace");
|
|
const binDir = path.join(root, "bin");
|
|
const commandPath = path.join(binDir, "codex");
|
|
const capturePath = path.join(root, "capture.json");
|
|
await fs.mkdir(workspace, { recursive: true });
|
|
await fs.mkdir(binDir, { recursive: true });
|
|
await writeFakeCodexCommand(commandPath);
|
|
|
|
const previousHome = process.env.HOME;
|
|
const previousPath = process.env.PATH;
|
|
process.env.HOME = root;
|
|
process.env.PATH = `${binDir}${path.delimiter}${process.env.PATH ?? ""}`;
|
|
await seedSharedCodexAuth(root);
|
|
|
|
let loggedCommand: string | null = null;
|
|
let loggedEnv: Record<string, string> = {};
|
|
try {
|
|
const result = await execute({
|
|
runId: "run-meta",
|
|
agent: {
|
|
id: "agent-1",
|
|
companyId: "company-1",
|
|
name: "Codex Coder",
|
|
adapterType: "codex_local",
|
|
adapterConfig: { engine: "cli" },
|
|
},
|
|
runtime: {
|
|
sessionId: null,
|
|
sessionParams: null,
|
|
sessionDisplayId: null,
|
|
taskKey: null,
|
|
},
|
|
config: {
|
|
engine: "cli",
|
|
command: "codex",
|
|
cwd: workspace,
|
|
env: {
|
|
PAPERCLIP_TEST_CAPTURE_PATH: capturePath,
|
|
},
|
|
promptTemplate: "Follow the paperclip heartbeat.",
|
|
},
|
|
context: {},
|
|
authToken: "run-jwt-token",
|
|
onLog: async () => {},
|
|
onMeta: async (meta) => {
|
|
loggedCommand = meta.command;
|
|
loggedEnv = meta.env ?? {};
|
|
},
|
|
});
|
|
|
|
expect(result.exitCode).toBe(0);
|
|
expect(result.errorMessage).toBeNull();
|
|
expect(loggedCommand).toBe(commandPath);
|
|
expect(loggedEnv.HOME).toBe(root);
|
|
expect(loggedEnv.PAPERCLIP_RESOLVED_COMMAND).toBe(commandPath);
|
|
} finally {
|
|
if (previousHome === undefined) delete process.env.HOME;
|
|
else process.env.HOME = previousHome;
|
|
if (previousPath === undefined) delete process.env.PATH;
|
|
else process.env.PATH = previousPath;
|
|
await fs.rm(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it("injects bridge env into sandbox-managed remote runs", async () => {
|
|
const root = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-codex-execute-sandbox-"));
|
|
const localWorkspace = path.join(root, "workspace");
|
|
const remoteWorkspace = path.join(root, "sandbox");
|
|
const binDir = path.join(root, "bin");
|
|
const commandPath = path.join(binDir, "codex");
|
|
const capturePath = path.join(remoteWorkspace, "capture.json");
|
|
const previousHome = process.env.HOME;
|
|
const previousPath = process.env.PATH;
|
|
|
|
await fs.mkdir(localWorkspace, { recursive: true });
|
|
await fs.mkdir(remoteWorkspace, { recursive: true });
|
|
await fs.mkdir(binDir, { recursive: true });
|
|
await writeFakeCodexCommand(commandPath);
|
|
|
|
process.env.HOME = root;
|
|
process.env.PATH = `${binDir}${path.delimiter}${process.env.PATH ?? ""}`;
|
|
await seedSharedCodexAuth(root);
|
|
|
|
try {
|
|
const result = await execute({
|
|
runId: "run-sandbox-auth",
|
|
agent: {
|
|
id: "agent-1",
|
|
companyId: "company-1",
|
|
name: "Codex Coder",
|
|
adapterType: "codex_local",
|
|
adapterConfig: { engine: "cli" },
|
|
},
|
|
runtime: {
|
|
sessionId: null,
|
|
sessionParams: null,
|
|
sessionDisplayId: null,
|
|
taskKey: null,
|
|
},
|
|
config: {
|
|
engine: "cli",
|
|
command: commandPath,
|
|
cwd: localWorkspace,
|
|
env: {
|
|
PAPERCLIP_TEST_CAPTURE_PATH: capturePath,
|
|
},
|
|
promptTemplate: "Follow the paperclip heartbeat.",
|
|
},
|
|
context: {},
|
|
executionTarget: {
|
|
kind: "remote",
|
|
transport: "sandbox",
|
|
providerKey: "e2b",
|
|
environmentId: "env-1",
|
|
leaseId: "lease-1",
|
|
remoteCwd: remoteWorkspace,
|
|
timeoutMs: 30_000,
|
|
runner: createLocalSandboxRunner(),
|
|
},
|
|
authToken: "run-jwt-token",
|
|
onLog: async () => {},
|
|
});
|
|
|
|
expect(result.exitCode).toBe(0);
|
|
expect(result.errorMessage).toBeNull();
|
|
|
|
const capture = JSON.parse(await fs.readFile(capturePath, "utf8")) as CapturePayload;
|
|
expect(capture.codexHome).toBe(path.join(remoteWorkspace, ".paperclip-runtime", "codex", "home"));
|
|
expect(capture.paperclipApiUrl).toMatch(/^http:\/\/127\.0\.0\.1:\d+$/);
|
|
expect(capture.paperclipApiKey).not.toBe("run-jwt-token");
|
|
expect(capture.paperclipApiBridgeMode).toBe("queue_v1");
|
|
} finally {
|
|
if (previousHome === undefined) delete process.env.HOME;
|
|
else process.env.HOME = previousHome;
|
|
if (previousPath === undefined) delete process.env.PATH;
|
|
else process.env.PATH = previousPath;
|
|
await fs.rm(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it("injects structured Paperclip wake payloads into env and prompt", async () => {
|
|
const root = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-codex-execute-wake-"));
|
|
const workspace = path.join(root, "workspace");
|
|
const commandPath = path.join(root, "codex");
|
|
const capturePath = path.join(root, "capture.json");
|
|
await fs.mkdir(workspace, { recursive: true });
|
|
await writeFakeCodexCommand(commandPath);
|
|
|
|
const previousHome = process.env.HOME;
|
|
process.env.HOME = root;
|
|
await seedSharedCodexAuth(root);
|
|
|
|
try {
|
|
const result = await execute({
|
|
runId: "run-wake",
|
|
agent: {
|
|
id: "agent-1",
|
|
companyId: "company-1",
|
|
name: "Codex Coder",
|
|
adapterType: "codex_local",
|
|
adapterConfig: { engine: "cli" },
|
|
},
|
|
runtime: {
|
|
sessionId: null,
|
|
sessionParams: null,
|
|
sessionDisplayId: null,
|
|
taskKey: null,
|
|
},
|
|
config: {
|
|
engine: "cli",
|
|
command: commandPath,
|
|
cwd: workspace,
|
|
env: {
|
|
PAPERCLIP_TEST_CAPTURE_PATH: capturePath,
|
|
},
|
|
promptTemplate: "Follow the paperclip heartbeat.",
|
|
},
|
|
context: {
|
|
issueId: "issue-1",
|
|
taskId: "issue-1",
|
|
wakeReason: "issue_commented",
|
|
wakeCommentId: "comment-2",
|
|
paperclipWake: {
|
|
reason: "issue_commented",
|
|
issue: {
|
|
id: "issue-1",
|
|
identifier: "PAP-874",
|
|
title: "chat-speed issues",
|
|
status: "in_progress",
|
|
priority: "medium",
|
|
},
|
|
commentIds: ["comment-1", "comment-2"],
|
|
latestCommentId: "comment-2",
|
|
comments: [
|
|
{
|
|
id: "comment-1",
|
|
issueId: "issue-1",
|
|
body: "First comment",
|
|
bodyTruncated: false,
|
|
createdAt: "2026-03-28T14:35:00.000Z",
|
|
author: { type: "user", id: "user-1" },
|
|
},
|
|
{
|
|
id: "comment-2",
|
|
issueId: "issue-1",
|
|
body: "Second comment",
|
|
bodyTruncated: false,
|
|
createdAt: "2026-03-28T14:35:10.000Z",
|
|
author: { type: "user", id: "user-1" },
|
|
},
|
|
],
|
|
commentWindow: {
|
|
requestedCount: 2,
|
|
includedCount: 2,
|
|
missingCount: 0,
|
|
},
|
|
truncated: false,
|
|
fallbackFetchNeeded: false,
|
|
},
|
|
},
|
|
authToken: "run-jwt-token",
|
|
onLog: async () => {},
|
|
});
|
|
|
|
expect(result.exitCode).toBe(0);
|
|
expect(result.errorMessage).toBeNull();
|
|
|
|
const capture = JSON.parse(await fs.readFile(capturePath, "utf8")) as CapturePayload;
|
|
expect(capture.paperclipEnvKeys).toContain("PAPERCLIP_WAKE_PAYLOAD_JSON");
|
|
expect(capture.paperclipWakePayloadJson).not.toBeNull();
|
|
expect(JSON.parse(capture.paperclipWakePayloadJson ?? "{}")).toMatchObject({
|
|
reason: "issue_commented",
|
|
latestCommentId: "comment-2",
|
|
commentIds: ["comment-1", "comment-2"],
|
|
});
|
|
expect(capture.prompt).toContain("## Paperclip Wake Payload");
|
|
expect(capture.prompt).toContain("Treat this wake payload as the highest-priority change for the current heartbeat.");
|
|
expect(capture.prompt).toContain("Do not switch to another issue until you have handled this wake.");
|
|
expect(capture.prompt).toContain(
|
|
"acknowledge the latest comment and explain how it changes your next action.",
|
|
);
|
|
expect(capture.prompt).toContain("First comment");
|
|
expect(capture.prompt).toContain("Second comment");
|
|
} finally {
|
|
if (previousHome === undefined) delete process.env.HOME;
|
|
else process.env.HOME = previousHome;
|
|
await fs.rm(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it("classifies remote-compaction high-demand failures as retryable transient upstream errors", async () => {
|
|
const root = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-codex-execute-transient-"));
|
|
const workspace = path.join(root, "workspace");
|
|
const commandPath = path.join(root, "codex");
|
|
await fs.mkdir(workspace, { recursive: true });
|
|
await writeFailingCodexCommand(
|
|
commandPath,
|
|
"Error running remote compact task: We're currently experiencing high demand, which may cause temporary errors.",
|
|
);
|
|
|
|
const previousHome = process.env.HOME;
|
|
process.env.HOME = root;
|
|
await seedSharedCodexAuth(root);
|
|
|
|
try {
|
|
const result = await execute({
|
|
runId: "run-transient-error",
|
|
agent: {
|
|
id: "agent-1",
|
|
companyId: "company-1",
|
|
name: "Codex Coder",
|
|
adapterType: "codex_local",
|
|
adapterConfig: { engine: "cli" },
|
|
},
|
|
runtime: {
|
|
sessionId: null,
|
|
sessionParams: null,
|
|
sessionDisplayId: null,
|
|
taskKey: null,
|
|
},
|
|
config: {
|
|
engine: "cli",
|
|
command: commandPath,
|
|
cwd: workspace,
|
|
promptTemplate: "Follow the paperclip heartbeat.",
|
|
},
|
|
context: {},
|
|
authToken: "run-jwt-token",
|
|
onLog: async () => {},
|
|
});
|
|
|
|
expect(result.exitCode).toBe(1);
|
|
expect(result.errorCode).toBe("codex_transient_upstream");
|
|
expect(result.errorFamily).toBe("transient_upstream");
|
|
expect(result.errorMessage).toContain("high demand");
|
|
} finally {
|
|
if (previousHome === undefined) delete process.env.HOME;
|
|
else process.env.HOME = previousHome;
|
|
await fs.rm(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it.each([true, false])("retries missing resume only before a session starts (started=%s)", async (started) => {
|
|
const root = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-codex-resume-stop-"));
|
|
const commandPath = path.join(root, "codex");
|
|
const attemptsPath = path.join(root, "attempts");
|
|
await seedSharedCodexAuth(root);
|
|
await fs.writeFile(commandPath, `#!/usr/bin/env node
|
|
const fs = require("node:fs");
|
|
fs.appendFileSync(${JSON.stringify(attemptsPath)}, "attempt\\n");
|
|
if (process.argv.includes("resume")) {
|
|
console.error("state db missing rollout path for thread unrelated-old-thread");
|
|
${started ? 'console.log(JSON.stringify({ type: "thread.started", thread_id: "existing-session" }));' : ''}
|
|
process.exitCode = 1;
|
|
} else {
|
|
console.log(JSON.stringify({ type: "thread.started", thread_id: "fresh-session" }));
|
|
console.log(JSON.stringify({ type: "turn.completed", usage: { input_tokens: 1, output_tokens: 1 } }));
|
|
}
|
|
`, "utf8");
|
|
await fs.chmod(commandPath, 0o755);
|
|
try {
|
|
const result = await execute({
|
|
runId: `resume-stop-${started}`,
|
|
agent: { id: "agent-1", companyId: "company-1", name: "Codex", adapterType: "codex_local", adapterConfig: { engine: "cli" } },
|
|
runtime: { sessionId: "existing-session", sessionParams: null, sessionDisplayId: "existing-session", taskKey: null },
|
|
config: { engine: "cli", command: commandPath, cwd: root, promptTemplate: "Test resume." },
|
|
context: {}, onLog: async () => {},
|
|
});
|
|
expect((await fs.readFile(attemptsPath, "utf8")).trim().split("\n")).toHaveLength(started ? 1 : 2);
|
|
expect(result.sessionId).toBe(started ? "existing-session" : "fresh-session");
|
|
} finally {
|
|
await fs.rm(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it("classifies mid-turn harness crashes as retryable transient upstream errors", async () => {
|
|
const root = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-codex-execute-harness-crash-"));
|
|
const workspace = path.join(root, "workspace");
|
|
const commandPath = path.join(root, "codex");
|
|
await fs.mkdir(workspace, { recursive: true });
|
|
// Faithful to the observed MCP transport crash: the protocol stream starts,
|
|
// then the process dies with only a harness tracing line on stderr — no
|
|
// protocol-terminal event (error / turn.failed / turn.completed).
|
|
const script = `#!/usr/bin/env node
|
|
console.log(JSON.stringify({ type: "thread.started", thread_id: "thread-crash-1" }));
|
|
console.log(JSON.stringify({ type: "item.completed", item: { type: "agent_message", text: "Starting the task." } }));
|
|
console.error("2026-07-23T22:58:56.007042Z ERROR rmcp::transport::worker: worker quit with fatal: Transport channel closed, when UnexpectedContentType(Some(\\"text/plain\\"))");
|
|
process.exit(1);
|
|
`;
|
|
await fs.writeFile(commandPath, script, "utf8");
|
|
await fs.chmod(commandPath, 0o755);
|
|
|
|
const previousHome = process.env.HOME;
|
|
process.env.HOME = root;
|
|
await seedSharedCodexAuth(root);
|
|
|
|
try {
|
|
const result = await execute({
|
|
runId: "run-harness-crash",
|
|
agent: {
|
|
id: "agent-1",
|
|
companyId: "company-1",
|
|
name: "Codex Coder",
|
|
adapterType: "codex_local",
|
|
adapterConfig: { engine: "cli" },
|
|
},
|
|
runtime: {
|
|
sessionId: null,
|
|
sessionParams: null,
|
|
sessionDisplayId: null,
|
|
taskKey: null,
|
|
},
|
|
config: {
|
|
engine: "cli",
|
|
command: commandPath,
|
|
cwd: workspace,
|
|
promptTemplate: "Follow the paperclip heartbeat.",
|
|
},
|
|
context: {},
|
|
authToken: "run-jwt-token",
|
|
onLog: async () => {},
|
|
});
|
|
|
|
expect(result.exitCode).toBe(1);
|
|
expect(result.errorCode).toBe("codex_harness_crash");
|
|
expect(result.errorFamily).toBe("transient_upstream");
|
|
expect(result.errorMessage).toContain("Transport channel closed");
|
|
expect(result.sessionId).toBe("thread-crash-1");
|
|
expect(result.clearSession).toBe(false);
|
|
expect((result.resultJson as Record<string, unknown>).errorFamily).toBe("transient_upstream");
|
|
} finally {
|
|
if (previousHome === undefined) delete process.env.HOME;
|
|
else process.env.HOME = previousHome;
|
|
await fs.rm(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it("persists retry-not-before metadata for codex provider quota failures", async () => {
|
|
const root = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-codex-execute-usage-limit-"));
|
|
const workspace = path.join(root, "workspace");
|
|
const commandPath = path.join(root, "codex");
|
|
await fs.mkdir(workspace, { recursive: true });
|
|
await writeFailingCodexCommand(
|
|
commandPath,
|
|
"You've hit your usage limit for GPT-5.3-Codex-Spark. Switch to another model now, or try again at 11:31 PM.",
|
|
);
|
|
|
|
const previousHome = process.env.HOME;
|
|
process.env.HOME = root;
|
|
await seedSharedCodexAuth(root);
|
|
vi.useFakeTimers();
|
|
vi.setSystemTime(new Date(2026, 3, 22, 22, 29, 0));
|
|
|
|
try {
|
|
const result = await execute({
|
|
runId: "run-usage-limit",
|
|
agent: {
|
|
id: "agent-1",
|
|
companyId: "company-1",
|
|
name: "Codex Coder",
|
|
adapterType: "codex_local",
|
|
adapterConfig: { engine: "cli" },
|
|
},
|
|
runtime: {
|
|
sessionId: "codex-session-usage-limit",
|
|
sessionParams: {
|
|
sessionId: "codex-session-usage-limit",
|
|
cwd: workspace,
|
|
},
|
|
sessionDisplayId: "codex-session-usage-limit",
|
|
taskKey: null,
|
|
},
|
|
config: {
|
|
engine: "cli",
|
|
command: commandPath,
|
|
cwd: workspace,
|
|
model: "gpt-5.3-codex-spark",
|
|
promptTemplate: "Follow the paperclip heartbeat.",
|
|
},
|
|
context: {},
|
|
authToken: "run-jwt-token",
|
|
onLog: async () => {},
|
|
});
|
|
|
|
expect(result.exitCode).toBe(1);
|
|
expect(result.errorCode).toBe("provider_quota");
|
|
expect(result.errorFamily).toBe("provider_quota");
|
|
const expectedRetryNotBefore = new Date(2026, 3, 22, 23, 31, 0, 0).toISOString();
|
|
expect(result.retryNotBefore).toBe(expectedRetryNotBefore);
|
|
expect(result.resultJson?.retryNotBefore).toBe(expectedRetryNotBefore);
|
|
expect(result.resultJson?.providerQuotaRetryNotBefore).toBe(expectedRetryNotBefore);
|
|
expect(new Date(String(result.resultJson?.transientRetryNotBefore)).getTime()).toBe(
|
|
new Date(2026, 3, 22, 23, 31, 0, 0).getTime(),
|
|
);
|
|
} finally {
|
|
vi.useRealTimers();
|
|
if (previousHome === undefined) delete process.env.HOME;
|
|
else process.env.HOME = previousHome;
|
|
await fs.rm(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it("classifies Codex refresh-token auth failures without credential telemetry", async () => {
|
|
const root = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-codex-execute-refresh-token-"));
|
|
const workspace = path.join(root, "workspace");
|
|
const commandPath = path.join(root, "codex");
|
|
await fs.mkdir(workspace, { recursive: true });
|
|
await writeFailingCodexCommand(commandPath, "OAuth failed: refresh_token_reused");
|
|
|
|
const previousHome = process.env.HOME;
|
|
process.env.HOME = root;
|
|
await seedSharedCodexAuth(root);
|
|
|
|
try {
|
|
const result = await execute({
|
|
runId: "run-refresh-token-reused",
|
|
agent: {
|
|
id: "agent-1",
|
|
companyId: "company-1",
|
|
name: "Codex Coder",
|
|
adapterType: "codex_local",
|
|
adapterConfig: { engine: "cli" },
|
|
},
|
|
runtime: {
|
|
sessionId: null,
|
|
sessionParams: null,
|
|
sessionDisplayId: null,
|
|
taskKey: null,
|
|
},
|
|
config: {
|
|
engine: "cli",
|
|
command: commandPath,
|
|
cwd: workspace,
|
|
promptTemplate: "Follow the paperclip heartbeat.",
|
|
},
|
|
context: {},
|
|
authToken: "run-jwt-token",
|
|
onLog: async () => {},
|
|
});
|
|
|
|
expect(result.exitCode).toBe(1);
|
|
expect(result.errorCode).toBe("refresh_token_reused");
|
|
expect(result.errorFamily).toBe("refresh_token_reused");
|
|
expect(result.resultJson?.errorFamily).toBe("refresh_token_reused");
|
|
expect(result.resultJson).not.toHaveProperty("codexCredentialTelemetry");
|
|
} finally {
|
|
if (previousHome === undefined) delete process.env.HOME;
|
|
else process.env.HOME = previousHome;
|
|
await fs.rm(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it("uses safer invocation settings and a fresh-session handoff for codex transient fallback retries", async () => {
|
|
const root = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-codex-execute-fallback-"));
|
|
const workspace = path.join(root, "workspace");
|
|
const commandPath = path.join(root, "codex");
|
|
const capturePath = path.join(root, "capture.json");
|
|
await fs.mkdir(workspace, { recursive: true });
|
|
await writeFakeCodexCommand(commandPath);
|
|
|
|
const previousHome = process.env.HOME;
|
|
process.env.HOME = root;
|
|
await seedSharedCodexAuth(root);
|
|
|
|
let commandNotes: string[] = [];
|
|
try {
|
|
const result = await execute({
|
|
runId: "run-fallback",
|
|
agent: {
|
|
id: "agent-1",
|
|
companyId: "company-1",
|
|
name: "Codex Coder",
|
|
adapterType: "codex_local",
|
|
adapterConfig: { engine: "cli" },
|
|
},
|
|
runtime: {
|
|
sessionId: null,
|
|
sessionParams: {
|
|
sessionId: "codex-session-stale",
|
|
cwd: workspace,
|
|
},
|
|
sessionDisplayId: "codex-session-stale",
|
|
taskKey: null,
|
|
},
|
|
config: {
|
|
engine: "cli",
|
|
command: commandPath,
|
|
cwd: workspace,
|
|
fastMode: true,
|
|
model: "gpt-5.4",
|
|
env: {
|
|
PAPERCLIP_TEST_CAPTURE_PATH: capturePath,
|
|
},
|
|
promptTemplate: "Follow the paperclip heartbeat.",
|
|
},
|
|
context: {
|
|
codexTransientFallbackMode: "fresh_session_safer_invocation",
|
|
paperclipContinuationSummary: {
|
|
key: "continuation-summary",
|
|
title: "Continuation Summary",
|
|
body: "Issue continuation summary for the next fresh session.",
|
|
updatedAt: "2026-04-21T01:00:00.000Z",
|
|
},
|
|
},
|
|
authToken: "run-jwt-token",
|
|
onLog: async () => {},
|
|
onMeta: async (meta) => {
|
|
commandNotes = meta.commandNotes ?? [];
|
|
},
|
|
});
|
|
|
|
expect(result.exitCode).toBe(0);
|
|
expect(result.errorMessage).toBeNull();
|
|
|
|
const capture = JSON.parse(await fs.readFile(capturePath, "utf8")) as CapturePayload;
|
|
expect(capture.argv).toEqual(expect.arrayContaining(["exec", "--json", "-"]));
|
|
expect(capture.argv).not.toContain("resume");
|
|
expect(capture.argv).not.toContain('service_tier="fast"');
|
|
expect(capture.argv).not.toContain("features.fast_mode=true");
|
|
expect(capture.prompt).toContain("Paperclip session handoff:");
|
|
expect(capture.prompt).toContain("Issue continuation summary for the next fresh session.");
|
|
expect(commandNotes).toContain("Codex transient fallback requested safer invocation settings for this retry.");
|
|
expect(commandNotes).toContain("Codex transient fallback forced a fresh session with a continuation handoff.");
|
|
} finally {
|
|
if (previousHome === undefined) delete process.env.HOME;
|
|
else process.env.HOME = previousHome;
|
|
await fs.rm(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it("renders execution-stage wake instructions for reviewer and executor roles", async () => {
|
|
const root = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-codex-execute-stage-wake-"));
|
|
const workspace = path.join(root, "workspace");
|
|
const commandPath = path.join(root, "codex");
|
|
const capturePath = path.join(root, "capture.json");
|
|
await fs.mkdir(workspace, { recursive: true });
|
|
await writeFakeCodexCommand(commandPath);
|
|
|
|
const previousHome = process.env.HOME;
|
|
process.env.HOME = root;
|
|
await seedSharedCodexAuth(root);
|
|
|
|
try {
|
|
const result = await execute({
|
|
runId: "run-stage-wake",
|
|
agent: {
|
|
id: "agent-1",
|
|
companyId: "company-1",
|
|
name: "Codex Coder",
|
|
adapterType: "codex_local",
|
|
adapterConfig: { engine: "cli" },
|
|
},
|
|
runtime: {
|
|
sessionId: null,
|
|
sessionParams: null,
|
|
sessionDisplayId: null,
|
|
taskKey: null,
|
|
},
|
|
config: {
|
|
engine: "cli",
|
|
command: commandPath,
|
|
cwd: workspace,
|
|
env: {
|
|
PAPERCLIP_TEST_CAPTURE_PATH: capturePath,
|
|
},
|
|
promptTemplate: "Follow the paperclip heartbeat.",
|
|
},
|
|
context: {
|
|
issueId: "issue-1",
|
|
taskId: "issue-1",
|
|
wakeReason: "execution_review_requested",
|
|
paperclipWake: {
|
|
reason: "execution_review_requested",
|
|
issue: {
|
|
id: "issue-1",
|
|
identifier: "PAP-1207",
|
|
title: "implement the plan of PAP-1200",
|
|
status: "in_review",
|
|
priority: "medium",
|
|
},
|
|
executionStage: {
|
|
wakeRole: "reviewer",
|
|
stageId: "stage-1",
|
|
stageType: "review",
|
|
currentParticipant: { type: "agent", agentId: "qa-agent" },
|
|
returnAssignee: { type: "agent", agentId: "coder-agent" },
|
|
lastDecisionOutcome: null,
|
|
allowedActions: ["approve", "request_changes"],
|
|
},
|
|
commentIds: [],
|
|
latestCommentId: null,
|
|
comments: [],
|
|
commentWindow: {
|
|
requestedCount: 0,
|
|
includedCount: 0,
|
|
missingCount: 0,
|
|
},
|
|
truncated: false,
|
|
fallbackFetchNeeded: false,
|
|
},
|
|
},
|
|
authToken: "run-jwt-token",
|
|
onLog: async () => {},
|
|
});
|
|
|
|
expect(result.exitCode).toBe(0);
|
|
const capture = JSON.parse(await fs.readFile(capturePath, "utf8")) as CapturePayload;
|
|
expect(capture.prompt).toContain("execution wake role: reviewer");
|
|
expect(capture.prompt).toContain("You are waking as the active reviewer for this issue.");
|
|
expect(capture.prompt).toContain("Do not execute the task itself or continue executor work.");
|
|
expect(capture.prompt).toContain("allowed actions: approve, request_changes");
|
|
|
|
const executorCapturePath = path.join(root, "capture-executor.json");
|
|
const executorResult = await execute({
|
|
runId: "run-stage-wake-executor",
|
|
agent: {
|
|
id: "agent-1",
|
|
companyId: "company-1",
|
|
name: "Codex Coder",
|
|
adapterType: "codex_local",
|
|
adapterConfig: { engine: "cli" },
|
|
},
|
|
runtime: {
|
|
sessionId: null,
|
|
sessionParams: null,
|
|
sessionDisplayId: null,
|
|
taskKey: null,
|
|
},
|
|
config: {
|
|
engine: "cli",
|
|
command: commandPath,
|
|
cwd: workspace,
|
|
env: {
|
|
PAPERCLIP_TEST_CAPTURE_PATH: executorCapturePath,
|
|
},
|
|
promptTemplate: "Follow the paperclip heartbeat.",
|
|
},
|
|
context: {
|
|
issueId: "issue-1",
|
|
taskId: "issue-1",
|
|
wakeReason: "execution_changes_requested",
|
|
paperclipWake: {
|
|
reason: "execution_changes_requested",
|
|
issue: {
|
|
id: "issue-1",
|
|
identifier: "PAP-1207",
|
|
title: "implement the plan of PAP-1200",
|
|
status: "in_progress",
|
|
priority: "medium",
|
|
},
|
|
executionStage: {
|
|
wakeRole: "executor",
|
|
stageId: "stage-1",
|
|
stageType: "review",
|
|
currentParticipant: { type: "agent", agentId: "qa-agent" },
|
|
returnAssignee: { type: "agent", agentId: "coder-agent" },
|
|
lastDecisionOutcome: "changes_requested",
|
|
allowedActions: ["address_changes", "resubmit"],
|
|
},
|
|
commentIds: [],
|
|
latestCommentId: null,
|
|
comments: [],
|
|
commentWindow: {
|
|
requestedCount: 0,
|
|
includedCount: 0,
|
|
missingCount: 0,
|
|
},
|
|
truncated: false,
|
|
fallbackFetchNeeded: false,
|
|
},
|
|
},
|
|
authToken: "run-jwt-token",
|
|
onLog: async () => {},
|
|
});
|
|
|
|
expect(executorResult.exitCode).toBe(0);
|
|
const executorCapture = JSON.parse(await fs.readFile(executorCapturePath, "utf8")) as CapturePayload;
|
|
expect(executorCapture.prompt).toContain("execution wake role: executor");
|
|
expect(executorCapture.prompt).toContain("You are waking because changes were requested in the execution workflow.");
|
|
expect(executorCapture.prompt).toContain("allowed actions: address_changes, resubmit");
|
|
} finally {
|
|
if (previousHome === undefined) delete process.env.HOME;
|
|
else process.env.HOME = previousHome;
|
|
await fs.rm(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it("renders an issue-scoped wake prompt even when the wake has no comments yet", async () => {
|
|
const root = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-codex-execute-issue-wake-"));
|
|
const workspace = path.join(root, "workspace");
|
|
const commandPath = path.join(root, "codex");
|
|
const capturePath = path.join(root, "capture.json");
|
|
await fs.mkdir(workspace, { recursive: true });
|
|
await writeFakeCodexCommand(commandPath);
|
|
|
|
const previousHome = process.env.HOME;
|
|
process.env.HOME = root;
|
|
await seedSharedCodexAuth(root);
|
|
|
|
try {
|
|
const result = await execute({
|
|
runId: "run-issue-wake",
|
|
agent: {
|
|
id: "agent-1",
|
|
companyId: "company-1",
|
|
name: "Codex Coder",
|
|
adapterType: "codex_local",
|
|
adapterConfig: { engine: "cli" },
|
|
},
|
|
runtime: {
|
|
sessionId: null,
|
|
sessionParams: null,
|
|
sessionDisplayId: null,
|
|
taskKey: null,
|
|
},
|
|
config: {
|
|
engine: "cli",
|
|
command: commandPath,
|
|
cwd: workspace,
|
|
env: {
|
|
PAPERCLIP_TEST_CAPTURE_PATH: capturePath,
|
|
},
|
|
promptTemplate: "Follow the paperclip heartbeat.",
|
|
},
|
|
context: {
|
|
issueId: "issue-1",
|
|
taskId: "issue-1",
|
|
wakeReason: "issue_assigned",
|
|
paperclipWake: {
|
|
reason: "issue_assigned",
|
|
issue: {
|
|
id: "issue-1",
|
|
identifier: "PAP-1201",
|
|
title: "Fix gallery opening for inline images",
|
|
status: "in_progress",
|
|
priority: "medium",
|
|
},
|
|
checkedOutByHarness: true,
|
|
commentIds: [],
|
|
latestCommentId: null,
|
|
comments: [],
|
|
commentWindow: {
|
|
requestedCount: 0,
|
|
includedCount: 0,
|
|
missingCount: 0,
|
|
},
|
|
truncated: false,
|
|
fallbackFetchNeeded: false,
|
|
},
|
|
},
|
|
authToken: "run-jwt-token",
|
|
onLog: async () => {},
|
|
});
|
|
|
|
expect(result.exitCode).toBe(0);
|
|
expect(result.errorMessage).toBeNull();
|
|
|
|
const capture = JSON.parse(await fs.readFile(capturePath, "utf8")) as CapturePayload;
|
|
expect(capture.paperclipEnvKeys).toContain("PAPERCLIP_WAKE_PAYLOAD_JSON");
|
|
expect(capture.paperclipWakePayloadJson).not.toBeNull();
|
|
expect(JSON.parse(capture.paperclipWakePayloadJson ?? "{}")).toMatchObject({
|
|
reason: "issue_assigned",
|
|
issue: {
|
|
identifier: "PAP-1201",
|
|
title: "Fix gallery opening for inline images",
|
|
status: "in_progress",
|
|
priority: "medium",
|
|
},
|
|
checkedOutByHarness: true,
|
|
commentIds: [],
|
|
});
|
|
expect(capture.prompt).toContain("## Paperclip Wake Payload");
|
|
expect(capture.prompt).toContain("Do not switch to another issue until you have handled this wake.");
|
|
expect(capture.prompt).toContain("- issue: PAP-1201 Fix gallery opening for inline images");
|
|
expect(capture.prompt).not.toContain("- pending comments:");
|
|
expect(capture.prompt).not.toContain("acknowledge the latest comment");
|
|
expect(capture.prompt).not.toContain("Execution contract:");
|
|
expect(capture.prompt).toContain("- issue status: in_progress");
|
|
expect(capture.prompt).toContain("- checkout: already claimed by the harness for this run");
|
|
expect(capture.prompt).toContain("The harness already checked out this issue for the current run.");
|
|
} finally {
|
|
if (previousHome === undefined) delete process.env.HOME;
|
|
else process.env.HOME = previousHome;
|
|
await fs.rm(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it.each([{ conversationMode: false, resumedSession: true }, { conversationMode: true, resumedSession: true }, { conversationMode: true, resumedSession: false }])("retains current task policy (conversation=$conversationMode, resumed=$resumedSession)", async ({ conversationMode, resumedSession }) => {
|
|
const root = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-codex-execute-resume-wake-"));
|
|
const workspace = path.join(root, "workspace");
|
|
const commandPath = path.join(root, "codex");
|
|
const capturePath = path.join(root, "capture.json");
|
|
const instructionsPath = path.join(root, "AGENTS.md");
|
|
await fs.mkdir(workspace, { recursive: true });
|
|
await fs.writeFile(instructionsPath, "You are managed instructions.\n", "utf8");
|
|
await writeFakeCodexCommand(commandPath);
|
|
|
|
const previousHome = process.env.HOME;
|
|
process.env.HOME = root;
|
|
await seedSharedCodexAuth(root);
|
|
|
|
const policy = conversationMode
|
|
? buildPaperclipTaskMarkdown({
|
|
issue: { id: "issue-1", title: "Chat", workMode: "planning", conversationAgentId: "agent-1" },
|
|
interaction: { kind: "request_confirmation", status: "rejected" },
|
|
planReview: { status: "rejected", reason: "Revise the final note." },
|
|
includeDescription: false,
|
|
})
|
|
: "Current ordinary task policy";
|
|
let invocationPrompt = "";
|
|
let invocationNotes: string[] = [];
|
|
let promptMetrics: Record<string, number> = {};
|
|
try {
|
|
const result = await execute({
|
|
runId: "run-resume-wake",
|
|
agent: {
|
|
id: "agent-1",
|
|
companyId: "company-1",
|
|
name: "Codex Coder",
|
|
adapterType: "codex_local",
|
|
adapterConfig: { engine: "cli" },
|
|
},
|
|
runtime: {
|
|
sessionId: null,
|
|
sessionParams: {
|
|
sessionId: resumedSession ? "codex-session-1" : null,
|
|
cwd: workspace,
|
|
},
|
|
sessionDisplayId: null,
|
|
taskKey: null,
|
|
},
|
|
config: {
|
|
engine: "cli",
|
|
command: commandPath,
|
|
cwd: workspace,
|
|
instructionsFilePath: instructionsPath,
|
|
env: {
|
|
PAPERCLIP_TEST_CAPTURE_PATH: capturePath,
|
|
},
|
|
promptTemplate: conversationMode ? undefined : "Follow the paperclip heartbeat.",
|
|
},
|
|
context: {
|
|
conversationMode,
|
|
paperclipTaskMarkdown: `Full description that must not replay\n${policy}`,
|
|
paperclipTaskMarkdownCompact: policy,
|
|
issueId: "issue-1",
|
|
taskId: "issue-1",
|
|
wakeReason: "issue_commented",
|
|
wakeCommentId: "comment-2",
|
|
paperclipWake: {
|
|
reason: "issue_commented",
|
|
issue: {
|
|
id: "issue-1",
|
|
identifier: "PAP-874",
|
|
title: "chat-speed issues",
|
|
status: "in_progress",
|
|
priority: "medium",
|
|
},
|
|
commentIds: ["comment-2"],
|
|
latestCommentId: "comment-2",
|
|
comments: [
|
|
{
|
|
id: "comment-2",
|
|
issueId: "issue-1",
|
|
body: "Second comment",
|
|
bodyTruncated: false,
|
|
createdAt: "2026-03-28T14:35:10.000Z",
|
|
author: { type: "user", id: "user-1" },
|
|
},
|
|
],
|
|
commentWindow: {
|
|
requestedCount: 1,
|
|
includedCount: 1,
|
|
missingCount: 0,
|
|
},
|
|
truncated: false,
|
|
fallbackFetchNeeded: false,
|
|
},
|
|
},
|
|
authToken: "run-jwt-token",
|
|
onLog: async () => {},
|
|
onMeta: async (meta) => {
|
|
invocationPrompt = meta.prompt ?? "";
|
|
invocationNotes = meta.commandNotes ?? [];
|
|
promptMetrics = meta.promptMetrics ?? {};
|
|
},
|
|
});
|
|
|
|
expect(result.exitCode).toBe(0);
|
|
expect(result.errorMessage).toBeNull();
|
|
|
|
const capture = JSON.parse(await fs.readFile(capturePath, "utf8")) as CapturePayload;
|
|
if (resumedSession) expect(capture.argv).toEqual(expect.arrayContaining(["resume", "codex-session-1", "-"]));
|
|
else expect(capture.argv).not.toContain("resume");
|
|
expect(capture.prompt).toContain(resumedSession ? "## Paperclip Resume Delta" : "## Paperclip Wake Payload");
|
|
expect(capture.prompt).toContain("Do not switch to another issue until you have handled this wake.");
|
|
expect(capture.prompt).toContain("Second comment");
|
|
expect(capture.prompt).toContain(policy);
|
|
expect(invocationPrompt).toContain(policy);
|
|
if (resumedSession) expect(capture.prompt).not.toContain("Full description that must not replay");
|
|
else expect(capture.prompt).toContain("Full description that must not replay");
|
|
expect(promptMetrics.taskContextChars).toBe(resumedSession ? policy.length : `Full description that must not replay\n${policy}`.length);
|
|
if (conversationMode) {
|
|
expect(invocationPrompt).toContain(AGENT_CHAT_DIRECTIVE);
|
|
expect(invocationPrompt).toContain("baseRevisionId set to that latestRevisionId");
|
|
expect(capture.prompt).not.toContain("Execution contract:");
|
|
expect(capture.prompt).not.toContain("Use child issues");
|
|
} else {
|
|
expect(capture.prompt).toContain("Execution contract:");
|
|
}
|
|
expect(capture.prompt).not.toContain("Follow the paperclip heartbeat.");
|
|
if (resumedSession) {
|
|
expect(capture.prompt).not.toContain("You are managed instructions.");
|
|
expect(invocationPrompt).toContain("## Paperclip Resume Delta");
|
|
expect(invocationNotes).toContain("Skipped stdin instruction reinjection because an existing Codex session is being resumed with a wake delta.");
|
|
expect(promptMetrics.instructionsChars).toBe(0);
|
|
expect(promptMetrics.heartbeatPromptChars).toBe(0);
|
|
} else {
|
|
expect(capture.prompt).toContain("You are managed instructions.");
|
|
expect(promptMetrics.heartbeatPromptChars).toBeGreaterThan(0);
|
|
}
|
|
} finally {
|
|
if (previousHome === undefined) delete process.env.HOME;
|
|
else process.env.HOME = previousHome;
|
|
await fs.rm(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
it("uses a worktree-isolated CODEX_HOME and mounts the operational skill by default", async () => {
|
|
const root = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-codex-execute-"));
|
|
const workspace = path.join(root, "workspace");
|
|
const commandPath = path.join(root, "codex");
|
|
const capturePath = path.join(root, "capture.json");
|
|
const sharedCodexHome = path.join(root, "shared-codex-home");
|
|
const paperclipHome = path.join(root, "paperclip-home");
|
|
const isolatedCodexHome = path.join(
|
|
paperclipHome,
|
|
"instances",
|
|
"worktree-1",
|
|
"companies",
|
|
"company-1",
|
|
"codex-home",
|
|
);
|
|
const homeSkill = path.join(isolatedCodexHome, "skills", "paperclip");
|
|
await fs.mkdir(workspace, { recursive: true });
|
|
await fs.mkdir(sharedCodexHome, { recursive: true });
|
|
await fs.writeFile(path.join(sharedCodexHome, "auth.json"), `${fakeCodexAuthJson}\n`, "utf8");
|
|
await fs.writeFile(path.join(sharedCodexHome, "config.toml"), 'model = "codex-mini-latest"\n', "utf8");
|
|
await writeFakeCodexCommand(commandPath);
|
|
|
|
const previousHome = process.env.HOME;
|
|
const previousPaperclipHome = process.env.PAPERCLIP_HOME;
|
|
const previousPaperclipInstanceId = process.env.PAPERCLIP_INSTANCE_ID;
|
|
const previousPaperclipInWorktree = process.env.PAPERCLIP_IN_WORKTREE;
|
|
const previousCodexHome = process.env.CODEX_HOME;
|
|
process.env.HOME = root;
|
|
process.env.PAPERCLIP_HOME = paperclipHome;
|
|
process.env.PAPERCLIP_INSTANCE_ID = "worktree-1";
|
|
process.env.PAPERCLIP_IN_WORKTREE = "true";
|
|
process.env.CODEX_HOME = sharedCodexHome;
|
|
|
|
try {
|
|
const logs: LogEntry[] = [];
|
|
const result = await execute({
|
|
runId: "run-1",
|
|
agent: {
|
|
id: "agent-1",
|
|
companyId: "company-1",
|
|
name: "Codex Coder",
|
|
adapterType: "codex_local",
|
|
adapterConfig: { engine: "cli" },
|
|
},
|
|
runtime: {
|
|
sessionId: null,
|
|
sessionParams: null,
|
|
sessionDisplayId: null,
|
|
taskKey: null,
|
|
},
|
|
config: {
|
|
engine: "cli",
|
|
command: commandPath,
|
|
cwd: workspace,
|
|
env: {
|
|
PAPERCLIP_TEST_CAPTURE_PATH: capturePath,
|
|
},
|
|
promptTemplate: "Follow the paperclip heartbeat.",
|
|
},
|
|
context: {},
|
|
authToken: "run-jwt-token",
|
|
onLog: async (stream, chunk) => {
|
|
logs.push({ stream, chunk });
|
|
},
|
|
});
|
|
|
|
expect(result.exitCode).toBe(0);
|
|
expect(result.errorMessage).toBeNull();
|
|
|
|
const capture = JSON.parse(await fs.readFile(capturePath, "utf8")) as CapturePayload;
|
|
expect(capture.codexHome).toBe(isolatedCodexHome);
|
|
expect(capture.argv).toEqual(expect.arrayContaining(["exec", "--json", "-"]));
|
|
expect(capture.prompt).toContain("Follow the paperclip heartbeat.");
|
|
expect(capture.paperclipEnvKeys).toEqual(
|
|
expect.arrayContaining([
|
|
"PAPERCLIP_AGENT_ID",
|
|
"PAPERCLIP_API_KEY",
|
|
"PAPERCLIP_API_URL",
|
|
"PAPERCLIP_COMPANY_ID",
|
|
"PAPERCLIP_RUN_ID",
|
|
]),
|
|
);
|
|
|
|
const isolatedAuth = path.join(isolatedCodexHome, "auth.json");
|
|
const isolatedConfig = path.join(isolatedCodexHome, "config.toml");
|
|
|
|
expect((await fs.lstat(isolatedAuth)).isSymbolicLink()).toBe(true);
|
|
expect(await fs.realpath(isolatedAuth)).toBe(await fs.realpath(path.join(sharedCodexHome, "auth.json")));
|
|
expect((await fs.lstat(isolatedConfig)).isFile()).toBe(true);
|
|
expect(await fs.readFile(isolatedConfig, "utf8")).toBe('model = "codex-mini-latest"\n');
|
|
expect((await fs.lstat(homeSkill)).isSymbolicLink()).toBe(true);
|
|
expect(logs).toContainEqual(
|
|
expect.objectContaining({
|
|
stream: "stdout",
|
|
chunk: expect.stringContaining("Using worktree-isolated Codex home"),
|
|
}),
|
|
);
|
|
expect(logs).toContainEqual(
|
|
expect.objectContaining({
|
|
stream: "stdout",
|
|
chunk: expect.stringContaining('Injected Codex skill "paperclip"'),
|
|
}),
|
|
);
|
|
} finally {
|
|
if (previousHome === undefined) delete process.env.HOME;
|
|
else process.env.HOME = previousHome;
|
|
if (previousPaperclipHome === undefined) delete process.env.PAPERCLIP_HOME;
|
|
else process.env.PAPERCLIP_HOME = previousPaperclipHome;
|
|
if (previousPaperclipInstanceId === undefined) delete process.env.PAPERCLIP_INSTANCE_ID;
|
|
else process.env.PAPERCLIP_INSTANCE_ID = previousPaperclipInstanceId;
|
|
if (previousPaperclipInWorktree === undefined) delete process.env.PAPERCLIP_IN_WORKTREE;
|
|
else process.env.PAPERCLIP_IN_WORKTREE = previousPaperclipInWorktree;
|
|
if (previousCodexHome === undefined) delete process.env.CODEX_HOME;
|
|
else process.env.CODEX_HOME = previousCodexHome;
|
|
await fs.rm(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it("isolates connector skills by agent and revision without changing the selected model identity", async () => {
|
|
const root = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-connector-codex-"));
|
|
const workspace = path.join(root, "workspace");
|
|
const command = path.join(root, "codex");
|
|
const capture = path.join(root, "capture.json");
|
|
const sourceHome = path.join(root, "selected-account");
|
|
const skillSource = path.join(root, "skill-v1");
|
|
await fs.mkdir(workspace, { recursive: true });
|
|
await fs.mkdir(sourceHome, { recursive: true });
|
|
await fs.mkdir(skillSource, { recursive: true });
|
|
await fs.writeFile(path.join(sourceHome, "auth.json"), fakeCodexAuthJson);
|
|
await fs.writeFile(path.join(skillSource, "SKILL.md"), "# AgentMail\nAssigned inbox one.");
|
|
await writeFakeCodexCommand(command);
|
|
const keys = ["PAPERCLIP_HOME", "PAPERCLIP_INSTANCE_ID", "CODEX_HOME"] as const;
|
|
const previous = Object.fromEntries(keys.map((key) => [key, process.env[key]]));
|
|
process.env.PAPERCLIP_HOME = path.join(root, "paperclip");
|
|
process.env.PAPERCLIP_INSTANCE_ID = "connectors";
|
|
process.env.CODEX_HOME = sourceHome;
|
|
const invoke = async (agentId: string, digest: string | null, source = skillSource, connectorSkillInstructions = "") => {
|
|
const config = {
|
|
engine: "cli", command, cwd: workspace,
|
|
env: { CODEX_HOME: sourceHome, PAPERCLIP_TEST_CAPTURE_PATH: capture },
|
|
paperclipConnectorSkillDigest: digest,
|
|
paperclipSkillSync: { desiredSkills: digest ? ["paperclipai/paperclip/agentmail"] : [] },
|
|
paperclipRuntimeSkills: digest ? [{ key: "paperclipai/paperclip/agentmail", runtimeName: "agentmail", source }] : [],
|
|
};
|
|
const result = await execute({ runId: `run-${agentId}-${digest?.slice(0, 1) ?? "none"}`,
|
|
agent: { id: agentId, companyId: "company-1", name: "Email agent", adapterType: "codex_local", adapterConfig: config },
|
|
runtime: { sessionId: null, sessionParams: null, sessionDisplayId: null, taskKey: null },
|
|
config, context: { paperclipWake: { connectorSkillInstructions } }, authToken: "test-token", onLog: async () => {},
|
|
});
|
|
expect(result.errorMessage).toBeNull();
|
|
expect(result.exitCode).toBe(0);
|
|
return JSON.parse(await fs.readFile(capture, "utf8")) as CapturePayload;
|
|
};
|
|
try {
|
|
const first = await invoke("agent-1", "a".repeat(64));
|
|
expect(first.codexHome).toContain("connector-runtimes/agent-1/");
|
|
expect(await fs.realpath(path.join(first.codexHome!, "auth.json"))).toBe(await fs.realpath(path.join(sourceHome, "auth.json")));
|
|
expect(await fs.readFile(path.join(first.codexHome!, "skills/agentmail/SKILL.md"), "utf8")).toContain("inbox one");
|
|
await expect(fs.stat(path.join(sourceHome, "skills/agentmail"))).rejects.toMatchObject({ code: "ENOENT" });
|
|
const other = await invoke("agent-2", "a".repeat(64));
|
|
expect(other.codexHome).not.toBe(first.codexHome);
|
|
const nextSource = path.join(root, "skill-v2");
|
|
await fs.mkdir(nextSource);
|
|
await fs.writeFile(path.join(nextSource, "SKILL.md"), "# AgentMail\nAssigned inbox two.");
|
|
const next = await invoke("agent-1", "b".repeat(64), nextSource);
|
|
expect(next.codexHome).not.toBe(first.codexHome);
|
|
expect(await fs.readFile(path.join(next.codexHome!, "skills/agentmail/SKILL.md"), "utf8")).toContain("inbox two");
|
|
const inline = await invoke("agent-1", null, skillSource, "# AgentMail\nAssigned inbox inline@example.test");
|
|
expect(inline.prompt).toContain("Assigned inbox inline@example.test");
|
|
await expect(fs.stat(path.join(sourceHome, "skills/agentmail"))).rejects.toMatchObject({ code: "ENOENT" });
|
|
const removed = await invoke("agent-1", null);
|
|
expect(removed.prompt).not.toContain("inline@example.test");
|
|
expect(removed.codexHome).toBe(sourceHome);
|
|
await expect(fs.stat(path.join(removed.codexHome!, "skills/agentmail"))).rejects.toMatchObject({ code: "ENOENT" });
|
|
} finally {
|
|
for (const key of keys) { if (previous[key] === undefined) delete process.env[key]; else process.env[key] = previous[key]; }
|
|
await fs.rm(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it("respects an explicit CODEX_HOME config override even in worktree mode", async () => {
|
|
const root = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-codex-execute-explicit-"));
|
|
const workspace = path.join(root, "workspace");
|
|
const commandPath = path.join(root, "codex");
|
|
const capturePath = path.join(root, "capture.json");
|
|
const sharedCodexHome = path.join(root, "shared-codex-home");
|
|
const explicitCodexHome = path.join(root, "explicit-codex-home");
|
|
const paperclipHome = path.join(root, "paperclip-home");
|
|
await fs.mkdir(workspace, { recursive: true });
|
|
await fs.mkdir(sharedCodexHome, { recursive: true });
|
|
await fs.writeFile(path.join(sharedCodexHome, "auth.json"), `${fakeCodexAuthJson}\n`, "utf8");
|
|
await writeFakeCodexCommand(commandPath);
|
|
|
|
const previousHome = process.env.HOME;
|
|
const previousPaperclipHome = process.env.PAPERCLIP_HOME;
|
|
const previousPaperclipInstanceId = process.env.PAPERCLIP_INSTANCE_ID;
|
|
const previousPaperclipInWorktree = process.env.PAPERCLIP_IN_WORKTREE;
|
|
const previousCodexHome = process.env.CODEX_HOME;
|
|
process.env.HOME = root;
|
|
process.env.PAPERCLIP_HOME = paperclipHome;
|
|
process.env.PAPERCLIP_INSTANCE_ID = "worktree-1";
|
|
process.env.PAPERCLIP_IN_WORKTREE = "true";
|
|
process.env.CODEX_HOME = sharedCodexHome;
|
|
|
|
try {
|
|
const result = await execute({
|
|
runId: "run-2",
|
|
agent: {
|
|
id: "agent-1",
|
|
companyId: "company-1",
|
|
name: "Codex Coder",
|
|
adapterType: "codex_local",
|
|
adapterConfig: { engine: "cli" },
|
|
},
|
|
runtime: {
|
|
sessionId: null,
|
|
sessionParams: null,
|
|
sessionDisplayId: null,
|
|
taskKey: null,
|
|
},
|
|
config: {
|
|
engine: "cli",
|
|
command: commandPath,
|
|
cwd: workspace,
|
|
env: {
|
|
PAPERCLIP_TEST_CAPTURE_PATH: capturePath,
|
|
CODEX_HOME: explicitCodexHome,
|
|
},
|
|
promptTemplate: "Follow the paperclip heartbeat.",
|
|
paperclipSkillSync: {
|
|
desiredSkills: ["paperclip"],
|
|
},
|
|
},
|
|
context: {},
|
|
authToken: "run-jwt-token",
|
|
onLog: async () => {},
|
|
});
|
|
|
|
expect(result.exitCode).toBe(0);
|
|
expect(result.errorMessage).toBeNull();
|
|
|
|
const capture = JSON.parse(await fs.readFile(capturePath, "utf8")) as CapturePayload;
|
|
expect(capture.codexHome).toBe(explicitCodexHome);
|
|
expect((await fs.lstat(path.join(explicitCodexHome, "skills", "paperclip"))).isSymbolicLink()).toBe(true);
|
|
await expect(fs.lstat(path.join(paperclipHome, "instances", "worktree-1", "codex-home"))).rejects.toThrow();
|
|
} finally {
|
|
if (previousHome === undefined) delete process.env.HOME;
|
|
else process.env.HOME = previousHome;
|
|
if (previousPaperclipHome === undefined) delete process.env.PAPERCLIP_HOME;
|
|
else process.env.PAPERCLIP_HOME = previousPaperclipHome;
|
|
if (previousPaperclipInstanceId === undefined) delete process.env.PAPERCLIP_INSTANCE_ID;
|
|
else process.env.PAPERCLIP_INSTANCE_ID = previousPaperclipInstanceId;
|
|
if (previousPaperclipInWorktree === undefined) delete process.env.PAPERCLIP_IN_WORKTREE;
|
|
else process.env.PAPERCLIP_IN_WORKTREE = previousPaperclipInWorktree;
|
|
if (previousCodexHome === undefined) delete process.env.CODEX_HOME;
|
|
else process.env.CODEX_HOME = previousCodexHome;
|
|
await fs.rm(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
});
|