nolo-cli 0.180.0-alpha.2 → 0.182.0-alpha.1

package/chunk-G5LNJZJH.js

@@ -0,0 +1,584 @@
+import {
+  isCompiledBinary
+} from "./chunk-WACI5I6V.js";
+import {
+  DEFAULT_NOLO_SERVER_URL
+} from "./chunk-OLZBQWZU.js";
+import {
+  loadProfileConfig
+} from "./chunk-R5GO3YZP.js";
+import {
+  resolveDefaultSpawn
+} from "./chunk-Y6ROFCZO.js";
+import {
+  scheduleWindowsSelfUpdate
+} from "./chunk-53HMDUG6.js";
+import {
+  t
+} from "./chunk-PS3GU7YU.js";
+import {
+  normalizeServerOrigin
+} from "./chunk-CF7PE763.js";
+
+// packages/cli/updateCommands.ts
+import { existsSync, readFileSync, accessSync, constants } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+function resolvePackageJsonPath() {
+  if (isCompiledBinary()) {
+    const execDir = dirname(process.execPath);
+    const candidate2 = join(execDir, "package.json");
+    if (existsSync(candidate2)) return candidate2;
+    return null;
+  }
+  const CLI_DIR = dirname(fileURLToPath(import.meta.url));
+  const candidate = join(CLI_DIR, "package.json");
+  return existsSync(candidate) ? candidate : null;
+}
+var PACKAGE_JSON_PATH = resolvePackageJsonPath();
+function getCliInstallChannel(serverUrl) {
+  const normalized = normalizeServerOrigin(serverUrl);
+  if (!normalized) {
+    return "latest";
+  }
+  try {
+    const hostname = new URL(normalized).hostname.toLowerCase();
+    if (hostname === "us.nolo.chat" || hostname.endsWith(".us.nolo.chat")) {
+      return "alpha";
+    }
+  } catch {
+    if (/us\.nolo\.chat/i.test(normalized)) {
+      return "alpha";
+    }
+  }
+  return "latest";
+}
+function renderProgressBar(percent, width = 30) {
+  const pct = Math.max(0, Math.min(100, percent));
+  const filledLen = Math.round(width * pct / 100);
+  const emptyLen = width - filledLen;
+  const bar = "#".repeat(filledLen) + " ".repeat(emptyLen);
+  const pctText = pct.toFixed(1).padStart(5, " ");
+  return `[${bar}] ${pctText}%`;
+}
+function buildNpmSelfUpdateCommand(channel = "latest") {
+  return ["npm", "install", "-g", `nolo-cli@${channel}`, "--force", "--progress"];
+}
+function resolveStandaloneBundlePlatform(platform = process.platform, arch = process.arch) {
+  if (platform === "linux" && arch === "x64") {
+    return { tarballName: "nolo-linux-x64.tar.gz", extractSubdir: "nolo-linux-x64" };
+  }
+  if (platform === "darwin" && arch === "arm64") {
+    return { tarballName: "nolo-darwin-arm64.tar.gz", extractSubdir: "nolo-darwin-arm64" };
+  }
+  return null;
+}
+function resolveStandaloneBundleRepoBase(channel) {
+  return channel === "alpha" ? "https://us.nolo.chat" : "https://nolo.chat";
+}
+function buildStandaloneManualUpdateHint(channel) {
+  const repoBase = resolveStandaloneBundleRepoBase(channel);
+  return `curl -fsSL ${repoBase}/install-nolo.sh | sh`;
+}
+function resolveStandaloneInstallDir() {
+  const candidates = [
+    "/usr/local/bin",
+    join(homedir(), ".local/bin"),
+    join(homedir(), ".nolo/bin")
+  ];
+  for (const dir of candidates) {
+    if (!existsSync(dir)) continue;
+    try {
+      accessSync(dir, constants.W_OK);
+      return dir;
+    } catch {
+      continue;
+    }
+  }
+  return join(homedir(), ".nolo/bin");
+}
+function readPackageInfo() {
+  if (PACKAGE_JSON_PATH) {
+    try {
+      const raw = readFileSync(PACKAGE_JSON_PATH, "utf8");
+      const parsed = JSON.parse(raw);
+      return {
+        name: parsed.name || "nolo-cli",
+        version: parsed.version || "0.0.0"
+      };
+    } catch {
+    }
+  }
+  return {
+    name: process.env.NOLO_CLI_PACKAGE_NAME || "nolo-cli",
+    version: process.env.NOLO_CLI_VERSION || "0.0.0"
+  };
+}
+function buildCliVersionText(info) {
+  return `${info.name} ${info.version}`;
+}
+function buildSelfUpdateCommand(serverUrl) {
+  return buildNpmSelfUpdateCommand(getCliInstallChannel(serverUrl));
+}
+function resolveSelfUpdateServerUrl(env = process.env, override) {
+  if (override?.trim()) {
+    return normalizeServerOrigin(override);
+  }
+  const fromEnv = env.NOLO_SERVER || env.BASE_URL;
+  if (typeof fromEnv === "string" && fromEnv.trim()) {
+    return normalizeServerOrigin(fromEnv);
+  }
+  const profile = loadProfileConfig();
+  const profileUrl = profile?.profiles?.[profile.currentProfile]?.serverUrl;
+  if (profileUrl?.trim()) {
+    return normalizeServerOrigin(profileUrl);
+  }
+  return DEFAULT_NOLO_SERVER_URL;
+}
+function buildCliDoctorText(info) {
+  return [
+    t("updateDoctorTitle"),
+    "---------------",
+    t("updateDoctorVersion", info.packageName, info.version),
+    t("updateDoctorInstall", info.installKind),
+    t("updateDoctorChannel", info.updateChannel),
+    t("updateDoctorEntry", info.entrypoint),
+    t("updateDoctorServer", info.serverUrl),
+    t("updateDoctorProfile", info.profileName),
+    t("updateDoctorCommand"),
+    "",
+    t("updateDoctorDiff"),
+    t("updateDoctorOlder"),
+    "",
+    t("updateDoctorManual", info.installKind === "standalone-bundle" ? buildStandaloneManualUpdateHint(info.updateChannel) : buildNpmSelfUpdateCommand(info.updateChannel).join(" "))
+  ].join("\n");
+}
+function isRunSelfUpdateOptions(value) {
+  return typeof value === "object" && value !== null && ("output" in value || "spawn" in value || "entrypointPath" in value || "serverUrl" in value || "env" in value || "platform" in value || "scheduleWindowsUpdate" in value);
+}
+async function forwardSpawnOutput(stream, output) {
+  if (!stream) {
+    return;
+  }
+  for await (const chunk of stream) {
+    output.write(normalizeSpawnChunk(chunk));
+  }
+}
+function normalizeSpawnChunk(chunk) {
+  if (typeof chunk === "string" || chunk instanceof Uint8Array) {
+    return chunk;
+  }
+  if (chunk instanceof ArrayBuffer) {
+    return new Uint8Array(chunk);
+  }
+  return new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+}
+async function runShellScript(script, {
+  output,
+  spawn,
+  env,
+  cwd,
+  useCustomSink
+}) {
+  const proc = spawn({
+    cmd: ["sh", "-c", script],
+    cwd,
+    // Capture mode (TUI sink): ignore stdin — the TUI's own decoder is
+    // reading the tty, and a child that reads stdin would race it for keys.
+    // The inherit branch is unreachable inside the TUI (useCustomSink is
+    // always true there) and stays the correct choice for `nolo update`.
+    stdin: useCustomSink ? "ignore" : "inherit",
+    stdout: useCustomSink ? "pipe" : "inherit",
+    stderr: useCustomSink ? "pipe" : "inherit",
+    env
+  });
+  if (!useCustomSink) {
+    return proc.exited;
+  }
+  const [exitCode] = await Promise.all([
+    proc.exited,
+    forwardSpawnOutput(proc.stdout, output),
+    forwardSpawnOutput(proc.stderr, output)
+  ]);
+  return exitCode;
+}
+function shellQuote(value) {
+  return "'" + value.replace(/'/g, "'\\''") + "'";
+}
+function buildStandaloneUpdateScript(args) {
+  const curl = "curl -fL --progress-bar --connect-timeout 20 --max-time 600 --speed-limit 1 --speed-time 60";
+  return `set -eu
+EXTRACT_DIR=${shellQuote(args.extractDir)}
+ENTRY=${shellQuote(args.symlinkPath)}
+CURRENT_VERSION=${shellQuote(args.currentVersion)}
+STAGING="$EXTRACT_DIR.new.$$"
+BACKUP="$EXTRACT_DIR.old.$$"
+LINK="$ENTRY.new.$$"
+old_moved=0
+new_moved=0
+committed=0
+cleanup() {
+  status=$?
+  trap - 0 HUP INT TERM
+  if [ "$committed" = 0 ]; then
+    if [ "$new_moved" = 1 ] && [ -d "$EXTRACT_DIR" ]; then
+      mv "$EXTRACT_DIR" "$STAGING" || exit 1
+    fi
+    if [ "$old_moved" = 1 ] && [ -d "$BACKUP" ]; then
+      mv "$BACKUP" "$EXTRACT_DIR" || exit 1
+    fi
+  fi
+  rm -rf "$STAGING" || true
+  rm -f "$LINK" || true
+  exit "$status"
+}
+# Refuse collisions before installing cleanup: never remove somebody else's path.
+if [ -e "$STAGING" ] || [ -L "$STAGING" ] ||
+   [ -e "$BACKUP" ] || [ -L "$BACKUP" ] ||
+   [ -e "$LINK" ] || [ -L "$LINK" ]; then
+  echo "Error: update staging path already exists" >&2
+  exit 1
+fi
+mkdir -p "\${EXTRACT_DIR%/*}"
+mkdir "$STAGING"
+trap cleanup 0
+trap 'exit 1' HUP INT TERM
+
+echo ${shellQuote(`Downloading nolo from ${args.tarballUrl}...`)}
+if ! ${curl} ${shellQuote(args.tarballUrl)} -o "$STAGING/bundle.tar.gz"; then
+  ${args.tarballUrl !== args.fallbackUrl ? `echo ${shellQuote(`Primary source unavailable, trying ${args.fallbackUrl}...`)}
+  if ! ${curl} ${shellQuote(args.fallbackUrl)} -o "$STAGING/bundle.tar.gz"; then
+    echo "Error: download failed" >&2
+    exit 1
+  fi` : `echo "Error: download failed" >&2
+  exit 1`}
+fi
+tar -xzf "$STAGING/bundle.tar.gz" -C "$STAGING"
+rm -f "$STAGING/bundle.tar.gz"
+chmod +x "$STAGING/nolo"
+# A failing, empty or malformed version response must not touch the live install.
+VERSION_TEXT=$("$STAGING/nolo" -v)
+case "$VERSION_TEXT" in
+  "nolo-cli "*) VERSION=\${VERSION_TEXT#nolo-cli } ;;
+  *) VERSION=$VERSION_TEXT ;;
+esac
+CORE=\${VERSION%%[-+]*}
+MAJOR=\${CORE%%.*}
+REST=\${CORE#*.}
+MINOR=\${REST%%.*}
+PATCH=\${REST#*.}
+case "$MAJOR:$MINOR:$PATCH" in
+  *[!0-9:]*|:*|*::*|*:) echo "Error: invalid bundle version" >&2; exit 1 ;;
+esac
+if [ "$CORE" != "$MAJOR.$MINOR.$PATCH" ]; then
+  echo "Error: invalid bundle version" >&2
+  exit 1
+fi
+case "$VERSION" in
+  *[!0-9A-Za-z.+-]*) echo "Error: invalid bundle version" >&2; exit 1 ;;
+esac
+case "$CURRENT_VERSION" in
+  "nolo-cli "*) CUR_VER=\${CURRENT_VERSION#nolo-cli } ;;
+  *) CUR_VER=$CURRENT_VERSION ;;
+esac
+CUR_CORE=\${CUR_VER%%[-+]*}
+CUR_MAJOR=\${CUR_CORE%%.*}
+CUR_REST=\${CUR_CORE#*.}
+CUR_MINOR=\${CUR_REST%%.*}
+CUR_PATCH=\${CUR_REST#*.}
+if [ -n "$CUR_MAJOR" ] && [ -n "$CUR_MINOR" ] && [ -n "$CUR_PATCH" ]; then
+  case "$CUR_MAJOR:$CUR_MINOR:$CUR_PATCH" in
+    *[!0-9:]*|:*|*::*|*:) ;;
+    *)
+      if [ "$CUR_CORE" = "$CUR_MAJOR.$CUR_MINOR.$CUR_PATCH" ]; then
+        is_downgrade=0
+        if [ "$MAJOR" -lt "$CUR_MAJOR" ]; then
+          is_downgrade=1
+        elif [ "$MAJOR" -eq "$CUR_MAJOR" ]; then
+          if [ "$MINOR" -lt "$CUR_MINOR" ]; then
+            is_downgrade=1
+          elif [ "$MINOR" -eq "$CUR_MINOR" ]; then
+            if [ "$PATCH" -lt "$CUR_PATCH" ]; then
+              is_downgrade=1
+            fi
+          fi
+        fi
+        if [ "$is_downgrade" = 1 ]; then
+          echo "Error: refusing downgrade from $CURRENT_VERSION to $VERSION" >&2
+          exit 11
+        fi
+      fi
+      ;;
+  esac
+fi
+if [ "$VERSION" = "$CURRENT_VERSION" ]; then
+  echo "\u2713 Already up to date (nolo-cli $VERSION)."
+  exit 10
+fi
+mkdir -p "\${ENTRY%/*}"
+# mv without -T is portable only when the destination is not a directory.
+if [ -d "$ENTRY" ] || [ -L "$EXTRACT_DIR" ]; then
+  echo "Error: refusing directory entrypoint or symlink bundle directory" >&2
+  exit 1
+fi
+ln -s "$EXTRACT_DIR/nolo" "$LINK"
+if [ -e "$EXTRACT_DIR" ]; then
+  old_moved=1
+  mv "$EXTRACT_DIR" "$BACKUP"
+fi
+new_moved=1
+mv "$STAGING" "$EXTRACT_DIR"
+mv -f "$LINK" "$ENTRY"
+committed=1
+# Retain only the newest recovery copy from this run; prune older backups.
+for old_copy in "$EXTRACT_DIR.old."*; do
+  if [ -d "$old_copy" ] && [ ! -L "$old_copy" ] && [ "$old_copy" != "$BACKUP" ]; then
+    rm -rf "$old_copy" || true
+  fi
+done
+# Retain the previous bundle as a recovery copy; never unlink the live entry.
+echo "nolo updated to $ENTRY"
+`;
+}
+async function runStandaloneBundleUpdate(options) {
+  const output = options.output ?? process.stdout;
+  const spawn = options.spawn ?? resolveDefaultSpawn();
+  const env = options.env ?? process.env;
+  const serverUrl = resolveSelfUpdateServerUrl(env, options.serverUrl);
+  const channel = getCliInstallChannel(serverUrl);
+  const platform = resolveStandaloneBundlePlatform();
+  if (!platform) {
+    output.write(
+      t("updateUnsupported", process.platform, process.arch, buildStandaloneManualUpdateHint(channel))
+    );
+    return 1;
+  }
+  const { tarballName, extractSubdir } = platform;
+  const repoBase = resolveStandaloneBundleRepoBase(channel);
+  const tarballUrl = `${repoBase}/public/downloads/${tarballName}`;
+  const fallbackUrl = `https://nolo.chat/public/downloads/${tarballName}`;
+  const extractDir = join(homedir(), ".nolo", extractSubdir);
+  const installDir = resolveStandaloneInstallDir();
+  const symlinkPath = join(installDir, "nolo");
+  const script = buildStandaloneUpdateScript({
+    tarballUrl,
+    fallbackUrl,
+    extractDir,
+    symlinkPath,
+    currentVersion: readPackageInfo().version
+  });
+  output.write(`
+${t("updateInstallerTitle")}
+`);
+  output.write(`-----------------------------------------
+`);
+  output.write(`${t("updateBundleTarget", channel)}
+`);
+  output.write(`${t("updateBundleDownloading")}
+`);
+  const useCustomSink = options.output !== void 0;
+  const exitCode = await runShellScript(script, {
+    output,
+    spawn,
+    env,
+    useCustomSink
+  });
+  if (exitCode === 10) {
+    output.write(`  ${renderProgressBar(100)}
+`);
+    return 0;
+  }
+  if (exitCode === 0) {
+    output.write(`  ${renderProgressBar(100)}
+`);
+    output.write(`${t("updateCompleted")}
+
+`);
+  }
+  return exitCode;
+}
+var NOLO_UPDATE_CHECK_KILL_SWITCH = "NOLO_CLI_NO_UPDATE_CHECK";
+function parseCliVersion(raw) {
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(raw.trim());
+  if (!match) return null;
+  return {
+    main: [Number(match[1]), Number(match[2]), Number(match[3])],
+    pre: match[4] ? match[4].split(".") : []
+  };
+}
+function compareCliVersions(a, b) {
+  const pa = parseCliVersion(a);
+  const pb = parseCliVersion(b);
+  if (!pa || !pb) return a.localeCompare(b);
+  for (let i = 0; i < 3; i++) {
+    if (pa.main[i] !== pb.main[i]) return pa.main[i] < pb.main[i] ? -1 : 1;
+  }
+  if (pa.pre.length === 0 && pb.pre.length === 0) return 0;
+  if (pa.pre.length === 0) return 1;
+  if (pb.pre.length === 0) return -1;
+  const len = Math.max(pa.pre.length, pb.pre.length);
+  for (let i = 0; i < len; i++) {
+    const x = pa.pre[i];
+    const y = pb.pre[i];
+    if (x === void 0) return -1;
+    if (y === void 0) return 1;
+    if (x === y) continue;
+    const xn = /^\d+$/.test(x) ? Number(x) : NaN;
+    const yn = /^\d+$/.test(y) ? Number(y) : NaN;
+    if (!Number.isNaN(xn) && !Number.isNaN(yn)) return xn < yn ? -1 : 1;
+    if (!Number.isNaN(xn)) return -1;
+    if (!Number.isNaN(yn)) return 1;
+    return x < y ? -1 : 1;
+  }
+  return 0;
+}
+async function checkForCliUpdate(currentVersion, serverUrl, options = {}) {
+  const env = options.env ?? process.env;
+  if ((env[NOLO_UPDATE_CHECK_KILL_SWITCH] ?? process.env[NOLO_UPDATE_CHECK_KILL_SWITCH]) === "1") {
+    return null;
+  }
+  if (!currentVersion || !parseCliVersion(currentVersion)) return null;
+  const channel = getCliInstallChannel(serverUrl);
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const timeoutMs = options.timeoutMs ?? 2e3;
+  try {
+    const res = await fetchImpl(
+      `https://registry.npmjs.org/nolo-cli/${channel}`,
+      {
+        signal: AbortSignal.timeout(timeoutMs),
+        headers: { accept: "application/json" }
+      }
+    );
+    if (!res.ok) return null;
+    const data = await res.json();
+    const latestVersion = data.version;
+    if (!latestVersion || !parseCliVersion(latestVersion) || compareCliVersions(latestVersion, currentVersion) <= 0) {
+      return null;
+    }
+    return { latestVersion, channel };
+  } catch {
+    return null;
+  }
+}
+async function runSelfUpdateDetailed(outputOrOptions) {
+  const options = outputOrOptions === void 0 ? {} : isRunSelfUpdateOptions(outputOrOptions) ? outputOrOptions : { output: outputOrOptions };
+  if (isCompiledBinary()) {
+    return {
+      exitCode: await runStandaloneBundleUpdate(options),
+      disposition: "completed"
+    };
+  }
+  const output = options.output ?? process.stdout;
+  const spawn = options.spawn ?? resolveDefaultSpawn();
+  const env = options.env ?? process.env;
+  const serverUrl = resolveSelfUpdateServerUrl(env, options.serverUrl);
+  const channel = getCliInstallChannel(serverUrl);
+  const command = buildNpmSelfUpdateCommand(channel);
+  if ((options.platform ?? process.platform) === "win32") {
+    const packageInfo = readPackageInfo();
+    const entrypointPath = options.entrypointPath ?? fileURLToPath(import.meta.url);
+    const schedule = options.scheduleWindowsUpdate ?? scheduleWindowsSelfUpdate;
+    try {
+      const scheduled = schedule({
+        channel,
+        currentVersion: packageInfo.version,
+        entrypointPath,
+        env
+      });
+      output.write(`
+${t("updateInstallerTitle")}
+`);
+      output.write(`-----------------------------------------
+`);
+      output.write(`${t("updateNpmTarget", channel)}
+`);
+      output.write(`${t("updateScheduled", String(scheduled.helperPid))}
+`);
+      output.write(`${t("updateKeepUsing")}
+`);
+      output.write(`${t("updateBackground")}
+`);
+      output.write(`${t("updateCheckLog", scheduled.logPath)}
+
+`);
+      return { exitCode: 0, disposition: "scheduled" };
+    } catch (error) {
+      output.write(
+        `${t("updateScheduleFailed", error instanceof Error ? error.message : String(error))}
+`
+      );
+      output.write(
+        `${t("updateManualClose", command.join(" "))}
+`
+      );
+      return { exitCode: 1, disposition: "completed" };
+    }
+  }
+  output.write(`
+${t("updateInstallerTitle")}
+`);
+  output.write(`-----------------------------------------
+`);
+  output.write(`${t("updateNpmTarget", channel)}
+`);
+  output.write(`${t("updateNpmDownloading")}
+`);
+  const useCustomSink = options.output !== void 0;
+  const proc = spawn({
+    cmd: command,
+    // Capture mode (TUI sink): ignore stdin — see runShellScript.
+    stdin: useCustomSink ? "ignore" : "inherit",
+    stdout: useCustomSink ? "pipe" : "inherit",
+    stderr: useCustomSink ? "pipe" : "inherit",
+    env
+  });
+  if (!useCustomSink) {
+    const exitCode2 = await proc.exited;
+    if (exitCode2 === 0) {
+      output.write(`  ${renderProgressBar(100)}
+`);
+      output.write(`${t("updateCompleted")}
+
+`);
+    }
+    return { exitCode: exitCode2, disposition: "completed" };
+  }
+  const [exitCode] = await Promise.all([
+    proc.exited,
+    forwardSpawnOutput(proc.stdout, output),
+    forwardSpawnOutput(proc.stderr, output)
+  ]);
+  if (exitCode === 0) {
+    output.write(`  ${renderProgressBar(100)}
+`);
+    output.write(`${t("updateCompleted")}
+
+`);
+  }
+  return { exitCode, disposition: "completed" };
+}
+async function runSelfUpdate(outputOrOptions) {
+  return (await runSelfUpdateDetailed(outputOrOptions)).exitCode;
+}
+
+export {
+  getCliInstallChannel,
+  renderProgressBar,
+  buildNpmSelfUpdateCommand,
+  resolveStandaloneBundlePlatform,
+  resolveStandaloneBundleRepoBase,
+  buildStandaloneManualUpdateHint,
+  readPackageInfo,
+  buildCliVersionText,
+  buildSelfUpdateCommand,
+  resolveSelfUpdateServerUrl,
+  buildCliDoctorText,
+  buildStandaloneUpdateScript,
+  runStandaloneBundleUpdate,
+  NOLO_UPDATE_CHECK_KILL_SWITCH,
+  compareCliVersions,
+  checkForCliUpdate,
+  runSelfUpdateDetailed,
+  runSelfUpdate
+};

package/{chunk-HTSXDJHA.js → chunk-GQEQYXWV.js}

@@ -1,17 +1,17 @@
-import {
-  buildDialogAttachmentPlan,
-  extractFileContentIds
-} from "./chunk-OFFL4DCR.js";
 import {
   BUILTIN_DIALOG_LLM_FALLBACK_MODEL,
   BUILTIN_SUMMARY_LLM_CONFIG
 } from "./chunk-523DITKR.js";
+import {
+  buildDialogAttachmentPlan,
+  extractFileContentIds
+} from "./chunk-OFFL4DCR.js";
 import {
   isMediaToolConfirmation
 } from "./chunk-QYPE3TS3.js";
 import {
   runLlm
-} from "./chunk-HS7JBDUJ.js";
+} from "./chunk-QHFRRM5U.js";
 import {
   getApproxPricePerImage
 } from "./chunk-4JH2UMJR.js";
