@posthog/wizard 2.38.2 → 2.39.0

package/dist/security-CSlaLY6P.js

@@ -0,0 +1,204 @@
+import { s as logToFile } from "./debug-BZnZ7Gvh.js";
+import { a as wizardCanUseTool, g as createTriageLLMProvider } from "./agent-interface-BR3zAUpM.js";
+import { c as isWizardDocumentationPath, d as repeatBlockReason, f as scanAndTriage, i as createRepeatBlockTracker, u as recordExternalScan } from "./yara-hooks-DNn1Jqih.js";
+//#region src/lib/agent/runner/harness/pi/security.ts
+/** warlock ScanMatch → the report shape `recordExternalScan` expects. */
+function toReportViolation(m) {
+	return {
+		rule: m.rule,
+		severity: m.metadata.severity ?? "unknown",
+		category: m.metadata.category ?? "unknown",
+		description: m.metadata.description ?? ""
+	};
+}
+const str = (v) => typeof v === "string" ? v : "";
+/**
+* Translate a pi tool name to the claude-cased name + input the shared policy
+* expects. pi field names (from the live tool stream): bash{command},
+* read/edit/write{path}, write adds {content}, edit adds {edits}, grep{path}.
+*/
+function toClaudePolicyCall(toolName, input) {
+	switch (toolName) {
+		case "bash": return {
+			name: "Bash",
+			input: { command: str(input.command) }
+		};
+		case "read": return {
+			name: "Read",
+			input: { file_path: input.path }
+		};
+		case "write": return {
+			name: "Write",
+			input: { file_path: input.path }
+		};
+		case "edit": return {
+			name: "Edit",
+			input: { file_path: input.path }
+		};
+		case "grep": return {
+			name: "Grep",
+			input: { path: input.path }
+		};
+		default: return {
+			name: toolName,
+			input
+		};
+	}
+}
+/**
+* The agent-facing block message. Includes the rule's remediation so a blocked
+* agent can self-correct (e.g. "move PII to identify()/$set") instead of
+* retrying near-identical content.
+*/
+function blockMessage(m) {
+	const remediation = m.metadata.remediation ? ` Fix: ${m.metadata.remediation}.` : "";
+	return `[YARA] ${m.rule}: ${m.metadata.description ?? "security rule matched"}.${remediation} Blocked for security.`;
+}
+/**
+* YARA scan of the content a tool is about to act on, BEFORE it executes.
+* - bash → scan the command ('command'-context rules: exfiltration,
+*   destructive, force-push). No triage — a flagged command always blocks,
+*   same as the anthropic PreToolUse hook, so the LLM call would be wasted.
+* - write/edit → scan the content being written ('output'-context rules:
+*   hardcoded keys, PII), WITH triage, and with the same wizard-doc
+*   `posthog_pii` suppression the anthropic path uses so the agent's own
+*   event-plan files aren't blocked.
+* Returns a block reason, or undefined to allow. Read/grep are post-scanned on
+* their output (in the tool_result hook), not here.
+*/
+async function preExecutionYaraBlock(toolName, input, llmProvider, repeatTracker) {
+	let content;
+	let ctx;
+	let triage;
+	let phase;
+	let tool;
+	switch (toolName) {
+		case "bash":
+			content = str(input.command);
+			ctx = "command";
+			triage = void 0;
+			phase = "PreToolUse";
+			tool = "Bash";
+			break;
+		case "write":
+			content = str(input.content);
+			ctx = "output";
+			triage = llmProvider;
+			phase = "PostToolUse";
+			tool = "Write";
+			break;
+		case "edit":
+			content = (Array.isArray(input.edits) ? input.edits : []).map((e) => str(e?.newText)).join("\n");
+			ctx = "output";
+			triage = llmProvider;
+			phase = "PostToolUse";
+			tool = "Edit";
+			break;
+		default: return;
+	}
+	if (!content) return void 0;
+	let matches = await scanAndTriage(content, ctx, triage);
+	if (ctx === "output" && isWizardDocumentationPath(str(input.path))) matches = matches.filter((m) => m.metadata.category !== "posthog_pii");
+	recordExternalScan(phase, tool, matches.map(toReportViolation), "blocked");
+	if (matches.length === 0) return void 0;
+	return repeatBlockReason(repeatTracker?.attempt(toolName, content) ?? 1, toolName, blockMessage(matches[0]));
+}
+/**
+* The pure gate decision for a single tool call. Reuses `wizardCanUseTool`
+* (deny → block) then the YARA content scan (match → block). Fail-closed: any
+* thrown error blocks.
+*/
+async function evaluateToolCall(toolName, input, ctx = {}, llmProvider) {
+	try {
+		const policy = toClaudePolicyCall(toolName, input);
+		const decision = wizardCanUseTool(policy.name, policy.input, {
+			disallowedTools: ctx.disallowedTools,
+			wizardAskPending: ctx.getWizardAskPending?.() ?? false
+		});
+		if (decision.behavior === "deny") return {
+			block: true,
+			reason: decision.message
+		};
+		const yaraReason = await preExecutionYaraBlock(toolName, input, llmProvider, ctx.repeatTracker);
+		if (yaraReason) return {
+			block: true,
+			reason: yaraReason
+		};
+		return { block: false };
+	} catch (err) {
+		logToFile("[pi-security] gate error — failing closed:", err);
+		return {
+			block: true,
+			reason: "Security check failed; tool blocked (fail-closed)."
+		};
+	}
+}
+/** pi result tool names whose OUTPUT gets scanned for 'input'-context rules. */
+function isPostScanTool(toolName) {
+	return toolName === "read" || toolName === "bash";
+}
+/**
+* Build the pi security extension + the shared state the backend inspects.
+* Install the returned factory via `extensionFactories`; pass the same factory
+* into every subagent session so the fence is inherited.
+*/
+function createSecurityExtension(ctx = {}) {
+	const state = {
+		criticalViolation: false,
+		blockedCount: 0,
+		toolCalls: 0
+	};
+	const llmProvider = createTriageLLMProvider(ctx.triageAuth);
+	const gateCtx = {
+		...ctx,
+		repeatTracker: ctx.repeatTracker ?? createRepeatBlockTracker()
+	};
+	const factory = (pi) => {
+		pi.on("tool_call", async (event) => {
+			if (state.criticalViolation) return {
+				block: true,
+				reason: "Run terminated by a security violation."
+			};
+			state.toolCalls += 1;
+			if (state.toolCalls > 250) return {
+				block: true,
+				reason: `Stopped: exceeded 250 tool calls (runaway guard).`
+			};
+			const decision = await evaluateToolCall(event.toolName, event.input ?? {}, gateCtx, llmProvider);
+			if (decision.block) {
+				state.blockedCount += 1;
+				logToFile(`[pi-security] BLOCK ${event.toolName}: ${decision.reason}`);
+				return {
+					block: true,
+					reason: decision.reason
+				};
+			}
+			return {};
+		});
+		pi.on("tool_result", async (event) => {
+			if (!isPostScanTool(event.toolName)) return {};
+			const text = (event.content ?? []).map((c) => c && c.type === "text" ? c.text : "").join("\n");
+			if (!text) return {};
+			try {
+				const matches = await scanAndTriage(text, "input", llmProvider);
+				recordExternalScan("PostToolUse", event.toolName === "read" ? "Read" : "Bash", matches.map(toReportViolation), "aborted");
+				if (matches.length > 0) {
+					state.criticalViolation = true;
+					logToFile(`[pi-security] POST-SCAN VIOLATION ${event.toolName}: ${matches[0].rule}`);
+				}
+			} catch (err) {
+				state.criticalViolation = true;
+				logToFile("[pi-security] post-scan error — failing closed:", err);
+			}
+			return {};
+		});
+	};
+	return {
+		factory,
+		state
+	};
+}
+//#endregion
+export { createSecurityExtension };
+
+//# sourceMappingURL=security-CSlaLY6P.js.map

