nolo-cli 0.6.1 → 0.8.0-alpha.10

package/chunk-5MIDPSSK.js

@@ -0,0 +1,206 @@
+import {
+  extractCustomId
+} from "./chunk-DFFIZ25G.js";
+import {
+  getActiveDialogKey
+} from "./chunk-3ASDTTEI.js";
+import {
+  compactWhitespace
+} from "./chunk-DWLEOOGR.js";
+import {
+  asTrimmedLowercaseString
+} from "./chunk-QSJ3HFEF.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
+
+// packages/ai/tools/toolApiClient.ts
+var MAIN_SERVER = "https://nolo.chat";
+var getIsDesktopApp = () => typeof window !== "undefined" && Boolean(window.__NOLO_DESKTOP__);
+var isLocalServerUrl = (value) => {
+  if (!value) return false;
+  try {
+    const hostname = new URL(value).hostname.toLowerCase();
+    return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1";
+  } catch {
+    return false;
+  }
+};
+var resolveDesktopSafeServer = (value) => {
+  if (!getIsDesktopApp()) return value || MAIN_SERVER;
+  return isLocalServerUrl(value) ? MAIN_SERVER : value || MAIN_SERVER;
+};
+var selectCurrentServerFromState = (state) => resolveDesktopSafeServer(state?.settings?.currentServer);
+var selectCurrentTokenFromState = (state) => typeof state?.auth?.currentToken === "string" ? state.auth.currentToken : null;
+var selectCurrentDialogKeyFromState = (_state) => getActiveDialogKey();
+var resolveToolBaseUrl = (currentServer) => {
+  const _window = globalThis.window;
+  if (!_window) return (currentServer || "").replace(/\/+$/, "");
+  const fallbackLocal = _window.location.origin;
+  if (!currentServer) return fallbackLocal;
+  return currentServer.replace(/\/+$/, "");
+};
+var DESKTOP_LOCAL_TOOL_PATHS = /* @__PURE__ */ new Set([
+  "/api/exec-shell",
+  "/api/check-env",
+  "/api/read-file",
+  "/api/write-file",
+  "/api/apply-edit",
+  "/api/apply-line-edits",
+  "/api/code-search",
+  "/api/search-repo",
+  "/api/desktop/files/roots",
+  "/api/desktop/files/roots/request",
+  "/api/desktop/files/list",
+  "/api/desktop/files/read",
+  "/api/desktop/files/plan",
+  "/api/desktop/files/approve",
+  "/api/desktop/files/execute",
+  "/api/desktop/files/undo",
+  "/api/desktop/files/history"
+]);
+var getWindowOrigin = () => {
+  const _window = globalThis.window;
+  const origin = _window?.location?.origin;
+  return typeof origin === "string" && origin ? origin.replace(/\/+$/, "") : null;
+};
+var resolveToolApiBaseUrl = (currentServer, path) => {
+  if (path && DESKTOP_LOCAL_TOOL_PATHS.has(path) && getIsDesktopApp()) {
+    const localOrigin = getWindowOrigin();
+    if (localOrigin) return localOrigin;
+  }
+  return resolveToolBaseUrl(currentServer);
+};
+var getRequestConfig = (thunkApi) => {
+  const state = thunkApi.getState();
+  const currentServer = selectCurrentServerFromState(state);
+  const token = selectCurrentTokenFromState(state);
+  if (!currentServer) throw new Error("\u65E0\u6CD5\u83B7\u53D6\u5F53\u524D\u670D\u52A1\u5668\u5730\u5740\u3002");
+  return { currentServer, token };
+};
+var getToolBaseUrl = (thunkApi) => {
+  const { currentServer } = getRequestConfig(thunkApi);
+  const baseUrl = resolveToolBaseUrl(currentServer);
+  if (!baseUrl) throw new Error("\u65E0\u6CD5\u83B7\u53D6\u5DE5\u5177\u670D\u52A1\u5668\u5730\u5740\u3002");
+  return baseUrl;
+};
+var getToolRequestContext = (thunkApi) => {
+  const { currentServer, token } = getRequestConfig(thunkApi);
+  const baseUrl = resolveToolBaseUrl(currentServer);
+  if (!baseUrl) throw new Error("\u65E0\u6CD5\u83B7\u53D6\u5DE5\u5177\u670D\u52A1\u5668\u5730\u5740\u3002");
+  return {
+    currentServer,
+    token,
+    baseUrl
+  };
+};
+var maybeAttachDialogId = (thunkApi, body) => {
+  if (!isRecord(body)) return body;
+  if ("dialogId" in body) return body;
+  const state = thunkApi.getState();
+  const currentDialogKey = selectCurrentDialogKeyFromState(state);
+  const dialogId = currentDialogKey ? extractCustomId(currentDialogKey) : null;
+  if (!dialogId) return body;
+  return {
+    ...body,
+    dialogId
+  };
+};
+var ToolApiError = class extends Error {
+  status;
+  code;
+  details;
+  constructor(message, options) {
+    super(message);
+    this.name = "ToolApiError";
+    this.status = options?.status;
+    this.code = options?.code;
+    this.details = options?.details;
+  }
+};
+var buildToolRequestHeaders = (thunkApi, options = {}) => {
+  const { withAuth = false, agentKey } = options;
+  const { token } = getRequestConfig(thunkApi);
+  const headers = { "Content-Type": "application/json" };
+  if (withAuth && token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  if (agentKey && typeof agentKey === "string" && agentKey.trim()) {
+    headers["X-Nolo-Agent-Key"] = agentKey.trim();
+  }
+  if (typeof window !== "undefined" && window.__NOLO_DESKTOP__) {
+    headers["X-Nolo-Desktop-Tool"] = "1";
+  }
+  return headers;
+};
+var buildResponsePreview = (text) => compactWhitespace(text).slice(0, 240);
+var looksLikeHtmlResponse = (text, contentType) => {
+  if (contentType?.toLowerCase().includes("text/html")) return true;
+  const trimmed = asTrimmedLowercaseString(text);
+  return trimmed.startsWith("<!doctype html") || trimmed.startsWith("<html");
+};
+async function callToolApi(thunkApi, path, body, options = {}) {
+  const { currentServer } = getRequestConfig(thunkApi);
+  const baseUrl = resolveToolApiBaseUrl(currentServer, path);
+  if (!baseUrl) throw new Error("\u65E0\u6CD5\u83B7\u53D6\u5DE5\u5177\u670D\u52A1\u5668\u5730\u5740\u3002");
+  const url = `${baseUrl}${path}`;
+  const headers = buildToolRequestHeaders(thunkApi, options);
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(maybeAttachDialogId(thunkApi, body))
+  });
+  const contentType = response.headers.get("content-type");
+  const responseText = await response.text();
+  if (!response.ok) {
+    let errorMessage = `API \u8BF7\u6C42\u5931\u8D25\uFF0C\u72B6\u6001\u7801: ${response.status}`;
+    let errorCode;
+    let errorDetails;
+    try {
+      const errorData = JSON.parse(responseText);
+      const err = errorData?.error;
+      if (err) {
+        errorMessage += `: ${err.message ?? JSON.stringify(err)}`;
+        errorCode = typeof err.code === "string" ? err.code : void 0;
+        errorDetails = err.details;
+      }
+    } catch {
+      errorCode = looksLikeHtmlResponse(responseText, contentType) ? "HTML_ERROR_RESPONSE" : "NON_JSON_ERROR_RESPONSE";
+      errorDetails = {
+        contentType,
+        responsePreview: buildResponsePreview(responseText)
+      };
+      if (typeof errorDetails.responsePreview === "string" && errorDetails.responsePreview) {
+        errorMessage += `: ${errorDetails.responsePreview}`;
+      }
+    }
+    throw new ToolApiError(errorMessage, {
+      status: response.status,
+      code: errorCode,
+      details: errorDetails
+    });
+  }
+  try {
+    return JSON.parse(responseText);
+  } catch {
+    throw new ToolApiError("\u670D\u52A1\u7AEF\u8FD4\u56DE\u4E86\u65E0\u6CD5\u89E3\u6790\u7684\u975E JSON \u54CD\u5E94", {
+      status: response.status,
+      code: looksLikeHtmlResponse(responseText, contentType) ? "HTML_RESPONSE" : "INVALID_JSON_RESPONSE",
+      details: {
+        contentType,
+        responsePreview: buildResponsePreview(responseText)
+      }
+    });
+  }
+}
+
+export {
+  resolveToolBaseUrl,
+  resolveToolApiBaseUrl,
+  getRequestConfig,
+  getToolBaseUrl,
+  getToolRequestContext,
+  ToolApiError,
+  buildToolRequestHeaders,
+  callToolApi
+};

