nolo-cli 0.149.0-alpha.1 → 0.151.0-alpha.3

package/{chunk-CFT5HBGW.js → chunk-YVLQXTUB.js}

@@ -1,18 +1,407 @@
 import {
   isAgentRunTerminalStatus,
   normalizeRunTitle
-} from "./chunk-4JMDLJAD.js";
+} from "./chunk-PJNFNEJE.js";
+import {
+  resolvePlatformAuthToken
+} from "./chunk-K2AER7RX.js";
 import {
   isCompiledBinary,
   resolveCliEntrypointPath
 } from "./chunk-A7GB5UGH.js";
 
+// packages/cli/client/originShellApprovalTransport.ts
+import { realpathSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+
+// packages/cli/client/originShellApprovalBridge.ts
+import { isAbsolute } from "node:path";
+var IDENTITY_KEYS = ["runId", "agentKey", "ownerUserId", "deviceId", "workspaceRoot"];
+var CALL_KEYS = [...IDENTITY_KEYS, "toolName", "command", "executionPayload"];
+var MAX_REQUESTS_PER_BRIDGE = 256;
+function createOriginShellApprovalBridge(deps) {
+  const binding = { ...deps.binding };
+  const now = deps.now ?? Date.now;
+  const createRequestId = deps.createRequestId ?? (() => crypto.randomUUID());
+  const timeoutMs = deps.timeoutMs ?? 6e4;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > 3e5) {
+    throw new Error("Shell approval timeout must be finite, > 0 and <= 300000ms");
+  }
+  const requests = /* @__PURE__ */ new Map();
+  const fail = (reason) => ({ ok: false, reason });
+  const snapshot = (request) => ({ ok: true, request: { ...request } });
+  const validIdentity = (call) => {
+    try {
+      return IDENTITY_KEYS.every((key) => typeof call[key] === "string" && call[key].trim().length > 0 && call[key] === binding[key]) && isAbsolute(call.workspaceRoot) && deps.resolveWorkspace(call.workspaceRoot) === binding.workspaceRoot;
+    } catch {
+      return false;
+    }
+  };
+  if (!validIdentity(binding)) throw new Error("Shell approval requires a canonical host binding");
+  const timeout = () => {
+    const time = now();
+    let expired = 0;
+    for (const [id, request] of requests) {
+      if ((request.state === "pending" || request.state === "approved") && (!Number.isFinite(time) || time < request.createdAt || time >= request.expiresAt)) {
+        requests.set(id, { ...request, state: "expired" });
+        expired += 1;
+      }
+    }
+    return expired;
+  };
+  const lookup = (id, call) => {
+    timeout();
+    if (!validIdentity(call)) return fail("identity_mismatch");
+    const request = requests.get(id);
+    if (!request) return fail("unknown_request");
+    if (!CALL_KEYS.every((key) => request[key] === call[key])) return fail("call_mismatch");
+    return snapshot(request);
+  };
+  return {
+    request(call) {
+      timeout();
+      if (!validIdentity(call)) return fail("identity_mismatch");
+      if (typeof call.toolName !== "string" || !call.toolName.trim() || typeof call.command !== "string" || !call.command.trim()) return fail("invalid_request");
+      if (requests.size >= MAX_REQUESTS_PER_BRIDGE) return fail("capacity");
+      const createdAt = now();
+      if (!Number.isFinite(createdAt) || !Number.isFinite(createdAt + timeoutMs)) return fail("invalid_request");
+      let requestId;
+      try {
+        requestId = createRequestId();
+      } catch {
+        return fail("invalid_request");
+      }
+      if (typeof requestId !== "string" || !requestId.trim() || requests.has(requestId)) return fail("invalid_request");
+      const request = {
+        ...binding,
+        toolName: call.toolName,
+        command: call.command,
+        ...call.executionPayload !== void 0 ? { executionPayload: call.executionPayload } : {},
+        requestId,
+        createdAt,
+        expiresAt: createdAt + timeoutMs,
+        state: "pending"
+      };
+      requests.set(requestId, request);
+      return snapshot(request);
+    },
+    decide(id, call, decision) {
+      const result = lookup(id, call);
+      if (!result.ok) return result;
+      if (result.request.state !== "pending") {
+        return fail(result.request.state === "approved" ? "invalid_request" : result.request.state);
+      }
+      if (decision !== "approve" && decision !== "deny") return fail("invalid_request");
+      const request = {
+        ...result.request,
+        state: decision === "approve" ? "approved" : "denied"
+      };
+      requests.set(id, request);
+      return snapshot(request);
+    },
+    revoke() {
+      for (const [id, request] of requests) {
+        if (request.state === "pending" || request.state === "approved") {
+          requests.set(id, { ...request, state: "revoked" });
+        }
+      }
+    },
+    timeout,
+    consume(id, call) {
+      const result = lookup(id, call);
+      if (!result.ok) return result;
+      if (result.request.state !== "approved") return fail(result.request.state);
+      const request = { ...result.request, state: "consumed" };
+      requests.set(id, request);
+      return snapshot(request);
+    }
+  };
+}
+
+// packages/cli/client/originShellApprovalTransport.ts
+var KIND = "nolo.shell-approval.v1";
+var MAX = 256;
+var TTL = 6e4;
+var NOTICE = "Executes with this local user's reachable permissions; workspace is NOT a directory sandbox.";
+function payloadCall(payload, binding) {
+  if (typeof payload !== "string" || payload.length > 262144) throw new Error("Invalid approval payload");
+  const execution = JSON.parse(JSON.parse(payload).binding);
+  if (execution.workspaceRoot !== binding.workspaceRoot || typeof execution.input?.command !== "string") {
+    throw new Error("Approval binding mismatch");
+  }
+  return { ...binding, toolName: "execShell", command: execution.input.command, executionPayload: payload };
+}
+function send(channel, message) {
+  if (channel.connected === false || !channel.send) throw new Error("Approval channel disconnected");
+  channel.send({ kind: KIND, ...message });
+}
+function attachShellApprovalHost(channel, host) {
+  const binding = Object.freeze({ ...host.binding });
+  const bridge = createOriginShellApprovalBridge({ binding, resolveWorkspace: realpathSync });
+  let closed = false;
+  let count = 0;
+  const active = /* @__PURE__ */ new Set();
+  const close = () => {
+    if (closed) return;
+    closed = true;
+    bridge.revoke();
+    for (const controller of active) controller.abort();
+    active.clear();
+    try {
+      send(channel, { type: "revoke" });
+    } catch {
+    }
+    channel.removeListener("message", receive);
+    channel.removeListener("disconnect", close);
+    channel.removeListener("exit", close);
+    channel.removeListener("error", close);
+    host.signal.removeEventListener("abort", close);
+  };
+  const receive = (message) => {
+    if (closed || message?.kind !== KIND) return;
+    if (message.type === "hello") {
+      try {
+        send(channel, { type: "binding", binding });
+      } catch {
+        close();
+      }
+      return;
+    }
+    if (message.type !== "request") return;
+    if (++count > MAX || typeof message.id !== "string" || message.id.length > 100) {
+      close();
+      return;
+    }
+    const id = message.id;
+    void (async () => {
+      let controller;
+      let timer;
+      try {
+        if (message.runId !== binding.runId) throw new Error("Wrong run");
+        const call = payloadCall(message.payload, binding);
+        const pending = bridge.request(call);
+        if (!pending.ok) throw new Error("Request refused");
+        controller = new AbortController();
+        active.add(controller);
+        const cancelled = new Promise((resolve2) => {
+          controller.signal.addEventListener("abort", () => resolve2(false), { once: true });
+        });
+        timer = setTimeout(() => controller.abort(), Math.max(0, pending.request.expiresAt - Date.now()));
+        const approved = await Promise.race([
+          host.confirm({
+            ...binding,
+            toolName: "execShell",
+            command: call.command,
+            expiresAt: pending.request.expiresAt,
+            permissionNotice: NOTICE
+          }, controller.signal),
+          cancelled
+        ]);
+        if (closed || controller.signal.aborted || approved !== true) throw new Error("Not approved");
+        const decided = bridge.decide(pending.request.requestId, call, "approve");
+        const consumed = decided.ok && bridge.consume(pending.request.requestId, call);
+        if (!consumed || !consumed.ok) throw new Error("Approval expired");
+        send(channel, {
+          type: "decision",
+          id,
+          runId: binding.runId,
+          approved: true,
+          ticket: pending.request.requestId,
+          expiresAt: pending.request.expiresAt
+        });
+      } catch {
+        try {
+          if (!closed) send(channel, { type: "decision", id, runId: binding.runId, approved: false });
+        } catch {
+          close();
+        }
+      } finally {
+        if (timer) clearTimeout(timer);
+        if (controller) {
+          controller.abort();
+          active.delete(controller);
+        }
+      }
+    })();
+  };
+  channel.on("message", receive);
+  channel.on("disconnect", close);
+  channel.on("exit", close);
+  channel.on("error", close);
+  host.signal.addEventListener("abort", close, { once: true });
+  if (host.signal.aborted) close();
+  return close;
+}
+function createShellApprovalChild(channel, timeoutMs = TTL) {
+  let closed = false;
+  let binding;
+  let count = 0;
+  const pending = /* @__PURE__ */ new Map();
+  const tickets = /* @__PURE__ */ new Map();
+  const close = () => {
+    if (closed) return;
+    closed = true;
+    tickets.clear();
+    for (const entry of pending.values()) {
+      clearTimeout(entry.timer);
+      entry.reject(new Error("Shell approval revoked"));
+    }
+    pending.clear();
+    channel.removeListener("message", receive);
+    channel.removeListener("disconnect", close);
+  };
+  const receive = (message) => {
+    if (closed || message?.kind !== KIND) return;
+    if (message.type === "revoke") {
+      close();
+      return;
+    }
+    if (message.type === "binding") {
+      if (binding) {
+        close();
+        return;
+      }
+      binding = Object.freeze({ ...message.binding });
+      return;
+    }
+    if (message.type !== "decision") return;
+    const entry = pending.get(message.id);
+    if (!entry) return;
+    pending.delete(message.id);
+    clearTimeout(entry.timer);
+    if (!binding || message.runId !== binding.runId || message.approved !== true || typeof message.ticket !== "string" || !Number.isFinite(message.expiresAt) || message.expiresAt <= Date.now() || message.expiresAt > Date.now() + TTL || tickets.has(message.ticket)) {
+      entry.reject(new Error("Shell approval denied"));
+      return;
+    }
+    tickets.set(message.ticket, { payload: entry.payload, expiresAt: message.expiresAt });
+    entry.resolve(message.ticket);
+  };
+  channel.on("message", receive);
+  channel.on("disconnect", close);
+  try {
+    send(channel, { type: "hello" });
+  } catch {
+    close();
+  }
+  return {
+    close,
+    authority: {
+      async request(payload) {
+        if (++count > MAX) throw new Error("Shell approval capacity exceeded");
+        const deadline = Date.now() + Math.min(timeoutMs, TTL);
+        while (!binding && !closed && Date.now() < deadline) await new Promise((resolve2) => setTimeout(resolve2, 5));
+        if (closed || !binding) throw new Error("Shell approval unavailable");
+        payloadCall(payload, binding);
+        const id = randomUUID();
+        return new Promise((resolve2, reject) => {
+          const timer = setTimeout(() => {
+            pending.delete(id);
+            reject(new Error("Shell approval timeout"));
+          }, Math.min(timeoutMs, TTL));
+          pending.set(id, { payload, resolve: resolve2, reject, timer });
+          try {
+            send(channel, { type: "request", id, runId: binding.runId, payload });
+          } catch {
+            close();
+          }
+        });
+      },
+      consume(ticket, payload) {
+        const entry = tickets.get(ticket);
+        tickets.delete(ticket);
+        if (closed || channel.connected === false || !binding || !entry || entry.payload !== payload || entry.expiresAt <= Date.now()) {
+          throw new Error("Shell approval invalid or revoked");
+        }
+        payloadCall(payload, binding);
+      }
+    }
+  };
+}
+
 // packages/cli/agentRunControl.ts
 import { homedir as nodeHomedir } from "node:os";
