@pensar/apex 0.0.111 → 0.0.112

package/build/cli-5d6cs4dq.js

@@ -0,0 +1,53 @@
+// src/core/providers/types.ts
+var AVAILABLE_PROVIDERS = [
+  {
+    id: "anthropic",
+    name: "Anthropic",
+    description: "Claude Pro/Max or API key",
+    requiresAPIKey: true
+  },
+  {
+    id: "openai",
+    name: "OpenAI",
+    description: "GPT-4 and other OpenAI models",
+    requiresAPIKey: true
+  },
+  {
+    id: "google",
+    name: "Google",
+    description: "Gemini and other Google AI models",
+    requiresAPIKey: true
+  },
+  {
+    id: "openrouter",
+    name: "OpenRouter",
+    description: "Access multiple AI models through one API",
+    requiresAPIKey: true
+  },
+  {
+    id: "inception",
+    name: "Inception",
+    description: "Mercury and other Inception models",
+    requiresAPIKey: true
+  },
+  {
+    id: "bedrock",
+    name: "AWS Bedrock",
+    description: "Amazon Bedrock AI models",
+    requiresAPIKey: true
+  },
+  {
+    id: "local",
+    name: "Local LLM",
+    description: "OpenAI-compatible local model (vLLM, LM Studio, Ollama)",
+    requiresAPIKey: false
+  },
+  {
+    id: "pensar",
+    name: "Pensar",
+    description: "Managed inference via Pensar Console (usage-based billing)",
+    requiresAPIKey: false
+  }
+];
+
+export { AVAILABLE_PROVIDERS };

package/build/cli-6gtnyaqf.js

@@ -0,0 +1,109 @@
+// src/core/agents/specialized/utils.ts
+import { readFileSync, existsSync } from "fs";
+import { execSync } from "child_process";
+function readOsRelease() {
+  try {
+    const content = readFileSync("/etc/os-release", "utf8");
+    const lines = content.split(/\r?\n/);
+    const map = {};
+    for (const line of lines) {
+      const idx = line.indexOf("=");
+      if (idx === -1)
+        continue;
+      const key = line.slice(0, idx);
+      let value = line.slice(idx + 1);
+      if (value.startsWith('"') && value.endsWith('"')) {
+        value = value.slice(1, -1);
+      }
+      map[key] = value;
+    }
+    return map;
+  } catch {
+    return {};
+  }
+}
+function detectDocker() {
+  try {
+    if (existsSync("/.dockerenv"))
+      return true;
+  } catch {}
+  try {
+    const cgroup = readFileSync("/proc/1/cgroup", "utf8");
+    if (/docker|containerd|kubepods/i.test(cgroup))
+      return true;
+  } catch {}
+  return false;
+}
+function toolExists(commandName) {
+  try {
+    execSync(`command -v ${commandName} >/dev/null 2>&1`, {
+      stdio: "ignore",
+      shell: "/bin/bash"
+    });
+    return true;
+  } catch {
+    try {
+      execSync(`which ${commandName} >/dev/null 2>&1`, {
+        stdio: "ignore",
+        shell: "/bin/bash"
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+function detectEnvironment() {
+  const osRelease = readOsRelease();
+  const prettyName = osRelease["PRETTY_NAME"];
+  const id = osRelease["ID"]?.toLowerCase();
+  const idLike = osRelease["ID_LIKE"];
+  const isKali = Boolean(id && /kali/.test(id) || prettyName && /kali/i.test(prettyName));
+  const isDocker = detectDocker();
+  const toolsToCheck = [
+    "nmap",
+    "gobuster",
+    "sqlmap",
+    "nikto",
+    "hydra",
+    "john",
+    "hashcat",
+    "tcpdump",
+    "tshark",
+    "nc",
+    "socat",
+    "curl",
+    "wget",
+    "git"
+  ];
+  const availableTools = [];
+  const missingTools = [];
+  for (const tool of toolsToCheck) {
+    (toolExists(tool) ? availableTools : missingTools).push(tool);
+  }
+  return { isDocker, isKali, prettyName, idLike, availableTools, missingTools };
+}
+function detectOSAndEnhancePrompt(prompt) {
+  try {
+    const env = detectEnvironment();
+    const lines = [];
+    lines.push("[ENV CONTEXT]");
+    lines.push(`OS: ${env.prettyName ?? process.platform} | InDocker: ${env.isDocker ? "yes" : "no"} | Kali: ${env.isKali ? "yes" : "no"}`);
+    if (env.availableTools.length > 0) {
+      lines.push(`Tools available: ${env.availableTools.sort().join(", ")}`);
+    }
+    if (env.missingTools.length > 0) {
+      lines.push(`Tools missing: ${env.missingTools.sort().join(", ")}`);
+    }
+    lines.push(`[/ENV CONTEXT]
+`);
+    return `${lines.join(`
+`)}
+${prompt}`;
+  } catch (error) {
+    console.error("Error detecting environment:", error);
+    return prompt;
+  }
+}
+
+export { toolExists, detectOSAndEnhancePrompt };

package/build/cli-7ckctq7a.js

@@ -0,0 +1,45 @@
+import {
+  __commonJS
+} from "./cli-8rxa073f.js";
+
+// node_modules/@vercel/oidc/dist/token-error.js
+var require_token_error = __commonJS((exports, module) => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var token_error_exports = {};
+  __export(token_error_exports, {
+    VercelOidcTokenError: () => VercelOidcTokenError
+  });
+  module.exports = __toCommonJS(token_error_exports);
+
+  class VercelOidcTokenError extends Error {
+    constructor(message, cause) {
+      super(message);
+      this.name = "VercelOidcTokenError";
+      this.cause = cause;
+    }
+    toString() {
+      if (this.cause) {
+        return `${this.name}: ${this.message}: ${this.cause}`;
+      }
+      return `${this.name}: ${this.message}`;
+    }
+  }
+});
+
+export { require_token_error };

package/build/cli-8rxa073f.js

@@ -0,0 +1,104 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+var __dispose = Symbol.dispose || /* @__PURE__ */ Symbol.for("Symbol.dispose");
+var __asyncDispose = Symbol.asyncDispose || /* @__PURE__ */ Symbol.for("Symbol.asyncDispose");
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function")
+      throw TypeError('Object expected to be assigned to "using" declaration');
+    var dispose;
+    if (async)
+      dispose = value[__asyncDispose];
+    if (dispose === undefined)
+      dispose = value[__dispose];
+    if (typeof dispose !== "function")
+      throw TypeError("Object not disposable");
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  }, fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e), next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0])
+          return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError)
+      throw error;
+  };
+  return next();
+};
+
+export { __toESM, __toCommonJS, __commonJS, __export, __esm, __require, __using, __callDispose };

