@garuda-agent/garuda 0.14.1 → 0.16.0

package/dist/setupCommand-VA7D5MZK.js

@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+import {
+  BUILTIN_PROVIDERS,
+  KEY_NAME,
+  MODELS_FILE,
+  chooseModel,
+  credentialsPath,
+  loadModelsConfig,
+  maskKey,
+  readCredentials,
+  resolveModel,
+  setDefaultModel,
+  writeCredentials
+} from "./chunk-NP6RIC25.js";
+import "./chunk-EIXUSVFX.js";
+import {
+  knownModels
+} from "./chunk-R7I2NBPX.js";
+import "./chunk-ATW7BNIG.js";
+import "./chunk-3EQU2GUX.js";
+
+// src/cli/setupCommand.ts
+import { homedir } from "os";
+var CHECK_TIMEOUT_MS = 1e4;
+var LOCAL_LIST_TIMEOUT_MS = 2e3;
+var OTHER = "another model";
+var ONE_WORD = /^[!-~]+$/;
+var PROVIDER_TITLES = {
+  anthropic: "Anthropic (Claude)",
+  openrouter: "OpenRouter",
+  ollama: "Ollama (this machine)",
+  lmstudio: "LM Studio (this machine)",
+  llamacpp: "llama.cpp (this machine)",
+  vllm: "vLLM (this machine)"
+};
+async function setupCommand(options, deps) {
+  const { io } = deps;
+  if ((deps.platform ?? process.platform) === "win32") {
+    io.print(
+      "Garuda supports macOS and Linux. On Windows, run Garuda in WSL (Windows Subsystem for Linux)."
+    );
+    return 1;
+  }
+  const home = deps.home ?? homedir();
+  const env = deps.env ?? process.env;
+  const models = await loadModelsConfig(home);
+  if (models.problem !== void 0) {
+    io.print(models.problem);
+    return 1;
+  }
+  if (options.show === true) return show(io, models.config, home, env);
+  if (!io.interactive) {
+    io.print(
+      "garuda setup asks questions, so it needs a terminal. In a script, set the key in its environment variable (for example ANTHROPIC_API_KEY) and the model with --model or GARUDA_MODEL."
+    );
+    return 1;
+  }
+  try {
+    if (options.forget !== void 0 && options.forget !== false) {
+      return await forget(io, home, options.forget === true ? void 0 : options.forget);
+    }
+    return await setup(io, models.config, home, env, deps.fetch ?? fetch);
+  } catch (error) {
+    if (error.name === "ExitPromptError") {
+      io.print("Setup stopped. Nothing changed.");
+      return 130;
+    }
+    throw error;
+  }
+}
+async function setup(io, config, home, env, fetcher) {
+  const stored = await readCredentials(home);
+  if (stored.warning !== void 0) {
+    io.print(stored.warning);
+    io.print(`Fix or remove ${credentialsPath(home)}, then run garuda setup again.`);
+    return 1;
+  }
+  const providers = { ...BUILTIN_PROVIDERS, ...config.providers };
+  const provider = await io.select(
+    "Provider",
+    Object.keys(providers).map((name) => ({
+      name: PROVIDER_TITLES[name] ?? `${name} (~/${MODELS_FILE})`,
+      value: name,
+      ...config.providers[name] === void 0 ? {} : { description: "from your models.json" }
+    }))
+  );
+  const def = providers[provider];
+  const model = await pickModel(io, provider, def, fetcher);
+  const spec = provider === "anthropic" ? model : `${provider}/${model}`;
+  try {
+    resolveModel(spec, config);
+  } catch (error) {
+    io.print(error.message);
+    return 1;
+  }
+  const keyName = def.type === "anthropic" ? def.apiKeyEnv ?? "ANTHROPIC_API_KEY" : def.apiKeyEnv;
+  let newKey;
+  if (keyName !== void 0) {
+    const fromEnv = env[keyName] ?? "";
+    const old = stored.keys[keyName];
+    if (fromEnv !== "") {
+      io.print(
+        `${keyName} is set in your environment, and it wins over a stored key. Garuda stores no key for it.`
+      );
+    } else if (old !== void 0 && await io.confirm(`Keep the stored ${keyName} (${maskKey(old)})?`, true)) {
+    } else {
+      newKey = await askKey(io, keyName);
+    }
+    if (await io.confirm("Check the key now? (a free request that lists models)", true)) {
+      for (; ; ) {
+        const key = fromEnv !== "" ? fromEnv : newKey ?? old;
+        const result = await checkKey(provider, def, key, env, fetcher);
+        io.print(result.message);
+        if (result.ok) break;
+        const next = await io.select("What now?", [
+          ...fromEnv === "" ? [{ name: "Enter the key again", value: "again" }] : [],
+          { name: "Store it anyway", value: "store" },
+          { name: "Stop (nothing changes)", value: "stop" }
+        ]);
+        if (next === "stop") {
+          io.print("Setup stopped. Nothing changed.");
+          return 1;
+        }
+        if (next === "store") break;
+        newKey = await askKey(io, keyName);
+      }
+    }
+  } else if (def.local === true) {
+    const result = await checkKey(provider, def, void 0, env, fetcher);
+    io.print(result.ok ? result.message : `${result.message} Start the server before you use it.`);
+  }
+  await setDefaultModel(spec, home);
+  if (newKey !== void 0 && keyName !== void 0) {
+    await writeCredentials({ ...stored.keys, [keyName]: newKey }, home);
+  }
+  io.print("");
+  io.print(`Model: ${spec} (the default in ~/${MODELS_FILE})`);
+  if (keyName !== void 0) {
+    const where = (env[keyName] ?? "") !== "" ? "from your environment" : `in ${credentialsPath(home)}`;
+    const key = (env[keyName] ?? "") !== "" ? env[keyName] : newKey ?? stored.keys[keyName] ?? "";
+    io.print(`Key: ${keyName} ${maskKey(key)} ${where}`);
+  }
+  if ((env.GARUDA_MODEL ?? "") !== "") {
+    io.print(`GARUDA_MODEL is set (${env.GARUDA_MODEL}), and it wins over this default.`);
+  }
+  io.print("Done. Start Garuda with: garuda");
+  return 0;
+}
+async function pickModel(io, provider, def, fetcher) {
+  let listed = [];
+  const notes = /* @__PURE__ */ new Map();
+  if (def.type === "anthropic") {
+    for (const { id, info } of knownModels()) {
+      listed.push(id);
+      if (info.price !== void 0) {
+        notes.set(id, `$${info.price.input} in, $${info.price.output} out per million tokens`);
+      }
+    }
+  } else if (def.local === true && def.baseUrl !== void 0) {
+    listed = await localModels(def.baseUrl, fetcher);
+  }
+  if (listed.length > 0) {
+    const picked = await io.select("Model", [
+      ...listed.map((id) => {
+        const note = notes.get(id);
+        return { name: id, value: id, ...note === void 0 ? {} : { description: note } };
+      }),
+      { name: "Another model (type its name)", value: OTHER }
+    ]);
+    if (picked !== OTHER) return picked;
+  }
+  for (; ; ) {
+    const typed = (await io.input(
+      provider === "openrouter" ? "Model (for example qwen/qwen3-coder)" : "Model name"
+    )).trim();
+    if (typed !== "" && ONE_WORD.test(typed)) return typed;
+    io.print("Type a model name with no spaces.");
+  }
+}
+async function localModels(baseUrl, fetcher) {
+  try {
+    const response = await fetcher(`${baseUrl.replace(/\/+$/, "")}/models`, {
+      signal: AbortSignal.timeout(LOCAL_LIST_TIMEOUT_MS)
+    });
+    if (!response.ok) return [];
+    const body = await response.json();
+    return (body.data ?? []).map((m) => m.id).filter((id) => typeof id === "string" && id.length <= 200 && ONE_WORD.test(id)).slice(0, 50);
+  } catch {
+    return [];
+  }
+}
+async function askKey(io, keyName) {
+  for (; ; ) {
+    const key = (await io.secret(`${keyName} (the input is hidden)`)).trim();
+    if (key !== "" && key.length <= 4096 && ONE_WORD.test(key)) return key;
+    io.print("A key is one word with no spaces. Paste it again.");
+  }
+}
+async function checkKey(provider, def, key, env, fetcher = fetch) {
+  let url;
+  const headers = {};
+  if (def.type === "anthropic") {
+    const base = (env.ANTHROPIC_BASE_URL ?? "") !== "" ? env.ANTHROPIC_BASE_URL : "https://api.anthropic.com";
+    url = `${base.replace(/\/+$/, "")}/v1/models?limit=1`;
+    headers["anthropic-version"] = "2023-06-01";
+    if (key !== void 0) headers["x-api-key"] = key;
+  } else {
+    url = `${def.baseUrl.replace(/\/+$/, "")}/models`;
+    if (key !== void 0) headers.authorization = `Bearer ${key}`;
+  }
+  const host = new URL(url).host;
+  try {
+    const response = await fetcher(url, {
+      headers,
+      redirect: "error",
+      signal: AbortSignal.timeout(CHECK_TIMEOUT_MS)
+    });
+    await response.body?.cancel();
+    if (response.ok) {
+      return {
+        ok: true,
+        message: key === void 0 ? `${provider} answered at ${host}.` : `${provider} answered: the key works.`
+      };
+    }
+    if (response.status === 401 || response.status === 403) {
+      return { ok: false, message: `${provider} refused the key (HTTP ${response.status}).` };
+    }
+    return { ok: false, message: `${host} answered HTTP ${response.status}.` };
+  } catch (error) {
+    const reason = error.name === "TimeoutError" ? "no answer in time" : error.cause?.code ?? error.message;
+    return { ok: false, message: `Garuda could not reach ${host} (${reason}).` };
+  }
+}
+async function show(io, config, home, env) {
+  const stored = await readCredentials(home);
+  const spec = chooseModel(config, env.GARUDA_MODEL);
+  io.print(
+    spec === void 0 ? "Model: none. Run garuda setup." : `Model: ${spec} (${(env.GARUDA_MODEL ?? "") !== "" ? "GARUDA_MODEL" : `the default in ~/${MODELS_FILE}`})`
+  );
+  const providers = { ...BUILTIN_PROVIDERS, ...config.providers };
+  const names = /* @__PURE__ */ new Set(["ANTHROPIC_API_KEY"]);
+  for (const def of Object.values(providers))
+    if (def.apiKeyEnv !== void 0) names.add(def.apiKeyEnv);
+  for (const name of Object.keys(stored.keys)) names.add(name);
+  for (const name of [...names].sort()) {
+    const fromEnv = env[name] ?? "";
+    const fromFile = stored.keys[name];
+    io.print(
+      fromEnv !== "" ? `${name}: ${maskKey(fromEnv)} from the environment${fromFile === void 0 ? "" : " (it wins over the stored key)"}` : fromFile !== void 0 ? `${name}: ${maskKey(fromFile)} in ${credentialsPath(home)}` : `${name}: not set`
+    );
+  }
+  if (stored.warning !== void 0) io.print(stored.warning);
+  return 0;
+}
+async function forget(io, home, name) {
+  const stored = await readCredentials(home);
+  if (stored.warning !== void 0) {
+    io.print(stored.warning);
+    return 1;
+  }
+  const names = Object.keys(stored.keys);
+  if (name !== void 0 && !KEY_NAME.test(name)) {
+    io.print(`"${name}" is not a key name (for example ANTHROPIC_API_KEY).`);
+    return 1;
+  }
+  if (name !== void 0 && stored.keys[name] === void 0) {
+    io.print(`No stored key is named ${name}.`);
+    return 1;
+  }
+  if (names.length === 0) {
+    io.print("No keys are stored.");
+    return 0;
+  }
+  const gone = name === void 0 ? names : [name];
+  const question = gone.length === 1 ? `Remove the stored ${gone[0]} (${maskKey(stored.keys[gone[0]])})?` : `Remove all ${gone.length} stored keys (${gone.join(", ")})?`;
+  if (!await io.confirm(question, false)) {
+    io.print("Nothing changed.");
+    return 0;
+  }
+  const rest = Object.fromEntries(Object.entries(stored.keys).filter(([n]) => !gone.includes(n)));
+  await writeCredentials(rest, home);
+  io.print(`Removed: ${gone.join(", ")}.`);
+  return 0;
+}
+async function terminalIO() {
+  const { confirm, input, password, select } = await import("@inquirer/prompts");
+  return {
+    interactive: process.stdin.isTTY === true && process.stdout.isTTY === true,
+    select: (message, choices) => select({ message, choices, pageSize: 12 }),
+    input: (message, initial) => input({ message, ...initial === void 0 ? {} : { default: initial } }),
+    secret: (message) => password({ message, mask: "*" }),
+    confirm: (message, initial) => confirm({ message, default: initial }),
+    print: (text) => process.stdout.write(`${text}
+`)
+  };
+}
+export {
+  CHECK_TIMEOUT_MS,
+  checkKey,
+  setupCommand,
+  terminalIO
+};
+//# sourceMappingURL=setupCommand-VA7D5MZK.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@garuda-agent/garuda",
-  "version": "0.14.1",
+  "version": "0.16.0",
   "description": "Garuda: a terminal coding agent with an OS sandbox, approvals and an audit log.",
   "license": "Apache-2.0",
   "author": "Madhusudhan Vasanth Kumar",
