nolo-cli 0.149.0-alpha.1 → 0.151.0-alpha.3

package/chunk-ZEZC7IIM.js

@@ -0,0 +1,126 @@
+// packages/connector-experimental/codexBinary.ts
+import { copyFileSync, existsSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+var WINDOWS_APPS_CODEX_PATTERN = /\\WindowsApps\\OpenAI\.Codex_[^\\]+\\app\\resources$/i;
+function pathEntries(env) {
+  return (env.PATH ?? process.env.PATH ?? "").split(process.platform === "win32" ? ";" : ":");
+}
+function findWindowsAppsCodex(env) {
+  if (process.platform !== "win32") return "";
+  for (const entry of pathEntries(env)) {
+    if (!WINDOWS_APPS_CODEX_PATTERN.test(entry)) continue;
+    const candidate = join(entry, "codex.exe");
+    if (existsSync(candidate)) return candidate;
+  }
+  return "";
+}
+function copyCodexToUserBin(source, env) {
+  const target = env.NOLO_CODEX_SHIM_PATH ?? join(homedir(), ".nolo", "bin", "codex.exe");
+  if (existsSync(target)) return target;
+  mkdirSync(dirname(target), { recursive: true });
+  copyFileSync(source, target);
+  return target;
+}
+function resolveLaunchableCodexCommand(env = process.env) {
+  const explicit = env.NOLO_CODEX_BIN?.trim();
+  if (explicit) return explicit;
+  const windowsAppsCodex = findWindowsAppsCodex(env);
+  if (windowsAppsCodex) return copyCodexToUserBin(windowsAppsCodex, env);
+  return "codex";
+}
+
+// packages/connector-experimental/cliProcessEnv.ts
+import { execSync } from "child_process";
+function readMacSystemProxyEnv() {
+  if (process.platform !== "darwin") return {};
+  try {
+    const raw = String(execSync("scutil --proxy", { encoding: "utf8" }) || "");
+    const values = /* @__PURE__ */ new Map();
+    for (const line of raw.split("\n")) {
+      const match = line.match(/^\s*([A-Za-z0-9_]+)\s*:\s*(.+?)\s*$/);
+      if (!match) continue;
+      values.set(match[1], match[2].replace(/^"|"$/g, ""));
+    }
+    const httpEnabled = values.get("HTTPEnable") === "1";
+    const httpsEnabled = values.get("HTTPSEnable") === "1";
+    const httpHost = values.get("HTTPProxy")?.trim();
+    const httpsHost = values.get("HTTPSProxy")?.trim();
+    const httpPort = values.get("HTTPPort")?.trim();
+    const httpsPort = values.get("HTTPSPort")?.trim();
+    const noProxy = values.get("ExceptionsList")?.trim();
+    const httpProxy = httpEnabled && httpHost && httpPort ? `http://${httpHost}:${httpPort}` : "";
+    const httpsProxy = httpsEnabled && httpsHost && httpsPort ? `http://${httpsHost}:${httpsPort}` : "";
+    const allProxy = httpsProxy || httpProxy;
+    return {
+      ...httpProxy ? { HTTP_PROXY: httpProxy, http_proxy: httpProxy } : {},
+      ...httpsProxy ? { HTTPS_PROXY: httpsProxy, https_proxy: httpsProxy } : {},
+      ...allProxy ? { ALL_PROXY: allProxy, all_proxy: allProxy } : {},
+      ...noProxy ? { NO_PROXY: noProxy, no_proxy: noProxy } : {}
+    };
+  } catch {
+    return {};
+  }
+}
+function normalizeProxyEnv(env) {
+  const explicitHttp = env.HTTP_PROXY?.trim() || env.http_proxy?.trim() || "";
+  const explicitHttps = env.HTTPS_PROXY?.trim() || env.https_proxy?.trim() || "";
+  const explicitAll = env.ALL_PROXY?.trim() || env.all_proxy?.trim() || "";
+  const explicitNoProxy = env.NO_PROXY?.trim() || env.no_proxy?.trim() || "";
+  const fallback = explicitHttp || explicitHttps || explicitAll ? {} : readMacSystemProxyEnv();
+  const httpProxy = explicitHttp || fallback.HTTP_PROXY || fallback.http_proxy || "";
+  const httpsProxy = explicitHttps || fallback.HTTPS_PROXY || fallback.https_proxy || httpProxy;
+  const allProxy = explicitAll || fallback.ALL_PROXY || fallback.all_proxy || httpsProxy || httpProxy;
+  const noProxy = explicitNoProxy || fallback.NO_PROXY || fallback.no_proxy || "";
+  return {
+    ...env,
+    ...httpProxy ? { HTTP_PROXY: httpProxy, http_proxy: httpProxy } : {},
+    ...httpsProxy ? { HTTPS_PROXY: httpsProxy, https_proxy: httpsProxy } : {},
+    ...allProxy ? { ALL_PROXY: allProxy, all_proxy: allProxy } : {},
+    ...noProxy ? { NO_PROXY: noProxy, no_proxy: noProxy } : {}
+  };
+}
+function buildCliProcessEnv(extraEnv) {
+  const baseEnv = {
+    ...process.env,
+    ...extraEnv,
+    NO_COLOR: "1"
+  };
+  if (process.platform === "darwin") {
+    const defaultMacPaths = [
+      `${process.env.HOME || ""}/.local/bin`,
+      "/opt/homebrew/bin",
+      "/opt/homebrew/sbin",
+      "/usr/local/bin",
+      "/usr/local/sbin",
+      `${process.env.HOME || ""}/.bun/bin`,
+      `${process.env.HOME || ""}/Library/pnpm`,
+      `${process.env.HOME || ""}/.npm-global/bin`,
+      `${process.env.HOME || ""}/bin`
+    ];
+    const existingPath = baseEnv.PATH || "/usr/bin:/bin:/usr/sbin:/sbin";
+    const paths = existingPath.split(":");
+    for (const p of defaultMacPaths) {
+      if (p && !paths.includes(p)) {
+        paths.unshift(p);
+      }
+    }
+    baseEnv.PATH = paths.join(":");
+  }
+  if (baseEnv.HOME) {
+    const delimiter = process.platform === "win32" ? ";" : ":";
+    const openCodeBin = `${baseEnv.HOME}/.opencode/bin`;
+    const paths = (baseEnv.PATH || "").split(delimiter);
+    if (!paths.includes(openCodeBin)) baseEnv.PATH = [...paths, openCodeBin].filter(Boolean).join(delimiter);
+  }
+  return Object.fromEntries(
+    Object.entries(normalizeProxyEnv(baseEnv)).filter(
+      (entry) => typeof entry[1] === "string"
+    )
+  );
+}
+
+export {
+  resolveLaunchableCodexCommand,
+  buildCliProcessEnv
+};

package/{chunk-ALGORS6Y.js → chunk-ZF6526IQ.js}

@@ -1,10 +1,15 @@
 import {
   buildLocalAgentLookupKeys,
+  classifyAgentApiKeyRef,
+  formatUnsupportedAgentApiKeyRefMessage,
   shouldReadAgentKeyRemotely
-} from "./chunk-OTGFTBLI.js";
+} from "./chunk-UUPR3TD7.js";
 import {
   resolveCliAgentKeyInput
-} from "./chunk-SV5IJK6K.js";
+} from "./chunk-NBTY7YJF.js";
+import {
+  createAgentKey
+} from "./chunk-5EMSBTQ6.js";
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";
@@ -19,9 +24,6 @@ import {
   readPipeText,
   spawnProcess
 } from "./chunk-Y6ROFCZO.js";
