@deksden-com/dd-flow-cli 0.9.0-beta.11 → 0.9.0-beta.111

package/dist/harness-runtime/lib/daemon-operations.mjs

@@ -0,0 +1,226 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, readdir, link, unlink, open } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { hashJson, writeJsonAtomic } from "./runner-events.mjs";
+import { errorRecord, isObservationLoss, reportedError } from "./operation-errors.mjs";
+import { assertDaemonOwnership, budgetObservationScope, releaseBudgetObservation, completeBudgetOperation } from "./managed-daemon.mjs";
+import { readModelObservations, modelAttribution } from "./model-observations.mjs";
+
+const productive = new Set(["session.create", "session.prompt", "session.start", "session.fork", "session.resume"]);
+const controls = new Map();
+const dispatchGenerations = new Map();
+
+async function controlDispatch(root, request, action) {
+  const key = request.operation === "daemon.stop" ? `stop:${request.params?.cancelTree === true}` : `cancel:${request.params?.sessionId ?? ""}`;
+  let pending = controls.get(root);
+  if (!pending) { pending = new Map(); controls.set(root, pending); }
+  if (pending.has(key)) return await pending.get(key);
+  // Preserve the adapter's identity check for every distinct cancel target.
+  // A stop arriving after cancel waits for its attempts before verification.
+  const predecessors = key.startsWith("stop:") ? [...pending.values()] : [];
+  const promise = (async () => { await Promise.allSettled(predecessors); return await action(); })();
+  pending.set(key, promise);
+  try { return await promise; }
+  finally { pending.delete(key); if (!pending.size) controls.delete(root); }
+}
+function location(root, id) {
+  if (typeof id !== "string" || !id) throw Object.assign(new Error("operation id is required"), { code: "operation_id_required" });
+  return path.join(root, "operations", createHash("sha256").update(id).digest("hex"));
+}
+async function read(file) { try { return JSON.parse(await readFile(file, "utf8")); } catch (error) { if (error.code === "ENOENT") return null; throw error; } }
+
+export async function inspectDaemonOperation(root, id) {
+  if (typeof root !== "string" || !path.isAbsolute(root)) throw Object.assign(new Error("operation observation requires an absolute state directory"), { code: "invalid_path" });
+  const directory = location(root, id);
+  const requested = await read(path.join(directory, "requested.json"));
+  if (!requested) throw Object.assign(new Error("daemon operation is not recorded"), { code: "operation_not_found", details: { operation_id: id } });
+  const settlement = await read(path.join(directory, "settlement.json"));
+  const hookFailures = [];
+  for (const name of await readdir(path.join(directory, "hooks")).catch(error => { if (error.code === "ENOENT") return []; throw error; })) {
+    if (!/^[A-Za-z0-9-]{1,128}\.json$/.test(name)) continue;
+    const binding = await read(path.join(directory, "hooks", name));
+    if (binding?.schema_id !== "dd-flow/hook-request@1" || binding.request_id !== name.slice(0, -5) || binding.operation_id !== id || binding.daemon_id !== requested.daemon_id) continue;
+    const failure = await read(path.join(root, "hook-failures", name));
+    if (failure?.request_id !== binding.request_id || typeof failure.code !== "string" || typeof failure.message !== "string") continue;
+    hookFailures.push({ code: failure.code, message: failure.message, observed_at: failure.observed_at ?? null, details: { ...failure.details, ...binding, effect: "unknown" } });
+  }
+  hookFailures.sort((a, b) => String(a.observed_at ?? "").localeCompare(String(b.observed_at ?? "")));
+  // Admission failure is causal evidence, not proof that the native tree stopped.
+  return { ...requested, ...(await read(path.join(directory, "result.json")) ?? await read(path.join(directory, "interrupted.json")) ?? await read(path.join(directory, "observation-lost.json")) ?? { state: "running" }), ...(settlement ? { settlement } : {}), ...(hookFailures[0] ? { primary_error: hookFailures[0] } : {}) };
+}
+
+/** Retry only the bookkeeping that follows a durable productive receipt.
+ * This is intentionally separate from dispatch: it never invokes a native
+ * prompt/create/fork operation, so recovery cannot duplicate agent work. */
+export async function settleDaemonOperation(root, id) {
+  const current = await inspectDaemonOperation(root, id);
+  if (current.state !== "completed") return current;
+  if (current.settlement?.state === "settled") return current;
+  let settlement;
+  try {
+    settlement = await completeBudgetOperation(root, {
+      id: current.operation_id,
+      operation: current.operation,
+      params: { sessionId: current.session_id ?? undefined }
+    }, current.result);
+  } catch (error) {
+    settlement = { state: "pending", reason: "settlement_error", observed_at: new Date().toISOString(), error: errorRecord(error) };
+  }
+  try { await writeSettlement(root, id, settlement); }
+  catch (error) {
+    settlement = { state: "blocked", reason: "settlement_storage_error", observed_at: new Date().toISOString(), error: errorRecord(error) };
+  }
+  return { ...current, settlement };
+}
+
+/** A sealed whole-tree stop is the only authority that may turn an unknown
+ * productive request into a terminal interruption.  This is deliberately a
+ * journal operation: a closed daemon cannot be asked to manufacture a reply. */
+export async function interruptDaemonOperation(root, id, barrier) {
+  if (!barrier || typeof barrier !== "object" || typeof barrier.control_id !== "string" || !barrier.control_id) throw Object.assign(new Error("interruption requires a sealed control identity"), { code: "stop_barrier_invalid" });
+  const current = await inspectDaemonOperation(root, id);
+  if (["completed", "failed", "interrupted"].includes(current.state)) return current;
+  if (!(["running", "awaiting_provider"].includes(current.state)) || !productive.has(current.operation)) throw Object.assign(new Error("only an observed productive operation may be interrupted"), { code: "operation_not_interruptible" });
+  // A lazy session/create is allowed to have no ACP/native session id yet.
+  // The owned daemon identity plus the sealed stop operation is the authority
+  // in that case; never manufacture a session id merely to satisfy the check.
+  const barrierSession = barrier.session_id ?? null;
+  const currentSession = current.session_id ?? null;
+  if (barrier.daemon_id !== current.daemon_id || barrierSession !== currentSession) throw Object.assign(new Error("interruption barrier belongs to another daemon operation"), { code: "stop_barrier_mismatch" });
+  const value = { state: "interrupted", outcome: "interrupted", observed_at: new Date().toISOString(), interrupted_by: { control_id: barrier.control_id, stop_operation_id: barrier.stop_operation_id, evidence: barrier.evidence ?? null }, error: { code: "operation_interrupted", message: "Operation was interrupted after the owned native tree was stopped", cause: current.error ?? null } };
+  const saved = await writeTerminal(root, id, value);
+  if (saved.state !== "interrupted" || saved.interrupted_by?.control_id !== barrier.control_id) throw Object.assign(new Error("operation already has a conflicting terminal outcome"), { code: "operation_terminal_conflict" });
+  return await inspectDaemonOperation(root, id);
+}
+
+/** At-most-once dispatch and a durable terminal reply, including when the socket
+ * observer disconnects. Recovery reads this receipt; it never resends a prompt. */
+export async function durableDaemonDispatch(root, request, action, observe) {
+  if (request.operation === "operation.inspect") return await inspectDaemonOperation(root, request.params?.operationId);
+  if (request.operation === "daemon.status") {
+    const result = await action();
+    if (!result?.config?.journal) return result;
+    try { return { ...result, model_attribution: modelAttribution(await readModelObservations(result.config.journal)) }; }
+    catch (error) { return { ...result, model_observation_error: errorRecord(error) }; }
+  }
+  if (request.operation === "session.inspect") {
+    const scope = await budgetObservationScope(root, request.params?.sessionId);
+    const result = await action();
+    let settlement;
+    if (!scope?.operationIds.length) settlement = { state: "not_required" };
+    else if (result?.settled !== true) settlement = { state: "pending", reason: "tree_unsettled" };
+    else try {
+      await releaseBudgetObservation(scope, result);
+      settlement = { state: "settled", operation_ids: scope.operationIds, source: "inspection" };
+    } catch (error) {
+      settlement = { state: "pending", reason: "settlement_error", observed_at: new Date().toISOString(), error: errorRecord(error) };
+    }
+    return settlement.state === "not_required" || !result || typeof result !== "object" || Array.isArray(result) ? result : { ...result, settlement };
+  }
+  const control = ["daemon.stop", "session.cancel"].includes(request.operation);
+  if (!productive.has(request.operation) && !control) return await action();
+  const generation = dispatchGenerations.get(root) ?? 0;
+  if (control) dispatchGenerations.set(root, generation + 1);
+  const assertCurrent = () => { if (generation !== (dispatchGenerations.get(root) ?? 0)) throw Object.assign(new Error("control cancelled a queued productive dispatch"), { code: "operation_cancelled" }); };
+  const result = await journalDispatch(root, request, async () => {
+    // Persist before admission so a racing fence can observe the writer.
+    if (!control) await assertDaemonOwnership(root, { "operation-id": request.id, operation: request.operation, "native-session-id": request.params?.sessionId, "prompt-sha256": typeof request.params?.prompt === "string" ? createHash("sha256").update(request.params.prompt).digest("hex") : undefined }, assertCurrent);
+    if (!control) assertCurrent();
+    return control ? await controlDispatch(root, request, action) : await action();
+  });
+  if (control) return result;
+  let settlement;
+  try {
+    settlement = await completeBudgetOperation(root, request, result, observe);
+  } catch (error) {
+    settlement = { state: "pending", reason: "settlement_error", observed_at: new Date().toISOString(), error: errorRecord(error) };
+  }
+  try { await writeSettlement(root, request.id, settlement); }
+  catch (error) {
+    settlement = { state: "blocked", reason: "settlement_storage_error", observed_at: new Date().toISOString(), error: errorRecord(error) };
+  }
+  return settlement?.state === "not_required" || !result || typeof result !== "object" || Array.isArray(result)
+    ? result
+    : { ...result, settlement };
+}
+
+async function writeSettlement(root, id, value) {
+  const directory = location(root, id);
+  await writeJsonAtomic(path.join(directory, "settlement.json"), value);
+}
+
+/** Startup has no registered daemon yet. Its existing native implementation
+ * owns registration/admission; only the CLI entrypoint uses this journal path. */
+export async function durableDaemonStart(options, action) {
+  const root = options.stateDir;
+  if (typeof root !== "string" || !path.isAbsolute(root)) throw Object.assign(new Error("daemon startup requires an absolute state directory"), { code: "invalid_path" });
+  // Keep only configuration locations, never inherited credentials. The owned
+  // scope can reuse this exact adapter launch after retiring the old daemon.
+  const launch = { schema_id: "dd-flow/native-launch@1", executable: options.entryPath ?? null, args: process.argv.slice(2), cwd: process.cwd(), runtime_owner: process.env.DD_FLOW_RUNTIME_OWNER ?? null,
+    env: Object.fromEntries(["CODEX_HOME", "DD_FLOW_CONFIG_HOME", "DD_FLOW_HOME", "DD_FLOW_BIN", "DD_FLOW_RESOURCE_HOME"].map(key => [key, process.env[key] ?? null])) };
+  const request = { id: process.env.DD_EVAL_OPERATION_ID ?? randomUUID(), operation: "daemon.start", params: { ...options, runtimeOwner: process.env.DD_FLOW_RUNTIME_OWNER ?? null, resourceHome: process.env.DD_FLOW_RESOURCE_HOME ?? null, launch } };
+  return await journalDispatch(root, request, () => action(options));
+}
+
+async function journalDispatch(root, request, action) {
+  const directory = location(root, request.id), fingerprint = hashJson({ operation: request.operation, params: request.params ?? {} });
+  await mkdir(directory, { recursive: true, mode: 0o700 });
+  // Publish a complete request atomically and exclusively. Writing directly with
+  // wx exposes a partially written JSON document to a concurrent observer.
+  const temporary = path.join(directory, `requested-${randomUUID()}.json`);
+  const daemon = await read(path.join(root, "daemon.json"));
+  const startup = request.operation === "daemon.start";
+  const daemonId = daemon?.daemon_id ?? daemon?.config?.daemonId ?? null;
+  await writeJsonAtomic(temporary, { schema_id: "dd-flow/daemon-operation@1", operation_id: request.id, operation: request.operation, session_id: request.params?.sessionId ?? null, daemon_id: startup ? null : daemonId, ...(startup ? { predecessor_daemon_id: daemonId, launch: request.params?.launch } : {}), params_sha256: fingerprint, requested_at: new Date().toISOString() });
+  try {
+    await link(temporary, path.join(directory, "requested.json"));
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    const saved = await inspectDaemonOperation(root, request.id);
+    if (saved.params_sha256 !== fingerprint) throw Object.assign(new Error("operation id was reused with different parameters"), { code: "operation_conflict", details: { operation_id: request.id } });
+    if (saved.state === "completed") return saved.result;
+    if (["failed", "interrupted"].includes(saved.state)) throw reportedError(saved.error, "provider operation failed");
+    throw Object.assign(new Error("provider operation has no confirmed terminal result; inspect the existing operation instead of resending it"), { code: "operation_observation_lost", details: { operation_id: request.id, receipt_directory: directory } });
+  } finally { await unlink(temporary); }
+  let result;
+  try {
+    result = await action();
+  }
+  catch (error) {
+    const unknown = isObservationLoss(error);
+    if (unknown) await writeJsonAtomic(path.join(directory, "observation-lost.json"), { state: "awaiting_provider", observed_at: new Date().toISOString(), error: errorRecord(error) });
+    else {
+      const terminal = await writeTerminal(root, request.id, { state: "failed", observed_at: new Date().toISOString(), error: errorRecord(error) });
+      if (terminal.state !== "failed") throw reportedError(terminal.error, "provider operation did not retain this failure");
+    }
+    throw error;
+  }
+  try {
+    const terminal = await writeTerminal(root, request.id, { state: "completed", ...(startup ? { started_daemon_id: result?.daemon_id ?? null } : {}), finished_at: new Date().toISOString(), result });
+    if (terminal.state !== "completed") throw reportedError(terminal.error, "provider operation was terminalized before its late reply arrived");
+  } catch (cause) {
+    if (cause?.code === "operation_interrupted" || cause?.code === "operation_terminal_conflict") throw cause;
+    throw Object.assign(new Error("provider returned but the durable reply could not be saved; do not resend the operation"), { code: "operation_observation_lost", cause, details: { operation_id: request.id, receipt_directory: directory } });
+  }
+  return result;
+}
+
+/** `result.json` is the one exclusive terminal slot. Old interrupted.json
+ * files remain readable for compatibility, but new writes never race them. */
+async function writeTerminal(root, id, value) {
+  const file = path.join(location(root, id), "result.json");
+  const temporary = `${file}.${randomUUID()}.tmp`;
+  const handle = await open(temporary, "wx", 0o600);
+  try { await handle.writeFile(`${JSON.stringify(value, null, 2)}\n`); await handle.sync(); }
+  finally { await handle.close(); }
+  try {
+    await link(temporary, file);
+    return value;
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    const saved = await read(file);
+    if (!saved || !["completed", "failed", "interrupted"].includes(saved.state)) throw Object.assign(new Error("operation terminal record is invalid"), { code: "operation_terminal_conflict" });
+    return saved;
+  } finally { await unlink(temporary); }
+}

package/dist/harness-runtime/lib/dd-agy-daemon.d.mts

@@ -0,0 +1,6 @@
+export declare function qualifyAgyHooks(projectRoot: string, options?: { stateDir?: string | null; install?: boolean }): Promise<{
+  hooksSha256: string;
+  workspaceHooksPath: string;
+  workspaceHooksSha256: string;
+  workspaceHooksInstalled: string;
+}>;