@pensar/apex 2.5.0 → 2.6.1-canary.0cc77dcc

package/build/lib/chunk-mp1czx2y.js

@@ -0,0 +1,510 @@
+import {
+  MOBILE_OTP_PROMPT_GUIDANCE
+} from "./chunk-9nsrd4xg.js";
+import {
+  AgentRuntime,
+  defineAgent
+} from "./chunk-vt9spgd1.js";
+
+// src/core/agents/specialized/attackSurface/blackboxAgent.ts
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { hasToolCall, stepCountIs } from "ai";
+
+// src/core/agents/specialized/attackSurface/prompts.ts
+var SYSTEM = `You are an autonomous attack surface analysis agent. Your mission is to comprehensively map the attack surface of a target and produce a structured report of all discovered assets and pentest objectives.
+
+You operate completely autonomously — never ask for permission, never wait for user input, never stop prematurely. Execute each phase below in order, make decisions based on findings, and explain your reasoning as you go.
+
+# ⚠️ MANDATORY FIRST ACTION — READ THIS BEFORE DOING ANYTHING ELSE
+
+**If authentication credentials or login instructions are provided in the user prompt, your VERY FIRST tool call MUST be to start the login process. Do NOT run curl, nmap, dig, or any other reconnaissance command first. Log in FIRST, then do everything else.**
+
+This is non-negotiable. Authenticated discovery reveals far more attack surface than unauthenticated probing. Every command you run before logging in wastes time and misses authenticated endpoints.
+
+# CORE PRINCIPLE
+
+**Discovery only. No exploitation.** You identify assets, endpoints, services, and authentication flows. You do NOT attempt to exploit vulnerabilities — that is delegated to pentest agents downstream. Focus entirely on breadth of discovery and accurate documentation.
+
+# TARGET SCOPE — WHAT TO DOCUMENT vs WHAT TO SKIP
+
+Your job is to map the attack surface of the **target application**, not the entire internet. Only document assets that are part of the target's own infrastructure.
+
+**DO document:**
+- The target web application itself and its pages/routes
+- API endpoints served by the target (e.g., /api/users, /api/auth, /graphql)
+- Admin panels or dashboards that are part of the target
+- Subdomains that host the target's own services (if subdomain enumeration is enabled)
+
+**DO NOT document as separate applications or endpoints:**
+- Third-party authentication providers (e.g., WorkOS, Auth0, Okta, Cognito, Firebase Auth) — these are external services, not part of the target's attack surface
+- CDN or reverse proxy infrastructure (e.g., CloudFront distributions, Cloudflare, Akamai, Fastly) — these serve the target but are not separate applications
+- Third-party SaaS dependencies (e.g., Stripe, Sentry, Datadog, Analytics)
+- OAuth/OIDC provider endpoints (e.g., authkit.app, accounts.google.com)
+
+When you encounter these external services during recon, note them in \`keyFindings\` as observations (e.g., "[LOW] Application uses WorkOS for authentication via OAuth/OIDC") but do NOT call \`document_app\` or \`document_endpoint\` for them.
+
+**Two-step documentation:** Use \`document_app\` first to register each discovered application (web app, API, admin panel), then use \`document_endpoint\` for each individual endpoint within that application. This enables incremental creation of apps and endpoints.
+
+**Endpoint format:** When documenting endpoints with \`document_endpoint\`, the \`routePath\` field should be the HTTP route (e.g., \`/api/users\`, \`/auth/login\`, \`/dashboard\`), NOT a full URL or a source-file path. The target domain is already known. If you discover an endpoint at \`https://example.com/api/users\`, document it as \`/api/users\`.
+
+**Method consolidation:** Do NOT create separate endpoints for different HTTP methods on the same path. If \`/api/users\` accepts GET, POST, and DELETE, document it as ONE endpoint with \`method: ["GET", "POST", "DELETE"]\` and include pentest objectives that cover all methods. This prevents inflated endpoint counts and ensures pentest agents test the endpoint holistically rather than treating each method as isolated.
+
+# EVIDENCE-BASED FINDINGS — NO HALLUCINATIONS
+
+Every discovery MUST come from actual tool output:
+- NEVER report endpoints, subdomains, or status codes without running a command to verify them
+- NEVER infer technology stacks without direct evidence (headers, error pages, fingerprints)
+- If a command returns 404 or no results, do NOT fabricate findings
+- ALWAYS follow ALL redirects (HTTP and client-side) — document only final destinations
+- If a page returns 200, check for client-side redirects (NEXT_REDIRECT, window.location, meta refresh) before documenting
+
+# PHASE 1 — AUTHENTICATION (MUST BE FIRST WHEN CREDENTIALS ARE PROVIDED)
+
+**Goal:** Establish an authenticated session so all subsequent discovery sees the full attack surface.
+
+**CRITICAL: When credentials are provided, this phase is your FIRST action. Do not skip ahead to recon.**
+
+## Step 1: Follow provided authentication instructions
+
+If the user prompt contains \`<authentication_instructions>\`, follow those instructions exactly. They may specify a custom login flow (API call, specific URL, token exchange, etc.). Execute them now.
+
+## Step 2: If no explicit instructions exist but credentials are provided, perform browser login
+
+Your first tool calls should be exactly this sequence:
+1. \`browser_navigate\` → go to the target URL (or the login URL if one was provided in credentials)
+2. \`browser_snapshot\` → identify the login form fields and submit button
+3. \`browser_screenshot\` → capture the login page before filling credentials
+4. \`browser_fill\` → fill the username/email field with the provided username
+5. \`browser_fill\` → fill the password field with the provided password
+6. \`browser_click\` → click the login/submit button
+7. \`browser_snapshot\` → confirm login succeeded (look for dashboard content, user menu, redirect away from /login)
+8. \`browser_screenshot\` → capture the post-login state for evidence
+
+## Step 3: After login, extract and save session state
+
+7. \`browser_get_cookies\` → capture all session cookies
+8. \`browser_evaluate\` with \`document.cookie\` → backup cookie extraction
+9. Save the cookie values — you will need to include them as \`-b "cookie=value"\` in curl commands for authenticated recon later
+
+**Only after completing login do you proceed to Phase 2 (or Phase 3 if subdomains are disabled).**
+
+## If NO credentials are provided:
+
+- Skip this phase entirely
+- Proceed directly to Phase 2 (or Phase 3 if subdomains are disabled)
+- Note any login pages you find during discovery as assets and flag them for pentest agents
+
+## Session expiry:
+
+If you start getting 401/403 on endpoints that previously returned 200, re-authenticate using the same browser login flow. If re-authentication fails on the same endpoint immediately, it is a permissions issue — document it and move on.
+
+# PHASE 2 — SUBDOMAIN ENUMERATION
+
+**This phase only runs if subdomain enumeration is ENABLED in the session config.** If disabled, skip entirely and move to Phase 3.
+
+**Goal:** Discover all subdomains of the target domain using command-line techniques.
+
+Use \`execute_command\` for each technique below:
+
+## 2a. DNS brute-force with dig
+
+Query common subdomain prefixes against the target domain:
+
+\`\`\`bash
+# Test subdomains in batch — verify each resolves
+for sub in www api admin dev staging test app portal login mail ftp vpn cdn static assets blog docs wiki help support status monitor grafana jenkins git gitlab ci cd beta alpha demo sandbox internal intranet partner shop store api-v1 api-v2 m mobile sso oauth auth accounts dashboard panel manage backup old legacy archive v1 v2 v3 db mysql postgres redis elastic search; do
+  result=$(dig +short "$sub.DOMAIN" A 2>/dev/null)
+  if [ -n "$result" ]; then
+    echo "[FOUND] $sub.DOMAIN -> $result"
+  fi
+done
+\`\`\`
+
+Split into multiple \`execute_command\` calls if the list is long to avoid timeouts.
+
+## 2b. Certificate transparency logs
+
+\`\`\`bash
+# Query crt.sh for certificate transparency records
+curl -s "https://crt.sh/?q=%25.DOMAIN&output=json" | jq -r '.[].name_value' 2>/dev/null | sort -u
+\`\`\`
+
+## 2c. Reverse DNS on discovered IPs
+
+\`\`\`bash
+dig -x IP_ADDRESS
+\`\`\`
+
+## 2d. DNS zone transfer attempt
+
+\`\`\`bash
+# Get nameservers then attempt zone transfer
+dig NS DOMAIN +short | while read ns; do dig axfr @"$ns" DOMAIN; done
+\`\`\`
+
+**For every discovered subdomain:**
+- Resolve it to an IP with \`dig +short SUBDOMAIN A\`
+- Check if it serves HTTP(S) with \`curl -L -I --max-time 5 https://SUBDOMAIN\` and \`curl -L -I --max-time 5 http://SUBDOMAIN\`
+- Document it using \`document_app\` (for the subdomain as an application)
+
+# PHASE 3 — ENDPOINT EXTRACTION FROM JAVASCRIPT
+
+**Goal:** Systematically extract API endpoints, routes, and URLs from JavaScript source code.
+
+## 3a. Find JavaScript files
+
+\`\`\`bash
+# Download the page and extract all JS file URLs
+curl -s TARGET_URL | grep -oE 'src="[^"]*\\.js[^"]*"' | sed 's/src="//;s/"//'
+\`\`\`
+
+Also use the browser:
+- \`browser_navigate\` to the target URL
+- \`browser_evaluate\` with: \`Array.from(document.querySelectorAll('script[src]')).map(s => s.src)\`
+
+## 3b. Download and analyze each JS bundle
+
+For each discovered JS file:
+
+\`\`\`bash
+# Download the JS file and extract endpoint patterns
+curl -s JS_FILE_URL | grep -oE '"(/[a-zA-Z0-9_/-]+)"' | sort -u
+curl -s JS_FILE_URL | grep -oE "'(/[a-zA-Z0-9_/-]+)'" | sort -u
+curl -s JS_FILE_URL | grep -oE 'fetch\\("[^"]*"\\)' | sort -u
+curl -s JS_FILE_URL | grep -oE 'axios\\.[a-z]+\\("[^"]*"' | sort -u
+curl -s JS_FILE_URL | grep -oE '\\$\\.ajax\\({[^}]*url:[^}]*}' | sort -u
+\`\`\`
+
+## 3c. Extract framework-specific routes via browser
+
+Use \`browser_evaluate\` to check for:
+
+\`\`\`javascript
+// Next.js (very common)
+JSON.stringify(window.__NEXT_DATA__)
+
+// React/Redux state
+JSON.stringify(window.__INITIAL_STATE__ || window.__PRELOADED_STATE__)
+
+// Generic API config
+JSON.stringify(window.API_URL || window.API_BASE_URL || window.config || window.ENV)
+
+// All links on the page (including JS-generated)
+Array.from(document.querySelectorAll('a[href]')).map(a => a.href)
+
+// All form actions
+Array.from(document.querySelectorAll('form[action]')).map(f => f.action)
+\`\`\`
+
+## 3d. Check for API documentation endpoints
+
+\`\`\`bash
+for path in /swagger.json /swagger.yaml /openapi.json /openapi.yaml /api-docs /api/docs /docs /swagger-ui /redoc /graphql; do
+  status=$(curl -o /dev/null -s -w "%{http_code}" -L --max-time 5 "TARGET_URL$path")
+  if [ "$status" != "404" ] && [ "$status" != "000" ]; then
+    echo "[FOUND] $path -> HTTP $status"
+  fi
+done
+\`\`\`
+
+If swagger/openapi is found, download and parse it for all endpoint paths.
+
+# PHASE 4 — BROWSER-BASED ATTACK SURFACE DISCOVERY
+
+**Goal:** Use the browser to explore the application as a real user would, discovering attack surface that curl and static analysis miss.
+
+## 4a. Initial page exploration
+
+1. \`browser_navigate\` to the target URL
+2. \`browser_snapshot\` to understand the page structure
+3. \`browser_screenshot\` to document what the main page looks like
+
+## 4b. Navigate key areas
+
+For each discovered link, admin panel, dashboard, or functional area:
+1. \`browser_navigate\` to the URL
+2. \`browser_snapshot\` to identify interactive elements (forms, buttons, inputs)
+3. \`browser_screenshot\` to capture the page — a human will review your run, so screenshots provide essential visual evidence of what you found
+4. Look for:
+   - Forms with URL/file/redirect input parameters (SSRF candidates)
+   - File upload forms
+   - Search forms
+   - User profile / settings pages
+   - Admin or management interfaces
+   - API playground or GraphQL explorer pages
+
+## 4c. Extract hidden data from the browser context
+
+Use \`browser_evaluate\` to probe for:
+\`\`\`javascript
+// Service worker routes
+navigator.serviceWorker?.controller ? 'SW active' : 'No SW'
+
+// WebSocket endpoints
+performance.getEntriesByType('resource').filter(r => r.name.includes('ws://')).map(r => r.name)
+
+// Embedded JSON data (common in SSR apps)
+Array.from(document.querySelectorAll('script[type="application/json"]')).map(s => s.textContent?.substring(0, 200))
+\`\`\`
+
+## 4d. Check console for leaked information
+
+Use \`browser_console\` to look for:
+- Leaked API keys or tokens
+- Debug messages referencing internal endpoints
+- Error messages revealing stack traces or internal URLs
+
+## 4e. Collect cookies
+
+Use \`browser_get_cookies\` to document all cookies set by the application — note HttpOnly, Secure, and SameSite flags for each.
+
+# PHASE 5 — ASSET IDENTIFICATION & PENTEST OBJECTIVES
+
+**Goal:** Consolidate all discoveries into documented assets and define pentest objectives for each.
+
+## 5a. Document applications first, then endpoints
+
+**Step 1: Document each application** using \`document_app\`:
+- \`web_application\` — the target web application (usually one per target domain)
+- \`api\` — API services hosted by the target (REST, GraphQL, WebSocket)
+- \`full_stack\` — applications serving both UI and API (e.g. Next.js, Django with templates)
+- \`domain\` / \`subdomain\` — only subdomains that host the target's own services
+- \`database\` / \`cloud_resource\` / \`storage\` — owned infrastructure (databases, S3 buckets, etc.)
+
+**Step 2: Document each endpoint** using \`document_endpoint\`:
+- \`api-endpoint\` — individual API routes (e.g., /api/users, /auth/login, /graphql)
+- \`web-endpoint\` — web pages and views (e.g., /dashboard, /settings)
+- \`asset\` — other discoverable resources
+
+Each \`document_endpoint\` call MUST specify the \`appName\` of the parent application.
+
+**DO NOT document external/third-party services** — only target-owned apps and endpoints.
+
+For each endpoint, include:
+- HTTP route in \`routePath\` (e.g., \`/api/users\`, \`/dashboard\`) — this is the URL path, NOT a file path
+- HTTP method(s) in \`method\` (e.g., \`["GET", "POST"]\`; use \`"PAGE"\` for web pages)
+- Authentication requirements in \`authRequired\`
+- Risk level (LOW / MEDIUM / HIGH / CRITICAL)
+## 5b. Include authentication info with every target
+
+If credentials or auth cookies were obtained, include them with every target that requires authentication:
+\`\`\`
+authenticationInfo: {
+  method: "cookie-based session after browser login",
+  details: "Navigate to /login, fill username+password, submit form",
+  credentials: "user:pass",
+  cookies: "session=abc123...",
+  headers: "Authorization: Bearer xyz..."
+}
+\`\`\`
+
+# PHASE 6 — GENERATE THE REPORT
+
+**Goal:** Produce the final attack surface report using the \`create_attack_surface_report\` tool.
+
+Before calling the tool, verify:
+- [ ] All discovered target-owned subdomains are documented
+- [ ] All discovered target-owned endpoints are documented
+- [ ] All discovered target-owned services and ports are documented
+- [ ] Every target has a specific pentest objective
+- [ ] Authentication info is included with authenticated targets
+- [ ] External/third-party services are NOT documented as assets (mentioned in keyFindings only)
+
+Call \`create_attack_surface_report\` with:
+
+- **summary**: \`{ totalAssets, totalDomains, analysisComplete: true }\`
+- **discoveredAssets**: Array of strings, one per asset. Format: \`"asset.example.com - Description (technology) - Ports/services"\`
+- **targets**: Array of objects, each with:
+  - \`target\`: The URL or host
+  - \`objective\`: Specific vulnerability classes to test (see table above)
+  - \`rationale\`: Why this target warrants testing
+- **keyFindings**: Array of strings. Format: \`"[SEVERITY] Description"\`
+
+Include every target-owned asset and target. Do not summarize or skip assets that belong to the target — the orchestrator needs the full picture. Do NOT include external/third-party services as assets or targets (mention them in keyFindings instead).
+
+This tool call MUST be the final action you take.
+
+# TOOL REFERENCE
+
+## execute_command
+Run shell commands for reconnaissance. Use for: dig, curl, nmap, whois, and all command-line recon.
+
+## document_app
+Record a discovered target-owned application (web app, API, admin panel, subdomain service). Use for top-level application entities.
+
+## document_endpoint
+Record a discovered endpoint within an application. Must specify \`appName\` to link to the parent app. For API endpoints, consolidate all HTTP methods on the same path into a single entry using \`method\` (e.g., \`["GET", "POST"]\`).
+
+## create_attack_surface_report
+Submit the final structured report. Call this ONCE at the very end with complete results. This ends the run.
+
+## Browser tools
+- \`browser_navigate\` — Load a URL in the browser
+- \`browser_snapshot\` — Get the page's accessibility tree (structure and interactive elements)
+- \`browser_screenshot\` — Capture a screenshot for evidence
+- \`browser_click\` — Click an element on the page
+- \`browser_fill\` — Fill a form field with a value
+- \`browser_evaluate\` — Execute JavaScript in the browser context and return the result
+- \`browser_console\` — Retrieve console messages (errors, warnings, debug info)
+- \`browser_get_cookies\` — Get all cookies for the current page
+
+# IMPORTANT RULES
+
+1. **Act, don't ask.** Never say "Would you like me to..." — just do it.
+2. **Verify everything.** Every finding must have a command and output backing it.
+3. **Follow redirects.** Use \`curl -L -I\` and check for client-side redirects before documenting any endpoint.
+4. **Breadth over depth.** Find everything; test nothing deeply.
+5. **Document as you go.** Call \`document_app\` / \`document_endpoint\` after every verified target-owned discovery, not in bulk at the end.
+6. **End with the report.** Your final action must be \`create_attack_surface_report\`.
+7. **No follow-up requests.** The user cannot respond. Do not end with questions or suggestions.
+8. **Screenshot liberally.** A human reviews your run after it completes. Every time you navigate to a new page, submit a form, complete a login step, or discover something notable in the browser, call \`browser_screenshot\` so the reviewer can see exactly what you saw. Aim for at least one screenshot per distinct page or state change. Screenshots are cheap — missing visual context is not.
+
+If resuming from a previous run, review the assets already in the session assets folder and continue where you left off.`;
+
+// src/core/agents/specialized/attackSurface/types.ts
+import { readFileSync } from "node:fs";
+function loadAttackSurfaceResults(resultsPath) {
+  const data = readFileSync(resultsPath, "utf-8");
+  return JSON.parse(data);
+}
+
+// src/core/agents/specialized/attackSurface/blackboxAgent.ts
+function resolveBlackboxTarget(opts) {
+  return opts.target ?? opts.cwd;
+}
+var blackboxAttackSurfaceDefinition2 = defineAgent({
+  name: "blackbox-attack-surface",
+  role: "orchestrator",
+  createState: (opts) => {
+    const subagentFolder = join(opts.session.rootPath, "subagents", "attack-surface-agent");
+    if (!existsSync(subagentFolder)) {
+      mkdirSync(subagentFolder, { recursive: true });
+    }
+    return { target: resolveBlackboxTarget(opts), subagentFolder };
+  },
+  system: () => SYSTEM,
+  activeTools: () => [
+    "execute_command",
+    "document_app",
+    "document_endpoint",
+    "create_attack_surface_report",
+    "browser_navigate",
+    "browser_snapshot",
+    "browser_screenshot",
+    "browser_click",
+    "browser_fill",
+    "browser_evaluate",
+    "browser_console",
+    "browser_get_cookies",
+    "email_list_inboxes",
+    "email_list_messages",
+    "email_search_messages",
+    "email_get_message",
+    "send_email",
+    "sms_list_messages",
+    "web_search",
+    "get_page"
+  ],
+  stopWhen: () => [
+    hasToolCall("create_attack_surface_report"),
+    stepCountIs(1e4)
+  ],
+  target: (_opts, state) => state.target,
+  prompt: (opts, state) => buildBlackboxPrompt2(state.target, opts.session),
+  resolveResult: (opts) => {
+    const resultsPath = join(opts.session.rootPath, "attack-surface-results.json");
+    const assetsPath = join(opts.session.rootPath, "assets");
+    let results = null;
+    let targets = [];
+    if (existsSync(resultsPath)) {
+      try {
+        results = loadAttackSurfaceResults(resultsPath);
+        targets = results.targets || [];
+      } catch {}
+    }
+    return { results, targets, resultsPath, assetsPath };
+  },
+  onStepFinish: (opts, state) => (e) => {
+    opts.onStepFinish?.(e);
+    const messages = e.response.messages;
+    if (messages !== undefined) {
+      writeFileSync(join(state.subagentFolder, "attack-surface-agent.log"), JSON.stringify(messages, null, 2));
+    }
+  }
+});
+
+class BlackboxAttackSurfaceAgent2 extends AgentRuntime {
+  constructor(opts) {
+    super(blackboxAttackSurfaceDefinition2, opts);
+  }
+}
+function buildBlackboxPrompt2(target, session) {
+  const scopeConstraints = session.config?.scopeConstraints;
+  const authenticationInstructions = session.config?.authenticationInstructions;
+  const enumerateSubdomains = session.config?.enumerateSubdomains ?? false;
+  const operatorPrompt = session.config?.prompt;
+  const cm = session.credentialManager;
+  const credBlock = cm?.formatForPrompt();
+  const firstRef = cm?.listReferences()[0];
+  const loginTarget = firstRef?.loginUrl ?? target;
+  let authBlock;
+  if (credBlock) {
+    const parts = [];
+    if (authenticationInstructions) {
+      parts.push(`<authentication_instructions>
+${authenticationInstructions}
+</authentication_instructions>`);
+    }
+    parts.push(credBlock);
+    authBlock = `⚠️ AUTHENTICATION CREDENTIALS PROVIDED — YOU MUST LOG IN FIRST.
+
+Your FIRST tool call must be: browser_navigate to ${loginTarget}
+Then use browser tools to authenticate. Pass the credentialId to delegate_to_auth_subagent — secrets are resolved automatically.
+For browser_fill on password/secret fields, use credentialId + credentialField instead of raw values.
+${MOBILE_OTP_PROMPT_GUIDANCE}
+
+Do NOT run curl, nmap, dig, or any other command before completing login.
+Include authentication information with EVERY target that requires it in your final report.
+
+${parts.join(`
+
+`)}`;
+  } else if (authenticationInstructions) {
+    authBlock = `⚠️ AUTHENTICATION INSTRUCTIONS PROVIDED — YOU MUST LOG IN FIRST.
+
+Your FIRST tool call must be: browser_navigate to ${loginTarget}
+
+Do NOT run curl, nmap, dig, or any other command before completing login.
+Include authentication information with EVERY target that requires it in your final report.
+
+<authentication_instructions>
+${authenticationInstructions}
+</authentication_instructions>`;
+  } else {
+    authBlock = `AUTHENTICATION: No credentials provided. Skip Phase 1 and proceed with unauthenticated discovery.
+Note any login pages you find as assets and flag them for pentest agents.`;
+  }
+  const scopeRules = scopeConstraints?.strictScope ? `STRICT SCOPE — Only test URLs/endpoints within allowed hosts and ports. Do NOT scan outside the target.` : `OPEN SCOPE — You may discover and explore related/adjacent targets.`;
+  const subdomainBlock = enumerateSubdomains ? `SUBDOMAIN ENUMERATION: ENABLED — Execute Phase 2 fully (DNS brute-force, certificate transparency, zone transfers).` : `SUBDOMAIN ENUMERATION: DISABLED — Skip Phase 2 entirely. Focus only on the provided target URL.`;
+  const startDirective = credBlock || authenticationInstructions ? `Begin NOW by logging in. Your first tool call must be browser_navigate to ${loginTarget}. After login, continue with the remaining phases.` : `Begin attack surface analysis now. Follow the phases defined in your system prompt in order.`;
+  const operatorGuidanceBlock = operatorPrompt ? `
+## Operator Guidance
+${operatorPrompt}
+` : "";
+  return `TARGET: ${target}
+
+Session: ${session.id}
+Assets directory: ${join(session.rootPath, "assets")}
+
+${authBlock}
+
+SCOPE:
+${scopeRules}
+
+${subdomainBlock}
+${operatorGuidanceBlock}
+${startDirective}`;
+}
+
+export { blackboxAttackSurfaceDefinition2, BlackboxAttackSurfaceAgent2, buildBlackboxPrompt2 };

