relay-ide 0.1.0

package/dist/test/server/clipboard.js

@@ -0,0 +1,56 @@
+import { execFile, execFileSync } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const SUPPORTED_MIME = {
+    'image/png': { ext: '.png', osascriptClass: '«class PNGf»' },
+    'image/jpeg': { ext: '.jpg', osascriptClass: '«class JPEG»' },
+    'image/gif': { ext: '.gif', osascriptClass: '«class GIFf»' },
+    'image/webp': { ext: '.webp', osascriptClass: '«class PNGf»' },
+};
+let cachedTool;
+export function detectClipboardTool() {
+    if (cachedTool !== undefined)
+        return cachedTool;
+    if (process.platform === 'darwin') {
+        cachedTool = 'osascript';
+        return cachedTool;
+    }
+    if (process.env['DISPLAY'] || process.env['WAYLAND_DISPLAY']) {
+        try {
+            execFileSync('which', ['xclip'], { stdio: 'ignore' });
+            cachedTool = 'xclip';
+            return cachedTool;
+        }
+        catch {
+            // xclip not found
+        }
+    }
+    cachedTool = null;
+    return cachedTool;
+}
+function mimeInfo(mimeType) {
+    const info = SUPPORTED_MIME[mimeType];
+    if (!info)
+        throw new Error(`Unsupported MIME type: ${mimeType}`);
+    return info;
+}
+export function extensionForMime(mimeType) {
+    return mimeInfo(mimeType).ext;
+}
+export async function setClipboardImage(filePath, mimeType) {
+    const tool = detectClipboardTool();
+    const info = mimeInfo(mimeType); // throws if unsupported
+    if (tool === 'osascript') {
+        const script = `set the clipboard to (read (POSIX file "${filePath}") as ${info.osascriptClass})`;
+        await execFileAsync('osascript', ['-e', script]);
+        return true;
+    }
+    if (tool === 'xclip') {
+        await execFileAsync('xclip', ['-selection', 'clipboard', '-t', mimeType, '-i', filePath]);
+        return true;
+    }
+    return false;
+}
+export function _resetForTesting() {
+    cachedTool = undefined;
+}

package/dist/test/server/config.js

