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

package/dist/types/config/model-discovery.d.ts

@@ -11,6 +11,18 @@ import type { ModelSpec } from "@oh-my-pi/pi-catalog/types";
 import type { ProviderDiscovery } from "./models-config-schema.js";
 export declare const DISCOVERY_DEFAULT_CONTEXT_WINDOW = 128000;
 export declare const DISCOVERY_DEFAULT_MAX_TOKENS = 32768;
+/**
+ * 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 declare function discoveryProbeTimeoutMs(baseUrl: string, loopbackMs: number): number;
 export declare function getImplicitOllamaBaseUrl(): string;
 export declare function getOllamaContextLengthOverride(): number | undefined;
 /** Routes discovered-model `maxTokens` defaults around Anthropic's 3× output divisor. */

package/dist/types/config/settings-schema.d.ts

@@ -4151,6 +4151,16 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Enable the web_search tool for live web results";
         };
     };
+    readonly "security.enabled": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly group: "Available Tools";
+            readonly label: "Security";
+            readonly description: "Enable OMP-native security scan planning, execution, and the read-only security:// resource namespace";
+        };
+    };
     readonly "ask.enabled": {
         readonly type: "boolean";
         readonly default: true;

package/dist/types/extensibility/legacy-pi-coding-agent-shim.d.ts

@@ -77,6 +77,21 @@ export interface LsOperations {
 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;
+}
 /** Format the active shortcut for legacy extensions that render keybinding hints. */
 export declare function keyText(action: Keybinding): string;
 /** Parse frontmatter using the historical Pi package-root helper. */
@@ -110,6 +125,14 @@ export declare function createFindTool(cwd: string, options?: FindToolOptions):
 export declare function createLsToolDefinition(cwd: string, options?: LsToolOptions): ToolDefinition;
 /** Create the legacy ls tool. */
 export declare function createLsTool(cwd: string, options?: LsToolOptions): ToolDefinition;
+/** Create the legacy edit tool definition. */
+export declare function createEditToolDefinition(cwd: string, options?: EditToolOptions): ToolDefinition;
+/** Create the legacy edit tool. */
+export declare function createEditTool(cwd: string, options?: EditToolOptions): ToolDefinition;
+/** Create the legacy write tool definition. */
+export declare function createWriteToolDefinition(cwd: string, options?: WriteToolOptions): ToolDefinition;
+/** Create the legacy write tool. */
+export declare function createWriteTool(cwd: string, options?: WriteToolOptions): ToolDefinition;
 /** Create legacy read, bash, edit, and write tools. */
 export declare function createCodingTools(cwd: string): ToolDefinition[];
 /** Create legacy read, grep, find, and ls tools. */

package/dist/types/internal-urls/index.d.ts

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

package/dist/types/internal-urls/security-protocol.d.ts

@@ -0,0 +1,15 @@
+import { SecurityStore } from "../security/store.js";
+import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext, UrlCompletion } from "./types.js";
+export type SecurityStoreResolver = (cwd: string, signal?: AbortSignal) => Promise<SecurityStore>;
+export declare function isSecurityEnabled(): boolean;
+export declare class SecurityDisabledError extends Error {
+    constructor();
+}
+export declare class SecurityProtocolHandler implements ProtocolHandler {
+    #private;
+    readonly scheme = "security";
+    readonly immutable = true;
+    constructor(resolveStore?: SecurityStoreResolver, enabled?: () => boolean);
+    resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource>;
+    complete(query?: string, context?: ResolveContext): Promise<UrlCompletion[]>;
+}

package/dist/types/internal-urls/types.d.ts

@@ -1,7 +1,7 @@
 /**
  * Types for the internal URL routing system.
  *
- * Internal URLs (`agent://`, `artifact://`, `history://`, `issue://`, `local://`, `mcp://`, `memory://`, `omp://`, `pr://`, `rule://`, `skill://`, `ssh://`, `vault://`, and `xd://`) are resolved by tools like read,
+ * Internal URLs (`agent://`, `artifact://`, `history://`, `issue://`, `local://`, `mcp://`, `memory://`, `omp://`, `pr://`, `rule://`, `security://`, `skill://`, `ssh://`, `vault://`, and `xd://`) are resolved by tools like read,
  * providing access to agent outputs and server resources without exposing filesystem paths.
  */
 import type { Skill } from "../extensibility/skills.js";

package/dist/types/sdk.d.ts

