npm - claude-remote-cli - Versions diffs - 3.9.4 → 3.10.0 - Mend

claude-remote-cli 3.9.4 → 3.10.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

package/dist/frontend/assets/index-BTOnhJQN.css +32 -0
package/dist/frontend/assets/index-Dgf6cKGu.js +52 -0
package/dist/frontend/index.html +2 -2
package/dist/server/branch-linker.js +136 -0
package/dist/server/config.js +31 -1
package/dist/server/index.js +260 -6
package/dist/server/integration-github.js +117 -0
package/dist/server/integration-jira.js +177 -0
package/dist/server/integration-linear.js +176 -0
package/dist/server/org-dashboard.js +222 -0
package/dist/server/review-poller.js +241 -0
package/dist/server/sessions.js +43 -3
package/dist/server/ticket-transitions.js +265 -0
package/dist/server/watcher.js +124 -0
package/dist/test/branch-linker.test.js +231 -0
package/dist/test/branch-watcher.test.js +73 -0
package/dist/test/config.test.js +56 -0
package/dist/test/integration-github.test.js +203 -0
package/dist/test/integration-jira.test.js +302 -0
package/dist/test/integration-linear.test.js +293 -0
package/dist/test/org-dashboard.test.js +240 -0
package/dist/test/review-poller.test.js +344 -0
package/dist/test/ticket-transitions.test.js +470 -0
package/package.json +1 -1
package/dist/frontend/assets/index-BYv7-2w9.css +0 -32
package/dist/frontend/assets/index-CO9tRKXI.js +0 -52

package/dist/frontend/index.html CHANGED Viewed

@@ -11,8 +11,8 @@
   <meta name="apple-mobile-web-app-capable" content="yes" />
   <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
   <meta name="theme-color" content="#1a1a1a" />
-  <script type="module" crossorigin src="/assets/index-CO9tRKXI.js"></script>
-  <link rel="stylesheet" crossorigin href="/assets/index-BYv7-2w9.css">
+  <script type="module" crossorigin src="/assets/index-Dgf6cKGu.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-BTOnhJQN.css">
 </head>
 <body>
   <div id="app"></div>

package/dist/server/branch-linker.js ADDED Viewed

