nolo-cli 0.8.0 → 0.9.0

package/chunk-7QRKCBOP.js

@@ -0,0 +1,1078 @@
+import {
+  createCliLocalRuntimeAdapter,
+  summarizeEndpoint
+} from "./chunk-LARL2V6G.js";
+import {
+  clipMultilineText
+} from "./chunk-MKMWT7SA.js";
+import {
+  readPipeText,
+  spawnProcess
+} from "./chunk-IDZTNRP2.js";
+import {
+  parseUserIdFromAuthToken
+} from "./chunk-ISNCLGUZ.js";
+import {
+  DEFAULT_NOLO_SERVER_URL
+} from "./chunk-OLZBQWZU.js";
+import {
+  runLocalAgentTurn
+} from "./chunk-XS466O7S.js";
+import {
+  resolveLocalRuntimeEnvFromPolicy
+} from "./chunk-5CS33IBL.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import {
+  asRecordOrEmpty
+} from "./chunk-KX6YBIHG.js";
+import {
+  asTrimmedNonEmptyStringArray
+} from "./chunk-I42VC5KR.js";
+import {
+  asTrimmedString
+} from "./chunk-3EUW3WEO.js";
+import {
+  asOptionalPositiveFiniteNumber
+} from "./chunk-U6VC4MU4.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
+
+// packages/ai/agent/machineRunPermissions.ts
+var DEFAULT_POLICY = {
+  mode: "read_only",
+  allowFilesystemRead: true,
+  allowFilesystemWrite: false,
+  allowShell: false,
+  writableRoots: []
+};
+var WRITE_DENIED = "Machine permission denied: this bound machine agent is read-only for filesystem writes. Enable machine write permission for this agent before asking it to modify files.";
+var SHELL_DENIED = "Machine permission denied: this bound machine agent cannot run arbitrary shell commands. Enable machine shell permission for this agent before asking it to execute commands.";
+function normalizeWritableRoots(value) {
+  return asTrimmedNonEmptyStringArray(value);
+}
+function resolveMachineRunPermissionPolicy(agentConfig) {
+  const runtimeBinding = asRecordOrEmpty(agentConfig?.runtimeBinding);
+  const raw = asRecordOrEmpty(
+    agentConfig?.machinePermissions ?? runtimeBinding.permissions ?? runtimeBinding.machinePermissions
+  );
+  const mode = raw.mode === "full_access" || raw.allowFilesystemWrite === true || raw.allowShell === true ? "full_access" : "read_only";
+  if (mode === "full_access") {
+    return {
+      mode,
+      allowFilesystemRead: raw.allowFilesystemRead !== false,
+      allowFilesystemWrite: true,
+      allowShell: raw.allowShell !== false,
+      writableRoots: normalizeWritableRoots(raw.writableRoots)
+    };
+  }
+  return {
+    ...DEFAULT_POLICY,
+    allowFilesystemRead: raw.allowFilesystemRead !== false
+  };
+}
+var WRITE_INTENT_RE = /\b(write|overwrite|edit|modify|delete|remove|rename|move|create|save|patch|apply patch|mkdir|touch|rm|rmdir|del|erase|copy-item|move-item|remove-item|set-content|add-content|new-item)\b|(\u5199\u5165|\u5199\u6587\u4EF6|\u5220\u9664|\u79FB\u9664|\u91CD\u547D\u540D|\u79FB\u52A8|\u521B\u5EFA|\u65B0\u5EFA|\u4FDD\u5B58|\u4FEE\u6539|\u7F16\u8F91|\u6253\u8865\u4E01|\u5E94\u7528\u8865\u4E01)/i;
+var SHELL_INTENT_RE = /\b(run|execute|exec)\s+(?:a\s+)?(?:shell|command|terminal|powershell|pwsh|bash|zsh|cmd\.exe|npm|bun|node|python|git|curl|wget|ssh|scp|chmod|chown|sudo|tests?|test suite)\b|\b(open|start)\s+(?:a\s+)?(?:shell|terminal)\b|\b(powershell|pwsh|bash|zsh|cmd\.exe|ssh|sudo)\b|(\u8FD0\u884C\u547D\u4EE4|\u6267\u884C\u547D\u4EE4|\u547D\u4EE4\u884C|\u7EC8\u7AEF|\u63A7\u5236\u53F0)/i;
+var NEGATION_RE = /\b(do not|don't|dont|never|no need to|without|非目标|不要|不需要|禁止|无需)\b|[\u4E0D\u975E]/i;
+function stripNegatedPolicySentences(task) {
+  return task.split(/([\n.;!?。；！？])/).reduce((segments, part, index, parts) => {
+    if (index % 2 === 1) return segments;
+    const separator = parts[index + 1] ?? "";
+    const segment = `${part}${separator}`;
+    const mentionsRestrictedAction = WRITE_INTENT_RE.test(segment) || SHELL_INTENT_RE.test(segment);
+    if (mentionsRestrictedAction && NEGATION_RE.test(segment)) return segments;
+    segments.push(segment);
+    return segments;
+  }, []).join("");
+}
+function assertMachineRunAllowed(userInput, policy) {
+  const task = stripNegatedPolicySentences(String(userInput || ""));
+  if (!policy.allowFilesystemWrite && WRITE_INTENT_RE.test(task)) {
+    throw new Error(WRITE_DENIED);
+  }
+  if (!policy.allowShell && SHELL_INTENT_RE.test(task)) {
+    throw new Error(SHELL_DENIED);
+  }
+}
+function buildMachinePermissionPromptBlock(policy) {
+  return [
+    "--- Machine permission policy ---",
+    `Mode: ${policy.mode}`,
+    `Filesystem reads are ${policy.allowFilesystemRead ? "allowed" : "not allowed"}.`,
+    `File writes are ${policy.allowFilesystemWrite ? "allowed" : "not allowed"}.`,
+    `Arbitrary shell commands are ${policy.allowShell ? "allowed" : "not allowed"}.`,
+    policy.writableRoots.length ? `Writable roots: ${policy.writableRoots.join(", ")}` : "Writable roots: none.",
+    "If the user asks for an operation outside this policy, refuse instead of attempting it."
+  ].join("\n");
+}
+
+// packages/cli/connectorRunArtifact.ts
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+var MAX_PATCH_PREVIEW_CHARS = 24e3;
+function normalizePath(value) {
+  return resolve(value.trim());
+}
+function resolveConnectorRunCwd(args) {
+  const explicit = args.env?.NOLO_CONNECTOR_WORKDIR || args.env?.NOLO_AGENT_WORKDIR || "";
+  const candidate = explicit || args.policy.writableRoots[0] || args.fallbackCwd || process.cwd();
+  const cwd = normalizePath(candidate);
+  if (!existsSync(cwd)) {
+    throw new Error(`Connector run cwd does not exist: ${cwd}`);
+  }
+  return cwd;
+}
+async function runGit(args, cwd, options = {}) {
+  const proc = spawnProcess({
+    cmd: ["git", ...args],
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    stdin: "ignore"
+  });
+  const [stdout, exitCode] = await Promise.all([
+    readPipeText(proc.stdout),
+    proc.exited
+  ]);
+  if (exitCode !== 0) return null;
+  return options.trim === false ? stdout.replace(/\r?\n$/, "") : stdout.trim();
+}
+function parseStatusChangedFiles(statusShort) {
+  if (!statusShort) return [];
+  return [...new Set(statusShort.split(/\r?\n/).map((line) => {
+    const porcelainMatch = line.match(/^.{2} (.+)$/);
+    if (porcelainMatch?.[1]) return porcelainMatch[1].trim();
+    const trimmedMatch = line.match(/^[MADRCU?!]{1,2}\s+(.+)$/);
+    return trimmedMatch?.[1]?.trim() ?? "";
+  }).map((line) => line.includes(" -> ") ? line.split(" -> ").at(-1) ?? line : line).filter(Boolean))];
+}
+async function readConnectorGitHead(cwd) {
+  return runGit(["rev-parse", "HEAD"], cwd);
+}
+async function collectConnectorRunArtifact(args) {
+  const collectedAt = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const [headSha, statusShort, diffStat, patchText] = await Promise.all([
+      readConnectorGitHead(args.cwd),
+      runGit(["status", "--short"], args.cwd, { trim: false }),
+      runGit(["diff", "--stat"], args.cwd),
+      runGit(["diff", "--no-color", "--unified=3"], args.cwd)
+    ]);
+    const patchPreview = patchText ? clipMultilineText(patchText, MAX_PATCH_PREVIEW_CHARS) || void 0 : void 0;
+    return {
+      cwd: args.cwd,
+      exitStatus: args.exitStatus,
+      collectedAt,
+      baseSha: args.baseSha ?? null,
+      headSha,
+      changedFiles: parseStatusChangedFiles(statusShort),
+      ...statusShort ? { statusShort } : {},
+      ...diffStat ? { diffStat } : {},
+      ...patchPreview ? { patchPreview } : {},
+      ...args.error ? { error: args.error } : {}
+    };
+  } catch (error) {
+    return {
+      cwd: args.cwd,
+      exitStatus: args.exitStatus,
+      collectedAt,
+      baseSha: args.baseSha ?? null,
+      ...args.error ? { error: args.error } : {},
+      artifactError: toErrorMessage(error)
+    };
+  }
+}
+
+// packages/cli/machineWsPromptMaterialization.ts
+import { createHash } from "node:crypto";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+var CLOUD_PROMPT_PAGE_READ_COMMAND = "bun packages/cli/index.ts doc read";
+function byteLength(value) {
+  return Buffer.byteLength(value, "utf8");
+}
+function shortHash(value) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 12);
+}
+function resolvePromptInlineMaxBytes(env) {
+  const raw = Number(env.NOLO_CONNECTOR_PROMPT_INLINE_MAX_BYTES);
+  return Number.isFinite(raw) && raw >= 1024 ? raw : 32e3;
+}
+function materializeLargeConnectorPrompt(args) {
+  const promptBytes = byteLength(args.prompt);
+  const promptHash = shortHash(args.prompt);
+  const maxInlineBytes = resolvePromptInlineMaxBytes(args.env);
+  if (promptBytes <= maxInlineBytes) {
+    return {
+      prompt: args.prompt,
+      promptBytes,
+      promptHash,
+      promptRef: null
+    };
+  }
+  const promptDir = join(args.cwd, ".nolo", "agent-prompts");
+  mkdirSync(promptDir, { recursive: true });
+  const promptRef = join(promptDir, `${args.requestId}-${promptHash}.md`);
+  writeFileSync(promptRef, args.prompt, "utf8");
+  return {
+    prompt: [
+      "A large Nolo runtime prompt has been materialized outside this command argument.",
+      ...args.runtimePromptPage?.dbKey ? [
+        "Cloud prompt page is the shared audit/context source.",
+        `Cloud prompt page: ${args.runtimePromptPage.dbKey}`,
+        `Read cloud page: ${CLOUD_PROMPT_PAGE_READ_COMMAND} ${JSON.stringify(args.runtimePromptPage.dbKey)}`,
+        ...args.runtimePromptPage.promptHash ? [`Cloud prompt sha256 prefix: ${args.runtimePromptPage.promptHash}`] : [],
+        ""
+      ] : [],
+      "Local prompt file is the execution-machine fallback and should match the cloud page content at run start.",
+      `Prompt file: ${promptRef}`,
+      `Prompt bytes: ${promptBytes}`,
+      `Prompt sha256 prefix: ${promptHash}`,
+      "",
+      "Prefer the cloud prompt page for shared context when readable; use the local prompt file as fallback.",
+      "Local repository edits, diffs, test output, and commits are still authoritative for local execution facts.",
+      "If neither source is readable, stop and report PROMPT_REF_UNREADABLE with both references."
+    ].join("\n"),
+    promptBytes,
+    promptHash,
+    promptRef
+  };
+}
+function readRuntimePromptPageMeta(parsed) {
+  const page = parsed?.payload?.meta?.runtimePromptPage;
+  if (!page || typeof page !== "object") return null;
+  return {
+    dbKey: typeof page.dbKey === "string" ? page.dbKey : void 0,
+    promptHash: typeof page.promptHash === "string" ? page.promptHash : void 0,
+    contentBytes: typeof page.contentBytes === "number" ? page.contentBytes : void 0
+  };
+}
+
+// packages/cli/machineWsRunDispatchPurity.ts
+function logConnectorRun(message, fields = {}) {
+  console.error(`[nolo-connector] ${message} ${JSON.stringify(fields)}`);
+}
+function summarizeRuntimePolicyForLogs(policy) {
+  return {
+    hasPolicy: Boolean(policy),
+    runtimeTools: policy?.runtimeTools ?? [],
+    agentTools: policy?.agentTools ?? [],
+    workspaceMode: policy?.workspace?.mode ?? null,
+    workspaceCwd: policy?.workspace?.cwd ?? null,
+    shellEnabled: policy?.shell?.enabled ?? null
+  };
+}
+function summarizeAgentConfigForLogs(agentConfig) {
+  const config = asRecordOrEmpty(agentConfig);
+  const runtimeBinding = asRecordOrEmpty(config.runtimeBinding);
+  return {
+    apiSource: readField(config, "apiSource") ?? null,
+    provider: readField(config, "provider") ?? null,
+    cliProvider: readField(config, "cliProvider") ?? null,
+    model: readField(config, "model") ?? null,
+    customProviderEndpoint: summarizeEndpoint(readField(config, "customProviderUrl")) ?? null,
+    useServerProxy: readField(config, "useServerProxy") ?? null,
+    skipLocalRuntimeEnsure: readField(config, "skipLocalRuntimeEnsure") ?? null,
+    hasApiKey: isNonEmptyString(readField(config, "apiKey")),
+    apiKeyHeader: readField(config, "apiKeyHeader") ?? null,
+    hasApiKeyFromAgentKey: (() => {
+      const value = readField(config, "apiKeyFromAgentKey");
+      return typeof value === "string" && value.length > 0;
+    })(),
+    runtimeBindingKind: readField(runtimeBinding, "kind") ?? null,
+    runtimeMachineId: readField(runtimeBinding, "machineId") ?? null,
+    connectorSurface: readField(runtimeBinding, "connectorSurface") ?? readField(runtimeBinding, "surface") ?? null
+  };
+}
+function readField(record, key) {
+  if (!isRecord(record)) return void 0;
+  return record[key];
+}
+function runtimePolicyFromConnectorPayload(parsed) {
+  const obj = asRecordOrEmpty(parsed);
+  const payload = asRecordOrEmpty(obj.payload);
+  const meta = asRecordOrEmpty(payload.meta);
+  const fromMeta = readField(meta, "runtimeToolPolicySnapshot");
+  const agentConfig = asRecordOrEmpty(payload.agentConfig);
+  const fromAgent = readField(agentConfig, "runtimeToolPolicy");
+  const policy = isRecord(fromMeta) ? fromMeta : isRecord(fromAgent) ? fromAgent : null;
+  return policy ? policy : void 0;
+}
+function requestsLocalWorkspaceRuntime(policy) {
+  return Boolean(
+    Array.isArray(policy?.runtimeTools) && policy.runtimeTools.length > 0
+  );
+}
+function isMachineBoundLocalCustomProvider(agentConfig) {
+  const config = asRecordOrEmpty(agentConfig);
+  const runtimeBinding = asRecordOrEmpty(config.runtimeBinding);
+  const machineIdRaw = readField(runtimeBinding, "machineId");
+  const machineId = asTrimmedString(machineIdRaw);
+  const providerUrlRaw = readField(config, "customProviderUrl");
+  const providerUrl = asTrimmedString(providerUrlRaw);
+  if (!machineId || !providerUrl) return false;
+  try {
+    const hostname = new URL(providerUrl).hostname.toLowerCase();
+    return hostname === "127.0.0.1" || hostname === "localhost" || hostname === "::1";
+  } catch {
+    return false;
+  }
+}
+function hasExplicitMachinePermissions(agentConfig) {
+  const config = asRecordOrEmpty(agentConfig);
+  const runtimeBinding = asRecordOrEmpty(config.runtimeBinding);
+  return Boolean(
+    isRecord(readField(config, "machinePermissions")) || isRecord(readField(runtimeBinding, "permissions")) || isRecord(readField(runtimeBinding, "machinePermissions")) || isRecord(readField(readField(config, "boundRuntimeMachine"), "permissions"))
+  );
+}
+function runtimeWorkspacePermissionPolicy(runtimePolicy, runtimeEnv, cwd) {
+  if (!requestsLocalWorkspaceRuntime(runtimePolicy)) return null;
+  return {
+    mode: "full_access",
+    allowFilesystemRead: true,
+    allowFilesystemWrite: true,
+    allowShell: Array.isArray(runtimePolicy?.runtimeTools) && runtimePolicy.runtimeTools.includes("execShell"),
+    writableRoots: [cwd]
+  };
+}
+function scopePermissionPolicyToRuntimeWorkspace(policy, runtimePolicy, cwd) {
+  if (!requestsLocalWorkspaceRuntime(runtimePolicy)) return policy;
+  return {
+    ...policy,
+    writableRoots: policy.allowFilesystemWrite ? [cwd] : []
+  };
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function readToolName(item) {
+  if (typeof item === "string") return item;
+  if (!isRecord(item)) return "";
+  const direct = readField(item, "name");
+  if (isNonEmptyString(direct)) return direct;
+  const functionField = readField(item, "function");
+  if (isRecord(functionField)) {
+    const inner = readField(functionField, "name");
+    if (isNonEmptyString(inner)) return inner;
+  }
+  return "";
+}
+function mergeToolNames(...values) {
+  const names = [];
+  for (const value of values) {
+    if (!Array.isArray(value)) continue;
+    for (const item of value) {
+      const name = readToolName(item);
+      if (name && !names.includes(name)) names.push(name);
+    }
+  }
+  return names;
+}
+function localRuntimeEnvFromPolicy(runtimeEnv, policy) {
+  return resolveLocalRuntimeEnvFromPolicy(runtimeEnv, policy);
+}
+function forwardedUserAuthToken(parsed) {
+  const obj = asRecordOrEmpty(parsed);
+  const payload = asRecordOrEmpty(obj.payload);
+  const meta = asRecordOrEmpty(payload.meta);
+  const value = readField(meta, "userAuthToken");
+  return asTrimmedString(value);
+}
+function withForwardedUserAuthToken(runtimeEnv, parsed) {
+  const userAuthToken = forwardedUserAuthToken(parsed);
+  return userAuthToken ? { ...runtimeEnv, AUTH_TOKEN: userAuthToken } : runtimeEnv;
+}
+function runtimeWorkspaceRootFromTrace(trace) {
+  if (!Array.isArray(trace)) return void 0;
+  for (const message of trace) {
+    if (!isRecord(message)) continue;
+    const metadataValue = readField(message, "tool_result_metadata");
+    const metadata = isRecord(metadataValue) ? metadataValue : null;
+    const rootRaw = metadata ? readField(metadata, "workspaceRoot") : void 0;
+    const workspaceRoot = asTrimmedString(rootRaw);
+    if (workspaceRoot) return workspaceRoot;
+  }
+  return void 0;
+}
+function buildArtifactProgress(args) {
+  if (!isRecord(args.artifacts)) return null;
+  const changedFilesRaw = readField(args.artifacts, "changedFiles");
+  const changedFiles = Array.isArray(changedFilesRaw) ? changedFilesRaw : [];
+  const statusShortRaw = readField(args.artifacts, "statusShort");
+  const statusShort = asTrimmedString(statusShortRaw);
+  if (changedFiles.length === 0 && !statusShort) return null;
+  const runtimeToolsRaw = args.runtimePolicy?.runtimeTools;
+  const runtimeTools = Array.isArray(runtimeToolsRaw) ? runtimeToolsRaw : [];
+  const shellTool = runtimeTools.includes("execShell") ? "execShell" : "workspaceArtifact";
+  return {
+    eventType: "tool-result",
+    toolCallCount: 1,
+    toolResultCount: 1,
+    lastToolNames: [shellTool],
+    workspaceRoot: args.workspaceRoot,
+    ...args.workspaceKind ? { workspaceKind: args.workspaceKind } : {},
+    message: statusShort || `${changedFiles.length} changed file(s)`,
+    updatedAt: Date.now()
+  };
+}
+async function defaultRunConnectorLocalRuntimeAgent(args) {
+  const obj = asRecordOrEmpty(args.parsed);
+  const payload = asRecordOrEmpty(obj.payload);
+  const agentKeyRaw = readField(payload, "agentKey");
+  const agentKey = typeof agentKeyRaw === "string" ? agentKeyRaw : "";
+  const agentConfigRaw = readField(payload, "agentConfig");
+  const payloadAgentConfig = asRecordOrEmpty(agentConfigRaw);
+  const policy = runtimePolicyFromConnectorPayload(args.parsed);
+  const toolNames = mergeToolNames(
+    readField(payloadAgentConfig, "toolNames"),
+    readField(payloadAgentConfig, "tools"),
+    policy?.agentTools,
+    policy?.runtimeTools
+  );
+  const apiSourceRaw = readField(payloadAgentConfig, "apiSource");
+  const providerRaw = readField(payloadAgentConfig, "provider");
+  const agentRecord = {
+    ...payloadAgentConfig,
+    dbKey: agentKey,
+    id: agentKey,
+    key: agentKey,
+    apiSource: typeof apiSourceRaw === "string" ? apiSourceRaw : "platform",
+    provider: typeof providerRaw === "string" ? providerRaw : typeof apiSourceRaw === "string" ? apiSourceRaw : "openai",
+    toolNames,
+    ...policy ? { runtimeToolPolicy: policy } : {}
+  };
+  const store = /* @__PURE__ */ new Map([
+    [agentKey, agentRecord],
+    [`agent-${args.runtimeEnv.NOLO_USER_ID || "local"}-${agentKey}`, agentRecord],
+    [`agent-${args.runtimeEnv.NOLO_LOCAL_USER_ID || args.runtimeEnv.NOLO_USER_ID || "local"}-${agentKey}`, agentRecord]
+  ]);
+  const env = localRuntimeEnvFromPolicy(
+    withForwardedUserAuthToken(args.runtimeEnv, args.parsed),
+    policy
+  );
+  logConnectorRun("agent.run.local-runtime.env", {
+    requestId: readField(obj, "requestId"),
+    agentKey,
+    cwd: args.cwd,
+    ...summarizeRuntimePolicyForLogs(policy)
+  });
+  const adapter = createCliLocalRuntimeAdapter({
+    env,
+    cwd: args.cwd,
+    fetchImpl: args.fetchImpl ?? fetch,
+    store: {
+      read: async (key) => store.get(key) ?? null,
+      write: async (key, value) => {
+        store.set(key, value);
+        return value;
+      },
+      batch: async (ops) => {
+        for (const op of ops) {
+          if (op.type === "put") store.set(op.key, op.value);
+        }
+      },
+      iterator: async function* (options) {
+        const keys = [...store.keys()].sort();
+        for (const key of keys) {
+          if (key < options.gte) continue;
+          if (options.lte && key > options.lte) continue;
+          if (options.lt && key >= options.lt) continue;
+          yield [key, store.get(key)];
+        }
+      }
+    }
+  });
+  let toolCallCount = 0;
+  let toolResultCount = 0;
+  const lastToolNames = [];
+  let runtimeWorkspaceRoot;
+  let runtimeWorkspaceKind;
+  const noteToolName = (toolName) => {
+    if (!toolName) return;
+    const existingIndex = lastToolNames.indexOf(toolName);
+    if (existingIndex >= 0) lastToolNames.splice(existingIndex, 1);
+    lastToolNames.push(toolName);
+    while (lastToolNames.length > 8) lastToolNames.shift();
+  };
+  const userInputRaw = readField(payload, "userInput");
+  const continueDialogIdRaw = readField(payload, "continueDialogId");
+  const result = await runLocalAgentTurn({
+    adapter,
+    agentRef: agentKey,
+    input: typeof userInputRaw === "string" ? userInputRaw : "",
+    continueDialogId: typeof continueDialogIdRaw === "string" ? continueDialogIdRaw : void 0,
+    ...args.abortSignal ? { abortSignal: args.abortSignal } : {},
+    onToolEvent: (event) => {
+      if (event.type === "tool-call") toolCallCount += 1;
+      if (event.type === "tool-result") toolResultCount += 1;
+      noteToolName(event.toolName);
+      const metadata = asRecordOrEmpty(event.metadata);
+      const rootRaw = asOptionalTrimmedString(readField(metadata, "workspaceRoot"));
+      if (rootRaw) runtimeWorkspaceRoot = rootRaw;
+      const kindRaw = asOptionalTrimmedString(readField(metadata, "workspaceKind"));
+      if (kindRaw) runtimeWorkspaceKind = kindRaw;
+      args.onProgress?.({
+        eventType: event.type,
+        toolCallCount,
+        toolResultCount,
+        lastToolNames: [...lastToolNames],
+        ...runtimeWorkspaceRoot ? { workspaceRoot: runtimeWorkspaceRoot } : {},
+        ...runtimeWorkspaceKind ? { workspaceKind: runtimeWorkspaceKind } : {},
+        ...event.message ? { message: event.message } : {},
+        updatedAt: Date.now()
+      });
+    }
+  });
+  return {
+    ...result,
+    runtimeWorkspaceRoot: runtimeWorkspaceRootFromTrace(result.trace) ?? runtimeWorkspaceRoot
+  };
+}
+function normalizeConnectorRunTimeoutMs(value) {
+  const finite = asOptionalPositiveFiniteNumber(value);
+  if (finite === void 0) return void 0;
+  return Math.floor(finite);
+}
+function isConnectorUserInput(value) {
+  return Array.isArray(value);
+}
+function readConnectorTextPart(part) {
+  if (!isRecord(part)) return null;
+  const text = readField(part, "text");
+  if (readField(part, "type") === "text" && isNonEmptyString(text)) {
+    return text;
+  }
+  return null;
+}
+function readConnectorImageUrlPart(part) {
+  if (!isRecord(part)) return null;
+  if (readField(part, "type") !== "image_url") return null;
+  const imageUrlValue = readField(part, "image_url");
+  if (!isRecord(imageUrlValue)) return null;
+  const url = readField(imageUrlValue, "url");
+  if (typeof url !== "string" || !url.trim()) return null;
+  return url.trim();
+}
+function extractMultimodalUserInput(userInput) {
+  if (typeof userInput === "string") {
+    return { text: userInput, imageUrls: [] };
+  }
+  if (!isConnectorUserInput(userInput)) {
+    return { text: String(userInput ?? ""), imageUrls: [] };
+  }
+  const textParts = [];
+  const imageUrls = [];
+  for (const part of userInput) {
+    const text = readConnectorTextPart(part);
+    if (text !== null) {
+      textParts.push(text);
+      continue;
+    }
+    const url = readConnectorImageUrlPart(part);
+    if (url !== null) imageUrls.push(url);
+  }
+  return { text: textParts.join("\n"), imageUrls };
+}
+
+// packages/cli/chatgptWebImageLocalJob.ts
+import {
+  mkdirSync as mkdirSync2,
+  readFileSync,
+  statSync,
+  unlinkSync,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join as join2 } from "node:path";
+var CHATGPT_WEB_IMAGE_LOCAL_JOB = "chatgptWebImageGenerate";
+function readChatgptWebImageLocalJobMeta(payload) {
+  if (!isRecord(payload)) return null;
+  const meta = isRecord(payload.meta) ? payload.meta : null;
+  if (!meta || meta.localJob !== CHATGPT_WEB_IMAGE_LOCAL_JOB) return null;
+  const prompt = asTrimmedString(meta.prompt);
+  const userAuthToken = asTrimmedString(meta.userAuthToken);
+  const serverBase = asTrimmedString(meta.serverBase);
+  return {
+    prompt,
+    ...userAuthToken ? { userAuthToken } : {},
+    ...serverBase ? { serverBase } : {}
+  };
+}
+function defaultLockPath(home) {
+  return join2(home, ".nolo", "chatgpt-web-image.lock");
+}
+function defaultOutDir(home) {
+  return join2(home, "nolo-image-lab", "out");
+}
+function acquireChatgptWebImageLock(lockPath) {
+  mkdirSync2(dirname(lockPath), { recursive: true });
+  try {
+    writeFileSync2(lockPath, `${process.pid}
+${Date.now()}
+`, { flag: "wx" });
+  } catch (error) {
+    const code = error && typeof error === "object" && "code" in error ? error.code : void 0;
+    if (code === "EEXIST") {
+      throw new Error("ChatGPT \u7F51\u9875\u751F\u56FE\u4EFB\u52A1\u6B63\u5728\u8FDB\u884C\u4E2D\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5\uFF08\u9501\u6587\u4EF6\u5360\u7528\uFF09");
+    }
+    throw error;
+  }
+  return () => {
+    try {
+      unlinkSync(lockPath);
+    } catch {
+    }
+  };
+}
+async function runOracleGenerateImage(args) {
+  const proc = args.spawn({
+    cmd: [
+      "npx",
+      "-y",
+      "@steipete/oracle",
+      "--engine",
+      "browser",
+      "--browser-manual-login",
+      "--browser-model-strategy",
+      "current",
+      "--generate-image",
+      args.outPath,
+      "-p",
+      args.prompt,
+      "--browser-timeout",
+      "15m",
+      "--browser-input-timeout",
+      "180s"
+    ],
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    proc.exited,
+    readPipeText(proc.stdout),
+    readPipeText(proc.stderr)
+  ]);
+  if (exitCode !== 0) {
+    const detail = (stderr || stdout || "").trim().slice(0, 800);
+    throw new Error(
+      detail ? `ChatGPT \u7F51\u9875\u751F\u56FE\u5931\u8D25\uFF08oracle exit ${exitCode}\uFF09\uFF1A${detail}` : `ChatGPT \u7F51\u9875\u751F\u56FE\u5931\u8D25\uFF08oracle exit ${exitCode}\uFF09`
+    );
+  }
+}
+function assertOutputImage(outPath) {
+  let st;
+  try {
+    st = statSync(outPath);
+  } catch {
+    throw new Error(`ChatGPT \u7F51\u9875\u751F\u56FE\u672A\u4EA7\u51FA\u6587\u4EF6\uFF1A${outPath}`);
+  }
+  if (!st.isFile() || st.size <= 0) {
+    throw new Error(`ChatGPT \u7F51\u9875\u751F\u56FE\u6587\u4EF6\u65E0\u6548\u6216\u4E3A\u7A7A\uFF1A${outPath}`);
+  }
+}
+async function uploadPngToNoloFs(args) {
+  const bytes = readFileSync(args.outPath);
+  const form = new FormData();
+  const fileName = basename(args.outPath) || "chatgpt-web.png";
+  form.append(
+    "file",
+    new Blob([bytes], { type: "image/png" }),
+    fileName
+  );
+  form.append(
+    "metadata",
+    JSON.stringify({
+      type: "file",
+      fileCategory: "image",
+      ownerType: "user",
+      userId: args.userId,
+      source: "chatgpt-web-image",
+      model: "chatgpt-web",
+      prompt: args.prompt,
+      tags: ["ai-generated", "chatgpt-web", "image"]
+    })
+  );
+  form.append("userId", args.userId);
+  form.append("ownerType", "user");
+  form.append("ownerId", args.userId);
+  const base = args.serverBase.replace(/\/+$/, "") || DEFAULT_NOLO_SERVER_URL;
+  const url = `${base}/api/v1/db/upload`;
+  const headers = {};
+  if (args.userAuthToken) {
+    headers.Authorization = `Bearer ${args.userAuthToken}`;
+  }
+  const response = await args.fetchImpl(url, {
+    method: "POST",
+    headers,
+    body: form
+  });
+  const body = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    const errField = body.error;
+    const message = typeof errField === "string" && errField || isRecord(errField) && typeof errField.message === "string" && errField.message || typeof body.details === "string" && body.details || `HTTP ${response.status}`;
+    throw new Error(`\u4E0A\u4F20\u751F\u56FE\u7ED3\u679C\u5230 Nolo FS \u5931\u8D25\uFF1A${message}`);
+  }
+  const fileId = asTrimmedString(body.fileId);
+  if (!fileId) {
+    throw new Error("\u4E0A\u4F20\u751F\u56FE\u7ED3\u679C\u6210\u529F\u4F46\u54CD\u5E94\u7F3A\u5C11 fileId");
+  }
+  const metadata = asRecordOrEmpty(body.metadata);
+  return { fileId, metadata };
+}
+async function runChatgptWebImageLocalJob(input, deps = {}) {
+  const prompt = asTrimmedString(input.prompt);
+  if (!prompt) {
+    throw new Error("\u7F3A\u5C11\u751F\u56FE prompt\uFF08payload.meta.prompt \u5FC5\u586B\uFF09");
+  }
+  const home = (deps.homedir ?? homedir)();
+  const lockPath = deps.lockPath ?? defaultLockPath(home);
+  const outDir = deps.outDir ?? defaultOutDir(home);
+  const release = acquireChatgptWebImageLock(lockPath);
+  try {
+    mkdirSync2(outDir, { recursive: true });
+    const stamp = (deps.now ?? Date.now)();
+    const outPath = join2(outDir, `chatgpt-web-${stamp}.png`);
+    await runOracleGenerateImage({
+      prompt,
+      outPath,
+      spawn: deps.spawn ?? spawnProcess
+    });
+    assertOutputImage(outPath);
+    const userAuthToken = input.userAuthToken?.trim() || "";
+    const userId = parseUserIdFromAuthToken(userAuthToken) || "default";
+    const serverBase = (input.serverBase?.trim() || DEFAULT_NOLO_SERVER_URL).replace(/\/+$/, "");
+    const uploaded = await uploadPngToNoloFs({
+      outPath,
+      prompt,
+      userAuthToken,
+      serverBase,
+      userId,
+      fetchImpl: deps.fetchImpl ?? fetch
+    });
+    const rawData = {
+      text: `\u5DF2\u751F\u6210 1 \u5F20\u56FE\u7247\u3002`,
+      imageCount: 1,
+      files: [
+        {
+          fileId: uploaded.fileId,
+          metadata: {
+            ...uploaded.metadata,
+            prompt,
+            model: "chatgpt-web"
+          }
+        }
+      ]
+    };
+    return {
+      rawData,
+      outPath,
+      fileId: uploaded.fileId
+    };
+  } finally {
+    release();
+  }
+}
+
+// packages/cli/machineWsRunDispatch.ts
+var activeRunAbortControllers = /* @__PURE__ */ new Map();
+async function handleConnectorRunMessage(message, send, executeCli, runtimeEnv, fetchImpl, deps = {}) {
+  let parsed;
+  try {
+    parsed = JSON.parse(message);
+  } catch {
+    return;
+  }
+  if (!isRecord(parsed) || typeof parsed.requestId !== "string") return;
+  const requestId = parsed.requestId;
+  if (parsed.type === "agent.run.cancel") {
+    const controller = activeRunAbortControllers.get(requestId);
+    if (controller) {
+      controller.abort(new Error("agent.run.cancel received from server"));
+    }
+    return;
+  }
+  if (parsed.type !== "agent.run") return;
+  const payload = asRecordOrEmpty(parsed.payload);
+  const agentConfig = asRecordOrEmpty(payload.agentConfig);
+  const runAbortController = new AbortController();
+  activeRunAbortControllers.set(requestId, runAbortController);
+  const sendProgress = (progress) => {
+    send(JSON.stringify({
+      type: "agent.run.progress",
+      requestId,
+      progress
+    }));
+  };
+  const resolveConnectorRunCwd2 = deps.resolveConnectorRunCwd ?? resolveConnectorRunCwd;
+  const resolveMachineRunPermissionPolicy2 = deps.resolveMachineRunPermissionPolicy ?? resolveMachineRunPermissionPolicy;
+  const assertMachineRunAllowed2 = deps.assertMachineRunAllowed ?? assertMachineRunAllowed;
+  const readConnectorGitHead2 = deps.readConnectorGitHead ?? readConnectorGitHead;
+  const collectConnectorRunArtifact2 = deps.collectConnectorRunArtifact ?? collectConnectorRunArtifact;
+  const materializeLargeConnectorPrompt2 = deps.materializeLargeConnectorPrompt ?? materializeLargeConnectorPrompt;
+  const readRuntimePromptPageMeta2 = deps.readRuntimePromptPageMeta ?? readRuntimePromptPageMeta;
+  const runConnectorLocalRuntimeAgent = deps.runConnectorLocalRuntimeAgent ?? defaultRunConnectorLocalRuntimeAgent;
+  const runChatgptWebImageLocalJob2 = deps.runChatgptWebImageLocalJob ?? runChatgptWebImageLocalJob;
+  try {
+    const chatgptWebImageJob = readChatgptWebImageLocalJobMeta(payload);
+    if (chatgptWebImageJob) {
+      logConnectorRun("agent.run.local-job.start", {
+        requestId,
+        localJob: "chatgptWebImageGenerate",
+        agentKey: readField2(payload, "agentKey"),
+        promptBytes: Buffer.byteLength(chatgptWebImageJob.prompt || "", "utf8")
+      });
+      const userAuthToken = chatgptWebImageJob.userAuthToken || forwardedUserAuthToken(parsed) || "";
+      const jobResult = await runChatgptWebImageLocalJob2({
+        prompt: chatgptWebImageJob.prompt,
+        userAuthToken,
+        serverBase: chatgptWebImageJob.serverBase
+      });
+      const galleryRawData = jobResult.rawData;
+      send(JSON.stringify({
+        type: "agent.run.result",
+        requestId,
+        result: {
+          content: JSON.stringify(galleryRawData),
+          model: "chatgpt-web",
+          artifacts: {
+            localJob: "chatgptWebImageGenerate",
+            ...jobResult.outPath ? { outPath: jobResult.outPath } : {},
+            ...jobResult.fileId ? { fileId: jobResult.fileId } : {},
+            imageCount: galleryRawData.imageCount
+          }
+        }
+      }));
+      return;
+    }
+    const machinePermissionPolicy = resolveMachineRunPermissionPolicy2(agentConfig);
+    const runtimePolicy = runtimePolicyFromConnectorPayload(parsed);
+    const extractedInput = extractMultimodalUserInput(payload.userInput);
+    const userInput = extractedInput.text;
+    const connectorImageUrls = extractedInput.imageUrls;
+    const timeout = normalizeConnectorRunTimeoutMs(payload.timeoutMs);
+    let cwd = resolveConnectorRunCwd2({ env: runtimeEnv, policy: machinePermissionPolicy });
+    let runContent = "";
+    let runModel = (() => {
+      const value = readField2(agentConfig, "model");
+      return typeof value === "string" ? value : void 0;
+    })();
+    let runTrace = [];
+    let artifactCwd = cwd;
+    let baseSha = null;
+    if (agentConfig.apiSource === "cli") {
+      if (!deps.buildConnectorCliPrompt) {
+        throw new Error("buildConnectorCliPrompt is required for CLI connector runs.");
+      }
+      const runtimePermissionPolicy = !hasExplicitMachinePermissions(agentConfig) ? runtimeWorkspacePermissionPolicy(runtimePolicy, runtimeEnv, cwd) : null;
+      const effectivePermissionPolicy = scopePermissionPolicyToRuntimeWorkspace(
+        runtimePermissionPolicy ?? machinePermissionPolicy,
+        runtimePolicy,
+        cwd
+      );
+      assertMachineRunAllowed2(userInput, effectivePermissionPolicy);
+      baseSha = await readConnectorGitHead2(artifactCwd);
+      const providerRaw = readField2(agentConfig, "cliProvider");
+      const fallbackProvider = readField2(agentConfig, "provider");
+      const provider = asOptionalTrimmedString(providerRaw) ?? asOptionalTrimmedString(fallbackProvider) ?? "copilot";
+      const finalProvider = provider.trim() || "copilot";
+      const payloadAgentKey = readField2(payload, "agentKey");
+      const payloadRuntimeContext = readField2(payload, "runtimeContext");
+      const builtPrompt = deps.buildConnectorCliPrompt(agentConfig, userInput, {
+        agentKey: typeof payloadAgentKey === "string" ? payloadAgentKey : "",
+        runtimeContext: payloadRuntimeContext
+      }, effectivePermissionPolicy);
+      const materializedPrompt = materializeLargeConnectorPrompt2({
+        prompt: builtPrompt,
+        cwd,
+        env: runtimeEnv,
+        requestId,
+        runtimePromptPage: readRuntimePromptPageMeta2(parsed)
+      });
+      const runtimePromptPage = readRuntimePromptPageMeta2(parsed);
+      const startAt = Date.now();
+      const progressBase = {
+        provider: finalProvider,
+        requestId,
+        promptBytes: materializedPrompt.promptBytes,
+        promptHash: materializedPrompt.promptHash,
+        ...materializedPrompt.promptRef ? { promptRef: materializedPrompt.promptRef } : {},
+        ...runtimePromptPage?.dbKey ? { promptPageKey: runtimePromptPage.dbKey } : {},
+        ...runtimePromptPage?.promptHash ? { promptPageHash: runtimePromptPage.promptHash } : {},
+        workspaceRoot: artifactCwd,
+        workspaceKind: "current"
+      };
+      logConnectorRun("agent.run.cli.start", {
+        requestId,
+        agentKey: payloadAgentKey,
+        provider: finalProvider,
+        cwd,
+        artifactCwd,
+        timeout,
+        promptBytes: materializedPrompt.promptBytes,
+        promptHash: materializedPrompt.promptHash,
+        promptRef: materializedPrompt.promptRef,
+        promptPageKey: runtimePromptPage?.dbKey
+      });
+      sendProgress({
+        ...progressBase,
+        message: "cli-started",
+        updatedAt: startAt
+      });
+      const heartbeat = setInterval(() => {
+        sendProgress({
+          ...progressBase,
+          message: "cli-running",
+          updatedAt: Date.now()
+        });
+      }, 15e3);
+      const effectiveRuntimeEnv = withForwardedUserAuthToken(runtimeEnv, parsed);
+      const reasoningEffortRaw = readField2(agentConfig, "reasoning_effort");
+      const reasoningEffortFallback = readField2(agentConfig, "reasoningEffort");
+      const reasoningEffort = typeof reasoningEffortRaw === "string" && reasoningEffortRaw || typeof reasoningEffortFallback === "string" && reasoningEffortFallback || void 0;
+      const modelValue = readField2(agentConfig, "model");
+      const result2 = await executeCli(finalProvider, materializedPrompt.prompt, {
+        model: typeof modelValue === "string" ? modelValue : void 0,
+        timeout,
+        cwd,
+        yolo: true,
+        ...reasoningEffort ? { reasoningEffort } : {},
+        env: {
+          NOLO_SERVER: effectiveRuntimeEnv.NOLO_SERVER || effectiveRuntimeEnv.NOLO_SERVER_URL || effectiveRuntimeEnv.BASE_URL,
+          NOLO_SERVER_URL: effectiveRuntimeEnv.NOLO_SERVER_URL || effectiveRuntimeEnv.NOLO_SERVER || effectiveRuntimeEnv.BASE_URL,
+          BASE_URL: effectiveRuntimeEnv.BASE_URL || effectiveRuntimeEnv.NOLO_SERVER || effectiveRuntimeEnv.NOLO_SERVER_URL,
+          AUTH_TOKEN: effectiveRuntimeEnv.AUTH_TOKEN || effectiveRuntimeEnv.AUTH || effectiveRuntimeEnv.NOLO_MACHINE_API_KEY,
+          NOLO_MACHINE_API_KEY: effectiveRuntimeEnv.NOLO_MACHINE_API_KEY || effectiveRuntimeEnv.AUTH_TOKEN || effectiveRuntimeEnv.AUTH
+        },
+        ...connectorImageUrls.length > 0 ? { imageInputs: connectorImageUrls.map((url) => ({ source: url })) } : {}
+      }).finally(() => clearInterval(heartbeat));
+      logConnectorRun("agent.run.cli.result", {
+        requestId,
+        provider: finalProvider,
+        elapsed: result2.elapsed,
+        outputBytes: byteLengthLocal(result2.raw ?? result2.text ?? "")
+      });
+      runContent = result2.text;
+      const explicitModel = readField2(agentConfig, "model");
+      runModel = asOptionalTrimmedString(explicitModel) ?? finalProvider;
+      runTrace = [{ role: "assistant", content: result2.text }];
+      const artifacts2 = await collectConnectorRunArtifact2({
+        cwd: artifactCwd,
+        baseSha,
+        exitStatus: "completed"
+      });
+      const artifactProgress2 = buildArtifactProgress({
+        artifacts: artifacts2,
+        runtimePolicy,
+        workspaceRoot: artifactCwd,
+        workspaceKind: "current"
+      });
+      if (artifactProgress2) sendProgress(artifactProgress2);
+      send(JSON.stringify({
+        type: "agent.run.result",
+        requestId,
+        result: {
+          content: runContent,
+          model: runModel,
+          trace: runTrace,
+          artifacts: artifacts2
+        }
+      }));
+      return;
+    }
+    if (!requestsLocalWorkspaceRuntime(runtimePolicy) && !isMachineBoundLocalCustomProvider(agentConfig)) {
+      throw new Error("Connector can only execute non-CLI agents when runtimeToolPolicySnapshot requests a local workspace runtime.");
+    }
+    logConnectorRun("agent.run.local-runtime.start", {
+      requestId,
+      agentKey: readField2(payload, "agentKey"),
+      cwd,
+      timeout,
+      machineBoundLocalCustomProvider: isMachineBoundLocalCustomProvider(agentConfig),
+      runtimePolicy: Boolean(runtimePolicy),
+      ...summarizeAgentConfigForLogs(agentConfig)
+    });
+    baseSha = await readConnectorGitHead2(cwd);
+    const result = await runConnectorLocalRuntimeAgent({
+      parsed,
+      runtimeEnv: withForwardedUserAuthToken(runtimeEnv, parsed),
+      cwd,
+      fetchImpl,
+      onProgress: sendProgress,
+      abortSignal: runAbortController.signal
+    });
+    runContent = result.content;
+    runModel = result.model;
+    runTrace = result.trace ?? [];
+    artifactCwd = result.runtimeWorkspaceRoot ?? cwd;
+    const artifacts = await collectConnectorRunArtifact2({
+      cwd: artifactCwd,
+      baseSha,
+      exitStatus: "completed"
+    });
+    const artifactProgress = buildArtifactProgress({
+      artifacts,
+      runtimePolicy,
+      workspaceRoot: artifactCwd,
+      workspaceKind: "current"
+    });
+    if (artifactProgress) sendProgress(artifactProgress);
+    send(JSON.stringify({
+      type: "agent.run.result",
+      requestId,
+      result: {
+        content: runContent,
+        model: runModel,
+        trace: runTrace,
+        artifacts
+      }
+    }));
+  } catch (error) {
+    logConnectorRun("agent.run.error", {
+      requestId,
+      agentKey: readField2(payload, "agentKey"),
+      ...summarizeAgentConfigForLogs(agentConfig),
+      errorName: error instanceof Error ? error.name : null,
+      error: toErrorMessage(error)
+    });
+    const cancelled = runAbortController.signal.aborted;
+    send(JSON.stringify({
+      type: "agent.run.result",
+      requestId,
+      error: toErrorMessage(error),
+      ...cancelled ? { cancelled: true } : {}
+    }));
+  } finally {
+    if (activeRunAbortControllers.get(requestId) === runAbortController) {
+      activeRunAbortControllers.delete(requestId);
+    }
+  }
+}
+function byteLengthLocal(value) {
+  return Buffer.byteLength(value, "utf8");
+}
+function readField2(record, key) {
+  if (!isRecord(record)) return void 0;
+  return record[key];
+}
+
+export {
+  resolveMachineRunPermissionPolicy,
+  buildMachinePermissionPromptBlock,
+  summarizeAgentConfigForLogs,
+  runtimePolicyFromConnectorPayload,
+  requestsLocalWorkspaceRuntime,
+  isMachineBoundLocalCustomProvider,
+  hasExplicitMachinePermissions,
+  runtimeWorkspacePermissionPolicy,
+  scopePermissionPolicyToRuntimeWorkspace,
+  localRuntimeEnvFromPolicy,
+  buildArtifactProgress,
+  defaultRunConnectorLocalRuntimeAgent,
+  extractMultimodalUserInput,
+  handleConnectorRunMessage
+};