@@ -39,6 +39,13 @@ export interface CreateAgentSessionOptions {
     authStorage?: AuthStorage;
     /** Model registry. Default: discoverModels(authStorage, agentDir) */
     modelRegistry?: ModelRegistry;
+    /**
+     * Request credential resolver. Defaults to the model registry's normal
+     * session-affine resolver. Security scans use this narrow seam to keep one
+     * durable OAuth row pinned for the operation without changing ordinary
+     * provider routing.
+     */
+    getApiKey?: AgentOptions["getApiKey"];
     /** Model to use. Default: from settings, else first available */
     model?: Model;
     /** Raw model pattern(s) (e.g. from --model CLI flag) to resolve after extensions load.
@@ -158,6 +165,8 @@ export interface CreateAgentSessionOptions {
     mcpManager?: MCPManager;
     /** Enable LSP integration (tool, formatting, diagnostics, warmup). Default: true */
     enableLsp?: boolean;
+    /** Restrict LSP to navigation and diagnostics even when enabled. Defaults to true for restricted sessions. */
+    lspReadOnly?: boolean;
     /** Whether this invocation may expose IRC. `false` removes it even for subagents. */
     enableIrc?: boolean;
     /** Skip subprocess-kernel availability checks and prelude warmup */
@@ -166,6 +175,12 @@ export interface CreateAgentSessionOptions {
     toolNames?: string[];
     /** Limit the session to explicitly supplied tool names, without discovered extras. */
     restrictToolNames?: boolean;
+    /**
+     * Permit only caller-supplied SDK custom tools inside a restricted session.
+     * They must still be named in {@link toolNames}; discovered extensions, MCP,
+     * and ambient custom tools remain disabled. Default: false.
+     */
+    allowRestrictedCustomTools?: boolean;
     /** Output schema for structured completion (subagents). */
     outputSchema?: unknown;
     /** Enforcement policy for {@link outputSchema}; defaults to legacy permissive behavior. */
@@ -368,6 +383,8 @@ export interface BuildSystemPromptOptions {
     appendPrompt?: string;
     inlineToolDescriptors?: boolean;
     includeWorkspaceTree?: boolean;
+    /** Include the read-only security:// resource inventory entry. Default: false. */
+    securityEnabled?: boolean;
 }
 /**
  * Build the default provider-facing system prompt blocks.

package/dist/types/security/auth.d.ts

@@ -0,0 +1,30 @@
+import type { AgentOptions } from "@oh-my-pi/pi-agent-core";
+import type { OAuthAccessResolution } from "@oh-my-pi/pi-ai";
+import type { AuthStorage } from "../session/auth-storage.js";
+import type { SecurityAccountRef } from "./contracts/index.js";
+export interface ExactSecurityOAuthOptions {
+    authStorage: AuthStorage;
+    account: SecurityAccountRef;
+}
+export declare function assertSecurityIdentityMatches(account: SecurityAccountRef, resolution: {
+    credentialId?: number;
+    accountId?: string;
+    email?: string;
+    orgId?: string;
+    orgName?: string;
+}): void;
+export declare function selectSecurityAccount(authStorage: AuthStorage, provider: string, requestedCredentialId?: number, sessionId?: string): SecurityAccountRef;
+export declare function resolveExactSecurityOAuthAccess(authStorage: AuthStorage, account: SecurityAccountRef, options: {
+    forceRefresh: boolean;
+    signal?: AbortSignal;
+}): Promise<Extract<OAuthAccessResolution, {
+    ok: true;
+}>>;
+/**
+ * Build a request credential resolver pinned to one durable OAuth row.
+ *
+ * Initial resolution and refresh both target the same row. The auth driver's
+ * final sibling-rotation step returns `undefined`, so an unavailable account
+ * fails the scan rather than crossing an account/workspace boundary.
+ */
+export declare function createExactSecurityOAuthResolver(options: ExactSecurityOAuthOptions): NonNullable<AgentOptions["getApiKey"]>;

package/dist/types/security/cloud.d.ts

@@ -0,0 +1,79 @@
+import type { AuthStorage } from "../session/auth-storage.js";
+import { type SecurityAccountRef, type SecurityScanBundle, type SecuritySeverityLevel } from "./contracts/index.js";
+import type { SecurityStore } from "./store.js";
+type JsonObject = Record<string, unknown>;
+export type CodexSecurityCloudFetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export interface CodexSecurityCloudClientOptions {
+    authStorage: AuthStorage;
+    account: SecurityAccountRef;
+    baseUrl?: string;
+    fetch?: CodexSecurityCloudFetch;
+}
+export interface CodexSecurityCloudConfiguration {
+    id: string;
+    sourceId?: string;
+    repositoryId: string;
+    repositoryUrl: string;
+    environmentId: string;
+    state?: string;
+    currentStep?: string;
+    scanType?: string;
+    remainingScans?: number;
+    totalScans?: number;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface CodexSecurityCloudConfigurationPage {
+    items: CodexSecurityCloudConfiguration[];
+    nextCursor?: string;
+    totalInAccount?: number;
+}
+export interface StartCodexSecurityCloudScanInput {
+    repositoryId: string;
+    repositoryUrl: string;
+    environmentId: string;
+    lookbackDays?: number | "all";
+    maintainerAttackConcerns?: string;
+    maintainerFocusAreas?: string;
+    maintainerAdditionalContext?: string;
+    signal?: AbortSignal;
+}
+export interface CodexSecurityCloudStats {
+    configurationId: string;
+    sourceConfigurationId?: string;
+    currentStep?: string;
+    pendingCommits: number;
+    finishedCommits: number;
+    failedCommits: number;
+    findingCounts: Record<SecuritySeverityLevel, number>;
+    lastScannedCommit?: string;
+    lastScannedAt?: string;
+    updatedAt?: string;
+}
+export interface PullCodexSecurityCloudResultsInput {
+    client: CodexSecurityCloudClient;
+    configurationId: string;
+    store: SecurityStore;
+    signal?: AbortSignal;
+}
+export declare class CodexSecurityCloudHttpError extends Error {
+    readonly status: number;
+    readonly endpoint: string;
+    constructor(status: number, endpoint: string);
+}
+export declare class CodexSecurityCloudClient {
+    #private;
+    constructor(options: CodexSecurityCloudClientOptions);
+    listConfigurations(options?: {
+        limit?: number;
+        cursor?: string;
+        signal?: AbortSignal;
+    }): Promise<CodexSecurityCloudConfigurationPage>;
+    listAllConfigurations(signal?: AbortSignal): Promise<CodexSecurityCloudConfiguration[]>;
+    getConfiguration(configurationId: string, signal?: AbortSignal): Promise<CodexSecurityCloudConfiguration>;
+    startScan(input: StartCodexSecurityCloudScanInput): Promise<CodexSecurityCloudConfiguration>;
+    getStats(configurationId: string, signal?: AbortSignal): Promise<CodexSecurityCloudStats>;
+    listFindingDetails(repositoryUrl: string, configuration: CodexSecurityCloudConfiguration, signal?: AbortSignal): Promise<JsonObject[]>;
+}
+export declare function pullCodexSecurityCloudResults(input: PullCodexSecurityCloudResultsInput): Promise<SecurityScanBundle>;
+export {};

package/dist/types/security/comparison.d.ts

@@ -0,0 +1,49 @@
+import type { SecurityComparisonReport, SecurityFinding, SecurityScanBundle } from "./contracts/index.js";
+export interface SecurityDifferentialFindingMatch {
+    referenceFindingId: string;
+    candidateFindingId: string;
+    basis: "fingerprint" | "rule_location" | "taxonomy_location";
+}
+export interface SecurityDifferentialFindingSummary {
+    findingId: string;
+    ruleId: string;
+    title: string;
+    severity: SecurityFinding["severity"]["level"];
+    confidence: SecurityFinding["confidence"]["level"];
+    validationStatus: SecurityFinding["validation"]["status"];
+    dispositionStatus: SecurityFinding["disposition"]["status"];
+    primaryLocation?: {
+        path: string;
+        startLine: number;
+    };
+}
+export interface SecurityDifferentialScanSummary {
+    scanId: string;
+    producer: SecurityScanBundle["scan"]["producer"];
+    status: SecurityScanBundle["scan"]["status"];
+    findingCount: number;
+    actionableFindingCount: number;
+    validatedFindingCount: number;
+    rejectedFindingCount: number;
+    coverage: SecurityScanBundle["scan"]["coverage"];
+    metrics?: SecurityScanBundle["scan"]["metrics"];
+}
+export interface SecurityDifferentialReport {
+    referenceScanId: string;
+    candidateScanId: string;
+    matches: SecurityDifferentialFindingMatch[];
+    referenceOnlyFindingIds: string[];
+    candidateOnlyFindingIds: string[];
+    reference: SecurityDifferentialScanSummary;
+    candidate: SecurityDifferentialScanSummary;
+    referenceOnlyFindings: SecurityDifferentialFindingSummary[];
+    candidateOnlyFindings: SecurityDifferentialFindingSummary[];
+    referenceFindingCount: number;
+    candidateFindingCount: number;
+    matchedFindingCount: number;
+    recallAgainstReference: number;
+    precisionAgainstReference: number;
+    jaccardOverlap: number;
+}
+export declare function compareSecurityProducers(reference: SecurityScanBundle, candidate: SecurityScanBundle): SecurityDifferentialReport;
+export declare function compareSecurityLineage(before: SecurityScanBundle, after: SecurityScanBundle): SecurityComparisonReport;

package/dist/types/security/contracts/ids.d.ts

@@ -0,0 +1,15 @@
+import type { SecurityLocation } from "./types.js";
+export declare function canonicalSecurityJson(value: unknown): string;
+export interface SecurityFindingFingerprintInput {
+    ruleId: string;
+    category: string;
+    anchor?: string;
+    locations: readonly SecurityLocation[];
+}
+export declare function createSecurityFindingFingerprint(input: SecurityFindingFingerprintInput): string;
+export declare function createSecurityFindingId(fingerprint: string): string;
+export declare function createSecurityOccurrenceId(fingerprint: string, locations: readonly SecurityLocation[]): string;
+export declare function createSecurityEvidenceId(fingerprint: string, label: string, ordinal: number): string;
+export declare function createSecurityScanId(randomUuid?: () => string): string;
+export declare function createSecurityPlanId(fingerprint: string): string;
+export declare function encodeSecurityProjectKey(repositoryRoot: string): string;

package/dist/types/security/contracts/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./ids.js";
+export * from "./schemas.js";
+export * from "./types.js";
+export * from "./validation.js";