@cjhyy/code-shell-chat 0.8.0

package/dist/gateway.js

@@ -0,0 +1,287 @@
+import { channelCapabilities, supportsOutgoingAttachment, } from "./channel.js";
+import { materializeChatAttachments } from "./attachments.js";
+import { DesktopControlOperationError, DesktopControlUnavailableError, } from "./desktop-control-client.js";
+import { materializeOutgoingAttachments, splitNotificationTextForChannel, } from "./notification-relay.js";
+const MIMI_REPLY_CACHE_MAX_ENTRIES = 2_048;
+export const CODE_SHELL_REMOTE_COMMANDS = [
+    { name: "open", description: "打开 CodeShell 手机遥控隧道" },
+    { name: "close", description: "关闭 CodeShell 手机遥控隧道" },
+    { name: "status", description: "查看 CodeShell 手机遥控状态" },
+];
+/** Optional CodeShell integration. Unknown messages fall through to the next middleware. */
+export function createCodeShellRemoteCommands(options) {
+    return async ({ message, adapter, reply }, next) => {
+        const command = parseGatewayIntent(message.text);
+        if (command === "unsupported") {
+            await next();
+            return;
+        }
+        try {
+            if (command === "open") {
+                const opened = await options.desktop.open();
+                const qr = supportsOutgoingAttachment(adapter, "image")
+                    ? await renderPairingQrAttachment(opened.pairingUrl)
+                    : undefined;
+                await reply({
+                    text: [
+                        `公网隧道已开启：${opened.url}`,
+                        qr
+                            ? "配对入口 10 分钟内有效，请点击下方按钮或扫描二维码。"
+                            : "配对入口 10 分钟内有效，请点击下方按钮。",
+                        "打开后仍需输入桌面端已设置的访问口令。",
+                    ].join("\n"),
+                    button: { text: "打开手机遥控", url: opened.pairingUrl },
+                    ...(qr ? { attachments: [qr] } : {}),
+                });
+                return;
+            }
+            if (command === "close") {
+                await options.desktop.close();
+                await reply({ text: "公网隧道已关闭。" });
+                return;
+            }
+            const status = await options.desktop.status();
+            await reply({ text: formatStatus(status) });
+        }
+        catch (error) {
+            if (error instanceof DesktopControlUnavailableError) {
+                await reply({ text: `桌面端未在线：${error.message}` });
+                return;
+            }
+            if (error instanceof DesktopControlOperationError) {
+                await reply({ text: `操作失败：${error.message}` });
+                return;
+            }
+            await reply({
+                text: `操作失败：${error instanceof Error ? error.message : String(error)}`,
+            });
+        }
+    };
+}
+export function parseGatewayCommand(text) {
+    const first = text.trim().split(/\s+/, 1)[0]?.toLowerCase() ?? "";
+    const command = first.replace(/@[a-z0-9_]+$/i, "");
+    if (command === "/open")
+        return "open";
+    if (command === "/close")
+        return "close";
+    if (command === "/status")
+        return "status";
+    return "unsupported";
+}
+/**
+ * Only explicit slash commands short-circuit here. Every natural-language
+ * message — including "打开手机遥控" or "给我隧道地址" — flows to Mimi, whose
+ * MobileRemote tool decides the intent; regex alias matching was removed on
+ * purpose so intent understanding lives in one place (the model), not two.
+ */
+export function parseGatewayIntent(text) {
+    return parseGatewayCommand(text);
+}
+/** Final middleware: route ordinary text/media turns into the durable Mimi Pet session. */
+export function createMimiPetChat(options) {
+    // DeliveryQueue retries the same platform message after adapter.send fails.
+    // Cache the fully materialized reply (including attachment bytes) before the
+    // first send so retrying cannot re-run Mimi or any already-executed host
+    // action. Failed desktop/materialization work is evicted and remains retryable.
+    const replies = new Map();
+    const configuredChannels = options.channels ?? [];
+    return async ({ message, adapter, reply }) => {
+        if (!message.text.trim() && !message.attachments?.length)
+            return;
+        const cacheKey = mimiReplyCacheKey(message);
+        let cacheEntry;
+        let outgoing;
+        try {
+            if (!cacheKey) {
+                outgoing = await buildMimiOutgoingReplies(options, message, channelCapabilities(adapter), configuredChannels);
+            }
+            else {
+                const cached = replies.get(cacheKey);
+                if (cached) {
+                    // Refresh insertion order so active retries are not the first evicted.
+                    replies.delete(cacheKey);
+                    replies.set(cacheKey, cached);
+                    cacheEntry = cached;
+                    outgoing = await cached.outgoing;
+                }
+                else {
+                    const pending = buildMimiOutgoingReplies(options, message, channelCapabilities(adapter), configuredChannels);
+                    const entry = {
+                        outgoing: pending,
+                        nextSendIndex: 0,
+                        activeSends: 0,
+                        sendFailed: false,
+                    };
+                    replies.set(cacheKey, entry);
+                    cacheEntry = entry;
+                    while (replies.size > MIMI_REPLY_CACHE_MAX_ENTRIES) {
+                        const oldest = replies.keys().next().value;
+                        if (typeof oldest !== "string")
+                            break;
+                        replies.delete(oldest);
+                    }
+                    pending.catch(() => {
+                        if (replies.get(cacheKey) === entry)
+                            replies.delete(cacheKey);
+                    });
+                    outgoing = await pending;
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof DesktopControlUnavailableError) {
+                await reply({ text: `桌面端未在线：${error.message}` });
+                return;
+            }
+            if (error instanceof DesktopControlOperationError) {
+                await reply({ text: `Mimi Pet 处理失败：${error.message}` });
+                return;
+            }
+            await reply({
+                text: `Mimi Pet 处理失败：${error instanceof Error ? error.message : String(error)}`,
+            });
+            return;
+        }
+        // Adapter failures must escape to DeliveryQueue. Catching them above would
+        // turn a failed real reply into a successful generic error and lose it.
+        if (cacheEntry) {
+            if (cacheEntry.activeSends === 0)
+                cacheEntry.sendFailed = false;
+            cacheEntry.activeSends += 1;
+        }
+        try {
+            let index = cacheEntry?.nextSendIndex ?? 0;
+            while (index < outgoing.length) {
+                await reply(outgoing[index]);
+                index += 1;
+                if (cacheEntry)
+                    cacheEntry.nextSendIndex = index;
+            }
+        }
+        catch (error) {
+            if (cacheEntry)
+                cacheEntry.sendFailed = true;
+            throw error;
+        }
+        finally {
+            if (cacheEntry) {
+                cacheEntry.activeSends -= 1;
+                // DeliveryQueue now owns a durable completed-message dedupe record.
+                // Keep memory proportional to failed/in-flight sends, not successful chat.
+                if (cacheKey &&
+                    cacheEntry.activeSends === 0 &&
+                    !cacheEntry.sendFailed &&
+                    replies.get(cacheKey) === cacheEntry) {
+                    replies.delete(cacheKey);
+                }
+            }
+        }
+    };
+}
+async function buildMimiOutgoingReplies(options, message, capabilities, configuredChannels) {
+    const attachments = await materializeChatAttachments(message.attachments);
+    const result = await options.desktop.petChat({
+        message: message.text,
+        ...(attachments.length > 0 ? { attachments } : {}),
+        origin: {
+            channel: message.channel,
+            target: message.target,
+            senderId: message.senderId,
+            ...(message.messageId ? { messageId: message.messageId } : {}),
+            capabilities,
+            channels: gatewayChannelCatalog(message.channel, capabilities, configuredChannels),
+        },
+    });
+    const chunks = splitNotificationTextForChannel(result.text || "Mimi Pet 已处理，但没有返回文字内容。", message.channel, capabilities);
+    const outgoing = chunks.map((text) => ({ text }));
+    const last = outgoing.at(-1);
+    const button = normalizePetReplyButton(result.button);
+    if (button)
+        last.button = button;
+    if (result.attachments?.length && capabilities.outbound.attachments.length > 0) {
+        try {
+            const supported = result.attachments.filter((attachment) => capabilities.outbound.attachments.includes(attachment.kind));
+            const materialized = await materializeOutgoingAttachments(supported);
+            if (materialized.length > 0)
+                last.attachments = materialized;
+        }
+        catch {
+            // A stale or invalid host file must not drop Mimi's text reply.
+        }
+    }
+    return outgoing;
+}
+function gatewayChannelCatalog(currentChannel, currentCapabilities, adapters) {
+    const channels = new Map();
+    for (const adapter of adapters) {
+        if (!channels.has(adapter.channel)) {
+            channels.set(adapter.channel, channelCapabilities(adapter));
+        }
+    }
+    if (!channels.has(currentChannel) && channels.size >= 32) {
+        channels.delete([...channels.keys()].at(-1));
+    }
+    // The exact adapter that admitted this message is authoritative when several
+    // accounts or compatibility adapters share one channel name.
+    channels.set(currentChannel, currentCapabilities);
+    return [...channels].slice(0, 32).map(([channel, declared]) => ({
+        channel,
+        capabilities: declared,
+    }));
+}
+function normalizePetReplyButton(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const record = value;
+    if (Object.keys(record).some((key) => key !== "text" && key !== "url") ||
+        typeof record.text !== "string" ||
+        !record.text.trim() ||
+        record.text.length > 80 ||
+        /[\u0000-\u001f\u007f]/u.test(record.text) ||
+        typeof record.url !== "string" ||
+        record.url.length > 2_048 ||
+        record.url !== record.url.trim()) {
+        return undefined;
+    }
+    try {
+        const url = new URL(record.url);
+        if (url.protocol !== "https:" && url.protocol !== "http:")
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    return { text: record.text.trim(), url: record.url };
+}
+function mimiReplyCacheKey(message) {
+    if (!message.messageId)
+        return undefined;
+    return [message.channel, message.target, message.senderId, message.messageId].join("\0");
+}
+/** Render the one-time pairing URL as a PNG QR code; failures degrade to text+button. */
+async function renderPairingQrAttachment(pairingUrl) {
+    try {
+        const { default: QRCode } = await import("qrcode");
+        const data = await QRCode.toBuffer(pairingUrl, { type: "png", width: 512, margin: 2 });
+        return { kind: "image", name: "pairing-qr.png", mimeType: "image/png", data };
+    }
+    catch {
+        return undefined;
+    }
+}
+function formatStatus(status) {
+    const tunnel = status.tunnelConnected
+        ? "已连接"
+        : status.tunnelRunning
+            ? "连接中/异常"
+            : "未运行";
+    return [
+        "桌面端：在线",
+        `手机服务：${status.running ? "运行中" : "未运行"}`,
+        `公网隧道：${tunnel}`,
+        `访问口令：${status.passcodeSet ? "已设置" : "未设置"}`,
+        `在线设备：${status.onlineDeviceCount}`,
+        ...(status.url ? [`当前地址：${status.url}`] : []),
+    ].join("\n");
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./chat-gateway.js";
+export * from "./channel.js";
+export * from "./attachments.js";
+export * from "./media.js";
+export * from "./lifecycle.js";
+export * from "./webhook.js";
+export * from "./delivery-queue.js";
+export * from "./instance-lock.js";
+export * from "./notification-relay.js";
+export * from "./notification-progress.js";
+export * from "./service-manager.js";
+export * from "./ingress.js";
+export * from "./platform-canary.js";

package/dist/index.js

@@ -0,0 +1,13 @@
+export * from "./chat-gateway.js";
+export * from "./channel.js";
+export * from "./attachments.js";
+export * from "./media.js";
+export * from "./lifecycle.js";
+export * from "./webhook.js";
+export * from "./delivery-queue.js";
+export * from "./instance-lock.js";
+export * from "./notification-relay.js";
+export * from "./notification-progress.js";
+export * from "./service-manager.js";
+export * from "./ingress.js";
+export * from "./platform-canary.js";

package/dist/ingress.d.ts

@@ -0,0 +1,8 @@
+export declare const CHAT_WEBHOOK_PATHS: readonly ["/webhooks/line", "/webhooks/whatsapp", "/webhooks/teams"];
+export type IngressFormat = "caddy" | "nginx";
+export declare function renderWebhookIngress(input: {
+    format: IngressFormat;
+    publicHost: string;
+    upstream?: string;
+    maxBodyBytes?: number;
+}): string;

package/dist/ingress.js

@@ -0,0 +1,61 @@
+export const CHAT_WEBHOOK_PATHS = [
+    "/webhooks/line",
+    "/webhooks/whatsapp",
+    "/webhooks/teams",
+];
+export function renderWebhookIngress(input) {
+    const host = validateHost(input.publicHost);
+    const upstream = validateUpstream(input.upstream ?? "127.0.0.1:8787");
+    const maxBodyBytes = input.maxBodyBytes ?? 1_048_576;
+    if (!Number.isSafeInteger(maxBodyBytes) || maxBodyBytes <= 0) {
+        throw new Error("maxBodyBytes must be a positive integer");
+    }
+    if (input.format === "caddy") {
+        return `${host} {
+  request_body {
+    max_size ${maxBodyBytes}
+  }
+  @chat_webhooks path ${CHAT_WEBHOOK_PATHS.join(" ")}
+  reverse_proxy @chat_webhooks ${upstream}
+  respond /healthz 404
+  respond 404
+}
+`;
+    }
+    return `server {
+  listen 443 ssl http2;
+  server_name ${host};
+  client_max_body_size ${maxBodyBytes};
+
+  # Configure ssl_certificate and ssl_certificate_key using your ACME client.
+  location ~ ^/webhooks/(line|whatsapp|teams)$ {
+    proxy_pass http://${upstream};
+    proxy_set_header Host $host;
+    proxy_set_header X-Forwarded-Proto https;
+    proxy_request_buffering on;
+  }
+
+  location / { return 404; }
+}
+`;
+}
+function validateHost(value) {
+    const host = value.trim().toLowerCase();
+    if (!/^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}$/.test(host)) {
+        throw new Error("public host must be a DNS hostname");
+    }
+    return host;
+}
+function validateUpstream(value) {
+    const url = new URL(`http://${value}`);
+    if (!["127.0.0.1", "localhost", "[::1]", "::1"].includes(url.hostname) ||
+        !url.port ||
+        url.pathname !== "/" ||
+        url.username ||
+        url.password ||
+        url.search ||
+        url.hash) {
+        throw new Error("webhook upstream must be a loopback host:port");
+    }
+    return value;
+}

package/dist/instance-lock.d.ts

@@ -0,0 +1,24 @@
+interface GatewayLockRecord {
+    version: 1;
+    pid: number;
+    owner: string;
+    token: string;
+    startedAt: number;
+}
+export interface GatewayInstanceLease {
+    readonly path: string;
+    readonly owner: string;
+    release(): void;
+}
+export declare class GatewayAlreadyRunningError extends Error {
+    readonly path: string;
+    readonly current?: Readonly<Pick<GatewayLockRecord, "pid" | "owner" | "startedAt">> | undefined;
+    constructor(path: string, current?: Readonly<Pick<GatewayLockRecord, "pid" | "owner" | "startedAt">> | undefined);
+}
+/**
+ * Cross-process single-owner lease shared by the CLI and Desktop lifecycle.
+ * A dead owner's lock is reclaimed, while a live or unreadable lock fails
+ * closed so two processes can never consume the same platform updates.
+ */
+export declare function acquireGatewayInstanceLock(path: string, owner: string): GatewayInstanceLease;
+export {};

package/dist/instance-lock.js

@@ -0,0 +1,100 @@
+import { randomUUID } from "node:crypto";
+import { chmodSync, closeSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
+import { dirname } from "node:path";
+export class GatewayAlreadyRunningError extends Error {
+    path;
+    current;
+    constructor(path, current) {
+        super(current
+            ? `Chat Gateway 已由 ${current.owner} 运行（PID ${current.pid}）`
+            : `Chat Gateway 已在运行（锁文件：${path}）`);
+        this.path = path;
+        this.current = current;
+        this.name = "GatewayAlreadyRunningError";
+    }
+}
+/**
+ * Cross-process single-owner lease shared by the CLI and Desktop lifecycle.
+ * A dead owner's lock is reclaimed, while a live or unreadable lock fails
+ * closed so two processes can never consume the same platform updates.
+ */
+export function acquireGatewayInstanceLock(path, owner) {
+    if (!path || !owner)
+        throw new Error("gateway lock path and owner are required");
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const record = {
+        version: 1,
+        pid: process.pid,
+        owner,
+        token: randomUUID(),
+        startedAt: Date.now(),
+    };
+    for (let attempt = 0; attempt < 3; attempt++) {
+        let fd;
+        try {
+            fd = openSync(path, "wx", 0o600);
+            writeFileSync(fd, `${JSON.stringify(record)}\n`, "utf-8");
+            closeSync(fd);
+            fd = undefined;
+            if (process.platform !== "win32")
+                chmodSync(path, 0o600);
+            let released = false;
+            return {
+                path,
+                owner,
+                release: () => {
+                    if (released)
+                        return;
+                    released = true;
+                    removeOwnedLock(path, record.token);
+                },
+            };
+        }
+        catch (error) {
+            if (fd !== undefined)
+                closeSync(fd);
+            if (error.code !== "EEXIST")
+                throw error;
+            const existing = readLock(path);
+            if (!existing || isProcessAlive(existing.pid)) {
+                throw new GatewayAlreadyRunningError(path, existing
+                    ? { pid: existing.pid, owner: existing.owner, startedAt: existing.startedAt }
+                    : undefined);
+            }
+            // Only reclaim a well-formed lock whose process is demonstrably gone.
+            removeOwnedLock(path, existing.token);
+        }
+    }
+    throw new GatewayAlreadyRunningError(path);
+}
+function readLock(path) {
+    try {
+        const value = JSON.parse(readFileSync(path, "utf-8"));
+        if (value.version !== 1 ||
+            !Number.isSafeInteger(value.pid) ||
+            (value.pid ?? 0) <= 0 ||
+            typeof value.owner !== "string" ||
+            typeof value.token !== "string" ||
+            typeof value.startedAt !== "number") {
+            return undefined;
+        }
+        return value;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+function removeOwnedLock(path, token) {
+    const current = readLock(path);
+    if (current?.token === token)
+        rmSync(path, { force: true });
+}

package/dist/lark.d.ts

@@ -0,0 +1,20 @@
+import type { ChannelAdapter, ChannelMessageHandler, OutgoingMessage } from "./channel.js";
+export interface LarkAdapterConfig {
+    appId: string;
+    appSecret: string;
+    domain?: string;
+}
+export declare class LarkAdapter implements ChannelAdapter {
+    readonly channel = "lark";
+    readonly capabilities: import("./channel.js").ChannelCapabilities;
+    private readonly client;
+    private readonly ws;
+    private readonly delivery;
+    constructor(config: LarkAdapterConfig);
+    run(handler: ChannelMessageHandler, signal: AbortSignal): Promise<void>;
+    send(target: string, message: OutgoingMessage): Promise<void>;
+    private toAttachment;
+    private loadMessageResource;
+    private sendAttachment;
+    private createMessage;
+}