@unlinearity/cli-wechat-bridge 1.2.2 → 1.2.3

package/dist/companion/local-companion-start.js

@@ -5,13 +5,17 @@
 // This file is part of CLI-WeChat-Bridge. Modifications and derivative works
 // must be released under AGPL-3.0-or-later with full source code; see
 // LICENSE.txt. Network services built on it must offer source to users.
+import fs from "node:fs";
 import net from "node:net";
 import path from "node:path";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { BRIDGE_LOG_FILE } from "../wechat/channel-config.js";
+import { BRIDGE_LOG_FILE, getWorkspaceChannelPaths } from "../wechat/channel-config.js";
+import { resolveCodexDaemonControlSocketPath, } from "../bridge/bridge-adapters.codex.js";
 import { ensureWechatCredentials } from "../wechat/setup.js";
 import { ensureWecomAccount } from "../channels/wecom/setup.js";
+import { ensureTelegramAccount } from "../channels/telegram/setup.js";
+import { getBridgeChannelDisplayName, isBridgeChannelId, normalizeBridgeChannelId, } from "../core/channel-types.js";
 import { isDirectModuleRun } from "../core/direct-run.js";
 import { readBridgeLockFile, shouldAutoReclaimBridgeLock, } from "../bridge/bridge-state.js";
 import { clearLocalCompanionOccupancy, clearLocalCompanionEndpoint, readLocalCompanionEndpoint, } from "./local-companion-link.js";
@@ -23,8 +27,8 @@ const MODULE_DIR = path.dirname(MODULE_FILE);
 const RUNTIME_ENTRY_EXTENSION = path.extname(MODULE_FILE) === ".ts" ? ".ts" : ".js";
 const DEFAULT_WAIT_TIMEOUT_MS = 15_000;
 const DEFAULT_ADAPTER = "codex";
