relay-ide 0.1.0

package/dist/server/sessions.js

@@ -0,0 +1,638 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { AGENT_COMMANDS, AGENT_CONTINUE_ARGS, AGENT_YOLO_ARGS, resolveFramework, } from './types.js';
+import { createPtySession, upgradeHooksSettings } from './pty-handler.js';
+import { cleanupCodexHooksAdapter } from './codex-hooks-adapter.js';
+import { getWorkingTreeDiff } from './git.js';
+import { getPrForBranch, isStalePr } from './gh.js';
+import { trackEvent, recordSessionEvent, upsertSessionRollup, } from './analytics.js';
+import { createLogger } from './logger.js';
+const execFileAsync = promisify(execFile);
+const logger = createLogger('sessions');
+const STALE_THRESHOLD_MS = 5 * 60 * 1000; // 5 minutes
+// In-memory registry: id -> Session
+const sessions = new Map();
+// Session metadata cache: session ID or worktree path -> SessionMeta
+const metaCache = new Map();
+// Module-level defaults for hooks injection (set via configure())
+let defaultPort;
+let defaultForceOutputParser;
+let defaultConfigDir;
+function configure(opts) {
+    defaultPort = opts.port;
+    defaultForceOutputParser = opts.forceOutputParser;
+    defaultConfigDir = opts.configDir;
+}
+let terminalCounter = 0;
+let agentCounter = 0;
+const stateChangeCallbacks = [];
+function onStateChange(cb) {
+    stateChangeCallbacks.push(cb);
+}
+const sessionCreateCallbacks = [];
+function onSessionCreate(cb) {
+    sessionCreateCallbacks.push(cb);
+}
+function fireSessionCreate(sessionId, cwd, branchName) {
+    for (const cb of sessionCreateCallbacks) {
+        try {
+            cb(sessionId, cwd, branchName);
+        }
+        catch (err) {
+            logger.error('sessionCreate callback error:', err);
+        }
+    }
+}
+const sessionEndCallbacks = [];
+function onSessionEnd(cb) {
+    sessionEndCallbacks.push(cb);
+}
+function fireSessionEnd(sessionId, cwd, branchName) {
+    for (const cb of sessionEndCallbacks) {
+        try {
+            cb(sessionId, cwd, branchName);
+        }
+        catch (err) {
+            logger.error('sessionEnd callback error:', err);
+        }
+    }
+}
+export function fireStateChange(sessionId, state) {
+    for (const cb of [...stateChangeCallbacks])
+        cb(sessionId, state);
+}
+export function computeBackendState(session) {
+    // permission-prompt takes highest priority
+    if (session.agentState === 'permission-prompt')
+        return 'permission';
+    // error
+    if (session.agentState === 'error')
+        return 'error';
+    // processing = running
+    if (session.agentState === 'processing')
+        return 'running';
+    // initializing
+    if (session.agentState === 'initializing')
+        return 'initializing';
+    // idle or waiting-for-input = idle (explicitly idle-like agent states)
+    if (session.agentState === 'idle' ||
+        session.agentState === 'waiting-for-input')
+        return 'idle';
+    // For sessions without a recognized agentState (terminal/custom), fall back to idle flag
+    return session.idle ? 'idle' : 'running';
+}
+const backendStateChangeCallbacks = [];
+export function onBackendStateChange(cb) {
+    backendStateChangeCallbacks.push(cb);
+}
+export function fireBackendStateIfChanged(session) {
+    const newState = computeBackendState(session);
+    let permissionType;
+    if (newState === 'permission') {
+        permissionType =
+            session.currentActivity?.tool === 'AskUserQuestion'
+                ? 'question'
+                : 'approval';
+    }
+    if (session._lastEmittedBackendState === newState &&
+        session._lastEmittedPermissionType === permissionType)
+        return;
+    session._lastEmittedBackendState = newState;
+    session._lastEmittedPermissionType = permissionType;
+    for (const cb of [...backendStateChangeCallbacks]) {
+        try {
+            cb(session.id, newState, permissionType);
+        }
+        catch (err) {
+            logger.error('backendStateChange callback error:', err);
+        }
+    }
+}
+function create({ id: providedId, needsBranchRename, branchRenamePrompt, initialPrompt, workspaceId, additionalDirs, agent = 'claude', cols = 80, rows = 24, args = [], port, forceOutputParser, frameworks, ...rest }) {
+    const id = providedId || crypto.randomBytes(8).toString('hex');
+    const ptyParams = {
+        ...rest,
+        id,
+        agent,
+        cols,
+        rows,
+        args,
+        port: port ?? defaultPort,
+        forceOutputParser: forceOutputParser ?? defaultForceOutputParser,
+        configDir: rest.configDir ?? defaultConfigDir,
+        frameworks,
+    };
+    const { session: ptySession, result } = createPtySession(ptyParams, sessions, stateChangeCallbacks, sessionEndCallbacks, fireBackendStateIfChanged);
+    trackEvent({
+        category: 'session',
+        action: 'created',
+        target: id,
+        properties: {
+            agent,
+            type: rest.type ?? 'agent',
+            workspace: rest.repoPath,
+            mode: rest.command ? 'terminal' : 'agent',
+        },
+        session_id: id,
+    });
+    if (needsBranchRename) {
+        ptySession.needsBranchRename = true;
+    }
+    if (branchRenamePrompt) {
+        ptySession.branchRenamePrompt = branchRenamePrompt;
+    }
+    if (initialPrompt) {
+        ptySession.initialPrompt = initialPrompt;
+    }
+    if (workspaceId) {
+        ptySession.workspaceId = workspaceId;
+    }
+    if (additionalDirs?.length) {
+        ptySession.additionalDirs = additionalDirs;
+    }
+    fireSessionCreate(id, ptySession.cwd, ptySession.branchName);
+    // Record session start for analytics
+    recordSessionEvent({
+        session_id: id,
+        repo_path: ptySession.repoPath,
+        event_type: 'session_start',
+        timestamp: new Date().toISOString(),
+    });
+    upsertSessionRollup({
+        sessionId: id,
+        repoPath: ptySession.repoPath,
+        repoName: ptySession.repoName,
+        agentType: agent,
+        startedAt: new Date().toISOString(),
+    });
+    if (initialPrompt) {
+        const promptHandler = (changedId, state) => {
+            if (changedId === id &&
+                state === 'waiting-for-input' &&
+                ptySession.initialPrompt) {
+                const prompt = ptySession.initialPrompt;
+                ptySession.initialPrompt = undefined; // one-shot
+                // Small delay to ensure the agent's input handler is ready
+                setTimeout(() => {
+                    try {
+                        ptySession.pty.write(prompt + '\n');
+                    }
+                    catch (err) {
+                        logger.error('Failed to inject initial prompt:', err);
+                    }
+                }, 500);
+                // Remove this handler after firing
+                const idx = stateChangeCallbacks.indexOf(promptHandler);
+                if (idx !== -1)
+                    stateChangeCallbacks.splice(idx, 1);
+            }
+        };
+        stateChangeCallbacks.push(promptHandler);
+    }
+    return { ...result, needsBranchRename: !!ptySession.needsBranchRename };
+}
+function get(id) {
+    return sessions.get(id);
+}
+function list() {
+    return Array.from(sessions.values())
+        .map((s) => ({
+        id: s.id,
+        type: s.type,
+        agent: s.agent,
+        mode: s.mode,
+        repoPath: s.repoPath,
+        worktreePath: s.worktreePath,
+        cwd: s.cwd,
+        repoName: s.repoName,
+        branchName: s.branchName,
+        displayName: s.displayName,
+        createdAt: s.createdAt,
+        lastActivity: s.lastActivity,
+        idle: s.idle,
+        customCommand: s.customCommand,
+        useTmux: s.useTmux,
+        tmuxSessionName: s.tmuxSessionName,
+        status: s.status,
+        needsBranchRename: !!s.needsBranchRename,
+        agentState: s.agentState,
+        currentActivity: s.currentActivity,
+        ...(s.workspaceId ? { workspaceId: s.workspaceId } : {}),
+        ...(s.additionalDirs?.length
+            ? { additionalDirs: s.additionalDirs }
+            : {}),
+        ...(s.dataQuality !== undefined ? { dataQuality: s.dataQuality } : {}),
+    }))
+        .sort((a, b) => b.lastActivity.localeCompare(a.lastActivity));
+}
+function updateDisplayName(id, displayName) {
+    const session = sessions.get(id);
+    if (!session)
+        throw new Error('Session not found: ' + id);
+    session.displayName = displayName;
+    return { id, displayName };
+}
+function kill(id) {
+    const session = sessions.get(id);
+    if (!session) {
+        throw new Error(`Session not found: ${id}`);
+    }
+    try {
+        session.pty.kill('SIGTERM');
+    }
+    catch {
+        // PTY may already be dead (e.g. disconnected sessions) — still delete from registry
+    }
+    if (session.tmuxSessionName) {
+        execFile('tmux', ['kill-session', '-t', session.tmuxSessionName], () => { });
+    }
+    const durationS = Math.round((Date.now() - new Date(session.createdAt).getTime()) / 1000);
+    trackEvent({
+        category: 'session',
+        action: 'ended',
+        target: id,
+        properties: {
+            agent: session.agent,
+            type: session.type,
+            workspace: session.repoPath,
+            duration_s: durationS,
+        },
+        session_id: id,
+    });
+    fireSessionEnd(id, session.cwd, session.branchName);
+    // Clean up codex hooks adapter temp directory to avoid leaking temp files
+    if (session.agent === 'codex' && session.hooksActive) {
+        cleanupCodexHooksAdapter(id);
+    }
+    sessions.delete(id);
+}
+function killAllTmuxSessions() {
+    for (const session of sessions.values()) {
+        if (session.tmuxSessionName) {
+            execFile('tmux', ['kill-session', '-t', session.tmuxSessionName], () => { });
+        }
+    }
+}
+function resize(id, cols, rows) {
+    const session = sessions.get(id);
+    if (!session) {
+        throw new Error(`Session not found: ${id}`);
+    }
+    session.pty.resize(cols, rows);
+}
+function write(id, data) {
+    const session = sessions.get(id);
+    if (!session) {
+        throw new Error(`Session not found: ${id}`);
+    }
+    session.pty.write(data);
+}
+function nextTerminalName() {
+    return `Terminal ${++terminalCounter}`;
+}
+function nextAgentName() {
+    return `Agent ${++agentCounter}`;
+}
+function serializeAll(configDir) {
+    const scrollbackDirPath = path.join(configDir, 'scrollback');
+    fs.mkdirSync(scrollbackDirPath, { recursive: true });
+    const serializedPty = [];
+    for (const session of sessions.values()) {
+        // Write scrollback to disk
+        const scrollbackPath = path.join(scrollbackDirPath, session.id + '.buf');
+        fs.writeFileSync(scrollbackPath, session.scrollback.join(''), 'utf-8');
+        serializedPty.push({
+            id: session.id,
+            type: session.type,
+            agent: session.agent,
+            repoPath: session.repoPath,
+            worktreePath: session.worktreePath,
+            cwd: session.cwd,
+            repoName: session.repoName,
+            branchName: session.branchName,
+            displayName: session.displayName,
+            createdAt: session.createdAt,
+            lastActivity: session.lastActivity,
+            useTmux: session.useTmux,
+            tmuxSessionName: session.tmuxSessionName || '',
+            customCommand: session.customCommand,
+            yolo: session.yolo,
+            claudeArgs: session.sessionArgs ?? session.claudeArgs,
+            hookToken: session.hookToken,
+            hooksActive: session.hooksActive,
+            continuePolicy: session.continuePolicy,
+            ...(session.needsBranchRename
+                ? { needsBranchRename: true }
+                : {}),
+            ...(session.branchRenamePrompt
+                ? { branchRenamePrompt: session.branchRenamePrompt }
+                : {}),
+            ...(session.workspaceId ? { workspaceId: session.workspaceId } : {}),
+            ...(session.additionalDirs?.length
+                ? { additionalDirs: session.additionalDirs }
+                : {}),
+        });
+    }
+    const pending = {
+        version: 4,
+        timestamp: new Date().toISOString(),
+        sessions: serializedPty,
+    };
+    fs.writeFileSync(path.join(configDir, 'pending-sessions.json'), JSON.stringify(pending, null, 2), 'utf-8');
+}
+async function restoreFromDisk(configDir, workspaces, frameworks) {
+    const pendingPath = path.join(configDir, 'pending-sessions.json');
+    if (!fs.existsSync(pendingPath))
+        return 0;
+    let pending;
+    try {
+        pending = JSON.parse(fs.readFileSync(pendingPath, 'utf-8'));
+    }
+    catch {
+        fs.unlinkSync(pendingPath);
+        return 0;
+    }
+    // Ignore stale files (>5 minutes old)
+    if (Date.now() - new Date(pending.timestamp).getTime() > STALE_THRESHOLD_MS) {
+        fs.unlinkSync(pendingPath);
+        return 0;
+    }
+    // v2 → v3 migration
+    if (pending.version <= 2) {
+        for (const s of pending.sessions) {
+            const legacy = s;
+            // In v2 format, the field was called "repoPath" and stored the CWD
+            const v2Cwd = s['repoPath'];
+            if (!('cwd' in s) && v2Cwd) {
+                s.cwd = v2Cwd;
+            }
+            if (!('repoPath' in s) || v2Cwd === s.repoPath) {
+                // Derive repoPath from the configured workspaces (it's different from the old cwd meaning)
+                const configuredWorkspaces = workspaces ?? [];
+                const cwd = s.cwd ?? v2Cwd ?? '';
+                const matchedWorkspace = configuredWorkspaces.find((w) => cwd === w || cwd.startsWith(w + '/'));
+                if (!matchedWorkspace) {
+                    logger.warn(`v2→v3 migration: no configured workspace matches cwd "${cwd}", using cwd as repoPath`);
+                }
+                s.repoPath = matchedWorkspace ?? cwd;
+            }
+            if (!('worktreePath' in s)) {
+                const cwd = s.cwd ?? '';
+                const repoPath = s.repoPath ?? '';
+                // If cwd differs from repoPath, it's a worktree
+                s.worktreePath = cwd !== repoPath ? cwd : null;
+            }
+            // Map old types to new
+            if (s.type === 'repo' || s.type === 'worktree') {
+                s.type = 'agent';
+            }
+            // Clean up legacy fields (repoPath is now kept as it's our real field)
+            delete legacy.root;
+            delete legacy.worktreeName;
+        }
+    }
+    // v3 → v4 migration: workspacePath → repoPath
+    // NOTE: This block also fires for v1/v2 files, but is a no-op for them because
+    // the v2→v3 block above already sets `repoPath`, so the `!('repoPath' in s)`
+    // guard is false. Correctness depends on sequential execution order.
+    if (pending.version <= 3) {
+        for (const s of pending.sessions) {
+            const legacy = s;
+            if ('workspacePath' in legacy && !('repoPath' in s)) {
+                s.repoPath = legacy.workspacePath;
+                delete legacy.workspacePath;
+            }
+        }
+    }
+    const scrollbackDirPath = path.join(configDir, 'scrollback');
+    let restored = 0;
+    // Restore PTY sessions
+    for (const s of pending.sessions) {
+        // Load scrollback from disk
+        let initialScrollback;
+        const scrollbackPath = path.join(scrollbackDirPath, s.id + '.buf');
+        try {
+            const data = fs.readFileSync(scrollbackPath, 'utf-8');
+            if (data.length > 0)
+                initialScrollback = [data];
+        }
+        catch {
+            // Missing scrollback is non-fatal
+        }
+        // Determine spawn command and args
+        let command;
+        let args = [];
+        if (s.customCommand) {
+            // Terminal session — respawn the shell
+            command = s.customCommand;
+        }
+        else if (s.useTmux && s.tmuxSessionName) {
+            // Tmux session — check if tmux session is still alive
+            let tmuxAlive = false;
+            try {
+                await execFileAsync('tmux', ['has-session', '-t', s.tmuxSessionName]);
+                tmuxAlive = true;
+            }
+            catch {
+                // tmux session is gone
+            }
+            if (tmuxAlive) {
+                // Attach to surviving tmux session
+                command = 'tmux';
+                args = ['-u', 'attach-session', '-t', s.tmuxSessionName];
+                // Upgrade hooks-settings.json to include statusLine if missing (migration for pre-telemetry sessions)
+                if (s.hooksActive && defaultConfigDir) {
+                    const upgraded = upgradeHooksSettings(s.id, defaultConfigDir);
+                    if (upgraded)
+                        logger.info(`Upgraded hooks settings for session ${s.id} (added statusLine relay)`);
+                }
+            }
+            else {
+                // Tmux session died — fall back to agent with continue args + preserved flags
+                // Continue args first: Codex uses subcommands (resume --last) that must precede flags
+                let continueArgsList;
+                let yoloArgsList;
+                try {
+                    const framework = resolveFramework(frameworks ? { frameworks } : {}, s.agent);
+                    continueArgsList = framework.continueArgs;
+                    yoloArgsList = framework.yoloArgs;
+                }
+                catch {
+                    // Unknown framework — fall back to deprecated lookup tables
+                    continueArgsList = AGENT_CONTINUE_ARGS[s.agent] ?? [];
+                    yoloArgsList = AGENT_YOLO_ARGS[s.agent] ?? [];
+                }
+                args = [
+                    ...continueArgsList,
+                    ...(s.claudeArgs ?? []),
+                    ...(s.yolo ? yoloArgsList : []),
+                ];
+            }
+        }
+        else {
+            // Non-tmux agent session — respawn with continue args + preserved flags
+            // Continue args first: Codex uses subcommands (resume --last) that must precede flags
+            let continueArgsList;
+            let yoloArgsList;
+            try {
+                const framework = resolveFramework({}, s.agent);
+                continueArgsList = framework.continueArgs;
+                yoloArgsList = framework.yoloArgs;
+            }
+            catch {
+                // Unknown framework — fall back to deprecated lookup tables
+                continueArgsList = AGENT_CONTINUE_ARGS[s.agent] ?? [];
+                yoloArgsList = AGENT_YOLO_ARGS[s.agent] ?? [];
+            }
+            args = [
+                ...continueArgsList,
+                ...(s.claudeArgs ?? []),
+                ...(s.yolo ? yoloArgsList : []),
+            ];
+        }
+        try {
+            const createParams = {
+                id: s.id,
+                type: s.type,
+                agent: s.agent,
+                repoName: s.repoName,
+                repoPath: s.repoPath,
+                worktreePath: s.worktreePath,
+                cwd: s.cwd,
+                branchName: s.branchName,
+                displayName: s.displayName,
+                args,
+                useTmux: false, // Don't re-wrap in tmux — either attaching to existing or using plain agent
+                tmuxSessionName: s.tmuxSessionName,
+                restored: true,
+                yolo: s.yolo ?? false,
+                claudeArgs: s.claudeArgs ?? [],
+                hookToken: s.hookToken,
+                hooksActive: s.hooksActive,
+                continuePolicy: s.continuePolicy ?? 'never',
+                ...(s.needsBranchRename ? { needsBranchRename: true } : {}),
+                ...(s.branchRenamePrompt
+                    ? { branchRenamePrompt: s.branchRenamePrompt }
+                    : {}),
+                ...(s.workspaceId ? { workspaceId: s.workspaceId } : {}),
+                ...(s.additionalDirs?.length
+                    ? { additionalDirs: s.additionalDirs }
+                    : {}),
+            };
+            if (command)
+                createParams.command = command;
+            if (initialScrollback)
+                createParams.initialScrollback = initialScrollback;
+            create(createParams);
+            restored++;
+        }
+        catch (err) {
+            logger.error(`Failed to restore session ${s.id} (${s.displayName})`, err);
+        }
+        // Clean up scrollback file
+        try {
+            fs.unlinkSync(scrollbackPath);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    // Clean up
+    try {
+        fs.unlinkSync(pendingPath);
+    }
+    catch {
+        /* ignore */
+    }
+    try {
+        fs.rmdirSync(path.join(configDir, 'scrollback'));
+    }
+    catch {
+        /* ignore — may not be empty */
+    }
+    // Sync counters to avoid duplicate display names after restore
+    for (const s of sessions.values()) {
+        const agentMatch = s.displayName?.match(/^Agent (\d+)$/);
+        if (agentMatch)
+            agentCounter = Math.max(agentCounter, parseInt(agentMatch[1], 10));
+        const termMatch = s.displayName?.match(/^Terminal (\d+)$/);
+        if (termMatch)
+            terminalCounter = Math.max(terminalCounter, parseInt(termMatch[1], 10));
+    }
+    return restored;
+}
+/** Returns the set of tmux session names currently owned by restored sessions */
+function activeTmuxSessionNames() {
+    const names = new Set();
+    for (const session of sessions.values()) {
+        if (session.tmuxSessionName)
+            names.add(session.tmuxSessionName);
+    }
+    return names;
+}
+async function fetchMetaForSession(session) {
+    const repoPath = session.cwd;
+    const branch = session.branchName;
+    let prNumber = null;
+    let additions = 0;
+    let deletions = 0;
+    if (branch) {
+        try {
+            const pr = await getPrForBranch(repoPath, branch);
+            if (pr && !isStalePr(pr)) {
+                prNumber = pr.number;
+                additions = pr.additions;
+                deletions = pr.deletions;
+            }
+        }
+        catch {
+            /* gh CLI unavailable */
+        }
+    }
+    // Fallback to working tree diff if no PR data
+    if (additions === 0 && deletions === 0) {
+        const diff = await getWorkingTreeDiff(repoPath);
+        additions = diff.additions;
+        deletions = diff.deletions;
+    }
+    return {
+        prNumber,
+        additions,
+        deletions,
+        fetchedAt: new Date().toISOString(),
+    };
+}
+async function getSessionMeta(id, refresh = false) {
+    if (!refresh && metaCache.has(id))
+        return metaCache.get(id);
+    const session = sessions.get(id);
+    if (!session)
+        return metaCache.get(id) ?? null;
+    const summary = list().find((s) => s.id === id);
+    if (!summary)
+        return null;
+    const meta = await fetchMetaForSession(summary);
+    metaCache.set(id, meta);
+    return meta;
+}
+function getAllSessionMeta() {
+    const result = {};
+    for (const [key, meta] of metaCache) {
+        result[key] = meta;
+    }
+    return result;
+}
+// Populate cache for all active sessions (called on startup or refresh)
+async function populateMetaCache() {
+    const allSessions = list();
+    await Promise.allSettled(allSessions.map(async (s) => {
+        if (!metaCache.has(s.id)) {
+            const meta = await fetchMetaForSession(s);
+            metaCache.set(s.id, meta);
+        }
+    }));
+}
+export { configure, create, get, list, kill, killAllTmuxSessions, resize, updateDisplayName, write, onStateChange, onSessionCreate, onSessionEnd, nextTerminalName, nextAgentName, serializeAll, restoreFromDisk, activeTmuxSessionNames, getSessionMeta, getAllSessionMeta, populateMetaCache, AGENT_COMMANDS, AGENT_CONTINUE_ARGS, AGENT_YOLO_ARGS, };