@arnilo/prism-coding-agent 0.0.24 → 0.0.26

package/dist/process/types.d.ts

@@ -0,0 +1,146 @@
+import type { AgentIdentity, ExecutionPolicy, OwnershipScope } from "@arnilo/prism";
+/** Duck-typed long-running sandbox handle (mirrors coding-security SandboxProcessHandle). */
+export interface ProcessSandboxHandle {
+    write(data: Uint8Array): Promise<void>;
+    signal(name: string): Promise<void>;
+    kill(): Promise<void>;
+    release(): Promise<void>;
+    wait(options?: {
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<{
+        exitCode: number | null;
+    }>;
+}
+export interface ProcessSandboxStartRequest {
+    readonly file: string;
+    readonly args: readonly string[];
+    readonly cwd?: string;
+    readonly env?: Readonly<Record<string, string>>;
+    readonly onData?: (data: Buffer) => void;
+    readonly signal?: AbortSignal;
+    readonly timeout?: number;
+}
+/**
+ * Optional sandbox backend for ProcessSessions.
+ * Presence of `startProcess` = long-running capable; absence fails closed.
+ */
+export interface ProcessSandboxBackend {
+    startProcess?(request: ProcessSandboxStartRequest): Promise<ProcessSandboxHandle>;
+    status?(): Promise<{
+        readonly state: string;
+    }>;
+}
+export type ProcessSessionState = "starting" | "running" | "exited" | "killed" | "released" | "expired" | "unknown";
+export type ProcessSessionErrorCode = "ERR_PRISM_PROCESS_POLICY" | "ERR_PRISM_PROCESS_OWNERSHIP" | "ERR_PRISM_PROCESS_STATE" | "ERR_PRISM_PROCESS_LIMIT" | "ERR_PRISM_PROCESS_PTY_UNSUPPORTED" | "ERR_PRISM_PROCESS_UNSUPPORTED";
+export declare class ProcessSessionError extends Error {
+    readonly code: ProcessSessionErrorCode;
+    constructor(code: ProcessSessionErrorCode, message: string);
+}
+export interface ProcessSessionLimits {
+    readonly maxSessions?: number;
+    readonly maxInputBytes?: number;
+    readonly maxLifetimeMs?: number;
+    readonly maxOutputChunkBytes?: number;
+    readonly maxTotalOutputBytes?: number;
+}
+export interface ResolvedProcessSessionLimits {
+    readonly maxSessions: number;
+    readonly maxInputBytes: number;
+    readonly maxLifetimeMs: number;
+    readonly maxOutputChunkBytes: number;
+    readonly maxTotalOutputBytes: number;
+}
+export declare function resolveProcessSessionLimits(limits?: ProcessSessionLimits): ResolvedProcessSessionLimits;
+export interface ProcessStartRequest {
+    readonly command: string;
+    readonly args?: readonly string[];
+    readonly cwd?: string;
+    readonly env?: Readonly<Record<string, string>>;
+    /** Default false. true on unsupported platform → ERR_PRISM_PROCESS_PTY_UNSUPPORTED. */
+    readonly pty?: boolean;
+    readonly lifetimeMs?: number;
+    /** Owner string for this session; defaults to registry ownership key. */
+    readonly owner?: string;
+    /** When true, run cancel releases instead of killing (default kill). */
+    readonly releaseOnCancel?: boolean;
+}
+export interface ProcessOutputChunk {
+    readonly data: string;
+    /** Next byte cursor for paging. */
+    readonly cursor: number;
+    readonly eof: boolean;
+}
+export interface ProcessExitResult {
+    readonly exitCode: number | null;
+    readonly state: ProcessSessionState;
+}
+export interface ProcessSessionMetadata {
+    readonly id: string;
+    readonly commandFingerprint: string;
+    readonly owner: string;
+    readonly workspace: string;
+    readonly policyDecision: string;
+    readonly startedAt: string;
+    readonly exitedAt?: string;
+    readonly state: ProcessSessionState;
+    readonly releaseOnCancel: boolean;
+}
+export interface ProcessSession {
+    readonly id: string;
+    readonly state: ProcessSessionState;
+    readonly owner: string;
+    metadata(): ProcessSessionMetadata;
+    output(request?: {
+        cursor?: number;
+        maxBytes?: number;
+    }): Promise<ProcessOutputChunk>;
+    input(data: string | Uint8Array): Promise<void>;
+    wait(options?: {
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<ProcessExitResult>;
+    signal(name: "SIGTERM" | "SIGINT" | "SIGHUP"): Promise<void>;
+    kill(): Promise<void>;
+    release(): Promise<void>;
+}
+export type CodingProcessEvent = {
+    readonly type: "process_started" | "process_exited" | "process_killed" | "process_released" | "process_expired" | "process_unknown";
+    readonly sessionId: string;
+    readonly processId: string;
+    readonly owner: string;
+    readonly exitCode?: number | null;
+    readonly at: string;
+};
+export interface ProcessSessions {
+    start(request: ProcessStartRequest): Promise<ProcessSession>;
+    get(sessionId: string, owner?: string): ProcessSession;
+    /** Kill (default) or release all sessions for `owner`. */
+    cancelOwned(owner: string, options?: {
+        release?: boolean;
+    }): Promise<void>;
+    /** Mark a running session unknown (backend loss); never fabricates exitCode. */
+    markUnknown(sessionId: string, owner?: string): Promise<void>;
+    /**
+     * Host resume / sandbox-loss reconciliation: mark every running/starting session unknown.
+     * Never fabricates exitCode. O(owned sessions).
+     */
+    reconcile(): Promise<{
+        readonly markedUnknown: number;
+    }>;
+    dispose(): Promise<void>;
+}
+export interface CreateProcessSessionsOptions {
+    readonly cwd: string;
+    readonly policy?: ExecutionPolicy;
+    readonly limits?: ProcessSessionLimits;
+    readonly onEvent?: (event: CodingProcessEvent) => void;
+    readonly ownership?: OwnershipScope;
+    /** Host-verified identity; projects onto default owner when ownership omitted. */
+    readonly identity?: AgentIdentity;
+    /**
+     * When set: use `startProcess` if present; otherwise start() fails closed
+     * (`ERR_PRISM_PROCESS_UNSUPPORTED`). Native spawn only when sandbox omitted.
+     */
+    readonly sandbox?: ProcessSandboxBackend;
+}

package/dist/process/types.js

@@ -0,0 +1,19 @@
+import { DEFAULT_MAX_PROCESS_INPUT_BYTES, DEFAULT_MAX_PROCESS_LIFETIME_MS, DEFAULT_MAX_PROCESS_OUTPUT_CHUNK_BYTES, DEFAULT_MAX_PROCESS_SESSIONS, DEFAULT_MAX_PROCESS_TOTAL_OUTPUT_BYTES, HARD_MAX_PROCESS_INPUT_BYTES, HARD_MAX_PROCESS_LIFETIME_MS, HARD_MAX_PROCESS_OUTPUT_CHUNK_BYTES, HARD_MAX_PROCESS_SESSIONS, HARD_MAX_PROCESS_TOTAL_OUTPUT_BYTES, validateCodingLimit, } from "../limits.js";
+export class ProcessSessionError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "ProcessSessionError";
+        this.code = code;
+    }
+}
+export function resolveProcessSessionLimits(limits) {
+    return {
+        maxSessions: validateCodingLimit("maxSessions", limits?.maxSessions ?? DEFAULT_MAX_PROCESS_SESSIONS, HARD_MAX_PROCESS_SESSIONS),
+        maxInputBytes: validateCodingLimit("maxInputBytes", limits?.maxInputBytes ?? DEFAULT_MAX_PROCESS_INPUT_BYTES, HARD_MAX_PROCESS_INPUT_BYTES),
+        maxLifetimeMs: validateCodingLimit("maxLifetimeMs", limits?.maxLifetimeMs ?? DEFAULT_MAX_PROCESS_LIFETIME_MS, HARD_MAX_PROCESS_LIFETIME_MS),
+        maxOutputChunkBytes: validateCodingLimit("maxOutputChunkBytes", limits?.maxOutputChunkBytes ?? DEFAULT_MAX_PROCESS_OUTPUT_CHUNK_BYTES, HARD_MAX_PROCESS_OUTPUT_CHUNK_BYTES),
+        maxTotalOutputBytes: validateCodingLimit("maxTotalOutputBytes", limits?.maxTotalOutputBytes ?? DEFAULT_MAX_PROCESS_TOTAL_OUTPUT_BYTES, HARD_MAX_PROCESS_TOTAL_OUTPUT_BYTES),
+    };
+}
+//# sourceMappingURL=types.js.map

package/dist/repository.d.ts

@@ -146,5 +146,25 @@ export declare function compileSearchPattern(query: string, caseSensitive: boole
     } | null;
     patternBytes: number;
 };
+export interface RepositoryWalkLimits {
+    maxDepth: number;
+    maxEntries: number;
+    maxFiles: number;
+    exclude: ReadonlySet<string>;
+    includeHidden: boolean;
+    signal?: AbortSignal;
+    deadlineAt?: number;
+}
+export type RepositoryWalkEvent = {
+    type: "entry";
+    entry: RepoListEntry;
+    absolutePath: string;
+    depth: number;
+} | {
+    type: "limit";
+    truncatedBy: "entries" | "files" | "depth";
+};
+/** Injectable enumerator for list/search/glob. Default is the native opendir walker. */
+export type RepositoryWalk = (rootReal: string, startAbsolute: string, limits: RepositoryWalkLimits) => AsyncGenerator<RepositoryWalkEvent>;
 /** Local filesystem repository operations (default backend). */
-export declare function createLocalRepositoryOperations(limits?: RepositoryLimitOptions): RepositoryOperations;
+export declare function createLocalRepositoryOperations(limits?: RepositoryLimitOptions, walk?: RepositoryWalk): RepositoryOperations;

package/dist/repository.js

@@ -239,7 +239,7 @@ async function* walkRepository(rootReal, startAbsolute, limits) {
         }
     }
 }
