nolo-cli 0.7.0 → 0.8.0-alpha.11

package/chunk-IAXBCTTE.js

@@ -0,0 +1,175 @@
+import {
+  selectCurrentServer,
+  selectRemoteServers
+} from "./chunk-VEJLAVTC.js";
+import {
+  createUserKey,
+  extractAgentInfo,
+  extractCoverImage,
+  resolveShareAuthorIdentity,
+  sanitizeShareData,
+  shareKey,
+  toNonEmptyString
+} from "./chunk-PN7AFLOK.js";
+import {
+  noloDeleteRequest,
+  noloWriteRequest,
+  selectIdentityUser,
+  selectIdentityUserId
+} from "./chunk-EYEEHCU4.js";
+import {
+  normalizeTimeFields
+} from "./chunk-QYXLLLGL.js";
+
+// packages/share/action.ts
+var generateToken = () => {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  const charsLen = chars.length;
+  const maxValid = 252;
+  let token = "";
+  while (token.length < 10) {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    for (let i = 0; i < bytes.length && token.length < 10; i++) {
+      if (bytes[i] < maxValid) {
+        token += chars.charAt(bytes[i] % charsLen);
+      }
+    }
+  }
+  return token;
+};
+var assertDialogShareMessagesPresent = (type, data) => {
+  if (type !== "dialog") return;
+  const messages = Array.isArray(data.messages) ? data.messages : Array.isArray(data.history) ? data.history : [];
+  if (messages.length > 0) return;
+  throw new Error("Cannot share dialog without persisted messages.");
+};
+var resolveTableSharePayload = (type, data, userId, originServer) => {
+  if (type !== "table") return sanitizeShareData(data);
+  const tableDbKey = typeof data.dbKey === "string" && data.dbKey.trim().length > 0 ? data.dbKey : void 0;
+  const tableOwnerId = typeof data.tenantId === "string" && data.tenantId.trim().length > 0 ? data.tenantId : userId;
+  if (!tableDbKey) {
+    throw new Error("Table share requires a dbKey.");
+  }
+  return {
+    mode: "live",
+    tableDbKey,
+    tableOwnerId,
+    originServer
+  };
+};
+var shareResourceAction = async (config, thunkApi) => {
+  const state = thunkApi.getState();
+  const userId = selectIdentityUserId(state);
+  const currentUser = selectIdentityUser(state);
+  if (!userId) {
+    throw new Error("User must be logged in to share resources.");
+  }
+  const token = generateToken();
+  const key = shareKey.create(token);
+  const currentServer = selectCurrentServer(state);
+  assertDialogShareMessagesPresent(config.type, config.data);
+  const snapshotData = resolveTableSharePayload(
+    config.type,
+    config.data,
+    userId,
+    currentServer
+  );
+  const coverImage = extractCoverImage(config.type, snapshotData);
+  const agentInfo = extractAgentInfo(config.type, snapshotData);
+  const createdAt = Date.now();
+  const { db: clientDb } = thunkApi.extra;
+  let authorProfile = null;
+  if (clientDb) {
+    try {
+      authorProfile = await clientDb.get(createUserKey.profile(userId));
+    } catch {
+      authorProfile = null;
+    }
+  }
+  const { authorName, authorAvatar } = resolveShareAuthorIdentity({
+    user: currentUser,
+    profile: authorProfile
+  });
+  if (agentInfo.sourceAgentKey && !agentInfo.sourceAgentName) {
+    if (clientDb) {
+      try {
+        const agentData = await clientDb.get(agentInfo.sourceAgentKey);
+        const name = toNonEmptyString(agentData?.name);
+        if (name) agentInfo.sourceAgentName = name;
+      } catch {
+      }
+    }
+  }
+  const sharedObject = {
+    type: config.type,
+    version: 1,
+    data: snapshotData,
+    meta: {
+      authorId: userId,
+      ...authorName ? { authorName } : {},
+      ...authorAvatar ? { authorAvatar } : {},
+      createdAt,
+      visibility: config.visibility ?? "private",
+      title: config.title,
+      description: config.description,
+      originalId: config.data.dbKey ?? config.data.id,
+      coverImage,
+      ...agentInfo
+    }
+  };
+  const servers = [
+    currentServer,
+    ...selectRemoteServers(state).filter((server) => server !== currentServer)
+  ].filter(Boolean);
+  const replicaServers = servers.filter((server) => server !== currentServer);
+  if (servers.length === 0) {
+    throw new Error("No available server to publish share.");
+  }
+  if (config.type === "table" && sharedObject.data.mode === "live") {
+    sharedObject.data = {
+      ...sharedObject.data,
+      originServer: currentServer
+    };
+    sharedObject.meta = {
+      ...sharedObject.meta,
+      mode: "live",
+      tableDbKey: typeof sharedObject.data.tableDbKey === "string" ? sharedObject.data.tableDbKey : void 0,
+      tableOwnerId: typeof sharedObject.data.tableOwnerId === "string" ? sharedObject.data.tableOwnerId : void 0,
+      originServer: currentServer,
+      replicaServers
+    };
+  }
+  const persistedSharedObject = normalizeTimeFields({
+    ...sharedObject,
+    dbKey: key,
+    userId
+  });
+  const indexKeys = shareKey.allIndexKeysFromShare(key, persistedSharedObject);
+  const results = await Promise.all(
+    servers.map(
+      (server) => noloWriteRequest(server, { data: persistedSharedObject, customKey: key, userId, indexKeys }, state)
+    )
+  );
+  const [originPublished, ...replicaPublishResults] = results;
+  if (!originPublished) {
+    const successfulReplicaServers = replicaServers.filter(
+      (_, index) => replicaPublishResults[index]
+    );
+    await Promise.all(
+      successfulReplicaServers.map(
+        (server) => noloDeleteRequest(server, key, { type: "single" }, state)
+      )
+    );
+    throw new Error("Failed to publish share to origin server.");
+  }
+  if (!clientDb) {
+    throw new Error("Client database instance is required in shareResourceAction");
+  }
+  await clientDb.put(key, persistedSharedObject);
+  return { token, key };
+};
+
+export {
+  shareResourceAction
+};

