@happyvertical/smrt-app-cli 0.30.0

package/dist/index.js

@@ -0,0 +1,1024 @@
+import { r as requestJson, g as getServerUrl, a as getStoredToken, s as saveAuth, l as loadCliConfig, c as clearStoredToken } from "./config-Bgq_EQoJ.js";
+import { b, d, e } from "./config-Bgq_EQoJ.js";
+import { spawn, spawnSync } from "node:child_process";
+async function fetchResourceList(context, options = {}) {
+  try {
+    return await requestJson(
+      context,
+      options.path ?? "/api/_resources",
+      { method: "GET" },
+      {
+        fetch: options.fetch,
+        requireAuth: options.requireAuth,
+        loadedConfig: options.loadedConfig
+      }
+    );
+  } catch (error) {
+    if (error instanceof Error && /401|unauthor/i.test(error.message)) {
+      throw new Error(
+        `Not authenticated to ${context.envPrefix.toLowerCase()}. Run \`${context.envPrefix.toLowerCase()} auth login\` first.`
+      );
+    }
+    throw error;
+  }
+}
+function findResourceBySlug(response, slug) {
+  return response.resources.find((r) => r.slug === slug);
+}
+function findCommand(resource, commandName) {
+  return resource.commands.find((c) => c.commandName === commandName);
+}
+async function invokeCommand(options) {
+  const { context, resource, command, parsed, fetch: fetchImpl } = options;
+  const url = await buildUrl(context, resource, command, parsed, options.id);
+  const headers = new Headers();
+  const token = await getStoredToken(context);
+  if (token) headers.set("authorization", `Bearer ${token}`);
+  let body;
+  if (command.httpMethod !== "GET" && command.httpMethod !== "DELETE") {
+    if (Object.keys(parsed.body).length > 0 || parsed.fromPositional) {
+      headers.set("content-type", "application/json");
+      body = JSON.stringify(parsed.body);
+    }
+  }
+  const impl = fetchImpl ?? fetch;
+  return impl(url, {
+    method: command.httpMethod,
+    headers,
+    body
+  });
+}
+async function buildUrl(context, resource, command, parsed, id) {
+  const serverUrl = await getServerUrl(context);
+  const segments = ["api"];
+  for (const piece of splitPath(resource.apiPath)) {
+    segments.push(encodeURIComponent(piece));
+  }
+  if (command.scope === "item") {
+    if (!id) {
+      throw new Error(
+        `Command \`${resource.slug} ${command.commandName}\` requires an id positional argument.`
+      );
+    }
+    segments.push(encodeURIComponent(id));
+  }
+  for (const seg of command.pathSegments) {
+    for (const piece of splitPath(seg)) {
+      segments.push(encodeURIComponent(piece));
+    }
+  }
+  const base = `${serverUrl}/${segments.join("/")}`;
+  if (command.httpMethod === "GET" && Object.keys(parsed.query).length > 0) {
+    const params = new URLSearchParams();
+    for (const [k, v] of Object.entries(parsed.query)) {
+      if (Array.isArray(v)) {
+        for (const x of v) params.append(k, x);
+      } else {
+        params.set(k, v);
+      }
+    }
+    return `${base}?${params.toString()}`;
+  }
+  return base;
+}
+function splitPath(s) {
+  if (typeof s !== "string") return [];
+  return s.split("/").filter((p) => p.length > 0);
+}
+const JSON_BUFFER_LIMIT = 10 * 1024 * 1024;
+async function renderResponse(response, options = {}) {
+  try {
+    return await renderResponseUnchecked(response, options);
+  } catch (err) {
+    if (err instanceof BrokenPipeError) {
+      return { exitCode: 0 };
+    }
+    throw err;
+  }
+}
+async function renderResponseUnchecked(response, options = {}) {
+  const stdout = options.stdout ?? process.stdout;
+  const stderr = options.stderr ?? process.stderr;
+  const isTty = options.stdoutIsTty ?? Boolean(stdout.isTTY);
+  const ct = (response.headers.get("content-type") ?? "").toLowerCase();
+  const cl = Number(response.headers.get("content-length") ?? "");
+  const isJson = ct.startsWith("application/json") || /\+json(\s|;|$)/.test(ct);
+  const isText = ct.startsWith("text/");
+  if (response.status === 204) {
+    return { exitCode: 0 };
+  }
+  if (response.status >= 400) {
+    if (isJson) {
+      const result = await readUntilLimitOrStream(
+        response,
+        JSON_BUFFER_LIMIT,
+        stderr
+      );
+      if (result.overflowed) {
+        stderr.write(
+          "\n[smrt-app-cli] error response exceeded 10MB cap; streamed raw\n"
+        );
+      } else if (result.text) {
+        const pretty = safePrettyJson(result.text) ?? result.text;
+        stderr.write(`${pretty}
+`);
+      }
+      return { exitCode: response.status >= 500 ? 2 : 1 };
+    }
+    if (isText) {
+      await pipeBody(response, stderr);
+      return { exitCode: response.status >= 500 ? 2 : 1 };
+    }
+    stderr.write(
+      `error: ${response.status} ${response.statusText || "HTTP error"}
+`
+    );
+    return { exitCode: response.status >= 500 ? 2 : 1 };
+  }
+  if (isJson) {
+    if (cl && cl > JSON_BUFFER_LIMIT) {
+      stderr.write(
+        `[smrt-app-cli] response too large to pretty-print (${cl} bytes); streaming raw JSON
+`
+      );
+      await pipeBody(response, stdout);
+      return { exitCode: 0 };
+    }
+    const result = await readUntilLimitOrStream(
+      response,
+      JSON_BUFFER_LIMIT,
+      stdout
+    );
+    if (result.overflowed) {
+      stderr.write(
+        "[smrt-app-cli] response exceeded 10MB cap; streamed raw JSON\n"
+      );
+      return { exitCode: 0 };
+    }
+    if (!result.text) return { exitCode: 0 };
+    const pretty = safePrettyJson(result.text) ?? result.text;
+    stdout.write(`${pretty}
+`);
+    return { exitCode: 0 };
+  }
+  if (isText) {
+    await pipeBody(response, stdout);
+    return { exitCode: 0 };
+  }
+  if (isTty) {
+    const size = cl ? ` (${cl} bytes)` : "";
+    stderr.write(
+      `[smrt-app-cli] binary response${size}; redirect to a file to capture: <cli> ... > out.bin
+`
+    );
+    return { exitCode: 1 };
+  }
+  await pipeBody(response, stdout);
+  return { exitCode: 0 };
+}
+async function readUntilLimitOrStream(response, limit, out) {
+  if (!response.body) return { text: "", overflowed: false };
+  const writeStream = out ?? process.stdout;
+  const reader = response.body.getReader();
+  const chunks = [];
+  let size = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (!value) continue;
+    size += value.byteLength;
+    if (size > limit) {
+      for (const c of chunks) await writeChunk(writeStream, c);
+      await writeChunk(writeStream, value);
+      while (true) {
+        const next = await reader.read();
+        if (next.done) break;
+        if (next.value) await writeChunk(writeStream, next.value);
+      }
+      return { text: "", overflowed: true };
+    }
+    chunks.push(value);
+  }
+  return {
+    text: new TextDecoder().decode(
+      Buffer.concat(chunks.map((c) => Buffer.from(c)))
+    ),
+    overflowed: false
+  };
+}
+class BrokenPipeError extends Error {
+  constructor(cause) {
+    super("Output stream closed");
+    this.name = "BrokenPipeError";
+    if (cause !== void 0) this.cause = cause;
+  }
+}
+async function writeChunk(out, chunk) {
+  const stream = out;
+  let ok;
+  try {
+    ok = stream.write(Buffer.from(chunk));
+  } catch (err) {
+    throw new BrokenPipeError(err);
+  }
+  if (ok) return;
+  await new Promise((resolve, reject) => {
+    const onDrain = () => {
+      stream.off("error", onError);
+      resolve();
+    };
+    const onError = (err) => {
+      stream.off("drain", onDrain);
+      reject(new BrokenPipeError(err));
+    };
+    stream.once("drain", onDrain);
+    stream.once("error", onError);
+  });
+}
+async function pipeBody(response, out) {
+  if (!response.body) return;
+  const reader = response.body.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      await writeChunk(out, value);
+    }
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+}
+function safePrettyJson(text) {
+  if (!text) return void 0;
+  try {
+    return JSON.stringify(JSON.parse(text), null, 2);
+  } catch {
+    return void 0;
+  }
+}
+function classifySchema(schema) {
+  if (!schema || Object.keys(schema).length === 0) return { kind: "missing" };
+  if (schema.type !== "object") {
+    return { kind: "unsupported", reason: "schema root is not an object" };
+  }
+  if (schema.oneOf || schema.anyOf || schema.allOf || schema.$ref) {
+    return { kind: "unsupported", reason: "oneOf/anyOf/allOf/$ref" };
+  }
+  const props = schema.properties ?? {};
+  for (const [name, prop] of Object.entries(props)) {
+    const status = classifyProperty(prop);
+    if (status.kind === "unsupported") {
+      return {
+        kind: "unsupported",
+        reason: `${name}: ${status.reason}`
+      };
+    }
+  }
+  return { kind: "ok" };
+}
+function classifyProperty(prop) {
+  const t = normaliseType(prop);
+  if (!t) return { kind: "unsupported", reason: "no type" };
+  if (prop.oneOf || prop.anyOf || prop.allOf || prop.$ref) {
+    return { kind: "unsupported", reason: "oneOf/anyOf/allOf/$ref" };
+  }
+  if (t.primary === "object") {
+    return { kind: "unsupported", reason: "nested object" };
+  }
+  if (t.primary === "array") {
+    const items = prop.items;
+    const itemsType = items?.type;
+    if (itemsType !== "string" && itemsType !== "integer" && itemsType !== "number") {
+      return { kind: "unsupported", reason: "array of non-primitives" };
+    }
+  }
+  return { kind: "ok" };
+}
+function normaliseType(prop) {
+  const raw = prop.type;
+  if (typeof raw === "string") {
+    return {
+      primary: raw,
+      nullable: Boolean(prop.nullable)
+    };
+  }
+  if (Array.isArray(raw)) {
+    const nullable = raw.includes("null");
+    const nonNull = raw.find((t) => t !== "null");
+    if (!nonNull) return void 0;
+    return { primary: nonNull, nullable };
+  }
+  return void 0;
+}
+function buildFlagParser(schema, options = {}) {
+  const status = options.positionalOnly ? { kind: "unsupported", reason: "forced positional" } : classifySchema(schema);
+  if (status.kind !== "ok") {
+    return { status, parse: makePositionalParser() };
+  }
+  return {
+    status,
+    parse: makeRichParser(schema)
+  };
+}
+function makePositionalParser() {
+  return (argv, httpMethod) => {
+    const positional = argv.find((a) => !a.startsWith("-"));
+    if (!positional) {
+      return { body: {}, query: {}, fromPositional: true };
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(positional);
+    } catch (error) {
+      throw new Error(
+        `Could not parse positional JSON argument: ${error.message}`
+      );
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("Positional JSON argument must be an object.");
+    }
+    if (httpMethod === "GET") {
+      return {
+        body: {},
+        query: objectToQuery(parsed),
+        fromPositional: true
+      };
+    }
+    return { body: parsed, query: {}, fromPositional: true };
+  };
+}
+function makeRichParser(schema) {
+  const props = schema.properties ?? {};
+  const required = new Set(schema.required ?? [] ?? []);
+  const additionalProperties = schema.additionalProperties !== false;
+  return (argv, httpMethod) => {
+    const out = {};
+    let positionalJson;
+    for (let i = 0; i < argv.length; i++) {
+      const arg = argv[i];
+      if (!arg.startsWith("-")) {
+        if (positionalJson) {
+          throw new Error(`Unexpected extra positional argument: ${arg}`);
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(arg);
+        } catch {
+          throw new Error(
+            `Unknown positional argument (not valid JSON): ${arg}`
+          );
+        }
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+          throw new Error("Positional JSON argument must be an object.");
+        }
+        positionalJson = parsed;
+        continue;
+      }
+      if (arg === "--") break;
+      if (arg.startsWith("--no-")) {
+        const flagName = arg.slice("--no-".length);
+        const prop2 = props[flagName];
+        if (!prop2) {
+          if (additionalProperties) {
+            out[flagName] = false;
+            continue;
+          }
+          throw new Error(`Unknown flag: ${arg}`);
+        }
+        const t2 = normaliseType(prop2);
+        if (t2?.primary !== "boolean") {
+          throw new Error(`--no-${flagName} requires a boolean flag.`);
+        }
+        out[flagName] = false;
+        continue;
+      }
+      let key;
+      let value;
+      const eqIdx = arg.indexOf("=");
+      if (eqIdx >= 0) {
+        key = arg.slice(2, eqIdx);
+        value = arg.slice(eqIdx + 1);
+      } else {
+        key = arg.slice(2);
+        const prop2 = props[key];
+        const t2 = prop2 ? normaliseType(prop2) : void 0;
+        if (t2?.primary === "boolean") {
+          const next2 = argv[i + 1];
+          if (next2 === "true" || next2 === "false") {
+            out[key] = next2 === "true";
+            i += 1;
+            continue;
+          }
+          out[key] = true;
+          continue;
+        }
+        const next = argv[i + 1];
+        if (next === void 0 || next.startsWith("-")) {
+          throw new Error(`Flag --${key} requires a value.`);
+        }
+        value = next;
+        i += 1;
+      }
+      const prop = props[key];
+      if (!prop) {
+        if (!additionalProperties) {
+          throw new Error(`Unknown flag: --${key}`);
+        }
+        appendValue(out, key, value);
+        continue;
+      }
+      const t = normaliseType(prop);
+      if (!t) throw new Error(`Unknown flag: --${key}`);
+      if (t.nullable && value === "null") {
+        out[key] = null;
+        continue;
+      }
+      switch (t.primary) {
+        case "string": {
+          const allowed = prop.enum;
+          if (allowed && !allowed.includes(value)) {
+            throw new Error(
+              `--${key}: expected one of ${allowed.join(", ")}; got ${JSON.stringify(value)}.`
+            );
+          }
+          out[key] = value;
+          break;
+        }
+        case "integer": {
+          const n = Number(value);
+          if (!Number.isInteger(n)) {
+            throw new Error(
+              `--${key}: expected integer; got ${JSON.stringify(value)}.`
+            );
+          }
+          out[key] = n;
+          break;
+        }
+        case "number": {
+          const n = Number(value);
+          if (Number.isNaN(n)) {
+            throw new Error(
+              `--${key}: expected number; got ${JSON.stringify(value)}.`
+            );
+          }
+          out[key] = n;
+          break;
+        }
+        case "boolean": {
+          if (value === "true" || value === "false") {
+            out[key] = value === "true";
+          } else {
+            throw new Error(
+              `--${key}: boolean accepts true/false; got ${JSON.stringify(value)}.`
+            );
+          }
+          break;
+        }
+        case "array": {
+          const items = prop.items;
+          const itemsType = items?.type;
+          const parts = value.includes(",") ? value.split(",") : [value];
+          const arr = Array.isArray(out[key]) ? out[key] : [];
+          for (const part of parts) {
+            arr.push(coerce(part, itemsType));
+          }
+          out[key] = arr;
+          break;
+        }
+        default:
+          throw new Error(`--${key}: unsupported schema type ${t.primary}.`);
+      }
+    }
+    if (positionalJson) {
+      for (const [k, v] of Object.entries(positionalJson)) {
+        if (out[k] === void 0) out[k] = v;
+      }
+    }
+    for (const [name, prop] of Object.entries(props)) {
+      if (out[name] !== void 0) continue;
+      if (prop.default !== void 0) {
+        out[name] = prop.default;
+      }
+    }
+    for (const name of required) {
+      if (out[name] === void 0) {
+        throw new Error(`Missing required flag: --${name}`);
+      }
+    }
+    if (httpMethod === "GET") {
+      return { body: {}, query: objectToQuery(out), fromPositional: false };
+    }
+    return { body: out, query: {}, fromPositional: false };
+  };
+}
+function appendValue(out, key, value) {
+  if (out[key] === void 0) {
+    out[key] = value;
+  } else if (Array.isArray(out[key])) {
+    out[key].push(value);
+  } else {
+    out[key] = [out[key], value];
+  }
+}
+function coerce(value, type) {
+  if (type === "integer") {
+    const n = Number(value);
+    if (!Number.isInteger(n)) throw new Error(`expected integer; got ${value}`);
+    return n;
+  }
+  if (type === "number") {
+    const n = Number(value);
+    if (Number.isNaN(n)) throw new Error(`expected number; got ${value}`);
+    return n;
+  }
+  return value;
+}
+function objectToQuery(obj) {
+  const q = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v === void 0 || v === null) continue;
+    if (Array.isArray(v)) {
+      q[k] = v.map((x) => String(x));
+    } else {
+      q[k] = String(v);
+    }
+  }
+  return q;
+}
+async function runAuthLogin(options, args) {
+  const stdout = options.stdout ?? process.stdout;
+  const sleep = options.sleepMs ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const { noOpen, serverUrl } = parseAuthLoginArgs(args, options.noOpenDefault);
+  const targetServer = (serverUrl ?? await getServerUrl(options.context)).replace(/\/+$/u, "");
+  const start = await requestJson(
+    options.context,
+    "/api/cli/auth/start",
+    { method: "POST" },
+    { auth: false, serverUrl: targetServer }
+  );
+  stdout.write(`Open ${start.verificationUrl}
+`);
+  stdout.write(`Code: ${start.userCode}
+`);
+  if (!noOpen) openVerificationUrl(start.verificationUrl);
+  const expiresAt = new Date(start.expiresAt).getTime();
+  let interval = start.interval ?? 2;
+  const stderr = options.stderr ?? process.stderr;
+  while (Date.now() < expiresAt) {
+    await sleep(interval * 1e3);
+    try {
+      const token = await requestJson(
+        options.context,
+        "/api/cli/auth/token",
+        {
+          body: JSON.stringify({ deviceCode: start.deviceCode }),
+          method: "POST"
+        },
+        { auth: false, serverUrl: targetServer }
+      );
+      if (token.status === "approved" && token.accessToken) {
+        await saveAuth(options.context, targetServer, token.accessToken);
+        stdout.write(`Authenticated to ${targetServer}
+`);
+        return;
+      }
+      if (token.status === "expired") break;
+      interval = token.interval ?? interval;
+    } catch (error) {
+      if (error instanceof Error) {
+        const status = error.status;
+        if (status === 410 || error.message.includes("HTTP 410")) break;
+        if (isTransientPollError(error, status)) {
+          stderr.write(
+            `[smrt-app-cli] auth poll: ${error.message} (retrying in ${interval}s)
+`
+          );
+          continue;
+        }
+      }
+      throw error;
+    }
+  }
+  throw new Error("Terminal login request expired.");
+}
+function isTransientPollError(error, status) {
+  if (status !== void 0) {
+    if (status >= 500 && status < 600) return true;
+    if (status >= 400 && status < 500) return false;
+  }
+  const msg = error.message;
+  if (/^HTTP 4(?!10)\d\d/.test(msg)) return false;
+  if (/^HTTP 5\d\d/.test(msg)) return true;
+  if (/fetch failed/i.test(msg)) return true;
+  if (/ECONNRESET|ETIMEDOUT|ENOTFOUND|EAI_AGAIN/i.test(msg)) return true;
+  return false;
+}
+async function runAuthStatus(options) {
+  const stdout = options.stdout ?? process.stdout;
+  const config = await loadCliConfig(options.context);
+  const serverUrl = await getServerUrl(options.context, config);
+  const token = await getStoredToken(options.context, config);
+  if (!token) {
+    stdout.write(
+      `${JSON.stringify({ authenticated: false, serverUrl }, null, 2)}
+`
+    );
+    return;
+  }
+  try {
+    const session = await requestJson(
+      options.context,
+      "/api/cli/auth/session",
+      { method: "GET" }
+    );
+    stdout.write(`${JSON.stringify({ ...session, serverUrl }, null, 2)}
+`);
+  } catch (error) {
+    stdout.write(
+      `${JSON.stringify(
+        {
+          authenticated: false,
+          serverUrl,
+          error: error instanceof Error ? error.message : String(error)
+        },
+        null,
+        2
+      )}
+`
+    );
+  }
+}
+async function runAuthLogout(options) {
+  const stdout = options.stdout ?? process.stdout;
+  try {
+    await requestJson(options.context, "/api/cli/auth/session", {
+      method: "DELETE"
+    });
+  } catch {
+  }
+  await clearStoredToken(options.context);
+  stdout.write(`${JSON.stringify({ authenticated: false }, null, 2)}
+`);
+}
+function parseAuthLoginArgs(args, noOpenDefault = false) {
+  const result = {
+    noOpen: noOpenDefault
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--no-open") {
+      result.noOpen = true;
+    } else if (arg === "--server") {
+      result.serverUrl = args[i + 1];
+      i += 1;
+    } else if (arg?.startsWith("--server=")) {
+      result.serverUrl = arg.slice("--server=".length);
+    } else {
+      throw new Error(`Unknown auth login option: ${arg}`);
+    }
+  }
+  return result;
+}
+function commandExists(cmd) {
+  if (process.platform === "win32") return true;
+  return spawnSync("sh", ["-lc", `command -v ${cmd}`], { stdio: "ignore" }).status === 0;
+}
+function openVerificationUrl(url) {
+  const candidates = process.platform === "darwin" ? [{ args: [url], command: "open" }] : process.platform === "win32" ? (
+    // `explorer.exe <url>` interprets `?` as a wildcard and silently
+    // drops everything after it — every device-code URL has query
+    // params (`?userCode=...`), so the browser never opened on
+    // Windows. `cmd.exe /c start "" "<url>"` is the conventional
+    // shell-out: the empty `""` is the window title (required
+    // because `start` would otherwise consume the URL as the
+    // title), and the quoted URL preserves `?`. (#1311 review #5.)
+    [{ args: ["/c", "start", "", url], command: "cmd.exe" }]
+  ) : [
+    { args: [url], command: "xdg-open" },
+    { args: ["open", url], command: "gio" }
+  ];
+  const opener = candidates.find((c) => commandExists(c.command));
+  if (!opener) return;
+  const child = spawn(opener.command, opener.args, {
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true
+  });
+  child.on("error", () => void 0);
+  child.unref();
+}
+async function runMcpCommand(options, args) {
+  const stdout = options.stdout ?? process.stdout;
+  const sub = args[0];
+  if (sub === "tools") {
+    const result = await requestJson(
+      options.context,
+      "/api/mcp/tools",
+      { method: "GET" },
+      { fetch: options.fetch }
+    );
+    stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+    return;
+  }
+  if (sub === "call") {
+    const name = args[1];
+    const payload = args[2] ?? "{}";
+    if (!name) throw new Error("Usage: mcp call <tool> [<json>]");
+    let parsed;
+    try {
+      parsed = JSON.parse(payload);
+    } catch (error) {
+      throw new Error(
+        `Could not parse mcp call payload: ${error.message}`
+      );
+    }
+    const result = await requestJson(
+      options.context,
+      "/api/mcp/call",
+      {
+        body: JSON.stringify({ arguments: parsed, name }),
+        method: "POST"
+      },
+      { fetch: options.fetch }
+    );
+    stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+    return;
+  }
+  throw new Error("Usage: mcp tools | mcp call <tool> [<json>]");
+}
+async function runResourcesCommand(options, args) {
+  const stdout = options.stdout ?? process.stdout;
+  const stderr = options.stderr ?? process.stderr;
+  const json = args.includes("--json");
+  const debug = args.includes("--debug");
+  const response = options.injectResponse ?? await fetchResourceList(options.context, {
+    fetch: options.fetch
+  });
+  if (json) {
+    stdout.write(`${JSON.stringify(response, null, 2)}
+`);
+    return;
+  }
+  if (response.resources.length === 0) {
+    if (!response.user.authenticated) {
+      stdout.write("(no resources — not authenticated)\n");
+    } else {
+      stdout.write("(no resources discovered)\n");
+    }
+    return;
+  }
+  for (const resource of response.resources) {
+    stdout.write(`${resource.slug}  (${resource.className})
+`);
+    for (const command of resource.commands) {
+      stdout.write(`  - ${formatCommandLine(resource, command)}
+`);
+    }
+  }
+  if (response.warnings.length > 0) {
+    if (debug) {
+      stderr.write(`
+warnings:
+`);
+      for (const w of response.warnings) {
+        stderr.write(`  - ${w}
+`);
+      }
+    } else {
+      stderr.write(
+        `
+${response.warnings.length} command${response.warnings.length === 1 ? "" : "s"} unavailable (use --debug for details)
+`
+      );
+    }
+  }
+}
+function formatCommandLine(_resource, command) {
+  const idHint = command.scope === "item" ? " <id>" : "";
+  const description = command.description ? `  — ${command.description}` : "";
+  return `${command.commandName}${idHint}${description}`;
+}
+function createAppCli(options) {
+  const envPrefix = options.envPrefix ?? options.name.toUpperCase();
+  const configDir = options.configDir ?? options.name.toLowerCase();
+  const context = {
+    envPrefix,
+    appSlug: configDir,
+    defaultServerUrl: options.defaultServerUrl
+  };
+  const extraByName = /* @__PURE__ */ new Map();
+  for (const cmd of options.extraCommands ?? []) {
+    extraByName.set(cmd.name, cmd);
+  }
+  return {
+    run: (argv) => runCli(context, options, extraByName, argv),
+    startMcpBridge: async (serverInfo) => {
+      const { runMcpStdioBridge: runMcpStdioBridge2 } = await import("./config-Bgq_EQoJ.js").then((n) => n.f);
+      await runMcpStdioBridge2({
+        ...context,
+        serverInfo: {
+          name: serverInfo?.name ?? `${options.name}-mcp`,
+          version: serverInfo?.version ?? "0.0.0"
+        }
+      });
+    }
+  };
+}
+const BUILT_IN_COMMANDS = /* @__PURE__ */ new Set(["auth", "resources", "mcp"]);
+async function runCli(context, options, extras, argv) {
+  const stdout = process.stdout;
+  const stderr = process.stderr;
+  try {
+    await dispatchCli(context, options, extras, argv, stdout, stderr);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    stderr.write(`${message}
+`);
+    process.exitCode = 1;
+  }
+}
+async function dispatchCli(context, options, extras, argv, stdout, stderr) {
+  if (argv.length === 0 || argv[0] === "help" || argv[0] === "--help") {
+    printUsage(options, extras, stdout);
+    return;
+  }
+  const [command, ...rest] = argv;
+  const extra = extras.get(command);
+  if (extra) {
+    if (BUILT_IN_COMMANDS.has(command)) {
+      stderr.write(
+        `[smrt-app-cli] extra command \`${command}\` shadows a built-in.
+`
+      );
+    }
+    const ctx = await buildAppContext(context, extra.needsResources ?? false);
+    await extra.run(rest, ctx);
+    return;
+  }
+  if (command === "auth") {
+    const sub = rest[0];
+    const opts = { context, stdout, stderr };
+    if (sub === "login") return runAuthLogin(opts, rest.slice(1));
+    if (sub === "status") return runAuthStatus(opts);
+    if (sub === "logout") return runAuthLogout(opts);
+    throw new Error(
+      "Usage: auth login [--server <url>] [--no-open] | status | logout"
+    );
+  }
+  if (command === "mcp") {
+    return runMcpCommand({ context, stdout }, rest);
+  }
+  if (command === "resources") {
+    return runResourcesCommand({ context, stdout, stderr }, rest);
+  }
+  await runResourceCommand(context, command, rest, stdout, stderr);
+}
+async function runResourceCommand(context, slug, rest, stdout, stderr) {
+  const response = await fetchResourceList(context);
+  const resource = findResourceBySlug(response, slug);
+  if (!resource) {
+    const suggestions = response.resources.map((r) => r.slug).filter((s) => similar(s, slug)).slice(0, 3);
+    const hint = suggestions.length ? `  Did you mean: ${suggestions.join(", ")}?` : "";
+    throw new Error(`Unknown resource: ${slug}.${hint}`);
+  }
+  const commandName = rest[0];
+  if (!commandName) {
+    throw new Error(
+      `Usage: ${slug} <command> [id] [...]. Available: ${resource.commands.map((c) => c.commandName).join(", ")}`
+    );
+  }
+  const command = findCommand(resource, commandName);
+  if (!command) {
+    throw new Error(
+      `Unknown command \`${commandName}\` on resource \`${slug}\`. Available: ${resource.commands.map((c) => c.commandName).join(", ")}`
+    );
+  }
+  let positional = rest.slice(1);
+  let id;
+  if (command.scope === "item") {
+    id = positional[0];
+    if (!id) {
+      throw new Error(
+        `Command \`${slug} ${commandName}\` requires an id positional argument.`
+      );
+    }
+    if (findCommand(resource, id)) {
+      throw new Error(
+        `\`${id}\` is a command on \`${slug}\`, not an id. Did you mean: \`${slug} ${id}${findCommand(resource, id)?.scope === "item" ? " <id>" : ""}\`? \`${slug} ${commandName}\` is an item-scope command and needs an id as the next argument.`
+      );
+    }
+    positional = positional.slice(1);
+  }
+  const parser = buildFlagParser(command.parameters);
+  if (parser.status.kind === "unsupported") {
+    stderr.write(
+      `[smrt-app-cli] complex schema for \`${slug} ${commandName}\`; pass JSON payload directly
+`
+    );
+  } else if (parser.status.kind === "missing") {
+    stderr.write(
+      `[smrt-app-cli] schema unavailable for \`${slug} ${commandName}\`; pass JSON payload directly: $ <cli> ${slug} ${commandName}${id ? ` ${id}` : ""} '<json>'
+`
+    );
+  }
+  const parsed = parser.parse(positional, command.httpMethod);
+  const response2 = await invokeCommand({
+    context,
+    resource,
+    command,
+    parsed,
+    id
+  });
+  const { exitCode } = await renderResponse(response2, { stdout, stderr });
+  if (exitCode !== 0) process.exitCode = exitCode;
+}
+async function buildAppContext(context, eagerResources) {
+  const config = await loadCliConfig(context);
+  const serverUrl = await getServerUrl(context, config);
+  const token = await getStoredToken(context, config);
+  let resourcesPromise = null;
+  const getResources = () => {
+    if (!resourcesPromise) {
+      resourcesPromise = fetchResourceList(context, { loadedConfig: config });
+    }
+    return resourcesPromise;
+  };
+  if (eagerResources) {
+    void getResources();
+  }
+  return {
+    config,
+    serverUrl,
+    token,
+    getResources,
+    requestJson: (path, init, opts) => requestJson(context, path, init, { loadedConfig: config, ...opts }),
+    request: async (path, init) => {
+      const headers = new Headers(init?.headers);
+      if (token) headers.set("authorization", `Bearer ${token}`);
+      return fetch(`${serverUrl}${path}`, { ...init, headers });
+    },
+    stdout: process.stdout,
+    stderr: process.stderr
+  };
+}
+function printUsage(options, extras, out) {
+  const name = options.name;
+  out.write(`Usage:
+`);
+  out.write(`  ${name} auth login [--server <url>] [--no-open]
+`);
+  out.write(`  ${name} auth status
+`);
+  out.write(`  ${name} auth logout
+`);
+  out.write(`  ${name} resources [--json] [--debug]
+`);
+  out.write(
+    `  ${name} <resource> <command> [id] [--flags...] [json-payload]
+`
+  );
+  out.write(`  ${name} mcp tools
+`);
+  out.write(`  ${name} mcp call <tool> [<json>]
+`);
+  for (const cmd of extras.values()) {
+    out.write(`  ${name} ${cmd.name}  — ${cmd.description}
+`);
+  }
+}
+function similar(a, b2) {
+  if (a === b2) return true;
+  if (Math.abs(a.length - b2.length) > 2) return false;
+  let diff = 0;
+  for (let i = 0; i < Math.max(a.length, b2.length); i++) {
+    if (a[i] !== b2[i]) diff += 1;
+    if (diff > 2) return false;
+  }
+  return true;
+}
+export {
+  buildFlagParser,
+  buildUrl,
+  classifySchema,
+  clearStoredToken,
+  createAppCli,
+  b as createMcpStdioBridge,
+  fetchResourceList,
+  findCommand,
+  findResourceBySlug,
+  getServerUrl,
+  getStoredToken,
+  invokeCommand,
+  loadCliConfig,
+  renderResponse,
+  requestJson,
+  d as runMcpStdioBridge,
+  saveAuth,
+  e as saveCliConfig
+};