@wrongstack/acp 0.306.4 → 0.307.1

package/dist/agent/protocol-handler.d.ts

@@ -1,4 +1,5 @@
 import { type ProtocolHandlerOptions, WRONGSTACK_VERSION } from './protocol-contract.js';
+import { errorToJsonRpc } from './protocol-session-ops.js';
 export type { AgentCapabilities, ClientCapabilities, PromptCapabilities, ProtocolHandlerOptions, RunTurn, RunTurnApi, RunTurnInput, RunTurnPermissionRequest, RunTurnResult, SessionConfigOption, SessionMode, SessionPersistence, SessionState, } from './protocol-contract.js';
 export { WRONGSTACK_VERSION };
 export declare class ACPProtocolHandler {
@@ -37,73 +38,26 @@ export declare class ACPProtocolHandler {
     /** Abort all active turns and drop session state. */
     close(): void;
     private disposeSession;
+    private sessionContext;
     private handleRequest;
     private handleInitialize;
     private handleAuthenticate;
     private handleLogout;
-    private handleSessionNew;
-    private handleSessionLoad;
     private handleSessionResume;
     private handleSessionClose;
     private handleSessionDelete;
-    private handleSessionFork;
     private handleProvidersList;
     private handleProvidersSet;
     private handleProvidersDisable;
     private handleMcpMessage;
-    private handleSessionPrompt;
-    private handleSetMode;
-    private handleSetConfigOption;
     private handleSessionList;
     private handleNotification;
     private sendNotification;
-    /** Best-effort durable persistence of a session + its recorded history. */
+    private sendResult;
     private persist;
     private sendError;
-    /**
-     * Allocate a session id (WS-015).
-     *
-     * This was `this.nextId++`, so ids were `sess_1`, `sess_2`, … — and the
-     * handler has no per-connection ownership: any caller that names a session
-     * id can `session/load`, `session/prompt`, `session/cancel` or
-     * `session/delete` it. Over stdio that is academic (one client per process),
-     * but the agent also serves over HTTP, where a guessable id is the whole
-     * authorization story for any local process or page that reaches the port.
-     *
-     * Random ids do not create ownership — they remove the trivial enumeration
-     * that made its absence exploitable. Real per-connection ownership is the
-     * larger fix and is noted in the WS-015 test file.
-     *
-     * The counter is retained: it keeps ids ordered for debugging and guarantees
-     * uniqueness within a process even in the (impossible) event of a UUID
-     * collision. The random half is what makes the id unguessable.
-     */
-    /**
-     * Resolve a client-supplied `cwd` for a session, or `null` when it is not
-     * usable (WS-015).
-     *
-     * `session/new`, `session/load` and `session/fork` all took `params.cwd`
-     * with a single `typeof === 'string'` check and nothing else. That value is
-     * the working directory the agent then reads, writes and executes in.
-     *
-     * SCOPE, deliberately stated: this does NOT confine the session to a root.
-     * In ACP the client IS the editor and legitimately names its own workspace —
-     * Zed and JetBrains pass the project root — so a fixed boundary here would
-     * break the integration this package exists for. What it enforces is that
-     * the directory is absolute and actually exists as a directory: a relative
-     * or missing `cwd` is a bug or an attack under either reading, and silently
-     * running the agent somewhere other than where the client asked is worse
-     * than refusing. Confinement, if wanted, belongs in an operator-set option
-     * on top of this, not in place of it.
-     */
-    private resolveSessionCwd;
     private allocId;
 }
-declare function errorToJsonRpc(err: unknown): {
-    code: number;
-    message: string;
-    data?: unknown;
-};
 /** Internal deterministic seam used by the per-file coverage suite. */
 export declare const protocolHandlerCoverage: {
     errorToJsonRpc: typeof errorToJsonRpc;

package/dist/agent/protocol-session-management.d.ts

@@ -0,0 +1,36 @@
+import type { ClientCapabilities, RunTurn, SessionConfigOption, SessionMode, SessionPersistence, SessionState } from './protocol-contract.js';
+export interface ProtocolSessionContext {
+    sessions: Map<string, SessionState>;
+    maxSessions: number;
+    defaultCwd: string;
+    modes: readonly SessionMode[];
+    configOptions: readonly SessionConfigOption[];
+    store: SessionPersistence | undefined;
+    replayFor: ((sessionId: string) => Array<{
+        sessionUpdate: string;
+        content: unknown;
+    }>) | undefined;
+    seedFor: ((sessionId: string, history: Array<{
+        sessionUpdate: string;
+        content: unknown;
+    }>) => void) | undefined;
+    onSessionNew: (state: SessionState) => void;
+    allocId: () => string;
+    persist: (state: SessionState, history?: Array<{
+        sessionUpdate: string;
+        content: unknown;
+    }>) => Promise<void>;
+    sendNotification: (params: unknown) => Promise<void>;
+    sendError: (id: string | number, code: number, message: string, data?: unknown) => Promise<void>;
+    sendResult: (id: string | number, result: unknown) => Promise<void>;
+    request: (method: string, params: unknown, timeoutMs?: number) => Promise<unknown>;
+    runTurn: RunTurn;
+    clientCapabilities: ClientCapabilities;
+}
+export declare function handleSessionNewOp(ctx: ProtocolSessionContext, id: string | number, params: unknown): Promise<boolean>;
+export declare function handleSessionLoadOp(ctx: ProtocolSessionContext, id: string | number, params: unknown): Promise<boolean>;
+export declare function handleSessionForkOp(ctx: ProtocolSessionContext, id: string | number, params: unknown): Promise<boolean>;
+export declare function handleSessionPromptOp(ctx: ProtocolSessionContext, id: string | number, params: unknown): Promise<boolean>;
+export declare function handleSetModeOp(ctx: ProtocolSessionContext, id: string | number, params: unknown): Promise<boolean>;
+export declare function handleSetConfigOptionOp(ctx: ProtocolSessionContext, id: string | number, params: unknown): Promise<boolean>;
+//# sourceMappingURL=protocol-session-management.d.ts.map

package/dist/agent/protocol-session-ops.d.ts

@@ -0,0 +1,59 @@
+import { type ClientCapabilities, type RunTurnApi, type SessionConfigOption, type SessionMode } from './protocol-contract.js';
+export declare const WRONGSTACK_AUTH_METHODS: {
+    id: string;
+    name: string;
+    description: string;
+    type: string;
+    args: string[];
+}[];
+/** Single global mode id, sufficient for v1. */
+export declare const DEFAULT_MODE_ID = "code";
+export declare const DEFAULT_MAX_SESSIONS = 64;
+export declare const DEFAULT_MODES: readonly SessionMode[];
+export declare function resolveSessionCwd(requested: string): Promise<string | null>;
+export declare function errorToJsonRpc(err: unknown): {
+    code: number;
+    message: string;
+    data?: unknown;
+};
+export declare function createRunTurnApi(sessionId: string, clientCapabilities: ClientCapabilities, request: (method: string, params: unknown) => Promise<unknown>): RunTurnApi;
+export declare function buildInitializeResult(agentName: string, modes: readonly SessionMode[], configOptions: readonly SessionConfigOption[]): {
+    protocolVersion: 1;
+    agentCapabilities: {
+        loadSession: boolean;
+        promptCapabilities: {
+            image: boolean;
+            audio: boolean;
+            embeddedContext: boolean;
+        };
+        mcpCapabilities: {
+            http: boolean;
+            sse: boolean;
+        };
+        sessionCapabilities: {
+            close: {};
+            list: {};
+            delete: {};
+            resume: {};
+            fork: {};
+        };
+        auth: {
+            logout: {};
+        };
+    };
+    agentInfo: {
+        name: string;
+        title: string;
+        version: string;
+    };
+    authMethods: {
+        id: string;
+        name: string;
+        description: string;
+        type: string;
+        args: string[];
+    }[];
+    modes: readonly SessionMode[];
+    configOptions: readonly SessionConfigOption[];
+};
+//# sourceMappingURL=protocol-session-ops.d.ts.map