relay-ide 0.1.0

package/dist/server/telemetry.js

@@ -0,0 +1,236 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { Router } from 'express';
+import { createLogger } from './logger.js';
+const logger = createLogger('telemetry');
+const POLL_INTERVAL_MS = 2_000;
+const PERSIST_INTERVAL_MS = 60_000;
+const STALE_THRESHOLD_MS = 5 * 60 * 1000;
+let activeDeps = null;
+let pollTimer = null;
+let persistTimer = null;
+let sessionTelemetry = new Map();
+let accountTelemetry = null;
+let restoredPendingOnly = false;
+function telemetryDir(configDir) {
+    return path.join(configDir, 'telemetry');
+}
+function pendingFilePath(configDir) {
+    return path.join(configDir, 'pending-telemetry.json');
+}
+function asNumber(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+function asString(value, fallback = '') {
+    return typeof value === 'string' ? value : fallback;
+}
+function telemetryToObject() {
+    return Object.fromEntries(sessionTelemetry.entries());
+}
+function sameTelemetry(a, b) {
+    if (!a)
+        return false;
+    return (a.sessionId === b.sessionId &&
+        a.model === b.model &&
+        a.totalInputTokens === b.totalInputTokens &&
+        a.totalOutputTokens === b.totalOutputTokens &&
+        a.totalCacheRead === b.totalCacheRead &&
+        a.totalCacheWrite === b.totalCacheWrite &&
+        a.contextPercent === b.contextPercent &&
+        a.contextWindowSize === b.contextWindowSize &&
+        a.costUsd === b.costUsd &&
+        a.source === b.source);
+}
+function sameAccountTelemetry(a, b) {
+    if (!a)
+        return false;
+    return (a.fiveHourUsedPercent === b.fiveHourUsedPercent &&
+        a.fiveHourResetsAt === b.fiveHourResetsAt &&
+        a.sevenDayUsedPercent === b.sevenDayUsedPercent &&
+        a.sevenDayResetsAt === b.sevenDayResetsAt);
+}
+function extractTelemetry(sessionId, payload) {
+    if (!payload || typeof payload !== 'object')
+        return null;
+    const data = payload;
+    const contextWindow = (data.context_window ?? {});
+    const currentUsage = (contextWindow.current_usage ?? {});
+    const cost = (data.cost ?? {});
+    const rateLimits = (data.rate_limits ?? {});
+    const fiveHour = (rateLimits.five_hour ?? {});
+    const sevenDay = (rateLimits.seven_day ?? {});
+    const model = (data.model ?? {});
+    const session = {
+        sessionId,
+        model: typeof model.display_name === 'string' ? model.display_name : null,
+        totalInputTokens: asNumber(contextWindow.total_input_tokens, 0),
+        totalOutputTokens: asNumber(contextWindow.total_output_tokens, 0),
+        totalCacheRead: asNumber(currentUsage.cache_read_input_tokens, 0),
+        totalCacheWrite: asNumber(currentUsage.cache_creation_input_tokens, 0),
+        contextPercent: asNumber(contextWindow.used_percentage, -1),
+        contextWindowSize: asNumber(contextWindow.context_window_size, 0),
+        costUsd: typeof cost.total_cost_usd === 'number' ? cost.total_cost_usd : null,
+        source: 'statusLine',
+    };
+    const account = typeof fiveHour.used_percentage === 'number' ||
+        typeof sevenDay.used_percentage === 'number' ||
+        typeof fiveHour.resets_at === 'string' ||
+        typeof sevenDay.resets_at === 'string'
+        ? {
+            fiveHourUsedPercent: asNumber(fiveHour.used_percentage, -1),
+            fiveHourResetsAt: asString(fiveHour.resets_at),
+            sevenDayUsedPercent: asNumber(sevenDay.used_percentage, -1),
+            sevenDayResetsAt: asString(sevenDay.resets_at),
+        }
+        : null;
+    return { session, account };
+}
+function restorePendingTelemetry(configDir) {
+    const pendingPath = pendingFilePath(configDir);
+    if (!fs.existsSync(pendingPath))
+        return;
+    try {
+        const pending = JSON.parse(fs.readFileSync(pendingPath, 'utf-8'));
+        const ageMs = Date.now() - new Date(pending.timestamp).getTime();
+        if (!Number.isFinite(ageMs) || ageMs > STALE_THRESHOLD_MS) {
+            fs.unlinkSync(pendingPath);
+            return;
+        }
+        sessionTelemetry = new Map(Object.entries(pending.sessions ?? {}));
+        accountTelemetry = pending.account ?? null;
+        restoredPendingOnly =
+            sessionTelemetry.size > 0 || accountTelemetry !== null;
+        fs.unlinkSync(pendingPath);
+    }
+    catch {
+        try {
+            fs.unlinkSync(pendingPath);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+function persistPendingTelemetry(configDir) {
+    const payload = {
+        version: 1,
+        timestamp: new Date().toISOString(),
+        sessions: telemetryToObject(),
+        account: accountTelemetry,
+    };
+    const filePath = pendingFilePath(configDir);
+    try {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, JSON.stringify(payload, null, 2), 'utf-8');
+    }
+    catch (err) {
+        logger.warn('Failed to persist pending telemetry:', err);
+    }
+}
+function collectTelemetry() {
+    if (!activeDeps)
+        return;
+    const activeSessions = activeDeps.getActiveSessions();
+    const activeSessionIds = new Set(activeSessions.map((session) => session.id));
+    if (activeSessionIds.size > 0) {
+        restoredPendingOnly = false;
+        for (const sessionId of [...sessionTelemetry.keys()]) {
+            if (!activeSessionIds.has(sessionId)) {
+                sessionTelemetry.delete(sessionId);
+            }
+        }
+    }
+    else if (!restoredPendingOnly) {
+        sessionTelemetry = new Map();
+    }
+    for (const session of activeSessions) {
+        const filePath = path.join(telemetryDir(activeDeps.configDir), `${session.id}.json`);
+        let raw;
+        try {
+            raw = fs.readFileSync(filePath, 'utf-8');
+        }
+        catch (err) {
+            const error = err;
+            if (error.code !== 'ENOENT') {
+                logger.warn(`[telemetry] Failed to read telemetry for session ${session.id}:`, err);
+            }
+            continue;
+        }
+        let payload;
+        try {
+            payload = JSON.parse(raw);
+        }
+        catch (err) {
+            logger.warn(`[telemetry] Malformed telemetry JSON for session ${session.id}:`, err);
+            continue;
+        }
+        const extracted = extractTelemetry(session.id, payload);
+        if (!extracted)
+            continue;
+        if (!sameTelemetry(sessionTelemetry.get(session.id), extracted.session)) {
+            const nextSessionTelemetry = {
+                ...extracted.session,
+                updatedAt: new Date().toISOString(),
+            };
+            sessionTelemetry.set(session.id, nextSessionTelemetry);
+            activeDeps.broadcastEvent('session-telemetry', {
+                sessionId: session.id,
+                data: nextSessionTelemetry,
+            });
+        }
+        if (extracted.account &&
+            !sameAccountTelemetry(accountTelemetry, extracted.account)) {
+            accountTelemetry = {
+                ...extracted.account,
+                updatedAt: new Date().toISOString(),
+            };
+            activeDeps.broadcastEvent('account-telemetry', {
+                data: accountTelemetry,
+            });
+        }
+    }
+}
+export function startTelemetry(deps) {
+    stopTelemetry();
+    activeDeps = deps;
+    restorePendingTelemetry(deps.configDir);
+    collectTelemetry();
+    pollTimer = setInterval(collectTelemetry, POLL_INTERVAL_MS);
+    persistTimer = setInterval(() => persistPendingTelemetry(deps.configDir), PERSIST_INTERVAL_MS);
+}
+export function stopTelemetry() {
+    if (pollTimer) {
+        clearInterval(pollTimer);
+        pollTimer = null;
+    }
+    if (persistTimer) {
+        clearInterval(persistTimer);
+        persistTimer = null;
+    }
+    if (activeDeps) {
+        persistPendingTelemetry(activeDeps.configDir);
+    }
+    activeDeps = null;
+    sessionTelemetry = new Map();
+    accountTelemetry = null;
+    restoredPendingOnly = false;
+}
+export function getTelemetryForSession(sessionId) {
+    return sessionTelemetry.get(sessionId);
+}
+export function getAccountTelemetry() {
+    return accountTelemetry;
+}
+export function createTelemetryRouter() {
+    const router = Router();
+    router.get('/sessions', (_req, res) => {
+        res.json(telemetryToObject());
+    });
+    router.get('/account', (_req, res) => {
+        res.json(accountTelemetry);
+    });
+    router.get('/setup-status', (_req, res) => {
+        res.json({ installed: activeDeps !== null });
+    });
+    return router;
+}

package/dist/server/ticket-transitions.js

@@ -0,0 +1,166 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { Router } from 'express';
+import { loadConfig } from './config.js';
+import { createLogger } from './logger.js';
+const execFileAsync = promisify(execFile);
+const logger = createLogger('ticket-transitions');
+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,
+        });
+        return true;
+    }
+    catch (err) {
+        logger.error(`[ticket-transitions] Failed to add label "${label}" to #${issueNumber}:`, err);
+        return false;
+    }
+}
+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 name via acli. Returns true on success, false on failure. */
+async function jiraTransition(exec, ticketId, transitionName) {
+    try {
+        await exec('acli', [
+            'jira',
+            'workitem',
+            'transition',
+            '--key',
+            ticketId,
+            '--status',
+            transitionName,
+            '--yes',
+        ], { timeout: 10_000 });
+        return true;
+    }
+    catch (err) {
+        logger.error(`[ticket-transitions] Jira transition failed for ${ticketId}:`, err);
+        return false;
+    }
+}
+/**
+ * Best-effort source detection from a ticket ID pattern.
+ */
+function detectTicketSource(ticketId, links) {
+    // Use explicit source from branch link if available
+    if (links) {
+        const linkWithSource = links.find((l) => l.source);
+        if (linkWithSource?.source)
+            return linkWithSource.source;
+    }
+    if (ticketId.startsWith('GH-'))
+        return 'github';
+    // Prefer Jira for PROJECT-style keys (>= 3 uppercase letters before dash).
+    const prefix = ticketId.split('-')[0] ?? '';
+    if (prefix.length >= 3)
+        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 Jira status mapping for a transition state from config */
+    function getJiraStatusMapping(config, state) {
+        return config.integrations?.jira?.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;
+            const ok = await addLabel(exec, ctx.repoPath, issueNum, 'in-progress');
+            if (ok)
+                transitionMap.set(ctx.ticketId, 'in-progress');
+        }
+        else if (ctx.source === 'jira') {
+            const config = loadConfig(configPath);
+            const transitionName = getJiraStatusMapping(config, 'in-progress');
+            if (transitionName) {
+                const ok = await jiraTransition(exec, ctx.ticketId, transitionName);
+                if (ok)
+                    transitionMap.set(ctx.ticketId, 'in-progress');
+            }
+        }
+    }
+    async function checkPrTransitions(prs, branchLinks) {
+        const config = loadConfig(configPath);
+        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, links);
+                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;
+                        await removeLabel(exec, repoPath, issueNum, 'in-progress');
+                        const ok = await addLabel(exec, repoPath, issueNum, 'code-review');
+                        if (ok)
+                            transitionMap.set(ticketId, 'code-review');
+                    }
+                    else if (source === 'jira') {
+                        const transitionName = getJiraStatusMapping(config, 'code-review');
+                        if (transitionName) {
+                            const ok = await jiraTransition(exec, ticketId, transitionName);
+                            if (ok)
+                                transitionMap.set(ticketId, 'code-review');
+                        }
+                    }
+                }
+                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;
+                        await removeLabel(exec, repoPath, issueNum, 'code-review');
+                        const ok = await addLabel(exec, repoPath, issueNum, 'ready-for-qa');
+                        if (ok)
+                            transitionMap.set(ticketId, 'ready-for-qa');
+                    }
+                    else if (source === 'jira') {
+                        const transitionName = getJiraStatusMapping(config, 'ready-for-qa');
+                        if (transitionName) {
+                            const ok = await jiraTransition(exec, ticketId, transitionName);
+                            if (ok)
+                                transitionMap.set(ticketId, 'ready-for-qa');
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return { router, transitionOnSessionCreate, checkPrTransitions };
+}

package/dist/server/types.js

@@ -0,0 +1,146 @@
+export const BUILTIN_FRAMEWORKS = {
+    claude: {
+        id: 'claude',
+        displayName: 'Claude Code',
+        command: 'claude',
+        continueArgs: ['--continue'],
+        yoloArgs: ['--dangerously-skip-permissions'],
+        parserType: 'claude',
+        eventSource: 'hooks',
+        capabilities: {
+            supportsHooks: true,
+            supportsContinue: true,
+            supportsYolo: true,
+            supportsTelemetry: true,
+        },
+    },
+    codex: {
+        id: 'codex',
+        displayName: 'Codex',
+        command: 'codex',
+        continueArgs: ['resume', '--last'],
+        yoloArgs: ['--ask-for-approval', 'never', '--sandbox', 'workspace-write'],
+        parserType: 'codex',
+        eventSource: 'hooks',
+        capabilities: {
+            supportsHooks: true,
+            supportsContinue: true,
+            supportsYolo: true,
+            supportsTelemetry: false,
+        },
+    },
+    opencode: {
+        id: 'opencode',
+        displayName: 'OpenCode',
+        command: 'opencode',
+        continueArgs: ['--continue'],
+        yoloArgs: [],
+        yoloEnv: {
+            OPENCODE_CONFIG_CONTENT: JSON.stringify({
+                permission: {
+                    read: 'allow',
+                    edit: 'allow',
+                    bash: 'allow',
+                    glob: 'allow',
+                    grep: 'allow',
+                    list: 'allow',
+                    task: 'allow',
+                    webfetch: 'allow',
+                    websearch: 'allow',
+                    codesearch: 'allow',
+                    lsp: 'allow',
+                    skill: 'allow',
+                },
+            }),
+        },
+        parserType: 'opencode',
+        eventSource: 'plugin',
+        capabilities: {
+            supportsHooks: false,
+            supportsContinue: true,
+            supportsYolo: true,
+            supportsTelemetry: true,
+        },
+    },
+};
+export function resolveFramework(config, frameworkId) {
+    const builtin = BUILTIN_FRAMEWORKS[frameworkId];
+    const override = config.frameworks?.[frameworkId];
+    if (!builtin && !override) {
+        throw new Error(`Unknown framework: "${frameworkId}". Register it in config.frameworks.`);
+    }
+    if (!builtin) {
+        // fully custom framework from config — validate all required fields before returning
+        const custom = override;
+        const validEventSources = [
+            'hooks',
+            'plugin',
+            'parser',
+            'timer',
+        ];
+        if (!custom.id ||
+            !custom.displayName ||
+            !custom.command ||
+            !Array.isArray(custom.continueArgs) ||
+            !Array.isArray(custom.yoloArgs) ||
+            !custom.parserType ||
+            !custom.eventSource ||
+            !validEventSources.includes(custom.eventSource) ||
+            !custom.capabilities ||
+            typeof custom.capabilities.supportsHooks !== 'boolean' ||
+            typeof custom.capabilities.supportsContinue !== 'boolean' ||
+            typeof custom.capabilities.supportsYolo !== 'boolean' ||
+            typeof custom.capabilities.supportsTelemetry !== 'boolean') {
+            throw new Error(`Custom framework "${frameworkId}" must define id, displayName, command, continueArgs, yoloArgs, parserType, eventSource, and complete capabilities.`);
+        }
+        return { ...custom };
+    }
+    if (!override) {
+        return builtin;
+    }
+    // shallow merge at top level, deep merge for capabilities
+    const { capabilities: overrideCaps, ...overrideRest } = override;
+    return {
+        ...builtin,
+        ...overrideRest,
+        capabilities: overrideCaps
+            ? { ...builtin.capabilities, ...overrideCaps }
+            : builtin.capabilities,
+    };
+}
+// Deprecated aliases derived from BUILTIN_FRAMEWORKS for backward compatibility
+export const AGENT_COMMANDS = Object.fromEntries(Object.values(BUILTIN_FRAMEWORKS).map((f) => [f.id, f.command]));
+export const AGENT_CONTINUE_ARGS = Object.fromEntries(Object.values(BUILTIN_FRAMEWORKS).map((f) => [f.id, f.continueArgs]));
+export const AGENT_YOLO_ARGS = Object.fromEntries(Object.values(BUILTIN_FRAMEWORKS).map((f) => [f.id, f.yoloArgs]));
+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/server/utils.js

@@ -0,0 +1,23 @@
+// 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;
+    env.CLAUDE_CODE_NO_FLICKER = '1';
+    return env;
+}