@pensar/apex 2.5.0 → 2.6.1-canary.025b1ecf

package/build/lib/core/agents/offSecAgent/tools/index.js

@@ -0,0 +1,262 @@
+import {
+  addMemory2,
+  applyPatch2,
+  ASK_USER_QUESTIONS_TOOL_NAME2,
+  AskUserQuestionSchema2,
+  BROWSER_TOOL_NAMES2,
+  createBrowserToolsetFactories2,
+  createBrowserToolset2,
+  CallbackListenerRegistry2,
+  startCallbackListener2,
+  pollCallbackListener2,
+  stopCallbackListener2,
+  checkpointState2,
+  completeAuthentication2,
+  crawlAuthenticated2,
+  createAttackSurfaceReport2,
+  createFile2,
+  createTask2,
+  delegateAuth2,
+  deleteFile2,
+  detectAuthScheme2,
+  documentApp2,
+  documentEndpoint2,
+  documentVulnerability2,
+  createEmailToolset2,
+  EMAIL_TOOL_NAMES2,
+  SEND_EMAIL_TOOL_NAME2,
+  executeCommand2,
+  extractJsEndpoints2,
+  getMemory2,
+  getPage2,
+  gitDiff2,
+  gitStatus2,
+  globFiles2,
+  grep2,
+  httpRequest2,
+  listFiles2,
+  listMemories2,
+  listPromptInjections2,
+  listTasksTool2,
+  probeAuthEndpoints2,
+  profileCodebase2,
+  provideComparisonResults2,
+  queryWhiteboxCatalog2,
+  readFile2,
+  readSkill2,
+  REPORT_ERROR_TOOL_NAME2,
+  ReportErrorReasonSchema2,
+  createReportErrorTool2,
+  PentestReportedError2,
+  RESPONSE_TOOL_NAME2,
+  createResponseTool2,
+  runAttackSurface2,
+  runCodeQuery2,
+  runPentestWorkflow3,
+  runWhiteboxScan2,
+  SMS_LIST_MESSAGES_TOOL_NAME2,
+  SMS_TOOL_NAMES2,
+  sessionHasSmsPasswordless2,
+  smsListMessages2,
+  spawnCodingAgent2,
+  spawnPentestAgent2,
+  spawnPentestSwarm2,
+  submitPlan2,
+  testEndpointVariations2,
+  updateFile2,
+  updateTask2,
+  validateDiscovery2,
+  webSearch2,
+  createWhiteboxCandidate2,
+  updateWhiteboxCandidate2,
+  listWhiteboxCandidates2,
+  startWhiteboxJob2,
+  pollWhiteboxJob2,
+  stopWhiteboxJob2,
+  readWhiteboxArtifact2,
+  listWorkspaceApps2,
+  createWorkspaceApp2,
+  updateWorkspaceApp2,
+  listWorkspaceEndpoints2,
+  createWorkspaceEndpoint2,
+  updateWorkspaceEndpoint2,
+  listWorkspaceDomains2,
+  createWorkspaceDomain2,
+  writePlan2,
+  listToolRegistryNames2,
+  createAllTools2,
+  createToolsForNames2,
+  WORKSPACE_TOOL_NAMES2,
+  WORKSPACE_WRITE_TOOL_NAMES2,
+  ALL_TOOL_NAMES2,
+  FAST_STRIKE_EXCLUDED_TOOL_NAMES2,
+  PLAN_MODE_TOOL_NAMES2,
+  SKILL_TOOL_NAMES2
+} from "../../../../chunk-gdrv2h1p.js";
+import"../../../../chunk-ja7j565c.js";
+import"../../../../chunk-3q89v4xv.js";
+import {
+  readSandboxAgentEnv2,
+  PerCommandShell2,
+  PatchApplyError2,
+  applyFileDiff2,
+  parseUnifiedDiff2,
+  resolveBrowserHeaderPolicy2,
+  transformScriptToFunction2,
+  parseStorageStateResult2,
+  setHeadlessMode2,
+  setUserAgent2,
+  setViewportSize2,
+  PlaywrightMcpSession2,
+  createBrowserTools2,
+  ScopeViolationError2,
+  resolverSessionFromCtx2,
+  getAllowedHosts2,
+  isHostAllowed2,
+  extractHostname2,
+  assertUrlInScope2,
+  extractHostsFromCommand2,
+  assertCommandInScope2,
+  checkSandboxPlaywright2,
+  installSandboxPlaywright2,
+  ensureSandboxPlaywright2,
+  ensureSandboxBrowser2,
+  SandboxBrowserBackend2,
+  createSandboxBrowserTools2
+} from "../../../../chunk-fy3bbbqy.js";
+import"../../../../chunk-8d8w07a9.js";
+import"../../../../chunk-t5bt5vn1.js";
+import"../../../../chunk-eb4h4k1f.js";
+import"../../../../chunk-vx228eeq.js";
+import"../../../../chunk-sgd2126b.js";
+import"../../../../chunk-8vhr65w3.js";
+import"../../../../chunk-2njv7wz3.js";
+import"../../../../chunk-jdjagvgr.js";
+import"../../../../chunk-kfvq4m1s.js";
+import"../../../../chunk-zrbqn62x.js";
+import"../../../../chunk-mv74mq5n.js";
+import"../../../../chunk-bx94rwt5.js";
+export {
+  ALL_TOOL_NAMES2 as ALL_TOOL_NAMES,
+  ASK_USER_QUESTIONS_TOOL_NAME2 as ASK_USER_QUESTIONS_TOOL_NAME,
+  AskUserQuestionSchema2 as AskUserQuestionSchema,
+  BROWSER_TOOL_NAMES2 as BROWSER_TOOL_NAMES,
+  CallbackListenerRegistry2 as CallbackListenerRegistry,
+  EMAIL_TOOL_NAMES2 as EMAIL_TOOL_NAMES,
+  EMAIL_TOOL_NAMES2 as EMAIL_TOOL_NAMES_ACTIVE,
+  FAST_STRIKE_EXCLUDED_TOOL_NAMES2 as FAST_STRIKE_EXCLUDED_TOOL_NAMES,
+  PLAN_MODE_TOOL_NAMES2 as PLAN_MODE_TOOL_NAMES,
+  PatchApplyError2 as PatchApplyError,
+  PentestReportedError2 as PentestReportedError,
+  PerCommandShell2 as PerCommandShell,
+  PlaywrightMcpSession2 as PlaywrightMcpSession,
+  REPORT_ERROR_TOOL_NAME2 as REPORT_ERROR_TOOL_NAME,
+  RESPONSE_TOOL_NAME2 as RESPONSE_TOOL_NAME,
+  ReportErrorReasonSchema2 as ReportErrorReasonSchema,
+  SEND_EMAIL_TOOL_NAME2 as SEND_EMAIL_TOOL_NAME,
+  SKILL_TOOL_NAMES2 as SKILL_TOOL_NAMES,
+  SMS_LIST_MESSAGES_TOOL_NAME2 as SMS_LIST_MESSAGES_TOOL_NAME,
+  SMS_TOOL_NAMES2 as SMS_TOOL_NAMES,
+  SMS_TOOL_NAMES2 as SMS_TOOL_NAMES_ACTIVE,
+  SandboxBrowserBackend2 as SandboxBrowserBackend,
+  ScopeViolationError2 as ScopeViolationError,
+  WORKSPACE_TOOL_NAMES2 as WORKSPACE_TOOL_NAMES,
+  WORKSPACE_WRITE_TOOL_NAMES2 as WORKSPACE_WRITE_TOOL_NAMES,
+  addMemory2 as addMemory,
+  applyFileDiff2 as applyFileDiff,
+  applyPatch2 as applyPatch,
+  assertCommandInScope2 as assertCommandInScope,
+  assertUrlInScope2 as assertUrlInScope,
+  checkSandboxPlaywright2 as checkSandboxPlaywright,
+  checkpointState2 as checkpointState,
+  completeAuthentication2 as completeAuthentication,
+  crawlAuthenticated2 as crawlAuthenticated,
+  createAllTools2 as createAllTools,
+  createAttackSurfaceReport2 as createAttackSurfaceReport,
+  createBrowserTools2 as createBrowserTools,
+  createBrowserToolset2 as createBrowserToolset,
+  createBrowserToolsetFactories2 as createBrowserToolsetFactories,
+  createEmailToolset2 as createEmailToolset,
+  createFile2 as createFile,
+  createReportErrorTool2 as createReportErrorTool,
+  createResponseTool2 as createResponseTool,
+  createSandboxBrowserTools2 as createSandboxBrowserTools,
+  createTask2 as createTask,
+  createToolsForNames2 as createToolsForNames,
+  createWhiteboxCandidate2 as createWhiteboxCandidate,
+  createWorkspaceApp2 as createWorkspaceApp,
+  createWorkspaceDomain2 as createWorkspaceDomain,
+  createWorkspaceEndpoint2 as createWorkspaceEndpoint,
+  delegateAuth2 as delegateAuth,
+  deleteFile2 as deleteFile,
+  detectAuthScheme2 as detectAuthScheme,
+  documentApp2 as documentApp,
+  documentEndpoint2 as documentEndpoint,
+  documentVulnerability2 as documentVulnerability,
+  ensureSandboxBrowser2 as ensureSandboxBrowser,
+  ensureSandboxPlaywright2 as ensureSandboxPlaywright,
+  executeCommand2 as executeCommand,
+  extractHostname2 as extractHostname,
+  extractHostsFromCommand2 as extractHostsFromCommand,
+  extractJsEndpoints2 as extractJsEndpoints,
+  getAllowedHosts2 as getAllowedHosts,
+  getMemory2 as getMemory,
+  getPage2 as getPage,
+  gitDiff2 as gitDiff,
+  gitStatus2 as gitStatus,
+  globFiles2 as globFiles,
+  grep2 as grep,
+  httpRequest2 as httpRequest,
+  installSandboxPlaywright2 as installSandboxPlaywright,
+  isHostAllowed2 as isHostAllowed,
+  listFiles2 as listFiles,
+  listMemories2 as listMemories,
+  listPromptInjections2 as listPromptInjections,
+  listTasksTool2 as listTasksTool,
+  listToolRegistryNames2 as listToolRegistryNames,
+  listWhiteboxCandidates2 as listWhiteboxCandidates,
+  listWorkspaceApps2 as listWorkspaceApps,
+  listWorkspaceDomains2 as listWorkspaceDomains,
+  listWorkspaceEndpoints2 as listWorkspaceEndpoints,
+  parseStorageStateResult2 as parseStorageStateResult,
+  parseUnifiedDiff2 as parseUnifiedDiff,
+  pollCallbackListener2 as pollCallbackListener,
+  pollWhiteboxJob2 as pollWhiteboxJob,
+  probeAuthEndpoints2 as probeAuthEndpoints,
+  profileCodebase2 as profileCodebase,
+  provideComparisonResults2 as provideComparisonResults,
+  queryWhiteboxCatalog2 as queryWhiteboxCatalog,
+  readFile2 as readFile,
+  readSandboxAgentEnv2 as readSandboxAgentEnv,
+  readSkill2 as readSkill,
+  readWhiteboxArtifact2 as readWhiteboxArtifact,
+  resolveBrowserHeaderPolicy2 as resolveBrowserHeaderPolicy,
+  resolverSessionFromCtx2 as resolverSessionFromCtx,
+  runAttackSurface2 as runAttackSurface,
+  runCodeQuery2 as runCodeQuery,
+  runPentestWorkflow3 as runPentestWorkflow,
+  runWhiteboxScan2 as runWhiteboxScan,
+  sessionHasSmsPasswordless2 as sessionHasSmsPasswordless,
+  setHeadlessMode2 as setHeadlessMode,
+  setUserAgent2 as setUserAgent,
+  setViewportSize2 as setViewportSize,
+  smsListMessages2 as smsListMessages,
+  spawnCodingAgent2 as spawnCodingAgent,
+  spawnPentestAgent2 as spawnPentestAgent,
+  spawnPentestSwarm2 as spawnPentestSwarm,
+  startCallbackListener2 as startCallbackListener,
+  startWhiteboxJob2 as startWhiteboxJob,
+  stopCallbackListener2 as stopCallbackListener,
+  stopWhiteboxJob2 as stopWhiteboxJob,
+  submitPlan2 as submitPlan,
+  testEndpointVariations2 as testEndpointVariations,
+  transformScriptToFunction2 as transformScriptToFunction,
+  updateFile2 as updateFile,
+  updateTask2 as updateTask,
+  updateWhiteboxCandidate2 as updateWhiteboxCandidate,
+  updateWorkspaceApp2 as updateWorkspaceApp,
+  updateWorkspaceEndpoint2 as updateWorkspaceEndpoint,
+  validateDiscovery2 as validateDiscovery,
+  webSearch2 as webSearch,
+  writePlan2 as writePlan
+};