@@ -11064,7 +11064,7 @@ var messageSlice = createSliceWithThunks({
             runtimeOptions: args.runtimeOptions
           });
           if (agentKeyToUse) {
-            const { streamAgentChatTurn } = await import("./agentSlice-FCDRLXVA.js");
+            const { streamAgentChatTurn } = await import("./agentSlice-NG7VBT4O.js");
             await dispatch(
               streamAgentChatTurn({
                 agentKey: agentKeyToUse,
@@ -13881,7 +13881,7 @@ var deleteDialogThunk = async (payload, thunkApi) => {
   }
   if (isCurrentDialog) {
     await thunkApi.dispatch(resetMsgs());
-    const { clearPendingAttachments: clearPendingAttachments2 } = await import("./dialogSlice-PKFXK5WM.js");
+    const { clearPendingAttachments: clearPendingAttachments2 } = await import("./dialogSlice-VHGZCHAQ.js");
     dispatch(clearPendingAttachments2());
   }
   return { dialogKey, isCurrentDialog, attachmentPlan };
@@ -13889,15 +13889,15 @@ var deleteDialogThunk = async (payload, thunkApi) => {
 
 // packages/chat/dialog/dialogSlice.ts
 var runCreateDialogAction = async (args, thunkApi) => {
-  const { createDialogAction } = await import("./createDialogAction-G7QCYQT7.js");
+  const { createDialogAction } = await import("./createDialogAction-DBTKPCXV.js");
   return createDialogAction(args, thunkApi);
 };
 var runCreateAgentAutomationAction = async (args, thunkApi) => {
-  const { createAgentAutomationAction } = await import("./createAgentAutomationAction-ZOFCBZRE.js");
+  const { createAgentAutomationAction } = await import("./createAgentAutomationAction-FAOPVXNF.js");
   return createAgentAutomationAction(args, thunkApi);
 };
 var runUpdateDialogTitleAction = async (args, thunkApi) => {
-  const { updateDialogTitleAction } = await import("./updateDialogTitleAction-UUZ5HDM2.js");
+  const { updateDialogTitleAction } = await import("./updateDialogTitleAction-WBIPSXFL.js");
   return updateDialogTitleAction(args, thunkApi);
 };
 var runAddDialogAgentAction = async (args, thunkApi) => {
@@ -13921,7 +13921,7 @@ var runSetDialogExtraReferencesAction = async (args, thunkApi) => {
   return setDialogExtraReferencesAction(args, thunkApi);
 };
 var runHandleSendMessageAction = async (args, thunkApi) => {
-  const { handleSendMessageAction } = await import("./handleSendMessageAction-HUQLERJP.js");
+  const { handleSendMessageAction } = await import("./handleSendMessageAction-XTQQEVD4.js");
   return handleSendMessageAction(args, thunkApi);
 };
 function clearDialogState() {
@@ -13934,7 +13934,7 @@ var createPageAndAddReference = createAsyncThunk(
   async (payload, { dispatch, getState, rejectWithValue }) => {
     const { slateData, jsonData, title, type, fileId, groupId, dialogKey } = payload;
     try {
-      const { createDocState } = await import("./docStore-NAEY4CEK.js");
+      const { createDocState } = await import("./docStore-XGWH3T7Q.js");
       const pageKey = await createDocState(
         { slateData, title },
         { dispatch, getState }

package/{chunk-OXYSTN6B.js → chunk-GTQKUQGF.js}

@@ -3,7 +3,7 @@ import {
   classifyAgentApiKeyRef,
   formatUnsupportedAgentApiKeyRefMessage,
   shouldReadAgentKeyRemotely
-} from "./chunk-CTEEJJVR.js";
+} from "./chunk-MPIAKYZ7.js";
 import {
   resolveCliAgentKeyInput
 } from "./chunk-NBTY7YJF.js";

package/{chunk-WQAOAJ5Q.js → chunk-HRTEMYBI.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-62TBKWTV.js";
 import {
   clearCliLocalRuntimePreparedAgentCache
-} from "./chunk-SGATEZV5.js";
+} from "./chunk-BNEHIKIR.js";
 import {
   readCredentialAvailability
 } from "./chunk-R4BMKAR5.js";
@@ -19,7 +19,7 @@ import {
   resolveAgentRecordFromHybridStore,
   sanitizeAgentRecordForCliOutput,
   writeAgentRecord
-} from "./chunk-OXYSTN6B.js";
+} from "./chunk-GTQKUQGF.js";
 import {
   resolveCliAgentKeyInput
 } from "./chunk-NBTY7YJF.js";

package/{chunk-H63VHVFY.js → chunk-J2EVUNED.js}

@@ -1,12 +1,12 @@
 import {
   requireTokenUser
-} from "./chunk-4FZUUCXQ.js";
-import {
-  t
-} from "./chunk-TDX2L4W2.js";
+} from "./chunk-MMSZKZWA.js";
 import {
   resolveServerUrl
 } from "./chunk-WACI5I6V.js";
+import {
+  t
+} from "./chunk-PS3GU7YU.js";
 
 // packages/cli/cliApiClient.ts
 var CliApiError = class extends Error {