relay-ide 0.1.0

package/dist/server/branch-linker.js

@@ -0,0 +1,137 @@
+import path from 'node:path';
+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 GIT_TIMEOUT_MS = 10_000;
+const CACHE_TTL_MS = 60_000;
+let cache = null;
+/** Clears the branch linker cache (call when sessions are created or ended). */
+export function invalidateBranchLinkerCache() {
+    cache = null;
+}
+/**
+ * Extracts all ticket IDs from a branch name.
+ * Returns an array of normalized ticket IDs (e.g. "PROJ-123", "GH-456").
+ */
+function extractTicketIds(branchName) {
+    const ids = [];
+    // Jira style: PROJECT-123 (2+ uppercase letters, dash, digits)
+    // Skip "GH" prefix — that's our GitHub Issues namespace, handled separately below.
+    const jiraRegex = /([A-Z]{2,}-\d+)/gi;
+    let match;
+    while ((match = jiraRegex.exec(branchName)) !== null) {
+        if (match[1] && match[1].toUpperCase().split('-')[0] !== 'GH') {
+            ids.push(match[1].toUpperCase());
+        }
+    }
+    // GitHub Issues: gh-123 at word boundaries (start/end or preceded/followed by dash or slash)
+    const ghRegex = /(?:^|[-/])gh-(\d+)(?:[-/]|$)/gi;
+    while ((match = ghRegex.exec(branchName)) !== null) {
+        ids.push(`GH-${match[1]}`);
+    }
+    return ids;
+}
+/**
+ * Creates and returns an Express Router that handles all /branch-linker routes.
+ *
+ * Caller is responsible for mounting and applying auth middleware:
+ *   app.use('/branch-linker', requireAuth, createBranchLinkerRouter({ configPath }));
+ */
+export function createBranchLinkerRouter(deps) {
+    const { configPath } = deps;
+    const exec = deps.execAsync ?? execFileAsync;
+    const getActiveBranchNames = deps.getActiveBranchNames ?? (() => new Map());
+    const router = Router();
+    function getConfig() {
+        return loadConfig(configPath);
+    }
+    /** Core link-building logic, usable both from the HTTP handler and internal callers. */
+    async function fetchLinks() {
+        const config = getConfig();
+        const workspacePaths = config.repos ?? [];
+        if (workspacePaths.length === 0) {
+            return {};
+        }
+        const now = Date.now();
+        // Return cached result if still fresh
+        if (cache && now - cache.fetchedAt < CACHE_TTL_MS) {
+            return cache.links;
+        }
+        // Get active branch names per repo from sessions
+        const activeBranchNames = getActiveBranchNames();
+        // Fetch branches per workspace using Promise.allSettled (partial failures are non-fatal)
+        const results = await Promise.allSettled(workspacePaths.map(async (wsPath) => {
+            let stdout;
+            try {
+                ({ stdout } = await exec('git', ['branch', '--format=%(refname:short)'], { cwd: wsPath, timeout: GIT_TIMEOUT_MS }));
+            }
+            catch {
+                // Not a git repo or git not available — non-fatal
+                return [];
+            }
+            const repoName = path.basename(wsPath);
+            const activeInRepo = activeBranchNames.get(wsPath) ?? new Set();
+            const branchNames = stdout
+                .split('\n')
+                .map((b) => b.trim())
+                .filter(Boolean);
+            const links = [];
+            for (const branchName of branchNames) {
+                const ticketIds = extractTicketIds(branchName);
+                for (const ticketId of ticketIds) {
+                    // Infer ticket source from ID pattern
+                    let source;
+                    if (ticketId.startsWith('GH-')) {
+                        source = 'github';
+                    }
+                    else {
+                        // Non-GH ticket IDs (e.g., PROJ-123) assumed to be Jira
+                        source = 'jira';
+                    }
+                    links.push({
+                        ticketId,
+                        link: {
+                            repoPath: wsPath,
+                            repoName,
+                            branchName,
+                            hasActiveSession: activeInRepo.has(branchName),
+                            source,
+                        },
+                    });
+                }
+            }
+            return links;
+        }));
+        // Build the ticket -> BranchLink[] map
+        const linksMap = new Map();
+        for (const result of results) {
+            if (result.status === 'fulfilled') {
+                for (const { ticketId, link } of result.value) {
+                    const existing = linksMap.get(ticketId);
+                    if (existing) {
+                        existing.push(link);
+                    }
+                    else {
+                        linksMap.set(ticketId, [link]);
+                    }
+                }
+            }
+        }
+        // Convert Map to plain object for JSON serialization
+        const response = {};
+        for (const [ticketId, links] of linksMap) {
+            response[ticketId] = links;
+        }
+        // Update module-level cache
+        cache = { links: response, fetchedAt: now };
+        return response;
+    }
+    // GET /branch-linker/links — map of ticketId -> BranchLink[]
+    router.get('/links', async (_req, res) => {
+        const response = await fetchLinks();
+        res.json(response);
+    });
+    return Object.assign(router, { fetchLinks });
+}

