beecork 1.5.0 → 1.6.0

package/dist/channels/whatsapp.js

@@ -1,3 +1,16 @@
+/*
+ * WhatsApp integration via @whiskeysockets/baileys.
+ *
+ * baileys is a peer-optional dependency loaded by dynamic import, and its
+ * runtime types are intentionally loose (the lib uses heavy union/index
+ * types that don't survive serialization across the dynamic-import boundary).
+ * Trying to type every variant of Baileys' message/connection shapes would
+ * either pull baileys into the static graph (bloating non-WhatsApp installs)
+ * or require maintaining a parallel shim. We accept `any` at this trust
+ * boundary; runtime validation lives in the descriptors table inside
+ * messages.upsert.
+ */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import fs from 'node:fs';
 import { logger } from '../util/logger.js';
 import { saveMedia, isOversized } from '../media/store.js';
@@ -11,8 +24,6 @@ export class WhatsAppChannel {
     id = 'whatsapp';
     name = 'WhatsApp';
     maxMessageLength = WHATSAPP_MAX_LENGTH;
-    supportsStreaming = false;
-    supportsMedia = true;
     sock = null;
     ctx;
     allowedNumbers;
@@ -24,12 +35,42 @@ export class WhatsAppChannel {
         this.ctx = ctx;
         this.allowedNumbers = new Set(ctx.config.whatsapp?.allowedNumbers ?? []);
     }
+    /**
+     * Schedule the next reconnect with exponential backoff. Unlike the previous
+     * inline setTimeout, this path retries when `start()` itself rejects (auth
+     * failure, baileys init throw, etc.) instead of going permanently silent
+     * after a single failed attempt.
+     */
+    scheduleReconnect() {
+        this.reconnectAttempts++;
+        if (this.reconnectAttempts > this.maxReconnectAttempts) {
+            logger.error(`WhatsApp reconnect failed after ${this.maxReconnectAttempts} attempts, giving up`);
+            this.ctx
+                .notifyCallback?.('⚠️ WhatsApp disconnected after 10 reconnection attempts. Restart daemon to reconnect.')
+                .catch((err) => logger.error('Failed to send WhatsApp disconnect notification:', err));
+            return;
+        }
+        const delayIdx = Math.min(this.reconnectAttempts - 1, this.backoffDelays.length - 1);
+        const delay = this.backoffDelays[delayIdx];
+        logger.warn(`WhatsApp connection closed, reconnecting in ${delay / 1000}s (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})...`);
+        setTimeout(() => {
+            this.start().catch((err) => {
+                logger.error('WhatsApp reconnect attempt failed:', err);
+                // Recurse via scheduleReconnect so backoff keeps escalating instead of
+                // silently dropping the reconnect chain after one failed start().
+                this.scheduleReconnect();
+            });
+        }, delay);
+    }
     async start() {
         // Initialize voice providers (STT + TTS)
         this.voice.init(this.ctx.config);
         try {
-            const { default: makeWASocket, useMultiFileAuthState, DisconnectReason, downloadMediaMessage, fetchLatestBaileysVersion } = await import('@whiskeysockets/baileys');
-            const sessionPath = this.ctx.config.whatsapp?.sessionPath ?? `${process.env.HOME}/.beecork/whatsapp-session`;
+            const { default: makeWASocket, useMultiFileAuthState, DisconnectReason, downloadMediaMessage, fetchLatestBaileysVersion, } = await import('@whiskeysockets/baileys');
+            const { getWhatsappSessionPath } = await import('../util/paths.js');
+            // Use the centralized path helper — the previous fallback hard-coded
+            // process.env.HOME which bypassed BEECORK_HOME for tests/isolation.
+            const sessionPath = this.ctx.config.whatsapp?.sessionPath ?? getWhatsappSessionPath();
             fs.mkdirSync(sessionPath, { recursive: true, mode: 0o700 });
             const { state, saveCreds } = await useMultiFileAuthState(sessionPath);
             const { version } = await fetchLatestBaileysVersion().catch(() => ({ version: undefined }));
@@ -56,21 +97,7 @@ export class WhatsAppChannel {
                 if (connection === 'close') {
                     const reason = lastDisconnect?.error?.output?.statusCode;
                     if (reason !== DisconnectReason.loggedOut) {
-                        this.reconnectAttempts++;
-                        if (this.reconnectAttempts > this.maxReconnectAttempts) {
-                            logger.error(`WhatsApp reconnect failed after ${this.maxReconnectAttempts} attempts, giving up`);
-                            this.ctx.notifyCallback?.('⚠️ WhatsApp disconnected after 10 reconnection attempts. Restart daemon to reconnect.')
-                                .catch(err => logger.error('Failed to send WhatsApp disconnect notification:', err));
-                            return;
-                        }
-                        const delayIdx = Math.min(this.reconnectAttempts - 1, this.backoffDelays.length - 1);
-                        const delay = this.backoffDelays[delayIdx];
-                        logger.warn(`WhatsApp connection closed, reconnecting in ${delay / 1000}s (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})...`);
-                        setTimeout(() => {
-                            this.start().catch(err => {
-                                logger.error('WhatsApp reconnect failed:', err);
-                            });
-                        }, delay);
+                        this.scheduleReconnect();
                     }
                     else {
                         logger.error('WhatsApp logged out. Please re-scan QR code.');
@@ -90,13 +117,18 @@ export class WhatsAppChannel {
                     return;
                 // Rate limit check
                 if (!inboundLimiter.check(this.id)) {
-                    await sock.sendMessage(sender, { text: "I'm receiving too many messages right now. Please wait a moment." }).catch(() => { });
+                    await sock
+                        .sendMessage(sender, {
+                        text: "I'm receiving too many messages right now. Please wait a moment.",
+                    })
+                        .catch(() => { });
                     return;
                 }
                 const text = msg.message.conversation ||
                     msg.message.extendedTextMessage?.text ||
                     msg.message.imageMessage?.caption ||
-                    msg.message.videoMessage?.caption || '';
+                    msg.message.videoMessage?.caption ||
+                    '';
                 const descriptors = [
                     {
                         key: 'imageMessage',
@@ -160,7 +192,7 @@ export class WhatsAppChannel {
                 const waResults = await Promise.allSettled(waDownloadTasks);
                 const media = waResults
                     .filter((r) => r.status === 'fulfilled' && r.value !== null)
-                    .map(r => r.value);
+                    .map((r) => r.value);
                 // Transcribe voice messages if STT is configured
                 await this.voice.transcribe(media);
                 if (!text && media.length === 0)
@@ -202,7 +234,11 @@ export class WhatsAppChannel {
                         return;
                     // Send voice reply if TTS generated audio
                     if (pipelineResult.audioPath) {
-                        await sock.sendMessage(sender, { audio: { url: pipelineResult.audioPath }, mimetype: 'audio/ogg; codecs=opus', ptt: true });
+                        await sock.sendMessage(sender, {
+                            audio: { url: pipelineResult.audioPath },
+                            mimetype: 'audio/ogg; codecs=opus',
+                            ptt: true,
+                        });
                         if (pipelineResult.voiceOnly)
                             return;
                     }
@@ -210,7 +246,10 @@ export class WhatsAppChannel {
                 }
                 catch (err) {
                     logger.error('WhatsApp message handler error:', err);
-                    await sock.sendMessage(sender, { text: 'Something went wrong processing your message. Check daemon logs for details.' })
+                    await sock
+                        .sendMessage(sender, {
+                        text: 'Something went wrong processing your message. Check daemon logs for details.',
+                    })
                         .catch((sendErr) => logger.error('WhatsApp: failed to send fallback error message:', sendErr));
                 }
             });
@@ -236,7 +275,7 @@ export class WhatsAppChannel {
             text,
             maxLength: WHATSAPP_MAX_LENGTH,
             retryLabel: 'whatsapp-send',
-            sendChunk: chunk => sock.sendMessage(peerId, { text: chunk }),
+            sendChunk: (chunk) => sock.sendMessage(peerId, { text: chunk }),
         });
     }
     async sendNotification(message, _urgent) {
@@ -259,9 +298,6 @@ export class WhatsAppChannel {
         const status = active ? 'composing' : 'paused';
         await sock.sendPresenceUpdate(status, peerId).catch(() => { });
     }
-    onMessage(_handler) {
-        // Messages are handled directly in start()
-    }
     // ─── Private ───
     async sendResponse(jid, text, tabName) {
         const sock = this.sock;
@@ -271,7 +307,7 @@ export class WhatsAppChannel {
                 tabName,
                 maxLength: WHATSAPP_MAX_LENGTH,
                 retryLabel: 'whatsapp-send',
-                sendChunk: chunk => sock.sendMessage(jid, { text: chunk }),
+                sendChunk: (chunk) => sock.sendMessage(jid, { text: chunk }),
             });
         }
         catch (err) {

package/dist/cli/capabilities.js

@@ -1,15 +1,15 @@
 import readline from 'node:readline';
 function ask(rl, question, defaultValue) {
     const prompt = defaultValue ? `${question} [${defaultValue}]: ` : `${question}: `;
-    return new Promise(r => rl.question(prompt, a => r(a.trim() || defaultValue || '')));
+    return new Promise((r) => rl.question(prompt, (a) => r(a.trim() || defaultValue || '')));
 }
 export async function enableCapability(packId) {
     const { getAvailablePacks, isEnabled, enablePack } = await import('../capabilities/index.js');
     const packs = getAvailablePacks();
-    const pack = packs.find(p => p.id === packId);
+    const pack = packs.find((p) => p.id === packId);
     if (!pack) {
         console.log(`Unknown capability: "${packId}"`);
-        console.log('Available: ' + packs.map(p => p.id).join(', '));
+        console.log('Available: ' + packs.map((p) => p.id).join(', '));
         return;
     }
     if (isEnabled(packId)) {
@@ -46,7 +46,7 @@ export async function listCapabilities() {
         web: 'Web',
     };
     for (const category of categories) {
-        const categoryPacks = packs.filter(p => p.category === category);
+        const categoryPacks = packs.filter((p) => p.category === category);
         if (categoryPacks.length === 0)
             continue;
         console.log(`  ${categoryNames[category]}:`);

package/dist/cli/channel.js

@@ -1,17 +1,24 @@
-import { execSync } from 'node:child_process';
+import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 const CHANNEL_PREFIX = 'beecork-channel-';
+const SAFE_NPM_PACKAGE = /^[@a-zA-Z0-9_/.-]+$/;
 export function channelInstall(packageName) {
     // Normalize name
-    const fullName = packageName.startsWith(CHANNEL_PREFIX) ? packageName : `${CHANNEL_PREFIX}${packageName}`;
+    const fullName = packageName.startsWith(CHANNEL_PREFIX)
+        ? packageName
+        : `${CHANNEL_PREFIX}${packageName}`;
+    if (!SAFE_NPM_PACKAGE.test(fullName)) {
+        console.error(`Invalid package name: ${fullName}`);
+        process.exit(1);
+    }
     console.log(`Installing channel: ${fullName}...`);
     try {
-        execSync(`npm install -g ${fullName}`, { stdio: 'inherit' });
+        execFileSync('npm', ['install', '-g', fullName], { stdio: 'inherit' });
         console.log(`\nChannel "${fullName}" installed.`);
         console.log('Restart the daemon to activate: beecork stop && beecork start');
     }
-    catch (err) {
+    catch {
         console.error(`Failed to install ${fullName}. Check the package name and try again.`);
         process.exit(1);
     }
@@ -173,8 +180,11 @@ npm publish
 }
 export function channelList() {
     try {
-        const output = execSync('npm list -g --depth=0', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
-        const lines = output.split('\n').filter(line => line.includes(CHANNEL_PREFIX));
+        const output = execFileSync('npm', ['list', '-g', '--depth=0'], {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const lines = output.split('\n').filter((line) => line.includes(CHANNEL_PREFIX));
         if (lines.length === 0) {
             console.log('No community channels installed.');
             console.log(`Install one: beecork channel install <name>`);

package/dist/cli/commands.js

@@ -4,6 +4,7 @@ import { spawn, execSync } from 'node:child_process';
 import { getDb, closeDb } from '../db/index.js';
 import { getConfig } from '../config.js';
 import { TaskStore } from '../tasks/store.js';
+import { TabStore } from '../session/tab-store.js';
 import { getDaemonPid, timeAgo } from './helpers.js';
 import { startService, stopService } from '../service/install.js';
 import { getPidPath, getLogsDir } from '../util/paths.js';
@@ -71,17 +72,17 @@ export async function showStatus() {
     console.log(`Daemon: ${pid ? `running (PID ${pid})` : 'stopped'}`);
     console.log(`Deployment: ${config.deployment}`);
     try {
-        const db = getDb();
-        const tabs = db.prepare('SELECT * FROM tabs ORDER BY last_activity_at DESC').all();
+        getDb(); // ensure DB initialized
+        const tabs = TabStore.listAll();
         console.log(`\nTabs (${tabs.length}):`);
         for (const tab of tabs) {
-            const ago = timeAgo(tab.last_activity_at);
+            const ago = timeAgo(tab.lastActivityAt);
             const pidInfo = tab.pid ? ` (PID ${tab.pid})` : '';
             console.log(`  ${tab.name.padEnd(20)} ${tab.status.padEnd(12)} last active: ${ago}${pidInfo}`);
         }
         const store = new TaskStore();
         const jobs = store.list();
-        const activeJobs = jobs.filter(j => j.enabled);
+        const activeJobs = jobs.filter((j) => j.enabled);
         console.log(`\nTasks: ${activeJobs.length} active (${jobs.length} total)`);
         if (activeJobs.length > 0) {
             for (const job of activeJobs.slice(0, 5)) {
@@ -97,8 +98,8 @@ export async function showStatus() {
     console.log('');
 }
 export async function listTabs() {
-    const db = requireDb();
-    const tabs = db.prepare('SELECT * FROM tabs ORDER BY last_activity_at DESC').all();
+    requireDb();
+    const tabs = TabStore.listAll();
     closeDb();
     if (tabs.length === 0) {
         console.log('No tabs.');
@@ -106,8 +107,8 @@ export async function listTabs() {
     }
     console.log(`\nTabs (${tabs.length}):\n`);
     for (const tab of tabs) {
-        const ago = timeAgo(tab.last_activity_at);
-        console.log(`  ${tab.name.padEnd(20)} [${tab.status}] dir:${tab.working_dir} — ${ago}`);
+        const ago = timeAgo(tab.lastActivityAt);
+        console.log(`  ${tab.name.padEnd(20)} [${tab.status}] dir:${tab.workingDir} — ${ago}`);
     }
     console.log('');
 }
@@ -186,7 +187,9 @@ export async function deleteWatcher(id) {
 }
 export async function listMemories() {
     const db = requireDb();
-    const memories = db.prepare('SELECT * FROM memories ORDER BY created_at DESC LIMIT 50').all();
+    const memories = db
+        .prepare('SELECT * FROM memories ORDER BY created_at DESC LIMIT 50')
+        .all();
     closeDb();
     if (memories.length === 0) {
         console.log('No memories stored.');

package/dist/cli/doctor.js

@@ -1,7 +1,8 @@
 import fs from 'node:fs';
 import { execSync } from 'node:child_process';
 import { getConfig } from '../config.js';
-import { getDbPath, getPidPath, getBeecorkHome } from '../util/paths.js';
+import { getDbPath, getPidPath, getBeecorkHome, getConfigPath, getMcpConfigPath, getWhatsappSessionPath, } from '../util/paths.js';
+import { getMediaDir } from '../media/store.js';
 export async function runDoctor() {
     const checks = [];
     // 1. Check Claude binary
@@ -19,10 +20,14 @@ export async function runDoctor() {
         }
     }
     catch {
-        checks.push({ name: 'Claude Code', status: 'fail', message: 'Claude Code binary not found. Install: npm install -g @anthropic-ai/claude-code' });
+        checks.push({
+            name: 'Claude Code',
+            status: 'fail',
+            message: 'Claude Code binary not found. Install: npm install -g @anthropic-ai/claude-code',
+        });
     }
     // 2. Check config file
-    const configPath = `${getBeecorkHome()}/config.json`;
+    const configPath = getConfigPath();
     if (fs.existsSync(configPath)) {
         try {
             const config = getConfig();
@@ -30,17 +35,31 @@ export async function runDoctor() {
             // 3. Check Telegram token
             if (config.telegram?.token) {
                 try {
-                    const resp = await fetch(`https://api.telegram.org/bot${config.telegram.token}/getMe`, { signal: AbortSignal.timeout(10000) });
+                    const resp = await fetch(`https://api.telegram.org/bot${config.telegram.token}/getMe`, {
+                        signal: AbortSignal.timeout(10000),
+                    });
                     if (resp.ok) {
-                        const data = await resp.json();
-                        checks.push({ name: 'Telegram bot', status: 'pass', message: `@${data.result.username}` });
+                        const data = (await resp.json());
+                        checks.push({
+                            name: 'Telegram bot',
+                            status: 'pass',
+                            message: `@${data.result.username}`,
+                        });
                     }
                     else {
-                        checks.push({ name: 'Telegram bot', status: 'fail', message: 'Invalid token — getMe returned error' });
+                        checks.push({
+                            name: 'Telegram bot',
+                            status: 'fail',
+                            message: 'Invalid token — getMe returned error',
+                        });
                     }
                 }
-                catch (err) {
-                    checks.push({ name: 'Telegram bot', status: 'warn', message: 'Could not reach Telegram API' });
+                catch {
+                    checks.push({
+                        name: 'Telegram bot',
+                        status: 'warn',
+                        message: 'Could not reach Telegram API',
+                    });
                 }
             }
             else {
@@ -48,12 +67,16 @@ export async function runDoctor() {
             }
             // 4. Check WhatsApp session
             if (config.whatsapp?.enabled) {
-                const sessionPath = config.whatsapp.sessionPath || `${getBeecorkHome()}/whatsapp-session`;
+                const sessionPath = config.whatsapp.sessionPath || getWhatsappSessionPath();
                 if (fs.existsSync(sessionPath) && fs.readdirSync(sessionPath).length > 0) {
                     checks.push({ name: 'WhatsApp session', status: 'pass', message: sessionPath });
                 }
                 else {
-                    checks.push({ name: 'WhatsApp session', status: 'warn', message: 'No session data — QR scan needed' });
+                    checks.push({
+                        name: 'WhatsApp session',
+                        status: 'warn',
+                        message: 'No session data — QR scan needed',
+                    });
                 }
             }
         }
@@ -62,14 +85,18 @@ export async function runDoctor() {
         }
     }
     else {
-        checks.push({ name: 'Config', status: 'fail', message: `Not found at ${configPath}. Run: beecork setup` });
+        checks.push({
+            name: 'Config',
+            status: 'fail',
+            message: `Not found at ${configPath}. Run: beecork setup`,
+        });
     }
     // 5. Check database
     const dbPath = getDbPath();
     if (fs.existsSync(dbPath)) {
         try {
-            const Database = (await import('better-sqlite3')).default;
-            const db = new Database(dbPath, { readonly: true });
+            const { openDb } = await import('../db/connection.js');
+            const db = openDb(dbPath, { readonly: true });
             const integrity = db.pragma('integrity_check');
             if (integrity[0]?.integrity_check === 'ok') {
                 const size = (fs.statSync(dbPath).size / 1024).toFixed(0);
@@ -85,7 +112,11 @@ export async function runDoctor() {
         }
     }
     else {
-        checks.push({ name: 'Database', status: 'warn', message: 'No database yet — starts on first run' });
+        checks.push({
+            name: 'Database',
+            status: 'warn',
+            message: 'No database yet — starts on first run',
+        });
     }
     // 6. Check daemon
     const pidPath = getPidPath();
@@ -96,7 +127,11 @@ export async function runDoctor() {
             checks.push({ name: 'Daemon', status: 'pass', message: `Running (PID ${pid})` });
         }
         catch {
-            checks.push({ name: 'Daemon', status: 'warn', message: `Stale PID file (PID ${pid} not running)` });
+            checks.push({
+                name: 'Daemon',
+                status: 'warn',
+                message: `Stale PID file (PID ${pid} not running)`,
+            });
         }
     }
     else {
@@ -104,7 +139,7 @@ export async function runDoctor() {
     }
     // 7. Check disk space for media
     try {
-        const mediaDir = `${getBeecorkHome()}/media`;
+        const mediaDir = getMediaDir();
         const homeDir = getBeecorkHome();
         // Simple check: can we write a temp file?
         const testPath = `${homeDir}/.doctor-test`;
@@ -112,25 +147,45 @@ export async function runDoctor() {
         fs.unlinkSync(testPath);
         if (fs.existsSync(mediaDir)) {
             const files = fs.readdirSync(mediaDir);
-            checks.push({ name: 'Media dir', status: 'pass', message: `${files.length} files in ${mediaDir}` });
+            checks.push({
+                name: 'Media dir',
+                status: 'pass',
+                message: `${files.length} files in ${mediaDir}`,
+            });
         }
         else {
-            checks.push({ name: 'Media dir', status: 'pass', message: 'Not created yet (created on first media)' });
+            checks.push({
+                name: 'Media dir',
+                status: 'pass',
+                message: 'Not created yet (created on first media)',
+            });
         }
     }
     catch {
-        checks.push({ name: 'Disk space', status: 'fail', message: 'Cannot write to beecork home directory' });
+        checks.push({
+            name: 'Disk space',
+            status: 'fail',
+            message: 'Cannot write to beecork home directory',
+        });
     }
     // 8. Check MCP config
-    const mcpConfigPath = `${getBeecorkHome()}/mcp-config.json`;
+    const mcpConfigPath = getMcpConfigPath();
     if (fs.existsSync(mcpConfigPath)) {
         try {
             const mcpConfig = JSON.parse(fs.readFileSync(mcpConfigPath, 'utf-8'));
             const serverCount = Object.keys(mcpConfig.mcpServers || {}).length;
-            checks.push({ name: 'MCP config', status: 'pass', message: `${serverCount} server(s) configured` });
+            checks.push({
+                name: 'MCP config',
+                status: 'pass',
+                message: `${serverCount} server(s) configured`,
+            });
         }
         catch {
-            checks.push({ name: 'MCP config', status: 'fail', message: 'Invalid JSON in mcp-config.json' });
+            checks.push({
+                name: 'MCP config',
+                status: 'fail',
+                message: 'Invalid JSON in mcp-config.json',
+            });
         }
     }
     else {
@@ -145,8 +200,8 @@ export async function runDoctor() {
     for (const check of checks) {
         console.log(`  ${icons[check.status]} ${check.name}: ${check.message}`);
     }
-    const fails = checks.filter(c => c.status === 'fail').length;
-    const warns = checks.filter(c => c.status === 'warn').length;
+    const fails = checks.filter((c) => c.status === 'fail').length;
+    const warns = checks.filter((c) => c.status === 'warn').length;
     console.log(`\n  ${checks.length} checks: ${checks.length - fails - warns} passed, ${warns} warnings, ${fails} failures\n`);
     if (fails > 0)
         process.exit(1);

package/dist/cli/handoff.d.ts

@@ -1,15 +1,8 @@
-interface TabInfo {
-    name: string;
-    sessionId: string;
-    workingDir: string;
-    status: string;
-    lastActivity: string;
-    recentMessages: Array<{
-        role: string;
-        content: string;
-    }>;
-}
-export declare function exportTab(tabName: string): TabInfo | null;
+import { exportTab, formatHandoffInfo, type TabHandoffInfo } from '../session/handoff.js';
+export { exportTab, formatHandoffInfo, type TabHandoffInfo };
+/**
+ * CLI-only flow: print the handoff info, spawn claude with `--resume`, and
+ * inherit stdio so the user is dropped into an interactive session. Calls
+ * `process.exit` on subprocess exit — only safe from the CLI entry point.
+ */
 export declare function attachTab(tabName: string): void;
-export declare function formatHandoffInfo(info: TabInfo): string;
-export {};

package/dist/cli/handoff.js

@@ -1,21 +1,13 @@
 import { spawn } from 'node:child_process';
-import { getDb } from '../db/index.js';
 import { getConfig } from '../config.js';
-import { TabStore } from '../session/tab-store.js';
-export function exportTab(tabName) {
-    const tab = TabStore.findByName(tabName);
-    if (!tab)
-        return null;
-    const messages = getDb().prepare('SELECT role, content FROM messages WHERE tab_id = ? ORDER BY created_at DESC LIMIT 5').all(tab.id);
-    return {
-        name: tab.name,
-        sessionId: tab.sessionId,
-        workingDir: tab.workingDir,
-        status: tab.status,
-        lastActivity: tab.lastActivityAt,
-        recentMessages: messages.reverse(),
-    };
-}
+import { exportTab, formatHandoffInfo } from '../session/handoff.js';
+// Re-export the daemon-shared helpers so existing CLI callers keep working.
+export { exportTab, formatHandoffInfo };
+/**
+ * CLI-only flow: print the handoff info, spawn claude with `--resume`, and
+ * inherit stdio so the user is dropped into an interactive session. Calls
+ * `process.exit` on subprocess exit — only safe from the CLI entry point.
+ */
 export function attachTab(tabName) {
     const info = exportTab(tabName);
     if (!info) {
@@ -30,10 +22,7 @@ export function attachTab(tabName) {
     console.log(`  Status: ${info.status}`);
     console.log('');
     // Spawn Claude Code in the terminal, resuming the session
-    const child = spawn(bin, [
-        '--session-id', info.sessionId,
-        '--resume',
-    ], {
+    const child = spawn(bin, ['--session-id', info.sessionId, '--resume'], {
         cwd: info.workingDir,
         stdio: 'inherit', // Attach to terminal
         env: { ...process.env },
@@ -42,27 +31,3 @@ export function attachTab(tabName) {
         process.exit(code ?? 0);
     });
 }
-export function formatHandoffInfo(info) {
-    const lines = [
-        `Session Handoff — tab "${info.name}"`,
-        '',
-        `Session ID: ${info.sessionId}`,
-        `Working dir: ${info.workingDir}`,
-        `Status: ${info.status}`,
-        `Last activity: ${info.lastActivity}`,
-        '',
-        'To resume in terminal:',
-        `  beecork attach ${info.name}`,
-        '',
-        'Or manually:',
-        `  cd ${info.workingDir}`,
-        `  claude --session-id ${info.sessionId} --resume`,
-    ];
-    if (info.recentMessages.length > 0) {
-        lines.push('', 'Recent context:');
-        for (const msg of info.recentMessages) {
-            lines.push(`  [${msg.role}] ${msg.content.slice(0, 150)}${msg.content.length > 150 ? '...' : ''}`);
-        }
-    }
-    return lines.join('\n');
-}

package/dist/cli/mcp.js

@@ -1,14 +1,14 @@
 import fs from 'node:fs';
-import { getBeecorkHome } from '../util/paths.js';
-const MCP_CONFIG_PATH = `${getBeecorkHome()}/mcp-config.json`;
+import { getMcpConfigPath } from '../util/paths.js';
 function loadMcpConfig() {
-    if (fs.existsSync(MCP_CONFIG_PATH)) {
-        return JSON.parse(fs.readFileSync(MCP_CONFIG_PATH, 'utf-8'));
+    const path = getMcpConfigPath();
+    if (fs.existsSync(path)) {
+        return JSON.parse(fs.readFileSync(path, 'utf-8'));
     }
     return { mcpServers: {} };
 }
 function saveMcpConfig(config) {
-    fs.writeFileSync(MCP_CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+    fs.writeFileSync(getMcpConfigPath(), JSON.stringify(config, null, 2), { mode: 0o600 });
 }
 export function mcpAdd(name, command, args) {
     const config = loadMcpConfig();