cc2im 0.2.0

package/dist/hub/agent-manager.js

@@ -0,0 +1,311 @@
+/**
+ * Agent Lifecycle Manager — hub 侧
+ * 管理 agent 的注册/注销、启动/停止、健康检查
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+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 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
+export class AgentManager {
+    processes = new Map();
+    config;
+    getConnectedAgents;
+    onEvent;
+    stoppedManually = new Set(); // agents stopped by user intent
+    shuttingDown = false; // suppress auto-restart during hub shutdown
+    restartAttempts = new Map(); // backoff tracking
+    constructor(getConnectedAgents, onEvent) {
+        this.config = this.loadConfig();
+        this.getConnectedAgents = getConnectedAgents;
+        this.onEvent = onEvent;
+    }
+    loadConfig() {
+        if (existsSync(AGENTS_JSON_PATH)) {
+            return JSON.parse(readFileSync(AGENTS_JSON_PATH, 'utf8'));
+        }
+        return { defaultAgent: 'brain', agents: {} };
+    }
+    saveConfig() {
+        writeFileSync(AGENTS_JSON_PATH, JSON.stringify(this.config, null, 2) + '\n');
+    }
+    getConfig() {
+        return this.config;
+    }
+    reloadConfig() {
+        this.config = this.loadConfig();
+    }
+    register(name, cwd, claudeArgs) {
+        if (this.config.agents[name]) {
+            return { success: false, error: `Agent "${name}" already exists` };
+        }
+        if (!existsSync(cwd)) {
+            return { success: false, error: `Directory "${cwd}" does not exist` };
+        }
+        this.config.agents[name] = {
+            name,
+            cwd,
+            claudeArgs,
+            createdAt: new Date().toISOString().split('T')[0],
+            autoStart: true,
+        };
+        this.saveConfig();
+        console.log(`[agent-manager] Registered "${name}" → ${cwd}`);
+        return { success: true };
+    }
+    async deregister(name) {
+        if (!this.config.agents[name]) {
+            return { success: false, error: `Agent "${name}" not found` };
+        }
+        await this.stop(name);
+        delete this.config.agents[name];
+        if (this.config.defaultAgent === name) {
+            const remaining = Object.keys(this.config.agents);
+            this.config.defaultAgent = remaining[0] || '';
+        }
+        this.saveConfig();
+        console.log(`[agent-manager] Deregistered "${name}"`);
+        return { success: true };
+    }
+    start(name) {
+        if (!this.config.agents[name]) {
+            return { success: false, error: `Agent "${name}" not found in config` };
+        }
+        // Guard: refuse to spawn if spoke is already connected (externally started)
+        const connected = this.getConnectedAgents();
+        if (!this.processes.has(name) && connected.includes(name)) {
+            return { success: false, error: `Agent "${name}" is already running externally (spoke connected). Stop it manually first.` };
+        }
+        // If process exists but spoke not connected, it's stale — kill and restart
+        if (this.processes.has(name)) {
+            if (connected.includes(name)) {
+                return { success: false, error: `Agent "${name}" is already running and connected` };
+            }
+            console.log(`[agent-manager] Agent "${name}" has stale process (not connected), restarting`);
+            const stale = this.processes.get(name);
+            this.killProcessTree(stale);
+            this.processes.delete(name);
+        }
+        const agent = this.config.agents[name];
+        // Resolve spoke script path (works for both tsx/src and compiled/dist)
+        const dir = import.meta.dirname;
+        const spokeTs = join(dir, '..', 'spoke', 'index.ts');
+        const spokeJs = join(dir, '..', 'spoke', 'index.js');
+        const spokeScript = existsSync(spokeTs) ? spokeTs : spokeJs;
+        // Write .mcp.json in agent's cwd
+        ensureMcpJson(agent.cwd, spokeScript, name);
+        // 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;
+        const claudeArgs = [
+            '--dangerously-load-development-channels', 'server:cc2im',
+            ...(useAutoMode ? ['--enable-auto-mode'] : []),
+            ...(agent.claudeArgs || []),
+        ];
+        // Use `expect` to allocate a pseudo-tty so CC enters interactive mode.
+        // Unlike `script`, `expect` creates its own pty without needing a tty stdin.
+        // The expect script auto-approves the workspace trust prompt and then waits.
+        const logPath = join(agentDir, 'claude.log');
+        const expectScriptPath = join(agentDir, 'start.exp');
+        const expectScript = [
+            `log_file -a {${logPath}}`,
+            `spawn claude ${claudeArgs.map(a => `{${a}}`).join(' ')}`,
+            '',
+            '# Auto-approve workspace trust prompt if it appears',
+            'set timeout 30',
+            'expect {',
+            '  "confirm" {',
+            '    after 500',
+            '    send "\\r"',
+            '  }',
+            '  timeout {}',
+            '}',
+            '',
+            '# Keep CC running until it exits',
+            'set timeout -1',
+            'expect eof',
+        ].join('\n');
+        writeFileSync(expectScriptPath, expectScript + '\n');
+        // macOS: caffeinate -i prevents idle sleep
+        const cmd = process.platform === 'darwin' ? 'caffeinate' : 'expect';
+        const args = process.platform === 'darwin'
+            ? ['-i', 'expect', expectScriptPath]
+            : [expectScriptPath];
+        console.log(`[agent-manager] Starting "${name}" in ${agent.cwd}`);
+        const child = spawn(cmd, args, {
+            cwd: agent.cwd,
+            stdio: ['pipe', 'ignore', 'ignore'],
+            detached: true, // new process group — allows killing entire tree with -pid
+        });
+        child.on('exit', (code) => {
+            console.log(`[agent-manager] Agent "${name}" exited (code ${code})`);
+            this.processes.delete(name);
+            this.onEvent?.('agent_stopped', name, { code });
+            // Don't restart if: shutting down, or user explicitly stopped
+            if (this.shuttingDown)
+                return;
+            if (this.stoppedManually.has(name)) {
+                this.stoppedManually.delete(name);
+                this.restartAttempts.delete(name);
+                return;
+            }
+            const agentConfig = this.config.agents[name];
+            if (!agentConfig?.autoStart)
+                return;
+            // Backoff: track consecutive restarts within time window
+            const now = Date.now();
+            const attempts = this.restartAttempts.get(name);
+            if (attempts && now - attempts.firstAt < RESTART_WINDOW_MS) {
+                attempts.count++;
+                if (attempts.count > MAX_RESTART_ATTEMPTS) {
+                    console.error(`[agent-manager] "${name}" crashed ${attempts.count} times in ${Math.round((now - attempts.firstAt) / 1000)}s — giving up auto-restart`);
+                    this.restartAttempts.delete(name);
+                    this.onEvent?.('agent_dead', name);
+                    return;
+                }
+            }
+            else {
+                this.restartAttempts.set(name, { count: 1, firstAt: now });
+            }
+            const attempt = this.restartAttempts.get(name);
+            const delay = RESTART_DELAY_MS * attempt.count; // 5s, 10s, 15s, 20s, 25s
+            console.log(`[agent-manager] Auto-restarting "${name}" in ${delay / 1000}s (attempt ${attempt.count}/${MAX_RESTART_ATTEMPTS})`);
+            setTimeout(() => {
+                if (this.shuttingDown || this.stoppedManually.has(name))
+                    return;
+                const result = this.start(name);
+                if (!result.success) {
+                    console.log(`[agent-manager] Failed to restart "${name}": ${result.error}`);
+                }
+            }, delay);
+        });
+        this.processes.set(name, child);
+        this.onEvent?.('agent_started', name);
+        return { success: true };
+    }
+    /** Stop an agent and wait for the process to exit (with timeout).
+     *  Marks as manually stopped — will NOT auto-restart. */
+    stop(name) {
+        const child = this.processes.get(name);
+        if (!child) {
+            return Promise.resolve({ success: false, error: `Agent "${name}" is not running` });
+        }
+        this.stoppedManually.add(name);
+        return new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                // Force kill entire process tree if SIGTERM didn't work
+                this.killProcessTree(child);
+                this.processes.delete(name);
+                console.log(`[agent-manager] Force-killed "${name}" (SIGTERM timeout)`);
+                resolve({ success: true });
+            }, STOP_TIMEOUT_MS);
+            child.once('exit', () => {
+                clearTimeout(timeout);
+                this.processes.delete(name);
+                console.log(`[agent-manager] Stopped "${name}"`);
+                resolve({ success: true });
+            });
+            // SIGTERM the entire process group
+            this.killProcessTree(child, 'SIGTERM');
+        });
+    }
+    list() {
+        const connected = this.getConnectedAgents();
+        return Object.entries(this.config.agents).map(([name, agent]) => ({
+            name,
+            cwd: agent.cwd,
+            // 'connected' = spoke online, 'starting' = process spawned but not yet connected, 'stopped' = no process
+            status: connected.includes(name) ? 'connected'
+                : this.processes.has(name) ? 'starting'
+                    : 'stopped',
+            autoStart: agent.autoStart ?? false,
+            claudeArgs: agent.claudeArgs || [],
+            isDefault: this.config.defaultAgent === name,
+        }));
+    }
+    /** Kill an agent's entire process tree (caffeinate → expect → claude).
+     *  Uses negative PID to kill the process group created by detached: true. */
+    killProcessTree(child, signal = 'SIGKILL') {
+        try {
+            // Kill entire process group (negative PID)
+            process.kill(-child.pid, signal);
+        }
+        catch {
+            // Fallback: kill just the child
+            try {
+                child.kill(signal);
+            }
+            catch { /* already dead */ }
+        }
+    }
+    /** Kill an agent's process for restart (e.g., after heartbeat eviction).
+     *  Does NOT mark as manually stopped — child.on('exit') will auto-restart. */
+    killForRestart(name) {
+        const child = this.processes.get(name);
+        if (child) {
+            console.log(`[agent-manager] Killing "${name}" for restart`);
+            this.killProcessTree(child);
+        }
+    }
+    async restart(name) {
+        // Only restart hub-managed agents. Externally started agents (foreground CLI)
+        // cannot be stopped by the hub — refuse rather than spawn a duplicate.
+        if (!this.processes.has(name)) {
+            const connected = this.getConnectedAgents();
+            if (connected.includes(name)) {
+                return { success: false, error: `Agent "${name}" was started externally. Stop it manually, then use start.` };
+            }
+            return { success: false, error: `Agent "${name}" is not running` };
+        }
+        await this.stop(name);
+        this.stoppedManually.delete(name); // restart is intentional, allow re-start
+        this.restartAttempts.delete(name); // reset backoff
+        return this.start(name);
+    }
+    updateEffort(name, effort) {
+        if (!this.config.agents[name]) {
+            return { success: false, error: `Agent "${name}" not found` };
+        }
+        const agent = this.config.agents[name];
+        const args = agent.claudeArgs || [];
+        const effortIdx = args.indexOf('--effort');
+        if (effortIdx >= 0) {
+            args[effortIdx + 1] = effort;
+        }
+        else {
+            args.push('--effort', effort);
+        }
+        agent.claudeArgs = args;
+        this.saveConfig();
+        return { success: true };
+    }
+    startAutoAgents() {
+        for (const [name, agent] of Object.entries(this.config.agents)) {
+            if (agent.autoStart) {
+                const result = this.start(name);
+                if (result.success) {
+                    console.log(`[agent-manager] Auto-started "${name}"`);
+                }
+                else {
+                    console.log(`[agent-manager] Failed to auto-start "${name}": ${result.error}`);
+                }
+            }
+        }
+    }
+    /** Check if this agent's process is managed (spawned) by the hub. */
+    isManaged(name) {
+        return this.processes.has(name);
+    }
+    async stopAll() {
+        this.shuttingDown = true;
+        const names = [...this.processes.keys()];
+        await Promise.all(names.map(name => this.stop(name)));
+    }
+}

