nolo-cli 0.1.22 → 0.1.26

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;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nolo-cli",
-  "version": "0.1.22",
+  "version": "0.1.26",
   "type": "module",
   "description": "Agent-first terminal workspace for Nolo",
   "bin": {
@@ -11,17 +11,35 @@
     "index.ts",
     "agentRuntimeLocal.ts",
     "agentAliases.ts",
+    "agentCommandSupport.ts",
+    "agentListCommands.ts",
     "localRuntimeDb.ts",
     "agentRuntimeCommands.ts",
+    "agentListHelpers.ts",
+    "agentMachineCommands.ts",
     "agentPullCommand.ts",
+    "agentRecordCommands.ts",
+    "agentRecordHelpers.ts",
     "agentRunCommand.ts",
     "authCommands.ts",
+    "cliCommandAdapters.ts",
+    "cliCommandFactories.ts",
+    "cliCommandDispatch.ts",
+    "cliCommandTypes.ts",
+    "cliEnvHelpers.ts",
     "commandRegistry.ts",
     "connectorRunArtifact.ts",
     "connectorWebSocketTarget.ts",
     "defaultServer.ts",
+    "agentInternalCommandEntries.ts",
+    "internalCommandEntries.ts",
     "machineCommands.ts",
+    "offlineMarxistsAgentCommand.ts",
+    "runtimeDoctorCommands.ts",
+    "scriptCommandEntries.ts",
+    "systemInternalCommandEntries.ts",
     "taskRunCommand.ts",
+    "workflowInternalCommandEntries.ts",
     "runtimeModeArgs.ts",
     "tableCommands.ts",
     "updateCommands.ts",
@@ -32,8 +50,9 @@
     "connector-experimental/**/*.ts",
     "agent-runtime/**/*.ts",
     "database/**/*.ts",
+    "ai/**/*.ts",
     "connector-experimental/**/*.ts",
-    "ai/**/*.ts"
+    "render/**/*.ts"
   ],
   "publishConfig": {
     "access": "public"
@@ -47,6 +66,7 @@
   "dependencies": {
     "date-fns-tz": "^2.0.0",
     "level": "^10.0.0",
+    "js-yaml": "^4.1.0",
     "ulid": "^2.3.0"
   }
 }

package/render/canvas/canvasEditContext.ts