@@ -0,0 +1,137 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+export const DEFAULTS = {
+    host: '0.0.0.0',
+    port: 3456,
+    cookieTTL: '24h',
+    repos: [],
+    claudeCommand: 'claude',
+    claudeArgs: [],
+    defaultAgent: 'claude',
+    defaultContinue: true,
+    defaultYolo: false,
+    launchInTmux: false,
+    defaultNotifications: true,
+    workspaces: [],
+};
+export function loadConfig(configPath) {
+    if (!fs.existsSync(configPath)) {
+        throw new Error(`Config file not found: ${configPath}`);
+    }
+    const raw = fs.readFileSync(configPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    const config = { ...DEFAULTS, ...parsed };
+    // Validate and clean workspaceGroups
+    if (config.workspaceGroups != null) {
+        const validPaths = new Set(config.workspaces ?? []);
+        const seenPaths = new Set();
+        const cleaned = {};
+        for (const [groupName, paths] of Object.entries(config.workspaceGroups)) {
+            if (!Array.isArray(paths)) {
+                console.warn(`workspaceGroups: group "${groupName}" value is not an array, skipping`);
+                continue;
+            }
+            const filteredPaths = [];
+            for (const p of paths) {
+                if (!validPaths.has(p)) {
+                    console.warn(`workspaceGroups: path "${p}" in group "${groupName}" is not in workspaces[], skipping`);
+                    continue;
+                }
+                if (seenPaths.has(p)) {
+                    console.warn(`workspaceGroups: path "${p}" in group "${groupName}" is already assigned to another group, skipping`);
+                    continue;
+                }
+                seenPaths.add(p);
+                filteredPaths.push(p);
+            }
+            if (filteredPaths.length > 0) {
+                cleaned[groupName] = filteredPaths;
+            }
+        }
+        config.workspaceGroups = cleaned;
+    }
+    return config;
+}
+export function saveConfig(configPath, config) {
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+}
+function metaDir(configPath) {
+    return path.join(path.dirname(configPath), 'worktree-meta');
+}
+function metaFilePath(configPath, worktreePath) {
+    const hash = crypto.createHash('sha256').update(worktreePath).digest('hex').slice(0, 16);
+    return path.join(metaDir(configPath), hash + '.json');
+}
+export function ensureMetaDir(configPath) {
+    const dir = metaDir(configPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+export function readMeta(configPath, worktreePath) {
+    const fp = metaFilePath(configPath, worktreePath);
+    try {
+        return JSON.parse(fs.readFileSync(fp, 'utf8'));
+    }
+    catch (_) {
+        return null;
+    }
+}
+export function writeMeta(configPath, meta) {
+    const fp = metaFilePath(configPath, meta.worktreePath);
+    ensureMetaDir(configPath);
+    fs.writeFileSync(fp, JSON.stringify(meta, null, 2), 'utf8');
+}
+export function deleteMeta(configPath, worktreePath) {
+    const fp = metaFilePath(configPath, worktreePath);
+    try {
+        fs.unlinkSync(fp);
+    }
+    catch (_) {
+        // File may not exist; ignore
+    }
+}
+export function getWorkspaceSettings(config, workspacePath) {
+    const globalDefaults = {
+        defaultAgent: config.defaultAgent,
+        defaultContinue: config.defaultContinue,
+        defaultYolo: config.defaultYolo,
+        launchInTmux: config.launchInTmux,
+        claudeArgs: config.claudeArgs,
+    };
+    const perWorkspace = config.workspaceSettings?.[workspacePath] || {};
+    // Per-workspace settings override global — only for defined keys
+    return { ...globalDefaults, ...perWorkspace };
+}
+export function resolveSessionSettings(config, repoPath, overrides) {
+    const ws = getWorkspaceSettings(config, repoPath);
+    return {
+        agent: overrides.agent ?? ws.defaultAgent ?? 'claude',
+        yolo: overrides.yolo ?? ws.defaultYolo ?? false,
+        continue: overrides.continue ?? ws.defaultContinue ?? true,
+        useTmux: overrides.useTmux ?? ws.launchInTmux ?? false,
+        claudeArgs: overrides.claudeArgs ?? ws.claudeArgs ?? [],
+    };
+}
+export function deleteWorkspaceSettingKeys(configPath, config, workspacePath, keys) {
+    if (!config.workspaceSettings?.[workspacePath])
+        return;
+    for (const key of keys) {
+        delete config.workspaceSettings[workspacePath][key];
+    }
+    // Clean up empty workspace entries
+    if (Object.keys(config.workspaceSettings[workspacePath]).length === 0) {
+        delete config.workspaceSettings[workspacePath];
+    }
+    saveConfig(configPath, config);
+}
+export function setWorkspaceSettings(configPath, config, workspacePath, settings) {
+    if (!config.workspaceSettings)
+        config.workspaceSettings = {};
+    config.workspaceSettings[workspacePath] = {
+        ...config.workspaceSettings[workspacePath],
+        ...settings,
+    };
+    saveConfig(configPath, config);
+}

package/dist/test/server/git.js

@@ -0,0 +1,308 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+function normalizeBranchNames(stdout) {
+    const branches = stdout
+        .split('\n')
+        .map((branch) => branch.trim())
+        .filter((branch) => branch && !branch.includes('HEAD'))
+        .map((branch) => branch.replace(/^origin\//, ''));
+    return [...new Set(branches)].sort();
+}
+async function listBranches(repoPath, options = {}) {
+    const run = options.exec || execFileAsync;
+    if (options.refresh) {
+        try {
+            await run('git', ['fetch', '--all', '--prune'], { cwd: repoPath });
+        }
+        catch {
+            // Best effort — still return the locally-known refs below.
+        }
+    }
+    try {
+        const { stdout } = await run('git', ['branch', '-a', '--format=%(refname:short)'], { cwd: repoPath });
+        return normalizeBranchNames(stdout);
+    }
+    catch {
+        return [];
+    }
+}
+async function getCurrentBranch(repoPath, options = {}) {
+    const run = options.exec || execFileAsync;
+    try {
+        const { stdout } = await run('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: repoPath });
+        return stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+async function getActivityFeed(repoPath, options = {}) {
+    const run = options.exec || execFileAsync;
+    try {
+        const { stdout } = await run('git', [
+            'log',
+            '--all',
+            '--since=24 hours ago',
+            '--oneline',
+            '--max-count=50',
+            '--format=%H|%h|%s|%an|%ar|%D',
+        ], { cwd: repoPath, timeout: 5000 });
+        const lines = stdout.split('\n').filter((line) => line.trim());
+        const entries = [];
+        for (const line of lines) {
+            try {
+                // Split into exactly 6 parts by the first 5 pipe characters
+                const parts = [];
+                let remaining = line;
+                for (let i = 0; i < 5; i++) {
+                    const idx = remaining.indexOf('|');
+                    if (idx === -1)
+                        break;
+                    parts.push(remaining.slice(0, idx));
+                    remaining = remaining.slice(idx + 1);
+                }
+                parts.push(remaining);
+                if (parts.length < 5)
+                    continue;
+                const hash = parts[0] ?? '';
+                const shortHash = parts[1] ?? '';
+                const message = parts[2] ?? '';
+                const author = parts[3] ?? '';
+                const timeAgo = parts[4] ?? '';
+                const decorations = parts[5] ?? '';
+                if (!hash || !shortHash)
+                    continue;
+                const branches = decorations
+                    .split(',')
+                    .map((d) => d.trim())
+                    .filter((d) => d && !d.startsWith('tag:') && d !== 'HEAD')
+                    .map((d) => d.replace(/^HEAD -> /, '').replace(/^origin\//, ''));
+                entries.push({
+                    hash: hash.trim(),
+                    shortHash: shortHash.trim(),
+                    message: message.trim(),
+                    author: author.trim(),
+                    timeAgo: timeAgo.trim(),
+                    branches: [...new Set(branches)],
+                });
+            }
+            catch {
+                // Skip malformed lines
+                continue;
+            }
+        }
+        return entries;
+    }
+    catch {
+        return [];
+    }
+}
+async function getCiStatus(repoPath, branch, options = {}) {
+    const run = options.exec || execFileAsync;
+    let stdout;
+    let stderr;
+    try {
+        ({ stdout, stderr } = await run('gh', ['pr', 'checks', branch, '--json', 'name,state,conclusion'], { cwd: repoPath, timeout: 5000 }));
+    }
+    catch (err) {
+        if (err && typeof err === 'object') {
+            const errObj = err;
+            const errorText = errObj.stderr ?? errObj.message ?? '';
+            // gh not installed
+            if (errObj.code === 'ENOENT')
+                return null;
+            // Not authenticated
+            if (typeof errorText === 'string' &&
+                (errorText.includes('not logged into') || errorText.includes('authentication'))) {
+                return { total: 0, passing: 0, failing: 0, pending: 0, authError: true };
+            }
+            // No PR for branch
+            if (typeof errorText === 'string' &&
+                (errorText.includes('no pull requests found') || errorText.includes('Could not find'))) {
+                return null;
+            }
+        }
+        return null;
+    }
+    // gh may exit 0 but write errors or auth prompts to stderr
+    if (stderr && (stderr.includes('not logged into') || stderr.includes('authentication'))) {
+        return { total: 0, passing: 0, failing: 0, pending: 0, authError: true };
+    }
+    if (!stdout.trim())
+        return null;
+    try {
+        const checks = JSON.parse(stdout);
+        let passing = 0;
+        let failing = 0;
+        let pending = 0;
+        for (const check of checks) {
+            const conclusion = (check.conclusion ?? '').toUpperCase();
+            const state = (check.state ?? '').toUpperCase();
+            if (conclusion === 'SUCCESS' || conclusion === 'SKIPPED' || conclusion === 'NEUTRAL') {
+                passing++;
+            }
+            else if (conclusion === 'FAILURE' || conclusion === 'CANCELLED' || conclusion === 'TIMED_OUT') {
+                failing++;
+            }
+            else if (state === 'IN_PROGRESS' || state === 'QUEUED' || state === 'PENDING' || conclusion === '') {
+                pending++;
+            }
+            else {
+                // Unknown conclusion — treat as pending rather than silently ignoring
+                pending++;
+            }
+        }
+        return { total: checks.length, passing, failing, pending };
+    }
+    catch {
+        return null;
+    }
+}
+async function getPrForBranch(repoPath, branch, options = {}) {
+    const run = options.exec || execFileAsync;
+    let stdout;
+    try {
+        ({ stdout } = await run('gh', [
+            'pr',
+            'view',
+            branch,
+            '--json',
+            'number,title,url,state,headRefName,baseRefName,reviewDecision,isDraft,additions,deletions,mergeable',
+        ], { cwd: repoPath, timeout: 5000 }));
+    }
+    catch {
+        return null;
+    }
+    if (!stdout.trim())
+        return null;
+    try {
+        const data = JSON.parse(stdout);
+        return {
+            number: data.number,
+            title: data.title,
+            url: data.url,
+            state: data.state,
+            headRefName: data.headRefName,
+            baseRefName: data.baseRefName,
+            isDraft: data.isDraft,
+            reviewDecision: data.reviewDecision ?? null,
+            additions: data.additions ?? 0,
+            deletions: data.deletions ?? 0,
+            mergeable: data.mergeable ?? 'UNKNOWN',
+            unresolvedCommentCount: 0,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function switchBranch(repoPath, branch, options = {}) {
+    const run = options.exec || execFileAsync;
+    try {
+        await run('git', ['checkout', branch], { cwd: repoPath, timeout: 5000 });
+        return { success: true };
+    }
+    catch (err) {
+        if (err && typeof err === 'object') {
+            const errObj = err;
+            const errorText = errObj.stderr ?? errObj.message ?? 'Unknown error';
+            return { success: false, error: errorText.trim() };
+        }
+        return { success: false, error: 'Unknown error' };
+    }
+}
+async function getCommitsAhead(repoPath, branch, baseBranch, options = {}) {
+    const run = options.exec || execFileAsync;
+    try {
+        const { stdout } = await run('git', ['rev-list', '--count', `${baseBranch}..${branch}`], { cwd: repoPath, timeout: 5000 });
+        const count = parseInt(stdout.trim(), 10);
+        return Number.isFinite(count) ? count : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+async function getUnresolvedCommentCount(repoPath, prNumber, options = {}) {
+    const run = options.exec || execFileAsync;
+    try {
+        const { stdout: repoStdout } = await run('gh', ['repo', 'view', '--json', 'nameWithOwner', '--jq', '.nameWithOwner'], { cwd: repoPath, timeout: 5000 });
+        const nameWithOwner = repoStdout.trim();
+        if (!nameWithOwner)
+            return 0;
+        const [owner, repo] = nameWithOwner.split('/');
+        if (!owner || !repo)
+            return 0;
+        const query = `query($owner: String!, $repo: String!, $number: Int!) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $number) {
+      reviewThreads(first: 100) {
+        nodes { isResolved }
+      }
+    }
+  }
+}`;
+        const { stdout } = await run('gh', [
+            'api', 'graphql',
+            '-f', `query=${query}`,
+            '-f', `owner=${owner}`,
+            '-f', `repo=${repo}`,
+            '-F', `number=${prNumber}`,
+        ], { cwd: repoPath, timeout: 10000 });
+        const result = JSON.parse(stdout);
+        const nodes = result?.data?.repository?.pullRequest?.reviewThreads?.nodes ?? [];
+        return nodes.filter((n) => !n.isResolved).length;
+    }
+    catch {
+        return 0;
+    }
+}
+async function getWorkingTreeDiff(repoPath, exec = execFileAsync) {
+    try {
+        const { stdout } = await exec('git', ['diff', '--shortstat'], { cwd: repoPath, timeout: 5000 });
+        // Output like: " 3 files changed, 55 insertions(+), 12 deletions(-)"
+        const insertions = stdout.match(/(\d+) insertion/);
+        const deletions = stdout.match(/(\d+) deletion/);
+        return {
+            additions: insertions?.[1] ? parseInt(insertions[1], 10) : 0,
+            deletions: deletions?.[1] ? parseInt(deletions[1], 10) : 0,
+        };
+    }
+    catch {
+        return { additions: 0, deletions: 0 };
+    }
+}
+/**
+ * Convert a git branch name to a human-readable display name.
+ * "fix-mobile-scroll-bug" → "Fix mobile scroll bug"
+ * "feature/add-auth"      → "Add auth"
+ */
+function branchToDisplayName(branch) {
+    const stripped = branch.replace(/^(feature|fix|chore|refactor|docs|test|ci|build)\//i, '');
+    const words = stripped.replace(/[-_]/g, ' ').trim();
+    if (!words)
+        return branch;
+    return words.charAt(0).toUpperCase() + words.slice(1);
+}
+async function isBranchStale(repoPath, branch, options = {}) {
+    const run = options.exec || execFileAsync;
+    try {
+        for (const base of ['main', 'master']) {
+            try {
+                const { stdout } = await run('git', ['rev-list', '--count', `${base}..${branch}`], { cwd: repoPath, timeout: 5000 });
+                const count = parseInt(stdout.trim(), 10);
+                if (count === 0)
+                    return true;
+                return false;
+            }
+            catch {
+                continue;
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+export { listBranches, normalizeBranchNames, getActivityFeed, getCiStatus, getPrForBranch, getUnresolvedCommentCount, switchBranch, getCommitsAhead, getCurrentBranch, getWorkingTreeDiff, branchToDisplayName, isBranchStale, };

package/dist/test/server/hooks.js

@@ -0,0 +1,196 @@
+import crypto from 'node:crypto';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { Router } from 'express';
+import express from 'express';
+import { stripAnsi, cleanEnv } from './utils.js';
+import { branchToDisplayName } from './git.js';
+import { writeMeta } from './config.js';
+const execFileAsync = promisify(execFile);
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const LOCALHOST_ADDRS = new Set(['127.0.0.1', '::1', '::ffff:127.0.0.1']);
+const DEFAULT_RENAME_PROMPT = 'Output ONLY a short kebab-case git branch name (no explanation, no backticks, no prefix, just the name) that describes this task:';
+const RENAME_RETRY_DELAY_MS = 5000;
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function setAgentState(session, state, deps) {
+    session.agentState = state;
+    deps.fireStateChange(session.id, state);
+    session._lastHookTime = Date.now();
+}
+function extractToolDetail(_toolName, toolInput) {
+    if (toolInput && typeof toolInput === 'object') {
+        const input = toolInput;
+        if (typeof input.file_path === 'string')
+            return input.file_path;
+        if (typeof input.path === 'string')
+            return input.path;
+        if (typeof input.command === 'string')
+            return input.command.slice(0, 80);
+    }
+    return undefined;
+}
+async function spawnBranchRename(session, promptText, deps) {
+    const cleanedPrompt = stripAnsi(promptText).slice(0, 500);
+    const renamePrompt = session.branchRenamePrompt ?? DEFAULT_RENAME_PROMPT;
+    const fullPrompt = renamePrompt + '\n\n' + cleanedPrompt;
+    const env = cleanEnv();
+    for (let attempt = 0; attempt < 2; attempt++) {
+        // Check session still exists before attempting
+        if (!deps.getSession(session.id))
+            return;
+        if (attempt > 0) {
+            await new Promise((resolve) => setTimeout(resolve, RENAME_RETRY_DELAY_MS));
+            // Re-check after delay
+            if (!deps.getSession(session.id))
+                return;
+        }
+        try {
+            const { stdout } = await execFileAsync('claude', ['-p', '--model', 'haiku', fullPrompt], { cwd: session.cwd, timeout: 30000, env });
+            // Sanitize output
+            let branchName = stdout
+                .replace(/`/g, '')
+                .replace(/[^a-zA-Z0-9-]/g, '-')
+                .replace(/-+/g, '-')
+                .replace(/^-+|-+$/g, '')
+                .toLowerCase()
+                .slice(0, 60);
+            if (!branchName)
+                continue;
+            // Check session still exists before renaming
+            if (!deps.getSession(session.id))
+                return;
+            await execFileAsync('git', ['branch', '-m', branchName], { cwd: session.cwd });
+            session.branchName = branchName;
+            session.displayName = branchToDisplayName(branchName);
+            deps.broadcastEvent('session-renamed', {
+                sessionId: session.id,
+                branchName: session.branchName,
+                displayName: session.displayName,
+            });
+            if (deps.configPath) {
+                writeMeta(deps.configPath, {
+                    worktreePath: session.repoPath,
+                    displayName: session.displayName,
+                    lastActivity: session.lastActivity,
+                    branchName: session.branchName,
+                });
+            }
+            return; // success
+        }
+        catch (err) {
+            if (attempt === 1) {
+                console.error('[hooks] branch rename failed after 2 attempts:', err);
+                session.needsBranchRename = true;
+            }
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+export function createHooksRouter(deps) {
+    const router = Router();
+    // Middleware: IP allowlist — only localhost, do NOT trust X-Forwarded-For
+    router.use((req, res, next) => {
+        const remoteAddr = req.socket.remoteAddress;
+        if (!remoteAddr || !LOCALHOST_ADDRS.has(remoteAddr)) {
+            res.status(403).json({ error: 'Forbidden' });
+            return;
+        }
+        next();
+    });
+    // Middleware: parse JSON with generous limit for PostToolUse payloads
+    router.use(express.json({ limit: '5mb' }));
+    // Middleware: token verification
+    router.use((req, res, next) => {
+        const sessionId = req.query.sessionId;
+        const token = req.query.token;
+        if (typeof sessionId !== 'string' || !sessionId) {
+            res.status(400).json({ error: 'Missing sessionId' });
+            return;
+        }
+        if (typeof token !== 'string' || !token) {
+            res.status(400).json({ error: 'Missing token' });
+            return;
+        }
+        const session = deps.getSession(sessionId);
+        if (!session) {
+            res.status(404).json({ error: 'Session not found' });
+            return;
+        }
+        const tokenBuf = Buffer.from(token);
+        const hookTokenBuf = Buffer.from(session.hookToken);
+        if (tokenBuf.length !== hookTokenBuf.length || !crypto.timingSafeEqual(tokenBuf, hookTokenBuf)) {
+            res.status(403).json({ error: 'Invalid token' });
+            return;
+        }
+        req._hookSession = session;
+        next();
+    });
+    // ---------------------------------------------------------------------------
+    // Route handlers
+    // ---------------------------------------------------------------------------
+    // POST /stop → idle
+    router.post('/stop', (req, res) => {
+        const session = req._hookSession;
+        setAgentState(session, 'idle', deps);
+        res.json({ ok: true });
+    });
+    // POST /notification → permission-prompt | waiting-for-input
+    router.post('/notification', (req, res) => {
+        const session = req._hookSession;
+        const type = req.query.type;
+        if (type === 'permission_prompt') {
+            setAgentState(session, 'permission-prompt', deps);
+            session.lastAttentionNotifiedAt = Date.now();
+            deps.notifySessionAttention(session.id, { displayName: session.displayName, type: session.type });
+        }
+        else if (type === 'idle_prompt') {
+            setAgentState(session, 'waiting-for-input', deps);
+            session.lastAttentionNotifiedAt = Date.now();
+            deps.notifySessionAttention(session.id, { displayName: session.displayName, type: session.type });
+        }
+        res.json({ ok: true });
+    });
+    // POST /prompt-submit → processing (+ optional branch rename on first message)
+    router.post('/prompt-submit', (req, res) => {
+        const session = req._hookSession;
+        setAgentState(session, 'processing', deps);
+        if (session.needsBranchRename === true) {
+            session.needsBranchRename = false;
+            const promptText = typeof req.body?.prompt === 'string' ? req.body.prompt : '';
+            spawnBranchRename(session, promptText, deps).catch((err) => {
+                console.error('[hooks] spawnBranchRename error:', err);
+            });
+        }
+        res.json({ ok: true });
+    });
+    // POST /session-end → acknowledge hook (PTY onExit owns actual cleanup and cleanedUp flag)
+    router.post('/session-end', (_req, res) => {
+        // Acknowledge hook — PTY onExit owns actual cleanup and cleanedUp flag
+        res.json({ ok: true });
+    });
+    // POST /tool-use → set currentActivity
+    router.post('/tool-use', (req, res) => {
+        const session = req._hookSession;
+        const body = req.body;
+        const toolName = typeof body?.tool_name === 'string' ? body.tool_name : '';
+        const toolInput = body?.tool_input;
+        const detail = extractToolDetail(toolName, toolInput);
+        session.currentActivity = detail !== undefined ? { tool: toolName, detail } : { tool: toolName };
+        deps.broadcastEvent('session-activity-changed', { sessionId: session.id });
+        res.json({ ok: true });
+    });
+    // POST /tool-result → clear currentActivity
+    router.post('/tool-result', (req, res) => {
+        const session = req._hookSession;
+        session.currentActivity = undefined;
+        deps.broadcastEvent('session-activity-changed', { sessionId: session.id });
+        res.json({ ok: true });
+    });
+    return router;
+}