-function log(adapter, message, channelId = "wechat") {
-    process.stderr.write(`[${channelId}-${adapter}] ${message}\n`);
+function log(options, message) {
+    process.stderr.write(`[${options.channelId ?? "wechat"}-${options.adapter}] ${message}\n`);
 }
 export function normalizeComparablePath(cwd) {
     const normalized = path.resolve(cwd);
@@ -115,6 +119,8 @@ export function parseCliArgs(argv) {
     let timeoutMs = DEFAULT_WAIT_TIMEOUT_MS;
     let sessionStartMode;
     let channelId = "wechat";
+    let attachCurrentSession = false;
+    let codexThreadId;
     const cliArgs = [];
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
@@ -134,15 +140,14 @@ export function parseCliArgs(argv) {
             process.stdout.write([
                 `Usage: ${commandName} [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [--session-start-mode <restore|new>] [...${helpAdapter} args]`,
                 "",
-                `Ensures the ${channelId === "wecom" ? "WeCom" : "WeChat"} runtime for the current directory, then opens or reuses the visible CLI.`,
+                `Ensures the ${getBridgeChannelDisplayName(channelId)} runtime for the current directory, then opens or reuses the visible CLI.`,
                 "If a same-workspace daemon is running, the command delegates to that daemon.",
-                helpAdapter === "codex"
-                    ? "Codex restores the current session by default."
-                    : `${adapterLabel} starts a fresh session by default.`,
-                helpAdapter === "codex"
-                    ? "Use --session-start-mode new to explicitly start a fresh session."
-                    : "Use --session-start-mode restore to explicitly restore the previous session.",
+                `${adapterLabel} starts a fresh session by default.`,
+                "Use --session-start-mode restore to explicitly restore the previous session.",
                 "Use --doctor to check the selected adapter and workspace without starting it.",
+                helpAdapter === "codex"
+                    ? `Use --attach-current-session to attach ${getBridgeChannelDisplayName(channelId)} to the live Codex daemon session in this directory (Codex >= 0.162 shared background server), instead of opening a visible client.`
+                    : "",
                 "Without a daemon, the transient runtime is companion-bound and stops when the visible CLI closes.",
                 "Unknown arguments are forwarded to the visible CLI client.",
                 "",
@@ -153,7 +158,7 @@ export function parseCliArgs(argv) {
             continue;
         }
         if (arg === "--channel") {
-            if (!next || (next !== "wechat" && next !== "wecom")) {
+            if (!isBridgeChannelId(next) || next === "local") {
                 throw new Error(`Invalid channel: ${next ?? "(missing)"}`);
             }
             channelId = next;
@@ -204,8 +209,23 @@ export function parseCliArgs(argv) {
             i += 1;
             continue;
         }
+        if (arg === "--attach-current-session") {
+            attachCurrentSession = true;
+            continue;
+        }
+        if (arg === "--codex-thread-id") {
+            if (!next) {
+                throw new Error("--codex-thread-id requires a value");
+            }
+            codexThreadId = next;
+            i += 1;
+            continue;
+        }
         cliArgs.push(arg);
     }
+    if (attachCurrentSession && adapter !== "codex") {
+        throw new Error("--attach-current-session requires the codex adapter");
+    }
     return {
         adapter,
         cwd,
@@ -214,6 +234,8 @@ export function parseCliArgs(argv) {
         sessionStartMode: sessionStartMode ?? defaultSessionStartMode(adapter),
         cliArgs,
         channelId,
+        attachCurrentSession,
+        codexThreadId,
     };
 }
 function isPidAlive(pid) {
@@ -238,9 +260,9 @@ async function waitForProcessExit(pid, timeoutMs) {
     }
     return !isPidAlive(pid);
 }
-async function stopExistingBridge(lock, requestedAdapter) {
+async function stopExistingBridge(lock, options) {
     const { pid, cwd } = lock;
-    log(requestedAdapter, `Stopping existing bridge for ${cwd} (pid=${pid})...`);
+    log(options, `Stopping existing bridge for ${cwd} (pid=${pid})...`);
     try {
         process.kill(pid);
     }
@@ -264,7 +286,7 @@ async function stopExistingBridge(lock, requestedAdapter) {
     else {
         clearLocalCompanionEndpoint(cwd);
     }
-    log(requestedAdapter, `Cleared stale local companion endpoint for previous workspace ${cwd}.`);
+    log(options, `Cleared stale local companion endpoint for previous workspace ${cwd}.`);
 }
 async function isEndpointReachable(endpoint) {
     await new Promise((resolve) => setTimeout(resolve, 0));
@@ -289,7 +311,8 @@ async function isEndpointReachable(endpoint) {
         socket.once("error", () => finish(false));
     });
 }
-async function readUsableEndpoint(cwd, adapter) {
+async function readUsableEndpoint(options) {
+    const { cwd, adapter } = options;
     const endpoint = readLocalCompanionEndpoint(cwd, { adapter });
     if (!endpoint || endpoint.kind !== adapter) {
         return { endpoint: null };
@@ -298,7 +321,7 @@ async function readUsableEndpoint(cwd, adapter) {
         return { endpoint };
     }
     clearLocalCompanionEndpoint(cwd, endpoint.instanceId, { adapter });
-    log(adapter, `Removed stale local companion endpoint for ${cwd}.`);
+    log(options, `Removed stale local companion endpoint for ${cwd}.`);
     return { endpoint: null };
 }
 function isCompanionAlive(endpoint) {
@@ -314,21 +337,31 @@ function isCompanionAlive(endpoint) {
     return false;
 }
 export function buildBackgroundBridgeArgs(entryPath, options) {
-    const lifecycle = "companion_bound";
+    // The attach bridge outlives this launcher (no visible client keeps the
+    // foreground alive), so it must not be companion-bound to the launcher pid.
+    const lifecycle = options.attachCurrentSession ? "persistent" : "companion_bound";
     const args = ["--no-warnings"];
     if (path.extname(entryPath) === ".ts") {
         args.push("--experimental-strip-types");
     }
     args.push(entryPath, "--adapter", options.adapter, "--cwd", options.cwd, "--lifecycle", lifecycle);
-    if (options.channelId === "wecom") {
-        args.push("--channel", "wecom");
+    if (options.channelId) {
+        args.push("--channel", options.channelId);
     }
-    if (options.sessionStartMode !== "restore") {
-        args.push("--session-start-mode", options.sessionStartMode);
+    // Attach discovery owns thread selection; do not restore stale bridge state.
+    const sessionStartMode = options.attachCurrentSession ? "new" : options.sessionStartMode;
+    if (sessionStartMode !== "restore") {
+        args.push("--session-start-mode", sessionStartMode);
     }
     if (options.profile) {
         args.push("--profile", options.profile);
     }
+    if (options.attachCurrentSession) {
+        args.push("--codex-attach-daemon");
+        if (options.codexThreadId) {
+            args.push("--codex-thread-id", options.codexThreadId);
+        }
+    }
     return args;
 }
 function startBridgeInBackground(options) {
@@ -348,10 +381,11 @@ function startBridgeInBackground(options) {
     });
     child.unref();
 }
-async function waitForEndpoint(cwd, adapter, timeoutMs) {
+async function waitForEndpoint(options) {
+    const { cwd, adapter, timeoutMs } = options;
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
-        const result = await readUsableEndpoint(cwd, adapter);
+        const result = await readUsableEndpoint(options);
         if (result.endpoint) {
             return result.endpoint;
         }
@@ -361,25 +395,25 @@ async function waitForEndpoint(cwd, adapter, timeoutMs) {
 }
 async function ensureBridgeReady(options) {
     // If the lock is absent or the lock-holding process is dead, do NOT trust a
-    // leftover endpoint.  The bridge (WeChat transport) may have crashed while
+    // leftover endpoint.  The channel transport may have crashed while
     // the opencode server kept running.  Starting only the panel would leave no
-    // bridge to poll WeChat messages.
+    // bridge to receive channel messages.
     const lock = readBridgeLockFile();
     const lockProcessAlive = lock ? isPidAlive(lock.pid) : false;
     if (!lock || !lockProcessAlive) {
         if (lock && !lockProcessAlive) {
-            log(options.adapter, `Found stale lock for ${options.cwd} (pid=${lock.pid} dead). Clearing.`);
+            log(options, `Found stale lock for ${options.cwd} (pid=${lock.pid} dead). Clearing.`);
             clearLocalCompanionEndpoint(options.cwd, undefined, {
                 adapter: options.adapter,
             });
         }
-        log(options.adapter, `Starting bridge in background for ${options.cwd}...`);
+        log(options, `Starting bridge in background for ${options.cwd}...`);
         startBridgeInBackground(options);
-        await waitForEndpoint(options.cwd, options.adapter, options.timeoutMs);
+        await waitForEndpoint(options);
         return { shouldOpenVisibleClient: true };
     }
     // Lock is held by a live process; decide whether to reuse, switch, or replace it.
-    const endpointResult = await readUsableEndpoint(options.cwd, options.adapter);
+    const endpointResult = await readUsableEndpoint(options);
     const decision = decideLaunchAction({
         requestedAdapter: options.adapter,
         requestedCwd: options.cwd,
@@ -391,31 +425,31 @@ async function ensureBridgeReady(options) {
         sessionStartMode: options.sessionStartMode,
         requestedChannelId: options.channelId,
     });
-    log(options.adapter, decision.message);
+    log(options, decision.message);
     if (decision.kind === "already_active") {
         return { shouldOpenVisibleClient: false };
     }
     if (decision.kind === "open_companion") {
         if (!endpointResult.endpoint) {
-            await waitForEndpoint(options.cwd, options.adapter, options.timeoutMs);
+            await waitForEndpoint(options);
         }
         return { shouldOpenVisibleClient: true };
     }
     if (decision.kind === "switch_workspace") {
         try {
-            await stopExistingBridge(lock, options.adapter);
+            await stopExistingBridge(lock, options);
         }
         catch (error) {
-            log(options.adapter, decision.failureMessage);
+            log(options, decision.failureMessage);
             throw error;
         }
     }
     else {
-        await stopExistingBridge(lock, options.adapter);
+        await stopExistingBridge(lock, options);
     }
-    log(options.adapter, `Starting replacement bridge in background for ${options.cwd}...`);
+    log(options, `Starting replacement bridge in background for ${options.cwd}...`);
     startBridgeInBackground(options);
-    await waitForEndpoint(options.cwd, options.adapter, options.timeoutMs);
+    await waitForEndpoint(options);
     return { shouldOpenVisibleClient: true };
 }
 // The daemon's ensure_slot can legitimately take a while: opening a visible
@@ -460,10 +494,10 @@ export async function tryDelegateToDaemon(options, deps = {}) {
         // launch: fall back to a local companion-bound bridge so the user still
         // gets a working terminal instead of an error for work the daemon may
         // still complete.
-        log(options.adapter, `Daemon delegation failed (${response.error ?? "unknown error"}). Falling back to a local bridge.`);
+        log(options, `Daemon delegation failed (${response.error ?? "unknown error"}). Falling back to a local bridge.`);
         return false;
     }
-    log(options.adapter, `Delegated to running ${requestedChannel}-daemon for ${options.cwd}.`, requestedChannel);
+    log(options, `Delegated to running ${requestedChannel}-daemon for ${options.cwd}.`);
     return true;
 }
 export async function runVisibleClient(options, runners = {}) {
@@ -487,17 +521,30 @@ export async function ensureCompanionStartWechatCredentials(adapter, ensureCrede
     await ensureCredentials({
         requireUserId: true,
         validateExisting: true,
-        log: (message) => log(adapter, message),
+        log: (message) => log({ adapter, channelId: "wechat" }, message),
     });
 }
-export async function ensureCompanionStartChannelCredentials(options) {
-    if (options.channelId === "wecom") {
+const channelCredentialSetups = {
+    wechat: async (options) => {
+        await ensureCompanionStartWechatCredentials(options.adapter);
+    },
+    wecom: async (options) => {
         await ensureWecomAccount({
-            log: (message) => log(options.adapter, message, "wecom"),
+            log: (message) => log(options, message),
+        });
+    },
+    telegram: async (options) => {
+        await ensureTelegramAccount({
+            log: (message) => log(options, message),
         });
-        return;
+    },
+};
+export async function ensureCompanionStartChannelCredentials(options) {
+    const channelId = options.channelId ?? "wechat";
+    if (channelId === "local") {
+        throw new Error("The local channel does not support companion launchers.");
     }
-    await ensureCompanionStartWechatCredentials(options.adapter);
+    await channelCredentialSetups[channelId](options);
 }
 export async function runLocalCompanionStart(argv = process.argv.slice(2)) {
     if (argv.includes("--doctor")) {
@@ -507,6 +554,9 @@ export async function runLocalCompanionStart(argv = process.argv.slice(2)) {
     }
     const options = parseCliArgs(argv);
     await ensureCompanionStartChannelCredentials(options);
+    if (options.attachCurrentSession) {
+        return await runAttachCurrentSession(options);
+    }
     if (await tryDelegateToDaemon(options)) {
         return 0;
     }
@@ -516,29 +566,98 @@ export async function runLocalCompanionStart(argv = process.argv.slice(2)) {
     }
     return await runVisibleClient(options);
 }
+export function resolveAttachedBridgeThreadId(state, lock, options) {
+    if (!lock || !state || typeof state !== "object") {
+        return null;
+    }
+    const parsed = state;
+    const channelId = options.channelId ?? "wechat";
+    if (lock.adapter !== "codex" ||
+        !isSameWorkspaceCwd(lock.cwd, options.cwd) ||
+        (lock.channelId ?? "wechat") !== channelId ||
+        parsed.instanceId !== lock.instanceId ||
+        parsed.adapter !== "codex" ||
+        typeof parsed.cwd !== "string" ||
+        !isSameWorkspaceCwd(parsed.cwd, options.cwd) ||
+        (parsed.channelId ?? "wechat") !== channelId ||
+        typeof parsed.sharedThreadId !== "string" ||
+        !parsed.sharedThreadId ||
+        (options.codexThreadId && parsed.sharedThreadId !== options.codexThreadId)) {
+        return null;
+    }
+    return parsed.sharedThreadId;
+}
+export function formatAttachedBridgeMessage(options, sharedThreadId) {
+    return `Attached Codex daemon thread ${sharedThreadId.slice(0, 8)} for ${options.cwd}. ${getBridgeChannelDisplayName(options.channelId ?? "wechat")} forwarding is active; the visible Codex session keeps running unchanged.`;
+}
+async function waitForAttachedBridgeState(options) {
+    const { cwd, timeoutMs } = options;
+    const stateFile = getWorkspaceChannelPaths(cwd).stateFile;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        try {
+            const raw = fs.readFileSync(stateFile, "utf8");
+            const parsed = JSON.parse(raw);
+            const lock = readBridgeLockFile();
+            const sharedThreadId = resolveAttachedBridgeThreadId(parsed, lock, options);
+            if (sharedThreadId && lock && isPidAlive(lock.pid)) {
+                return { sharedThreadId };
+            }
+        }
+        catch {
+            // Not written yet; keep polling until the deadline.
+        }
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    throw new Error(`Timed out waiting for the attach bridge to bind a Codex thread for ${cwd}. Check ${BRIDGE_LOG_FILE}.`);
+}
+/**
+ * Attach flow: bind the selected channel to the live Codex shared-daemon session in the
+ * workspace. No visible client is opened — the owning Codex TUI stays as-is —
+ * so readiness is the persisted bridge state carrying the attached thread id.
+ */
+async function runAttachCurrentSession(options) {
+    const daemonEndpoint = readDaemonEndpoint();
+    if (daemonEndpoint && (await isDaemonEndpointAlive(daemonEndpoint))) {
+        const channel = daemonEndpoint.channelId ?? "wechat";
+        throw new Error(`A ${channel}-daemon is running for ${daemonEndpoint.cwd}. Attach mode needs the workspace bridge lock; stop the daemon first or use its slots.`);
+    }
+    const socketPath = resolveCodexDaemonControlSocketPath();
+    if (!fs.existsSync(socketPath)) {
+        throw new Error(`No shared Codex app-server daemon socket at ${socketPath}. Attach mode requires Codex >= 0.162 with its shared background server (the default). Sessions started with --no-daemon, --oss, or a --profile, and desktop-app embedded sessions, cannot be attached.`);
+    }
+    const lock = readBridgeLockFile();
+    if (lock) {
+        if (isPidAlive(lock.pid)) {
+            await stopExistingBridge(lock, options);
+        }
+        else {
+            clearLocalCompanionEndpoint(options.cwd, undefined, { adapter: options.adapter });
+            log(options, `Cleared stale bridge lock and endpoint for ${lock.cwd}.`);
+        }
+    }
+    log(options, `Starting attach bridge in background for ${options.cwd}...`);
+    startBridgeInBackground(options);
+    const state = await waitForAttachedBridgeState(options);
+    log(options, formatAttachedBridgeMessage(options, state.sharedThreadId));
+    return 0;
+}
 export async function main(argv = process.argv.slice(2)) {
     try {
         const exitCode = await runLocalCompanionStart(argv);
         process.exit(exitCode);
     }
     catch (error) {
-        const adapter = (() => {
-            try {
-                return parseCliArgs(argv).adapter;
-            }
-            catch {
-                return DEFAULT_ADAPTER;
-            }
-        })();
-        const channelId = (() => {
-            try {
-                return parseCliArgs(argv).channelId ?? "wechat";
-            }
-            catch {
-                return "wechat";
-            }
-        })();
-        log(adapter, error instanceof Error ? error.message : String(error), channelId);
+        // Argument validation may fail; retain the wrapper's channel and adapter
+        // without running the failing parser again.
+        const adapterIndex = argv.lastIndexOf("--adapter");
+        const adapterValue = adapterIndex >= 0 ? argv[adapterIndex + 1] : undefined;
+        const adapter = adapterValue && ["codex", "claude", "opencode", "pi"].includes(adapterValue)
+            ? adapterValue
+            : DEFAULT_ADAPTER;
+        const channelIndex = argv.lastIndexOf("--channel");
+        const channelId = normalizeBridgeChannelId(channelIndex >= 0 ? argv[channelIndex + 1] : undefined);
+        log({ adapter, channelId }, error instanceof Error ? error.message : String(error));
         process.exit(1);
     }
 }

package/dist/core/channel-types.js

@@ -1,7 +1,15 @@
+export const BRIDGE_CHANNEL_DISPLAY_NAMES = {
+    wechat: "WeChat",
+    wecom: "WeCom",
+    telegram: "Telegram",
+    local: "Local",
+};
+export function isBridgeChannelId(value) {
+    return typeof value === "string" && Object.hasOwn(BRIDGE_CHANNEL_DISPLAY_NAMES, value);
+}
+export function getBridgeChannelDisplayName(channelId) {
+    return BRIDGE_CHANNEL_DISPLAY_NAMES[channelId];
+}
 export function normalizeBridgeChannelId(value) {
-    if (value === "wecom")
-        return "wecom";
-    if (value === "local")
-        return "local";
-    return "wechat";
+    return isBridgeChannelId(value) ? value : "wechat";
 }

package/dist/daemon/wechat-daemon.js

@@ -39,11 +39,15 @@ import { forwardBridgeEvent } from "../core/bridge-event-forwarder.js";
 import { isDirectModuleRun } from "../core/direct-run.js";
 import { WechatChannelPort } from "../channels/wechat/wechat-channel-port.js";
 import { ensureWecomAccount } from "../channels/wecom/setup.js";
+import { ensureTelegramAccount } from "../channels/telegram/setup.js";
+import { TelegramTransport } from "../channels/telegram/telegram-transport.js";
+import { TelegramChannelPort } from "../channels/telegram/telegram-channel-port.js";
 import { WecomChannelPort } from "../channels/wecom/wecom-channel-port.js";
 import { WecomTransport } from "../channels/wecom/wecom-transport.js";
 import { createChannelDriver } from "../channels/channel-driver-factory.js";
 import { LocalChannelPort } from "../channels/local/local-channel-port.js";
 import { getLocalChannelFiles, LOCAL_CHANNEL_OPERATOR_ID, } from "../channels/local/local-driver.js";
+import { getBridgeChannelDisplayName, isBridgeChannelId, normalizeBridgeChannelId, } from "../core/channel-types.js";
 import { clearLocalCompanionEndpoint, clearLocalCompanionOccupancy, readLocalCompanionEndpoint, } from "../companion/local-companion-link.js";
 import { attachDaemonRequestListener, buildDaemonToken, clearDaemonEndpoint, DAEMON_PROTOCOL_VERSION, isPidAlive, readDaemonEndpoint, sendDaemonRequest, sendDaemonResponse, writeDaemonEndpoint, } from "./daemon-link.js";
 const MODULE_FILE = fileURLToPath(import.meta.url);
@@ -65,11 +69,7 @@ const DAEMON_ADAPTERS = ["codex", "claude", "opencode", "pi"];
 function getCliChannelId(argv = process.argv.slice(2)) {
     const index = argv.indexOf("--channel");
     const value = index >= 0 ? argv[index + 1] : undefined;
-    if (value === "wecom")
-        return "wecom";
-    if (value === "local")
-        return "local";
-    return "wechat";
+    return normalizeBridgeChannelId(value);
 }
 function log(message) {
     process.stderr.write(`[${getCliChannelId()}-daemon] ${message}\n`);
@@ -141,7 +141,7 @@ export function parseDaemonCliArgs(argv) {
         }
         const next = argv[i + 1];
         if (arg === "--help" || arg === "-h") {
-            const channelDisplayName = channelId === "wecom" ? "WeCom" : channelId === "local" ? "Local" : "WeChat";
+            const channelDisplayName = getBridgeChannelDisplayName(channelId);
             process.stdout.write([
                 `Usage: ${channelId}-daemon [--cwd <path>] [--adapter <codex|claude|opencode|pi>] [--profile <name-or-path>] [--no-open]`,
                 "",
@@ -160,7 +160,7 @@ export function parseDaemonCliArgs(argv) {
             continue;
         }
         if (arg === "--channel") {
-            if (!next || (next !== "wechat" && next !== "wecom" && next !== "local")) {
+            if (!isBridgeChannelId(next)) {
                 throw new Error(`Invalid channel: ${next ?? "(missing)"}`);
             }
             channelId = next;
@@ -573,6 +573,7 @@ export class WechatDaemon {
     channelDriver;
     channelId;
     wecomTransport;
+    telegramTransport;
     localFiles;
     inboundConversationContext = new InboundConversationContext();
     fallbackConversation;
@@ -601,6 +602,7 @@ export class WechatDaemon {
         this.transport = params.transport;
         this.channelId = params.channelId ?? "wechat";
         this.wecomTransport = params.wecomTransport ?? null;
+        this.telegramTransport = params.telegramTransport ?? null;
         this.localFiles = params.localFiles ?? null;
         this.deps = params.deps ?? {};
         this.channelDriver = createChannelDriver({
@@ -609,6 +611,7 @@ export class WechatDaemon {
             accountId: params.accountId,
             wechatTransport: this.transport,
             wecomTransport: this.wecomTransport,
+            telegramTransport: this.telegramTransport,
             localFiles: this.localFiles,
             buildWechatInboundPrompt: (text, attachments) => buildWechatInboundPrompt(text, attachments.filter((attachment) => attachment.kind === "image" || attachment.kind === "file")),
             log: (message) => this.daemonLog(message),
@@ -893,6 +896,12 @@ export class WechatDaemon {
         catch {
             // Best effort shutdown.
         }
+        try {
+            await this.telegramTransport?.stop();
+        }
+        catch {
+            // Best effort shutdown.
+        }
         clearDaemonEndpoint();
         for (const slot of this.slots.values()) {
             try {
@@ -1402,6 +1411,16 @@ export class WechatDaemon {
                 },
             });
         }
+        if (this.channelId === "telegram") {
+            return new TelegramChannelPort({
+                transport: this.telegramTransport,
+                sendText: (target, text, kind) => this.queueWechatMessage(this.authorizedUserId, text, toWechatSendContext(kind), target),
+                prefixText: (currentAdapter, text) => prefixDaemonAdapterMessage(currentAdapter ?? adapter, text),
+                onEmptyVisibleReply: (currentAdapter, rawText) => {
+                    appendDaemonLog(`empty_visible_final_reply: adapter=${currentAdapter ?? adapter} raw=${truncatePreview(rawText)}`);
+                },
+            });
+        }
         if (this.channelId === "local") {
             return new LocalChannelPort({
                 sendText: (recipientId, text, context) => this.queueWechatMessage(recipientId, text, context),
@@ -2415,19 +2434,26 @@ export async function runDaemon(options) {
     const wecomAccount = options.channelId === "wecom"
         ? await ensureWecomAccount({ log })
         : null;
+    const telegramAccount = options.channelId === "telegram"
+        ? await ensureTelegramAccount({ log })
+        : null;
     const credentials = wecomAccount
         ? { userId: wecomAccount.operatorUserId }
-        : options.channelId === "local"
-            ? { userId: LOCAL_CHANNEL_OPERATOR_ID }
-            : await ensureWechatCredentials({
-                requireUserId: true,
-                validateExisting: true,
-                log,
-            });
+        : telegramAccount
+            ? { userId: telegramAccount.operatorUserId }
+            : options.channelId === "local"
+                ? { userId: LOCAL_CHANNEL_OPERATOR_ID }
+                : await ensureWechatCredentials({
+                    requireUserId: true,
+                    validateExisting: true,
+                    log,
+                });
     if (!credentials.userId) {
         throw new Error(options.channelId === "wecom"
             ? "Saved WeCom credentials are missing operatorUserId."
-            : "Saved WeChat credentials are missing userId.");
+            : options.channelId === "telegram"
+                ? "Saved Telegram credentials are missing operatorUserId."
+                : "Saved WeChat credentials are missing userId.");
     }
     const daemon = new WechatDaemon({
         cwd: options.cwd,
@@ -2437,7 +2463,7 @@ export async function runDaemon(options) {
             ? new WeChatTransport({ log, logError })
             : null,
         channelId: options.channelId,
-        accountId: wecomAccount?.botId,
+        accountId: wecomAccount?.botId ?? telegramAccount?.botUsername,
         wecomTransport: wecomAccount
             ? new WecomTransport({
                 account: wecomAccount,
@@ -2447,6 +2473,15 @@ export async function runDaemon(options) {
                 },
             })
             : null,
+        telegramTransport: telegramAccount
+            ? new TelegramTransport({
+                account: telegramAccount,
+                logger: {
+                    log: (message) => log(message),
+                    error: (message) => logError(message),
+                },
+            })
+            : null,
         localFiles: options.channelId === "local"
             ? getLocalChannelFiles(options.cwd)
             : null,

package/dist/i18n/messages-en.js

@@ -337,6 +337,7 @@ export const messages = {
     "status.questions": "{count} question(s)",
     "operator.wechat": "the configured WeChat owner",
     "operator.wecom": "the paired WeCom operator",
+    "operator.telegram": "the paired Telegram operator",
     "operator.local": "the local operator",
     "status.label.instance_id": "instance_id",
     "status.label.adapter": "adapter",

package/dist/i18n/messages-zh.js

@@ -337,6 +337,7 @@ export const messages = {
     "status.questions": "{count} 个问题",
     "operator.wechat": "已配置的微信操作者",
     "operator.wecom": "已配对的企业微信操作者",
+    "operator.telegram": "已配对的 Telegram 操作者",
     "operator.local": "本地操作者",
     "status.label.instance_id": "实例 ID",
     "status.label.adapter": "适配器",