godmode 0.0.2 → 0.0.3

package/dist/{add-AJERMPEA.js → add-D74TIN3J.js}

@@ -1,18 +1,19 @@
 #!/usr/bin/env node
 import {
   addApi
-} from "./chunk-2J2VDCQ4.js";
-import "./chunk-EXWYJU2I.js";
+} from "./chunk-KHFZI7IA.js";
+import "./chunk-3AQ2CZKC.js";
+import "./chunk-YDXTIN53.js";
 
 // src/commands/add.ts
-async function runAdd(args) {
+async function runAdd(args, scope = "project") {
   if (!args[0] || args[0] === "--help" || args[0] === "-h") {
     console.log(`Add an extension from a folder, built-in name, or manifest.
 
 Usage:
-  godmode extension add <name>          Built-in extension (e.g. stripe, github)
-  godmode extension add <folder>        Folder containing manifest.yaml
-  godmode extension add <manifest>      Direct path to manifest.yaml/json
+  godmode ext install <name>            Built-in extension (e.g. stripe, github)
+  godmode ext install <folder>          Folder containing manifest.yaml
+  godmode ext install <manifest>        Direct path to manifest.yaml/json
 
 Manifest format (manifest.yaml):
   slug:    stripe             CLI name
@@ -33,13 +34,13 @@ Types:
   mcp                         MCP endpoint  (requires url)
 
 Examples:
-  $ godmode extension add stripe
-  $ godmode extension add ./my-extension
-  $ godmode extension add ./my-extension/manifest.yaml
-  $ godmode extension add openai`);
+  $ godmode ext install stripe
+  $ godmode ext install ./my-extension
+  $ godmode ext install ./my-extension/manifest.yaml
+  $ godmode ext install openai`);
     process.exit(args[0] ? 0 : 1);
   }
-  await addApi(args[0]);
+  await addApi(args[0], scope);
 }
 export {
   runAdd

package/dist/{chunk-EXWYJU2I.js → chunk-3AQ2CZKC.js}

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  AuthStrategy
+} from "./chunk-YDXTIN53.js";
 
 // ../../interfaces/mcp/src/index.ts
 var requestId = 0;
@@ -53,9 +56,7 @@ function buildAuthHeaders(config) {
   const headers = { ...config.headers };
   const token = config.auth?.env ? process.env[config.auth.env] : void 0;
   if (token) {
-    const authType = config.auth?.type || "bearer";
-    if (authType === "bearer") headers["Authorization"] = `Bearer ${token}`;
-    else if (authType === "api-key") headers[config.auth?.header || "X-API-Key"] = token;
+    AuthStrategy.for(config.auth).apply(headers, token);
   }
   return headers;
 }
@@ -120,7 +121,7 @@ function validateMcpFlags(method, query) {
 }
 async function executeMcpTool(config, toolName, args, options) {
   const headers = buildAuthHeaders(config);
-  if (options.dryRun || options.verbose) {
+  if (options.dryRun || options.debug) {
     process.stderr.write(`CALL ${config.url} \u2192 ${toolName}
 `);
     if (Object.keys(args).length) {

package/dist/chunk-4EU5JX6C.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+import {
+  loadSettingsDetailed,
+  settingsErrorMessage
+} from "./chunk-SMQBMG24.js";
+
+// src/permissions.ts
+function checkPermission(input) {
+  const loaded = loadSettingsDetailed();
+  const settingsError = loaded.errors[0];
+  if (settingsError) {
+    return {
+      allowed: false,
+      reason: settingsErrorMessage(settingsError),
+      defaultDenied: true
+    };
+  }
+  const blocks = loaded.sources.map((source) => ({
+    origin: `${source.scope}:${source.path}`,
+    permissions: source.settings.extensions?.[input.extension]?.permissions
+  })).filter((source) => !!source.permissions);
+  const hasAny = blocks.some(({ permissions }) => !!(permissions?.allow?.length || permissions?.deny?.length));
+  if (!hasAny) return { allowed: true };
+  for (const block of blocks) {
+    for (const rule of block.permissions?.deny ?? []) {
+      if (ruleMatches(rule, input)) {
+        return {
+          allowed: false,
+          reason: `denied by permissions for ${input.extension}: ${describe(rule, input, "deny")}`,
+          rule,
+          origin: block.origin
+        };
+      }
+    }
+  }
+  for (const block of blocks) {
+    for (const rule of block.permissions?.allow ?? []) {
+      if (ruleMatches(rule, input)) return { allowed: true, rule, origin: block.origin };
+    }
+  }
+  return {
+    allowed: false,
+    reason: `no allow rule matches ${input.resource} ${input.method.toUpperCase()} for ${input.extension}`,
+    defaultDenied: true
+  };
+}
+function explainPermission(input) {
+  return { ...checkPermission(input), input };
+}
+function suggestedAllowRule(input) {
+  return [
+    "permissions:",
+    "  allow:",
+    `    - resources: [${input.resource}]`,
+    `      methods: [${input.method.toUpperCase()}]`
+  ].join("\n");
+}
+function ruleMatches(rule, input) {
+  const resources = rule.resources ?? ["*"];
+  const resourceOk = resources.some((pattern) => matchResource(pattern, input.resource));
+  if (!resourceOk) return false;
+  if (!rule.methods || rule.methods.length === 0) return true;
+  return rule.methods.some((m) => m.toLowerCase() === input.method.toLowerCase());
+}
+function matchResource(pattern, resource) {
+  if (pattern === "*" || pattern === resource) return true;
+  const pp = pattern.split(".");
+  const rp = resource.split(".");
+  if (pp[pp.length - 1] === "*" && rp.length >= pp.length) {
+    for (let i = 0; i < pp.length - 1; i++) {
+      if (pp[i] !== "*" && pp[i] !== rp[i]) return false;
+    }
+    return true;
+  }
+  if (pp.length !== rp.length) return false;
+  for (let i = 0; i < pp.length; i++) {
+    if (pp[i] !== "*" && pp[i] !== rp[i]) return false;
+  }
+  return true;
+}
+function describe(rule, input, effect) {
+  const res = (rule.resources ?? ["*"]).join(", ");
+  const mth = rule.methods?.join(", ") || "any method";
+  return `${effect} ${res} [${mth}] while acting on ${input.resource} ${input.method.toUpperCase()}`;
+}
+function resourceFromSegments(segments) {
+  const parts = segments.filter((s) => !s.isParam).map((s) => s.value).filter((v) => !/^v\d+$/i.test(v));
+  return parts.join(".") || "*";
+}
+function resourceFromTool(toolName) {
+  return toolName;
+}
+function resourceFromRawPath(path) {
+  const parts = path.split("/").filter(Boolean).filter((v) => !/^v\d+$/i.test(v));
+  return parts.join(".") || "*";
+}
+
+// ../../interfaces/api/src/match.ts
+function matchRoute(manifest, userSegments, method) {
+  if (userSegments.length > 0) {
+    const ver = manifest.versions.find((v) => v.name === userSegments[0]);
+    if (ver) {
+      const match = findMatch(manifest.routes, userSegments.slice(1), method, ver.name);
+      if (match) return match;
+    }
+  }
+  return findMatch(manifest.routes, userSegments, method);
+}
+function findMatch(routes, userSegments, method, version) {
+  let bestMatch = null;
+  let bestScore = -1;
+  for (const route of routes) {
+    if (route.method !== method) continue;
+    if (route.segments.length !== userSegments.length) continue;
+    if (version !== void 0 && route.version !== version) continue;
+    let score = 0;
+    const params = {};
+    let matches = true;
+    for (let i = 0; i < route.segments.length; i++) {
+      const seg = route.segments[i];
+      const userSeg = userSegments[i];
+      if (seg.isParam) {
+        params[seg.value] = userSeg;
+      } else if (seg.value === userSeg) {
+        score += 1;
+      } else {
+        matches = false;
+        break;
+      }
+    }
+    if (matches && (score > bestScore || score === bestScore && isLaterVersion(route, bestMatch?.route))) {
+      bestScore = score;
+      bestMatch = { route, params };
+    }
+  }
+  return bestMatch;
+}
+function isLaterVersion(a, b) {
+  if (!b) return true;
+  return a.version > b.version;
+}
+function suggestRoutes(manifest, userSegments) {
+  if (!userSegments.length) return [];
+  return manifest.routes.filter((route) => {
+    if (route.segments.length < userSegments.length) return false;
+    const firstSeg = route.segments[0];
+    return !firstSeg.isParam && firstSeg.value === userSegments[0];
+  });
+}
+
+export {
+  checkPermission,
+  explainPermission,
+  suggestedAllowRule,
+  resourceFromSegments,
+  resourceFromTool,
+  resourceFromRawPath,
+  matchRoute,
+  suggestRoutes
+};

package/dist/{chunk-GJCJO7YT.js → chunk-AWGLXW3B.js}

@@ -1,6 +1,18 @@
 #!/usr/bin/env node
+import {
+  AuthStrategy
+} from "./chunk-YDXTIN53.js";
 
 // ../../interfaces/api/src/request.ts
+var HttpStatusError = class extends Error {
+  constructor(status, statusText, body) {
+    super(body || `${status} ${statusText}`);
+    this.status = status;
+    this.statusText = statusText;
+  }
+  status;
+  statusText;
+};
 async function executeToString(manifest, match, options) {
   const baseUrl = manifest.config.url;
   if (!baseUrl) {
@@ -21,20 +33,13 @@ async function executeToString(manifest, match, options) {
     throw new Error(`Missing ${authConfig.env}. Set it in .env or export it in your shell.`);
   }
   if (token) {
-    const authType = authConfig?.type || "bearer";
-    if (authType === "bearer") {
-      headers["Authorization"] = `Bearer ${token}`;
-    } else if (authType === "api-key") {
-      headers[authConfig?.header || "X-API-Key"] = token;
-    } else if (authType === "basic") {
-      headers["Authorization"] = `Basic ${token}`;
-    }
+    AuthStrategy.for(authConfig).apply(headers, token);
   }
   if (options.body && !headers["Content-Type"]) {
     headers["Content-Type"] = "application/json";
   }
   const method = match.route.method.toUpperCase();
-  if (options.dryRun || options.verbose) {
+  if (options.dryRun || options.debug) {
     process.stderr.write(`${method} ${url.toString()}
 `);
     for (const [k, v] of Object.entries(headers)) {
@@ -54,7 +59,7 @@ async function executeToString(manifest, match, options) {
     headers,
     body: options.body || void 0
   });
-  if (options.verbose) {
+  if (options.debug) {
     process.stderr.write(`${response.status} ${response.statusText}
 `);
     response.headers.forEach((v, k) => process.stderr.write(`  ${k}: ${v}
@@ -73,7 +78,7 @@ async function executeToString(manifest, match, options) {
   } else {
     result = text;
   }
-  if (!response.ok) throw new Error(result);
+  if (!response.ok) throw new HttpStatusError(response.status, response.statusText, result);
   return result;
 }
 async function execute(manifest, match, options) {
@@ -81,6 +86,14 @@ async function execute(manifest, match, options) {
     const result = await executeToString(manifest, match, options);
     if (result) process.stdout.write(result + "\n");
   } catch (err) {
+    if (err instanceof HttpStatusError) {
+      process.stderr.write(`${err.status} ${err.statusText}
+`);
+      if (err.message) process.stderr.write(err.message + "\n");
+      if (err.status >= 400 && err.status < 500) process.exit(10);
+      if (err.status >= 500) process.exit(11);
+      process.exit(12);
+    }
     process.stderr.write(err.message + "\n");
     process.exit(1);
   }