@garuda-agent/garuda 0.0.1 → 0.15.0

package/SECURITY.md

@@ -0,0 +1,32 @@
+# Security policy
+
+Garuda runs commands and edits files for a model, so we take security reports seriously.
+
+## Supported versions
+
+| Version | Supported |
+| --- | --- |
+| 0.14.x | Yes |
+| Older | No |
+
+## Report a vulnerability
+
+Do not open a public issue. Use GitHub's private vulnerability reporting: in this repository, open
+**Security**, then **Report a vulnerability**. Give:
+
+- the version (`garuda --version`) and the platform (macOS or Linux, the sandbox in use);
+- the steps to reproduce, and what you expected;
+- the effect, for example a sandbox escape, a permission or team-policy bypass, a secret in a
+  session file or the audit log, or a write that the user did not approve.
+
+You get an answer within 7 days. We agree a fix and a disclosure date with you, and we credit you in
+the release notes unless you ask us not to.
+
+## Scope
+
+In scope: the permission engine and the team policy, the OS sandbox (Seatbelt, bubblewrap), the
+network allowlist and its proxy, secret redaction, the audit log, and the consent for project
+content (hooks, MCP servers, settings, commands, skills, agents).
+
+Known limits are listed in the README under the status table. A report about one of them is still
+welcome when it shows a new way to reach the same effect.