package/chunk-IDZTNRP2.js

@@ -0,0 +1,85 @@
+// packages/cli/processSpawn.ts
+import { spawn } from "node:child_process";
+function spawnProcess(options) {
+  let [command, ...args] = options.cmd;
+  if (process.platform === "win32") {
+    const lower = command.toLowerCase();
+    if ((lower === "npm" || lower === "npx" || lower === "pnpm" || lower === "yarn" || lower === "nolo") && !lower.endsWith(".cmd") && !lower.endsWith(".exe") && !lower.endsWith(".bat")) {
+      command = `${command}.cmd`;
+    }
+  }
+  let child;
+  try {
+    child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: [
+        options.stdin ?? "pipe",
+        options.stdout ?? "pipe",
+        options.stderr ?? "pipe"
+      ]
+    });
+  } catch {
+    return {
+      exited: Promise.resolve(127),
+      stdin: null,
+      stdout: null,
+      stderr: null
+    };
+  }
+  const exited = new Promise((resolve) => {
+    child.on("exit", (code) => resolve(code ?? 1));
+    child.on("error", () => resolve(127));
+  });
+  return {
+    exited,
+    stdin: child.stdin,
+    stdout: child.stdout,
+    stderr: child.stderr
+  };
+}
+async function readPipeText(stream) {
+  if (!stream) return "";
+  const anyStream = stream;
+  if (typeof anyStream.setEncoding !== "function" && typeof anyStream[Symbol.asyncIterator] === "function") {
+    const chunks = [];
+    for await (const chunk of anyStream) {
+      if (typeof chunk === "string") chunks.push(chunk);
+      else if (chunk instanceof Uint8Array) chunks.push(Buffer.from(chunk).toString("utf8"));
+      else if (Buffer.isBuffer(chunk)) chunks.push(chunk.toString("utf8"));
+      else chunks.push(String(chunk ?? ""));
+    }
+    return chunks.join("");
+  }
+  return new Promise((resolve) => {
+    let data = "";
+    let done = false;
+    const finish = () => {
+      if (done) return;
+      done = true;
+      resolve(data);
+    };
+    if (typeof anyStream.setEncoding === "function") {
+      anyStream.setEncoding("utf8");
+    }
+    stream.on("data", (chunk) => {
+      data += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+    });
+    stream.on("end", finish);
+    stream.on("close", finish);
+    stream.on("error", finish);
+  });
+}
+function resolveDefaultSpawn() {
+  const bunSpawn = globalThis.Bun?.spawn;
+  if (typeof bunSpawn === "function") {
+    return bunSpawn;
+  }
+  return spawnProcess;
+}
+
+export {
+  spawnProcess,
+  readPipeText,
+  resolveDefaultSpawn
+};

package/chunk-ISNCLGUZ.js