-import { dirname, isAbsolute, join, resolve } from "node:path";
+import { dirname, isAbsolute as isAbsolute2, join, resolve } from "node:path";
 import * as nodeFs from "node:fs";
 import { execFileSync as nodeExecFileSync, spawn as nodeSpawn } from "node:child_process";
 
+// packages/cli/client/localRuntimeHelpers.ts
+var REMOTE_DIALOG_SYNC_TIMEOUT_MS = 1e4;
+var remoteDialogSyncTimeoutMsForTest;
+function setRemoteDialogSyncTimeoutForTest(ms) {
+  remoteDialogSyncTimeoutMsForTest = ms;
+}
+function remoteDialogSyncTimeout() {
+  return remoteDialogSyncTimeoutMsForTest ?? REMOTE_DIALOG_SYNC_TIMEOUT_MS;
+}
+function resolveRuntimeServerUrl(env) {
+  return (env?.NOLO_SERVER_URL || env?.NOLO_SERVER || env?.BASE_URL || "").replace(/\/+$/, "");
+}
+function resolveRuntimeAuthToken(env) {
+  return resolvePlatformAuthToken(env ?? {});
+}
+
+// packages/cli/agentRunResultFile.ts
+function resolveResultServerMeta(input) {
+  const serverUrl = resolveRuntimeServerUrl(input.env);
+  const authToken = resolveRuntimeAuthToken(input.env);
+  const syncEnabled = input.userId !== "local" && Boolean(serverUrl) && Boolean(authToken);
+  if (!syncEnabled) {
+    return { server: "local", serverSync: "none" };
+  }
+  return {
+    server: serverOriginForDialog(serverUrl),
+    serverSync: input.hasSubjectRefs === void 0 ? void 0 : input.hasSubjectRefs ? "awaited" : "best-effort"
+  };
+}
+var resultHeaderMeta = /* @__PURE__ */ new WeakMap();
+function recordRunResultHeaderMeta(result, meta) {
+  const clean = {};
+  if (meta.model) clean.model = meta.model;
+  if (meta.dialogServer) clean.dialogServer = meta.dialogServer;
+  if (meta.serverSync) clean.serverSync = meta.serverSync;
+  if (Object.keys(clean).length > 0) resultHeaderMeta.set(result, clean);
+}
+function getRunResultHeaderMeta(result) {
+  return result && resultHeaderMeta.get(result) || {};
+}
+function serverOriginForDialog(serverUrl) {
+  const raw = serverUrl?.trim();
+  if (!raw) return "local";
+  try {
+    return new URL(raw).origin;
+  } catch {
+    return raw.replace(/\/+$/, "") || "local";
+  }
+}
+function yamlScalar(value) {
+  return typeof value === "number" ? String(value) : JSON.stringify(value);
+}
+function buildResultFrontMatter(input) {
+  const entries = [
+    ["runId", input.runId],
+    ["status", input.status],
+    ["agentName", input.agentName],
+    ["model", input.model],
+    ["startedAt", input.startedAt],
+    ["endedAt", input.endedAt],
+    ["durationMs", input.durationMs],
+    ["toolCallCount", input.toolCallCount],
+    ["dialogId", input.dialogId],
+    ["server", input.server],
+    ["serverSync", input.serverSync],
+    ["cwd", input.cwd],
+    ["continuedFrom", input.continuedFrom]
+  ];
+  const lines = entries.filter(([, v]) => v !== void 0 && v !== "").map(([k, v]) => `${k}: ${yamlScalar(v)}`);
+  return `---
+${lines.join("\n")}
+---
+`;
+}
+function buildResultFileContent(input, body) {
+  return `${buildResultFrontMatter(input)}${body}`;
+}
+
 // packages/ai/tools/agent/runFailureClass.ts
 var RATE_LIMIT_PATTERN = /429|rate.?limit|quota|insufficient.?balance|UPSTREAM_402|cooling|冷却/i;
 var PROVIDER_ERROR_PATTERN = /provider|upstream|5\d\d|bad.?gateway|service.?unavailable|overloaded/i;