package/dist/security-CSlaLY6P.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"security-CSlaLY6P.js","names":[],"sources":["../src/lib/agent/runner/harness/pi/security.ts"],"sourcesContent":["/**\n * Fail-closed security for the pi backend (#525). pi has no built-in\n * permission layer, so we attach an extension that intercepts every tool call\n * — built-in (bash/read/edit/write/grep) AND custom — through pi's `tool_call`\n * hook and reuses the EXACT anthropic policy: `wizardCanUseTool` (the bash\n * allowlist + .env fencing) plus the YARA pre-scan. A `tool_result` hook\n * post-scans output. Both fail closed: a scanner error blocks, and a critical\n * post-scan violation latches so every subsequent tool call is blocked and the\n * run terminates as a YARA violation.\n *\n * Scanning runs through @posthog/warlock via yara-hooks' `scanAndTriage` — the\n * same engine, rules, chunking, and LLM triage policy as the anthropic\n * harness. pi handlers are async (pi's ExtensionHandler accepts promises), so\n * the WASM scan awaits inline.\n *\n * This is the one fence. Subagents run their own pi session with the SAME\n * extension installed (see subagent.ts), so a child cannot escape it.\n */\n\nimport type { LLMProvider, ScanMatch } from '@posthog/warlock';\nimport { wizardCanUseTool } from '@lib/agent/agent-interface';\nimport {\n  createRepeatBlockTracker,\n  isWizardDocumentationPath,\n  recordExternalScan,\n  repeatBlockReason,\n  scanAndTriage,\n  type RepeatBlockTracker,\n  type ScanContext,\n} from '@lib/yara-hooks';\nimport {\n  createTriageLLMProvider,\n  type TriageGatewayAuth,\n} from '@lib/agent/triage-provider';\nimport { logToFile } from '@utils/debug';\n\n/** warlock ScanMatch → the report shape `recordExternalScan` expects. */\nfunction toReportViolation(m: ScanMatch) {\n  return {\n    rule: m.rule,\n    severity: m.metadata.severity ?? 'unknown',\n    category: m.metadata.category ?? 'unknown',\n    description: m.metadata.description ?? '',\n  };\n}\n\n/** Runaway backstop: hard cap on tool calls per (sub)agent session. */\nexport const MAX_TOOL_CALLS = 250;\n\nexport interface ToolGateContext {\n  disallowedTools?: readonly string[];\n  /** True while a wizard_ask overlay is open (interactive); blocks Write/Edit. */\n  getWizardAskPending?: () => boolean;\n  /**\n   * Gateway auth for the LLM triage pass. pi auths the gateway\n   * programmatically and never sets ANTHROPIC_BASE_URL/AUTH_TOKEN on the env,\n   * so without this triage silently no-ops and every flagged match is acted\n   * on (fail-closed, but no false-positive filtering).\n   */\n  triageAuth?: TriageGatewayAuth;\n  /**\n   * Per-run tracker of YARA-blocked payloads. When the agent retries content\n   * that was already blocked, the block reason escalates (\"change the code,\n   * not the retry\" → \"report it and move on\"). The extension wires one in;\n   * absent (tests calling `evaluateToolCall` directly) every block reads as\n   * a first attempt.\n   */\n  repeatTracker?: RepeatBlockTracker;\n}\n\nexport interface GateDecision {\n  block: boolean;\n  reason?: string;\n}\n\nconst str = (v: unknown): string => (typeof v === 'string' ? v : '');\n\n/**\n * Translate a pi tool name to the claude-cased name + input the shared policy\n * expects. pi field names (from the live tool stream): bash{command},\n * read/edit/write{path}, write adds {content}, edit adds {edits}, grep{path}.\n */\nfunction toClaudePolicyCall(\n  toolName: string,\n  input: Record<string, unknown>,\n): { name: string; input: Record<string, unknown> } {\n  switch (toolName) {\n    case 'bash':\n      return { name: 'Bash', input: { command: str(input.command) } };\n    case 'read':\n      return { name: 'Read', input: { file_path: input.path } };\n    case 'write':\n      return { name: 'Write', input: { file_path: input.path } };\n    case 'edit':\n      return { name: 'Edit', input: { file_path: input.path } };\n    case 'grep':\n      return { name: 'Grep', input: { path: input.path } };\n    default:\n      // Custom tools (load_skill_menu, set_env_values, dispatch_agent, …) +\n      // find/ls: no path/command, policy allows (their own handlers are fenced).\n      return { name: toolName, input };\n  }\n}\n\n/**\n * The agent-facing block message. Includes the rule's remediation so a blocked\n * agent can self-correct (e.g. \"move PII to identify()/$set\") instead of\n * retrying near-identical content.\n */\nfunction blockMessage(m: ScanMatch): string {\n  const remediation = m.metadata.remediation\n    ? ` Fix: ${m.metadata.remediation}.`\n    : '';\n  return `[YARA] ${m.rule}: ${\n    m.metadata.description ?? 'security rule matched'\n  }.${remediation} Blocked for security.`;\n}\n\n/**\n * YARA scan of the content a tool is about to act on, BEFORE it executes.\n * - bash → scan the command ('command'-context rules: exfiltration,\n *   destructive, force-push). No triage — a flagged command always blocks,\n *   same as the anthropic PreToolUse hook, so the LLM call would be wasted.\n * - write/edit → scan the content being written ('output'-context rules:\n *   hardcoded keys, PII), WITH triage, and with the same wizard-doc\n *   `posthog_pii` suppression the anthropic path uses so the agent's own\n *   event-plan files aren't blocked.\n * Returns a block reason, or undefined to allow. Read/grep are post-scanned on\n * their output (in the tool_result hook), not here.\n */\nasync function preExecutionYaraBlock(\n  toolName: string,\n  input: Record<string, unknown>,\n  llmProvider: LLMProvider | undefined,\n  repeatTracker?: RepeatBlockTracker,\n): Promise<string | undefined> {\n  let content: string;\n  let ctx: ScanContext;\n  let triage: LLMProvider | undefined;\n  // Report labels for the scan report (phase/tool), matching the anthropic\n  // hooks so pi and anthropic runs read the same in telemetry.\n  let phase: string;\n  let tool: string;\n  switch (toolName) {\n    case 'bash':\n      content = str(input.command);\n      ctx = 'command';\n      triage = undefined;\n      phase = 'PreToolUse';\n      tool = 'Bash';\n      break;\n    case 'write':\n      content = str(input.content);\n      ctx = 'output';\n      triage = llmProvider;\n      phase = 'PostToolUse';\n      tool = 'Write';\n      break;\n    case 'edit':\n      // Scan ONLY the replacement text. `edits` is [{oldText, newText}] and\n      // oldText is pre-existing file content the agent is changing — scanning\n      // it blocks edits whose *surroundings* contain a violation, and even\n      // edits that are removing one (field FPs: capture edits adjacent to\n      // existing identify() PII; pre-existing violations blocking their own\n      // replacement). Matches the anthropic path, which scans new_string only.\n      content = (Array.isArray(input.edits) ? input.edits : [])\n        .map((e) => str((e as Record<string, unknown>)?.newText))\n        .join('\\n');\n      ctx = 'output';\n      triage = llmProvider;\n      phase = 'PostToolUse';\n      tool = 'Edit';\n      break;\n    default:\n      return undefined;\n  }\n  if (!content) return undefined;\n\n  let matches = await scanAndTriage(content, ctx, triage);\n  if (ctx === 'output' && isWizardDocumentationPath(str(input.path))) {\n    matches = matches.filter((m) => m.metadata.category !== 'posthog_pii');\n  }\n  recordExternalScan(phase, tool, matches.map(toReportViolation), 'blocked');\n  if (matches.length === 0) return undefined;\n\n  const attempt = repeatTracker?.attempt(toolName, content) ?? 1;\n  return repeatBlockReason(attempt, toolName, blockMessage(matches[0]));\n}\n\n/**\n * The pure gate decision for a single tool call. Reuses `wizardCanUseTool`\n * (deny → block) then the YARA content scan (match → block). Fail-closed: any\n * thrown error blocks.\n */\nexport async function evaluateToolCall(\n  toolName: string,\n  input: Record<string, unknown>,\n  ctx: ToolGateContext = {},\n  llmProvider?: LLMProvider,\n): Promise<GateDecision> {\n  try {\n    const policy = toClaudePolicyCall(toolName, input);\n    const decision = wizardCanUseTool(policy.name, policy.input, {\n      disallowedTools: ctx.disallowedTools,\n      wizardAskPending: ctx.getWizardAskPending?.() ?? false,\n    });\n    if (decision.behavior === 'deny') {\n      return { block: true, reason: decision.message };\n    }\n\n    const yaraReason = await preExecutionYaraBlock(\n      toolName,\n      input,\n      llmProvider,\n      ctx.repeatTracker,\n    );\n    if (yaraReason) return { block: true, reason: yaraReason };\n\n    return { block: false };\n  } catch (err) {\n    logToFile('[pi-security] gate error — failing closed:', err);\n    return {\n      block: true,\n      reason: 'Security check failed; tool blocked (fail-closed).',\n    };\n  }\n}\n\n/** pi result tool names whose OUTPUT gets scanned for 'input'-context rules. */\nfunction isPostScanTool(toolName: string): boolean {\n  return toolName === 'read' || toolName === 'bash';\n}\n\n/** Mutable state the backend reads after the run to classify the outcome. */\nexport interface SecurityState {\n  criticalViolation: boolean;\n  blockedCount: number;\n  toolCalls: number;\n}\n\n/**\n * Build the pi security extension + the shared state the backend inspects.\n * Install the returned factory via `extensionFactories`; pass the same factory\n * into every subagent session so the fence is inherited.\n */\nexport function createSecurityExtension(ctx: ToolGateContext = {}): {\n  factory: (pi: PiExtensionApiLike) => void;\n  state: SecurityState;\n} {\n  const state: SecurityState = {\n    criticalViolation: false,\n    blockedCount: 0,\n    toolCalls: 0,\n  };\n\n  // One triage provider per extension. Undefined (no gateway auth) means\n  // triage is skipped and every flagged match is acted on — fail closed.\n  const llmProvider = createTriageLLMProvider(ctx.triageAuth);\n\n  // One tracker per extension = per (sub)agent session, so an identical\n  // payload retried after a block gets the escalating reason.\n  const gateCtx: ToolGateContext = {\n    ...ctx,\n    repeatTracker: ctx.repeatTracker ?? createRepeatBlockTracker(),\n  };\n\n  const factory = (pi: PiExtensionApiLike): void => {\n    pi.on('tool_call', async (event) => {\n      // A latched post-scan violation blocks everything that follows.\n      if (state.criticalViolation) {\n        return {\n          block: true,\n          reason: 'Run terminated by a security violation.',\n        };\n      }\n      state.toolCalls += 1;\n      if (state.toolCalls > MAX_TOOL_CALLS) {\n        return {\n          block: true,\n          reason: `Stopped: exceeded ${MAX_TOOL_CALLS} tool calls (runaway guard).`,\n        };\n      }\n      const decision = await evaluateToolCall(\n        event.toolName,\n        event.input ?? {},\n        gateCtx,\n        llmProvider,\n      );\n      if (decision.block) {\n        state.blockedCount += 1;\n        logToFile(`[pi-security] BLOCK ${event.toolName}: ${decision.reason}`);\n        return { block: true, reason: decision.reason };\n      }\n      return {};\n    });\n\n    pi.on('tool_result', async (event) => {\n      if (!isPostScanTool(event.toolName)) return {};\n      const text = (event.content ?? [])\n        .map((c) => (c && c.type === 'text' ? c.text : ''))\n        .join('\\n');\n      if (!text) return {};\n      try {\n        // 'input'-context rules (prompt injection in read content), with\n        // triage — same policy as the anthropic PostToolUse Read hook.\n        const matches = await scanAndTriage(text, 'input', llmProvider);\n        recordExternalScan(\n          'PostToolUse',\n          event.toolName === 'read' ? 'Read' : 'Bash',\n          matches.map(toReportViolation),\n          'aborted',\n        );\n        if (matches.length > 0) {\n          state.criticalViolation = true;\n          logToFile(\n            `[pi-security] POST-SCAN VIOLATION ${event.toolName}: ${matches[0].rule}`,\n          );\n        }\n      } catch (err) {\n        // Fail closed: a scanner error on output latches a violation.\n        state.criticalViolation = true;\n        logToFile('[pi-security] post-scan error — failing closed:', err);\n      }\n      return {};\n    });\n  };\n\n  return { factory, state };\n}\n\n/**\n * Minimal structural type for pi's ExtensionAPI — just the `on` overloads we\n * use. Kept local so this module has no value import from the pi SDK (so the\n * CommonJS unit tests can load it directly). Handlers may return promises —\n * pi's real ExtensionHandler is `(event, ctx) => Promise<R | void> | R | void`.\n */\nexport interface PiExtensionApiLike {\n  on(\n    event: 'tool_call',\n    handler: (event: {\n      toolName: string;\n      input?: Record<string, unknown>;\n    }) =>\n      | { block?: boolean; reason?: string }\n      | Promise<{ block?: boolean; reason?: string }>,\n  ): void;\n  on(\n    event: 'tool_result',\n    handler: (event: {\n      toolName: string;\n      content?: Array<{ type: string; text?: string }>;\n      isError?: boolean;\n    }) => Record<string, never> | Promise<Record<string, never>>,\n  ): void;\n}\n"],"mappings":"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"}

