@swmansion/argent 0.5.2 → 0.6.0-next.1

package/dist/cli-cmds.mjs

@@ -0,0 +1,729 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+
+// ../argent-cli/src/run.ts
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+
+// ../argent-tools-client/src/launcher.ts
+import * as net from "node:net";
+import * as fs from "node:fs";
+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";
+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 {
+    ...baseEnv,
+    PORT: String(port),
+    ARGENT_SIMULATOR_SERVER_DIR: paths.simulatorServerDir,
+    ARGENT_NATIVE_DEVTOOLS_DIR: paths.nativeDevtoolsDir
+  };
+}
+function findFreePort() {
+  return new Promise((resolve2, reject) => {
+    const srv = net.createServer();
+    srv.listen(0, "127.0.0.1", () => {
+      const addr = srv.address();
+      if (!addr || typeof addr !== "object") {
+        srv.close(() => reject(new Error("Could not bind to find free port")));
+        return;
+      }
+      const port = addr.port;
+      srv.close((err) => {
+        if (err) reject(err);
+        else resolve2(port);
+      });
+    });
+    srv.on("error", reject);
+  });
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isHealthy(port) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 2e3);
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/tools`, {
+      signal: controller.signal
+    });
+    return res.ok;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function spawnToolsServer(paths, port) {
+  return new Promise((resolve2, reject) => {
+    let logFd;
+    try {
+      fs.mkdirSync(STATE_DIR, { recursive: true });
+      logFd = fs.openSync(LOG_FILE, "a");
+    } catch {
+      logFd = fs.openSync("/dev/null", "w");
+    }
+    const child = spawn("node", [paths.bundlePath, "start"], {
+      detached: true,
+      stdio: ["ignore", "pipe", logFd],
+      env: buildToolsServerEnv(paths, port)
+    });
+    child.unref();
+    const pid = child.pid;
+    if (!pid) {
+      reject(new Error("Failed to get PID of spawned tools server"));
+      return;
+    }
+    let settled = false;
+    const settle = (fn) => {
+      if (settled) return;
+      settled = true;
+      fn();
+    };
+    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+)/);
+      if (match) {
+        const actualPort = parseInt(match[1], 10);
+        rl.close();
+        child.stdout?.resume();
+        settle(() => resolve2({ port: actualPort, pid }));
+      }
+    });
+    child.on("error", (err) => {
+      rl.close();
+      settle(() => reject(err));
+    });
+    child.on("exit", (code) => {
+      rl.close();
+      settle(() => reject(new Error(`tool-server exited with code ${code} before becoming ready`)));
+    });
+    const timer = setTimeout(() => {
+      rl.close();
+      settle(() => reject(new Error("Timed out waiting for tools server to become ready")));
+    }, 15e3);
+    rl.on("close", () => clearTimeout(timer));
+  });
+}
+async function readState() {
+  try {
+    const raw = await readFile(STATE_FILE, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeState(state) {
+  await mkdir(STATE_DIR, { recursive: true });
+  await writeFile(STATE_FILE, JSON.stringify(state, null, 2) + "\n", "utf8");
+}
+async function clearState() {
+  try {
+    await unlink(STATE_FILE);
+  } catch {
+  }
+}
+async function killToolServer() {
+  const state = await readState();
+  if (!state) return;
+  try {
+    process.kill(state.pid, "SIGTERM");
+  } catch {
+  }
+  await clearState();
+}
+async function ensureToolsServer(paths) {
+  const state = await readState();
+  if (state) {
+    const alive = isProcessAlive(state.pid);
+    if (alive) {
+      const healthy = await isHealthy(state.port);
+      if (healthy) {
+        return `http://127.0.0.1:${state.port}`;
+      }
+    }
+    await clearState();
+  }
+  const port = await findFreePort();
+  const { port: actualPort, pid } = await spawnToolsServer(paths, port);
+  await writeState({
+    port: actualPort,
+    pid,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    bundlePath: paths.bundlePath
+  });
+  return `http://127.0.0.1:${actualPort}`;
+}
+
+// ../argent-tools-client/src/tools-client.ts
+function createToolsClient(options = {}) {
+  let cached = null;
+  async function baseUrl() {
+    if (process.env.ARGENT_TOOLS_URL) return process.env.ARGENT_TOOLS_URL;
+    if (cached) return cached;
+    if (!options.paths) {
+      throw new Error(
+        "tools-client: cannot spawn tool-server without `paths`; set ARGENT_TOOLS_URL or pass paths to createToolsClient()"
+      );
+    }
+    cached = await ensureToolsServer(options.paths);
+    return cached;
+  }
+  async function fetchTools() {
+    const url = await baseUrl();
+    const res = await fetch(`${url}/tools`);
+    if (!res.ok) throw new Error(`GET /tools failed: ${res.status} ${res.statusText}`);
+    const json = await res.json();
+    return json.tools;
+  }
+  async function fetchTool(name) {
+    const tools2 = await fetchTools();
+    return tools2.find((t) => t.name === name) ?? null;
+  }
+  async function callTool(name, args) {
+    const url = await baseUrl();
+    const res = await fetch(`${url}/tools/${encodeURIComponent(name)}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(args ?? {})
+    });
+    const json = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      throw new Error(json.error ?? json.message ?? `${res.status} ${res.statusText}`);
+    }
+    return { data: json.data, note: json.note };
+  }
+  return { fetchTools, fetchTool, callTool, baseUrl };
+}
+
+// ../argent-cli/src/flag-parser.ts
+var FlagParseException = class extends Error {
+};
+function isScalarType(type) {
+  return type === "string" || type === "number" || type === "integer" || type === "boolean";
+}
+function coerceScalar(raw, type, field) {
+  if (type === "number") {
+    const n = Number(raw);
+    if (Number.isNaN(n)) throw new FlagParseException(`--${field} expected a number, got "${raw}"`);
+    return n;
+  }
+  if (type === "integer") {
+    const n = Number(raw);
+    if (!Number.isInteger(n))
+      throw new FlagParseException(`--${field} expected an integer, got "${raw}"`);
+    return n;
+  }
+  if (type === "boolean") {
+    if (raw === "true" || raw === "1") return true;
+    if (raw === "false" || raw === "0") return false;
+    throw new FlagParseException(`--${field} expected true/false, got "${raw}"`);
+  }
+  return raw;
+}
+function parseJsonOrThrow(raw, label) {
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
+    throw new FlagParseException(
+      `${label} could not be parsed as JSON: ${err instanceof Error ? err.message : err}`
+    );
+  }
+}
+function parseFlags(argv, schema) {
+  const properties = schema?.properties ?? {};
+  const args = {};
+  const positional = [];
+  let helpRequested = false;
+  let rawArgs = null;
+  const seenArrayFields = /* @__PURE__ */ new Set();
+  function takeNext(i, flag) {
+    if (i + 1 >= argv.length) {
+      throw new FlagParseException(`--${flag} requires a value`);
+    }
+    return { value: argv[i + 1], nextIndex: i + 1 };
+  }
+  for (let i = 0; i < argv.length; i++) {
+    const tok = argv[i];
+    if (tok === "--help" || tok === "-h") {
+      helpRequested = true;
+      continue;
+    }
+    if (tok === "--") {
+      for (let j = i + 1; j < argv.length; j++) positional.push(argv[j]);
+      break;
+    }
+    if (!tok.startsWith("--")) {
+      positional.push(tok);
+      continue;
+    }
+    const eq = tok.indexOf("=");
+    let flag;
+    let inlineValue;
+    if (eq >= 0) {
+      flag = tok.slice(2, eq);
+      inlineValue = tok.slice(eq + 1);
+    } else {
+      flag = tok.slice(2);
+    }
+    if (flag === "args") {
+      const { value: value2, nextIndex: nextIndex2 } = inlineValue !== void 0 ? { value: inlineValue, nextIndex: i } : takeNext(i, "args");
+      rawArgs = value2;
+      i = nextIndex2;
+      continue;
+    }
+    if (flag.endsWith("-json")) {
+      const fieldName = flag.slice(0, -"-json".length);
+      const { value: value2, nextIndex: nextIndex2 } = inlineValue !== void 0 ? { value: inlineValue, nextIndex: i } : takeNext(i, flag);
+      args[fieldName] = parseJsonOrThrow(value2, `--${flag}`);
+      i = nextIndex2;
+      continue;
+    }
+    if (flag.startsWith("no-")) {
+      const fieldName = flag.slice(3);
+      const propSchema2 = properties[fieldName];
+      if (propSchema2?.type === "boolean") {
+        if (inlineValue !== void 0) {
+          throw new FlagParseException(`--no-${fieldName} does not take a value`);
+        }
+        args[fieldName] = false;
+        continue;
+      }
+    }
+    const propSchema = properties[flag];
+    if (propSchema?.type === "boolean") {
+      if (inlineValue !== void 0) {
+        args[flag] = coerceScalar(inlineValue, "boolean", flag);
+      } else {
+        args[flag] = true;
+      }
+      continue;
+    }
+    if (propSchema?.type === "array") {
+      const itemType = propSchema.items?.type;
+      if (!isScalarType(itemType)) {
+        throw new FlagParseException(
+          `--${flag} is an array of objects; pass it as --${flag}-json '<json>' or --args '<json>'`
+        );
+      }
+      const { value: value2, nextIndex: nextIndex2 } = inlineValue !== void 0 ? { value: inlineValue, nextIndex: i } : takeNext(i, flag);
+      const coerced = coerceScalar(value2, itemType, flag);
+      if (!seenArrayFields.has(flag)) {
+        args[flag] = [coerced];
+        seenArrayFields.add(flag);
+      } else {
+        args[flag].push(coerced);
+      }
+      if (inlineValue === void 0) i = nextIndex2;
+      continue;
+    }
+    if (propSchema?.type === "object") {
+      throw new FlagParseException(
+        `--${flag} is an object; pass it as --${flag}-json '<json>' or --args '<json>'`
+      );
+    }
+    const { value, nextIndex } = inlineValue !== void 0 ? { value: inlineValue, nextIndex: i } : takeNext(i, flag);
+    args[flag] = coerceScalar(value, propSchema?.type, flag);
+    if (inlineValue === void 0) i = nextIndex;
+  }
+  return { args, positional, helpRequested, rawArgs };
+}
+function formatSchemaUsage(schema) {
+  if (!schema || !schema.properties) return "  (no parameters)";
+  const required = new Set(schema.required ?? []);
+  const lines = [];
+  const entries = Object.entries(schema.properties);
+  if (entries.length === 0) return "  (no parameters)";
+  let maxFlagLen = 0;
+  for (const [name, prop] of entries) {
+    const display = renderFlagName(name, prop);
+    if (display.length > maxFlagLen) maxFlagLen = display.length;
+  }
+  for (const [name, prop] of entries) {
+    const flag = renderFlagName(name, prop).padEnd(maxFlagLen, " ");
+    const typeLabel = renderType(prop);
+    const req = required.has(name) ? " (required)" : "";
+    const desc = prop.description ? `  ${prop.description}` : "";
+    lines.push(`  ${flag}  ${typeLabel}${req}${desc}`);
+  }
+  return lines.join("\n");
+}
+function renderFlagName(name, prop) {
+  if (prop.type === "object" || prop.type === "array" && !isScalarType(prop.items?.type)) {
+    return `--${name}-json <json>`;
+  }
+  if (prop.type === "boolean") return `--${name}`;
+  return `--${name} <value>`;
+}
+function renderType(prop) {
+  if (prop.enum && Array.isArray(prop.enum)) {
+    return `enum: ${prop.enum.map((v) => JSON.stringify(v)).join(" | ")}`;
+  }
+  if (prop.type === "array") {
+    const item = prop.items?.type ?? "any";
+    const suffix = isScalarType(prop.items?.type) ? " (repeatable)" : "";
+    return `array<${item}>${suffix}`;
+  }
+  return prop.type ?? "any";
+}
+
+// ../argent-cli/src/run.ts
+function splitOptions(argv) {
+  let json = false;
+  let outPath = null;
+  const rest = [];
+  for (let i = 0; i < argv.length; i++) {
+    const tok = argv[i];
+    if (tok === "--json") {
+      json = true;
+      continue;
+    }
+    if (tok === "--out") {
+      const v = argv[i + 1];
+      if (!v) throw new FlagParseException("--out requires a path");
+      outPath = v;
+      i += 1;
+      continue;
+    }
+    if (tok.startsWith("--out=")) {
+      outPath = tok.slice("--out=".length);
+      continue;
+    }
+    rest.push(tok);
+  }
+  return { json, outPath, argvForFlags: rest };
+}
+async function readStdin() {
+  return new Promise((resolve2, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve2(data));
+    process.stdin.on("error", reject);
+  });
+}
+function printToolHelp(meta) {
+  const description = meta.description?.trim() ?? "";
+  console.log(`argent run ${meta.name} [flags]`);
+  if (description) console.log(`
+${description}
+`);
+  console.log("Flags:");
+  console.log(formatSchemaUsage(meta.inputSchema));
+  console.log("\nGlobal flags:");
+  console.log("  --args <json>          Pass the entire payload as JSON (overrides flags)");
+  console.log("  --args -               Read the entire payload as JSON from stdin");
+  console.log("  --<field>-json <json>  Pass a single field as JSON (objects/nested arrays)");
+  console.log("  --json                 Print the raw JSON result");
+  console.log("  --out <path>           For image results, save to <path> instead of fetching URL");
+  console.log("  --help, -h             Show this help");
+}
+async function fetchImageToFile(result, outPath) {
+  const url = result.url;
+  if (!url) {
+    throw new Error("Tool result did not include a `url`; cannot save image");
+  }
+  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.writeFileSync(outPath, buf);
+}
+function renderResult(result, outputHint, json) {
+  if (json) return JSON.stringify(result, null, 2);
+  if (outputHint === "image" && result && typeof result === "object" && "path" in result && typeof result.path === "string") {
+    const r = result;
+    return `Saved screenshot: ${r.path}`;
+  }
+  if (typeof result === "string") return result;
+  return JSON.stringify(result, null, 2);
+}
+async function run(argv, options) {
+  const { fetchTool, callTool } = createToolsClient({ paths: options.paths });
+  const [toolName, ...rest] = argv;
+  if (!toolName || toolName === "--help" || toolName === "-h") {
+    console.log(`Usage: argent run <tool> [flags]
+
+Invoke a tool exposed by the argent tool-server. Run \`argent tools\` to list
+available tools, or \`argent tools describe <name>\` to see one tool's flags.
+
+Examples:
+  argent run list-simulators
+  argent run gesture-tap --udid <UDID> --x 0.5 --y 0.5
+  argent run screenshot --udid <UDID> --out ./screen.png
+  argent run run-sequence --udid <UDID> --steps-json '[{"tool":"button","args":{"button":"home"}}]'
+  argent run gesture-tap --args '{"udid":"<UDID>","x":0.5,"y":0.5}'
+`);
+    return;
+  }
+  const { json, outPath, argvForFlags } = splitOptions(rest);
+  const meta = await fetchTool(toolName);
+  if (!meta) {
+    console.error(`Tool "${toolName}" not found. Run \`argent tools\` to list available tools.`);
+    process.exit(1);
+  }
+  let parsed;
+  try {
+    parsed = parseFlags(argvForFlags, meta.inputSchema);
+  } catch (err) {
+    if (err instanceof FlagParseException) {
+      console.error(`Error: ${err.message}
+`);
+      printToolHelp(meta);
+      process.exit(2);
+    }
+    throw err;
+  }
+  if (parsed.helpRequested) {
+    printToolHelp(meta);
+    return;
+  }
+  let payload = {};
+  if (parsed.rawArgs !== null) {
+    let rawJson = parsed.rawArgs;
+    if (rawJson === "-") {
+      rawJson = await readStdin();
+    }
+    try {
+      const parsedRaw = JSON.parse(rawJson);
+      if (parsedRaw === null || typeof parsedRaw !== "object" || Array.isArray(parsedRaw)) {
+        console.error("--args must be a JSON object");
+        process.exit(2);
+      }
+      payload = parsedRaw;
+    } catch (err) {
+      console.error(`--args is not valid JSON: ${err instanceof Error ? err.message : err}`);
+      process.exit(2);
+    }
+  }
+  for (const [k, v] of Object.entries(parsed.args)) {
+    payload[k] = v;
+  }
+  let result;
+  let note;
+  try {
+    const resp = await callTool(toolName, payload);
+    result = resp.data;
+    note = resp.note;
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+  if (outPath && meta.outputHint === "image" && result && typeof result === "object") {
+    try {
+      await fetchImageToFile(result, outPath);
+    } catch (err) {
+      console.error(`Failed to save image: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  }
+  if (note) console.error(note);
+  console.log(renderResult(result, meta.outputHint, json));
+  if (outPath && meta.outputHint === "image" && !json) {
+    console.log(`Wrote: ${outPath}`);
+  }
+}
+
+// ../argent-cli/src/tools.ts
+function summarize(description, max = 80) {
+  if (!description) return "";
+  const firstLine = description.split("\n", 1)[0].trim();
+  if (firstLine.length <= max) return firstLine;
+  return firstLine.slice(0, max - 1).trimEnd() + "\u2026";
+}
+async function tools(argv, options) {
+  const { fetchTool, fetchTools } = createToolsClient({ paths: options.paths });
+  async function listTools(json2) {
+    const list = await fetchTools();
+    if (json2) {
+      console.log(JSON.stringify(list, null, 2));
+      return;
+    }
+    if (list.length === 0) {
+      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);
+    for (const t of sorted) {
+      const summary = summarize(t.description);
+      console.log(`  ${t.name.padEnd(maxName, " ")}  ${summary}`);
+    }
+    console.log(`
+${sorted.length} tools. Run \`argent tools describe <name>\` for details.`);
+  }
+  async function describeTool(name, json2) {
+    const meta = await fetchTool(name);
+    if (!meta) {
+      console.error(`Tool "${name}" not found. Run \`argent tools\` to list available tools.`);
+      process.exit(1);
+    }
+    if (json2) {
+      console.log(JSON.stringify(meta, null, 2));
+      return;
+    }
+    console.log(`Tool: ${meta.name}
+`);
+    if (meta.description) console.log(`${meta.description.trim()}
+`);
+    console.log("Flags:");
+    console.log(formatSchemaUsage(meta.inputSchema));
+    if (meta.outputHint) console.log(`
+Output hint: ${meta.outputHint}`);
+  }
+  const json = argv.includes("--json");
+  const positional = argv.filter((a) => !a.startsWith("--"));
+  const sub = positional[0];
+  if (!sub) {
+    await listTools(json);
+    return;
+  }
+  if (sub === "describe") {
+    const name = positional[1];
+    if (!name) {
+      console.error("Usage: argent tools describe <tool-name>");
+      process.exit(1);
+    }
+    await describeTool(name, json);
+    return;
+  }
+  if (sub === "--help" || sub === "-h") {
+    console.log(`Usage:
+  argent tools                       List available tools
+  argent tools describe <name>       Show one tool's flags and description
+
+Options:
+  --json                             Print machine-readable JSON
+`);
+    return;
+  }
+  console.error(`Unknown subcommand: tools ${sub}`);
+  process.exit(1);
+}
+
+// ../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 { 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");
+function readState2() {
+  try {
+    return JSON.parse(fs3.readFileSync(STATE_FILE2, "utf8"));
+  } catch {
+    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) {
+    if (json) {
+      console.log(JSON.stringify({ running: false }, null, 2));
+    } else {
+      console.log("tool-server: not running (no state file)");
+    }
+    return;
+  }
+  const alive = isProcessAlive2(state.pid);
+  const healthy = alive ? await isHealthy2(state.port) : false;
+  if (json) {
+    console.log(JSON.stringify({ running: alive && healthy, ...state, alive, healthy }, null, 2));
+    return;
+  }
+  console.log(`tool-server:`);
+  console.log(`  url:        http://127.0.0.1:${state.port}`);
+  console.log(`  pid:        ${state.pid}`);
+  console.log(`  startedAt:  ${state.startedAt}`);
+  console.log(`  process:    ${alive ? "alive" : "dead"}`);
+  console.log(`  health:     ${healthy ? "ok" : "unreachable"}`);
+  if (!alive || !healthy) {
+    console.log(`
+State file is stale; next \`argent\` invocation will respawn the server.`);
+  }
+}
+async function stopCmd() {
+  const state = readState2();
+  if (!state) {
+    console.log("tool-server: not running");
+    return;
+  }
+  await killToolServer();
+  console.log(`tool-server stopped (pid ${state.pid}).`);
+}
+function logsCmd(follow) {
+  if (!fs3.existsSync(LOG_FILE2)) {
+    console.log(`No log file at ${LOG_FILE2}`);
+    return;
+  }
+  if (!follow) {
+    process.stdout.write(fs3.readFileSync(LOG_FILE2, "utf8"));
+    return;
+  }
+  const child = spawn2("tail", ["-f", LOG_FILE2], { stdio: "inherit" });
+  child.on("exit", (code) => process.exit(code ?? 0));
+}
+async function server(argv) {
+  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 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
+`);
+    return;
+  }
+  switch (sub) {
+    case "status":
+      await statusCmd(json);
+      return;
+    case "stop":
+      await stopCmd();
+      return;
+    case "logs":
+      logsCmd(follow);
+      return;
+    default:
+      console.error(`Unknown subcommand: server ${sub}`);
+      process.exit(1);
+  }
+}
+export {
+  run,
+  server,
+  tools
+};