@teamvibe/poller 0.1.12 → 0.1.14

package/README.md

@@ -0,0 +1,84 @@
+# @teamvibe/poller
+
+Self-hosted poller that connects your Slack workspace to Claude Code via TeamVibe.
+
+## Prerequisites
+
+- **Node.js** 20+
+- **Claude Code CLI** (`claude`) installed and authenticated
+- A **TeamVibe poller token** (get one from the TeamVibe dashboard)
+
+## Quick Start
+
+### Install as a macOS service (recommended)
+
+```bash
+npx @teamvibe/poller install
+```
+
+The interactive installer will:
+1. Prompt for your `TEAMVIBE_POLLER_TOKEN`
+2. Prompt for your `CLAUDE_CODE_OAUTH_TOKEN` (or auto-detect it)
+3. Configure optional settings (API URL, max concurrent sessions)
+4. Detect your `claude` CLI path
+5. Install the package globally (if needed) for a stable service path
+6. Create `~/.teamvibe/.env` with your configuration
+7. Install and start a launchd service that runs automatically on login
+
+### Run directly
+
+```bash
+npx @teamvibe/poller
+```
+
+Make sure `~/.teamvibe/.env` exists with at least `TEAMVIBE_POLLER_TOKEN` set.
+
+## Updating
+
+```bash
+npx @teamvibe/poller update
+```
+
+This updates the global installation to the latest version and restarts the service if installed.
+
+## Service Management
+
+```bash
+poller status     # Check if the service is running
+poller stop       # Stop the service
+poller start      # Start the service
+poller restart    # Restart the service
+poller uninstall  # Remove the service
+```
+
+## Logs
+
+When running as a service, logs are written to:
+
+```
+~/.teamvibe/logs/poller.stdout.log
+~/.teamvibe/logs/poller.stderr.log
+```
+
+Follow logs in real-time:
+
+```bash
+tail -f ~/.teamvibe/logs/poller.stdout.log
+```
+
+## Configuration
+
+All configuration is via environment variables (or `~/.teamvibe/.env`):
+
+| Variable | Required | Default | Description |
+|----------|----------|---------|-------------|
+| `TEAMVIBE_POLLER_TOKEN` | Yes | — | Your poller authentication token |
+| `CLAUDE_CODE_OAUTH_TOKEN` | No | — | Claude Code OAuth token (from `claude setup-token`) |
+| `TEAMVIBE_API_URL` | No | `https://poller.api.teamvibe.ai` | API endpoint |
+| `MAX_CONCURRENT_SESSIONS` | No | `5` | Max parallel Claude sessions |
+| `CLAUDE_CLI_PATH` | No | `claude` | Path to Claude Code CLI |
+| `TEAMVIBE_DATA_DIR` | No | `~/.teamvibe` | Data directory for brains and state |
+
+## How It Works
+
+The poller authenticates with the TeamVibe API using your token, then continuously polls an SQS queue for incoming messages from Slack. When a message arrives, it spawns a Claude Code session with the appropriate brain (knowledge base) and streams the response back to Slack.

package/dist/claude-spawner.js

@@ -275,20 +275,21 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
 }
 export async function spawnClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = true, lastMessageTs, onMessageSent) {
     const result = await runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage, lastMessageTs, onMessageSent);
-    // If session ID is "already in use" (stale lock file), retry with no session ID (let Claude generate a new one)
-    if (!result.success && sessionId && result.error?.includes('already in use')) {
-        sessionLog.info('Session ID already in use (stale lock), retrying without session ID');
-        const { randomUUID } = await import('crypto');
-        const freshId = randomUUID();
-        const retryResult = await runClaudeCode(msg, sessionLog, cwd, freshId, true, lastMessageTs, onMessageSent);
-        return { ...retryResult, newSessionId: freshId };
-    }
     // If --resume failed, retry as a fresh session (session files may have been lost on container restart)
+    let retryResult = result;
     if (!result.success && sessionId && !isFirstMessage) {
         sessionLog.info('Resume failed, retrying as fresh session (session files may have been lost)');
-        return runClaudeCode(msg, sessionLog, cwd, sessionId, true, lastMessageTs, onMessageSent);
+        retryResult = await runClaudeCode(msg, sessionLog, cwd, sessionId, true, lastMessageTs, onMessageSent);
+    }
+    // If session ID is "already in use" (stale lock file), retry with a fresh session ID
+    if (!retryResult.success && sessionId && retryResult.error?.includes('already in use')) {
+        sessionLog.info('Session ID already in use (stale lock), retrying with fresh session ID');
+        const { randomUUID } = await import('crypto');
+        const freshId = randomUUID();
+        const freshResult = await runClaudeCode(msg, sessionLog, cwd, freshId, true, lastMessageTs, onMessageSent);
+        return { ...freshResult, newSessionId: freshId };
     }
