The open-source app everyone uses to manage agents at work
TypeScript acpxagent-orchestrationagent-skillsagentic-aiai-agentsai-engineeringai-governanceai-toolsautonomous-agentsclaudeclaude-codeclaude-skillscodexhermesllmmcpmulti-agentopenclawproject-managementworkflow-automation
import fs from "node:fs/promises";
import os from "node:os";
import path from "node:path";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import type { AdapterExecutionContext } from "@paperclipai/adapter-utils";
import type { RunProcessResult } from "@paperclipai/adapter-utils/server-utils";
const mocks = vi.hoisted(() => ({
process: vi.fn(), restore: vi.fn(), stop: vi.fn(),
}));
vi.mock("@paperclipai/adapter-utils/execution-target", async (importOriginal) => ({
...await importOriginal<typeof import("@paperclipai/adapter-utils/execution-target")>(),
ensureAdapterExecutionTargetRuntimeCommandInstalled: vi.fn(),
ensureAdapterExecutionTargetCommandResolvable: vi.fn(),
prepareAdapterExecutionTargetRuntime: vi.fn(async () => ({
runtimeRootDir: "/workspace/runtime", workspaceRemoteDir: "/workspace",
assetDirs: {}, restoreWorkspace: mocks.restore,
})),
readAdapterExecutionTargetHomeDir: vi.fn(async () => "/home/fixture"),
startAdapterExecutionTargetPaperclipBridge: vi.fn(async () => ({ env: {}, stop: mocks.stop })),
runAdapterExecutionTargetProcess: mocks.process,
}));
import { execute } from "./execute.js";
import { prepareAdapterExecutionTargetRuntime } from "@paperclipai/adapter-utils/execution-target";
const rawOutput = "private-output-canary";
const rawError = "<html>504 Gateway Time-out private-provider-token-canary</html>";
const failed: RunProcessResult = {
timedOut: true, exitCode: null, signal: null, stdout: rawOutput, stderr: rawError,
pid: null, startedAt: "2020-01-01T00:00:00.000Z", durationMs: 100,
};
describe("OpenCode timeout reporting", () => {
let dir: string;
beforeEach(async () => {
dir = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-opencode-timeout-"));
vi.stubEnv("XDG_CONFIG_HOME", dir);
mocks.process.mockReset().mockResolvedValue(failed);
mocks.restore.mockReset().mockResolvedValue(undefined);
mocks.stop.mockReset().mockResolvedValue(undefined);
});
afterEach(async () => {
vi.unstubAllEnvs();
await fs.rm(dir, { recursive: true, force: true });
});
const context = (timeoutSec: number, remote = true): AdapterExecutionContext => ({
runId: "run-fixture",
agent: { id: "agent-fixture", companyId: "company-fixture", name: "Fixture", adapterType: "opencode_local", adapterConfig: {} },
runtime: { sessionId: null, sessionParams: null, sessionDisplayId: null, taskKey: null },
config: { command: "opencode", model: "openai/fixture", cwd: dir, timeoutSec,
env: { OPENCODE_ALLOW_ALL_MODELS: "1" } },
context: {}, onLog: async () => {},
...(remote ? { executionTarget: { kind: "remote", transport: "sandbox", providerKey: "daytona", remoteCwd: "/workspace" } } : {}),
});
it.each([
[0, true, 14400, "sandbox_default"], [12, true, 12, "configured"],
[-1, true, 0, "configured"], [0, false, 0, "unlimited"], [12, false, 12, "configured"],
] as const)("keeps policy separate from an opaque timeout (%s, remote=%s)", async (configured, remote, resolved, source) => {
const result = await execute(context(configured, remote));
expect(result).toMatchObject({ timedOut: true, exitCode: null, signal: null,
errorMessage: "OpenCode execution timed out",
resultJson: { adapterExecutionTimeout: { timeoutSec: resolved, source } } });
expect(JSON.stringify(result)).not.toContain("private-");
expect(result.errorMessage).not.toContain(String(resolved));
expect(mocks.process).toHaveBeenCalledTimes(1);
expect(mocks.process.mock.calls[0]![4]).toMatchObject({ timeoutSec: resolved, graceSec: 20 });
expect(mocks.restore).toHaveBeenCalledTimes(remote ? 1 : 0);
expect(mocks.stop).toHaveBeenCalledTimes(remote ? 1 : 0);
});
it.each([0, 7])("retains output and completion semantics for a non-timeout exit %s", async (exitCode) => {
mocks.process.mockResolvedValue({ ...failed, timedOut: false, exitCode, stderr: "fixture failure" });
const result = await execute(context(0));
expect(result).toMatchObject({ timedOut: false, exitCode, signal: null,
errorMessage: exitCode === 0 ? null : "fixture failure",
resultJson: { stdout: rawOutput, stderr: "fixture failure",
adapterExecutionTimeout: { timeoutSec: 14400, source: "sandbox_default" } } });
expect(mocks.process).toHaveBeenCalledTimes(1);
expect(mocks.restore).toHaveBeenCalledTimes(1);
expect(mocks.stop).toHaveBeenCalledTimes(1);
});
it("uploads the sandbox shell plugin and launches with its remote config home", async () => {
vi.mocked(prepareAdapterExecutionTargetRuntime).mockImplementationOnce(async (input) => {
const asset = input.assets?.find(asset => asset.key === "xdgConfig");
expect(asset).toBeDefined();
const plugins = await fs.readdir(path.join(asset!.localDir, "opencode", "plugins"));
expect(plugins).toHaveLength(1);
return { target: input.target!, additionalSourceDirs: {}, additionalSourceFailures: [], workspaceSyncSnapshot: null,
runtimeRootDir: "/workspace/runtime", workspaceRemoteDir: "/workspace",
assetDirs: { xdgConfig: "/workspace/runtime/config" }, restoreWorkspace: mocks.restore };
});
await execute(context(0));
expect(mocks.process.mock.calls[0]![4].env.XDG_CONFIG_HOME).toBe("/workspace/runtime/config");
expect(mocks.process.mock.calls[0]![4].env).not.toHaveProperty("BASH_ENV");
});
it("runs the sandbox CLI through the actual process seam with session dispatch and incremental output", async () => {
const actual = await vi.importActual<typeof import("@paperclipai/adapter-utils/execution-target")>("@paperclipai/adapter-utils/execution-target");
mocks.process.mockImplementation(actual.runAdapterExecutionTargetProcess);
const logs = vi.fn(async () => {});
const runner = {
execute: vi.fn(async (input: { useSession?: boolean; onLog?: (stream: "stdout" | "stderr", chunk: string) => Promise<void> }) => {
// A synchronous command can lose its HTTP response before the run's
// configured deadline. Session dispatch must keep that request off the
// main CLI path; it must not replay the agent to recover the response.
if (!input.useSession) return failed;
await input.onLog?.("stdout", "streamed fixture output");
return { ...failed, timedOut: false, exitCode: 0, stdout: "streamed fixture output", stderr: "" };
}),
};
const ctx = context(0);
ctx.onLog = logs;
ctx.executionTarget = { kind: "remote", transport: "sandbox", providerKey: "daytona", remoteCwd: "/workspace", runner };
const result = await execute(ctx);
expect(result).toMatchObject({ timedOut: false, exitCode: 0, errorMessage: null,
resultJson: { stdout: "streamed fixture output", adapterExecutionTimeout: { timeoutSec: 14400, source: "sandbox_default" } } });
expect(runner.execute).toHaveBeenCalledTimes(1);
expect(runner.execute.mock.calls[0]![0]).toMatchObject({ command: "opencode", useSession: true, timeoutMs: 14400000, commandTimeoutMs: 14400000 });
expect(logs).toHaveBeenCalledWith("stdout", "streamed fixture output");
expect(mocks.restore).toHaveBeenCalledTimes(1);
expect(mocks.stop).toHaveBeenCalledTimes(1);
});
it("keeps other sandbox providers on their existing command path", async () => {
const ctx = context(12);
ctx.executionTarget = { kind: "remote", transport: "sandbox", providerKey: "fixture-provider", remoteCwd: "/workspace" };
await execute(ctx);
expect(mocks.process.mock.calls[0]![4]).not.toHaveProperty("useSession");
});
it("retains real local deadline and termination behavior without claiming provider origin", async () => {
const actual = await vi.importActual<typeof import("@paperclipai/adapter-utils/execution-target")>("@paperclipai/adapter-utils/execution-target");
mocks.process.mockImplementation(actual.runAdapterExecutionTargetProcess);
const command = path.join(dir, "fixture-opencode");
await fs.writeFile(command, "#!/usr/bin/env node\nsetInterval(() => {}, 1000);\n", { mode: 0o755 });
const ctx = context(0.1, false);
ctx.config.command = command;
ctx.config.graceSec = 0.1;
const result = await execute(ctx);
expect(result).toMatchObject({ timedOut: true, exitCode: null, signal: "SIGTERM",
errorMessage: "OpenCode execution timed out",
resultJson: { adapterExecutionTimeout: { timeoutSec: 0.1, source: "configured" } } });
expect(mocks.process).toHaveBeenCalledTimes(1);
});
});