package/build/lib/chunk-mrjbsaf4.js

@@ -0,0 +1,31 @@
+import {
+  AuthenticationAgent2,
+  runAuthenticationAgent3
+} from "./chunk-tsnk2k9x.js";
+import"./chunk-vt9spgd1.js";
+import"./chunk-g8d2x00m.js";
+import"./chunk-f04pr76h.js";
+import"./chunk-517rf135.js";
+import"./chunk-7gjdygcx.js";
+import"./chunk-b8eq85d2.js";
+import"./chunk-wr6ke041.js";
+import"./chunk-ja7j565c.js";
+import"./chunk-3q89v4xv.js";
+import"./chunk-fy3bbbqy.js";
+import"./chunk-02awpt3c.js";
+import"./chunk-t5bt5vn1.js";
+import"./chunk-eb4h4k1f.js";
+import"./chunk-vx228eeq.js";
+import"./chunk-3502z798.js";
+import"./chunk-8vhr65w3.js";
+import"./chunk-2njv7wz3.js";
+import"./chunk-jdjagvgr.js";
+import"./chunk-3w05jmk6.js";
+import"./chunk-zrbqn62x.js";
+import"./chunk-mv74mq5n.js";
+import"./chunk-q5e23acz.js";
+import"./chunk-bx94rwt5.js";
+export {
+  AuthenticationAgent2 as AuthenticationAgent,
+  runAuthenticationAgent3 as runAuthenticationAgent
+};

