claude-remote-cli 3.9.4 → 3.10.0

package/dist/server/integration-jira.js

@@ -0,0 +1,177 @@
+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;
+        try {
+            const parsed = new URL(baseUrl);
+            const isHttps = parsed.protocol === 'https:';
+            const isLocalHttp = parsed.protocol === 'http:' && (parsed.hostname === 'localhost' || parsed.hostname === '127.0.0.1');
+            if (!isHttps && !isLocalHttp) {
+                console.warn('[integration-jira] JIRA_BASE_URL failed validation (must be https or http://localhost), treating as unconfigured');
+                return null;
+            }
+        }
+        catch {
+            console.warn('[integration-jira] JIRA_BASE_URL is not a valid URL, treating as unconfigured');
+            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/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/org-dashboard.js

@@ -0,0 +1,222 @@
+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;
+/**
+ * Extracts "owner/repo" from a git remote URL.
+ * Handles both SSH (git@github.com:owner/repo.git) and HTTPS (https://github.com/owner/repo.git) forms.
+ */
+function extractOwnerRepo(remoteUrl) {
+    // SSH: git@github.com:owner/repo.git
+    const sshMatch = remoteUrl.match(/git@[^:]+:([^/]+\/[^/]+?)(?:\.git)?$/);
+    if (sshMatch)
+        return sshMatch[1] ?? null;
+    // HTTPS: https://github.com/owner/repo.git
+    const httpsMatch = remoteUrl.match(/https?:\/\/[^/]+\/([^/]+\/[^/]+?)(?:\.git)?$/);
+    if (httpsMatch)
+        return httpsMatch[1] ?? null;
+    return null;
+}
+/**
+ * Returns a map of "owner/repo" → workspace path for all git workspaces.
+ * Workspaces that are not git repos or have no remote are omitted.
+ */
+async function buildRepoMap(workspacePaths, exec) {
+    const map = new Map();
+    await Promise.all(workspacePaths.map(async (wsPath) => {
+        try {
+            const { stdout } = await exec('git', ['remote', 'get-url', 'origin'], { cwd: wsPath, timeout: GH_TIMEOUT_MS });
+            const ownerRepo = extractOwnerRepo(stdout.trim());
+            if (ownerRepo) {
+                map.set(ownerRepo.toLowerCase(), wsPath);
+            }
+        }
+        catch {
+            // Not a git repo or no remote — skip
+        }
+    }));
+    return map;
+}
+/**
+ * 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.workspaces ?? [];
+        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);
+        // 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,
+                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,
+                        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;
+}