@@ -0,0 +1,136 @@
+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 GIT_TIMEOUT_MS = 10_000;
+const CACHE_TTL_MS = 60_000;
+let cache = null;
+/** Clears the branch linker cache (call when sessions are created or ended). */
+export function invalidateBranchLinkerCache() {
+    cache = null;
+}
+/**
+ * Extracts all ticket IDs from a branch name.
+ * Returns an array of normalized ticket IDs (e.g. "PROJ-123", "GH-456").
+ */
+function extractTicketIds(branchName) {
+    const ids = [];
+    // Jira/Linear style: PROJECT-123 (2+ uppercase letters, dash, digits)
+    // Skip "GH" prefix — that's our GitHub Issues namespace, handled separately below.
+    const jiraRegex = /([A-Z]{2,}-\d+)/gi;
+    let match;
+    while ((match = jiraRegex.exec(branchName)) !== null) {
+        if (match[1] && match[1].toUpperCase().split('-')[0] !== 'GH') {
+            ids.push(match[1].toUpperCase());
+        }
+    }
+    // GitHub Issues: gh-123 at word boundaries (start/end or preceded/followed by dash or slash)
+    const ghRegex = /(?:^|[-/])gh-(\d+)(?:[-/]|$)/gi;
+    while ((match = ghRegex.exec(branchName)) !== null) {
+        ids.push(`GH-${match[1]}`);
+    }
+    return ids;
+}
+/**
+ * Creates and returns an Express Router that handles all /branch-linker routes.
+ *
+ * Caller is responsible for mounting and applying auth middleware:
+ *   app.use('/branch-linker', requireAuth, createBranchLinkerRouter({ configPath }));
+ */
+export function createBranchLinkerRouter(deps) {
+    const { configPath } = deps;
+    const exec = deps.execAsync ?? execFileAsync;
+    const getActiveBranchNames = deps.getActiveBranchNames ?? (() => new Map());
+    const router = Router();
+    function getConfig() {
+        return loadConfig(configPath);
+    }
+    /** Core link-building logic, usable both from the HTTP handler and internal callers. */
+    async function fetchLinks() {
+        const config = getConfig();
+        const workspacePaths = config.workspaces ?? [];
+        if (workspacePaths.length === 0) {
+            return {};
+        }
+        const now = Date.now();
+        // Return cached result if still fresh
+        if (cache && now - cache.fetchedAt < CACHE_TTL_MS) {
+            return cache.links;
+        }
+        // Get active branch names per repo from sessions
+        const activeBranchNames = getActiveBranchNames();
+        // Fetch branches per workspace using Promise.allSettled (partial failures are non-fatal)
+        const results = await Promise.allSettled(workspacePaths.map(async (wsPath) => {
+            let stdout;
+            try {
+                ({ stdout } = await exec('git', ['branch', '--format=%(refname:short)'], { cwd: wsPath, timeout: GIT_TIMEOUT_MS }));
+            }
+            catch {
+                // Not a git repo or git not available — non-fatal
+                return [];
+            }
+            const repoName = path.basename(wsPath);
+            const activeInRepo = activeBranchNames.get(wsPath) ?? new Set();
+            const branchNames = stdout.split('\n').map((b) => b.trim()).filter(Boolean);
+            const links = [];
+            for (const branchName of branchNames) {
+                const ticketIds = extractTicketIds(branchName);
+                for (const ticketId of ticketIds) {
+                    // Infer ticket source from ID pattern
+                    let source;
+                    if (ticketId.startsWith('GH-')) {
+                        source = 'github';
+                    }
+                    else if (process.env.JIRA_API_TOKEN) {
+                        source = 'jira';
+                    }
+                    else if (process.env.LINEAR_API_KEY) {
+                        source = 'linear';
+                    }
+                    links.push({
+                        ticketId,
+                        link: {
+                            repoPath: wsPath,
+                            repoName,
+                            branchName,
+                            hasActiveSession: activeInRepo.has(branchName),
+                            source,
+                        },
+                    });
+                }
+            }
+            return links;
+        }));
+        // Build the ticket -> BranchLink[] map
+        const linksMap = new Map();
+        for (const result of results) {
+            if (result.status === 'fulfilled') {
+                for (const { ticketId, link } of result.value) {
+                    const existing = linksMap.get(ticketId);
+                    if (existing) {
+                        existing.push(link);
+                    }
+                    else {
+                        linksMap.set(ticketId, [link]);
+                    }
+                }
+            }
+        }
+        // Convert Map to plain object for JSON serialization
+        const response = {};
+        for (const [ticketId, links] of linksMap) {
+            response[ticketId] = links;
+        }
+        // Update module-level cache
+        cache = { links: response, fetchedAt: now };
+        return response;
+    }
+    // GET /branch-linker/links — map of ticketId -> BranchLink[]
+    router.get('/links', async (_req, res) => {
+        const response = await fetchLinks();
+        res.json(response);
+    });
+    return Object.assign(router, { fetchLinks });
+}

package/dist/server/config.js CHANGED Viewed

@@ -21,7 +21,37 @@ export function loadConfig(configPath) {
     }
     const raw = fs.readFileSync(configPath, 'utf8');
     const parsed = JSON.parse(raw);