package/chunk-5MMAK75Q.js

@@ -0,0 +1,15 @@
+import {
+  compactWhitespace
+} from "./chunk-DWLEOOGR.js";
+
+// packages/core/clipCompactText.ts
+function clipCompactText(value, max, ellipsis = "...") {
+  const compact = compactWhitespace(value);
+  if (compact.length <= max) return compact;
+  if (max <= ellipsis.length) return compact.slice(0, max);
+  return `${compact.slice(0, max - ellipsis.length)}${ellipsis}`;
+}
+
+export {
+  clipCompactText
+};

package/chunk-5VV37AT4.js

@@ -0,0 +1,222 @@
+import {
+  clearCliLocalRuntimePreparedAgentCache
+} from "./chunk-IHHA5Y2S.js";
+import {
+  getReadableCliDb
+} from "./chunk-W4NVOSFF.js";
+import {
+  buildCreatedAgentRecord,
+  buildUpdatedAgentRecord,
+  normalizeAgentRecordForOutput,
+  parseAgentUpdateArgs,
+  resolveAgentRecordFromHybridStore,
+  sanitizeAgentRecordForCliOutput,
+  writeAgentRecord
+} from "./chunk-FQZWM5YX.js";
+import {
+  resolveCliAgentKeyInput
+} from "./chunk-VHBWHNVT.js";
+import {
+  parseUserIdFromAuthToken,
+  resolveAuthToken
+} from "./chunk-ISNCLGUZ.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+
+// packages/cli/agentRecordCommands.ts
+async function runAgentReadCommand(args, deps = {}) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const agentInput = args[0]?.trim();
+  if (!agentInput || agentInput === "--help" || agentInput === "-h") {
+    output.write("Usage: nolo agent read <agent>\n");
+    return agentInput ? 0 : 1;
+  }
+  const authToken = resolveAuthToken(args, env);
+  if (!authToken) {
+    output.write("[nolo] agent read requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+    return 1;
+  }
+  const agentKey = resolveCliAgentKeyInput(agentInput);
+  const db = deps.db ?? await getReadableCliDb(output);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const fallbackFetchImpl = deps.fallbackFetchImpl;
+  try {
+    const result = await resolveAgentRecordFromHybridStore({
+      agentInput,
+      cliArgs: args,
+      env,
+      db,
+      fetchImpl,
+      fallbackFetchImpl
+    });
+    if (!result) {
+      throw new Error(`agent not found: ${agentKey}`);
+    }
+    output.write(JSON.stringify({
+      ...normalizeAgentRecordForOutput(result.agentKey, authToken, result.record),
+      source: result.source
+    }, null, 2));
+    output.write("\n");
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] agent read failed: ${toErrorMessage(error)}
+`
+    );
+    return 1;
+  }
+}
+async function runAgentUpdateCommand(args, deps = {}) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  let parsed;
+  try {
+    parsed = parseAgentUpdateArgs(args);
+  } catch (error) {
+    output.write(`[nolo] agent update failed: ${toErrorMessage(error)}
+`);
+    return 1;
+  }
+  if (!parsed) {
+    output.write(
+      "Usage: nolo agent update <agent> [--model <id>] [--cli-provider <provider>] [--api-source <source>] [--max-concurrent <n>] [--expires-at <iso>] [--prompt <text> | --prompt-file <path> | --prompt-doc <pageKey>] [--tools <json>] [--copy-provider-from <agent>] [--field key=value]\n".replace("[--field key=value]", `[--handle <name>] [--field key=value]  (e.g. --field disabledTools='["exa_search"]' to disable default tools)`)
+    );
+    return args[0] ? 0 : 1;
+  }
+  const authToken = resolveAuthToken(args, env);
+  if (!authToken) {
+    output.write("[nolo] agent update requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+    return 1;
+  }
+  const userId = parseUserIdFromAuthToken(authToken);
+  if (!userId) {
+    output.write("[nolo] agent update could not read userId from AUTH_TOKEN.\n");
+    return 1;
+  }
+  const db = deps.db ?? await getReadableCliDb(output);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const fallbackFetchImpl = deps.fallbackFetchImpl;
+  try {
+    const built = await buildUpdatedAgentRecord({
+      cliArgs: args,
+      parsed,
+      env,
+      db,
+      fetchImpl,
+      fallbackFetchImpl,
+      authToken
+    });
+    await writeAgentRecord({
+      agentKey: built.agentKey,
+      authToken,
+      fallbackFetchImpl,
+      fetchImpl,
+      serverUrl: built.serverUrl,
+      userId,
+      record: built.nextRecord
+    });
+    await db.put(built.agentKey, {
+      ...built.nextRecord,
+      dbKey: built.agentKey,
+      key: built.nextRecord?.key || built.agentKey,
+      serverOrigin: built.serverUrl
+    });
+    clearCliLocalRuntimePreparedAgentCache();
+    output.write(JSON.stringify({
+      ok: true,
+      agentKey: built.agentKey,
+      baseUrl: built.serverUrl,
+      updates: sanitizeAgentRecordForCliOutput(built.updates),
+      record: sanitizeAgentRecordForCliOutput(built.nextRecord)
+    }, null, 2));
+    output.write("\n");
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] agent update failed: ${toErrorMessage(error)}
+`
+    );
+    return 1;
+  }
+}
+async function runAgentCreateCommand(args, deps = {}) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  let parsed;
+  try {
+    parsed = parseAgentUpdateArgs(args);
+  } catch (error) {
+    output.write(`[nolo] agent create failed: ${toErrorMessage(error)}
+`);
+    return 1;
+  }
+  if (!parsed) {
+    output.write(
+      "Usage: nolo agent create <agent> [--model <id>] [--cli-provider <provider>] [--api-source <source>] [--max-concurrent <n>] [--expires-at <iso>] [--prompt <text> | --prompt-file <path> | --prompt-doc <pageKey>] [--tools <json>] [--copy-provider-from <agent>] [--name <name>] [--custom-provider-url <url>] [--provider-api-key <key>] [--field key=value]\n".replace("[--field key=value]", "[--handle <name>] [--field key=value]")
+    );
+    return args[0] ? 0 : 1;
+  }
+  const authToken = resolveAuthToken(args, env);
+  if (!authToken) {
+    output.write("[nolo] agent create requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+    return 1;
+  }
+  const userId = parseUserIdFromAuthToken(authToken);
+  if (!userId) {
+    output.write("[nolo] agent create could not read userId from AUTH_TOKEN.\n");
+    return 1;
+  }
+  const db = deps.db ?? await getReadableCliDb(output);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const fallbackFetchImpl = deps.fallbackFetchImpl;
+  try {
+    const built = await buildCreatedAgentRecord({
+      cliArgs: args,
+      parsed,
+      env,
+      db,
+      fetchImpl,
+      fallbackFetchImpl,
+      authToken
+    });
+    await writeAgentRecord({
+      agentKey: built.agentKey,
+      authToken,
+      fallbackFetchImpl,
+      fetchImpl,
+      serverUrl: built.serverUrl,
+      userId,
+      record: built.nextRecord
+    });
+    await db.put(built.agentKey, {
+      ...built.nextRecord,
+      dbKey: built.agentKey,
+      key: built.nextRecord?.key || built.agentKey,
+      serverOrigin: built.serverUrl
+    });
+    clearCliLocalRuntimePreparedAgentCache();
+    output.write(JSON.stringify({
+      ok: true,
+      agentKey: built.agentKey,
+      baseUrl: built.serverUrl,
+      updates: sanitizeAgentRecordForCliOutput(built.updates),
+      record: sanitizeAgentRecordForCliOutput(built.nextRecord)
+    }, null, 2));
+    output.write("\n");
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] agent create failed: ${toErrorMessage(error)}
+`
+    );
+    return 1;
+  }
+}
+
+export {
+  runAgentReadCommand,
+  runAgentUpdateCommand,
+  runAgentCreateCommand
+};

package/chunk-63W5N6P3.js

@@ -0,0 +1,150 @@
+// packages/create/editor/transforms/slateToRenderMarkdown.ts
+function renderTextNode(node) {
+  if (!node || typeof node.text !== "string") return "";
+  let text = node.text;
+  if (!text) return "";
+  if (node.bold) text = `**${text}**`;
+  if (node.italic) text = `*${text}*`;
+  if (node.strikethrough) text = `~~${text}~~`;
+  return text;
+}
+function renderPlainText(node, options = {}) {
+  if (!node) return "";
+  if (typeof node.text === "string") return renderTextNode(node);
+  if (!Array.isArray(node.children)) return "";
+  return node.children.map((child) => renderPlainText(child, options)).join("");
+}
+function renderTable(node, options) {
+  const rows = Array.isArray(node.children) ? node.children : [];
+  if (rows.length === 0) return "";
+  const alignments = Array.isArray(node.columns) ? node.columns.map((column) => column?.align || "left") : [];
+  const renderedRows = rows.map(
+    (row) => (Array.isArray(row?.children) ? row.children : []).map((cell) => {
+      const content = renderPlainText(cell, options).replace(/\n+/g, " ").trim();
+      return content || " ";
+    })
+  );
+  const header = renderedRows[0] || [];
+  const divider = header.map((_, index) => {
+    const align = alignments[index];
+    if (align === "center") return ":---:";
+    if (align === "right") return "---:";
+    return "---";
+  });
+  const body = renderedRows.slice(1);
+  return [header, divider, ...body].map((cells) => `| ${cells.join(" | ")} |`).join("\n") + "\n\n";
+}
+function renderListItem(node, listDepth, ordered, start, index, options = {}) {
+  const indentation = "  ".repeat(listDepth);
+  const marker = node.checked === true ? "- [x]" : node.checked === false ? "- [ ]" : ordered ? `${start + index}.` : "-";
+  const segments = Array.isArray(node.children) ? node.children : [];
+  const renderedSegments = segments.flatMap((child) => {
+    const rendered = renderNode(child, listDepth + 1, options).trimEnd();
+    return rendered ? [rendered] : [];
+  });
+  if (renderedSegments.length === 0) {
+    return `${indentation}${marker}
+`;
+  }
+  const [first, ...rest] = renderedSegments;
+  const lines = first.split("\n");
+  const firstLine = lines.shift() || "";
+  const restFirst = lines.map((line) => `${indentation}  ${line}`).join("\n");
+  const restBlocks = rest.map((block) => `${indentation}  ${block}`).join("\n");
+  return [
+    `${indentation}${marker} ${firstLine}`,
+    restFirst,
+    restBlocks
+  ].filter(Boolean).join("\n") + "\n";
+}
+function renderNode(node, listDepth = 0, options = {}) {
+  if (!node) return "";
+  switch (node.type) {
+    case "heading-one":
+      return `# ${node.children.map((n) => renderNode(n, listDepth, options)).join("")}
+
+`;
+    case "heading-two":
+      return `## ${node.children.map((n) => renderNode(n, listDepth, options)).join("")}
+
+`;
+    case "heading-three":
+      return `### ${node.children.map((n) => renderNode(n, listDepth, options)).join("")}
+
+`;
+    case "heading-four":
+      return `#### ${node.children.map((n) => renderNode(n, listDepth, options)).join("")}
+
+`;
+    case "heading-five":
+      return `##### ${node.children.map((n) => renderNode(n, listDepth, options)).join("")}
+
+`;
+    case "heading-six":
+      return `###### ${node.children.map((n) => renderNode(n, listDepth, options)).join("")}
+
+`;
+    case "paragraph":
+      return `${node.children.map((n) => renderNode(n, listDepth, options)).join("")}
+
+`;
+    case "list":
+      return node.children.map(
+        (item, index) => renderListItem(item, listDepth, !!node.ordered, node.start || 1, index, options)
+      ).join("");
+    case "list-item":
+      return renderListItem(node, listDepth, false, 1, 0, options);
+    case "quote": {
+      const content = node.children.map((n) => renderNode(n, listDepth, options)).join("").trim();
+      return `> ${content.replace(/\n/g, "\n> ")}
+
+`;
+    }
+    case "code-block": {
+      const code = node.children.map(
+        (line) => (line.children || []).map((text) => text.text).join("")
+      ).join("\n");
+      return "```" + (node.language || "") + "\n" + code + "\n```\n\n";
+    }
+    case "link": {
+      const linkText = node.children.map((n) => renderNode(n, listDepth, options)).join("");
+      return `[${linkText}](${node.url})`;
+    }
+    case "table":
+      return renderTable(node, options);
+    case "code-inline":
+      return `\`${node.children.map((n) => renderNode(n, listDepth, options)).join("")}\``;
+    case "mention": {
+      if (options.mentionResolver) {
+        return options.mentionResolver(node);
+      }
+      const label = node.label || node.resourceId || "mention";
+      const resourceType = node.resourceType || "unknown";
+      const resourceId = node.resourceId || "unknown";
+      return `@[${resourceType}:${resourceId}|${label}]`;
+    }
+    case "image": {
+      const alt = node.alt || "";
+      const title = node.title ? ` "${node.title}"` : "";
+      return `![${alt}](${node.url || ""}${title})`;
+    }
+    case "html-inline":
+      return typeof node.html === "string" ? node.html : "";
+    case "html-block":
+      return typeof node.html === "string" ? `${node.html}
+
+` : "";
+    case "thematic-break":
+      return "---\n\n";
+    default:
+      return renderTextNode(node) || (node.children ? node.children.map((child) => renderNode(child, listDepth, options)).join("") : "");
+  }
+}
+function slateToRenderMarkdown(nodes, options = {}) {
+  if (!nodes || nodes.length === 0) return "";
+  return nodes.map((node) => renderNode(node, 0, options)).join("").trim() + "\n";
+}
+
+export {
+  slateToRenderMarkdown
+};