-async function listLocal(request, defaults) {
+async function listLocal(request, defaults, walk) {
     const resolved = await resolveRepoPath(request.root, request.path);
     const maxResults = validateCodingLimit("maxResults", request.maxResults ?? defaults.maxResults, HARD_MAX_REPO_RESULTS);
     const offset = validateCodingLimitAllowZero("offset", request.offset ?? 0, HARD_MAX_REPO_ENTRIES);
@@ -286,7 +286,7 @@ async function listLocal(request, defaults) {
         throw new RepositoryError(`cannot open path: ${message}`);
     }
     try {
-        for await (const event of walkRepository(resolved.rootReal, resolved.absolute, {
+        for await (const event of walk(resolved.rootReal, resolved.absolute, {
             maxDepth,
             maxEntries: defaults.maxEntries,
             maxFiles: defaults.maxFiles,
@@ -458,7 +458,7 @@ async function searchFileLines(absolutePath, relativePath, testLine, options) {
         await handle.close();
     }
 }
-async function searchLocal(request, defaults) {
+async function searchLocal(request, defaults, walk) {
     const mode = request.mode ?? "literal";
     if (mode !== "literal") {
         throw new RepositoryError(`unsupported search mode: ${String(mode)} (literal only)`);
@@ -519,7 +519,7 @@ async function searchLocal(request, defaults) {
             await runFile(resolved.absolute, resolved.relative);
         }
         else if (startStat.isDirectory()) {
-            for await (const event of walkRepository(resolved.rootReal, resolved.absolute, {
+            for await (const event of walk(resolved.rootReal, resolved.absolute, {
                 maxDepth: defaults.maxDepth,
                 maxEntries: defaults.maxEntries,
                 maxFiles: defaults.maxFiles,
@@ -603,7 +603,7 @@ async function searchLocal(request, defaults) {
         filesSkippedOversize,
     };
 }
-async function globLocal(request, defaults) {
+async function globLocal(request, defaults, walk) {
     try {
         validateGlobPattern(request.pattern, defaults.maxPatternBytes);
     }
@@ -669,7 +669,7 @@ async function globLocal(request, defaults) {
         throw new RepositoryError(`cannot open path: ${message}`);
     }
     try {
-        for await (const event of walkRepository(resolved.rootReal, resolved.absolute, {
+        for await (const event of walk(resolved.rootReal, resolved.absolute, {
             maxDepth,
             maxEntries: defaults.maxEntries,
             maxFiles: defaults.maxFiles,
@@ -728,12 +728,12 @@ async function globLocal(request, defaults) {
     };
 }
 /** Local filesystem repository operations (default backend). */
-export function createLocalRepositoryOperations(limits) {
+export function createLocalRepositoryOperations(limits, walk = walkRepository) {
     const resolved = resolveRepositoryLimits(limits);
     return {
-        list: (request) => listLocal(request, resolved),
-        search: (request) => searchLocal(request, resolved),
-        glob: (request) => globLocal(request, resolved),
+        list: (request) => listLocal(request, resolved, walk),
+        search: (request) => searchLocal(request, resolved, walk),
+        glob: (request) => globLocal(request, resolved, walk),
     };
 }
 //# sourceMappingURL=repository.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arnilo/prism-coding-agent",
-  "version": "0.0.24",
+  "version": "0.0.26",
   "description": "Optional coding-agent tools (shell, read, write, edit, repo_list, repo_search, glob, delete, move, opt-in Git/check/ask-user-decision, and durable plan/checkpoint helpers) package for Prism.",
   "type": "module",
   "main": "./dist/index.js",
@@ -28,8 +28,8 @@
     "diff": "^9.0.0"
   },
   "peerDependencies": {
-    "@arnilo/prism": "0.0.24",
-    "@arnilo/prism-workflows": "0.0.24"
+    "@arnilo/prism": "0.0.26",
+    "@arnilo/prism-workflows": "0.0.26"
   },
   "devDependencies": {
     "@arnilo/prism": "file:../..",