@cjhyy/code-shell-chat 0.8.0

package/dist/desktop-control-client.js

@@ -0,0 +1,309 @@
+import { constants } from "node:fs";
+import { chmod, lstat, mkdir, open, rename, rm, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { dirname } from "node:path";
+import { spawn } from "node:child_process";
+import { DESKTOP_CONTROL_PROTOCOL_VERSION, } from "./protocol.js";
+const MAX_DESKTOP_CONTROL_DESCRIPTOR_BYTES = 64 * 1024;
+const MAX_DESKTOP_EVENT_CHECKPOINT_BYTES = 16 * 1024;
+export class DesktopControlUnavailableError extends Error {
+    constructor(message = "桌面端未在线") {
+        super(message);
+        this.name = "DesktopControlUnavailableError";
+    }
+}
+export class DesktopControlOperationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DesktopControlOperationError";
+    }
+}
+export class DesktopControlClient {
+    config;
+    fetchFn;
+    spawnFn;
+    readDescriptorFn;
+    sleepFn;
+    constructor(config, opts = {}) {
+        this.config = config;
+        this.fetchFn = opts.fetch ?? fetch;
+        this.spawnFn = opts.spawn ?? spawn;
+        this.readDescriptorFn =
+            opts.readDescriptor ?? (() => readSecureDescriptor(this.config.descriptorPath));
+        this.sleepFn = opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    }
+    async open() {
+        await this.ensureDesktopAvailable();
+        return this.request("POST", "/v1/open", 120_000);
+    }
+    async close() {
+        await this.request("POST", "/v1/close", 15_000);
+    }
+    status() {
+        return this.request("GET", "/v1/status", 5_000);
+    }
+    pairingUrl() {
+        return this.request("POST", "/v1/pairing-url", 10_000);
+    }
+    async petChat(input) {
+        await this.ensureDesktopAvailable();
+        return this.request("POST", "/v1/pet/chat", 150_000, input);
+    }
+    events(after = 0, waitMs = 25_000, signal) {
+        if (!Number.isSafeInteger(after) || after < 0 || waitMs < 0 || waitMs > 25_000) {
+            throw new Error("invalid desktop event cursor");
+        }
+        return this.request("GET", `/v1/events?after=${after}&waitMs=${Math.floor(waitMs)}`, waitMs + 5_000, undefined, signal);
+    }
+    async watchEvents(signal, handle, options = {}) {
+        const saved = options.checkpointPath
+            ? await readEventCheckpoint(options.checkpointPath)
+            : undefined;
+        let streamId = saved?.streamId;
+        let cursor = saved?.cursor ?? 0;
+        let retryMs = options.retryBaseMs ?? 1_000;
+        const retryMaxMs = options.retryMaxMs ?? 30_000;
+        let recovering = false;
+        while (!signal.aborted) {
+            try {
+                const page = await this.events(cursor, 25_000, signal);
+                if ((streamId !== undefined && streamId !== page.streamId) || page.resetCursor === true) {
+                    // Reset before reading a replacement/rolled-back outbox or a high old
+                    // cursor could mask new events forever.
+                    streamId = page.streamId;
+                    cursor = 0;
+                    continue;
+                }
+                streamId = page.streamId;
+                for (const event of page.events) {
+                    if (signal.aborted)
+                        return;
+                    await handle(event, { streamId });
+                    const nextCursor = Math.max(cursor, event.id);
+                    if (options.checkpointPath) {
+                        await writeEventCheckpoint(options.checkpointPath, {
+                            version: 1,
+                            streamId,
+                            cursor: nextCursor,
+                        });
+                    }
+                    // Advance the acknowledgement cursor only after its durable
+                    // checkpoint succeeds. Otherwise a failed checkpoint write followed
+                    // by another poll could make Desktop prune an event this process
+                    // cannot prove it consumed across a restart.
+                    cursor = nextCursor;
+                }
+                cursor = Math.max(cursor, page.cursor);
+                if (recovering) {
+                    recovering = false;
+                    options.onRecovered?.();
+                }
+                retryMs = options.retryBaseMs ?? 1_000;
+            }
+            catch (error) {
+                if (signal.aborted)
+                    return;
+                recovering = true;
+                options.onError?.(error);
+                await Promise.race([this.sleepFn(retryMs), waitForAbort(signal)]);
+                retryMs = Math.min(retryMaxMs, retryMs * 2);
+            }
+        }
+    }
+    async ensureDesktopAvailable() {
+        try {
+            await this.status();
+            return;
+        }
+        catch (error) {
+            if (!(error instanceof DesktopControlUnavailableError))
+                throw error;
+        }
+        if (!this.config.autoLaunch || !this.config.command) {
+            throw new DesktopControlUnavailableError("桌面端未在线，且自动唤起已关闭");
+        }
+        try {
+            const child = this.spawnFn(this.config.command, this.config.args, {
+                detached: true,
+                stdio: "ignore",
+            });
+            child.unref();
+        }
+        catch (error) {
+            throw new DesktopControlUnavailableError(`无法唤起桌面端：${error instanceof Error ? error.message : String(error)}`);
+        }
+        const deadline = Date.now() + this.config.startupTimeoutMs;
+        while (Date.now() < deadline) {
+            await this.sleepFn(500);
+            try {
+                await this.status();
+                return;
+            }
+            catch (error) {
+                if (!(error instanceof DesktopControlUnavailableError))
+                    throw error;
+            }
+        }
+        throw new DesktopControlUnavailableError("已唤起桌面端，但本地控制面未在超时前就绪");
+    }
+    async request(method, path, timeoutMs, payload, signal) {
+        let descriptor;
+        try {
+            descriptor = parseDescriptor(await this.readDescriptorFn());
+        }
+        catch (error) {
+            if (error instanceof DesktopControlUnavailableError)
+                throw error;
+            throw new DesktopControlUnavailableError(`无法读取桌面端控制信息：${error instanceof Error ? error.message : String(error)}`);
+        }
+        const controller = new AbortController();
+        const abortRequest = () => controller.abort();
+        if (signal?.aborted)
+            controller.abort();
+        else
+            signal?.addEventListener("abort", abortRequest, { once: true });
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        let response;
+        try {
+            response = await this.fetchFn(`${descriptor.baseUrl}${path}`, {
+                method,
+                headers: {
+                    authorization: `Bearer ${descriptor.token}`,
+                    ...(payload === undefined ? {} : { "content-type": "application/json" }),
+                },
+                ...(payload === undefined ? {} : { body: JSON.stringify(payload) }),
+                signal: controller.signal,
+            });
+        }
+        catch (error) {
+            throw new DesktopControlUnavailableError(`无法连接桌面端：${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", abortRequest);
+        }
+        let body;
+        try {
+            body = await response.json();
+        }
+        catch {
+            throw new DesktopControlOperationError(`桌面端返回了无效响应（HTTP ${response.status}）`);
+        }
+        if (!response.ok) {
+            throw new DesktopControlOperationError(typeof body?.message === "string"
+                ? body.message
+                : `桌面端操作失败（HTTP ${response.status}）`);
+        }
+        return body;
+    }
+}
+async function waitForAbort(signal) {
+    if (signal.aborted)
+        return;
+    await new Promise((resolve) => signal.addEventListener("abort", () => resolve(), { once: true }));
+}
+export function parseDescriptor(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new DesktopControlUnavailableError("桌面端控制信息不是有效 JSON");
+    }
+    if (parsed.version !== DESKTOP_CONTROL_PROTOCOL_VERSION ||
+        typeof parsed.pid !== "number" ||
+        typeof parsed.baseUrl !== "string" ||
+        typeof parsed.token !== "string" ||
+        !/^[a-f0-9]{64}$/.test(parsed.token) ||
+        typeof parsed.startedAt !== "number") {
+        throw new DesktopControlUnavailableError("桌面端控制协议版本或字段无效");
+    }
+    const url = new URL(parsed.baseUrl);
+    if (url.protocol !== "http:" ||
+        url.hostname !== "127.0.0.1" ||
+        !url.port ||
+        url.pathname !== "/" ||
+        url.username ||
+        url.password ||
+        url.search ||
+        url.hash) {
+        throw new DesktopControlUnavailableError("桌面端控制地址必须是 127.0.0.1 loopback HTTP");
+    }
+    return parsed;
+}
+async function readSecureDescriptor(path) {
+    return readOwnerOnlyFile(path, MAX_DESKTOP_CONTROL_DESCRIPTOR_BYTES, "桌面端控制信息");
+}
+async function readEventCheckpoint(path) {
+    try {
+        const raw = await readOwnerOnlyFile(path, MAX_DESKTOP_EVENT_CHECKPOINT_BYTES, "Desktop event checkpoint");
+        const parsed = JSON.parse(raw);
+        if (parsed.version !== 1 ||
+            typeof parsed.streamId !== "string" ||
+            !/^[a-f0-9]{32}$/.test(parsed.streamId) ||
+            !Number.isSafeInteger(parsed.cursor) ||
+            (parsed.cursor ?? -1) < 0) {
+            throw new Error(`Invalid Desktop event checkpoint: ${path}`);
+        }
+        return parsed;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+async function writeEventCheckpoint(path, checkpoint) {
+    const dir = dirname(path);
+    await mkdir(dir, { recursive: true, mode: 0o700 });
+    const dirInfo = await lstat(dir);
+    if (dirInfo.isSymbolicLink() || !dirInfo.isDirectory()) {
+        throw new Error(`Desktop event checkpoint parent is not a regular directory: ${dir}`);
+    }
+    await chmod(dir, 0o700).catch(() => undefined);
+    const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, `${JSON.stringify(checkpoint)}\n`, {
+            encoding: "utf-8",
+            mode: 0o600,
+            flag: "wx",
+        });
+        await rename(temporary, path);
+        await chmod(path, 0o600).catch(() => undefined);
+    }
+    catch (error) {
+        await rm(temporary, { force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+async function readOwnerOnlyFile(path, maxBytes, label) {
+    const pathInfo = await lstat(path);
+    if (pathInfo.isSymbolicLink() || !pathInfo.isFile()) {
+        throw new Error(`${label} is not a regular file: ${path}`);
+    }
+    if (process.platform !== "win32" && (pathInfo.mode & 0o077) !== 0) {
+        throw new Error(`${label} permissions must be 0600: ${path}`);
+    }
+    if (pathInfo.size > maxBytes)
+        throw new Error(`${label} is too large: ${path}`);
+    const noFollow = process.platform === "win32" ? 0 : constants.O_NOFOLLOW;
+    const handle = await open(path, constants.O_RDONLY | noFollow);
+    try {
+        const openedInfo = await handle.stat();
+        if (!openedInfo.isFile())
+            throw new Error(`${label} is not a regular file: ${path}`);
+        if (process.platform !== "win32" && (openedInfo.mode & 0o077) !== 0) {
+            throw new Error(`${label} permissions must be 0600: ${path}`);
+        }
+        if (openedInfo.size > maxBytes)
+            throw new Error(`${label} is too large: ${path}`);
+        const raw = await handle.readFile("utf-8");
+        if (Buffer.byteLength(raw, "utf-8") > maxBytes) {
+            throw new Error(`${label} is too large: ${path}`);
+        }
+        return raw;
+    }
+    finally {
+        await handle.close();
+    }
+}

package/dist/dingtalk.d.ts

@@ -0,0 +1,19 @@
+import type { ChannelAdapter, ChannelMessage, ChannelMessageHandler, OutgoingMessage } from "./channel.js";
+export interface DingTalkAdapterConfig {
+    clientId: string;
+    clientSecret: string;
+    onConnected?: () => void;
+}
+/** Parse one Stream frame without exposing the SDK client, useful for discovery and tests. */
+export declare function parseDingTalkTextMessage(data: string, messageId?: string): ChannelMessage | undefined;
+export declare class DingTalkAdapter implements ChannelAdapter {
+    private readonly fetchFn;
+    readonly channel = "dingtalk";
+    readonly capabilities: import("./channel.js").ChannelCapabilities;
+    private readonly client;
+    private readonly onConnected?;
+    private readonly responseUrls;
+    constructor(config: DingTalkAdapterConfig, fetchFn?: typeof fetch);
+    run(handler: ChannelMessageHandler, signal: AbortSignal): Promise<void>;
+    send(target: string, message: OutgoingMessage): Promise<void>;
+}

package/dist/dingtalk.js

@@ -0,0 +1,93 @@
+import { DWClient, TOPIC_ROBOT } from "dingtalk-stream";
+import { BUILTIN_CHANNEL_CAPABILITIES } from "./channel.js";
+import { dispatchSafely, waitForAbort } from "./lifecycle.js";
+/** Parse one Stream frame without exposing the SDK client, useful for discovery and tests. */
+export function parseDingTalkTextMessage(data, messageId) {
+    let message;
+    try {
+        message = JSON.parse(data);
+    }
+    catch {
+        return undefined;
+    }
+    if (message.msgtype !== "text" || !message.text?.content || !message.conversationId) {
+        return undefined;
+    }
+    return {
+        channel: "dingtalk",
+        target: message.conversationId,
+        senderId: message.senderStaffId || message.senderId,
+        text: message.text.content,
+        ...(messageId ? { messageId } : {}),
+        metadata: {
+            ...(typeof message.conversationTitle === "string" && message.conversationTitle.trim()
+                ? { conversationTitle: message.conversationTitle.trim() }
+                : {}),
+            ...(typeof message.conversationType === "string"
+                ? { conversationType: message.conversationType }
+                : {}),
+            ...(typeof message.senderNick === "string" && message.senderNick.trim()
+                ? { senderName: message.senderNick.trim() }
+                : {}),
+        },
+    };
+}
+export class DingTalkAdapter {
+    fetchFn;
+    channel = "dingtalk";
+    capabilities = BUILTIN_CHANNEL_CAPABILITIES.dingtalk;
+    client;
+    onConnected;
+    responseUrls = new Map();
+    constructor(config, fetchFn = fetch) {
+        this.fetchFn = fetchFn;
+        this.client = new DWClient({ clientId: config.clientId, clientSecret: config.clientSecret });
+        this.onConnected = config.onConnected;
+    }
+    async run(handler, signal) {
+        this.client.registerCallbackListener(TOPIC_ROBOT, async (frame) => {
+            const incoming = parseDingTalkTextMessage(frame.data, frame.headers.messageId);
+            if (!incoming)
+                return;
+            const message = JSON.parse(frame.data);
+            this.responseUrls.set(incoming.target, message.sessionWebhook);
+            // dispatchSafely so a rejected delivery never escapes this stream
+            // callback as an unhandled rejection (which would crash the process);
+            // the SUCCESS ack below must still run so DingTalk stops redelivering.
+            await dispatchSafely(handler, incoming);
+            this.client.socketCallBackResponse(frame.headers.messageId, { status: "SUCCESS" });
+        });
+        await this.client.connect();
+        this.onConnected?.();
+        try {
+            await waitForAbort(signal);
+        }
+        finally {
+            this.client.disconnect();
+        }
+    }
+    async send(target, message) {
+        const responseUrl = this.responseUrls.get(target);
+        if (!responseUrl)
+            throw new Error(`钉钉会话 ${target} 没有可用的临时回复地址`);
+        const body = message.button
+            ? {
+                msgtype: "actionCard",
+                actionCard: {
+                    title: message.title ?? "Chat message",
+                    text: message.text,
+                    singleTitle: message.button.text,
+                    singleURL: message.button.url,
+                },
+            }
+            : { msgtype: "text", text: { content: message.text } };
+        const response = await this.fetchFn(responseUrl, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (!response.ok)
+            throw new Error(`钉钉回复失败（HTTP ${response.status}）`);
+    }
+}

package/dist/discord.d.ts

@@ -0,0 +1,23 @@
+import type { ChannelAdapter, ChannelMessageHandler, ChatCommandDefinition, OutgoingMessage } from "./channel.js";
+export interface DiscordAdapterConfig {
+    botToken: string;
+}
+export interface DiscordAdapterOptions {
+    commands?: readonly ChatCommandDefinition[];
+    fetch?: typeof fetch;
+}
+export declare class DiscordAdapter implements ChannelAdapter {
+    private readonly config;
+    readonly channel = "discord";
+    readonly capabilities: import("./channel.js").ChannelCapabilities;
+    readonly combinesTextAndAttachmentsAtomically = true;
+    private readonly client;
+    private readonly interactionContext;
+    private readonly commands;
+    private readonly fetchFn;
+    constructor(config: DiscordAdapterConfig, options?: DiscordAdapterOptions);
+    run(handler: ChannelMessageHandler, signal: AbortSignal): Promise<void>;
+    send(target: string, message: OutgoingMessage): Promise<void>;
+    private handleInteraction;
+    private registerCommands;
+}

package/dist/discord.js

@@ -0,0 +1,134 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { ActionRowBuilder, ButtonBuilder, ButtonStyle, ChannelType, Client, Events, GatewayIntentBits, Partials, } from "discord.js";
+import { BUILTIN_CHANNEL_CAPABILITIES } from "./channel.js";
+import { dispatchSafely, waitForAbort } from "./lifecycle.js";
+import { mediaKind, outgoingAttachments, remoteAttachment } from "./media.js";
+export class DiscordAdapter {
+    config;
+    channel = "discord";
+    capabilities = BUILTIN_CHANNEL_CAPABILITIES.discord;
+    combinesTextAndAttachmentsAtomically = true;
+    client;
+    interactionContext = new AsyncLocalStorage();
+    commands;
+    fetchFn;
+    constructor(config, options = {}) {
+        this.config = config;
+        this.commands = options.commands ?? [];
+        this.fetchFn = options.fetch ?? fetch;
+        this.client = new Client({
+            intents: [
+                GatewayIntentBits.Guilds,
+                GatewayIntentBits.GuildMessages,
+                GatewayIntentBits.DirectMessages,
+                GatewayIntentBits.MessageContent,
+            ],
+            partials: [Partials.Channel],
+        });
+    }
+    async run(handler, signal) {
+        const onMessage = (message) => {
+            if (message.author.bot || (!message.content && message.attachments.size === 0))
+                return;
+            const attachments = message.attachments.map((attachment) => remoteAttachment({
+                id: attachment.id,
+                kind: mediaKind(attachment.contentType ?? undefined, attachment.name),
+                name: attachment.name,
+                mimeType: attachment.contentType ?? undefined,
+                size: attachment.size,
+                url: attachment.url,
+                fetch: this.fetchFn,
+            }));
+            void dispatchSafely(handler, {
+                channel: this.channel,
+                target: message.channelId,
+                senderId: message.author.id,
+                text: message.content,
+                messageId: message.id,
+                ...(attachments.length > 0 ? { attachments } : {}),
+            });
+        };
+        const onInteraction = (interaction) => {
+            if (!interaction.isChatInputCommand() || !interaction.channelId)
+                return;
+            if (!this.commands.some(({ name }) => name === interaction.commandName))
+                return;
+            void this.handleInteraction(interaction, handler);
+        };
+        this.client.on(Events.MessageCreate, onMessage);
+        this.client.on(Events.InteractionCreate, onInteraction);
+        await this.client.login(this.config.botToken);
+        if (this.commands.length > 0)
+            await this.registerCommands();
+        try {
+            await waitForAbort(signal);
+        }
+        finally {
+            this.client.off(Events.MessageCreate, onMessage);
+            this.client.off(Events.InteractionCreate, onInteraction);
+            this.client.destroy();
+        }
+    }
+    async send(target, message) {
+        const payload = toDiscordPayload(message);
+        const interactionState = this.interactionContext.getStore();
+        if (interactionState?.interaction.channelId === target) {
+            interactionState.replied = true;
+            await interactionState.interaction.editReply(payload);
+            return;
+        }
+        const channel = await this.client.channels.fetch(target);
+        if (!channel || channel.type === ChannelType.GuildCategory || !channel.isSendable()) {
+            throw new Error(`Discord channel ${target} 不支持发送消息`);
+        }
+        await channel.send(payload);
+    }
+    async handleInteraction(interaction, handler) {
+        const target = interaction.channelId;
+        await interaction.deferReply({ ephemeral: interaction.inGuild() });
+        const state = { interaction, replied: false };
+        await this.interactionContext.run(state, () => dispatchSafely(handler, {
+            channel: this.channel,
+            target,
+            senderId: interaction.user.id,
+            text: `/${interaction.commandName}`,
+            messageId: interaction.id,
+        }));
+        if (!state.replied)
+            await interaction.deleteReply().catch(() => undefined);
+    }
+    async registerCommands() {
+        const commands = this.client.application?.commands;
+        if (!commands)
+            throw new Error("Discord application command manager 不可用");
+        const existing = await commands.fetch();
+        for (const command of this.commands) {
+            if (!existing.some(({ name }) => name === command.name))
+                await commands.create(command);
+        }
+    }
+}
+function toDiscordPayload(message) {
+    const attachments = outgoingAttachments(message, BUILTIN_CHANNEL_CAPABILITIES.discord.outbound.attachments);
+    return {
+        content: message.text,
+        ...(attachments.length > 0
+            ? {
+                files: attachments.map((attachment) => ({
+                    attachment: Buffer.from(attachment.data),
+                    name: attachment.name,
+                })),
+            }
+            : {}),
+        ...(message.button
+            ? {
+                components: [
+                    new ActionRowBuilder().addComponents(new ButtonBuilder()
+                        .setStyle(ButtonStyle.Link)
+                        .setLabel(message.button.text)
+                        .setURL(message.button.url)),
+                ],
+            }
+            : {}),
+    };
+}

package/dist/gateway.d.ts

@@ -0,0 +1,34 @@
+import type { ChatMiddleware } from "./chat-gateway.js";
+import { type ChannelAdapter } from "./channel.js";
+import { type DesktopControlClient } from "./desktop-control-client.js";
+export interface CodeShellRemoteCommandsOptions {
+    desktop: Pick<DesktopControlClient, "open" | "close" | "status">;
+}
+export interface MimiPetChatOptions {
+    desktop: Pick<DesktopControlClient, "petChat">;
+    /** Enabled adapters whose declared capabilities back first-level Gateway discovery. */
+    channels?: readonly ChannelAdapter[];
+}
+export declare const CODE_SHELL_REMOTE_COMMANDS: readonly [{
+    readonly name: "open";
+    readonly description: "打开 CodeShell 手机遥控隧道";
+}, {
+    readonly name: "close";
+    readonly description: "关闭 CodeShell 手机遥控隧道";
+}, {
+    readonly name: "status";
+    readonly description: "查看 CodeShell 手机遥控状态";
+}];
+/** Optional CodeShell integration. Unknown messages fall through to the next middleware. */
+export declare function createCodeShellRemoteCommands(options: CodeShellRemoteCommandsOptions): ChatMiddleware;
+export type GatewayCommand = "open" | "close" | "status" | "unsupported";
+export declare function parseGatewayCommand(text: string): GatewayCommand;
+/**
+ * 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 declare function parseGatewayIntent(text: string): GatewayCommand;
+/** Final middleware: route ordinary text/media turns into the durable Mimi Pet session. */
+export declare function createMimiPetChat(options: MimiPetChatOptions): ChatMiddleware;