relay-ide 0.1.0

package/dist/server/integration-github.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 GH_TIMEOUT_MS = 10_000;
+const CACHE_TTL_MS = 60_000;
+/**
+ * Creates and returns an Express Router that handles all /integration-github routes.
+ *
+ * Caller is responsible for mounting and applying auth middleware:
+ *   app.use('/integration-github', requireAuth, createIntegrationGitHubRouter({ configPath }));
+ */
+export function createIntegrationGitHubRouter(deps) {
+    const { configPath } = deps;
+    const exec = deps.execAsync ?? execFileAsync;
+    const router = Router();
+    // Per-repo 60s in-memory cache
+    const repoCache = new Map();
+    function getConfig() {
+        return loadConfig(configPath);
+    }
+    // GET /integrations/github/issues — list open issues assigned to @me across all workspaces
+    router.get('/issues', async (_req, res) => {
+        const config = getConfig();
+        const workspacePaths = config.repos ?? [];
+        if (workspacePaths.length === 0) {
+            const response = {
+                issues: [],
+                error: 'no_workspaces',
+            };
+            res.json(response);
+            return;
+        }
+        const now = Date.now();
+        // Fetch issues per repo using Promise.allSettled (partial failures are non-fatal)
+        const results = await Promise.allSettled(workspacePaths.map(async (wsPath) => {
+            // Return cached result if still fresh
+            const cached = repoCache.get(wsPath);
+            if (cached && now - cached.fetchedAt < CACHE_TTL_MS) {
+                return cached.issues;
+            }
+            let stdout;
+            try {
+                ({ stdout } = await exec('gh', [
+                    'issue',
+                    'list',
+                    '--assignee',
+                    '@me',
+                    '--state',
+                    'open',
+                    '--json',
+                    'number,title,url,state,labels,assignees,createdAt,updatedAt',
+                    '--limit',
+                    '50',
+                ], { cwd: wsPath, timeout: GH_TIMEOUT_MS }));
+            }
+            catch (err) {
+                const errCode = err.code;
+                if (errCode === 'ENOENT') {
+                    throw Object.assign(new Error('gh_not_in_path'), {
+                        code: 'GH_NOT_IN_PATH',
+                    });
+                }
+                // Check for auth failure via stderr
+                const stderr = err.stderr ?? '';
+                if (stderr.includes('not logged') ||
+                    stderr.includes('auth') ||
+                    stderr.includes('authentication')) {
+                    throw Object.assign(new Error('gh_not_authenticated'), {
+                        code: 'GH_NOT_AUTHENTICATED',
+                    });
+                }
+                // Not a github repo or other non-fatal error
+                return [];
+            }
+            let items;
+            try {
+                items = JSON.parse(stdout);
+            }
+            catch {
+                return [];
+            }
+            const repoName = path.basename(wsPath);
+            const issues = items.map((item) => ({
+                number: item.number,
+                title: item.title,
+                url: item.url,
+                state: item.state === 'OPEN' ? 'OPEN' : 'CLOSED',
+                labels: item.labels,
+                assignees: item.assignees,
+                createdAt: item.createdAt,
+                updatedAt: item.updatedAt,
+                repoName,
+                repoPath: wsPath,
+            }));
+            // Update per-repo cache
+            repoCache.set(wsPath, { issues, fetchedAt: now });
+            return issues;
+        }));
+        // Check if gh is not in path or not authenticated (any settled rejection with known codes)
+        for (const result of results) {
+            if (result.status === 'rejected') {
+                const err = result.reason;
+                if (err.code === 'GH_NOT_IN_PATH') {
+                    const response = {
+                        issues: [],
+                        error: 'gh_not_in_path',
+                    };
+                    res.json(response);
+                    return;
+                }
+                if (err.code === 'GH_NOT_AUTHENTICATED') {
+                    const response = {
+                        issues: [],
+                        error: 'gh_not_authenticated',
+                    };
+                    res.json(response);
+                    return;
+                }
+            }
+        }
+        // Merge all fulfilled results
+        const allIssues = [];
+        for (const result of results) {
+            if (result.status === 'fulfilled') {
+                allIssues.push(...result.value);
+            }
+        }
+        // Sort by updatedAt descending
+        allIssues.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+        const response = { issues: allIssues };
+        res.json(response);
+    });
+    return router;
+}

