nolo-cli 0.8.0-alpha.2 → 0.8.0-alpha.21

package/chunk-OLZBQWZU.js

@@ -0,0 +1,6 @@
+// packages/cli/defaultServer.ts
+var DEFAULT_NOLO_SERVER_URL = "https://nolo.chat";
+
+export {
+  DEFAULT_NOLO_SERVER_URL
+};

package/chunk-OOSFSFMA.js

@@ -0,0 +1,271 @@
+import {
+  API_ENDPOINTS,
+  NOLO_CLUSTER_SERVERS,
+  isLocalDevServerOrigin,
+  isNoloClusterServerOrigin,
+  normalizeKnownServerOrigin
+} from "./chunk-LCBAMY2M.js";
+import {
+  normalizeServerOrigin
+} from "./chunk-CF7PE763.js";
+
+// packages/app/utils/env.ts
+var processEnv = typeof process !== "undefined" ? process.env : void 0;
+var reactNativeDev = typeof globalThis !== "undefined" && "__DEV__" in globalThis ? globalThis.__DEV__ : void 0;
+var isProduction = processEnv?.NOLO_FORCE_PRODUCTION === "1" || processEnv?.NODE_ENV === "production" || reactNativeDev === false;
+var getIsDesktopApp = () => (typeof process !== "undefined" ? process.env?.NOLO_DESKTOP : processEnv?.NOLO_DESKTOP) === "1" || typeof window !== "undefined" && window.__NOLO_DESKTOP__ === true;
+var isDesktopApp = getIsDesktopApp();
+
+// packages/core/abortError.ts
+function isAbortError(error) {
+  if (!error || typeof error !== "object") return false;
+  return error.name === "AbortError";
+}
+
+// packages/core/clientLogger.ts
+var LOG_LEVELS = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+var serializeValue = (value, seen = /* @__PURE__ */ new WeakSet()) => {
+  if (value instanceof Error) {
+    return {
+      name: value.name,
+      message: value.message,
+      ...value.stack ? { stack: value.stack } : {}
+    };
+  }
+  if (typeof value !== "object" || value === null) {
+    if (typeof value === "bigint") {
+      return value.toString();
+    }
+    return value;
+  }
+  if (seen.has(value)) {
+    return "[Circular]";
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    return value.map((item) => serializeValue(item, seen));
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, item]) => [key, serializeValue(item, seen)])
+  );
+};
+var getLogLevel = () => {
+  const configured = typeof process !== "undefined" && typeof process.env?.NOLO_LOG_LEVEL === "string" ? process.env.NOLO_LOG_LEVEL : "info";
+  return LOG_LEVELS[configured] ?? LOG_LEVELS.info;
+};
+var writeLog = (level, name, fields, message) => {
+  if (LOG_LEVELS[level] < getLogLevel()) {
+    return;
+  }
+  const serializedFields = serializeValue(fields);
+  const payload = {
+    level,
+    ...name ? { name } : {},
+    ...serializedFields,
+    ...message ? { msg: message } : {}
+  };
+  const output = JSON.stringify(payload);
+  const isNodeRuntime = typeof process !== "undefined" && typeof process.stderr?.write === "function";
+  if (isNodeRuntime) {
+    process.stderr.write(`${output}
+`);
+    return;
+  }
+  const consoleMethod = console[level] ?? console.log;
+  if (Object.keys(fields).length === 0 && message) {
+    consoleMethod(`[${name}] ${message}`);
+  } else {
+    consoleMethod(output);
+  }
+};
+var parseArgs = (first, second) => {
+  if (typeof first === "string") {
+    return { fields: {}, message: first };
+  }
+  return { fields: first ?? {}, message: second };
+};
+var createClientLogger = (name, parentFields = {}) => {
+  const log = (level, first, second) => {
+    const { fields, message } = parseArgs(first, second);
+    writeLog(level, name, { ...parentFields, ...fields }, message);
+  };
+  return {
+    debug: (first, second) => log("debug", first, second),
+    info: (first, second) => log("info", first, second),
+    warn: (first, second) => log("warn", first, second),
+    error: (first, second) => log("error", first, second),
+    child: (fields) => createClientLogger(name, { ...parentFields, ...fields })
+  };
+};
+
+// packages/app/utils/retryFetch.ts
+var TRANSIENT_READ_RETRY_STATUSES = /* @__PURE__ */ new Set([502, 503, 504]);
+var DEFAULT_RETRY_DELAYS_MS = [300, 1e3];
+var sleep = (ms) => new Promise((resolve) => {
+  setTimeout(resolve, ms);
+});
+var getRequestMethod = (input, init) => {
+  if (init?.method) return init.method.toUpperCase();
+  if (typeof Request !== "undefined" && input instanceof Request) {
+    return input.method.toUpperCase();
+  }
+  return "GET";
+};
+var isRetryableReadMethod = (method) => method === "GET" || method === "HEAD";
+var fetchWithTransientReadRetry = async (input, init, options = {}) => {
+  const method = getRequestMethod(input, init);
+  const canRetry = isRetryableReadMethod(method);
+  const delaysMs = options.delaysMs ?? DEFAULT_RETRY_DELAYS_MS;
+  const retryStatuses = options.retryStatuses ?? TRANSIENT_READ_RETRY_STATUSES;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const wait = options.sleep ?? sleep;
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      const response = await fetchImpl(input, init);
+      const shouldRetry = canRetry && retryStatuses.has(response.status) && attempt < delaysMs.length;
+      if (!shouldRetry) return response;
+    } catch (error) {
+      const shouldRetry = canRetry && !isAbortError(error) && attempt < delaysMs.length;
+      if (!shouldRetry) throw error;
+    }
+    await wait(delaysMs[attempt]);
+  }
+};
+
+// packages/database/levelNotFoundError.ts
+function isLevelNotFoundError(error) {
+  if (!error || typeof error !== "object") return false;
+  const e = error;
+  return e.notFound === true || e.name === "NotFoundError" || e.code === "LEVEL_NOT_FOUND" || e.code === "LEVEL_NOT_FOUND_ERROR" || e.message === "NotFound";
+}
+
+// packages/database/actions/common.ts
+var logger = createClientLogger("database");
+var normalizeServer = (server) => normalizeKnownServerOrigin(server) ?? normalizeServerOrigin(server);
+var mergeConfiguredServers = (currentServer, syncServers) => {
+  const runtimeOrigin = !getIsDesktopApp() && typeof window !== "undefined" && typeof window.location?.origin === "string" && /^https?:\/\//.test(window.location.origin) ? window.location.origin : void 0;
+  const raw = [
+    currentServer,
+    ...Array.isArray(syncServers) ? syncServers : [],
+    runtimeOrigin
+  ].filter(
+    (s) => typeof s === "string" && s.trim().length > 0
+  );
+  const normalized = raw.map(normalizeServer);
+  const shouldIncludeClusterPeers = normalized.some(isNoloClusterServerOrigin) || typeof currentServer === "string" && isLocalDevServerOrigin(currentServer);
+  if (shouldIncludeClusterPeers) {
+    normalized.push(...NOLO_CLUSTER_SERVERS);
+  }
+  return Array.from(new Set(normalized));
+};
+var getAllServers = (currentServer, syncServers, preferredServer) => {
+  const preferredNormalized = typeof preferredServer === "string" && preferredServer.trim().length > 0 ? normalizeServer(preferredServer) : null;
+  const servers = mergeConfiguredServers(
+    currentServer,
+    preferredNormalized && isNoloClusterServerOrigin(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;
+};
+var fetchFromClientDb = async (clientDb, dbKey) => {
+  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;
+  }
+};
+var SERVER_TIMEOUT = 5e3;
+var READ_TIMEOUT_ERROR_NAME = "ReadTimeoutError";
+var isPublicFileDbKey = (dbKey) => dbKey.startsWith("file-");
+var buildReadUrl = (dbKey) => isPublicFileDbKey(dbKey) ? `${API_ENDPOINTS.DATABASE}/file/metadata/${encodeURIComponent(dbKey)}` : `${API_ENDPOINTS.DATABASE}/read/${encodeURIComponent(dbKey)}`;
+var createReadTimeoutError = (server, dbKey) => {
+  const error = new Error(
+    `Timed out reading key "${dbKey}" from ${normalizeServer(server)}.`
+  );
+  error.name = READ_TIMEOUT_ERROR_NAME;
+  return error;
+};
+var isReadTimeoutError = (error) => error instanceof Error && error.name === READ_TIMEOUT_ERROR_NAME;
+var fetchFromServer = async (server, dbKey, token, signal) => {
+  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 fetchWithTransientReadRetry(
+      `${server}${buildReadUrl(dbKey)}`,
+      {
+        signal: controller.signal,
+        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) {
+    clearTimeout(timeoutId);
+    signal?.removeEventListener("abort", onExternalAbort);
+    if (didTimeout) {
+      throw createReadTimeoutError(server, dbKey);
+    }
+    if (signal?.aborted || isAbortError(err)) {
+      throw err;
+    }
+    return null;
+  }
+};
+var normalizeTimeFields = (data) => ({
+  ...data,
+  createdAt: data.createdAt || (/* @__PURE__ */ new Date()).toISOString(),
+  updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+  updated_at: void 0,
+  created_at: void 0
+});
+
+export {
+  isProduction,
+  getIsDesktopApp,
+  createClientLogger,
+  isAbortError,
+  fetchWithTransientReadRetry,
+  logger,
+  getAllServers,
+  fetchFromClientDb,
+  isReadTimeoutError,
+  fetchFromServer,
+  normalizeTimeFields
+};

package/chunk-OPZYGHUC.js

@@ -0,0 +1,89 @@
+// packages/agent-runtime/thinkTagParser.ts
+var OPEN_TAG = "<think>";
+var CLOSE_TAG = "</think>";
+function longestTagPrefixLength(buffer, tag) {
+  const max = Math.min(buffer.length, tag.length - 1);
+  for (let len = max; len > 0; len--) {
+    if (tag.startsWith(buffer.slice(-len))) {
+      return len;
+    }
+  }
+  return 0;
+}
+function extractThinkContent(content) {
+  const regex = new RegExp(`${OPEN_TAG}([\\s\\S]*?)${CLOSE_TAG}`, "g");
+  const matches = [...content.matchAll(regex)];
+  if (matches.length === 0) {
+    return { content };
+  }
+  const reasoning = matches.map((m) => m[1]).join("\n");
+  const cleaned = content.replace(regex, "");
+  return { content: cleaned.replace(/^\n/, ""), reasoning };
+}
+function createThinkParserState() {
+  return { mode: "content", buffer: "", trimNextVisible: false };
+}
+function processThinkChunk(chunk, state) {
+  let visible = "";
+  let reasoning = "";
+  let { mode, buffer, trimNextVisible } = state;
+  buffer += chunk;
+  while (true) {
+    if (mode === "content") {
+      const idx = buffer.indexOf(OPEN_TAG);
+      if (idx === -1) {
+        const keep = longestTagPrefixLength(buffer, OPEN_TAG);
+        visible += buffer.slice(0, buffer.length - keep);
+        buffer = buffer.slice(buffer.length - keep);
+        break;
+      }
+      visible += buffer.slice(0, idx);
+      buffer = buffer.slice(idx + OPEN_TAG.length);
+      mode = "reasoning";
+    } else {
+      const idx = buffer.indexOf(CLOSE_TAG);
+      if (idx === -1) {
+        const keep = longestTagPrefixLength(buffer, CLOSE_TAG);
+        reasoning += buffer.slice(0, buffer.length - keep);
+        buffer = buffer.slice(buffer.length - keep);
+        break;
+      }
+      reasoning += buffer.slice(0, idx);
+      buffer = buffer.slice(idx + CLOSE_TAG.length);
+      mode = "content";
+      trimNextVisible = true;
+    }
+  }
+  if (mode === "content" && visible.length > 0 && trimNextVisible) {
+    visible = visible.replace(/^\n/, "");
+    trimNextVisible = false;
+  }
+  return { content: visible, reasoning, state: { mode, buffer, trimNextVisible } };
+}
+function flushThinkParser(state) {
+  const { mode, buffer, trimNextVisible } = state;
+  if (mode === "reasoning") {
+    return {
+      content: "",
+      reasoning: buffer,
+      state: { mode: "content", buffer: "", trimNextVisible: false }
+    };
+  }
+  let visible = buffer;
+  const nextTrim = trimNextVisible;
+  if (nextTrim) {
+    visible = visible.replace(/^\n/, "");
+  }
+  return {
+    content: visible,
+    reasoning: "",
+    state: { mode: "content", buffer: "", trimNextVisible: false }
+  };
+}
+
+export {
+  extractThinkContent,
+  createThinkParserState,
+  processThinkChunk,
+  flushThinkParser
+};

package/chunk-OWOHNGCN.js

@@ -0,0 +1,50 @@
+import {
+  compactWhitespace
+} from "./chunk-DWLEOOGR.js";
+
+// packages/chat/dialog/dialogTitle.ts
+var GENERATED_DIALOG_TITLE_MAX_CHARS = 36;
+var FALLBACK_DIALOG_TITLE_MAX_CHARS = 24;
+var WRAPPING_QUOTES_RE = /^[`"'“”‘’「」『』《》]+|[`"'“”‘’「」『』《》]+$/gu;
+var TRAILING_TITLE_PUNCTUATION_RE = /[。！？!?；;，,、：:]+$/u;
+var clip = (text, maxChars) => text.length <= maxChars ? text : `${text.slice(0, maxChars - 1).trimEnd()}\u2026`;
+var toSingleLine = (value) => value.replace(/\r\n?/g, "\n").split("\n").map((line) => line.trim()).find(Boolean) ?? "";
+var stripTitleFormatting = (value) => value.replace(/^(?:[-*#>]+\s*|\d+\.\s+)/, "").replace(WRAPPING_QUOTES_RE, "").replace(TRAILING_TITLE_PUNCTUATION_RE, "").trim();
+var pickLeadingClause = (value) => {
+  const firstLine = toSingleLine(value);
+  if (!firstLine) return "";
+  const separatorIndexes = [firstLine.indexOf("\uFF1A"), firstLine.indexOf(":")].filter((index) => index > 0).sort((left, right) => left - right);
+  for (const index of separatorIndexes) {
+    const clause = firstLine.slice(0, index).trim();
+    if (clause.length >= 4) return clause;
+  }
+  return firstLine;
+};
+var normalizeDialogTitle = (rawTitle, maxChars = GENERATED_DIALOG_TITLE_MAX_CHARS) => {
+  if (typeof rawTitle !== "string") return "";
+  const normalized = stripTitleFormatting(
+    compactWhitespace(toSingleLine(rawTitle))
+  );
+  if (!normalized) return "";
+  return clip(normalized, maxChars);
+};
+var buildDialogFallbackTitleFromUserInput = (userInput, maxChars = FALLBACK_DIALOG_TITLE_MAX_CHARS) => {
+  if (typeof userInput !== "string") return "";
+  const candidate = pickLeadingClause(userInput);
+  return normalizeDialogTitle(candidate || userInput, maxChars);
+};
+var buildDialogFallbackTitleFromMessages = (messages) => {
+  for (const message of messages) {
+    if (message?.role !== "user") continue;
+    const title = buildDialogFallbackTitleFromUserInput(message?.content);
+    if (title) return title;
+  }
+  return "";
+};
+var resolveDialogTitle = (generatedTitle, fallbackTitle) => normalizeDialogTitle(generatedTitle) || fallbackTitle.trim();
+
+export {
+  normalizeDialogTitle,
+  buildDialogFallbackTitleFromMessages,
+  resolveDialogTitle
+};