relay-ide 0.1.0

package/dist/test/server/integration-github.js

@@ -0,0 +1,117 @@
+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.workspaces ?? [];
+        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/test/server/integration-jira.js

@@ -0,0 +1,164 @@
+import { Router } from 'express';
+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 router = Router();
+    // Single 60s in-memory cache (Jira is cross-workspace, not per-repo)
+    const issuesCache = new Map();
+    function getEnvVars() {
+        const token = process.env.JIRA_API_TOKEN;
+        const email = process.env.JIRA_EMAIL;
+        const baseUrl = process.env.JIRA_BASE_URL;
+        if (!token || !email || !baseUrl)
+            return null;
+        return { token, email, baseUrl };
+    }
+    function buildAuthHeader(email, token) {
+        return `Basic ${Buffer.from(`${email}:${token}`).toString('base64')}`;
+    }
+    // GET /integrations/jira/configured — returns whether env vars are set
+    router.get('/configured', (_req, res) => {
+        const env = getEnvVars();
+        res.json({ configured: env !== null });
+    });
+    // GET /integrations/jira/issues — search issues assigned to currentUser
+    router.get('/issues', async (_req, res) => {
+        const env = getEnvVars();
+        if (!env) {
+            const response = { issues: [], error: 'jira_not_configured' };
+            res.json(response);
+            return;
+        }
+        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;
+        }
+        const jql = 'assignee=currentUser() AND status NOT IN (Done, Closed) ORDER BY updated DESC';
+        const fields = 'summary,status,priority,customfield_10016,customfield_10020,assignee,updated';
+        const url = `${env.baseUrl}/rest/api/3/search?jql=${encodeURIComponent(jql)}&fields=${encodeURIComponent(fields)}&maxResults=50`;
+        let data;
+        try {
+            const fetchResult = await Promise.allSettled([
+                fetch(url, {
+                    headers: {
+                        Authorization: buildAuthHeader(env.email, env.token),
+                        Accept: 'application/json',
+                    },
+                }),
+            ]);
+            const settled = fetchResult[0];
+            if (settled.status === 'rejected') {
+                const response = { issues: [], error: 'jira_fetch_failed' };
+                res.json(response);
+                return;
+            }
+            const httpRes = settled.value;
+            if (httpRes.status === 401 || httpRes.status === 403) {
+                const response = { issues: [], error: 'jira_auth_failed' };
+                res.json(response);
+                return;
+            }
+            if (!httpRes.ok) {
+                const response = { issues: [], error: 'jira_fetch_failed' };
+                res.json(response);
+                return;
+            }
+            data = (await httpRes.json());
+        }
+        catch {
+            const response = { issues: [], error: 'jira_fetch_failed' };
+            res.json(response);
+            return;
+        }
+        const issues = data.issues.map((item) => {
+            const projectKey = item.key.split('-')[0] ?? item.key;
+            const sprint = item.fields.customfield_10020;
+            const latestSprint = sprint && sprint.length > 0 ? sprint[sprint.length - 1]?.name ?? null : null;
+            return {
+                key: item.key,
+                title: item.fields.summary,
+                url: `${env.baseUrl}/browse/${item.key}`,
+                status: item.fields.status.name,
+                priority: item.fields.priority?.name ?? null,
+                sprint: latestSprint,
+                storyPoints: item.fields.customfield_10016,
+                assignee: item.fields.assignee?.displayName ?? null,
+                updatedAt: item.fields.updated,
+                projectKey,
+            };
+        });
+        // Sort by updatedAt descending
+        issues.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+        // Update cache
+        issuesCache.set(JIRA_ISSUES_CACHE_KEY, { issues, fetchedAt: now });
+        const response = { issues };
+        res.json(response);
+    });
+    // GET /integrations/jira/statuses?projectKey=X — fetch project statuses
+    router.get('/statuses', async (req, res) => {
+        const env = getEnvVars();
+        if (!env) {
+            res.json({ statuses: [], error: 'jira_not_configured' });
+            return;
+        }
+        const projectKey = req.query['projectKey'];
+        if (!projectKey || typeof projectKey !== 'string') {
+            res.status(400).json({ statuses: [], error: 'missing_project_key' });
+            return;
+        }
+        const url = `${env.baseUrl}/rest/api/3/project/${encodeURIComponent(projectKey)}/statuses`;
+        let rawData;
+        try {
+            const fetchResults = await Promise.allSettled([
+                fetch(url, {
+                    headers: {
+                        Authorization: buildAuthHeader(env.email, env.token),
+                        Accept: 'application/json',
+                    },
+                }),
+            ]);
+            const settled = fetchResults[0];
+            if (settled.status === 'rejected') {
+                res.json({ statuses: [], error: 'jira_fetch_failed' });
+                return;
+            }
+            const httpRes = settled.value;
+            if (httpRes.status === 401 || httpRes.status === 403) {
+                res.json({ statuses: [], error: 'jira_auth_failed' });
+                return;
+            }
+            if (!httpRes.ok) {
+                res.json({ statuses: [], error: 'jira_fetch_failed' });
+                return;
+            }
+            rawData = (await httpRes.json());
+        }
+        catch {
+            res.json({ statuses: [], error: 'jira_fetch_failed' });
+            return;
+        }
+        // Flatten statuses across all issue types and deduplicate by id
+        const seen = new Set();
+        const statuses = [];
+        for (const issueType of rawData) {
+            for (const s of issueType.statuses) {
+                if (!seen.has(s.id)) {
+                    seen.add(s.id);
+                    statuses.push({ id: s.id, name: s.name });
+                }
+            }
+        }
+        res.json({ statuses });
+    });
+    return router;
+}

package/dist/test/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/test/server/mobile-input-pipeline.js

@@ -0,0 +1,123 @@
+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);
+    }
+}