nolo-cli 0.1.19 → 0.1.20

package/machineCommands.ts

@@ -1,9 +1,15 @@
-import type { MachineHeartbeat } from "./connector-experimental/protocol";
-import { detectMachineInfo } from "./connector-experimental/machineInfo";
-import { mkdirSync, openSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
+import type { MachineHeartbeat } from "./connector-experimental/protocol";
+import { detectMachineInfo } from "./connector-experimental/machineInfo";
+import { spawn } from "node:child_process";
+import { mkdirSync, openSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
+import {
+  collectConnectorRunArtifact,
+  readConnectorGitHead,
+  resolveConnectorRunCwd,
+} from "./connectorRunArtifact";
 import {
   type HeartbeatLoopOptions,
   runHeartbeatLoop as defaultRunHeartbeatLoop,
@@ -22,11 +28,11 @@ type ConnectorWebSocketOptions = {
   onMessage: (message: string) => void | Promise<void>;
   sentMessages: string[];
 };
-type LocalCliExecutor = (
-  provider: string,
-  prompt: string,
-  options: { model?: string; yolo?: boolean }
-) => Promise<{ text: string; raw?: string; elapsed?: number }>;
+type LocalCliExecutor = (
+  provider: string,
+  prompt: string,
+  options: { model?: string; timeout?: number; cwd?: string; yolo?: boolean; env?: EnvLike }
+) => Promise<{ text: string; raw?: string; elapsed?: number }>;
 
 export type MachineSummary = {
   machineId: string;
@@ -40,12 +46,15 @@ export type MachineSummary = {
   lastSeenAt: number;
 };
 
-type MachineCommandDeps = {
-  env?: EnvLike;
-  output?: OutputLike;
-  fetchImpl?: typeof fetch;
-  machineInfo?: () => MachineHeartbeat;
-  runHeartbeatLoop?: (options: HeartbeatLoopOptions) => Promise<void>;
+type MachineCommandDeps = {
+  env?: EnvLike;
+  output?: OutputLike;
+  cliEntrypointPath?: string;
+  maxConnectorAttempts?: number;
+  sleep?: (ms: number) => Promise<void>;
+  fetchImpl?: typeof fetch;
+  machineInfo?: () => MachineHeartbeat;
+  runHeartbeatLoop?: (options: HeartbeatLoopOptions) => Promise<void>;
   connectWebSocket?: (url: string, options: ConnectorWebSocketOptions) => Promise<void>;
   executeCli?: LocalCliExecutor;
   spawnDaemon?: (args: {
@@ -99,13 +108,17 @@ function resolveConnectAuthToken(args: string[], env: EnvLike) {
   return readOption(args, "--api-key") || readOption(args, "--token") || resolveAuthToken(env);
 }
 
-function resolveDaemonLogPath(env: EnvLike) {
-  return env.NOLO_CONNECT_LOG || join(homedir(), ".nolo", "logs", "connector.log");
-}
-
-function defaultSpawnDaemon(args: {
-  cmd: string[];
-  cwd: string;
+function resolveDaemonLogPath(env: EnvLike) {
+  return env.NOLO_CONNECT_LOG || join(homedir(), ".nolo", "logs", "connector.log");
+}
+
+function buildDaemonCommand(cliEntrypointPath: string | undefined) {
+  return [process.execPath, cliEntrypointPath || import.meta.path, "connect", "--ws"];
+}
+
+function defaultSpawnDaemon(args: {
+  cmd: string[];
+  cwd: string;
   env: EnvLike;
   logPath: string;
 }) {
@@ -114,24 +127,35 @@ function defaultSpawnDaemon(args: {
   const env = Object.fromEntries(
     Object.entries(args.env).filter((entry): entry is [string, string] => typeof entry[1] === "string")
   );
-  const proc = Bun.spawn({
-    cmd: args.cmd,
-    cwd: args.cwd,
-    env,
-    stdin: "ignore",
-    stdout: out,
-    stderr: out,
-  });
-  proc.unref();
-  return { pid: proc.pid };
-}
-
-function resolveHeartbeatIntervalMs(env: EnvLike) {
-  const raw = Number(env.NOLO_CONNECT_HEARTBEAT_MS ?? "");
-  return Number.isFinite(raw) && raw > 0 ? raw : 30_000;
-}
-
-async function defaultConnectWebSocket(url: string, options: ConnectorWebSocketOptions) {
+  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 };
+}
+
+function resolveHeartbeatIntervalMs(env: EnvLike) {
+  const raw = Number(env.NOLO_CONNECT_HEARTBEAT_MS ?? "");
+  return Number.isFinite(raw) && raw > 0 ? raw : 30_000;
+}
+
+const CONNECTOR_WS_KEEPALIVE_MS = 25_000;
+
+function buildConnectorKeepaliveMessage() {
+  return JSON.stringify({ type: "connector.keepalive", sentAt: Date.now() });
+}
+
+const defaultSleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
+
+function resolveConnectorReconnectDelayMs(env: EnvLike) {
+  const raw = Number(env.NOLO_CONNECT_RECONNECT_MS ?? "");
+  return Number.isFinite(raw) && raw >= 0 ? raw : 5_000;
+}
+
+async function defaultConnectWebSocket(url: string, options: ConnectorWebSocketOptions) {
   const WebSocketCtor = globalThis.WebSocket;
   if (!WebSocketCtor) {
     throw new Error("WebSocket is not available in this runtime");
@@ -139,16 +163,34 @@ async function defaultConnectWebSocket(url: string, options: ConnectorWebSocketO
   await new Promise<void>((resolve, reject) => {
     const ws = new WebSocketCtor(url, {
       headers: options.headers,
-    } as any);
-    let opened = false;
-    ws.addEventListener("open", () => {
-      opened = true;
-    }, { once: true });
-    ws.addEventListener("error", () => reject(new Error("connector websocket failed")));
-    ws.addEventListener("close", () => {
-      if (opened) resolve();
-      else reject(new Error("connector websocket closed before opening"));
-    }, { once: true });
+    } as any);
+    let opened = false;
+    let keepalive: ReturnType<typeof setInterval> | null = null;
+    const clearKeepalive = () => {
+      if (keepalive) {
+        clearInterval(keepalive);
+        keepalive = null;
+      }
+    };
+    ws.addEventListener("open", () => {
+      opened = true;
+      keepalive = setInterval(() => {
+        try {
+          ws.send(buildConnectorKeepaliveMessage());
+        } catch {
+          clearKeepalive();
+        }
+      }, CONNECTOR_WS_KEEPALIVE_MS);
+    }, { once: true });
+    ws.addEventListener("error", () => {
+      clearKeepalive();
+      reject(new Error("connector websocket failed"));
+    });
+    ws.addEventListener("close", () => {
+      clearKeepalive();
+      if (opened) resolve();
+      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(() => {
@@ -160,30 +202,96 @@ async function defaultConnectWebSocket(url: string, options: ConnectorWebSocketO
   });
 }
 
-async function defaultExecuteCli(provider: string, prompt: string, options: { model?: string; yolo?: boolean }) {
-  const { executeCli } = await import("./ai/agent/cliExecutor");
-  return executeCli(provider as any, prompt, options);
-}
+async function defaultExecuteCli(
+  provider: string,
+  prompt: string,
+  options: { model?: string; timeout?: number; cwd?: string; yolo?: boolean; env?: EnvLike }
+) {
+  const { executeCli } = await import("./ai/agent/cliExecutor");
+  return executeCli(provider as any, prompt, options);
+}
 
 function detectLaunchableMachineInfo() {
   return detectMachineInfo({ probeLaunchable: true });
 }
 
-function buildConnectorCliPrompt(agentConfig: any, userInput: string) {
-  const policy = resolveMachineRunPermissionPolicy(agentConfig);
-  return [
-    typeof agentConfig?.prompt === "string" ? agentConfig.prompt.trim() : "",
-    buildMachinePermissionPromptBlock(policy),
-    `--- User task ---\n${userInput}`,
-  ].filter(Boolean).join("\n\n");
-}
-
-async function handleConnectorRunMessage(
-  machine: MachineHeartbeat,
-  message: string,
-  send: (message: string) => void,
-  executeCli: LocalCliExecutor
-) {
+function inferTaskRunRole(agentKey: string, agentConfig: any) {
+  const haystack = [
+    agentKey,
+    agentConfig?.name,
+    agentConfig?.prompt,
+  ].filter(Boolean).join("\n").toLowerCase();
+  if (haystack.includes("frontend") || haystack.includes("前端")) return "frontend";
+  if (haystack.includes("fullstack") || haystack.includes("全栈")) return "fullstack";
+  if (haystack.includes("review") || haystack.includes("审查")) return "reviewer";
+  if (haystack.includes("project-manager") || haystack.includes("项目经理")) return "pm";
+  return "codex";
+}
+
+function buildTaskRunBridgePrompt(args: {
+  agentKey: string;
+  agentConfig: any;
+  runtimeContext: any;
+}) {
+  const taskRun = args.runtimeContext?.taskRun;
+  const rowDbKey = typeof taskRun?.rowDbKey === "string" ? taskRun.rowDbKey.trim() : "";
+  if (!rowDbKey) return "";
+  const workItemId = typeof taskRun?.workItemId === "string" ? taskRun.workItemId.trim() : "";
+  const role = inferTaskRunRole(args.agentKey, args.agentConfig);
+  return [
+    "--- Nolo task-run tool bridge ---",
+    "This CLI runtime does not receive server-side function tools directly.",
+    "Use the local task-run bridge command for durable task state writes. Do not edit meta.taskRun with table or database commands.",
+    "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 task context.",
+    "Cost boundary: read taskRun.control from context. Prefer low-cost/free-window models for routine work, and reserve Codex for supervision, quality gates, complex unblocking, and main/release decisions.",
+    `Read context: bun packages/cli/index.ts task-run read-context --row-dbkey ${JSON.stringify(rowDbKey)}`,
+    ...(workItemId
+      ? [
+          `Claim work item: bun packages/cli/index.ts task-run claim-work-item --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --agent-key ${JSON.stringify(args.agentKey)} --role ${role}`,
+          `Set blocker: bun packages/cli/index.ts task-run set-blocker --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --layer tool --code <CODE> --message <MESSAGE>`,
+          `Clear resolved blocker: bun packages/cli/index.ts task-run clear-blocker --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --blocker-id <BLOCKER_ID>`,
+          `Submit outcome: bun packages/cli/index.ts task-run submit-outcome --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --summary <SUMMARY>`,
+          `Request review: bun packages/cli/index.ts task-run request-review --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --reviewer-agent-key <AGENT_KEY> --message <MESSAGE>`,
+          `Record review: bun packages/cli/index.ts task-run record-review --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --review-status <passed|needs_changes|blocked> --reviewer-agent-key ${JSON.stringify(args.agentKey)} --findings <FINDINGS>`,
+          `Close work item: bun packages/cli/index.ts task-run close-work-item --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --summary <SUMMARY>`,
+        ]
+      : []),
+    "If a bridge command fails, report the exact command and error.",
+  ].join("\n");
+}
+
+function buildConnectorCliPrompt(agentConfig: any, userInput: string, bridgeArgs?: {
+  agentKey: string;
+  runtimeContext: any;
+}) {
+  const policy = resolveMachineRunPermissionPolicy(agentConfig);
+  return [
+    typeof agentConfig?.prompt === "string" ? agentConfig.prompt.trim() : "",
+    bridgeArgs ? buildTaskRunBridgePrompt({
+      agentKey: bridgeArgs.agentKey,
+      agentConfig,
+      runtimeContext: bridgeArgs.runtimeContext,
+    }) : "",
+    buildMachinePermissionPromptBlock(policy),
+    `--- User task ---\n${userInput}`,
+  ].filter(Boolean).join("\n\n");
+}
+
+function normalizeConnectorRunTimeoutMs(value: unknown): number | undefined {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return undefined;
+  }
+  return Math.floor(value);
+}
+
+async function handleConnectorRunMessage(
+  machine: MachineHeartbeat,
+  message: string,
+  send: (message: string) => void,
+  executeCli: LocalCliExecutor,
+  runtimeEnv: EnvLike
+) {
   let parsed: any;
   try {
     parsed = JSON.parse(message);
@@ -196,37 +304,124 @@ async function handleConnectorRunMessage(
     if (agentConfig.apiSource !== "cli") {
       throw new Error("Connector can only execute CLI agents. Set the agent apiSource to cli and choose a cliProvider.");
     }
-    const provider = String(agentConfig.cliProvider || "copilot");
-    const policy = resolveMachineRunPermissionPolicy(agentConfig);
-    const userInput = String(parsed.payload?.userInput ?? "");
-    assertMachineRunAllowed(userInput, policy);
-    const result = await executeCli(
-      provider,
-      buildConnectorCliPrompt(agentConfig, userInput),
-      {
-        model: agentConfig.model || undefined,
-        yolo: true,
-      }
-    );
-    send(JSON.stringify({
+    const provider = String(agentConfig.cliProvider || "copilot");
+    const policy = resolveMachineRunPermissionPolicy(agentConfig);
+    const userInput = String(parsed.payload?.userInput ?? "");
+    const timeout = normalizeConnectorRunTimeoutMs(parsed.payload?.timeoutMs);
+    assertMachineRunAllowed(userInput, policy);
+    const cwd = resolveConnectorRunCwd({ env: runtimeEnv, policy });
+    const baseSha = await readConnectorGitHead(cwd);
+    const result = await executeCli(
+      provider,
+      buildConnectorCliPrompt(agentConfig, userInput, {
+        agentKey: String(parsed.payload?.agentKey ?? ""),
+        runtimeContext: parsed.payload?.runtimeContext,
+      }),
+      {
+        model: agentConfig.model || undefined,
+        timeout,
+        cwd,
+        yolo: true,
+        env: {
+          NOLO_SERVER: runtimeEnv.NOLO_SERVER || runtimeEnv.NOLO_SERVER_URL || runtimeEnv.BASE_URL,
+          NOLO_SERVER_URL: runtimeEnv.NOLO_SERVER_URL || runtimeEnv.NOLO_SERVER || runtimeEnv.BASE_URL,
+          BASE_URL: runtimeEnv.BASE_URL || runtimeEnv.NOLO_SERVER || runtimeEnv.NOLO_SERVER_URL,
+          AUTH_TOKEN: runtimeEnv.AUTH_TOKEN || runtimeEnv.AUTH || runtimeEnv.NOLO_MACHINE_API_KEY,
+          NOLO_MACHINE_API_KEY: runtimeEnv.NOLO_MACHINE_API_KEY || runtimeEnv.AUTH_TOKEN || runtimeEnv.AUTH,
+        },
+      }
+    );
+    const artifacts = await collectConnectorRunArtifact({
+      cwd,
+      baseSha,
+      exitStatus: "completed",
+    });
+    send(JSON.stringify({
       type: "agent.run.result",
       requestId: parsed.requestId,
       result: {
-        content: result.text,
-        model: agentConfig.model ?? provider,
-        trace: [{ role: "assistant", content: result.text }],
-      },
-    }));
+        content: result.text,
+        model: agentConfig.model ?? provider,
+        trace: [{ role: "assistant", content: result.text }],
+        artifacts,
+      },
+    }));
   } catch (error) {
     send(JSON.stringify({
       type: "agent.run.result",
       requestId: parsed.requestId,
       error: error instanceof Error ? error.message : String(error),
     }));
-  }
-}
-
-export function formatMachineStatus(machines: MachineSummary[]) {
+  }
+}
+
+async function runConnectorWebSocketSession(options: {
+  env: EnvLike;
+  output: OutputLike;
+  machine: MachineHeartbeat;
+  sendHeartbeat: () => Promise<void>;
+  runHeartbeatLoop: (options: HeartbeatLoopOptions) => Promise<void>;
+  connectWebSocket: (url: string, options: ConnectorWebSocketOptions) => Promise<void>;
+  executeCli: LocalCliExecutor;
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+  authToken: string;
+}) {
+  const sentMessages: string[] = [];
+  const heartbeatAbort = new AbortController();
+  try {
+    await options.sendHeartbeat();
+    options.output.write(
+      `Connector websocket connected: ${options.machine.name} (${options.machine.machineId})\n`
+    );
+    const heartbeatLoopPromise = options.runHeartbeatLoop({
+      intervalMs: resolveHeartbeatIntervalMs(options.env),
+      sendHeartbeat: options.sendHeartbeat,
+      signal: heartbeatAbort.signal,
+    });
+    const wsTarget = await resolveConnectorWebSocketTarget({
+      serverUrl: options.serverUrl,
+      machineId: options.machine.machineId,
+      headers: { Authorization: `Bearer ${options.authToken}` },
+      fetchImpl: options.fetchImpl,
+    });
+    const websocketPromise = options.connectWebSocket(
+      wsTarget,
+      {
+        headers: { Authorization: `Bearer ${options.authToken}` },
+        sentMessages,
+        onMessage: (message) => handleConnectorRunMessage(
+          options.machine,
+          message,
+          (response) => sentMessages.push(response),
+          options.executeCli,
+          {
+            ...options.env,
+            NOLO_SERVER: options.serverUrl,
+            NOLO_SERVER_URL: options.serverUrl,
+            BASE_URL: options.serverUrl,
+            AUTH_TOKEN: options.authToken,
+            NOLO_MACHINE_API_KEY: options.authToken,
+          }
+        ),
+      }
+    );
+    await Promise.race([websocketPromise, heartbeatLoopPromise]);
+    heartbeatAbort.abort();
+    await Promise.allSettled([websocketPromise, heartbeatLoopPromise]);
+    return 0;
+  } catch (error) {
+    heartbeatAbort.abort();
+    options.output.write(
+      `[nolo] Connector websocket failed: ${
+        error instanceof Error ? error.message : String(error)
+      }\n`
+    );
+    return 1;
+  }
+}
+
+export function formatMachineStatus(machines: MachineSummary[]) {
   if (machines.length === 0) {
     return "No connected machines.\nRun `nolo connect` on this computer to register it once.\n";
   }
@@ -273,62 +468,41 @@ export async function runMachineConnectCommand(
     }
   };
 
-  if (hasFlag(args, "--daemon") || hasFlag(args, "--background")) {
-    const logPath = resolveDaemonLogPath(env);
-    const result = (deps.spawnDaemon ?? defaultSpawnDaemon)({
-      cmd: [process.execPath, import.meta.path, "connect", "--ws"],
-      cwd: process.cwd(),
-      env,
-      logPath,
+  if (hasFlag(args, "--daemon") || hasFlag(args, "--background")) {
+    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}\n`);
     return 0;
   }
 
-  if (hasFlag(args, "--ws")) {
-    const sentMessages: string[] = [];
-    const heartbeatAbort = new AbortController();
-    try {
-      await sendHeartbeat();
-      output.write(`Connector websocket connected: ${machine.name} (${machine.machineId})\n`);
-      const heartbeatLoopPromise = (deps.runHeartbeatLoop ?? defaultRunHeartbeatLoop)({
-        intervalMs: resolveHeartbeatIntervalMs(env),
-        sendHeartbeat,
-        signal: heartbeatAbort.signal,
-      });
-      const wsTarget = await resolveConnectorWebSocketTarget({
-        serverUrl,
-        machineId: machine.machineId,
-        headers: { Authorization: `Bearer ${authToken}` },
-        fetchImpl,
-      });
-      const websocketPromise = (deps.connectWebSocket ?? defaultConnectWebSocket)(
-        wsTarget,
-        {
-          headers: { Authorization: `Bearer ${authToken}` },
-          sentMessages,
-          onMessage: (message) => handleConnectorRunMessage(
-            machine,
-            message,
-            (response) => sentMessages.push(response),
-            deps.executeCli ?? defaultExecuteCli
-          ),
-        }
-      );
-      await Promise.race([websocketPromise, heartbeatLoopPromise]);
-      heartbeatAbort.abort();
-      await Promise.allSettled([websocketPromise, heartbeatLoopPromise]);
-      return 0;
-    } catch (error) {
-      heartbeatAbort.abort();
-      output.write(
-        `[nolo] Connector websocket failed: ${
-          error instanceof Error ? error.message : String(error)
-        }\n`
-      );
-      return 1;
-    }
-  }
+  if (hasFlag(args, "--ws")) {
+    const maxAttempts = deps.maxConnectorAttempts ?? Infinity;
+    const sleep = deps.sleep ?? defaultSleep;
+    const reconnectDelayMs = resolveConnectorReconnectDelayMs(env);
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      const exitCode = await runConnectorWebSocketSession({
+        env,
+        output,
+        machine,
+        sendHeartbeat,
+        runHeartbeatLoop: deps.runHeartbeatLoop ?? defaultRunHeartbeatLoop,
+        connectWebSocket: deps.connectWebSocket ?? defaultConnectWebSocket,
+        executeCli: deps.executeCli ?? defaultExecuteCli,
+        fetchImpl,
+        serverUrl,
+        authToken,
+      });
+      if (attempt >= maxAttempts) return exitCode;
+      output.write(`[nolo] Connector websocket disconnected. Reconnecting in ${reconnectDelayMs}ms.\n`);
+      await sleep(reconnectDelayMs);
+    }
+    return 0;
+  }
 
   if (hasFlag(args, "--watch")) {
     output.write(`Connecting machine heartbeat loop: ${machine.name} (${machine.platform}/${machine.arch})\n`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nolo-cli",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "type": "module",
   "description": "Agent-first terminal workspace for Nolo",
   "bin": {
@@ -17,10 +17,13 @@
     "agentRunCommand.ts",
     "authCommands.ts",
     "commandRegistry.ts",
+    "connectorRunArtifact.ts",
     "connectorWebSocketTarget.ts",
     "defaultServer.ts",
     "machineCommands.ts",
+    "taskRunCommand.ts",
     "runtimeModeArgs.ts",
+    "tableCommands.ts",
     "updateCommands.ts",
     "client/**/*.ts",
     "tui/**/*.ts",