@qlingzzy/qling 1.0.0

package/dist/agents/isolation-policy.d.ts

@@ -0,0 +1,14 @@
+export interface IsolationPolicyInput {
+    workspaceDir: string;
+    mode: "worktree" | "off";
+    requireGit: boolean;
+    nonGitPolicy: "warn" | "deny" | "off";
+}
+export interface IsolationPolicyResult {
+    level: "ok" | "warn" | "deny";
+    useWorktree: boolean;
+    isGitWorkspace: boolean;
+    message?: string;
+}
+export declare function evaluateIsolationPolicy(input: IsolationPolicyInput): Promise<IsolationPolicyResult>;
+//# sourceMappingURL=isolation-policy.d.ts.map

package/dist/agents/isolation-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isolation-policy.d.ts","sourceRoot":"","sources":["../../src/agents/isolation-policy.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,oBAAoB;IACnC,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,UAAU,GAAG,KAAK,CAAC;IACzB,UAAU,EAAE,OAAO,CAAC;IACpB,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC;CACvC;AAED,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,CAAC;IAC9B,WAAW,EAAE,OAAO,CAAC;IACrB,cAAc,EAAE,OAAO,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAMD,wBAAsB,uBAAuB,CAC3C,KAAK,EAAE,oBAAoB,GAC1B,OAAO,CAAC,qBAAqB,CAAC,CAmDhC"}

package/dist/agents/isolation-policy.js

@@ -0,0 +1,52 @@
+import { existsSync } from "fs";
+import path from "path";
+function isGitWorkspace(workspaceDir) {
+    return existsSync(path.join(workspaceDir, ".git"));
+}
+export async function evaluateIsolationPolicy(input) {
+    const gitWorkspace = isGitWorkspace(input.workspaceDir);
+    if (input.mode === "off") {
+        return {
+            level: "ok",
+            useWorktree: false,
+            isGitWorkspace: gitWorkspace,
+        };
+    }
+    if (gitWorkspace) {
+        return {
+            level: "ok",
+            useWorktree: true,
+            isGitWorkspace: true,
+            message: "Git workspace detected; worktree isolation is available.",
+        };
+    }
+    if (!input.requireGit) {
+        return {
+            level: "ok",
+            useWorktree: false,
+            isGitWorkspace: false,
+            message: "Non-git workspace; isolation continues without worktree.",
+        };
+    }
+    if (input.nonGitPolicy === "deny") {
+        return {
+            level: "deny",
+            useWorktree: false,
+            isGitWorkspace: false,
+            message: "Non-git workspace blocked by agents.isolation.non_git_policy=deny",
+        };
+    }
+    if (input.nonGitPolicy === "warn") {
+        return {
+            level: "warn",
+            useWorktree: false,
+            isGitWorkspace: false,
+            message: "Non-git workspace; degraded to non-worktree isolation.",
+        };
+    }
+    return {
+        level: "ok",
+        useWorktree: false,
+        isGitWorkspace: false,
+    };
+}

package/dist/channels/console-channel.d.ts

@@ -0,0 +1,15 @@
+import type { Channel, ApprovalRequest, ApprovalResponse } from "./types.js";
+export declare class ConsoleChannel implements Channel {
+    name: string;
+    private userMessageHandler;
+    private rl;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    sendText(text: string): Promise<void>;
+    sendToolStart(toolName: string, args: Record<string, unknown>): Promise<void>;
+    sendToolResult(toolName: string, output: string, isError: boolean): Promise<void>;
+    sendError(text: string): Promise<void>;
+    onUserMessage(handler: (msg: string) => Promise<void>): void;
+    requestApproval(request: ApprovalRequest): Promise<ApprovalResponse>;
+}
+//# sourceMappingURL=console-channel.d.ts.map

package/dist/channels/console-channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-channel.d.ts","sourceRoot":"","sources":["../../src/channels/console-channel.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE7E,qBAAa,cAAe,YAAW,OAAO;IAC5C,IAAI,SAAa;IACjB,OAAO,CAAC,kBAAkB,CAAiD;IAC3E,OAAO,CAAC,EAAE,CAAmC;IAEvC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAqBtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAKrB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIrC,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAK7E,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAKjF,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI5C,aAAa,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;IAItD,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAoB3E"}

package/dist/channels/console-channel.js