@@ -676,6 +1065,7 @@ async function gcRunRecords(deps = {}, options = {}) {
     const runsDirForLegacy = resolveRunsDir(deps.env, deps.homedir);
     tryUnlinkFile(fs, join(runsDirForLegacy, `${record.runId}.report.md`));
     tryUnlinkFile(fs, join(runsDirForLegacy, `${record.runId}.report.json`));
+    tryUnlinkFile(fs, record.resultFile ?? join(runsDirForLegacy, `${record.runId}.result.md`));
     if (!logOk || !msgOk || !queueOk) {
       failedIds.push(record.runId);
       continue;
@@ -716,7 +1106,7 @@ function stripBackgroundFlag(args) {
 function absolutizeSkillArgs(args, baseCwd = process.cwd()) {
   const result = [];
   const resolveIfPath = (value) => {
-    if (isAbsolute(value)) return value;
+    if (isAbsolute2(value)) return value;
     const looksLikePath = value.includes("/") || value.endsWith(".md");
     return looksLikePath ? resolve(baseCwd, value) : value;
   };
@@ -855,7 +1245,8 @@ async function spawnLocalBackgroundRun(input, deps = {}) {
     ...typeof input.parentDialogId === "string" && input.parentDialogId.trim() ? { parentDialogId: input.parentDialogId.trim() } : {},
     ...dodCommands && dodCommands.length > 0 ? { dodCommands } : {},
     ...spawnHead ? { spawnHead } : {},
-    ...input.ephemeral ? { ephemeral: true } : {}
+    ...input.ephemeral ? { ephemeral: true } : {},
+    ...typeof input.continuedFrom === "string" && input.continuedFrom.trim() ? { continuedFrom: input.continuedFrom.trim() } : {}
   };
   fs.writeFileSync(recordPath, JSON.stringify(record, null, 2));
   const rawArgsWithQueue = (input.rawArgs ?? []).some(
@@ -880,8 +1271,17 @@ async function spawnLocalBackgroundRun(input, deps = {}) {
     cwd: input.cwd,
     env: childEnv,
     detached: true,
-    stdio: ["ignore", logFd, logFd]
+    stdio: deps.shellApprovalHost ? ["ignore", logFd, logFd, "ipc"] : ["ignore", logFd, logFd]
   });
+  if (deps.shellApprovalHost) {
+    attachShellApprovalHost(proc, { ...deps.shellApprovalHost, binding: {
+      ...deps.shellApprovalHost.binding,
+      runId,
+      agentKey: input.agentKey,
+      workspaceRoot: nodeFs.realpathSync(input.cwd ?? process.cwd())
+    } });
+    proc.channel?.unref?.();
+  }
   proc.unref();
   if (typeof proc.pid === "number") {
     const processStartedAt = (deps.getProcessStartTime ?? defaultGetProcessStartTime)(proc.pid);
@@ -998,17 +1398,37 @@ function transitionRunToTerminal(runId, update, deps = {}, options = {}) {
     }
     if (typeof update.lastAssistantText === "string" && update.lastAssistantText) {
       record2.lastAssistantText = update.lastAssistantText.slice(0, 2e3);
-    } else if (!record2.lastAssistantText && record2.msgFile) {
+    }
+    record2.endedAt = now().toISOString();
+    if (typeof update.lastAssistantText === "string" && update.lastAssistantText) {
       try {
         const fs = deps.fs ?? nodeFs;
-        if (fs.existsSync(record2.msgFile)) {
-          const content = fs.readFileSync(record2.msgFile, "utf8");
-          if (content) record2.lastAssistantText = content.slice(0, 2e3);
-        }
+        const resultFile = join(resolveRunsDir(deps.env, deps.homedir), `${runId}.result.md`);
+        const startedMs = Date.parse(record2.startedAt);
+        const endedMs = Date.parse(record2.endedAt);
+        const content = buildResultFileContent(
+          {
+            runId,
+            status: record2.status,
+            agentName: record2.agentName,
+            model: update.model,
+            startedAt: record2.startedAt,
+            endedAt: record2.endedAt,
+            ...Number.isFinite(startedMs) && Number.isFinite(endedMs) ? { durationMs: Math.max(0, endedMs - startedMs) } : {},
+            toolCallCount: record2.toolCallCount,
+            dialogId: record2.dialogId,
+            server: update.dialogServer ?? "local",
+            serverSync: update.serverSync,
+            cwd: record2.cwd,
+            continuedFrom: record2.continuedFrom
+          },
+          update.lastAssistantText
+        );
+        fs.writeFileSync(resultFile, content, "utf8");
+        record2.resultFile = resultFile;
       } catch {
       }
     }
-    record2.endedAt = now().toISOString();
     if (typeof update.note === "string" && update.note.trim()) {
       record2.note = update.note.trim();
     }
@@ -1059,7 +1479,14 @@ function defaultGetProcessStartTime(pid) {
     const output = nodeExecFileSync("ps", ["-o", "lstart=", "-p", String(pid)], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
-      timeout: 1e3
+      timeout: 1e3,
+      // `ps -o lstart` 的日期串随系统 locale 变化：
+      //   LANG=en_US.UTF-8 → "Thu Oct  8 08:54:18 2026"（new Date 可解析）
+      //   LANG=zh_CN.UTF-8 → "四 10月  8 08:54:18 2026"（new Date → NaN → null）
+      // 这会让 isPidReused 的结论依赖调用者环境：同一条 run 记录在英文
+      // locale 下被判 pid reused → orphaned，中文 locale 下不判。强制 C
+      // locale 让输出恒为可解析的英文格式，结果与 locale 无关。
+      env: { ...process.env, LC_ALL: "C", LANG: "C" }
     }).trim();
     if (!output) return null;
     const d = new Date(output);
@@ -1543,6 +1970,15 @@ async function runAgentKillCommand(args, deps) {
 }
 
 export {
+  createShellApprovalChild,
+  setRemoteDialogSyncTimeoutForTest,
+  remoteDialogSyncTimeout,
+  resolveRuntimeServerUrl,
+  resolveRuntimeAuthToken,
+  resolveResultServerMeta,
+  recordRunResultHeaderMeta,
+  getRunResultHeaderMeta,
+  serverOriginForDialog,
   RUN_TERMINAL_STATUSES,
   isRunTerminalStatus,
   resolveNoloHome,