relay-ide 0.1.0

package/dist/server/opencode-relay.js

@@ -0,0 +1,53 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+/** Source code for the opencode relay plugin — written to opencode's plugin directory */
+const RELAY_PLUGIN_SOURCE = `
+// OpenCode plugin that relays lifecycle events to relay-ide server.
+// Reads CRC_RELAY_URL, CRC_SESSION_ID, CRC_RELAY_TOKEN from env (injected per session by PTY handler).
+export default async () => {
+  const relayUrl = process.env.CRC_RELAY_URL;
+  const sessionId = process.env.CRC_SESSION_ID;
+  const token = process.env.CRC_RELAY_TOKEN;
+
+  if (!relayUrl || !sessionId || !token) return {};
+
+  const relay = async (eventType, data = {}) => {
+    try {
+      await fetch(\`\${relayUrl}/hooks/agent-event\`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ sessionId, token, eventType, data, timestamp: new Date().toISOString() }),
+      });
+    } catch { /* best-effort, don't crash opencode */ }
+  };
+
+  return {
+    'session.created': async () => relay('session.started'),
+    'session.idle': async () => relay('session.idle'),
+    'session.status': async (input) => relay('state.changed', { status: input }),
+    'session.error': async (input) => relay('state.changed', { status: 'error', error: input }),
+    'permission.asked': async (input) => relay('permission.requested', { permission: input }),
+    'permission.replied': async (input) => relay('permission.resolved', { reply: input }),
+    'tool.execute.before': async (input) => relay('tool.started', { tool: input }),
+    'tool.execute.after': async (input, output) => relay('tool.finished', { tool: input, result: output }),
+    'message.updated': async (input) => relay('telemetry.updated', { message: input }),
+  };
+};
+`.trim();
+/**
+ * Write the relay plugin to opencode's global plugin directory.
+ * Idempotent — overwrites the same file each time.
+ *
+ * @param pluginDir - Override the plugin directory (defaults to ~/.config/opencode/plugins). Used in tests.
+ * @returns The path to the written plugin file.
+ */
+export function installOpencodeRelayPlugin(pluginDir) {
+    const dir = pluginDir ?? path.join(os.homedir(), '.config', 'opencode', 'plugins');
+    fs.mkdirSync(dir, { recursive: true });
+    const pluginPath = path.join(dir, 'crc-relay.ts');
+    fs.writeFileSync(pluginPath, RELAY_PLUGIN_SOURCE, 'utf-8');
+    return pluginPath;
+}
+/** Exported for testing */
+export { RELAY_PLUGIN_SOURCE };

package/dist/server/org-dashboard.js