package/dist/server/integration-jira.js

@@ -0,0 +1,210 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { Router } from 'express';
+const execFileAsync = promisify(execFile);
+const JIRA_TIMEOUT_MS = 10_000;
+const CACHE_TTL_MS = 60_000;
+const JIRA_ISSUES_CACHE_KEY = 'jira_issues';
+/**
+ * Creates and returns an Express Router that handles all /integration-jira routes.
+ *
+ * Caller is responsible for mounting and applying auth middleware:
+ *   app.use('/integration-jira', requireAuth, createIntegrationJiraRouter({ configPath }));
+ */
+export function createIntegrationJiraRouter(deps) {
+    const exec = deps.execAsync ?? execFileAsync;
+    const router = Router();
+    // Single 60s in-memory cache (Jira is cross-workspace, not per-repo)
+    const issuesCache = new Map();
+    // Cached site URL — resolved once per server lifetime
+    let cachedSiteUrl = null;
+    async function getSiteUrl() {
+        if (cachedSiteUrl !== null)
+            return cachedSiteUrl;
+        const { stdout } = await exec('acli', ['jira', 'auth', 'status'], {
+            timeout: JIRA_TIMEOUT_MS,
+        });
+        const match = /Site:\s*([\w-]+\.atlassian\.net)/.exec(stdout);
+        if (!match || !match[1]) {
+            throw new Error('Could not parse site URL from acli jira auth status output');
+        }
+        cachedSiteUrl = match[1];
+        return cachedSiteUrl;
+    }
+    // GET /integrations/jira/issues — search issues assigned to currentUser
+    router.get('/issues', async (_req, res) => {
+        const now = Date.now();
+        // Return cached result if still fresh
+        const cached = issuesCache.get(JIRA_ISSUES_CACHE_KEY);
+        if (cached && now - cached.fetchedAt < CACHE_TTL_MS) {
+            const response = { issues: cached.issues };
+            res.json(response);
+            return;
+        }
+        let siteUrl;
+        try {
+            siteUrl = await getSiteUrl();
+        }
+        catch (err) {
+            const errCode = err.code;
+            if (errCode === 'ENOENT') {
+                const response = {
+                    issues: [],
+                    error: 'acli_not_in_path',
+                };
+                res.json(response);
+                return;
+            }
+            const stderr = err.stderr ?? '';
+            if (stderr.includes('not logged') ||
+                stderr.includes('auth') ||
+                stderr.includes('unauthorized')) {
+                const response = {
+                    issues: [],
+                    error: 'acli_not_authenticated',
+                };
+                res.json(response);
+                return;
+            }
+            const response = {
+                issues: [],
+                error: 'jira_fetch_failed',
+            };
+            res.json(response);
+            return;
+        }
+        let stdout;
+        try {
+            ({ stdout } = await exec('acli', [
+                'jira',
+                'workitem',
+                'search',
+                '--jql',
+                'assignee=currentUser() AND status NOT IN (Done, Closed) ORDER BY updated DESC',
+                '--json',
+                '--limit',
+                '50',
+            ], { timeout: JIRA_TIMEOUT_MS }));
+        }
+        catch (err) {
+            const errCode = err.code;
+            if (errCode === 'ENOENT') {
+                const response = {
+                    issues: [],
+                    error: 'acli_not_in_path',
+                };
+                res.json(response);
+                return;
+            }
+            const stderr = err.stderr ?? '';
+            if (stderr.includes('not logged') ||
+                stderr.includes('auth') ||
+                stderr.includes('unauthorized')) {
+                const response = {
+                    issues: [],
+                    error: 'acli_not_authenticated',
+                };
+                res.json(response);
+                return;
+            }
+            const response = {
+                issues: [],
+                error: 'jira_fetch_failed',
+            };
+            res.json(response);
+            return;
+        }
+        let items;
+        try {
+            items = JSON.parse(stdout);
+        }
+        catch {
+            const response = {
+                issues: [],
+                error: 'jira_fetch_failed',
+            };
+            res.json(response);
+            return;
+        }
+        const issues = items.map((item) => ({
+            key: item.key,
+            title: item.fields.summary,
+            url: `https://${siteUrl}/browse/${item.key}`,
+            status: item.fields.status.name,
+            priority: item.fields.priority?.name ?? null,
+            assignee: item.fields.assignee?.displayName ?? null,
+            projectKey: item.key.split('-')[0] ?? item.key,
+            updatedAt: '',
+            sprint: null,
+            storyPoints: null,
+        }));
+        // Update cache
+        issuesCache.set(JIRA_ISSUES_CACHE_KEY, { issues, fetchedAt: now });
+        const response = { issues };
+        res.json(response);
+    });
+    // GET /integrations/jira/statuses?projectKey=X — fetch unique statuses for a project
+    router.get('/statuses', async (req, res) => {
+        const projectKey = req.query['projectKey'];
+        if (!projectKey || typeof projectKey !== 'string') {
+            res.status(400).json({ statuses: [], error: 'missing_project_key' });
+            return;
+        }
+        // Sanitize: only allow [A-Z0-9]+ to prevent command injection
+        if (!/^[A-Z0-9]+$/.test(projectKey)) {
+            res.status(400).json({ statuses: [], error: 'invalid_project_key' });
+            return;
+        }
+        let stdout;
+        try {
+            ({ stdout } = await exec('acli', [
+                'jira',
+                'workitem',
+                'search',
+                '--jql',
+                `project = ${projectKey}`,
+                '--fields',
+                'status',
+                '--json',
+                '--limit',
+                '50',
+            ], { timeout: JIRA_TIMEOUT_MS }));
+        }
+        catch (err) {
+            const errCode = err.code;
+            if (errCode === 'ENOENT') {
+                res.json({ statuses: [], error: 'acli_not_in_path' });
+                return;
+            }
+            const stderr = err.stderr ?? '';
+            if (stderr.includes('not logged') ||
+                stderr.includes('auth') ||
+                stderr.includes('unauthorized')) {
+                res.json({ statuses: [], error: 'acli_not_authenticated' });
+                return;
+            }
+            res.json({ statuses: [], error: 'jira_fetch_failed' });
+            return;
+        }
+        let items;
+        try {
+            items = JSON.parse(stdout);
+        }
+        catch {
+            res.json({ statuses: [], error: 'jira_fetch_failed' });
+            return;
+        }
+        // Deduplicate statuses by id
+        const seen = new Set();
+        const statuses = [];
+        for (const item of items) {
+            const { id, name } = item.fields.status;
+            if (!seen.has(id)) {
+                seen.add(id);
+                statuses.push({ id, name });
+            }
+        }
+        res.json({ statuses });
+    });
+    return router;
+}

