@aster110/cc2wechat 1.0.0

package/src/cli.ts

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+
+import { execSync } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loginWithQRWeb } from './auth.js';
+import { saveAccount, getActiveAccount } from './store.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const serverPath = path.join(__dirname, 'server.js');
+
+const command = process.argv[2];
+
+function printUsage(): void {
+  console.log(`
+  🦞 wechat-claude — WeChat channel for Claude Code
+
+  Usage:
+    npx @aster110/wechat-claude install    Setup: register MCP + scan QR login
+    npx @aster110/wechat-claude login      Re-login (scan QR code)
+    npx @aster110/wechat-claude status     Check connection status
+    npx @aster110/wechat-claude help       Show this help
+`);
+}
+
+async function install(): Promise<void> {
+  console.log('\n  🦞 wechat-claude installer\n');
+
+  // Step 1: Register MCP server
+  console.log('  [1/3] Registering MCP server...');
+  try {
+    execSync(
+      `claude mcp add -s user wechat-channel node ${serverPath}`,
+      { stdio: 'pipe' },
+    );
+    console.log('  ✅ MCP server registered (user-level)\n');
+  } catch {
+    // May already exist, try remove + add
+    try {
+      execSync(`claude mcp remove -s user wechat-channel`, { stdio: 'pipe' });
+      execSync(
+        `claude mcp add -s user wechat-channel node ${serverPath}`,
+        { stdio: 'pipe' },
+      );
+      console.log('  ✅ MCP server updated (user-level)\n');
+    } catch (err) {
+      console.error('  ⚠️  Failed to register MCP server. You may need to add it manually:');
+      console.log(`  claude mcp add -s user wechat-channel node ${serverPath}\n`);
+    }
+  }
+
+  // Step 2: QR Login
+  console.log('  [2/3] WeChat QR login...');
+  const existing = getActiveAccount();
+  if (existing) {
+    console.log(`  ℹ️  Found existing account: ${existing.accountId}`);
+    console.log('  Skipping login. Run "npx @aster110/wechat-claude login" to re-login.\n');
+  } else {
+    try {
+      const result = await loginWithQRWeb();
+      saveAccount({
+        accountId: result.accountId.replace(/@/g, '-').replace(/\./g, '-'),
+        token: result.token,
+        baseUrl: result.baseUrl,
+        savedAt: new Date().toISOString(),
+      });
+      console.log(`  ✅ Login successful! Account: ${result.accountId}\n`);
+    } catch (err) {
+      console.error(`  ❌ Login failed: ${err}`);
+      console.log('  Run "npx @aster110/wechat-claude login" to retry.\n');
+    }
+  }
+
+  // Step 3: Print next steps
+  console.log('  [3/3] Setup complete!\n');
+  console.log('  Next steps:');
+  console.log('  1. Start Claude Code with WeChat channel:');
+  console.log('     claude --dangerously-load-development-channels server:wechat-channel\n');
+  console.log('  2. Send a message to your WeChat — Claude Code will auto-reply!\n');
+}
+
+async function login(): Promise<void> {
+  console.log('\n  🦞 WeChat QR Login\n');
+  try {
+    const result = await loginWithQRWeb();
+    saveAccount({
+      accountId: result.accountId.replace(/@/g, '-').replace(/\./g, '-'),
+      token: result.token,
+      baseUrl: result.baseUrl,
+      savedAt: new Date().toISOString(),
+    });
+    console.log(`\n  ✅ Login successful! Account: ${result.accountId}\n`);
+  } catch (err) {
+    console.error(`\n  ❌ Login failed: ${err}\n`);
+    process.exit(1);
+  }
+}
+
+function status(): void {
+  const account = getActiveAccount();
+  if (account) {
+    console.log(`\n  🦞 WeChat Channel Status\n`);
+    console.log(`  Account: ${account.accountId}`);
+    console.log(`  Token: ${account.token.slice(0, 10)}...`);
+    console.log(`  Base URL: ${account.baseUrl || 'https://ilinkai.weixin.qq.com'}`);
+    console.log(`  Saved: ${account.savedAt}\n`);
+  } else {
+    console.log('\n  ⚠️  Not logged in. Run: npx @aster110/wechat-claude install\n');
+  }
+}
+
+switch (command) {
+  case 'install':
+  case 'setup':
+    install().catch(console.error);
+    break;
+  case 'login':
+    login().catch(console.error);
+    break;
+  case 'status':
+    status();
+    break;
+  case 'help':
+  case '--help':
+  case '-h':
+  case undefined:
+    printUsage();
+    break;
+  default:
+    console.error(`  Unknown command: ${command}`);
+    printUsage();
+    process.exit(1);
+}