-    return result;
+    return retryResult;
 }
 const activeProcesses = new Map();
 export function getActiveProcessCount() {

package/dist/cli/commands.d.ts

@@ -0,0 +1 @@
+export declare function handleCommand(command: string): Promise<void>;

package/dist/cli/commands.js

@@ -0,0 +1,59 @@
+import { install } from './install.js';
+import { uninstall } from './uninstall.js';
+import { update } from './update.js';
+import { logs } from './logs.js';
+import { start, stop, restart, status } from './service.js';
+function showHelp() {
+    console.log(`TeamVibe Poller
+
+Usage: poller [command]
+
+Commands:
+  (no command)    Start the poller (default)
+  install         Install as a macOS launchd service (interactive)
+  uninstall       Remove the launchd service
+  update          Update to the latest version and restart
+  start           Start the installed service
+  stop            Stop the installed service
+  restart         Restart the installed service
+  status          Show service status
+  logs            Tail service logs
+  --help, -h      Show this help message
+`);
+}
+export async function handleCommand(command) {
+    switch (command) {
+        case 'install':
+            await install();
+            break;
+        case 'uninstall':
+            await uninstall();
+            break;
+        case 'update':
+            update();
+            break;
+        case 'logs':
+            logs();
+            break;
+        case 'start':
+            start();
+            break;
+        case 'stop':
+            stop();
+            break;
+        case 'restart':
+            restart();
+            break;
+        case 'status':
+            status();
+            break;
+        case '--help':
+        case '-h':
+            showHelp();
+            break;
+        default:
+            console.error(`Unknown command: ${command}`);
+            showHelp();
+            process.exit(1);
+    }
+}

package/dist/cli/install.d.ts

@@ -0,0 +1 @@
+export declare function install(): Promise<void>;

package/dist/cli/install.js

@@ -0,0 +1,196 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import { prompt, confirm } from './prompt.js';
+import { generatePlist, PLIST_PATH, TEAMVIBE_DIR, LOGS_DIR, SERVICE_LABEL } from './plist.js';
+function tryGetClaudeSetupToken() {
+    try {
+        const result = execSync('claude setup-token 2>/dev/null', {
+            encoding: 'utf-8',
+            timeout: 15000,
+        }).trim();
+        if (result)
+            return result;
+    }
+    catch {
+        // Not available
+    }
+    return null;
+}
+export async function install() {
+    if (process.platform !== 'darwin') {
+        console.error('Error: Service installation is only supported on macOS.');
+        process.exit(1);
+    }
+    console.log('TeamVibe Poller - Service Installation\n');
+    // Check if already installed
+    if (fs.existsSync(PLIST_PATH)) {
+        const overwrite = await confirm('Service is already installed. Overwrite?', false);
+        if (!overwrite) {
+            console.log('Aborted.');
+            return;
+        }
+        // Unload existing service
+        try {
+            execSync(`launchctl unload "${PLIST_PATH}" 2>/dev/null`, { stdio: 'ignore' });
+        }
+        catch {
+            // Ignore if not loaded
+        }
+    }
+    // Load existing .env values as defaults
+    const existingEnv = loadExistingEnv();
+    // Collect configuration
+    console.log('Step 1: Poller Token\n');
+    console.log('  Get your token from the TeamVibe dashboard (Pollers > Setup Instructions).');
+    console.log('  If you lost it, use "Regenerate Token" from the poller menu.\n');
+    const token = await prompt('TEAMVIBE_POLLER_TOKEN', existingEnv['TEAMVIBE_POLLER_TOKEN']);
+    if (!token) {
+        console.error('\nError: TEAMVIBE_POLLER_TOKEN is required.');
+        process.exit(1);
+    }
+    console.log('\nStep 2: Claude Code Authentication\n');
+    console.log('  The poller needs Claude Code credentials to run AI sessions.');
+    console.log('  Run `claude setup-token` in a terminal to generate a token.\n');
+    let claudeOAuthToken = existingEnv['CLAUDE_CODE_OAUTH_TOKEN'] || '';
+    const autoToken = tryGetClaudeSetupToken();
+    if (autoToken) {
+        console.log('  Auto-detected Claude setup token.');
+        const useAuto = await confirm('  Use the detected token?');
+        if (useAuto) {
+            claudeOAuthToken = autoToken;
+        }
+    }
+    if (!claudeOAuthToken) {
+        claudeOAuthToken = await prompt('CLAUDE_CODE_OAUTH_TOKEN');
+    }
+    console.log('\nStep 3: Optional Settings\n');
+    const apiUrl = await prompt('TEAMVIBE_API_URL', existingEnv['TEAMVIBE_API_URL'] || 'https://poller.api.teamvibe.ai');
+    const maxConcurrent = await prompt('MAX_CONCURRENT_SESSIONS', existingEnv['MAX_CONCURRENT_SESSIONS'] || '5');
+    // Resolve claude CLI path
+    console.log('\nStep 4: Detecting paths\n');
+    let claudePath = '';
+    try {
+        claudePath = execSync('which claude', { encoding: 'utf-8' }).trim();
+    }
+    catch {
+        // Not found
+    }
+    if (!claudePath) {
+        claudePath = await prompt('Path to claude CLI (not found in PATH)');
+        if (!claudePath) {
+            console.error('Error: claude CLI path is required.');
+            process.exit(1);
+        }
+    }
+    else {
+        console.log(`  Found claude CLI at: ${claudePath}`);
+    }
+    // Resolve node and poller paths
+    const nodePath = process.execPath;
+    let pollerPath = path.resolve(process.argv[1] ?? '.');
+    // Detect if running via npx (temporary cache path) — need a stable path for launchd
+    const isNpx = pollerPath.includes('/_npx/') || pollerPath.includes('\\_npx\\');
+    if (isNpx) {
+        console.log('\n  Detected npx execution — installing globally for a stable service path...');
+        try {
+            execSync('npm install -g @teamvibe/poller', { stdio: 'inherit' });
+            const globalPollerPath = execSync('which poller', { encoding: 'utf-8' }).trim();
+            if (globalPollerPath) {
+                // Resolve the actual script behind the bin symlink
+                const realBin = fs.realpathSync(globalPollerPath);
+                pollerPath = realBin;
+                console.log(`  Installed globally: ${pollerPath}`);
+            }
+        }
+        catch {
+            console.error('\n  Warning: Could not install globally. The service may not start after reboot.');
+            console.error('  Run `npm install -g @teamvibe/poller` manually, then re-run `poller install`.');
+            const cont = await confirm('  Continue anyway?', false);
+            if (!cont)
+                return;
+        }
+    }
+    console.log(`  Node path: ${nodePath}`);
+    console.log(`  Poller path: ${pollerPath}`);
+    // Create directories
+    fs.mkdirSync(TEAMVIBE_DIR, { recursive: true });
+    fs.mkdirSync(LOGS_DIR, { recursive: true });
+    // Write .env file
+    const envPath = path.join(TEAMVIBE_DIR, '.env');
+    const envLines = [
+        `TEAMVIBE_POLLER_TOKEN=${token}`,
+        `TEAMVIBE_API_URL=${apiUrl}`,
+        `MAX_CONCURRENT_SESSIONS=${maxConcurrent}`,
+        `CLAUDE_CLI_PATH=${claudePath}`,
+    ];
+    if (claudeOAuthToken) {
+        envLines.push(`CLAUDE_CODE_OAUTH_TOKEN=${claudeOAuthToken}`);
+    }
+    let writeEnv = true;
+    if (fs.existsSync(envPath)) {
+        writeEnv = await confirm('\n.env file already exists. Overwrite?', false);
+        if (!writeEnv) {
+            console.log('Keeping existing .env file.');
+        }
+    }
+    if (writeEnv) {
+        fs.writeFileSync(envPath, envLines.join('\n') + '\n');
+        console.log(`\nWrote ${envPath}`);
+    }
+    // Build PATH that includes common locations for claude CLI
+    const pathDirs = new Set();
+    const claudeDir = path.dirname(claudePath);
+    pathDirs.add(claudeDir);
+    pathDirs.add('/opt/homebrew/bin');
+    pathDirs.add('/usr/local/bin');
+    pathDirs.add('/usr/bin');
+    pathDirs.add('/bin');
+    const plistEnvVars = {
+        PATH: Array.from(pathDirs).join(':'),
+    };
+    // Write plist
+    const plistContent = generatePlist(nodePath, pollerPath, plistEnvVars);
+    const launchAgentsDir = path.dirname(PLIST_PATH);
+    fs.mkdirSync(launchAgentsDir, { recursive: true });
+    fs.writeFileSync(PLIST_PATH, plistContent);
+    console.log(`Wrote ${PLIST_PATH}`);
+    // Load service
+    try {
+        execSync(`launchctl load "${PLIST_PATH}"`);
+        console.log(`\nService '${SERVICE_LABEL}' installed and started.`);
+        console.log(`\nUseful commands:`);
+        console.log(`  poller status   - Check service status`);
+        console.log(`  poller stop     - Stop the service`);
+        console.log(`  poller start    - Start the service`);
+        console.log(`  poller restart  - Restart the service`);
+        console.log(`  poller uninstall - Remove the service`);
+        console.log(`\nLogs:`);
+        console.log(`  tail -f ${path.join(LOGS_DIR, 'poller.stdout.log')}`);
+        console.log(`  tail -f ${path.join(LOGS_DIR, 'poller.stderr.log')}`);
+    }
+    catch (error) {
+        console.error(`Failed to load service: ${error instanceof Error ? error.message : error}`);
+        console.log(`You can manually load it with: launchctl load "${PLIST_PATH}"`);
+    }
+}
+function loadExistingEnv() {
+    const envPath = path.join(TEAMVIBE_DIR, '.env');
+    const result = {};
+    try {
+        const content = fs.readFileSync(envPath, 'utf-8');
+        for (const line of content.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            const eqIdx = trimmed.indexOf('=');
+            if (eqIdx > 0) {
+                result[trimmed.slice(0, eqIdx)] = trimmed.slice(eqIdx + 1);
+            }
+        }
+    }
+    catch {
+        // No existing file
+    }
+    return result;
+}

package/dist/cli/logs.d.ts

@@ -0,0 +1 @@
+export declare function logs(): void;

package/dist/cli/logs.js

@@ -0,0 +1,23 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { spawn } from 'child_process';
+import { LOGS_DIR } from './plist.js';
+export function logs() {
+    const stdoutLog = path.join(LOGS_DIR, 'poller.stdout.log');
+    const stderrLog = path.join(LOGS_DIR, 'poller.stderr.log');
+    const filesToTail = [];
+    if (fs.existsSync(stdoutLog))
+        filesToTail.push(stdoutLog);
+    if (fs.existsSync(stderrLog))
+        filesToTail.push(stderrLog);
+    if (filesToTail.length === 0) {
+        console.error(`No log files found in ${LOGS_DIR}`);
+        console.error('Is the service installed? Run `poller install` first.');
+        process.exit(1);
+    }
+    const tail = spawn('tail', ['-f', ...filesToTail], { stdio: 'inherit' });
+    process.on('SIGINT', () => {
+        tail.kill();
+        process.exit(0);
+    });
+}

package/dist/cli/plist.d.ts

@@ -0,0 +1,5 @@
+export declare const SERVICE_LABEL = "ai.teamvibe.poller";
+export declare const PLIST_PATH: string;
+export declare const TEAMVIBE_DIR: string;
+export declare const LOGS_DIR: string;
+export declare function generatePlist(nodePath: string, pollerPath: string, envVars?: Record<string, string>): string;

package/dist/cli/plist.js

@@ -0,0 +1,60 @@
+import * as path from 'path';
+import * as os from 'os';
+export const SERVICE_LABEL = 'ai.teamvibe.poller';
+export const PLIST_PATH = path.join(os.homedir(), 'Library', 'LaunchAgents', `${SERVICE_LABEL}.plist`);
+export const TEAMVIBE_DIR = path.join(os.homedir(), '.teamvibe');
+export const LOGS_DIR = path.join(TEAMVIBE_DIR, 'logs');
+export function generatePlist(nodePath, pollerPath, envVars) {
+    let envSection = '';
+    if (envVars && Object.keys(envVars).length > 0) {
+        const entries = Object.entries(envVars)
+            .map(([key, value]) => `      <key>${escapeXml(key)}</key>\n      <string>${escapeXml(value)}</string>`)
+            .join('\n');
+        envSection = `
+    <key>EnvironmentVariables</key>
+    <dict>
+${entries}
+    </dict>`;
+    }
+    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>${escapeXml(nodePath)}</string>
+        <string>${escapeXml(pollerPath)}</string>
+    </array>
+
+    <key>WorkingDirectory</key>
+    <string>${escapeXml(TEAMVIBE_DIR)}</string>${envSection}
+
+    <key>KeepAlive</key>
+    <true/>
+
+    <key>RunAtLoad</key>
+    <true/>
+
+    <key>ThrottleInterval</key>
+    <integer>10</integer>
+
+    <key>StandardOutPath</key>
+    <string>${escapeXml(path.join(LOGS_DIR, 'poller.stdout.log'))}</string>
+
+    <key>StandardErrorPath</key>
+    <string>${escapeXml(path.join(LOGS_DIR, 'poller.stderr.log'))}</string>
+</dict>
+</plist>
+`;
+}
+function escapeXml(str) {
+    return str
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}

package/dist/cli/prompt.d.ts

@@ -0,0 +1,2 @@
+export declare function prompt(question: string, defaultValue?: string): Promise<string>;
+export declare function confirm(question: string, defaultYes?: boolean): Promise<boolean>;

package/dist/cli/prompt.js

@@ -0,0 +1,22 @@
+import * as readline from 'readline';
+export function prompt(question, defaultValue) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const suffix = defaultValue ? ` [${defaultValue}]` : '';
+    return new Promise((resolve) => {
+        rl.question(`${question}${suffix}: `, (answer) => {
+            rl.close();
+            resolve(answer.trim() || defaultValue || '');
+        });
+    });
+}
+export function confirm(question, defaultYes = true) {
+    const hint = defaultYes ? '[Y/n]' : '[y/N]';
+    return prompt(`${question} ${hint}`).then((answer) => {
+        if (!answer)
+            return defaultYes;
+        return answer.toLowerCase().startsWith('y');
+    });
+}

package/dist/cli/service.d.ts

@@ -0,0 +1,4 @@
+export declare function start(): void;
+export declare function stop(): void;
+export declare function restart(): void;
+export declare function status(): void;

package/dist/cli/service.js

@@ -0,0 +1,86 @@
+import * as fs from 'fs';
+import { execSync } from 'child_process';
+import { PLIST_PATH, SERVICE_LABEL } from './plist.js';
+function ensureInstalled() {
+    if (process.platform !== 'darwin') {
+        console.error('Error: Service management is only supported on macOS.');
+        process.exit(1);
+    }
+    if (!fs.existsSync(PLIST_PATH)) {
+        console.error('Service is not installed. Run `poller install` first.');
+        process.exit(1);
+    }
+}
+export function start() {
+    ensureInstalled();
+    try {
+        execSync(`launchctl load "${PLIST_PATH}"`);
+        console.log(`Service '${SERVICE_LABEL}' started.`);
+    }
+    catch (error) {
+        console.error(`Failed to start: ${error instanceof Error ? error.message : error}`);
+        console.log('The service may already be running. Check with `poller status`.');
+    }
+}
+export function stop() {
+    ensureInstalled();
+    try {
+        execSync(`launchctl unload "${PLIST_PATH}"`);
+        console.log(`Service '${SERVICE_LABEL}' stopped.`);
+    }
+    catch (error) {
+        console.error(`Failed to stop: ${error instanceof Error ? error.message : error}`);
+    }
+}
+export function restart() {
+    ensureInstalled();
+    try {
+        execSync(`launchctl unload "${PLIST_PATH}" 2>/dev/null`, { stdio: 'ignore' });
+    }
+    catch {
+        // Ignore
+    }
+    try {
+        execSync(`launchctl load "${PLIST_PATH}"`);
+        console.log(`Service '${SERVICE_LABEL}' restarted.`);
+    }
+    catch (error) {
+        console.error(`Failed to restart: ${error instanceof Error ? error.message : error}`);
+    }
+}
+export function status() {
+    if (process.platform !== 'darwin') {
+        console.error('Error: Service management is only supported on macOS.');
+        process.exit(1);
+    }
+    if (!fs.existsSync(PLIST_PATH)) {
+        console.log('Service is not installed.');
+        return;
+    }
+    try {
+        const output = execSync(`launchctl list | grep "${SERVICE_LABEL}"`, {
+            encoding: 'utf-8',
+        }).trim();
+        if (output) {
+            const parts = output.split('\t');
+            const pid = parts[0];
+            const lastExitStatus = parts[1];
+            if (pid && pid !== '-') {
+                console.log(`Service '${SERVICE_LABEL}' is running (PID: ${pid})`);
+            }
+            else {
+                console.log(`Service '${SERVICE_LABEL}' is loaded but not running`);
+                if (lastExitStatus && lastExitStatus !== '0') {
+                    console.log(`Last exit status: ${lastExitStatus}`);
+                }
+            }
+        }
+        else {
+            console.log(`Service '${SERVICE_LABEL}' is installed but not loaded.`);
+        }
+    }
+    catch {
+        console.log(`Service '${SERVICE_LABEL}' is installed but not loaded.`);
+        console.log(`Start it with: poller start`);
+    }
+}

package/dist/cli/uninstall.d.ts

@@ -0,0 +1 @@
+export declare function uninstall(): Promise<void>;

package/dist/cli/uninstall.js

@@ -0,0 +1,37 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import { confirm } from './prompt.js';
+import { PLIST_PATH, TEAMVIBE_DIR, SERVICE_LABEL } from './plist.js';
+export async function uninstall() {
+    if (process.platform !== 'darwin') {
+        console.error('Error: Service management is only supported on macOS.');
+        process.exit(1);
+    }
+    if (!fs.existsSync(PLIST_PATH)) {
+        console.log('Service is not installed.');
+        return;
+    }
+    console.log('TeamVibe Poller - Service Uninstall\n');
+    // Unload service
+    try {
+        execSync(`launchctl unload "${PLIST_PATH}"`);
+        console.log('Service stopped.');
+    }
+    catch {
+        console.log('Service was not running.');
+    }
+    // Remove plist
+    fs.unlinkSync(PLIST_PATH);
+    console.log(`Removed ${PLIST_PATH}`);
+    // Optionally remove .env
+    const envPath = path.join(TEAMVIBE_DIR, '.env');
+    if (fs.existsSync(envPath)) {
+        const removeEnv = await confirm('Remove ~/.teamvibe/.env file?', false);
+        if (removeEnv) {
+            fs.unlinkSync(envPath);
+            console.log(`Removed ${envPath}`);
+        }
+    }
+    console.log(`\nService '${SERVICE_LABEL}' has been uninstalled.`);
+}

package/dist/cli/update.d.ts

@@ -0,0 +1 @@
+export declare function update(): void;

package/dist/cli/update.js

@@ -0,0 +1,34 @@
+import * as fs from 'fs';
+import { execSync } from 'child_process';
+import { PLIST_PATH, SERVICE_LABEL } from './plist.js';
+export function update() {
+    console.log('TeamVibe Poller - Update\n');
+    console.log('Updating @teamvibe/poller...');
+    try {
+        execSync('npm install -g @teamvibe/poller@latest', { stdio: 'inherit' });
+    }
+    catch {
+        console.error('Failed to update. Try running: npm install -g @teamvibe/poller@latest');
+        process.exit(1);
+    }
+    // Restart the service if installed
+    if (process.platform === 'darwin' && fs.existsSync(PLIST_PATH)) {
+        console.log(`\nRestarting service '${SERVICE_LABEL}'...`);
+        try {
+            execSync(`launchctl unload "${PLIST_PATH}" 2>/dev/null`, { stdio: 'ignore' });
+        }
+        catch {
+            // Ignore
+        }
+        try {
+            execSync(`launchctl load "${PLIST_PATH}"`);
+            console.log('Service restarted.');
+        }
+        catch (error) {
+            console.error(`Failed to restart: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    else {
+        console.log('\nUpdate complete. Restart the poller to use the new version.');
+    }
+}

package/dist/index.js

@@ -1,265 +1,11 @@
 #!/usr/bin/env node
-import { config } from './config.js';
-import { logger } from './logger.js';
-import { pollMessages, deleteMessage, extendVisibility, } from './sqs-poller.js';
-import { spawnClaudeCode, isAtCapacity, getActiveProcessCount } from './claude-spawner.js';
-import { sendSlackError, addReaction, getUserInfo, startTypingIndicator } from './slack-client.js';
-import { acquireSessionLock, releaseSessionLock, updateSessionId } from './session-store.js';
-import { getBrainPath, ensureDirectories, ensureBaseBrain, pushBrainChanges } from './brain-manager.js';
-import { initAuth, stopRefresh } from './auth-provider.js';
-logger.info('TeamVibe Poller starting...');
-logger.info(`   Max concurrent: ${config.MAX_CONCURRENT_SESSIONS}`);
-logger.info(`   Brains path: ${config.BRAINS_PATH}`);
-// Track active message processing
-const processingMessages = new Set();
-// Per-thread completion signals
-const threadCompletionSignals = new Map();
-const waitingCountByThread = new Map();
-function getQueueStats() {
-    let totalWaiting = 0;
-    waitingCountByThread.forEach((count) => {
-        totalWaiting += count;
-    });
-    return {
-        processing: processingMessages.size,
-        threadsWithWaiting: waitingCountByThread.size,
-        totalWaiting,
-    };
+const command = process.argv[2];
+if (command && ['install', 'uninstall', 'update', 'logs', 'status', 'start', 'stop', 'restart', '--help', '-h'].includes(command)) {
+    const { handleCommand } = await import('./cli/commands.js');
+    await handleCommand(command);
 }
-function logQueueState(context) {
-    const stats = getQueueStats();
-    logger.info(`[Queue] ${context} | Processing: ${stats.processing}, Threads with waiting: ${stats.threadsWithWaiting}, Total waiting: ${stats.totalWaiting}`);
+else {
+    const { startPoller } = await import('./poller.js');
+    await startPoller();
 }
-function waitForThreadCompletion(threadId) {
-    return new Promise((resolve) => {
-        const signals = threadCompletionSignals.get(threadId) || [];
-        signals.push(resolve);
-        threadCompletionSignals.set(threadId, signals);
-        const currentCount = waitingCountByThread.get(threadId) || 0;
-        waitingCountByThread.set(threadId, currentCount + 1);
-        logger.info(`[Queue] Thread ${threadId}: ${currentCount + 1} message(s) now waiting`);
-        logQueueState('After enqueue');
-    });
-}
-function signalThreadCompletion(threadId) {
-    const signals = threadCompletionSignals.get(threadId);
-    const waitingCount = signals?.length || 0;
-    if (signals && signals.length > 0) {
-        logger.info(`[Queue] Thread ${threadId} completed, waking ${waitingCount} waiting message(s)`);
-        signals.forEach((resolve) => resolve());
-        threadCompletionSignals.delete(threadId);
-        waitingCountByThread.delete(threadId);
-        logQueueState('After signal');
-    }
-}
-function startHeartbeat(receiptHandle, sessionLog) {
-    return setInterval(async () => {
-        try {
-            await extendVisibility(receiptHandle, config.VISIBILITY_TIMEOUT_SECONDS);
-            sessionLog.info(`Heartbeat: extended visibility by ${config.VISIBILITY_TIMEOUT_SECONDS}s`);
-        }
-        catch (error) {
-            sessionLog.error(`Heartbeat failed: ${error instanceof Error ? error.message : error}`);
-        }
-    }, config.HEARTBEAT_INTERVAL_MS);
-}
-async function processMessage(received) {
-    const { queueMessage, receiptHandle, messageId } = received;
-    const logSessionId = messageId.slice(0, 8);
-    const threadId = queueMessage.thread_id;
-    const sessionLog = logger.createSession(logSessionId);
-    // Fetch user info if we only have ID
-    if (queueMessage.source !== 'cron' &&
-        queueMessage.sender.name === 'Unknown User' &&
-        queueMessage.sender.id !== 'unknown') {
-        const userInfo = await getUserInfo(queueMessage.teamvibe.botToken, queueMessage.sender.id);
-        queueMessage.sender.name = userInfo.realName;
-        sessionLog.info(`Resolved user: ${userInfo.realName} (@${userInfo.name})`);
-    }
-    sessionLog.info(`Processing message from ${queueMessage.sender.name} (${queueMessage.sender.id})`);
-    sessionLog.info(`Thread: ${threadId}`);
-    sessionLog.info(`Brain: ${queueMessage.teamvibe.brain?.brainId ?? 'none'}`);
-    sessionLog.info(`Type: ${queueMessage.type}`);
-    sessionLog.info(`Log file: ${sessionLog.getLogFile()}`);
-    const hasSlackContext = Boolean(queueMessage.response_context.slack?.channel &&
-        queueMessage.response_context.slack?.message_ts);
-    // Get brain path for this channel
-    let kbPath;
-    try {
-        kbPath = await getBrainPath(queueMessage.teamvibe.brain);
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        sessionLog.error(`Failed to clone brain: ${errorMessage}`);
-        if (hasSlackContext) {
-            try {
-                await sendSlackError(queueMessage, `Failed to clone brain repository: ${errorMessage}`);
-                await addReaction(queueMessage, 'x');
-            }
-            catch (slackError) {
-                sessionLog.error(`Failed to send Slack error: ${slackError}`);
-            }
-        }
-        await deleteMessage(receiptHandle);
-        return;
-    }
-    // Try to acquire session lock
-    let lockResult = await acquireSessionLock(threadId, kbPath);
-    if (!lockResult.success) {
-        sessionLog.info(`Session ${threadId} is processing, waiting for completion...`);
-        const waitHeartbeat = startHeartbeat(receiptHandle, sessionLog);
-        try {
-            await waitForThreadCompletion(threadId);
-            sessionLog.info(`Thread ${threadId} completed, retrying lock acquisition`);
-            lockResult = await acquireSessionLock(threadId, kbPath);
-            if (!lockResult.success) {
-                sessionLog.info('Lock still held, re-queuing for next completion');
-                clearInterval(waitHeartbeat);
-                return processMessage(received);
-            }
-        }
-        finally {
-            clearInterval(waitHeartbeat);
-        }
-    }
-    const { session, lockToken } = lockResult;
-    const isFirstMessage = session.message_count === 1;
-    sessionLog.info(`Acquired lock on session ${threadId}, Claude session: ${session.session_id}, mode: ${isFirstMessage ? 'new' : 'resume'}, message #${session.message_count}`);
-    logQueueState(`Lock acquired for ${threadId}`);
-    processingMessages.add(messageId);
-    const heartbeat = startHeartbeat(receiptHandle, sessionLog);
-    // Start typing indicator
-    const stopTyping = hasSlackContext
-        ? startTypingIndicator(queueMessage)
-        : undefined;
-    try {
-        const result = await spawnClaudeCode(queueMessage, sessionLog, kbPath, session.session_id || undefined, isFirstMessage, session.last_message_ts, () => stopTyping?.());
-        stopTyping?.();
-        // If Claude generated a new session ID (stale lock recovery), persist it
-        if (result.newSessionId && lockToken) {
-            await updateSessionId(threadId, lockToken, result.newSessionId);
-        }
-        if (result.success) {
-            sessionLog.info('Claude Code completed successfully');
-            // Push any changes in the channel brain repo
-            if (queueMessage.teamvibe.brain?.brainId) {
-                await pushBrainChanges(kbPath, queueMessage.teamvibe.brain.brainId);
-            }
-            if (lockToken) {
-                const lastMessageTs = queueMessage.response_context.slack?.message_ts;
-                await releaseSessionLock(threadId, lockToken, 'idle', lastMessageTs);
-            }
-        }
-        else {
-            sessionLog.error(`Claude Code failed: ${result.error}`);
-            if (hasSlackContext) {
-                await sendSlackError(queueMessage, result.error || `Process exited with code ${result.exitCode}`);
-                await addReaction(queueMessage, 'x');
-            }
-            if (lockToken) {
-                await releaseSessionLock(threadId, lockToken, 'idle');
-            }
-        }
-        await deleteMessage(receiptHandle);
-        sessionLog.info('Message processed and deleted');
-    }
-    catch (error) {
-        stopTyping?.();
-        sessionLog.error(`Error processing message: ${error instanceof Error ? error.message : error}`);
-        if (lockToken) {
-            try {
-                await releaseSessionLock(threadId, lockToken, 'idle');
-            }
-            catch (releaseError) {
-                sessionLog.error(`Failed to release lock: ${releaseError}`);
-            }
-        }
-        if (hasSlackContext) {
-            try {
-                await sendSlackError(queueMessage, error instanceof Error ? error.message : 'Unknown error');
-                await addReaction(queueMessage, 'x');
-            }
-            catch (slackError) {
-                sessionLog.error(`Failed to send Slack error: ${slackError}`);
-            }
-        }
-        throw error;
-    }
-    finally {
-        clearInterval(heartbeat);
-        processingMessages.delete(messageId);
-        signalThreadCompletion(threadId);
-    }
-}
-async function pollLoop() {
-    logger.info('Poll loop started');
-    while (true) {
-        try {
-            if (isAtCapacity()) {
-                logger.debug(`At capacity (${getActiveProcessCount()}/${config.MAX_CONCURRENT_SESSIONS}), waiting...`);
-                await sleep(1000);
-                continue;
-            }
-            const availableSlots = config.MAX_CONCURRENT_SESSIONS - getActiveProcessCount();
-            logger.debug(`Polling for up to ${availableSlots} messages...`);
-            const messages = await pollMessages(availableSlots);
-            if (messages.length === 0) {
-                continue;
-            }
-            logger.info(`Received ${messages.length} message(s) from SQS`);
-            logQueueState('After SQS poll');
-            const processPromises = messages.map((msg) => processMessage(msg).catch((error) => {
-                logger.error(`Failed to process message ${msg.messageId}:`, error);
-            }));
-            // Don't await - let them run in parallel
-            Promise.all(processPromises);
-        }
-        catch (error) {
-            logger.error('Error in poll loop:', error);
-            await sleep(5000);
-        }
-    }
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-// Graceful shutdown
-let shuttingDown = false;
-async function shutdown(signal) {
-    if (shuttingDown)
-        return;
-    shuttingDown = true;
-    logger.info(`${signal} received, shutting down gracefully...`);
-    stopRefresh();
-    const shutdownTimeout = 30000;
-    const startTime = Date.now();
-    while (processingMessages.size > 0) {
-        if (Date.now() - startTime > shutdownTimeout) {
-            logger.warn('Shutdown timeout reached, forcing exit');
-            break;
-        }
-        logger.info(`Waiting for ${processingMessages.size} message(s) to complete...`);
-        await sleep(1000);
-    }
-    logger.info('Shutdown complete');
-    process.exit(0);
-}
-process.on('SIGINT', () => shutdown('SIGINT'));
-process.on('SIGTERM', () => shutdown('SIGTERM'));
-async function main() {
-    // Token-based auth: fetch credentials before starting
-    if (config.TEAMVIBE_API_URL && config.TEAMVIBE_POLLER_TOKEN) {
-        await initAuth(config.TEAMVIBE_API_URL, config.TEAMVIBE_POLLER_TOKEN);
-    }
-    else {
-        logger.info(`   Queue: ${config.SQS_QUEUE_URL}`);
-        logger.info(`   Sessions table: ${config.SESSIONS_TABLE}`);
-    }
-    await ensureDirectories();
-    await ensureBaseBrain();
-    await pollLoop();
-}
-main().catch((error) => {
-    logger.error('Fatal error:', error);
-    process.exit(1);
-});
+export {};

package/dist/poller.d.ts

@@ -0,0 +1 @@
+export declare function startPoller(): Promise<void>;

package/dist/poller.js

@@ -0,0 +1,260 @@
+import { config } from './config.js';
+import { logger } from './logger.js';
+import { pollMessages, deleteMessage, extendVisibility, } from './sqs-poller.js';
+import { spawnClaudeCode, isAtCapacity, getActiveProcessCount } from './claude-spawner.js';
+import { sendSlackError, addReaction, getUserInfo, startTypingIndicator } from './slack-client.js';
+import { acquireSessionLock, releaseSessionLock, updateSessionId } from './session-store.js';
+import { getBrainPath, ensureDirectories, ensureBaseBrain, pushBrainChanges } from './brain-manager.js';
+import { initAuth, stopRefresh } from './auth-provider.js';
+// Track active message processing
+const processingMessages = new Set();
+// Per-thread completion signals
+const threadCompletionSignals = new Map();
+const waitingCountByThread = new Map();
+function getQueueStats() {
+    let totalWaiting = 0;
+    waitingCountByThread.forEach((count) => {
+        totalWaiting += count;
+    });
+    return {
+        processing: processingMessages.size,
+        threadsWithWaiting: waitingCountByThread.size,
+        totalWaiting,
+    };
+}
+function logQueueState(context) {
+    const stats = getQueueStats();
+    logger.info(`[Queue] ${context} | Processing: ${stats.processing}, Threads with waiting: ${stats.threadsWithWaiting}, Total waiting: ${stats.totalWaiting}`);
+}
+function waitForThreadCompletion(threadId) {
+    return new Promise((resolve) => {
+        const signals = threadCompletionSignals.get(threadId) || [];
+        signals.push(resolve);
+        threadCompletionSignals.set(threadId, signals);
+        const currentCount = waitingCountByThread.get(threadId) || 0;
+        waitingCountByThread.set(threadId, currentCount + 1);
+        logger.info(`[Queue] Thread ${threadId}: ${currentCount + 1} message(s) now waiting`);
+        logQueueState('After enqueue');
+    });
+}
+function signalThreadCompletion(threadId) {
+    const signals = threadCompletionSignals.get(threadId);
+    const waitingCount = signals?.length || 0;
+    if (signals && signals.length > 0) {
+        logger.info(`[Queue] Thread ${threadId} completed, waking ${waitingCount} waiting message(s)`);
+        signals.forEach((resolve) => resolve());
+        threadCompletionSignals.delete(threadId);
+        waitingCountByThread.delete(threadId);
+        logQueueState('After signal');
+    }
+}
+function startHeartbeat(receiptHandle, sessionLog) {
+    return setInterval(async () => {
+        try {
+            await extendVisibility(receiptHandle, config.VISIBILITY_TIMEOUT_SECONDS);
+            sessionLog.info(`Heartbeat: extended visibility by ${config.VISIBILITY_TIMEOUT_SECONDS}s`);
+        }
+        catch (error) {
+            sessionLog.error(`Heartbeat failed: ${error instanceof Error ? error.message : error}`);
+        }
+    }, config.HEARTBEAT_INTERVAL_MS);
+}
+async function processMessage(received) {
+    const { queueMessage, receiptHandle, messageId } = received;
+    const logSessionId = messageId.slice(0, 8);
+    const threadId = queueMessage.thread_id;
+    const sessionLog = logger.createSession(logSessionId);
+    // Fetch user info if we only have ID
+    if (queueMessage.source !== 'cron' &&
+        queueMessage.sender.name === 'Unknown User' &&
+        queueMessage.sender.id !== 'unknown') {
+        const userInfo = await getUserInfo(queueMessage.teamvibe.botToken, queueMessage.sender.id);
+        queueMessage.sender.name = userInfo.realName;
+        sessionLog.info(`Resolved user: ${userInfo.realName} (@${userInfo.name})`);
+    }
+    sessionLog.info(`Processing message from ${queueMessage.sender.name} (${queueMessage.sender.id})`);
+    sessionLog.info(`Thread: ${threadId}`);
+    sessionLog.info(`Brain: ${queueMessage.teamvibe.brain?.brainId ?? 'none'}`);
+    sessionLog.info(`Type: ${queueMessage.type}`);
+    sessionLog.info(`Log file: ${sessionLog.getLogFile()}`);
+    const hasSlackContext = Boolean(queueMessage.response_context.slack?.channel &&
+        queueMessage.response_context.slack?.message_ts);
+    // Get brain path for this channel
+    let kbPath;
+    try {
+        kbPath = await getBrainPath(queueMessage.teamvibe.brain);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        sessionLog.error(`Failed to clone brain: ${errorMessage}`);
+        if (hasSlackContext) {
+            try {
+                await sendSlackError(queueMessage, `Failed to clone brain repository: ${errorMessage}`);
+                await addReaction(queueMessage, 'x');
+            }
+            catch (slackError) {
+                sessionLog.error(`Failed to send Slack error: ${slackError}`);
+            }
+        }
+        await deleteMessage(receiptHandle);
+        return;
+    }
+    // Try to acquire session lock
+    let lockResult = await acquireSessionLock(threadId, kbPath);
+    if (!lockResult.success) {
+        sessionLog.info(`Session ${threadId} is processing, waiting for completion...`);
+        const waitHeartbeat = startHeartbeat(receiptHandle, sessionLog);
+        try {
+            await waitForThreadCompletion(threadId);
+            sessionLog.info(`Thread ${threadId} completed, retrying lock acquisition`);
+            lockResult = await acquireSessionLock(threadId, kbPath);
+            if (!lockResult.success) {
+                sessionLog.info('Lock still held, re-queuing for next completion');
+                clearInterval(waitHeartbeat);
+                return processMessage(received);
+            }
+        }
+        finally {
+            clearInterval(waitHeartbeat);
+        }
+    }
+    const { session, lockToken } = lockResult;
+    const isFirstMessage = session.message_count === 1;
+    sessionLog.info(`Acquired lock on session ${threadId}, Claude session: ${session.session_id}, mode: ${isFirstMessage ? 'new' : 'resume'}, message #${session.message_count}`);
+    logQueueState(`Lock acquired for ${threadId}`);
+    processingMessages.add(messageId);
+    const heartbeat = startHeartbeat(receiptHandle, sessionLog);
+    // Start typing indicator
+    const stopTyping = hasSlackContext
+        ? startTypingIndicator(queueMessage)
+        : undefined;
+    try {
+        const result = await spawnClaudeCode(queueMessage, sessionLog, kbPath, session.session_id || undefined, isFirstMessage, session.last_message_ts, () => stopTyping?.());
+        stopTyping?.();
+        // If Claude generated a new session ID (stale lock recovery), persist it
+        if (result.newSessionId && lockToken) {
+            await updateSessionId(threadId, lockToken, result.newSessionId);
+        }
+        if (result.success) {
+            sessionLog.info('Claude Code completed successfully');
+            // Push any changes in the channel brain repo
+            if (queueMessage.teamvibe.brain?.brainId) {
+                await pushBrainChanges(kbPath, queueMessage.teamvibe.brain.brainId);
+            }
+            if (lockToken) {
+                const lastMessageTs = queueMessage.response_context.slack?.message_ts;
+                await releaseSessionLock(threadId, lockToken, 'idle', lastMessageTs);
+            }
+        }
+        else {
+            sessionLog.error(`Claude Code failed: ${result.error}`);
+            if (hasSlackContext) {
+                await sendSlackError(queueMessage, result.error || `Process exited with code ${result.exitCode}`);
+                await addReaction(queueMessage, 'x');
+            }
+            if (lockToken) {
+                await releaseSessionLock(threadId, lockToken, 'idle');
+            }
+        }
+        await deleteMessage(receiptHandle);
+        sessionLog.info('Message processed and deleted');
+    }
+    catch (error) {
+        stopTyping?.();
+        sessionLog.error(`Error processing message: ${error instanceof Error ? error.message : error}`);
+        if (lockToken) {
+            try {
+                await releaseSessionLock(threadId, lockToken, 'idle');
+            }
+            catch (releaseError) {
+                sessionLog.error(`Failed to release lock: ${releaseError}`);
+            }
+        }
+        if (hasSlackContext) {
+            try {
+                await sendSlackError(queueMessage, error instanceof Error ? error.message : 'Unknown error');
+                await addReaction(queueMessage, 'x');
+            }
+            catch (slackError) {
+                sessionLog.error(`Failed to send Slack error: ${slackError}`);
+            }
+        }
+        throw error;
+    }
+    finally {
+        clearInterval(heartbeat);
+        processingMessages.delete(messageId);
+        signalThreadCompletion(threadId);
+    }
+}
+async function pollLoop() {
+    logger.info('Poll loop started');
+    while (true) {
+        try {
+            if (isAtCapacity()) {
+                logger.debug(`At capacity (${getActiveProcessCount()}/${config.MAX_CONCURRENT_SESSIONS}), waiting...`);
+                await sleep(1000);
+                continue;
+            }
+            const availableSlots = config.MAX_CONCURRENT_SESSIONS - getActiveProcessCount();
+            logger.debug(`Polling for up to ${availableSlots} messages...`);
+            const messages = await pollMessages(availableSlots);
+            if (messages.length === 0) {
+                continue;
+            }
+            logger.info(`Received ${messages.length} message(s) from SQS`);
+            logQueueState('After SQS poll');
+            const processPromises = messages.map((msg) => processMessage(msg).catch((error) => {
+                logger.error(`Failed to process message ${msg.messageId}:`, error);
+            }));
+            // Don't await - let them run in parallel
+            Promise.all(processPromises);
+        }
+        catch (error) {
+            logger.error('Error in poll loop:', error);
+            await sleep(5000);
+        }
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// Graceful shutdown
+let shuttingDown = false;
+async function shutdown(signal) {
+    if (shuttingDown)
+        return;
+    shuttingDown = true;
+    logger.info(`${signal} received, shutting down gracefully...`);
+    stopRefresh();
+    const shutdownTimeout = 30000;
+    const startTime = Date.now();
+    while (processingMessages.size > 0) {
+        if (Date.now() - startTime > shutdownTimeout) {
+            logger.warn('Shutdown timeout reached, forcing exit');
+            break;
+        }
+        logger.info(`Waiting for ${processingMessages.size} message(s) to complete...`);
+        await sleep(1000);
+    }
+    logger.info('Shutdown complete');
+    process.exit(0);
+}
+export async function startPoller() {
+    logger.info('TeamVibe Poller starting...');
+    logger.info(`   Max concurrent: ${config.MAX_CONCURRENT_SESSIONS}`);
+    logger.info(`   Brains path: ${config.BRAINS_PATH}`);
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+    // Token-based auth: fetch credentials before starting
+    if (config.TEAMVIBE_API_URL && config.TEAMVIBE_POLLER_TOKEN) {
+        await initAuth(config.TEAMVIBE_API_URL, config.TEAMVIBE_POLLER_TOKEN);
+    }
+    else {
+        logger.info(`   Queue: ${config.SQS_QUEUE_URL}`);
+        logger.info(`   Sessions table: ${config.SESSIONS_TABLE}`);
+    }
+    await ensureDirectories();
+    await ensureBaseBrain();
+    await pollLoop();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamvibe/poller",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {