nolo-cli 0.1.32 → 0.1.33

package/machineWatchCommands.ts

@@ -1,8 +1,8 @@
 import type { MachineHeartbeat } from "./connector-experimental/protocol";
 import type { HeartbeatLoopOptions } from "./connector-experimental/heartbeatLoop";
-import type { OutputLike } from "./cliIoTypes";
 
 type EnvLike = Record<string, string | undefined>;
+type OutputLike = { write(chunk: string): unknown };
 
 function resolveHeartbeatIntervalMs(env: EnvLike) {
   const raw = Number(env.NOLO_CONNECT_HEARTBEAT_MS ?? "");

package/machineWsRunDispatch.ts

@@ -1,6 +1,4 @@
 import { runLocalAgentTurn, type LocalAgentToolEvent } from "./agent-runtime/localLoop";
-import { resolveHostRuntimeConfigFromEnv } from "./agent-runtime/hostRuntimeConfig";
-import { normalizeAgentRunDialogLineage } from "./ai/agent/agentRunDialogLineage";
 import {
   assertMachineRunAllowed as defaultAssertMachineRunAllowed,
   resolveMachineRunPermissionPolicy as defaultResolveMachineRunPermissionPolicy,
@@ -58,7 +56,7 @@ type ConnectorRunProgress = {
 
 type PermissionPolicy = ReturnType<typeof defaultResolveMachineRunPermissionPolicy>;
 
-export type MachineWsRunDispatchDeps = {
+type MachineWsRunDispatchDeps = {
   assertMachineRunAllowed?: typeof defaultAssertMachineRunAllowed;
   resolveMachineRunPermissionPolicy?: typeof defaultResolveMachineRunPermissionPolicy;
   resolveConnectorRunCwd?: typeof defaultResolveConnectorRunCwd;
@@ -150,7 +148,6 @@ function hasExplicitMachinePermissions(agentConfig: any) {
 
 function runtimeWorkspacePermissionPolicy(
   runtimePolicy: ConnectorRuntimePolicy | undefined,
-  hostRuntimeConfig: { capabilities: { allowShell: boolean } },
   cwd: string
 ): PermissionPolicy | null {
   if (!requestsTaskWorktree(runtimePolicy)) return null;
@@ -158,10 +155,7 @@ function runtimeWorkspacePermissionPolicy(
     mode: "full_access",
     allowFilesystemRead: true,
     allowFilesystemWrite: true,
-    allowShell:
-      hostRuntimeConfig.capabilities.allowShell &&
-      Array.isArray(runtimePolicy?.runtimeTools) &&
-      runtimePolicy.runtimeTools.includes("execShell"),
+    allowShell: runtimePolicy?.shell?.enabled !== false,
     writableRoots: [cwd],
   };
 }
@@ -199,6 +193,9 @@ function mergeToolNames(...values: unknown[]) {
 function localRuntimeEnvFromPolicy(runtimeEnv: EnvLike, policy?: ConnectorRuntimePolicy): EnvLike {
   return {
     ...runtimeEnv,
+    ...(policy?.shell?.enabled && policy.shell.mode === "worktree"
+      ? { NOLO_LOCAL_SHELL_MODE: "worktree" }
+      : {}),
     ...(policy?.workspace?.cwd ? { NOLO_LOCAL_WORKTREE: policy.workspace.cwd } : {}),
   };
 }
@@ -272,12 +269,6 @@ async function defaultRunConnectorLocalRuntimeAgent(args: {
     ? args.parsed.payload.agentConfig
     : {};
   const policy = runtimePolicyFromConnectorPayload(args.parsed);
-  const wantsTaskWorktree = requestsTaskWorktree(policy);
-  const hostRuntimeConfig = resolveHostRuntimeConfigFromEnv({
-    env: args.runtimeEnv,
-    surface: "connector-local",
-    workspaceBinding: wantsTaskWorktree ? "default-cwd" : "explicit-cwd",
-  });
   const agentRecord = {
     ...payloadAgentConfig,
     dbKey: agentKey,
@@ -303,10 +294,11 @@ async function defaultRunConnectorLocalRuntimeAgent(args: {
     withForwardedUserAuthToken(args.runtimeEnv, args.parsed),
     policy
   );
+  const wantsTaskWorktree = requestsTaskWorktree(policy);
   const adapter = createCliLocalRuntimeAdapter({
     env,
-    hostRuntimeConfig,
     cwd: args.cwd,
+    useCwdAsTaskWorkspaceBase: wantsTaskWorktree,
     ...(wantsTaskWorktree
       ? {
           prepareTaskWorktree: (input) => prepareTaskWorktree({
@@ -389,20 +381,6 @@ function normalizeConnectorRunTimeoutMs(value: unknown): number | undefined {
   return Math.floor(value);
 }
 
-function normalizeConnectorRunPayloadContinueDialogId(payload: unknown) {
-  if (!isRecord(payload)) return payload;
-  const dialogLineage = normalizeAgentRunDialogLineage({
-    continueDialogId: payload.continueDialogId,
-  });
-  const normalizedPayload = { ...payload };
-  if (dialogLineage.continueDialogId) {
-    normalizedPayload.continueDialogId = dialogLineage.continueDialogId;
-  } else {
-    delete normalizedPayload.continueDialogId;
-  }
-  return normalizedPayload;
-}
-
 export async function handleConnectorRunMessage(
   message: string,
   send: (message: string) => void,
@@ -418,12 +396,6 @@ export async function handleConnectorRunMessage(
     return;
   }
   if (parsed?.type !== "agent.run" || typeof parsed.requestId !== "string") return;
-  if (isRecord(parsed)) {
-    parsed = {
-      ...parsed,
-      payload: normalizeConnectorRunPayloadContinueDialogId(parsed.payload),
-    };
-  }
   const agentConfig = parsed.payload?.agentConfig ?? {};
   const sendProgress = (progress: ConnectorRunProgress) => {
     send(JSON.stringify({
@@ -451,11 +423,6 @@ export async function handleConnectorRunMessage(
   try {
     const machinePermissionPolicy = resolveMachineRunPermissionPolicy(agentConfig);
     const runtimePolicy = runtimePolicyFromConnectorPayload(parsed);
-    const hostRuntimeConfig = resolveHostRuntimeConfigFromEnv({
-      env: runtimeEnv,
-      surface: agentConfig.apiSource === "cli" ? "connector-cli" : "connector-local",
-      workspaceBinding: requestsTaskWorktree(runtimePolicy) ? "default-cwd" : "explicit-cwd",
-    });
     const userInput = String(parsed.payload?.userInput ?? "");
     const timeout = normalizeConnectorRunTimeoutMs(parsed.payload?.timeoutMs);
     let cwd = resolveConnectorRunCwd({ env: runtimeEnv, policy: machinePermissionPolicy });
@@ -478,7 +445,7 @@ export async function handleConnectorRunMessage(
         artifactCwd = prepared.path;
       }
       const runtimePermissionPolicy = !hasExplicitMachinePermissions(agentConfig)
-        ? runtimeWorkspacePermissionPolicy(runtimePolicy, hostRuntimeConfig, cwd)
+        ? runtimeWorkspacePermissionPolicy(runtimePolicy, cwd)
         : null;
       const effectivePermissionPolicy = scopePermissionPolicyToRuntimeWorkspace(
         runtimePermissionPolicy ?? machinePermissionPolicy,
@@ -536,18 +503,17 @@ export async function handleConnectorRunMessage(
           updatedAt: Date.now(),
         });
       }, 15_000);
-      const effectiveRuntimeEnv = withForwardedUserAuthToken(runtimeEnv, parsed);
       const result = await executeCli(provider, materializedPrompt.prompt, {
         model: agentConfig.model || undefined,
         timeout,
         cwd,
         yolo: true,
         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,
+          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,
         },
       }).finally(() => clearInterval(heartbeat));
       logConnectorRun("agent.run.cli.result", {
@@ -589,7 +555,7 @@ export async function handleConnectorRunMessage(
     baseSha = await readConnectorGitHead(cwd);
     const result = await runConnectorLocalRuntimeAgent({
       parsed,
-      runtimeEnv: withForwardedUserAuthToken(runtimeEnv, parsed),
+      runtimeEnv,
       cwd,
       fetchImpl,
       onProgress: sendProgress,

package/machineWsSession.ts

@@ -119,7 +119,6 @@ export async function runMachineWsSession(options: {
   resolveConnectorWebSocketTarget: (args: {
     serverUrl: string;
     machineId: string;
-    connectorSurface?: string;
     headers: Record<string, string>;
   }) => Promise<string>;
   connectWebSocket: (url: string, options: ConnectorWebSocketOptions) => Promise<void>;
@@ -150,7 +149,6 @@ export async function runMachineWsSession(options: {
     const wsTarget = await options.resolveConnectorWebSocketTarget({
       serverUrl: options.serverUrl,
       machineId: options.machine.machineId,
-      connectorSurface: "cli",
       headers: { Authorization: `Bearer ${options.authToken}` },
     });
     websocketPromise = options.connectWebSocket(wsTarget, {

package/offlineMarxistsAgentCommand.ts

@@ -0,0 +1,314 @@
+import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
+
+type EnvLike = Record<string, string | undefined>;
+
+type OutputLike = {
+  write(chunk: string): unknown;
+};
+
+type SetupOfflineMarxistsAgentDeps = {
+  env?: EnvLike;
+  output?: OutputLike;
+  fetchImpl?: typeof fetch;
+  now?: () => number;
+};
+
+type ParsedArgs = {
+  serverUrl: string;
+  authToken: string;
+  userId: string;
+  sourceAgentKey: string;
+  targetAgentId: string;
+  targetAgentKey: string;
+  spaceId: string;
+  name: string;
+  publicAgent: boolean;
+  json: boolean;
+};
+
+const DEFAULT_USER_ID = "b2e06f801f";
+const DEFAULT_SPACE_ID = "01KKY77TT0DA9NY7TNW3R7255N";
+const DEFAULT_SOURCE_AGENT_ID = "01MIMO25MONTH00000001PGT4X";
+const DEFAULT_TARGET_AGENT_ID = "01OFFMARXBOOK000000010AHL1";
+const DEFAULT_AGENT_NAME = "离线马克思主义文库书籍转换助手";
+const TOOL_NAME = "convertMarxistsBookToOfflineHtml";
+const AGENT_TOOLS = [TOOL_NAME];
+
+function readFlagValue(args: string[], flag: string) {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : undefined;
+}
+
+function parseUserIdFromToken(token: string) {
+  const payload = token.split(".")[0];
+  if (!payload) return "";
+  try {
+    const normalized = payload.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = normalized + "=".repeat((4 - (normalized.length % 4)) % 4);
+    const parsed = JSON.parse(Buffer.from(padded, "base64").toString("utf8"));
+    return typeof parsed?.userId === "string" ? parsed.userId : "";
+  } catch {
+    return "";
+  }
+}
+
+function normalizeBaseUrl(value: string) {
+  return value.trim().replace(/\/+$/, "");
+}
+
+function parseArgs(args: string[], env: EnvLike): ParsedArgs | null {
+  if (args.includes("--help") || args.includes("-h")) return null;
+  const serverUrl = normalizeBaseUrl(
+    readFlagValue(args, "--server") ??
+      readFlagValue(args, "--server-url") ??
+      env.NOLO_SERVER ??
+      env.BASE_URL ??
+      DEFAULT_NOLO_SERVER_URL
+  );
+  const authToken = readFlagValue(args, "--token") ?? env.AUTH_TOKEN ?? env.NOLO_AUTH_TOKEN ?? "";
+  const userId =
+    readFlagValue(args, "--user-id") ??
+    env.NOLO_USER_ID ??
+    parseUserIdFromToken(authToken) ??
+    DEFAULT_USER_ID;
+  const sourceAgentKey =
+    readFlagValue(args, "--source-agent") ??
+    env.NOLO_MIMO_SOURCE_AGENT_KEY ??
+    `agent-${userId}-${DEFAULT_SOURCE_AGENT_ID}`;
+  const targetAgentId =
+    readFlagValue(args, "--target-agent-id") ??
+    env.NOLO_OFFLINE_MARXISTS_AGENT_ID ??
+    DEFAULT_TARGET_AGENT_ID;
+  const targetAgentKey =
+    readFlagValue(args, "--target-agent") ??
+    env.NOLO_OFFLINE_MARXISTS_AGENT_KEY ??
+    `agent-${userId}-${targetAgentId}`;
+  const spaceId =
+    readFlagValue(args, "--space") ??
+    env.NOLO_OFFLINE_MARXISTS_SPACE_ID ??
+    DEFAULT_SPACE_ID;
+
+  if (!authToken.trim()) return null;
+  return {
+    serverUrl,
+    authToken,
+    userId,
+    sourceAgentKey,
+    targetAgentId,
+    targetAgentKey,
+    spaceId,
+    name: readFlagValue(args, "--name") ?? DEFAULT_AGENT_NAME,
+    publicAgent: args.includes("--public"),
+    json: args.includes("--json"),
+  };
+}
+
+async function readDbRecord(args: {
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+  authToken: string;
+  dbKey: string;
+}) {
+  const res = await args.fetchImpl(
+    `${args.serverUrl}/api/v1/db/read/${encodeURIComponent(args.dbKey)}`,
+    { headers: { Authorization: `Bearer ${args.authToken}` } }
+  );
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(`read ${args.dbKey} failed (${res.status}): ${JSON.stringify(data)}`);
+  }
+  return (data as any)?.data ?? data;
+}
+
+async function writeDbRecord(args: {
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+  authToken: string;
+  userId: string;
+  dbKey: string;
+  data: Record<string, any>;
+}) {
+  const res = await args.fetchImpl(`${args.serverUrl}/api/v1/db/write/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${args.authToken}`,
+    },
+    body: JSON.stringify({
+      customKey: args.dbKey,
+      userId: args.userId,
+      data: { ...args.data, dbKey: args.dbKey },
+    }),
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(`write ${args.dbKey} failed (${res.status}): ${JSON.stringify(data)}`);
+  }
+}
+
+function buildTargetAgent(args: {
+  parsed: ParsedArgs;
+  source: Record<string, any>;
+  now: number;
+}) {
+  const { parsed, source, now } = args;
+  if (!source.apiKey) {
+    throw new Error(`source agent ${parsed.sourceAgentKey} has no apiKey`);
+  }
+  if (!source.customProviderUrl) {
+    throw new Error(`source agent ${parsed.sourceAgentKey} has no customProviderUrl`);
+  }
+  return {
+    id: parsed.targetAgentId,
+    type: "agent",
+    name: parsed.name,
+    description:
+      "把 Marxists.org 中文旧式书籍页面转换为可离线打开的单文件 HTML，保留原 CSS、表格排版和背景纹理。",
+    prompt:
+      "你是离线书籍转换助手。用户给出 Marxists.org 中文书籍页面或要求保存离线书籍时，只能调用 convertMarxistsBookToOfflineHtml，不要使用普通网页抓取流程。最终回答必须逐字给出 rawData.fileUrl、rawData.pageCount、rawData.hasNetworkUrls、rawData.byteLength。",
+    isPublic: parsed.publicAgent,
+    model: source.model ?? "mimo-v2.5-pro",
+    provider: source.provider ?? "custom",
+    apiSource: source.apiSource ?? "custom",
+    apiKey: source.apiKey,
+    customProviderUrl: source.customProviderUrl,
+    apiKeyHeader: source.apiKeyHeader ?? "api-key",
+    tools: AGENT_TOOLS,
+    temperature: source.temperature ?? 0.2,
+    maxTokens: source.maxTokens ?? 4096,
+    category: "document-tools",
+    tags: ["offline-book", "marxists", "mimo"],
+    userId: parsed.userId,
+    createdAt: source.createdAt ?? now,
+    updatedAt: now,
+  };
+}
+
+async function attachAgentToSpace(args: {
+  fetchImpl: typeof fetch;
+  parsed: ParsedArgs;
+  contentKey: string;
+  title: string;
+  now: number;
+}) {
+  const spaceKey = `space-${args.parsed.spaceId}`;
+  const space = await readDbRecord({
+    fetchImpl: args.fetchImpl,
+    serverUrl: args.parsed.serverUrl,
+    authToken: args.parsed.authToken,
+    dbKey: spaceKey,
+  });
+  await writeDbRecord({
+    fetchImpl: args.fetchImpl,
+    serverUrl: args.parsed.serverUrl,
+    authToken: args.parsed.authToken,
+    userId: args.parsed.userId,
+    dbKey: spaceKey,
+    data: {
+      ...space,
+      contents: {
+        ...(space.contents ?? {}),
+        [args.contentKey]: {
+          ...(space.contents?.[args.contentKey] ?? {}),
+          title: args.title,
+          type: "agent",
+          contentKey: args.contentKey,
+          createdAt: space.contents?.[args.contentKey]?.createdAt ?? args.now,
+          updatedAt: args.now,
+        },
+      },
+      updatedAt: args.now,
+    },
+  });
+}
+
+function writeUsage(output: OutputLike) {
+  output.write(
+    "Usage: nolo agent setup-offline-marxists [--server https://nolo.chat] [--source-agent <key>] [--space <spaceId>] [--target-agent-id <id>] [--json]\n" +
+      "Requires AUTH_TOKEN from `nolo login` or --token.\n"
+  );
+}
+
+export async function runSetupOfflineMarxistsAgentCommand(
+  args: string[],
+  deps: SetupOfflineMarxistsAgentDeps = {}
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const parsed = parseArgs(args, env);
+  if (!parsed) {
+    writeUsage(output);
+    return 1;
+  }
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const now = deps.now?.() ?? Date.now();
+
+  try {
+    const source = await readDbRecord({
+      fetchImpl,
+      serverUrl: parsed.serverUrl,
+      authToken: parsed.authToken,
+      dbKey: parsed.sourceAgentKey,
+    });
+    const target = buildTargetAgent({ parsed, source, now });
+    await writeDbRecord({
+      fetchImpl,
+      serverUrl: parsed.serverUrl,
+      authToken: parsed.authToken,
+      userId: parsed.userId,
+      dbKey: parsed.targetAgentKey,
+      data: target,
+    });
+    const publicKey = `agent-pub-${parsed.targetAgentId}`;
+    if (parsed.publicAgent) {
+      await writeDbRecord({
+        fetchImpl,
+        serverUrl: parsed.serverUrl,
+        authToken: parsed.authToken,
+        userId: parsed.userId,
+        dbKey: publicKey,
+        data: target,
+      });
+    }
+    await attachAgentToSpace({
+      fetchImpl,
+      parsed,
+      contentKey: parsed.publicAgent ? publicKey : parsed.targetAgentKey,
+      title: parsed.name,
+      now,
+    });
+
+    const result = {
+      serverUrl: parsed.serverUrl,
+      sourceAgentKey: parsed.sourceAgentKey,
+      agentKey: parsed.targetAgentKey,
+      agentUrl: `${parsed.serverUrl}/${parsed.targetAgentKey}`,
+      publicKey: parsed.publicAgent ? publicKey : null,
+      spaceId: parsed.spaceId,
+      model: target.model,
+      provider: target.provider,
+      customProviderUrl: target.customProviderUrl,
+      tools: target.tools,
+    };
+    if (parsed.json) {
+      output.write(`${JSON.stringify(result, null, 2)}\n`);
+    } else {
+      output.write(
+        [
+          `created/updated: ${result.agentKey}`,
+          `url: ${result.agentUrl}`,
+          `space: ${result.spaceId}`,
+          `model: ${result.model}`,
+          `tools: ${result.tools.join(", ")}`,
+          "",
+        ].join("\n")
+      );
+    }
+    return 0;
+  } catch (error) {
+    output.write(
+      `setup-offline-marxists failed: ${error instanceof Error ? error.message : String(error)}\n`
+    );
+    return 1;
+  }
+}