@@ -0,0 +1,241 @@
+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';
+import { buildRepoMap } from './git.js';
+import { createLogger } from './logger.js';
+const execFileAsync = promisify(execFile);
+const logger = createLogger('org-dashboard');
+const GH_TIMEOUT_MS = 10_000;
+const CACHE_TTL_MS = 60_000;
+/**
+ * Extracts "owner/repo" from a GitHub API repository_url.
+ * e.g. "https://api.github.com/repos/owner/repo" → "owner/repo"
+ */
+function repoFromApiUrl(repositoryUrl) {
+    const match = repositoryUrl.match(/\/repos\/([^/]+\/[^/]+)$/);
+    return match ? (match[1] ?? null) : null;
+}
+// Router factory
+/**
+ * Creates and returns an Express Router that handles all /org-dashboard routes.
+ *
+ * Caller is responsible for mounting and applying auth middleware:
+ *   app.use('/org-dashboard', requireAuth, createOrgDashboardRouter({ configPath }));
+ */
+export function createOrgDashboardRouter(deps) {
+    const { configPath } = deps;
+    const exec = deps.execAsync ?? execFileAsync;
+    const router = Router();
+    // Server-lifetime cache for GitHub user login
+    let cachedUser = null;
+    // 60s in-memory cache for search results
+    let cache = null;
+    function getConfig() {
+        return loadConfig(configPath);
+    }
+    // GET /org-dashboard/prs — list all open PRs involving the current user across all workspaces
+    router.get('/prs', async (_req, res) => {
+        const config = getConfig();
+        const workspacePaths = config.repos ?? [];
+        if (workspacePaths.length === 0) {
+            const response = {
+                prs: [],
+                error: 'no_workspaces',
+            };
+            res.json(response);
+            return;
+        }
+        // Return cached results if still fresh
+        const now = Date.now();
+        if (cache && now - cache.fetchedAt < CACHE_TTL_MS) {
+            const response = { prs: cache.prs };
+            res.json(response);
+            return;
+        }
+        // Resolve GitHub user (cached for server lifetime)
+        if (!cachedUser) {
+            try {
+                const { stdout } = await exec('gh', ['api', 'user', '--jq', '.login'], {
+                    timeout: GH_TIMEOUT_MS,
+                });
+                cachedUser = stdout.trim();
+            }
+            catch (err) {
+                const errCode = err.code;
+                if (errCode === 'ENOENT') {
+                    const response = {
+                        prs: [],
+                        error: 'gh_not_in_path',
+                    };
+                    res.json(response);
+                    return;
+                }
+                const response = {
+                    prs: [],
+                    error: 'gh_not_authenticated',
+                };
+                res.json(response);
+                return;
+            }
+        }
+        const currentUser = cachedUser;
+        // Build repo → workspace path map
+        const repoMap = await buildRepoMap(workspacePaths, exec);
+        // Check for GraphQL path (GitHub App token)
+        const githubToken = config.github?.accessToken;
+        if (githubToken && deps.fetchGraphQL) {
+            try {
+                const result = await deps.fetchGraphQL(githubToken, repoMap);
+                cachedUser = result.username;
+                const prs = result.prs;
+                prs.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+                cache = { prs, fetchedAt: now };
+                // Fire ticket transitions (same best-effort as below)
+                if (deps.checkPrTransitions && deps.getBranchLinks) {
+                    deps
+                        .getBranchLinks()
+                        .then((links) => deps.checkPrTransitions(prs, links))
+                        .catch(() => { });
+                }
+                const response = { prs };
+                res.json(response);
+                return;
+            }
+            catch (err) {
+                logger.warn('[org-dashboard] GraphQL fetch failed, falling back to gh CLI:', err instanceof Error ? err.message : String(err));
+            }
+        }
+        // Single gh search API call
+        let searchResponse;
+        try {
+            const { stdout } = await exec('gh', ['api', 'search/issues?q=is:pr+is:open+involves:@me&per_page=100'], { timeout: GH_TIMEOUT_MS });
+            searchResponse = JSON.parse(stdout);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            const errCode = err.code;
+            if (msg.includes('ETIMEDOUT') || msg.includes('timed out')) {
+                const response = { prs: [], error: 'gh_timeout' };
+                res.json(response);
+                return;
+            }
+            if (errCode === 'ENOENT') {
+                const response = {
+                    prs: [],
+                    error: 'gh_not_in_path',
+                };
+                res.json(response);
+                return;
+            }
+            const response = {
+                prs: [],
+                error: 'gh_not_authenticated',
+            };
+            res.json(response);
+            return;
+        }
+        const items = searchResponse.items ?? [];
+        // Filter to only repos matching workspace paths and map to PullRequest
+        const prs = [];
+        for (const item of items) {
+            // The search API can return non-PR issues — skip them
+            if (!item.pull_request)
+                continue;
+            const ownerRepo = repoFromApiUrl(item.repository_url);
+            if (!ownerRepo)
+                continue;
+            const wsPath = repoMap.get(ownerRepo.toLowerCase());
+            if (!wsPath)
+                continue;
+            // Determine role
+            const isAuthor = item.user.login === currentUser;
+            const isReviewer = !isAuthor &&
+                Array.isArray(item.requested_reviewers) &&
+                item.requested_reviewers.some((r) => r.login === currentUser);
+            if (!isAuthor && !isReviewer)
+                continue;
+            const role = isAuthor ? 'author' : 'reviewer';
+            const repoName = path.basename(wsPath);
+            prs.push({
+                number: item.number,
+                title: item.title,
+                url: item.html_url,
+                headRefName: item.pull_request?.head?.ref ?? '',
+                baseRefName: item.pull_request?.base?.ref ?? '',
+                state: 'OPEN',
+                author: item.user.login,
+                role,
+                updatedAt: item.updated_at,
+                additions: 0,
+                deletions: 0,
+                reviewDecision: null,
+                mergeable: null,
+                isDraft: false,
+                ciStatus: null,
+                repoName,
+                repoPath: wsPath,
+            });
+        }
+        // Sort by updatedAt descending
+        prs.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+        // Update cache
+        cache = { prs, fetchedAt: now };
+        // Fire ticket transitions check (best-effort, don't block response)
+        // Include recently merged PRs for MERGED->ready-for-qa transitions
+        if (deps.checkPrTransitions && deps.getBranchLinks) {
+            const transitionPrs = [...prs];
+            // Fetch recently merged PRs (last 7 days) for transition checks
+            try {
+                const mergedSince = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000)
+                    .toISOString()
+                    .split('T')[0];
+                const { stdout: mergedStdout } = await exec('gh', [
+                    'api',
+                    `search/issues?q=is:pr+is:merged+merged:>=${mergedSince}+involves:@me&per_page=50`,
+                ], { timeout: GH_TIMEOUT_MS });
+                const mergedResponse = JSON.parse(mergedStdout);
+                for (const item of mergedResponse.items ?? []) {
+                    if (!item.pull_request)
+                        continue;
+                    const ownerRepo = repoFromApiUrl(item.repository_url);
+                    if (!ownerRepo)
+                        continue;
+                    const wsPath = repoMap.get(ownerRepo.toLowerCase());
+                    if (!wsPath)
+                        continue;
+                    transitionPrs.push({
+                        number: item.number,
+                        title: item.title,
+                        url: item.html_url,
+                        headRefName: item.pull_request?.head?.ref ?? '',
+                        baseRefName: item.pull_request?.base?.ref ?? '',
+                        state: 'MERGED',
+                        author: item.user.login,
+                        role: 'author',
+                        updatedAt: item.updated_at,
+                        additions: 0,
+                        deletions: 0,
+                        reviewDecision: null,
+                        mergeable: null,
+                        isDraft: false,
+                        ciStatus: null,
+                        repoName: path.basename(wsPath),
+                        repoPath: wsPath,
+                    });
+                }
+            }
+            catch {
+                // Merged PR fetch is best-effort — don't block transitions
+            }
+            deps
+                .getBranchLinks()
+                .then((links) => deps.checkPrTransitions(transitionPrs, links))
+                .catch(() => { });
+        }
+        const response = { prs };
+        res.json(response);
+    });
+    return router;
+}