@@ -0,0 +1,127 @@
+import React from "react";
+import type { AgentRuntimeOptions } from "ai/agent/types";
+import type { CanvasEvent } from "./types";
+
+export type CanvasEditSelection = {
+  sourceMessageId?: string;
+  selectedNodeId: string;
+  part: string;
+  path: string[];
+  type: string;
+  props: Record<string, unknown>;
+  style: Record<string, unknown>;
+};
+
+const CANVAS_EDIT_SELECTION_EVENT = "nolo:canvas-edit-selection";
+
+let currentSelection: CanvasEditSelection | null = null;
+let pendingSelection: CanvasEditSelection | null = null;
+const listeners = new Set<(selection: CanvasEditSelection | null) => void>();
+const patchListeners = new Map<string, Set<(events: CanvasEvent[]) => void>>();
+const queuedPatches = new Map<string, CanvasEvent[][]>();
+
+export function publishCanvasEditSelection(
+  selection: CanvasEditSelection | null
+) {
+  currentSelection = selection;
+  listeners.forEach((listener) => listener(selection));
+
+  if (typeof window !== "undefined") {
+    window.dispatchEvent(
+      new CustomEvent(CANVAS_EDIT_SELECTION_EVENT, { detail: selection })
+    );
+  }
+}
+
+export function subscribeCanvasEditSelection(
+  listener: (selection: CanvasEditSelection | null) => void
+) {
+  listeners.add(listener);
+  listener(currentSelection);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+export function useCanvasEditSelection() {
+  const [selection, setSelection] =
+    React.useState<CanvasEditSelection | null>(currentSelection);
+
+  React.useEffect(
+    () => subscribeCanvasEditSelection(setSelection),
+    []
+  );
+
+  return selection;
+}
+
+export function markPendingCanvasEditSelection(
+  selection: CanvasEditSelection | null
+) {
+  pendingSelection = selection;
+}
+
+export function consumePendingCanvasEditSelection() {
+  const selection = pendingSelection;
+  pendingSelection = null;
+  return selection;
+}
+
+export function publishCanvasMessagePatch(
+  sourceMessageId: string,
+  events: CanvasEvent[]
+) {
+  if (!events.length) return;
+
+  const queued = queuedPatches.get(sourceMessageId) ?? [];
+  queued.push(events);
+  queuedPatches.set(sourceMessageId, queued);
+
+  patchListeners
+    .get(sourceMessageId)
+    ?.forEach((listener) => listener(events));
+}
+
+export function subscribeCanvasMessagePatches(
+  sourceMessageId: string,
+  listener: (events: CanvasEvent[]) => void
+) {
+  const listenersForMessage = patchListeners.get(sourceMessageId) ?? new Set();
+  listenersForMessage.add(listener);
+  patchListeners.set(sourceMessageId, listenersForMessage);
+
+  queuedPatches
+    .get(sourceMessageId)
+    ?.forEach((events) => listener(events));
+
+  return () => {
+    listenersForMessage.delete(listener);
+    if (!listenersForMessage.size) {
+      patchListeners.delete(sourceMessageId);
+    }
+  };
+}
+
+export function buildCanvasNodeEditingTarget(
+  selection: CanvasEditSelection
+): NonNullable<AgentRuntimeOptions["editingTarget"]> {
+  return {
+    kind: "canvas_node",
+    key: selection.selectedNodeId,
+    title: selection.part,
+    summary: [
+      "用户正在编辑 Canvas Tree 画布中的一个已选中节点。",
+      "只输出针对选中节点的 canvas_snapshot updateNode 事件，除非用户明确要求新增内容。",
+      "不要重建整棵树，不要输出 Markdown、解释、React、HTML、CSS 或 JS 源码。",
+    ].join("\n"),
+    metadata: {
+      sourceMessageId: selection.sourceMessageId,
+      selectedNodeId: selection.selectedNodeId,
+      part: selection.part,
+      path: selection.path,
+      type: selection.type,
+      props: selection.props,
+      style: selection.style,
+    },
+  };
+}

package/render/canvas/canvasRuntime.ts

@@ -0,0 +1,57 @@
+export type CanvasRuntimeAction =
+  | {
+      type: "toggle";
+      key: string;
+    }
+  | {
+      type: "setState";
+      key: string;
+      value: unknown;
+    }
+  | {
+      type: "scrollTo";
+      targetId: string;
+    };
+
+export type CanvasRuntimeState = Record<string, unknown>;
+
+export function parseCanvasRuntimeAction(action: unknown): CanvasRuntimeAction | null {
+  if (!action || typeof action !== "object") return null;
+  const candidate = action as Record<string, unknown>;
+  const type = candidate.type;
+
+  if (type === "toggle" && typeof candidate.key === "string" && candidate.key.trim()) {
+    return { type, key: candidate.key };
+  }
+
+  if (type === "setState" && typeof candidate.key === "string" && candidate.key.trim()) {
+    return { type, key: candidate.key, value: candidate.value };
+  }
+
+  if (type === "scrollTo" && typeof candidate.targetId === "string" && candidate.targetId.trim()) {
+    return { type, targetId: candidate.targetId };
+  }
+
+  return null;
+}
+
+export function reduceCanvasRuntimeAction(
+  state: CanvasRuntimeState,
+  action: CanvasRuntimeAction
+): CanvasRuntimeState {
+  if (action.type === "toggle") {
+    return {
+      ...state,
+      [action.key]: !state[action.key],
+    };
+  }
+
+  if (action.type === "setState") {
+    return {
+      ...state,
+      [action.key]: action.value,
+    };
+  }
+
+  return state;
+}

package/render/canvas/canvasSnapshotParser.ts

@@ -0,0 +1,76 @@
+import {
+  applyCanvasEvent,
+  createCanvasDocument,
+  normalizeCanvasEvent,
+} from "./canvasTree";
+import type { CanvasDocument, CanvasEvent } from "./types";
+
+export type ParsedCanvasSnapshotMessage = {
+  document: CanvasDocument;
+  events: CanvasEvent[];
+  eventCount: number;
+};
+
+export function hasCanvasSnapshotSignal(content: string): boolean {
+  return content.includes("canvas_snapshot");
+}
+
+export function extractCanvasSnapshotText(content: unknown): string | null {
+  if (typeof content === "string") {
+    return hasCanvasSnapshotSignal(content) ? content : null;
+  }
+  if (!Array.isArray(content)) return null;
+
+  const text = content
+    .map((item) =>
+      item?.type === "text" && typeof item.text === "string" ? item.text : ""
+    )
+    .filter(Boolean)
+    .join("\n");
+
+  return hasCanvasSnapshotSignal(text) ? text : null;
+}
+
+function isCanvasEvent(value: unknown): value is CanvasEvent {
+  if (!value || typeof value !== "object") return false;
+  const event = value as { type?: unknown };
+  return (
+    event.type === "appendNode" ||
+    event.type === "updateNode" ||
+    event.type === "selectNode"
+  );
+}
+
+export function parseCanvasSnapshotMessage(
+  content: string
+): ParsedCanvasSnapshotMessage | null {
+  if (!hasCanvasSnapshotSignal(content)) return null;
+
+  let document = createCanvasDocument("root");
+  const events: CanvasEvent[] = [];
+  let eventCount = 0;
+
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{") || !trimmed.includes("canvas_snapshot")) {
+      continue;
+    }
+
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed?.type !== "canvas_snapshot" || !isCanvasEvent(parsed.event)) {
+        continue;
+      }
+      const event = normalizeCanvasEvent(parsed.event);
+      if (!event) continue;
+      document = applyCanvasEvent(document, event);
+      events.push(event);
+      eventCount += 1;
+    } catch {
+      // Streaming messages often end with a partial JSON line. Ignore it until
+      // the next render provides a complete line.
+    }
+  }
+
+  return eventCount > 0 ? { document, events, eventCount } : null;
+}