package/dist/server/browser-content.js

@@ -0,0 +1,145 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import crypto from 'node:crypto';
+import { Router } from 'express';
+const tokenStore = new Map();
+const pathToToken = new Map();
+// ── Scoped auth token ──
+let scopedToken = '';
+export function generateScopedToken() {
+    scopedToken = crypto.randomBytes(32).toString('hex');
+    return scopedToken;
+}
+export function validateScopedToken(token) {
+    return token.length > 0 && token === scopedToken;
+}
+// ── Content tokens ──
+export function createBrowserToken(filePath) {
+    const existing = pathToToken.get(filePath);
+    if (existing && tokenStore.has(existing))
+        return existing;
+    const token = crypto.randomBytes(16).toString('hex');
+    const baseDir = path.dirname(filePath);
+    tokenStore.set(token, { baseDir, filePath, createdAt: Date.now() });
+    pathToToken.set(filePath, token);
+    return token;
+}
+export function validateToken(token) {
+    const entry = tokenStore.get(token);
+    return entry ? { baseDir: entry.baseDir, filePath: entry.filePath } : null;
+}
+export function resolveTokenPath(token, relativePath) {
+    const entry = tokenStore.get(token);
+    if (!entry)
+        return null;
+    if (path.isAbsolute(relativePath))
+        return null;
+    const resolved = path.resolve(entry.baseDir, relativePath);
+    if (!resolved.startsWith(entry.baseDir + path.sep) &&
+        resolved !== entry.baseDir)
+        return null;
+    try {
+        const realBaseDir = fs.realpathSync(entry.baseDir);
+        const realResolved = fs.realpathSync(resolved);
+        if (realResolved !== realBaseDir &&
+            !realResolved.startsWith(realBaseDir + path.sep))
+            return null;
+    }
+    catch {
+        return null;
+    }
+    return resolved;
+}
+export function getTokenForPath(filePath) {
+    return pathToToken.get(filePath) ?? null;
+}
+export function cleanExpiredTokens(ttlMs) {
+    const now = Date.now();
+    for (const [token, entry] of tokenStore) {
+        if (now - entry.createdAt >= ttlMs) {
+            tokenStore.delete(token);
+            pathToToken.delete(entry.filePath);
+        }
+    }
+}
+export function _resetForTesting() {
+    tokenStore.clear();
+    pathToToken.clear();
+    scopedToken = '';
+}
+// ── Express router ──
+export function createBrowserContentRouter(broadcastEvent) {
+    const router = Router();
+    router.post('/browser-tabs', (req, res) => {
+        const authHeader = req.headers.authorization;
+        const bearerToken = authHeader?.startsWith('Bearer ')
+            ? authHeader.slice(7)
+            : '';
+        if (!validateScopedToken(bearerToken)) {
+            res.status(401).json({ error: 'Invalid browser token' });
+            return;
+        }
+        const { path: filePath } = req.body;
+        if (!filePath || typeof filePath !== 'string') {
+            res.status(400).json({ error: 'path is required' });
+            return;
+        }
+        const resolved = path.resolve(filePath);
+        try {
+            const stat = fs.statSync(resolved);
+            if (!stat.isFile()) {
+                res
+                    .status(400)
+                    .json({ error: 'path must be a file, not a directory' });
+                return;
+            }
+        }
+        catch {
+            res.status(404).json({ error: 'file not found' });
+            return;
+        }
+        const existingToken = getTokenForPath(resolved);
+        if (existingToken) {
+            // Always emit browser-tab-opened (not just refreshed) so reconnecting clients,
+            // second devices, or users who closed the tab get it re-opened with the token.
+            // openHtmlTab on the frontend is idempotent — it focuses existing tabs.
+            broadcastEvent('browser-tab-opened', {
+                filePath: resolved,
+                token: existingToken,
+            });
+            broadcastEvent('browser-tab-refreshed', { filePath: resolved });
+            res.json({ token: existingToken, refreshed: true });
+            return;
+        }
+        const token = createBrowserToken(resolved);
+        broadcastEvent('browser-tab-opened', { filePath: resolved, token });
+        res.json({ token, refreshed: false });
+    });
+    router.get('/browser-content/:token/*', (req, res) => {
+        const { token } = req.params;
+        const relativePath = req.params[0] ?? '';
+        if (!relativePath) {
+            res.status(400).send('Missing file path');
+            return;
+        }
+        const resolved = resolveTokenPath(token, relativePath);
+        if (!resolved) {
+            res.status(403).send('Forbidden');
+            return;
+        }
+        let stat;
+        try {
+            stat = fs.statSync(resolved);
+        }
+        catch {
+            res.status(404).send('Not found');
+            return;
+        }
+        if (!stat.isFile()) {
+            res.status(400).send('Not a file');
+            return;
+        }
+        res.sendFile(resolved);
+    });
+    return router;
+}