package/dist/server/output-parsers/claude-parser.js

@@ -0,0 +1,56 @@
+// Duplicated from utils.ts to preserve output-parsers/ module boundary
+const ANSI_RE = /\x1b\[[0-9;]*[a-zA-Z]|\x1b\][^\x07]*\x07|\x1b[()][AB012]|\x1b\[\?[0-9;]*[hlm]|\x1b\[[0-9]*[ABCDJKH]/g;
+/**
+ * Claude Code output parser.
+ *
+ * Claude Code uses a React/Ink TUI. This parser detects semantic state
+ * transitions by pattern-matching on cleaned terminal output.
+ */
+export class ClaudeOutputParser {
+    currentState = 'initializing';
+    hasSeenFirstPrompt = false;
+    onData(chunk, _recentScrollback) {
+        const clean = chunk.replace(ANSI_RE, '');
+        if (!clean.trim())
+            return null;
+        const newState = this.classify(clean);
+        if (newState && newState !== this.currentState) {
+            this.currentState = newState;
+            return { state: newState };
+        }
+        return null;
+    }
+    reset() {
+        this.currentState = 'initializing';
+        this.hasSeenFirstPrompt = false;
+    }
+    get state() {
+        return this.currentState;
+    }
+    classify(clean) {
+        // Permission prompt detection (highest priority)
+        if (/\bAllow\b/.test(clean) && /\bDeny\b/.test(clean)) {
+            return 'permission-prompt';
+        }
+        // Error detection
+        if (/^Error:|^ERROR:|✗\s|error:/m.test(clean)) {
+            return 'error';
+        }
+        // Waiting for input: the ">" prompt on its own line, or initial greeting
+        if (/^>\s*$/m.test(clean) ||
+            /How can I help/i.test(clean) ||
+            /What would you like/i.test(clean)) {
+            this.hasSeenFirstPrompt = true;
+            return 'waiting-for-input';
+        }
+        // Processing: substantive output after the first prompt
+        if (this.hasSeenFirstPrompt && clean.trim().length > 0) {
+            return 'processing';
+        }
+        // Still initializing if we haven't seen the first prompt
+        if (!this.hasSeenFirstPrompt) {
+            return 'initializing';
+        }
+        return null;
+    }
+}

package/dist/server/output-parsers/codex-parser.js

@@ -0,0 +1,13 @@
+/**
+ * Codex output parser — stub.
+ *
+ * Always returns null, which tells the system to fall back to
+ * timer-based idle detection. Replace with real pattern matching
+ * when Codex TUI patterns are mapped.
+ */
+export class CodexOutputParser {
+    onData(_chunk, _recentScrollback) {
+        return null;
+    }
+    reset() { }
+}

package/dist/server/output-parsers/index.js

@@ -0,0 +1,14 @@
+import { ClaudeOutputParser } from './claude-parser.js';
+import { CodexOutputParser } from './codex-parser.js';
+import { OpencodeOutputParser } from './opencode-parser.js';
+import { NullOutputParser } from './null-parser.js';
+/**
+ * Registry: factory per parser type. Unknown keys return undefined (fall back to timer-based detection).
+ * Keys match AgentFramework.parserType values. 'none' is for frameworks that opt out of parsing.
+ */
+export const outputParsers = {
+    claude: () => new ClaudeOutputParser(),
+    codex: () => new CodexOutputParser(),
+    opencode: () => new OpencodeOutputParser(),
+    none: () => new NullOutputParser(),
+};

package/dist/server/output-parsers/null-parser.js

@@ -0,0 +1,12 @@
+/**
+ * Null output parser — always returns null.
+ *
+ * Used for agents with no known output patterns. Falls back to
+ * timer-based idle detection in the calling code.
+ */
+export class NullOutputParser {
+    onData(_chunk, _recentScrollback) {
+        return null;
+    }
+    reset() { }
+}

package/dist/server/output-parsers/opencode-parser.js

@@ -0,0 +1,77 @@
+// Duplicated from utils.ts to preserve output-parsers/ module boundary
+const ANSI_RE = /\x1b\[[0-9;]*[a-zA-Z]|\x1b\][^\x07]*\x07|\x1b[()][AB012]|\x1b\[\?[0-9;]*[hlm]|\x1b\[[0-9]*[ABCDJKH]/g;
+/**
+ * OpenCode output parser.
+ *
+ * OpenCode uses a Bubble Tea TUI. This parser detects semantic state
+ * transitions by pattern-matching on cleaned terminal output.
+ *
+ * Key patterns:
+ *   Permission prompt: lines starting with `!` followed by "permission"
+ *   Tool use (processing): `$` bash, `<-` edit, `->` read, `*` glob/grep, `%` webfetch
+ *   Agent header: `> build . provider/model` — indicates initializing/resuming
+ *   Waiting for input: bare `>` prompt or "Ready" / "assistant: done" patterns
+ */
+export class OpencodeOutputParser {
+    currentState = 'initializing';
+    hasSeenFirstPrompt = false;
+    onData(chunk, _recentScrollback) {
+        const clean = chunk.replace(ANSI_RE, '');
+        if (!clean.trim())
+            return null;
+        const newState = this.classify(clean);
+        if (newState && newState !== this.currentState) {
+            this.currentState = newState;
+            return { state: newState };
+        }
+        return null;
+    }
+    reset() {
+        this.currentState = 'initializing';
+        this.hasSeenFirstPrompt = false;
+    }
+    get state() {
+        return this.currentState;
+    }
+    classify(clean) {
+        // Permission prompt: highest priority — line starting with ! followed by "permission"
+        if (/^!\s.*permission/im.test(clean)) {
+            return 'permission-prompt';
+        }
+        // Waiting for input: "Ready" or "assistant: done" patterns
+        if (/\bReady\b/.test(clean) || /assistant:\s*done/i.test(clean)) {
+            this.hasSeenFirstPrompt = true;
+            return 'waiting-for-input';
+        }
+        // Bare `>` prompt on its own line (not followed by provider/model info)
+        if (/^>\s*$/m.test(clean)) {
+            this.hasSeenFirstPrompt = true;
+            return 'waiting-for-input';
+        }
+        // Agent header: `> build . provider/model` — initializing/resuming
+        // Matches `>` followed by typical opencode startup text (not bare >)
+        if (/^>\s+\S+.*\//m.test(clean)) {
+            this.hasSeenFirstPrompt = true;
+            return 'initializing';
+        }
+        // Tool icons indicating active processing (after first prompt seen)
+        if (this.hasSeenFirstPrompt &&
+            (/^\$\s/m.test(clean) || // bash/shell
+                /^<-\s/m.test(clean) || // file edit
+                /^->\s/m.test(clean) || // file read
+                /^\*\s/m.test(clean) || // glob/grep
+                /^%\s/m.test(clean)) // webfetch
+        ) {
+            return 'processing';
+        }
+        // General processing: substantive output after first prompt
+        if (this.hasSeenFirstPrompt && clean.trim().length > 0) {
+            return 'processing';
+        }
+        // Still initializing before first prompt
+        if (!this.hasSeenFirstPrompt) {
+            return 'initializing';
+        }
+        return null;
+    }
+}