nolo-cli 0.8.0 → 0.9.1

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-5PJ3VWCS.js

@@ -0,0 +1,360 @@
+import {
+  readDbRecord,
+  writeAgentRecord
+} from "./chunk-7OOXPE3N.js";
+import {
+  buildSkillSummaryMarker
+} from "./chunk-VF4K2QE6.js";
+import {
+  buildSkillDocMarkdown
+} from "./chunk-ZQ2UM4KG.js";
+import {
+  createSpaceKey
+} from "./chunk-UAD2WT54.js";
+import {
+  parseUserIdFromAuthToken,
+  readOption,
+  resolveAuthToken,
+  resolveServerUrl
+} from "./chunk-ISNCLGUZ.js";
+import {
+  require_index_umd
+} from "./chunk-SH2CFQOH.js";
+import {
+  asTrimmedLowercaseString
+} from "./chunk-QSJ3HFEF.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 {
+  __toESM
+} from "./chunk-4VNS5WPM.js";
+
+// packages/cli/docPageHelpers.ts
+var import_ulid = __toESM(require_index_umd(), 1);
+import { readFileSync } from "node:fs";
+function getCliArg(args, flag) {
+  const idx = args.indexOf(flag);
+  return idx !== -1 ? args[idx + 1] : void 0;
+}
+function readBodyArg(args, fallback = "") {
+  const bodyFile = getCliArg(args, "--body-file");
+  if (bodyFile !== void 0) {
+    return readFileSync(bodyFile, "utf8");
+  }
+  return getCliArg(args, "--body") ?? fallback;
+}
+function textToSlate(text) {
+  return text.split("\n").map((line) => ({
+    type: "paragraph",
+    children: [{ text: line }]
+  }));
+}
+function createPageId() {
+  return (0, import_ulid.ulid)();
+}
+function buildPageKey(userId, pageId) {
+  return `page-${userId}-${pageId}`;
+}
+function buildPageRecord(args) {
+  const { dbKey, pageId, title, spaceId, content, existing, meta, slateData } = args;
+  const now = Date.now();
+  const createdAt = typeof existing?.createdAt === "number" ? existing.createdAt : now;
+  const created = typeof existing?.created === "string" ? existing.created : new Date(createdAt).toISOString();
+  const nextRecord = {
+    ...existing ?? {},
+    id: existing?.id ?? pageId,
+    dbKey,
+    type: "page",
+    title,
+    spaceId,
+    content,
+    updatedAt: now,
+    createdAt,
+    created
+  };
+  if (meta !== void 0) {
+    if (meta === null) {
+      delete nextRecord.meta;
+    } else {
+      nextRecord.meta = meta;
+    }
+  }
+  if (slateData !== void 0) {
+    if (slateData === null) {
+      delete nextRecord.slateData;
+    } else {
+      nextRecord.slateData = slateData;
+    }
+  } else if (!existing?.slateData) {
+    nextRecord.slateData = textToSlate(content);
+  }
+  return nextRecord;
+}
+
+// packages/cli/docSkillHelpers.ts
+function normalizeSkillSeed(input) {
+  return input.trim().toLowerCase().replace(/[^a-z0-9\u4e00-\u9fa5]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function deterministicId(prefix, seed) {
+  let h = 2166136261;
+  for (let i = 0; i < seed.length; i++) {
+    h ^= seed.charCodeAt(i);
+    h = h * 16777619 >>> 0;
+  }
+  const suffix = h.toString(36).toUpperCase().padStart(14, "0");
+  return (prefix + suffix).slice(0, 26);
+}
+function buildSkillDocId(input) {
+  return deterministicId("01SK", normalizeSkillSeed(input) || input);
+}
+function buildSkillPageKey(userId, skillId) {
+  return buildPageKey(userId, skillId);
+}
+function buildSkillPageRecord(args) {
+  const {
+    dbKey,
+    skillId,
+    title,
+    spaceId,
+    body,
+    skillConfig,
+    evalConfig,
+    workflowConfig,
+    existing
+  } = args;
+  return {
+    ...buildPageRecord({
+      dbKey,
+      pageId: skillId,
+      title,
+      spaceId,
+      content: buildSkillDocMarkdown({
+        body,
+        skillConfig,
+        evalConfig,
+        workflowConfig
+      }),
+      existing,
+      meta: {
+        ...existing?.meta ?? {},
+        kind: "skill",
+        skillConfig,
+        ...evalConfig ? { evalConfig } : {},
+        ...workflowConfig ? { workflowConfig } : {}
+      },
+      slateData: null
+    })
+  };
+}
+function parseJsonArg(raw, fallback) {
+  if (raw === void 0) return fallback;
+  return JSON.parse(raw);
+}
+
+// packages/cli/docSpaceHelpers.ts
+async function ensurePageAttachedToSpace(params) {
+  const { baseUrl, userId, authToken, spaceId, contentKey, title, skillSummary } = params;
+  const spaceKey = createSpaceKey.space(spaceId);
+  const spaceRecord = await readDbRecord({
+    dbKey: spaceKey,
+    authToken,
+    fetchImpl: fetch,
+    serverUrl: baseUrl
+  });
+  const now = Date.now();
+  await writeAgentRecord({
+    agentKey: spaceKey,
+    authToken,
+    fetchImpl: fetch,
+    serverUrl: baseUrl,
+    userId,
+    record: {
+      ...spaceRecord,
+      contents: {
+        ...spaceRecord.contents ?? {},
+        [contentKey]: {
+          ...spaceRecord.contents?.[contentKey] ?? {},
+          title,
+          type: "page",
+          contentKey,
+          ...skillSummary !== void 0 ? { skillSummary } : {},
+          updatedAt: now,
+          createdAt: spaceRecord.contents?.[contentKey]?.createdAt ?? now
+        }
+      },
+      updatedAt: now
+    }
+  });
+}
+async function removePageFromSpace(params) {
+  const { baseUrl, userId, authToken, spaceId, contentKey } = params;
+  const spaceKey = createSpaceKey.space(spaceId);
+  const spaceRecord = await readDbRecord({
+    dbKey: spaceKey,
+    authToken,
+    fetchImpl: fetch,
+    serverUrl: baseUrl
+  });
+  const nextContents = { ...spaceRecord.contents ?? {} };
+  delete nextContents[contentKey];
+  await writeAgentRecord({
+    agentKey: spaceKey,
+    authToken,
+    fetchImpl: fetch,
+    serverUrl: baseUrl,
+    userId,
+    record: {
+      ...spaceRecord,
+      contents: nextContents,
+      updatedAt: Date.now()
+    }
+  });
+}
+
+// packages/cli/docCommandShared.ts
+function hasHelpArg(args) {
+  return args.includes("--help") || args.includes("-h");
+}
+function hasFlag(args, flag) {
+  return args.includes(flag);
+}
+function normalizeBaseUrl(base) {
+  return normalizeServerOrigin(base);
+}
+function localBaseFromEnv(env) {
+  return normalizeBaseUrl(env.SCRIPT_LOCAL_BASE_URL || DEFAULT_LOCAL_API_ORIGIN);
+}
+function targetToBase(target, env) {
+  const normalized = asTrimmedLowercaseString(target);
+  if (normalized === "local") return localBaseFromEnv(env);
+  if (normalized === "main") return normalizeBaseUrl(NOLO_CLUSTER_SERVERS[0]);
+  if (normalized === "us") return normalizeBaseUrl(NOLO_CLUSTER_SERVERS[1]);
+  return normalizeBaseUrl(target);
+}
+function parseSyncTargets(raw, env) {
+  if (!raw) return void 0;
+  return raw.split(",").map((value) => value.trim()).filter(Boolean).filter((value) => value !== "none").map((value) => targetToBase(value, env));
+}
+function isLocalBaseUrl(baseUrl) {
+  try {
+    const hostname = new URL(baseUrl).hostname;
+    return hostname === "localhost" || hostname === "127.0.0.1";
+  } catch {
+    return false;
+  }
+}
+function resolveWriteTargets(args, env) {
+  const explicitSync = parseSyncTargets(readOption(args, "--sync"), env);
+  const targets = hasFlag(args, "--local-only") ? [localBaseFromEnv(env)] : explicitSync ?? [resolveServerUrl(args, env)];
+  const filtered = hasFlag(args, "--no-local") ? targets.filter((target) => !isLocalBaseUrl(target)) : targets;
+  return Array.from(new Set(filtered.map(normalizeBaseUrl)));
+}
+function readTitle(args) {
+  const valueFlags = /* @__PURE__ */ new Set([
+    "--title",
+    "--name",
+    "--description",
+    "--body",
+    "--body-file",
+    "--space",
+    "--id",
+    "--key",
+    "--kind",
+    "--sync",
+    "--tools",
+    "--required-skills",
+    "--recommended-skills",
+    "--preferred-agents",
+    "--trigger-mode",
+    "--budget-tier",
+    "--prompt-patch",
+    "--token",
+    "--server"
+  ]);
+  return readOption(args, "--title") ?? args.find((value, index) => {
+    if (index === 0) return false;
+    if (valueFlags.has(args[index - 1])) return false;
+    return !value.startsWith("-");
+  });
+}
+function resolveDocKind(args, fallback) {
+  if (hasFlag(args, "--page") || readOption(args, "--kind") === "page") return "page";
+  return fallback;
+}
+function requireTokenUser(args, env, dryRun) {
+  const authToken = resolveAuthToken(args, env);
+  const userId = parseUserIdFromAuthToken(authToken) || env.USER_ID || "";
+  if (!authToken && !dryRun) {
+    throw new Error("doc command requires an auth token. Pass --token or set AUTH_TOKEN.");
+  }
+  if (!userId && !dryRun) {
+    throw new Error("auth token does not contain userId. Pass a user-scoped token.");
+  }
+  return {
+    authToken,
+    userId: userId || "dry-run"
+  };
+}
+async function writePageRecord(args) {
+  await writeAgentRecord({
+    agentKey: args.dbKey,
+    authToken: args.authToken,
+    fetchImpl: fetch,
+    serverUrl: args.serverUrl,
+    userId: args.userId,
+    record: args.record
+  });
+  if (args.spaceId) {
+    await ensurePageAttachedToSpace({
+      baseUrl: args.serverUrl,
+      userId: args.userId,
+      authToken: args.authToken,
+      spaceId: args.spaceId,
+      contentKey: args.dbKey,
+      title: args.title,
+      skillSummary: args.skillSummary
+    });
+  }
+}
+async function readPageRecord(args) {
+  return readDbRecord({
+    dbKey: args.dbKey,
+    authToken: args.authToken,
+    fetchImpl: fetch,
+    serverUrl: args.serverUrl
+  });
+}
+function buildSkillSummaryForRecord(record) {
+  const meta = record?.meta;
+  const skillConfig = meta?.skillConfig;
+  if (!skillConfig) return void 0;
+  return buildSkillSummaryMarker(meta);
+}
+
+export {
+  readBodyArg,
+  createPageId,
+  buildPageKey,
+  buildPageRecord,
+  buildSkillDocId,
+  buildSkillPageKey,
+  buildSkillPageRecord,
+  parseJsonArg,
+  removePageFromSpace,
+  hasHelpArg,
+  hasFlag,
+  resolveWriteTargets,
+  readTitle,
+  resolveDocKind,
+  requireTokenUser,
+  writePageRecord,
+  readPageRecord,
+  buildSkillSummaryForRecord
+};