claude-remote-cli 3.9.5 → 3.10.0

package/dist/server/review-poller.js

@@ -0,0 +1,241 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { loadConfig, saveConfig } from './config.js';
+const execFileAsync = promisify(execFile);
+const GH_TIMEOUT_MS = 15_000;
+const DEFAULT_POLL_INTERVAL_MS = 300_000; // 5 minutes
+// ─── Module state ─────────────────────────────────────────────────────────────
+let timer = null;
+let ghMissingWarned = false;
+let pollInFlight = false;
+let activePollPromise = null;
+// ─── Public API ───────────────────────────────────────────────────────────────
+export function startPolling(deps) {
+    if (timer !== null)
+        return;
+    const config = loadConfig(deps.configPath);
+    const intervalMs = config.automations?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    activePollPromise = pollOnce(deps);
+    activePollPromise.finally(() => { activePollPromise = null; });
+    timer = setInterval(() => {
+        activePollPromise = pollOnce(deps);
+        activePollPromise.finally(() => { activePollPromise = null; });
+    }, intervalMs);
+}
+export async function stopPolling() {
+    if (timer !== null) {
+        clearInterval(timer);
+        timer = null;
+    }
+    if (activePollPromise) {
+        await activePollPromise;
+        activePollPromise = null;
+    }
+    ghMissingWarned = false;
+}
+export function isPolling() {
+    return timer !== null;
+}
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+/**
+ * Extracts "owner/repo" from a git remote URL.
+ * Handles SSH (git@github.com:owner/repo.git) and HTTPS forms.
+ */
+function extractOwnerRepo(remoteUrl) {
+    const sshMatch = remoteUrl.match(/git@[^:]+:([^/]+\/[^/]+?)(?:\.git)?$/);
+    if (sshMatch)
+        return sshMatch[1] ?? null;
+    const httpsMatch = remoteUrl.match(/https?:\/\/[^/]+\/([^/]+\/[^/]+?)(?:\.git)?$/);
+    if (httpsMatch)
+        return httpsMatch[1] ?? null;
+    return null;
+}
+/** Extracts the PR number from a GitHub API URL like .../pulls/123 */
+function extractPrNumber(subjectUrl) {
+    const match = subjectUrl.match(/\/pulls\/(\d+)$/);
+    if (!match)
+        return null;
+    const num = parseInt(match[1] ?? '', 10);
+    return isNaN(num) ? null : num;
+}
+/** Returns the workspace path whose git remote matches the given owner/repo, or null. */
+async function findWorkspaceForRepo(ownerRepo, workspacePaths, exec) {
+    for (const workspacePath of workspacePaths) {
+        try {
+            const { stdout } = await exec('git', ['remote', 'get-url', 'origin'], {
+                cwd: workspacePath,
+                timeout: GH_TIMEOUT_MS,
+            });
+            const remoteOwnerRepo = extractOwnerRepo(stdout.trim());
+            if (remoteOwnerRepo && remoteOwnerRepo.toLowerCase() === ownerRepo.toLowerCase()) {
+                return workspacePath;
+            }
+        }
+        catch (err) {
+            // Not a git repo, no remote, or timed out — skip this workspace
+            const error = err;
+            if (error.code && error.code !== 'ENOENT') {
+                console.warn(`[review-poller] Error checking remote for ${workspacePath}:`, error.message);
+            }
+        }
+    }
+    return null;
+}
+// ─── Core poll logic ──────────────────────────────────────────────────────────
+async function pollOnce(deps) {
+    if (pollInFlight)
+        return;
+    pollInFlight = true;
+    try {
+        const exec = deps.execAsync ?? execFileAsync;
+        let config;
+        try {
+            config = loadConfig(deps.configPath);
+        }
+        catch (err) {
+            console.warn('[review-poller] Failed to load config:', err);
+            return;
+        }
+        if (!config.automations?.autoCheckoutReviewRequests)
+            return;
+        // Capture poll-start time as watermark — avoids gap where notifications
+        // arriving between fetch and save would be skipped permanently
+        const pollStartTimestamp = new Date().toISOString();
+        // First run: default to "now" so we skip all historical notifications.
+        // The first poll cycle always produces zero checkouts — only notifications
+        // arriving after this timestamp will be processed.
+        const lastPollTimestamp = config.automations?.lastPollTimestamp ?? new Date().toISOString();
+        // Fetch review_requested notifications from GitHub
+        let notifications;
+        try {
+            const { stdout } = await exec('gh', [
+                'api',
+                '/notifications',
+                '--jq',
+                '.[] | select(.reason == "review_requested") | {id, reason, subject, repository, updated_at}',
+            ], { timeout: GH_TIMEOUT_MS });
+            // gh --jq with select returns newline-delimited JSON objects
+            const lines = stdout.trim().split('\n').filter(Boolean);
+            notifications = [];
+            let parseFailures = 0;
+            for (const line of lines) {
+                try {
+                    notifications.push(JSON.parse(line));
+                }
+                catch {
+                    parseFailures++;
+                }
+            }
+            if (parseFailures > 0 && notifications.length === 0) {
+                console.warn(`[review-poller] All ${parseFailures} notification lines failed to parse — gh output format may have changed`);
+            }
+        }
+        catch (err) {
+            const error = err;
+            if (error.code === 'ENOENT') {
+                if (!ghMissingWarned) {
+                    console.warn('[review-poller] gh CLI not found — stopping poller');
+                    ghMissingWarned = true;
+                }
+                void stopPolling();
+                return;
+            }
+            if (error.killed) {
+                console.warn('[review-poller] gh notifications timed out, skipping cycle');
+                return;
+            }
+            // Auth failures and other gh errors come through stderr in the error message
+            console.warn('[review-poller] gh notifications failed, skipping cycle:', error.message);
+            return;
+        }
+        // Filter to notifications newer than the last poll
+        const newNotifications = notifications.filter((n) => new Date(n.updated_at) > new Date(lastPollTimestamp));
+        const workspacePaths = deps.getWorkspacePaths();
+        for (const notification of newNotifications) {
+            if (notification.subject.type !== 'PullRequest')
+                continue;
+            const prNumber = extractPrNumber(notification.subject.url);
+            if (prNumber === null) {
+                console.warn('[review-poller] Could not extract PR number from:', notification.subject.url);
+                continue;
+            }
+            const ownerRepo = notification.repository.full_name;
+            let workspacePath;
+            try {
+                workspacePath = await findWorkspaceForRepo(ownerRepo, workspacePaths, exec);
+            }
+            catch (err) {
+                console.warn('[review-poller] Error finding workspace for', ownerRepo, ':', err);
+                continue;
+            }
+            if (workspacePath === null) {
+                // No local workspace for this repo — skip silently
+                continue;
+            }
+            const localBranch = `review-pr-${prNumber}`;
+            const worktreePath = path.join(workspacePath, '.worktrees', localBranch);
+            // Skip if worktree already exists (e.g., from a previous poll)
+            if (fs.existsSync(worktreePath)) {
+                continue;
+            }
+            // Fetch the PR's head ref into a local branch, then create worktree from it
+            try {
+                await exec('git', ['fetch', 'origin', `pull/${prNumber}/head:${localBranch}`], { cwd: workspacePath, timeout: GH_TIMEOUT_MS });
+            }
+            catch (err) {
+                // Branch may already exist from a prior fetch — continue to worktree add
+                const errMsg = err.message ?? '';
+                if (!errMsg.includes('already exists')) {
+                    console.warn(`[review-poller] Failed to fetch PR #${prNumber}:`, err);
+                    continue;
+                }
+            }
+            try {
+                await exec('git', ['worktree', 'add', worktreePath, localBranch], { cwd: workspacePath, timeout: GH_TIMEOUT_MS });
+            }
+            catch (err) {
+                console.warn(`[review-poller] Failed to create worktree for PR #${prNumber}:`, err);
+                continue;
+            }
+            // Optionally start a review session
+            const settings = deps.getWorkspaceSettings(workspacePath);
+            if (config.automations?.autoReviewOnCheckout && settings?.promptCodeReview) {
+                try {
+                    await deps.createSession({
+                        repoPath: workspacePath,
+                        worktreePath,
+                        branchName: localBranch,
+                        initialPrompt: settings.promptCodeReview,
+                    });
+                }
+                catch (err) {
+                    console.warn(`[review-poller] Failed to create review session for PR #${prNumber}:`, err);
+                }
+            }
+            deps.broadcastEvent('review-checkout', {
+                prNumber,
+                ownerRepo,
+                worktreePath,
+                branchName: localBranch,
+                title: notification.subject.title,
+            });
+        }
+        // Update lastPollTimestamp — re-read config to avoid overwriting concurrent changes
+        try {
+            const freshConfig = loadConfig(deps.configPath);
+            freshConfig.automations = {
+                ...freshConfig.automations,
+                lastPollTimestamp: pollStartTimestamp,
+            };
+            saveConfig(deps.configPath, freshConfig);
+        }
+        catch (err) {
+            console.warn('[review-poller] Failed to save config after poll:', err);
+        }
+    }
+    finally {
+        pollInFlight = false;
+    }
+}

