cc2im 0.2.0

package/dist/plugins/weixin/media.js

@@ -0,0 +1,83 @@
+/**
+ * 媒体下载 + AES 解密
+ * 从 cc2wx.ts:31-106 搬迁，逻辑不变
+ */
+import { existsSync, mkdirSync, writeFileSync, readdirSync, statSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { createDecipheriv } from 'node:crypto';
+import { SOCKET_DIR } from '../../shared/socket.js';
+const MEDIA_DIR = join(SOCKET_DIR, 'media');
+const CDN_DOWNLOAD_URL = 'https://novac2c.cdn.weixin.qq.com/c2c/download';
+const MEDIA_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24 hours
+export function cleanupMedia() {
+    try {
+        if (!existsSync(MEDIA_DIR))
+            return;
+        const now = Date.now();
+        let cleaned = 0;
+        for (const file of readdirSync(MEDIA_DIR)) {
+            const filepath = join(MEDIA_DIR, file);
+            const age = now - statSync(filepath).mtimeMs;
+            if (age > MEDIA_MAX_AGE_MS) {
+                unlinkSync(filepath);
+                cleaned++;
+            }
+        }
+        if (cleaned > 0)
+            console.log(`[hub] Cleaned ${cleaned} expired media files`);
+    }
+    catch (err) {
+        console.error(`[hub] Media cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function parseAesKey(aesKeyB64) {
+    const hexStr = Buffer.from(aesKeyB64, 'base64').toString('utf8');
+    return Buffer.from(hexStr, 'hex');
+}
+function detectExt(buf) {
+    if (buf[0] === 0xff && buf[1] === 0xd8)
+        return 'jpg';
+    if (buf[0] === 0x89 && buf[1] === 0x50)
+        return 'png';
+    if (buf[0] === 0x47 && buf[1] === 0x49)
+        return 'gif';
+    if (buf[0] === 0x52 && buf[1] === 0x49)
+        return 'webp';
+    // MP4/MOV: ftyp box at offset 4
+    if (buf.length >= 8 && buf[4] === 0x66 && buf[5] === 0x74 && buf[6] === 0x79 && buf[7] === 0x70)
+        return 'mp4';
+    if (buf[0] === 0x25 && buf[1] === 0x50 && buf[2] === 0x44 && buf[3] === 0x46)
+        return 'pdf';
+    return 'bin';
+}
+export async function downloadMedia(item) {
+    const mediaItem = item?.image_item || item?.video_item || item?.file_item || item?.voice_item;
+    if (!mediaItem?.media?.encrypt_query_param)
+        return null;
+    const { encrypt_query_param, aes_key } = mediaItem.media;
+    try {
+        const cdnUrl = `${CDN_DOWNLOAD_URL}?encrypted_query_param=${encodeURIComponent(encrypt_query_param)}`;
+        const resp = await fetch(cdnUrl, { method: 'GET' });
+        if (!resp.ok) {
+            console.log(`[hub] CDN download failed: HTTP ${resp.status}`);
+            return null;
+        }
+        let buffer = Buffer.from(await resp.arrayBuffer());
+        if (aes_key) {
+            const key = parseAesKey(aes_key);
+            const decipher = createDecipheriv('aes-128-ecb', key, Buffer.alloc(0));
+            buffer = Buffer.concat([decipher.update(buffer), decipher.final()]);
+        }
+        mkdirSync(MEDIA_DIR, { recursive: true });
+        const ext = detectExt(buffer);
+        const filename = `${Date.now()}.${ext}`;
+        const filepath = join(MEDIA_DIR, filename);
+        writeFileSync(filepath, buffer);
+        console.log(`[hub] Media saved: ${filepath} (${buffer.length} bytes, ${ext})`);
+        return filepath;
+    }
+    catch (err) {
+        console.error(`[hub] Media download failed: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}

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

@@ -0,0 +1,35 @@
+/**
+ * Permission state management for channel-based approval flow.
+ * Tracks pending permission requests and matches incoming messages as verdicts.
+ *
+ * Channel-agnostic: accepts a sendFn callback for sending prompts,
+ * and a UserRef map for resolving target users.
+ */
+import type { HubContext } from '../../shared/plugin.js';
+/** Identifies a user on a specific channel */
+export interface UserRef {
+    userId: string;
+    channelId: string;
+}
+export declare class PermissionManager {
+    private pending;
+    /** Handle a permission_request from a spoke */
+    handleRequest(agentId: string, msg: {
+        requestId: string;
+        toolName: string;
+        description: string;
+        inputPreview: string;
+        userId?: string;
+    }, ctx: HubContext, sendFn: (userId: string, text: string) => Promise<void>, lastUserByAgent: Map<string, UserRef>, lastGlobalUser: UserRef | null): Promise<void>;
+    /** Try to match an incoming WeChat message as a permission verdict. Returns true if handled. */
+    tryHandleVerdict(msg: {
+        type: string;
+        text?: string;
+        userId: string;
+        channelId?: string;
+    }, ctx: HubContext): boolean;
+    /** Handle permission_timeout from spoke */
+    handleTimeout(requestId: string): void;
+    /** Clean up stale permissions (called periodically) */
+    cleanup(): void;
+}

package/dist/plugins/weixin/permission.js

@@ -0,0 +1,96 @@
+/**
+ * Permission state management for channel-based approval flow.
+ * Tracks pending permission requests and matches incoming messages as verdicts.
+ *
+ * Channel-agnostic: accepts a sendFn callback for sending prompts,
+ * and a UserRef map for resolving target users.
+ */
+const PERMISSION_TTL_MS = 6 * 60 * 1000; // 6 minutes (spoke timeout is 5 min)
+const SIMPLE_RE = /^\s*(y|yes|ok|好|批准|always|始终|总是|n|no|不|拒绝)\s*$/i;
+export class PermissionManager {
+    pending = [];
+    /** Handle a permission_request from a spoke */
+    async handleRequest(agentId, msg, ctx, sendFn, lastUserByAgent, lastGlobalUser) {
+        const ref = msg.userId
+            ? { userId: msg.userId, channelId: lastUserByAgent.get(agentId)?.channelId || lastGlobalUser?.channelId || '' }
+            : lastUserByAgent.get(agentId) || lastGlobalUser;
+        const targetUserId = ref?.userId;
+        if (!targetUserId) {
+            console.log(`[hub] No user to forward permission request to`);
+            return;
+        }
+        this.pending.push({
+            requestId: msg.requestId,
+            agentId,
+            toolName: msg.toolName,
+            userId: targetUserId,
+            channelId: ref?.channelId || '',
+            createdAt: Date.now(),
+        });
+        let preview = msg.inputPreview;
+        try {
+            const parsed = JSON.parse(preview);
+            if (parsed.command)
+                preview = parsed.command;
+            else if (parsed.file_path)
+                preview = parsed.file_path;
+            else
+                preview = JSON.stringify(parsed, null, 2);
+        }
+        catch { /* keep original */ }
+        const prompt = [
+            `🔐 [${agentId}] Claude 请求权限`,
+            `工具: ${msg.toolName}`,
+            `说明: ${msg.description}`,
+            '',
+            preview.slice(0, 800),
+            '',
+            `回复 yes 批准 / always 始终批准 / no 拒绝`,
+        ].join('\n');
+        ctx.broadcastMonitor({ kind: 'permission_request', agentId, toolName: msg.toolName, timestamp: new Date().toISOString() });
+        await sendFn(targetUserId, prompt);
+    }
+    /** Try to match an incoming WeChat message as a permission verdict. Returns true if handled. */
+    tryHandleVerdict(msg, ctx) {
+        if (msg.type !== 'text' || !msg.text || this.pending.length === 0)
+            return false;
+        const simpleMatch = msg.text.match(SIMPLE_RE);
+        if (!simpleMatch)
+            return false;
+        const reply = simpleMatch[1].trim().toLowerCase();
+        const isAlways = /^(always|始终|总是)$/.test(reply);
+        const isAllow = isAlways || /^(y|yes|ok|好|批准)$/i.test(reply);
+        const idx = this.pending.findIndex(p => p.userId === msg.userId && (!msg.channelId || p.channelId === msg.channelId));
+        if (idx < 0)
+            return false;
+        const pending = this.pending.splice(idx, 1)[0];
+        const behavior = isAlways ? 'always' : isAllow ? 'allow' : 'deny';
+        ctx.deliverToAgent(pending.agentId, {
+            type: 'permission_verdict',
+            requestId: pending.requestId,
+            behavior,
+            toolName: pending.toolName,
+        });
+        console.log(`[hub] Permission verdict: ${pending.requestId} → ${behavior}`);
+        ctx.broadcastMonitor({ kind: 'permission_verdict', agentId: pending.agentId, behavior, timestamp: new Date().toISOString() });
+        return true;
+    }
+    /** Handle permission_timeout from spoke */
+    handleTimeout(requestId) {
+        const idx = this.pending.findIndex(p => p.requestId === requestId);
+        if (idx >= 0) {
+            this.pending.splice(idx, 1);
+            console.log(`[hub] Permission expired: ${requestId} (removed from queue)`);
+        }
+    }
+    /** Clean up stale permissions (called periodically) */
+    cleanup() {
+        const now = Date.now();
+        for (let i = this.pending.length - 1; i >= 0; i--) {
+            if (now - this.pending[i].createdAt > PERMISSION_TTL_MS) {
+                console.log(`[hub] Cleaning stale permission: ${this.pending[i].requestId}`);
+                this.pending.splice(i, 1);
+            }
+        }
+    }
+}

package/dist/plugins/weixin/qr-login.d.ts

@@ -0,0 +1,23 @@
+declare const CRED_DIR: string;
+declare const CRED_PATH: string;
+declare const POLL_INTERVAL = 2000;
+export interface QrCode {
+    qrUrl: string;
+    qrDataUrl: string;
+    qrToken: string;
+}
+export interface QrCredentials {
+    token: string;
+    baseUrl: string;
+    accountId: string;
+    userId: string;
+}
+export type QrStatus = 'pending' | 'scanned' | 'confirmed' | 'expired';
+export declare function fetchQrCode(): Promise<QrCode>;
+export declare function checkQrStatus(qrToken: string): Promise<{
+    status: QrStatus;
+    credentials?: QrCredentials;
+}>;
+export declare function saveCredentials(creds: QrCredentials, channelId?: string): void;
+export declare function loadCredentials(channelId?: string): QrCredentials | null;
+export { CRED_DIR, CRED_PATH, POLL_INTERVAL };

package/dist/plugins/weixin/qr-login.js

@@ -0,0 +1,77 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import QRCode from 'qrcode';
+const ILINK_BASE = 'https://ilinkai.weixin.qq.com';
+const CRED_DIR = join(homedir(), '.weixin-bot');
+const CRED_PATH = join(CRED_DIR, 'credentials.json');
+const POLL_INTERVAL = 2000;
+export async function fetchQrCode() {
+    const resp = await fetch(`${ILINK_BASE}/ilink/bot/get_bot_qrcode?bot_type=3`);
+    if (!resp.ok)
+        throw new Error(`iLink QR API error: ${resp.status}`);
+    const data = await resp.json();
+    if (!data.qrcode_img_content || !data.qrcode) {
+        throw new Error('iLink 返回的 QR 数据不完整');
+    }
+    const qrUrl = data.qrcode_img_content;
+    // Generate QR code as data URL (iLink returns a scan URL, not an image)
+    const qrDataUrl = await QRCode.toDataURL(qrUrl, { width: 220, margin: 1 });
+    return { qrUrl, qrDataUrl, qrToken: data.qrcode };
+}
+export async function checkQrStatus(qrToken) {
+    const resp = await fetch(`${ILINK_BASE}/ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrToken)}`, { headers: { 'iLink-App-ClientVersion': '1' } });
+    if (!resp.ok)
+        throw new Error(`iLink status API error: ${resp.status}`);
+    const data = await resp.json();
+    if (data.status === 'scaned')
+        return { status: 'scanned' };
+    if (data.status === 'expired')
+        return { status: 'expired' };
+    if (data.status === 'confirmed') {
+        if (!data.bot_token || !data.ilink_bot_id || !data.ilink_user_id) {
+            throw new Error('授权成功但未返回凭证');
+        }
+        return {
+            status: 'confirmed',
+            credentials: {
+                token: data.bot_token,
+                baseUrl: data.baseurl || ILINK_BASE,
+                accountId: data.ilink_bot_id,
+                userId: data.ilink_user_id,
+            },
+        };
+    }
+    return { status: 'pending' };
+}
+/** Atomic write: write to .tmp then rename (prevents corruption on crash). */
+function atomicWrite(path, data) {
+    const tmp = path + '.tmp';
+    writeFileSync(tmp, data, { mode: 0o600 });
+    renameSync(tmp, path);
+}
+export function saveCredentials(creds, channelId) {
+    mkdirSync(CRED_DIR, { recursive: true, mode: 0o700 });
+    const json = JSON.stringify(creds, null, 2) + '\n';
+    // Always write global file (backward compat for CLI `cc2im login`)
+    atomicWrite(CRED_PATH, json);
+    // Also write per-channel file when channelId is provided
+    if (channelId) {
+        atomicWrite(join(CRED_DIR, `credentials-${channelId}.json`), json);
+    }
+}
+export function loadCredentials(channelId) {
+    if (channelId) {
+        // Try per-channel file first
+        const channelPath = join(CRED_DIR, `credentials-${channelId}.json`);
+        if (existsSync(channelPath)) {
+            return JSON.parse(readFileSync(channelPath, 'utf8'));
+        }
+    }
+    // Fall back to global file
+    if (existsSync(CRED_PATH)) {
+        return JSON.parse(readFileSync(CRED_PATH, 'utf8'));
+    }
+    return null;
+}
+export { CRED_DIR, CRED_PATH, POLL_INTERVAL };

package/dist/plugins/weixin/weixin-channel.d.ts

@@ -0,0 +1,33 @@
+/**
+ * WeixinChannel — wraps WeixinConnection as a Cc2imChannel implementation.
+ *
+ * Composition adapter: translates between the WeChat-specific WeixinConnection
+ * API and the platform-agnostic Cc2imChannel interface. Supports multi-instance
+ * via constructor-injected id/label (e.g. "weixin-alice", "weixin-bob").
+ */
+import type { Cc2imChannel, ChannelStatus, IncomingChannelMessage } from '../../shared/channel.js';
+export declare class WeixinChannel implements Cc2imChannel {
+    readonly id: string;
+    readonly type: "weixin";
+    readonly label: string;
+    private weixin;
+    private status;
+    private messageHandlers;
+    private statusHandlers;
+    constructor(id?: string, label?: string);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    getStatus(): ChannelStatus;
+    sendText(userId: string, text: string): Promise<void>;
+    sendFile(userId: string, filePath: string): Promise<void>;
+    startTyping(userId: string): Promise<void>;
+    stopTyping(userId: string): Promise<void>;
+    onMessage(handler: (msg: IncomingChannelMessage) => Promise<void>): void;
+    onStatusChange(handler: (status: ChannelStatus, detail?: string) => void): void;
+    /**
+     * Wire WeixinConnection's single-handler callback into our multi-handler
+     * fan-out. Called once during connect(), before startListening().
+     */
+    private registerMessageBridge;
+    private setStatus;
+}

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

@@ -0,0 +1,123 @@
+/**
+ * WeixinChannel — wraps WeixinConnection as a Cc2imChannel implementation.
+ *
+ * Composition adapter: translates between the WeChat-specific WeixinConnection
+ * API and the platform-agnostic Cc2imChannel interface. Supports multi-instance
+ * via constructor-injected id/label (e.g. "weixin-alice", "weixin-bob").
+ */
+import { WeixinConnection } from './connection.js';
+const IMAGE_EXTS = new Set(['jpg', 'jpeg', 'png', 'gif', 'webp', 'bmp']);
+export class WeixinChannel {
+    id;
+    type = 'weixin';
+    label;
+    weixin;
+    status = 'disconnected';
+    messageHandlers = [];
+    statusHandlers = [];
+    constructor(id = 'weixin', label = '微信') {
+        this.id = id;
+        this.label = label;
+        this.weixin = new WeixinConnection();
+    }
+    // ── lifecycle ────────────────────────────────────────────────────
+    async connect() {
+        this.setStatus('connecting');
+        try {
+            await this.weixin.login(this.id);
+            this.weixin.restoreContextCache(this.id);
+            this.registerMessageBridge();
+            this.weixin.startListening();
+            // startPolling is a long-running loop — fire-and-forget.
+            // If it exits (session expired / network error), mark status.
+            this.weixin.startPolling().catch((err) => {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.error(`[${this.id}] Polling error: ${msg}`);
+                this.setStatus('expired', msg);
+            });
+            this.setStatus('connected');
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`[${this.id}] Connect failed: ${msg}`);
+            this.setStatus('disconnected', msg);
+            throw err;
+        }
+    }
+    async disconnect() {
+        this.weixin.saveContextCache(this.id);
+        this.weixin.stop();
+        this.setStatus('disconnected');
+    }
+    getStatus() {
+        return this.status;
+    }
+    // ── outbound ─────────────────────────────────────────────────────
+    async sendText(userId, text) {
+        await this.weixin.send(userId, text);
+    }
+    async sendFile(userId, filePath) {
+        const ext = filePath.split('.').pop()?.toLowerCase() || '';
+        if (IMAGE_EXTS.has(ext)) {
+            await this.weixin.sendImage(userId, filePath);
+        }
+        else {
+            await this.weixin.sendFile(userId, filePath);
+        }
+    }
+    async startTyping(userId) {
+        await this.weixin.startTyping(userId);
+    }
+    async stopTyping(userId) {
+        await this.weixin.stopTyping(userId);
+    }
+    // ── inbound ──────────────────────────────────────────────────────
+    onMessage(handler) {
+        this.messageHandlers.push(handler);
+    }
+    // ── status events ────────────────────────────────────────────────
+    onStatusChange(handler) {
+        this.statusHandlers.push(handler);
+    }
+    // ── private ──────────────────────────────────────────────────────
+    /**
+     * Wire WeixinConnection's single-handler callback into our multi-handler
+     * fan-out. Called once during connect(), before startListening().
+     */
+    registerMessageBridge() {
+        this.weixin.setMessageHandler(async (msg) => {
+            const channelMsg = {
+                channelId: this.id,
+                channelType: this.type,
+                userId: msg.userId,
+                text: msg.text,
+                type: (msg.type || 'text'),
+                mediaPath: msg.mediaPath ?? undefined,
+                voiceText: msg.voiceText ?? undefined,
+                timestamp: msg.timestamp || new Date(),
+                raw: msg.raw,
+            };
+            for (const handler of this.messageHandlers) {
+                try {
+                    await handler(channelMsg);
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    console.error(`[${this.id}] Message handler error: ${errMsg}`);
+                }
+            }
+        });
+    }
+    setStatus(status, detail) {
+        this.status = status;
+        for (const handler of this.statusHandlers) {
+            try {
+                handler(status, detail);
+            }
+            catch (err) {
+                const errMsg = err instanceof Error ? err.message : String(err);
+                console.error(`[${this.id}] Status handler error: ${errMsg}`);
+            }
+        }
+    }
+}

package/dist/shared/channel-config.d.ts

@@ -0,0 +1,8 @@
+import type { ChannelType } from './channel.js';
+export interface ChannelConfig {
+    id: string;
+    type: ChannelType;
+    accountName: string;
+}
+export declare function loadChannelConfigs(): ChannelConfig[];
+export declare function saveChannelConfigs(configs: ChannelConfig[]): void;

package/dist/shared/channel-config.js

@@ -0,0 +1,14 @@
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { SOCKET_DIR } from './socket.js';
+const CHANNELS_JSON_PATH = join(SOCKET_DIR, 'channels.json');
+export function loadChannelConfigs() {
+    if (!existsSync(CHANNELS_JSON_PATH)) {
+        // Backwards-compatible default: single weixin channel
+        return [{ id: 'weixin', type: 'weixin', accountName: '微信' }];
+    }
+    return JSON.parse(readFileSync(CHANNELS_JSON_PATH, 'utf8'));
+}
+export function saveChannelConfigs(configs) {
+    writeFileSync(CHANNELS_JSON_PATH, JSON.stringify(configs, null, 2));
+}

package/dist/shared/channel.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Channel abstraction — unified interface for IM platform instances.
+ *
+ * A "channel" is a platform INSTANCE (not type). You can have multiple
+ * WeChat channels (weixin-alice, weixin-bob) each with its own
+ * session, QR code, and user pool.
+ */
+export type ChannelStatus = 'connected' | 'disconnected' | 'expired' | 'connecting';
+export type ChannelType = 'weixin' | 'telegram' | 'slack' | 'discord';
+export interface IncomingChannelMessage {
+    channelId: string;
+    channelType: ChannelType;
+    userId: string;
+    text?: string;
+    type: 'text' | 'image' | 'video' | 'voice' | 'file';
+    mediaPath?: string;
+    voiceText?: string;
+    timestamp: Date;
+    raw?: any;
+}
+export interface Cc2imChannel {
+    /** Instance ID, e.g. "weixin-alice", "weixin-bob" */
+    readonly id: string;
+    /** Platform type, e.g. "weixin". Determines UI icon and grouping */
+    readonly type: ChannelType;
+    /** Display label, e.g. "Alice·微信" */
+    readonly label: string;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    getStatus(): ChannelStatus;
+    sendText(userId: string, text: string): Promise<void>;
+    sendFile(userId: string, filePath: string): Promise<void>;
+    startTyping(userId: string): Promise<void>;
+    stopTyping(userId: string): Promise<void>;
+    onMessage(handler: (msg: IncomingChannelMessage) => Promise<void>): void;
+    onStatusChange(handler: (status: ChannelStatus, detail?: string) => void): void;
+}

package/dist/shared/channel.js

@@ -0,0 +1,8 @@
+/**
+ * Channel abstraction — unified interface for IM platform instances.
+ *
+ * A "channel" is a platform INSTANCE (not type). You can have multiple
+ * WeChat channels (weixin-alice, weixin-bob) each with its own
+ * session, QR code, and user pool.
+ */
+export {};

package/dist/shared/mcp-config.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Shared utility for managing .mcp.json in agent working directories
+ */
+/** Ensure the cc2im spoke entry exists in the agent's .mcp.json */
+export declare function ensureMcpJson(agentCwd: string, spokeScriptPath: string, agentId: string): void;

package/dist/shared/mcp-config.js

@@ -0,0 +1,44 @@
+/**
+ * Shared utility for managing .mcp.json in agent working directories
+ */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+/**
+ * Resolve the command + args for running the spoke script.
+ * - .ts files: use cc2im's own tsx binary (absolute path from node_modules/.bin/)
+ * - .js files: use node directly (process.execPath)
+ */
+function resolveRunner(spokeScriptPath) {
+    if (spokeScriptPath.endsWith('.ts')) {
+        // Walk up from spoke script to find cc2im's node_modules/.bin/tsx
+        // spokeScriptPath is like /path/to/cc2im/src/spoke/index.ts
+        const cc2imRoot = dirname(dirname(dirname(spokeScriptPath))); // src/spoke/index.ts → cc2im root
+        const tsxBin = join(cc2imRoot, 'node_modules', '.bin', 'tsx');
+        if (existsSync(tsxBin)) {
+            return { command: tsxBin, args: [] };
+        }
+        // Fallback: try npx tsx (may not work on clean workspaces)
+        return { command: 'npx', args: ['tsx'] };
+    }
+    // .js files: node can run them directly
+    return { command: process.execPath, args: [] };
+}
+/** Ensure the cc2im spoke entry exists in the agent's .mcp.json */
+export function ensureMcpJson(agentCwd, spokeScriptPath, agentId) {
+    const mcpPath = join(agentCwd, '.mcp.json');
+    const runner = resolveRunner(spokeScriptPath);
+    const entry = {
+        command: runner.command,
+        args: [...runner.args, spokeScriptPath, '--agent-id', agentId],
+    };
+    let config = { mcpServers: {} };
+    if (existsSync(mcpPath)) {
+        try {
+            config = JSON.parse(readFileSync(mcpPath, 'utf8'));
+        }
+        catch { }
+        config.mcpServers = config.mcpServers || {};
+    }
+    config.mcpServers['cc2im'] = entry;
+    writeFileSync(mcpPath, JSON.stringify(config, null, 2) + '\n');
+}

package/dist/shared/plugin.d.ts

@@ -0,0 +1,32 @@
+import type { EventEmitter } from 'node:events';
+import type { AgentManager } from '../hub/agent-manager.js';
+import type { Router } from '../hub/router.js';
+import type { AgentsConfig, HubToSpoke, HubEventData } from './types.js';
+import type { Cc2imChannel } from './channel.js';
+/** Hub services and events available to plugins */
+export interface HubContext extends EventEmitter {
+    deliverToAgent(agentId: string, msg: HubToSpoke): boolean;
+    broadcastMonitor(event: HubEventData): void;
+    getConnectedAgents(): string[];
+    getAgentManager(): AgentManager;
+    getRouter(): Router;
+    getConfig(): AgentsConfig;
+    /** Register a channel (called by ChannelManager during init) */
+    registerChannel(channel: Cc2imChannel): void;
+    /** Look up a channel by its instance ID */
+    getChannel(channelId: string): Cc2imChannel | undefined;
+    /** Get all registered channels */
+    getChannels(): Cc2imChannel[];
+    /** Add a channel at runtime (persists to channels.json) */
+    addChannel(type: string, channelId: string, accountName: string): Promise<void>;
+    /** Remove a channel at runtime (persists to channels.json) */
+    removeChannel(channelId: string): Promise<void>;
+    /** Reconnect a channel (disconnect + connect with fresh credentials) */
+    reconnectChannel(channelId: string): Promise<void>;
+}
+/** Plugin definition */
+export interface Cc2imPlugin {
+    name: string;
+    init(ctx: HubContext): Promise<void> | void;
+    destroy(): Promise<void> | void;
+}

package/dist/shared/plugin.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/socket.d.ts

@@ -0,0 +1,5 @@
+export declare const SOCKET_DIR: string;
+export declare const HUB_SOCKET_PATH: string;
+export declare function ensureSocketDir(): void;
+export declare function encodeFrame(data: unknown): Buffer;
+export declare function createFrameParser(onFrame: (data: unknown) => void): (chunk: Buffer) => void;