claude-remote-cli 3.9.5 → 3.11.0

package/dist/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/server/integration-jira.js

@@ -0,0 +1,172 @@
+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/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;
+}