nolo-cli 0.35.0-alpha.1 → 0.36.0-alpha.2

package/chunk-T5HJEUQN.js

@@ -0,0 +1,956 @@
+import {
+  loadProfileConfig
+} from "./chunk-UNZDCI3O.js";
+import {
+  resolveDefaultSpawn
+} from "./chunk-IDZTNRP2.js";
+import {
+  isCompiledBinary
+} from "./chunk-A7GB5UGH.js";
+import {
+  DEFAULT_NOLO_SERVER_URL
+} from "./chunk-OLZBQWZU.js";
+import {
+  normalizeServerOrigin
+} from "./chunk-CF7PE763.js";
+
+// packages/cli/updateCommands.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, accessSync, constants } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname2, join as join2 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// packages/cli/windowsSelfUpdate.ts
+import { spawn } from "node:child_process";
+import {
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeSync,
+  writeFileSync
+} from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { dirname, isAbsolute, join, normalize } from "node:path";
+import { randomUUID } from "node:crypto";
+var UPDATE_STATE_FILE = "update-result.json";
+var UPDATE_STALE_MS = 15 * 60 * 1e3;
+var UPDATE_LOCK_FILE = "update.lock";
+function resolveNoloHome(env, homeDir = homedir()) {
+  return env.NOLO_HOME?.trim() || join(homeDir, ".nolo");
+}
+function resolveWindowsUpdateStatePath(env = process.env, homeDir = homedir()) {
+  return join(resolveNoloHome(env, homeDir), "updates", UPDATE_STATE_FILE);
+}
+function resolveTrustedWindowsToolPaths(env, execPath, overrides) {
+  const nodePath = overrides.nodePath ?? execPath;
+  const npmCliPath = overrides.npmCliPath ?? join(dirname(nodePath), "node_modules", "npm", "bin", "npm-cli.js");
+  const windowsRoot = env.SystemRoot?.trim() || env.WINDIR?.trim();
+  const powershellPath = overrides.powershellPath ?? (windowsRoot ? join(
+    windowsRoot,
+    "System32",
+    "WindowsPowerShell",
+    "v1.0",
+    "powershell.exe"
+  ) : "");
+  for (const [label, path] of Object.entries({
+    nodePath,
+    npmCliPath,
+    powershellPath
+  })) {
+    if (!path || !isAbsolute(path) || !existsSync(path)) {
+      throw new Error(
+        `Could not resolve trusted ${label}: ${path || "missing"}`
+      );
+    }
+  }
+  return { nodePath, npmCliPath, powershellPath };
+}
+function removeOwnedLock(lockPath, updateId) {
+  try {
+    const raw = readFileSync(lockPath, "utf8").trim();
+    const owner = raw.startsWith("{") ? JSON.parse(raw).updateId : raw;
+    if (owner === updateId) {
+      rmSync(lockPath, { force: true });
+    }
+  } catch {
+  }
+}
+function writeJsonAtomic(path, value) {
+  mkdirSync(dirname(path), { recursive: true });
+  const tempPath = `${path}.${process.pid}.tmp`;
+  writeFileSync(tempPath, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+  renameSync(tempPath, path);
+}
+function readWindowsUpdateState(env = process.env, homeDir = homedir()) {
+  const statePath = resolveWindowsUpdateStatePath(env, homeDir);
+  if (!existsSync(statePath)) return null;
+  try {
+    const parsed = JSON.parse(
+      readFileSync(statePath, "utf8")
+    );
+    if (!parsed || !["pending", "success", "failed"].includes(parsed.status)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function consumeWindowsUpdateStartupNotice(env = process.env, options = {}) {
+  const homeDir = options.homeDir ?? homedir();
+  const statePath = resolveWindowsUpdateStatePath(env, homeDir);
+  const state = readWindowsUpdateState(env, homeDir);
+  if (!state) return null;
+  if (state.status === "pending") {
+    if (options.ownerUpdateId && state.updateId && options.ownerUpdateId === state.updateId) {
+      return null;
+    }
+    const startedAt = Date.parse(state.startedAt);
+    const age = (options.now ?? Date.now()) - startedAt;
+    if (!Number.isFinite(age) || age < UPDATE_STALE_MS) {
+      return {
+        blocking: true,
+        text: `Nolo update is still running. Try again shortly.
+Log: ${state.logPath}`
+      };
+    }
+    if (state.lockPath && state.updateId) {
+      removeOwnedLock(state.lockPath, state.updateId);
+    }
+    rmSync(statePath, { force: true });
+    return {
+      blocking: false,
+      text: `The previous Nolo update helper stopped unexpectedly. Verify with "nolo -v"; a manual npm repair may be required.
+Log: ${state.logPath}`
+    };
+  }
+  rmSync(statePath, { force: true });
+  if (state.status === "success") {
+    return {
+      blocking: false,
+      text: `Nolo updated successfully: ${state.currentVersion} -> ${state.targetVersion ?? "latest"}.
+Log: ${state.logPath}`
+    };
+  }
+  return {
+    blocking: false,
+    text: `Nolo update failed. Verify with "nolo -v"; npm may require a manual repair.${state.message ? `
+${state.message}` : ""}
+Log: ${state.logPath}`
+  };
+}
+function defaultLaunchWindowsUpdateHelper(input) {
+  const child = spawn(input.execPath, [input.helperPath, input.payload], {
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true,
+    env: input.env
+  });
+  child.unref();
+  if (!child.pid) {
+    throw new Error("Windows update helper did not start");
+  }
+  return child.pid;
+}
+function buildWindowsUpdateHelperSource() {
+  return String.raw`"use strict";
+const { spawnSync } = require("node:child_process");
+const { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } = require("node:fs");
+const { dirname, isAbsolute, join, normalize, relative } = require("node:path");
+
+const payload = JSON.parse(Buffer.from(process.argv[2], "base64url").toString("utf8"));
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const log = (line) => appendFileSync(payload.logPath, "[" + new Date().toISOString() + "] " + line + "\n", "utf8");
+const writeState = (next) => {
+  mkdirSync(dirname(payload.statePath), { recursive: true });
+  const temp = payload.statePath + "." + payload.updateId + ".tmp";
+  writeFileSync(temp, JSON.stringify(next, null, 2) + "\n", "utf8");
+  renameSync(temp, payload.statePath);
+};
+const runNpm = (args) => {
+  const command = [payload.nodePath, payload.npmCliPath, ...args].join(" ");
+  log("> " + command);
+  const result = spawnSync(payload.nodePath, [payload.npmCliPath, ...args], {
+    encoding: "utf8",
+    windowsHide: true,
+    env: process.env,
+    cwd: payload.updateDir,
+    timeout: args[0] === "install" ? 5 * 60 * 1000 : 30 * 1000,
+  });
+  if (result.stdout) appendFileSync(payload.logPath, result.stdout, "utf8");
+  if (result.stderr) appendFileSync(payload.logPath, result.stderr, "utf8");
+  if (result.error) throw result.error;
+  return { code: result.status == null ? 1 : result.status, stdout: String(result.stdout || "").trim() };
+};
+const listOtherNoloPids = () => {
+  const script = "$selfPid=" + process.pid + "; Get-CimInstance Win32_Process | Where-Object { $_.ProcessId -ne $selfPid -and ($_.Name -ieq 'node.exe' -or $_.Name -ieq 'bun.exe') -and $_.CommandLine -and $_.CommandLine -match '\\\\node_modules\\\\nolo-cli\\\\index\\.js' } | ForEach-Object { $_.ProcessId }";
+  const result = spawnSync(payload.powershellPath, ["-NoProfile", "-NonInteractive", "-Command", script], {
+    encoding: "utf8",
+    windowsHide: true,
+    env: process.env,
+    cwd: payload.updateDir,
+    timeout: 10 * 1000,
+  });
+  if (result.error || result.status !== 0) {
+    throw new Error("Could not verify that all other Nolo windows are closed");
+  }
+  return String(result.stdout || "").split(/\r?\n/).map((value) => value.trim()).filter(Boolean);
+};
+const parseVersion = (raw) => {
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(String(raw).trim());
+  return match ? { main: [Number(match[1]), Number(match[2]), Number(match[3])], pre: match[4] ? match[4].split(".") : [] } : null;
+};
+const compare = (a, b) => {
+  const pa = parseVersion(a); const pb = parseVersion(b);
+  if (!pa || !pb) throw new Error("Invalid version comparison: " + a + " / " + 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 && !pb.pre.length) return 0;
+  if (!pa.pre.length) return 1;
+  if (!pb.pre.length) return -1;
+  for (let i = 0; i < Math.max(pa.pre.length, pb.pre.length); i++) {
+    const x = pa.pre[i], y = pb.pre[i];
+    if (x === undefined) return -1; if (y === undefined) return 1; if (x === y) continue;
+    const xn = /^\d+$/.test(x) ? Number(x) : NaN, 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;
+};
+const isWithin = (root, candidate) => {
+  const rel = relative(normalize(root), normalize(candidate));
+  return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+};
+const quoteCmd = (value) => '"' + String(value).replace(/"/g, '""') + '"';
+const quotePowerShell = (value) => "'" + String(value).replace(/'/g, "''") + "'";
+const quoteSh = (value) => "'" + String(value).replace(/'/g, "'\\''") + "'";
+const switchWindowsShims = (shimDir, entrypoint) => {
+  const shims = [
+    { path: join(shimDir, "nolo.cmd"), content: "@ECHO off\r\n" + quoteCmd(payload.nodePath) + " " + quoteCmd(entrypoint) + " %*\r\n" },
+    { path: join(shimDir, "nolo.ps1"), content: "& " + quotePowerShell(payload.nodePath) + " " + quotePowerShell(entrypoint) + " $args\r\nexit $LASTEXITCODE\r\n" },
+    { path: join(shimDir, "nolo"), content: "#!/bin/sh\nexec " + quoteSh(payload.nodePath.replace(/\\/g, "/")) + " " + quoteSh(entrypoint.replace(/\\/g, "/")) + " \"$@\"\n" },
+  ];
+  mkdirSync(shimDir, { recursive: true });
+  const prepared = shims.map((shim) => {
+    const temp = shim.path + "." + payload.updateId + ".new";
+    const backup = shim.path + "." + payload.updateId + ".bak";
+    writeFileSync(temp, shim.content, "utf8");
+    return { ...shim, temp, backup, existed: existsSync(shim.path) };
+  });
+  const activated = [];
+  try {
+    for (const shim of prepared) {
+      if (shim.existed) renameSync(shim.path, shim.backup);
+      try {
+        renameSync(shim.temp, shim.path);
+      } catch (error) {
+        if (shim.existed) {
+          try { renameSync(shim.backup, shim.path); } catch {}
+        }
+        throw error;
+      }
+      try { chmodSync(shim.path, 0o755); } catch {}
+      activated.push(shim);
+    }
+  } catch (error) {
+    for (const shim of [...activated].reverse()) {
+      try { rmSync(shim.path, { force: true }); } catch {}
+      if (shim.existed) {
+        try { renameSync(shim.backup, shim.path); } catch {}
+      }
+    }
+    for (const shim of prepared) try { rmSync(shim.temp, { force: true }); } catch {}
+    throw error;
+  }
+  return {
+    rollback: () => {
+      for (const shim of [...activated].reverse()) {
+        try { rmSync(shim.path, { force: true }); } catch {}
+        if (shim.existed) {
+          try { renameSync(shim.backup, shim.path); } catch {}
+        }
+      }
+    },
+    commit: () => {
+      for (const shim of prepared) {
+        try { rmSync(shim.backup, { force: true }); } catch {}
+      }
+    },
+  };
+};
+
+(async () => {
+  let uncommittedVersionPrefix = null;
+  const base = {
+    status: "pending",
+    currentVersion: payload.currentVersion,
+    channel: payload.channel,
+    startedAt: payload.startedAt,
+    logPath: payload.logPath,
+    helperPid: process.pid,
+    updateId: payload.updateId,
+    lockPath: payload.lockPath,
+  };
+  try {
+    log("Waiting for parent process " + payload.parentPid + " to exit");
+    let parentExited = false;
+    for (let waited = 0; waited < 480; waited++) {
+      try { process.kill(payload.parentPid, 0); await delay(250); }
+      catch { parentExited = true; break; }
+    }
+    if (!parentExited) throw new Error("Timed out waiting for the current Nolo process to exit");
+    await delay(250);
+
+    const otherProcessDeadline = Date.now() + 120 * 1000;
+    let otherPids = listOtherNoloPids();
+    let checks = 0;
+    while (otherPids.length > 0 && Date.now() < otherProcessDeadline) {
+      if (checks === 0 || checks % 10 === 0) log("Waiting for other Nolo processes: " + otherPids.join(", "));
+      await delay(1000);
+      otherPids = listOtherNoloPids();
+      checks++;
+    }
+    if (otherPids.length > 0) {
+      throw new Error("Other Nolo processes are still running: " + otherPids.join(", "));
+    }
+
+    const prefixResult = runNpm(["prefix", "-g"]);
+    if (prefixResult.code !== 0 || !prefixResult.stdout) throw new Error("Could not resolve npm global prefix");
+    const prefix = prefixResult.stdout.split(/\r?\n/).at(-1).trim();
+    const expectedRoot = normalize(join(prefix, "node_modules", "nolo-cli")).toLowerCase();
+    const managedRoot = normalize(payload.managedRoot).toLowerCase();
+    const oldEntrypoint = normalize(payload.entrypointPath).toLowerCase();
+    if (!isWithin(expectedRoot, oldEntrypoint) && !isWithin(managedRoot, oldEntrypoint)) {
+      throw new Error("Refusing to update a different npm prefix. Current entrypoint: " + payload.entrypointPath + "; npm prefix: " + prefix);
+    }
+
+    const targetResult = runNpm(["view", "nolo-cli@" + payload.channel, "version"]);
+    if (targetResult.code !== 0 || !parseVersion(targetResult.stdout)) {
+      throw new Error("Could not resolve nolo-cli@" + payload.channel + " target version");
+    }
+    const targetVersion = targetResult.stdout.split(/\r?\n/).at(-1).trim();
+    if (compare(targetVersion, payload.currentVersion) < 0) {
+      throw new Error("Refusing to downgrade " + payload.currentVersion + " to " + targetVersion);
+    }
+
+    if (compare(targetVersion, payload.currentVersion) > 0) {
+      const versionPrefix = join(payload.managedRoot, targetVersion + "-" + payload.updateId);
+      uncommittedVersionPrefix = versionPrefix;
+      mkdirSync(versionPrefix, { recursive: true });
+      const install = runNpm(["install", "-g", "--prefix", versionPrefix, "nolo-cli@" + payload.channel, "--force", "--progress"]);
+      if (install.code !== 0) throw new Error("npm install exited with code " + install.code);
+      const stagedPackagePath = join(versionPrefix, "node_modules", "nolo-cli", "package.json");
+      const staged = JSON.parse(readFileSync(stagedPackagePath, "utf8"));
+      if (staged.version !== targetVersion) {
+        throw new Error("Staged version mismatch: expected " + targetVersion + ", got " + (staged.version || "unknown"));
+      }
+      const stagedEntrypoint = join(versionPrefix, "node_modules", "nolo-cli", "index.js");
+      if (!existsSync(stagedEntrypoint)) throw new Error("Staged nolo entrypoint is missing");
+      const switchedShims = switchWindowsShims(prefix, stagedEntrypoint);
+      const verify = spawnSync(payload.nodePath, [stagedEntrypoint, "-v"], {
+        encoding: "utf8",
+        windowsHide: true,
+        env: { ...process.env, NOLO_UPDATE_OWNER_ID: payload.updateId },
+        cwd: payload.updateDir,
+        timeout: 30 * 1000,
+      });
+      if (verify.error || verify.status !== 0 || !String(verify.stdout || "").includes(targetVersion)) {
+        switchedShims.rollback();
+        throw new Error("The staged CLI failed its post-switch version check; the previous launch shims were restored");
+      }
+      switchedShims.commit();
+      uncommittedVersionPrefix = null;
+      for (const entry of readdirSync(payload.managedRoot)) {
+        const candidate = join(payload.managedRoot, entry);
+        if (normalize(candidate) !== normalize(versionPrefix)) {
+          try { rmSync(candidate, { recursive: true, force: true }); } catch {}
+        }
+      }
+      log("Verified nolo-cli " + targetVersion + " at " + stagedEntrypoint);
+    } else {
+      log("Already current at " + targetVersion);
+    }
+    writeState({ ...base, status: "success", targetVersion, finishedAt: new Date().toISOString() });
+  } catch (error) {
+    const message = error && error.message ? error.message : String(error);
+    log("ERROR: " + message);
+    if (uncommittedVersionPrefix) {
+      try { rmSync(uncommittedVersionPrefix, { recursive: true, force: true }); } catch {}
+    }
+    writeState({ ...base, status: "failed", finishedAt: new Date().toISOString(), message });
+    process.exitCode = 1;
+  } finally {
+    try {
+      const lock = JSON.parse(readFileSync(payload.lockPath, "utf8"));
+      if (lock.updateId === payload.updateId) {
+        rmSync(payload.lockPath, { force: true });
+      }
+    } catch {}
+    try { rmSync(__filename, { force: true }); } catch {}
+  }
+})();
+`;
+}
+function scheduleWindowsSelfUpdate(options) {
+  const env = options.env ?? process.env;
+  const homeDir = options.homeDir ?? homedir();
+  const statePath = resolveWindowsUpdateStatePath(env, homeDir);
+  const updateDir = dirname(statePath);
+  const managedRoot = join(resolveNoloHome(env, homeDir), "cli", "versions");
+  const lockPath = join(updateDir, UPDATE_LOCK_FILE);
+  const updateId = randomUUID();
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const logPath = join(updateDir, `update-${stamp}.log`);
+  const helperPath = join(
+    options.tempDir ?? tmpdir(),
+    `nolo-update-${randomUUID()}.cjs`
+  );
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  mkdirSync(updateDir, { recursive: true });
+  mkdirSync(dirname(helperPath), { recursive: true });
+  try {
+    const lockFd = openSync(lockPath, "wx");
+    try {
+      writeSync(
+        lockFd,
+        JSON.stringify({ updateId, startedAt }),
+        void 0,
+        "utf8"
+      );
+    } finally {
+      closeSync(lockFd);
+    }
+  } catch (error) {
+    if (!readWindowsUpdateState(env, homeDir)) {
+      try {
+        const lock = JSON.parse(readFileSync(lockPath, "utf8"));
+        const age = Date.now() - Date.parse(lock.startedAt ?? "");
+        if (Number.isFinite(age) && age >= UPDATE_STALE_MS) {
+          rmSync(lockPath, { force: true });
+          return scheduleWindowsSelfUpdate(options);
+        }
+      } catch {
+      }
+    }
+    throw new Error(
+      `Another Nolo update is already pending (${lockPath}): ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const execPath = options.execPath ?? process.execPath;
+  let trustedTools;
+  try {
+    trustedTools = resolveTrustedWindowsToolPaths(env, execPath, options);
+  } catch (error) {
+    removeOwnedLock(lockPath, updateId);
+    throw error;
+  }
+  const pending = {
+    status: "pending",
+    currentVersion: options.currentVersion,
+    channel: options.channel,
+    startedAt,
+    logPath,
+    updateId,
+    lockPath
+  };
+  try {
+    writeFileSync(helperPath, buildWindowsUpdateHelperSource(), "utf8");
+    writeFileSync(logPath, `[${startedAt}] Windows update scheduled
+`, "utf8");
+    writeJsonAtomic(statePath, pending);
+  } catch (error) {
+    removeOwnedLock(lockPath, updateId);
+    rmSync(helperPath, { force: true });
+    throw error;
+  }
+  const payload = Buffer.from(
+    JSON.stringify({
+      parentPid: options.parentPid ?? process.pid,
+      currentVersion: options.currentVersion,
+      channel: options.channel,
+      entrypointPath: normalize(options.entrypointPath),
+      startedAt,
+      statePath,
+      logPath,
+      updateDir,
+      updateId,
+      lockPath,
+      managedRoot,
+      ...trustedTools
+    }),
+    "utf8"
+  ).toString("base64url");
+  const launch = options.launchDetached ?? defaultLaunchWindowsUpdateHelper;
+  let helperPid;
+  try {
+    helperPid = launch({
+      execPath: options.execPath ?? process.execPath,
+      helperPath,
+      payload,
+      env
+    });
+  } catch (error) {
+    const state = readWindowsUpdateState(env, homeDir);
+    if (state?.updateId === updateId) {
+      rmSync(statePath, { force: true });
+    }
+    removeOwnedLock(lockPath, updateId);
+    rmSync(helperPath, { force: true });
+    throw error;
+  }
+  try {
+    writeJsonAtomic(statePath, { ...pending, helperPid });
+  } catch (error) {
+    try {
+      writeFileSync(
+        logPath,
+        `[${(/* @__PURE__ */ new Date()).toISOString()}] Could not persist helper pid: ${error instanceof Error ? error.message : String(error)}
+`,
+        { encoding: "utf8", flag: "a" }
+      );
+    } catch {
+    }
+  }
+  return { helperPid, statePath, logPath };
+}
+
+// packages/cli/updateCommands.ts
+function resolvePackageJsonPath() {
+  if (isCompiledBinary()) {
+    const execDir = dirname2(process.execPath);
+    const candidate2 = join2(execDir, "package.json");
+    if (existsSync2(candidate2)) return candidate2;
+    return null;
+  }
+  const CLI_DIR = dirname2(fileURLToPath(import.meta.url));
+  const candidate = join2(CLI_DIR, "package.json");
+  return existsSync2(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",
+    join2(homedir2(), ".local/bin"),
+    join2(homedir2(), ".nolo/bin")
+  ];
+  for (const dir of candidates) {
+    if (!existsSync2(dir)) continue;
+    try {
+      accessSync(dir, constants.W_OK);
+      return dir;
+    } catch {
+      continue;
+    }
+  }
+  return join2(homedir2(), ".nolo/bin");
+}
+function readPackageInfo() {
+  if (PACKAGE_JSON_PATH) {
+    try {
+      const raw = readFileSync2(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 [
+    "Nolo CLI doctor",
+    "---------------",
+    `version  ${info.packageName} ${info.version}`,
+    `install  ${info.installKind}`,
+    `channel  ${info.updateChannel}`,
+    `entry    ${info.entrypoint}`,
+    `server   ${info.serverUrl}`,
+    `profile  ${info.profileName}`,
+    `update   nolo update`,
+    "",
+    "If direct `nolo` differs from repo-local `bun ./packages/cli/index.ts`,",
+    "the global install is older than this checkout.",
+    "",
+    `Manual update: ${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: spawn2,
+  env,
+  cwd,
+  useCustomSink
+}) {
+  const proc = spawn2({
+    cmd: ["sh", "-c", script],
+    cwd,
+    stdin: "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;
+}
+async function runStandaloneBundleUpdate(options) {
+  const output = options.output ?? process.stdout;
+  const spawn2 = 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(
+      `\u2717 Standalone-bundle self-update is not supported on this platform
+  (platform=${process.platform}, arch=${process.arch}).
+  Only linux-x64 and darwin-arm64 bundles are published.
+  Falling back is not possible from a compiled binary; reinstall via:
+    ${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 = join2(homedir2(), ".nolo", extractSubdir);
+  const installDir = resolveStandaloneInstallDir();
+  const symlinkPath = join2(installDir, "nolo");
+  const script = `set -euo pipefail
+TEMP_DIR=$(mktemp -d)
+trap 'rm -rf "$TEMP_DIR"' EXIT
+
+echo "Downloading nolo from ${tarballUrl}..."
+if ! curl -fL --progress-bar "${tarballUrl}" -o "$TEMP_DIR/${tarballName}"; then
+  ${tarballUrl !== fallbackUrl ? `echo "Primary source unavailable, trying ${fallbackUrl}..."
+  if ! curl -fL --progress-bar "${fallbackUrl}" -o "$TEMP_DIR/${tarballName}"; then
+    echo "Error: download failed from ${fallbackUrl}" >&2
+    exit 1
+  fi` : `echo "Error: download failed from ${tarballUrl}" >&2
+  exit 1`}
+fi
+
+mkdir -p "${extractDir}"
+tar -xzf "$TEMP_DIR/${tarballName}" -C "${extractDir}"
+chmod +x "${extractDir}/nolo"
+
+mkdir -p "${installDir}"
+if [ -e "${symlinkPath}" ] || [ -L "${symlinkPath}" ]; then
+  rm -f "${symlinkPath}"
+fi
+ln -s "${extractDir}/nolo" "${symlinkPath}"
+trap - EXIT
+
+echo "nolo updated to ${installDir}/nolo"
+`;
+  output.write(`
+Nolo Agent CLI Installer & Updater
+`);
+  output.write(`-----------------------------------------
+`);
+  output.write(`\u2713 Target channel: ${channel} (standalone bundle)
+`);
+  output.write(`\u25B8 Downloading and installing bundle...
+`);
+  const useCustomSink = options.output !== void 0;
+  const exitCode = await runShellScript(script, {
+    output,
+    spawn: spawn2,
+    env,
+    useCustomSink
+  });
+  if (exitCode === 0) {
+    output.write(`  ${renderProgressBar(100)}
+`);
+    output.write(`\u2713 Update completed successfully!
+
+`);
+  }
+  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 spawn2 = 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(`
+Nolo Agent CLI Installer & Updater
+`);
+      output.write(`-----------------------------------------
+`);
+      output.write(`\u2713 Target channel: ${channel} (nolo-cli@${channel})
+`);
+      output.write(`\u2713 Safe Windows update scheduled (helper pid ${scheduled.helperPid}).
+`);
+      output.write(`\u25B8 Exit Nolo normally. Installation starts after this process releases its files.
+`);
+      output.write(`\u25B8 Do not open another Nolo window until the update finishes.
+`);
+      output.write(`  Log: ${scheduled.logPath}
+
+`);
+      return { exitCode: 0, disposition: "scheduled" };
+    } catch (error) {
+      output.write(
+        `\u2717 Could not schedule the Windows update: ${error instanceof Error ? error.message : String(error)}
+`
+      );
+      output.write(
+        `  Manual update after closing every Nolo window: ${command.join(" ")}
+`
+      );
+      return { exitCode: 1, disposition: "completed" };
+    }
+  }
+  output.write(`
+Nolo Agent CLI Installer & Updater
+`);
+  output.write(`-----------------------------------------
+`);
+  output.write(`\u2713 Target channel: ${channel} (nolo-cli@${channel})
+`);
+  output.write(`\u25B8 Downloading and installing package via npm...
+`);
+  const useCustomSink = options.output !== void 0;
+  const proc = spawn2({
+    cmd: command,
+    stdin: "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(`\u2713 Update completed successfully!
+
+`);
+    }
+    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(`\u2713 Update completed successfully!
+
+`);
+  }
+  return { exitCode, disposition: "completed" };
+}
+async function runSelfUpdate(outputOrOptions) {
+  return (await runSelfUpdateDetailed(outputOrOptions)).exitCode;
+}
+
+export {
+  consumeWindowsUpdateStartupNotice,
+  getCliInstallChannel,
+  renderProgressBar,
+  buildNpmSelfUpdateCommand,
+  resolveStandaloneBundlePlatform,
+  resolveStandaloneBundleRepoBase,
+  buildStandaloneManualUpdateHint,
+  readPackageInfo,
+  buildCliVersionText,
+  buildSelfUpdateCommand,
+  resolveSelfUpdateServerUrl,
+  buildCliDoctorText,
+  runStandaloneBundleUpdate,
+  NOLO_UPDATE_CHECK_KILL_SWITCH,
+  compareCliVersions,
+  checkForCliUpdate,
+  runSelfUpdateDetailed,
+  runSelfUpdate
+};