package/dist/server/sessions.js

@@ -30,6 +30,20 @@ const stateChangeCallbacks = [];
 function onStateChange(cb) {
     stateChangeCallbacks.push(cb);
 }
+const sessionCreateCallbacks = [];
+function onSessionCreate(cb) {
+    sessionCreateCallbacks.push(cb);
+}
+function fireSessionCreate(sessionId, repoPath, branchName) {
+    for (const cb of sessionCreateCallbacks) {
+        try {
+            cb(sessionId, repoPath, branchName);
+        }
+        catch (err) {
+            console.error('[sessions] sessionCreate callback error:', err);
+        }
+    }
+}
 const sessionEndCallbacks = [];
 function onSessionEnd(cb) {
     sessionEndCallbacks.push(cb);
@@ -45,10 +59,10 @@ function fireSessionEnd(sessionId, repoPath, branchName) {
     }
 }
 export function fireStateChange(sessionId, state) {
-    for (const cb of stateChangeCallbacks)
+    for (const cb of [...stateChangeCallbacks])
         cb(sessionId, state);
 }
-function create({ id: providedId, needsBranchRename, branchRenamePrompt, agent = 'claude', cols = 80, rows = 24, args = [], port, forceOutputParser, ...rest }) {
+function create({ id: providedId, needsBranchRename, branchRenamePrompt, initialPrompt, agent = 'claude', cols = 80, rows = 24, args = [], port, forceOutputParser, ...rest }) {
     const id = providedId || crypto.randomBytes(8).toString('hex');
     const ptyParams = {
         ...rest,
@@ -79,6 +93,32 @@ function create({ id: providedId, needsBranchRename, branchRenamePrompt, agent =
     if (branchRenamePrompt) {
         ptySession.branchRenamePrompt = branchRenamePrompt;
     }
+    if (initialPrompt) {
+        ptySession.initialPrompt = initialPrompt;
+    }
+    fireSessionCreate(id, ptySession.repoPath, ptySession.branchName);
+    if (initialPrompt) {
+        const promptHandler = (changedId, state) => {
+            if (changedId === id && state === 'waiting-for-input' && ptySession.initialPrompt) {
+                const prompt = ptySession.initialPrompt;
+                ptySession.initialPrompt = undefined; // one-shot
+                // Small delay to ensure the agent's input handler is ready
+                setTimeout(() => {
+                    try {
+                        ptySession.pty.write(prompt + '\n');
+                    }
+                    catch (err) {
+                        console.error('[sessions] Failed to inject initial prompt:', err);
+                    }
+                }, 500);
+                // Remove this handler after firing
+                const idx = stateChangeCallbacks.indexOf(promptHandler);
+                if (idx !== -1)
+                    stateChangeCallbacks.splice(idx, 1);
+            }
+        };
+        stateChangeCallbacks.push(promptHandler);
+    }
     return { ...result, needsBranchRename: !!ptySession.needsBranchRename };
 }
 function get(id) {
@@ -391,4 +431,4 @@ async function populateMetaCache() {
         }
     }));
 }
-export { configure, create, get, list, kill, killAllTmuxSessions, resize, updateDisplayName, write, onIdleChange, onStateChange, onSessionEnd, findRepoSession, nextTerminalName, nextAgentName, serializeAll, restoreFromDisk, activeTmuxSessionNames, getSessionMeta, getAllSessionMeta, populateMetaCache, AGENT_COMMANDS, AGENT_CONTINUE_ARGS, AGENT_YOLO_ARGS };
+export { configure, create, get, list, kill, killAllTmuxSessions, resize, updateDisplayName, write, onIdleChange, onStateChange, onSessionCreate, onSessionEnd, findRepoSession, nextTerminalName, nextAgentName, serializeAll, restoreFromDisk, activeTmuxSessionNames, getSessionMeta, getAllSessionMeta, populateMetaCache, AGENT_COMMANDS, AGENT_CONTINUE_ARGS, AGENT_YOLO_ARGS };

package/dist/server/ticket-transitions.js

@@ -0,0 +1,265 @@
+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;
+function ghIssueNumber(ticketId) {
+    const match = ticketId.match(/^GH-(\d+)$/i);
+    return match ? match[1] : null;
+}
+async function addLabel(exec, repoPath, issueNumber, label) {
+    try {
+        await exec('gh', ['issue', 'edit', issueNumber, '--add-label', label], {
+            cwd: repoPath,
+            timeout: GH_TIMEOUT_MS,
+        });
+        return true;
+    }
+    catch (err) {
+        console.error(`[ticket-transitions] Failed to add label "${label}" to #${issueNumber}:`, err);
+        return false;
+    }
+}
+async function removeLabel(exec, repoPath, issueNumber, label) {
+    try {
+        await exec('gh', ['issue', 'edit', issueNumber, '--remove-label', label], {
+            cwd: repoPath,
+            timeout: GH_TIMEOUT_MS,
+        });
+    }
+    catch {
+        // Label may not exist — non-fatal
+    }
+}
+/** Returns true if the URL is safe to use as a Jira base URL. */
+function isValidJiraUrl(url) {
+    try {
+        const parsed = new URL(url);
+        if (parsed.protocol === 'https:')
+            return true;
+        if (parsed.protocol === 'http:' && (parsed.hostname === 'localhost' || parsed.hostname === '127.0.0.1'))
+            return true;
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+/** Call a Jira transition by ID. Returns true on success, false on failure. */
+async function jiraTransition(ticketId, transitionId) {
+    const baseUrl = process.env.JIRA_BASE_URL;
+    const email = process.env.JIRA_EMAIL;
+    const token = process.env.JIRA_API_TOKEN;
+    if (!baseUrl || !email || !token)
+        return false;
+    if (!isValidJiraUrl(baseUrl)) {
+        console.warn(`[ticket-transitions] JIRA_BASE_URL failed validation, skipping transition for ${ticketId}`);
+        return false;
+    }
+    try {
+        const res = await fetch(`${baseUrl}/rest/api/3/issue/${encodeURIComponent(ticketId)}/transitions`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Basic ${Buffer.from(email + ':' + token).toString('base64')}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ transition: { id: transitionId } }),
+        });
+        if (!res.ok) {
+            console.error(`[ticket-transitions] Jira transition returned ${res.status} for ${ticketId}`);
+            return false;
+        }
+        return true;
+    }
+    catch (err) {
+        console.error(`[ticket-transitions] Jira transition failed for ${ticketId}:`, err);
+        return false;
+    }
+}
+/** Update a Linear issue state. Returns true on success, false on failure. */
+async function linearStateUpdate(ticketIdentifier, stateId) {
+    const apiKey = process.env.LINEAR_API_KEY;
+    if (!apiKey)
+        return false;
+    // Linear mutations need the issue ID, but we only have the identifier (e.g. "TEAM-123").
+    // Resolve the issue ID by identifier, then update state.
+    try {
+        const searchRes = await fetch('https://api.linear.app/graphql', {
+            method: 'POST',
+            headers: { 'Authorization': `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                query: `query($filter: IssueFilter) { issues(filter: $filter, first: 1) { nodes { id } } }`,
+                variables: { filter: { identifier: { eq: ticketIdentifier } } },
+            }),
+        });
+        if (!searchRes.ok) {
+            console.error(`[ticket-transitions] Linear issue lookup returned ${searchRes.status} for ${ticketIdentifier}`);
+            return false;
+        }
+        const searchData = (await searchRes.json());
+        const issueId = searchData.data?.issues?.nodes?.[0]?.id;
+        if (!issueId)
+            return false;
+        const updateRes = await fetch('https://api.linear.app/graphql', {
+            method: 'POST',
+            headers: { 'Authorization': `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                query: `mutation($id: String!, $stateId: String!) { issueUpdate(id: $id, input: { stateId: $stateId }) { success } }`,
+                variables: { id: issueId, stateId },
+            }),
+        });
+        if (!updateRes.ok) {
+            console.error(`[ticket-transitions] Linear state update returned ${updateRes.status} for ${ticketIdentifier}`);
+            return false;
+        }
+        return true;
+    }
+    catch (err) {
+        console.error(`[ticket-transitions] Linear state update failed for ${ticketIdentifier}:`, err);
+        return false;
+    }
+}
+/**
+ * Best-effort source detection from a ticket ID pattern.
+ * Known limitation: when both Jira and Linear are configured, non-GH tickets
+ * are matched by whichever env var is present. This is imperfect — a future
+ * improvement would persist the source alongside branch links.
+ */
+function detectTicketSource(ticketId, links) {
+    // Use explicit source from branch link if available
+    if (links) {
+        const linkWithSource = links.find((l) => l.source);
+        if (linkWithSource?.source)
+            return linkWithSource.source;
+    }
+    if (ticketId.startsWith('GH-'))
+        return 'github';
+    // Prefer Jira for PROJECT-style keys (>= 3 uppercase letters before dash)
+    // since Jira project keys are typically longer than Linear team keys (2-3 chars).
+    const prefix = ticketId.split('-')[0] ?? '';
+    if (prefix.length >= 3 && process.env.JIRA_API_TOKEN)
+        return 'jira';
+    if (process.env.LINEAR_API_KEY)
+        return 'linear';
+    if (process.env.JIRA_API_TOKEN)
+        return 'jira';
+    return 'github'; // fallback
+}
+export function createTicketTransitionsRouter(deps) {
+    // In-memory idempotency guard: ticketId -> last transitioned state
+    const transitionMap = new Map();
+    const exec = deps.execAsync ?? execFileAsync;
+    const { configPath } = deps;
+    const router = Router();
+    /** Get status mapping for a transition state from config */
+    function getStatusMapping(config, source, state) {
+        if (source === 'jira')
+            return config.integrations?.jira?.statusMappings?.[state];
+        return config.integrations?.linear?.statusMappings?.[state];
+    }
+    async function transitionOnSessionCreate(ctx) {
+        const current = transitionMap.get(ctx.ticketId);
+        if (current && current !== 'none')
+            return;
+        if (ctx.source === 'github') {
+            const issueNum = ghIssueNumber(ctx.ticketId);
+            if (!issueNum)
+                return;
+            const ok = await addLabel(exec, ctx.repoPath, issueNum, 'in-progress');
+            if (ok)
+                transitionMap.set(ctx.ticketId, 'in-progress');
+        }
+        else if (ctx.source === 'jira') {
+            const config = loadConfig(configPath);
+            const transitionId = getStatusMapping(config, 'jira', 'in-progress');
+            if (transitionId) {
+                const ok = await jiraTransition(ctx.ticketId, transitionId);
+                if (ok)
+                    transitionMap.set(ctx.ticketId, 'in-progress');
+            }
+        }
+        else if (ctx.source === 'linear') {
+            const config = loadConfig(configPath);
+            const stateId = getStatusMapping(config, 'linear', 'in-progress');
+            if (stateId) {
+                const ok = await linearStateUpdate(ctx.ticketId, stateId);
+                if (ok)
+                    transitionMap.set(ctx.ticketId, 'in-progress');
+            }
+        }
+    }
+    async function checkPrTransitions(prs, branchLinks) {
+        const config = loadConfig(configPath);
+        for (const pr of prs) {
+            for (const [ticketId, links] of Object.entries(branchLinks)) {
+                const linked = links.some((l) => l.branchName === pr.headRefName);
+                if (!linked)
+                    continue;
+                const current = transitionMap.get(ticketId);
+                const source = detectTicketSource(ticketId, links);
+                if (pr.state === 'OPEN' && current !== 'code-review' && current !== 'ready-for-qa') {
+                    if (source === 'github') {
+                        const issueNum = ghIssueNumber(ticketId);
+                        if (!issueNum)
+                            continue;
+                        const repoPath = links[0]?.repoPath;
+                        if (!repoPath)
+                            continue;
+                        await removeLabel(exec, repoPath, issueNum, 'in-progress');
+                        const ok = await addLabel(exec, repoPath, issueNum, 'code-review');
+                        if (ok)
+                            transitionMap.set(ticketId, 'code-review');
+                    }
+                    else if (source === 'jira') {
+                        const transitionId = getStatusMapping(config, 'jira', 'code-review');
+                        if (transitionId) {
+                            const ok = await jiraTransition(ticketId, transitionId);
+                            if (ok)
+                                transitionMap.set(ticketId, 'code-review');
+                        }
+                    }
+                    else if (source === 'linear') {
+                        const stateId = getStatusMapping(config, 'linear', 'code-review');
+                        if (stateId) {
+                            const ok = await linearStateUpdate(ticketId, stateId);
+                            if (ok)
+                                transitionMap.set(ticketId, 'code-review');
+                        }
+                    }
+                }
+                else if (pr.state === 'MERGED' && current !== 'ready-for-qa') {
+                    if (source === 'github') {
+                        const issueNum = ghIssueNumber(ticketId);
+                        if (!issueNum)
+                            continue;
+                        const repoPath = links[0]?.repoPath;
+                        if (!repoPath)
+                            continue;
+                        await removeLabel(exec, repoPath, issueNum, 'code-review');
+                        const ok = await addLabel(exec, repoPath, issueNum, 'ready-for-qa');
+                        if (ok)
+                            transitionMap.set(ticketId, 'ready-for-qa');
+                    }
+                    else if (source === 'jira') {
+                        const transitionId = getStatusMapping(config, 'jira', 'ready-for-qa');
+                        if (transitionId) {
+                            const ok = await jiraTransition(ticketId, transitionId);
+                            if (ok)
+                                transitionMap.set(ticketId, 'ready-for-qa');
+                        }
+                    }
+                    else if (source === 'linear') {
+                        const stateId = getStatusMapping(config, 'linear', 'ready-for-qa');
+                        if (stateId) {
+                            const ok = await linearStateUpdate(ticketId, stateId);
+                            if (ok)
+                                transitionMap.set(ticketId, 'ready-for-qa');
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return { router, transitionOnSessionCreate, checkPrTransitions };
+}