claude-remote-cli 3.2.0 → 3.3.1

package/dist/server/sdk-handler.js

@@ -1,539 +0,0 @@
-import crypto from 'node:crypto';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { query as sdkQuery } from '@anthropic-ai/claude-agent-sdk';
-const MAX_EVENTS = 2000;
-const IDLE_TIMEOUT_MS = 5000;
-// Controller for streaming user messages into an SDK query
-class SdkInputController {
-    resolveNext = null;
-    queue = [];
-    done = false;
-    push(msg) {
-        if (this.done)
-            return;
-        if (this.resolveNext) {
-            const resolve = this.resolveNext;
-            this.resolveNext = null;
-            resolve({ value: msg, done: false });
-        }
-        else {
-            this.queue.push(msg);
-        }
-    }
-    close() {
-        this.done = true;
-        if (this.resolveNext) {
-            const resolve = this.resolveNext;
-            this.resolveNext = null;
-            resolve({ value: undefined, done: true });
-        }
-    }
-    [Symbol.asyncIterator]() {
-        return {
-            next: () => {
-                if (this.queue.length > 0) {
-                    return Promise.resolve({ value: this.queue.shift(), done: false });
-                }
-                if (this.done) {
-                    return Promise.resolve({ value: undefined, done: true });
-                }
-                return new Promise((resolve) => {
-                    this.resolveNext = resolve;
-                });
-            },
-        };
-    }
-}
-const runtimeStates = new Map();
-// Debug log state
-let debugLogEnabled = false;
-const DEBUG_DIR = path.join(os.homedir(), '.config', 'claude-remote-cli', 'debug');
-const MAX_DEBUG_FILE_SIZE = 10 * 1024 * 1024; // 10MB
-const DEBUG_FILE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
-export function enableDebugLog(enabled) {
-    debugLogEnabled = enabled;
-    if (enabled) {
-        fs.mkdirSync(DEBUG_DIR, { recursive: true });
-        cleanupOldDebugFiles();
-    }
-}
-function cleanupOldDebugFiles() {
-    try {
-        const files = fs.readdirSync(DEBUG_DIR);
-        const now = Date.now();
-        for (const file of files) {
-            if (!file.endsWith('.jsonl'))
-                continue;
-            const filePath = path.join(DEBUG_DIR, file);
-            try {
-                const stat = fs.statSync(filePath);
-                if (now - stat.mtimeMs > DEBUG_FILE_MAX_AGE_MS) {
-                    fs.unlinkSync(filePath);
-                }
-            }
-            catch {
-                // ignore individual file errors
-            }
-        }
-    }
-    catch {
-        // ignore if directory doesn't exist yet
-    }
-}
-// Async write queue to avoid blocking the event loop on debug log writes
-const debugWriteQueue = new Map();
-let debugFlushPending = false;
-function flushDebugWrites() {
-    if (debugFlushPending)
-        return;
-    debugFlushPending = true;
-    queueMicrotask(() => {
-        debugFlushPending = false;
-        for (const [filePath, lines] of debugWriteQueue) {
-            const data = lines.join('');
-            debugWriteQueue.delete(filePath);
-            fs.appendFile(filePath, data, 'utf-8', () => { });
-        }
-    });
-}
-function debugLogEvent(sessionId, event) {
-    if (!debugLogEnabled)
-        return;
-    try {
-        const filePath = path.join(DEBUG_DIR, `${sessionId}.jsonl`);
-        const line = JSON.stringify({ ...event, _logged: new Date().toISOString() }) + '\n';
-        // Async rotation check (best-effort, runs periodically)
-        fs.stat(filePath, (err, stat) => {
-            if (!err && stat.size > MAX_DEBUG_FILE_SIZE) {
-                const rotatedPath = filePath + '.1';
-                fs.unlink(rotatedPath, () => {
-                    fs.rename(filePath, rotatedPath, () => { });
-                });
-            }
-        });
-        // Queue the write
-        const existing = debugWriteQueue.get(filePath);
-        if (existing) {
-            existing.push(line);
-        }
-        else {
-            debugWriteQueue.set(filePath, [line]);
-        }
-        flushDebugWrites();
-    }
-    catch {
-        // debug logging should never crash the server
-    }
-}
-const FILE_EDIT_TOOLS = new Set(['Edit', 'Write', 'MultiEdit']);
-function extractAssistantEvents(msg, timestamp) {
-    const events = [];
-    const content = msg.message.content;
-    const textParts = [];
-    const thinkingParts = [];
-    for (const block of content) {
-        if (block.type === 'text' && block.text) {
-            textParts.push(block.text);
-        }
-        else if (block.type === 'thinking' && block.thinking) {
-            thinkingParts.push(block.thinking);
-        }
-        else if (block.type === 'tool_use' && block.name && block.id) {
-            const input = (block.input || {});
-            const isFileEdit = FILE_EDIT_TOOLS.has(block.name);
-            const filePath = input.file_path || input.path;
-            if (isFileEdit) {
-                const evt = {
-                    type: 'file_change',
-                    id: block.id,
-                    toolName: block.name,
-                    toolInput: input,
-                    timestamp,
-                };
-                if (filePath)
-                    evt.path = filePath;
-                events.push(evt);
-            }
-            else {
-                events.push({
-                    type: 'tool_call',
-                    id: block.id,
-                    toolName: block.name,
-                    toolInput: input,
-                    timestamp,
-                });
-            }
-        }
-    }
-    if (thinkingParts.length > 0) {
-        // Prepend thinking before text/tool events
-        events.unshift({
-            type: 'reasoning',
-            text: thinkingParts.join('\n'),
-            timestamp,
-        });
-    }
-    if (textParts.length > 0) {
-        // Insert text event after thinking but before tool events
-        const insertIdx = thinkingParts.length > 0 ? 1 : 0;
-        events.splice(insertIdx, 0, {
-            type: 'agent_message',
-            id: msg.uuid,
-            text: textParts.join(''),
-            timestamp,
-        });
-    }
-    return events;
-}
-function mapSdkMessageAll(msg) {
-    const timestamp = new Date().toISOString();
-    const events = [];
-    if (msg.type === 'system' && msg.subtype === 'init') {
-        events.push({
-            type: 'session_started',
-            id: msg.session_id,
-            timestamp,
-        });
-        return events;
-    }
-    if (msg.type === 'assistant') {
-        return extractAssistantEvents(msg, timestamp);
-    }
-    if (msg.type === 'result') {
-        if (msg.subtype === 'success') {
-            events.push({
-                type: 'turn_completed',
-                usage: {
-                    input_tokens: msg.usage.input_tokens,
-                    output_tokens: msg.usage.output_tokens,
-                },
-                timestamp,
-            });
-        }
-        else {
-            events.push({
-                type: 'error',
-                text: msg.errors.join('; '),
-                timestamp,
-            });
-        }
-        return events;
-    }
-    return events;
-}
-function addEvent(session, event, state) {
-    session.events.push(event);
-    // FIFO cap
-    while (session.events.length > MAX_EVENTS) {
-        session.events.shift();
-    }
-    // Notify listeners
-    for (const listener of state.eventListeners) {
-        try {
-            listener(event);
-        }
-        catch {
-            // listeners should not crash the handler
-        }
-    }
-    // Debug log
-    debugLogEvent(session.id, event);
-}
-function resetIdleTimer(session, state, idleChangeCallbacks) {
-    if (session.idle) {
-        session.idle = false;
-        for (const cb of idleChangeCallbacks)
-            cb(session.id, false);
-    }
-    if (state.idleTimer)
-        clearTimeout(state.idleTimer);
-    state.idleTimer = setTimeout(() => {
-        if (!session.idle) {
-            session.idle = true;
-            for (const cb of idleChangeCallbacks)
-                cb(session.id, true);
-        }
-    }, IDLE_TIMEOUT_MS);
-}
-export function createSdkSession(params, sessionsMap, idleChangeCallbacks) {
-    const { id, type, agent = 'claude', repoName, repoPath, cwd, root, worktreeName, branchName, displayName, prompt, } = params;
-    const createdAt = new Date().toISOString();
-    const resolvedCwd = cwd || repoPath;
-    // Strip sensitive env vars from child process
-    const env = Object.assign({}, process.env);
-    delete env.CLAUDECODE;
-    // Strip server-internal env vars
-    for (const key of Object.keys(env)) {
-        if (key.startsWith('VAPID_') || key === 'PIN_HASH') {
-            delete env[key];
-        }
-    }
-    const abortController = new AbortController();
-    const inputController = new SdkInputController();
-    // Permission queue for canUseTool callbacks
-    const permissionQueue = new Map();
-    const session = {
-        id,
-        type: type || 'worktree',
-        agent,
-        mode: 'sdk',
-        root: root || '',
-        repoName: repoName || '',
-        repoPath,
-        worktreeName: worktreeName || '',
-        branchName: branchName || worktreeName || '',
-        displayName: displayName || worktreeName || repoName || '',
-        createdAt,
-        lastActivity: createdAt,
-        idle: false,
-        cwd: resolvedCwd,
-        customCommand: null,
-        status: 'active',
-        needsBranchRename: false,
-        events: [],
-        sdkSessionId: null,
-        tokenUsage: { input: 0, output: 0 },
-        estimatedCost: 0,
-    };
-    const state = {
-        query: null,
-        abortController,
-        permissionQueue,
-        eventListeners: [],
-        inputController,
-        idleTimer: null,
-    };
-    // Try to create the SDK query
-    let q;
-    try {
-        q = sdkQuery({
-            prompt: inputController,
-            options: {
-                abortController,
-                cwd: resolvedCwd,
-                env,
-                canUseTool: async (toolName, input, options) => {
-                    const requestId = options.toolUseID || crypto.randomBytes(8).toString('hex');
-                    // Emit a tool_call event for the permission request
-                    const permEvent = {
-                        type: 'tool_call',
-                        id: requestId,
-                        toolName,
-                        toolInput: input,
-                        status: 'pending',
-                        text: options.title || `Claude wants to use ${toolName}`,
-                        timestamp: new Date().toISOString(),
-                    };
-                    addEvent(session, permEvent, state);
-                    return new Promise((resolve, reject) => {
-                        permissionQueue.set(requestId, { resolve, reject });
-                        // Clean up on abort
-                        options.signal.addEventListener('abort', () => {
-                            permissionQueue.delete(requestId);
-                            reject(new Error('Permission request aborted'));
-                        }, { once: true });
-                    });
-                },
-            },
-        });
-        state.query = q;
-    }
-    catch (err) {
-        console.warn('SDK init failed, falling back to PTY:', err instanceof Error ? err.message : String(err));
-        return { fallback: true };
-    }
-    sessionsMap.set(id, session);
-    runtimeStates.set(id, state);
-    // Send initial prompt if provided
-    if (prompt) {
-        inputController.push({
-            type: 'user',
-            message: { role: 'user', content: prompt },
-            parent_tool_use_id: null,
-            session_id: id,
-        });
-    }
-    // Start consuming the event stream in the background
-    void (async () => {
-        try {
-            for await (const msg of q) {
-                session.lastActivity = new Date().toISOString();
-                resetIdleTimer(session, state, idleChangeCallbacks);
-                const events = mapSdkMessageAll(msg);
-                for (const event of events) {
-                    addEvent(session, event, state);
-                    // Track token usage
-                    if (event.type === 'turn_completed' && event.usage) {
-                        session.tokenUsage.input += event.usage.input_tokens;
-                        session.tokenUsage.output += event.usage.output_tokens;
-                    }
-                    // Track session ID
-                    if (event.type === 'session_started' && event.id) {
-                        session.sdkSessionId = event.id;
-                    }
-                }
-            }
-        }
-        catch (err) {
-            const errorEvent = {
-                type: 'error',
-                text: err instanceof Error ? err.message : 'SDK stream error',
-                timestamp: new Date().toISOString(),
-            };
-            addEvent(session, errorEvent, state);
-        }
-    })();
-    const result = {
-        id,
-        type: session.type,
-        agent: session.agent,
-        mode: 'sdk',
-        root: session.root,
-        repoName: session.repoName,
-        repoPath,
-        worktreeName: session.worktreeName,
-        branchName: session.branchName,
-        displayName: session.displayName,
-        createdAt,
-        lastActivity: createdAt,
-        idle: false,
-        cwd: resolvedCwd,
-        customCommand: null,
-        useTmux: false,
-        tmuxSessionName: '',
-        status: 'active',
-        needsBranchRename: false,
-    };
-    return { session, result };
-}
-export function sendMessage(sessionId, text) {
-    const state = runtimeStates.get(sessionId);
-    if (!state || !state.inputController) {
-        throw new Error(`SDK session not found or not active: ${sessionId}`);
-    }
-    state.inputController.push({
-        type: 'user',
-        message: { role: 'user', content: text },
-        parent_tool_use_id: null,
-        session_id: sessionId,
-    });
-}
-export function handlePermission(sessionId, requestId, approved) {
-    const state = runtimeStates.get(sessionId);
-    if (!state) {
-        throw new Error(`SDK session not found: ${sessionId}`);
-    }
-    const pending = state.permissionQueue.get(requestId);
-    if (!pending) {
-        throw new Error(`No pending permission request: ${requestId}`);
-    }
-    state.permissionQueue.delete(requestId);
-    if (approved) {
-        pending.resolve({ behavior: 'allow' });
-    }
-    else {
-        pending.resolve({ behavior: 'deny', message: 'User denied permission' });
-    }
-}
-export function interruptSession(sessionId) {
-    const state = runtimeStates.get(sessionId);
-    if (!state) {
-        throw new Error(`SDK session not found: ${sessionId}`);
-    }
-    if (state.query) {
-        void state.query.interrupt().catch(() => {
-            // If interrupt fails, abort
-            state.abortController.abort();
-        });
-    }
-}
-export function killSdkSession(sessionId) {
-    const state = runtimeStates.get(sessionId);
-    if (!state)
-        return;
-    // Reject all pending permission requests
-    for (const [, pending] of state.permissionQueue) {
-        pending.reject(new Error('Session killed'));
-    }
-    state.permissionQueue.clear();
-    // Close input stream
-    if (state.inputController) {
-        state.inputController.close();
-    }
-    // Close the query
-    if (state.query) {
-        state.query.close();
-    }
-    // Abort
-    state.abortController.abort();
-    // Clear idle timer
-    if (state.idleTimer)
-        clearTimeout(state.idleTimer);
-    // Clean up runtime state
-    runtimeStates.delete(sessionId);
-}
-export function onSdkEvent(sessionId, callback) {
-    const state = runtimeStates.get(sessionId);
-    if (!state) {
-        return () => { };
-    }
-    state.eventListeners.push(callback);
-    return () => {
-        const idx = state.eventListeners.indexOf(callback);
-        if (idx !== -1)
-            state.eventListeners.splice(idx, 1);
-    };
-}
-export function hasSdkRuntime(sessionId) {
-    return runtimeStates.has(sessionId);
-}
-export function serializeSdkSession(session) {
-    return {
-        id: session.id,
-        type: session.type,
-        agent: session.agent,
-        mode: 'sdk',
-        root: session.root,
-        repoName: session.repoName,
-        repoPath: session.repoPath,
-        worktreeName: session.worktreeName,
-        branchName: session.branchName,
-        displayName: session.displayName,
-        createdAt: session.createdAt,
-        lastActivity: session.lastActivity,
-        cwd: session.cwd,
-        sdkSessionId: session.sdkSessionId,
-        tokenUsage: { ...session.tokenUsage },
-        estimatedCost: session.estimatedCost,
-        events: session.events.slice(-100), // Keep last 100 events for restore
-    };
-}
-export function restoreSdkSession(serialized, sessionsMap) {
-    const session = {
-        id: serialized.id,
-        type: serialized.type,
-        agent: serialized.agent,
-        mode: 'sdk',
-        root: serialized.root,
-        repoName: serialized.repoName,
-        repoPath: serialized.repoPath,
-        worktreeName: serialized.worktreeName,
-        branchName: serialized.branchName,
-        displayName: serialized.displayName,
-        createdAt: serialized.createdAt,
-        lastActivity: serialized.lastActivity,
-        idle: true,
-        cwd: serialized.cwd,
-        customCommand: null,
-        status: 'disconnected',
-        needsBranchRename: false,
-        events: serialized.events || [],
-        sdkSessionId: serialized.sdkSessionId,
-        tokenUsage: serialized.tokenUsage || { input: 0, output: 0 },
-        estimatedCost: serialized.estimatedCost || 0,
-    };
-    sessionsMap.set(session.id, session);
-    return session;
-}