@@ -52,6 +52,7 @@
   },
   "packageManager": "pnpm@10.28.0",
   "dependencies": {
+    "@agentclientprotocol/sdk": "1.7.0",
     "@anthropic-ai/sdk": "^0.128.0",
     "@inquirer/prompts": "^8.7.2",
     "@modelcontextprotocol/client": "^2.1.0",

package/dist/chunk-6TWBYMY7.js

@@ -1,9 +0,0 @@
-#!/usr/bin/env node
-
-// src/version.ts
-var VERSION = "0.14.1";
-
-export {
-  VERSION
-};
-//# sourceMappingURL=chunk-6TWBYMY7.js.map

package/dist/chunk-V7WPGQLB.js

@@ -1,207 +0,0 @@
-#!/usr/bin/env node
-import {
-  keepSecretForRedaction
-} from "./chunk-ITITLNAR.js";
-import {
-  lookupModel
-} from "./chunk-W7BPYQMW.js";
-import {
-  isLoopbackHost
-} from "./chunk-ATW7BNIG.js";
-
-// src/model/providers.ts
-import { readFile } from "fs/promises";
-import { homedir } from "os";
-import { join } from "path";
-import { z } from "zod";
-var MODELS_FILE = join(".garuda", "models.json");
-var priceSchema = z.strictObject({
-  input: z.number().min(0),
-  output: z.number().min(0),
-  cacheRead: z.number().min(0),
-  cacheWrite: z.number().min(0)
-});
-var providerSchema = z.strictObject({
-  type: z.enum(["anthropic", "openai-compatible"]),
-  /** For openai-compatible: the URL that ends before /chat/completions. */
-  baseUrl: z.url().optional(),
-  /** The environment variable that holds the API key. */
-  apiKeyEnv: z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).optional(),
-  /** A server on this machine: price 0 unless a model entry says otherwise. */
-  local: z.boolean().optional(),
-  /** Allow plain http to a host that is not this machine. Off: an API key could travel in clear text. */
-  allowInsecureHttp: z.boolean().optional()
-});
-var modelSchema = z.strictObject({
-  contextWindow: z.number().int().min(4096).optional(),
-  price: priceSchema.optional(),
-  maxTokens: z.number().int().min(256).optional(),
-  /**
-   * Tool calls that the model writes as JSON text (openai-compatible only): "whole" (default) when
-   * the whole reply is calls, "lines" when calls stand on their own lines between prose, "off".
-   */
-  textToolCalls: z.enum(["off", "whole", "lines"]).optional()
-});
-var fileSchema = z.strictObject({
-  providers: z.record(z.string().regex(/^[a-z][a-z0-9-]{0,31}$/), providerSchema).default({}),
-  /** Keyed by the full spec, for example "ollama/qwen3-coder:30b". */
-  models: z.record(z.string(), modelSchema).default({})
-});
-var BUILTIN_PROVIDERS = {
-  anthropic: { type: "anthropic" },
-  ollama: { type: "openai-compatible", baseUrl: "http://localhost:11434/v1", local: true },
-  lmstudio: { type: "openai-compatible", baseUrl: "http://localhost:1234/v1", local: true },
-  llamacpp: { type: "openai-compatible", baseUrl: "http://localhost:8080/v1", local: true },
-  vllm: { type: "openai-compatible", baseUrl: "http://localhost:8000/v1", local: true },
-  openrouter: {
-    type: "openai-compatible",
-    baseUrl: "https://openrouter.ai/api/v1",
-    apiKeyEnv: "OPENROUTER_API_KEY"
-  }
-};
-var OPEN_MODEL_DEFAULT_WINDOW = 32768;
-var ZERO_PRICE = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
-async function loadModelsConfig(home = homedir()) {
-  const file = join(home, MODELS_FILE);
-  let text;
-  try {
-    text = await readFile(file, "utf8");
-  } catch (error) {
-    if (error.code === "ENOENT")
-      return { config: { providers: {}, models: {} } };
-    return {
-      config: { providers: {}, models: {} },
-      problem: `${file}: ${error.message}`
-    };
-  }
-  try {
-    const parsed = fileSchema.safeParse(JSON.parse(text));
-    if (!parsed.success) {
-      return {
-        config: { providers: {}, models: {} },
-        problem: `${file}: ${z.prettifyError(parsed.error)}`
-      };
-    }
-    return { config: parsed.data };
-  } catch (error) {
-    return {
-      config: { providers: {}, models: {} },
-      problem: `${file}: invalid JSON: ${error.message}`
-    };
-  }
-}
-var keptKeys = /* @__PURE__ */ new Map();
-function keepProviderKey(name) {
-  const value = process.env[name];
-  if (value !== void 0 && value !== "") {
-    keptKeys.set(name, value);
-    keepSecretForRedaction(name, value);
-    delete process.env[name];
-  }
-}
-function hasProviderKey(name) {
-  return keptKeys.has(name) || (process.env[name] ?? "") !== "";
-}
-function providerKey(env, name) {
-  if (name === void 0) return void 0;
-  return keptKeys.get(name) ?? env[name];
-}
-function resolveModel(spec, config = { providers: {}, models: {} }) {
-  const providers = { ...BUILTIN_PROVIDERS, ...config.providers };
-  const slash = spec.indexOf("/");
-  const [provider, model] = slash === -1 ? ["anthropic", spec] : [spec.slice(0, slash), spec.slice(slash + 1)];
-  const def = providers[provider];
-  if (def === void 0) {
-    throw new Error(
-      `Unknown model provider "${provider}" in "${spec}". Known providers: ${Object.keys(providers).join(", ")}. Add others in ~/${MODELS_FILE}.`
-    );
-  }
-  if (model === "") throw new Error(`"${spec}" names no model. Use <provider>/<model>.`);
-  if (def.type === "openai-compatible") checkBaseUrl(provider, def);
-  const entry = config.models[spec] ?? (provider === "anthropic" ? config.models[model] : void 0);
-  const base = def.type === "anthropic" ? lookupModel(model) : { contextWindow: OPEN_MODEL_DEFAULT_WINDOW, ...def.local ? { price: ZERO_PRICE } : {} };
-  const info = {
-    contextWindow: entry?.contextWindow ?? base.contextWindow,
-    ...entry?.price !== void 0 ? { price: entry.price } : base.price !== void 0 ? { price: base.price } : {},
-    // Thinking by model (0.9): only Claude models on the Anthropic provider have it.
-    ...base.thinking === void 0 ? {} : { thinking: base.thinking }
-  };
-  const notes = [];
-  if (def.type === "openai-compatible" && entry?.contextWindow === void 0) {
-    notes.push(
-      `Garuda assumes a ${OPEN_MODEL_DEFAULT_WINDOW}-token context window for ${spec}. Set the real value ("contextWindow") for "${spec}" in ~/${MODELS_FILE}; the server must allow it too (for Ollama: OLLAMA_CONTEXT_LENGTH).`
-    );
-  }
-  return {
-    spec,
-    provider,
-    model,
-    def,
-    info,
-    notes,
-    ...entry?.maxTokens === void 0 ? {} : { maxTokens: entry.maxTokens },
-    ...def.type === "anthropic" ? {
-      async createBatch(env = process.env, options = {}) {
-        const apiKey = providerKey(env, def.apiKeyEnv ?? "ANTHROPIC_API_KEY");
-        const { AnthropicBatchClient } = await import("./anthropic-NQDBCHJU.js");
-        return new AnthropicBatchClient({ model, ...apiKey ? { apiKey } : {}, ...options });
-      }
-    } : {},
-    async create(env = process.env) {
-      const apiKey = providerKey(env, def.apiKeyEnv);
-      if (def.apiKeyEnv !== void 0 && (apiKey === void 0 || apiKey === "")) {
-        throw new Error(`Set ${def.apiKeyEnv} to use the ${provider} provider.`);
-      }
-      if (def.type === "anthropic") {
-        const key = providerKey(env, def.apiKeyEnv ?? "ANTHROPIC_API_KEY");
-        const { AnthropicClient } = await import("./anthropic-NQDBCHJU.js");
-        return new AnthropicClient({ model, ...key ? { apiKey: key } : {} });
-      }
-      const { OpenAICompatibleClient } = await import("./openaiCompatible-CJWVJP5M.js");
-      return new OpenAICompatibleClient({
-        provider,
-        baseUrl: def.baseUrl,
-        model,
-        ...apiKey === void 0 ? {} : { apiKey },
-        ...entry?.textToolCalls === void 0 ? {} : { textToolCalls: entry.textToolCalls }
-      });
-    }
-  };
-}
-function checkBaseUrl(provider, def) {
-  if (def.baseUrl === void 0) throw new Error(`Provider "${provider}" needs a baseUrl.`);
-  const url = new URL(def.baseUrl);
-  if (url.protocol !== "https:" && url.protocol !== "http:") {
-    throw new Error(`Provider "${provider}": the baseUrl must use http or https.`);
-  }
-  if (url.username !== "" || url.password !== "") {
-    throw new Error(`Provider "${provider}": put credentials in apiKeyEnv, not in the baseUrl.`);
-  }
-  if (url.protocol === "http:" && !isLoopbackHost(url.hostname) && def.allowInsecureHttp !== true) {
-    throw new Error(
-      `Provider "${provider}" uses plain http to ${url.hostname}. Use https, or set "allowInsecureHttp": true for a trusted network.`
-    );
-  }
-}
-
-// src/permissions/autoApprover.ts
-var AutoApprover = class {
-  requests = [];
-  answer;
-  constructor(answer = "once") {
-    this.answer = typeof answer === "function" ? answer : () => answer;
-  }
-  async ask(request) {
-    this.requests.push(request);
-    return this.answer(request);
-  }
-};
-
-export {
-  loadModelsConfig,
-  keepProviderKey,
-  hasProviderKey,
-  resolveModel,
-  AutoApprover
-};
-//# sourceMappingURL=chunk-V7WPGQLB.js.map