astragate 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,2360 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import process5 from "process";
+import { Argument, Command } from "commander";
+
+// src/errors.ts
+var AstraError = class extends Error {
+  hint;
+  constructor(message, hint) {
+    super(message);
+    this.name = "AstraError";
+    this.hint = hint;
+  }
+};
+
+// src/lib/http.ts
+var ApiError = class extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "ApiError";
+    this.status = status;
+  }
+};
+function baseUrlFor(host, port) {
+  let h = host.trim();
+  if (!h || h === "0.0.0.0" || h === "*" || h === "::") h = "127.0.0.1";
+  if (h.startsWith("[") && h.endsWith("]")) h = h.slice(1, -1);
+  return `http://${h.includes(":") ? `[${h}]` : h}:${port}`;
+}
+function adminHeaders(mutating, runtimeToken) {
+  const headers = { Accept: "application/json" };
+  if (mutating) headers["X-Astra-Admin"] = "1";
+  if (runtimeToken) headers["X-Astra-Runtime-Token"] = runtimeToken;
+  return headers;
+}
+async function apiRequest(options) {
+  const { base, path: path13, method = "GET", body, runtimeToken, timeoutMs = 1e4 } = options;
+  const doFetch = options.fetchImpl ?? globalThis.fetch;
+  if (!doFetch) {
+    throw new AstraError("fetch is unavailable. The Astra CLI requires Node.js 18+.");
+  }
+  const mutating = method !== "GET";
+  const headers = adminHeaders(mutating, runtimeToken);
+  if (body !== void 0) headers["Content-Type"] = "application/json";
+  let response;
+  try {
+    response = await doFetch(base + path13, {
+      method,
+      headers,
+      body: body === void 0 ? void 0 : JSON.stringify(body),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (err) {
+    throw new AstraError(
+      `Cannot reach the Astra server at ${base} (${describeFetchError(err)}).`,
+      "Start it with `astra start`."
+    );
+  }
+  const text = await response.text();
+  let payload;
+  if (text.trim()) {
+    try {
+      payload = JSON.parse(text);
+    } catch {
+      payload = void 0;
+    }
+  }
+  if (!response.ok) {
+    const serverMessage = readErrorMessage(payload);
+    throw new ApiError(
+      serverMessage ?? `${response.status} ${response.statusText || "request failed"}`,
+      response.status
+    );
+  }
+  return payload;
+}
+function readErrorMessage(payload) {
+  if (payload && typeof payload === "object" && "error" in payload) {
+    const e = payload.error;
+    if (typeof e === "string" && e) return e;
+  }
+  return void 0;
+}
+function describeFetchError(err) {
+  if (err instanceof Error) {
+    if (err.name === "TimeoutError" || err.name === "AbortError") return "timed out";
+    return err.message;
+  }
+  return String(err);
+}
+async function checkHealth(base, fetchImpl, timeoutMs = 2500) {
+  const doFetch = fetchImpl ?? globalThis.fetch;
+  if (!doFetch) return false;
+  try {
+    const res = await doFetch(`${base}/api/health`, { signal: AbortSignal.timeout(timeoutMs) });
+    if (!res.ok) return false;
+    const payload = await res.json();
+    return payload.status === "ok";
+  } catch {
+    return false;
+  }
+}
+async function shutdownRequest(base, runtimeToken, fetchImpl) {
+  await apiRequest({
+    base,
+    path: "/api/admin/shutdown",
+    method: "POST",
+    runtimeToken,
+    timeoutMs: 5e3,
+    fetchImpl
+  });
+}
+
+// src/ui.ts
+import process2 from "process";
+var useColor = process2.stdout.isTTY === true && process2.env.NO_COLOR !== "1" && process2.env.TERM !== "dumb";
+function wrap(open) {
+  return (text) => useColor ? `\x1B[${open}m${text}\x1B[0m` : text;
+}
+var style = {
+  bold: wrap("1"),
+  dim: wrap("2"),
+  green: wrap("32"),
+  yellow: wrap("33"),
+  red: wrap("31"),
+  cyan: wrap("36")
+};
+function info(message) {
+  console.log(message);
+}
+function success(message) {
+  console.log(style.green(message));
+}
+function warn(message) {
+  console.log(style.yellow(message));
+}
+function fail(message) {
+  console.error(style.red(message));
+}
+function printTable(rows, headers) {
+  const all = headers ? [headers, ...rows] : rows;
+  if (all.length === 0) return;
+  const widths = [];
+  for (const row of all) {
+    row.forEach((cell, i) => {
+      widths[i] = Math.max(widths[i] ?? 0, cell.length);
+    });
+  }
+  const line = (row) => row.map((cell, i) => cell + " ".repeat((widths[i] ?? 0) - cell.length)).join("  ");
+  if (headers) console.log(style.bold(line(headers)));
+  for (const row of rows) console.log(line(row));
+}
+
+// src/lib/platform.ts
+var RID_PREFIX = { darwin: "osx", linux: "linux", win32: "win" };
+var SUPPORTED_ARCHES = ["x64", "arm64"];
+function platformInfo(platform = process.platform, arch = process.arch) {
+  const ridPrefix = RID_PREFIX[platform];
+  if (!ridPrefix || !SUPPORTED_ARCHES.includes(arch)) {
+    throw new AstraError(
+      `Astra does not ship binaries for ${platform}/${arch}.`,
+      "Supported platforms: macOS (x64, arm64), Linux (x64, arm64), Windows (x64, arm64)."
+    );
+  }
+  const p = platform;
+  const dir = `${p}-${arch}`;
+  return {
+    platform: p,
+    arch,
+    rid: `${ridPrefix}-${arch}`,
+    serverPackage: `@aidotnet/server-${dir}`,
+    desktopPackage: `@aidotnet/desktop-${dir}`,
+    serverDir: `server-${dir}`,
+    desktopDir: `desktop-${dir}`,
+    binaryName: p === "win32" ? "astra-server.exe" : "astra-server"
+  };
+}
+var CLIENT_KINDS = [
+  "codex",
+  "claude-code",
+  "gemini-cli",
+  "opencode",
+  "claude-desktop",
+  "grok-build"
+];
+
+// src/commands/manage.ts
+import process3 from "process";
+
+// ../packages/update-core/src/manifest.ts
+var DEFAULT_FEED_URL = "https://astra-gate.si/api/client-releases";
+var DEFAULT_CHANNEL = "stable";
+var UpdateFeedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UpdateFeedError";
+  }
+};
+async function fetchManifest(o = {}) {
+  const feed = (o.feedUrl ?? DEFAULT_FEED_URL).trim();
+  const channel = (o.channel ?? DEFAULT_CHANNEL).trim() || DEFAULT_CHANNEL;
+  const url = `${feed.replace(/\/+$/, "")}/${channel}/latest.json`;
+  const doFetch = o.fetchImpl ?? globalThis.fetch;
+  if (!doFetch) throw new UpdateFeedError("fetch is unavailable (Node.js 18+ required).");
+  let response;
+  try {
+    response = await doFetch(url, {
+      headers: {
+        Accept: "application/json",
+        ...o.userAgent ? { "User-Agent": o.userAgent } : {}
+      },
+      signal: AbortSignal.timeout(o.timeoutMs ?? 15e3)
+    });
+  } catch (err) {
+    const reason = err instanceof Error ? err.name === "TimeoutError" || err.name === "AbortError" ? "timed out" : err.message : String(err);
+    throw new UpdateFeedError(`Cannot reach the update feed at ${url} (${reason}).`);
+  }
+  if (!response.ok) {
+    throw new UpdateFeedError(`Update feed responded ${response.status} ${response.statusText} for ${url}.`);
+  }
+  let manifest;
+  try {
+    manifest = await response.json();
+  } catch (err) {
+    throw new UpdateFeedError(`Update feed returned invalid JSON (${err instanceof Error ? err.message : String(err)}).`);
+  }
+  if (!manifest || typeof manifest.version !== "string" || manifest.version.trim() === "") {
+    throw new UpdateFeedError("Update manifest has no version.");
+  }
+  return manifest;
+}
+
+// ../packages/update-core/src/version.ts
+function parseVersion(v) {
+  if (!v) return null;
+  const core = v.trim().split("-", 1)[0].split("+", 1)[0].replace(/^v/, "");
+  const m = /^(\d+)(?:\.(\d+))?(?:\.(\d+))?$/.exec(core);
+  if (!m) return null;
+  return [Number(m[1]), Number(m[2] ?? 0), Number(m[3] ?? 0)];
+}
+function isNewerVersion(candidate, current) {
+  const c = parseVersion(candidate);
+  const cur = parseVersion(current);
+  if (!c || !cur) return false;
+  for (let i = 0; i < 3; i++) {
+    const a = c[i];
+    const b = cur[i];
+    if (a !== b) return a > b;
+  }
+  return false;
+}
+function majorOf(v) {
+  const m = /^\s*(\d+)(?:\.|$)/.exec(v ?? "");
+  const group = m?.[1];
+  return group ? Number.parseInt(group, 10) : null;
+}
+function isApiVersionCompatible(serverApiVersion, expectedMajor) {
+  const major = majorOf(serverApiVersion);
+  return major !== null && major === expectedMajor;
+}
+
+// ../packages/update-core/src/state.ts
+import fs from "fs";
+import path from "path";
+var MAX_CONSECUTIVE_FAILURES = 2;
+var KNOWN_PHASES = [
+  "idle",
+  "checking",
+  "downloading",
+  "swapping",
+  "restarting",
+  "rolling-back",
+  "failed"
+];
+function initialState(now = () => /* @__PURE__ */ new Date()) {
+  return { phase: "idle", failedCount: 0, updatedAt: now().toISOString() };
+}
+function readUpdateState(file) {
+  let text;
+  try {
+    text = fs.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+  if (!text.trim()) return null;
+  try {
+    const raw = JSON.parse(text);
+    if (!raw || typeof raw !== "object" || !KNOWN_PHASES.includes(raw.phase)) return null;
+    return {
+      phase: raw.phase,
+      ...raw.targetVersion !== void 0 ? { targetVersion: raw.targetVersion } : {},
+      ...raw.previousVersion !== void 0 ? { previousVersion: raw.previousVersion } : {},
+      ...raw.step !== void 0 ? { step: raw.step } : {},
+      ...raw.error !== void 0 ? { error: raw.error } : {},
+      failedCount: typeof raw.failedCount === "number" ? raw.failedCount : 0,
+      updatedAt: typeof raw.updatedAt === "string" ? raw.updatedAt : (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch {
+    return null;
+  }
+}
+function writeUpdateState(file, state, now = () => /* @__PURE__ */ new Date()) {
+  const payload = { ...state, updatedAt: now().toISOString() };
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp`;
+  fs.writeFileSync(tmp, `${JSON.stringify(payload, null, 2)}
+`);
+  fs.renameSync(tmp, file);
+}
+
+// ../packages/update-core/src/paths.ts
+import path2 from "path";
+function updatePaths(home) {
+  return {
+    stagingDir: path2.join(home, "updates", "staging"),
+    backupsDir: path2.join(home, "backups"),
+    serverDir: path2.join(home, "server"),
+    stateFile: path2.join(home, "update-state.json")
+  };
+}
+function managedServerBinaryPath(serverDir, version, platform) {
+  return path2.join(serverDir, `astra-server-${version}${platform === "win32" ? ".exe" : ""}`);
+}
+
+// ../packages/update-core/src/npm-runner.ts
+import { spawn } from "child_process";
+import fs2 from "fs";
+import path3 from "path";
+function locateNpm(o = {}) {
+  const env = o.env ?? process.env;
+  const platform = o.platform ?? process.platform;
+  const execPath = o.execPath ?? process.execPath;
+  const isNode = /^node(\.exe)?$/i.test(path3.basename(execPath));
+  if (isNode) {
+    const found = npmBesideNode(execPath, platform);
+    if (found) return found;
+  }
+  const home = env.HOME ?? "";
+  const candidates = platform === "win32" ? [path3.join(process.env.APPDATA ?? path3.join(home, "AppData", "Roaming"), "npm", "npm.cmd")] : ["/opt/homebrew/bin/npm", "/usr/local/bin/npm", "/usr/bin/npm"];
+  for (const candidate of candidates) {
+    if (candidate && fs2.existsSync(candidate)) return { command: candidate, args: [] };
+  }
+  return { command: platform === "win32" ? "npm.cmd" : "npm", args: [] };
+}
+function npmBesideNode(execPath, platform) {
+  const execDir = path3.dirname(execPath);
+  const prefix = platform === "win32" ? execDir : path3.basename(execDir) === "bin" ? path3.dirname(execDir) : execDir;
+  const cli = path3.join(prefix, "lib", "node_modules", "npm", "bin", "npm-cli.js");
+  if (fs2.existsSync(cli)) return { command: execPath, args: [cli] };
+  return null;
+}
+function usesShell(command, platform) {
+  return platform === "win32" && command.endsWith(".cmd");
+}
+function runCapture(command, args, o = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, [...args], {
+      env: o.env,
+      windowsHide: true,
+      shell: usesShell(command, o.platform ?? process.platform)
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const timer = o.timeoutMs ? setTimeout(() => {
+      settled = true;
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      reject(new Error(`Command timed out after ${o.timeoutMs}ms: ${command} ${args.join(" ")}`));
+    }, o.timeoutMs) : null;
+    child.stdout?.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("error", (err) => {
+      if (timer) clearTimeout(timer);
+      if (!settled) reject(err);
+    });
+    child.on("close", (code) => {
+      if (timer) clearTimeout(timer);
+      if (!settled) resolve({ code, stdout, stderr });
+    });
+  });
+}
+function npmCommand(o) {
+  return o.npm ?? locateNpm(o);
+}
+async function npmInstallIntoPrefix(prefix, spec, o = {}) {
+  const npm = npmCommand(o);
+  const r = await runCapture(
+    npm.command,
+    [...npm.args, "install", "--prefix", prefix, "--no-audit", "--no-fund", "--loglevel", "error", spec],
+    { env: o.env, platform: o.platform, timeoutMs: o.installTimeoutMs ?? 6e5 }
+  );
+  if (r.code !== 0) {
+    throw new Error(`Failed to install ${spec}: ${r.stderr.trim() || `npm exited with code ${r.code}`}`);
+  }
+}
+
+// ../packages/update-core/src/install-info.ts
+import fs3 from "fs";
+import path4 from "path";
+function readInstallInfo(home) {
+  let text;
+  try {
+    text = fs3.readFileSync(path4.join(home, "install.json"), "utf8");
+  } catch {
+    return null;
+  }
+  if (!text.trim()) return null;
+  try {
+    const raw = JSON.parse(text);
+    if (!raw || typeof raw !== "object") return null;
+    const info2 = {};
+    for (const key of ["serverPath", "serverVersion", "desktopPath", "desktopVersion", "updatedAt"]) {
+      const v = raw[key];
+      if (typeof v === "string" && v.length > 0) info2[key] = v;
+    }
+    return info2;
+  } catch {
+    return null;
+  }
+}
+function writeInstallInfo(home, info2) {
+  const file = path4.join(home, "install.json");
+  fs3.mkdirSync(path4.dirname(file), { recursive: true });
+  fs3.writeFileSync(file, `${JSON.stringify(info2, null, 2)}
+`);
+}
+function applyServerInfo(existing, server) {
+  return {
+    ...existing ?? {},
+    serverPath: server.serverPath,
+    ...server.serverVersion ? { serverVersion: server.serverVersion } : {},
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// ../packages/update-core/src/staging.ts
+import { createHash } from "crypto";
+import fs4 from "fs";
+import path5 from "path";
+function sha256File(file) {
+  const hash = createHash("sha256");
+  hash.update(fs4.readFileSync(file));
+  return hash.digest("hex");
+}
+async function stageServerBinary(o) {
+  const install = o.installIntoPrefix ?? npmInstallIntoPrefix;
+  fs4.rmSync(o.stagingDir, { recursive: true, force: true });
+  fs4.mkdirSync(o.stagingDir, { recursive: true });
+  o.log?.(`Downloading ${o.serverPackage}@${o.version}\u2026`);
+  await install(o.stagingDir, `${o.serverPackage}@${o.version}`);
+  const binaryName = o.platform === "win32" ? "astra-server.exe" : "astra-server";
+  const staged = path5.join(o.stagingDir, "node_modules", ...o.serverPackage.split("/"), "bin", binaryName);
+  if (!fs4.existsSync(staged)) {
+    fs4.rmSync(o.stagingDir, { recursive: true, force: true });
+    throw new Error(`The staged package does not contain a server binary (${staged}).`);
+  }
+  if (o.sha256) {
+    o.log?.("Verifying checksum\u2026");
+    const actual = sha256File(staged);
+    if (actual.toLowerCase() !== o.sha256.toLowerCase()) {
+      fs4.rmSync(o.stagingDir, { recursive: true, force: true });
+      throw new Error(`Checksum mismatch for the staged server binary (expected ${o.sha256}, got ${actual}).`);
+    }
+  }
+  return { path: staged, version: o.version };
+}
+
+// ../packages/update-core/src/swap.ts
+import fs5 from "fs";
+import path6 from "path";
+var MAX_BACKUPS = 3;
+function backupCurrentBinary(o) {
+  if (!o.currentPath || !fs5.existsSync(o.currentPath)) return null;
+  const kind = o.kind ?? "server";
+  const dir = path6.join(o.backupsDir, kind);
+  fs5.mkdirSync(dir, { recursive: true });
+  const ext = o.platform === "win32" ? ".exe" : "";
+  const stamp = o.currentVersion ? `-${o.currentVersion}` : `-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+  const backupPath = path6.join(dir, `astra-server${stamp}${ext}`);
+  fs5.copyFileSync(o.currentPath, backupPath);
+  pruneBackups(dir, o.maxBackups ?? MAX_BACKUPS);
+  return backupPath;
+}
+function pruneBackups(dir, keep = MAX_BACKUPS) {
+  let entries = [];
+  try {
+    entries = fs5.readdirSync(dir).sort();
+  } catch {
+    return;
+  }
+  const excess = entries.length - keep;
+  for (let i = 0; i < excess; i++) {
+    try {
+      fs5.rmSync(path6.join(dir, entries[i]), { force: true });
+    } catch {
+    }
+  }
+}
+function installManagedBinary(o) {
+  const target = managedServerBinaryPath(o.serverDir, o.version, o.platform);
+  fs5.mkdirSync(o.serverDir, { recursive: true });
+  const tmp = `${target}.tmp`;
+  fs5.copyFileSync(o.stagedPath, tmp);
+  fs5.renameSync(tmp, target);
+  if (o.platform !== "win32") fs5.chmodSync(target, 493);
+  return target;
+}
+function pruneManagedBinaries(serverDir, currentTarget, keep = 2) {
+  let entries = [];
+  try {
+    entries = fs5.readdirSync(serverDir).filter((f) => /^astra-server-\d/.test(f));
+  } catch {
+    return;
+  }
+  const excess = entries.filter((f) => path6.join(serverDir, f) !== currentTarget).length - keep;
+  for (let i = 0; i < Math.max(0, excess); i++) {
+    try {
+      fs5.rmSync(path6.join(serverDir, entries[i]), { force: true });
+    } catch {
+    }
+  }
+}
+function installManagedWebRoot(binaryPath, serverDir) {
+  const src = path6.join(path6.dirname(binaryPath), "wwwroot");
+  if (!fs5.existsSync(src)) return false;
+  const dest = path6.join(serverDir, "wwwroot");
+  const tmp = `${dest}.tmp`;
+  const prev = `${dest}.prev`;
+  fs5.mkdirSync(serverDir, { recursive: true });
+  fs5.rmSync(tmp, { recursive: true, force: true });
+  fs5.cpSync(src, tmp, { recursive: true });
+  fs5.rmSync(prev, { recursive: true, force: true });
+  if (fs5.existsSync(dest)) fs5.renameSync(dest, prev);
+  fs5.renameSync(tmp, dest);
+  return true;
+}
+function commitManagedWebRoot(serverDir) {
+  fs5.rmSync(path6.join(serverDir, "wwwroot.prev"), { recursive: true, force: true });
+}
+function restoreManagedWebRoot(serverDir) {
+  const dest = path6.join(serverDir, "wwwroot");
+  const prev = `${dest}.prev`;
+  if (!fs5.existsSync(prev)) return;
+  fs5.rmSync(dest, { recursive: true, force: true });
+  fs5.renameSync(prev, dest);
+}
+
+// ../packages/update-core/src/apply.ts
+import fs6 from "fs";
+var UpdateError = class extends Error {
+  constructor(message, hint) {
+    super(message);
+    this.hint = hint;
+    this.name = "UpdateError";
+  }
+  hint;
+};
+async function applyServerUpdate(o) {
+  const paths = updatePaths(o.home);
+  const log = o.log ?? (() => {
+  });
+  const now = o.now ?? (() => /* @__PURE__ */ new Date());
+  const state = readUpdateState(paths.stateFile) ?? initialState(now);
+  if (!o.force && state.failedCount >= MAX_CONSECUTIVE_FAILURES) {
+    throw new UpdateError(
+      `The last ${state.failedCount} update attempts failed. Fix the problem and run the update with --retry.`,
+      state.error ?? void 0
+    );
+  }
+  if (!isNewerVersion(o.manifest.version, o.currentVersion)) {
+    throw new UpdateError(`Already on version ${o.currentVersion} (${o.manifest.version} is not newer).`);
+  }
+  if (o.manifest.apiVersion && !isApiVersionCompatible(o.manifest.apiVersion, o.expectedApiMajor)) {
+    throw new UpdateError(
+      `The update targets API major ${o.manifest.apiVersion} but this client expects ${o.expectedApiMajor}. Update the whole Astra install manually (npm install -g astragate).`
+    );
+  }
+  const setState = (phase, step, error) => {
+    writeUpdateState(
+      paths.stateFile,
+      {
+        ...state,
+        phase,
+        targetVersion: o.manifest.version,
+        previousVersion: o.currentVersion,
+        ...step !== void 0 ? { step } : {},
+        ...error !== void 0 ? { error } : { error: null },
+        failedCount: state.failedCount
+      },
+      now
+    );
+  };
+  const previousInstall = readInstallInfo(o.home);
+  let swapped = false;
+  let webRootSwapped = false;
+  let backupPath = null;
+  try {
+    setState("downloading", "downloading");
+    const platformInfo2 = o.manifest.platforms?.[o.platformKey];
+    const staged = await stageServerBinary({
+      home: o.home,
+      stagingDir: paths.stagingDir,
+      serverPackage: platformInfo2?.server ?? o.serverPackage,
+      version: o.manifest.version,
+      sha256: platformInfo2?.serverSha256 ?? null,
+      platform: o.platform,
+      npm: o.npm,
+      installIntoPrefix: o.installIntoPrefix,
+      log
+    });
+    setState("swapping", "swapping");
+    const wasRunning = await o.control.isRunning();
+    backupPath = backupCurrentBinary({
+      currentPath: o.currentServerPath,
+      backupsDir: paths.backupsDir,
+      currentVersion: o.currentVersion,
+      platform: o.platform
+    });
+    if (backupPath) log(`Backed up the current binary to ${backupPath}`);
+    const serverPath = installManagedBinary({
+      stagedPath: staged.path,
+      serverDir: paths.serverDir,
+      version: o.manifest.version,
+      platform: o.platform
+    });
+    writeInstallInfo(o.home, applyServerInfo(previousInstall, { serverPath, serverVersion: o.manifest.version }));
+    pruneManagedBinaries(paths.serverDir, serverPath);
+    swapped = true;
+    setState("restarting", "restarting");
+    if (wasRunning) {
+      log("Restarting the Astra server\u2026");
+      await o.control.stop();
+    }
+    try {
+      webRootSwapped = installManagedWebRoot(staged.path, paths.serverDir);
+    } catch (err) {
+      log(`Could not update the web UI files: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    await o.control.start();
+    const reported = await o.control.probeVersion();
+    if (reported !== o.manifest.version) {
+      throw new UpdateError(
+        `The server reports ${reported ?? "no version"} after the restart; expected ${o.manifest.version}.`
+      );
+    }
+    fs6.rmSync(paths.stagingDir, { recursive: true, force: true });
+    if (webRootSwapped) commitManagedWebRoot(paths.serverDir);
+    writeUpdateState(paths.stateFile, { ...initialState(now), phase: "idle" }, now);
+    log(`Astra updated to ${o.manifest.version}.`);
+    return { from: o.currentVersion, to: o.manifest.version, serverPath };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    setState("rolling-back", "rolling-back", message);
+    if (swapped) await rollback(o, previousInstall, backupPath, webRootSwapped, setState, log);
+    const failed = {
+      phase: "failed",
+      targetVersion: o.manifest.version,
+      previousVersion: o.currentVersion,
+      error: message,
+      failedCount: state.failedCount + 1,
+      updatedAt: now().toISOString()
+    };
+    writeUpdateState(paths.stateFile, failed, now);
+    throw err instanceof UpdateError ? err : new UpdateError(message);
+  }
+}
+async function rollback(o, previousInstall, backupPath, webRootSwapped, setState, log) {
+  const restorePath = previousInstall?.serverPath ?? backupPath;
+  try {
+    if (restorePath) {
+      log(`Rolling back to ${restorePath}`);
+      writeInstallInfo(o.home, applyServerInfo(previousInstall, { serverPath: restorePath }));
+    }
+    if (await o.control.isRunning()) await o.control.stop();
+    if (webRootSwapped) restoreManagedWebRoot(updatePaths(o.home).serverDir);
+    await o.control.start();
+  } catch (rollbackErr) {
+    setState("failed", void 0, `Rollback failed: ${rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr)}`);
+    log("Rollback failed \u2014 see the server log. `astra restore-all` still works offline.");
+  }
+}
+
+// ../packages/update-core/src/check.ts
+async function checkForServerUpdate(o) {
+  const doFetch = o.fetchImpl ?? globalThis.fetch;
+  if (o.baseUrl && doFetch) {
+    try {
+      const res = await doFetch(`${o.baseUrl.replace(/\/+$/, "")}/api/update/status`, {
+        signal: AbortSignal.timeout(o.timeoutMs ?? 3e3)
+      });
+      if (res.ok) {
+        const status = await res.json();
+        return {
+          availableVersion: status.available ?? null,
+          notes: status.notes ?? null,
+          source: "server"
+        };
+      }
+    } catch {
+    }
+  }
+  const manifest = await fetchManifest({
+    feedUrl: o.feedUrl ?? DEFAULT_FEED_URL,
+    channel: o.channel ?? DEFAULT_CHANNEL,
+    timeoutMs: o.timeoutMs,
+    fetchImpl: o.fetchImpl,
+    userAgent: o.userAgent
+  });
+  return {
+    availableVersion: isNewerVersion(manifest.version, o.currentVersion) ? manifest.version : null,
+    notes: manifest.notes ?? null,
+    source: "feed",
+    manifest
+  };
+}
+
+// ../packages/update-core/src/desktop-install.ts
+import fs7 from "fs";
+import path7 from "path";
+import { spawn as spawn2 } from "child_process";
+function walkFiles(dir, depth) {
+  if (depth < 0) return [];
+  let entries;
+  try {
+    entries = fs7.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const e of entries) {
+    const full = path7.join(dir, e.name);
+    if (e.isDirectory()) out.push(...walkFiles(full, depth - 1));
+    else if (e.isFile()) out.push(full);
+  }
+  return out;
+}
+function walkDirs(dir, depth) {
+  if (depth < 0) return [];
+  let entries;
+  try {
+    entries = fs7.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const e of entries) {
+    if (e.isDirectory()) {
+      const full = path7.join(dir, e.name);
+      out.push(full, ...walkDirs(full, depth - 1));
+    }
+  }
+  return out;
+}
+function findDesktopEntry(appDir, platform) {
+  if (!fs7.existsSync(appDir)) {
+    throw new Error(`The desktop package does not contain an app directory (${appDir}).`);
+  }
+  if (platform === "darwin") {
+    const bundles = walkDirs(appDir, 4).filter((d) => d.endsWith(".app")).sort((a, b) => a.length - b.length);
+    const first2 = bundles[0];
+    if (first2) return { path: first2, isBundle: true };
+    throw new Error("Could not find the .app bundle inside the desktop package.");
+  }
+  const exes = walkFiles(appDir, 3).filter((f) => platform === "win32" ? /\.exe$/i.test(f) : !/\.(so|png|json|sh|txt|desktop)$/i.test(f)).filter((f) => {
+    if (platform === "win32") return !/(crashpad|installer|unins|squirrel)/i.test(f);
+    try {
+      fs7.accessSync(f, fs7.constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }).sort((a, b) => a.split(path7.sep).length - b.split(path7.sep).length || a.length - b.length);
+  const first = exes[0];
+  if (first) return { path: first, isBundle: false };
+  throw new Error("Could not find the desktop executable inside the desktop package.");
+}
+function macLauncherTarget(home = "") {
+  return path7.join(home, "Applications", "Astra.app");
+}
+function winLauncherTarget(home, env = process.env) {
+  const base = env.APPDATA || path7.join(home, "AppData", "Roaming");
+  return path7.join(base, "Microsoft", "Windows", "Start Menu", "Programs", "Astra.lnk");
+}
+function linuxLauncherTarget(home) {
+  return path7.join(home, ".local", "share", "applications", "astra.desktop");
+}
+function renderLinuxDesktopFile(exePath) {
+  return `[Desktop Entry]
+Type=Application
+Name=Astra
+Comment=Local AI gateway
+Exec=${exePath}
+Terminal=false
+Categories=Development;Network;
+`;
+}
+function runCapture2(command, args, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const child = spawn2(command, [...args], { stdio: "ignore", windowsHide: true, shell: command.endsWith(".cmd") });
+    let settled = false;
+    const timer = setTimeout(() => {
+      settled = true;
+      reject(new Error(`${command} timed out`));
+    }, timeoutMs);
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      if (!settled) reject(err);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (!settled) resolve({ code, stderr: "" });
+    });
+  });
+}
+async function createLauncher(entry, platform, home, env = process.env) {
+  if (platform === "darwin") {
+    const target2 = macLauncherTarget(home);
+    fs7.mkdirSync(path7.dirname(target2), { recursive: true });
+    fs7.rmSync(target2, { force: true, recursive: true });
+    fs7.symlinkSync(entry.path, target2, "dir");
+    return target2;
+  }
+  if (platform === "win32") {
+    const target2 = winLauncherTarget(home, env);
+    fs7.mkdirSync(path7.dirname(target2), { recursive: true });
+    const esc = (s) => s.replace(/'/g, "''");
+    const ps = `$s=(New-Object -ComObject WScript.Shell).CreateShortcut('${esc(target2)}');$s.TargetPath='${esc(entry.path)}';$s.Save()`;
+    const r = await runCapture2("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", ps], 6e4);
+    if (r.code !== 0) throw new Error("Failed to create the Start Menu shortcut.");
+    return target2;
+  }
+  const target = linuxLauncherTarget(home);
+  fs7.mkdirSync(path7.dirname(target), { recursive: true });
+  fs7.writeFileSync(target, renderLinuxDesktopFile(entry.path));
+  return target;
+}
+function removeLauncher(platform, home, env = process.env) {
+  if (platform === "darwin") {
+    const target2 = macLauncherTarget(home);
+    try {
+      const st = fs7.lstatSync(target2);
+      if (st.isSymbolicLink()) fs7.rmSync(target2);
+    } catch {
+    }
+    return;
+  }
+  const target = platform === "win32" ? winLauncherTarget(home, env) : linuxLauncherTarget(home);
+  fs7.rmSync(target, { force: true });
+}
+async function installDesktopClient(o) {
+  const prefix = path7.join(o.home, "desktop");
+  const spec = `${o.desktopPackage}@${o.version}`;
+  o.log?.(`Installing ${spec} (this may take a minute)\u2026`);
+  await npmInstallIntoPrefix(prefix, spec, o.npm);
+  const pkgDir = path7.join(prefix, "node_modules", ...o.desktopPackage.split("/"));
+  const entry = findDesktopEntry(path7.join(pkgDir, "app"), o.platform);
+  const launcher = await createLauncher(entry, o.platform, o.home, o.npm?.env);
+  let version = o.version;
+  try {
+    const pkg = JSON.parse(fs7.readFileSync(path7.join(pkgDir, "package.json"), "utf8"));
+    version = pkg.version ?? version;
+  } catch {
+  }
+  return { path: entry.path, version, launcher };
+}
+
+// src/lib/paths.ts
+import os from "os";
+import path8 from "path";
+function astraHome(env = process.env) {
+  const override = env.ASTRA_HOME?.trim();
+  return override ? override : path8.join(os.homedir(), ".astra");
+}
+function homePaths(home) {
+  return {
+    home,
+    configFile: path8.join(home, "config.json"),
+    runtimeFile: path8.join(home, "runtime.json"),
+    installFile: path8.join(home, "install.json"),
+    logsDir: path8.join(home, "logs"),
+    serverStdoutLog: path8.join(home, "logs", "server-stdout.log"),
+    dbFile: path8.join(home, "astra.db"),
+    keysDir: path8.join(home, "keys"),
+    desktopPrefix: path8.join(home, "desktop")
+  };
+}
+
+// src/lib/browser.ts
+import { spawn as spawn3 } from "child_process";
+function openInBrowser(url, platform = process.platform) {
+  try {
+    if (platform === "darwin") {
+      spawn3("open", [url], { detached: true, stdio: "ignore" }).unref();
+      return;
+    }
+    if (platform === "win32") {
+      spawn3("rundll32", ["url.dll,FileProtocolHandler", url], {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true
+      }).unref();
+      return;
+    }
+    spawn3("xdg-open", [url], { detached: true, stdio: "ignore" }).unref();
+  } catch {
+  }
+}
+
+// src/lib/logs.ts
+import fs8 from "fs";
+import path9 from "path";
+function findNewestLog(home) {
+  const { logsDir, serverStdoutLog } = homePaths(home);
+  let candidates = [];
+  try {
+    candidates = fs8.readdirSync(logsDir).filter((f) => /^astra-\d{8}\.log$/.test(f)).map((f) => path9.join(logsDir, f));
+  } catch {
+  }
+  candidates.sort((a, b) => mtimeOf(b) - mtimeOf(a));
+  const newest = candidates[0];
+  if (newest) return newest;
+  if (fs8.existsSync(serverStdoutLog)) return serverStdoutLog;
+  throw new AstraError("No log files found.", "Start the server first: `astra start`.");
+}
+function mtimeOf(p) {
+  try {
+    return fs8.statSync(p).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+function tailLines(filePath, lineCount) {
+  const text = fs8.readFileSync(filePath, "utf8");
+  const lines = text.split(/\r?\n/);
+  while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  return lines.slice(-lineCount).join("\n");
+}
+function followFile(filePath, write) {
+  let pos = fs8.existsSync(filePath) ? fs8.statSync(filePath).size : 0;
+  let stopped = false;
+  let timer;
+  const tick = () => {
+    if (stopped) return;
+    try {
+      const st = fs8.existsSync(filePath) ? fs8.statSync(filePath) : null;
+      if (!st) {
+        pos = 0;
+      } else if (st.size < pos) {
+        pos = 0;
+      } else if (st.size > pos) {
+        const fd = fs8.openSync(filePath, "r");
+        try {
+          const buf = Buffer.alloc(st.size - pos);
+          const bytesRead = fs8.readSync(fd, buf, 0, buf.length, pos);
+          pos += bytesRead;
+          write(buf.toString("utf8"));
+        } finally {
+          fs8.closeSync(fd);
+        }
+      }
+    } catch {
+    }
+    timer = setTimeout(tick, 1e3);
+  };
+  tick();
+  return () => {
+    stopped = true;
+    if (timer) clearTimeout(timer);
+  };
+}
+
+// src/lib/server-lifecycle.ts
+import fs11 from "fs";
+import { spawn as spawn5 } from "child_process";
+
+// src/lib/json-file.ts
+import fs9 from "fs";
+import path10 from "path";
+function readTextOrNull(filePath) {
+  try {
+    return fs9.readFileSync(filePath, "utf8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT" || code === "EISDIR") return null;
+    throw err;
+  }
+}
+function readJsonFile(filePath) {
+  const text = readTextOrNull(filePath);
+  if (text === null || text.trim() === "") return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+function writeJsonFile(filePath, data, mode = 420) {
+  fs9.mkdirSync(path10.dirname(filePath), { recursive: true });
+  fs9.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}
+`, { mode });
+}
+
+// src/lib/config-file.ts
+var DEFAULT_PORT = 17321;
+var DEFAULT_HOST = "127.0.0.1";
+function readConfig(home) {
+  return readJsonFile(homePaths(home).configFile) ?? {};
+}
+function writeConfig(home, patch) {
+  const next = { ...readConfig(home), ...patch };
+  writeJsonFile(homePaths(home).configFile, next);
+  return next;
+}
+function normalizePort(value, fallback = DEFAULT_PORT) {
+  if (value === void 0 || value === null || value === "") return fallback;
+  const n = typeof value === "number" ? value : Number(value);
+  if (!Number.isInteger(n) || n < 1 || n > 65535) {
+    throw new AstraError(`Invalid port: ${String(value)}. Use a number between 1 and 65535.`);
+  }
+  return n;
+}
+function normalizeHost(value, fallback = DEFAULT_HOST) {
+  if (value === void 0 || value === null || value === "") return fallback;
+  if (typeof value !== "string") throw new AstraError(`Invalid host: ${String(value)}`);
+  return value;
+}
+
+// src/lib/runtime.ts
+var STARTED_BY_VALUES = ["cli", "desktop", "autostart"];
+function parseRuntimeJson(text) {
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const obj = raw;
+  const { pid, port, host } = obj;
+  if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) return null;
+  if (typeof port !== "number" || !Number.isInteger(port) || port <= 0 || port > 65535) return null;
+  if (typeof host !== "string" || host.trim() === "") return null;
+  const info2 = { pid, port, host };
+  if (typeof obj.version === "string") info2.version = obj.version;
+  if (typeof obj.apiVersion === "string") info2.apiVersion = obj.apiVersion;
+  if (typeof obj.startedBy === "string" && STARTED_BY_VALUES.includes(obj.startedBy)) {
+    info2.startedBy = obj.startedBy;
+  }
+  if (typeof obj.startedAt === "string") info2.startedAt = obj.startedAt;
+  if (typeof obj.runtimeToken === "string") info2.runtimeToken = obj.runtimeToken;
+  return info2;
+}
+function readRuntimeInfo(runtimeFile) {
+  const text = readTextOrNull(runtimeFile);
+  return text === null ? null : parseRuntimeJson(text);
+}
+
+// src/lib/binary.ts
+import fs10 from "fs";
+import path11 from "path";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+
+// package.json
+var package_default = {
+  name: "astragate",
+  version: "0.2.0",
+  description: "Astra \u2014 a local AI gateway. Install, start, stop and manage the astra-server from the terminal.",
+  license: "MIT",
+  type: "module",
+  bin: {
+    astra: "dist/index.js"
+  },
+  files: [
+    "dist"
+  ],
+  engines: {
+    node: ">=18"
+  },
+  keywords: [
+    "astra",
+    "ai",
+    "gateway",
+    "llm",
+    "proxy"
+  ],
+  scripts: {
+    build: "tsup",
+    watch: "tsup --watch",
+    test: "vitest run",
+    typecheck: "tsc --noEmit",
+    lint: "eslint ."
+  },
+  dependencies: {
+    commander: "^12.1.0"
+  },
+  optionalDependencies: {
+    "@aidotnet/server-darwin-arm64": "0.2.0",
+    "@aidotnet/server-darwin-x64": "0.2.0",
+    "@aidotnet/server-linux-arm64": "0.2.0",
+    "@aidotnet/server-linux-x64": "0.2.0",
+    "@aidotnet/server-win32-arm64": "0.2.0",
+    "@aidotnet/server-win32-x64": "0.2.0"
+  },
+  devDependencies: {
+    "@aidotnet/update-core": "workspace:*",
+    "@types/node": "^24.0.0",
+    eslint: "^9.17.0",
+    prettier: "^3.4.2",
+    tsup: "^8.3.5",
+    typescript: "^5.7.2",
+    "typescript-eslint": "^8.18.1",
+    vitest: "^3.0.0"
+  },
+  packageManager: "pnpm@9.15.0"
+};
+
+// src/version.ts
+var VERSION = package_default.version;
+var PACKAGE_NAME = package_default.name;
+
+// src/lib/binary.ts
+function findRepoRoot(startDir, exists) {
+  let dir = path11.resolve(startDir);
+  for (; ; ) {
+    if (exists(path11.join(dir, "src", "Astra.Server"))) return dir;
+    const parent = path11.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function defaultResolveFrom(baseDir, request) {
+  const require2 = createRequire(path11.join(baseDir, "index.js"));
+  return require2.resolve(request);
+}
+function resolveServerBinary(options = {}) {
+  const env = options.env ?? process.env;
+  const exists = options.existsSync ?? ((p) => fs10.existsSync(p));
+  const cwd = options.cwd ?? process.cwd();
+  const plat = platformInfo(options.platform ?? process.platform, options.arch ?? process.arch);
+  const envBin = env.ASTRA_SERVER_BIN?.trim();
+  if (envBin) {
+    if (!exists(envBin)) {
+      throw new AstraError(`ASTRA_SERVER_BIN points to a missing file: ${envBin}`);
+    }
+    return { command: envBin, args: [], serverPath: envBin, source: "env" };
+  }
+  const installPath = options.installServerPath?.trim();
+  if (installPath && exists(installPath)) {
+    return { command: installPath, args: [], serverPath: installPath, source: "install" };
+  }
+  const repoRoot = findRepoRoot(cwd, exists);
+  if (repoRoot) {
+    const binDir = path11.join(repoRoot, "src", "Astra.Server", "bin", "Debug", "net10.0");
+    const native = path11.join(binDir, plat.binaryName);
+    if (exists(native)) return { command: native, args: [], serverPath: native, source: "repo" };
+    const dll = path11.join(binDir, "astra-server.dll");
+    if (exists(dll)) return { command: "dotnet", args: [dll], serverPath: dll, source: "repo" };
+  }
+  const packaged = findPackagedServerBinary(options);
+  if ("path" in packaged) {
+    return { command: packaged.path, args: [], serverPath: packaged.path, source: "package" };
+  }
+  throw new AstraError(
+    `Could not find the Astra server binary. ${packaged.error}`,
+    `Reinstall the CLI (\`npm install -g ${PACKAGE_NAME}\`), or point ASTRA_SERVER_BIN at the server binary.`
+  );
+}
+function findPackagedServerBinary(options = {}) {
+  const exists = options.existsSync ?? ((p) => fs10.existsSync(p));
+  const readText = options.readFileSync ?? ((p, _enc) => fs10.readFileSync(p, "utf8"));
+  const baseDir = options.baseDir ?? path11.dirname(fileURLToPath(import.meta.url));
+  const plat = platformInfo(options.platform ?? process.platform, options.arch ?? process.arch);
+  const resolveFrom = options.resolveFrom ?? defaultResolveFrom;
+  try {
+    const pkgJsonPath = resolveFrom(baseDir, `${plat.serverPackage}/package.json`);
+    const pkg = JSON.parse(readText(pkgJsonPath, "utf8"));
+    const binRel = pkg.bin?.["astra-server"];
+    if (!binRel) return { error: `${plat.serverPackage} has no 'astra-server' bin entry.` };
+    const binPath = path11.resolve(path11.dirname(pkgJsonPath), binRel);
+    if (exists(binPath)) return { path: binPath };
+    return { error: `${plat.serverPackage} is installed but its binary is missing (${binPath}).` };
+  } catch {
+    return { error: `${plat.serverPackage} is not installed.` };
+  }
+}
+
+// src/lib/process-utils.ts
+import { spawn as spawn4 } from "child_process";
+function runCapture3(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn4(command, [...args], {
+      cwd: options.cwd,
+      env: options.env,
+      windowsHide: true,
+      shell: options.shell ?? false
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const timer = options.timeoutMs ? setTimeout(() => {
+      settled = true;
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      reject(new Error(`Command timed out after ${options.timeoutMs}ms: ${command} ${args.join(" ")}`));
+    }, options.timeoutMs) : null;
+    child.stdout?.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    if (options.input !== void 0) {
+      child.stdin?.write(options.input);
+    }
+    child.stdin?.end();
+    child.on("error", (err) => {
+      if (timer) clearTimeout(timer);
+      if (!settled) reject(err);
+    });
+    child.on("close", (code) => {
+      if (timer) clearTimeout(timer);
+      if (!settled) resolve({ code, stdout, stderr });
+    });
+  });
+}
+function spawnDetached(command, args, stdio) {
+  const child = spawn4(command, [...args], { detached: true, stdio, windowsHide: true });
+  child.unref();
+  return child;
+}
+function exitCodeOf(child) {
+  return new Promise((resolve, reject) => {
+    child.on("error", reject);
+    child.on("close", (code) => resolve(code));
+  });
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+async function terminatePid(pid, platform = process.platform) {
+  if (platform === "win32") {
+    try {
+      await runCapture3("taskkill", ["/PID", String(pid), "/T", "/F"], { timeoutMs: 1e4 });
+    } catch {
+    }
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+  }
+}
+async function killPid(pid, platform = process.platform) {
+  if (platform === "win32") {
+    await terminatePid(pid, platform);
+    return;
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+  }
+}
+async function waitForPidExit(pid, timeoutMs, isAlive = isPidAlive) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isAlive(pid)) return true;
+    await delay(300);
+  }
+  return !isAlive(pid);
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/lib/install-json.ts
+function readInstallJson(home) {
+  return readJsonFile(homePaths(home).installFile);
+}
+function writeInstallJson(home, data) {
+  writeJsonFile(homePaths(home).installFile, data);
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function applyServerInfo2(existing, server) {
+  return {
+    ...existing ?? {},
+    serverPath: server.serverPath,
+    ...server.serverVersion ? { serverVersion: server.serverVersion } : {},
+    updatedAt: nowIso()
+  };
+}
+function applyDesktopInfo(existing, desktop) {
+  return {
+    ...existing ?? {},
+    desktopPath: desktop.desktopPath,
+    ...desktop.desktopVersion ? { desktopVersion: desktop.desktopVersion } : {},
+    updatedAt: nowIso()
+  };
+}
+function clearDesktopInfo(existing) {
+  const { desktopPath: _dp, desktopVersion: _dv, ...rest } = existing ?? {};
+  return { ...rest, updatedAt: nowIso() };
+}
+
+// src/lib/server-lifecycle.ts
+function currentRuntime(home) {
+  return readRuntimeInfo(homePaths(home).runtimeFile);
+}
+function clearRuntimeFile(home) {
+  try {
+    fs11.rmSync(homePaths(home).runtimeFile, { force: true });
+  } catch {
+  }
+}
+async function probeRunning(home, fetchImpl) {
+  const rt = currentRuntime(home);
+  if (!rt) return null;
+  if (!isPidAlive(rt.pid)) return null;
+  const base = baseUrlFor(rt.host, rt.port);
+  if (await checkHealth(base, fetchImpl)) return { runtime: rt, base };
+  return null;
+}
+async function getServerVersion(command) {
+  try {
+    const r = await runCapture3(command.command, [...command.args, "version"], { timeoutMs: 15e3 });
+    if (r.code !== 0) return void 0;
+    const parsed = JSON.parse(r.stdout.trim());
+    return typeof parsed.version === "string" ? parsed.version : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function waitForHealthy(base, timeoutMs, aborted, fetchImpl) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (aborted?.()) return false;
+    if (await checkHealth(base, fetchImpl)) return true;
+    await delay(400);
+  }
+  return false;
+}
+async function waitForStartedServer(o) {
+  const isAlive = o.isAlive ?? isPidAlive;
+  const deadline = Date.now() + o.timeoutMs;
+  while (Date.now() < deadline) {
+    if (o.aborted?.()) return null;
+    const rt = o.readRuntime();
+    if (rt && isAlive(rt.pid)) {
+      const base = baseUrlFor(rt.host, rt.port);
+      if (await checkHealth(base, o.fetchImpl)) return { base, runtime: rt };
+    } else if (!rt && await checkHealth(o.fallbackBase, o.fetchImpl)) {
+      return { base: o.fallbackBase, runtime: null };
+    }
+    await delay(o.pollMs ?? 400);
+  }
+  return null;
+}
+function openLogFds(home) {
+  const p = homePaths(home);
+  fs11.mkdirSync(p.logsDir, { recursive: true });
+  const fd = fs11.openSync(p.serverStdoutLog, "a");
+  return { out: fd, err: fd, logFile: p.serverStdoutLog };
+}
+async function startServer(options = {}) {
+  const home = astraHome();
+  const p = homePaths(home);
+  const cfg = readConfig(home);
+  const port = normalizePort(options.port ?? cfg.port);
+  const host = normalizeHost(options.host ?? cfg.host);
+  if (options.port !== void 0 || options.host !== void 0 || cfg.port === void 0 || cfg.host === void 0) {
+    writeConfig(home, { port, host });
+  }
+  const existing = await probeRunning(home);
+  if (existing) {
+    return {
+      base: existing.base,
+      host: existing.runtime.host,
+      port: existing.runtime.port,
+      alreadyRunning: true,
+      pid: existing.runtime.pid,
+      command: resolveServerBinary({ installServerPath: readInstallJson(home)?.serverPath ?? null }),
+      logFile: p.serverStdoutLog
+    };
+  }
+  if (currentRuntime(home)) clearRuntimeFile(home);
+  const command = resolveServerBinary({ installServerPath: readInstallJson(home)?.serverPath ?? null });
+  const version = await getServerVersion(command);
+  writeInstallJson(
+    home,
+    applyServerInfo2(readInstallJson(home), {
+      serverPath: command.serverPath,
+      serverVersion: version
+    })
+  );
+  const args = [...command.args, "serve", "--port", String(port), "--host", host, "--started-by", "cli"];
+  const base = baseUrlFor(host, port);
+  if (options.foreground) {
+    const child2 = spawn5(command.command, args, { stdio: "inherit", windowsHide: true });
+    void (async () => {
+      if (await waitForHealthy(base, 2e4, () => child2.exitCode !== null)) {
+      }
+    })();
+    const code = await exitCodeOf(child2);
+    if (code !== 0) {
+      throw new AstraError(
+        `The server exited with code ${code}.`,
+        `Check the logs in ${p.logsDir}`
+      );
+    }
+    return { base, host, port, alreadyRunning: false, command, logFile: p.serverStdoutLog };
+  }
+  const fds = openLogFds(home);
+  let child;
+  try {
+    child = spawnDetached(command.command, args, ["ignore", fds.out, fds.err]);
+  } catch (err) {
+    throw new AstraError(
+      `Failed to start the server binary: ${err.message}`,
+      `Binary: ${command.command}`
+    );
+  } finally {
+    try {
+      fs11.closeSync(fds.out);
+    } catch {
+    }
+  }
+  const started = await waitForStartedServer({
+    fallbackBase: base,
+    timeoutMs: 2e4,
+    aborted: () => child.exitCode !== null,
+    readRuntime: () => currentRuntime(home)
+  });
+  if (!started) {
+    if (child.exitCode !== null && child.exitCode !== 0) {
+      throw new AstraError(
+        `The server exited with code ${child.exitCode} before becoming healthy.`,
+        `Check the log: ${p.serverStdoutLog}`
+      );
+    }
+    throw new AstraError(
+      `The server did not become healthy at ${base} within 20 seconds.`,
+      `Check the log: ${p.serverStdoutLog}`
+    );
+  }
+  const rt = started.runtime;
+  return {
+    base: started.base,
+    host: rt?.host ?? host,
+    port: rt?.port ?? port,
+    alreadyRunning: false,
+    pid: rt?.pid ?? child.pid,
+    command,
+    logFile: p.serverStdoutLog
+  };
+}
+async function stopServer() {
+  const home = astraHome();
+  const rt = currentRuntime(home);
+  if (!rt) return { stopped: false };
+  if (!isPidAlive(rt.pid)) {
+    clearRuntimeFile(home);
+    return { stopped: false };
+  }
+  const base = baseUrlFor(rt.host, rt.port);
+  if (rt.runtimeToken) {
+    try {
+      await shutdownRequest(base, rt.runtimeToken);
+    } catch {
+    }
+  }
+  if (!await waitForPidExit(rt.pid, 8e3)) {
+    await terminatePid(rt.pid);
+    if (!await waitForPidExit(rt.pid, 3e3)) {
+      await killPid(rt.pid);
+      await waitForPidExit(rt.pid, 2e3);
+    }
+  }
+  clearRuntimeFile(home);
+  return { stopped: true, pid: rt.pid };
+}
+async function serverStatus(fetchImpl) {
+  const home = astraHome();
+  const cfg = readConfig(home);
+  const configPort = normalizePort(cfg.port);
+  const configHost = normalizeHost(cfg.host);
+  const rt = currentRuntime(home);
+  if (!rt) return { running: false, staleRuntime: false, configPort, configHost };
+  if (!isPidAlive(rt.pid)) {
+    clearRuntimeFile(home);
+    return { running: false, staleRuntime: true, configPort, configHost };
+  }
+  const base = baseUrlFor(rt.host, rt.port);
+  const healthy = await checkHealth(base, fetchImpl);
+  return { running: healthy, base, runtime: rt, staleRuntime: false, configPort, configHost };
+}
+async function ensureServerRunning() {
+  const home = astraHome();
+  const existing = await probeRunning(home);
+  if (existing) return { base: existing.base, runtime: existing.runtime, started: false };
+  const result = await startServer({});
+  return { base: result.base, runtime: currentRuntime(home) ?? void 0, started: true };
+}
+
+// src/commands/manage.ts
+async function runStart(opts) {
+  console.log("Starting Astra\u2026");
+  const result = await startServer(opts);
+  if (result.alreadyRunning) {
+    success(`Astra is already running at ${style.cyan(result.base)} (pid ${result.pid ?? "?"}).`);
+    info(style.dim("Use `astra restart` to reload it."));
+    if (opts.open) openInBrowser(result.base);
+    return;
+  }
+  console.log(`  Binary   ${result.command.serverPath} ${style.dim(`(${result.command.source})`)}`);
+  console.log(`  Address  ${style.cyan(result.base)}`);
+  console.log(`  Log      ${style.dim(result.logFile)}`);
+  if (opts.foreground) return;
+  success(`Astra is running at ${style.cyan(result.base)}`);
+  if (opts.open) openInBrowser(result.base);
+}
+async function runStop() {
+  const result = await stopServer();
+  if (!result.stopped) {
+    console.log("Astra is not running.");
+    return;
+  }
+  success(`Astra stopped (pid ${result.pid ?? "?"}).`);
+}
+async function runRestart(opts) {
+  const status = await serverStatus();
+  if (status.running || status.runtime) {
+    console.log("Stopping Astra\u2026");
+    await stopServer();
+  }
+  await runStart(opts);
+}
+async function runStatus() {
+  const status = await serverStatus();
+  if (!status.running) {
+    if (status.staleRuntime) {
+      console.log(style.dim("Removed a stale runtime.json (its process is gone)."));
+    }
+    console.log(`Astra is not running. Start it with ${style.cyan("astra start")}.`);
+    process3.exitCode = 1;
+    return;
+  }
+  const rt = status.runtime;
+  if (!rt) return;
+  console.log("Astra is running");
+  console.log(`  URL      ${style.cyan(status.base ?? "")}`);
+  console.log(`  PID      ${rt.pid}`);
+  const versionLine = [rt.version, rt.apiVersion ? `API ${rt.apiVersion}` : void 0].filter(Boolean).join(" \xB7 ");
+  if (versionLine) console.log(`  Version  ${versionLine}`);
+  if (rt.startedBy) {
+    console.log(`  Started  by ${rt.startedBy}${rt.startedAt ? ` at ${rt.startedAt}` : ""}`);
+  }
+  if (status.base) {
+    try {
+      const r = await checkForServerUpdate({ currentVersion: VERSION, baseUrl: status.base, timeoutMs: 2e3 });
+      if (r.availableVersion) {
+        console.log(`  Update   ${style.cyan(r.availableVersion)} available \u2014 run ${style.cyan("astra update")}`);
+      }
+    } catch {
+    }
+  }
+}
+async function runLogs(opts) {
+  const home = astraHome();
+  const logFile = findNewestLog(home);
+  console.error(style.dim(`# ${logFile}`));
+  process3.stdout.write(`${tailLines(logFile, 100)}
+`);
+  if (opts.follow) {
+    console.error(style.dim("--- following (Ctrl+C to stop) ---"));
+    const stop = followFile(logFile, (chunk) => process3.stdout.write(chunk));
+    process3.on("SIGINT", () => {
+      stop();
+      process3.exit(0);
+    });
+    await new Promise(() => {
+    });
+  }
+}
+async function runOpen() {
+  const status = await serverStatus();
+  if (!status.running || !status.base) {
+    fail("Astra is not running.");
+    info(`Start it with ${style.cyan("astra start --open")}.`);
+    process3.exitCode = 1;
+    return;
+  }
+  openInBrowser(status.base);
+  console.log(`Opened ${status.base}`);
+}
+
+// src/commands/autostart.ts
+import os3 from "os";
+import process4 from "process";
+
+// src/lib/autostart.ts
+import fs12 from "fs";
+import os2 from "os";
+import path12 from "path";
+var LAUNCHD_LABEL = "io.astra.server";
+var SYSTEMD_UNIT_NAME = "astra.service";
+var SCHTASKS_TASK_NAME = "Astra Server";
+function xmlEscape(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function launchdPlistPath(home = os2.homedir()) {
+  return path12.join(home, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+}
+function renderLaunchdPlist(argv, logFile) {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${xmlEscape(LAUNCHD_LABEL)}</string>
+  <key>ProgramArguments</key>
+  <array>
+${argv.map((a) => `    <string>${xmlEscape(a)}</string>`).join("\n")}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <false/>
+  <key>ProcessType</key>
+  <string>Background</string>
+  <key>StandardOutPath</key>
+  <string>${xmlEscape(logFile)}</string>
+  <key>StandardErrorPath</key>
+  <string>${xmlEscape(logFile)}</string>
+</dict>
+</plist>
+`;
+}
+function systemdUnitPath(home = os2.homedir()) {
+  return path12.join(home, ".config", "systemd", "user", SYSTEMD_UNIT_NAME);
+}
+function systemdQuote(part) {
+  return /[\s"]/.test(part) ? `"${part.replace(/"/g, '\\"')}"` : part;
+}
+function renderSystemdUnit(argv) {
+  const exec2 = argv.map(systemdQuote).join(" ");
+  return `[Unit]
+Description=Astra local AI gateway server
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${exec2}
+Restart=on-failure
+RestartSec=3
+
+[Install]
+WantedBy=default.target
+`;
+}
+function quoteForTr(argv) {
+  const inner = argv.map((a) => /[\s"]/.test(a) ? `"${a}"` : a).join(" ").replace(/"/g, '\\"');
+  return `"${inner}"`;
+}
+function schtasksCreateArgs(argv) {
+  return ["/Create", "/F", "/SC", "ONLOGON", "/TN", SCHTASKS_TASK_NAME, "/TR", quoteForTr(argv)];
+}
+function schtasksDeleteArgs() {
+  return ["/Delete", "/F", "/TN", SCHTASKS_TASK_NAME];
+}
+function schtasksQueryArgs() {
+  return ["/Query", "/TN", SCHTASKS_TASK_NAME];
+}
+function autostartArgv(command) {
+  return [command.command, ...command.args, "serve", "--started-by", "autostart"];
+}
+async function exec(args) {
+  const [cmd, ...rest] = args;
+  if (!cmd) throw new AstraError("Missing command.");
+  return runCapture3(cmd, rest, { timeoutMs: 3e4 });
+}
+function logFileFor(lgHome) {
+  return path12.join(homePaths(lgHome).logsDir, "server-stdout.log");
+}
+async function enableAutostartMac(argv, home = os2.homedir(), lgHome = homePaths(home).home) {
+  const plist = launchdPlistPath(home);
+  fs12.mkdirSync(path12.dirname(plist), { recursive: true });
+  fs12.writeFileSync(plist, renderLaunchdPlist(argv, logFileFor(lgHome)));
+  await exec(["launchctl", "unload", plist]).catch(() => void 0);
+  const r = await exec(["launchctl", "load", plist]);
+  if (r.code !== 0) {
+    throw new AstraError("launchctl load failed.", r.stderr.trim() || r.stdout.trim() || void 0);
+  }
+}
+async function disableAutostartMac(home = os2.homedir()) {
+  const plist = launchdPlistPath(home);
+  await exec(["launchctl", "unload", plist]).catch(() => void 0);
+  fs12.rmSync(plist, { force: true });
+}
+async function autostartStatusMac(home = os2.homedir()) {
+  return fs12.existsSync(launchdPlistPath(home)) ? "enabled" : "disabled";
+}
+async function enableAutostartLinux(argv, home = os2.homedir()) {
+  const unit = systemdUnitPath(home);
+  fs12.mkdirSync(path12.dirname(unit), { recursive: true });
+  fs12.writeFileSync(unit, renderSystemdUnit(argv));
+  const reload = await exec(["systemctl", "--user", "daemon-reload"]);
+  if (reload.code !== 0) {
+    throw new AstraError(
+      "systemctl --user daemon-reload failed. Is systemd available (a WSL setup without systemd is not supported)?",
+      reload.stderr.trim() || void 0
+    );
+  }
+  const enable = await exec(["systemctl", "--user", "enable", "--now", SYSTEMD_UNIT_NAME]);
+  if (enable.code !== 0) {
+    throw new AstraError(
+      `systemctl --user enable --now ${SYSTEMD_UNIT_NAME} failed.`,
+      enable.stderr.trim() || void 0
+    );
+  }
+}
+async function disableAutostartLinux(home = os2.homedir()) {
+  await exec(["systemctl", "--user", "disable", "--now", SYSTEMD_UNIT_NAME]).catch(() => void 0);
+  fs12.rmSync(systemdUnitPath(home), { force: true });
+  await exec(["systemctl", "--user", "daemon-reload"]).catch(() => void 0);
+}
+async function autostartStatusLinux(home = os2.homedir()) {
+  if (!fs12.existsSync(systemdUnitPath(home))) return "disabled";
+  const r = await exec(["systemctl", "--user", "is-enabled", SYSTEMD_UNIT_NAME]).catch(() => null);
+  return r !== null && r.code === 0 && r.stdout.trim() === "enabled" ? "enabled" : "disabled";
+}
+async function enableAutostartWindows(argv) {
+  const r = await exec(["schtasks", ...schtasksCreateArgs(argv)]);
+  if (r.code !== 0) {
+    throw new AstraError("schtasks /Create failed.", r.stderr.trim() || void 0);
+  }
+}
+async function disableAutostartWindows() {
+  const r = await exec(["schtasks", ...schtasksDeleteArgs()]);
+  if (r.code !== 0 && !/does not exist|no existe/i.test(r.stderr + r.stdout)) {
+    throw new AstraError("schtasks /Delete failed.", r.stderr.trim() || void 0);
+  }
+}
+async function autostartStatusWindows() {
+  const r = await exec(["schtasks", ...schtasksQueryArgs()]);
+  return r.code === 0 ? "enabled" : "disabled";
+}
+
+// src/commands/autostart.ts
+async function dispatch(mac, linux, win) {
+  switch (process4.platform) {
+    case "darwin":
+      return mac();
+    case "win32":
+      return win();
+    case "linux":
+      return linux();
+    default:
+      throw new AstraError(`Autostart is not supported on ${process4.platform}.`);
+  }
+}
+async function runAutostart(action) {
+  const home = astraHome();
+  if (action === "status") {
+    const s = await dispatch(
+      () => autostartStatusMac(os3.homedir()),
+      () => autostartStatusLinux(os3.homedir()),
+      () => autostartStatusWindows()
+    );
+    console.log(`Autostart is ${s === "enabled" ? style.green("enabled") : "disabled"}.`);
+    return;
+  }
+  if (action === "enable") {
+    const command = resolveServerBinary();
+    const argv = autostartArgv(command);
+    await dispatch(
+      () => enableAutostartMac(argv, os3.homedir(), home),
+      () => enableAutostartLinux(argv, os3.homedir()),
+      () => enableAutostartWindows(argv)
+    );
+    success("Astra will start automatically at login.");
+  } else {
+    await dispatch(
+      () => disableAutostartMac(os3.homedir()),
+      () => disableAutostartLinux(os3.homedir()),
+      () => disableAutostartWindows()
+    );
+    success("Autostart disabled.");
+  }
+}
+
+// src/commands/desktop.ts
+import fs14 from "fs";
+
+// src/lib/desktop.ts
+import { spawn as spawn6 } from "child_process";
+function usesShell2(command) {
+  return process.platform === "win32" && command.endsWith(".cmd");
+}
+async function npmInstallGlobal() {
+  const npm = locateNpm();
+  const full = [...npm.args, "install", "-g", `${PACKAGE_NAME}@latest`, "--no-audit", "--no-fund", "--loglevel", "error"];
+  return new Promise((resolve, reject) => {
+    const child = spawn6(npm.command, full, {
+      stdio: "inherit",
+      windowsHide: true,
+      shell: usesShell2(npm.command)
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolve({ code, stderr: "" }));
+  });
+}
+
+// src/lib/desktop-server.ts
+import fs13 from "fs";
+function isEphemeralPackagePath(p) {
+  return /[\\/](_npx|dlx)[\\/]/.test(p);
+}
+function hasUsableServer(install, cliVersion, exists = (p) => fs13.existsSync(p)) {
+  const current = install?.serverPath?.trim();
+  if (!current || !exists(current) || isEphemeralPackagePath(current)) return false;
+  return !(install?.serverVersion && isNewerVersion(cliVersion, install.serverVersion));
+}
+function ensureDesktopServer(o) {
+  const install = readInstallJson(o.home);
+  const current = install?.serverPath;
+  if (current && hasUsableServer(install, o.version)) return { action: "kept", serverPath: current };
+  const packaged = (o.findPackaged ?? (() => findPackagedServerBinary()))();
+  if (!("path" in packaged)) return { action: "missing", reason: packaged.error };
+  let serverPath = packaged.path;
+  let action = "recorded";
+  if (isEphemeralPackagePath(packaged.path)) {
+    const { serverDir } = updatePaths(o.home);
+    serverPath = installManagedBinary({
+      stagedPath: packaged.path,
+      serverDir,
+      version: o.version,
+      platform: o.platform
+    });
+    if (installManagedWebRoot(packaged.path, serverDir)) commitManagedWebRoot(serverDir);
+    pruneManagedBinaries(serverDir, serverPath);
+    action = "copied";
+  }
+  writeInstallJson(
+    o.home,
+    applyServerInfo2(readInstallJson(o.home), { serverPath, serverVersion: o.version })
+  );
+  return { action, serverPath };
+}
+
+// src/lib/prompt.ts
+import readline from "readline";
+import { Writable } from "stream";
+function promptHidden(question) {
+  return new Promise((resolve, reject) => {
+    const stdin = process.stdin;
+    if (!stdin.isTTY) {
+      let data = "";
+      stdin.setEncoding("utf8");
+      stdin.on("data", (chunk) => {
+        data += chunk;
+      });
+      stdin.on("end", () => resolve(data.replace(/\r?\n$/, "")));
+      stdin.on("error", reject);
+      return;
+    }
+    process.stdout.write(question);
+    const muted = new Writable({
+      write(_chunk, _encoding, callback) {
+        callback();
+      }
+    });
+    const rl = readline.createInterface({ input: stdin, output: muted, terminal: true });
+    rl.question("", (answer) => {
+      rl.close();
+      process.stdout.write("\n");
+      resolve(answer);
+    });
+  });
+}
+function confirmPrompt(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(/^\s*(y|yes)/i.test(answer.trim()));
+    });
+  });
+}
+
+// src/commands/desktop.ts
+async function runInstall(opts) {
+  if (!opts.client) {
+    console.log("The Astra server is installed automatically with the npm package.");
+    console.log(`To install the desktop app, run ${style.cyan("astra install --desktop")}.`);
+    return;
+  }
+  const home = astraHome();
+  await installDesktopAt(home, VERSION);
+  const server = ensureDesktopServer({ home, version: VERSION, platform: platformInfo().platform });
+  if (server.action === "missing") {
+    warn(
+      `The desktop app cannot find an Astra server: ${server.reason} Install the CLI (\`npm i -g ${PACKAGE_NAME}\`) and run \`astra start\` once, or set ASTRA_SERVER_BIN.`
+    );
+  } else if (server.action === "copied") {
+    success(`Astra server ${VERSION} installed to ${server.serverPath}.`);
+  }
+  info("Launch it from your applications, or run `astra open` for the web UI.");
+}
+async function runUninstallClient() {
+  const home = astraHome();
+  const install = readInstallJson(home);
+  if (!install?.desktopPath && !fs14.existsSync(homePaths(home).desktopPrefix)) {
+    console.log("The desktop app is not installed.");
+    return;
+  }
+  removeLauncher(platformInfo().platform, home);
+  fs14.rmSync(homePaths(home).desktopPrefix, { recursive: true, force: true });
+  writeInstallJson(home, clearDesktopInfo(readInstallJson(home)));
+  success("Astra desktop app uninstalled.");
+}
+async function runUpdate(opts) {
+  const home = astraHome();
+  if (opts.check) {
+    await reportCheck();
+    return;
+  }
+  let manifest;
+  try {
+    manifest = await fetchManifest({ userAgent: `Astra-CLI/${VERSION}` });
+  } catch (err) {
+    if (!opts.client) throw err;
+    manifest = { version: VERSION };
+  }
+  if (!opts.client) {
+    await updateServer(home, manifest, opts.retry ?? false);
+    if (isNewerVersion(manifest.version, VERSION)) {
+      console.log(`Updating the Astra CLI (npm install -g ${PACKAGE_NAME}@latest)\u2026`);
+      const r = await npmInstallGlobal();
+      if (r.code !== 0) {
+        info(`npm install -g ${PACKAGE_NAME}@latest failed \u2014 the server is updated; run \`npm i -g ${PACKAGE_NAME}\` for the CLI.`);
+      } else {
+        success("The new CLI version is used the next time you run `astra`.");
+      }
+    }
+  }
+  const install = readInstallJson(home);
+  const wantsDesktop = opts.client || !!install?.desktopPath || fs14.existsSync(homePaths(home).desktopPrefix);
+  if (wantsDesktop) {
+    const target = isNewerVersion(manifest.version, VERSION) ? manifest.version : VERSION;
+    await installDesktopAt(home, target);
+  }
+}
+async function reportCheck() {
+  const status = await serverStatus();
+  const r = await checkForServerUpdate({
+    currentVersion: VERSION,
+    baseUrl: status.running ? status.base ?? void 0 : void 0
+  });
+  if (r.availableVersion) {
+    console.log(`Update available: ${style.cyan(r.availableVersion)} (current ${VERSION}).`);
+    if (r.notes) console.log(style.dim(r.notes));
+    console.log(`Run ${style.cyan("astra update")} to install.`);
+    process.exitCode = 1;
+  } else {
+    success(`Astra is up to date (${VERSION}).`);
+  }
+}
+async function installDesktopAt(home, version) {
+  const plat = platformInfo();
+  console.log(`Installing the Astra desktop app ${version} (this may take a minute)\u2026`);
+  const entry = await installDesktopClient({
+    home,
+    version,
+    desktopPackage: plat.desktopPackage,
+    platform: plat.platform
+  });
+  writeInstallJson(
+    home,
+    applyDesktopInfo(readInstallJson(home), {
+      desktopPath: entry.path,
+      desktopVersion: entry.version
+    })
+  );
+  success(`Astra desktop app installed (${entry.version}).`);
+}
+async function updateServer(home, manifest, force) {
+  if (!isNewerVersion(manifest.version, VERSION)) {
+    console.log(`Astra server is up to date (${VERSION}).`);
+    return;
+  }
+  const plat = platformInfo();
+  const status = await serverStatus();
+  const ok = await confirmPrompt(
+    `Update the Astra server ${VERSION} \u2192 ${manifest.version}? The gateway restarts and in-flight requests are interrupted. [y/N] `
+  );
+  if (!ok) {
+    console.log("Update cancelled.");
+    return;
+  }
+  const control = {
+    isRunning: async () => await probeRunning(home) !== null,
+    stop: async () => {
+      await stopServer();
+    },
+    start: async () => {
+      await startServer({});
+    },
+    probeVersion: async () => {
+      const rt = currentRuntime(home);
+      if (!rt) return null;
+      try {
+        const v = await apiRequest({
+          base: baseUrlFor(rt.host, rt.port),
+          path: "/api/version"
+        });
+        return v.version ?? null;
+      } catch {
+        return null;
+      }
+    }
+  };
+  await applyServerUpdate({
+    home,
+    manifest,
+    platformKey: `${plat.platform}-${plat.arch}`,
+    serverPackage: plat.serverPackage,
+    platform: plat.platform,
+    currentServerPath: readInstallJson(home)?.serverPath ?? null,
+    currentVersion: VERSION,
+    // The running server's API major is the compatibility anchor (fallback 1).
+    expectedApiMajor: majorOf(status.runtime?.apiVersion) ?? 1,
+    control,
+    force,
+    log: (line) => console.log(`  ${line}`)
+  });
+  success(`Astra server updated to ${manifest.version}.`);
+}
+
+// src/commands/uninstall.ts
+import fs15 from "fs";
+import { spawn as spawn7 } from "child_process";
+async function restoreAllOffline(purge) {
+  const command = resolveServerBinary();
+  const child = spawn7(
+    command.command,
+    [...command.args, "restore-all", ...purge ? ["--purge"] : []],
+    { stdio: "inherit", windowsHide: true }
+  );
+  const code = await exitCodeOf(child);
+  if (code !== 0) throw new AstraError(`restore-all exited with code ${code}.`);
+}
+async function runUninstall(opts) {
+  const home = astraHome();
+  info("Uninstalling Astra\u2026");
+  info("\u2022 Restoring client configurations\u2026");
+  try {
+    await restoreAllOffline(opts.purge === true);
+  } catch (err) {
+    warn(`restore-all failed: ${err.message}`);
+  }
+  info("\u2022 Disabling autostart\u2026");
+  try {
+    await runAutostart("disable");
+  } catch (err) {
+    warn(`Could not disable autostart: ${err.message}`);
+  }
+  info("\u2022 Removing the desktop app\u2026");
+  try {
+    await runUninstallClient();
+  } catch (err) {
+    warn(`Could not remove the desktop app: ${err.message}`);
+  }
+  info("\u2022 Stopping the server\u2026");
+  try {
+    await stopServer();
+  } catch (err) {
+    warn(`Could not stop the server: ${err.message}`);
+  }
+  if (opts.purge) {
+    if (process.stdin.isTTY) {
+      const ok = await confirmPrompt(`Delete all Astra data in ${home}? [y/N] `);
+      if (!ok) {
+        console.log("Skipped data deletion. Run `astra uninstall --purge` again to delete it.");
+        return;
+      }
+    }
+    fs15.rmSync(home, { recursive: true, force: true });
+    success(`Deleted ${home}.`);
+  }
+  success(`Astra uninstalled. Remove the npm package with \`npm uninstall -g ${PACKAGE_NAME}\`.`);
+}
+
+// src/commands/admin.ts
+async function api(path13, options = {}) {
+  const { base, runtime, started } = await ensureServerRunning();
+  if (started) console.log("Server was not running \u2014 started it in the background.");
+  return apiRequest({
+    base,
+    path: path13,
+    method: options.method ?? "GET",
+    body: options.body,
+    runtimeToken: runtime?.runtimeToken
+  });
+}
+function fmtBool(v) {
+  if (v === void 0) return "";
+  return v ? "yes" : "no";
+}
+function findProvider(providers, idOrName) {
+  const needle = idOrName.toLowerCase();
+  const byId = providers.find((p) => p.id.toLowerCase() === needle);
+  if (byId) return byId;
+  const byName = providers.filter((p) => p.name?.toLowerCase() === needle);
+  if (byName.length === 1) return byName[0];
+  if (byName.length > 1) {
+    throw new AstraError(
+      `Provider name "${idOrName}" is ambiguous.`,
+      `Matching ids: ${byName.map((p) => p.id).join(", ")} \u2014 use an id instead.`
+    );
+  }
+  return void 0;
+}
+async function runClientList() {
+  const rows = await api("/api/clients");
+  printTable(
+    rows.map((r) => [
+      r.kind,
+      r.name ?? "",
+      fmtBool(r.enabled),
+      r.status ?? "",
+      r.providerId ?? "",
+      r.selectedModel ?? "",
+      r.availability ?? ""
+    ]),
+    ["KIND", "NAME", "ENABLED", "STATUS", "PROVIDER", "MODEL", "AVAILABILITY"]
+  );
+}
+async function runClientStatus(kind) {
+  const rows = await api("/api/clients");
+  const row = rows.find((r) => r.kind === kind);
+  if (!row) throw new AstraError(`Unknown client kind: ${kind}.`);
+  console.log(`Client: ${row.name ?? row.kind} (${row.kind})`);
+  console.log(`  Enabled      ${fmtBool(row.enabled)}`);
+  if (row.status) console.log(`  Status       ${row.status}`);
+  if (row.availability) console.log(`  Availability ${row.availability}`);
+  if (row.providerId) console.log(`  Provider     ${row.providerId}`);
+  if (row.selectedModel) console.log(`  Model        ${row.selectedModel}`);
+}
+async function runClientEnable(kind, opts) {
+  const providers = await api("/api/providers");
+  const provider2 = findProvider(providers, opts.provider);
+  if (!provider2) {
+    throw new AstraError(
+      `No provider matches "${opts.provider}".`,
+      "Run `astra provider list` to see available providers."
+    );
+  }
+  await api(`/api/clients/${kind}/enable`, {
+    method: "POST",
+    body: { providerId: provider2.id, ...opts.model ? { model: opts.model } : {} }
+  });
+  success(
+    `Client "${kind}" enabled with provider "${provider2.name ?? provider2.id}"${opts.model ? ` (model: ${opts.model})` : ""}.`
+  );
+  console.log("Restart the client (Codex, Claude Desktop, \u2026) if it does not pick up the change.");
+}
+async function runClientDisable(kind) {
+  await api(`/api/clients/${kind}/disable`, { method: "POST", body: {} });
+  success(`Client "${kind}" disabled. Its original configuration was restored.`);
+}
+async function runProviderList() {
+  const rows = await api("/api/providers");
+  printTable(
+    rows.map((r) => [
+      r.id,
+      r.name ?? "",
+      r.templateId ?? "",
+      fmtBool(r.enabled),
+      r.modelCount === void 0 ? "" : String(r.modelCount)
+    ]),
+    ["ID", "NAME", "TEMPLATE", "ENABLED", "MODELS"]
+  );
+}
+async function runProviderAdd(opts) {
+  const templates = await api("/api/provider-templates");
+  const needle = opts.template.toLowerCase();
+  const template = templates.find(
+    (t) => t.id.toLowerCase() === needle || t.name?.toLowerCase() === needle
+  );
+  if (!template) {
+    throw new AstraError(
+      `Unknown provider template "${opts.template}".`,
+      `Available templates: ${templates.map((t) => t.id).join(", ") || "(none reported)"}`
+    );
+  }
+  const variants = template.variants ?? [];
+  let variantId = opts.variant;
+  if (variants.length > 0 && !variantId) {
+    throw new AstraError(
+      `Template "${template.id}" has variants \u2014 pass --variant.`,
+      `Variants: ${variants.map((v) => v.id).join(", ")}`
+    );
+  }
+  if (variantId && variants.length > 0 && !variants.some((v) => v.id === variantId)) {
+    throw new AstraError(
+      `Unknown variant "${variantId}" for template "${template.id}".`,
+      `Variants: ${variants.map((v) => v.id).join(", ")}`
+    );
+  }
+  if (variants.length === 0) variantId = void 0;
+  const created = await api("/api/providers", {
+    method: "POST",
+    body: {
+      templateId: template.id,
+      ...variantId ? { variantId } : {},
+      ...opts.name ? { name: opts.name } : {},
+      apiKey: opts.key
+    }
+  });
+  success(`Provider added: ${created.name ?? created.id} (id: ${created.id}).`);
+}
+async function runProviderRemove(id) {
+  try {
+    await api(`/api/providers/${encodeURIComponent(id)}`, { method: "DELETE" });
+  } catch (err) {
+    if (err instanceof ApiError && err.status === 409) {
+      throw new AstraError(
+        `Provider "${id}" is still bound to one or more clients.`,
+        "Disable the client or bind it to another provider first (`astra client disable <kind>`)."
+      );
+    }
+    throw err;
+  }
+  success(`Provider "${id}" removed.`);
+}
+
+// src/commands/config.ts
+import { spawn as spawn8 } from "child_process";
+async function runSetPassword() {
+  const password = await promptHidden("Enter new admin password: ");
+  if (!password) throw new AstraError("Password must not be empty.");
+  const confirm = await promptHidden("Repeat password: ");
+  if (confirm !== password) throw new AstraError("Passwords do not match.");
+  const command = resolveServerBinary();
+  const child = spawn8(command.command, [...command.args, "set-password"], {
+    stdio: ["pipe", "inherit", "inherit"],
+    windowsHide: true
+  });
+  child.stdin?.write(`${password}
+`);
+  child.stdin?.end();
+  const code = await exitCodeOf(child);
+  if (code !== 0) {
+    throw new AstraError(`set-password failed with exit code ${code}.`);
+  }
+  success("Admin password updated.");
+  const status = await serverStatus();
+  if (status.running) {
+    info("Restart the server for the new password to take effect: `astra restart`.");
+  }
+}
+
+// src/commands/restore-all.ts
+import { spawn as spawn9 } from "child_process";
+async function runRestoreAll(opts) {
+  const command = resolveServerBinary();
+  const args = [...command.args, "restore-all", ...opts.purge ? ["--purge"] : []];
+  const child = spawn9(command.command, args, { stdio: "inherit", windowsHide: true });
+  const code = await exitCodeOf(child);
+  if (code !== 0) {
+    throw new AstraError(`restore-all failed with exit code ${code}.`);
+  }
+  success(
+    opts.purge ? "All client configurations were restored and Astra entries were removed from them." : "All client configurations were restored."
+  );
+}
+
+// src/index.ts
+function addStartOptions(cmd) {
+  return cmd.option("--port <port>", "TCP port to listen on (default 17321)").option("--host <host>", "Address to bind (default 127.0.0.1)").option("--foreground", "Run the server in the foreground instead of detached").option("--open", "Open the web UI in the default browser");
+}
+var program = new Command();
+program.name("astra").description("Astra \u2014 a local AI gateway. Manage the astra-server from the terminal.").version(VERSION, "-v, --version", "Print the CLI version");
+addStartOptions(program).action((opts) => runStart(opts));
+addStartOptions(
+  program.command("start").description("Start the Astra server (background by default)")
+).action((opts) => runStart(opts));
+program.command("stop").description("Stop the running Astra server").action(() => runStop());
+addStartOptions(program.command("restart").description("Restart the Astra server")).action(
+  (opts) => runRestart(opts)
+);
+program.command("status").description("Show whether the server is running and its details").action(() => runStatus());
+program.command("logs").description("Show recent server logs").option("-f, --follow", "Keep printing new log output").action((opts) => runLogs(opts));
+program.command("open").description("Open the Astra web UI in the default browser").action(() => runOpen());
+var autostart = program.command("autostart").description("Manage starting Astra at login");
+autostart.command("enable").description("Enable autostart (LaunchAgent / systemd --user / schtasks)").action(() => runAutostart("enable"));
+autostart.command("disable").description("Disable autostart").action(() => runAutostart("disable"));
+autostart.command("status").description("Show whether autostart is enabled").action(() => runAutostart("status"));
+program.command("install").description("Install optional Astra components").option("--desktop", "Install the Astra desktop app for this platform").option("--client", "Alias of --desktop").action(
+  (opts) => runInstall({ client: opts.desktop || opts.client })
+);
+program.command("uninstall").description("Uninstall Astra (restore client configs, stop the server)").option("--desktop", "Only uninstall the desktop app").option("--client", "Alias of --desktop").option("--purge", "Also delete the Astra data directory (~/.astra)").action((opts) => {
+  if (opts.desktop || opts.client) return runUninstallClient();
+  return runUninstall({ purge: opts.purge });
+});
+program.command("update").description("Update astra (and the desktop app when installed), then restart the server").option("--desktop", "Only update the desktop app").option("--client", "Alias of --desktop").option("--check", "Only check for updates, do not install").option("--retry", "Retry even after repeated update failures").action(
+  (opts) => runUpdate({ client: opts.desktop || opts.client, check: opts.check, retry: opts.retry })
+);
+var client = program.command("client").description("Manage AI clients (Codex, Claude Code, \u2026)");
+client.command("list").description("List clients and their status").action(() => runClientList());
+client.command("status").description("Show one client in detail").addArgument(new Argument("<kind>", "Client kind").choices([...CLIENT_KINDS])).action((kind) => runClientStatus(kind));
+client.command("enable").description("Enable a client and point it at Astra").addArgument(new Argument("<kind>", "Client kind").choices([...CLIENT_KINDS])).requiredOption("--provider <id-or-name>", "Provider id or name to bind").option("--model <model>", "Model to write into the client configuration").action(
+  (kind, opts) => runClientEnable(kind, opts)
+);
+client.command("disable").description("Disable a client and restore its original configuration").addArgument(new Argument("<kind>", "Client kind").choices([...CLIENT_KINDS])).action((kind) => runClientDisable(kind));
+var provider = program.command("provider").description("Manage providers (upstream AI accounts)");
+provider.command("list").description("List providers").action(() => runProviderList());
+provider.command("add").description("Add a provider from a template").requiredOption("--template <id>", "Provider template id (see `astra provider templates`)").option("--variant <id>", "Template variant, when the template has variants").requiredOption("--key <apiKey>", "API key for the provider").option("--name <name>", "Display name for the provider").action(
+  (opts) => runProviderAdd(opts)
+);
+provider.command("remove").description("Remove a provider").argument("<id>", "Provider id").action((id) => runProviderRemove(id));
+program.command("config").description("Manage Astra configuration").command("set-password").description("Set the admin password (required before binding to a non-loopback address)").action(() => runSetPassword());
+program.command("restore-all").description("Restore every managed client configuration offline (no server needed)").option("--purge", "Also remove Astra entries from client configs entirely").action((opts) => runRestoreAll(opts));
+program.parseAsync(process5.argv).then(() => {
+}).catch((err) => {
+  if (err instanceof ApiError) {
+    fail(`error: ${err.message} (HTTP ${err.status})`);
+    process5.exitCode = 1;
+    return;
+  }
+  if (err instanceof AstraError) {
+    fail(`error: ${err.message}`);
+    if (err.hint) console.error(`  ${err.hint}`);
+    process5.exitCode = 1;
+    return;
+  }
+  fail(`error: ${err instanceof Error ? err.message : String(err)}`);
+  if (process5.env.ASTRA_DEBUG) console.error(err);
+  else console.error("Run with ASTRA_DEBUG=1 for a stack trace.");
+  process5.exitCode = 1;
+});
+//# sourceMappingURL=index.js.map