package/dist/server/integration-linear.js

@@ -0,0 +1,176 @@
+import { Router } from 'express';
+const LINEAR_GRAPHQL_URL = 'https://api.linear.app/graphql';
+const CACHE_TTL_MS = 60_000;
+/**
+ * Creates and returns an Express Router that handles all /integration-linear routes.
+ *
+ * Caller is responsible for mounting and applying auth middleware:
+ *   app.use('/integration-linear', requireAuth, createIntegrationLinearRouter({ configPath }));
+ */
+export function createIntegrationLinearRouter(_deps) {
+    const router = Router();
+    // Single 60s in-memory cache for assigned issues
+    let issuesCache = null;
+    // GET /integrations/linear/configured — check whether the API key is set
+    router.get('/configured', (_req, res) => {
+        const apiKey = process.env.LINEAR_API_KEY;
+        res.json({ configured: Boolean(apiKey) });
+    });
+    // GET /integrations/linear/issues — fetch assigned issues (non-completed, non-canceled)
+    router.get('/issues', async (_req, res) => {
+        const apiKey = process.env.LINEAR_API_KEY;
+        if (!apiKey) {
+            const response = { issues: [], error: 'linear_not_configured' };
+            res.json(response);
+            return;
+        }
+        // Return cached result if still fresh
+        const now = Date.now();
+        if (issuesCache && now - issuesCache.fetchedAt < CACHE_TTL_MS) {
+            const response = { issues: issuesCache.issues };
+            res.json(response);
+            return;
+        }
+        const query = `
+      query {
+        viewer {
+          assignedIssues(
+            filter: { state: { type: { nin: ["completed", "canceled"] } } }
+            first: 50
+            orderBy: updatedAt
+          ) {
+            nodes {
+              id
+              identifier
+              title
+              url
+              state { name }
+              priority
+              priorityLabel
+              cycle { name }
+              estimate
+              assignee { name }
+              updatedAt
+              team { id }
+            }
+          }
+        }
+      }
+    `;
+        let data;
+        try {
+            const fetchRes = await fetch(LINEAR_GRAPHQL_URL, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ query }),
+            });
+            if (fetchRes.status === 401 || fetchRes.status === 403) {
+                const response = { issues: [], error: 'linear_auth_failed' };
+                res.json(response);
+                return;
+            }
+            if (!fetchRes.ok) {
+                const response = { issues: [], error: 'linear_fetch_failed' };
+                res.json(response);
+                return;
+            }
+            data = await fetchRes.json();
+        }
+        catch {
+            const response = { issues: [], error: 'linear_fetch_failed' };
+            res.json(response);
+            return;
+        }
+        // Check for GraphQL-level auth errors
+        const gqlData = data;
+        if (gqlData.errors && gqlData.errors.length > 0) {
+            const errType = gqlData.errors[0]?.extensions?.type;
+            if (errType === 'authentication' || errType === 'authorization') {
+                const response = { issues: [], error: 'linear_auth_failed' };
+                res.json(response);
+                return;
+            }
+            const response = { issues: [], error: 'linear_fetch_failed' };
+            res.json(response);
+            return;
+        }
+        const nodes = gqlData.data?.viewer?.assignedIssues?.nodes ?? [];
+        const issues = nodes.map((node) => ({
+            id: node.id,
+            identifier: node.identifier,
+            title: node.title,
+            url: node.url,
+            state: node.state?.name ?? '',
+            priority: node.priority,
+            priorityLabel: node.priorityLabel,
+            cycle: node.cycle?.name ?? null,
+            estimate: node.estimate ?? null,
+            assignee: node.assignee?.name ?? null,
+            updatedAt: node.updatedAt,
+            teamId: node.team?.id ?? '',
+        }));
+        // Update cache
+        issuesCache = { issues, fetchedAt: now };
+        const response = { issues };
+        res.json(response);
+    });
+    // GET /integrations/linear/states?teamId=X — fetch workflow states for a team
+    router.get('/states', async (req, res) => {
+        const apiKey = process.env.LINEAR_API_KEY;
+        if (!apiKey) {
+            res.json({ states: [], error: 'linear_not_configured' });
+            return;
+        }
+        const teamId = req.query['teamId'];
+        if (typeof teamId !== 'string' || !teamId) {
+            res.status(400).json({ states: [], error: 'missing_team_id' });
+            return;
+        }
+        const query = `
+      query($teamId: String!) {
+        workflowStates(filter: { team: { id: { eq: $teamId } } }) {
+          nodes { id name }
+        }
+      }
+    `;
+        let data;
+        try {
+            const fetchRes = await fetch(LINEAR_GRAPHQL_URL, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ query, variables: { teamId } }),
+            });
+            if (fetchRes.status === 401 || fetchRes.status === 403) {
+                res.json({ states: [], error: 'linear_auth_failed' });
+                return;
+            }
+            if (!fetchRes.ok) {
+                res.json({ states: [], error: 'linear_fetch_failed' });
+                return;
+            }
+            data = await fetchRes.json();
+        }
+        catch {
+            res.json({ states: [], error: 'linear_fetch_failed' });
+            return;
+        }
+        const gqlData = data;
+        if (gqlData.errors && gqlData.errors.length > 0) {
+            res.json({ states: [], error: 'linear_fetch_failed' });
+            return;
+        }
+        const nodes = gqlData.data?.workflowStates?.nodes ?? [];
+        const states = nodes.map((node) => ({
+            id: node.id,
+            name: node.name,
+        }));
+        res.json({ states });
+    });
+    return router;
+}

