cc2im 0.2.0

package/dist/spoke/index.js

@@ -0,0 +1,115 @@
+/**
+ * cc2im Spoke — MCP channel server，桥接 CC ↔ Hub
+ *
+ * 启动流程：
+ * 1. 从参数读取 agentId
+ * 2. 连接 hub Unix socket，注册
+ * 3. 启动 MCP channel server（stdio transport，给 CC 用）
+ * 4. hub 消息 → MCP channel notification → CC
+ * 5. CC weixin_reply → spoke → hub → 微信
+ * 6. CC permission_request → spoke → hub → 微信
+ * 7. 微信 verdict → hub → spoke → CC
+ */
+import { appendFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { SOCKET_DIR } from '../shared/socket.js';
+import { SpokeSocketClient } from './socket-client.js';
+import { createChannelServer, setupTools, connectTransport, handleManagementResult } from './channel-server.js';
+import { PermissionRelay } from './permission.js';
+// --- Parse args ---
+const args = process.argv.slice(2);
+const agentIdIdx = args.indexOf('--agent-id');
+const agentId = agentIdIdx >= 0 ? args[agentIdIdx + 1] : 'default';
+if (!agentId) {
+    console.error('Usage: cc2im-spoke --agent-id <name>');
+    process.exit(1);
+}
+// --- Redirect stdout/stderr to log file (stdio is reserved for MCP) ---
+const LOG_FILE = join(SOCKET_DIR, 'agents', agentId, 'spoke.log');
+function log(...msgArgs) {
+    const line = `[${new Date().toISOString()}] ${msgArgs.join(' ')}\n`;
+    process.stderr.write(line);
+    try {
+        appendFileSync(LOG_FILE, line);
+    }
+    catch { }
+}
+console.log = log;
+console.error = (...msgArgs) => log('[ERROR]', ...msgArgs);
+// --- Setup ---
+const server = createChannelServer(agentId);
+const socketClient = new SpokeSocketClient(agentId, (msg) => {
+    switch (msg.type) {
+        case 'message': {
+            // Forward to CC as channel notification
+            tools.setLastUserId(msg.userId);
+            server.notification({
+                method: 'notifications/claude/channel',
+                params: {
+                    content: msg.text,
+                    meta: {
+                        userId: msg.userId,
+                        type: msg.msgType,
+                        source: 'weixin',
+                        timestamp: msg.timestamp,
+                    },
+                },
+            }).catch((err) => {
+                console.error(`[spoke:${agentId}] Failed to push channel notification: ${err.message}`);
+            });
+            break;
+        }
+        case 'permission_verdict': {
+            permissionRelay.handleVerdict(msg.requestId, msg.behavior, msg.toolName);
+            break;
+        }
+        case 'management_result': {
+            handleManagementResult(msg);
+            break;
+        }
+    }
+});
+const tools = setupTools(server, agentId, socketClient);
+const permissionRelay = new PermissionRelay(agentId, server, socketClient, tools.getCurrentUserId);
+permissionRelay.setup();
+// --- Exit when CC disconnects ---
+let exiting = false;
+function gracefulExit(reason) {
+    if (exiting)
+        return;
+    exiting = true;
+    console.log(`[spoke:${agentId}] ${reason}, exiting`);
+    socketClient.disconnect();
+    process.exit(0);
+}
+// Method 1: stdin EOF / close
+process.stdin.on('end', () => gracefulExit('CC disconnected (stdin EOF)'));
+process.stdin.on('close', () => gracefulExit('CC disconnected (stdin close)'));
+process.stdin.resume();
+// Method 2: MCP transport close
+server.onclose = () => gracefulExit('MCP transport closed');
+// Method 3: Poll parent PID — when CC dies, PPID becomes 1 (launchd/init)
+const ppidCheck = setInterval(() => {
+    if (process.ppid === 1) {
+        clearInterval(ppidCheck);
+        gracefulExit('Parent process gone (ppid became 1)');
+    }
+}, 3000);
+// --- Start ---
+async function main() {
+    // Connect MCP stdio first (CC is waiting for it)
+    await connectTransport(server);
+    // Then connect to hub
+    await socketClient.connect();
+    // Report ready
+    socketClient.send({ type: 'status', agentId, status: 'ready' });
+    // Heartbeat every 15s
+    setInterval(() => {
+        socketClient.send({ type: 'heartbeat', agentId });
+    }, 15_000);
+    console.log(`[spoke:${agentId}] Ready`);
+}
+main().catch((err) => {
+    console.error(`[spoke:${agentId}] Fatal: ${err.message}`);
+    process.exit(1);
+});

package/dist/spoke/permission.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Permission relay — spoke 侧
+ * 从 cc2wx.ts:257-425 搬迁，改为走 hub socket
+ *
+ * 流程：
+ * CC permission_request → spoke 转发到 hub → hub 转发到微信
+ * 微信 verdict → hub → spoke → CC
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import type { SpokeSocketClient } from './socket-client.js';
+export declare class PermissionRelay {
+    private agentId;
+    private server;
+    private socketClient;
+    private getCurrentUserId?;
+    private alwaysAllow;
+    private allowListPath;
+    private pendingVerdicts;
+    constructor(agentId: string, server: Server, socketClient: SpokeSocketClient, getCurrentUserId?: (() => string | null) | undefined);
+    private loadAllowList;
+    private saveAllowList;
+    /** Register the notification handler on the MCP server */
+    setup(): void;
+    /** Called when hub sends a verdict back */
+    handleVerdict(requestId: string, behavior: 'allow' | 'deny' | 'always', toolName?: string): void;
+    /** Add a tool to always-allow list */
+    addAlwaysAllow(toolName: string): void;
+}

package/dist/spoke/permission.js

@@ -0,0 +1,142 @@
+/**
+ * Permission relay — spoke 侧
+ * 从 cc2wx.ts:257-425 搬迁，改为走 hub socket
+ *
+ * 流程：
+ * CC permission_request → spoke 转发到 hub → hub 转发到微信
+ * 微信 verdict → hub → spoke → CC
+ */
+import { z } from 'zod';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { SOCKET_DIR } from '../shared/socket.js';
+const PermissionRequestSchema = z.object({
+    method: z.literal('notifications/claude/channel/permission_request'),
+    params: z.object({
+        request_id: z.string(),
+        tool_name: z.string(),
+        description: z.string(),
+        input_preview: z.string(),
+    }),
+});
+export class PermissionRelay {
+    agentId;
+    server;
+    socketClient;
+    getCurrentUserId;
+    alwaysAllow;
+    allowListPath;
+    pendingVerdicts = new Map();
+    constructor(agentId, server, socketClient, getCurrentUserId) {
+        this.agentId = agentId;
+        this.server = server;
+        this.socketClient = socketClient;
+        this.getCurrentUserId = getCurrentUserId;
+        this.allowListPath = join(SOCKET_DIR, 'agents', agentId, 'always-allow.json');
+        this.alwaysAllow = this.loadAllowList();
+    }
+    loadAllowList() {
+        try {
+            if (existsSync(this.allowListPath)) {
+                const data = JSON.parse(readFileSync(this.allowListPath, 'utf8'));
+                console.log(`[spoke:${this.agentId}] Loaded ${data.length} always-allow patterns`);
+                return new Set(data);
+            }
+        }
+        catch (err) {
+            console.error(`[spoke:${this.agentId}] Failed to load allow list: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return new Set();
+    }
+    saveAllowList() {
+        try {
+            const dir = join(SOCKET_DIR, 'agents', this.agentId);
+            mkdirSync(dir, { recursive: true });
+            writeFileSync(this.allowListPath, JSON.stringify([...this.alwaysAllow], null, 2) + '\n');
+            console.log(`[spoke:${this.agentId}] Saved ${this.alwaysAllow.size} always-allow patterns`);
+        }
+        catch (err) {
+            console.error(`[spoke:${this.agentId}] Failed to save allow list: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    /** Register the notification handler on the MCP server */
+    setup() {
+        this.server.setNotificationHandler(PermissionRequestSchema, async ({ params }) => {
+            console.log(`[spoke:${this.agentId}] Permission request: id=${params.request_id} tool=${params.tool_name}`);
+            // Auto-approve if in always-allow list
+            if (this.alwaysAllow.has(params.tool_name)) {
+                console.log(`[spoke:${this.agentId}] Auto-approved ${params.tool_name} (always allow)`);
+                await this.server.notification({
+                    method: 'notifications/claude/channel/permission',
+                    params: { request_id: params.request_id, behavior: 'allow' },
+                });
+                return;
+            }
+            // Forward to hub via socket, including originating userId for routing
+            const sent = this.socketClient.send({
+                type: 'permission_request',
+                agentId: this.agentId,
+                requestId: params.request_id,
+                toolName: params.tool_name,
+                description: params.description,
+                inputPreview: params.input_preview,
+                userId: this.getCurrentUserId?.() || undefined,
+            });
+            // If hub is disconnected, deny immediately instead of waiting 5 min
+            if (!sent) {
+                console.log(`[spoke:${this.agentId}] Hub disconnected, auto-denying permission: ${params.tool_name}`);
+                await this.server.notification({
+                    method: 'notifications/claude/channel/permission',
+                    params: { request_id: params.request_id, behavior: 'deny' },
+                });
+                return;
+            }
+            // Wait for verdict from hub (will be resolved by handleVerdict)
+            const behavior = await new Promise((resolve) => {
+                this.pendingVerdicts.set(params.request_id, { resolve, toolName: params.tool_name });
+                // Timeout: auto-deny after 5 minutes
+                setTimeout(() => {
+                    if (this.pendingVerdicts.has(params.request_id)) {
+                        this.pendingVerdicts.delete(params.request_id);
+                        resolve('deny');
+                        this.socketClient.send({
+                            type: 'permission_timeout',
+                            agentId: this.agentId,
+                            requestId: params.request_id,
+                        });
+                        console.log(`[spoke:${this.agentId}] Permission timeout: ${params.request_id}`);
+                    }
+                }, 5 * 60 * 1000);
+            });
+            await this.server.notification({
+                method: 'notifications/claude/channel/permission',
+                params: { request_id: params.request_id, behavior },
+            });
+            console.log(`[spoke:${this.agentId}] Permission verdict forwarded to CC: ${params.request_id} → ${behavior}`);
+        });
+    }
+    /** Called when hub sends a verdict back */
+    handleVerdict(requestId, behavior, toolName) {
+        const pending = this.pendingVerdicts.get(requestId);
+        if (pending) {
+            this.pendingVerdicts.delete(requestId);
+            if (behavior === 'always') {
+                const tool = toolName || pending.toolName;
+                this.addAlwaysAllow(tool);
+                console.log(`[spoke:${this.agentId}] Always-allow added: ${tool}`);
+                pending.resolve('allow');
+            }
+            else {
+                pending.resolve(behavior);
+            }
+        }
+        else {
+            console.log(`[spoke:${this.agentId}] Verdict for unknown request: ${requestId}`);
+        }
+    }
+    /** Add a tool to always-allow list */
+    addAlwaysAllow(toolName) {
+        this.alwaysAllow.add(toolName);
+        this.saveAllowList();
+    }
+}

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

@@ -0,0 +1,22 @@
+import type { HubToSpoke, SpokeToHub } from '../shared/types.js';
+export declare class SpokeSocketClient {
+    private socket;
+    private agentId;
+    private onMessage;
+    private reconnectTimer;
+    private reconnectDelay;
+    private connected;
+    constructor(agentId: string, onMessage: (msg: HubToSpoke) => void);
+    /**
+     * Start connecting to hub. Resolves immediately — connection happens
+     * in the background with auto-reconnect. This ensures the spoke
+     * process doesn't hang if the hub is unavailable at startup.
+     */
+    connect(): Promise<void>;
+    private doConnect;
+    private scheduleReconnect;
+    /** Send a message. Returns false if not connected (message dropped). */
+    send(msg: SpokeToHub): boolean;
+    isConnected(): boolean;
+    disconnect(): void;
+}

package/dist/spoke/socket-client.js

@@ -0,0 +1,83 @@
+import { createConnection } from 'node:net';
+import { HUB_SOCKET_PATH, encodeFrame, createFrameParser } from '../shared/socket.js';
+const RECONNECT_INTERVAL = 3000;
+const MAX_RECONNECT_INTERVAL = 30000;
+export class SpokeSocketClient {
+    socket = null;
+    agentId;
+    onMessage;
+    reconnectTimer = null;
+    reconnectDelay = RECONNECT_INTERVAL;
+    connected = false;
+    constructor(agentId, onMessage) {
+        this.agentId = agentId;
+        this.onMessage = onMessage;
+    }
+    /**
+     * Start connecting to hub. Resolves immediately — connection happens
+     * in the background with auto-reconnect. This ensures the spoke
+     * process doesn't hang if the hub is unavailable at startup.
+     */
+    connect() {
+        this.doConnect();
+        return Promise.resolve();
+    }
+    doConnect() {
+        const socket = createConnection(HUB_SOCKET_PATH, () => {
+            this.socket = socket;
+            this.connected = true;
+            this.reconnectDelay = RECONNECT_INTERVAL;
+            socket.write(encodeFrame({ type: 'register', agentId: this.agentId, pid: process.pid }));
+            console.log(`[spoke:${this.agentId}] Connected to hub`);
+        });
+        const parser = createFrameParser((frame) => {
+            this.onMessage(frame);
+        });
+        socket.on('data', parser);
+        socket.on('error', (err) => {
+            // Suppress ECONNREFUSED noise — reconnect handles it
+            if (err.code !== 'ECONNREFUSED') {
+                console.error(`[spoke:${this.agentId}] Socket error: ${err.message}`);
+            }
+        });
+        socket.on('close', () => {
+            const wasConnected = this.connected;
+            this.connected = false;
+            this.socket = null;
+            if (wasConnected) {
+                console.log(`[spoke:${this.agentId}] Disconnected from hub`);
+            }
+            this.scheduleReconnect();
+        });
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimer)
+            return;
+        console.log(`[spoke:${this.agentId}] Reconnecting in ${this.reconnectDelay / 1000}s...`);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.doConnect();
+        }, this.reconnectDelay);
+        // 指数退避，上限 30s
+        this.reconnectDelay = Math.min(this.reconnectDelay * 2, MAX_RECONNECT_INTERVAL);
+    }
+    /** Send a message. Returns false if not connected (message dropped). */
+    send(msg) {
+        if (this.socket && this.connected) {
+            this.socket.write(encodeFrame(msg));
+            return true;
+        }
+        console.log(`[spoke:${this.agentId}] Not connected, dropping message`);
+        return false;
+    }
+    isConnected() {
+        return this.connected;
+    }
+    disconnect() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        this.socket?.end();
+    }
+}