nolo-cli 0.1.12 → 0.1.14

package/client/localRuntimeAdapter.ts

@@ -0,0 +1,244 @@
+import type {
+  AgentRuntimeAgentConfig,
+  AgentRuntimeHostAdapter,
+  AgentRuntimeSaveTurnInput,
+} from "../agentRuntimeLocal";
+import type { AgentRuntimeChatMessage } from "../../agent-runtime";
+import { getDefaultCliLocalRuntimeDb } from "../localRuntimeDb";
+
+type EnvLike = Record<string, string | undefined>;
+
+export type CliLocalRuntimeDb = {
+  get(key: string): Promise<any>;
+  put(key: string, value: any): Promise<unknown>;
+  batch(ops: Array<{ type: "put"; key: string; value: any }>): Promise<unknown>;
+  iterator(options: { gte: string; lte?: string; lt?: string; reverse?: boolean; limit?: number }): AsyncIterable<[string, any]>;
+};
+
+export type CliLocalRuntimeAdapterDeps = {
+  env: EnvLike;
+  db?: CliLocalRuntimeDb;
+  now?: () => number;
+  createId?: () => string;
+  fetchImpl?: typeof fetch;
+};
+
+async function defaultLocalRuntimeDb(): Promise<CliLocalRuntimeDb> {
+  return getDefaultCliLocalRuntimeDb();
+}
+
+function createFallbackId() {
+  return `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`.toUpperCase();
+}
+
+function resolveOpenAiCompatibleBaseUrl(env: EnvLike) {
+  return (env.NOLO_LOCAL_OPENAI_BASE_URL || env.OPENAI_BASE_URL || "https://api.openai.com/v1")
+    .replace(/\/+$/, "");
+}
+
+function resolveApiKey(env: EnvLike) {
+  return env.OPENAI_API_KEY || env.NOLO_LOCAL_OPENAI_API_KEY || "";
+}
+
+function resolveLocalUserId(env: EnvLike) {
+  return env.NOLO_LOCAL_USER_ID || env.NOLO_USER_ID || "local";
+}
+
+async function resolveDb(deps: CliLocalRuntimeAdapterDeps) {
+  return deps.db ?? defaultLocalRuntimeDb();
+}
+
+async function readAgentFromDb(args: {
+  db: CliLocalRuntimeDb;
+  agentRef: string;
+  userId: string;
+}): Promise<AgentRuntimeAgentConfig | null> {
+  const candidates = [
+    args.agentRef,
+    `agent-${args.userId}-${args.agentRef}`,
+    `cybot-${args.userId}-${args.agentRef}`,
+  ];
+  for (const key of candidates) {
+    try {
+      const record = await args.db.get(key);
+      if (!record || typeof record !== "object") continue;
+      return {
+        key,
+        ...(typeof record.name === "string" ? { name: record.name } : {}),
+        ...(typeof record.prompt === "string" ? { prompt: record.prompt } : {}),
+        ...(typeof record.model === "string" ? { model: record.model } : {}),
+        ...(typeof record.provider === "string" ? { provider: record.provider } : {}),
+        ...(Array.isArray(record.toolNames) ? { toolNames: record.toolNames } : {}),
+      };
+    } catch {
+      // Try the next local LevelDB key convention.
+    }
+  }
+  return null;
+}
+
+function toOpenAiMessages(messages: AgentRuntimeChatMessage[]) {
+  return messages.map((message) => ({
+    role: message.role,
+    content: typeof message.content === "string"
+      ? message.content
+      : Array.isArray(message.content)
+        ? message.content
+            .map((part) => part.type === "text" ? part.text : `[image:${part.image_url.url}]`)
+            .join("\n")
+        : "",
+  }));
+}
+
+async function readDialogMessages(args: {
+  db: CliLocalRuntimeDb;
+  dialogId: string;
+}) {
+  const messages: AgentRuntimeChatMessage[] = [];
+  const prefix = `dialog-${args.dialogId}-msg-`;
+  const iterator = args.db.iterator({ gte: prefix, lte: `${prefix}\uffff` });
+  for await (const [, value] of iterator) {
+    if (!value || typeof value !== "object") continue;
+    if (value.role === "system") continue;
+    if (value.role === "user" || value.role === "assistant" || value.role === "tool") {
+      messages.push({
+        role: value.role,
+        content: value.content ?? null,
+        ...(typeof value.toolCallId === "string" ? { tool_call_id: value.toolCallId } : {}),
+        ...(Array.isArray(value.tool_calls) ? { tool_calls: value.tool_calls } : {}),
+      });
+    }
+  }
+  return messages;
+}
+
+async function writeDialog(args: {
+  db: CliLocalRuntimeDb;
+  input: AgentRuntimeSaveTurnInput;
+  userId: string;
+  now: () => number;
+  createId: () => string;
+}) {
+  const dialogId = args.createId();
+  const now = args.now();
+  const nowIso = new Date(now).toISOString();
+  const dialogKey = `dialog-${args.userId}-${dialogId}`;
+  const lastUser = [...args.input.messages].reverse().find((message) => message.role === "user");
+  const ops: Array<{ type: "put"; key: string; value: any }> = [
+    {
+      type: "put",
+      key: dialogKey,
+      value: {
+        id: dialogId,
+        dbKey: dialogKey,
+        type: "dialog",
+        userId: args.userId,
+        cybots: [args.input.agentKey],
+        primaryAgentKey: args.input.agentKey,
+        title: typeof lastUser?.content === "string" && lastUser.content.trim()
+          ? lastUser.content.trim().slice(0, 80)
+          : "Local agent run",
+        status: "done",
+        triggerType: "cli-local",
+        executionMode: "foreground",
+        createdAt: nowIso,
+        updatedAt: nowIso,
+        finishedAt: now,
+        usage: args.input.result.usage,
+      },
+    },
+    {
+      type: "put",
+      key: `dialog-${dialogId}-msg-user`,
+      value: {
+        id: "msg-user",
+        dbKey: `dialog-${dialogId}-msg-user`,
+        dialogId,
+        role: "user",
+        content: lastUser?.content ?? "",
+        userId: args.userId,
+        createdAt: nowIso,
+      },
+    },
+    {
+      type: "put",
+      key: `dialog-${dialogId}-msg-assistant`,
+      value: {
+        id: "msg-assistant",
+        dbKey: `dialog-${dialogId}-msg-assistant`,
+        dialogId,
+        role: "assistant",
+        content: args.input.result.content,
+        agentKey: args.input.agentKey,
+        cybotKey: args.input.agentKey,
+        createdAt: nowIso,
+      },
+    },
+  ];
+  await args.db.batch(ops);
+  return { dialogId };
+}
+
+export function createCliLocalRuntimeAdapter(
+  deps: CliLocalRuntimeAdapterDeps
+): AgentRuntimeHostAdapter {
+  const now = deps.now ?? Date.now;
+  const createId = deps.createId ?? createFallbackId;
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const userId = resolveLocalUserId(deps.env);
+
+  return {
+    host: "cli",
+    capabilities: ["leveldb-agent-config", "local-provider", "leveldb-persistence"],
+    loadAgentConfig: async (agentRef) => readAgentFromDb({
+      agentRef,
+      db: await resolveDb(deps),
+      userId,
+    }),
+    loadDialogHistory: async (dialogId) => readDialogMessages({
+      dialogId,
+      db: await resolveDb(deps),
+    }),
+    saveTurn: async (input) => writeDialog({
+      db: await resolveDb(deps),
+      input,
+      userId,
+      now,
+      createId,
+    }),
+    resolveProvider: async (agentConfig) => ({
+      model: agentConfig.model || "gpt-4.1-mini",
+      complete: async (messages) => {
+        const res = await fetchImpl(`${resolveOpenAiCompatibleBaseUrl(deps.env)}/chat/completions`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...(resolveApiKey(deps.env)
+              ? { Authorization: `Bearer ${resolveApiKey(deps.env)}` }
+              : {}),
+          },
+          body: JSON.stringify({
+            model: agentConfig.model || "gpt-4.1-mini",
+            messages: toOpenAiMessages(messages),
+            stream: false,
+          }),
+        });
+        const data = await res.json().catch(() => ({}));
+        if (!res.ok) {
+          throw new Error(`local provider failed: HTTP ${res.status} ${JSON.stringify(data)}`);
+        }
+        const content = String(data?.choices?.[0]?.message?.content ?? "");
+        return {
+          content,
+          model: agentConfig.model || "gpt-4.1-mini",
+          provider: agentConfig.provider || "openai-compatible",
+          usage: data?.usage,
+          trace: messages,
+        };
+      },
+    }),
+    executeTool: async () => {
+      throw new Error("Local runtime tools are not enabled for text-only CLI runs.");
+    },
+  };
+}