@@ -0,0 +1,66 @@
+// ============================================================
+// 轻灵 - Console Channel（控制台通道）
+// 封装标准输入/输出为 Channel 接口
+// ============================================================
+import * as readline from "readline";
+export class ConsoleChannel {
+    name = "console";
+    userMessageHandler = null;
+    rl = null;
+    async start() {
+        this.rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        this.rl.on("line", async (line) => {
+            const trimmed = line.trim();
+            if (trimmed && this.userMessageHandler) {
+                await this.userMessageHandler(trimmed);
+            }
+        });
+        this.rl.on("close", () => {
+            // Do not force process exit here.
+            // In run mode the channel may be attached with non-interactive stdio,
+            // and eager exit can terminate one-shot execution before agent.run() completes.
+            this.rl = null;
+        });
+    }
+    async stop() {
+        this.rl?.close();
+        this.rl = null;
+    }
+    async sendText(text) {
+        process.stdout.write(text + "\n");
+    }
+    async sendToolStart(toolName, args) {
+        const preview = JSON.stringify(args).slice(0, 80);
+        console.error("[tool] " + toolName + ": " + preview);
+    }
+    async sendToolResult(toolName, output, isError) {
+        const icon = isError ? "x" : "+";
+        console.error("[" + icon + "] " + toolName + ": " + output.split("\n")[0].slice(0, 80));
+    }
+    async sendError(text) {
+        console.error("[error] " + text);
+    }
+    onUserMessage(handler) {
+        this.userMessageHandler = handler;
+    }
+    async requestApproval(request) {
+        await this.sendText("\n[Approval Required] Tool: " + request.toolName + "\n" +
+            "Reason: " + request.reason + "\n" +
+            "Allow? (y/n): ");
+        return new Promise((resolve) => {
+            const originalHandler = this.userMessageHandler;
+            this.userMessageHandler = async (msg) => {
+                this.userMessageHandler = originalHandler;
+                const answer = msg.toLowerCase();
+                resolve({
+                    requestId: request.id,
+                    decision: answer === "y" || answer === "yes" ? "allow" : "deny",
+                    timestamp: Date.now(),
+                });
+            };
+        });
+    }
+}

package/dist/channels/registry.d.ts

