nolo-cli 0.8.0-alpha.2 → 0.8.0-alpha.21

package/machineCommands-RIO3RP5Q.js

@@ -0,0 +1,781 @@
+import {
+  buildMachinePermissionPromptBlock,
+  handleConnectorRunMessage,
+  resolveMachineRunPermissionPolicy
+} from "./chunk-2JCXITPK.js";
+import {
+  isConnectorWebSocketAuthError,
+  isConnectorWebSocketRetryableError,
+  resolveConnectorWebSocketTarget
+} from "./chunk-AVMKZHBC.js";
+import {
+  detectMachineInfo
+} from "./chunk-6HYVJV7B.js";
+import "./chunk-RCSJFQPB.js";
+import "./chunk-EHLHSX7R.js";
+import "./chunk-N54XAP77.js";
+import "./chunk-VHBWHNVT.js";
+import "./chunk-4O3CARJ4.js";
+import "./chunk-CMKUBIGW.js";
+import "./chunk-JBTJAPUF.js";
+import "./chunk-ATNTHIZI.js";
+import "./chunk-FSO5B7GH.js";
+import "./chunk-C3RUNRHT.js";
+import "./chunk-AL2KDGR2.js";
+import "./chunk-GAKEBQD6.js";
+import "./chunk-KQHGZWSV.js";
+import "./chunk-AS4PVWA4.js";
+import "./chunk-3LY4F7SV.js";
+import "./chunk-VP4WJWKW.js";
+import "./chunk-63W5N6P3.js";
+import "./chunk-VF4K2QE6.js";
+import "./chunk-UB6SN4NJ.js";
+import "./chunk-ENOG22KJ.js";
+import "./chunk-VC6OZXO5.js";
+import "./chunk-OWOHNGCN.js";
+import "./chunk-25LCXTML.js";
+import "./chunk-XENYHRUE.js";
+import "./chunk-2ECQG4YX.js";
+import "./chunk-4ZDM73SD.js";
+import "./chunk-MRC4Q34M.js";
+import "./chunk-MTU75CZ2.js";
+import "./chunk-CWMSB67P.js";
+import "./chunk-VUW5FBDB.js";
+import "./chunk-5EFXE3O7.js";
+import "./chunk-Z4NR32XR.js";
+import "./chunk-M76ECQRD.js";
+import "./chunk-SOTZ6RDN.js";
+import "./chunk-I6XMPTMR.js";
+import "./chunk-UAD2WT54.js";
+import "./chunk-DCOA4QSN.js";
+import "./chunk-IDZTNRP2.js";
+import {
+  isCompiledBinary
+} from "./chunk-ISNCLGUZ.js";
+import {
+  DEFAULT_NOLO_SERVER_URL
+} from "./chunk-OLZBQWZU.js";
+import "./chunk-WZSRQNQG.js";
+import "./chunk-O2ZNTTET.js";
+import "./chunk-5KLGBAAR.js";
+import "./chunk-ZNFJWEN4.js";
+import "./chunk-TILFE6LV.js";
+import "./chunk-4QEWT7KD.js";
+import "./chunk-OPZYGHUC.js";
+import "./chunk-AGFH73SK.js";
+import "./chunk-JRKKFRAV.js";
+import "./chunk-P3PKED2I.js";
+import "./chunk-5MMAK75Q.js";
+import "./chunk-BBYVOSU2.js";
+import "./chunk-5CS33IBL.js";
+import "./chunk-JZPBVBIY.js";
+import "./chunk-IWX4UW2E.js";
+import "./chunk-5MIDPSSK.js";
+import "./chunk-DFFIZ25G.js";
+import "./chunk-3ASDTTEI.js";
+import "./chunk-DWLEOOGR.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import "./chunk-H33743XH.js";
+import "./chunk-LM6IYQ3F.js";
+import "./chunk-VX3SXJ3N.js";
+import {
+  parsePositiveFiniteNumberOrFallback
+} from "./chunk-Y5GCAMGP.js";
+import "./chunk-URUUZLPA.js";
+import "./chunk-AZPCASRE.js";
+import "./chunk-7U44LYTR.js";
+import "./chunk-KX6YBIHG.js";
+import "./chunk-O4BU24WZ.js";
+import "./chunk-I42VC5KR.js";
+import "./chunk-WWC7I6TA.js";
+import "./chunk-QSJ3HFEF.js";
+import "./chunk-DSZUWUYB.js";
+import "./chunk-UTLZINAP.js";
+import "./chunk-OOSFSFMA.js";
+import "./chunk-GBRG75BQ.js";
+import "./chunk-4SN6J65J.js";
+import "./chunk-LCBAMY2M.js";
+import {
+  asTrimmedString
+} from "./chunk-3EUW3WEO.js";
+import "./chunk-U6VC4MU4.js";
+import {
+  normalizeServerOrigin
+} from "./chunk-CF7PE763.js";
+import "./chunk-G3SUCT4W.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
+import "./chunk-4VNS5WPM.js";
+
+// packages/connector-experimental/heartbeatLoop.ts
+var defaultSleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+async function runHeartbeatLoop(options) {
+  const sleep = options.sleep ?? defaultSleep;
+  let beats = 0;
+  while (!options.signal?.aborted) {
+    await options.sendHeartbeat();
+    beats += 1;
+    if (options.maxBeats && beats >= options.maxBeats) return;
+    if (options.signal?.aborted) return;
+    await sleep(options.intervalMs);
+  }
+}
+
+// packages/cli/machineDaemonCommands.ts
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var CONNECTOR_RUNTIME_WORKSPACE_PACKAGES = /* @__PURE__ */ new Set([
+  "connector-experimental",
+  "ai"
+]);
+function readJsonFile(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function getWorkspacePatterns(packageJson) {
+  if (Array.isArray(packageJson.workspaces)) return packageJson.workspaces;
+  return packageJson.workspaces?.packages ?? [];
+}
+function normalizePath(path) {
+  const resolved = resolve(path);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function isInsideOrSame(path, parent) {
+  const relativePath = relative(parent, path);
+  return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute(relativePath);
+}
+function findWorkspaceRoot(startPath) {
+  let current = resolve(startPath);
+  while (true) {
+    const packageJsonPath = join(current, "package.json");
+    if (existsSync(packageJsonPath)) {
+      const packageJson = readJsonFile(packageJsonPath);
+      if (packageJson && getWorkspacePatterns(packageJson).length > 0) {
+        return current;
+      }
+    }
+    const parent = dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function listWorkspacePackageJsonFiles(workspaceParent) {
+  let entries;
+  try {
+    entries = readdirSync(workspaceParent, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const results = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+    const relativePath = `${entry.name}/package.json`;
+    if (existsSync(join(workspaceParent, relativePath))) {
+      results.push(relativePath);
+    }
+  }
+  return results;
+}
+function validateConnectorWorkspaceLinks(cwd) {
+  const repoRoot = findWorkspaceRoot(cwd);
+  if (!repoRoot) return [];
+  const rootPackageJson = readJsonFile(join(repoRoot, "package.json"));
+  if (!rootPackageJson) return [];
+  const normalizedRepoRoot = normalizePath(realpathSync(repoRoot));
+  const errors = [];
+  for (const pattern of getWorkspacePatterns(rootPackageJson)) {
+    if (!pattern.endsWith("/*")) continue;
+    const workspaceParent = join(repoRoot, pattern.slice(0, -2));
+    if (!existsSync(workspaceParent)) continue;
+    for (const entry of listWorkspacePackageJsonFiles(workspaceParent)) {
+      const packageDir = join(workspaceParent, dirname(entry));
+      const packageJson = readJsonFile(join(workspaceParent, entry));
+      if (!packageJson?.name || !CONNECTOR_RUNTIME_WORKSPACE_PACKAGES.has(packageJson.name)) {
+        continue;
+      }
+      const linkPath = join(repoRoot, "node_modules", ...packageJson.name.split("/"));
+      if (!existsSync(linkPath)) {
+        errors.push(`${linkPath} is missing. Run bun install in ${repoRoot}.`);
+        continue;
+      }
+      const actualPath = normalizePath(realpathSync(linkPath));
+      const expectedPath = normalizePath(realpathSync(packageDir));
+      if (!isInsideOrSame(actualPath, normalizedRepoRoot)) {
+        errors.push(
+          `${linkPath} points outside this checkout: ${actualPath}. Run bun install in ${repoRoot}.`
+        );
+        continue;
+      }
+      if (actualPath !== expectedPath) {
+        errors.push(
+          `${linkPath} points at ${actualPath}, expected ${expectedPath}. Run bun install in ${repoRoot}.`
+        );
+      }
+    }
+  }
+  return errors;
+}
+async function checkConnectorWorkspaceLinks(cwd, output, validateWorkspaceLinks) {
+  const errors = await validateWorkspaceLinks(cwd);
+  if (errors.length === 0) return true;
+  output.write(
+    [
+      "[nolo] Connector workspace package links are unsafe.",
+      "The connector would import workspace packages from a different checkout, so machine capabilities and runtime behavior may be stale.",
+      ...errors,
+      ""
+    ].join("\n")
+  );
+  return false;
+}
+function resolveDaemonLogPath(env) {
+  return env.NOLO_CONNECT_LOG || join(homedir(), ".nolo", "logs", "connector.log");
+}
+function buildDaemonCommand(cliEntrypointPath) {
+  const execPath = process.execPath;
+  const entrypoint = cliEntrypointPath || fileURLToPath(import.meta.url);
+  if (isCompiledBinary() || entrypoint === execPath) {
+    return [execPath, "connect", "--ws"];
+  }
+  return [execPath, entrypoint, "connect", "--ws"];
+}
+function defaultSpawnDaemon(args) {
+  mkdirSync(dirname(args.logPath), { recursive: true });
+  const out = openSync(args.logPath, "a");
+  const env = Object.fromEntries(
+    Object.entries(args.env).filter((entry) => typeof entry[1] === "string")
+  );
+  const proc = spawn(args.cmd[0], args.cmd.slice(1), {
+    cwd: args.cwd,
+    env,
+    detached: true,
+    stdio: ["ignore", out, out]
+  });
+  proc.unref();
+  return { pid: proc.pid };
+}
+async function runMachineDaemonCommand(deps = {}) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const validateWorkspaceLinks = deps.validateWorkspaceLinks ?? validateConnectorWorkspaceLinks;
+  if (!await checkConnectorWorkspaceLinks(process.cwd(), output, validateWorkspaceLinks)) {
+    return 1;
+  }
+  const logPath = resolveDaemonLogPath(env);
+  const result = (deps.spawnDaemon ?? defaultSpawnDaemon)({
+    cmd: buildDaemonCommand(deps.cliEntrypointPath),
+    cwd: process.cwd(),
+    env,
+    logPath
+  });
+  output.write(`Connector daemon started${result.pid ? ` pid=${result.pid}` : ""}. Log: ${logPath}
+`);
+  return 0;
+}
+
+// packages/cli/machineHeartbeatCommands.ts
+async function runMachineHeartbeatConnectCommand(deps) {
+  const output = deps.output ?? process.stdout;
+  const machine = deps.machine;
+  try {
+    await deps.sendHeartbeat();
+  } catch (error) {
+    output.write(
+      `[nolo] Machine connect failed: ${toErrorMessage(error)}
+`
+    );
+    return 1;
+  }
+  output.write(`Connected machine: ${machine.name} (${machine.platform}/${machine.arch})
+`);
+  return 0;
+}
+
+// packages/cli/machineWatchCommands.ts
+function resolveHeartbeatIntervalMs(env) {
+  return parsePositiveFiniteNumberOrFallback(
+    env.NOLO_CONNECT_HEARTBEAT_MS,
+    3e4
+  );
+}
+async function runMachineWatchCommand(deps) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const machine = deps.machine;
+  output.write(`Connecting machine heartbeat loop: ${machine.name} (${machine.platform}/${machine.arch})
+`);
+  try {
+    await deps.runHeartbeatLoop({
+      intervalMs: resolveHeartbeatIntervalMs(env),
+      sendHeartbeat: deps.sendHeartbeat
+    });
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] Machine heartbeat loop failed: ${toErrorMessage(error)}
+`
+    );
+    return 1;
+  }
+}
+
+// packages/cli/machineWsSession.ts
+var CONNECTOR_WS_KEEPALIVE_MS = 25e3;
+function buildConnectorKeepaliveMessage() {
+  return JSON.stringify({ type: "connector.keepalive", sentAt: Date.now() });
+}
+function resolveHeartbeatIntervalMs2(env) {
+  return parsePositiveFiniteNumberOrFallback(
+    env.NOLO_CONNECT_HEARTBEAT_MS,
+    3e4
+  );
+}
+async function defaultConnectWebSocket(url, options) {
+  const WebSocketCtor = globalThis.WebSocket;
+  if (!WebSocketCtor) {
+    throw new Error("WebSocket is not available in this runtime");
+  }
+  await new Promise((resolve2, reject) => {
+    const ws = new WebSocketCtor(url, {
+      headers: options.headers
+    });
+    let opened = false;
+    let aborted = options.signal?.aborted ?? false;
+    let keepalive = null;
+    const clearKeepalive = () => {
+      if (keepalive) {
+        clearInterval(keepalive);
+        keepalive = null;
+      }
+    };
+    const handleAbort = () => {
+      aborted = true;
+      clearKeepalive();
+      try {
+        ws.close();
+      } catch {
+        resolve2();
+      }
+    };
+    options.signal?.addEventListener("abort", handleAbort, { once: true });
+    ws.addEventListener(
+      "open",
+      () => {
+        opened = true;
+        keepalive = setInterval(() => {
+          try {
+            ws.send(buildConnectorKeepaliveMessage());
+          } catch {
+            clearKeepalive();
+          }
+        }, CONNECTOR_WS_KEEPALIVE_MS);
+      },
+      { once: true }
+    );
+    ws.addEventListener("error", () => {
+      clearKeepalive();
+      if (aborted) {
+        resolve2();
+        return;
+      }
+      reject(new Error("connector websocket failed"));
+    });
+    ws.addEventListener(
+      "close",
+      () => {
+        clearKeepalive();
+        if (opened || aborted) resolve2();
+        else reject(new Error("connector websocket closed before opening"));
+      },
+      { once: true }
+    );
+    ws.addEventListener("message", (event) => {
+      const startIndex = options.sentMessages.length;
+      Promise.resolve(options.onMessage(String(event.data))).then(() => {
+        for (const message of options.sentMessages.slice(startIndex)) {
+          ws.send(message);
+        }
+      }).catch(() => void 0);
+    });
+  });
+}
+async function runMachineWsSession(options) {
+  const sentMessages = [];
+  const heartbeatAbort = new AbortController();
+  let heartbeatLoopPromise = null;
+  let websocketPromise = null;
+  try {
+    if (options.signal?.aborted) {
+      return { exitCode: 0 };
+    }
+    await options.sendHeartbeat();
+    options.output.write(
+      `Connector websocket connected: ${options.machine.name} (${options.machine.machineId})
+`
+    );
+    heartbeatLoopPromise = options.runHeartbeatLoop({
+      intervalMs: resolveHeartbeatIntervalMs2(options.env),
+      sendHeartbeat: options.sendHeartbeat,
+      signal: heartbeatAbort.signal
+    });
+    const heartbeatMonitorPromise = heartbeatLoopPromise.then(() => {
+      if (!heartbeatAbort.signal.aborted) {
+        throw new Error("connector heartbeat loop ended unexpectedly");
+      }
+    });
+    const wsTarget = await options.resolveConnectorWebSocketTarget({
+      serverUrl: options.serverUrl,
+      machineId: options.machine.machineId,
+      connectorSurface: "cli",
+      headers: { Authorization: `Bearer ${options.authToken}` }
+    });
+    websocketPromise = options.connectWebSocket(wsTarget, {
+      headers: { Authorization: `Bearer ${options.authToken}` },
+      signal: options.signal,
+      sentMessages,
+      onMessage: (message) => options.onMessage(message, (response) => {
+        sentMessages.push(response);
+      })
+    });
+    const abortPromise = options.signal ? new Promise((resolve2) => {
+      if (options.signal?.aborted) {
+        resolve2("aborted");
+        return;
+      }
+      options.signal?.addEventListener("abort", () => resolve2("aborted"), { once: true });
+    }) : null;
+    const raceResult = await Promise.race(
+      [websocketPromise, heartbeatMonitorPromise, abortPromise].filter(Boolean)
+    );
+    heartbeatAbort.abort();
+    await Promise.allSettled([websocketPromise, heartbeatLoopPromise]);
+    if (raceResult === "aborted") {
+      return { exitCode: 0 };
+    }
+    return { exitCode: 0 };
+  } catch (error) {
+    heartbeatAbort.abort();
+    await Promise.allSettled(
+      [websocketPromise, heartbeatLoopPromise].filter(Boolean)
+    );
+    if (isConnectorWebSocketAuthError(error)) {
+      options.output.write(
+        `[nolo] Connector websocket auth failed: ${error.message}. Re-register this machine or update NOLO_MACHINE_API_KEY.
+`
+      );
+      return { exitCode: 2 };
+    }
+    if (isConnectorWebSocketRetryableError(error)) {
+      const description = error.reason === "core_draining" ? "core draining" : error.reason;
+      options.output.write(
+        `[nolo] Connector websocket unavailable: ${description} (${error.message}).
+`
+      );
+      return {
+        exitCode: 1,
+        retryAfterMs: error.retryAfterMs,
+        reconnectReason: error.reason
+      };
+    }
+    options.output.write(
+      `[nolo] Connector websocket failed: ${toErrorMessage(error)}
+`
+    );
+    return { exitCode: 1 };
+  }
+}
+
+// packages/cli/machineStatusCommands.ts
+function resolveServerUrl(env) {
+  return normalizeServerOrigin(
+    env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL
+  );
+}
+function resolveAuthToken(env) {
+  return env.AUTH_TOKEN || env.AUTH || "";
+}
+function writeAuthMissing(output) {
+  output.write(
+    "[nolo] Machine commands require an auth token. Run `nolo login` or set AUTH_TOKEN.\n"
+  );
+}
+function formatMachineStatus(machines) {
+  if (machines.length === 0) {
+    return "No connected machines.\nRun `nolo connect` on this computer to register it once.\n";
+  }
+  return [
+    "Connected machines:",
+    ...machines.map((machine) => {
+      const caps = machine.capabilities.length ? machine.capabilities.join(", ") : "no capabilities";
+      const connector = machine.connectorStatus ? `  ws:${machine.connectorStatus}` : "";
+      return `- ${machine.name}  ${machine.status}${connector}  ${machine.platform}/${machine.arch}  ${caps}`;
+    }),
+    ""
+  ].join("\n");
+}
+async function runMachineStatusCommand(_args, deps = {}) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const authToken = resolveAuthToken(env);
+  if (!authToken) {
+    writeAuthMissing(output);
+    return 1;
+  }
+  const serverUrl = resolveServerUrl(env);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  let res;
+  try {
+    res = await fetchImpl(`${serverUrl}/api/machines`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${authToken}`
+      }
+    });
+  } catch (error) {
+    output.write(
+      `[nolo] Machine status failed: ${toErrorMessage(error)}
+`
+    );
+    return 1;
+  }
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    output.write(`[nolo] Machine status failed: HTTP ${res.status}
+${text}
+`);
+    return 1;
+  }
+  const data = await res.json().catch(() => ({ machines: [] }));
+  const machines = Array.isArray(data?.machines) ? data.machines : [];
+  output.write(formatMachineStatus(machines));
+  return 0;
+}
+
+// packages/cli/machineCommands.ts
+function resolveAuthToken2(env) {
+  return env.AUTH_TOKEN || env.AUTH || "";
+}
+function writeAuthMissing2(output) {
+  output.write(
+    "[nolo] Machine commands require an auth token. Run `nolo login` or set AUTH_TOKEN.\n"
+  );
+}
+function hasFlag(args, flag) {
+  return args.includes(flag);
+}
+function readOption(args, flag) {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === flag) {
+      const next = args[i + 1];
+      if (typeof next === "string" && !next.startsWith("-")) return next;
+      return "";
+    }
+    if (arg.startsWith(flag + "=")) {
+      return arg.slice(flag.length + 1);
+    }
+  }
+  return "";
+}
+function resolveConnectServerUrl(args, env) {
+  const fromFlag = readOption(args, "--server-url") || readOption(args, "--server");
+  const raw = fromFlag || env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL;
+  return String(raw).replace(/\/+$|\s+$/g, "").replace(/\/+$/g, "").replace(/\s+$/g, "");
+}
+function resolveConnectAuthToken(args, env) {
+  return readOption(args, "--machine-key") || readOption(args, "--token") || resolveAuthToken2(env);
+}
+var defaultSleep2 = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+async function sleepWithAbort(ms, sleep, signal) {
+  if (!signal) {
+    await sleep(ms);
+    return;
+  }
+  if (signal.aborted) return;
+  await Promise.race([
+    sleep(ms),
+    new Promise((resolve2) => {
+      signal.addEventListener("abort", () => resolve2(), { once: true });
+    })
+  ]);
+}
+function resolveConnectorReconnectDelayMs(env) {
+  const raw = Number(env.NOLO_CONNECT_RECONNECT_MS ?? "");
+  return Number.isFinite(raw) && raw >= 0 ? raw : 5e3;
+}
+async function defaultExecuteCli(provider, prompt, options) {
+  const { executeCli } = await import("./cliExecutor-K3F7DMRO.js");
+  return executeCli(provider, prompt, options);
+}
+function detectLaunchableMachineInfo() {
+  return detectMachineInfo({ probeLaunchable: true });
+}
+function findTaskRowSubjectRef(runtimeContext) {
+  const subjectRefs = Array.isArray(runtimeContext?.subjectRefs) ? runtimeContext.subjectRefs : [];
+  for (const ref of subjectRefs) {
+    if (!isRecord(ref)) continue;
+    if (ref.kind !== "table-row") continue;
+    const id = asTrimmedString(ref.id);
+    if (id) return id;
+  }
+  return "";
+}
+function buildTaskEvidencePrompt(args) {
+  const rowDbKey = findTaskRowSubjectRef(args.runtimeContext);
+  if (!rowDbKey) return "";
+  return [
+    "--- Nolo task evidence context ---",
+    "This CLI runtime does not receive server-side function tools directly.",
+    "Use the task row subjectRef and linked dialog evidence as durable task evidence.",
+    "Run commands from the repository root. The runner already provides server URL and auth in the environment.",
+    "Release boundary: after review passes, AI/reviewer/Codex may advance alpha for verification. Do not merge, push, or release main/release unless the human owner explicitly authorizes it in the current request.",
+    "Handoff context: query dialog.subjectRefs first, then inspect dialog checkpoints, artifacts, commits, and test evidence. Treat row activityRefs/latestActivityRef as cache hints, not state truth.",
+    "Reviewer autonomy: if you are reviewing and find a concrete fix, you may directly dispatch the rework agent/dialog instead of sending the task back to PM first.",
+    "Rework evidence rule: every implementation, review, and rework dialog must preserve the same table-row subjectRef and report any child/rework dialog id it starts.",
+    `Read task row: bun packages/cli/index.ts table query --table meta-0e95801d90-01KWSK4Q4TESXQ06SW39JN2TTJ --row ${JSON.stringify(rowDbKey)} --include-activity --output json`,
+    `Query linked dialogs: bun packages/cli/index.ts dialog query --row-dbkey ${JSON.stringify(rowDbKey)} --json`,
+    "If this run already has a dialog id, exclude it from evidence queries: bun packages/cli/index.ts dialog query --row-dbkey <rowDbKey> --exclude-dialog <currentDialogId> --json",
+    "Then read exact dialog traces with: bun packages/cli/index.ts dialog read <dialogId>",
+    "Reviewers must end with exactly one line: Review decision: approved | needs_changes | blocked",
+    "Report progress, blockers, worktree, branch, commit/diff, tests, and unverified items in the dialog."
+  ].join("\n");
+}
+function buildConnectorCliPrompt(agentConfig, userInput, bridgeArgs, permissionPolicy) {
+  const policy = permissionPolicy ?? resolveMachineRunPermissionPolicy(agentConfig);
+  return [
+    asTrimmedString(agentConfig?.prompt),
+    bridgeArgs ? buildTaskEvidencePrompt({
+      agentKey: bridgeArgs.agentKey,
+      agentConfig,
+      runtimeContext: bridgeArgs.runtimeContext
+    }) : "",
+    buildMachinePermissionPromptBlock(policy),
+    `--- User task ---
+${userInput}`
+  ].filter(Boolean).join("\n\n");
+}
+async function runMachineConnectCommand(args, deps = {}) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const authToken = resolveConnectAuthToken(args, env);
+  if (!authToken) {
+    writeAuthMissing2(output);
+    return 1;
+  }
+  const serverUrl = resolveConnectServerUrl(args, env);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  if (hasFlag(args, "--daemon") || hasFlag(args, "--background")) {
+    return runMachineDaemonCommand({
+      env,
+      output,
+      cliEntrypointPath: deps.cliEntrypointPath,
+      validateWorkspaceLinks: deps.validateWorkspaceLinks,
+      spawnDaemon: deps.spawnDaemon
+    });
+  }
+  const machine = (deps.machineInfo ?? detectLaunchableMachineInfo)();
+  const sendHeartbeat = async () => {
+    const res = await fetchImpl(`${serverUrl}/api/machines/heartbeat`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${authToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(machine)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`HTTP ${res.status}
+${text}`);
+    }
+  };
+  if (hasFlag(args, "--ws")) {
+    const validateWorkspaceLinks = deps.validateWorkspaceLinks ?? (() => []);
+    if (!await checkConnectorWorkspaceLinks(process.cwd(), output, validateWorkspaceLinks)) {
+      return 1;
+    }
+    const maxAttempts = deps.maxConnectorAttempts ?? Infinity;
+    const sleep = deps.sleep ?? defaultSleep2;
+    const reconnectDelayMs = resolveConnectorReconnectDelayMs(env);
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      if (deps.signal?.aborted) {
+        return 0;
+      }
+      const runtimeServerUrl = env.NOLO_CONNECT_RUNTIME_SERVER_URL || env.NOLO_RUNTIME_SERVER_URL || serverUrl;
+      const sessionResult = await runMachineWsSession({
+        env,
+        output,
+        signal: deps.signal,
+        machine,
+        sendHeartbeat,
+        runHeartbeatLoop: deps.runHeartbeatLoop ?? runHeartbeatLoop,
+        connectWebSocket: deps.connectWebSocket ?? defaultConnectWebSocket,
+        serverUrl,
+        authToken,
+        resolveConnectorWebSocketTarget: (options) => resolveConnectorWebSocketTarget({
+          ...options,
+          fetchImpl
+        }),
+        onMessage: (message, send) => handleConnectorRunMessage(
+          message,
+          send,
+          deps.executeCli ?? defaultExecuteCli,
+          {
+            ...env,
+            NOLO_SERVER: runtimeServerUrl,
+            NOLO_SERVER_URL: runtimeServerUrl,
+            BASE_URL: runtimeServerUrl,
+            AUTH_TOKEN: authToken,
+            NOLO_MACHINE_API_KEY: authToken
+          },
+          fetchImpl,
+          {
+            buildConnectorCliPrompt
+          }
+        )
+      });
+      const exitCode = sessionResult.exitCode;
+      if (exitCode === 2) return 1;
+      if (deps.signal?.aborted) {
+        return 0;
+      }
+      if (attempt >= maxAttempts) return exitCode;
+      const retryDelayMs = sessionResult.retryAfterMs ?? reconnectDelayMs;
+      const reconnectContext = sessionResult.reconnectReason === "core_draining" ? " during core draining" : "";
+      output.write(
+        `[nolo] Connector websocket disconnected${reconnectContext}. Reconnecting in ${retryDelayMs}ms.
+`
+      );
+      await sleepWithAbort(retryDelayMs, sleep, deps.signal);
+    }
+    return 0;
+  }
+  if (hasFlag(args, "--watch")) {
+    return runMachineWatchCommand({
+      env,
+      output,
+      machine,
+      sendHeartbeat,
+      runHeartbeatLoop: deps.runHeartbeatLoop ?? runHeartbeatLoop
+    });
+  }
+  return runMachineHeartbeatConnectCommand({
+    output,
+    machine,
+    sendHeartbeat
+  });
+}
+export {
+  formatMachineStatus,
+  runMachineConnectCommand,
+  runMachineStatusCommand
+};