nolo-cli 0.9.1 → 0.10.0

package/{chunk-4K2KKCSD.js → chunk-I5URP43I.js}

@@ -8,29 +8,25 @@ import {
   patch,
   remove,
   write
-} from "./chunk-COMXDWNM.js";
+} from "./chunk-BE2OOJ5P.js";
 import {
   asRecordOrEmpty
 } from "./chunk-KX6YBIHG.js";
 import {
   createAgentKey,
-  require_index_umd,
   toTrimmedString
-} from "./chunk-SH2CFQOH.js";
+} from "./chunk-O4BU24WZ.js";
 import {
   asyncThunkCreator,
   buildCreateSlice,
   getRuntimeServerContext
-} from "./chunk-EYEEHCU4.js";
+} from "./chunk-UTLZINAP.js";
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";
 import {
   asOptionalTrimmedString
 } from "./chunk-G3SUCT4W.js";
-import {
-  __toESM
-} from "./chunk-4VNS5WPM.js";
 
 // packages/ai/chat/agentCredentialSyncClient.ts
 function buildUrl(currentServer, credentialRef) {
@@ -86,7 +82,7 @@ var sanitizeOptionalModelString = (value) => {
 };
 
 // packages/ai/agent/agentSlice.ts
-var import_ulid = __toESM(require_index_umd());
+import { ulid } from "ulid";
 var createAgentCredentialBroker = createFileCredentialBroker;
 function setAgentCredentialBrokerFactoryForTests(factory) {
   createAgentCredentialBroker = factory ?? createFileCredentialBroker;
@@ -304,7 +300,7 @@ var slice = createSliceWithThunks({
       const overrides = {};
       if (args.systemPromptOverride !== void 0) overrides.prompt = args.systemPromptOverride;
       if (args.toolsOverride !== void 0) overrides.tools = args.toolsOverride;
-      const { _executeModel } = await import("./_executeModel-UD44KGZ4.js");
+      const { _executeModel } = await import("./_executeModel-YAXYAUOK.js");
       return _executeModel(
         {
           isStreaming: args.isStreaming ?? false,
@@ -325,7 +321,7 @@ var slice = createSliceWithThunks({
      * - 循环直到无工具调用或触发其他运行时停止条件
      */
     runAgent: create.asyncThunk(async (args, thunkApi) => {
-      const { runAgentClientLoop } = await import("./runAgentClientLoop-U5Q6NDTJ.js");
+      const { runAgentClientLoop } = await import("./runAgentClientLoop-AIGLXC3R.js");
       const { content: loopContent, toolCallCount } = await runAgentClientLoop(
         {
           agentKey: args.agentKey,
@@ -341,7 +337,7 @@ var slice = createSliceWithThunks({
      * 聊天轮次流式 Agent 调用
      */
     streamAgentChatTurn: create.asyncThunk(async (args, thunkApi) => {
-      const { streamAgentChatTurnHandler } = await import("./streamAgentChatTurn-UBDAOQWE.js");
+      const { streamAgentChatTurnHandler } = await import("./streamAgentChatTurn-HRMFFA7E.js");
       return streamAgentChatTurnHandler(args, thunkApi);
     }),
     /**
@@ -355,7 +351,7 @@ var slice = createSliceWithThunks({
         const effectiveUserId = asOptionalTrimmedString(userId) ?? "local";
         const processed = processAgentCreateForm(formData, effectiveUserId);
         const now = Date.now();
-        const id = (0, import_ulid.ulid)();
+        const id = ulid();
         const privateKey = createAgentKey.private(effectiveUserId, id);
         const publicKey = createAgentKey.public(id);
         let agent = {

package/{chunk-63SLEOLK.js → chunk-KBKYAONQ.js}

@@ -1,7 +1,7 @@
 import {
   selectCurrentServer,
   selectRemoteServers
-} from "./chunk-TSS3XJY4.js";
+} from "./chunk-4SIMLBEU.js";
 import {
   createUserKey,
   extractAgentInfo,
@@ -10,16 +10,16 @@ import {
   sanitizeShareData,
   shareKey,
   toNonEmptyString
-} from "./chunk-SH2CFQOH.js";
+} from "./chunk-O4BU24WZ.js";
 import {
   noloDeleteRequest,
   noloWriteRequest,
   selectIdentityUser,
   selectIdentityUserId
-} from "./chunk-EYEEHCU4.js";
+} from "./chunk-UTLZINAP.js";
 import {
   normalizeTimeFields
-} from "./chunk-QYXLLLGL.js";
+} from "./chunk-OOSFSFMA.js";
 
 // packages/share/action.ts
 var generateToken = () => {

package/{chunk-PCWC3JTN.js → chunk-MTU75CZ2.js}

@@ -1,6 +1,6 @@
 import {
   dialogMessageKey
-} from "./chunk-SH2CFQOH.js";
+} from "./chunk-O4BU24WZ.js";
 import {
   asOptionalFiniteNumber
 } from "./chunk-WWC7I6TA.js";

package/{chunk-5PJ3VWCS.js → chunk-NPVBXJY2.js}

@@ -1,7 +1,7 @@
 import {
   readDbRecord,
   writeAgentRecord
-} from "./chunk-7OOXPE3N.js";
+} from "./chunk-OR2XR25C.js";
 import {
   buildSkillSummaryMarker
 } from "./chunk-VF4K2QE6.js";
@@ -17,9 +17,6 @@ import {
   resolveAuthToken,
   resolveServerUrl
 } from "./chunk-ISNCLGUZ.js";
-import {
-  require_index_umd
-} from "./chunk-SH2CFQOH.js";
 import {
   asTrimmedLowercaseString
 } from "./chunk-QSJ3HFEF.js";
@@ -32,13 +29,10 @@ import {
 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";
+import { ulid } from "ulid";
 function getCliArg(args, flag) {
   const idx = args.indexOf(flag);
   return idx !== -1 ? args[idx + 1] : void 0;
@@ -57,7 +51,7 @@ function textToSlate(text) {
   }));
 }
 function createPageId() {
-  return (0, import_ulid.ulid)();
+  return ulid();
 }
 function buildPageKey(userId, pageId) {
   return `page-${userId}-${pageId}`;

package/{chunk-SH2CFQOH.js → chunk-O4BU24WZ.js}

@@ -12,187 +12,9 @@ import {
 } from "./chunk-G3SUCT4W.js";
 import {
   __commonJS,
-  __require,
   __toESM
 } from "./chunk-4VNS5WPM.js";
 
-// node_modules/ulid/dist/index.umd.js
-var require_index_umd = __commonJS({
-  "node_modules/ulid/dist/index.umd.js"(exports, module) {
-    (function(global, factory) {
-      typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : factory(global.ULID = {});
-    })(exports, function(exports2) {
-      "use strict";
-      function createError(message) {
-        var err = new Error(message);
-        err.source = "ulid";
-        return err;
-      }
-      var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-      var ENCODING_LEN = ENCODING.length;
-      var TIME_MAX = Math.pow(2, 48) - 1;
-      var TIME_LEN = 10;
-      var RANDOM_LEN = 16;
-      function replaceCharAt(str, index, char) {
-        if (index > str.length - 1) {
-          return str;
-        }
-        return str.substr(0, index) + char + str.substr(index + 1);
-      }
-      function incrementBase32(str) {
-        var done = void 0;
-        var index = str.length;
-        var char = void 0;
-        var charIndex = void 0;
-        var maxCharIndex = ENCODING_LEN - 1;
-        while (!done && index-- >= 0) {
-          char = str[index];
-          charIndex = ENCODING.indexOf(char);
-          if (charIndex === -1) {
-            throw createError("incorrectly encoded string");
-          }
-          if (charIndex === maxCharIndex) {
-            str = replaceCharAt(str, index, ENCODING[0]);
-            continue;
-          }
-          done = replaceCharAt(str, index, ENCODING[charIndex + 1]);
-        }
-        if (typeof done === "string") {
-          return done;
-        }
-        throw createError("cannot increment this string");
-      }
-      function randomChar(prng2) {
-        var rand = Math.floor(prng2() * ENCODING_LEN);
-        if (rand === ENCODING_LEN) {
-          rand = ENCODING_LEN - 1;
-        }
-        return ENCODING.charAt(rand);
-      }
-      function encodeTime(now, len) {
-        if (isNaN(now)) {
-          throw new Error(now + " must be a number");
-        }
-        if (now > TIME_MAX) {
-          throw createError("cannot encode time greater than " + TIME_MAX);
-        }
-        if (now < 0) {
-          throw createError("time must be positive");
-        }
-        if (Number.isInteger(now) === false) {
-          throw createError("time must be an integer");
-        }
-        var mod = void 0;
-        var str = "";
-        for (; len > 0; len--) {
-          mod = now % ENCODING_LEN;
-          str = ENCODING.charAt(mod) + str;
-          now = (now - mod) / ENCODING_LEN;
-        }
-        return str;
-      }
-      function encodeRandom(len, prng2) {
-        var str = "";
-        for (; len > 0; len--) {
-          str = randomChar(prng2) + str;
-        }
-        return str;
-      }
-      function decodeTime(id) {
-        if (id.length !== TIME_LEN + RANDOM_LEN) {
-          throw createError("malformed ulid");
-        }
-        var time = id.substr(0, TIME_LEN).split("").reverse().reduce(function(carry, char, index) {
-          var encodingIndex = ENCODING.indexOf(char);
-          if (encodingIndex === -1) {
-            throw createError("invalid character found: " + char);
-          }
-          return carry += encodingIndex * Math.pow(ENCODING_LEN, index);
-        }, 0);
-        if (time > TIME_MAX) {
-          throw createError("malformed ulid, timestamp too large");
-        }
-        return time;
-      }
-      function detectPrng() {
-        var allowInsecure = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : false;
-        var root = arguments[1];
-        if (!root) {
-          root = typeof window !== "undefined" ? window : null;
-        }
-        var browserCrypto = root && (root.crypto || root.msCrypto);
-        if (browserCrypto) {
-          return function() {
-            var buffer = new Uint8Array(1);
-            browserCrypto.getRandomValues(buffer);
-            return buffer[0] / 255;
-          };
-        } else {
-          try {
-            var nodeCrypto = __require("crypto");
-            return function() {
-              return nodeCrypto.randomBytes(1).readUInt8() / 255;
-            };
-          } catch (e) {
-          }
-        }
-        if (allowInsecure) {
-          try {
-            console.error("secure crypto unusable, falling back to insecure Math.random()!");
-          } catch (e) {
-          }
-          return function() {
-            return Math.random();
-          };
-        }
-        throw createError("secure crypto unusable, insecure Math.random not allowed");
-      }
-      function factory(currPrng) {
-        if (!currPrng) {
-          currPrng = detectPrng();
-        }
-        return function ulid3(seedTime) {
-          if (isNaN(seedTime)) {
-            seedTime = Date.now();
-          }
-          return encodeTime(seedTime, TIME_LEN) + encodeRandom(RANDOM_LEN, currPrng);
-        };
-      }
-      function monotonicFactory2(currPrng) {
-        if (!currPrng) {
-          currPrng = detectPrng();
-        }
-        var lastTime = 0;
-        var lastRandom = void 0;
-        return function ulid3(seedTime) {
-          if (isNaN(seedTime)) {
-            seedTime = Date.now();
-          }
-          if (seedTime <= lastTime) {
-            var incrementedRandom = lastRandom = incrementBase32(lastRandom);
-            return encodeTime(lastTime, TIME_LEN) + incrementedRandom;
-          }
-          lastTime = seedTime;
-          var newRandom = lastRandom = encodeRandom(RANDOM_LEN, currPrng);
-          return encodeTime(seedTime, TIME_LEN) + newRandom;
-        };
-      }
-      var ulid2 = factory();
-      exports2.replaceCharAt = replaceCharAt;
-      exports2.incrementBase32 = incrementBase32;
-      exports2.randomChar = randomChar;
-      exports2.encodeTime = encodeTime;
-      exports2.encodeRandom = encodeRandom;
-      exports2.decodeTime = decodeTime;
-      exports2.detectPrng = detectPrng;
-      exports2.factory = factory;
-      exports2.monotonicFactory = monotonicFactory2;
-      exports2.ulid = ulid2;
-      Object.defineProperty(exports2, "__esModule", { value: true });
-    });
-  }
-});
-
 // node_modules/rambda/dist/rambda.js
 var require_rambda = __commonJS({
   "node_modules/rambda/dist/rambda.js"(exports) {
@@ -2577,9 +2399,9 @@ function toTrimmedString(value) {
 }
 
 // packages/database/utils/ulid.ts
-var import_ulid = __toESM(require_index_umd(), 1);
+import { monotonicFactory } from "ulid";
 var prng = () => Math.random();
-var ulid = (0, import_ulid.monotonicFactory)(prng);
+var ulid = monotonicFactory(prng);
 
 // packages/database/keys.ts
 var import_rambda = __toESM(require_rambda(), 1);
@@ -3343,7 +3165,6 @@ var sanitizeShareData = (data) => {
 };
 
 export {
-  require_index_umd,
   ulid,
   toTrimmedString,
   toNonEmptyString,

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-7OOXPE3N.js → chunk-OR2XR25C.js}

@@ -2,7 +2,7 @@ import {
   buildLocalAgentLookupKeys,
   normalizeAgentHandle,
   shouldReadAgentKeyRemotely
-} from "./chunk-2PUGVR6E.js";
+} from "./chunk-CDTLMEB3.js";
 import {
   resolveCliAgentKeyInput
 } from "./chunk-VHBWHNVT.js";
@@ -22,7 +22,7 @@ import {
 } from "./chunk-HNMXYYJR.js";
 import {
   createAgentKey
-} from "./chunk-SH2CFQOH.js";
+} from "./chunk-O4BU24WZ.js";
 
 // packages/cli/agentRecordHelpers.ts
 import { readFileSync } from "node:fs";