package/dist/acpCommand-FZ2P5JFO.js

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+import {
+  keepProviderKey,
+  loadModelsConfig,
+  resolveModel
+} from "./chunk-YFQJXRIJ.js";
+import {
+  FileSessionStore,
+  Runtime,
+  auditDirFor
+} from "./chunk-K7KK7U44.js";
+import "./chunk-A2QAIRQL.js";
+import "./chunk-HRGX53VC.js";
+import "./chunk-G2AX7MGS.js";
+import {
+  loadSearchConfig
+} from "./chunk-B25VL4RU.js";
+import "./chunk-23FXBNBB.js";
+import {
+  VERSION
+} from "./chunk-EPKWDCV4.js";
+import "./chunk-5DEWP3YX.js";
+import "./chunk-ZAE25JM2.js";
+import "./chunk-ATW7BNIG.js";
+import "./chunk-PZS3V6P3.js";
+import "./chunk-OUCV3FCT.js";
+import "./chunk-SI2QJYCR.js";
+import "./chunk-WMOLXTBU.js";
+import "./chunk-HUIK3WXO.js";
+import "./chunk-3NJNVZTK.js";
+
+// src/cli/acpCommand.ts
+import { homedir } from "os";
+import { Readable } from "stream";
+async function acpCommand(options) {
+  const output = protocolOutput(process.stdout, process.stderr);
+  const input = Readable.toWeb(process.stdin);
+  const setup = await prepare(options);
+  const { acpServer } = await import("./server-R3GNIC33.js");
+  const server = acpServer({
+    version: VERSION,
+    createRuntime: async ({ root, approver, onEvent, onNotice }) => {
+      if (typeof setup === "string") throw new Error(setup);
+      return createRuntime(setup, { root, approver, onEvent, onNotice });
+    }
+  });
+  process.on("exit", () => server.shutdown());
+  const stop = () => {
+    server.shutdown();
+    process.exit(143);
+  };
+  process.once("SIGTERM", stop);
+  await server.serve(output, input);
+  await server.close();
+  return 0;
+}
+function protocolOutput(stdout, stderr) {
+  const write = stdout.write.bind(stdout);
+  const toStderr = stderr.write.bind(stderr);
+  stdout.write = ((...args) => toStderr(...args));
+  return new WritableStream({
+    write: (chunk) => new Promise((resolve, reject) => {
+      write(chunk, (error) => error ? reject(error) : resolve());
+    })
+  });
+}
+async function prepare(options) {
+  const spec = options.model ?? process.env.GARUDA_MODEL;
+  if (!spec) return "Set a model with --model <id> or the GARUDA_MODEL variable.";
+  const models = await loadModelsConfig();
+  if (models.problem !== void 0) return models.problem;
+  let resolved;
+  let sub;
+  try {
+    resolved = resolveModel(spec, models.config);
+    const subSpec = process.env.GARUDA_SUBAGENT_MODEL;
+    if (subSpec) sub = resolveModel(subSpec, models.config);
+  } catch (error) {
+    return error.message;
+  }
+  const search = await loadSearchConfig();
+  for (const name of [resolved.def.apiKeyEnv, sub?.def.apiKeyEnv, "ANTHROPIC_API_KEY"]) {
+    if (name !== void 0) keepProviderKey(name);
+  }
+  const { loadTeamPolicy } = await import("./policy-EJPLEEXP.js");
+  let team;
+  try {
+    team = await loadTeamPolicy();
+  } catch (error) {
+    return `Team policy: ${error.message}`;
+  }
+  return {
+    resolved,
+    ...sub === void 0 ? {} : { sub },
+    models: models.config,
+    ...team === void 0 ? {} : { team: { policy: team.policy, sources: team.sources } },
+    search
+  };
+}
+function createRuntime(setup, input) {
+  const { resolved, sub, models, team, search } = setup;
+  return Runtime.create({
+    root: input.root,
+    modelId: resolved.spec,
+    ...team === void 0 ? {} : { policy: team.policy, policySources: team.sources },
+    audit: { dir: auditDirFor(input.root) },
+    model: () => resolved.create(),
+    modelInfo: resolved.info,
+    ...resolved.maxTokens === void 0 ? {} : { maxTokens: resolved.maxTokens },
+    ...sub === void 0 ? {} : { subagentModel: { spec: sub.spec, model: () => sub.create(), info: sub.info } },
+    approver: input.approver,
+    store: new FileSessionStore(input.root),
+    undo: {},
+    skills: {},
+    languages: {},
+    // The editor cannot answer a question before session/new returns: only project settings that
+    // the user approved in a terminal apply; the rest is left out with a notice (docs/lld/acp.md).
+    projectSettings: { home: homedir(), ask: false },
+    ...search.config === void 0 && search.claude === void 0 ? {} : {
+      search: {
+        ...search.config === void 0 ? {} : { config: search.config },
+        ...search.claude === void 0 ? {} : { claude: search.claude },
+        ...search.use === void 0 ? {} : { use: search.use },
+        home: homedir()
+      }
+    },
+    agents: {
+      resolveModel: (spec) => {
+        const r = resolveModel(spec, models);
+        return { spec: r.spec, model: () => r.create(), info: r.info };
+      }
+    },
+    models: {
+      resolve: (spec) => {
+        const r = resolveModel(spec, models);
+        return {
+          spec: r.spec,
+          model: () => r.create(),
+          info: r.info,
+          ...r.maxTokens === void 0 ? {} : { maxTokens: r.maxTokens }
+        };
+      },
+      configured: Object.keys(models.models)
+    },
+    ...input.onEvent === void 0 ? {} : { onEvent: input.onEvent },
+    onNotice: input.onNotice
+  });
+}
+export {
+  acpCommand,
+  protocolOutput
+};
+//# sourceMappingURL=acpCommand-FZ2P5JFO.js.map

package/dist/anthropic-NQDBCHJU.js