package/build/lib/core/agents/offSecAgent/tools/listFiles.d.ts

@@ -0,0 +1,9 @@
+import type { ListFilesResult } from "./listFilesImpl";
+import type { ToolContext } from "./types";
+export { listRecursive } from "./listFilesImpl";
+export type { ListFilesResult };
+export declare function listFiles(ctx: ToolContext): import("ai").Tool<{
+    toolCallDescription: string;
+    directory?: string | undefined;
+    recursive?: boolean | undefined;
+}, ListFilesResult>;

package/build/lib/core/agents/offSecAgent/tools/listFilesImpl.d.ts

@@ -0,0 +1,27 @@
+import type { ListOpts } from "../../../tools/backends/types";
+import type { ToolContext } from "./types";
+export type ListFilesResult = {
+    success: boolean;
+    error: string;
+    files: string[];
+    directory: string;
+    count: number;
+    totalFound?: number;
+    /** Set when `totalFound` is a lower bound (the walk stopped early), not an exact count. */
+    totalFoundLowerBound?: boolean;
+    truncated?: boolean;
+};
+export declare const MAX_RECURSIVE = 200;
+export declare const MAX_NON_RECURSIVE = 500;
+/**
+ * Depth-first readdir walk that stops at the (maxEntries + 1)-th collected
+ * path — the overflow witness — instead of walking the whole tree for an
+ * exact total. First `maxEntries` paths match the unbounded walk on the same
+ * runtime (shared readdir order); visited directories still pay their full
+ * native width enumeration (docs/performance/pr-08-listing-result-limit.md).
+ */
+export declare function listRecursive(dir: string, maxEntries: number, signal?: AbortSignal): Promise<{
+    paths: string[];
+    truncated: boolean;
+}>;
+export declare function listFilesImpl(ctx: ToolContext, directory: string, o?: ListOpts): Promise<ListFilesResult>;

