relay-ide 0.1.0

package/dist/test/server/sessions.js

@@ -0,0 +1,434 @@
+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 } from './types.js';
+import { createPtySession } from './pty-handler.js';
+import { getPrForBranch, getWorkingTreeDiff } from './git.js';
+import { trackEvent } from './analytics.js';
+const execFileAsync = promisify(execFile);
+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;
+function configure(opts) {
+    defaultPort = opts.port;
+    defaultForceOutputParser = opts.forceOutputParser;
+}
+let terminalCounter = 0;
+let agentCounter = 0;
+const idleChangeCallbacks = [];
+function onIdleChange(cb) {
+    idleChangeCallbacks.push(cb);
+}
+const stateChangeCallbacks = [];
+function onStateChange(cb) {
+    stateChangeCallbacks.push(cb);
+}
+const sessionCreateCallbacks = [];
+function onSessionCreate(cb) {
+    sessionCreateCallbacks.push(cb);
+}
+function fireSessionCreate(sessionId, repoPath, branchName) {
+    for (const cb of sessionCreateCallbacks) {
+        try {
+            cb(sessionId, repoPath, branchName);
+        }
+        catch (err) {
+            console.error('[sessions] sessionCreate callback error:', err);
+        }
+    }
+}
+const sessionEndCallbacks = [];
+function onSessionEnd(cb) {
+    sessionEndCallbacks.push(cb);
+}
+function fireSessionEnd(sessionId, repoPath, branchName) {
+    for (const cb of sessionEndCallbacks) {
+        try {
+            cb(sessionId, repoPath, branchName);
+        }
+        catch (err) {
+            console.error('[sessions] sessionEnd callback error:', err);
+        }
+    }
+}
+export function fireStateChange(sessionId, state) {
+    for (const cb of [...stateChangeCallbacks])
+        cb(sessionId, state);
+}
+function create({ id: providedId, needsBranchRename, branchRenamePrompt, initialPrompt, agent = 'claude', cols = 80, rows = 24, args = [], port, forceOutputParser, ...rest }) {
+    const id = providedId || crypto.randomBytes(8).toString('hex');
+    const ptyParams = {
+        ...rest,
+        id,
+        agent,
+        cols,
+        rows,
+        args,
+        port: port ?? defaultPort,
+        forceOutputParser: forceOutputParser ?? defaultForceOutputParser,
+    };
+    const { session: ptySession, result } = createPtySession(ptyParams, sessions, idleChangeCallbacks, stateChangeCallbacks, sessionEndCallbacks);
+    trackEvent({
+        category: 'session',
+        action: 'created',
+        target: id,
+        properties: {
+            agent,
+            type: rest.type ?? 'worktree',
+            workspace: rest.root ?? 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;
+    }
+    fireSessionCreate(id, ptySession.repoPath, ptySession.branchName);
+    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) {
+                        console.error('[sessions] 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,
+        root: s.root,
+        repoName: s.repoName,
+        repoPath: s.repoPath,
+        worktreeName: s.worktreeName,
+        branchName: s.branchName,
+        displayName: s.displayName,
+        createdAt: s.createdAt,
+        lastActivity: s.lastActivity,
+        idle: s.idle,
+        cwd: s.cwd,
+        customCommand: s.customCommand,
+        useTmux: s.useTmux,
+        tmuxSessionName: s.tmuxSessionName,
+        status: s.status,
+        needsBranchRename: !!s.needsBranchRename,
+        agentState: s.agentState,
+        currentActivity: s.currentActivity,
+    }))
+        .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.root || session.repoPath,
+            duration_s: durationS,
+        },
+        session_id: id,
+    });
+    fireSessionEnd(id, session.repoPath, session.branchName);
+    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 findRepoSession(repoPath) {
+    return list().find((s) => s.type === 'repo' && s.repoPath === repoPath);
+}
+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,
+            root: session.root,
+            repoName: session.repoName,
+            repoPath: session.repoPath,
+            worktreeName: session.worktreeName,
+            branchName: session.branchName,
+            displayName: session.displayName,
+            createdAt: session.createdAt,
+            lastActivity: session.lastActivity,
+            useTmux: session.useTmux,
+            tmuxSessionName: session.tmuxSessionName,
+            customCommand: session.customCommand,
+            cwd: session.cwd,
+        });
+    }
+    const pending = {
+        version: 1,
+        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) {
+    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;
+    }
+    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];
+            }
+            else {
+                // Tmux session died — fall back to agent with continue args
+                args = [...AGENT_CONTINUE_ARGS[s.agent]];
+            }
+        }
+        else {
+            // Non-tmux agent session — respawn with continue args
+            args = [...AGENT_CONTINUE_ARGS[s.agent]];
+        }
+        try {
+            const createParams = {
+                id: s.id,
+                type: s.type,
+                agent: s.agent,
+                repoName: s.repoName,
+                repoPath: s.repoPath,
+                cwd: s.cwd,
+                root: s.root,
+                worktreeName: s.worktreeName,
+                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,
+            };
+            if (command)
+                createParams.command = command;
+            if (initialScrollback)
+                createParams.initialScrollback = initialScrollback;
+            create(createParams);
+            restored++;
+        }
+        catch {
+            console.error(`Failed to restore session ${s.id} (${s.displayName})`);
+        }
+        // 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.repoPath;
+    const branch = session.branchName;
+    let prNumber = null;
+    let additions = 0;
+    let deletions = 0;
+    if (branch) {
+        try {
+            const pr = await getPrForBranch(repoPath, branch);
+            if (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, onIdleChange, onStateChange, onSessionCreate, onSessionEnd, findRepoSession, nextTerminalName, nextAgentName, serializeAll, restoreFromDisk, activeTmuxSessionNames, getSessionMeta, getAllSessionMeta, populateMetaCache, AGENT_COMMANDS, AGENT_CONTINUE_ARGS, AGENT_YOLO_ARGS };

package/dist/test/server/ticket-transitions.js

@@ -0,0 +1,216 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { Router } from 'express';
+import { loadConfig } from './config.js';
+const execFileAsync = promisify(execFile);
+const GH_TIMEOUT_MS = 10_000;
+function ghIssueNumber(ticketId) {
+    const match = ticketId.match(/^GH-(\d+)$/i);
+    return match ? match[1] : null;
+}
+async function addLabel(exec, repoPath, issueNumber, label) {
+    try {
+        await exec('gh', ['issue', 'edit', issueNumber, '--add-label', label], {
+            cwd: repoPath,
+            timeout: GH_TIMEOUT_MS,
+        });
+    }
+    catch (err) {
+        console.error(`[ticket-transitions] Failed to add label "${label}" to #${issueNumber}:`, err);
+    }
+}
+async function removeLabel(exec, repoPath, issueNumber, label) {
+    try {
+        await exec('gh', ['issue', 'edit', issueNumber, '--remove-label', label], {
+            cwd: repoPath,
+            timeout: GH_TIMEOUT_MS,
+        });
+    }
+    catch {
+        // Label may not exist — non-fatal
+    }
+}
+/** Call a Jira transition by ID. Non-fatal on error. */
+async function jiraTransition(ticketId, transitionId) {
+    const baseUrl = process.env.JIRA_BASE_URL;
+    const email = process.env.JIRA_EMAIL;
+    const token = process.env.JIRA_API_TOKEN;
+    if (!baseUrl || !email || !token)
+        return;
+    try {
+        const res = await fetch(`${baseUrl}/rest/api/3/issue/${encodeURIComponent(ticketId)}/transitions`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Basic ${Buffer.from(email + ':' + token).toString('base64')}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ transition: { id: transitionId } }),
+        });
+        if (!res.ok) {
+            console.error(`[ticket-transitions] Jira transition returned ${res.status} for ${ticketId}`);
+        }
+    }
+    catch (err) {
+        console.error(`[ticket-transitions] Jira transition failed for ${ticketId}:`, err);
+    }
+}
+/** Update a Linear issue state. Non-fatal on error. */
+async function linearStateUpdate(ticketIdentifier, stateId) {
+    const apiKey = process.env.LINEAR_API_KEY;
+    if (!apiKey)
+        return;
+    // Linear mutations need the issue ID, but we only have the identifier (e.g. "TEAM-123").
+    // Resolve the issue ID by identifier, then update state.
+    try {
+        const searchRes = await fetch('https://api.linear.app/graphql', {
+            method: 'POST',
+            headers: { 'Authorization': `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                query: `query($filter: IssueFilter) { issues(filter: $filter, first: 1) { nodes { id } } }`,
+                variables: { filter: { identifier: { eq: ticketIdentifier } } },
+            }),
+        });
+        if (!searchRes.ok) {
+            console.error(`[ticket-transitions] Linear issue lookup returned ${searchRes.status} for ${ticketIdentifier}`);
+            return;
+        }
+        const searchData = (await searchRes.json());
+        const issueId = searchData.data?.issues?.nodes?.[0]?.id;
+        if (!issueId)
+            return;
+        const updateRes = await fetch('https://api.linear.app/graphql', {
+            method: 'POST',
+            headers: { 'Authorization': `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                query: `mutation($id: String!, $stateId: String!) { issueUpdate(id: $id, input: { stateId: $stateId }) { success } }`,
+                variables: { id: issueId, stateId },
+            }),
+        });
+        if (!updateRes.ok) {
+            console.error(`[ticket-transitions] Linear state update returned ${updateRes.status} for ${ticketIdentifier}`);
+        }
+    }
+    catch (err) {
+        console.error(`[ticket-transitions] Linear state update failed for ${ticketIdentifier}:`, err);
+    }
+}
+/**
+ * Best-effort source detection from a ticket ID pattern.
+ * Known limitation: when both Jira and Linear are configured, non-GH tickets
+ * are matched by whichever env var is present. This is imperfect — a future
+ * improvement would persist the source alongside branch links.
+ */
+function detectTicketSource(ticketId) {
+    if (ticketId.startsWith('GH-'))
+        return 'github';
+    // Prefer Jira for PROJECT-style keys (>= 3 uppercase letters before dash)
+    // since Jira project keys are typically longer than Linear team keys (2-3 chars).
+    const prefix = ticketId.split('-')[0] ?? '';
+    if (prefix.length >= 3 && process.env.JIRA_API_TOKEN)
+        return 'jira';
+    if (process.env.LINEAR_API_KEY)
+        return 'linear';
+    if (process.env.JIRA_API_TOKEN)
+        return 'jira';
+    return 'github'; // fallback
+}
+export function createTicketTransitionsRouter(deps) {
+    // In-memory idempotency guard: ticketId -> last transitioned state
+    const transitionMap = new Map();
+    const exec = deps.execAsync ?? execFileAsync;
+    const { configPath } = deps;
+    const router = Router();
+    /** Get status mapping for a transition state from config */
+    function getStatusMapping(source, state) {
+        const config = loadConfig(configPath);
+        if (source === 'jira')
+            return config.integrations?.jira?.statusMappings?.[state];
+        return config.integrations?.linear?.statusMappings?.[state];
+    }
+    async function transitionOnSessionCreate(ctx) {
+        const current = transitionMap.get(ctx.ticketId);
+        if (current && current !== 'none')
+            return;
+        if (ctx.source === 'github') {
+            const issueNum = ghIssueNumber(ctx.ticketId);
+            if (!issueNum)
+                return;
+            transitionMap.set(ctx.ticketId, 'in-progress');
+            await addLabel(exec, ctx.repoPath, issueNum, 'in-progress');
+        }
+        else if (ctx.source === 'jira') {
+            transitionMap.set(ctx.ticketId, 'in-progress');
+            const transitionId = getStatusMapping('jira', 'in-progress');
+            if (transitionId)
+                await jiraTransition(ctx.ticketId, transitionId);
+        }
+        else if (ctx.source === 'linear') {
+            transitionMap.set(ctx.ticketId, 'in-progress');
+            const stateId = getStatusMapping('linear', 'in-progress');
+            if (stateId)
+                await linearStateUpdate(ctx.ticketId, stateId);
+        }
+    }
+    async function checkPrTransitions(prs, branchLinks) {
+        for (const pr of prs) {
+            for (const [ticketId, links] of Object.entries(branchLinks)) {
+                const linked = links.some((l) => l.branchName === pr.headRefName);
+                if (!linked)
+                    continue;
+                const current = transitionMap.get(ticketId);
+                const source = detectTicketSource(ticketId);
+                if (pr.state === 'OPEN' && current !== 'code-review' && current !== 'ready-for-qa') {
+                    if (source === 'github') {
+                        const issueNum = ghIssueNumber(ticketId);
+                        if (!issueNum)
+                            continue;
+                        const repoPath = links[0]?.repoPath;
+                        if (!repoPath)
+                            continue;
+                        transitionMap.set(ticketId, 'code-review');
+                        await removeLabel(exec, repoPath, issueNum, 'in-progress');
+                        await addLabel(exec, repoPath, issueNum, 'code-review');
+                    }
+                    else if (source === 'jira') {
+                        transitionMap.set(ticketId, 'code-review');
+                        const transitionId = getStatusMapping('jira', 'code-review');
+                        if (transitionId)
+                            await jiraTransition(ticketId, transitionId);
+                    }
+                    else if (source === 'linear') {
+                        transitionMap.set(ticketId, 'code-review');
+                        const stateId = getStatusMapping('linear', 'code-review');
+                        if (stateId)
+                            await linearStateUpdate(ticketId, stateId);
+                    }
+                }
+                else if (pr.state === 'MERGED' && current !== 'ready-for-qa') {
+                    if (source === 'github') {
+                        const issueNum = ghIssueNumber(ticketId);
+                        if (!issueNum)
+                            continue;
+                        const repoPath = links[0]?.repoPath;
+                        if (!repoPath)
+                            continue;
+                        transitionMap.set(ticketId, 'ready-for-qa');
+                        await removeLabel(exec, repoPath, issueNum, 'code-review');
+                        await addLabel(exec, repoPath, issueNum, 'ready-for-qa');
+                    }
+                    else if (source === 'jira') {
+                        transitionMap.set(ticketId, 'ready-for-qa');
+                        const transitionId = getStatusMapping('jira', 'ready-for-qa');
+                        if (transitionId)
+                            await jiraTransition(ticketId, transitionId);
+                    }
+                    else if (source === 'linear') {
+                        transitionMap.set(ticketId, 'ready-for-qa');
+                        const stateId = getStatusMapping('linear', 'ready-for-qa');
+                        if (stateId)
+                            await linearStateUpdate(ticketId, stateId);
+                    }
+                }
+            }
+        }
+    }
+    return { router, transitionOnSessionCreate, checkPrTransitions };
+}

