@deksden-com/dd-flow-cli 0.9.0-beta.14 → 0.9.0-beta.141

package/dist/harness-runtime/lib/dd-droid-daemon.mjs

@@ -0,0 +1,140 @@
+import { SETUP_STARTUP_MS, startupObserver, observationDetails } from './setup-progress.mjs';
+import { callDaemonObserved } from './daemon-observation.mjs';
+import { admitNativeRequestBuffer, nativeObservationError } from "./native-streams.mjs";
+import { prepareDaemonRequest } from "./native-request-proof.mjs";
+import { createHash, randomUUID } from "node:crypto";
+import { chmod, lstat, mkdir, open, unlink, realpath } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import net from "node:net";
+import os from "node:os";
+import { DroidError, DroidRuntime, absolute, droidPaths, droidVersion, prepareDroidHome, readJson, removeDroidAuth, processSnapshot } from "./dd-droid.mjs";
+import { durableDaemonDispatch, inspectDaemonOperation, settleDaemonOperation, completeDaemonShutdown, commitDaemonShutdown, assertDaemonDispatch, assertDaemonRestartable, trackDaemonConnections, retireDaemonEndpoint, retireFailedDaemon } from "./daemon-operations.mjs";
+import { ObservationClock, validateObservationDuration } from "./observation-clock.mjs";
+import { writeJsonAtomic } from "./runner-events.mjs";
+import { errorRecord } from "./operation-errors.mjs";
+import { retainStartupFailure, prepareRuntimeOwner, cleanupFailedStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess } from "./managed-daemon.mjs";
+
+const REQUEST = "dd-droid/daemon-request@1", RESPONSE = "dd-droid/daemon-response@1";
+async function removeSocket(file) { try { if (!(await lstat(file)).isSocket()) throw new DroidError("unsafe_socket", "Refusing to replace non-socket daemon path"); await unlink(file); } catch (error) { if (error.code !== "ENOENT") throw error; } }
+export async function callDaemon(stateDir, operation, params = {}, timeoutMs = 30_000, operationId = process.env.DD_EVAL_OPERATION_ID ?? randomUUID()) {
+  const request = prepareDaemonRequest({ schema_id: REQUEST, id: operationId, operation, params });
+  return await callDaemonObserved({ stateDir, socket: droidPaths(stateDir).socket, request, responseSchema: RESPONSE, harness: 'droid', timeoutMs });
+}
+function sameConfig(a, b) { return ["cwd", "bin", "model", "reasoning", "mode", "provider", "ddFlowBin", "ddFlowHome", "resourceHome", "projectRoot", "noFlow","inactivityMs"].every(key => a?.[key] === b[key]); }
+export async function startDaemon(options) {
+  const paths = droidPaths(options.stateDir), noFlow = options.noFlow === true || (!options.ddFlowBin && !options.ddFlowHome);
+  const config = { stateDir: paths.dir, home: paths.home, bin: options.bin ?? process.env.DD_DROID_BIN ?? "droid", cwd: absolute(options.cwd, "--cwd"), projectRoot: absolute(options.projectRoot ?? options.cwd, "--project-root"), journal: absolute(options.journal ?? `${paths.dir}/events.jsonl`, "--journal"), entryPath: absolute(options.entryPath, "adapter entry"), authHome: absolute(options.authHome ?? os.homedir(), "auth home"), model: options.model ?? "gpt-5.6-sol", reasoning: options.reasoning ?? "high", mode: options.mode ?? "auto-high", provider: options.provider ?? "openai", noFlow, ddFlowBin: noFlow ? null : absolute(options.ddFlowBin, "--dd-flow-bin"), ddFlowHome: noFlow ? null : absolute(options.ddFlowHome, "--dd-flow-home"), resourceHome: noFlow ? null : process.env.DD_FLOW_RESOURCE_HOME ?? null, inactivityMs: options.timeoutMs ?? 600_000 };
+  await prepareRuntimeOwner(config, paths.dir);
+  config.cwd = await realpath(config.cwd); config.projectRoot = await realpath(config.projectRoot);
+  if (config.mode !== "auto-high") throw new DroidError("droid_mode_unsupported", "The qualified Droid profile requires auto-high");
+  config.inactivityMs = options.livenessTimeoutMs ?? options.timeoutMs ?? 600_000;
+  validateObservationDuration(config.inactivityMs);
+  await mkdir(paths.dir, { recursive: true, mode: 0o700 }); await chmod(paths.dir, 0o700);
+  let previous = await readJson(paths.state); assertDaemonRestartable(previous);
+  try { const live = await callDaemon(paths.dir, "daemon.status", {}, 1_000); if (!sameConfig(live.config, config)) throw new DroidError("daemon_config_mismatch", "Droid daemon already uses another configuration"); return { ...live, already_running: true }; } catch (error) { if (!["daemon_not_running", "daemon_timeout"].includes(error.code)) throw error; }
+  previous = await readJson(paths.state); assertDaemonRestartable(previous);
+  if (previous) {
+    const rows = await processSnapshot();
+    if (rows.some(row => !row.zombie && ([previous.pid, previous.provider_pid].includes(row.pid) || previous.owned_processes?.some(old => old.pid === row.pid && old.started === row.started)))) throw new DroidError("invalid_harness_crash", "Previous daemon or provider ownership remains; refusing another owner");
+  }
+  if (["clean", "unclean"].includes(previous?.shutdown_state)) await authorizeRetainedDaemonResume(paths.dir, previous, options.sessionId, config);
+  if (previous && !["failed", "starting", "clean"].includes(previous.shutdown_state)) throw new DroidError("invalid_harness_crash", "Previous Droid ownership must be reconciled before another daemon starts");
+  config.daemonId = randomUUID(); config.version = await droidVersion(config.bin);
+  await removeSocket(paths.socket); const home = await prepareDroidHome(config); Object.assign(config, home);
+  const resource = await registerDaemonProcess(config, { kind: "droid-daemon", owner: `droid:${config.daemonId}`, operation: `droid-daemon:${config.daemonId}`, stdout: paths.log, stderr: paths.log });
+  await writeJsonAtomic(paths.state, { schema_id: "dd-droid/daemon-state@1", config, daemon_id: config.daemonId, shutdown_state: "starting", sessions: previous?.sessions ?? [], root_session_id: previous?.root_session_id ?? null, descendants: previous?.descendants ?? [], last_result: previous?.last_result ?? null, resource_process: resource });
+  const log = await open(paths.log, "a", 0o600); const child = spawn(process.execPath, [config.entryPath, "daemon", "serve", "--state-dir", paths.dir], { cwd: config.cwd, detached: true, stdio: ["ignore", log.fd, log.fd] }); child.unref(); await log.close();
+  try {
+    await confirmDaemonProcess(config, resource, child);
+    const startupClock = new ObservationClock({ timeoutMs: SETUP_STARTUP_MS }); const startupProgress = startupObserver(paths.dir, config.daemonId);
+    while (!startupClock.sample(await startupProgress())) { await new Promise(resolve => setTimeout(resolve, 100)); const saved = await readJson(paths.state); if (saved?.startup_error) throw Object.assign(new Error(saved.startup_error.message), saved.startup_error); try { return await callDaemon(paths.dir, "daemon.status", {}, 1_000); } catch (error) { if (!["daemon_not_running", "daemon_timeout"].includes(error.code)) throw error; } }
+    throw Object.assign(new DroidError("daemon_start_failed", "Droid daemon did not become ready"), { details: observationDetails(startupClock, 'daemon-start', child.pid) });
+  } catch (error) { await cleanupFailedStart(config, resource, child, error); throw error; }
+}
+export async function stopDaemon(options) { return await confirmDaemonStopped(() => callDaemon(options.stateDir, "daemon.stop", { cancelTree: options.cancelTree === true }, 30_000), droidPaths(options.stateDir).socket, 30_000, { readState: () => readJson(droidPaths(options.stateDir).state) }); }
+export async function serveDaemon(stateDir) {
+  const paths = droidPaths(stateDir), state = await readJson(paths.state); if (!state?.config) throw new DroidError("daemon_state_missing", "Missing Droid daemon state");
+  let saving = Promise.resolve(), busy = null, stopping = false;
+  const save = patch => { Object.assign(state, patch, { pid: process.pid, updated_at: new Date().toISOString() }); const snapshot = structuredClone(state); saving = saving.catch(() => {}).then(() => writeJsonAtomic(paths.state, snapshot)); return saving; };
+  const runtime = new DroidRuntime(state.config, state, save);
+  const dispatch = async request => {
+    const params = request.params ?? {}, operation = request.operation;
+    if (operation === "daemon.status") { let observationError; try { await runtime.refreshTopology(); } catch (error) { observationError = errorRecord(error); } return { observation_error: observationError ?? null, daemon_id: state.daemon_id, pid: process.pid, config: state.config, shutdown_state: state.shutdown_state, provider_ready: Boolean(runtime.child && !runtime.closed), active_operation: busy, active_tree: Boolean(runtime.active || runtime.workingState !== "idle" || runtime.topologyIncomplete || [...runtime.topology.values()].some(child => !["completed", "cancelled", "failed"].includes(child.status))), sessions: runtime.rootId ? [runtime.rootId] : [], provider_pid: runtime.closed ? null : runtime.child?.pid }; }
+    if (operation === "hook.observe") return await runtime.observeHook(params.payload, params.eventId, params.deadlineAt);
+    if (operation === "session.inspect") return await runtime.inspect(params.sessionId, { ingestUsage: params.noFlow !== true });
+    if (operation === "session.cancel") {
+      runtime.requireIdentity(params.sessionId); const cleanup = await runtime.closeTree(true); let inspected;
+      try { inspected = await runtime.inspect(params.sessionId, { ignoreActive: true }); }
+      catch (error) { inspected = { harness: "droid-cli", provider_session_id: params.sessionId, descendants: [...runtime.topology.values()], inspection_error: errorRecord(error) }; }
+      return { ...inspected, cancelled: true, settled: cleanup.settled, cleanup };
+    }
+    if (operation === "daemon.stop") {
+      stopping = true;
+      try {
+        return await completeDaemonShutdown(paths.dir, state, save, async () => {
+        if (!params.cancelTree && (busy || (runtime.rootId && !(await runtime.inspect(runtime.rootId)).settled))) throw new DroidError("tree_not_settled", "Droid still owns unfinished work");
+        commitDaemonShutdown(paths.dir);
+        const cleanup = await runtime.closeTree(params.cancelTree === true);
+        if (runtime.rootId) try { await runtime.inspect(runtime.rootId, { ignoreActive: true }); } catch (error) { cleanup.inspection_error = errorRecord(error); }
+        // Native evidence failures remain visible, but cannot strand copied
+        // credentials or the daemon after the owned process tree is gone.
+        const clean = !cleanup.forced && !cleanup.topology_error && !cleanup.inspection_error;
+        return { clean, cleanup };
+        }, [
+          ["auth", () => removeDroidAuth(state.config)],
+          ["daemon_resource", () => finishDaemonProcess(state.config, state.resource_process)]
+        ]);
+      }
+      catch (error) { if (error.code === "tree_not_settled" && !runtime.closed) stopping = false; throw error; }
+    }
+    if (busy || stopping) throw new DroidError("operation_busy", "Another Droid operation is active");
+    busy = operation;
+    try {
+      await save({ active_operation: busy });
+      assertDaemonDispatch(paths.dir);
+      if (operation === "session.create") { if (params.prompt) throw new DroidError("invalid_create", "create does not execute a prompt"); return await runtime.create(request.id); }
+      if (operation === "session.resume") return await runtime.resume(params.sessionId);
+      if (["session.prompt", "session.start"].includes(operation)) return await runtime.prompt(params.sessionId, params.prompt, request.id, params.livenessTimeoutMs ?? runtime.config.inactivityMs);
+      throw new DroidError("unknown_operation", `Unknown Droid operation: ${operation}`);
+    } finally { busy = null; await save({ active_operation: null }); }
+  };
+  await removeSocket(paths.socket);
+  const server = net.createServer(socket => { socket.setEncoding("utf8"); let buffer = "", consumed = false; socket.on("error", () => {}); socket.on("data", chunk => { if (consumed) return; buffer += chunk; if (!admitNativeRequestBuffer(buffer, socket, RESPONSE)) { consumed = true; return; } const at = buffer.indexOf("\n"); if (at < 0) return; consumed = true;
+    void (async () => { let request; try { request = JSON.parse(buffer.slice(0, at)); if (request.schema_id !== REQUEST || typeof request.id !== "string" || typeof request.operation !== "string") throw new DroidError("daemon_protocol", "Malformed Droid daemon request"); let result;
+      if (request.operation === "operation.inspect") {
+        result = request.params?.settle === true ? await settleDaemonOperation(paths.dir, request.params?.operationId) : await inspectDaemonOperation(paths.dir, request.params?.operationId);
+        if (!["completed", "failed"].includes(result.state)) {
+          const recovered = await runtime.recoverOperation(request.params.operationId);
+          if (recovered) {
+            const terminal = { state: "completed", finished_at: new Date().toISOString(), result: recovered };
+            await writeJsonAtomic(`${paths.dir}/operations/${createHash("sha256").update(request.params.operationId).digest("hex")}/result.json`, terminal);
+            result = { ...result, ...terminal };
+          }
+        }
+      } else result = await durableDaemonDispatch(paths.dir, request, () => dispatch(request), () => dispatch({ operation: "session.inspect", params: request.params ?? {} })); const { _shutdown, ...receipt } = result;
+      // Close the listening endpoint before replying. `server.close()` keeps
+      // this already accepted connection alive, so the caller receives its
+      // durable stop receipt while the Unix pathname is atomically retired.
+      // Unlinking it from the request handler races that final response and
+      // can leave a stop caller observing the socket for its whole timeout.
+      if (_shutdown) retireDaemonEndpoint(server);
+      socket.end(`${JSON.stringify({ schema_id: RESPONSE, id: request.id, ok: true, result: receipt })}\n`);
+      } catch (error) { await retireFailedDaemon(server, state, error, save); socket.end(`${JSON.stringify({ schema_id: RESPONSE, id: request?.id, ok: false, error: errorRecord(error) })}\n`); } })();
+  }); });
+  trackDaemonConnections(server);
+  try { await runtime.start(); scheduleDaemonProcessHeartbeat(state.config, state.resource_process); await save({ shutdown_state: "running" }); await new Promise((resolve, reject) => { server.once("error", reject); server.listen(paths.socket, resolve); }); await chmod(paths.socket, 0o600); }
+  catch (error) {
+    let cleanup, cleanupError;
+    try { cleanup = await runtime.closeTree(true); }
+    catch (failure) { cleanupError = errorRecord(failure); error.details = { ...error.details, cleanup_failed: cleanupError }; }
+    try { await removeDroidAuth(state.config); }
+    catch (failure) { error.details = { ...error.details, auth_cleanup_failed: errorRecord(failure) }; }
+    if (!cleanupError) try { await finishDaemonProcess(state.config, state.resource_process, "failed", "startup_failed"); }
+    catch (failure) { error.details = { ...error.details, resource_cleanup_failed: errorRecord(failure) }; }
+    Object.assign(state, { shutdown_state: cleanupError || error.details?.resource_cleanup_failed || error.details?.auth_cleanup_failed ? "cleanup_failed" : "failed", ...(cleanupError ? { cleanup_error: cleanupError } : { cleanup }) });
+    await retainStartupFailure({ state, publish: save, log: paths.log, error });
+    throw error;
+  }
+  await new Promise(resolve => server.once("close", resolve));
+}
+import { authorizeRetainedDaemonResume } from "./driver-recovery.mjs";