package/build/lib/core/agents/offSecAgent/tools/listMemories.d.ts

@@ -0,0 +1,13 @@
+import { type MemorySummary } from "../../../memory";
+import type { ToolContext } from "./types";
+export type ListMemoriesResult = {
+    success: boolean;
+    error: string;
+    memories: MemorySummary[];
+    count: number;
+};
+export declare function listMemories(ctx: ToolContext): import("ai").Tool<{
+    toolCallDescription: string;
+    category?: "framework" | "app" | "general" | undefined;
+    tag?: string | undefined;
+}, ListMemoriesResult>;

package/build/lib/core/agents/offSecAgent/tools/listPromptInjections.d.ts

@@ -0,0 +1,18 @@
+import type { ToolContext } from "./types";
+export declare function listPromptInjections(ctx: ToolContext): import("ai").Tool<{
+    toolCallDescription: string;
+    category?: string | undefined;
+    tag?: string | undefined;
+}, {
+    success: boolean;
+    configured: boolean;
+    count: number;
+    injections: never[];
+    error: string;
+} | {
+    success: boolean;
+    configured: boolean;
+    count: number;
+    injections: import("../../../prompt-injections").PromptInjectionCatalogEntry[];
+    error?: undefined;
+}>;

package/build/lib/core/agents/offSecAgent/tools/listTasks.d.ts