package/client/profileConfig.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  buildEnvFromProfile,
+  loadProfileConfig,
+  saveDefaultProfile,
+} from "./profileConfig";
+
+describe("cli profile config", () => {
+  test("saves and loads the default profile", () => {
+    const dir = mkdtempSync(join(tmpdir(), "nolo-profile-"));
+    try {
+      const path = join(dir, "config.json");
+
+      saveDefaultProfile(path, {
+        serverUrl: "https://nolo.chat",
+        authToken: "token-123",
+        agentKey: "agent-pub-abc",
+        agentName: "app-builder",
+      });
+
+      const config = loadProfileConfig(path);
+      expect(config.currentProfile).toBe("default");
+      expect(config.profiles.default.serverUrl).toBe("https://nolo.chat");
+      expect(config.profiles.default.authToken).toBe("token-123");
+      expect(buildEnvFromProfile(config)).toEqual({
+        NOLO_PROFILE: "default",
+        NOLO_SERVER: "https://nolo.chat",
+        AUTH_TOKEN: "token-123",
+        NOLO_AGENT: "agent-pub-abc",
+        NOLO_AGENT_NAME: "app-builder",
+      });
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/client/streamingOutput.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, test } from "bun:test";
+
+import { createStreamingTextWriter, splitStreamingText } from "./streamingOutput";
+
+describe("streamingOutput", () => {
+  test("splits text into user-visible characters instead of UTF-16 code units", () => {
+    expect(splitStreamingText("A你👍🏽B")).toEqual(["A", "你", "👍🏽", "B"]);
+  });
+
+  test("flushes text in small character batches", () => {
+    const chunks: string[] = [];
+    const writer = createStreamingTextWriter({
+      write: (chunk) => chunks.push(chunk),
+      batchSize: 2,
+    });
+
+    writer.push("abcd");
+    writer.flushAll();
+
+    expect(chunks).toEqual(["ab", "cd"]);
+  });
+});

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",
@@ -73,6 +78,8 @@ export function renderHelpText() {
     "  nolo",
     "  nolo chat",
     "  nolo login",
+    "  nolo login --no-browser",
+    "  nolo login --token <auth-token>",
     "  nolo whoami",
     "  nolo connect",
     "  nolo connect --watch",
@@ -81,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,
+      });
+    }
+  }
+});