-import {
-  createAgentKey
-} from "./chunk-3AH7LNUB.js";
 
 // packages/cli/agentRecordHelpers.ts
 import { readFileSync } from "node:fs";
@@ -231,7 +233,14 @@ async function deleteDbRecord(args) {
   }
   return data;
 }
+function assertSupportedAgentApiKeyRef(record) {
+  const verdict = classifyAgentApiKeyRef(record?.apiKeyRef);
+  if (!verdict.ok) {
+    throw new Error(formatUnsupportedAgentApiKeyRefMessage(verdict.ref));
+  }
+}
 async function writeAgentRecord(args) {
+  assertSupportedAgentApiKeyRef(args.record);
   const res = await fetchWithTransportFallback(`${args.serverUrl}/api/v1/db/write/`, {
     method: "POST",
     headers: {
@@ -252,6 +261,30 @@ async function writeAgentRecord(args) {
     throw new Error(`write failed: HTTP ${res.status} ${JSON.stringify(data)}`);
   }
 }
+async function invalidateAgentRecordCache(args) {
+  const invalidated = [];
+  for (const key of new Set(args.keys.filter((k) => typeof k === "string" && k))) {
+    try {
+      await args.db.del(key);
+      invalidated.push(key);
+    } catch {
+    }
+  }
+  return invalidated;
+}
+async function refreshAgentRecordCache(args) {
+  try {
+    await args.db.put(args.agentKey, {
+      ...args.record,
+      dbKey: args.agentKey,
+      key: args.record?.key || args.agentKey,
+      serverOrigin: args.serverOrigin,
+      cachedAt: Date.now()
+    });
+  } catch {
+    await invalidateAgentRecordCache({ db: args.db, keys: [args.agentKey] });
+  }
+}
 async function resolveAgentRecordFromHybridStore(args) {
   const agentKey = resolveCliAgentKeyInput(args.agentInput);
   const authToken = args.cliArgs ? resolveAuthToken(args.cliArgs, args.env) : resolveAuthToken(args.env);
@@ -484,7 +517,7 @@ function parseAgentUpdateArgs(args) {
   );
   const expiresAt = parseIsoTimestampOption(readOption(args, "--expires-at"), "--expires-at");
   const handle = readOption(args, "--handle")?.trim();
-  const promptSources = [prompt, promptFile, promptDoc].filter(Boolean);
+  const promptSources = [prompt, promptFile, promptDoc].filter((value) => value !== void 0);
   if (promptSources.length > 1) {
     throw new Error("--prompt / --prompt-file / --prompt-doc are mutually exclusive.");
   }
@@ -492,7 +525,7 @@ function parseAgentUpdateArgs(args) {
   if (cliProvider) updates.cliProvider = cliProvider;
   if (apiSource) updates.apiSource = apiSource;
   if (provider) updates.provider = provider;
-  if (prompt) updates.prompt = prompt;
+  if (prompt !== void 0) updates.prompt = prompt;
   if (promptFile) updates.prompt = readFileSync(promptFile, "utf8");
   if (tools) updates.tools = parseJsonishValue(tools);
   if (name) updates.name = name;
@@ -523,7 +556,7 @@ async function buildCreatedAgentRecord(args) {
   const resolvedAgentInput = resolveCliAgentKeyInput(args.parsed.agentInput);
   const agentKey = resolvedAgentInput.startsWith("agent-") ? resolvedAgentInput : createAgentKey.private(userId || "local", resolvedAgentInput);
   if (args.parsed.presetId) {
-    const { resolveProviderPresetFields } = await import("./providerPresetApply-DD6NGWW6.js");
+    const { resolveProviderPresetFields } = await import("./providerPresetApply-MY66I6NT.js");
     const fields = resolveProviderPresetFields(args.parsed.presetId);
     if (fields.kind === "manual") {
       throw new Error(
@@ -668,6 +701,8 @@ export {
   queryUserRecords,
   deleteDbRecord,
   writeAgentRecord,
+  invalidateAgentRecordCache,
+  refreshAgentRecordCache,
   resolveAgentRecordFromHybridStore,
   agentRecordHasConfiguredCredential,
   sanitizeAgentRecordForCliOutput,

package/chunk-ZIWPQEFU.js

@@ -0,0 +1,165 @@
+import {
+  noloAgentId
+} from "./chunk-GKXCHNTE.js";
+import {
+  normalizeServerOrigin
+} from "./chunk-CF7PE763.js";
+import {
+  asTrimmedLowercaseString
+} from "./chunk-QSJ3HFEF.js";
+
+// packages/app/theme/fontPreference.ts
+var FONT_PRESET_ALIASES = {
+  system: "system",
+  default: "system",
+  hei: "hei",
+  heiti: "hei",
+  sans: "hei",
+  song: "song",
+  songti: "song",
+  serif: "song",
+  kai: "kai",
+  kaiti: "kai",
+  "kai-ti": "kai",
+  "fang-song": "fang-song",
+  fangsong: "fang-song",
+  "fang song": "fang-song"
+};
+var normalizeFontPreset = (value) => {
+  const normalized = asTrimmedLowercaseString(value);
+  if (!Object.hasOwn(FONT_PRESET_ALIASES, normalized)) return void 0;
+  return FONT_PRESET_ALIASES[normalized];
+};
+
+// packages/ai/policy/types.ts
+var DEFAULT_AGENT_BASE_POLICY = {
+  version: 1,
+  tone: {
+    preset: "default",
+    resolutionMode: "blend"
+  },
+  knowledgeCaptureMaxLevel: 4,
+  spaceContextMaxLevel: 4,
+  selfEvolutionMode: "knowledge_only"
+};
+var DEFAULT_USER_PREFERENCE_PROFILE = {
+  version: 1,
+  tone: {
+    preset: "default"
+  },
+  knowledgeCaptureLevel: 2,
+  spaceContextLevel: 3
+};
+
+// packages/app/settings/settingTypes.ts
+var SYSTEM_DEFAULT_AGENT_ID = "system-default";
+
+// packages/app/settings/settingNormalizers.ts
+var hasOwn = (target, key) => Object.prototype.hasOwnProperty.call(target, key);
+var normalizeDefaultAgentIdSetting = (value) => {
+  if (typeof value !== "string" || value.trim() === "") {
+    return void 0;
+  }
+  return value === noloAgentId || value === SYSTEM_DEFAULT_AGENT_ID ? SYSTEM_DEFAULT_AGENT_ID : value;
+};
+var normalizeAuthorityHomeServerSetting = (value) => {
+  const normalized = normalizeServerOrigin(value);
+  return /^https?:\/\//i.test(normalized) ? normalized : null;
+};
+var normalizeTonePresetSetting = (value) => {
+  switch (value) {
+    case "professional":
+    case "friendly":
+    case "direct":
+    case "pragmatic":
+    case "default":
+      return value;
+    default:
+      return DEFAULT_USER_PREFERENCE_PROFILE.tone?.preset ?? "default";
+  }
+};
+var normalizePolicyLevelSetting = (value, fallback) => {
+  const n = Number(value);
+  if (n === 1 || n === 2 || n === 3 || n === 4) {
+    return n;
+  }
+  return fallback;
+};
+var resolveDefaultAgentIdSetting = (value) => normalizeDefaultAgentIdSetting(value) ?? SYSTEM_DEFAULT_AGENT_ID;
+var omitKeys = (record, keys) => {
+  const next = { ...record };
+  keys.forEach((key) => {
+    delete next[key];
+  });
+  return next;
+};
+var isRecordLike = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var normalizeSystemBuiltinSkills = (value, defaults) => {
+  const base = isRecordLike(value) ? value : {};
+  const result = { ...defaults };
+  for (const key of Object.keys(base)) {
+    result[key] = Boolean(base[key]);
+  }
+  return result;
+};
+
+// packages/ai/policy/selfUpdateFields.ts
+var AGENT_UPDATE_FIELD_NAMES = [
+  "name",
+  "handle",
+  "model",
+  "provider",
+  "prompt",
+  "introduction",
+  "greeting",
+  "isPublic",
+  "tags",
+  "tools",
+  "references",
+  "temperature",
+  "top_p",
+  "frequency_penalty",
+  "presence_penalty",
+  "max_tokens",
+  "reasoning_effort"
+];
+var PRIMARY_AUTO_APPROVE_SELF_UPDATE_FIELDS = [
+  "greeting",
+  "introduction",
+  "tags"
+];
+var DEFAULT_AUTO_APPROVED_SELF_UPDATE_FIELDS = [
+  ...PRIMARY_AUTO_APPROVE_SELF_UPDATE_FIELDS
+];
+var VALID_AGENT_UPDATE_FIELDS = new Set(AGENT_UPDATE_FIELD_NAMES);
+var normalizeAgentUpdateFieldList = (value, fallback = DEFAULT_AUTO_APPROVED_SELF_UPDATE_FIELDS) => {
+  if (!Array.isArray(value)) {
+    return [...fallback];
+  }
+  const normalized = Array.from(
+    new Set(
+      value.filter(
+        (item) => typeof item === "string" && VALID_AGENT_UPDATE_FIELDS.has(item)
+      )
+    )
+  );
+  return normalized;
+};
+
+export {
+  normalizeFontPreset,
+  DEFAULT_AGENT_BASE_POLICY,
+  DEFAULT_USER_PREFERENCE_PROFILE,
+  AGENT_UPDATE_FIELD_NAMES,
+  DEFAULT_AUTO_APPROVED_SELF_UPDATE_FIELDS,
+  normalizeAgentUpdateFieldList,
+  SYSTEM_DEFAULT_AGENT_ID,
+  hasOwn,
+  normalizeDefaultAgentIdSetting,
+  normalizeAuthorityHomeServerSetting,
+  normalizeTonePresetSetting,
+  normalizePolicyLevelSetting,
+  resolveDefaultAgentIdSetting,
+  omitKeys,
+  normalizeSystemBuiltinSkills
+};

package/chunk-ZRAU6T47.js

@@ -0,0 +1,56 @@
+import {
+  addLeadingZeros,
+  requiredArgs,
+  toDate
+} from "./chunk-4LCOCOR5.js";
+
+// node_modules/date-fns/esm/formatISO/index.js
+function formatISO(date, options) {
+  var _options$format, _options$representati;
+  requiredArgs(1, arguments);
+  var originalDate = toDate(date);
+  if (isNaN(originalDate.getTime())) {
+    throw new RangeError("Invalid time value");
+  }
+  var format = String((_options$format = options === null || options === void 0 ? void 0 : options.format) !== null && _options$format !== void 0 ? _options$format : "extended");
+  var representation = String((_options$representati = options === null || options === void 0 ? void 0 : options.representation) !== null && _options$representati !== void 0 ? _options$representati : "complete");
+  if (format !== "extended" && format !== "basic") {
+    throw new RangeError("format must be 'extended' or 'basic'");
+  }
+  if (representation !== "date" && representation !== "time" && representation !== "complete") {
+    throw new RangeError("representation must be 'date', 'time', or 'complete'");
+  }
+  var result = "";
+  var tzOffset = "";
+  var dateDelimiter = format === "extended" ? "-" : "";
+  var timeDelimiter = format === "extended" ? ":" : "";
+  if (representation !== "time") {
+    var day = addLeadingZeros(originalDate.getDate(), 2);
+    var month = addLeadingZeros(originalDate.getMonth() + 1, 2);
+    var year = addLeadingZeros(originalDate.getFullYear(), 4);
+    result = "".concat(year).concat(dateDelimiter).concat(month).concat(dateDelimiter).concat(day);
+  }
+  if (representation !== "date") {
+    var offset = originalDate.getTimezoneOffset();
+    if (offset !== 0) {
+      var absoluteOffset = Math.abs(offset);
+      var hourOffset = addLeadingZeros(Math.floor(absoluteOffset / 60), 2);
+      var minuteOffset = addLeadingZeros(absoluteOffset % 60, 2);
+      var sign = offset < 0 ? "+" : "-";
+      tzOffset = "".concat(sign).concat(hourOffset, ":").concat(minuteOffset);
+    } else {
+      tzOffset = "Z";
+    }
+    var hour = addLeadingZeros(originalDate.getHours(), 2);
+    var minute = addLeadingZeros(originalDate.getMinutes(), 2);
+    var second = addLeadingZeros(originalDate.getSeconds(), 2);
+    var separator = result === "" ? "" : "T";
+    var time = [hour, minute, second].join(timeDelimiter);
+    result = "".concat(result).concat(separator).concat(time).concat(tzOffset);
+  }
+  return result;
+}
+
+export {
+  formatISO
+};

package/{cliExecutor-AWYR3T33.js → cliExecutor-BWBF2MTI.js}

@@ -1,7 +1,6 @@
 import {
   CLI_PROBE_BINARIES,
   CliProviderQuotaError,
-  buildCliProcessEnv,
   closeCliSession,
   detectCliProviderQuotaLimit,
   executeCli,
@@ -12,8 +11,10 @@ import {
   isBufferedCliStreamingProvider,
   materializeCliImageInputs,
   startCliSession
-} from "./chunk-4XEYAFLY.js";
-import "./chunk-JBTJAPUF.js";
+} from "./chunk-VL5KOY2C.js";
+import {
+  buildCliProcessEnv
+} from "./chunk-ZEZC7IIM.js";
 import {
   buildCliPrompt
 } from "./chunk-ATNTHIZI.js";

package/{clipboardy-BX4NMYHE.js → clipboardy-GCO3GT3I.js}

@@ -1,3 +1,6 @@
+import {
+  escapeStringRegexp
+} from "./chunk-IA7TRNNR.js";
 import {
   __commonJS,
   __require,
@@ -4173,14 +4176,6 @@ function uniqueString() {
   return crypto_random_string_default({ length: 32 });
 }
 
-// node_modules/subsume/node_modules/escape-string-regexp/index.js
-function escapeStringRegexp(string) {
-  if (typeof string !== "string") {
-    throw new TypeError("Expected a string");
-  }
-  return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
-}
-
 // node_modules/subsume/index.js
 var Subsume = class _Subsume {
   static parse(text, id) {