nolo-cli 0.1.13 → 0.1.14

package/client/streamingOutput.ts

@@ -0,0 +1,38 @@
+type OutputLike = {
+  write(chunk: string): unknown;
+};
+
+export function splitStreamingText(content: string): string[] {
+  const Segmenter = Intl.Segmenter;
+  if (typeof Segmenter === "function") {
+    const segmenter = new Segmenter(undefined, { granularity: "grapheme" });
+    return Array.from(segmenter.segment(content), (part) => part.segment);
+  }
+  return Array.from(content);
+}
+
+export function createStreamingTextWriter({
+  write,
+  batchSize = 3,
+}: {
+  write: OutputLike["write"];
+  batchSize?: number;
+}) {
+  const queue: string[] = [];
+  const safeBatchSize = Math.max(1, batchSize);
+
+  const flushNext = () => {
+    if (!queue.length) return;
+    write(queue.splice(0, safeBatchSize).join(""));
+  };
+
+  return {
+    push(content: string) {
+      queue.push(...splitStreamingText(content));
+      flushNext();
+    },
+    flushAll() {
+      while (queue.length) flushNext();
+    },
+  };
+}

package/commandRegistry.ts

@@ -16,6 +16,7 @@ export const COMMANDS: CommandEntry[] = [
   { path: ["skill-doc", "read"], script: "readSkillDoc.ts", description: "Read a skill doc" },
   { path: ["skill-doc", "update"], script: "updateSkillDoc.ts", description: "Update a skill doc" },
   { path: ["skill-doc", "delete"], script: "deleteSkillDoc.ts", description: "Delete a skill doc" },
+  { path: ["skill", "create-doc"], script: "createSkillDoc.ts", description: "Create a skill-backed doc" },
 
   { path: ["dialog", "read"], script: "readDialog.ts", description: "Read a dialog" },
   { path: ["space", "read"], script: "readSpace.ts", description: "Read a space" },
@@ -41,6 +42,8 @@ export const COMMANDS: CommandEntry[] = [
   { path: ["agent", "setup-demo"], script: "setupDemoAgent.ts", description: "Bootstrap demo publisher agents" },
   { path: ["agent", "supervise"], script: "runAutonomousAgent.ts", description: "Run an agent in autonomous cycles" },
 
+  { path: ["doctor", "runtime"], script: "", description: "Diagnose local-first agent runtime selection" },
+
   { path: ["llama"], script: "llamaServerSupervisor.ts", description: "Manage the llama.cpp runtime" },
   { path: ["model-runtime"], script: "localModelRuntimeSupervisor.ts", description: "Manage local model runtime processes" },
   { path: ["dev"], script: "devControl.ts", description: "Manage the local dev environment" },
@@ -50,7 +53,9 @@ export const GROUP_ORDER = [
   "chat",
   "doc",
   "skill-doc",
+  "skill",
   "agent",
+  "doctor",
   "dialog",
   "space",
   "table",
@@ -83,15 +88,17 @@ export function renderHelpText() {
     "  nolo connect --daemon --server-url https://api.nolo.chat --api-key sk_machine_xxx",
     "  nolo machine status",
     "  nolo doctor",
+    "  nolo doctor runtime",
     "  nolo update",
-    '  nolo doc create --title "Trip Notes" --body "hello"',
-    '  nolo skill-doc create --title "Agent Query Skill" --description "Inspect recent agent dialogs"',
+    '  nolo doc create --title "Trip Notes" --body "hello" --sync local,us --dry-run',
+    '  nolo skill-doc create --title "Agent Query Skill" --description "Inspect recent agent dialogs" --sync local,main,us',
     "  nolo agent list --json",
     "  nolo agent read agent-pub-01APPBUILDER00000001YAII3I",
     "  nolo agent bind-current agent-user-1-agent-1",
     "  nolo agent runtime-doctor agent-user-1-agent-1",
     '  nolo agent smoke-current agent-user-1-agent-1 --msg "ping"',
     '  nolo chat --agent agent-pub-01APPBUILDER00000001YAII3I --msg "你好"',
+    "  nolo space read 01KKY77TT0DA9NY7TNW3R7255N --content-key page-user-id --brief",
     "  nolo space delete --name-prefix rn_owner_verify_0504 --yes",
     "  nolo table data --table 01ABCXYZ --action query",
     "  nolo llama status",

package/connector-experimental/index.ts

@@ -0,0 +1,5 @@
+export * from "./capabilities";
+export * from "./codexBinary";
+export * from "./heartbeatLoop";
+export * from "./machineInfo";
+export * from "./protocol";

package/database/actions/cacheMergedUserData.ts

@@ -0,0 +1,64 @@
+import { createAsyncThunk } from "@reduxjs/toolkit";
+
+import type { AppThunkApi } from "app/store";
+
+import { fetchFromClientDb } from "./common";
+import { shouldReplaceWithNextRecord } from "../tombstones";
+
+type CacheableUserDataRecord = {
+  dbKey?: string;
+  serverOrigin?: string;
+  [key: string]: unknown;
+};
+
+export const shouldUpdateLocalUserDataCache = (
+  nextRecord: CacheableUserDataRecord,
+  localRecord: CacheableUserDataRecord | null
+): boolean => {
+  if (!nextRecord || typeof nextRecord !== "object") {
+    return false;
+  }
+
+  if (!localRecord || typeof localRecord !== "object") {
+    return true;
+  }
+
+  if (shouldReplaceWithNextRecord(nextRecord, localRecord)) {
+    return true;
+  }
+
+  return (
+    typeof localRecord.serverOrigin !== "string" &&
+    typeof nextRecord.serverOrigin === "string" &&
+    nextRecord.serverOrigin.trim().length > 0
+  );
+};
+
+export const cacheMergedUserDataThunk = createAsyncThunk<
+  void,
+  { records: CacheableUserDataRecord[] },
+  AppThunkApi
+>("db/cacheMergedUserData", async ({ records }, { extra }) => {
+  const clientDb = extra.db;
+  if (!clientDb) {
+    throw new Error("Client database is not available.");
+  }
+
+  for (const record of records) {
+    const dbKey = typeof record?.dbKey === "string" ? record.dbKey.trim() : "";
+    if (!dbKey) continue;
+
+    try {
+      const localRecord = await fetchFromClientDb(clientDb, dbKey);
+      if (!shouldUpdateLocalUserDataCache(record, localRecord)) {
+        continue;
+      }
+      await clientDb.put(dbKey, record);
+    } catch (error) {
+      console.warn("[useUserData] Failed to cache merged user data record", {
+        dbKey,
+        error,
+      });
+    }
+  }
+});

package/database/actions/common.ts

@@ -0,0 +1,242 @@
+// 文件路径: database/actions/common.ts
+
+import pino from "pino";
+import { getIsDesktopApp } from "app/utils/env";
+import { API_ENDPOINTS, NOLO_CLUSTER_SERVERS } from "../config";
+
+// RN 下 pino 的 browser 写法可能有兼容性问题
+// 使用简单的 console 封装作为 fallback
+const isRN = typeof navigator !== 'undefined' && (navigator as any).product === 'ReactNative';
+
+export const logger = isRN ? {
+  info: (...args: any[]) => console.log(...args),
+  warn: (...args: any[]) => console.warn(...args),
+  error: (...args: any[]) => console.error(...args),
+  debug: (...args: any[]) => console.log(...args), // console.debug in RN behaves like log
+  trace: (...args: any[]) => console.log(...args),
+  fatal: (...args: any[]) => console.error(...args),
+  child: () => logger // 简单返回自己
+} as unknown as pino.Logger : pino({
+  level: "info",
+  // transport: {
+  //   target: "pino-pretty",
+  // },
+});
+const normalizeServer = (server: string): string =>
+  server.trim().replace(/\/+$/, "");
+const isNoloClusterServer = (server: string): boolean =>
+  /^https?:\/\/(?:us\.)?nolo\.chat$/i.test(normalizeServer(server));
+
+export const mergeConfiguredServers = (
+  currentServer: string | undefined,
+  syncServers: string[] | undefined
+): string[] => {
+  const runtimeOrigin =
+    !getIsDesktopApp() &&
+      typeof window !== "undefined" &&
+      typeof window.location?.origin === "string" &&
+      /^https?:\/\//.test(window.location.origin)
+      ? window.location.origin
+      : undefined;
+
+  const raw = [
+    currentServer,
+    ...(Array.isArray(syncServers) ? syncServers : []),
+    runtimeOrigin,
+  ].filter(
+    (s): s is string => typeof s === "string" && s.trim().length > 0
+  );
+
+  const normalized = raw.map(normalizeServer);
+  if (normalized.some(isNoloClusterServer)) {
+    normalized.push(...NOLO_CLUSTER_SERVERS);
+  }
+  return Array.from(new Set(normalized));
+};
+// 全局缓存网络状态（仅 React Native 使用）
+let cachedNetworkState: boolean | null = null;
+let netInfoListenerInitialized = false;
+
+// 检测是否为 React Native 环境
+const isReactNative = (): boolean => {
+  return typeof navigator !== 'undefined' && (navigator as any).product === 'ReactNative';
+};
+
+// 初始化 NetInfo 监听器（仅在 React Native 环境调用）
+export const initNetworkListener = async () => {
+  if (!isReactNative() || netInfoListenerInitialized) return;
+
+  try {
+    // 动态导入 NetInfo，避免在 Web 环境下出错
+    const NetInfo = await import('@react-native-community/netinfo');
+    NetInfo.default.addEventListener(state => {
+      cachedNetworkState = state.isConnected ?? true;
+    });
+    netInfoListenerInitialized = true;
+    console.log('[NetInfo] Listener initialized');
+  } catch (error) {
+    console.warn('[NetInfo] Failed to initialize:', error);
+  }
+};
+
+// 改进的 isOnline 函数，兼容 Web 和 React Native
+export const isOnline = (): boolean => {
+  // React Native 环境：使用 NetInfo 缓存
+  if (isReactNative()) {
+    if (cachedNetworkState !== null) {
+      return cachedNetworkState;
+    }
+    // NetInfo 还未初始化，默认假设在线
+    return true;
+  }
+
+  // Web 环境：使用 navigator.onLine
+  if (typeof navigator !== "undefined" && typeof (navigator as any).onLine !== "undefined") {
+    return (navigator as any).onLine;
+  }
+
+  // 降级：默认假设在线
+  return true;
+};
+
+export const getAllServers = (
+  currentServer: string | undefined,
+  syncServers: string[] | undefined,
+  preferredServer?: string | null
+): string[] => {
+  const preferredNormalized =
+    typeof preferredServer === "string" && preferredServer.trim().length > 0
+      ? normalizeServer(preferredServer)
+      : null;
+  const servers = mergeConfiguredServers(
+    currentServer,
+    preferredNormalized && isNoloClusterServer(preferredNormalized)
+      ? [...(Array.isArray(syncServers) ? syncServers : []), preferredNormalized]
+      : syncServers
+  );
+  if (!preferredServer || typeof preferredServer !== "string") {
+    return servers;
+  }
+
+  const remaining = servers.filter(
+    (server) => normalizeServer(server) !== preferredNormalized
+  );
+  return preferredNormalized ? [preferredNormalized, ...remaining] : remaining;
+};
+
+const isLevelNotFoundError = (err: any): boolean => {
+  const code = err?.code;
+  return (
+    err?.notFound === true ||
+    err?.name === "NotFoundError" ||
+    code === "LEVEL_NOT_FOUND" ||
+    code === "LEVEL_NOT_FOUND_ERROR"
+  );
+};
+
+
+// 从客户端数据库获取数据 (无需改动)
+export const fetchFromClientDb = async (
+  clientDb: any,
+  dbKey: string
+): Promise<any> => {
+  if (!clientDb) {
+    logger.error(
+      { dbKey },
+      "Client database is undefined in fetchFromClientDb"
+    );
+    return null;
+  }
+  try {
+    return await clientDb.get(dbKey);
+  } catch (err) {
+    if (isLevelNotFoundError(err)) {
+      return null;
+    }
+    logger.error({ err, dbKey }, "Failed to get local data");
+    return null;
+  }
+};
+
+// ======================================================================
+// 【核心改造】: fetchFromServer 函数
+// ======================================================================
+const SERVER_TIMEOUT = 5000;
+export const READ_TIMEOUT_ERROR_NAME = "ReadTimeoutError";
+const isPublicFileDbKey = (dbKey: string): boolean => dbKey.startsWith("file-");
+// file-* 元数据接口对无 token 的 LLM/工具调用开放（仅 metadata）；
+// 常规 read 接口保留认证路径，避免普通业务数据被未授权盗链/枚举。
+const buildReadUrl = (dbKey: string): string =>
+  isPublicFileDbKey(dbKey)
+    ? `${API_ENDPOINTS.DATABASE}/file/metadata/${encodeURIComponent(dbKey)}`
+    : `${API_ENDPOINTS.DATABASE}/read/${encodeURIComponent(dbKey)}`;
+
+const createReadTimeoutError = (server: string, dbKey: string): Error => {
+  const error = new Error(
+    `Timed out reading key "${dbKey}" from ${normalizeServer(server)}.`
+  );
+  error.name = READ_TIMEOUT_ERROR_NAME;
+  return error;
+};
+
+export const isReadTimeoutError = (error: unknown): boolean =>
+  error instanceof Error && error.name === READ_TIMEOUT_ERROR_NAME;
+
+export const fetchFromServer = async (
+  server: string,
+  dbKey: string,
+  token?: string,
+  signal?: AbortSignal
+): Promise<any> => {
+  if (signal?.aborted) {
+    throw new DOMException("Aborted", "AbortError");
+  }
+
+  const controller = new AbortController();
+  let didTimeout = false;
+  const timeoutId = setTimeout(() => {
+    didTimeout = true;
+    controller.abort();
+  }, SERVER_TIMEOUT);
+  const onExternalAbort = () => controller.abort();
+  signal?.addEventListener("abort", onExternalAbort);
+
+  try {
+    const res = await fetch(
+      `${server}${buildReadUrl(dbKey)}`,
+      {
+        signal: controller.signal as any,
+        headers: {
+          "Content-Type": "application/json",
+          ...(token && { Authorization: `Bearer ${token}` }),
+        },
+      }
+    );
+    clearTimeout(timeoutId);
+    signal?.removeEventListener("abort", onExternalAbort);
+
+    if (res.status === 200) {
+      return await res.json();
+    }
+    return null;
+  } catch (err: any) {
+    clearTimeout(timeoutId);
+    signal?.removeEventListener("abort", onExternalAbort);
+    if (didTimeout) {
+      throw createReadTimeoutError(server, dbKey);
+    }
+    if (signal?.aborted || err.name === "AbortError") {
+      throw err;
+    }
+    return null;
+  }
+};
+
+// 规范化时间字段 (无需改动)
+export const normalizeTimeFields = (data: any): any => ({
+  ...data,
+  createdAt: data.createdAt || new Date().toISOString(),
+  updatedAt: new Date().toISOString(),
+  updated_at: undefined,
+  created_at: undefined,
+});

package/database/actions/deleteFile.ts

@@ -0,0 +1,40 @@
+
+import { removeAction } from "./remove";
+import { fetchFromClientDb } from "./common";
+import { deleteFileFromIndexedDb } from "../fileStorage";
+import { logger } from "./common";
+
+/**
+ * Delete File Action:
+ * 1. Retrieve metadata to get fileId (if different from dbKey, though usually dbKey maps to metadata which has the fileId)
+ * 2. Delete blob from IndexedDB (using fileId from metadata)
+ * 3. Call generic removeAction to delete metadata and notify servers
+ */
+export const deleteFileAction = async (
+    dbKey: string,
+    thunkApi: any
+): Promise<void> => {
+    const { db: clientDb } = thunkApi.extra;
+
+    try {
+        // 1. Get metadata to find the internal Blob ID (fileId)
+        const metadata = await fetchFromClientDb(clientDb, dbKey);
+
+        if (metadata && metadata.id) {
+            // 2. Delete blob from IndexedDB
+            try {
+                await deleteFileFromIndexedDb(metadata.id);
+                logger.debug({ fileId: metadata.id }, "Deleted file blob from IndexedDB");
+            } catch (err) {
+                logger.warn({ err, fileId: metadata.id }, "Failed to delete file blob from IndexedDB, proceeding to delete metadata");
+            }
+        }
+
+        // 3. Delete metadata and sync delete to servers
+        await removeAction(dbKey, thunkApi);
+
+    } catch (error) {
+        logger.error({ error, dbKey }, "Failed to delete file completely");
+        throw error;
+    }
+}

package/database/actions/fetchUserData.ts

@@ -0,0 +1,16 @@
+import { createAsyncThunk } from "@reduxjs/toolkit";
+import { fetchUserData } from "../client/fetchUserData";
+import { AppThunkApi } from "app/store";
+
+export const fetchUserDataThunk = createAsyncThunk<
+    any,
+    { types: string | string[]; userId: string; includeDeleted?: boolean },
+    AppThunkApi
+>("db/fetchUserData", async ({ types, userId, includeDeleted }, { extra }) => {
+    const { db } = extra;
+    if (!db) {
+        console.error("Database not available in fetchUserDataThunk");
+        throw new Error("Database not available");
+    }
+    return await fetchUserData(db, types, userId, { includeDeleted });
+});

package/database/actions/fileContent.ts

@@ -0,0 +1,125 @@
+// 文件路径: database/actions/fileContent.ts
+
+import type { AppThunkApi } from "app/store";
+import { API_ENDPOINTS } from "database/config";
+import { getRuntimeServerContext } from "database/runtimeServerContext";
+import {
+    loadFileFromIndexedDb,
+    saveFileToIndexedDb,
+    StoredFileRecord,
+} from "../fileStorage";
+import { getFileIdFromKey } from "../keys";
+
+/**
+ * 从 dbKey 中提取裸 ULID（用于 IndexedDB 查找）
+ *
+ * 如果传入的是完整 dbKey（如 file-{userId}-{fileId}），返回 fileId（ULID）。
+ * 如果传入的已经是裸 ULID，则原样返回。
+ */
+const resolveLocalFileId = (fileId: string): string => {
+    if (fileId.startsWith("file-")) {
+        return getFileIdFromKey(fileId) || fileId;
+    }
+    return fileId;
+};
+
+/**
+ * 读取文件内容（优先本地 IndexedDB，缺失时从服务器拉取并写入本地缓存）
+ *
+ * fileId 支持两种格式：
+ * - 完整 dbKey：file-{userId}-{fileId}（推荐，服务端可直接查询）
+ * - 裸 ULID：{fileId}（需要服务端 file-id 索引）
+ *
+ * 返回：
+ * - fileId: string
+ * - blob: Blob
+ * - source: "local" | "remote"
+ */
+export const readFileContentAction = async (
+    {
+        fileId,
+        useServerFallback = true,
+    }: { fileId: string; useServerFallback?: boolean },
+    thunkApi: AppThunkApi
+): Promise<{ fileId: string; blob: Blob; source: "local" | "remote" }> => {
+    if (!fileId || typeof fileId !== "string") {
+        throw new Error("readFileContentAction requires a valid fileId string.");
+    }
+
+    // IndexedDB 以裸 ULID 为 key 存储文件
+    const localId = resolveLocalFileId(fileId);
+
+    // 1. 先尝试从 IndexedDB 读取（使用裸 ULID）
+    const localRecord: StoredFileRecord | null =
+        await loadFileFromIndexedDb(localId);
+    if (localRecord) {
+        return {
+            fileId: localId,
+            blob: localRecord.blob,
+            source: "local",
+        };
+    }
+
+    // 2. 根据参数决定是否回退到服务器
+    if (!useServerFallback) {
+        throw new Error(
+            `Local file not found for id "${fileId}", and server fallback is disabled.`
+        );
+    }
+
+    // 3. 从服务器拉取文件内容（使用原始 fileId，完整 dbKey 可直接查询）
+    const state = thunkApi.getState();
+    const { currentServer, remoteServers: serversToTry } =
+        getRuntimeServerContext(state);
+
+    if (!currentServer) {
+        throw new Error(
+            `No current server configured. Cannot fetch remote file for id "${fileId}".`
+        );
+    }
+
+    let lastError = "";
+
+    for (const server of serversToTry) {
+        const url = `${server}${API_ENDPOINTS.DATABASE}/file/content/${fileId}`;
+        console.debug("[readFileContentAction] trying server:", url);
+
+        try {
+            const res = await fetch(url);
+            if (!res.ok) {
+                lastError = `HTTP ${res.status} from ${server}`;
+                console.debug("[readFileContentAction] server returned:", lastError);
+                continue;
+            }
+
+            const blob = await res.blob();
+
+            // 将从服务器获取的文件写入 IndexedDB，以裸 ULID 为 key 缓存
+            if (typeof indexedDB !== "undefined") {
+                void saveFileToIndexedDb(localId, blob).catch((err) => {
+                    console.warn(
+                        "[readFileContentAction] Failed to cache remote file into IndexedDB:",
+                        err
+                    );
+                });
+            }
+
+            return {
+                fileId: localId,
+                blob,
+                source: "remote" as const,
+            };
+        } catch (err: any) {
+            lastError = err?.message || "Network error";
+            console.debug(
+                "[readFileContentAction] fetch error from",
+                server,
+                lastError
+            );
+        }
+    }
+
+    throw new Error(
+        `Failed to fetch remote file content from all servers for id "${fileId}". Last error: ${lastError}`
+    );
+};