package/dist/hub/hub-context.d.ts

@@ -0,0 +1,27 @@
+import { EventEmitter } from 'node:events';
+import type { HubSocketServer } from './socket-server.js';
+import type { AgentManager } from './agent-manager.js';
+import type { Router } from './router.js';
+import type { HubContext } from '../shared/plugin.js';
+import type { AgentsConfig, HubToSpoke, HubEventData } from '../shared/types.js';
+import type { Cc2imChannel } from '../shared/channel.js';
+export declare class HubContextImpl extends EventEmitter implements HubContext {
+    private socketServer;
+    private agentManager;
+    private router;
+    private config;
+    private channels;
+    constructor(socketServer: HubSocketServer, agentManager: AgentManager, router: Router, config: AgentsConfig);
+    deliverToAgent(agentId: string, msg: HubToSpoke): boolean;
+    broadcastMonitor(event: HubEventData): void;
+    getConnectedAgents(): string[];
+    getAgentManager(): AgentManager;
+    getRouter(): Router;
+    getConfig(): AgentsConfig;
+    registerChannel(channel: Cc2imChannel): void;
+    getChannel(channelId: string): Cc2imChannel | undefined;
+    getChannels(): Cc2imChannel[];
+    addChannel(type: string, channelId: string, accountName: string): Promise<void>;
+    removeChannel(channelId: string): Promise<void>;
+    reconnectChannel(channelId: string): Promise<void>;
+}

