@sumicom/quicksave 0.6.0 → 0.6.2

package/dist/ai/sessionManager.js

@@ -0,0 +1,716 @@
+import { EventEmitter } from 'events';
+import { resolve, join } from 'path';
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { DEFAULT_AGENT, DEFAULT_MODEL, matchAllowPattern, } from '@sumicom/quicksave-shared';
+import { StreamCardBuilder, buildCardsFromHistory, loadPersistedCards } from './cardBuilder.js';
+import { SANDBOX_BASH_TOOL, SET_TITLE_TOOL } from './sandboxMcp.js';
+import { getSessionRegistry } from './sessionRegistry.js';
+/**
+ * Events emitted:
+ *   'card-event'             (event: CardEvent)
+ *   'card-stream-end'        (result: CardStreamEnd)
+ *   'user-input-request'     (request: ClaudeUserInputRequestPayload)
+ *   'user-input-resolved'    ({ requestId, sessionId })
+ *   'session-updated'        ({ sessionId, isActive, isStreaming, hasPendingInput, permissionMode })
+ *   'preferences-updated'    (prefs: ClaudePreferences)
+ *   'session-config-updated' ({ sessionId, config: Record<string, ConfigValue> })
+ */
+/** Tools auto-approved at each permission level (no user prompt). */
+const AUTO_APPROVE = {
+    bypassPermissions: new Set([
+        'Edit', 'Write', 'NotebookEdit', 'TodoWrite', 'Agent', 'EnterWorktree', 'ExitWorktree',
+        'WebFetch', 'WebSearch', 'Bash',
+        'Skill', 'ToolSearch', 'Config',
+        'CronCreate', 'CronDelete', 'CronList', 'RemoteTrigger',
+        'EnterPlanMode', 'ExitPlanMode',
+        'TaskOutput', 'TaskStop',
+    ]),
+    acceptEdits: new Set(['Edit', 'Write', 'NotebookEdit', 'TodoWrite', 'Agent', 'EnterWorktree', 'ExitWorktree', 'EnterPlanMode']),
+    default: new Set(['TodoWrite', 'EnterWorktree', 'ExitWorktree', 'Agent', 'EnterPlanMode']),
+    plan: new Set(['EnterPlanMode']),
+};
+const DEFAULT_SYSTEM_PROMPT = [
+    'For non-destructive shell commands (ls, cat, find, git log, git status, git diff, etc.), prefer SandboxBash over Bash. SandboxBash runs in a sandboxed environment. Use Bash only for commands that modify state.',
+    'Call SetTitle to set a descriptive session title when you start a new task or switch context. Keep titles short (e.g. "Fixing auth middleware", "Adding unit tests for UserService"). Update it when the focus changes.',
+].join('\n\n');
+function buildSystemPrompt(extra) {
+    return extra ? `${DEFAULT_SYSTEM_PROMPT}\n\n${extra}` : DEFAULT_SYSTEM_PROMPT;
+}
+function normalizeAgentId(value) {
+    if (value === 'claude-code' || value === 'claude-cli' || value === 'claude-sdk') {
+        return 'claude-code';
+    }
+    if (value === 'codex' || value === 'codex-mcp') {
+        return 'codex';
+    }
+    return undefined;
+}
+export class SessionManager extends EventEmitter {
+    sessions = new Map();
+    sessionAgents = new Map();
+    sessionPermissions = new Map();
+    sessionSandboxed = new Map();
+    sessionConfigs = new Map();
+    pendingInputRequests = new Map();
+    requestCounter = 0;
+    runtimeAllowPatterns = [];
+    preferences = { model: DEFAULT_MODEL };
+    providers;
+    defaultAgentId;
+    /** Guards against concurrent cold resumes. Queues prompts arriving while a spawn is in flight. */
+    coldResumeInFlight = new Map();
+    constructor(providers, defaultAgentId = DEFAULT_AGENT) {
+        super();
+        this.providers = new Map(providers.map((provider) => [provider.id, provider]));
+        this.defaultAgentId = this.providers.has(defaultAgentId)
+            ? defaultAgentId
+            : providers[0]?.id ?? DEFAULT_AGENT;
+    }
+    getProvider(agentId) {
+        const resolved = agentId && this.providers.has(agentId)
+            ? agentId
+            : this.defaultAgentId;
+        const provider = this.providers.get(resolved);
+        if (!provider) {
+            throw new Error(`Unknown agent: ${agentId ?? resolved}`);
+        }
+        return provider;
+    }
+    resolveAgentId(sessionId, cwd, requestedAgent) {
+        const activeAgent = this.sessions.get(sessionId)?.agentId;
+        if (activeAgent)
+            return activeAgent;
+        const rememberedAgent = this.sessionAgents.get(sessionId);
+        if (rememberedAgent)
+            return rememberedAgent;
+        const rawConfig = this.sessionConfigs.get(sessionId);
+        const configAgent = normalizeAgentId(rawConfig?.agent ?? rawConfig?.provider);
+        if (configAgent && this.providers.has(configAgent)) {
+            return configAgent;
+        }
+        if (cwd) {
+            const registryEntry = getSessionRegistry().getEntry(cwd, sessionId);
+            const registryAgent = normalizeAgentId(registryEntry?.agent
+                ?? (registryEntry?.provider));
+            if (registryAgent && this.providers.has(registryAgent)) {
+                return registryAgent;
+            }
+        }
+        const normalizedRequest = normalizeAgentId(requestedAgent);
+        if (normalizedRequest && this.providers.has(normalizedRequest)) {
+            return normalizedRequest;
+        }
+        return this.defaultAgentId;
+    }
+    // ── Preferences ──
+    async initPreferences() {
+        // Model is tracked from the last session's init event via onModelDetected callback.
+    }
+    getPreferences() {
+        return { ...this.preferences };
+    }
+    setPreferences(prefs) {
+        const next = { ...this.preferences };
+        let changed = false;
+        if (prefs.model !== undefined && prefs.model !== this.preferences.model) {
+            next.model = prefs.model;
+            changed = true;
+        }
+        if (prefs.reasoningEffort !== undefined && prefs.reasoningEffort !== this.preferences.reasoningEffort) {
+            next.reasoningEffort = prefs.reasoningEffort;
+            changed = true;
+        }
+        if (changed) {
+            this.preferences = next;
+            this.emit('preferences-updated', this.preferences);
+        }
+        return { ...this.preferences };
+    }
+    // ── Session Config ──
+    getSessionConfig(sessionId) {
+        return { ...this.sessionConfigs.get(sessionId) };
+    }
+    setSessionConfig(sessionId, key, value) {
+        const prev = this.sessionConfigs.get(sessionId) ?? {};
+        const next = { ...prev, [key]: value };
+        this.sessionConfigs.set(sessionId, next);
+        if (key === 'model' && typeof value === 'string') {
+            this.setPreferences({ model: value });
+        }
+        else if (key === 'reasoningEffort' && (typeof value === 'string' || value === null)) {
+            this.setPreferences({ reasoningEffort: value });
+        }
+        else if (key === 'permissionMode' && typeof value === 'string') {
+            this.setPermissionLevel(sessionId, value);
+            this.persistRegistryField(sessionId, 'permissionMode', value);
+        }
+        else if (key === 'sandboxed' && typeof value === 'boolean') {
+            this.sessionSandboxed.set(sessionId, value);
+            const ps = this.sessions.get(sessionId);
+            if (ps)
+                ps.sandboxed = value;
+            this.persistRegistryField(sessionId, 'sandboxed', value || undefined);
+        }
+        else if (key === 'agent' || key === 'provider') {
+            // Reject agent changes on active sessions — agent type is immutable once spawned
+            const ps = this.sessions.get(sessionId);
+            if (ps) {
+                this.emit('session-config-updated', { sessionId, config: next });
+                return next;
+            }
+            const agentId = normalizeAgentId(value);
+            if (!agentId || !this.providers.has(agentId)) {
+                this.emit('session-config-updated', { sessionId, config: next });
+                return next;
+            }
+            this.sessionAgents.set(sessionId, agentId);
+        }
+        this.emit('session-config-updated', { sessionId, config: next });
+        return next;
+    }
+    // ── Session Lifecycle ──
+    async startSession(opts) {
+        const validModes = ['default', 'acceptEdits', 'bypassPermissions', 'plan'];
+        const level = validModes.includes(opts.permissionMode)
+            ? opts.permissionMode : 'acceptEdits';
+        const sandboxed = !!opts.sandboxed;
+        const systemPrompt = buildSystemPrompt(opts.systemPrompt);
+        const provider = this.getProvider(opts.agent);
+        // Create cardBuilder with 'pending' sessionId — will be updated after provider returns real one
+        const cardBuilder = new StreamCardBuilder('pending', opts.streamId, opts.cwd);
+        const callbacks = this.makeCallbacks(provider.id);
+        const { sessionId, session: providerSession } = await provider.startSession({
+            prompt: opts.prompt,
+            cwd: opts.cwd,
+            streamId: opts.streamId,
+            model: opts.model,
+            permissionLevel: level,
+            sandboxed,
+            systemPrompt,
+        }, cardBuilder, callbacks);
+        // Update cardBuilder with real sessionId — new session has no prior JSONL
+        cardBuilder.updateSessionId(sessionId);
+        cardBuilder.jsonlCutoff = 0;
+        // Update callbacks to use real sessionId (re-bind the closures)
+        // The callbacks are already handed to the provider; for the permission handler
+        // we capture `sessionId` from the request parameter, so this is safe.
+        // Register session
+        this.sessionAgents.set(sessionId, provider.id);
+        this.sessionPermissions.set(sessionId, level);
+        if (sandboxed)
+            this.sessionSandboxed.set(sessionId, true);
+        const prevConfig = this.sessionConfigs.get(sessionId) ?? {};
+        this.sessionConfigs.set(sessionId, {
+            ...prevConfig,
+            agent: provider.id,
+            ...((provider.id !== 'codex' && opts.model)
+                ? { model: opts.model }
+                : (provider.id !== 'codex' && !prevConfig.model)
+                    ? { model: DEFAULT_MODEL }
+                    : {}),
+            permissionMode: level,
+            sandboxed,
+        });
+        const managed = {
+            sessionId,
+            agentId: provider.id,
+            providerSession,
+            cwd: opts.cwd,
+            streaming: true,
+            permissionLevel: level,
+            sandboxed,
+            cardBuilder,
+        };
+        this.sessions.set(sessionId, managed);
+        this.emitSessionUpdate(sessionId);
+        return sessionId;
+    }
+    async resumeSession(opts) {
+        const existing = this.sessions.get(opts.sessionId);
+        const agentId = this.resolveAgentId(opts.sessionId, opts.cwd, opts.agent);
+        // Hot resume: session is streaming and provider session is alive
+        if (existing?.streaming && existing.providerSession?.alive) {
+            console.log(`[session-manager] hot resume session=${opts.sessionId.slice(0, 8)} streaming=true`);
+            // Add user prompt to cardBuilder for getCards on reconnect
+            if (existing.cardBuilder) {
+                existing.cardBuilder.userMessage(opts.prompt);
+            }
+            // Queue the streamId so consumeStream picks it up after the current turn's result
+            const ps = existing.providerSession;
+            if (ps.pendingStreamIds) {
+                ps.pendingStreamIds.push(opts.streamId);
+            }
+            existing.providerSession.sendUserMessage(opts.prompt);
+            return opts.sessionId;
+        }
+        // Cold resume already in flight — queue the prompt instead of spawning again
+        const inFlight = this.coldResumeInFlight.get(opts.sessionId);
+        if (inFlight) {
+            console.log(`[session-manager] cold resume in flight, queuing prompt for session=${opts.sessionId.slice(0, 8)}`);
+            inFlight.queuedPrompts.push(opts.prompt);
+            return opts.sessionId;
+        }
+        // Cold resume: mark as in-flight, then delegate to provider
+        console.log(`[session-manager] cold resume session=${opts.sessionId.slice(0, 8)}`);
+        const flight = { queuedPrompts: [] };
+        this.coldResumeInFlight.set(opts.sessionId, flight);
+        try {
+            // Restore session settings from in-memory maps, falling back to persisted
+            // registry (survives daemon restarts).
+            const registryEntry = getSessionRegistry().getEntry(opts.cwd, opts.sessionId);
+            const validModes = ['default', 'acceptEdits', 'bypassPermissions', 'plan'];
+            const restoredLevel = this.sessionPermissions.get(opts.sessionId)
+                ?? (validModes.includes(registryEntry?.permissionMode) ? registryEntry.permissionMode : undefined);
+            const level = restoredLevel ?? 'acceptEdits';
+            const sandboxed = this.sessionSandboxed.get(opts.sessionId) ?? registryEntry?.sandboxed ?? false;
+            const provider = this.getProvider(agentId);
+            const cardBuilder = existing?.cardBuilder ?? new StreamCardBuilder(opts.sessionId, opts.streamId, opts.cwd);
+            await cardBuilder.snapshotCutoff();
+            const callbacks = this.makeCallbacks(provider.id);
+            const { sessionId, session: providerSession } = await provider.resumeSession({
+                sessionId: opts.sessionId,
+                prompt: opts.prompt,
+                cwd: opts.cwd,
+                streamId: opts.streamId,
+                permissionLevel: level,
+                sandboxed,
+                systemPrompt: buildSystemPrompt(),
+            }, cardBuilder, callbacks);
+            // Update or create session entry
+            this.sessionAgents.set(sessionId, provider.id);
+            if (existing) {
+                existing.agentId = provider.id;
+                existing.providerSession = providerSession;
+                existing.streaming = true;
+            }
+            else {
+                const managed = {
+                    sessionId,
+                    agentId: provider.id,
+                    providerSession,
+                    cwd: opts.cwd,
+                    streaming: true,
+                    permissionLevel: level,
+                    sandboxed,
+                    cardBuilder,
+                };
+                this.sessions.set(sessionId, managed);
+            }
+            this.emitSessionUpdate(sessionId);
+            // Drain queued prompts that arrived while spawning
+            for (const queued of flight.queuedPrompts) {
+                console.log(`[session-manager] draining queued prompt for session=${sessionId.slice(0, 8)}`);
+                providerSession.sendUserMessage(queued);
+            }
+            return sessionId;
+        }
+        finally {
+            this.coldResumeInFlight.delete(opts.sessionId);
+        }
+    }
+    async cancelSession(sessionId) {
+        const ps = this.sessions.get(sessionId);
+        if (!ps?.providerSession)
+            return false;
+        console.log(`[session-manager] cancel session=${sessionId.slice(0, 8)}`);
+        ps.providerSession.interrupt();
+        return true;
+    }
+    closeSession(sessionId) {
+        const ps = this.sessions.get(sessionId);
+        if (!ps)
+            return false;
+        if (ps.providerSession) {
+            ps.providerSession.kill();
+            ps.providerSession = null;
+        }
+        this.sessions.delete(sessionId);
+        this.emitSessionUpdate(sessionId);
+        return true;
+    }
+    // ── Permission ──
+    setPermissionLevel(sessionId, level) {
+        const ps = this.sessions.get(sessionId);
+        if (ps)
+            ps.permissionLevel = level;
+        this.sessionPermissions.set(sessionId, level);
+        this.emit('session-updated', {
+            sessionId,
+            isActive: !!ps,
+            isStreaming: ps?.streaming ?? false,
+            hasPendingInput: ps ? Array.from(this.pendingInputRequests.values()).some(p => p.request.sessionId === sessionId) : false,
+            permissionMode: level,
+        });
+        return true;
+    }
+    getPermissionLevel(sessionId) {
+        return this.sessions.get(sessionId)?.permissionLevel ?? 'acceptEdits';
+    }
+    resolveUserInput(response) {
+        const pending = this.pendingInputRequests.get(response.requestId);
+        if (!pending)
+            return false;
+        this.pendingInputRequests.delete(response.requestId);
+        pending.resolve(response);
+        // Clear pending input on the card
+        const ps = this.sessions.get(pending.request.sessionId);
+        if (ps?.cardBuilder) {
+            const cardEvt = ps.cardBuilder.clearPendingInput(response.requestId);
+            if (cardEvt)
+                this.emit('card-event', cardEvt);
+        }
+        // Persist allow pattern to settings.local.json if provided
+        if (response.allowPattern && ps?.cwd) {
+            this.persistAllowPattern(ps.cwd, response.allowPattern).catch((err) => {
+                console.error('[persistAllowPattern] failed:', err);
+            });
+        }
+        this.emit('user-input-resolved', { requestId: response.requestId, sessionId: pending.request.sessionId });
+        this.emitSessionUpdate(pending.request.sessionId);
+        return true;
+    }
+    // ── Query ──
+    getActiveSessions() {
+        const pendingSessionIds = new Set(Array.from(this.pendingInputRequests.values()).map(p => p.request.sessionId));
+        return Array.from(this.sessions.entries()).map(([id, ps]) => ({
+            sessionId: id,
+            cwd: ps.cwd,
+            agent: ps.agentId,
+            isStreaming: ps.streaming,
+            hasPendingInput: pendingSessionIds.has(id),
+            permissionMode: ps.permissionLevel,
+            sandboxed: ps.sandboxed || undefined,
+        }));
+    }
+    isStreaming(sessionId) {
+        return this.sessions.get(sessionId)?.streaming ?? false;
+    }
+    isOpen(sessionId) {
+        return this.sessions.has(sessionId);
+    }
+    getSessionCwd(sessionId) {
+        return this.sessions.get(sessionId)?.cwd;
+    }
+    getSessionAgent(sessionId, cwd) {
+        return this.resolveAgentId(sessionId, cwd);
+    }
+    getActiveSessionCount() {
+        return this.sessions.size;
+    }
+    getCardBuilder(sessionId) {
+        return this.sessions.get(sessionId)?.cardBuilder ?? null;
+    }
+    async listAvailableSessions(cwd) {
+        const registry = getSessionRegistry();
+        const registryEntries = registry.getEntriesForProject(cwd);
+        const pendingSessionIds = new Set(Array.from(this.pendingInputRequests.values()).map(p => p.request.sessionId));
+        return registryEntries.map(entry => ({
+            sessionId: entry.sessionId,
+            summary: entry.title ?? entry.firstPrompt ?? entry.sessionId.slice(0, 8),
+            lastModified: entry.lastAccessedAt,
+            createdAt: entry.createdAt,
+            cwd: entry.cwd,
+            agent: this.sessions.get(entry.sessionId)?.agentId
+                ?? this.sessionAgents.get(entry.sessionId)
+                ?? entry.agent
+                ?? (entry.provider === 'codex-mcp' ? 'codex' : entry.provider ? 'claude-code' : undefined),
+            gitBranch: entry.gitBranch,
+            messageCount: entry.messageCount,
+            isActive: this.sessions.has(entry.sessionId),
+            isStreaming: this.sessions.get(entry.sessionId)?.streaming ?? false,
+            hasPendingInput: pendingSessionIds.has(entry.sessionId),
+            permissionMode: this.sessions.get(entry.sessionId)?.permissionLevel
+                ?? this.sessionPermissions.get(entry.sessionId),
+        }));
+    }
+    async getCards(sessionId, cwd, offset = 0, limit = 50) {
+        const ps = this.sessions.get(sessionId);
+        const provider = this.getProvider(this.resolveAgentId(sessionId, cwd));
+        const cutoff = ps?.cardBuilder?.jsonlCutoff ?? undefined;
+        let result;
+        if (provider.historyMode === 'claude-jsonl') {
+            // Read JSONL history up to the cutoff (excludes the active turn's messages).
+            result = await buildCardsFromHistory(sessionId, cwd, offset, limit, cutoff);
+        }
+        else {
+            // Memory-mode: use in-memory cards from active turn, falling back to persisted history
+            const streamCards = ps?.cardBuilder?.getCards() ?? [];
+            const persisted = await loadPersistedCards(sessionId);
+            const cards = [...persisted, ...streamCards];
+            const total = cards.length;
+            const start = Math.max(0, total - offset - limit);
+            const end = Math.max(0, total - offset);
+            result = {
+                cards: cards.slice(start, end),
+                total,
+                hasMore: start > 0,
+            };
+        }
+        // Append in-memory cards for the active turn (initial load only — pagination
+        // already has these cards in the PWA's array, so appending them again would duplicate).
+        if (offset === 0 && provider.historyMode === 'claude-jsonl' && ps?.cardBuilder) {
+            const streamingCards = ps.cardBuilder.getCards();
+            if (streamingCards.length > 0) {
+                result.cards.push(...streamingCards);
+                result.total += streamingCards.length;
+            }
+        }
+        // Overlay pending inputs from pendingInputRequests onto matching cards.
+        const pendingByToolUseId = new Map();
+        for (const [, pending] of this.pendingInputRequests) {
+            if (pending.request.sessionId === sessionId && pending.request.toolUseId) {
+                pendingByToolUseId.set(pending.request.toolUseId, {
+                    sessionId: pending.request.sessionId,
+                    requestId: pending.request.requestId,
+                    inputType: pending.request.inputType,
+                    title: pending.request.title,
+                    message: pending.request.message,
+                    options: pending.request.options,
+                });
+            }
+        }
+        if (pendingByToolUseId.size > 0) {
+            for (const card of result.cards) {
+                if (card.type === 'tool_call' && card.toolUseId) {
+                    const pending = pendingByToolUseId.get(card.toolUseId);
+                    if (pending && !card.pendingInput) {
+                        card.pendingInput = pending;
+                    }
+                }
+            }
+        }
+        // Attach session title from config or registry
+        const configTitle = this.sessionConfigs.get(sessionId)?.title;
+        if (configTitle) {
+            result.title = configTitle;
+        }
+        else {
+            const registry = getSessionRegistry();
+            const entry = registry.getEntry(cwd, sessionId);
+            if (entry?.title)
+                result.title = entry.title;
+        }
+        return result;
+    }
+    getPendingInputRequests() {
+        return Array.from(this.pendingInputRequests.values()).map(p => p.request);
+    }
+    getDebugState() {
+        const pendingInputs = Array.from(this.pendingInputRequests.values()).map(p => ({
+            requestId: p.request.requestId,
+            sessionId: p.request.sessionId,
+            toolName: p.request.toolName,
+            agentId: p.request.agentId,
+            inputType: p.request.inputType,
+        }));
+        return { pendingInputs, activeSessions: this.getActiveSessions() };
+    }
+    cleanup() {
+        for (const [requestId, pending] of this.pendingInputRequests) {
+            pending.resolve({ sessionId: '', requestId, action: 'allow' });
+        }
+        this.pendingInputRequests.clear();
+        for (const [, ps] of this.sessions) {
+            if (ps.providerSession) {
+                try {
+                    ps.providerSession.kill();
+                }
+                catch { }
+                ps.providerSession = null;
+            }
+        }
+        this.sessions.clear();
+    }
+    // ── Private: Callbacks Factory ──
+    makeCallbacks(agentId) {
+        return {
+            emitCardEvent: (event) => {
+                this.emit('card-event', event);
+            },
+            emitStreamEnd: (result) => {
+                this.emit('card-stream-end', result);
+                // Update session streaming state
+                const ps = this.sessions.get(result.sessionId);
+                if (ps) {
+                    ps.streaming = false;
+                    this.emitSessionUpdate(result.sessionId);
+                }
+            },
+            handlePermissionRequest: async (sessionId, req) => {
+                return this.handlePermissionRequest(sessionId, req);
+            },
+            onModelDetected: (model) => {
+                if (agentId === 'claude-code') {
+                    this.preferences.model = model;
+                }
+            },
+        };
+    }
+    // ── Private: Permission Handling ──
+    async handlePermissionRequest(sessionId, req) {
+        const { toolName, toolInput, toolUseId } = req;
+        // Check auto-approve rules first
+        if (this.shouldAutoApprove(sessionId, toolName, toolInput)) {
+            return { action: 'allow' };
+        }
+        // Check runtime allow patterns
+        if (this.runtimeAllowPatterns.some(p => matchAllowPattern(p, toolName, toolInput))) {
+            return { action: 'allow' };
+        }
+        // Forward to PWA for user decision
+        const requestId = `perm-${++this.requestCounter}`;
+        const isQuestion = toolName === 'AskUserQuestion';
+        const questions = isQuestion ? toolInput.questions : undefined;
+        const request = {
+            sessionId,
+            requestId,
+            inputType: isQuestion ? 'question' : 'permission',
+            title: isQuestion
+                ? questions?.[0]?.question ?? 'Question from Claude'
+                : `Allow ${toolName}?`,
+            message: isQuestion ? undefined : JSON.stringify(toolInput).slice(0, 500),
+            toolName,
+            toolInput,
+            toolUseId,
+            ...(isQuestion && questions ? {
+                options: questions.flatMap((q) => (q.options ?? []).map((opt) => ({
+                    key: opt.label,
+                    label: opt.label,
+                    description: opt.description,
+                }))),
+            } : {}),
+        };
+        // Create card with pending input
+        const ps = this.sessions.get(sessionId);
+        const cb = ps?.cardBuilder;
+        if (cb) {
+            const pendingAttachment = {
+                sessionId,
+                requestId,
+                inputType: request.inputType,
+                title: request.title,
+                message: request.message,
+                options: request.options,
+            };
+            const cardEvt = cb.toolCallFromPermission(toolName, toolInput, toolUseId, pendingAttachment);
+            this.emit('card-event', cardEvt);
+        }
+        this.emit('user-input-request', request);
+        // Wait for user response
+        const response = await this.waitForUserInput(requestId, request);
+        if (response.action === 'deny') {
+            return { action: 'deny', response: response.response || 'User denied permission' };
+        }
+        // For AskUserQuestion, inject answer
+        if (isQuestion && response.response) {
+            const answers = {};
+            if (questions?.[0]?.question) {
+                answers[questions[0].question] = response.response;
+            }
+            return { action: 'allow', updatedInput: { ...toolInput, answers } };
+        }
+        return { action: 'allow' };
+    }
+    shouldAutoApprove(sessionId, toolName, input) {
+        // SetTitle — always approve
+        if (toolName === SET_TITLE_TOOL) {
+            if (input.title)
+                this.updateSessionTitle(sessionId, input.title);
+            return true;
+        }
+        // SandboxBash: auto-approve when sandboxed, otherwise check as Bash
+        if (toolName === SANDBOX_BASH_TOOL) {
+            if (this.sessions.get(sessionId)?.sandboxed)
+                return true;
+            toolName = 'Bash'; // fall through to permission check as Bash
+        }
+        // Check permission level auto-approve set
+        const level = this.sessions.get(sessionId)?.permissionLevel
+            ?? this.sessionPermissions.get(sessionId) ?? 'acceptEdits';
+        if (!AUTO_APPROVE[level].has(toolName))
+            return false;
+        // For file-writing tools, restrict to project cwd
+        const FILE_WRITE_TOOLS = new Set(['Write', 'Edit', 'NotebookEdit']);
+        if (FILE_WRITE_TOOLS.has(toolName)) {
+            const cwd = this.sessions.get(sessionId)?.cwd;
+            const filePath = (input.file_path ?? input.path);
+            if (filePath && cwd) {
+                const resolvedFile = resolve(filePath);
+                const resolvedCwd = resolve(cwd);
+                return resolvedFile === resolvedCwd || resolvedFile.startsWith(resolvedCwd + '/');
+            }
+        }
+        return true;
+    }
+    /** Update session title (triggered by SetTitle MCP tool). */
+    updateSessionTitle(sessionId, title) {
+        const config = this.sessionConfigs.get(sessionId) ?? {};
+        this.sessionConfigs.set(sessionId, { ...config, title });
+        this.emit('session-config-updated', { sessionId, config: this.sessionConfigs.get(sessionId) });
+        // Update session registry so it persists across restarts
+        const ps = this.sessions.get(sessionId);
+        if (ps?.cwd) {
+            const registry = getSessionRegistry();
+            const entry = registry.getEntry(ps.cwd, sessionId);
+            if (entry) {
+                registry.upsertEntry({ ...entry, title, lastAccessedAt: Date.now() });
+            }
+        }
+    }
+    emitSessionUpdate(sessionId) {
+        const ps = this.sessions.get(sessionId);
+        const hasPendingInput = Array.from(this.pendingInputRequests.values())
+            .some(p => p.request.sessionId === sessionId);
+        this.emit('session-updated', {
+            sessionId,
+            isActive: !!ps,
+            agent: ps?.agentId ?? this.sessionAgents.get(sessionId),
+            isStreaming: ps?.streaming ?? false,
+            hasPendingInput,
+            permissionMode: ps?.permissionLevel ?? this.sessionPermissions.get(sessionId),
+            sandboxed: ps?.sandboxed ?? this.sessionSandboxed.get(sessionId) ?? false,
+        });
+    }
+    persistRegistryField(sessionId, key, value) {
+        const registry = getSessionRegistry();
+        // Active session — cwd is in memory
+        const cwd = this.sessions.get(sessionId)?.cwd;
+        if (cwd) {
+            registry.updateEntry(cwd, sessionId, { [key]: value });
+            return;
+        }
+        // Inactive session — scan registry for the entry
+        for (const entry of registry.getEntriesForProject()) {
+            if (entry.sessionId === sessionId) {
+                registry.updateEntry(entry.cwd, sessionId, { [key]: value });
+                return;
+            }
+        }
+    }
+    async persistAllowPattern(cwd, pattern) {
+        if (!this.runtimeAllowPatterns.includes(pattern)) {
+            this.runtimeAllowPatterns.push(pattern);
+        }
+        const settingsPath = join(cwd, '.claude', 'settings.local.json');
+        let settings = {};
+        try {
+            settings = JSON.parse(await readFile(settingsPath, 'utf-8'));
+        }
+        catch { /* file doesn't exist yet */ }
+        const permissions = settings.permissions ?? {};
+        const allow = Array.isArray(permissions.allow) ? [...permissions.allow] : [];
+        if (!allow.includes(pattern)) {
+            allow.push(pattern);
+            settings.permissions = { ...permissions, allow };
+            await mkdir(join(cwd, '.claude'), { recursive: true });
+            await writeFile(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+            console.log(`[persistAllowPattern] saved ${pattern} to ${settingsPath}`);
+        }
+    }
+    waitForUserInput(requestId, request) {
+        return new Promise((resolve) => {
+            this.pendingInputRequests.set(requestId, { resolve, request });
+        });
+    }
+}
+//# sourceMappingURL=sessionManager.js.map