@@ -0,0 +1,146 @@
+import {
+  DEFAULT_NOLO_SERVER_URL
+} from "./chunk-OLZBQWZU.js";
+import {
+  DEFAULT_LOCAL_API_ORIGIN
+} from "./chunk-4SN6J65J.js";
+import {
+  NOLO_CLUSTER_SERVERS
+} from "./chunk-LCBAMY2M.js";
+import {
+  normalizeServerOrigin
+} from "./chunk-CF7PE763.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+
+// packages/cli/cliEnvHelpers.ts
+import { dirname, extname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+function resolveServerUrlFromEnv(env) {
+  return normalizeServerOrigin(
+    env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL
+  );
+}
+function isCliArgs(value) {
+  return Array.isArray(value);
+}
+function buildServerCandidates(values) {
+  return [...new Set(
+    values.filter((value) => typeof value === "string" && value.trim().length > 0).map((value) => normalizeServerOrigin(value))
+  )];
+}
+function resolveServerUrl(input, env) {
+  if (isCliArgs(input)) {
+    const explicit = readOption(input, "--server-url") || readOption(input, "--server");
+    return normalizeServerOrigin(explicit) || resolveServerUrlFromEnv(env ?? {});
+  }
+  return resolveServerUrlFromEnv(input);
+}
+function resolveServerCandidates(input, envOrPreferred, preferred) {
+  if (isCliArgs(input)) {
+    const env2 = envOrPreferred ?? {};
+    const explicitServer = resolveServerUrl(input, env2);
+    return buildServerCandidates([
+      explicitServer,
+      preferred?.trim(),
+      env2.NOLO_SERVER,
+      env2.BASE_URL,
+      env2.NOLO_SERVER_URL,
+      DEFAULT_NOLO_SERVER_URL,
+      ...NOLO_CLUSTER_SERVERS
+    ]);
+  }
+  const env = input;
+  return buildServerCandidates([
+    asOptionalTrimmedString(envOrPreferred),
+    env.NOLO_SERVER,
+    env.BASE_URL,
+    env.NOLO_SERVER_URL,
+    DEFAULT_NOLO_SERVER_URL,
+    ...NOLO_CLUSTER_SERVERS
+  ]);
+}
+function resolveDeleteServerCandidatesFromEnv(env, ...preferredValues) {
+  return buildServerCandidates([
+    ...preferredValues,
+    env.NOLO_SERVER,
+    env.BASE_URL,
+    env.NOLO_SERVER_URL,
+    env.READ_DIALOG_BASE,
+    DEFAULT_NOLO_SERVER_URL,
+    ...NOLO_CLUSTER_SERVERS,
+    DEFAULT_LOCAL_API_ORIGIN
+  ]);
+}
+function resolveDeleteServerCandidates(input, envOrPreferred, preferred) {
+  if (isCliArgs(input)) {
+    const env2 = envOrPreferred ?? {};
+    const explicitServer = resolveServerUrl(input, env2);
+    return resolveDeleteServerCandidatesFromEnv(env2, explicitServer, preferred?.trim());
+  }
+  const env = input;
+  return resolveDeleteServerCandidatesFromEnv(
+    env,
+    asOptionalTrimmedString(envOrPreferred)
+  );
+}
+function resolveAuthTokenFromEnv(env, extraEnvKeys = []) {
+  for (const key of ["AUTH_TOKEN", "AUTH", ...extraEnvKeys]) {
+    const value = env[key];
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  return "";
+}
+function resolveAuthToken(input, envOrExtraEnvKeys, extraEnvKeys = []) {
+  if (isCliArgs(input)) {
+    const env = envOrExtraEnvKeys ?? {};
+    return readOption(input, "--token") || readOption(input, "--machine-key") || resolveAuthTokenFromEnv(env, extraEnvKeys);
+  }
+  return resolveAuthTokenFromEnv(input, envOrExtraEnvKeys ?? []);
+}
+function parseUserIdFromAuthToken(token) {
+  const parts = token.trim().split(".").filter(Boolean);
+  const payloadCandidates = parts.length >= 3 ? [parts[1], parts[0]] : [parts[0]];
+  for (const payload of payloadCandidates) {
+    if (!payload) continue;
+    try {
+      const parsed = JSON.parse(Buffer.from(payload, "base64").toString("utf8"));
+      if (typeof parsed?.userId === "string") return parsed.userId;
+    } catch {
+    }
+  }
+  return "";
+}
+function readOption(args, flag) {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : void 0;
+}
+function isCompiledBinary() {
+  try {
+    const url = import.meta.url;
+    return url.startsWith("file:///$bunfs/root/") || url.startsWith("/$bunfs/root/");
+  } catch {
+    return false;
+  }
+}
+function resolveCliEntrypointPath(fromModuleUrl = import.meta.url) {
+  if (isCompiledBinary()) {
+    return process.execPath;
+  }
+  const sourcePath = fileURLToPath(fromModuleUrl);
+  const ext = extname(sourcePath) || ".ts";
+  return join(dirname(sourcePath), "..", `index${ext}`);
+}
+
+export {
+  resolveServerUrl,
+  resolveServerCandidates,
+  resolveDeleteServerCandidates,
+  resolveAuthTokenFromEnv,
+  resolveAuthToken,
+  parseUserIdFromAuthToken,
+  readOption,
+  isCompiledBinary,
+  resolveCliEntrypointPath
+};

package/chunk-IYQV26RA.js

@@ -0,0 +1,138 @@
+import {
+  selectCurrentServer
+} from "./chunk-VEJLAVTC.js";
+import {
+  patch
+} from "./chunk-G5H7RNFL.js";
+import {
+  selectIdentityToken
+} from "./chunk-EYEEHCU4.js";
+import {
+  getIsDesktopApp
+} from "./chunk-QYXLLLGL.js";
+
+// packages/ai/agent/cliChatClient.ts
+function getCliChatRequestConfig(thunkApi) {
+  const state = thunkApi.getState();
+  const currentServer = selectCurrentServer(state);
+  const token = selectIdentityToken(state);
+  if (!currentServer) throw new Error("\u65E0\u6CD5\u83B7\u53D6\u5F53\u524D\u670D\u52A1\u5668\u5730\u5740\u3002");
+  return { currentServer, token };
+}
+function resolveCliChatUrl(currentServer) {
+  if (getIsDesktopApp()) return "/api/cli/chat";
+  return `${currentServer}/api/cli/chat`;
+}
+async function postCliChat(thunkApi, body, signal) {
+  const { currentServer, token } = getCliChatRequestConfig(thunkApi);
+  return fetch(resolveCliChatUrl(currentServer), {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...token ? { Authorization: `Bearer ${token}` } : {}
+    },
+    body: JSON.stringify(body),
+    signal
+  });
+}
+async function startCliChatSession(thunkApi, args) {
+  const response = await postCliChat(thunkApi, {
+    action: "start",
+    cliProvider: args.cliProvider,
+    model: args.model,
+    systemPrompt: args.systemPrompt,
+    reasoningEffort: args.reasoningEffort,
+    temperature: args.temperature,
+    topP: args.topP,
+    frequencyPenalty: args.frequencyPenalty,
+    presencePenalty: args.presencePenalty,
+    maxTokens: args.maxTokens,
+    enableThinking: args.enableThinking,
+    thinkingBudget: args.thinkingBudget
+  });
+  return response.json();
+}
+async function getCliChatSession(thunkApi, args) {
+  const response = await postCliChat(thunkApi, {
+    action: "get",
+    sessionId: args.sessionId
+  });
+  return response.json();
+}
+async function closeCliChatSession(thunkApi, args) {
+  const response = await postCliChat(thunkApi, {
+    action: "close",
+    sessionId: args.sessionId
+  });
+  return response.json();
+}
+function createCliChatTurnStream(thunkApi, args, signal) {
+  return postCliChat(
+    thunkApi,
+    args.sessionId ? {
+      action: "turn",
+      sessionId: args.sessionId,
+      prompt: args.prompt,
+      model: args.model,
+      reasoningEffort: args.reasoningEffort,
+      temperature: args.temperature,
+      topP: args.topP,
+      frequencyPenalty: args.frequencyPenalty,
+      presencePenalty: args.presencePenalty,
+      maxTokens: args.maxTokens,
+      enableThinking: args.enableThinking,
+      thinkingBudget: args.thinkingBudget
+    } : {
+      prompt: args.prompt,
+      model: args.model,
+      cliProvider: args.cliProvider,
+      systemPrompt: args.systemPrompt,
+      reasoningEffort: args.reasoningEffort,
+      temperature: args.temperature,
+      topP: args.topP,
+      frequencyPenalty: args.frequencyPenalty,
+      presencePenalty: args.presencePenalty,
+      maxTokens: args.maxTokens,
+      enableThinking: args.enableThinking,
+      thinkingBudget: args.thinkingBudget
+    },
+    signal
+  );
+}
+
+// packages/chat/dialog/actions/cleanupCliSession.ts
+async function cleanupCliSessionForDialog(thunkApi, dialogConfig) {
+  const cliSessionId = dialogConfig?.cliSessionId;
+  const dialogKey = dialogConfig?.dbKey;
+  if (!cliSessionId || !dialogKey) return;
+  try {
+    await closeCliChatSession(
+      { getState: thunkApi.getState },
+      { sessionId: cliSessionId }
+    );
+  } catch {
+  }
+  try {
+    const patchResult = thunkApi.dispatch(
+      patch({
+        dbKey: dialogKey,
+        changes: {
+          cliSessionId: null
+        }
+      })
+    );
+    if (typeof patchResult?.unwrap === "function") {
+      await patchResult.unwrap();
+    } else {
+      await patchResult;
+    }
+  } catch {
+  }
+}
+
+export {
+  startCliChatSession,
+  getCliChatSession,
+  createCliChatTurnStream,
+  cleanupCliSessionForDialog
+};

package/chunk-J4576WMJ.js

@@ -0,0 +1,91 @@
+import {
+  dialogMessageKey
+} from "./chunk-PN7AFLOK.js";
+import {
+  asOptionalFiniteNumber
+} from "./chunk-WWC7I6TA.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+
+// packages/core/chat/dialogAttachmentCleanup.ts
+var FILE_CONTENT_RE = /(?:https?:\/\/[^/"'\s]+)?\/api\/v1\/db\/file\/content\/([^?#"'\s)]+)/g;
+function extractFileContentIds(value) {
+  const ids = /* @__PURE__ */ new Set();
+  const visit = (input) => {
+    if (typeof input === "string") {
+      for (const match of input.matchAll(FILE_CONTENT_RE)) {
+        const fileId = decodeURIComponent(match[1] ?? "").trim();
+        if (fileId) ids.add(fileId);
+      }
+      return;
+    }
+    if (Array.isArray(input)) {
+      for (const item of input) visit(item);
+      return;
+    }
+    if (input && typeof input === "object") {
+      for (const item of Object.values(input)) visit(item);
+    }
+  };
+  visit(value);
+  return [...ids];
+}
+function messageDbKey(dialogId, message) {
+  const dbKey = asOptionalTrimmedString(message.dbKey);
+  if (dbKey) return dbKey;
+  const id = asOptionalTrimmedString(message.id);
+  if (id) return dialogMessageKey(dialogId, id);
+  return null;
+}
+function asText(value) {
+  return asOptionalTrimmedString(value) ?? null;
+}
+function buildDialogAttachmentPlan(args) {
+  const messageKeys = new Set(
+    args.messages.map((message) => messageDbKey(args.dialogId, message)).filter((key) => Boolean(key))
+  );
+  const referencedFileIds = [
+    ...new Set(args.messages.flatMap((message) => extractFileContentIds(message)))
+  ];
+  const candidates = referencedFileIds.map((fileId) => {
+    const metadata = args.metadataByFileId[fileId];
+    const ownerType = asText(metadata?.ownerType);
+    const ownerId = asText(metadata?.ownerId);
+    const ownerDbKey = asText(metadata?.ownerDbKey);
+    const fileDbKey = asText(metadata?.dbKey);
+    const source = asText(metadata?.source);
+    const ownedByDialog = ownerType === "dialog" && ownerId === args.dialogId;
+    const ownedByMessage = Boolean(ownerDbKey && messageKeys.has(ownerDbKey));
+    const userOwnedReferenced = args.includeUserOwnedReferenced === true && Boolean(args.ownerId) && ownerType === "user" && ownerId === args.ownerId;
+    const canDelete = Boolean(fileDbKey && (ownedByDialog || ownedByMessage || userOwnedReferenced));
+    return {
+      fileId,
+      fileDbKey,
+      size: asOptionalFiniteNumber(metadata?.size) ?? null,
+      ownerType,
+      ownerId,
+      ownerDbKey,
+      source,
+      status: canDelete ? "delete" : "retain",
+      reason: canDelete ? ownedByMessage ? "ownerDbKey matches a message in this dialog" : userOwnedReferenced ? "user-owned file is referenced by this dialog and explicit referenced-attachment deletion is enabled" : "ownerType/ownerId matches this dialog" : fileDbKey ? "file ownership is not exclusive to this dialog" : "file metadata not found"
+    };
+  });
+  const deleteCandidates = candidates.filter((candidate) => candidate.status === "delete");
+  const retainedCandidates = candidates.filter((candidate) => candidate.status === "retain");
+  return {
+    dialogId: args.dialogId,
+    messageCount: args.messages.length,
+    referencedFileIds,
+    candidates,
+    deleteCandidates,
+    retainedCandidates,
+    bytesToDelete: deleteCandidates.reduce((sum, candidate) => sum + (candidate.size ?? 0), 0),
+    metadataReadFailures: args.metadataReadFailures ?? []
+  };
+}
+
+export {
+  extractFileContentIds,
+  buildDialogAttachmentPlan
+};