relay-ide 0.1.0

package/dist/server/sdk-handler.js

@@ -0,0 +1,539 @@
+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;
+}