package/dist/{setup-utils-DLGNk8T6.js → setup-utils-DfRLklZ3.js}

@@ -1,12 +1,12 @@
 import { t as __exportAll } from "./rolldown-runtime-B_-DWIq7.js";
-import { D as DUMMY_PROJECT_API_KEY, F as OAUTH_PORTS, G as POSTHOG_PROXY_CLIENT_ID, I as OAUTH_TIMEOUT_MS, K as POSTHOG_STATUS_PAGE_URL, N as ISSUES_URL, Q as WIZARD_CONTACT_EMAIL, T as DEFAULT_HOST_URL, et as WIZARD_OAUTH_SCOPES, f as getUI, s as logToFile, st as WIZARD_USER_AGENT, z as POSTHOG_DEV_CLIENT_ID } from "./debug-D1lORUFs.js";
-import { n as analytics } from "./analytics-Ciob-x8a.js";
-import { i as withUtm, n as openTrackedLink, t as withProgress } from "./telemetry-BfnR7gtf.js";
-import { a as getOAuthUrl, s as resolveBaseUrl } from "./urls-CilgPbS-.js";
-import { t as HostResolution } from "./host-resolution-BnUJZKId.js";
-import { t as provisionNewAccount } from "./provisioning-CgomM26T.js";
-import { a as fetchUserData, r as fetchProjectData } from "./api-T_WHs3qZ.js";
-import { i as wizardAbort } from "./wizard-abort-Cp5Y7f8C.js";
+import { D as DUMMY_PROJECT_API_KEY, F as OAUTH_PORTS, G as POSTHOG_PROXY_CLIENT_ID, I as OAUTH_TIMEOUT_MS, K as POSTHOG_STATUS_PAGE_URL, N as ISSUES_URL, Q as WIZARD_CONTACT_EMAIL, T as DEFAULT_HOST_URL, et as WIZARD_OAUTH_SCOPES, f as getUI, s as logToFile, st as WIZARD_USER_AGENT, z as POSTHOG_DEV_CLIENT_ID } from "./debug-BZnZ7Gvh.js";
+import { n as analytics } from "./analytics-C7Oc3yWZ.js";
+import { i as withUtm, n as openTrackedLink, t as withProgress } from "./telemetry-BCIe6Kli.js";
+import { a as getOAuthUrl, s as resolveBaseUrl } from "./urls-D1AehCBN.js";
+import { t as HostResolution } from "./host-resolution-DjQvur4X.js";
+import { t as provisionNewAccount } from "./provisioning-BInfIJy5.js";
+import { a as fetchUserData, r as fetchProjectData } from "./api-DSG-l8Ql.js";
+import { i as wizardAbort } from "./wizard-abort-5fOIcY8w.js";
 import { major, minVersion } from "semver";
 import * as fs$2 from "fs";
 import * as path$1 from "path";
@@ -1170,4 +1170,4 @@ async function askForProvisioningSignup(email, region, baseUrl) {
 //#endregion
 export { createVersionBucket as a, tryGetPackageJson as i, isUsingTypeScript as n, extractOAuthCode as o, setup_utils_exports as r, detectAllPackageManagers as s, getOrAskForProjectData as t };
 
-//# sourceMappingURL=setup-utils-DLGNk8T6.js.map
+//# sourceMappingURL=setup-utils-DfRLklZ3.js.map