codekin 0.5.4 → 0.6.0

package/server/dist/session-manager.d.ts

@@ -15,12 +15,15 @@
  * - SessionNaming: AI-powered session name generation with retry logic
  * - SessionPersistence: disk I/O for session state
  * - DiffManager: stateless git-diff operations
- * - evaluateRestart: pure restart-decision logic
+ * - SessionLifecycle: Claude process start/stop/restart and event wiring
+ * - evaluateRestart: pure restart-decision logic (used by SessionLifecycle)
  */
 import type { WebSocket } from 'ws';
+import type { CodingProvider } from './coding-process.js';
 import { SessionArchive } from './session-archive.js';
 import type { DiffFileStatus, DiffScope, Session, SessionInfo, WsServerMessage } from './types.js';
 import { ApprovalManager } from './approval-manager.js';
+import { SessionLifecycle } from './session-lifecycle.js';
 export interface CreateSessionOptions {
     source?: 'manual' | 'webhook' | 'workflow' | 'stepflow' | 'orchestrator' | 'agent';
     id?: string;
@@ -32,6 +35,10 @@ export interface CreateSessionOptions {
     permissionMode?: import('./types.js').PermissionMode;
     /** Additional tools to pre-approve via --allowedTools (e.g. 'Bash(curl:*)', 'WebFetch'). */
     allowedTools?: string[];
+    /** Extra directories to grant Claude access to via --add-dir. */
+    addDirs?: string[];
+    /** AI provider to use for this session. Defaults to 'claude'. */
+    provider?: import('./coding-process.js').CodingProvider;
 }
 export declare class SessionManager {
     /** All active (non-archived) sessions, keyed by session UUID. */
@@ -60,6 +67,10 @@ export declare class SessionManager {
     private sessionPersistence;
     /** Delegated diff operations (git diff, discard changes). */
     private diffManager;
+    /** Delegated prompt routing and tool approval logic. */
+    private promptRouter;
+    /** Delegated Claude process lifecycle (start, stop, restart, event wiring). */
+    private sessionLifecycle;
     /** Interval handle for the idle session reaper. */
     private _idleReaperInterval;
     constructor();
@@ -86,8 +97,16 @@ export declare class SessionManager {
      * Create a git worktree for a session. Creates a new branch and worktree
      * as a sibling directory of the project root.
      * Returns the worktree path on success, or null on failure.
+     *
+     * @param targetBranch — use this as the worktree branch name instead of
+     *   the default `wt/{shortId}`. The orchestrator uses this to create the
+     *   worktree directly on the desired feature branch so Claude doesn't
+     *   need to create a second branch.
+     * @param baseBranch — create the worktree branch from this ref (e.g.
+     *   'main'). Defaults to auto-detecting the default branch. Prevents
+     *   worktrees from accidentally branching off a random HEAD.
      */
-    createWorktree(sessionId: string, workingDir: string): Promise<string | null>;
+    createWorktree(sessionId: string, workingDir: string, targetBranch?: string, baseBranch?: string): Promise<string | null>;
     /**
      * Resolve the Claude CLI project storage directory for a given working dir.
      * Claude encodes the absolute path by replacing `/` with `-`.
@@ -106,8 +125,15 @@ export declare class SessionManager {
     /**
      * Clean up a git worktree and its branch. Runs asynchronously and logs errors
      * but never throws — session deletion must not be blocked by cleanup failures.
+     * Retries once on failure after a short delay.
      */
     private cleanupWorktree;
+    /**
+     * Detect the default branch of a repository (main, master, etc.).
+     * Tries `git symbolic-ref refs/remotes/origin/HEAD` first, then checks
+     * for common branch names. Returns null if detection fails.
+     */
+    private detectDefaultBranch;
     /** Get the configured worktree branch prefix (defaults to 'wt/'). */
     getWorktreeBranchPrefix(): string;
     /** Set the worktree branch prefix. */
@@ -134,6 +160,7 @@ export declare class SessionManager {
     }>;
     /** Clear the isProcessing flag for a session and broadcast the update. */
     clearProcessingFlag(sessionId: string): void;
+    private serializeSession;
     list(): SessionInfo[];
     /** List ALL sessions including orchestrator — used by orchestrator cleanup endpoints. */
     listAll(): SessionInfo[];
@@ -152,21 +179,14 @@ export declare class SessionManager {
     private archiveSessionIfWorthSaving;
     /**
      * Spawn (or re-spawn) a Claude CLI process for a session.
-     * Wires up all event handlers for streaming text, tools, prompts, and auto-restart.
+     * Delegates to SessionLifecycle.
      */
     startClaude(sessionId: string): boolean;
     /**
-     * Wait for a session's Claude process to emit its system_init event,
-     * indicating it is ready to accept input. Resolves immediately if the
-     * session already has a claudeSessionId (process previously initialized).
-     * Times out after `timeoutMs` (default 30s) to avoid hanging indefinitely.
+     * Wait for a session's Claude process to emit its system_init event.
+     * Delegates to SessionLifecycle.
      */
     waitForReady(sessionId: string, timeoutMs?: number): Promise<void>;
-    /**
-     * Attach all ClaudeProcess event listeners for a session.
-     * Extracted from startClaude() to keep that method focused on process setup.
-     */
-    private wireClaudeEvents;
     /** Broadcast a message and add it to the session's output history. */
     private broadcastAndHistory;
     /**
@@ -182,8 +202,6 @@ export declare class SessionManager {
     private onImageEvent;
     private onToolActiveEvent;
     private onToolDoneEvent;
-    private onPromptEvent;
-    private onControlRequestEvent;
     /**
      * Handle a Claude process 'result' event: update session state, apply API
      * retry logic for transient errors, broadcast result to clients, and trigger
@@ -206,76 +224,40 @@ export declare class SessionManager {
      * and trigger session naming if needed.
      */
     private finalizeResult;
-    /**
-     * Handle a Claude process 'exit' event: clean up state, notify exit listeners,
-     * and either auto-restart (within limits) or broadcast the final exit message.
-     *
-     * Uses evaluateRestart() for the restart decision, keeping this method focused
-     * on state updates, listener notification, and message broadcasting.
-     */
-    private handleClaudeExit;
+    /** Handle Claude process exit. Delegates to SessionLifecycle. @internal — used by tests. */
+    handleClaudeExit(...args: Parameters<SessionLifecycle['handleClaudeExit']>): void;
     /**
      * Send user input to a session's Claude process.
      * Auto-starts Claude if not running, with session context for continuity.
      */
     sendInput(sessionId: string, data: string): void;
     /**
-     * Route a user's prompt response to the correct handler: pending tool approval
-     * (from PermissionRequest hook), pending control request (from control_request
-     * fallback path), or plain message fallback.
+     * Route a user's prompt response to the correct handler.
+     * Delegates to PromptRouter.
      */
     sendPromptResponse(sessionId: string, value: string | string[], requestId?: string): void;
-    /** Decode the allow/deny/always/pattern intent from a prompt response value. */
-    private decodeApprovalValue;
-    /** Resolve a pending PreToolUse hook approval and update auto-approval registries. */
-    private resolveToolApproval;
-    /**
-     * Send an AskUserQuestion control response, mapping the user's answer(s) into
-     * the structured answers map the tool expects.
-     */
-    private handleAskUserQuestion;
-    /** Send a permission control response (allow/always_allow/approve_pattern/deny). */
-    private sendControlResponseForRequest;
     /**
      * Called by the PermissionRequest hook HTTP endpoint. Sends a prompt to clients
      * and returns a Promise that resolves when the user approves/denies.
+     * Delegates to PromptRouter.
      */
     requestToolApproval(sessionId: string, toolName: string, toolInput: Record<string, unknown>): Promise<{
         allow: boolean;
         always: boolean;
         answer?: string;
     }>;
-    /**
-     * Handle ExitPlanMode approval through PlanManager.
-     * Shows a plan-specific approval prompt (Approve/Reject) and blocks the hook
-     * until the user responds. On approve, returns allow:true (the hook will use
-     * the deny-with-approval-message workaround). On deny, returns allow:false.
-     */
-    private handleExitPlanModeApproval;
-    /**
-     * Check if a tool invocation can be auto-approved without prompting the user.
-     * Returns 'registry' if matched by auto-approval rules, 'session' if matched
-     * by the session's allowedTools list, 'headless' if the session has no clients
-     * and is a non-interactive source, or 'prompt' if the user needs to decide.
-     */
-    private resolveAutoApproval;
-    /**
-     * Check if a tool invocation matches any of the session's allowedTools patterns.
-     * Patterns follow Claude CLI format: 'ToolName' or 'ToolName(prefix:*)'.
-     * Examples: 'WebFetch', 'Bash(curl:*)', 'Bash(git:*)'.
-     */
-    private matchesAllowedTools;
-    /** Build a human-readable prompt string for a tool permission dialog. */
-    private summarizeToolPermission;
+    getSessionProvider(sessionId: string): string;
+    /** Update the provider for a session and restart with the new provider process. */
+    setProvider(sessionId: string, provider: CodingProvider): boolean;
     /** Update the model for a session and restart Claude with the new model. */
     setModel(sessionId: string, model: string): boolean;
     /** Update the permission mode for a session and restart Claude with the new mode. */
     setPermissionMode(sessionId: string, permissionMode: import('./types.js').PermissionMode): boolean;
+    /** Stop the Claude process for a session. Delegates to SessionLifecycle. */
     stopClaude(sessionId: string): void;
     /**
      * Stop the Claude process and wait for it to fully exit before resolving.
-     * This prevents race conditions when restarting with the same session ID
-     * (e.g. during mid-session worktree migration).
+     * Delegates to SessionLifecycle.
      */
     stopClaudeAndWait(sessionId: string): Promise<void>;
     /** Check if an error result text matches a transient API error worth retrying. */