package/dist/server/logger.js

@@ -0,0 +1,18 @@
+/**
+ * Create a namespaced logger that prefixes all messages.
+ *
+ * @param namespace - Namespace used in the log prefix.
+ * @returns A logger that delegates to `console.*`.
+ */
+export function createLogger(namespace) {
+    const prefix = `[${namespace}]`;
+    const log = (level, message, ...args) => {
+        console[level](`${prefix} ${message}`, ...args);
+    };
+    return {
+        debug: (message, ...args) => log('debug', message, ...args),
+        info: (message, ...args) => log('info', message, ...args),
+        warn: (message, ...args) => log('warn', message, ...args),
+        error: (message, ...args) => log('error', message, ...args),
+    };
+}

package/dist/server/mobile-input-pipeline.js

@@ -0,0 +1,129 @@
+export function codepointCount(str) {
+    let count = 0;
+    for (let i = 0; i < str.length; i++) {
+        count++;
+        if (str.charCodeAt(i) >= 0xd800 && str.charCodeAt(i) <= 0xdbff)
+            i++;
+    }
+    return count;
+}
+export function commonPrefixLength(a, b) {
+    let len = 0;
+    while (len < a.length && len < b.length && a[len] === b[len])
+        len++;
+    return len;
+}
+const DEL = '\x7f';
+function makeBackspaces(count) {
+    let s = '';
+    for (let i = 0; i < count; i++)
+        s += DEL;
+    return s;
+}
+function handleInsert(intent, currentValue) {
+    const { rangeStart, rangeEnd, data } = intent;
+    if (rangeStart !== null && rangeEnd !== null && rangeStart !== rangeEnd) {
+        // Non-collapsed range = autocorrect replacement
+        const replaced = intent.valueBefore.slice(rangeStart, rangeEnd);
+        const charsToDelete = codepointCount(replaced);
+        const payload = makeBackspaces(charsToDelete) + (data ?? '');
+        return { payload };
+    }
+    if (data) {
+        // Gboard cursor-0 bug: keyboard loses cursor position and prepends the
+        // replacement word at position 0 instead of replacing the last word in place.
+        // Detect by: multi-char data, cursor was at 0, and new value = data + old value.
+        const isCursor0Prepend = data.length > 1 &&
+            intent.cursorBefore === 0 &&
+            intent.valueBefore.length > 0 &&
+            currentValue === data + intent.valueBefore;
+        if (isCursor0Prepend) {
+            const lastSpaceIdx = intent.valueBefore.lastIndexOf(' ');
+            const lastWord = lastSpaceIdx >= 0
+                ? intent.valueBefore.slice(lastSpaceIdx + 1)
+                : intent.valueBefore;
+            // Buffer ends with a space — nothing to autocorrect
+            if (lastWord.length === 0) {
+                return {
+                    payload: '',
+                    newInputValue: intent.valueBefore,
+                    debug: 'CURSOR0: empty lastWord, skip',
+                };
+            }
+            const prefix = lastSpaceIdx >= 0 ? intent.valueBefore.slice(0, lastSpaceIdx + 1) : '';
+            // Gboard sometimes sends the full replacement word (data[0] === firstChar,
+            // e.g. "teh" → data="the") and sometimes only the suffix after the first
+            // char (data[0] !== firstChar, e.g. "tsestin" → data="esting ").
+            // Evidence from device diagnostics confirms both patterns occur.
+            const firstChar = lastWord.charAt(0);
+            const isSuffix = data.charAt(0) !== firstChar;
+            const replacement = isSuffix ? firstChar + data : data;
+            const payload = makeBackspaces(codepointCount(lastWord)) + replacement;
+            const debug = `CURSOR0: lastWord="${lastWord}" firstChar="${firstChar}" data[0]="${data.charAt(0)}" mode=${isSuffix ? 'suffix' : 'fullword'} replacement="${replacement}" del=${codepointCount(lastWord)}`;
+            return { payload, newInputValue: prefix + replacement, debug };
+        }
+        return { payload: data };
+    }
+    // No data and no range — fall back to diff
+    return handleFallbackDiff(intent, currentValue);
+}
+function handleDelete(intent, currentValue) {
+    const { rangeStart, rangeEnd, valueBefore } = intent;
+    if (rangeStart !== null && rangeEnd !== null) {
+        const deleted = valueBefore.slice(rangeStart, rangeEnd);
+        const charsToDelete = codepointCount(deleted);
+        return { payload: makeBackspaces(charsToDelete) };
+    }
+    // No range info — diff to figure out how many chars were deleted
+    const deleted = valueBefore.length - currentValue.length;
+    const charsToDelete = Math.max(1, deleted);
+    return { payload: makeBackspaces(charsToDelete) };
+}
+function handleReplacement(intent, currentValue) {
+    const { rangeStart, rangeEnd, data, valueBefore } = intent;
+    if (rangeStart !== null && rangeEnd !== null) {
+        const replaced = valueBefore.slice(rangeStart, rangeEnd);
+        const charsToDelete = codepointCount(replaced);
+        const payload = makeBackspaces(charsToDelete) + (data ?? '');
+        return { payload };
+    }
+    return handleFallbackDiff(intent, currentValue);
+}
+function handlePaste(intent, currentValue) {
+    const commonLen = commonPrefixLength(intent.valueBefore, currentValue);
+    const pasted = currentValue.slice(commonLen);
+    return { payload: pasted };
+}
+function handleFallbackDiff(intent, currentValue) {
+    const valueBefore = intent.valueBefore || '';
+    if (currentValue === valueBefore) {
+        return { payload: '' };
+    }
+    const commonLen = commonPrefixLength(valueBefore, currentValue);
+    const deletedSlice = valueBefore.slice(commonLen);
+    const charsToDelete = codepointCount(deletedSlice);
+    const newChars = currentValue.slice(commonLen);
+    const payload = makeBackspaces(charsToDelete) + newChars;
+    return { payload };
+}
+export function processIntent(intent, currentValue) {
+    switch (intent.type) {
+        case 'insertText':
+            return handleInsert(intent, currentValue);
+        case 'deleteContentBackward':
+        case 'deleteContentForward':
+        case 'deleteWordBackward':
+        case 'deleteWordForward':
+        case 'deleteSoftLineBackward':
+        case 'deleteSoftLineForward':
+        case 'deleteBySoftwareKeyboard':
+            return handleDelete(intent, currentValue);
+        case 'insertReplacementText':
+            return handleReplacement(intent, currentValue);
+        case 'insertFromPaste':
+        case 'insertFromDrop':
+            return handlePaste(intent, currentValue);
+        default:
+            return handleFallbackDiff(intent, currentValue);
+    }
+}