codekin 0.5.5 → 0.6.1

package/server/dist/opencode-process.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Manages an OpenCode server session via HTTP REST + SSE.
+ *
+ * OpenCode (github.com/anomalyco/opencode) uses a client/server architecture:
+ * - `opencode serve` runs a long-lived HTTP server
+ * - Sessions are created/managed via REST API
+ * - Real-time events stream via SSE (Server-Sent Events)
+ *
+ * This class wraps that model behind the same CodingProcess interface that
+ * ClaudeProcess implements, so SessionManager works identically for both.
+ *
+ * Key differences from ClaudeProcess:
+ * - No child process per session — one shared OpenCode server
+ * - Messages sent via HTTP POST, not stdin
+ * - Events received via SSE, not stdout NDJSON
+ * - Permissions handled via POST /permission/:id/reply, not control_response on stdin
+ */
+import { EventEmitter } from 'events';
+import type { ClaudeProcessEvents } from './claude-process.js';
+import { type CodingProcess, type CodingProvider, type ProviderCapabilities } from './coding-process.js';
+import type { PermissionMode } from './types.js';
+/** OpenCode model info returned from /config/providers. */
+export interface OpenCodeModelInfo {
+    id: string;
+    name: string;
+    providerID: string;
+    providerName: string;
+}
+/**
+ * Fetch the list of configured models from the running OpenCode server.
+ * Returns an empty array if the server is not running.
+ */
+export declare function fetchOpenCodeModels(workingDir: string): Promise<{
+    models: OpenCodeModelInfo[];
+    defaults: Record<string, string>;
+}>;
+/** Stop the shared OpenCode server. */
+export declare function stopOpenCodeServer(): void;
+export interface OpenCodeProcessOptions {
+    /** Absolute path to the project directory. */
+    workingDir: string;
+    /** Codekin session ID (used for internal tracking). */
+    sessionId?: string;
+    /** OpenCode's own session ID (used for resume — returned by getSessionId()). */
+    opencodeSessionId?: string;
+    /** Model in provider/model format (e.g. 'anthropic/claude-sonnet-4'). */
+    model?: string;
+    /** Additional environment variables (CODEKIN_SESSION_ID, etc.). */
+    extraEnv?: Record<string, string>;
+    /** Permission mode — mapped to OpenCode's permission config. */
+    permissionMode?: PermissionMode;
+}
+export declare class OpenCodeProcess extends EventEmitter<ClaudeProcessEvents> implements CodingProcess {
+    readonly provider: CodingProvider;
+    readonly capabilities: ProviderCapabilities;
+    private sessionId;
+    private opencodeSessionId;
+    private workingDir;
+    private model?;
+    private alive;
+    private abortController;
+    private startupTimer;
+    private permissionMode?;
+    private tasks;
+    private turnComplete;
+    private taskSeq;
+    /** Whether we've received streaming delta events this turn (to avoid double-emitting text). */
+    private receivedDeltas;
+    /** Whether we've already emitted text via message.part.updated (to avoid re-emitting from message.updated). */
+    private emittedPartText;
+    /** Last user input text — used to detect and strip user echo from assistant deltas. */
+    private lastUserInput;
+    /** Buffer for initial text deltas — held until we can check for user echo prefix. */
+    private deltaBuffer;
+    /** Whether the delta buffer has been flushed (user echo check complete). */
+    private deltaBufferFlushed;
+    /** Accumulated reasoning delta text for emitting thinking summaries during streaming. */
+    private reasoningBuffer;
+    /** Whether we've already emitted a thinking summary from reasoning deltas. */
+    private emittedReasoningSummary;
+    constructor(workingDir: string, opts?: Partial<OpenCodeProcessOptions>);
+    /** Connect to the OpenCode server, create a session, and subscribe to SSE events. */
+    start(): void;
+    private initialize;
+    /** Subscribe to the OpenCode SSE event stream and map events to CodingProcess events. */
+    private subscribeToEvents;
+    /**
+     * Check whether an SSE event belongs to this process's OpenCode session.
+     * Returns true if the event should be processed, false if it should be skipped.
+     * Rejects events when opencodeSessionId is not yet set (init window) to prevent
+     * cross-session leakage on the shared SSE stream.
+     */
+    private isOwnSession;
+    /** Flush any buffered text deltas that haven't been emitted yet (e.g. turn ended before buffer threshold). */
+    private flushDeltaBuffer;
+    /** Map an OpenCode SSE event to CodingProcess events. */
+    private handleSSEEvent;
+    /** Reply to an OpenCode permission request via HTTP. */
+    private replyToPermission;
+    /**
+     * Detect TodoWrite/TaskCreate/TaskUpdate tool calls and emit todo_update events.
+     * Mirrors the task-tracking logic in ClaudeProcess.handleTaskTool().
+     */
+    private handleTaskTool;
+    /** Send a user message to the OpenCode session. */
+    sendMessage(content: string): void;
+    /** No-op for OpenCode — raw protocol data is Claude-specific. */
+    sendRaw(_: string): void;
+    /**
+     * Respond to a permission/control request.
+     * Maps Codekin's allow/deny to OpenCode's once/always/reject.
+     */
+    sendControlResponse(requestId: string, behavior: 'allow' | 'deny'): void;
+    /** Stop the OpenCode session and disconnect the SSE stream. */
+    stop(): void;
+    isAlive(): boolean;
+    isReady(): boolean;
+    getSessionId(): string;
+    waitForExit(timeoutMs?: number): Promise<void>;
+}