@oh-my-pi/pi-coding-agent 17.2.0 → 17.2.1

package/dist/types/tools/index.d.ts

@@ -1,5 +1,5 @@
 import type { Clipboard, InMemorySnapshotStore } from "@oh-my-pi/hashline";
-import type { AgentTelemetryConfig, AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { AgentOptions, AgentTelemetryConfig, AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { FetchImpl, ImageContent, Model, ServiceTierByFamily, ToolChoice } from "@oh-my-pi/pi-ai";
 import type { AsyncJobManager } from "../async/job-manager.js";
 import type { Rule } from "../capability/rule.js";
@@ -65,6 +65,7 @@ export * from "./read.js";
 export * from "./report-tool-issue.js";
 export * from "./resolve.js";
 export * from "./review.js";
+export * from "./security-scan.js";
 export * from "./todo.js";
 export * from "./tts.js";
 export * from "./vibe.js";
@@ -123,6 +124,8 @@ export interface ToolSession {
     suppressSpawnAdvisory?: boolean;
     /** Optional fetch implementation injected into the URL read pipeline (tests, proxies). Defaults to global fetch. */
     fetch?: FetchImpl;
+    /** Provider credential resolver forwarded unchanged to restricted child sessions. */
+    getApiKey?: AgentOptions["getApiKey"];
     /** Skip subprocess-kernel availability checks and warmup */
     skipPythonPreflight?: boolean;
     /** Pre-loaded context files (AGENTS.md, etc) */
@@ -152,6 +155,8 @@ export interface ToolSession {
     customToolPaths?: ToolPathWithSource[];
     /** Whether LSP integrations are enabled */
     enableLsp?: boolean;
+    /** Whether LSP is limited to navigation and diagnostics. */
+    lspReadOnly?: boolean;
     /** Whether this invocation may expose IRC. `false` removes it even for subagents. */
     enableIrc?: boolean;
     /**

package/dist/types/tools/security-scan.d.ts

@@ -0,0 +1,96 @@
+import type { AgentTool, AgentToolResult, ToolTier } from "@oh-my-pi/pi-agent-core";
+import { type CodexSecurityCloudConfiguration, type CodexSecurityCloudStats } from "../security/cloud.js";
+import { type SecurityValidationStatus } from "../security/contracts/index.js";
+import type { SecurityOperationSnapshot } from "../security/coordinator.js";
+import type { ToolSession } from "./index.js";
+declare const securityScanSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    action: "cancel" | "cloud_pull" | "cloud_scans" | "cloud_start" | "cloud_status" | "preflight" | "start" | "status" | "validate";
+    plan_id?: string | undefined;
+    operation_id?: string | undefined;
+    target_kind?: "ref_diff" | "repository" | "scoped_path" | "working_tree" | undefined;
+    include_paths?: string[] | undefined;
+    exclude_paths?: string[] | undefined;
+    base_revision?: string | undefined;
+    head_revision?: string | undefined;
+    knowledge_base_paths?: string[] | undefined;
+    output_root?: string | undefined;
+    archive_existing?: boolean | undefined;
+    credential_id?: number | undefined;
+    scan_id?: string | undefined;
+    finding_id?: string | undefined;
+    validation_status?: "error" | "partial" | "rejected" | "unvalidated" | "validated" | undefined;
+    validation_summary?: string | undefined;
+    validation_evidence?: {
+        label: string;
+        explanation: string;
+    }[] | undefined;
+    cloud_configuration_id?: string | undefined;
+    repository_id?: string | undefined;
+    repository_url?: string | undefined;
+    environment_id?: string | undefined;
+    lookback_days?: number | "all" | undefined;
+}, {}>;
+type SecurityScanParams = typeof securityScanSchema.infer;
+export interface SecurityScanToolDetails {
+    action: SecurityScanParams["action"];
+    plan?: {
+        id: string;
+        fingerprint: string;
+    };
+    operation?: SecurityOperationSnapshot;
+    cancelled?: boolean;
+    finding?: {
+        id: string;
+        validationStatus: SecurityValidationStatus;
+    };
+    cloudConfigurations?: CodexSecurityCloudConfiguration[];
+    cloudStats?: CodexSecurityCloudStats;
+    cloudScan?: {
+        id: string;
+        repositoryUrl: string;
+    };
+    importedScan?: {
+        id: string;
+        findingCount: number;
+    };
+}
+export declare class SecurityScanTool implements AgentTool<typeof securityScanSchema, SecurityScanToolDetails> {
+    readonly session: ToolSession;
+    readonly name = "security_scan";
+    readonly approval: ToolTier;
+    readonly label = "Security Scan";
+    readonly loadMode = "discoverable";
+    readonly summary = "Run OMP-native scans and explicit Codex Security cloud operations";
+    readonly description: string;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        action: "cancel" | "cloud_pull" | "cloud_scans" | "cloud_start" | "cloud_status" | "preflight" | "start" | "status" | "validate";
+        plan_id?: string | undefined;
+        operation_id?: string | undefined;
+        target_kind?: "ref_diff" | "repository" | "scoped_path" | "working_tree" | undefined;
+        include_paths?: string[] | undefined;
+        exclude_paths?: string[] | undefined;
+        base_revision?: string | undefined;
+        head_revision?: string | undefined;
+        knowledge_base_paths?: string[] | undefined;
+        output_root?: string | undefined;
+        archive_existing?: boolean | undefined;
+        credential_id?: number | undefined;
+        scan_id?: string | undefined;
+        finding_id?: string | undefined;
+        validation_status?: "error" | "partial" | "rejected" | "unvalidated" | "validated" | undefined;
+        validation_summary?: string | undefined;
+        validation_evidence?: {
+            label: string;
+            explanation: string;
+        }[] | undefined;
+        cloud_configuration_id?: string | undefined;
+        repository_id?: string | undefined;
+        repository_url?: string | undefined;
+        environment_id?: string | undefined;
+        lookback_days?: number | "all" | undefined;
+    }, {}>;
+    readonly strict = true;
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: SecurityScanParams, signal?: AbortSignal): Promise<AgentToolResult<SecurityScanToolDetails>>;
+}
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "17.2.0",
+	"version": "17.2.1",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -52,17 +52,17 @@
 		"@agentclientprotocol/sdk": "1.2.1",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "17.2.0",
-		"@oh-my-pi/omp-stats": "17.2.0",
-		"@oh-my-pi/pi-agent-core": "17.2.0",
-		"@oh-my-pi/pi-ai": "17.2.0",
-		"@oh-my-pi/pi-catalog": "17.2.0",
-		"@oh-my-pi/pi-mnemopi": "17.2.0",
-		"@oh-my-pi/pi-natives": "17.2.0",
-		"@oh-my-pi/pi-tui": "17.2.0",
-		"@oh-my-pi/pi-utils": "17.2.0",
-		"@oh-my-pi/pi-wire": "17.2.0",
-		"@oh-my-pi/snapcompact": "17.2.0",
+		"@oh-my-pi/hashline": "17.2.1",
+		"@oh-my-pi/omp-stats": "17.2.1",
+		"@oh-my-pi/pi-agent-core": "17.2.1",
+		"@oh-my-pi/pi-ai": "17.2.1",
+		"@oh-my-pi/pi-catalog": "17.2.1",
+		"@oh-my-pi/pi-mnemopi": "17.2.1",
+		"@oh-my-pi/pi-natives": "17.2.1",
+		"@oh-my-pi/pi-tui": "17.2.1",
+		"@oh-my-pi/pi-utils": "17.2.1",
+		"@oh-my-pi/pi-wire": "17.2.1",
+		"@oh-my-pi/snapcompact": "17.2.1",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/api-logs": "^0.220.0",
 		"@opentelemetry/context-async-hooks": "^2.9.0",

package/scripts/security-compare.ts

@@ -0,0 +1,40 @@
+#!/usr/bin/env bun
+import * as path from "node:path";
+import { isEnoent } from "@oh-my-pi/pi-utils";
+import { compareSecurityProducers, importCodexSecurityBundle, parseSecurityScanBundle } from "../src/security";
+
+async function readBundle(directory: string) {
+	const root = path.resolve(directory);
+	let scan: unknown;
+	try {
+		scan = JSON.parse(await Bun.file(path.join(root, "scan.json")).text()) as unknown;
+	} catch (error) {
+		if (!isEnoent(error)) throw error;
+		return importCodexSecurityBundle(root, { repositoryRoot: root });
+	}
+	const findings = JSON.parse(await Bun.file(path.join(root, "findings.json")).text()) as unknown;
+	const report = await Bun.file(path.join(root, "report.md"))
+		.text()
+		.catch(() => undefined);
+	const sarifText = await Bun.file(path.join(root, "results.sarif"))
+		.text()
+		.catch(() => undefined);
+	return parseSecurityScanBundle({
+		scan,
+		findings,
+		report,
+		sarif: sarifText ? (JSON.parse(sarifText) as Record<string, unknown>) : undefined,
+	});
+}
+
+const [referenceDirectory, candidateDirectory, outputPath] = process.argv.slice(2);
+if (!referenceDirectory || !candidateDirectory) {
+	process.stderr.write(
+		"Usage: bun scripts/security-compare.ts <reference-scan-dir> <candidate-scan-dir> [output.json]\n",
+	);
+	process.exit(2);
+}
+const report = compareSecurityProducers(await readBundle(referenceDirectory), await readBundle(candidateDirectory));
+const serialized = `${JSON.stringify(report, null, 2)}\n`;
+if (outputPath) await Bun.write(path.resolve(outputPath), serialized);
+else process.stdout.write(serialized);

package/src/config/model-discovery.ts

@@ -62,6 +62,33 @@ async function withTimeoutSignal<T>(timeoutMs: number, fn: (signal: AbortSignal)
 	}
 }
 
+/** Generous discovery budget for a non-loopback (remote / LAN) inference host. */
+const REMOTE_DISCOVERY_TIMEOUT_MS = 10_000;
+
+/**
+ * Pick a discovery-probe timeout for a local-engine base URL.
+ *
+ * The implicit `127.0.0.1` default probe keeps a tight `loopbackMs` cap so a
+ * busy or foreign service on the default port never stalls startup. But that
+ * cap is far too short for a host reached over the network: a user who points
+ * `LLAMA_CPP_BASE_URL` / `OLLAMA_BASE_URL` / `OLLAMA_HOST` at a remote or LAN
+ * machine has real round-trip latency, and a 250ms cap made that server look
+ * empty (issue #7087). Anything that is not strictly loopback therefore gets
+ * {@link REMOTE_DISCOVERY_TIMEOUT_MS}.
+ */
+export function discoveryProbeTimeoutMs(baseUrl: string, loopbackMs: number): number {
+	let hostname: string;
+	try {
+		hostname = new URL(baseUrl).hostname;
+	} catch {
+		return loopbackMs;
+	}
+	hostname = hostname.replace(/^\[/, "").replace(/\]$/, "");
+	const isLoopback =
+		hostname === "localhost" || hostname === "0.0.0.0" || hostname === "::1" || /^127\./.test(hostname);
+	return isLoopback ? loopbackMs : REMOTE_DISCOVERY_TIMEOUT_MS;
+}
+
 const DEFAULT_OLLAMA_BASE_URL = "http://127.0.0.1:11434";
 const OLLAMA_HOST_DEFAULT_PORT = "11434";
 
@@ -391,7 +418,7 @@ async function discoverOllamaModelMetadata(
 ): Promise<OllamaDiscoveredModelMetadata | null> {
 	const showUrl = `${endpoint}/api/show`;
 	try {
-		const payload = await withTimeoutSignal(150, async signal => {
+		const payload = await withTimeoutSignal(discoveryProbeTimeoutMs(endpoint, 150), async signal => {
 			const response = await ctx.fetch(showUrl, {
 				method: "POST",
 				headers: { ...(headers ?? {}), "Content-Type": "application/json" },
@@ -444,7 +471,7 @@ export async function discoverOllamaModels(
 	const endpoint = normalizeOllamaBaseUrl(providerConfig.baseUrl);
 	const tagsUrl = `${endpoint}/api/tags`;
 	const headers = { ...(providerConfig.headers ?? {}) };
-	const payload = await withTimeoutSignal(250, async signal => {
+	const payload = await withTimeoutSignal(discoveryProbeTimeoutMs(endpoint, 250), async signal => {
 		const response = await ctx.fetch(tagsUrl, {
 			headers,
 			signal,
@@ -491,7 +518,7 @@ async function discoverLlamaCppServerMetadata(
 ): Promise<LlamaCppDiscoveredServerMetadata | null> {
 	const propsUrl = `${toLlamaCppNativeBaseUrl(baseUrl)}/props`;
 	try {
-		const payload = await withTimeoutSignal(150, async signal => {
+		const payload = await withTimeoutSignal(discoveryProbeTimeoutMs(baseUrl, 150), async signal => {
 			const response = await ctx.fetch(propsUrl, {
 				headers,
 				signal,
@@ -567,7 +594,7 @@ export async function discoverLlamaCppModels(
 	let headers = baseHeaders;
 	const attempt = async (h: Record<string, string>) => {
 		const [payload, metadata] = await Promise.all([
-			withTimeoutSignal(250, async signal => {
+			withTimeoutSignal(discoveryProbeTimeoutMs(baseUrl, 250), async signal => {
 				const response = await ctx.fetch(modelsUrl, {
 					headers: h,
 					signal,
@@ -641,7 +668,7 @@ export async function discoverLlamaCppModelRuntimeMetadata(
 	const baseHeaders: Record<string, string> = { ...(model.headers ?? {}) };
 	const attempt = async (headers: Record<string, string>) => {
 		const [entries, serverMetadata] = await Promise.all([
-			withTimeoutSignal(250, async signal => {
+			withTimeoutSignal(discoveryProbeTimeoutMs(nativeBaseUrl, 250), async signal => {
 				const response = await ctx.fetch(modelsUrl, {
 					headers,
 					signal,

package/src/config/model-registry.ts

@@ -27,6 +27,7 @@ import {
 	openaiCodexModelManagerOptions,
 	PROVIDER_DESCRIPTORS,
 	resolveModelCacheProviderId,
+	resolveOllamaModelCacheProviderId,
 } from "@oh-my-pi/pi-catalog/provider-models";
 import {
 	collapseBuiltModelVariants,
@@ -1699,6 +1700,9 @@ export class ModelRegistry {
 	}
 
 	#configuredDiscoveryCacheProviderId(providerConfig: DiscoveryProviderConfig): string {
+		if (providerConfig.discovery.type === "ollama") {
+			return resolveOllamaModelCacheProviderId(providerConfig.provider, providerConfig.baseUrl);
+		}
 		if (providerConfig.discovery.type === "openai-models-list") {
 			return `${providerConfig.provider}:openai-models-list-context-v2`;
 		}

package/src/config/settings-schema.ts

@@ -4062,6 +4062,18 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"security.enabled": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "tools",
+			group: "Available Tools",
+			label: "Security",
+			description:
+				"Enable OMP-native security scan planning, execution, and the read-only security:// resource namespace",
+		},
+	},
+
 	"ask.enabled": {
 		type: "boolean",
 		default: true,

package/src/eval/py/prelude.py

@@ -376,10 +376,14 @@ if "__omp_prelude_loaded__" not in globals():
             raise RuntimeError("tool bridge is unavailable in this kernel")
         return (base.rstrip("/"), token, session)
 
+    import urllib.error, urllib.request
+
+    # urllib discovers environment and macOS SystemConfiguration proxies. This
+    # host-owned loopback endpoint must always connect directly.
+    _BRIDGE_OPENER = urllib.request.build_opener(urllib.request.ProxyHandler({}))
+
     def _bridge_call(name: str, args: dict):
         """POST one request to the host tool bridge and return its `value`."""
-        import urllib.request, urllib.error
-
         base, token, session = _tool_proxy_from_env()
         _run_id_getter = globals().get("__omp_current_run_id__")
         _run_id = (
@@ -400,7 +404,7 @@ if "__omp_prelude_loaded__" not in globals():
             },
         )
         try:
-            with urllib.request.urlopen(req) as resp:
+            with _BRIDGE_OPENER.open(req) as resp:
                 body = resp.read()
         except urllib.error.HTTPError as exc:
             body = exc.read()

package/src/extensibility/legacy-pi-coding-agent-shim.ts

@@ -140,6 +140,25 @@ export interface LsToolOptions {
 	operations?: LsOperations;
 }
 
+export interface EditOperations {
+	readFile: (absolutePath: string) => Promise<Buffer>;
+	writeFile: (absolutePath: string, content: string) => Promise<void>;
+	access: (absolutePath: string) => Promise<void>;
+}
+
+export interface EditToolOptions {
+	operations?: EditOperations;
+}
+
+export interface WriteOperations {
+	writeFile: (absolutePath: string, content: string) => Promise<void>;
+	mkdir: (dir: string) => Promise<void>;
+}
+
+export interface WriteToolOptions {
+	operations?: WriteOperations;
+}
+
 const legacyBashSchema = Type.Object({
 	command: Type.String({ description: "Bash command to execute" }),
 	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds" })),
@@ -636,6 +655,40 @@ export function createLsTool(cwd: string, options?: LsToolOptions): ToolDefiniti
 	return createLsToolDefinition(cwd, options);
 }
 
+/** Create the legacy edit tool definition. */
+export function createEditToolDefinition(cwd: string, options?: EditToolOptions): ToolDefinition {
+	if (options?.operations) {
+		throw new Error(
+			"Legacy EditToolOptions.operations is not supported: OMP's built-in edit tool writes the local " +
+				"filesystem natively and exposes no pluggable operations seam. Register a custom edit tool via " +
+				"defineTool() instead of passing operations to createEditTool()/createEditToolDefinition().",
+		);
+	}
+	return legacyBuiltinTool(cwd, "edit");
+}
+
+/** Create the legacy edit tool. */
+export function createEditTool(cwd: string, options?: EditToolOptions): ToolDefinition {
+	return createEditToolDefinition(cwd, options);
+}
+
+/** Create the legacy write tool definition. */
+export function createWriteToolDefinition(cwd: string, options?: WriteToolOptions): ToolDefinition {
+	if (options?.operations) {
+		throw new Error(
+			"Legacy WriteToolOptions.operations is not supported: OMP's built-in write tool writes the local " +
+				"filesystem natively and exposes no pluggable operations seam. Register a custom write tool via " +
+				"defineTool() instead of passing operations to createWriteTool()/createWriteToolDefinition().",
+		);
+	}
+	return legacyBuiltinTool(cwd, "write");
+}
+
+/** Create the legacy write tool. */
+export function createWriteTool(cwd: string, options?: WriteToolOptions): ToolDefinition {
+	return createWriteToolDefinition(cwd, options);
+}
+
 /** Create legacy read, bash, edit, and write tools. */
 export function createCodingTools(cwd: string): ToolDefinition[] {
 	return LEGACY_CODING_TOOL_NAMES.map(name => legacyBuiltinTool(cwd, name));

package/src/internal-urls/index.ts

@@ -20,6 +20,7 @@ export * from "./omp-protocol";
 export * from "./parse";
 export * from "./router";
 export * from "./rule-protocol";
+export * from "./security-protocol";
 export * from "./skill-protocol";
 export * from "./ssh-protocol";
 export type * from "./types";

package/src/internal-urls/router.ts

@@ -1,5 +1,5 @@
 /**
- * Internal URL router for internal protocols (`agent://`, `artifact://`, `history://`, `issue://`, `local://`, `mcp://`, `memory://`, `omp://`, `pr://`, `rule://`, `skill://`, `ssh://`, `vault://`, and `xd://`).
+ * Internal URL router for internal protocols (`agent://`, `artifact://`, `history://`, `issue://`, `local://`, `mcp://`, `memory://`, `omp://`, `pr://`, `rule://`, `security://`, `skill://`, `ssh://`, `vault://`, and `xd://`).
  *
  * One process-global router with one handler per scheme. Access via
  * `InternalUrlRouter.instance()`. Handlers are stateless; per-session and
@@ -15,6 +15,7 @@ import { MemoryProtocolHandler } from "./memory-protocol";
 import { OmpProtocolHandler } from "./omp-protocol";
 import { extractUriScheme, parseInternalUrl } from "./parse";
 import { RuleProtocolHandler } from "./rule-protocol";
+import { SecurityProtocolHandler } from "./security-protocol";
 import { SkillProtocolHandler } from "./skill-protocol";
 import { SshProtocolHandler } from "./ssh-protocol";
 import type {
@@ -42,6 +43,8 @@ export class InternalUrlRouter {
 		this.register(new VaultProtocolHandler());
 		this.register(new SkillProtocolHandler());
 		this.register(new RuleProtocolHandler());
+		// Reserved OMP-owned security-analysis namespace; vendor adapters normalize into its store.
+		this.register(new SecurityProtocolHandler());
 		this.register(new McpProtocolHandler());
 		this.register(new IssueProtocolHandler());
 		this.register(new PrProtocolHandler());