package/dist/hub/hub-context.js

@@ -0,0 +1,57 @@
+import { EventEmitter } from 'node:events';
+import { randomUUID } from 'node:crypto';
+export class HubContextImpl extends EventEmitter {
+    socketServer;
+    agentManager;
+    router;
+    config;
+    channels = new Map();
+    constructor(socketServer, agentManager, router, config) {
+        super();
+        this.socketServer = socketServer;
+        this.agentManager = agentManager;
+        this.router = router;
+        this.config = config;
+    }
+    deliverToAgent(agentId, msg) {
+        const messageId = randomUUID();
+        this.emit('deliver:before', agentId, msg, messageId);
+        const ok = this.socketServer.send(agentId, msg);
+        this.emit('deliver:after', messageId, ok);
+        return ok;
+    }
+    broadcastMonitor(event) {
+        this.socketServer.broadcast(event);
+    }
+    getConnectedAgents() {
+        return this.socketServer.getConnectedAgents();
+    }
+    getAgentManager() {
+        return this.agentManager;
+    }
+    getRouter() {
+        return this.router;
+    }
+    getConfig() {
+        return this.config;
+    }
+    registerChannel(channel) {
+        this.channels.set(channel.id, channel);
+    }
+    getChannel(channelId) {
+        return this.channels.get(channelId);
+    }
+    getChannels() {
+        return Array.from(this.channels.values());
+    }
+    async addChannel(type, channelId, accountName) {
+        this.emit('channel:add', type, channelId, accountName);
+    }
+    async removeChannel(channelId) {
+        this.channels.delete(channelId);
+        this.emit('channel:remove', channelId);
+    }
+    async reconnectChannel(channelId) {
+        this.emit('channel:reconnect', channelId);
+    }
+}

