opencode-workflow-guard 1.12.1 → 1.13.1

package/test/test.mts

@@ -14,6 +14,7 @@ import {
 	WorkflowGuard,
 	buildCompactionContext,
 	detectVerifyCommand,
+	resolveVerifyTimeoutMs,
 	runVerify,
 	getCleanEnv,
 	resetVerifyState,
@@ -442,6 +443,11 @@ check("block auth with global flags (--dir)", blocked(await shell(`${ocCli} --di
 check("block config with global flags (-d)", blocked(await shell(`${ocCli} -d . ${"con" + "fig"} edit`)));
 check("block permission with global flags (--workspace)", blocked(await shell(`${ocCli} --workspace . ${"perm" + "ission"} grant`)));
 check("allow normal command", !(await shell("ls -la && git status")));
+const ocDir = ".open" + "code/plans/";
+check("allow gh issue create mentioning .opencode paths (not tamper)", !(await shell(`gh issue create --repo example/proj --title t --body 'see <project>/${ocDir}'`)));
+check("compound collaboration + tamper still blocked", blocked(await shell(`gh issue create --repo example/proj --title t && echo x > open${"code.json"}`)));
+check("collaboration command with real redirect to global config still blocked", blocked(await shell(`gh issue list > /var/home/x/.config/open${"code"}/opencode.json`)));
+check("collaboration command with redirect outside workspace still blocked", blocked(await shell(`gh pr create --title t > /tmp/wg-escape-probe`)));
 
 console.log("- Policy 6: tamper via edit tools (path protection) -");
 check("block edit of project opencode.json", blocked(await call("edit", { filePath: join(root, "opencode.json"), oldString: "a", newString: "b" }, { sessionID: "s-active" })));
@@ -449,6 +455,22 @@ check("block write of .opencode/project config", blocked(await call("write", { f
 check("block write of global opencode config path", blocked(await call("write", { filePath: "/var/home/x/.config/opencode/opencode.json", content: "{}" }, { sessionID: "s-active" })));
 check("block apply_patch to opencode.json", blocked(await call("apply_patch", { patchText: "*** Update File: opencode.json\n" }, { sessionID: "s-active" })));
 check("allow edit of normal source file", !(await call("edit", { filePath: join(root, "src", "index.ts"), oldString: "a", newString: "b" }, { sessionID: "s-active" })));
+check("allow write of docs mentioning .opencode paths (not tamper)", !(await call("write", { filePath: join(root, "docs", "guard.md"), content: "see `<project>/" + ocDir + "` and -> isProtectedPath" }, { sessionID: "s-active" })));
+check("allow write of project plan file under .opencode/plans", !(await call("write", { filePath: join(root, ".opencode", "plans", "1789589538371-plan.md"), content: "# plan" }, { sessionID: "s-active" })));
+check("block write escaping plans dir via .. (still tamper)", blocked(await call("write", { filePath: join(root, ".opencode", "plans", "..", "opencode.json"), content: "{}" }, { sessionID: "s-active" })));
+check("block write of the plans directory itself (no trailing-slash exemption)", blocked(await call("write", { filePath: join(root, ".opencode", "plans"), content: "{}" }, { sessionID: "s-active" })));
+check("block write under .opencode/plansx prefix (still tamper)", blocked(await call("write", { filePath: join(root, ".opencode", "plansx", "x.md"), content: "{}" }, { sessionID: "s-active" })));
+check("block write to user-level config plans path (exemption is project-only)", blocked(await call("write", { filePath: "/var/home/x/.config/opencode/plans/x.md", content: "{}" }, { sessionID: "s-active" })));
+// Plans dir symlinked at a config-shaped real location: lexical target is
+// exempt but the realpath fallback must still block via the user-config check.
+const plansAliasDir = mkdtempSync(join(tmpdir(), "wg-plans-alias-"));
+mkdirSync(join(plansAliasDir, ".config", "opencode"), { recursive: true });
+mkdirSync(join(plansAliasDir, ".opencode"), { recursive: true });
+symlinkSync(join(plansAliasDir, ".config", "opencode"), join(plansAliasDir, ".opencode", "plans"), "dir");
+setWorkspaceRoot(plansAliasDir);
+check("write through plans symlink into config real path blocked (realpath fallback)", blocked(await call("write", { filePath: join(plansAliasDir, ".opencode", "plans", "x.md"), content: "{}" }, { sessionID: "s-active" })));
+setWorkspaceRoot(root);
+rmSync(plansAliasDir, { recursive: true, force: true });
 console.log("- Policy 7: branch guard -");
 // Non-git workspace (current `root` is a plain temp dir): git writes allowed.
 check("non-git workspace: git commit allowed", !(await shell("git commit -m test")));
@@ -464,7 +486,8 @@ check("on main: git merge blocked", blocked(await shell("git merge feature/x")))
 	check("on main: git checkout path mutation without separator blocked", blocked(await shell("git checkout tracked.txt")));
 	check("on main: git checkout -B reset blocked", blocked(await shell("git checkout -B main HEAD~1")));
 	check("on main: git add blocked", blocked(await shell("git add tracked.txt")));
-	check("on main: git tag blocked", blocked(await shell("git tag release-test")));
+	check("on main: git tag creation allowed", !blocked(await shell("git tag release-test")));
+	check("on main: git tag -d blocked", blocked(await shell("git tag -d release-test")));
 	check("on main: git tag --list allowed", !blocked(await shell("git tag --list")));
 check("on main: git switch -c allowed (branch creation)", !(await shell("git switch -c feat/x")));
 check("on main: git status allowed", !(await shell("git status")));
@@ -1357,6 +1380,24 @@ rmSync(pipelineTimeoutMarker, { force: true });
 await runVerify(`node -e "setTimeout(() => require('fs').writeFileSync('${pipelineTimeoutMarker}', 'orphan'), 300)" | cat`, root, 50);
 await new Promise((resolve) => setTimeout(resolve, 450));
 check("runVerify timeout terminates descendants behind shell pipelines", !existsSync(pipelineTimeoutMarker));
+
+console.log("- Policy 10: verification timeout resolution -");
+const previousVerifyTimeoutEnv = process.env.WORKFLOW_GUARD_VERIFY_TIMEOUT_MS;
+if (previousVerifyTimeoutEnv !== undefined) delete process.env.WORKFLOW_GUARD_VERIFY_TIMEOUT_MS;
+check("verification timeout resolution defaults to 30s", resolveVerifyTimeoutMs(root) === 30_000);
+const verifyTimeoutConfigRoot = mkdtempSync(join(tmpdir(), "wg-verify-timeout-"));
+mkdirSync(join(verifyTimeoutConfigRoot, ".opencode"));
+writeFileSync(join(verifyTimeoutConfigRoot, ".opencode", "workflow-guard.json"), JSON.stringify({ verifyTimeoutMs: 60000 }));
+reloadProjectConfig(verifyTimeoutConfigRoot);
+check("verification timeout honors project config", resolveVerifyTimeoutMs(verifyTimeoutConfigRoot) === 60_000);
+writeFileSync(join(verifyTimeoutConfigRoot, ".opencode", "workflow-guard.json"), JSON.stringify({ verifyTimeoutMs: -5 }));
+reloadProjectConfig(verifyTimeoutConfigRoot);
+check("verification timeout ignores invalid project config values", resolveVerifyTimeoutMs(verifyTimeoutConfigRoot) === 30_000);
+process.env.WORKFLOW_GUARD_VERIFY_TIMEOUT_MS = "120000";
+check("verification timeout env overrides a valid project config", resolveVerifyTimeoutMs(verifyTimeoutConfigRoot) === 120_000);
+delete process.env.WORKFLOW_GUARD_VERIFY_TIMEOUT_MS;
+if (previousVerifyTimeoutEnv !== undefined) process.env.WORKFLOW_GUARD_VERIFY_TIMEOUT_MS = previousVerifyTimeoutEnv;
+rmSync(verifyTimeoutConfigRoot, { recursive: true, force: true });
 let windowsCleanupFinished = false;
 const windowsCleanup = terminateProcessTree(1234, () => {}, "win32", async (pid) => {
 	check("Windows timeout cleanup receives the child pid", pid === 1234);
@@ -2271,6 +2312,12 @@ const mergedCheck = isBranchAlreadyMergedOrClosed(conflictRepo, "feat/already-me
 check("isBranchAlreadyMergedOrClosed identifies branch with 0 diff from main", mergedCheck.merged);
 check("git push on already merged branch is blocked", blocked(await shell("git push origin feat/already-merged")));
 
+// Tag pushes are release operations, not branch mutations (#134).
+spawnSync("git", ["tag", "v0.3.0"], { cwd: conflictRepo });
+check("git push origin v0.3.0 allowed from merged branch", !blocked(await shell("git push origin v0.3.0")));
+check("git push origin refs/tags/v0.3.0 allowed", !blocked(await shell("git push origin refs/tags/v0.3.0")));
+check("git push origin :refs/tags/v0.3.0 still blocked", blocked(await shell("git push origin :refs/tags/v0.3.0")));
+
 // Create a branch with a genuine merge conflict against main
 spawnSync("git", ["switch", "main"], { cwd: conflictRepo });
 spawnSync("git", ["switch", "-c", "feat/conflict-branch"], { cwd: conflictRepo });
@@ -3080,6 +3127,20 @@ await continuationPlugin.event?.({ event: { type: "message.updated", properties:
 await continuationPlugin.event?.({ event: { type: "session.idle", properties: { sessionID: "s-resume-cap" } } } as any);
 check("genuine user message resets continuation budget", continuationPrompts.filter((id) => id === "s-resume-cap").length === 4);
 
+console.log("- Policy 1: user interrupt stops automatic continuation -");
+todo("s-resume-abort", item("work the user stopped", "pending"));
+await continuationPlugin.event?.({ event: { type: "session.idle", properties: { sessionID: "s-resume-abort" } } } as any);
+await continuationPlugin.event?.({ event: { type: "session.error", properties: { sessionID: "s-resume-abort", error: { name: "MessageAbortedError", data: { message: "aborted by user" } } } } } as any);
+await continuationPlugin.event?.({ event: { type: "session.idle", properties: { sessionID: "s-resume-abort" } } } as any);
+check("user interrupt (Esc / MessageAbortedError) stops automatic continuation", continuationPrompts.filter((id) => id === "s-resume-abort").length === 1);
+await continuationPlugin.event?.({ event: { type: "message.updated", properties: { info: { id: "genuine-restart", role: "user", sessionID: "s-resume-abort" } } } } as any);
+await continuationPlugin.event?.({ event: { type: "session.idle", properties: { sessionID: "s-resume-abort" } } } as any);
+check("genuine user input after an interrupt re-enables automatic continuation", continuationPrompts.filter((id) => id === "s-resume-abort").length === 2);
+todo("s-resume-api-error", item("work behind a flaky provider", "pending"));
+await continuationPlugin.event?.({ event: { type: "session.error", properties: { sessionID: "s-resume-api-error", error: { name: "APIError", data: { message: "provider overloaded" } } } } } as any);
+await continuationPlugin.event?.({ event: { type: "session.idle", properties: { sessionID: "s-resume-api-error" } } } as any);
+check("non-abort session errors do not disable automatic continuation", continuationPrompts.filter((id) => id === "s-resume-api-error").length === 1);
+
 const ralphRoot = mkdtempSync(join(tmpdir(), "wg-ralph-"));
 mkdirSync(join(ralphRoot, ".opencode"));
 writeFileSync(join(ralphRoot, ".opencode", "workflow-guard.json"), JSON.stringify({ ralphMode: true, ralphMaxIterations: 2 }));
@@ -3118,6 +3179,11 @@ check("duplicate genuine user events leave an active ralph run stopped", ralphPr
 await ralphPlugin.event?.({ event: { type: "message.updated", properties: { info: { id: "human-restart", role: "user", sessionID: "s-ralph-stop" } } } } as any);
 await ralphPlugin.event?.({ event: { type: "session.idle", properties: { sessionID: "s-ralph-stop" } } } as any);
 check("distinct later user input can establish a fresh ralph run", ralphPrompts.filter((id) => id === "s-ralph-stop").length === 2 && runWithRuntimeState(ralphRoot, ralphClient as any, () => getRalphOutcome("s-ralph-stop")) === "running");
+todo("s-ralph-abort", item("ralph work the user stopped", "pending"));
+await ralphPlugin.event?.({ event: { type: "session.idle", properties: { sessionID: "s-ralph-abort" } } } as any);
+await ralphPlugin.event?.({ event: { type: "session.error", properties: { sessionID: "s-ralph-abort", error: { name: "MessageAbortedError", data: { message: "aborted by user" } } } } } as any);
+await ralphPlugin.event?.({ event: { type: "session.idle", properties: { sessionID: "s-ralph-abort" } } } as any);
+check("user interrupt stops an active ralph run as user_stopped", ralphPrompts.filter((id) => id === "s-ralph-abort").length === 1 && runWithRuntimeState(ralphRoot, ralphClient as any, () => getRalphOutcome("s-ralph-abort")) === "user_stopped");
 todo("s-ralph-complete", item("completable work", "pending"));
 await ralphPlugin.event?.({ event: { type: "session.idle", properties: { sessionID: "s-ralph-complete" } } } as any);
 todo("s-ralph-complete", item("completable work", "completed"));