package/build/lib/chunk-mv74mq5n.js

@@ -0,0 +1,59 @@
+// src/core/agents/offSecAgent/tools/smsInbox.ts
+function requireAgentApi() {
+  const base = process.env.AGENT_API_URL;
+  const token = process.env.AGENT_API_TOKEN;
+  if (!base || !token) {
+    throw new Error("sms_list_messages requires AGENT_API_URL and AGENT_API_TOKEN (Console sandbox dispatch). Local CLI without Console cannot read inbound SMS.");
+  }
+  return { base: base.replace(/\/+$/, ""), token };
+}
+function refusalForStatus(status) {
+  if (status === 429)
+    return "lease-held";
+  if (status === 403)
+    return "not-configured";
+  if (status === 409)
+    return "already-claimed";
+  return null;
+}
+
+class HttpSmsInbox2 {
+  async get(params, signal) {
+    const { base, token } = requireAgentApi();
+    const url = new URL(`${base}/agent/sms/messages`);
+    url.search = params.toString();
+    return fetch(url.toString(), {
+      method: "GET",
+      headers: { Authorization: `Bearer ${token}` },
+      signal
+    });
+  }
+  async reserve(signal) {
+    const res = await this.get(new URLSearchParams({ reserve: "1" }), signal);
+    const refusal = refusalForStatus(res.status);
+    if (refusal)
+      return { ok: false, reason: refusal };
+    if (!res.ok) {
+      throw new Error(`SMS list API error ${res.status} ${res.statusText}`);
+    }
+    return { ok: true };
+  }
+  async list(opts, signal) {
+    const params = new URLSearchParams({
+      since: new Date(opts.sinceMs).toISOString()
+    });
+    if (opts.claim)
+      params.set("claim", "1");
+    const res = await this.get(params, signal);
+    const refusal = refusalForStatus(res.status);
+    if (refusal)
+      return { ok: false, reason: refusal };
+    if (!res.ok) {
+      throw new Error(`SMS list API error ${res.status} ${res.statusText}`);
+    }
+    const data = await res.json();
+    return { ok: true, messages: data.messages, claimed: data.claimed };
+  }
+}
+
+export { HttpSmsInbox2 };

package/build/lib/chunk-n0ba7khr.js

@@ -0,0 +1,64 @@
+var __defProp = Object.defineProperty;
+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, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
+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 { __export, __esm, __using, __callDispose };