package/src/qrcode-terminal.d.ts

@@ -0,0 +1,9 @@
+declare module 'qrcode-terminal' {
+  interface Options {
+    small?: boolean;
+  }
+  const qrcode: {
+    generate(text: string, opts?: Options, cb?: (qr: string) => void): void;
+  };
+  export default qrcode;
+}

package/src/server.ts

@@ -0,0 +1,479 @@
+#!/usr/bin/env node
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+
+import { loginWithQRWeb } from './auth.js';
+import { getActiveAccount, saveAccount, loadSyncBuf, saveSyncBuf } from './store.js';
+import {
+  getUpdates,
+  sendMessage,
+  sendTyping,
+  getConfig,
+  uploadAndSendMedia,
+} from './wechat-api.js';
+import fs from 'node:fs';
+import type { WeixinMessage } from './types.js';
+import { MessageItemType } from './types.js';
+
+// ---------------------------------------------------------------------------
+// State
+// ---------------------------------------------------------------------------
+
+let pollingActive = false;
+let pollingAbort: AbortController | null = null;
+
+/** Cache: userId -> typing_ticket */
+const typingTicketCache = new Map<string, string>();
+
+// ---------------------------------------------------------------------------
+// Message text extraction
+// ---------------------------------------------------------------------------
+
+function extractText(msg: WeixinMessage): string {
+  const parts: string[] = [];
+  for (const item of msg.item_list ?? []) {
+    if (item.type === MessageItemType.TEXT && item.text_item?.text) {
+      parts.push(item.text_item.text);
+    } else if (item.type === MessageItemType.IMAGE) {
+      parts.push('[Image]');
+    } else if (item.type === MessageItemType.VOICE && item.voice_item?.text) {
+      parts.push(`[Voice] ${item.voice_item.text}`);
+    } else if (item.type === MessageItemType.FILE && item.file_item?.file_name) {
+      parts.push(`[File: ${item.file_item.file_name}]`);
+    } else if (item.type === MessageItemType.VIDEO) {
+      parts.push('[Video]');
+    }
+  }
+  return parts.join('\n') || '[Empty message]';
+}
+
+// ---------------------------------------------------------------------------
+// Text chunking for WeChat 4000-char limit
+// ---------------------------------------------------------------------------
+
+const MAX_CHUNK_LENGTH = 3900;
+
+function chunkText(text: string): string[] {
+  if (text.length <= MAX_CHUNK_LENGTH) return [text];
+  const chunks: string[] = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= MAX_CHUNK_LENGTH) {
+      chunks.push(remaining);
+      break;
+    }
+    // Try to break at newline
+    let breakAt = remaining.lastIndexOf('\n', MAX_CHUNK_LENGTH);
+    if (breakAt < MAX_CHUNK_LENGTH * 0.5) {
+      // No good newline break, try space
+      breakAt = remaining.lastIndexOf(' ', MAX_CHUNK_LENGTH);
+    }
+    if (breakAt < MAX_CHUNK_LENGTH * 0.3) {
+      breakAt = MAX_CHUNK_LENGTH;
+    }
+    chunks.push(remaining.slice(0, breakAt));
+    remaining = remaining.slice(breakAt).trimStart();
+  }
+  return chunks;
+}
+
+// ---------------------------------------------------------------------------
+// Strip markdown for WeChat plain text
+// ---------------------------------------------------------------------------
+
+function stripMarkdown(text: string): string {
+  let result = text;
+  // Code blocks: strip fences, keep content
+  result = result.replace(/```[^\n]*\n?([\s\S]*?)```/g, (_, code: string) => code.trim());
+  // Images: remove
+  result = result.replace(/!\[[^\]]*\]\([^)]*\)/g, '');
+  // Links: keep display text
+  result = result.replace(/\[([^\]]+)\]\([^)]*\)/g, '$1');
+  // Bold/italic
+  result = result.replace(/\*\*(.+?)\*\*/g, '$1');
+  result = result.replace(/\*(.+?)\*/g, '$1');
+  result = result.replace(/__(.+?)__/g, '$1');
+  result = result.replace(/_(.+?)_/g, '$1');
+  // Headings
+  result = result.replace(/^#{1,6}\s+/gm, '');
+  // Horizontal rules
+  result = result.replace(/^[-*_]{3,}$/gm, '');
+  // Blockquotes
+  result = result.replace(/^>\s?/gm, '');
+  return result.trim();
+}
+
+// ---------------------------------------------------------------------------
+// MCP Server
+// ---------------------------------------------------------------------------
+
+const server = new Server(
+  { name: 'wechat-channel', version: '1.0.0' },
+  {
+    capabilities: {
+      experimental: { 'claude/channel': {} },
+      tools: {},
+    },
+  },
+);
+
+// -- Tools --
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'reply',
+      description:
+        'Reply to a WeChat message. Supports text and image/file. Set media to a local file path to send an image or file.',
+      inputSchema: {
+        type: 'object' as const,
+        properties: {
+          user_id: {
+            type: 'string',
+            description: 'The WeChat user ID to reply to (from_user_id from the incoming message)',
+          },
+          context_token: {
+            type: 'string',
+            description: 'The context_token from the incoming message (required for reply association)',
+          },
+          content: {
+            type: 'string',
+            description: 'Text content',
+          },
+          media: {
+            type: 'string',
+            description: 'Optional: absolute path to a local file (image/video/file) to send',
+          },
+        },
+        required: ['user_id', 'context_token', 'content'],
+      },
+    },
+    {
+      name: 'login',
+      description:
+        'Login to WeChat by scanning a QR code. Run this first if not already logged in.',
+      inputSchema: {
+        type: 'object' as const,
+        properties: {},
+      },
+    },
+  ],
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  if (name === 'login') {
+    try {
+      const result = await loginWithQRWeb();
+      saveAccount({
+        accountId: result.accountId,
+        token: result.token,
+        baseUrl: result.baseUrl,
+        savedAt: new Date().toISOString(),
+      });
+      // Start polling after login
+      startPolling();
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: `WeChat login successful! Account: ${result.accountId}. Polling started.`,
+          },
+        ],
+      };
+    } catch (err) {
+      return {
+        content: [
+          { type: 'text' as const, text: `Login failed: ${String(err)}` },
+        ],
+        isError: true,
+      };
+    }
+  }
+
+  if (name === 'reply') {
+    const userId = (args as Record<string, string>).user_id;
+    const contextToken = (args as Record<string, string>).context_token;
+    const content = (args as Record<string, string>).content;
+    const media = (args as Record<string, string>).media;
+
+    if (!userId || !contextToken || !content) {
+      return {
+        content: [
+          { type: 'text' as const, text: 'Missing required fields: user_id, context_token, content' },
+        ],
+        isError: true,
+      };
+    }
+
+    // Validate media path if provided
+    if (media && !fs.existsSync(media)) {
+      return {
+        content: [
+          { type: 'text' as const, text: `Media file not found: ${media}` },
+        ],
+        isError: true,
+      };
+    }
+
+    const account = getActiveAccount();
+    if (!account) {
+      return {
+        content: [
+          { type: 'text' as const, text: 'Not logged in. Use the login tool first.' },
+        ],
+        isError: true,
+      };
+    }
+
+    try {
+      // Send typing indicator
+      const ticket = typingTicketCache.get(userId);
+      if (ticket) {
+        await sendTyping(account.token, userId, ticket, 1, account.baseUrl).catch(() => {});
+      }
+
+      // Strip markdown and chunk
+      const plainText = stripMarkdown(content);
+      const chunks = chunkText(plainText);
+
+      for (const chunk of chunks) {
+        await sendMessage(account.token, userId, chunk, contextToken, account.baseUrl);
+      }
+
+      // Send media if provided
+      let mediaSent = false;
+      if (media) {
+        await uploadAndSendMedia({
+          token: account.token,
+          toUser: userId,
+          contextToken,
+          filePath: media,
+          baseUrl: account.baseUrl,
+        });
+        mediaSent = true;
+      }
+
+      // Cancel typing
+      if (ticket) {
+        await sendTyping(account.token, userId, ticket, 2, account.baseUrl).catch(() => {});
+      }
+
+      const parts = [`Reply sent to ${userId} (${chunks.length} chunk${chunks.length > 1 ? 's' : ''})`];
+      if (mediaSent) parts.push(`Media sent: ${media}`);
+
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: parts.join('. '),
+          },
+        ],
+      };
+    } catch (err) {
+      return {
+        content: [
+          { type: 'text' as const, text: `Failed to send reply: ${String(err)}` },
+        ],
+        isError: true,
+      };
+    }
+  }
+
+  return {
+    content: [{ type: 'text' as const, text: `Unknown tool: ${name}` }],
+    isError: true,
+  };
+});
+
+// ---------------------------------------------------------------------------
+// Long-polling loop
+// ---------------------------------------------------------------------------
+
+const SESSION_EXPIRED_ERRCODE = -14;
+const MAX_CONSECUTIVE_FAILURES = 3;
+const BACKOFF_DELAY_MS = 30_000;
+const RETRY_DELAY_MS = 2_000;
+const SESSION_PAUSE_MS = 5 * 60_000;
+
+function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const t = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      'abort',
+      () => {
+        clearTimeout(t);
+        reject(new Error('aborted'));
+      },
+      { once: true },
+    );
+  });
+}
+
+async function pollLoop(account: { token: string; accountId: string; baseUrl?: string }): Promise<void> {
+  let buf = loadSyncBuf(account.accountId);
+  let consecutiveFailures = 0;
+  let nextTimeoutMs = 35_000;
+
+  process.stderr.write(`[wechat-channel] Polling started for account ${account.accountId}\n`);
+
+  while (pollingActive && !pollingAbort?.signal.aborted) {
+    try {
+      const resp = await getUpdates(account.token, buf, account.baseUrl, nextTimeoutMs);
+
+      // Update timeout if server suggests one
+      if (resp.longpolling_timeout_ms != null && resp.longpolling_timeout_ms > 0) {
+        nextTimeoutMs = resp.longpolling_timeout_ms;
+      }
+
+      // Check for API errors
+      const isApiError =
+        (resp.ret !== undefined && resp.ret !== 0) ||
+        (resp.errcode !== undefined && resp.errcode !== 0);
+
+      if (isApiError) {
+        const isSessionExpired =
+          resp.errcode === SESSION_EXPIRED_ERRCODE || resp.ret === SESSION_EXPIRED_ERRCODE;
+
+        if (isSessionExpired) {
+          process.stderr.write(
+            `[wechat-channel] Session expired (errcode ${SESSION_EXPIRED_ERRCODE}), pausing ${Math.ceil(SESSION_PAUSE_MS / 60_000)} min\n`,
+          );
+          consecutiveFailures = 0;
+          await sleep(SESSION_PAUSE_MS, pollingAbort?.signal);
+          continue;
+        }
+
+        consecutiveFailures++;
+        process.stderr.write(
+          `[wechat-channel] getUpdates error: ret=${resp.ret} errcode=${resp.errcode} errmsg=${resp.errmsg ?? ''} (${consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES})\n`,
+        );
+        if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+          consecutiveFailures = 0;
+          await sleep(BACKOFF_DELAY_MS, pollingAbort?.signal);
+        } else {
+          await sleep(RETRY_DELAY_MS, pollingAbort?.signal);
+        }
+        continue;
+      }
+
+      consecutiveFailures = 0;
+
+      // Save sync buf
+      if (resp.get_updates_buf != null && resp.get_updates_buf !== '') {
+        saveSyncBuf(account.accountId, resp.get_updates_buf);
+        buf = resp.get_updates_buf;
+      }
+
+      // Process messages
+      const msgs = resp.msgs ?? [];
+      for (const msg of msgs) {
+        // Only process user messages (message_type === 1)
+        if (msg.message_type !== 1) continue;
+
+        const text = extractText(msg);
+        const fromUser = msg.from_user_id ?? 'unknown';
+        const contextToken = msg.context_token ?? '';
+
+        process.stderr.write(`[wechat-channel] Message from ${fromUser}: ${text.slice(0, 100)}\n`);
+
+        // Cache typing ticket for this user
+        try {
+          const cfg = await getConfig(account.token, fromUser, contextToken, account.baseUrl);
+          if (cfg.typing_ticket) {
+            typingTicketCache.set(fromUser, cfg.typing_ticket);
+          }
+        } catch {
+          // non-critical
+        }
+
+        // Send typing indicator
+        const ticket = typingTicketCache.get(fromUser);
+        if (ticket) {
+          await sendTyping(account.token, fromUser, ticket, 1, account.baseUrl).catch(() => {});
+        }
+
+        // Push to Claude Code via channel notification
+        server.notification({
+          method: 'notifications/claude/channel',
+          params: {
+            content: `${text}\n\n[System: Reply via the "reply" tool. user_id and context_token are in the message metadata above.]`,
+            meta: {
+              source: 'wechat',
+              sender: fromUser,
+              user_id: fromUser,
+              context_token: contextToken,
+              message_id: String(msg.message_id ?? ''),
+              session_id: msg.session_id ?? '',
+            },
+          },
+        });
+      }
+    } catch (err) {
+      if (pollingAbort?.signal.aborted) return;
+      consecutiveFailures++;
+      process.stderr.write(
+        `[wechat-channel] Poll error (${consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES}): ${String(err)}\n`,
+      );
+      if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+        consecutiveFailures = 0;
+        await sleep(BACKOFF_DELAY_MS, pollingAbort?.signal);
+      } else {
+        await sleep(RETRY_DELAY_MS, pollingAbort?.signal);
+      }
+    }
+  }
+}
+
+function startPolling(): void {
+  const account = getActiveAccount();
+  if (!account) {
+    process.stderr.write('[wechat-channel] No account found, skipping polling\n');
+    return;
+  }
+  if (pollingActive) {
+    process.stderr.write('[wechat-channel] Polling already active\n');
+    return;
+  }
+
+  pollingActive = true;
+  pollingAbort = new AbortController();
+
+  // Run poll loop in background (don't await)
+  pollLoop(account).catch((err) => {
+    if (!pollingAbort?.signal.aborted) {
+      process.stderr.write(`[wechat-channel] Poll loop crashed: ${String(err)}\n`);
+    }
+    pollingActive = false;
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main(): Promise<void> {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  process.stderr.write('[wechat-channel] MCP server started\n');
+
+  // Auto-start polling if we have saved credentials
+  const account = getActiveAccount();
+  if (account) {
+    process.stderr.write(`[wechat-channel] Found saved account: ${account.accountId}\n`);
+    startPolling();
+  } else {
+    process.stderr.write('[wechat-channel] No saved account. Use the login tool to connect.\n');
+  }
+}
+
+main().catch((err) => {
+  process.stderr.write(`[wechat-channel] Fatal: ${String(err)}\n`);
+  process.exit(1);
+});

package/src/store.ts

@@ -0,0 +1,79 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const CHANNEL_DIR = path.join(os.homedir(), '.claude', 'channels', 'wechat-channel');
+
+function ensureDir(dir: string): void {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+// ---------------------------------------------------------------------------
+// Account credentials
+// ---------------------------------------------------------------------------
+
+export interface AccountData {
+  accountId: string;
+  token: string;
+  baseUrl?: string;
+  savedAt: string;
+}
+
+function accountsFilePath(): string {
+  return path.join(CHANNEL_DIR, 'accounts.json');
+}
+
+export function loadAccounts(): AccountData[] {
+  try {
+    const raw = fs.readFileSync(accountsFilePath(), 'utf-8');
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+export function saveAccount(account: AccountData): void {
+  ensureDir(CHANNEL_DIR);
+  const accounts = loadAccounts().filter((a) => a.accountId !== account.accountId);
+  accounts.push(account);
+  const filePath = accountsFilePath();
+  fs.writeFileSync(filePath, JSON.stringify(accounts, null, 2), 'utf-8');
+  try {
+    fs.chmodSync(filePath, 0o600);
+  } catch {
+    // best-effort
+  }
+}
+
+export function getActiveAccount(): AccountData | null {
+  const accounts = loadAccounts();
+  return accounts.length > 0 ? accounts[accounts.length - 1]! : null;
+}
+
+export function removeAccount(accountId: string): void {
+  const accounts = loadAccounts().filter((a) => a.accountId !== accountId);
+  ensureDir(CHANNEL_DIR);
+  fs.writeFileSync(accountsFilePath(), JSON.stringify(accounts, null, 2), 'utf-8');
+}
+
+// ---------------------------------------------------------------------------
+// Sync buf (long-poll cursor)
+// ---------------------------------------------------------------------------
+
+function syncBufFilePath(accountId: string): string {
+  return path.join(CHANNEL_DIR, `sync-buf-${accountId}.txt`);
+}
+
+export function loadSyncBuf(accountId: string): string {
+  try {
+    return fs.readFileSync(syncBufFilePath(accountId), 'utf-8');
+  } catch {
+    return '';
+  }
+}
+
+export function saveSyncBuf(accountId: string, buf: string): void {
+  ensureDir(CHANNEL_DIR);
+  fs.writeFileSync(syncBufFilePath(accountId), buf, 'utf-8');
+}