nolo-cli 0.32.0 → 0.33.0-alpha.2

package/chunk-HS7MLR74.js

@@ -0,0 +1,38 @@
+// packages/shared/providerSecrets.ts
+function providerSecretKey(presetId) {
+  const normalized = presetId.trim().replace(/[^a-zA-Z0-9]+/g, "_").toUpperCase();
+  return `${normalized}_KEY`;
+}
+
+// packages/ai/agent/providerSecrets.ts
+var STORAGE_KEY = "nolo-local-secrets";
+function readLocalSecrets() {
+  if (typeof localStorage === "undefined") return {};
+  try {
+    const value = JSON.parse(localStorage.getItem(STORAGE_KEY) ?? "{}");
+    return value && typeof value === "object" ? value : {};
+  } catch {
+    return {};
+  }
+}
+function getLocalProviderSecret(presetId) {
+  return readLocalSecrets()[providerSecretKey(presetId)] ?? null;
+}
+async function getServerProviderSecret(args) {
+  try {
+    const response = await fetch(
+      `${args.serverOrigin}/api/user-secrets/get?presetId=${encodeURIComponent(args.presetId)}`,
+      { cache: "no-store", headers: { Authorization: `Bearer ${args.token}` } }
+    );
+    if (!response.ok) return null;
+    const body = await response.json();
+    return body.value ?? null;
+  } catch {
+    return null;
+  }
+}
+
+export {
+  getLocalProviderSecret,
+  getServerProviderSecret
+};

package/{chunk-3AUWC6EM.js → chunk-HUCT7HID.js}

@@ -1,11 +1,14 @@
 import {
   TOOL_PACKS,
   buildCodeWorkDiscipline
-} from "./chunk-CF7S2RYZ.js";
+} from "./chunk-WLH5BAKX.js";
 import {
   buildSkillDocMarkdown,
   resolvePageSkillMetadata
-} from "./chunk-ZWJOGMKH.js";
+} from "./chunk-AETZ7AD6.js";
+import {
+  canonicalizeToolNames
+} from "./chunk-ZZ2MH7LE.js";
 import {
   asNonEmptyStringArray
 } from "./chunk-I42VC5KR.js";
@@ -13,85 +16,6 @@ import {
   asOptionalTrimmedString
 } from "./chunk-G3SUCT4W.js";
 
