cc2im 0.2.0 → 0.2.2

package/README.md

@@ -115,6 +115,20 @@ cc2im install
 
 cc2im 为**单用户场景**设计（一个人通过微信控制自己的多个 agent）。多用户并发时，权限审批和回复路由可能出现竞争。
 
+## 更新日志
+
+### v0.2.2 (2026-04-20)
+
+- **fix**: CC 启动时若 `--continue` 触发 "Resume from summary" 会话选择器，expect 脚本现在会自动选第一项；新增 60s 连接超时兜底，卡住时自动 kill 并用新会话重试
+- **fix**: 每个微信 channel 使用独立凭证文件（`credentials-{channelId}.json`），不再互相覆盖，解决新增第二个账号导致第一个掉线的问题
+
+### v0.2.1 (2026-04-07)
+
+- 新用户首次启动引导文案优化
+- 休眠/唤醒后自动重连微信，连续 poll 超时时触发重连
+- Hub 启动时清理孤儿 agent 进程
+- 重启后通过 `--continue` 恢复 agent 的最近 session
+
 ## License
 
 [MIT](./LICENSE)

package/dist/cli.js

@@ -47,20 +47,18 @@ function loadAgentsJson() {
 function ensureDefaultConfig() {
     ensureSocketDir();
     if (!existsSync(AGENTS_JSON_PATH)) {
-        const defaultConfig = {
-            defaultAgent: 'brain',
-            agents: {
-                brain: {
-                    name: 'brain',
-                    cwd: join(homedir(), 'brain'),
-                    claudeArgs: ['--effort', 'max'],
-                    createdAt: new Date().toISOString().split('T')[0],
-                    autoStart: true,
-                },
-            },
-        };
+        const defaultConfig = { defaultAgent: '', agents: {} };
         writeFileSync(AGENTS_JSON_PATH, JSON.stringify(defaultConfig, null, 2) + '\n');
-        console.log(`[cc2im] Created default config: ${AGENTS_JSON_PATH}`);
+    }
+}
+function checkAgentsExist() {
+    const config = loadAgentsJson();
+    if (!config || Object.keys(config.agents).length === 0) {
+        console.log(`\n  No agents registered yet. Quick setup:\n`);
+        console.log(`    1. cc2im login                          # WeChat QR login`);
+        console.log(`    2. cc2im agent register <name> <dir>    # e.g. cc2im agent register mybot ~/projects/mybot`);
+        console.log(`    3. cc2im start                          # start hub + agents\n`);
+        process.exit(1);
     }
 }
 // --- Commands ---
@@ -118,11 +116,13 @@ async function login() {
 }
 async function runHub() {
     ensureDefaultConfig();
+    checkAgentsExist();
     const { startHub } = await import('./hub/index.js');
     await startHub({ autoStartAgents: false });
 }
 async function runStart() {
     ensureDefaultConfig();
+    checkAgentsExist();
     console.log('[cc2im] Starting hub + auto-start agents...');
     const { startHub } = await import('./hub/index.js');
     await startHub({ autoStartAgents: true });
@@ -167,15 +167,22 @@ function agentRegister(name, cwd) {
         console.error(`Directory "${cwd}" does not exist`);
         process.exit(1);
     }
+    const isFirst = Object.keys(config.agents).length === 0;
     config.agents[name] = {
         name,
         cwd,
         claudeArgs: [],
         createdAt: new Date().toISOString().split('T')[0],
-        autoStart: false,
+        autoStart: isFirst,
     };
+    if (isFirst || !config.defaultAgent) {
+        config.defaultAgent = name;
+    }
     writeFileSync(AGENTS_JSON_PATH, JSON.stringify(config, null, 2) + '\n');
     console.log(`[cc2im] Registered agent "${name}" → ${cwd}`);
+    if (isFirst) {
+        console.log(`[cc2im] Set as default agent (autoStart: true)`);
+    }
 }
 function agentDeregister(name) {
     ensureDefaultConfig();
@@ -214,7 +221,7 @@ const arg = process.argv[4];
 switch (command) {
     case '--version':
     case '-v':
-        console.log('cc2im v0.1.0');
+        console.log('cc2im v0.2.0');
         break;
     case 'login':
         await login();
@@ -294,7 +301,7 @@ switch (command) {
     case '--help':
     case '-h':
     default:
-        console.log(`cc2im v0.1.0 — IM gateway for multiple Claude Code instances
+        console.log(`cc2im v0.2.0 — IM gateway for multiple Claude Code instances
 
 Usage:
   cc2im login              微信扫码登录

package/dist/hub/agent-manager.d.ts

@@ -11,7 +11,16 @@ export declare class AgentManager {
     private stoppedManually;
     private shuttingDown;
     private restartAttempts;
+    private skipContinueOnce;
     constructor(getConnectedAgents: () => string[], onEvent?: (kind: string, agentId: string, extra?: Record<string, any>) => void);
+    /**
+     * Kill orphan agent processes from a previous hub session.
+     * Reads PGIDs saved by the previous hub, kills any still-alive process groups,
+     * then clears the file. Called once in constructor before any agents are started.
+     */
+    private killOrphanProcesses;
+    /** Persist current agent PGIDs to disk for orphan cleanup on next startup. */
+    private savePgids;
     private loadConfig;
     private saveConfig;
     getConfig(): AgentsConfig;

package/dist/hub/agent-manager.js

@@ -8,10 +8,14 @@ import { spawn } from 'node:child_process';
 import { SOCKET_DIR } from '../shared/socket.js';
 import { ensureMcpJson } from '../shared/mcp-config.js';
 const AGENTS_JSON_PATH = join(SOCKET_DIR, 'agents.json');
+const PGID_FILE_PATH = join(SOCKET_DIR, 'agent-pgids.json');
 const STOP_TIMEOUT_MS = 5000;
 const RESTART_DELAY_MS = 5000;
 const MAX_RESTART_ATTEMPTS = 5;
 const RESTART_WINDOW_MS = 5 * 60_000; // 5 min — reset counter if stable for this long
+const CONNECT_TIMEOUT_MS = 60_000; // if spoke doesn't connect within this window after spawn,
+// assume init got stuck (e.g. unknown interactive prompt)
+// and restart without --continue to unblock
 export class AgentManager {
     processes = new Map();
     config;
@@ -20,10 +24,54 @@ export class AgentManager {
     stoppedManually = new Set(); // agents stopped by user intent
     shuttingDown = false; // suppress auto-restart during hub shutdown
     restartAttempts = new Map(); // backoff tracking
+    skipContinueOnce = new Set(); // agents to start without --continue on next spawn
+    // (used when previous session stalled during init)
     constructor(getConnectedAgents, onEvent) {
         this.config = this.loadConfig();
         this.getConnectedAgents = getConnectedAgents;
         this.onEvent = onEvent;
+        this.killOrphanProcesses();
+    }
+    /**
+     * Kill orphan agent processes from a previous hub session.
+     * Reads PGIDs saved by the previous hub, kills any still-alive process groups,
+     * then clears the file. Called once in constructor before any agents are started.
+     */
+    killOrphanProcesses() {
+        try {
+            if (!existsSync(PGID_FILE_PATH))
+                return;
+            const pgids = JSON.parse(readFileSync(PGID_FILE_PATH, 'utf8'));
+            let killed = 0;
+            for (const [name, pgid] of Object.entries(pgids)) {
+                try {
+                    process.kill(-pgid, 'SIGKILL'); // kill entire process group
+                    killed++;
+                    console.log(`[agent-manager] Killed orphan "${name}" (pgid ${pgid})`);
+                }
+                catch {
+                    // ESRCH = process group doesn't exist (already dead) — expected
+                }
+            }
+            if (killed > 0) {
+                console.log(`[agent-manager] Cleaned up ${killed} orphan process group(s)`);
+            }
+        }
+        catch { }
+        // Clear the file — we'll write fresh PGIDs as agents start
+        this.savePgids();
+    }
+    /** Persist current agent PGIDs to disk for orphan cleanup on next startup. */
+    savePgids() {
+        const pgids = {};
+        for (const [name, child] of this.processes) {
+            if (child.pid)
+                pgids[name] = child.pid; // detached child.pid === pgid
+        }
+        try {
+            writeFileSync(PGID_FILE_PATH, JSON.stringify(pgids) + '\n');
+        }
+        catch { }
     }
     loadConfig() {
         if (existsSync(AGENTS_JSON_PATH)) {
@@ -102,11 +150,14 @@ export class AgentManager {
         // Ensure agent log directory
         const agentDir = join(SOCKET_DIR, 'agents', name);
         mkdirSync(agentDir, { recursive: true });
-        // autoMode defaults to true — auto-approve safe operations, deny risky ones
-        const useAutoMode = agent.autoMode !== false;
+        // Skip --continue if the previous spawn stalled during init — start fresh instead
+        const skipContinue = this.skipContinueOnce.delete(name);
+        if (skipContinue) {
+            console.log(`[agent-manager] "${name}": starting without --continue (previous session stalled during init)`);
+        }
         const claudeArgs = [
             '--dangerously-load-development-channels', 'server:cc2im',
-            ...(useAutoMode ? ['--enable-auto-mode'] : []),
+            ...(skipContinue ? [] : ['--continue']), // resume most recent session unless last attempt stalled
             ...(agent.claudeArgs || []),
         ];
         // Use `expect` to allocate a pseudo-tty so CC enters interactive mode.
@@ -118,12 +169,22 @@ export class AgentManager {
             `log_file -a {${logPath}}`,
             `spawn claude ${claudeArgs.map(a => `{${a}}`).join(' ')}`,
             '',
-            '# Auto-approve workspace trust prompt if it appears',
-            'set timeout 30',
+            '# Auto-handle initialization prompts:',
+            '#   - Workspace trust prompt ("confirm" text)',
+            '#   - "Resume from summary" session picker (shown by --continue for old/large sessions)',
+            '# exp_continue keeps listening so multiple prompts in sequence are all handled.',
+            '# If 60s passes with no further known prompts, assume CC is up and switch to eof wait.',
+            'set timeout 60',
             'expect {',
+            '  "Resume from summary" {',
+            '    after 500',
+            '    send "1\\r"',
+            '    exp_continue',
+            '  }',
             '  "confirm" {',
             '    after 500',
             '    send "\\r"',
+            '    exp_continue',
             '  }',
             '  timeout {}',
             '}',
@@ -144,9 +205,23 @@ export class AgentManager {
             stdio: ['pipe', 'ignore', 'ignore'],
             detached: true, // new process group — allows killing entire tree with -pid
         });
+        // Fallback: if spoke doesn't connect within CONNECT_TIMEOUT_MS, assume init got stuck
+        // (e.g. an unknown interactive prompt blocked CC) and kill the process tree.
+        // On next auto-restart, --continue is skipped so CC starts with a fresh session.
+        const connectTimer = setTimeout(() => {
+            if (!this.processes.has(name))
+                return; // already exited/stopped
+            if (this.getConnectedAgents().includes(name))
+                return; // healthy, no action needed
+            console.warn(`[agent-manager] "${name}" did not connect within ${CONNECT_TIMEOUT_MS / 1000}s — killing to restart without --continue`);
+            this.skipContinueOnce.add(name);
+            this.killProcessTree(child);
+        }, CONNECT_TIMEOUT_MS);
         child.on('exit', (code) => {
+            clearTimeout(connectTimer);
             console.log(`[agent-manager] Agent "${name}" exited (code ${code})`);
             this.processes.delete(name);
+            this.savePgids();
             this.onEvent?.('agent_stopped', name, { code });
             // Don't restart if: shutting down, or user explicitly stopped
             if (this.shuttingDown)
@@ -187,6 +262,7 @@ export class AgentManager {
             }, delay);
         });
         this.processes.set(name, child);
+        this.savePgids();
         this.onEvent?.('agent_started', name);
         return { success: true };
     }

package/dist/plugins/channel-manager/index.js

@@ -10,14 +10,20 @@ import { copyFileSync, mkdirSync } from 'node:fs';
 import { SOCKET_DIR } from '../../shared/socket.js';
 import { PermissionManager } from '../weixin/permission.js';
 const TYPING_ACK_DELAY_MS = 10_000; // 10s before "processing..." ack
+const SLEEP_DETECT_INTERVAL_MS = 10_000; // check every 10s
+const SLEEP_THRESHOLD_MS = 30_000; // 30s gap = likely sleep/wake
 export function createChannelManagerPlugin(channels) {
     let permissionMgr;
     let cleanupInterval;
+    let sleepDetectInterval;
     const lastUserByAgent = new Map();
     const lastChannelByUser = new Map(); // userId -> channelId
     let lastGlobalUser = null;
     // Per-agent pending ack timer: agentId -> { ref, timer }
     const pendingAck = new Map();
+    // Auto-reconnect state per channel
+    const reconnectTimers = new Map();
+    const reconnectAttempts = new Map();
     // Channel lookup by id
     const channelMap = new Map();
     for (const ch of channels) {
@@ -213,7 +219,7 @@ export function createChannelManagerPlugin(channels) {
                         await channelSendText(ref, `\uD83D\uDCEC ${routed.agentId} \u6682\u65F6\u79BB\u7EBF\uFF0C\u6D88\u606F\u5DF2\u6392\u961F\uFF0C\u4E0A\u7EBF\u540E\u81EA\u52A8\u6295\u9012\u3002`);
                     }
                 });
-                // Channel status change -> monitor broadcast
+                // Channel status change -> monitor broadcast + auto-reconnect on expired
                 ch.onStatusChange((status, detail) => {
                     console.log(`[channel-manager] ${ch.label} status: ${status}${detail ? ` (${detail})` : ''}`);
                     ctx.broadcastMonitor({
@@ -222,11 +228,49 @@ export function createChannelManagerPlugin(channels) {
                         timestamp: new Date().toISOString(),
                         text: `${ch.label}: ${status}${detail ? ` — ${detail}` : ''}`,
                     });
+                    if (status === 'expired') {
+                        scheduleReconnect(ch);
+                    }
+                    else if (status === 'connected') {
+                        // Reset backoff on successful connect
+                        reconnectAttempts.delete(ch.id);
+                        const timer = reconnectTimers.get(ch.id);
+                        if (timer) {
+                            clearTimeout(timer);
+                            reconnectTimers.delete(ch.id);
+                        }
+                    }
                 });
             }
             for (const ch of channels) {
                 wireChannel(ch);
             }
+            // --- Auto-reconnect with exponential backoff ---
+            function scheduleReconnect(ch, overrideDelaySec) {
+                if (reconnectTimers.has(ch.id))
+                    return; // already scheduled
+                const attempt = (reconnectAttempts.get(ch.id) ?? 0) + 1;
+                reconnectAttempts.set(ch.id, attempt);
+                const delaySec = overrideDelaySec ?? Math.min(10 * Math.pow(2, attempt - 1), 300); // 10s, 20s, 40s, ..., max 5min
+                console.log(`[channel-manager] Scheduling reconnect for "${ch.id}" in ${delaySec}s (attempt ${attempt})`);
+                const timer = setTimeout(async () => {
+                    reconnectTimers.delete(ch.id);
+                    console.log(`[channel-manager] Auto-reconnecting "${ch.id}" (attempt ${attempt})...`);
+                    try {
+                        await ch.disconnect();
+                    }
+                    catch { }
+                    try {
+                        await ch.connect();
+                        console.log(`[channel-manager] "${ch.id}" auto-reconnected successfully`);
+                    }
+                    catch (err) {
+                        console.error(`[channel-manager] "${ch.id}" auto-reconnect failed: ${err.message}`);
+                        // onStatusChange will fire 'expired' or 'disconnected' → re-schedule
+                    }
+                }, delaySec * 1000);
+                reconnectTimers.set(ch.id, timer);
+            }
             // --- Runtime channel add/remove ---
             ctx.on('channel:add', async (type, channelId, accountName) => {
                 if (channelMap.has(channelId))
@@ -342,6 +386,30 @@ export function createChannelManagerPlugin(channels) {
             });
             // Permission cleanup interval
             cleanupInterval = setInterval(() => permissionMgr.cleanup(), 60_000);
+            // --- Sleep/wake detection ---
+            // macOS sleep kills TCP connections; detect wake via timer gap and reconnect immediately
+            let lastTick = Date.now();
+            sleepDetectInterval = setInterval(() => {
+                const now = Date.now();
+                const elapsed = now - lastTick;
+                lastTick = now;
+                if (elapsed > SLEEP_THRESHOLD_MS) {
+                    const gapSec = Math.round(elapsed / 1000);
+                    console.log(`[channel-manager] System wake detected (${gapSec}s gap), reconnecting all channels...`);
+                    for (const ch of channelMap.values()) {
+                        if (ch.getStatus() === 'connected' || ch.getStatus() === 'connecting') {
+                            // Cancel any pending scheduled reconnect — we're doing it now
+                            const pending = reconnectTimers.get(ch.id);
+                            if (pending) {
+                                clearTimeout(pending);
+                                reconnectTimers.delete(ch.id);
+                            }
+                            reconnectAttempts.delete(ch.id);
+                            scheduleReconnect(ch, 2); // 2s delay — let network stack settle after wake
+                        }
+                    }
+                }
+            }, SLEEP_DETECT_INTERVAL_MS);
             // --- Connect all channels ---
             for (const ch of channels) {
                 try {
@@ -356,6 +424,12 @@ export function createChannelManagerPlugin(channels) {
         async destroy() {
             if (cleanupInterval)
                 clearInterval(cleanupInterval);
+            if (sleepDetectInterval)
+                clearInterval(sleepDetectInterval);
+            // Cancel pending reconnect timers
+            for (const timer of reconnectTimers.values())
+                clearTimeout(timer);
+            reconnectTimers.clear();
             // Disconnect all channels
             for (const ch of channels) {
                 try {

package/dist/plugins/weixin/connection.d.ts

@@ -19,6 +19,12 @@ export declare class WeixinConnection {
     private onIncoming;
     private listening;
     private cleanupTimer;
+    private consecutiveErrors;
+    private onStalledCallback;
+    constructor(channelId?: string);
+    /** Register a callback fired when polling hits too many consecutive errors. */
+    onStalled(handler: () => void): void;
+    private handlePollError;
     setMessageHandler(handler: OnMessageCallback): void;
     /** Persist context tokens to disk so replies work after hub restart */
     saveContextCache(channelId?: string): void;

package/dist/plugins/weixin/connection.js

@@ -7,7 +7,7 @@ import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join, basename } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { downloadMedia, cleanupMedia } from './media.js';
-import { loadCredentials, CRED_PATH } from './qr-login.js';
+import { loadCredentials, CRED_DIR } from './qr-login.js';
 import { splitIntoChunks, formatChunks } from './chunker.js';
 import { uploadMedia } from './media-upload.js';
 import { SOCKET_DIR } from '../../shared/socket.js';
@@ -15,12 +15,40 @@ const ALLOWED_USERS = process.env.CC2IM_ALLOWED_USERS
     ? process.env.CC2IM_ALLOWED_USERS.split(',').map(s => s.trim())
     : [];
 const CONTEXT_CACHE_PATH = join(SOCKET_DIR, 'weixin-context.json');
+const STALL_THRESHOLD = 5; // consecutive errors before declaring stalled
 export class WeixinConnection {
-    bot = new WeixinBot();
+    bot;
     recentMessages = new Map(); // userId -> raw msg for reply
     onIncoming = null;
     listening = false;
     cleanupTimer = null;
+    consecutiveErrors = 0;
+    onStalledCallback = null;
+    constructor(channelId) {
+        // Each channel gets its own tokenPath so the SDK reads/writes isolated credentials.
+        // Without this, all channels share ~/.weixin-bot/credentials.json and the last
+        // login overwrites everyone else's credentials.
+        const tokenPath = channelId
+            ? join(CRED_DIR, `credentials-${channelId}.json`)
+            : undefined; // SDK default (~/.weixin-bot/credentials.json)
+        this.bot = new WeixinBot({
+            tokenPath,
+            onError: (error) => this.handlePollError(error),
+        });
+    }
+    /** Register a callback fired when polling hits too many consecutive errors. */
+    onStalled(handler) {
+        this.onStalledCallback = handler;
+    }
+    handlePollError(_error) {
+        this.consecutiveErrors++;
+        if (this.consecutiveErrors >= STALL_THRESHOLD && this.onStalledCallback) {
+            console.error(`[weixin] ${this.consecutiveErrors} consecutive poll errors, signalling stall`);
+            this.onStalledCallback();
+            // Reset so callback isn't fired on every subsequent error
+            this.consecutiveErrors = 0;
+        }
+    }
     setMessageHandler(handler) {
         this.onIncoming = handler;
     }
@@ -70,17 +98,19 @@ export class WeixinConnection {
         catch { }
     }
     async login(channelId) {
-        // Load per-channel credentials (falls back to global file)
-        const channelCreds = loadCredentials(channelId);
-        if (!channelCreds) {
-            throw new Error('未找到微信登录凭证! 请先运行: cc2im login');
+        // Per-channel credentials are handled by the SDK's tokenPath (set in constructor).
+        // For backward compat: if no per-channel file exists, copy from global file.
+        if (channelId) {
+            const channelCredPath = join(CRED_DIR, `credentials-${channelId}.json`);
+            if (!existsSync(channelCredPath)) {
+                // Fall back: try loading from our qr-login module (checks per-channel then global)
+                const fallback = loadCredentials(channelId);
+                if (fallback) {
+                    writeFileSync(channelCredPath, JSON.stringify(fallback, null, 2) + '\n', { mode: 0o600 });
+                }
+            }
         }
-        // Write per-channel creds to the global path so the SDK picks them up.
-        // TODO: Race condition if two channels call login() concurrently — channel B
-        // could overwrite the global file before channel A's bot.login() reads it.
-        // Currently safe because channel-manager starts channels sequentially.
-        writeFileSync(CRED_PATH, JSON.stringify(channelCreds, null, 2) + '\n', { mode: 0o600 });
-        console.log('[hub] 使用已保存的凭证登录微信...');
+        console.log(`[hub] 使用已保存的凭证登录微信 (${channelId || 'default'})...`);
         const creds = await this.bot.login();
         console.log(`[hub] 微信连接成功! accountId=${creds.accountId}`);
         if (ALLOWED_USERS.length === 0) {
@@ -97,6 +127,8 @@ export class WeixinConnection {
         cleanupMedia();
         this.cleanupTimer = setInterval(cleanupMedia, 6 * 60 * 60 * 1000);
         this.bot.onMessage(async (msg) => {
+            // Successful message = connection healthy
+            this.consecutiveErrors = 0;
             // Allowlist check
             if (ALLOWED_USERS.length > 0 && !ALLOWED_USERS.includes(msg.userId)) {
                 console.log(`[hub] Blocked message from unlisted user: ${msg.userId}`);

package/dist/plugins/weixin/weixin-channel.js

@@ -24,9 +24,18 @@ export class WeixinChannel {
     async connect() {
         this.setStatus('connecting');
         try {
+            // Fresh connection on every connect() — avoids Node.js fetch reusing
+            // stale TCP connections from a previous session (e.g. after macOS sleep/wake)
+            this.weixin = new WeixinConnection(this.id);
             await this.weixin.login(this.id);
             this.weixin.restoreContextCache(this.id);
             this.registerMessageBridge();
+            // Detect stalled polling (too many consecutive timeouts) → mark expired
+            this.weixin.onStalled(() => {
+                if (this.status !== 'disconnected') {
+                    this.setStatus('expired', 'Long-poll stalled: consecutive timeouts');
+                }
+            });
             this.weixin.startListening();
             // startPolling is a long-running loop — fire-and-forget.
             // If it exits (session expired / network error), mark status.

package/dist/spoke/index.js

@@ -99,7 +99,8 @@ const ppidCheck = setInterval(() => {
 async function main() {
     // Connect MCP stdio first (CC is waiting for it)
     await connectTransport(server);
-    // Then connect to hub
+    // Then connect to hub (exit if hub is unreachable for too long)
+    socketClient.onReconnectGiveUp(() => gracefulExit('Hub unreachable, giving up reconnect'));
     await socketClient.connect();
     // Report ready
     socketClient.send({ type: 'status', agentId, status: 'ready' });

package/dist/spoke/socket-client.d.ts

@@ -6,6 +6,8 @@ export declare class SpokeSocketClient {
     private reconnectTimer;
     private reconnectDelay;
     private connected;
+    private disconnectedSince;
+    private onGiveUp;
     constructor(agentId: string, onMessage: (msg: HubToSpoke) => void);
     /**
      * Start connecting to hub. Resolves immediately — connection happens
@@ -14,6 +16,8 @@ export declare class SpokeSocketClient {
      */
     connect(): Promise<void>;
     private doConnect;
+    /** Register a callback invoked when reconnect attempts are exhausted (hub unreachable for too long). */
+    onReconnectGiveUp(handler: () => void): void;
     private scheduleReconnect;
     /** Send a message. Returns false if not connected (message dropped). */
     send(msg: SpokeToHub): boolean;

package/dist/spoke/socket-client.js

@@ -2,6 +2,7 @@ import { createConnection } from 'node:net';
 import { HUB_SOCKET_PATH, encodeFrame, createFrameParser } from '../shared/socket.js';
 const RECONNECT_INTERVAL = 3000;
 const MAX_RECONNECT_INTERVAL = 30000;
+const MAX_RECONNECT_DURATION_MS = 60_000; // give up after 60s of failed reconnects
 export class SpokeSocketClient {
     socket = null;
     agentId;
@@ -9,6 +10,8 @@ export class SpokeSocketClient {
     reconnectTimer = null;
     reconnectDelay = RECONNECT_INTERVAL;
     connected = false;
+    disconnectedSince = null;
+    onGiveUp = null;
     constructor(agentId, onMessage) {
         this.agentId = agentId;
         this.onMessage = onMessage;
@@ -27,6 +30,7 @@ export class SpokeSocketClient {
             this.socket = socket;
             this.connected = true;
             this.reconnectDelay = RECONNECT_INTERVAL;
+            this.disconnectedSince = null; // reset on successful connect
             socket.write(encodeFrame({ type: 'register', agentId: this.agentId, pid: process.pid }));
             console.log(`[spoke:${this.agentId}] Connected to hub`);
         });
@@ -50,9 +54,23 @@ export class SpokeSocketClient {
             this.scheduleReconnect();
         });
     }
+    /** Register a callback invoked when reconnect attempts are exhausted (hub unreachable for too long). */
+    onReconnectGiveUp(handler) {
+        this.onGiveUp = handler;
+    }
     scheduleReconnect() {
         if (this.reconnectTimer)
             return;
+        // Track how long we've been disconnected
+        if (this.disconnectedSince === null) {
+            this.disconnectedSince = Date.now();
+        }
+        const elapsed = Date.now() - this.disconnectedSince;
+        if (elapsed > MAX_RECONNECT_DURATION_MS) {
+            console.log(`[spoke:${this.agentId}] Hub unreachable for ${Math.round(elapsed / 1000)}s, giving up`);
+            this.onGiveUp?.();
+            return;
+        }
         console.log(`[spoke:${this.agentId}] Reconnecting in ${this.reconnectDelay / 1000}s...`);
         this.reconnectTimer = setTimeout(() => {
             this.reconnectTimer = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc2im",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "IM gateway for multiple local Claude Code instances",
   "author": "roxorlt",
   "license": "MIT",