@@ -0,0 +1,10 @@
+import type { Channel } from "./types.js";
+export declare class ChannelRegistry {
+    private channels;
+    register(channel: Channel): void;
+    get(name: string): Channel | undefined;
+    getAll(): Channel[];
+    startAll(): Promise<void>;
+    stopAll(): Promise<void>;
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/channels/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/channels/registry.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAA8B;IAE9C,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAIhC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAItC,MAAM,IAAI,OAAO,EAAE;IAIb,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAMzB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAK/B"}

package/dist/channels/registry.js

@@ -0,0 +1,25 @@
+// ============================================================
+// 轻灵 - Channel Registry（通道注册表）
+// ============================================================
+export class ChannelRegistry {
+    channels = new Map();
+    register(channel) {
+        this.channels.set(channel.name, channel);
+    }
+    get(name) {
+        return this.channels.get(name);
+    }
+    getAll() {
+        return Array.from(this.channels.values());
+    }
+    async startAll() {
+        for (const channel of this.channels.values()) {
+            await channel.start();
+        }
+    }
+    async stopAll() {
+        for (const channel of this.channels.values()) {
+            await channel.stop();
+        }
+    }
+}

package/dist/channels/slack-channel.d.ts

@@ -0,0 +1,35 @@
+import type { Channel, ApprovalRequest, ApprovalResponse } from "./types.js";
+export interface SlackChannelConfig {
+    botToken: string;
+    appToken?: string;
+    channelIds?: string[];
+    pollIntervalMs?: number;
+}
+export declare class SlackChannel implements Channel {
+    name: string;
+    private botToken;
+    private channelIds;
+    private pollIntervalMs;
+    private userMessageHandler;
+    private running;
+    private lastTs;
+    private lastActiveChannelId;
+    private pollTimer;
+    private pendingApprovals;
+    constructor(config: SlackChannelConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    sendText(text: string): Promise<void>;
+    sendToolStart(toolName: string, args: Record<string, unknown>): Promise<void>;
+    sendToolResult(toolName: string, output: string, isError: boolean): Promise<void>;
+    sendError(text: string): Promise<void>;
+    onUserMessage(handler: (msg: string) => Promise<void>): void;
+    requestApproval(request: ApprovalRequest): Promise<ApprovalResponse>;
+    private apiCall;
+    private discoverChannels;
+    private pollAllChannels;
+    private resolveTargetChannelIds;
+    private tryHandleApprovalText;
+    private resolvePendingApprovalKey;
+}
+//# sourceMappingURL=slack-channel.d.ts.map

package/dist/channels/slack-channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack-channel.d.ts","sourceRoot":"","sources":["../../src/channels/slack-channel.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE7E,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,qBAAa,YAAa,YAAW,OAAO;IAC1C,IAAI,SAAW;IACf,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,UAAU,CAAW;IAC7B,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,kBAAkB,CAAiD;IAC3E,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,MAAM,CAA6B;IAC3C,OAAO,CAAC,mBAAmB,CAAuB;IAClD,OAAO,CAAC,SAAS,CAA+C;IAChE,OAAO,CAAC,gBAAgB,CAOpB;gBAEQ,MAAM,EAAE,kBAAkB;IAMhC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAkBtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAarB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBrC,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAK7E,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAKjF,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI5C,aAAa,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;IAItD,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;YAmD5D,OAAO;YAcP,gBAAgB;YAiBhB,eAAe;IAsC7B,OAAO,CAAC,uBAAuB;IAU/B,OAAO,CAAC,qBAAqB;IAqB7B,OAAO,CAAC,yBAAyB;CAUlC"}

package/dist/channels/slack-channel.js

@@ -0,0 +1,232 @@
+// ============================================================
+// 轻灵 - Slack Bot Channel（Slack Bot 通道）
+// axios + Web API polling，无 SDK 依赖
+// ============================================================
+import axios from "axios";
+export class SlackChannel {
+    name = "slack";
+    botToken;
+    channelIds;
+    pollIntervalMs;
+    userMessageHandler = null;
+    running = false;
+    lastTs = new Map();
+    lastActiveChannelId = null;
+    pollTimer = null;
+    pendingApprovals = new Map();
+    constructor(config) {
+        this.botToken = config.botToken;
+        this.channelIds = config.channelIds ?? [];
+        this.pollIntervalMs = config.pollIntervalMs ?? 3000;
+    }
+    async start() {
+        if (!this.botToken) {
+            console.error("[Slack] No bot token configured");
+            return;
+        }
+        this.running = true;
+        if (this.channelIds.length === 0) {
+            await this.discoverChannels();
+        }
+        this.pollTimer = setInterval(() => {
+            this.pollAllChannels().catch((err) => {
+                console.error("[Slack] Poll error: " + err.message);
+            });
+        }, this.pollIntervalMs);
+    }
+    async stop() {
+        this.running = false;
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+        for (const [shortId, pending] of this.pendingApprovals) {
+            clearTimeout(pending.timer);
+            pending.resolve({ requestId: pending.requestId, decision: "deny", timestamp: Date.now() });
+            this.pendingApprovals.delete(shortId);
+        }
+    }
+    async sendText(text) {
+        const targets = this.resolveTargetChannelIds();
+        if (targets.length === 0) {
+            console.error("[Slack] sendText skipped: no target channel");
+            return;
+        }
+        const body = text.length > 3000 ? text.slice(0, 3000) + "\n... [truncated]" : text;
+        for (const channelId of targets) {
+            try {
+                await this.apiCall("chat.postMessage", {
+                    channel: channelId,
+                    text: body,
+                });
+            }
+            catch (err) {
+                console.error("[Slack] sendText failed: " + err.message);
+            }
+        }
+    }
+    async sendToolStart(toolName, args) {
+        const preview = JSON.stringify(args).slice(0, 200);
+        await this.sendText("[tool:start] " + toolName + "\n```" + preview + "```");
+    }
+    async sendToolResult(toolName, output, isError) {
+        const status = isError ? "error" : "ok";
+        await this.sendText("[tool:" + status + "] " + toolName + "\n" + output.slice(0, 500));
+    }
+    async sendError(text) {
+        await this.sendText("[error] " + text);
+    }
+    onUserMessage(handler) {
+        this.userMessageHandler = handler;
+    }
+    async requestApproval(request) {
+        const targets = this.resolveTargetChannelIds();
+        if (targets.length === 0) {
+            return { requestId: request.id, decision: "deny", timestamp: Date.now() };
+        }
+        const text = ":warning: *Approval Required*\n" +
+            "*Tool:* " + request.toolName + "\n" +
+            "*Reason:* " + request.reason + "\n" +
+            "Reply with `allow " + request.id.slice(0, 8) + "` or `deny " + request.id.slice(0, 8) + "`";
+        for (const channelId of targets) {
+            try {
+                await this.apiCall("chat.postMessage", {
+                    channel: channelId,
+                    text,
+                });
+            }
+            catch (err) {
+                console.error("[Slack] Approval send failed: " + err.message);
+            }
+        }
+        const shortId = request.id.slice(0, 8).toLowerCase();
+        return new Promise((resolve) => {
+            const existing = this.pendingApprovals.get(shortId);
+            if (existing) {
+                clearTimeout(existing.timer);
+                existing.resolve({ requestId: existing.requestId, decision: "deny", timestamp: Date.now() });
+                this.pendingApprovals.delete(shortId);
+            }
+            const timer = setTimeout(() => {
+                const pending = this.pendingApprovals.get(shortId);
+                if (!pending || pending.requestId !== request.id) {
+                    return;
+                }
+                this.pendingApprovals.delete(shortId);
+                pending.resolve({ requestId: request.id, decision: "deny", timestamp: Date.now() });
+            }, 300_000);
+            this.pendingApprovals.set(shortId, {
+                requestId: request.id,
+                resolve,
+                timer,
+            });
+        });
+    }
+    // --- Private ---
+    async apiCall(method, body) {
+        const resp = await axios.post("https://slack.com/api/" + method, body, {
+            headers: {
+                Authorization: "Bearer " + this.botToken,
+                "Content-Type": "application/json",
+            },
+            timeout: 10000,
+        });
+        if (resp.data && resp.data.ok === false) {
+            throw new Error("Slack API error: " + (resp.data.error ?? "unknown"));
+        }
+        return resp.data;
+    }
+    async discoverChannels() {
+        try {
+            const resp = await this.apiCall("conversations.list", {
+                types: "public_channel,private_channel",
+                limit: 100,
+            });
+            const channels = resp.channels;
+            if (channels) {
+                this.channelIds = channels
+                    .filter((c) => c.is_member)
+                    .map((c) => String(c.id));
+            }
+        }
+        catch (err) {
+            console.error("[Slack] Channel discovery failed: " + err.message);
+        }
+    }
+    async pollAllChannels() {
+        if (!this.running || !this.userMessageHandler)
+            return;
+        for (const channelId of this.channelIds) {
+            try {
+                const params = { channel: channelId, limit: 10 };
+                const last = this.lastTs.get(channelId);
+                if (last)
+                    params.oldest = last;
+                const resp = await this.apiCall("conversations.history", params);
+                const messages = resp.messages;
+                if (!messages || messages.length === 0)
+                    continue;
+                for (const msg of messages) {
+                    if (msg.bot_id)
+                        continue;
+                    if (msg.subtype)
+                        continue;
+                    const ts = String(msg.ts ?? "");
+                    const text = String(msg.text ?? "");
+                    if (!text.trim())
+                        continue;
+                    if (!last || ts > last) {
+                        this.lastTs.set(channelId, ts);
+                    }
+                    if (this.tryHandleApprovalText(text)) {
+                        continue;
+                    }
+                    this.lastActiveChannelId = channelId;
+                    await this.userMessageHandler(text);
+                }
+            }
+            catch (err) {
+                console.error("[Slack] Poll channel " + channelId + " error: " + err.message);
+            }
+        }
+    }
+    resolveTargetChannelIds() {
+        if (this.channelIds.length > 0) {
+            return [...this.channelIds];
+        }
+        if (this.lastActiveChannelId !== null) {
+            return [this.lastActiveChannelId];
+        }
+        return [];
+    }
+    tryHandleApprovalText(text) {
+        const m = /^\s*(allow|deny)\s+([a-z0-9]{4,})\b/i.exec(text.trim());
+        if (!m) {
+            return false;
+        }
+        const decision = m[1].toLowerCase() === "allow" ? "allow" : "deny";
+        const token = m[2].toLowerCase();
+        const key = this.resolvePendingApprovalKey(token);
+        if (!key) {
+            return false;
+        }
+        const pending = this.pendingApprovals.get(key);
+        if (!pending) {
+            return false;
+        }
+        clearTimeout(pending.timer);
+        this.pendingApprovals.delete(key);
+        pending.resolve({ requestId: pending.requestId, decision, timestamp: Date.now() });
+        return true;
+    }
+    resolvePendingApprovalKey(token) {
+        if (this.pendingApprovals.has(token)) {
+            return token;
+        }
+        const matches = [...this.pendingApprovals.keys()].filter((k) => k.startsWith(token));
+        if (matches.length === 1) {
+            return matches[0];
+        }
+        return null;
+    }
+}

package/dist/channels/telegram-channel.d.ts

@@ -0,0 +1,32 @@
+import type { Channel, ApprovalRequest, ApprovalResponse } from "./types.js";
+export interface TelegramChannelConfig {
+    token: string;
+    pollIntervalMs?: number;
+    allowedChatIds?: string[];
+}
+export declare class TelegramChannel implements Channel {
+    name: string;
+    private token;
+    private pollIntervalMs;
+    private allowedChatIds;
+    private baseUrl;
+    private userMessageHandler;
+    private running;
+    private lastUpdateId;
+    private lastActiveChatId;
+    private pendingApprovals;
+    constructor(config: TelegramChannelConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    sendText(text: string): Promise<void>;
+    sendToolStart(toolName: string, args: Record<string, unknown>): Promise<void>;
+    sendToolResult(toolName: string, output: string, isError: boolean): Promise<void>;
+    sendError(text: string): Promise<void>;
+    onUserMessage(handler: (msg: string) => Promise<void>): void;
+    requestApproval(request: ApprovalRequest): Promise<ApprovalResponse>;
+    handleCallbackQuery(callbackData: string, callbackQueryId: string): void;
+    private pollLoop;
+    private isAllowedChat;
+    private resolveTargetChatIds;
+}
+//# sourceMappingURL=telegram-channel.d.ts.map

package/dist/channels/telegram-channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telegram-channel.d.ts","sourceRoot":"","sources":["../../src/channels/telegram-channel.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE7E,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;CAC3B;AAED,qBAAa,eAAgB,YAAW,OAAO;IAC7C,IAAI,SAAc;IAClB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,cAAc,CAAW;IACjC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,kBAAkB,CAAiD;IAC3E,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,gBAAgB,CAAuB;IAC/C,OAAO,CAAC,gBAAgB,CAA2D;gBAEvE,MAAM,EAAE,qBAAqB;IAOnC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAStB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAerC,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAK7E,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAKjF,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI5C,aAAa,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;IAItD,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAyC1E,mBAAmB,CAAC,YAAY,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,IAAI;YA+B1D,QAAQ;IAkCtB,OAAO,CAAC,aAAa;IAKrB,OAAO,CAAC,oBAAoB;CAS7B"}

package/dist/channels/telegram-channel.js

@@ -0,0 +1,167 @@
+// ============================================================
+// 轻灵 - Telegram Bot Channel（Telegram Bot 通道）
+// axios + long-poll，无额外 SDK
+// ============================================================
+import axios from "axios";
+export class TelegramChannel {
+    name = "telegram";
+    token;
+    pollIntervalMs;
+    allowedChatIds;
+    baseUrl;
+    userMessageHandler = null;
+    running = false;
+    lastUpdateId = 0;
+    lastActiveChatId = null;
+    pendingApprovals = new Map();
+    constructor(config) {
+        this.token = config.token;
+        this.pollIntervalMs = config.pollIntervalMs ?? 3000;
+        this.allowedChatIds = (config.allowedChatIds ?? []).map(Number);
+        this.baseUrl = "https://api.telegram.org/bot" + this.token;
+    }
+    async start() {
+        if (!this.token) {
+            console.error("[Telegram] No token configured");
+            return;
+        }
+        this.running = true;
+        this.pollLoop().catch(() => { });
+    }
+    async stop() {
+        this.running = false;
+    }
+    async sendText(text) {
+        const targets = this.resolveTargetChatIds();
+        if (targets.length === 0) {
+            console.error("[Telegram] sendText skipped: no target chat id");
+            return;
+        }
+        const body = text.length > 4000 ? text.slice(0, 4000) + "\n... [truncated]" : text;
+        for (const chatId of targets) {
+            await axios.post(this.baseUrl + "/sendMessage", {
+                chat_id: chatId,
+                text: body,
+            });
+        }
+    }
+    async sendToolStart(toolName, args) {
+        const preview = JSON.stringify(args).slice(0, 200);
+        await this.sendText("[tool:start] " + toolName + "\n" + preview);
+    }
+    async sendToolResult(toolName, output, isError) {
+        const status = isError ? "error" : "ok";
+        await this.sendText("[tool:" + status + "] " + toolName + "\n" + output.slice(0, 500));
+    }
+    async sendError(text) {
+        await this.sendText("[error] " + text);
+    }
+    onUserMessage(handler) {
+        this.userMessageHandler = handler;
+    }
+    async requestApproval(request) {
+        const targets = this.resolveTargetChatIds();
+        if (targets.length === 0) {
+            return {
+                requestId: request.id,
+                decision: "deny",
+                timestamp: Date.now(),
+            };
+        }
+        const text = "[Approval Required]\n" +
+            "Tool: " + request.toolName + "\n" +
+            "Reason: " + request.reason + "\n" +
+            "Approve this tool call?";
+        return new Promise((resolve) => {
+            this.pendingApprovals.set(request.id, resolve);
+            const keyboard = {
+                inline_keyboard: [
+                    [
+                        { text: "Allow", callback_data: request.id + ":allow" },
+                        { text: "Deny", callback_data: request.id + ":deny" },
+                    ],
+                ],
+            };
+            Promise.all(targets.map((chatId) => axios.post(this.baseUrl + "/sendMessage", {
+                chat_id: chatId,
+                text,
+                reply_markup: keyboard,
+            }))).catch((err) => {
+                console.error("[Telegram] Approval send failed: " + err.message);
+            });
+        });
+    }
+    handleCallbackQuery(callbackData, callbackQueryId) {
+        const match = /^(.*):(allow|deny)$/.exec(callbackData);
+        if (!match) {
+            axios
+                .post(this.baseUrl + "/answerCallbackQuery", {
+                callback_query_id: callbackQueryId,
+                text: "Unsupported callback",
+            })
+                .catch(() => { });
+            return;
+        }
+        const requestId = match[1];
+        const decision = match[2];
+        const resolver = this.pendingApprovals.get(requestId);
+        if (resolver) {
+            this.pendingApprovals.delete(requestId);
+            resolver({
+                requestId,
+                decision: decision === "allow" ? "allow" : "deny",
+                timestamp: Date.now(),
+            });
+        }
+        // Acknowledge callback
+        axios.post(this.baseUrl + "/answerCallbackQuery", {
+            callback_query_id: callbackQueryId,
+            text: "Processed",
+        }).catch(() => { });
+    }
+    // --- Private ---
+    async pollLoop() {
+        while (this.running) {
+            try {
+                const resp = await axios.post(this.baseUrl + "/getUpdates", {
+                    offset: this.lastUpdateId + 1,
+                    timeout: this.pollIntervalMs + 5000,
+                    allowed_updates: ["message", "callback_query"],
+                }, { timeout: this.pollIntervalMs + 10000 });
+                const updates = resp.data?.result ?? [];
+                for (const update of updates) {
+                    if (update.update_id > this.lastUpdateId) {
+                        this.lastUpdateId = update.update_id;
+                    }
+                    if (update.message && this.userMessageHandler) {
+                        if (this.isAllowedChat(update.message.chat.id)) {
+                            this.lastActiveChatId = Number(update.message.chat.id);
+                            await this.userMessageHandler(update.message.text ?? "");
+                        }
+                    }
+                    if (update.callback_query) {
+                        this.handleCallbackQuery(update.callback_query.data ?? "", update.callback_query.id);
+                    }
+                }
+            }
+            catch (err) {
+                console.error("[Telegram] Poll error: " + err.message);
+            }
+            await new Promise((r) => setTimeout(r, this.pollIntervalMs));
+        }
+    }
+    isAllowedChat(chatId) {
+        if (this.allowedChatIds.length === 0)
+            return true;
+        return this.allowedChatIds.includes(chatId);
+    }
+    resolveTargetChatIds() {
+        if (this.allowedChatIds.length > 0) {
+            return [...this.allowedChatIds];
+        }
+        if (this.lastActiveChatId !== null) {
+            return [this.lastActiveChatId];
+        }
+        return [];
+    }
+}