-    return { ...DEFAULTS, ...parsed };
+    const config = { ...DEFAULTS, ...parsed };
+    // Validate and clean workspaceGroups
+    if (config.workspaceGroups != null) {
+        const validPaths = new Set(config.workspaces ?? []);
+        const seenPaths = new Set();
+        const cleaned = {};
+        for (const [groupName, paths] of Object.entries(config.workspaceGroups)) {
+            if (!Array.isArray(paths)) {
+                console.warn(`workspaceGroups: group "${groupName}" value is not an array, skipping`);
+                continue;
+            }
+            const filteredPaths = [];
+            for (const p of paths) {
+                if (!validPaths.has(p)) {
+                    console.warn(`workspaceGroups: path "${p}" in group "${groupName}" is not in workspaces[], skipping`);
+                    continue;
+                }
+                if (seenPaths.has(p)) {
+                    console.warn(`workspaceGroups: path "${p}" in group "${groupName}" is already assigned to another group, skipping`);
+                    continue;
+                }
+                seenPaths.add(p);
+                filteredPaths.push(p);
+            }
+            if (filteredPaths.length > 0) {
+                cleaned[groupName] = filteredPaths;
+            }
+        }
+        config.workspaceGroups = cleaned;
+    }
+    return config;
 }
 export function saveConfig(configPath, config) {
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');

package/dist/server/index.js CHANGED Viewed

@@ -13,14 +13,21 @@ import * as auth from './auth.js';
 import * as sessions from './sessions.js';
 import { AGENT_CONTINUE_ARGS, AGENT_YOLO_ARGS, serializeAll, restoreFromDisk, activeTmuxSessionNames, populateMetaCache } from './sessions.js';
 import { setupWebSocket } from './ws.js';
-import { WorktreeWatcher, WORKTREE_DIRS, isValidWorktreePath, parseWorktreeListPorcelain, parseAllWorktrees } from './watcher.js';
+import { WorktreeWatcher, BranchWatcher, WORKTREE_DIRS, isValidWorktreePath, parseWorktreeListPorcelain, parseAllWorktrees } from './watcher.js';
 import { isInstalled as serviceIsInstalled } from './service.js';
 import { extensionForMime, setClipboardImage } from './clipboard.js';
 import { listBranches, isBranchStale } from './git.js';
 import * as push from './push.js';
 import { initAnalytics, closeAnalytics, createAnalyticsRouter } from './analytics.js';
 import { createWorkspaceRouter } from './workspaces.js';
+import { createOrgDashboardRouter } from './org-dashboard.js';
+import { createIntegrationGitHubRouter } from './integration-github.js';
+import { createBranchLinkerRouter, invalidateBranchLinkerCache } from './branch-linker.js';
 import { createHooksRouter } from './hooks.js';
+import { createTicketTransitionsRouter } from './ticket-transitions.js';
+import { createIntegrationJiraRouter } from './integration-jira.js';
+import { createIntegrationLinearRouter } from './integration-linear.js';
+import { startPolling, stopPolling } from './review-poller.js';
 import { MOUNTAIN_NAMES } from './types.js';
 import { semverLessThan } from './utils.js';
 const __filename = fileURLToPath(import.meta.url);
@@ -235,6 +242,26 @@ async function main() {
     watcher.rebuild(config.workspaces || []);
     const server = http.createServer(app);
     const { broadcastEvent } = setupWebSocket(server, authenticatedTokens, watcher, CONFIG_PATH);
+    // Watch .git/HEAD files for branch changes and update active sessions
+    const branchWatcher = new BranchWatcher((cwdPath, newBranch) => {
+        for (const session of sessions.list()) {
+            if (session.repoPath === cwdPath || session.cwd === cwdPath) {
+                const raw = sessions.get(session.id);
+                if (raw) {
+                    raw.branchName = newBranch;
+                    broadcastEvent('session-renamed', {
+                        sessionId: session.id,
+                        branchName: newBranch,
+                        displayName: raw.displayName,
+                    });
+                }
+            }
+        }
+    });
+    branchWatcher.rebuild(config.workspaces || []);
+    watcher.on('worktrees-changed', () => {
+        branchWatcher.rebuild(config.workspaces || []);
+    });
     // Configure session defaults for hooks injection
     sessions.configure({ port: config.port, forceOutputParser: config.forceOutputParser ?? false });
     // Mount hooks router BEFORE auth middleware — hook callbacks come from localhost Claude Code
@@ -249,6 +276,45 @@ async function main() {
     // Mount workspace router
     const workspaceRouter = createWorkspaceRouter({ configPath: CONFIG_PATH });
     app.use('/workspaces', requireAuth, workspaceRouter);
+    // Mount GitHub integration router
+    const integrationGitHubRouter = createIntegrationGitHubRouter({ configPath: CONFIG_PATH });
+    app.use('/integration-github', requireAuth, integrationGitHubRouter);
+    // Mount Jira integration router
+    const integrationJiraRouter = createIntegrationJiraRouter({ configPath: CONFIG_PATH });
+    app.use('/integration-jira', requireAuth, integrationJiraRouter);
+    // Mount Linear integration router
+    const integrationLinearRouter = createIntegrationLinearRouter({ configPath: CONFIG_PATH });
+    app.use('/integration-linear', requireAuth, integrationLinearRouter);
+    // Mount branch linker router
+    const branchLinkerRouter = createBranchLinkerRouter({
+        configPath: CONFIG_PATH,
+        getActiveBranchNames: () => {
+            const workspaces = config.workspaces ?? [];
+            const map = new Map();
+            for (const s of sessions.list()) {
+                if (!s.branchName)
+                    continue;
+                // Normalize: match session repoPath to workspace root
+                // (worktree sessions store the worktree path, not workspace root)
+                const wsRoot = workspaces.find((ws) => s.repoPath.startsWith(ws)) ?? s.repoPath;
+                const existing = map.get(wsRoot);
+                if (existing) {
+                    existing.add(s.branchName);
+                }
+                else {
+                    map.set(wsRoot, new Set([s.branchName]));
+                }
+            }
+            return map;
+        },
+    });
+    app.use('/branch-linker', requireAuth, branchLinkerRouter);
+    // Mount ticket transitions router
+    const { router: ticketTransitionsRouter, transitionOnSessionCreate, checkPrTransitions } = createTicketTransitionsRouter({ configPath: CONFIG_PATH });
+    app.use('/ticket-transitions', requireAuth, ticketTransitionsRouter);
+    // Mount org dashboard router — use branchLinkerRouter.fetchLinks() directly (no loopback HTTP)
+    const orgDashboardRouter = createOrgDashboardRouter({ configPath: CONFIG_PATH, checkPrTransitions, getBranchLinks: () => branchLinkerRouter.fetchLinks() });
+    app.use('/org-dashboard', requireAuth, orgDashboardRouter);
     // Mount analytics router
     app.use('/analytics', requireAuth, createAnalyticsRouter(configDir));
     // Restore sessions from a previous update restart
@@ -258,6 +324,45 @@ async function main() {
     }
     // Populate session metadata cache in background (non-blocking)
     populateMetaCache().catch(() => { });
+    // Build shared deps for review poller
+    function buildPollerDeps() {
+        return {
+            configPath: CONFIG_PATH,
+            getWorkspacePaths: () => config.workspaces ?? [],
+            getWorkspaceSettings: (wsPath) => config.workspaceSettings?.[wsPath],
+            createSession: async (opts) => {
+                const resolved = resolveSessionSettings(config, opts.repoPath, {});
+                const roots = config.rootDirs || [];
+                const root = roots.find((r) => opts.repoPath.startsWith(r)) || '';
+                const repoName = opts.repoPath.split('/').filter(Boolean).pop() || 'session';
+                const worktreeName = opts.worktreePath.split('/').pop() || '';
+                const displayName = sessions.nextAgentName();
+                sessions.create({
+                    type: 'worktree',
+                    agent: resolved.agent,
+                    repoName,
+                    repoPath: opts.worktreePath,
+                    cwd: opts.worktreePath,
+                    root,
+                    worktreeName,
+                    branchName: opts.branchName,
+                    displayName,
+                    args: [...resolved.claudeArgs, ...(resolved.yolo ? AGENT_YOLO_ARGS[resolved.agent] : [])],
+                    configPath: CONFIG_PATH,
+                    useTmux: resolved.useTmux,
+                    ...(opts.initialPrompt != null && { initialPrompt: opts.initialPrompt }),
+                });
+            },
+            broadcastEvent,
+        };
+    }
+    // Start review request poller if enabled
+    if (config.automations?.autoCheckoutReviewRequests) {
+        startPolling(buildPollerDeps());
+    }
+    // Invalidate branch linker cache on session lifecycle changes
+    sessions.onSessionCreate(() => { invalidateBranchLinkerCache(); });
+    sessions.onSessionEnd(() => { invalidateBranchLinkerCache(); });
     // Push notifications on session idle (skip when hooks already sent attention notification)
     sessions.onIdleChange((sessionId, idle) => {
         if (idle) {
@@ -301,9 +406,43 @@ async function main() {
         });
         res.json({ ok: true });
     });
-    // GET /sessions
-    app.get('/sessions', requireAuth, (_req, res) => {
-        res.json(sessions.list());
+    // GET /sessions — enrich with live branch from git (rate-limited to avoid spawning git on every poll)
+    const branchRefreshCache = new Map(); // sessionId -> last refresh timestamp
+    const BRANCH_REFRESH_INTERVAL_MS = 10_000;
+    app.get('/sessions', requireAuth, async (_req, res) => {
+        const allSessions = sessions.list();
+        const now = Date.now();
+        // Prune cache entries for sessions that no longer exist
+        const activeIds = new Set(allSessions.map((s) => s.id));
+        for (const sessionId of branchRefreshCache.keys()) {
+            if (!activeIds.has(sessionId))
+                branchRefreshCache.delete(sessionId);
+        }
+        await Promise.all(allSessions.map(async (s) => {
+            if (s.type !== 'repo' && s.type !== 'worktree')
+                return;
+            if (!s.repoPath)
+                return;
+            const lastRefresh = branchRefreshCache.get(s.id) ?? 0;
+            if (now - lastRefresh < BRANCH_REFRESH_INTERVAL_MS)
+                return;
+            const cwd = s.type === 'repo' ? s.repoPath : s.cwd;
+            if (!cwd)
+                return;
+            branchRefreshCache.set(s.id, now);
+            try {
+                const { stdout } = await execFileAsync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd });
+                const liveBranch = stdout.trim();
+                if (liveBranch && liveBranch !== s.branchName) {
+                    s.branchName = liveBranch;
+                    const raw = sessions.get(s.id);
+                    if (raw)
+                        raw.branchName = liveBranch;
+                }
+            }
+            catch { /* non-fatal */ }
+        }));
+        res.json(allSessions);
     });
     // GET /repos — scan root dirs for repos
     app.get('/repos', requireAuth, async (_req, res) => {
@@ -455,6 +594,50 @@ async function main() {
         await execFileAsync('tmux', ['-V']);
     });
     boolConfigEndpoints('defaultNotifications', true);
+    // GET /config/automations — get automation settings
+    app.get('/config/automations', requireAuth, (_req, res) => {
+        res.json(config.automations ?? {});
+    });
+    // PATCH /config/automations — update automation settings and start/stop poller
+    app.patch('/config/automations', requireAuth, (req, res) => {
+        const body = req.body;
+        const prev = config.automations ?? {};
+        const next = { ...prev };
+        if (typeof body.autoCheckoutReviewRequests === 'boolean') {
+            next.autoCheckoutReviewRequests = body.autoCheckoutReviewRequests;
+        }
+        if (typeof body.autoReviewOnCheckout === 'boolean') {
+            next.autoReviewOnCheckout = body.autoReviewOnCheckout;
+        }
+        if (typeof body.pollIntervalMs === 'number' && body.pollIntervalMs >= 60000) {
+            next.pollIntervalMs = body.pollIntervalMs;
+        }
+        // Enforce: auto-review requires auto-checkout
+        if (!next.autoCheckoutReviewRequests) {
+            next.autoReviewOnCheckout = false;
+        }
+        config.automations = next;
+        try {
+            saveConfig(CONFIG_PATH, config);
+        }
+        catch (err) {
+            config.automations = prev;
+            console.error('[config] Failed to save automation settings:', err);
+            res.status(500).json({ error: 'Failed to save settings' });
+            return;
+        }
+        // Start or stop poller based on new setting
+        void stopPolling().then(() => {
+            if (next.autoCheckoutReviewRequests) {
+                startPolling(buildPollerDeps());
+            }
+        });
+        res.json(next);
+    });
+    // GET /config/workspace-groups — return workspace group configuration
+    app.get('/config/workspace-groups', requireAuth, (_req, res) => {
+        res.json({ groups: config.workspaceGroups ?? {} });
+    });
     // GET /push/vapid-key
     app.get('/push/vapid-key', requireAuth, (_req, res) => {
         const key = push.getVapidPublicKey();
@@ -552,7 +735,7 @@ async function main() {
     });
     // POST /sessions
     app.post('/sessions', requireAuth, async (req, res) => {
-        const { repoPath, repoName, worktreePath, branchName, claudeArgs, yolo, agent, useTmux, cols, rows, needsBranchRename, branchRenamePrompt } = req.body;
+        const { repoPath, repoName, worktreePath, branchName, claudeArgs, yolo, agent, useTmux, cols, rows, needsBranchRename, branchRenamePrompt, ticketContext } = req.body;
         if (!repoPath) {
             res.status(400).json({ error: 'repoPath is required' });
             return;
@@ -563,6 +746,57 @@ async function main() {
         const resolved = resolveSessionSettings(config, repoPath, { agent, yolo, useTmux, claudeArgs });
         const resolvedAgent = resolved.agent;
         const name = repoName || repoPath.split('/').filter(Boolean).pop() || 'session';
+        let initialPrompt;
+        if (ticketContext && (typeof ticketContext.ticketId !== 'string' || typeof ticketContext.title !== 'string' || typeof ticketContext.url !== 'string')) {
+            res.status(400).json({ error: 'ticketContext requires string ticketId, title, and url' });
+            return;
+        }
+        if (ticketContext) {
+            // Validate source is a known integration
+            if (ticketContext.source !== 'github' && ticketContext.source !== 'jira' && ticketContext.source !== 'linear') {
+                res.status(400).json({ error: "ticketContext.source must be 'github', 'jira', or 'linear'" });
+                return;
+            }
+            // Validate repoPath is a configured workspace
+            const configuredWorkspaces = config.workspaces || [];
+            if (!configuredWorkspaces.includes(ticketContext.repoPath)) {
+                res.status(400).json({ error: 'ticketContext.repoPath is not a configured workspace' });
+                return;
+            }
+            // Validate integration is configured for the claimed source
+            if (ticketContext.source === 'jira') {
+                if (!process.env['JIRA_API_TOKEN'] || !process.env['JIRA_EMAIL'] || !process.env['JIRA_BASE_URL']) {
+                    res.status(400).json({ error: 'Jira integration is not configured' });
+                    return;
+                }
+            }
+            else if (ticketContext.source === 'linear') {
+                if (!process.env['LINEAR_API_KEY']) {
+                    res.status(400).json({ error: 'Linear integration is not configured' });
+                    return;
+                }
+            }
+            // Validate ticket ID format per source
+            if (ticketContext.source === 'github' && !/^GH-\d+$/.test(ticketContext.ticketId)) {
+                res.status(400).json({ error: 'ticketContext.ticketId for github must match GH-<number>' });
+                return;
+            }
+            if ((ticketContext.source === 'jira' || ticketContext.source === 'linear') && !/^[A-Z]+-\d+$/.test(ticketContext.ticketId)) {
+                res.status(400).json({ error: 'ticketContext.ticketId must match <PROJECT>-<number>' });
+                return;
+            }
+        }
+        if (ticketContext) {
+            // Use ticketContext.repoPath (workspace root) for settings lookup
+            const settings = config.workspaceSettings?.[ticketContext.repoPath];
+            const template = settings?.promptStartWork ??
+                'You are working on ticket {ticketId}: {title}\n\nTicket URL: {ticketUrl}\n\nPlease start by understanding the issue and proposing an approach.';
+            initialPrompt = template
+                .replace(/\{ticketId\}/g, ticketContext.ticketId)
+                .replace(/\{title\}/g, ticketContext.title)
+                .replace(/\{ticketUrl\}/g, ticketContext.url)
+                .replace(/\{description\}/g, ticketContext.description ?? '');
+        }
         const baseArgs = [
             ...(resolved.claudeArgs),
             ...(resolved.yolo ? AGENT_YOLO_ARGS[resolvedAgent] : []),
@@ -674,7 +908,13 @@ async function main() {
                                 useTmux: resolved.useTmux,
                                 ...(safeCols != null && { cols: safeCols }),
                                 ...(safeRows != null && { rows: safeRows }),
+                                ...(initialPrompt != null && { initialPrompt }),
                             });
+                            if (ticketContext) {
+                                transitionOnSessionCreate(ticketContext).catch((err) => {
+                                    console.error('[index] transition on session create failed:', err);
+                                });
+                            }
                             res.status(201).json(repoSession);
                             return;
                         }
@@ -700,6 +940,7 @@ async function main() {
                                 useTmux: resolved.useTmux,
                                 ...(safeCols != null && { cols: safeCols }),
                                 ...(safeRows != null && { rows: safeRows }),
+                                ...(initialPrompt != null && { initialPrompt }),
                             });
                             writeMeta(CONFIG_PATH, {
                                 worktreePath: sessionRepoPath,
@@ -707,6 +948,11 @@ async function main() {
                                 lastActivity: new Date().toISOString(),
                                 branchName: branchName || worktreeName,
                             });
+                            if (ticketContext) {
+                                transitionOnSessionCreate(ticketContext).catch((err) => {
+                                    console.error('[index] transition on session create failed:', err);
+                                });
+                            }
                             res.status(201).json(session);
                             return;
                         }
@@ -747,6 +993,7 @@ async function main() {
             ...(safeRows != null && { rows: safeRows }),
             needsBranchRename: isMountainName || (needsBranchRename ?? false),
             branchRenamePrompt: branchRenamePrompt ?? '',
+            ...(initialPrompt != null && { initialPrompt }),
         });
         if (!worktreePath) {
             writeMeta(CONFIG_PATH, {
@@ -756,6 +1003,11 @@ async function main() {
                 branchName: branchName || worktreeName,
             });
         }
+        if (ticketContext) {
+            transitionOnSessionCreate(ticketContext).catch((err) => {
+                console.error('[index] transition on session create failed:', err);
+            });
+        }
         res.status(201).json(session);
     });
     // POST /sessions/repo — start a session in the repo root (no worktree)
@@ -945,8 +1197,10 @@ async function main() {
     catch {
         // tmux not installed or no sessions — ignore
     }
-    function gracefulShutdown() {
+    async function gracefulShutdown() {
+        await stopPolling();
         closeAnalytics();
+        branchWatcher.close();
         server.close();
         // Serialize sessions to disk BEFORE killing them
         const configDir = path.dirname(CONFIG_PATH);

package/dist/server/integration-github.js ADDED Viewed

@@ -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;
+}