cc2im 0.2.0

package/dist/hub/launchd.js

@@ -0,0 +1,151 @@
+/**
+ * launchd 集成 — macOS 后台服务化
+ */
+import { writeFileSync, readFileSync, unlinkSync, existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { execSync, spawn } from 'node:child_process';
+import { SOCKET_DIR } from '../shared/socket.js';
+const PLIST_LABEL = 'com.cc2im.hub';
+const PLIST_DIR = join(homedir(), 'Library', 'LaunchAgents');
+const PLIST_PATH = join(PLIST_DIR, `${PLIST_LABEL}.plist`);
+const LOG_PATH = join(SOCKET_DIR, 'hub.log');
+const ERROR_LOG_PATH = join(SOCKET_DIR, 'hub.error.log');
+function findBinary(name) {
+    try {
+        return execSync(`which ${name}`, { encoding: 'utf8' }).trim();
+    }
+    catch {
+        throw new Error(`"${name}" not found in PATH`);
+    }
+}
+function getCliScript() {
+    // Resolve cli.ts/cli.js path relative to this file
+    const dir = import.meta.dirname;
+    const cliTs = join(dir, '..', 'cli.ts');
+    const cliJs = join(dir, '..', 'cli.js');
+    if (existsSync(cliTs))
+        return cliTs;
+    if (existsSync(cliJs))
+        return cliJs;
+    throw new Error('Cannot find cli entry point');
+}
+export function install() {
+    if (process.platform !== 'darwin') {
+        console.error('[cc2im] launchd is macOS-only');
+        process.exit(1);
+    }
+    const npxPath = findBinary('npx');
+    const cliScript = getCliScript();
+    const pathEnv = process.env.PATH || '/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin';
+    mkdirSync(PLIST_DIR, { recursive: true });
+    mkdirSync(SOCKET_DIR, { recursive: true });
+    const plist = `<?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>${PLIST_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>caffeinate</string>
+    <string>-i</string>
+    <string>${npxPath}</string>
+    <string>tsx</string>
+    <string>${cliScript}</string>
+    <string>start</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${LOG_PATH}</string>
+  <key>StandardErrorPath</key>
+  <string>${ERROR_LOG_PATH}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${pathEnv}</string>
+    <key>HOME</key>
+    <string>${homedir()}</string>
+  </dict>
+  <key>WorkingDirectory</key>
+  <string>${homedir()}</string>
+</dict>
+</plist>
+`;
+    writeFileSync(PLIST_PATH, plist);
+    console.log(`[cc2im] Plist written to ${PLIST_PATH}`);
+    try {
+        execSync(`launchctl load ${PLIST_PATH}`, { stdio: 'inherit' });
+        console.log(`[cc2im] Service loaded: ${PLIST_LABEL}`);
+    }
+    catch {
+        console.error('[cc2im] Failed to load service. You may need to load manually:');
+        console.error(`  launchctl load ${PLIST_PATH}`);
+    }
+}
+export function uninstall() {
+    if (existsSync(PLIST_PATH)) {
+        try {
+            execSync(`launchctl unload ${PLIST_PATH}`, { stdio: 'inherit' });
+            console.log(`[cc2im] Service unloaded`);
+        }
+        catch {
+            console.log('[cc2im] Service was not loaded');
+        }
+        unlinkSync(PLIST_PATH);
+        console.log(`[cc2im] Plist removed: ${PLIST_PATH}`);
+    }
+    else {
+        console.log(`[cc2im] No plist found at ${PLIST_PATH}`);
+    }
+}
+export function status() {
+    // Check launchd service
+    try {
+        const output = execSync('launchctl list', { encoding: 'utf8' });
+        const line = output.split('\n').find(l => l.includes('cc2im'));
+        if (line) {
+            console.log(`Hub service: ${line.trim()}`);
+        }
+        else {
+            console.log('Hub service: not loaded');
+        }
+    }
+    catch {
+        console.log('Hub service: unable to check');
+    }
+    // Check socket file
+    const hubSockPath = join(SOCKET_DIR, 'hub.sock');
+    console.log(`Hub socket: ${existsSync(hubSockPath) ? 'exists' : 'not found'}`);
+    // Check agents.json
+    const agentsPath = join(SOCKET_DIR, 'agents.json');
+    if (existsSync(agentsPath)) {
+        try {
+            const config = JSON.parse(readFileSync(agentsPath, 'utf8'));
+            const names = Object.keys(config.agents);
+            console.log(`Agents configured: ${names.join(', ') || 'none'}`);
+            console.log(`Default agent: ${config.defaultAgent}`);
+        }
+        catch {
+            console.log('Agents config: unable to parse');
+        }
+    }
+}
+export function logs() {
+    console.log(`[cc2im] Tailing logs from ${LOG_PATH} and ${ERROR_LOG_PATH}`);
+    console.log('Press Ctrl+C to stop.\n');
+    const files = [];
+    if (existsSync(LOG_PATH))
+        files.push(LOG_PATH);
+    if (existsSync(ERROR_LOG_PATH))
+        files.push(ERROR_LOG_PATH);
+    if (files.length === 0) {
+        console.log('No log files found yet.');
+        return;
+    }
+    const tail = spawn('tail', ['-f', ...files], { stdio: 'inherit' });
+    tail.on('exit', () => process.exit(0));
+}

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

@@ -0,0 +1,7 @@
+import type { Cc2imPlugin, HubContext } from '../shared/plugin.js';
+export declare class PluginManager {
+    private plugins;
+    register(plugin: Cc2imPlugin): void;
+    initAll(ctx: HubContext): Promise<void>;
+    destroyAll(): Promise<void>;
+}

package/dist/hub/plugin-manager.js

@@ -0,0 +1,29 @@
+export class PluginManager {
+    plugins = [];
+    register(plugin) {
+        this.plugins.push(plugin);
+        console.log(`[plugin] Registered: ${plugin.name}`);
+    }
+    async initAll(ctx) {
+        for (const plugin of this.plugins) {
+            try {
+                await plugin.init(ctx);
+                console.log(`[plugin] Initialized: ${plugin.name}`);
+            }
+            catch (err) {
+                console.error(`[plugin] Failed to init "${plugin.name}": ${err.message}`);
+            }
+        }
+    }
+    async destroyAll() {
+        for (const plugin of [...this.plugins].reverse()) {
+            try {
+                await plugin.destroy();
+                console.log(`[plugin] Destroyed: ${plugin.name}`);
+            }
+            catch (err) {
+                console.error(`[plugin] Failed to destroy "${plugin.name}": ${err.message}`);
+            }
+        }
+    }
+}

package/dist/hub/router.d.ts

@@ -0,0 +1,21 @@
+import type { AgentsConfig } from '../shared/types.js';
+export interface RouteResult {
+    agentId: string;
+    text: string;
+    /** true when @mentioned an agent not in config */
+    unknownAgent: boolean;
+    /** intercepted hub command (not forwarded to spoke) */
+    intercepted?: {
+        command: 'restart' | 'effort';
+        args?: string[];
+    };
+    /** channel that originated this message */
+    channelId?: string;
+}
+export declare class Router {
+    private config;
+    constructor(config: AgentsConfig);
+    route(text: string, channelId?: string): RouteResult;
+    getAgentNames(): string[];
+    updateConfig(config: AgentsConfig): void;
+}

package/dist/hub/router.js

@@ -0,0 +1,35 @@
+export class Router {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    route(text, channelId) {
+        const match = text.match(/^@(\S+)\s+([\s\S]+)$/);
+        if (match) {
+            const name = match[1];
+            const content = match[2].trim();
+            if (this.config.agents[name]) {
+                // Check for intercepted commands
+                if (/^(重启|restart)$/i.test(content)) {
+                    return { agentId: name, text: content, unknownAgent: false, intercepted: { command: 'restart' }, channelId };
+                }
+                const effortMatch = content.match(/^\/effort\s+(\S+)$/i);
+                if (effortMatch) {
+                    return { agentId: name, text: content, unknownAgent: false, intercepted: { command: 'effort', args: [effortMatch[1]] }, channelId };
+                }
+                return { agentId: name, text: content, unknownAgent: false, channelId };
+            }
+            // @name not found in config
+            return { agentId: name, text, unknownAgent: true, channelId };
+        }
+        // No @mention: use channel default → global default
+        const defaultAgent = (channelId && this.config.channelDefaults?.[channelId]) || this.config.defaultAgent;
+        return { agentId: defaultAgent, text, unknownAgent: false, channelId };
+    }
+    getAgentNames() {
+        return Object.keys(this.config.agents);
+    }
+    updateConfig(config) {
+        this.config = config;
+    }
+}

package/dist/hub/socket-server.d.ts

@@ -0,0 +1,23 @@
+import type { SpokeToHub, HubToSpoke, HubEventData } from '../shared/types.js';
+export declare class HubSocketServer {
+    private spokes;
+    private lastHeartbeat;
+    private monitors;
+    private server;
+    private onMessage;
+    private onEvict?;
+    private onAgentOnline?;
+    private onAgentOffline?;
+    private heartbeatChecker;
+    constructor(onMessage: (agentId: string, msg: SpokeToHub) => void, opts?: {
+        onEvict?: (agentId: string) => void;
+        onAgentOnline?: (agentId: string) => void;
+        onAgentOffline?: (agentId: string) => void;
+    });
+    start(): Promise<void>;
+    send(agentId: string, msg: HubToSpoke): boolean;
+    /** Broadcast an event to all connected monitors. No-op if none connected. */
+    broadcast(event: HubEventData): void;
+    getConnectedAgents(): string[];
+    stop(): void;
+}

package/dist/hub/socket-server.js

@@ -0,0 +1,191 @@
+import { createServer, createConnection } from 'node:net';
+import { unlinkSync, existsSync } from 'node:fs';
+import { HUB_SOCKET_PATH, ensureSocketDir, encodeFrame, createFrameParser } from '../shared/socket.js';
+/** Check if another hub is already listening on the socket path. */
+function probeSocket(socketPath) {
+    return new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+            conn.destroy();
+            resolve(false); // Timed out — treat as stale
+        }, 1000);
+        const conn = createConnection(socketPath, () => {
+            // Connection succeeded — another hub is alive
+            clearTimeout(timeout);
+            conn.destroy();
+            resolve(true);
+        });
+        conn.on('error', () => {
+            clearTimeout(timeout);
+            resolve(false); // ECONNREFUSED / ENOENT — no hub listening
+        });
+    });
+}
+const HEARTBEAT_TIMEOUT_MS = 45_000; // 3 missed heartbeats (15s interval)
+export class HubSocketServer {
+    spokes = new Map();
+    lastHeartbeat = new Map();
+    monitors = new Set();
+    server = createServer();
+    onMessage;
+    onEvict;
+    onAgentOnline;
+    onAgentOffline;
+    heartbeatChecker = null;
+    constructor(onMessage, opts) {
+        this.onMessage = onMessage;
+        this.onEvict = opts?.onEvict;
+        this.onAgentOnline = opts?.onAgentOnline;
+        this.onAgentOffline = opts?.onAgentOffline;
+    }
+    async start() {
+        ensureSocketDir();
+        // Probe existing socket — refuse to start if another hub is alive
+        if (existsSync(HUB_SOCKET_PATH)) {
+            const alive = await probeSocket(HUB_SOCKET_PATH);
+            if (alive) {
+                console.error(`[hub] ✗ Another hub is already running on ${HUB_SOCKET_PATH}. Stop it first.`);
+                process.exit(1);
+            }
+            // Stale socket from a crash — safe to clean up
+            unlinkSync(HUB_SOCKET_PATH);
+        }
+        this.server.on('connection', (socket) => {
+            let agentId = null;
+            let isMonitor = false;
+            const parser = createFrameParser((frame) => {
+                // First message must be registration (spoke or monitor)
+                if (!agentId && !isMonitor) {
+                    if (frame.type === 'register_monitor') {
+                        isMonitor = true;
+                        this.monitors.add(socket);
+                        console.log(`[hub] Monitor connected (${this.monitors.size} total)`);
+                        // Send current state: all connected spokes
+                        const now = new Date().toISOString();
+                        for (const agId of this.spokes.keys()) {
+                            socket.write(encodeFrame({ type: 'hub_event', event: { kind: 'agent_online', agentId: agId, timestamp: now } }));
+                        }
+                        return;
+                    }
+                    if (frame.type === 'register') {
+                        agentId = frame.agentId;
+                        const existing = this.spokes.get(agentId);
+                        if (existing && existing.socket !== socket) {
+                            console.log(`[hub] Replacing stale connection for ${agentId}`);
+                            existing.socket.destroy();
+                            if (existing.pid) {
+                                try {
+                                    process.kill(existing.pid, 'SIGTERM');
+                                    console.log(`[hub] Killed replaced spoke "${agentId}" (pid ${existing.pid})`);
+                                }
+                                catch { /* already dead */ }
+                            }
+                        }
+                        const rawPid = frame.pid;
+                        const pid = typeof rawPid === 'number' && rawPid > 0 && Number.isInteger(rawPid) ? rawPid : undefined;
+                        this.spokes.set(agentId, { agentId: agentId, socket, pid });
+                        this.lastHeartbeat.set(agentId, Date.now());
+                        console.log(`[hub] Spoke registered: ${agentId}`);
+                        this.broadcast({ kind: 'agent_online', agentId: agentId, timestamp: new Date().toISOString() });
+                        this.onAgentOnline?.(agentId);
+                        return;
+                    }
+                }
+                // Monitor is read-only, ignore any further messages
+                if (isMonitor)
+                    return;
+                if (agentId) {
+                    // Track heartbeats silently
+                    if (frame.type === 'heartbeat') {
+                        this.lastHeartbeat.set(agentId, Date.now());
+                        return;
+                    }
+                    this.onMessage(agentId, frame);
+                }
+            });
+            socket.on('data', parser);
+            socket.on('close', () => {
+                if (isMonitor) {
+                    this.monitors.delete(socket);
+                    console.log(`[hub] Monitor disconnected (${this.monitors.size} total)`);
+                    return;
+                }
+                if (agentId) {
+                    const current = this.spokes.get(agentId);
+                    if (current && current.socket === socket) {
+                        this.spokes.delete(agentId);
+                        this.lastHeartbeat.delete(agentId);
+                        console.log(`[hub] Spoke disconnected: ${agentId}`);
+                        this.broadcast({ kind: 'agent_offline', agentId, timestamp: new Date().toISOString() });
+                        this.onAgentOffline?.(agentId);
+                    }
+                }
+            });
+            socket.on('error', (err) => {
+                console.error(`[hub] Socket error (${agentId || 'monitor'}):`, err.message);
+            });
+        });
+        this.server.listen(HUB_SOCKET_PATH, () => {
+            console.log(`[hub] Listening on ${HUB_SOCKET_PATH}`);
+        });
+        // Periodically evict spokes that missed heartbeats + clean stale monitors
+        this.heartbeatChecker = setInterval(() => {
+            for (const s of this.monitors) {
+                if (s.destroyed)
+                    this.monitors.delete(s);
+            }
+            const now = Date.now();
+            for (const [agentId, lastSeen] of this.lastHeartbeat) {
+                if (now - lastSeen > HEARTBEAT_TIMEOUT_MS) {
+                    const spoke = this.spokes.get(agentId);
+                    if (spoke) {
+                        console.log(`[hub] Evicting stale spoke "${agentId}" (no heartbeat for ${Math.round((now - lastSeen) / 1000)}s)`);
+                        spoke.socket.destroy();
+                        this.spokes.delete(agentId);
+                        this.lastHeartbeat.delete(agentId);
+                        this.broadcast({ kind: 'agent_offline', agentId, timestamp: new Date().toISOString() });
+                        if (spoke.pid) {
+                            try {
+                                process.kill(spoke.pid, 'SIGTERM');
+                                console.log(`[hub] Sent SIGTERM to zombie spoke "${agentId}" (pid ${spoke.pid})`);
+                            }
+                            catch {
+                                // Process already dead — that's fine
+                            }
+                        }
+                        this.onEvict?.(agentId);
+                    }
+                }
+            }
+        }, 15_000);
+    }
+    send(agentId, msg) {
+        const spoke = this.spokes.get(agentId);
+        if (!spoke)
+            return false;
+        const ok = spoke.socket.write(encodeFrame(msg));
+        if (!ok)
+            console.log(`[hub] ⚠ Back-pressure on socket to ${agentId}`);
+        if (spoke.socket.destroyed)
+            console.log(`[hub] ⚠ Socket to ${agentId} is destroyed!`);
+        return true;
+    }
+    /** Broadcast an event to all connected monitors. No-op if none connected. */
+    broadcast(event) {
+        if (this.monitors.size === 0)
+            return;
+        const frame = encodeFrame({ type: 'hub_event', event });
+        for (const socket of this.monitors) {
+            socket.write(frame);
+        }
+    }
+    getConnectedAgents() {
+        return [...this.spokes.keys()];
+    }
+    stop() {
+        if (this.heartbeatChecker)
+            clearInterval(this.heartbeatChecker);
+        this.server.close();
+        if (existsSync(HUB_SOCKET_PATH))
+            unlinkSync(HUB_SOCKET_PATH);
+    }
+}

package/dist/plugins/channel-manager/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ChannelManager plugin — unified channel lifecycle, routing, and permissions.
+ *
+ * Replaces the weixin plugin's "glue" logic with a channel-agnostic implementation.
+ * Owns: channel lifecycle, message routing (channel<->agent), typing indicators,
+ * pending-ack timers, permission management, and user-tracking per agent.
+ */
+import type { Cc2imPlugin } from '../../shared/plugin.js';
+import type { Cc2imChannel } from '../../shared/channel.js';
+export declare function createChannelManagerPlugin(channels: Cc2imChannel[]): Cc2imPlugin;