@@ -0,0 +1,327 @@
+#!/usr/bin/env node
+
+// src/model/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+import { Agent, fetch as undiciFetch } from "undici";
+var WEB_SEARCH_TOOL = "web_search_20250305";
+var AnthropicClient = class {
+  /** Claude's web search runs on Anthropic's servers (0.6). */
+  serverTools = ["web_search"];
+  client;
+  model;
+  constructor(options) {
+    this.model = options.model;
+    this.client = options.client ?? new Anthropic(clientOptions(options.apiKey));
+  }
+  async *stream(request, options) {
+    const stream = this.client.messages.stream(
+      toWireParams(this.model, request),
+      options?.signal === void 0 ? {} : { signal: options.signal }
+    );
+    for await (const event of stream) {
+      if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+        yield { type: "text_delta", text: event.delta.text };
+      } else if (event.type === "content_block_delta" && event.delta.type === "thinking_delta" && event.delta.thinking !== "" && request.thinking?.hide !== true) {
+        yield { type: "thinking_delta", text: event.delta.thinking };
+      }
+    }
+    const final = await stream.finalMessage();
+    const response = fromWireMessage(final);
+    yield {
+      type: "response",
+      response: request.thinking?.hide === true ? withHiddenThinking(response) : response
+    };
+  }
+};
+function withHiddenThinking(response) {
+  return {
+    ...response,
+    content: response.content.map((b) => b.type === "thinking" ? { ...b, text: "" } : b)
+  };
+}
+var STREAM_IDLE_MS = 20 * 6e4;
+var dispatchers = /* @__PURE__ */ new Map();
+function streamFetch(idleMs = STREAM_IDLE_MS) {
+  let agent = dispatchers.get(idleMs);
+  if (agent === void 0) {
+    agent = new Agent({ bodyTimeout: idleMs });
+    dispatchers.set(idleMs, agent);
+  }
+  const dispatcher = agent;
+  return ((input, init) => undiciFetch(input, { ...init, dispatcher }));
+}
+function clientOptions(apiKey) {
+  return { ...apiKey === void 0 ? {} : { apiKey }, fetch: streamFetch() };
+}
+function toWireParams(model, request) {
+  const params = {
+    model,
+    max_tokens: request.maxTokens,
+    system: [{ type: "text", text: request.system, cache_control: { type: "ephemeral" } }],
+    messages: request.messages.map(toWireMessage)
+  };
+  const last = params.messages.at(-1);
+  if (last !== void 0 && Array.isArray(last.content) && last.content.length > 0) {
+    const blocks = last.content;
+    const block = blocks.findLast((b) => b.type !== "thinking" && b.type !== "redacted_thinking");
+    if (block !== void 0) block.cache_control = { type: "ephemeral" };
+  }
+  const tools = toWireTools(request.tools, request.serverTools ?? []);
+  if (tools.length > 0) params.tools = tools;
+  const thinking = request.thinking;
+  if (thinking?.adaptive === true || thinking?.display !== void 0) {
+    params.thinking = {
+      type: "adaptive",
+      ...thinking.display === void 0 ? {} : { display: thinking.display }
+    };
+  }
+  if (thinking?.effort !== void 0) params.output_config = { effort: thinking.effort };
+  return params;
+}
+function toWireTools(tools, serverTools = []) {
+  const out = [
+    ...tools.map(
+      (tool) => ({
+        name: tool.name,
+        description: tool.description,
+        input_schema: { ...tool.inputSchema, type: "object" }
+      })
+    ),
+    ...serverTools.map(
+      (spec) => ({
+        type: WEB_SEARCH_TOOL,
+        name: "web_search",
+        max_uses: spec.maxUses,
+        ...spec.allowedDomains === void 0 ? {} : { allowed_domains: [...spec.allowedDomains] },
+        ...spec.blockedDomains === void 0 ? {} : { blocked_domains: [...spec.blockedDomains] }
+      })
+    )
+  ];
+  const last = out.at(-1);
+  if (last !== void 0) last.cache_control = { type: "ephemeral" };
+  return out;
+}
+function toWireMessage(message) {
+  return { role: message.role, content: message.content.map(toWireBlock) };
+}
+function toWireBlock(block) {
+  switch (block.type) {
+    case "text":
+      return block.citations === void 0 ? { type: "text", text: block.text } : {
+        type: "text",
+        text: block.text,
+        citations: structuredClone(block.citations)
+      };
+    // Server tool blocks go back exactly as they came (the results hold encrypted content), and so
+    // do thinking blocks (0.9: the signature checks them).
+    case "server_tool_use":
+    case "server_tool_result":
+    case "thinking":
+      return structuredClone(block.wire);
+    case "tool_use":
+      return { type: "tool_use", id: block.id, name: block.name, input: block.input };
+    case "tool_result":
+      return {
+        type: "tool_result",
+        tool_use_id: block.toolUseId,
+        content: block.content,
+        is_error: block.isError
+      };
+  }
+}
+function fromWireMessage(message) {
+  const content = [];
+  for (const block of message.content) {
+    if (block.type === "text") {
+      const citations = block.citations ?? [];
+      content.push(
+        citations.length === 0 ? { type: "text", text: block.text } : { type: "text", text: block.text, citations: structuredClone(citations) }
+      );
+    } else if (block.type === "tool_use") {
+      content.push({ type: "tool_use", id: block.id, name: block.name, input: block.input });
+    } else if (block.type === "server_tool_use") {
+      content.push({
+        type: "server_tool_use",
+        id: block.id,
+        name: block.name,
+        input: block.input,
+        wire: structuredClone(block)
+      });
+    } else if (block.type === "web_search_tool_result") {
+      content.push(webSearchResult(block));
+    } else if (block.type === "thinking") {
+      content.push({ type: "thinking", text: block.thinking, wire: structuredClone(block) });
+    } else if (block.type === "redacted_thinking") {
+      content.push({ type: "thinking", text: "", wire: structuredClone(block) });
+    }
+  }
+  return {
+    content,
+    stopReason: fromWireStopReason(message.stop_reason),
+    usage: fromWireUsage(message.usage)
+  };
+}
+function webSearchResult(block) {
+  const wire = structuredClone(block);
+  if (!Array.isArray(block.content)) {
+    return {
+      type: "server_tool_result",
+      toolUseId: block.tool_use_id,
+      name: "web_search",
+      results: [],
+      error: block.content.error_code,
+      wire
+    };
+  }
+  return {
+    type: "server_tool_result",
+    toolUseId: block.tool_use_id,
+    name: "web_search",
+    results: block.content.map((r) => ({
+      title: r.title,
+      url: r.url,
+      ...r.page_age === null || r.page_age === void 0 ? {} : { age: r.page_age }
+    })),
+    wire
+  };
+}
+function fromWireStopReason(reason) {
+  switch (reason) {
+    case "end_turn":
+    case "stop_sequence":
+      return "end_turn";
+    case "tool_use":
+      return "tool_use";
+    case "max_tokens":
+    case "model_context_window_exceeded":
+      return "max_tokens";
+    case "refusal":
+      return "refusal";
+    case "pause_turn":
+      return "pause_turn";
+    default:
+      return "other";
+  }
+}
+function fromWireUsage(usage) {
+  const searches = usage.server_tool_use?.web_search_requests ?? 0;
+  return {
+    inputTokens: usage.input_tokens,
+    outputTokens: usage.output_tokens,
+    cacheReadTokens: usage.cache_read_input_tokens ?? 0,
+    cacheWriteTokens: usage.cache_creation_input_tokens ?? 0,
+    ...searches > 0 ? { webSearches: searches } : {}
+  };
+}
+var BATCH_CHECK_TIMEOUT_MS = 6e4;
+var MAX_FAILED_CHECKS = 10;
+var BATCH_POLL_MS = [5e3, 1e4, 2e4, 3e4];
+var AnthropicBatchClient = class {
+  serverTools = ["web_search"];
+  client;
+  model;
+  pollMs;
+  onWait;
+  noticeMs;
+  constructor(options) {
+    this.model = options.model;
+    this.pollMs = options.pollMs ?? BATCH_POLL_MS;
+    this.onWait = options.onWait;
+    this.noticeMs = options.noticeMs ?? 6e4;
+    this.client = options.client ?? new Anthropic(clientOptions(options.apiKey));
+  }
+  async *stream(request, options) {
+    const signal = options?.signal;
+    const params = toWireParams(
+      this.model,
+      request
+    );
+    const batch = await this.client.messages.batches.create(
+      { requests: [{ custom_id: "garuda", params }] },
+      signal === void 0 ? {} : { signal }
+    );
+    const started = Date.now();
+    this.onWait?.({ batchId: batch.id, waitedMs: 0, status: "created" });
+    let noticed = 0;
+    let failed = 0;
+    try {
+      for (let i = 0; ; i++) {
+        await wait(this.pollMs[Math.min(i, this.pollMs.length - 1)] ?? 3e4, signal);
+        let status;
+        try {
+          const state = await this.client.messages.batches.retrieve(batch.id, void 0, {
+            timeout: BATCH_CHECK_TIMEOUT_MS,
+            ...signal === void 0 ? {} : { signal }
+          });
+          status = state.processing_status;
+          failed = 0;
+        } catch (error) {
+          if (signal?.aborted === true || ++failed >= MAX_FAILED_CHECKS) throw error;
+          status = "check failed, trying again";
+        }
+        if (status === "ended") break;
+        const waited = Date.now() - started;
+        if (waited - noticed >= this.noticeMs) {
+          noticed = waited;
+          this.onWait?.({ batchId: batch.id, waitedMs: waited, status });
+        }
+      }
+    } catch (error) {
+      await this.client.messages.batches.cancel(batch.id).catch(() => void 0);
+      throw error;
+    }
+    const results = await this.client.messages.batches.results(batch.id);
+    for await (const item of results) {
+      if (item.custom_id !== "garuda") continue;
+      const result = item.result;
+      if (result.type === "succeeded") {
+        const response = { ...fromWireMessage(result.message), priceFactor: 0.5 };
+        const text = response.content.map((b) => b.type === "text" ? b.text : "").join("");
+        if (text !== "") yield { type: "text_delta", text };
+        yield { type: "response", response };
+        return;
+      }
+      if (result.type === "errored") {
+        const detail = result.error.error;
+        throw Object.assign(new Error(`Batch request failed: ${detail.message}`), {
+          error: result.error
+        });
+      }
+      throw new Error(`The batch request was ${result.type}.`);
+    }
+    throw new Error("The batch ended without a result.");
+  }
+};
+function wait(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason);
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+export {
+  AnthropicBatchClient,
+  AnthropicClient,
+  BATCH_CHECK_TIMEOUT_MS,
+  BATCH_POLL_MS,
+  STREAM_IDLE_MS,
+  WEB_SEARCH_TOOL,
+  clientOptions,
+  fromWireMessage,
+  streamFetch,
+  toWireMessage,
+  toWireParams,
+  toWireTools,
+  withHiddenThinking
+};
+//# sourceMappingURL=anthropic-NQDBCHJU.js.map

package/dist/chunk-23FXBNBB.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+// src/commands/builtins.ts
+var BUILTIN_COMMANDS = [
+  "help",
+  "usage",
+  "session",
+  "sessions",
+  "models",
+  "export",
+  "compact",
+  "diff",
+  "schedule",
+  "jobs",
+  "where",
+  "defs",
+  "refs",
+  "callers",
+  "impact",
+  "map",
+  "mcp",
+  "hooks",
+  "lsp",
+  "languages",
+  "experts",
+  "audit",
+  "commands",
+  "agents",
+  "plan",
+  "build",
+  "new",
+  "init",
+  "editor",
+  "details",
+  "thinking",
+  "search",
+  "undo",
+  "redo",
+  "exit",
+  "quit"
+];
+
+export {
+  BUILTIN_COMMANDS
+};
+//# sourceMappingURL=chunk-23FXBNBB.js.map