@@ -0,0 +1,24 @@
+import type { ToolContext } from "./types";
+type ListTasksResult = {
+    success: boolean;
+    error?: string;
+    tasks: Array<{
+        id: number;
+        subject: string;
+        status: string;
+        objective: string;
+        technique: string;
+        result?: string;
+    }>;
+    summary: {
+        total: number;
+        pending: number;
+        in_progress: number;
+        completed: number;
+        failed: number;
+    };
+};
+export declare function listTasksTool(ctx: ToolContext): import("ai").Tool<{
+    status?: "pending" | "in_progress" | "completed" | "failed" | undefined;
+}, ListTasksResult>;
+export {};

package/build/lib/core/agents/offSecAgent/tools/patchApply.d.ts

@@ -0,0 +1,24 @@
+import type { ParsedFileDiff } from "./patchParse";
+export type EolAdaptation = "none" | "added-cr" | "stripped-cr" | "matched-lines";
+export type AppliedHunkOutcome = {
+    /** Old-side line the hunk actually matched at (1-based, original file). */
+    matchedAt: number;
+    /** Line drift from the declared oldStart (negative = earlier). */
+    offset: number;
+};
+export declare class PatchApplyError extends Error {
+    readonly hunkIndex: number;
+    readonly kind: "no-context-match" | "invalid-hunk";
+    constructor(message: string, hunkIndex: number, kind?: "no-context-match" | "invalid-hunk");
+}
+/**
+ * Apply a file diff's hunks to content. Hunks are located against the
+ * original content (overlaps and same-point insertions rejected), then
+ * spliced bottom-up so earlier hunks' line numbers stay valid. Returns the
+ * new content plus per-hunk match positions for receipts.
+ */
+export declare function applyFileDiff(content: string, file: ParsedFileDiff): {
+    content: string;
+    outcomes: AppliedHunkOutcome[];
+    eolAdaptation: EolAdaptation;
+};

