relay-ide 0.1.0

package/dist/test/server/review-poller.js

@@ -0,0 +1,218 @@
+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;
+// ─── Public API ───────────────────────────────────────────────────────────────
+export function startPolling(deps) {
+    if (timer !== null)
+        return;
+    const config = loadConfig(deps.configPath);
+    const intervalMs = config.automations?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    timer = setInterval(() => {
+        void pollOnce(deps);
+    }, intervalMs);
+}
+export function stopPolling() {
+    if (timer !== null) {
+        clearInterval(timer);
+        timer = null;
+    }
+}
+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 {
+            // Not a git repo or no remote — skip
+        }
+    }
+    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;
+        // Default to "now" on first run to avoid processing all historical notifications
+        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 = [];
+            for (const line of lines) {
+                try {
+                    notifications.push(JSON.parse(line));
+                }
+                catch {
+                    // gh may output non-JSON warnings mixed with results — skip
+                }
+            }
+        }
+        catch (err) {
+            const error = err;
+            if (error.code === 'ENOENT') {
+                if (!ghMissingWarned) {
+                    console.warn('[review-poller] gh CLI not found — stopping poller');
+                    ghMissingWarned = true;
+                }
+                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
+        config.automations = {
+            ...config.automations,
+            lastPollTimestamp: new Date().toISOString(),
+        };
+        try {
+            saveConfig(deps.configPath, config);
+        }
+        catch (err) {
+            console.warn('[review-poller] Failed to save config after poll:', err);
+        }
+    }
+    finally {
+        pollInFlight = false;
+    }
+}

package/dist/test/server/service.js

@@ -0,0 +1,169 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execSync } from 'node:child_process';
+import { DEFAULTS } from './config.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const SERVICE_LABEL = 'com.claude-remote-cli';
+const HOME = process.env.HOME || process.env.USERPROFILE || '~';
+const CONFIG_DIR = path.join(HOME, '.config', 'claude-remote-cli');
+function getPlatform() {
+    if (process.platform === 'darwin')
+        return 'macos';
+    if (process.platform === 'linux')
+        return 'linux';
+    throw new Error('Unsupported platform: ' + process.platform + '. Only macOS and Linux are supported.');
+}
+function getServicePaths() {
+    const platform = getPlatform();
+    if (platform === 'macos') {
+        return {
+            servicePath: path.join(HOME, 'Library', 'LaunchAgents', SERVICE_LABEL + '.plist'),
+            logDir: path.join(CONFIG_DIR, 'logs'),
+            label: SERVICE_LABEL,
+        };
+    }
+    return {
+        servicePath: path.join(HOME, '.config', 'systemd', 'user', 'claude-remote-cli.service'),
+        logDir: null,
+        label: 'claude-remote-cli',
+    };
+}
+function generateServiceFile(platform, opts) {
+    const { nodePath, scriptPath, configPath, port, host, logDir } = opts;
+    if (platform === 'macos') {
+        return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${SERVICE_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodePath}</string>
+    <string>${scriptPath}</string>
+    <string>--config</string>
+    <string>${configPath}</string>
+    <string>--port</string>
+    <string>${port}</string>
+    <string>--host</string>
+    <string>${host}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${path.join(logDir, 'stdout.log')}</string>
+  <key>StandardErrorPath</key>
+  <string>${path.join(logDir, 'stderr.log')}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${process.env.PATH}</string>
+  </dict>
+</dict>
+</plist>`;
+    }
+    return `[Unit]
+Description=Claude Remote CLI
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${nodePath} ${scriptPath} --config ${configPath} --port ${port} --host ${host}
+Restart=on-failure
+RestartSec=5
+Environment=PATH=${process.env.PATH}
+
+[Install]
+WantedBy=default.target`;
+}
+function isInstalled() {
+    const { servicePath } = getServicePaths();
+    return fs.existsSync(servicePath);
+}
+function install(opts) {
+    const platform = getPlatform();
+    const { servicePath, logDir } = getServicePaths();
+    if (isInstalled()) {
+        throw new Error('Service is already installed. Run `claude-remote-cli uninstall` first.');
+    }
+    const nodePath = process.execPath;
+    const scriptPath = path.resolve(__dirname, '..', 'bin', 'claude-remote-cli.js');
+    const configPath = opts.configPath || path.join(CONFIG_DIR, 'config.json');
+    const port = opts.port || String(DEFAULTS.port);
+    const host = opts.host || DEFAULTS.host;
+    const content = generateServiceFile(platform, { nodePath, scriptPath, configPath, port, host, logDir });
+    fs.mkdirSync(path.dirname(servicePath), { recursive: true });
+    if (logDir)
+        fs.mkdirSync(logDir, { recursive: true });
+    fs.writeFileSync(servicePath, content, 'utf8');
+    if (platform === 'macos') {
+        execSync('launchctl load -w ' + servicePath, { stdio: 'inherit' });
+    }
+    else {
+        execSync('systemctl --user daemon-reload', { stdio: 'inherit' });
+        execSync('systemctl --user enable --now claude-remote-cli', { stdio: 'inherit' });
+    }
+    console.log('Service installed and started.');
+    if (logDir) {
+        console.log('Logs: ' + logDir);
+    }
+    else {
+        console.log('Logs: journalctl --user -u claude-remote-cli -f');
+    }
+}
+function uninstall() {
+    const platform = getPlatform();
+    const { servicePath } = getServicePaths();
+    if (!isInstalled()) {
+        throw new Error('Service is not installed.');
+    }
+    if (platform === 'macos') {
+        try {
+            execSync('launchctl unload ' + servicePath, { stdio: 'inherit' });
+        }
+        catch (_) {
+            // Ignore errors from already-unloaded services
+        }
+    }
+    else {
+        try {
+            execSync('systemctl --user disable --now claude-remote-cli', { stdio: 'inherit' });
+        }
+        catch (_) {
+            // Ignore errors from already-disabled services
+        }
+    }
+    fs.unlinkSync(servicePath);
+    console.log('Service uninstalled.');
+}
+function status() {
+    const platform = getPlatform();
+    if (!isInstalled()) {
+        return { installed: false, running: false };
+    }
+    const running = checkRunning(platform);
+    return { installed: true, running };
+}
+function checkRunning(platform) {
+    if (platform === 'macos') {
+        try {
+            const out = execSync('launchctl list ' + SERVICE_LABEL, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+            return !out.includes('"LastExitStatus" = -1');
+        }
+        catch (_) {
+            return false;
+        }
+    }
+    try {
+        execSync('systemctl --user is-active claude-remote-cli', { stdio: ['pipe', 'pipe', 'pipe'] });
+        return true;
+    }
+    catch (_) {
+        return false;
+    }
+}
+export { getPlatform, getServicePaths, generateServiceFile, isInstalled, install, uninstall, status, SERVICE_LABEL, CONFIG_DIR };