package/dist/server/clipboard.js

@@ -0,0 +1,63 @@
+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/server/codex-hooks-adapter.js

@@ -0,0 +1,93 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { createLogger } from './logger.js';
+const logger = createLogger('codex-hooks-adapter');
+// Codex hook event names that we relay
+const CODEX_EVENTS = [
+    'SessionStart',
+    'Stop',
+    'UserPromptSubmit',
+    'PreToolUse',
+    'PostToolUse',
+];
+// Map codex events to our canonical event types
+const EVENT_MAP = {
+    SessionStart: 'session.started',
+    Stop: 'session.ended',
+    UserPromptSubmit: 'prompt.submitted',
+    PreToolUse: 'tool.started',
+    PostToolUse: 'tool.finished',
+};
+/**
+ * Write codex hooks adapter to a temp directory.
+ * Returns the directory path (set as CODEX_CONFIG_DIR).
+ */
+export function writeCodexHooksAdapter(sessionId, port, hookToken, _configDir) {
+    const tmpDir = path.join(os.tmpdir(), 'relay-ide', `codex-hooks-${sessionId}`);
+    fs.mkdirSync(tmpDir, { recursive: true });
+    // Write session config for the relay script to read
+    const configPath = path.join(tmpDir, 'session.json');
+    fs.writeFileSync(configPath, JSON.stringify({ sessionId, port, hookToken }), 'utf-8');
+    logger.debug('Wrote Codex session config', configPath);
+    // Write relay script — reads config from file to avoid shell injection
+    // Parse session.json once (single node invocation) to extract all values at once for performance.
+    const relayScript = `#!/usr/bin/env bash
+set -u
+INPUT=$(cat)
+EVENT="\${HOOK_EVENT_NAME:-unknown}"
+CANONICAL_EVENT=""
+case "$EVENT" in
+  SessionStart) CANONICAL_EVENT="session.started" ;;
+  Stop) CANONICAL_EVENT="session.ended" ;;
+  UserPromptSubmit) CANONICAL_EVENT="prompt.submitted" ;;
+  PreToolUse) CANONICAL_EVENT="tool.started" ;;
+  PostToolUse) CANONICAL_EVENT="tool.finished" ;;
+  *) CANONICAL_EVENT="$EVENT" ;;
+esac
+CONFIG_FILE="${configPath}"
+  read -r SESSION_ID PORT TOKEN < <(node -e "const fs=require('node:fs');const{sessionId,port,hookToken}=JSON.parse(fs.readFileSync(process.argv[1],'utf8'));process.stdout.write([sessionId,port,hookToken].join(' ')+'\\n');" "$CONFIG_FILE")
+TIMESTAMP=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+PAYLOAD=$(printf '{"sessionId":"%s","token":"%s","eventType":"%s","data":%s,"timestamp":"%s"}' "$SESSION_ID" "$TOKEN" "$CANONICAL_EVENT" "$INPUT" "$TIMESTAMP")
+curl -s -X POST "http://127.0.0.1:$PORT/hooks/agent-event" \\
+  -H "Content-Type: application/json" \\
+  -d "$PAYLOAD" \\
+  > /dev/null 2>&1 || true
+`;
+    const relayPath = path.join(tmpDir, 'relay.sh');
+    fs.writeFileSync(relayPath, relayScript, { mode: 0o755 });
+    // Read existing user hooks if present
+    let existingHooks = {};
+    const userHooksPath = path.join(os.homedir(), '.codex', 'hooks.json');
+    try {
+        existingHooks = JSON.parse(fs.readFileSync(userHooksPath, 'utf-8'));
+    }
+    catch {
+        /* no existing hooks */
+    }
+    // Build merged hooks: append our relay to each event
+    const relayHook = { type: 'command', command: relayPath };
+    const mergedHooks = { ...existingHooks };
+    for (const event of CODEX_EVENTS) {
+        const existing = mergedHooks[event] ?? [];
+        mergedHooks[event] = [...existing, relayHook];
+    }
+    fs.writeFileSync(path.join(tmpDir, 'hooks.json'), JSON.stringify(mergedHooks, null, 2));
+    return tmpDir;
+}
+/**
+ * Remove the codex hooks adapter temp directory for a session.
+ * Called when the session ends to avoid leaking temp files.
+ */
+export function cleanupCodexHooksAdapter(sessionId) {
+    const tmpDir = path.join(os.tmpdir(), 'relay-ide', `codex-hooks-${sessionId}`);
+    try {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+        logger.debug('Cleaned up Codex hooks adapter', tmpDir);
+    }
+    catch {
+        // Non-fatal — temp dir may not exist or already be cleaned up
+    }
+}
+/** Exported for testing */
+export { CODEX_EVENTS, EVENT_MAP };