package/build/cli-bp6d08sg.js

@@ -0,0 +1,110 @@
+import {
+  get,
+  init,
+  update
+} from "./cli-jb0gcnrs.js";
+
+// src/core/api/constants.ts
+var PENSAR_API_BASE_URL = "https://api.pensar.dev";
+var PENSAR_GATEWAY_BASE_URL = "https://gateway.pensar.dev";
+var PENSAR_CONSOLE_BASE_URL = "https://console.pensar.dev";
+function getPensarApiUrl() {
+  return process.env.PENSAR_API_URL || PENSAR_API_BASE_URL;
+}
+function getPensarGatewayUrl() {
+  return process.env.PENSAR_GATEWAY_URL || PENSAR_GATEWAY_BASE_URL;
+}
+function getPensarConsoleUrl() {
+  return process.env.PENSAR_CONSOLE_URL || PENSAR_CONSOLE_BASE_URL;
+}
+
+// src/core/config/index.ts
+var config = {
+  get,
+  init,
+  update
+};
+
+// src/core/auth/token.ts
+function decodeJwtPayload(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3)
+      return null;
+    const payload = Buffer.from(parts[1], "base64url").toString("utf-8");
+    return JSON.parse(payload);
+  } catch {
+    return null;
+  }
+}
+function isTokenExpired(token, bufferSeconds = 60) {
+  const payload = decodeJwtPayload(token);
+  if (!payload || typeof payload.exp !== "number")
+    return true;
+  const nowSeconds = Math.floor(Date.now() / 1000);
+  return payload.exp - nowSeconds < bufferSeconds;
+}
+var cachedClientId = null;
+async function fetchWorkOSClientId() {
+  if (cachedClientId)
+    return cachedClientId;
+  try {
+    const apiUrl = getPensarApiUrl();
+    const response = await fetch(`${apiUrl}/api/cli/config`);
+    if (!response.ok)
+      return null;
+    const data = await response.json();
+    cachedClientId = data.workosClientId;
+    return cachedClientId;
+  } catch {
+    return null;
+  }
+}
+async function refreshAccessToken(clientId, refreshToken) {
+  try {
+    const response = await fetch("https://api.workos.com/user_management/authenticate", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        client_id: clientId,
+        grant_type: "refresh_token",
+        refresh_token: refreshToken
+      })
+    });
+    if (!response.ok) {
+      console.error(`[pensar] Token refresh failed: ${response.status} ${response.statusText}`);
+      return null;
+    }
+    const data = await response.json();
+    await config.update({
+      accessToken: data.access_token,
+      refreshToken: data.refresh_token
+    });
+    return data.access_token;
+  } catch (err) {
+    console.error("[pensar] Token refresh error:", err);
+    return null;
+  }
+}
+async function ensureValidToken(cfg) {
+  if (cfg.accessToken) {
+    if (!isTokenExpired(cfg.accessToken)) {
+      return { token: cfg.accessToken, type: "workos" };
+    }
+    if (cfg.refreshToken) {
+      const clientId = await fetchWorkOSClientId();
+      if (clientId) {
+        const newToken = await refreshAccessToken(clientId, cfg.refreshToken);
+        if (newToken) {
+          return { token: newToken, type: "workos" };
+        }
+      }
+    }
+  }
+  if (cfg.pensarAPIKey) {
+    return { token: cfg.pensarAPIKey, type: "legacy" };
+  }
+  return null;
+}
+
+export { getPensarApiUrl, getPensarGatewayUrl, getPensarConsoleUrl, config, ensureValidToken };