package/dist/test/server/types.js

@@ -0,0 +1,20 @@
+// Agent command records
+export const AGENT_COMMANDS = {
+    claude: 'claude',
+    codex: 'codex',
+};
+export const AGENT_CONTINUE_ARGS = {
+    claude: ['--continue'],
+    codex: ['resume', '--last'],
+};
+export const AGENT_YOLO_ARGS = {
+    claude: ['--dangerously-skip-permissions'],
+    codex: ['--full-auto'],
+};
+export const MOUNTAIN_NAMES = [
+    'everest', 'kilimanjaro', 'denali', 'fuji', 'rainier', 'matterhorn',
+    'elbrus', 'aconcagua', 'kangchenjunga', 'lhotse', 'makalu', 'cho-oyu',
+    'dhaulagiri', 'manaslu', 'annapurna', 'nanga-parbat', 'olympus',
+    'mont-blanc', 'k2', 'vinson', 'erebus', 'logan', 'puncak-jaya',
+    'wilhelm', 'cook', 'ararat', 'etna', 'shasta', 'whitney', 'hood',
+];

package/dist/test/server/utils.js

@@ -0,0 +1,22 @@
+// Strip ANSI escape sequences (CSI, OSC, charset, mode sequences)
+export const ANSI_RE = /\x1b\[[0-9;]*[a-zA-Z]|\x1b\][^\x07]*\x07|\x1b[()][AB012]|\x1b\[\?[0-9;]*[hlm]|\x1b\[[0-9]*[ABCDJKH]/g;
+export function stripAnsi(text) {
+    return text.replace(ANSI_RE, '');
+}
+export function semverLessThan(a, b) {
+    const parse = (v) => (v.split('-').at(0) ?? v).split('.').map(Number);
+    const pa = parse(a);
+    const pb = parse(b);
+    const aMaj = pa[0] ?? 0, aMin = pa[1] ?? 0, aPat = pa[2] ?? 0;
+    const bMaj = pb[0] ?? 0, bMin = pb[1] ?? 0, bPat = pb[2] ?? 0;
+    if (aMaj !== bMaj)
+        return aMaj < bMaj;
+    if (aMin !== bMin)
+        return aMin < bMin;
+    return aPat < bPat;
+}
+export function cleanEnv() {
+    const env = Object.assign({}, process.env);
+    delete env.CLAUDECODE;
+    return env;
+}