@garuda-agent/garuda 0.0.1 → 0.14.1

package/dist/chunk-HUIK3WXO.js

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+import {
+  commandMatches,
+  commandParts,
+  hostMatches,
+  pathMatches
+} from "./chunk-3NJNVZTK.js";
+
+// src/permissions/policy.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { z } from "zod";
+var POLICY_FILE = join(".garuda", "policy.json");
+function managedPolicyPath(platform = process.platform) {
+  if (platform === "darwin") return "/Library/Application Support/Garuda/policy.json";
+  if (platform === "linux") return "/etc/garuda/policy.json";
+  return void 0;
+}
+function ignoredProjectPolicy(root) {
+  const file = join(root, POLICY_FILE);
+  return existsSync(file) ? file : void 0;
+}
+var policySchema = z.strictObject({
+  disallowedCommands: z.array(z.string()).optional(),
+  requireSandbox: z.boolean().optional(),
+  denyPaths: z.array(z.string()).optional(),
+  allowedModels: z.array(z.string()).optional(),
+  network: z.strictObject({
+    blockedHosts: z.array(z.string()).optional(),
+    strictAllowlist: z.boolean().optional()
+  }).optional(),
+  limits: z.strictObject({
+    maxSteps: z.number().int().positive().optional(),
+    tokenBudget: z.number().int().positive().optional()
+  }).optional(),
+  audit: z.strictObject({
+    enabled: z.boolean().optional(),
+    level: z.enum(["all", "mutations", "denials"]).optional()
+  }).optional()
+});
+function parsePolicy(json) {
+  const result = policySchema.safeParse(json);
+  if (!result.success) {
+    throw new Error(`Invalid policy schema: ${z.prettifyError(result.error)}`);
+  }
+  const data = result.data;
+  return {
+    ...data.disallowedCommands === void 0 ? {} : { disallowedCommands: data.disallowedCommands },
+    ...data.requireSandbox === void 0 ? {} : { requireSandbox: data.requireSandbox },
+    ...data.denyPaths === void 0 ? {} : { denyPaths: data.denyPaths },
+    ...data.allowedModels === void 0 ? {} : { allowedModels: data.allowedModels },
+    ...data.network === void 0 ? {} : {
+      network: {
+        ...data.network.blockedHosts === void 0 ? {} : { blockedHosts: data.network.blockedHosts },
+        ...data.network.strictAllowlist === void 0 ? {} : { strictAllowlist: data.network.strictAllowlist }
+      }
+    },
+    ...data.limits === void 0 ? {} : {
+      limits: {
+        ...data.limits.maxSteps === void 0 ? {} : { maxSteps: data.limits.maxSteps },
+        ...data.limits.tokenBudget === void 0 ? {} : { tokenBudget: data.limits.tokenBudget }
+      }
+    },
+    ...data.audit === void 0 ? {} : {
+      audit: {
+        ...data.audit.enabled === void 0 ? {} : { enabled: data.audit.enabled },
+        ...data.audit.level === void 0 ? {} : { level: data.audit.level }
+      }
+    }
+  };
+}
+async function readPolicyFile(file) {
+  let text;
+  try {
+    text = await readFile(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw new Error(`${file}: ${error.message}`);
+  }
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch (error) {
+    throw new Error(`${file}: invalid JSON: ${error.message}`);
+  }
+  try {
+    return parsePolicy(json);
+  } catch (error) {
+    throw new Error(`${file}: ${error.message}`);
+  }
+}
+function mergePolicies(user, managed) {
+  if (user === void 0) return managed;
+  if (managed === void 0) return user;
+  const union = (a, b) => a === void 0 && b === void 0 ? void 0 : [.../* @__PURE__ */ new Set([...a ?? [], ...b ?? []])];
+  const either = (a, b) => a === void 0 && b === void 0 ? void 0 : a === true || b === true;
+  const lower = (a, b) => a === void 0 ? b : b === void 0 ? a : Math.min(a, b);
+  const disallowedCommands = union(user.disallowedCommands, managed.disallowedCommands);
+  const denyPaths = union(user.denyPaths, managed.denyPaths);
+  const requireSandbox = either(user.requireSandbox, managed.requireSandbox);
+  const allowedModels = managed.allowedModels ?? user.allowedModels;
+  const blockedHosts = union(user.network?.blockedHosts, managed.network?.blockedHosts);
+  const strictAllowlist = either(user.network?.strictAllowlist, managed.network?.strictAllowlist);
+  const maxSteps = lower(user.limits?.maxSteps, managed.limits?.maxSteps);
+  const tokenBudget = lower(user.limits?.tokenBudget, managed.limits?.tokenBudget);
+  const audit = managed.audit ?? user.audit;
+  return {
+    ...disallowedCommands === void 0 ? {} : { disallowedCommands },
+    ...requireSandbox === void 0 ? {} : { requireSandbox },
+    ...denyPaths === void 0 ? {} : { denyPaths },
+    ...allowedModels === void 0 ? {} : { allowedModels },
+    ...blockedHosts === void 0 && strictAllowlist === void 0 ? {} : {
+      network: {
+        ...blockedHosts === void 0 ? {} : { blockedHosts },
+        ...strictAllowlist === void 0 ? {} : { strictAllowlist }
+      }
+    },
+    ...maxSteps === void 0 && tokenBudget === void 0 ? {} : {
+      limits: {
+        ...maxSteps === void 0 ? {} : { maxSteps },
+        ...tokenBudget === void 0 ? {} : { tokenBudget }
+      }
+    },
+    ...audit === void 0 ? {} : { audit }
+  };
+}
+async function loadTeamPolicy(options = {}) {
+  const userFile = join(options.home ?? homedir(), POLICY_FILE);
+  const managedFile = "managed" in options ? options.managed : managedPolicyPath();
+  const user = await readPolicyFile(userFile);
+  const managed = managedFile === void 0 ? void 0 : await readPolicyFile(managedFile);
+  const policy = mergePolicies(user, managed);
+  if (policy === void 0) return void 0;
+  const sources = [
+    ...managed === void 0 || managedFile === void 0 ? [] : [managedFile],
+    ...user === void 0 ? [] : [userFile]
+  ];
+  return { policy, sources };
+}
+function isCommandDisallowedByPolicy(policy, command) {
+  if (!policy.disallowedCommands || policy.disallowedCommands.length === 0) {
+    return { disallowed: false };
+  }
+  const parts = commandParts(command);
+  for (const pattern of policy.disallowedCommands) {
+    const hit = (part) => commandMatches(pattern, part);
+    if (parts.some(hit) || hit(command)) {
+      return {
+        disallowed: true,
+        pattern,
+        reason: `Command is disallowed by team policy: pattern "${pattern}".`
+      };
+    }
+  }
+  return { disallowed: false };
+}
+function isSandboxRequiredByPolicy(policy, outsideSandbox) {
+  if (policy.requireSandbox === true && outsideSandbox) {
+    return {
+      disallowed: true,
+      reason: "The team policy requires the OS sandbox: this command would run outside it (outside_sandbox, or no sandbox on this machine)."
+    };
+  }
+  return { disallowed: false };
+}
+function isPathDeniedByPolicy(policy, path) {
+  if (!policy.denyPaths || policy.denyPaths.length === 0) {
+    return { denied: false };
+  }
+  for (const pattern of policy.denyPaths) {
+    if (pathMatches(pattern, path)) {
+      return {
+        denied: true,
+        pattern,
+        reason: `Access to path "${path}" is disallowed by team policy: pattern "${pattern}".`
+      };
+    }
+  }
+  return { denied: false };
+}
+function isModelAllowedByPolicy(policy, modelId) {
+  if (!policy.allowedModels || policy.allowedModels.length === 0) {
+    return { allowed: true };
+  }
+  const allowed = policy.allowedModels.some((pattern) => commandMatches(pattern, modelId));
+  if (!allowed) {
+    return {
+      allowed: false,
+      reason: `Model "${modelId}" is not permitted by team policy. Allowed: ${policy.allowedModels.join(", ")}.`
+    };
+  }
+  return { allowed: true };
+}
+function assertModelAllowedByPolicy(policy, modelId) {
+  if (policy === void 0) return;
+  const decision = isModelAllowedByPolicy(policy, modelId);
+  if (!decision.allowed) {
+    throw new Error(decision.reason ?? `Model "${modelId}" is not permitted by team policy.`);
+  }
+}
+function isHostBlockedByPolicy(policy, host) {
+  if (!policy.network?.blockedHosts || policy.network.blockedHosts.length === 0) {
+    return { blocked: false };
+  }
+  const name = host.replace(/^\[|\]$/g, "").replace(/\.$/, "");
+  for (const pattern of policy.network.blockedHosts) {
+    if (hostMatches(pattern, name)) {
+      return {
+        blocked: true,
+        pattern,
+        reason: `Network access to host "${host}" is blocked by team policy: pattern "${pattern}".`
+      };
+    }
+  }
+  return { blocked: false };
+}
+
+export {
+  POLICY_FILE,
+  managedPolicyPath,
+  ignoredProjectPolicy,
+  parsePolicy,
+  mergePolicies,
+  loadTeamPolicy,
+  isCommandDisallowedByPolicy,
+  isSandboxRequiredByPolicy,
+  isPathDeniedByPolicy,
+  isModelAllowedByPolicy,
+  assertModelAllowedByPolicy,
+  isHostBlockedByPolicy
+};
+//# sourceMappingURL=chunk-HUIK3WXO.js.map