package/dist/hub/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * cc2im Hub — 常驻进程，核心路由 + 插件加载
+ */
+export declare function startHub(options?: {
+    autoStartAgents?: boolean;
+}): Promise<void>;

package/dist/hub/index.js

@@ -0,0 +1,234 @@
+/**
+ * cc2im Hub — 常驻进程，核心路由 + 插件加载
+ */
+import { existsSync, readFileSync, statSync, truncateSync } from 'node:fs';
+import { join } from 'node:path';
+import { HubSocketServer } from './socket-server.js';
+import { Router } from './router.js';
+import { AgentManager } from './agent-manager.js';
+import { HubContextImpl } from './hub-context.js';
+import { PluginManager } from './plugin-manager.js';
+import { createPersistencePlugin } from '../plugins/persistence/index.js';
+import { createCronSchedulerPlugin } from '../plugins/cron-scheduler/index.js';
+import { WeixinChannel } from '../plugins/weixin/weixin-channel.js';
+import { loadChannelConfigs } from '../shared/channel-config.js';
+import { createChannelManagerPlugin } from '../plugins/channel-manager/index.js';
+import { createWebMonitorPlugin } from '../plugins/web-monitor/index.js';
+import { SOCKET_DIR } from '../shared/socket.js';
+// --- Config ---
+const AGENTS_JSON_PATH = join(SOCKET_DIR, 'agents.json');
+function loadAgentsConfig() {
+    if (existsSync(AGENTS_JSON_PATH)) {
+        return JSON.parse(readFileSync(AGENTS_JSON_PATH, 'utf8'));
+    }
+    return { defaultAgent: 'brain', agents: {} };
+}
+const MAX_LOG_BYTES = 50 * 1024 * 1024; // 50 MB
+function truncateLogs() {
+    const logDir = SOCKET_DIR;
+    for (const name of ['hub.log', 'hub.error.log']) {
+        const p = join(logDir, name);
+        try {
+            if (existsSync(p) && statSync(p).size > MAX_LOG_BYTES) {
+                truncateSync(p, 0);
+                console.log(`[hub] Truncated oversized log: ${name}`);
+            }
+        }
+        catch { }
+    }
+}
+// --- Main ---
+export async function startHub(options) {
+    truncateLogs();
+    const config = loadAgentsConfig();
+    const router = new Router(config);
+    let socketServer;
+    let ctx;
+    const agentManager = new AgentManager(() => socketServer.getConnectedAgents(), (kind, agentId, extra) => {
+        const event = { kind: kind, agentId, timestamp: new Date().toISOString(), ...extra };
+        ctx.broadcastMonitor(event);
+        if (kind === 'agent_dead')
+            ctx.emit('agent:dead', agentId);
+    });
+    socketServer = new HubSocketServer(async (agentId, msg) => {
+        // Management messages are core — handle before emitting to plugins
+        if (msg.type === 'management') {
+            await handleManagement(agentId, msg, agentManager, router, socketServer, ctx);
+            return;
+        }
+        ctx.emit('spoke:message', agentId, msg);
+    }, {
+        onEvict: (agentId) => {
+            ctx.emit('agent:evicted', agentId);
+            // Kill the process — child.on('exit') in AgentManager will handle restart
+            if (agentManager.isManaged(agentId)) {
+                agentManager.killForRestart(agentId);
+            }
+        },
+        onAgentOnline: (agentId) => ctx.emit('agent:online', agentId),
+        onAgentOffline: (agentId) => ctx.emit('agent:offline', agentId),
+    });
+    ctx = new HubContextImpl(socketServer, agentManager, router, config);
+    const pluginManager = new PluginManager();
+    const channelConfigs = loadChannelConfigs();
+    const channels = channelConfigs.map(cfg => {
+        switch (cfg.type) {
+            case 'weixin':
+                return new WeixinChannel(cfg.id, cfg.accountName);
+            default:
+                console.warn(`[hub] Unknown channel type: ${cfg.type}, skipping "${cfg.id}"`);
+                return null;
+        }
+    }).filter((ch) => ch !== null);
+    if (channels.length === 0) {
+        console.warn('[hub] No channels configured, creating default weixin channel');
+        channels.push(new WeixinChannel());
+    }
+    pluginManager.register(createPersistencePlugin());
+    pluginManager.register(createCronSchedulerPlugin());
+    pluginManager.register(createChannelManagerPlugin(channels));
+    pluginManager.register(createWebMonitorPlugin());
+    // --- Start ---
+    await socketServer.start();
+    await pluginManager.initAll(ctx);
+    if (options?.autoStartAgents) {
+        agentManager.startAutoAgents();
+    }
+    ctx.emit('hub:ready');
+    // Graceful shutdown
+    const shutdown = async () => {
+        console.log('[hub] Shutting down...');
+        ctx.emit('hub:shutdown');
+        await pluginManager.destroyAll();
+        await agentManager.stopAll();
+        socketServer.stop();
+        process.exit(0);
+    };
+    process.on('SIGTERM', shutdown);
+    process.on('SIGINT', shutdown);
+}
+/** Handle management messages (agent register/start/stop/list) — core logic */
+async function handleManagement(agentId, msg, agentManager, router, socketServer, ctx) {
+    console.log(`[hub] Management request from ${agentId}: ${msg.action}`);
+    const targetName = msg.params?.name;
+    const isSelfAction = targetName === agentId &&
+        (msg.action === 'stop' || msg.action === 'deregister');
+    const sendResult = (result) => {
+        socketServer.send(agentId, {
+            type: 'management_result',
+            requestId: msg.requestId,
+            success: result.success,
+            data: result.data,
+            error: result.error,
+        });
+    };
+    let result;
+    switch (msg.action) {
+        case 'register': {
+            result = agentManager.register(msg.params.name, msg.params.cwd, msg.params.claudeArgs);
+            if (result.success) {
+                router.updateConfig(agentManager.getConfig());
+                ctx.broadcastMonitor({ kind: 'config_changed', agentId: msg.params.name, timestamp: new Date().toISOString() });
+            }
+            break;
+        }
+        case 'deregister': {
+            if (isSelfAction) {
+                sendResult({ success: true });
+                await agentManager.deregister(msg.params.name);
+                router.updateConfig(agentManager.getConfig());
+                ctx.broadcastMonitor({ kind: 'config_changed', agentId: msg.params.name, timestamp: new Date().toISOString() });
+                return;
+            }
+            result = await agentManager.deregister(msg.params.name);
+            if (result.success) {
+                router.updateConfig(agentManager.getConfig());
+                ctx.broadcastMonitor({ kind: 'config_changed', agentId: msg.params.name, timestamp: new Date().toISOString() });
+            }
+            break;
+        }
+        case 'start': {
+            result = agentManager.start(msg.params.name);
+            break;
+        }
+        case 'stop': {
+            if (!agentManager.isManaged(targetName)) {
+                result = { success: false, error: `Agent "${targetName}" is not managed by this hub (started externally)` };
+                break;
+            }
+            if (isSelfAction) {
+                sendResult({ success: true });
+                await agentManager.stop(msg.params.name);
+                return;
+            }
+            result = await agentManager.stop(msg.params.name);
+            break;
+        }
+        case 'list': {
+            result = { success: true, data: agentManager.list() };
+            break;
+        }
+        case 'cron_create': {
+            const { createJob: dbCreate, CronScheduler: Sched } = await import('../plugins/cron-scheduler/index.js');
+            const p = msg.params;
+            const tmpSched = new Sched(ctx);
+            const nextRun = tmpSched.calcNextRun(p.scheduleType, p.scheduleValue, p.timezone || 'Asia/Shanghai');
+            if (!nextRun) {
+                const errMsg = p.scheduleType === 'once'
+                    ? 'Once schedule is in the past'
+                    : `Invalid schedule: ${p.scheduleType} "${p.scheduleValue}"`;
+                result = { success: false, error: errMsg };
+                break;
+            }
+            const job = dbCreate({
+                name: p.name,
+                agentId: p.agentId || agentId,
+                scheduleType: p.scheduleType,
+                scheduleValue: p.scheduleValue,
+                timezone: p.timezone || 'Asia/Shanghai',
+                message: p.message,
+                enabled: true,
+                nextRun,
+                createdBy: agentId,
+            });
+            result = { success: true, data: job };
+            break;
+        }
+        case 'cron_list': {
+            const { listJobs: dbList, getRecentRuns: dbRuns } = await import('../plugins/cron-scheduler/index.js');
+            const jobs = dbList(msg.params?.agentId);
+            const data = jobs.map(j => ({
+                ...j,
+                recentRuns: dbRuns(j.id, 5),
+            }));
+            result = { success: true, data };
+            break;
+        }
+        case 'cron_delete': {
+            const { deleteJob: dbDelete } = await import('../plugins/cron-scheduler/index.js');
+            const ok = dbDelete(msg.params.jobId);
+            result = ok ? { success: true } : { success: false, error: 'Job not found' };
+            break;
+        }
+        case 'cron_update': {
+            const { updateJob: dbUpdate } = await import('../plugins/cron-scheduler/index.js');
+            const { jobId, ...updates } = msg.params;
+            const ok = dbUpdate(jobId, updates);
+            result = ok ? { success: true } : { success: false, error: 'Job not found' };
+            break;
+        }
+        default:
+            result = { success: false, error: `Unknown action: ${msg.action}` };
+    }
+    if (!isSelfAction) {
+        sendResult(result);
+    }
+}
+// Run if executed directly (not imported)
+const isDirectRun = process.argv[1]?.includes('hub/index');
+if (isDirectRun) {
+    startHub().catch((err) => {
+        console.error(`[hub] Fatal: ${err.message}`);
+        process.exit(1);
+    });
+}

package/dist/hub/launchd.d.ts

@@ -0,0 +1,7 @@
+/**
+ * launchd 集成 — macOS 后台服务化
+ */
+export declare function install(): void;
+export declare function uninstall(): void;
+export declare function status(): void;
+export declare function logs(): void;