package/build/lib/core/agents/offSecAgent/tools/patchParse.d.ts

@@ -0,0 +1,24 @@
+export type PatchLineTag = "context" | "delete" | "add";
+export type PatchLine = {
+    tag: PatchLineTag;
+    text: string;
+};
+export type ParsedHunk = {
+    oldStart: number;
+    oldCount: number;
+    newStart: number;
+    newCount: number;
+    lines: PatchLine[];
+    /** The hunk's final old-side line has no trailing newline in the source. */
+    oldEndsWithoutNewline: boolean;
+    /** The hunk's final new-side line has no trailing newline in the result. */
+    newEndsWithoutNewline: boolean;
+};
+export type ParsedFileDiff = {
+    oldPath: string;
+    newPath: string;
+    hunks: ParsedHunk[];
+    isNew: boolean;
+    isDelete: boolean;
+};
+export declare function parseUnifiedDiff(patch: string): ParsedFileDiff[];

package/build/lib/core/agents/offSecAgent/tools/perCommandShell.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Workspace-configured agent environment variables, transported into the
+ * sandbox as a single JSON blob (`PENSAR_AGENT_ENV_VARS`) by the platform's
+ * dispatch layer. They are merged into every command's environment.
+ *
+ * Fail-soft: a missing or malformed blob yields no extra vars rather than
+ * throwing — a parse failure must not break command execution.
+ */
+export declare function readSandboxAgentEnv(): Record<string, string>;
+export interface ShellExecuteOptions {
+    /** Working directory for this invocation; defaults to the executor's cwd. */
+    cwd?: string;
+    /** Per-invocation environment, highest precedence below the shell controls. */
+    env?: Record<string, string>;
+    /** Deadline in seconds; omit for no deadline (caller abort still applies). */
+    timeoutSeconds?: number;
+    abortSignal?: AbortSignal;
+    /** Live stdout chunks as they arrive (best-effort UX, not authoritative). */
+    onData?: (chunk: string) => void;
+}
+export interface ShellExecuteResult {
+    stdout: string;
+    stderr: string;
+    /** Real exit code, or 124 (timeout) / 130 (abort or cancel) on kill paths. */
+    exitCode: number;
+    timedOut: boolean;
+    stdoutTruncated: boolean;
+    stderrTruncated: boolean;
+    /**
+     * True when the terminating path never observed the process group gone
+     * within its bounded window (posix), or on any kill path on win32 where
+     * only the leader can be signalled. Cleanup may be incomplete; this is
+     * surfaced rather than silently succeeding. Children that left the group
+     * (setsid) are not owned and are not claimed.
+     */
+    cleanupUnconfirmed: boolean;
+}
+/**
+ * Fresh shell per invocation: every `execute` runs the command in a NEW
+ * process group with an explicit working directory and the configured,
+ * curated environment. Nothing — cwd, exports, functions, background jobs —
+ * carries across calls; there is no persistent job table. Children that
+ * redirect their stdio survive a completed SUCCESS as ordinary processes;
+ * timeout/abort/cancel and completed-nonzero exits all run one terminating
+ * path that TERM→KILLs the invocation's own group and settles only once the
+ * group is observed gone (bounded). Calls are FIFO-serialized, so
+ * cancel/dispose always address exactly one active invocation.
+ */
+export declare class PerCommandShell {
+    private readonly cwd?;
+    private readonly extraEnv?;
+    private disposed;
+    private active;
+    private activeCompletion;
+    private disposeBarrier;
+    private writeChain;
+    constructor(opts?: {
+        cwd?: string;
+        env?: Record<string, string>;
+    });
+    execute(command: string, opts?: ShellExecuteOptions): Promise<ShellExecuteResult>;
+    executeArgv(executable: string, args: readonly string[], opts?: ShellExecuteOptions): Promise<ShellExecuteResult>;
+    private executeInvocation;
+    private runInvocation;
+    /**
+     * Cancel the invocation currently owned by this executor. Returns true when
+     * a live invocation was cancelled; queued invocations and previously
+     * completed invocations' surviving services are untouched.
+     */
+    cancelCurrentCommand(): boolean;
+    /**
+     * Settle and clean the active invocation (if any), refuse further
+     * invocations, and drain the FIFO tail of already-queued calls. Returns an
+     * idempotent barrier that resolves once every owned invocation — the
+     * active one AND previously queued ones — has settled; the 3s kill
+     * protocol is never fire-and-forget. Never touches processes left behind
+     * by previously completed invocations — those are untracked and owned by
+     * their launcher.
+     */
+    dispose(): Promise<void>;
+    private acquireTurn;
+}