@swmansion/argent 0.9.0 → 0.10.0

package/dist/cli-cmds.mjs

@@ -1,8 +1,161 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/sisteransi/src/index.js
+var require_src = __commonJS({
+  "../../node_modules/sisteransi/src/index.js"(exports, module) {
+    "use strict";
+    var ESC2 = "\x1B";
+    var CSI2 = `${ESC2}[`;
+    var beep = "\x07";
+    var cursor = {
+      to(x3, y) {
+        if (!y) return `${CSI2}${x3 + 1}G`;
+        return `${CSI2}${y + 1};${x3 + 1}H`;
+      },
+      move(x3, y) {
+        let ret = "";
+        if (x3 < 0) ret += `${CSI2}${-x3}D`;
+        else if (x3 > 0) ret += `${CSI2}${x3}C`;
+        if (y < 0) ret += `${CSI2}${-y}A`;
+        else if (y > 0) ret += `${CSI2}${y}B`;
+        return ret;
+      },
+      up: (count = 1) => `${CSI2}${count}A`,
+      down: (count = 1) => `${CSI2}${count}B`,
+      forward: (count = 1) => `${CSI2}${count}C`,
+      backward: (count = 1) => `${CSI2}${count}D`,
+      nextLine: (count = 1) => `${CSI2}E`.repeat(count),
+      prevLine: (count = 1) => `${CSI2}F`.repeat(count),
+      left: `${CSI2}G`,
+      hide: `${CSI2}?25l`,
+      show: `${CSI2}?25h`,
+      save: `${ESC2}7`,
+      restore: `${ESC2}8`
+    };
+    var scroll = {
+      up: (count = 1) => `${CSI2}S`.repeat(count),
+      down: (count = 1) => `${CSI2}T`.repeat(count)
+    };
+    var erase = {
+      screen: `${CSI2}2J`,
+      up: (count = 1) => `${CSI2}1J`.repeat(count),
+      down: (count = 1) => `${CSI2}J`.repeat(count),
+      line: `${CSI2}2K`,
+      lineEnd: `${CSI2}K`,
+      lineStart: `${CSI2}1K`,
+      lines(count) {
+        let clear = "";
+        for (let i = 0; i < count; i++)
+          clear += this.line + (i < count - 1 ? cursor.up() : "");
+        if (count)
+          clear += cursor.left;
+        return clear;
+      }
+    };
+    module.exports = { cursor, scroll, erase, beep };
+  }
+});
+
+// ../../node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS({
+  "../../node_modules/picocolors/picocolors.js"(exports, module) {
+    var p2 = process || {};
+    var argv = p2.argv || [];
+    var env = p2.env || {};
+    var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p2.platform === "win32" || (p2.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+    var formatter = (open, close, replace = open) => (input) => {
+      let string = "" + input, index = string.indexOf(close, open.length);
+      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    };
+    var replaceClose = (string, close, replace, index) => {
+      let result = "", cursor = 0;
+      do {
+        result += string.substring(cursor, index) + replace;
+        cursor = index + close.length;
+        index = string.indexOf(close, cursor);
+      } while (~index);
+      return result + string.substring(cursor);
+    };
+    var createColors = (enabled = isColorSupported) => {
+      let f2 = enabled ? formatter : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: f2("\x1B[0m", "\x1B[0m"),
+        bold: f2("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: f2("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: f2("\x1B[3m", "\x1B[23m"),
+        underline: f2("\x1B[4m", "\x1B[24m"),
+        inverse: f2("\x1B[7m", "\x1B[27m"),
+        hidden: f2("\x1B[8m", "\x1B[28m"),
+        strikethrough: f2("\x1B[9m", "\x1B[29m"),
+        black: f2("\x1B[30m", "\x1B[39m"),
+        red: f2("\x1B[31m", "\x1B[39m"),
+        green: f2("\x1B[32m", "\x1B[39m"),
+        yellow: f2("\x1B[33m", "\x1B[39m"),
+        blue: f2("\x1B[34m", "\x1B[39m"),
+        magenta: f2("\x1B[35m", "\x1B[39m"),
+        cyan: f2("\x1B[36m", "\x1B[39m"),
+        white: f2("\x1B[37m", "\x1B[39m"),
+        gray: f2("\x1B[90m", "\x1B[39m"),
+        bgBlack: f2("\x1B[40m", "\x1B[49m"),
+        bgRed: f2("\x1B[41m", "\x1B[49m"),
+        bgGreen: f2("\x1B[42m", "\x1B[49m"),
+        bgYellow: f2("\x1B[43m", "\x1B[49m"),
+        bgBlue: f2("\x1B[44m", "\x1B[49m"),
+        bgMagenta: f2("\x1B[45m", "\x1B[49m"),
+        bgCyan: f2("\x1B[46m", "\x1B[49m"),
+        bgWhite: f2("\x1B[47m", "\x1B[49m"),
+        blackBright: f2("\x1B[90m", "\x1B[39m"),
+        redBright: f2("\x1B[91m", "\x1B[39m"),
+        greenBright: f2("\x1B[92m", "\x1B[39m"),
+        yellowBright: f2("\x1B[93m", "\x1B[39m"),
+        blueBright: f2("\x1B[94m", "\x1B[39m"),
+        magentaBright: f2("\x1B[95m", "\x1B[39m"),
+        cyanBright: f2("\x1B[96m", "\x1B[39m"),
+        whiteBright: f2("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: f2("\x1B[100m", "\x1B[49m"),
+        bgRedBright: f2("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: f2("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: f2("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: f2("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: f2("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: f2("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: f2("\x1B[107m", "\x1B[49m")
+      };
+    };
+    module.exports = createColors();
+    module.exports.createColors = createColors;
+  }
+});
 
 // ../argent-cli/src/run.ts
 import * as fs2 from "node:fs";
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 
 // ../argent-tools-client/src/launcher.ts
 import * as net from "node:net";
@@ -11,20 +164,36 @@ import * as path from "node:path";
 import * as readline from "node:readline";
 import { homedir } from "node:os";
 import { spawn } from "node:child_process";
-import { mkdir, writeFile, readFile, unlink } from "node:fs/promises";
+import { randomBytes } from "node:crypto";
+import { mkdir, writeFile, readFile, unlink, rename, chmod } from "node:fs/promises";
 var STATE_DIR = path.join(homedir(), ".argent");
 var STATE_FILE = path.join(STATE_DIR, "tool-server.json");
 var LOG_FILE = path.join(STATE_DIR, "tool-server.log");
-function buildToolsServerEnv(paths, port, baseEnv = process.env) {
-  return {
+var AUTH_TOKEN_BYTES = 32;
+var AUTH_TOKEN_ENV = "ARGENT_AUTH_TOKEN";
+var AUTOSPAWN_IDLE_TIMEOUT_MINUTES = 30;
+function buildToolsServerEnv(paths, port, baseEnv = process.env, options = {}) {
+  const env = {
     ...baseEnv,
-    PORT: String(port),
+    ARGENT_PORT: String(port),
     ARGENT_SIMULATOR_SERVER_DIR: paths.simulatorServerDir,
     ARGENT_NATIVE_DEVTOOLS_DIR: paths.nativeDevtoolsDir
   };
+  if (options.host !== void 0) env.ARGENT_HOST = options.host;
+  if (options.idleTimeoutMinutes !== void 0) {
+    env.ARGENT_IDLE_TIMEOUT_MINUTES = String(options.idleTimeoutMinutes);
+  }
+  if (options.token) env[AUTH_TOKEN_ENV] = options.token;
+  return env;
+}
+function generateToken() {
+  return randomBytes(AUTH_TOKEN_BYTES).toString("hex");
+}
+function generateAuthToken() {
+  return generateToken();
 }
 function findFreePort() {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const srv = net.createServer();
     srv.listen(0, "127.0.0.1", () => {
       const addr = srv.address();
@@ -35,7 +204,7 @@ function findFreePort() {
       const port = addr.port;
       srv.close((err) => {
         if (err) reject(err);
-        else resolve2(port);
+        else resolve3(port);
       });
     });
     srv.on("error", reject);
@@ -49,12 +218,28 @@ function isProcessAlive(pid) {
     return false;
   }
 }
-async function isHealthy(port) {
+function isToolsServerProcessAlive(pid) {
+  return isProcessAlive(pid);
+}
+function healthCheckHost(host) {
+  if (host === "0.0.0.0" || host === "") return "127.0.0.1";
+  if (host === "::" || host === "::0") return "::1";
+  return host;
+}
+function formatUrl(host, port) {
+  const h2 = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+  return `http://${h2}:${port}`;
+}
+function authHeaders(token) {
+  return token ? { Authorization: `Bearer ${token}` } : {};
+}
+async function isToolsServerHealthy(port, host = "127.0.0.1", timeoutMs = 2e3, token) {
   const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), 2e3);
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
-    const res = await fetch(`http://127.0.0.1:${port}/tools`, {
-      signal: controller.signal
+    const res = await fetch(`${formatUrl(healthCheckHost(host), port)}/tools`, {
+      signal: controller.signal,
+      headers: authHeaders(token)
     });
     return res.ok;
   } catch {
@@ -63,8 +248,8 @@ async function isHealthy(port) {
     clearTimeout(timer);
   }
 }
-function spawnToolsServer(paths, port) {
-  return new Promise((resolve2, reject) => {
+function spawnToolsServer(paths, port, options = {}) {
+  return new Promise((resolve3, reject) => {
     let logFd;
     try {
       fs.mkdirSync(STATE_DIR, { recursive: true });
@@ -75,7 +260,7 @@ function spawnToolsServer(paths, port) {
     const child = spawn("node", [paths.bundlePath, "start"], {
       detached: true,
       stdio: ["ignore", "pipe", logFd],
-      env: buildToolsServerEnv(paths, port)
+      env: buildToolsServerEnv(paths, port, process.env, options)
     });
     child.unref();
     const pid = child.pid;
@@ -91,12 +276,12 @@ function spawnToolsServer(paths, port) {
     };
     const rl = readline.createInterface({ input: child.stdout });
     rl.on("line", (line) => {
-      const match = line.match(/Tools server listening on http:\/\/127\.0\.0\.1:(\d+)/);
+      const match = line.match(/Tools server listening on http:\/\/.+:(\d+)/);
       if (match) {
         const actualPort = parseInt(match[1], 10);
         rl.close();
         child.stdout?.resume();
-        settle(() => resolve2({ port: actualPort, pid }));
+        settle(() => resolve3({ port: actualPort, pid }));
       }
     });
     child.on("error", (err) => {
@@ -114,7 +299,7 @@ function spawnToolsServer(paths, port) {
     rl.on("close", () => clearTimeout(timer));
   });
 }
-async function readState() {
+async function readToolsServerState() {
   try {
     const raw = await readFile(STATE_FILE, "utf8");
     return JSON.parse(raw);
@@ -122,22 +307,73 @@ async function readState() {
     return null;
   }
 }
-async function writeState(state) {
+async function writeToolsServerState(state) {
   await mkdir(STATE_DIR, { recursive: true });
-  await writeFile(STATE_FILE, JSON.stringify(state, null, 2) + "\n", "utf8");
+  const tmp = `${STATE_FILE}.${process.pid}.tmp`;
+  try {
+    await writeFile(tmp, JSON.stringify(state, null, 2) + "\n", {
+      encoding: "utf8",
+      mode: 384
+    });
+    await chmod(tmp, 384);
+    await rename(tmp, STATE_FILE);
+  } catch (err) {
+    await unlink(tmp).catch(() => {
+    });
+    throw err;
+  }
+}
+function writeToolsServerStateSync(state) {
+  fs.mkdirSync(STATE_DIR, { recursive: true });
+  fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2) + "\n", {
+    encoding: "utf8",
+    mode: 384
+  });
+  fs.chmodSync(STATE_FILE, 384);
 }
-async function clearState() {
+async function clearToolsServerState() {
   try {
     await unlink(STATE_FILE);
   } catch {
   }
 }
+var readState = readToolsServerState;
+var writeState = writeToolsServerState;
+var clearState = clearToolsServerState;
+var SIGTERM_GRACE_MS = 6e3;
+var SIGKILL_GRACE_MS = 1e3;
+var KILL_POLL_MS = 100;
+async function waitForExit(pid, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive(pid)) return true;
+    await new Promise((r) => setTimeout(r, KILL_POLL_MS));
+  }
+  return !isProcessAlive(pid);
+}
 async function killToolServer() {
   const state = await readState();
   if (!state) return;
-  try {
-    process.kill(state.pid, "SIGTERM");
-  } catch {
+  let exited = !isProcessAlive(state.pid);
+  if (!exited) {
+    try {
+      process.kill(state.pid, "SIGTERM");
+    } catch {
+      exited = true;
+    }
+  }
+  if (!exited) {
+    exited = await waitForExit(state.pid, SIGTERM_GRACE_MS);
+  }
+  if (!exited) {
+    try {
+      process.kill(state.pid, "SIGKILL");
+    } catch {
+      exited = true;
+    }
+    if (!exited) {
+      await waitForExit(state.pid, SIGKILL_GRACE_MS);
+    }
   }
   await clearState();
 }
@@ -146,29 +382,154 @@ async function ensureToolsServer(paths) {
   if (state) {
     const alive = isProcessAlive(state.pid);
     if (alive) {
-      const healthy = await isHealthy(state.port);
+      const host = state.host ?? "127.0.0.1";
+      const healthy = await isToolsServerHealthy(state.port, host, 2e3, state.token);
       if (healthy) {
-        return `http://127.0.0.1:${state.port}`;
+        return {
+          url: formatUrl(healthCheckHost(host), state.port),
+          token: state.token ?? ""
+        };
       }
     }
     await clearState();
   }
+  const token = generateToken();
   const port = await findFreePort();
-  const { port: actualPort, pid } = await spawnToolsServer(paths, port);
+  const { port: actualPort, pid } = await spawnToolsServer(paths, port, {
+    token,
+    idleTimeoutMinutes: AUTOSPAWN_IDLE_TIMEOUT_MINUTES
+  });
   await writeState({
     port: actualPort,
     pid,
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    bundlePath: paths.bundlePath
+    bundlePath: paths.bundlePath,
+    host: "127.0.0.1",
+    token
+  });
+  return { url: formatUrl("127.0.0.1", actualPort), token };
+}
+
+// ../argent-tools-client/src/link-config.ts
+import * as path2 from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { mkdir as mkdir2, writeFile as writeFile2, readFile as readFile2, unlink as unlink2, chmod as chmod2 } from "node:fs/promises";
+var LINK_DIR = path2.join(homedir2(), ".argent");
+var LINK_FILE = path2.join(LINK_DIR, "link.json");
+async function readLinkConfig() {
+  try {
+    const raw = await readFile2(LINK_FILE, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed.url !== "string" || typeof parsed.host !== "string" || typeof parsed.port !== "number" || typeof parsed.createdAt !== "string") {
+      return null;
+    }
+    return {
+      url: parsed.url,
+      host: parsed.host,
+      port: parsed.port,
+      createdAt: parsed.createdAt,
+      ...typeof parsed.token === "string" ? { token: parsed.token } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeLinkConfig(cfg) {
+  await mkdir2(LINK_DIR, { recursive: true });
+  await writeFile2(LINK_FILE, JSON.stringify(cfg, null, 2) + "\n", {
+    encoding: "utf8",
+    mode: 384
   });
-  return `http://127.0.0.1:${actualPort}`;
+  await chmod2(LINK_FILE, 384);
+}
+async function clearLinkConfig() {
+  try {
+    await unlink2(LINK_FILE);
+  } catch {
+  }
+}
+async function getResolvedToolsUrl() {
+  const envUrl = process.env.ARGENT_TOOLS_URL;
+  if (envUrl) {
+    const link3 = await readLinkConfig();
+    const envToken = process.env[AUTH_TOKEN_ENV];
+    return {
+      url: envUrl,
+      source: "env",
+      ...envToken ? { token: envToken } : {},
+      ...link3 ? { shadowedLink: link3 } : {}
+    };
+  }
+  const link2 = await readLinkConfig();
+  if (link2) {
+    return { url: link2.url, source: "link", ...link2.token ? { token: link2.token } : {} };
+  }
+  return { url: null, source: "none" };
+}
+var LINK_URL_SCHEME = "argent:";
+function formatLinkUrl(parts) {
+  const h2 = parts.host.includes(":") && !parts.host.startsWith("[") ? `[${parts.host}]` : parts.host;
+  const auth = parts.token ? `${encodeURIComponent(parts.token)}@` : "";
+  return `${LINK_URL_SCHEME}//${auth}${h2}:${parts.port}`;
+}
+function parseLinkUrl(input) {
+  if (!input.startsWith(`${LINK_URL_SCHEME}//`)) return null;
+  let u;
+  try {
+    u = new URL(input);
+  } catch {
+    throw new Error(
+      `Invalid connection string "${input}" \u2014 expected argent://[<token>@]<host>:<port>`
+    );
+  }
+  const host = u.hostname.startsWith("[") ? u.hostname.slice(1, -1) : u.hostname;
+  if (!host) throw new Error(`Connection string "${input}" is missing a host.`);
+  if (!u.port) throw new Error(`Connection string "${input}" is missing a port.`);
+  const port = Number(u.port);
+  const token = u.username ? decodeURIComponent(u.username) : void 0;
+  return { host, port, ...token ? { token } : {} };
+}
+function httpFromHostPort(host, port) {
+  const h2 = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+  return `http://${h2}:${port}`;
+}
+function parseLinkTarget(input) {
+  const argent = parseLinkUrl(input);
+  if (argent) {
+    return {
+      url: httpFromHostPort(argent.host, argent.port),
+      host: argent.host,
+      port: argent.port,
+      ...argent.token ? { token: argent.token } : {}
+    };
+  }
+  if (!/^https?:\/\//i.test(input)) return null;
+  let u;
+  try {
+    u = new URL(input);
+  } catch {
+    throw new Error(`Invalid URL "${input}" \u2014 expected http(s)://<host>[:<port>][/path].`);
+  }
+  const host = u.hostname.startsWith("[") ? u.hostname.slice(1, -1) : u.hostname;
+  if (!host) throw new Error(`URL "${input}" is missing a host.`);
+  const port = u.port ? Number(u.port) : u.protocol === "https:" ? 443 : 80;
+  const path6 = u.pathname === "/" ? "" : u.pathname.replace(/\/+$/, "");
+  const url = `${u.protocol}//${u.host}${path6}`;
+  const token = u.username ? decodeURIComponent(u.username) : void 0;
+  return { url, host, port, ...token ? { token } : {} };
 }
 
 // ../argent-tools-client/src/tools-client.ts
+function authHeaders2(token) {
+  return token ? { Authorization: `Bearer ${token}` } : {};
+}
 function createToolsClient(options = {}) {
   let cached = null;
   async function baseUrl() {
-    if (process.env.ARGENT_TOOLS_URL) return process.env.ARGENT_TOOLS_URL;
+    const resolved = await getResolvedToolsUrl();
+    if (resolved.url) {
+      return { url: resolved.url, token: resolved.token ?? "" };
+    }
     if (cached) return cached;
     if (!options.paths) {
       throw new Error(
@@ -179,8 +540,8 @@ function createToolsClient(options = {}) {
     return cached;
   }
   async function fetchTools() {
-    const url = await baseUrl();
-    const res = await fetch(`${url}/tools`);
+    const { url, token } = await baseUrl();
+    const res = await fetch(`${url}/tools`, { headers: authHeaders2(token) });
     if (!res.ok) throw new Error(`GET /tools failed: ${res.status} ${res.statusText}`);
     const json = await res.json();
     return json.tools;
@@ -190,10 +551,10 @@ function createToolsClient(options = {}) {
     return tools2.find((t) => t.name === name) ?? null;
   }
   async function callTool(name, args) {
-    const url = await baseUrl();
+    const { url, token } = await baseUrl();
     const res = await fetch(`${url}/tools/${encodeURIComponent(name)}`, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
+      headers: { "Content-Type": "application/json", ...authHeaders2(token) },
       body: JSON.stringify(args ?? {})
     });
     const json = await res.json().catch(() => ({}));
@@ -259,7 +620,7 @@ function parseFlags(argv, schema) {
       continue;
     }
     if (tok === "--") {
-      for (let j = i + 1; j < argv.length; j++) positional.push(argv[j]);
+      for (let j2 = i + 1; j2 < argv.length; j2++) positional.push(argv[j2]);
       break;
     }
     if (!tok.startsWith("--")) {
@@ -366,7 +727,7 @@ function renderFlagName(name, prop) {
 }
 function renderType(prop) {
   if (prop.enum && Array.isArray(prop.enum)) {
-    return `enum: ${prop.enum.map((v) => JSON.stringify(v)).join(" | ")}`;
+    return `enum: ${prop.enum.map((v2) => JSON.stringify(v2)).join(" | ")}`;
   }
   if (prop.type === "array") {
     const item = prop.items?.type ?? "any";
@@ -388,9 +749,9 @@ function splitOptions(argv) {
       continue;
     }
     if (tok === "--out") {
-      const v = argv[i + 1];
-      if (!v) throw new FlagParseException("--out requires a path");
-      outPath = v;
+      const v2 = argv[i + 1];
+      if (!v2) throw new FlagParseException("--out requires a path");
+      outPath = v2;
       i += 1;
       continue;
     }
@@ -403,13 +764,13 @@ function splitOptions(argv) {
   return { json, outPath, argvForFlags: rest };
 }
 async function readStdin() {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     let data = "";
     process.stdin.setEncoding("utf8");
     process.stdin.on("data", (chunk) => {
       data += chunk;
     });
-    process.stdin.on("end", () => resolve2(data));
+    process.stdin.on("end", () => resolve3(data));
     process.stdin.on("error", reject);
   });
 }
@@ -437,7 +798,7 @@ async function fetchImageToFile(result, outPath) {
   const res = await fetch(url);
   if (!res.ok) throw new Error(`Failed to download image: ${res.status} ${res.statusText}`);
   const buf = Buffer.from(await res.arrayBuffer());
-  fs2.mkdirSync(path2.dirname(path2.resolve(outPath)), { recursive: true });
+  fs2.mkdirSync(path3.dirname(path3.resolve(outPath)), { recursive: true });
   fs2.writeFileSync(outPath, buf);
 }
 function renderResult(result, outputHint, json) {
@@ -507,8 +868,8 @@ Examples:
       process.exit(2);
     }
   }
-  for (const [k, v] of Object.entries(parsed.args)) {
-    payload[k] = v;
+  for (const [k2, v2] of Object.entries(parsed.args)) {
+    payload[k2] = v2;
   }
   let result;
   let note;
@@ -554,8 +915,8 @@ async function tools(argv, options) {
       console.log("(no tools registered)");
       return;
     }
-    const sorted = [...list].sort((a, b) => a.name.localeCompare(b.name));
-    const maxName = sorted.reduce((m, t) => Math.max(m, t.name.length), 0);
+    const sorted = [...list].sort((a, b2) => a.name.localeCompare(b2.name));
+    const maxName = sorted.reduce((m2, t) => Math.max(m2, t.name.length), 0);
     for (const t of sorted) {
       const summary = summarize(t.description);
       console.log(`  ${t.name.padEnd(maxName, " ")}  ${summary}`);
@@ -614,12 +975,12 @@ Options:
 
 // ../argent-cli/src/server.ts
 import * as fs3 from "node:fs";
-import * as path3 from "node:path";
-import { homedir as homedir2 } from "node:os";
+import * as path4 from "node:path";
+import { homedir as homedir3, networkInterfaces } from "node:os";
 import { spawn as spawn2 } from "node:child_process";
-var STATE_DIR2 = path3.join(homedir2(), ".argent");
-var STATE_FILE2 = path3.join(STATE_DIR2, "tool-server.json");
-var LOG_FILE2 = path3.join(STATE_DIR2, "tool-server.log");
+var STATE_DIR2 = path4.join(homedir3(), ".argent");
+var STATE_FILE2 = path4.join(STATE_DIR2, "tool-server.json");
+var LOG_FILE2 = path4.join(STATE_DIR2, "tool-server.log");
 function readState2() {
   try {
     return JSON.parse(fs3.readFileSync(STATE_FILE2, "utf8"));
@@ -627,26 +988,6 @@ function readState2() {
     return null;
   }
 }
-function isProcessAlive2(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function isHealthy2(port, timeoutMs = 2e3) {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const res = await fetch(`http://127.0.0.1:${port}/tools`, { signal: controller.signal });
-    return res.ok;
-  } catch {
-    return false;
-  } finally {
-    clearTimeout(timer);
-  }
-}
 async function statusCmd(json) {
   const state = readState2();
   if (!state) {
@@ -657,14 +998,22 @@ async function statusCmd(json) {
     }
     return;
   }
-  const alive = isProcessAlive2(state.pid);
-  const healthy = alive ? await isHealthy2(state.port) : false;
+  const host = state.host ?? "127.0.0.1";
+  const alive = isToolsServerProcessAlive(state.pid);
+  const healthy = alive ? await isToolsServerHealthy(state.port, host, 2e3, state.token) : false;
   if (json) {
-    console.log(JSON.stringify({ running: alive && healthy, ...state, alive, healthy }, null, 2));
+    const { token, ...publicState } = state;
+    console.log(
+      JSON.stringify(
+        { running: alive && healthy, ...publicState, hasToken: !!token, alive, healthy },
+        null,
+        2
+      )
+    );
     return;
   }
   console.log(`tool-server:`);
-  console.log(`  url:        http://127.0.0.1:${state.port}`);
+  console.log(`  url:        ${formatUrl(host, state.port)}`);
   console.log(`  pid:        ${state.pid}`);
   console.log(`  startedAt:  ${state.startedAt}`);
   console.log(`  process:    ${alive ? "alive" : "dead"}`);
@@ -695,12 +1044,312 @@ function logsCmd(follow) {
   const child = spawn2("tail", ["-f", LOG_FILE2], { stdio: "inherit" });
   child.on("exit", (code) => process.exit(code ?? 0));
 }
-async function server(argv) {
+var StartFlagError = class extends Error {
+};
+function parseStartFlags(argv) {
+  const flags2 = {
+    port: null,
+    host: "127.0.0.1",
+    idleTimeoutMinutes: 0,
+    detach: false,
+    force: false,
+    noAuth: false,
+    help: false
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const tok = argv[i];
+    const takeValue = (name) => {
+      const v2 = argv[i + 1];
+      if (v2 === void 0) throw new StartFlagError(`${name} requires a value`);
+      i += 1;
+      return v2;
+    };
+    if (tok === "--help" || tok === "-h") {
+      flags2.help = true;
+      continue;
+    }
+    if (tok === "--detach" || tok === "-d") {
+      flags2.detach = true;
+      continue;
+    }
+    if (tok === "--force") {
+      flags2.force = true;
+      continue;
+    }
+    if (tok === "--no-auth") {
+      flags2.noAuth = true;
+      continue;
+    }
+    if (tok === "--port" || tok === "-p") {
+      flags2.port = parsePort(takeValue("--port"));
+      continue;
+    }
+    if (tok.startsWith("--port=")) {
+      flags2.port = parsePort(tok.slice("--port=".length));
+      continue;
+    }
+    if (tok === "--host") {
+      flags2.host = takeValue("--host");
+      continue;
+    }
+    if (tok.startsWith("--host=")) {
+      flags2.host = tok.slice("--host=".length);
+      continue;
+    }
+    if (tok === "--idle-timeout") {
+      flags2.idleTimeoutMinutes = parseIdle(takeValue("--idle-timeout"));
+      continue;
+    }
+    if (tok.startsWith("--idle-timeout=")) {
+      flags2.idleTimeoutMinutes = parseIdle(tok.slice("--idle-timeout=".length));
+      continue;
+    }
+    throw new StartFlagError(`Unknown flag: ${tok}`);
+  }
+  return flags2;
+}
+var NON_NEGATIVE_INT = /^\d+$/;
+function parsePort(raw) {
+  if (!NON_NEGATIVE_INT.test(raw) || Number(raw) > 65535) {
+    throw new StartFlagError(`--port must be an integer 0..65535, got "${raw}"`);
+  }
+  return Number(raw);
+}
+function parseIdle(raw) {
+  if (!NON_NEGATIVE_INT.test(raw)) {
+    throw new StartFlagError(`--idle-timeout must be a non-negative integer, got "${raw}"`);
+  }
+  return Number(raw);
+}
+function printStartHelp() {
+  console.log(`Usage: argent server start [flags]
+
+Spawn a long-lived tool-server. Foreground by default so process supervisors
+(systemd, Docker, supervisord) can own the lifecycle.
+
+Flags:
+  --port, -p <n>          Bind to port <n> (0 = pick a free port). Default: 3001
+  --host <h>              Bind address. Default: 127.0.0.1
+                          Use 0.0.0.0 to expose on every interface.
+  --idle-timeout <m>      Auto-shutdown after <m> idle minutes (0 disables).
+                          Default: 0 (never auto-shutdown).
+  --detach, -d            Run as a detached background process and return.
+  --force                 If a tool-server is already running, kill it first.
+  --no-auth               Disable authentication (no token). Anyone who can
+                          reach the port can drive the server. Dev/trusted only.
+  --help, -h              Show this help.
+
+Auth:
+  By default the server mints a bearer token and prints a one-line connection
+  string. Pair a client by pasting it into \`argent link\`:
+      argent link argent://<token>@<host>:<port>
+  Pass --no-auth to run without a token (unauthenticated).
+
+Examples:
+  argent server start
+  argent server start --port 4000
+  argent server start --host 0.0.0.0 --port 4000
+  argent server start --detach
+  argent server start --host 0.0.0.0 --no-auth
+`);
+}
+function isLoopback(host) {
+  return host === "127.0.0.1" || host === "localhost" || host === "::1";
+}
+function isWildcard(host) {
+  return host === "0.0.0.0" || host === "::" || host === "::0" || host === "";
+}
+function primaryLanIPv4() {
+  const ifaces = networkInterfaces();
+  for (const addrs of Object.values(ifaces)) {
+    for (const ni of addrs ?? []) {
+      if (ni.family === "IPv4" && !ni.internal) return ni.address;
+    }
+  }
+  return null;
+}
+function resolveConnectHost(bindHost) {
+  if (isWildcard(bindHost)) return primaryLanIPv4() ?? "127.0.0.1";
+  return bindHost;
+}
+function printConnectionInfo(bindHost, port, token) {
+  const connectHost = resolveConnectHost(bindHost);
+  console.log("");
+  console.log("  Connect a client:");
+  console.log(`      argent link ${formatLinkUrl({ host: connectHost, port, token })}`);
+  const flagsForm = token ? `argent link --host ${connectHost} --port ${port} --token ${token}` : `argent link --host ${connectHost} --port ${port}`;
+  console.log(`      (or: ${flagsForm})${token ? "" : "   [unauthenticated]"}`);
+  if (isWildcard(bindHost)) {
+    console.log(
+      `  note: bound to ${bindHost}; ${connectHost} is a best guess \u2014 replace it with the address clients actually reach this machine on.`
+    );
+  }
+}
+async function ensureNoExistingServer(force) {
+  const state = await readToolsServerState();
+  if (!state) return;
+  const alive = isToolsServerProcessAlive(state.pid);
+  const healthy = alive ? await isToolsServerHealthy(state.port, state.host ?? "127.0.0.1") : false;
+  if (alive && healthy && !force) {
+    const url = formatUrl(state.host ?? "127.0.0.1", state.port);
+    throw new StartFlagError(
+      `tool-server is already running at ${url} (pid ${state.pid}).
+Use \`argent server stop\` first, or pass \`--force\` to replace it.`
+    );
+  }
+  if (alive && force) {
+    await killToolServer();
+  } else {
+    await clearToolsServerState();
+  }
+}
+async function resolvePort(requested) {
+  if (requested === null) return 3001;
+  if (requested === 0) return findFreePort();
+  return requested;
+}
+async function startCmd(argv, paths) {
+  if (!paths) {
+    console.error("argent server start: bundled runtime paths missing \u2014 this build is incomplete.");
+    process.exit(1);
+  }
+  let flags2;
+  try {
+    flags2 = parseStartFlags(argv);
+  } catch (err) {
+    if (err instanceof StartFlagError) {
+      console.error(`Error: ${err.message}
+`);
+      printStartHelp();
+      process.exit(2);
+    }
+    throw err;
+  }
+  if (flags2.help) {
+    printStartHelp();
+    return;
+  }
+  try {
+    await ensureNoExistingServer(flags2.force);
+  } catch (err) {
+    if (err instanceof StartFlagError) {
+      console.error(err.message);
+      process.exit(1);
+    }
+    throw err;
+  }
+  const port = await resolvePort(flags2.port);
+  const token = flags2.noAuth ? void 0 : generateAuthToken();
+  if (!isLoopback(flags2.host)) {
+    if (token) {
+      process.stderr.write(
+        `Note: tool-server will be reachable on ${flags2.host}:${port} over plain HTTP (bearer-token auth, no TLS). Keep it to a trusted network or VPN.
+`
+      );
+    } else {
+      process.stderr.write(
+        `WARNING: tool-server will be reachable on ${flags2.host}:${port} with NO auth (--no-auth) \u2014 anyone who can reach the port can drive it. Do not expose to untrusted networks.
+`
+      );
+    }
+  }
+  if (flags2.detach) {
+    await runDetached(paths, port, flags2.host, flags2.idleTimeoutMinutes, token);
+    return;
+  }
+  await runForeground(paths, port, flags2.host, flags2.idleTimeoutMinutes, token);
+}
+async function runDetached(paths, port, host, idleTimeoutMinutes, token) {
+  const { port: actualPort, pid } = await spawnToolsServer(paths, port, {
+    host,
+    idleTimeoutMinutes,
+    token
+  });
+  await writeToolsServerState({
+    port: actualPort,
+    pid,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    bundlePath: paths.bundlePath,
+    host,
+    ...token ? { token } : {}
+  });
+  const url = formatUrl(host, actualPort);
+  console.log(`tool-server started: ${url} (pid ${pid})`);
+  printConnectionInfo(host, actualPort, token);
+  console.log("");
+  console.log(`  logs:   ${LOG_FILE2}`);
+  console.log(`  status: argent server status`);
+  console.log(`  stop:   argent server stop`);
+}
+async function runForeground(paths, port, host, idleTimeoutMinutes, token) {
+  const env = buildToolsServerEnv(paths, port, process.env, {
+    host,
+    idleTimeoutMinutes,
+    token
+  });
+  const child = spawn2("node", [paths.bundlePath, "start"], {
+    stdio: "inherit",
+    env
+  });
+  const forward = (signal) => () => {
+    try {
+      child.kill(signal);
+    } catch {
+    }
+  };
+  const onInt = forward("SIGINT");
+  const onTerm = forward("SIGTERM");
+  process.on("SIGINT", onInt);
+  process.on("SIGTERM", onTerm);
+  let stateWritten = false;
+  const childPid = child.pid;
+  if (childPid !== void 0) {
+    try {
+      writeToolsServerStateSync({
+        port,
+        pid: childPid,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        bundlePath: paths.bundlePath,
+        host,
+        ...token ? { token } : {}
+      });
+      stateWritten = true;
+    } catch {
+    }
+  }
+  printConnectionInfo(host, port, token);
+  await new Promise(() => {
+    const cleanup = () => {
+      process.removeListener("SIGINT", onInt);
+      process.removeListener("SIGTERM", onTerm);
+      if (stateWritten) {
+        clearToolsServerState().catch(() => {
+        });
+      }
+    };
+    child.on("error", (err) => {
+      cleanup();
+      console.error(`argent server start: failed to spawn tool-server: ${err.message}`);
+      process.exit(1);
+    });
+    child.on("exit", (code, signal) => {
+      cleanup();
+      const exitCode = code ?? (signal ? 128 + (signalNumber(signal) ?? 0) : 0);
+      process.exit(exitCode);
+    });
+  });
+}
+function signalNumber(signal) {
+  const map = { SIGINT: 2, SIGTERM: 15, SIGHUP: 1, SIGKILL: 9 };
+  return map[signal] ?? null;
+}
+async function server(argv, options) {
   const sub = argv[0];
   const json = argv.includes("--json");
   const follow = argv.includes("-f") || argv.includes("--follow");
   if (!sub || sub === "--help" || sub === "-h") {
     console.log(`Usage:
+  argent server start [flags]     Spawn a long-lived tool-server (see --help)
   argent server status [--json]   Show tool-server pid, port, and health
   argent server stop              Terminate the running tool-server
   argent server logs [-f]         Print (or follow) the tool-server log
@@ -708,6 +1357,9 @@ async function server(argv) {
     return;
   }
   switch (sub) {
+    case "start":
+      await startCmd(argv.slice(1), options?.paths);
+      return;
     case "status":
       await statusCmd(json);
       return;
@@ -722,8 +1374,1644 @@ async function server(argv) {
       process.exit(1);
   }
 }
+
+// ../../node_modules/@clack/core/dist/index.mjs
+import { styleText as v } from "node:util";
+import { stdout as x, stdin as D } from "node:process";
+import * as b from "node:readline";
+import E from "node:readline";
+
+// ../../node_modules/fast-string-truncated-width/dist/utils.js
+var getCodePointsLength = /* @__PURE__ */ (() => {
+  const SURROGATE_PAIR_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  return (input) => {
+    let surrogatePairsNr = 0;
+    SURROGATE_PAIR_RE.lastIndex = 0;
+    while (SURROGATE_PAIR_RE.test(input)) {
+      surrogatePairsNr += 1;
+    }
+    return input.length - surrogatePairsNr;
+  };
+})();
+var isFullWidth = (x3) => {
+  return x3 === 12288 || x3 >= 65281 && x3 <= 65376 || x3 >= 65504 && x3 <= 65510;
+};
+var isWideNotCJKTNotEmoji = (x3) => {
+  return x3 === 8987 || x3 === 9001 || x3 >= 12272 && x3 <= 12287 || x3 >= 12289 && x3 <= 12350 || x3 >= 12441 && x3 <= 12543 || x3 >= 12549 && x3 <= 12591 || x3 >= 12593 && x3 <= 12686 || x3 >= 12688 && x3 <= 12771 || x3 >= 12783 && x3 <= 12830 || x3 >= 12832 && x3 <= 12871 || x3 >= 12880 && x3 <= 19903 || x3 >= 65040 && x3 <= 65049 || x3 >= 65072 && x3 <= 65106 || x3 >= 65108 && x3 <= 65126 || x3 >= 65128 && x3 <= 65131 || x3 >= 127488 && x3 <= 127490 || x3 >= 127504 && x3 <= 127547 || x3 >= 127552 && x3 <= 127560 || x3 >= 131072 && x3 <= 196605 || x3 >= 196608 && x3 <= 262141;
+};
+
+// ../../node_modules/fast-string-truncated-width/dist/index.js
+var ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y;
+var CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
+var CJKT_WIDE_RE = /(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/yu;
+var TAB_RE = /\t{1,1000}/y;
+var EMOJI_RE = new RegExp("[\\u{1F1E6}-\\u{1F1FF}]{2}|\\u{1F3F4}[\\u{E0061}-\\u{E007A}]{2}[\\u{E0030}-\\u{E0039}\\u{E0061}-\\u{E007A}]{1,3}\\u{E007F}|(?:\\p{Emoji}\\uFE0F\\u20E3?|\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation})(?:\\u200D(?:\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation}|\\p{Emoji}\\uFE0F\\u20E3?))*", "yu");
+var LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+var MODIFIER_RE = new RegExp("\\p{M}+", "gu");
+var NO_TRUNCATION = { limit: Infinity, ellipsis: "" };
+var getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {}) => {
+  const LIMIT = truncationOptions.limit ?? Infinity;
+  const ELLIPSIS = truncationOptions.ellipsis ?? "";
+  const ELLIPSIS_WIDTH = truncationOptions?.ellipsisWidth ?? (ELLIPSIS ? getStringTruncatedWidth(ELLIPSIS, NO_TRUNCATION, widthOptions).width : 0);
+  const ANSI_WIDTH = 0;
+  const CONTROL_WIDTH = widthOptions.controlWidth ?? 0;
+  const TAB_WIDTH = widthOptions.tabWidth ?? 8;
+  const EMOJI_WIDTH = widthOptions.emojiWidth ?? 2;
+  const FULL_WIDTH_WIDTH = 2;
+  const REGULAR_WIDTH = widthOptions.regularWidth ?? 1;
+  const WIDE_WIDTH = widthOptions.wideWidth ?? FULL_WIDTH_WIDTH;
+  const PARSE_BLOCKS = [
+    [LATIN_RE, REGULAR_WIDTH],
+    [ANSI_RE, ANSI_WIDTH],
+    [CONTROL_RE, CONTROL_WIDTH],
+    [TAB_RE, TAB_WIDTH],
+    [EMOJI_RE, EMOJI_WIDTH],
+    [CJKT_WIDE_RE, WIDE_WIDTH]
+  ];
+  let indexPrev = 0;
+  let index = 0;
+  let length = input.length;
+  let lengthExtra = 0;
+  let truncationEnabled = false;
+  let truncationIndex = length;
+  let truncationLimit = Math.max(0, LIMIT - ELLIPSIS_WIDTH);
+  let unmatchedStart = 0;
+  let unmatchedEnd = 0;
+  let width = 0;
+  let widthExtra = 0;
+  outer: while (true) {
+    if (unmatchedEnd > unmatchedStart || index >= length && index > indexPrev) {
+      const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
+      lengthExtra = 0;
+      for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
+        const codePoint = char.codePointAt(0) || 0;
+        if (isFullWidth(codePoint)) {
+          widthExtra = FULL_WIDTH_WIDTH;
+        } else if (isWideNotCJKTNotEmoji(codePoint)) {
+          widthExtra = WIDE_WIDTH;
+        } else {
+          widthExtra = REGULAR_WIDTH;
+        }
+        if (width + widthExtra > truncationLimit) {
+          truncationIndex = Math.min(truncationIndex, Math.max(unmatchedStart, indexPrev) + lengthExtra);
+        }
+        if (width + widthExtra > LIMIT) {
+          truncationEnabled = true;
+          break outer;
+        }
+        lengthExtra += char.length;
+        width += widthExtra;
+      }
+      unmatchedStart = unmatchedEnd = 0;
+    }
+    if (index >= length) {
+      break outer;
+    }
+    for (let i = 0, l = PARSE_BLOCKS.length; i < l; i++) {
+      const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i];
+      BLOCK_RE.lastIndex = index;
+      if (BLOCK_RE.test(input)) {
+        lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input.slice(index, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index;
+        widthExtra = lengthExtra * BLOCK_WIDTH;
+        if (width + widthExtra > truncationLimit) {
+          truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / BLOCK_WIDTH));
+        }
+        if (width + widthExtra > LIMIT) {
+          truncationEnabled = true;
+          break outer;
+        }
+        width += widthExtra;
+        unmatchedStart = indexPrev;
+        unmatchedEnd = index;
+        index = indexPrev = BLOCK_RE.lastIndex;
+        continue outer;
+      }
+    }
+    index += 1;
+  }
+  return {
+    width: truncationEnabled ? truncationLimit : width,
+    index: truncationEnabled ? truncationIndex : length,
+    truncated: truncationEnabled,
+    ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
+  };
+};
+var dist_default = getStringTruncatedWidth;
+
+// ../../node_modules/fast-string-width/dist/index.js
+var NO_TRUNCATION2 = {
+  limit: Infinity,
+  ellipsis: "",
+  ellipsisWidth: 0
+};
+var fastStringWidth = (input, options = {}) => {
+  return dist_default(input, NO_TRUNCATION2, options).width;
+};
+var dist_default2 = fastStringWidth;
+
+// ../../node_modules/fast-wrap-ansi/lib/main.js
+var ESC = "\x1B";
+var CSI = "\x9B";
+var END_CODE = 39;
+var ANSI_ESCAPE_BELL = "\x07";
+var ANSI_CSI = "[";
+var ANSI_OSC = "]";
+var ANSI_SGR_TERMINATOR = "m";
+var ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+var GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
+var getClosingCode = (openingCode) => {
+  if (openingCode >= 30 && openingCode <= 37)
+    return 39;
+  if (openingCode >= 90 && openingCode <= 97)
+    return 39;
+  if (openingCode >= 40 && openingCode <= 47)
+    return 49;
+  if (openingCode >= 100 && openingCode <= 107)
+    return 49;
+  if (openingCode === 1 || openingCode === 2)
+    return 22;
+  if (openingCode === 3)
+    return 23;
+  if (openingCode === 4)
+    return 24;
+  if (openingCode === 7)
+    return 27;
+  if (openingCode === 8)
+    return 28;
+  if (openingCode === 9)
+    return 29;
+  if (openingCode === 0)
+    return 0;
+  return void 0;
+};
+var wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+var wrapAnsiHyperlink = (url) => `${ESC}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+var wrapWord = (rows, word, columns) => {
+  const characters = word[Symbol.iterator]();
+  let isInsideEscape = false;
+  let isInsideLinkEscape = false;
+  let lastRow = rows.at(-1);
+  let visible = lastRow === void 0 ? 0 : dist_default2(lastRow);
+  let currentCharacter = characters.next();
+  let nextCharacter = characters.next();
+  let rawCharacterIndex = 0;
+  while (!currentCharacter.done) {
+    const character = currentCharacter.value;
+    const characterLength = dist_default2(character);
+    if (visible + characterLength <= columns) {
+      rows[rows.length - 1] += character;
+    } else {
+      rows.push(character);
+      visible = 0;
+    }
+    if (character === ESC || character === CSI) {
+      isInsideEscape = true;
+      isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
+    }
+    if (isInsideEscape) {
+      if (isInsideLinkEscape) {
+        if (character === ANSI_ESCAPE_BELL) {
+          isInsideEscape = false;
+          isInsideLinkEscape = false;
+        }
+      } else if (character === ANSI_SGR_TERMINATOR) {
+        isInsideEscape = false;
+      }
+    } else {
+      visible += characterLength;
+      if (visible === columns && !nextCharacter.done) {
+        rows.push("");
+        visible = 0;
+      }
+    }
+    currentCharacter = nextCharacter;
+    nextCharacter = characters.next();
+    rawCharacterIndex += character.length;
+  }
+  lastRow = rows.at(-1);
+  if (!visible && lastRow !== void 0 && lastRow.length && rows.length > 1) {
+    rows[rows.length - 2] += rows.pop();
+  }
+};
+var stringVisibleTrimSpacesRight = (string) => {
+  const words = string.split(" ");
+  let last = words.length;
+  while (last) {
+    if (dist_default2(words[last - 1])) {
+      break;
+    }
+    last--;
+  }
+  if (last === words.length) {
+    return string;
+  }
+  return words.slice(0, last).join(" ") + words.slice(last).join("");
+};
+var exec = (string, columns, options = {}) => {
+  if (options.trim !== false && string.trim() === "") {
+    return "";
+  }
+  let returnValue = "";
+  let escapeCode;
+  let escapeUrl;
+  const words = string.split(" ");
+  let rows = [""];
+  let rowLength = 0;
+  for (let index = 0; index < words.length; index++) {
+    const word = words[index];
+    if (options.trim !== false) {
+      const row = rows.at(-1) ?? "";
+      const trimmed = row.trimStart();
+      if (row.length !== trimmed.length) {
+        rows[rows.length - 1] = trimmed;
+        rowLength = dist_default2(trimmed);
+      }
+    }
+    if (index !== 0) {
+      if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+        rows.push("");
+        rowLength = 0;
+      }
+      if (rowLength || options.trim === false) {
+        rows[rows.length - 1] += " ";
+        rowLength++;
+      }
+    }
+    const wordLength = dist_default2(word);
+    if (options.hard && wordLength > columns) {
+      const remainingColumns = columns - rowLength;
+      const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns);
+      const breaksStartingNextLine = Math.floor((wordLength - 1) / columns);
+      if (breaksStartingNextLine < breaksStartingThisLine) {
+        rows.push("");
+      }
+      wrapWord(rows, word, columns);
+      rowLength = dist_default2(rows.at(-1) ?? "");
+      continue;
+    }
+    if (rowLength + wordLength > columns && rowLength && wordLength) {
+      if (options.wordWrap === false && rowLength < columns) {
+        wrapWord(rows, word, columns);
+        rowLength = dist_default2(rows.at(-1) ?? "");
+        continue;
+      }
+      rows.push("");
+      rowLength = 0;
+    }
+    if (rowLength + wordLength > columns && options.wordWrap === false) {
+      wrapWord(rows, word, columns);
+      rowLength = dist_default2(rows.at(-1) ?? "");
+      continue;
+    }
+    rows[rows.length - 1] += word;
+    rowLength += wordLength;
+  }
+  if (options.trim !== false) {
+    rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+  }
+  const preString = rows.join("\n");
+  let inSurrogate = false;
+  for (let i = 0; i < preString.length; i++) {
+    const character = preString[i];
+    returnValue += character;
+    if (!inSurrogate) {
+      inSurrogate = character >= "\uD800" && character <= "\uDBFF";
+      if (inSurrogate) {
+        continue;
+      }
+    } else {
+      inSurrogate = false;
+    }
+    if (character === ESC || character === CSI) {
+      GROUP_REGEX.lastIndex = i + 1;
+      const groupsResult = GROUP_REGEX.exec(preString);
+      const groups = groupsResult?.groups;
+      if (groups?.code !== void 0) {
+        const code = Number.parseFloat(groups.code);
+        escapeCode = code === END_CODE ? void 0 : code;
+      } else if (groups?.uri !== void 0) {
+        escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
+      }
+    }
+    if (preString[i + 1] === "\n") {
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      const closingCode = escapeCode ? getClosingCode(escapeCode) : void 0;
+      if (escapeCode && closingCode) {
+        returnValue += wrapAnsiCode(closingCode);
+      }
+    } else if (character === "\n") {
+      if (escapeCode && getClosingCode(escapeCode)) {
+        returnValue += wrapAnsiCode(escapeCode);
+      }
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink(escapeUrl);
+      }
+    }
+  }
+  return returnValue;
+};
+var CRLF_OR_LF = /\r?\n/;
+function wrapAnsi(string, columns, options) {
+  return String(string).normalize().split(CRLF_OR_LF).map((line) => exec(line, columns, options)).join("\n");
+}
+
+// ../../node_modules/@clack/core/dist/index.mjs
+var import_sisteransi = __toESM(require_src(), 1);
+import { ReadStream as O } from "node:tty";
+function f(r, t, s) {
+  if (!s.some((o) => !o.disabled)) return r;
+  const e2 = r + t, i = Math.max(s.length - 1, 0), n = e2 < 0 ? i : e2 > i ? 0 : e2;
+  return s[n].disabled ? f(n, t < 0 ? -1 : 1, s) : n;
+}
+var G = ["up", "down", "left", "right", "space", "enter", "cancel"];
+var K = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+var h = { actions: new Set(G), aliases: /* @__PURE__ */ new Map([["k", "up"], ["j", "down"], ["h", "left"], ["l", "right"], ["", "cancel"], ["escape", "cancel"]]), messages: { cancel: "Canceled", error: "Something went wrong" }, withGuide: true, date: { monthNames: [...K], messages: { required: "Please enter a valid date", invalidMonth: "There are only 12 months in a year", invalidDay: (r, t) => `There are only ${r} days in ${t}`, afterMin: (r) => `Date must be on or after ${r.toISOString().slice(0, 10)}`, beforeMax: (r) => `Date must be on or before ${r.toISOString().slice(0, 10)}` } } };
+function C(r, t) {
+  if (typeof r == "string") return h.aliases.get(r) === t;
+  for (const s of r) if (s !== void 0 && C(s, t)) return true;
+  return false;
+}
+function z(r, t) {
+  if (r === t) return;
+  const s = r.split(`
+`), e2 = t.split(`
+`), i = Math.max(s.length, e2.length), n = [];
+  for (let o = 0; o < i; o++) s[o] !== e2[o] && n.push(o);
+  return { lines: n, numLinesBefore: s.length, numLinesAfter: e2.length, numLines: i };
+}
+var Y = globalThis.process.platform.startsWith("win");
+var k = /* @__PURE__ */ Symbol("clack:cancel");
+function q(r) {
+  return r === k;
+}
+function w(r, t) {
+  const s = r;
+  s.isTTY && s.setRawMode(t);
+}
+function R({ input: r = D, output: t = x, overwrite: s = true, hideCursor: e2 = true } = {}) {
+  const i = b.createInterface({ input: r, output: t, prompt: "", tabSize: 1 });
+  b.emitKeypressEvents(r, i), r instanceof O && r.isTTY && r.setRawMode(true);
+  const n = (o, { name: u, sequence: a }) => {
+    const l = String(o);
+    if (C([l, u, a], "cancel")) {
+      e2 && t.write(import_sisteransi.cursor.show), process.exit(0);
+      return;
+    }
+    if (!s) return;
+    const c = u === "return" ? 0 : -1, y = u === "return" ? -1 : 0;
+    b.moveCursor(t, c, y, () => {
+      b.clearLine(t, 1, () => {
+        r.once("keypress", n);
+      });
+    });
+  };
+  return e2 && t.write(import_sisteransi.cursor.hide), r.once("keypress", n), () => {
+    r.off("keypress", n), e2 && t.write(import_sisteransi.cursor.show), r instanceof O && r.isTTY && !Y && r.setRawMode(false), i.terminal = false, i.close();
+  };
+}
+var A = (r) => "columns" in r && typeof r.columns == "number" ? r.columns : 80;
+var L = (r) => "rows" in r && typeof r.rows == "number" ? r.rows : 20;
+function W(r, t, s, e2 = s, i = s, n) {
+  const o = A(r ?? x);
+  return wrapAnsi(t, o - s.length, { hard: true, trim: false }).split(`
+`).map((u, a, l) => {
+    const c = n ? n(u, a) : u;
+    return a === 0 ? `${e2}${c}` : a === l.length - 1 ? `${i}${c}` : `${s}${c}`;
+  }).join(`
+`);
+}
+var m = class {
+  input;
+  output;
+  _abortSignal;
+  rl;
+  opts;
+  _render;
+  _track = false;
+  _prevFrame = "";
+  _subscribers = /* @__PURE__ */ new Map();
+  _cursor = 0;
+  state = "initial";
+  error = "";
+  value;
+  userInput = "";
+  constructor(t, s = true) {
+    const { input: e2 = D, output: i = x, render: n, signal: o, ...u } = t;
+    this.opts = u, this.onKeypress = this.onKeypress.bind(this), this.close = this.close.bind(this), this.render = this.render.bind(this), this._render = n.bind(this), this._track = s, this._abortSignal = o, this.input = e2, this.output = i;
+  }
+  unsubscribe() {
+    this._subscribers.clear();
+  }
+  setSubscriber(t, s) {
+    const e2 = this._subscribers.get(t) ?? [];
+    e2.push(s), this._subscribers.set(t, e2);
+  }
+  on(t, s) {
+    this.setSubscriber(t, { cb: s });
+  }
+  once(t, s) {
+    this.setSubscriber(t, { cb: s, once: true });
+  }
+  emit(t, ...s) {
+    const e2 = this._subscribers.get(t) ?? [], i = [];
+    for (const n of e2) n.cb(...s), n.once && i.push(() => e2.splice(e2.indexOf(n), 1));
+    for (const n of i) n();
+  }
+  prompt() {
+    return new Promise((t) => {
+      if (this._abortSignal) {
+        if (this._abortSignal.aborted) return this.state = "cancel", this.close(), t(k);
+        this._abortSignal.addEventListener("abort", () => {
+          this.state = "cancel", this.close();
+        }, { once: true });
+      }
+      this.rl = E.createInterface({ input: this.input, tabSize: 2, prompt: "", escapeCodeTimeout: 50, terminal: true }), this.rl.prompt(), this.opts.initialUserInput !== void 0 && this._setUserInput(this.opts.initialUserInput, true), this.input.on("keypress", this.onKeypress), w(this.input, true), this.output.on("resize", this.render), this.render(), this.once("submit", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), w(this.input, false), t(this.value);
+      }), this.once("cancel", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), w(this.input, false), t(k);
+      });
+    });
+  }
+  _isActionKey(t, s) {
+    return t === "	";
+  }
+  _shouldSubmit(t, s) {
+    return true;
+  }
+  _setValue(t) {
+    this.value = t, this.emit("value", this.value);
+  }
+  _setUserInput(t, s) {
+    this.userInput = t ?? "", this.emit("userInput", this.userInput), s && this._track && this.rl && (this.rl.write(this.userInput), this._cursor = this.rl.cursor);
+  }
+  _clearUserInput() {
+    this.rl?.write(null, { ctrl: true, name: "u" }), this._setUserInput("");
+  }
+  onKeypress(t, s) {
+    if (this._track && s.name !== "return" && (s.name && this._isActionKey(t, s) && this.rl?.write(null, { ctrl: true, name: "h" }), this._cursor = this.rl?.cursor ?? 0, this._setUserInput(this.rl?.line)), this.state === "error" && (this.state = "active"), s?.name && (!this._track && h.aliases.has(s.name) && this.emit("cursor", h.aliases.get(s.name)), h.actions.has(s.name) && this.emit("cursor", s.name)), t && (t.toLowerCase() === "y" || t.toLowerCase() === "n") && this.emit("confirm", t.toLowerCase() === "y"), this.emit("key", t?.toLowerCase(), s), s?.name === "return" && this._shouldSubmit(t, s)) {
+      if (this.opts.validate) {
+        const e2 = this.opts.validate(this.value);
+        e2 && (this.error = e2 instanceof Error ? e2.message : e2, this.state = "error", this.rl?.write(this.userInput));
+      }
+      this.state !== "error" && (this.state = "submit");
+    }
+    C([t, s?.name, s?.sequence], "cancel") && (this.state = "cancel"), (this.state === "submit" || this.state === "cancel") && this.emit("finalize"), this.render(), (this.state === "submit" || this.state === "cancel") && this.close();
+  }
+  close() {
+    this.input.unpipe(), this.input.removeListener("keypress", this.onKeypress), this.output.write(`
+`), w(this.input, false), this.rl?.close(), this.rl = void 0, this.emit(`${this.state}`, this.value), this.unsubscribe();
+  }
+  restoreCursor() {
+    const t = wrapAnsi(this._prevFrame, process.stdout.columns, { hard: true, trim: false }).split(`
+`).length - 1;
+    this.output.write(import_sisteransi.cursor.move(-999, t * -1));
+  }
+  render() {
+    const t = wrapAnsi(this._render(this) ?? "", process.stdout.columns, { hard: true, trim: false });
+    if (t !== this._prevFrame) {
+      if (this.state === "initial") this.output.write(import_sisteransi.cursor.hide);
+      else {
+        const s = z(this._prevFrame, t), e2 = L(this.output);
+        if (this.restoreCursor(), s) {
+          const i = Math.max(0, s.numLinesAfter - e2), n = Math.max(0, s.numLinesBefore - e2);
+          let o = s.lines.find((u) => u >= i);
+          if (o === void 0) {
+            this._prevFrame = t;
+            return;
+          }
+          if (s.lines.length === 1) {
+            this.output.write(import_sisteransi.cursor.move(0, o - n)), this.output.write(import_sisteransi.erase.lines(1));
+            const u = t.split(`
+`);
+            this.output.write(u[o]), this._prevFrame = t, this.output.write(import_sisteransi.cursor.move(0, u.length - o - 1));
+            return;
+          } else if (s.lines.length > 1) {
+            if (i < n) o = i;
+            else {
+              const a = o - n;
+              a > 0 && this.output.write(import_sisteransi.cursor.move(0, a));
+            }
+            this.output.write(import_sisteransi.erase.down());
+            const u = t.split(`
+`).slice(o);
+            this.output.write(u.join(`
+`)), this._prevFrame = t;
+            return;
+          }
+        }
+        this.output.write(import_sisteransi.erase.down());
+      }
+      this.output.write(t), this.state === "initial" && (this.state = "active"), this._prevFrame = t;
+    }
+  }
+};
+var X = class extends m {
+  get cursor() {
+    return this.value ? 0 : 1;
+  }
+  get _value() {
+    return this.cursor === 0;
+  }
+  constructor(t) {
+    super(t, false), this.value = !!t.initialValue, this.on("userInput", () => {
+      this.value = this._value;
+    }), this.on("confirm", (s) => {
+      this.output.write(import_sisteransi.cursor.move(0, -1)), this.value = s, this.state = "submit", this.close();
+    }), this.on("cursor", () => {
+      this.value = !this.value;
+    });
+  }
+};
+var ut = class extends m {
+  options;
+  cursor = 0;
+  get _selectedValue() {
+    return this.options[this.cursor];
+  }
+  changeValue() {
+    this.value = this._selectedValue.value;
+  }
+  constructor(t) {
+    super(t, false), this.options = t.options;
+    const s = this.options.findIndex(({ value: i }) => i === t.initialValue), e2 = s === -1 ? 0 : s;
+    this.cursor = this.options[e2].disabled ? f(e2, 1, this.options) : e2, this.changeValue(), this.on("cursor", (i) => {
+      switch (i) {
+        case "left":
+        case "up":
+          this.cursor = f(this.cursor, -1, this.options);
+          break;
+        case "down":
+        case "right":
+          this.cursor = f(this.cursor, 1, this.options);
+          break;
+      }
+      this.changeValue();
+    });
+  }
+};
+var ht = class extends m {
+  get userInputWithCursor() {
+    if (this.state === "submit") return this.userInput;
+    const t = this.userInput;
+    if (this.cursor >= t.length) return `${this.userInput}\u2588`;
+    const s = t.slice(0, this.cursor), [e2, ...i] = t.slice(this.cursor);
+    return `${s}${v("inverse", e2)}${i.join("")}`;
+  }
+  get cursor() {
+    return this._cursor;
+  }
+  constructor(t) {
+    super({ ...t, initialUserInput: t.initialUserInput ?? t.initialValue }), this.on("userInput", (s) => {
+      this._setValue(s);
+    }), this.on("finalize", () => {
+      this.value || (this.value = t.defaultValue), this.value === void 0 && (this.value = "");
+    });
+  }
+};
+
+// ../../node_modules/@clack/prompts/dist/index.mjs
+import { styleText as e, stripVTControlCharacters as nt2 } from "node:util";
+import V2 from "node:process";
+var import_sisteransi2 = __toESM(require_src(), 1);
+import { existsSync as Qt, lstatSync as wt, readdirSync as Zt } from "node:fs";
+import { dirname as bt, join as te } from "node:path";
+function ee() {
+  return V2.platform !== "win32" ? V2.env.TERM !== "linux" : !!V2.env.CI || !!V2.env.WT_SESSION || !!V2.env.TERMINUS_SUBLIME || V2.env.ConEmuTask === "{cmd::Cmder}" || V2.env.TERM_PROGRAM === "Terminus-Sublime" || V2.env.TERM_PROGRAM === "vscode" || V2.env.TERM === "xterm-256color" || V2.env.TERM === "alacritty" || V2.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+var tt = ee();
+var ot2 = () => process.env.CI === "true";
+var w2 = (t, i) => tt ? t : i;
+var Tt = w2("\u25C6", "*");
+var at2 = w2("\u25A0", "x");
+var ut2 = w2("\u25B2", "x");
+var H = w2("\u25C7", "o");
+var lt = w2("\u250C", "T");
+var $ = w2("\u2502", "|");
+var x2 = w2("\u2514", "\u2014");
+var _t = w2("\u2510", "T");
+var xt = w2("\u2518", "\u2014");
+var z2 = w2("\u25CF", ">");
+var U = w2("\u25CB", " ");
+var et2 = w2("\u25FB", "[\u2022]");
+var K2 = w2("\u25FC", "[+]");
+var Y2 = w2("\u25FB", "[ ]");
+var Et = w2("\u25AA", "\u2022");
+var st = w2("\u2500", "-");
+var ct = w2("\u256E", "+");
+var Gt = w2("\u251C", "+");
+var $t = w2("\u256F", "+");
+var dt = w2("\u2570", "+");
+var Mt = w2("\u256D", "+");
+var ht2 = w2("\u25CF", "\u2022");
+var pt = w2("\u25C6", "*");
+var mt = w2("\u25B2", "!");
+var gt = w2("\u25A0", "x");
+var P = (t) => {
+  switch (t) {
+    case "initial":
+    case "active":
+      return e("cyan", Tt);
+    case "cancel":
+      return e("red", at2);
+    case "error":
+      return e("yellow", ut2);
+    case "submit":
+      return e("green", H);
+  }
+};
+var yt = (t) => {
+  switch (t) {
+    case "initial":
+    case "active":
+      return e("cyan", $);
+    case "cancel":
+      return e("red", $);
+    case "error":
+      return e("yellow", $);
+    case "submit":
+      return e("green", $);
+  }
+};
+var Ot = (t, i, s, r, u, n = false) => {
+  let a = i, c = 0;
+  if (n) for (let o = r - 1; o >= s && (a -= t[o].length, c++, !(a <= u)); o--) ;
+  else for (let o = s; o < r && (a -= t[o].length, c++, !(a <= u)); o++) ;
+  return { lineCount: a, removals: c };
+};
+var F = ({ cursor: t, options: i, style: s, output: r = process.stdout, maxItems: u = Number.POSITIVE_INFINITY, columnPadding: n = 0, rowPadding: a = 4 }) => {
+  const c = A(r) - n, o = L(r), l = e("dim", "..."), d = Math.max(o - a, 0), g = Math.max(Math.min(u, d), 5);
+  let p2 = 0;
+  t >= g - 3 && (p2 = Math.max(Math.min(t - g + 3, i.length - g), 0));
+  let f2 = g < i.length && p2 > 0, h2 = g < i.length && p2 + g < i.length;
+  const I = Math.min(p2 + g, i.length), m2 = [];
+  let y = 0;
+  f2 && y++, h2 && y++;
+  const v2 = p2 + (f2 ? 1 : 0), C2 = I - (h2 ? 1 : 0);
+  for (let b2 = v2; b2 < C2; b2++) {
+    const G2 = wrapAnsi(s(i[b2], b2 === t), c, { hard: true, trim: false }).split(`
+`);
+    m2.push(G2), y += G2.length;
+  }
+  if (y > d) {
+    let b2 = 0, G2 = 0, M = y;
+    const N = t - v2;
+    let O2 = d;
+    const j2 = () => Ot(m2, M, 0, N, O2), k2 = () => Ot(m2, M, N + 1, m2.length, O2, true);
+    f2 ? ({ lineCount: M, removals: b2 } = j2(), M > O2 && (h2 || (O2 -= 1), { lineCount: M, removals: G2 } = k2())) : (h2 || (O2 -= 1), { lineCount: M, removals: G2 } = k2(), M > O2 && (O2 -= 1, { lineCount: M, removals: b2 } = j2())), b2 > 0 && (f2 = true, m2.splice(0, b2)), G2 > 0 && (h2 = true, m2.splice(m2.length - G2, G2));
+  }
+  const S = [];
+  f2 && S.push(l);
+  for (const b2 of m2) for (const G2 of b2) S.push(G2);
+  return h2 && S.push(l), S;
+};
+var ue = (t) => {
+  const i = t.active ?? "Yes", s = t.inactive ?? "No";
+  return new X({ active: i, inactive: s, signal: t.signal, input: t.input, output: t.output, initialValue: t.initialValue ?? true, render() {
+    const r = t.withGuide ?? h.withGuide, u = `${P(this.state)}  `, n = r ? `${e("gray", $)}  ` : "", a = W(t.output, t.message, n, u), c = `${r ? `${e("gray", $)}
+` : ""}${a}
+`, o = this.value ? i : s;
+    switch (this.state) {
+      case "submit": {
+        const l = r ? `${e("gray", $)}  ` : "";
+        return `${c}${l}${e("dim", o)}`;
+      }
+      case "cancel": {
+        const l = r ? `${e("gray", $)}  ` : "";
+        return `${c}${l}${e(["strikethrough", "dim"], o)}${r ? `
+${e("gray", $)}` : ""}`;
+      }
+      default: {
+        const l = r ? `${e("cyan", $)}  ` : "", d = r ? e("cyan", x2) : "";
+        return `${c}${l}${this.value ? `${e("green", z2)} ${i}` : `${e("dim", U)} ${e("dim", i)}`}${t.vertical ? r ? `
+${e("cyan", $)}  ` : `
+` : ` ${e("dim", "/")} `}${this.value ? `${e("dim", U)} ${e("dim", s)}` : `${e("green", z2)} ${s}`}
+${d}
+`;
+      }
+    }
+  } }).prompt();
+};
+var R2 = { message: (t = [], { symbol: i = e("gray", $), secondarySymbol: s = e("gray", $), output: r = process.stdout, spacing: u = 1, withGuide: n } = {}) => {
+  const a = [], c = n ?? h.withGuide, o = c ? s : "", l = c ? `${i}  ` : "", d = c ? `${s}  ` : "";
+  for (let p2 = 0; p2 < u; p2++) a.push(o);
+  const g = Array.isArray(t) ? t : t.split(`
+`);
+  if (g.length > 0) {
+    const [p2, ...f2] = g;
+    p2.length > 0 ? a.push(`${l}${p2}`) : a.push(c ? i : "");
+    for (const h2 of f2) h2.length > 0 ? a.push(`${d}${h2}`) : a.push(c ? s : "");
+  }
+  r.write(`${a.join(`
+`)}
+`);
+}, info: (t, i) => {
+  R2.message(t, { ...i, symbol: e("blue", ht2) });
+}, success: (t, i) => {
+  R2.message(t, { ...i, symbol: e("green", pt) });
+}, step: (t, i) => {
+  R2.message(t, { ...i, symbol: e("green", H) });
+}, warn: (t, i) => {
+  R2.message(t, { ...i, symbol: e("yellow", mt) });
+}, warning: (t, i) => {
+  R2.warn(t, i);
+}, error: (t, i) => {
+  R2.message(t, { ...i, symbol: e("red", gt) });
+} };
+var me = (t = "", i) => {
+  const s = i?.output ?? process.stdout, r = i?.withGuide ?? h.withGuide ? `${e("gray", x2)}  ` : "";
+  s.write(`${r}${e("red", t)}
+
+`);
+};
+var ge = (t = "", i) => {
+  const s = i?.output ?? process.stdout, r = i?.withGuide ?? h.withGuide ? `${e("gray", lt)}  ` : "";
+  s.write(`${r}${t}
+`);
+};
+var ye = (t = "", i) => {
+  const s = i?.output ?? process.stdout, r = i?.withGuide ?? h.withGuide ? `${e("gray", $)}
+${e("gray", x2)}  ` : "";
+  s.write(`${r}${t}
+
+`);
+};
+var Te = (t) => e("magenta", t);
+var ft = ({ indicator: t = "dots", onCancel: i, output: s = process.stdout, cancelMessage: r, errorMessage: u, frames: n = tt ? ["\u25D2", "\u25D0", "\u25D3", "\u25D1"] : ["\u2022", "o", "O", "0"], delay: a = tt ? 80 : 120, signal: c, ...o } = {}) => {
+  const l = ot2();
+  let d, g, p2 = false, f2 = false, h2 = "", I, m2 = performance.now();
+  const y = A(s), v2 = o?.styleFrame ?? Te, C2 = (_) => {
+    const A2 = _ > 1 ? u ?? h.messages.error : r ?? h.messages.cancel;
+    f2 = _ === 1, p2 && (W2(A2, _), f2 && typeof i == "function" && i());
+  }, S = () => C2(2), b2 = () => C2(1), G2 = () => {
+    process.on("uncaughtExceptionMonitor", S), process.on("unhandledRejection", S), process.on("SIGINT", b2), process.on("SIGTERM", b2), process.on("exit", C2), c && c.addEventListener("abort", b2);
+  }, M = () => {
+    process.removeListener("uncaughtExceptionMonitor", S), process.removeListener("unhandledRejection", S), process.removeListener("SIGINT", b2), process.removeListener("SIGTERM", b2), process.removeListener("exit", C2), c && c.removeEventListener("abort", b2);
+  }, N = () => {
+    if (I === void 0) return;
+    l && s.write(`
+`);
+    const _ = wrapAnsi(I, y, { hard: true, trim: false }).split(`
+`);
+    _.length > 1 && s.write(import_sisteransi2.cursor.up(_.length - 1)), s.write(import_sisteransi2.cursor.to(0)), s.write(import_sisteransi2.erase.down());
+  }, O2 = (_) => _.replace(/\.+$/, ""), j2 = (_) => {
+    const A2 = (performance.now() - _) / 1e3, L2 = Math.floor(A2 / 60), D2 = Math.floor(A2 % 60);
+    return L2 > 0 ? `[${L2}m ${D2}s]` : `[${D2}s]`;
+  }, k2 = o.withGuide ?? h.withGuide, rt2 = (_ = "") => {
+    p2 = true, d = R({ output: s }), h2 = O2(_), m2 = performance.now(), k2 && s.write(`${e("gray", $)}
+`);
+    let A2 = 0, L2 = 0;
+    G2(), g = setInterval(() => {
+      if (l && h2 === I) return;
+      N(), I = h2;
+      const D2 = v2(n[A2]);
+      let Z;
+      if (l) Z = `${D2}  ${h2}...`;
+      else if (t === "timer") Z = `${D2}  ${h2} ${j2(m2)}`;
+      else {
+        const kt = ".".repeat(Math.floor(L2)).slice(0, 3);
+        Z = `${D2}  ${h2}${kt}`;
+      }
+      const Bt = wrapAnsi(Z, y, { hard: true, trim: false });
+      s.write(Bt), A2 = A2 + 1 < n.length ? A2 + 1 : 0, L2 = L2 < 4 ? L2 + 0.125 : 0;
+    }, a);
+  }, W2 = (_ = "", A2 = 0, L2 = false) => {
+    if (!p2) return;
+    p2 = false, clearInterval(g), N();
+    const D2 = A2 === 0 ? e("green", H) : A2 === 1 ? e("red", at2) : e("red", ut2);
+    h2 = _ ?? h2, L2 || (t === "timer" ? s.write(`${D2}  ${h2} ${j2(m2)}
+`) : s.write(`${D2}  ${h2}
+`)), M(), d();
+  };
+  return { start: rt2, stop: (_ = "") => W2(_, 0), message: (_ = "") => {
+    h2 = O2(_ ?? h2);
+  }, cancel: (_ = "") => W2(_, 1), error: (_ = "") => W2(_, 2), clear: () => W2("", 0, true), get isCancelled() {
+    return f2;
+  } };
+};
+var jt = { light: w2("\u2500", "-"), heavy: w2("\u2501", "="), block: w2("\u2588", "#") };
+var it2 = (t, i) => t.includes(`
+`) ? t.split(`
+`).map((s) => i(s)).join(`
+`) : i(t);
+var xe = (t) => {
+  const i = (s, r) => {
+    const u = s.label ?? String(s.value);
+    switch (r) {
+      case "disabled":
+        return `${e("gray", U)} ${it2(u, (n) => e("gray", n))}${s.hint ? ` ${e("dim", `(${s.hint ?? "disabled"})`)}` : ""}`;
+      case "selected":
+        return `${it2(u, (n) => e("dim", n))}`;
+      case "active":
+        return `${e("green", z2)} ${u}${s.hint ? ` ${e("dim", `(${s.hint})`)}` : ""}`;
+      case "cancelled":
+        return `${it2(u, (n) => e(["strikethrough", "dim"], n))}`;
+      default:
+        return `${e("dim", U)} ${it2(u, (n) => e("dim", n))}`;
+    }
+  };
+  return new ut({ options: t.options, signal: t.signal, input: t.input, output: t.output, initialValue: t.initialValue, render() {
+    const s = t.withGuide ?? h.withGuide, r = `${P(this.state)}  `, u = `${yt(this.state)}  `, n = W(t.output, t.message, u, r), a = `${s ? `${e("gray", $)}
+` : ""}${n}
+`;
+    switch (this.state) {
+      case "submit": {
+        const c = s ? `${e("gray", $)}  ` : "", o = W(t.output, i(this.options[this.cursor], "selected"), c);
+        return `${a}${o}`;
+      }
+      case "cancel": {
+        const c = s ? `${e("gray", $)}  ` : "", o = W(t.output, i(this.options[this.cursor], "cancelled"), c);
+        return `${a}${o}${s ? `
+${e("gray", $)}` : ""}`;
+      }
+      default: {
+        const c = s ? `${e("cyan", $)}  ` : "", o = s ? e("cyan", x2) : "", l = a.split(`
+`).length, d = s ? 2 : 1;
+        return `${a}${c}${F({ output: t.output, cursor: this.cursor, options: this.options, maxItems: t.maxItems, columnPadding: c.length, rowPadding: l + d, style: (g, p2) => i(g, g.disabled ? "disabled" : p2 ? "active" : "inactive") }).join(`
+${c}`)}
+${o}
+`;
+      }
+    }
+  } }).prompt();
+};
+var Nt = `${e("gray", $)}  `;
+var Pe = (t) => new ht({ validate: t.validate, placeholder: t.placeholder, defaultValue: t.defaultValue, initialValue: t.initialValue, output: t.output, signal: t.signal, input: t.input, render() {
+  const i = t?.withGuide ?? h.withGuide, s = `${`${i ? `${e("gray", $)}
+` : ""}${P(this.state)}  `}${t.message}
+`, r = t.placeholder ? e("inverse", t.placeholder[0]) + e("dim", t.placeholder.slice(1)) : e(["inverse", "hidden"], "_"), u = this.userInput ? this.userInputWithCursor : r, n = this.value ?? "";
+  switch (this.state) {
+    case "error": {
+      const a = this.error ? `  ${e("yellow", this.error)}` : "", c = i ? `${e("yellow", $)}  ` : "", o = i ? e("yellow", x2) : "";
+      return `${s.trim()}
+${c}${u}
+${o}${a}
+`;
+    }
+    case "submit": {
+      const a = n ? `  ${e("dim", n)}` : "", c = i ? e("gray", $) : "";
+      return `${s}${c}${a}`;
+    }
+    case "cancel": {
+      const a = n ? `  ${e(["strikethrough", "dim"], n)}` : "", c = i ? e("gray", $) : "";
+      return `${s}${c}${a}${n.trim() ? `
+${c}` : ""}`;
+    }
+    default: {
+      const a = i ? `${e("cyan", $)}  ` : "", c = i ? e("cyan", x2) : "";
+      return `${s}${a}${u}
+${c}
+`;
+    }
+  }
+} }).prompt();
+
+// ../argent-cli/src/link.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+var WILDCARD_HOSTS = /* @__PURE__ */ new Set(["0.0.0.0", "::", "::0", ""]);
+function isLoopback2(host) {
+  return host === "127.0.0.1" || host === "localhost" || host === "::1";
+}
+function validateHost(raw) {
+  const trimmed = raw.trim();
+  if (WILDCARD_HOSTS.has(trimmed)) {
+    throw new StartFlagError(
+      `--host ${trimmed === "" ? '""' : trimmed} is a bind address, not a connect address \u2014 use 127.0.0.1 or the actual reachable host.`
+    );
+  }
+  return trimmed;
+}
+function validateConnectPort(raw) {
+  const port = parsePort(raw);
+  if (port === 0) {
+    throw new StartFlagError(`--port must be 1..65535 for a connect target, got "${raw}"`);
+  }
+  return port;
+}
+function parseLinkFlags(argv) {
+  const flags2 = {
+    host: null,
+    port: null,
+    token: null,
+    url: null,
+    yes: false,
+    noVerify: false,
+    help: false
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const tok = argv[i];
+    const takeValue = (name) => {
+      const v2 = argv[i + 1];
+      if (v2 === void 0) throw new StartFlagError(`${name} requires a value`);
+      i += 1;
+      return v2;
+    };
+    if (tok === "--help" || tok === "-h") {
+      flags2.help = true;
+      continue;
+    }
+    if (tok === "--yes" || tok === "-y") {
+      flags2.yes = true;
+      continue;
+    }
+    if (tok === "--no-verify") {
+      flags2.noVerify = true;
+      continue;
+    }
+    if (tok === "--host") {
+      flags2.host = validateHost(takeValue("--host"));
+      continue;
+    }
+    if (tok.startsWith("--host=")) {
+      flags2.host = validateHost(tok.slice("--host=".length));
+      continue;
+    }
+    if (tok === "--port" || tok === "-p") {
+      flags2.port = validateConnectPort(takeValue("--port"));
+      continue;
+    }
+    if (tok.startsWith("--port=")) {
+      flags2.port = validateConnectPort(tok.slice("--port=".length));
+      continue;
+    }
+    if (tok === "--token") {
+      flags2.token = takeValue("--token");
+      continue;
+    }
+    if (tok.startsWith("--token=")) {
+      flags2.token = tok.slice("--token=".length);
+      continue;
+    }
+    if (!tok.startsWith("-")) {
+      const parsed = parseLinkTarget(tok);
+      if (!parsed) {
+        throw new StartFlagError(
+          `Unrecognized argument "${tok}". Expected an argent://\u2026 pairing string, an http(s):// URL, or flags (see --help).`
+        );
+      }
+      flags2.host = validateHost(parsed.host);
+      flags2.port = validateConnectPort(String(parsed.port));
+      flags2.url = parsed.url;
+      if (parsed.token) flags2.token = parsed.token;
+      continue;
+    }
+    throw new StartFlagError(`Unknown flag: ${tok}`);
+  }
+  return flags2;
+}
+function parseUnlinkFlags(argv) {
+  const flags2 = { yes: false, help: false };
+  for (const tok of argv) {
+    if (tok === "--help" || tok === "-h") {
+      flags2.help = true;
+      continue;
+    }
+    if (tok === "--yes" || tok === "-y") {
+      flags2.yes = true;
+      continue;
+    }
+    throw new StartFlagError(`Unknown flag: ${tok}`);
+  }
+  return flags2;
+}
+function printLinkHelp() {
+  console.log(`Usage: argent link [<target>] [flags]
+
+Route argent client requests (argent tools / run / mcp) to a remote tool-server
+instead of auto-spawning a local one. The target is persisted to ~/.argent/link.json
+and survives shell restarts.
+
+<target> may be:
+  - argent://[<token>@]<host>:<port>   the string \`argent server start\` prints
+  - http(s)://<host>[:<port>][/path]   a full URL \u2014 use this for a reverse proxy
+                                       or tunnel (ngrok, cloudflared, nginx). The
+                                       scheme and any path prefix are preserved;
+                                       requests go to <url>/tools.
+
+The easiest LAN path is to paste the connection string from \`argent server start\`:
+  argent link argent://<token>@10.0.0.42:3001
+For a tunnel, point at its public URL and pass the server's token:
+  argent link https://argent.example.com --token <token>
+
+Resolution order for the tool-server URL:
+  1. ARGENT_TOOLS_URL environment variable (highest precedence)
+  2. ~/.argent/link.json (this command)
+  3. Auto-spawn a local tool-server (default)
+
+Flags:
+  --host <h>        Remote host or IP to connect to. Prompts interactively if
+                    omitted. Wildcards (0.0.0.0, ::) are bind addresses, not
+                    connect targets, and are rejected \u2014 use 127.0.0.1 or the
+                    actual reachable host.
+  --port, -p <n>    Remote port (1..65535). Defaults to 3001. Prompts if omitted.
+  --token <t>       Bearer token for a server that enforces auth. Usually
+                    supplied inside the argent:// string instead.
+  --no-verify       Skip the pre-flight GET /tools health check.
+  --yes, -y         Non-interactive. Requires --host (port defaults to 3001).
+                    Fails if --host is missing.
+  --help, -h        Show this help.
+
+Examples:
+  argent link argent://ab12\u2026c2@10.0.0.42:3001   Pair from a server-start string.
+  argent link https://argent.example.com --token ab12\u2026c2
+                                             Link through an HTTPS tunnel/proxy.
+  argent link                                Interactive prompts for host and port.
+  argent link --host 10.0.0.42 --port 3001   Confirms interactively, then saves.
+  argent link --host 10.0.0.42 --token ab12\u2026c2 --yes
+                                             Non-interactive, authenticated.
+  argent link --host 10.0.0.42 --yes --no-verify
+                                             Saves immediately, no health check.
+
+Security:
+  The token (if any) is stored 0600 and sent as a bearer header. An http:// link
+  has no TLS \u2014 treat any non-loopback http link as trusted-network-only. Prefer
+  an https:// tunnel/proxy when crossing untrusted networks.
+
+Notes:
+  - If ARGENT_TOOLS_URL is also set in your environment, it overrides the link.
+  - To stop using the remote target, run \`argent unlink\`.
+  - \`argent server start/stop/status\` manage the local tool-server lifecycle
+    and are unaffected by linking.
+  - Restart your editor (Claude / Cursor / VS Code) afterwards \u2014 a running
+    \`argent mcp\` process caches the target at startup and won't pick up the
+    new link until it's relaunched.
+`);
+}
+function printUnlinkHelp() {
+  console.log(`Usage: argent unlink [flags]
+
+Remove the persisted remote tool-server link (~/.argent/link.json) and return
+to default local auto-spawn behaviour.
+
+Flags:
+  --yes, -y     Skip the confirmation prompt.
+  --help, -h    Show this help.
+
+Examples:
+  argent unlink         Confirms, then removes the link.
+  argent unlink --yes   Removes without confirmation. Safe in scripts.
+
+Notes:
+  - No-op (exit 0) if no link is currently set.
+  - If ARGENT_TOOLS_URL is also set in your environment, it still takes
+    precedence after unlinking \u2014 unset it manually for fully local behaviour.
+  - This does not stop or start any tool-server process. Use
+    \`argent server stop\` if you also want to terminate a running local server.
+  - Restart your editor afterwards \u2014 a running \`argent mcp\` process won't
+    revert to local auto-spawn until it's relaunched.
+`);
+}
+async function promptHost(existing, initial) {
+  const hostInput = await Pe({
+    message: "Remote host or IP to connect to",
+    placeholder: existing?.host ?? "127.0.0.1",
+    initialValue: initial ?? existing?.host,
+    validate(value) {
+      if (!value || !value.trim()) return "Host cannot be empty.";
+      const trimmed = value.trim();
+      if (WILDCARD_HOSTS.has(trimmed)) {
+        return `${trimmed} is a bind address, not a connect address \u2014 use 127.0.0.1 or the actual reachable host.`;
+      }
+    }
+  });
+  if (q(hostInput)) {
+    me("Link cancelled.");
+    process.exit(0);
+  }
+  return hostInput.trim();
+}
+async function promptPort(existing, initial) {
+  const defaultPort = initial ?? existing?.port ?? 3001;
+  const portInput = await Pe({
+    message: "Remote port",
+    placeholder: String(defaultPort),
+    initialValue: String(defaultPort),
+    validate(value) {
+      if (!value || !value.trim()) return "Port cannot be empty.";
+      try {
+        validateConnectPort(value.trim());
+      } catch (err) {
+        if (err instanceof StartFlagError) return err.message;
+        throw err;
+      }
+    }
+  });
+  if (q(portInput)) {
+    me("Link cancelled.");
+    process.exit(0);
+  }
+  return validateConnectPort(portInput.trim());
+}
+async function preflightHealth(url, token) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 3e3);
+  try {
+    const res = await fetch(`${url}/tools`, {
+      signal: controller.signal,
+      headers: token ? { Authorization: `Bearer ${token}` } : {}
+    });
+    if (!res.ok) {
+      const hint = res.status === 401 ? " \u2014 the server requires a token; pass --token or use the argent:// link from `server start`" : res.status === 403 ? " \u2014 the server refused this host (DNS-rebinding guard); reach it by its bind host or start it with --host" : "";
+      return { ok: false, error: `${res.status} ${res.statusText}${hint}` };
+    }
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function printRestartHint() {
+  console.log(
+    import_picocolors.default.dim("Restart your editor to apply the change to any running `argent mcp` session.")
+  );
+}
+function printSecurityCaveat(host, token, url) {
+  if (isLoopback2(host)) return;
+  const tls = url.startsWith("https://");
+  if (tls) {
+    if (!token) {
+      process.stderr.write(
+        import_picocolors.default.yellow(
+          `WARNING: ${host} is reached over HTTPS but with NO token \u2014 anyone who can reach the URL can drive the server. Pair with a token.
+`
+        )
+      );
+    }
+    return;
+  }
+  if (token) {
+    process.stderr.write(
+      import_picocolors.default.dim(
+        `Note: ${host} is reached over plain HTTP (bearer-token auth, no TLS). Keep this link to a trusted network or VPN, or front it with an https:// tunnel.
+`
+      )
+    );
+    return;
+  }
+  process.stderr.write(
+    import_picocolors.default.yellow(
+      `WARNING: linked target ${host} is non-loopback and has NO token \u2014 tool calls travel over plain HTTP with no auth. Treat this link as trusted-network-only, or pair with a token (start the server without --no-auth).
+`
+    )
+  );
+}
+async function link(argv) {
+  let flags2;
+  try {
+    flags2 = parseLinkFlags(argv);
+  } catch (err) {
+    if (err instanceof StartFlagError) {
+      console.error(`Error: ${err.message}
+`);
+      printLinkHelp();
+      process.exit(2);
+    }
+    throw err;
+  }
+  if (flags2.help) {
+    printLinkHelp();
+    return;
+  }
+  if (flags2.yes && flags2.host === null) {
+    console.error("Error: --yes requires --host (port defaults to 3001).\n");
+    printLinkHelp();
+    process.exit(2);
+  }
+  const existing = await readLinkConfig();
+  let host;
+  if (flags2.host !== null) {
+    host = flags2.host;
+  } else {
+    ge(import_picocolors.default.bgCyan(import_picocolors.default.black(" argent link ")));
+    if (existing) {
+      R2.info(`Current link: ${import_picocolors.default.cyan(existing.url)} (${existing.createdAt})`);
+    }
+    host = await promptHost(existing);
+  }
+  let port;
+  if (flags2.port !== null) {
+    port = flags2.port;
+  } else if (flags2.yes) {
+    port = 3001;
+  } else {
+    port = await promptPort(existing);
+  }
+  const token = flags2.token ?? (existing && existing.host === host && existing.port === port ? existing.token : void 0);
+  let url = flags2.url ?? formatUrl(host, port);
+  if (!flags2.yes && existing) {
+    if (existing.url === url) {
+      R2.info(`Already linked to ${import_picocolors.default.cyan(url)}.`);
+      ye("No changes.");
+      return;
+    }
+    const overwrite = await ue({
+      message: `Replace existing link ${import_picocolors.default.dim(existing.url)} with ${import_picocolors.default.cyan(url)}?`,
+      initialValue: true
+    });
+    if (q(overwrite) || !overwrite) {
+      me("Link cancelled.");
+      process.exit(0);
+    }
+  }
+  if (!flags2.noVerify) {
+    while (true) {
+      const spinnerActive = !flags2.yes;
+      let spinner = null;
+      if (spinnerActive) {
+        spinner = ft();
+        spinner.start(`Verifying tool-server at ${url}...`);
+      }
+      const result = await preflightHealth(url, token);
+      if (result.ok) {
+        if (spinner) spinner.stop(import_picocolors.default.green("Tool-server reachable."));
+        break;
+      }
+      if (spinner) spinner.stop(import_picocolors.default.red("Verification failed."));
+      const detail = result.error ? ` (${result.error})` : "";
+      if (flags2.yes) {
+        console.error(
+          `Error: pre-flight GET ${url}/tools failed${detail}. Make sure the remote tool-server is running, or pass --no-verify to skip.`
+        );
+        process.exit(1);
+      }
+      R2.error(`pre-flight GET ${url}/tools failed${detail}.`);
+      const action = await xe({
+        message: "How would you like to proceed?",
+        options: [
+          { value: "retry", label: "Retry verification" },
+          { value: "modify", label: "Modify host and port, then retry" },
+          { value: "skip", label: "Skip verification and save anyway" },
+          { value: "cancel", label: "Cancel" }
+        ],
+        initialValue: "retry"
+      });
+      if (q(action) || action === "cancel") {
+        me("Link cancelled.");
+        process.exit(0);
+      }
+      if (action === "skip") break;
+      if (action === "modify") {
+        host = await promptHost(existing, host);
+        port = await promptPort(existing, port);
+        url = formatUrl(host, port);
+      }
+    }
+  }
+  const cfg = {
+    url,
+    host,
+    port,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...token ? { token } : {}
+  };
+  await writeLinkConfig(cfg);
+  if (existing && existing.url !== url) {
+    console.log(`${import_picocolors.default.green("\u2713")} Link updated: ${import_picocolors.default.dim(existing.url)} \u2192 ${import_picocolors.default.cyan(url)}`);
+  } else {
+    console.log(`${import_picocolors.default.green("\u2713")} Linked: ${import_picocolors.default.cyan(url)}`);
+  }
+  if (token) console.log(import_picocolors.default.dim("  auth: token stored in ~/.argent/link.json (0600)"));
+  printSecurityCaveat(host, token, url);
+  if (process.env.ARGENT_TOOLS_URL) {
+    console.log(
+      import_picocolors.default.yellow(
+        `Note: ARGENT_TOOLS_URL=${process.env.ARGENT_TOOLS_URL} is set in your environment and takes precedence over the link.`
+      )
+    );
+  }
+  printRestartHint();
+}
+async function unlink3(argv) {
+  let flags2;
+  try {
+    flags2 = parseUnlinkFlags(argv);
+  } catch (err) {
+    if (err instanceof StartFlagError) {
+      console.error(`Error: ${err.message}
+`);
+      printUnlinkHelp();
+      process.exit(2);
+    }
+    throw err;
+  }
+  if (flags2.help) {
+    printUnlinkHelp();
+    return;
+  }
+  const existing = await readLinkConfig();
+  if (!existing) {
+    console.log("Not currently linked \u2014 already using local tool-server.");
+    return;
+  }
+  if (!flags2.yes) {
+    const confirmed = await ue({
+      message: `Remove link to ${import_picocolors.default.cyan(existing.url)}?`,
+      initialValue: true
+    });
+    if (q(confirmed) || !confirmed) {
+      me("Unlink cancelled.");
+      process.exit(0);
+    }
+  }
+  await clearLinkConfig();
+  console.log(`${import_picocolors.default.green("\u2713")} Unlinked from ${import_picocolors.default.dim(existing.url)}.`);
+  if (process.env.ARGENT_TOOLS_URL) {
+    console.log(
+      import_picocolors.default.yellow(
+        `The env var ARGENT_TOOLS_URL is also set in your shell (=${process.env.ARGENT_TOOLS_URL}) and takes precedence \u2014 unset it manually if you want fully local behaviour.`
+      )
+    );
+  }
+  printRestartHint();
+}
+
+// ../argent-cli/src/flags.ts
+import * as fs4 from "node:fs";
+import * as path5 from "node:path";
+import { homedir as homedir4 } from "node:os";
+var FLAG_REGISTRY = [
+  // {
+  //   name: "example-flag",
+  //   description: "One-line summary shown by `argent flags`.",
+  // },
+];
+function getFlagDefinition(name, registry = FLAG_REGISTRY) {
+  return registry.find((def) => def.name === name);
+}
+var PROJECT_MARKERS = [".argent", ".git", "package.json"];
+function resolveProjectRoot(startDir) {
+  const initial = path5.resolve(startDir);
+  let current = initial;
+  while (true) {
+    for (const marker of PROJECT_MARKERS) {
+      if (fs4.existsSync(path5.join(current, marker))) return current;
+    }
+    const parent = path5.dirname(current);
+    if (parent === current) return initial;
+    current = parent;
+  }
+}
+function getFlagsPath(scope, options = {}) {
+  const home = options.homeDir ?? homedir4();
+  if (scope === "global") {
+    return path5.join(home, ".argent", "flags.json");
+  }
+  const cwd = options.cwd ?? process.cwd();
+  return path5.join(resolveProjectRoot(cwd), ".argent", "flags.json");
+}
+function readFlagsFile(filePath) {
+  let raw;
+  try {
+    raw = fs4.readFileSync(filePath, "utf8");
+  } catch {
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return {};
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+  const flags2 = parsed.flags;
+  if (!flags2 || typeof flags2 !== "object" || Array.isArray(flags2)) return {};
+  const out = {};
+  for (const [k2, v2] of Object.entries(flags2)) {
+    if (typeof v2 === "boolean") out[k2] = v2;
+  }
+  return out;
+}
+function writeFlagsFile(filePath, flags2) {
+  if (Object.keys(flags2).length === 0) {
+    if (fs4.existsSync(filePath)) fs4.rmSync(filePath, { force: true });
+    const parent = path5.dirname(filePath);
+    try {
+      if (fs4.existsSync(parent) && fs4.readdirSync(parent).length === 0) {
+        fs4.rmdirSync(parent);
+      }
+    } catch {
+    }
+    return;
+  }
+  fs4.mkdirSync(path5.dirname(filePath), { recursive: true });
+  const tmp = `${filePath}.${process.pid}.tmp`;
+  fs4.writeFileSync(tmp, JSON.stringify({ flags: flags2 }, null, 2) + "\n");
+  fs4.renameSync(tmp, filePath);
+}
+function readFlags(scope, options = {}) {
+  return readFlagsFile(getFlagsPath(scope, options));
+}
+function setFlag(name, value, scope, options = {}) {
+  const filePath = getFlagsPath(scope, options);
+  const current = readFlagsFile(filePath);
+  current[name] = value;
+  writeFlagsFile(filePath, current);
+}
+function unsetFlag(name, scope, options = {}) {
+  const filePath = getFlagsPath(scope, options);
+  const current = readFlagsFile(filePath);
+  if (!Object.hasOwn(current, name)) return false;
+  delete current[name];
+  writeFlagsFile(filePath, current);
+  return true;
+}
+function isFlagEnabled(name, options = {}) {
+  const projectFlags = readFlags("project", options);
+  if (Object.hasOwn(projectFlags, name)) return projectFlags[name];
+  const globalFlags = readFlags("global", options);
+  if (Object.hasOwn(globalFlags, name)) return globalFlags[name];
+  return false;
+}
+var FLAG_NAME_RE = /^[a-zA-Z][a-zA-Z0-9._-]*$/;
+function parseToggleArgs(argv, command) {
+  let name = null;
+  let scope = "global";
+  let positionalOnly = false;
+  for (let i = 0; i < argv.length; i++) {
+    const tok = argv[i];
+    if (positionalOnly) {
+      if (name !== null) throw new Error(`Unexpected extra argument: "${tok}"`);
+      name = tok;
+      continue;
+    }
+    if (tok === "--") {
+      positionalOnly = true;
+      continue;
+    }
+    if (tok === "--scope") {
+      const v2 = argv[i + 1];
+      if (v2 === void 0) throw new Error("--scope requires a value (project|global)");
+      scope = parseScope(v2);
+      i += 1;
+      continue;
+    }
+    if (tok.startsWith("--scope=")) {
+      scope = parseScope(tok.slice("--scope=".length));
+      continue;
+    }
+    if (tok.startsWith("--")) {
+      throw new Error(`Unknown flag: ${tok}`);
+    }
+    if (name !== null) {
+      throw new Error(`Unexpected extra argument: "${tok}"`);
+    }
+    name = tok;
+  }
+  if (name === null) {
+    throw new Error(`Usage: argent ${command} <flag-name> [--scope project|global]`);
+  }
+  if (!FLAG_NAME_RE.test(name)) {
+    throw new Error(
+      `Invalid flag name "${name}". Must start with a letter and contain only letters, digits, ".", "_", or "-".`
+    );
+  }
+  return { name, scope };
+}
+function parseScope(raw) {
+  if (raw === "global" || raw === "project") return raw;
+  throw new Error(`--scope must be "project" or "global", got "${raw}"`);
+}
+function printToggleHelp(command) {
+  const summary = command === "enable" ? "Enable a predefined feature flag (see `argent flags`) at the chosen scope." : "Remove a feature flag entry at the chosen scope. Falls back to the global value if set; otherwise the flag is treated as off.";
+  console.log(`Usage: argent ${command} <flag-name> [--scope project|global]
+
+${summary}
+
+Storage:
+  ~/.argent/flags.json                 (global, default)
+  <project-root>/.argent/flags.json    (project, with --scope project)
+
+Options:
+  --scope <global|project>   Where to write (default: global)
+  --help, -h                 Show this help
+`);
+}
+function runToggle(argv, command, registry) {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    printToggleHelp(command);
+    return;
+  }
+  let parsed;
+  try {
+    parsed = parseToggleArgs(argv, command);
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(2);
+  }
+  if (command === "enable" && getFlagDefinition(parsed.name, registry) === void 0) {
+    console.error(
+      `Error: Unknown feature flag "${parsed.name}". Run \`argent flags\` to see available flags.`
+    );
+    process.exit(2);
+  }
+  const filePath = getFlagsPath(parsed.scope);
+  try {
+    if (command === "enable") {
+      setFlag(parsed.name, true, parsed.scope);
+    } else {
+      unsetFlag(parsed.name, parsed.scope);
+    }
+  } catch (err) {
+    console.error(`Failed to ${command} flag: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  if (command === "enable") {
+    console.log(`Enabled flag "${parsed.name}" (${parsed.scope}). Stored at ${filePath}.`);
+  } else {
+    console.log(`Disabled flag "${parsed.name}" (${parsed.scope}).`);
+  }
+}
+function enable(argv, registry = FLAG_REGISTRY) {
+  runToggle(argv, "enable", registry);
+}
+function disable(argv, registry = FLAG_REGISTRY) {
+  runToggle(argv, "disable", registry);
+}
+function flags(argv, registry = FLAG_REGISTRY) {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(`Usage: argent flags [--json]
+
+List the available feature flags and their current state. Flags are
+predefined; project-scoped values override global ones.
+
+Options:
+  --json   Print machine-readable JSON
+`);
+    return;
+  }
+  const json = argv.includes("--json");
+  const projectFlags = readFlags("project");
+  const globalFlags = readFlags("global");
+  const effective = {};
+  for (const [k2, v2] of Object.entries(globalFlags)) effective[k2] = { value: v2, scope: "global" };
+  for (const [k2, v2] of Object.entries(projectFlags)) effective[k2] = { value: v2, scope: "project" };
+  const registryView = registry.map((def) => {
+    const eff = Object.hasOwn(effective, def.name) ? effective[def.name] : void 0;
+    return {
+      name: def.name,
+      description: def.description,
+      enabled: eff?.value ?? false,
+      scope: eff?.scope ?? null
+    };
+  });
+  const known = new Set(registry.map((def) => def.name));
+  const unrecognized = Object.keys(effective).filter((name) => !known.has(name)).sort().map((name) => ({ name, enabled: effective[name].value, scope: effective[name].scope }));
+  if (json) {
+    console.log(
+      JSON.stringify(
+        {
+          flags: registryView,
+          unrecognized,
+          global: globalFlags,
+          project: projectFlags,
+          effective,
+          paths: {
+            global: getFlagsPath("global"),
+            project: getFlagsPath("project")
+          }
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (registryView.length === 0) {
+    console.log("No feature flags are defined.");
+  } else {
+    console.log("Feature flags (project overrides global):");
+    const maxName = registryView.reduce((m2, f2) => Math.max(m2, f2.name.length), 0);
+    for (const f2 of registryView) {
+      const stateLabel = f2.enabled ? "enabled" : "disabled";
+      const scopeLabel = f2.scope ? ` (${f2.scope})` : "";
+      console.log(`  ${f2.name.padEnd(maxName, " ")}  ${stateLabel.padEnd(8)}${scopeLabel}`);
+      console.log(`  ${" ".repeat(maxName)}  ${f2.description}`);
+    }
+  }
+  if (unrecognized.length > 0) {
+    console.log("\nStored but no longer recognized (safe to `argent disable`):");
+    const maxName = unrecognized.reduce((m2, f2) => Math.max(m2, f2.name.length), 0);
+    for (const f2 of unrecognized) {
+      const stateLabel = f2.enabled ? "enabled" : "disabled";
+      console.log(`  ${f2.name.padEnd(maxName, " ")}  ${stateLabel.padEnd(8)} (${f2.scope})`);
+    }
+  }
+  console.log(`
+  Global:  ${getFlagsPath("global")}`);
+  console.log(`  Project: ${getFlagsPath("project")}`);
+}
 export {
+  FLAG_REGISTRY,
+  disable,
+  enable,
+  flags,
+  getFlagDefinition,
+  isFlagEnabled,
+  link,
   run,
   server,
-  tools
+  tools,
+  unlink3 as unlink
 };