harnery 0.44.0 → 0.45.0

package/dist/lib/tunnel/state.js

@@ -1,7 +1,8 @@
 // Tunnel config + state persistence + provider helpers. Commands default to
 // <cwd>/.cache/tunnel/; gitignored, so the allowlist is per-machine.
 import { spawnSync } from "node:child_process";
-import { accessSync, chmodSync, constants, existsSync, mkdirSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { accessSync, chmodSync, constants, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
 import { homedir } from "node:os";
 import { delimiter, join, resolve } from "node:path";
 import { isPathAllowed } from "./path-scope.js";
@@ -104,7 +105,17 @@ export function readState(name = DEFAULT_INSTANCE, root = process.cwd()) {
     }
 }
 export function writeState(state, root = process.cwd()) {
-    writeFileSync(cachePath(stateFile(state.name), root), JSON.stringify(state, null, 2));
+    const path = cachePath(stateFile(state.name), root);
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    try {
+        writeFileSync(temporary, JSON.stringify(state, null, 2), { flag: "wx", mode: 0o600 });
+        renameSync(temporary, path);
+    }
+    catch (error) {
+        if (existsSync(temporary))
+            unlinkSync(temporary);
+        throw error;
+    }
 }
 export function clearState(name = DEFAULT_INSTANCE, root = process.cwd()) {
     const p = cachePath(stateFile(name), root);
@@ -139,14 +150,49 @@ export function isProcessAlive(pid) {
         return false;
     }
 }
-/** True when both the local gate and its provider-side process are live. */
-export function isTunnelStateLive(state, processAlive = isProcessAlive) {
-    if (!processAlive(state.gate_pid))
-        return false;
-    if (state.provider === "tailscale")
-        return true;
-    const providerPid = state.cloudflared_pid ?? state.provider_pid;
-    return typeof providerPid === "number" && processAlive(providerPid);
+/** Classify saved original witnesses under the verifier's registration custody. */
+export function tunnelReadiness(state, verifier) {
+    if (!state ||
+        typeof state !== "object" ||
+        Object.hasOwn(state, "provider_pid") ||
+        Object.hasOwn(state, "provider_start_token") ||
+        typeof state.registration_id !== "string" ||
+        !state.registration_id ||
+        !Number.isSafeInteger(state.gate_pid) ||
+        state.gate_pid < 1 ||
+        typeof state.gate_start_token !== "string" ||
+        !state.gate_start_token)
+        return "unknown";
+    const targets = [{ pid: state.gate_pid, token: state.gate_start_token }];
+    if (state.provider === "tailscale") {
+        if (state.provider_state !== "ready" ||
+            state.cloudflared_pid !== undefined ||
+            state.cloudflared_start_token !== undefined)
+            return "unknown";
+    }
+    else if (state.provider === "cloudflare") {
+        if (!Number.isSafeInteger(state.cloudflared_pid) ||
+            state.cloudflared_pid < 1 ||
+            typeof state.cloudflared_start_token !== "string" ||
+            !state.cloudflared_start_token)
+            return "unknown";
+        targets.push({ pid: state.cloudflared_pid, token: state.cloudflared_start_token });
+    }
+    else
+        return "unknown";
+    try {
+        return verifier.withRegistration(state, () => {
+            const observed = targets.map(({ pid, token }) => verifier.observeProcess(pid, token));
+            if (observed.every((value) => value === "absent"))
+                return "dead";
+            if (observed.every((value) => value === "same"))
+                return "ready";
+            return "unknown";
+        });
+    }
+    catch {
+        return "unknown";
+    }
 }
 export function tunnelTargetPort(state) {
     const value = /^[a-z][a-z\d+.-]*:\/\//i.test(state.target)
@@ -173,10 +219,10 @@ export function tunnelTargetPort(state) {
  * link 400s. Matching the vhost too keeps the returned tunnel the one that
  * actually serves the caller's origin.
  */
-export function findLiveTunnelForOrigin(port, vhost, root = process.cwd(), processAlive = isProcessAlive) {
+export function findLiveTunnelForOrigin(port, vhost, root, verifier) {
     return (listStates(root).find((state) => tunnelTargetPort(state) === port &&
         state.vhost === vhost &&
-        isTunnelStateLive(state, processAlive)) ?? null);
+        tunnelReadiness(state, verifier) === "ready") ?? null);
 }
 /** True when the tunnel's path scope forwards every one of `paths`. */
 export function tunnelServesPaths(state, paths) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harnery",
-  "version": "0.44.0",
+  "version": "0.45.0",
   "description": "Multi-agent coordination for AI coding agents - Claude Code, Cursor, and Codex.",
   "license": "MIT",
   "author": "Ryan Kelly",
@@ -67,6 +67,11 @@
       "types": "./dist/core/context/index.d.ts",
       "import": "./dist/core/context/index.js"
     },
+    "./core/turn-rollback": {
+      "bun": "./src/core/turn-rollback/index.ts",
+      "types": "./dist/core/turn-rollback/index.d.ts",
+      "import": "./dist/core/turn-rollback/index.js"
+    },
     "./core/workflow": {
       "bun": "./src/core/workflow/index.ts",
       "types": "./dist/core/workflow/index.d.ts",

package/src/commander.ts

@@ -795,6 +795,16 @@ function harneryCommandBundles({
       load: async (program) =>
         (await import("./commands/workflow.ts")).registerWorkflowCommand(program, emit),
     },
+    lazy(
+      "turn-rollback",
+      "Capture and review exact turn paths before restoring owned content.",
+      async (program) =>
+        (await import("./commands/turn-rollback.ts")).registerTurnRollbackCommand(
+          program,
+          emit,
+          context,
+        ),
+    ),
     lazy("work", "Track durable objectives across bounded workflow attempts.", async (program) =>
       (await import("./commands/work.ts")).registerWorkCommand(program, emit),
     ),

package/src/commands/files.ts

@@ -4,6 +4,7 @@ import type { Command } from "commander";
 import type { EmitContext, HarneryProgramContext } from "../commander.ts";
 import { resolveCoordRoot } from "../core/agents/coord-client.ts";
 import { DEFAULT_WEB_PORT, resolveWebPort } from "../core/config.ts";
+import { createTunnelReadinessVerifier } from "../core/servers/index.ts";
 import { coordRootId, localCoordRootIdUrl } from "../lib/coord-root-id.ts";
 import {
   encodedRepoPath,
@@ -14,10 +15,10 @@ import {
 } from "../lib/local-file-url.ts";
 import { isPathAllowed } from "../lib/tunnel/path-scope.ts";
 import {
-  isTunnelStateLive,
   listStates,
-  type ProcessAliveCheck,
+  type TunnelReadinessVerifier,
   type TunnelState,
+  tunnelReadiness,
   tunnelTargetPort,
 } from "../lib/tunnel/state.ts";
 
@@ -208,10 +209,10 @@ export function tunnelFileUrl(
   local: LocalFileUrl,
   port: number,
   states: TunnelState[],
-  processAlive?: ProcessAliveCheck,
+  verifier: TunnelReadinessVerifier,
 ): string {
   const live = states.filter(
-    (state) => tunnelTargetPort(state) === port && isTunnelStateLive(state, processAlive),
+    (state) => tunnelTargetPort(state) === port && tunnelReadiness(state, verifier) === "ready",
   );
   if (local.mode === "raw") {
     const path = `/${encodedRepoPath(local.relPath)}`;
@@ -309,7 +310,14 @@ export function registerFilesCommand(
             mode: opts.raw ? "raw" : opts.viewer ? "viewer" : "auto",
           });
           if (opts.verify !== false) await verifyDashboardRoot(coordRoot, port);
-          const url = opts.tunnel ? tunnelFileUrl(result, port, listStates(coordRoot)) : result.url;
+          const url = opts.tunnel
+            ? tunnelFileUrl(
+                result,
+                port,
+                listStates(coordRoot),
+                createTunnelReadinessVerifier({ coordRoot }),
+              )
+            : result.url;
           emit.text(`${url}\n`);
         } catch (error) {
           if (error instanceof TunnelLinkError) {

package/src/commands/servers.ts

@@ -1,5 +1,4 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
-import { hostname } from "node:os";
 import type { Command } from "commander";
 import type { EmitContext, HarneryProgramContext } from "../commander.ts";
 import { resolveCoordRoot } from "../core/agents/coord-client.ts";
@@ -111,23 +110,13 @@ export function registerServersCommand(
           const preview = Boolean(options.type) && !options.yes;
           const results: Array<StopResult | { id: string; would_stop: true }> = [];
           for (const stray of strays) {
-            results.push(
-              await stopServer(
-                {
-                  schema_version: 1,
-                  id: `pid-${stray.pid}`,
-                  kind: "session",
-                  type: "unregistered",
-                  label: stray.command,
-                  pid: stray.pid,
-                  ...(stray.start_token ? { start_token: stray.start_token } : {}),
-                  host: hostname(),
-                  started_at: new Date().toISOString(),
-                  registered_at: new Date().toISOString(),
-                },
-                { coordRoot },
-              ),
-            );
+            const receipt = adoptServer(stray.pid, {
+              coordRoot,
+              type: "unregistered",
+              owner: "none",
+              dependencies: { listServers: () => report },
+            });
+            results.push(await stopServer(receipt, { coordRoot }));
           }
           for (const view of selected) {
             if (preview && !ids.includes(view.record.id))
@@ -408,14 +397,14 @@ export function registerServersCommand(
 
   cmd
     .command("unregister <id>")
-    .description("Remove a server's record (with --pid, only if the record still names that pid)")
+    .description("Remove the exact observed server registration (optionally require --pid)")
     .option("--pid <pid>", "Only remove when the record names this pid")
     .action((id: string, options: { pid?: string }) => {
       try {
-        const removed = unregisterServer(id, {
-          coordRoot: root(),
-          ...(options.pid ? { pid: integer(options.pid, "--pid") } : {}),
-        });
+        const coordRoot = root();
+        const record = readServer(id, { coordRoot });
+        const matchesPid = !options.pid || record?.pid === integer(options.pid, "--pid");
+        const removed = !!record && matchesPid && unregisterServer(record, { coordRoot });
         emit.config({ format: "json" });
         emit.data({ id, removed });
       } catch (error) {