-// packages/agent-runtime/toolNameAliases.ts
-var LEGACY_TOOL_NAME_ALIASES = {
-  createPage: "createDoc",
-  updatePage: "updateDoc",
-  update_page: "updateDoc",
-  create_page: "createDoc",
-  fetchwebpage: "fetchWebpage",
-  fetch_webpage: "fetchWebpage",
-  "fetch-page": "fetchWebpage",
-  exasearch: "exa_search",
-  "exa-search": "exa_search",
-  exa_search: "exa_search",
-  firecrawlscrape: "firecrawl_scrape",
-  "firecrawl-scrape": "firecrawl_scrape",
-  firecrawl_scrape: "firecrawl_scrape",
-  firecrawlsearch: "firecrawl_search",
-  "firecrawl-search": "firecrawl_search",
-  firecrawl_search: "firecrawl_search",
-  readDoc: "readDoc",
-  readpage: "readDoc",
-  read_page: "readDoc",
-  read_doc: "readDoc",
-  createdoc: "createDoc",
-  updateDocTool: "updateDoc",
-  terminalCommand: "execShell",
-  terminal_command: "execShell",
-  runCommand: "execShell",
-  run_command: "execShell",
-  runInBash: "execShell",
-  run_in_bash: "execShell",
-  executeCommand: "execShell",
-  execute_command: "execShell",
-  // Codex CLI 风格工具名 → nolo 原生工具名
-  bash: "execShell",
-  shell: "execShell",
-  read: "readFile",
-  edit: "editFile",
-  write: "writeFile",
-  glob: "globFiles",
-  grep: "searchFiles",
-  // 联网搜索别名
-  web_search: "exa_search",
-  websearch: "exa_search",
-  search_web: "exa_search",
-  searchweb: "exa_search",
-  webfetch: "fetchWebpage",
-  web_fetch: "fetchWebpage",
-  fetchweb: "fetchWebpage",
-  fetch_web: "fetchWebpage",
-  // 模型偶尔会把 loadSkill 幻觉成 readSkill（参数风格 name= 一致），
-  // 规范化到 loadSkill，避免 localToolPolicy 把这种调用直接拦死。
-  readSkill: "loadSkill"
-};
-var normalizeToolName = (name) => name.replace(/[-_]/g, "").toLowerCase();
-var canonicalizeToolName = (rawName) => {
-  const trimmedName = rawName.trim();
-  if (!trimmedName) return rawName;
-  if (LEGACY_TOOL_NAME_ALIASES[trimmedName]) {
-    return LEGACY_TOOL_NAME_ALIASES[trimmedName];
-  }
-  const normalizedRawName = normalizeToolName(trimmedName);
-  const matchedAlias = Object.entries(LEGACY_TOOL_NAME_ALIASES).find(
-    ([alias]) => normalizeToolName(alias) === normalizedRawName
-  );
-  return matchedAlias?.[1] ?? trimmedName;
-};
-var canonicalizeToolNames = (toolNames) => Array.from(
-  new Set(
-    toolNames.filter((toolName) => typeof toolName === "string").map(canonicalizeToolName)
-  )
-);
-var prioritizeToolNames = (toolNames, preferredToolNames) => {
-  const canonicalTools = canonicalizeToolNames(toolNames);
-  const preferred = new Set(canonicalizeToolNames(preferredToolNames));
-  const prioritized = canonicalTools.filter((toolName) => preferred.has(toolName));
-  const remaining = canonicalTools.filter((toolName) => !preferred.has(toolName));
-  return [...prioritized, ...remaining];
-};
-
 // packages/ai/skills/referenceRuntime.ts
 var joinUniqueStrings = (...groups) => Array.from(new Set(groups.flatMap((items) => asNonEmptyStringArray(items))));
 var extractRuntimePageCapabilities = (content) => {
@@ -663,9 +587,6 @@ async function resolveCodingEffectiveTools(userId) {
 }
 
 export {
-  canonicalizeToolName,
-  canonicalizeToolNames,
-  prioritizeToolNames,
   extractRuntimePageCapabilities,
   buildSkillGuidancePromptBlock,
   resolveSkillGraphFromRoots,

package/{chunk-PTHDLIRB.js → chunk-I6N2UVVY.js}

@@ -1,7 +1,7 @@
 import {
   generatePkcePair,
   startCallbackServer
-} from "./chunk-SFWZUTCI.js";
+} from "./chunk-GTYM4HKV.js";
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";

package/chunk-IDAU4UFS.js

@@ -0,0 +1,437 @@
+import {
+  asOptionalFiniteNumber
+} from "./chunk-WWC7I6TA.js";
+import {
+  isLevelNotFoundError
+} from "./chunk-OW765XBU.js";
+import {
+  asTrimmedString
+} from "./chunk-3EUW3WEO.js";
+import {
+  asOptionalPositiveFiniteNumber
+} from "./chunk-U6VC4MU4.js";
+
+// packages/database/sync/syncMappingKeys.ts
+var SYNC_MAPPING_KEY_PREFIX = "syncmap-local-";
+var SYNC_MAPPING_KEY_SEPARATOR = "::";
+var SYNC_MAPPING_RECORD_TYPE = "sync_mapping";
+var normalizeSegment = (value) => asTrimmedString(value);
+function buildSyncMappingRecordKey(accountUserId, localDbKey) {
+  const account = normalizeSegment(accountUserId);
+  const local = normalizeSegment(localDbKey);
+  if (!account) {
+    throw new Error("syncMapping record key requires accountUserId");
+  }
+  if (!local) {
+    throw new Error("syncMapping record key requires localDbKey");
+  }
+  if (account.includes(SYNC_MAPPING_KEY_SEPARATOR)) {
+    throw new Error(
+      `syncMapping accountUserId must not contain "${SYNC_MAPPING_KEY_SEPARATOR}"`
+    );
+  }
+  return `${SYNC_MAPPING_KEY_PREFIX}${account}${SYNC_MAPPING_KEY_SEPARATOR}${local}`;
+}
+function isSyncMappingRecordKey(dbKey) {
+  const key = normalizeSegment(dbKey);
+  return key.startsWith(SYNC_MAPPING_KEY_PREFIX);
+}
+function syncMappingRecordKeyRange() {
+  const start = SYNC_MAPPING_KEY_PREFIX;
+  return {
+    gte: start,
+    lte: `${start}\uFFFF`
+  };
+}
+
+// packages/database/sync/syncMappingDurable.ts
+var clean = (value) => asTrimmedString(value);
+function toDurableSyncMappingRecord(input) {
+  const localDbKey = clean(input.localDbKey);
+  const remoteDbKey = clean(input.remoteDbKey);
+  const accountUserId = clean(input.accountUserId);
+  const contentType = clean(input.contentType) || "unknown";
+  const updatedAt = asOptionalFiniteNumber(input.updatedAt) ?? Date.now();
+  if (!localDbKey || !remoteDbKey || !accountUserId) {
+    throw new Error("durable syncMapping requires local/remote/account keys");
+  }
+  const dbKey = buildSyncMappingRecordKey(accountUserId, localDbKey);
+  return {
+    type: SYNC_MAPPING_RECORD_TYPE,
+    userId: "local",
+    dbKey,
+    localDbKey,
+    remoteDbKey,
+    accountUserId,
+    contentType,
+    updatedAt
+  };
+}
+function parseDurableSyncMappingRecord(value) {
+  if (!value || typeof value !== "object") return null;
+  const row = value;
+  if (row.type !== SYNC_MAPPING_RECORD_TYPE) return null;
+  if (row.userId !== "local" && row.userId !== void 0) {
+    return null;
+  }
+  const localDbKey = clean(row.localDbKey);
+  const remoteDbKey = clean(row.remoteDbKey);
+  const accountUserId = clean(row.accountUserId);
+  const contentType = clean(row.contentType) || "unknown";
+  const updatedAt = asOptionalFiniteNumber(row.updatedAt) ?? Date.now();
+  if (!localDbKey || !remoteDbKey || !accountUserId) return null;
+  if (localDbKey === remoteDbKey) return null;
+  if (accountUserId === "local") return null;
+  return {
+    localDbKey,
+    remoteDbKey,
+    accountUserId,
+    contentType,
+    updatedAt
+  };
+}
+async function persistSyncMappingToDb(db, input) {
+  const record = toDurableSyncMappingRecord(input);
+  await db.put(record.dbKey, record);
+  return record;
+}
+async function removeSyncMappingFromDb(db, accountUserId, localDbKey) {
+  const dbKey = buildSyncMappingRecordKey(accountUserId, localDbKey);
+  try {
+    if (typeof db.del === "function") {
+      await db.del(dbKey);
+      return true;
+    }
+    await db.put(dbKey, null);
+    return true;
+  } catch (err) {
+    if (isLevelNotFoundError(err)) return false;
+    throw err;
+  }
+}
+async function loadSyncMappingsFromDb(db) {
+  if (typeof db.iterator !== "function") {
+    return [];
+  }
+  const range = syncMappingRecordKeyRange();
+  let iterator = db.iterator(range);
+  if (iterator && typeof iterator.then === "function") {
+    iterator = await iterator;
+  }
+  if (!iterator) return [];
+  const out = [];
+  for await (const entry of iterator) {
+    const pair = entry;
+    const key = Array.isArray(pair) ? pair[0] : "";
+    const value = Array.isArray(pair) ? pair[1] : null;
+    if (!isSyncMappingRecordKey(key)) continue;
+    if (value == null) continue;
+    const mapping = parseDurableSyncMappingRecord(value);
+    if (mapping) out.push(mapping);
+  }
+  return out;
+}
+
+// packages/database/sync/syncMapping.ts
+var normalizeKey = (value) => asTrimmedString(value);
+var normalizeContentType = (value) => {
+  const trimmed = normalizeKey(value);
+  return trimmed.length > 0 ? trimmed : "unknown";
+};
+var toUpdatedAt = (value, fallback) => {
+  const asNumber = asOptionalPositiveFiniteNumber(value);
+  if (asNumber !== void 0) return asNumber;
+  if (typeof value === "string" && value.trim()) {
+    return asOptionalPositiveFiniteNumber(Date.parse(value)) ?? fallback;
+  }
+  return fallback;
+};
+var pairKey = (accountUserId, localDbKey) => `${accountUserId}\0${localDbKey}`;
+function normalizeSyncMapping(input, now = Date.now()) {
+  const localDbKey = normalizeKey(input.localDbKey);
+  const remoteDbKey = normalizeKey(input.remoteDbKey);
+  const accountUserId = normalizeKey(input.accountUserId);
+  const contentType = normalizeContentType(input.contentType);
+  if (!localDbKey) {
+    throw new Error("syncMapping.localDbKey is required");
+  }
+  if (!remoteDbKey) {
+    throw new Error("syncMapping.remoteDbKey is required");
+  }
+  if (!accountUserId) {
+    throw new Error("syncMapping.accountUserId is required");
+  }
+  if (localDbKey === remoteDbKey) {
+    throw new Error("syncMapping.localDbKey and remoteDbKey must differ");
+  }
+  if (accountUserId === "local") {
+    throw new Error(
+      "syncMapping.accountUserId must be a non-local account user id"
+    );
+  }
+  return {
+    localDbKey,
+    remoteDbKey,
+    accountUserId,
+    contentType,
+    updatedAt: toUpdatedAt(input.updatedAt, now)
+  };
+}
+function createSyncMappingStore(options) {
+  const now = options?.now ?? Date.now;
+  const byPair = /* @__PURE__ */ new Map();
+  const remoteToPair = /* @__PURE__ */ new Map();
+  const forgetRemoteIndex = (mapping) => {
+    if (!mapping) return;
+    const current = remoteToPair.get(mapping.remoteDbKey);
+    if (current === pairKey(mapping.accountUserId, mapping.localDbKey)) {
+      remoteToPair.delete(mapping.remoteDbKey);
+    }
+  };
+  return {
+    put(input) {
+      const mapping = normalizeSyncMapping(input, now());
+      const key = pairKey(mapping.accountUserId, mapping.localDbKey);
+      const previousLocal = byPair.get(key);
+      if (previousLocal) {
+        forgetRemoteIndex(previousLocal);
+      }
+      const previousPairForRemote = remoteToPair.get(mapping.remoteDbKey);
+      if (previousPairForRemote && previousPairForRemote !== key) {
+        const displaced = byPair.get(previousPairForRemote);
+        if (displaced) {
+          byPair.delete(previousPairForRemote);
+        }
+      }
+      byPair.set(key, mapping);
+      remoteToPair.set(mapping.remoteDbKey, key);
+      return { ...mapping };
+    },
+    get(localDbKey, accountUserId) {
+      const local = normalizeKey(localDbKey);
+      if (!local) return null;
+      const account = normalizeKey(accountUserId);
+      if (account) {
+        const mapping = byPair.get(pairKey(account, local));
+        return mapping ? { ...mapping } : null;
+      }
+      let best = null;
+      for (const mapping of byPair.values()) {
+        if (mapping.localDbKey !== local) continue;
+        if (!best || mapping.updatedAt > best.updatedAt) {
+          best = mapping;
+        }
+      }
+      return best ? { ...best } : null;
+    },
+    getByRemoteDbKey(remoteDbKey, accountUserId) {
+      const key = normalizeKey(remoteDbKey);
+      if (!key) return null;
+      const pair = remoteToPair.get(key);
+      if (!pair) return null;
+      const mapping = byPair.get(pair);
+      if (!mapping) return null;
+      const account = normalizeKey(accountUserId);
+      if (account && mapping.accountUserId !== account) return null;
+      return { ...mapping };
+    },
+    list(filter) {
+      const accountUserId = normalizeKey(filter?.accountUserId);
+      const contentType = normalizeKey(filter?.contentType);
+      const rows = Array.from(byPair.values()).filter((mapping) => {
+        if (accountUserId && mapping.accountUserId !== accountUserId) {
+          return false;
+        }
+        if (contentType && mapping.contentType !== contentType) return false;
+        return true;
+      });
+      return rows.map((mapping) => ({ ...mapping })).sort(
+        (left, right) => right.updatedAt - left.updatedAt || left.localDbKey.localeCompare(right.localDbKey) || left.accountUserId.localeCompare(right.accountUserId)
+      );
+    },
+    remove(localDbKey, accountUserId) {
+      const local = normalizeKey(localDbKey);
+      if (!local) return false;
+      const account = normalizeKey(accountUserId);
+      if (account) {
+        const key = pairKey(account, local);
+        const existing = byPair.get(key);
+        if (!existing) return false;
+        byPair.delete(key);
+        forgetRemoteIndex(existing);
+        return true;
+      }
+      let removed = false;
+      for (const [key, mapping] of Array.from(byPair.entries())) {
+        if (mapping.localDbKey !== local) continue;
+        byPair.delete(key);
+        forgetRemoteIndex(mapping);
+        removed = true;
+      }
+      return removed;
+    },
+    clear() {
+      byPair.clear();
+      remoteToPair.clear();
+    },
+    size() {
+      return byPair.size;
+    }
+  };
+}
+var defaultSyncMappingStore = createSyncMappingStore();
+var mappingVersion = 0;
+var mappingListeners = /* @__PURE__ */ new Set();
+var sameConsumerMapping = (a, b) => {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  return a.localDbKey === b.localDbKey && a.remoteDbKey === b.remoteDbKey && a.accountUserId === b.accountUserId && a.contentType === b.contentType;
+};
+var notifySyncMappingListeners = () => {
+  mappingVersion += 1;
+  for (const listener of mappingListeners) {
+    try {
+      listener();
+    } catch {
+    }
+  }
+};
+function subscribeSyncMappingVersion(listener) {
+  mappingListeners.add(listener);
+  return () => {
+    mappingListeners.delete(listener);
+  };
+}
+function getSyncMappingVersion() {
+  return mappingVersion;
+}
+var boundClientDb = null;
+var mappingsHydrated = false;
+var hydrateEpoch = 0;
+var hydrateInFlight = null;
+function bindSyncMappingClientDb(db) {
+  boundClientDb = db;
+  mappingsHydrated = false;
+  hydrateEpoch += 1;
+}
+function getBoundSyncMappingClientDb() {
+  return boundClientDb;
+}
+async function ensureSyncMappingsHydrated(db) {
+  const client = db ?? boundClientDb;
+  if (!client) return false;
+  if (mappingsHydrated) return false;
+  if (hydrateInFlight && hydrateInFlight.epoch === hydrateEpoch) {
+    await hydrateInFlight.promise;
+    return false;
+  }
+  const epoch = hydrateEpoch;
+  const clientAtStart = client;
+  const promise = (async () => {
+    const rows = await loadSyncMappingsFromDb(clientAtStart);
+    if (epoch !== hydrateEpoch) {
+      return false;
+    }
+    const beforeSize = defaultSyncMappingStore.size();
+    defaultSyncMappingStore.clear();
+    for (const row of rows) {
+      try {
+        defaultSyncMappingStore.put(row);
+      } catch {
+      }
+    }
+    mappingsHydrated = true;
+    if (beforeSize > 0 || rows.length > 0 || defaultSyncMappingStore.size() > 0) {
+      notifySyncMappingListeners();
+    }
+    return true;
+  })();
+  hydrateInFlight = { epoch, promise };
+  try {
+    return await promise;
+  } finally {
+    if (hydrateInFlight?.promise === promise) {
+      hydrateInFlight = null;
+    }
+  }
+}
+function putSyncMapping(mapping) {
+  const account = normalizeKey(mapping.accountUserId);
+  const local = normalizeKey(mapping.localDbKey);
+  const previous = account && local ? defaultSyncMappingStore.get(local, account) : null;
+  const next = defaultSyncMappingStore.put(mapping);
+  if (!sameConsumerMapping(previous, next)) {
+    notifySyncMappingListeners();
+  }
+  return next;
+}
+async function putSyncMappingDurable(mapping) {
+  const normalized = normalizeSyncMapping(mapping);
+  if (!boundClientDb) {
+    throw new Error(
+      "putSyncMappingDurable requires a bound client DB; refuse silent memory-only durability"
+    );
+  }
+  await persistSyncMappingToDb(boundClientDb, normalized);
+  return putSyncMapping(normalized);
+}
+function getSyncMapping(localDbKey, accountUserId) {
+  return defaultSyncMappingStore.get(localDbKey, accountUserId);
+}
+function getSyncMappingByRemoteDbKey(remoteDbKey, accountUserId) {
+  return defaultSyncMappingStore.getByRemoteDbKey(remoteDbKey, accountUserId);
+}
+function listSyncMappings(filter) {
+  return defaultSyncMappingStore.list(filter);
+}
+function removeSyncMapping(localDbKey, accountUserId) {
+  const removed = defaultSyncMappingStore.remove(localDbKey, accountUserId);
+  if (removed) {
+    notifySyncMappingListeners();
+  }
+  return removed;
+}
+async function removeSyncMappingDurable(localDbKey, accountUserId) {
+  const account = normalizeKey(accountUserId);
+  const local = normalizeKey(localDbKey);
+  if (!account || !local) return false;
+  if (boundClientDb) {
+    await removeSyncMappingFromDb(boundClientDb, account, local);
+  }
+  return removeSyncMapping(local, account);
+}
+function clearSyncMappings() {
+  const hadRows = defaultSyncMappingStore.size() > 0;
+  defaultSyncMappingStore.clear();
+  mappingsHydrated = false;
+  hydrateEpoch += 1;
+  if (hadRows) {
+    notifySyncMappingListeners();
+  }
+}
+function getDefaultSyncMappingStore() {
+  return defaultSyncMappingStore;
+}
+function areSyncMappingsHydrated() {
+  return mappingsHydrated;
+}
+
+export {
+  normalizeSyncMapping,
+  createSyncMappingStore,
+  subscribeSyncMappingVersion,
+  getSyncMappingVersion,
+  bindSyncMappingClientDb,
+  getBoundSyncMappingClientDb,
+  ensureSyncMappingsHydrated,
+  putSyncMapping,
+  putSyncMappingDurable,
+  getSyncMapping,
+  getSyncMappingByRemoteDbKey,
+  listSyncMappings,
+  removeSyncMapping,
+  removeSyncMappingDurable,
+  clearSyncMappings,
+  getDefaultSyncMappingStore,
+  areSyncMappingsHydrated
+};

package/{chunk-Q76I4SXI.js → chunk-IHEC7VBF.js}

@@ -2,7 +2,7 @@ import {
   deleteDbRecord,
   queryUserRecords,
   readDbRecord
-} from "./chunk-V42OE5HT.js";
+} from "./chunk-YDTYDA5W.js";
 import {
   mergeAndDedupUserData
 } from "./chunk-KQHGZWSV.js";

package/{chunk-OWHNFZNW.js → chunk-IL545V3E.js}

@@ -1,10 +1,7 @@
 import {
   readDbRecord,
   writeAgentRecord
-} from "./chunk-V42OE5HT.js";
-import {
-  createSpaceKey
-} from "./chunk-V54H24CQ.js";
+} from "./chunk-YDTYDA5W.js";
 import {
   buildSkillSummaryMarker
 } from "./chunk-VF4K2QE6.js";
@@ -14,6 +11,9 @@ import {
   resolveAuthToken,
   resolveServerUrl
 } from "./chunk-A7GB5UGH.js";
+import {
+  createSpaceKey
+} from "./chunk-JTSGWTYZ.js";
 import {
   asTrimmedLowercaseString
 } from "./chunk-QSJ3HFEF.js";