openclaw-codex-feishu 0.1.1

package/dist/runtime/bridgeRuntime.js

@@ -0,0 +1,303 @@
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { resolveConfig } from "../config.js";
+import { RawChunkRenderer } from "../render/rawChunkRenderer.js";
+import { BindingStore } from "../state/bindingStore.js";
+import { JournalStore } from "../state/journalStore.js";
+import { AppServerClient } from "../transport/appServerClient.js";
+import { KeyedQueue } from "../utils/keyedQueue.js";
+export class BridgeRuntime {
+    logger;
+    chatSink;
+    config;
+    bindingStore;
+    journalStore;
+    renderer;
+    queue = new KeyedQueue();
+    client;
+    constructor(rawConfig, logger, chatSink) {
+        this.logger = logger;
+        this.chatSink = chatSink;
+        this.config = resolveConfig(rawConfig);
+        this.bindingStore = new BindingStore(this.config.dataDir);
+        this.journalStore = new JournalStore(this.config.dataDir);
+        this.renderer = new RawChunkRenderer(this, this.config.feishu.streamChunkChars ?? 1500);
+        this.client = new AppServerClient(this.config.command, this.config.args, logger);
+        this.client.onNotification((notification) => {
+            void this.handleNotification(notification.method, notification.params ?? {});
+        });
+        this.client.onExit(() => {
+            this.logger.error("Codex app-server transport exited unexpectedly");
+        });
+    }
+    async start() {
+        await mkdir(this.config.dataDir, { recursive: true });
+        await this.client.initialize();
+    }
+    stop() {
+        this.client.stop();
+    }
+    async sendChunk(bindingKey, chunk) {
+        const [channel, accountId, peerKey] = bindingKey.split(":");
+        if (channel !== "feishu")
+            return;
+        await this.chatSink.sendText({ channel, accountId, peerKey }, chunk);
+    }
+    async handleCodexToolTask(identity, task, context) {
+        const input = context ? `${task}\n\nContext:\n${context}` : task;
+        await this.dispatchUserInput(identity, input);
+        return "Codex 已接管，输出将直接回流到当前 Feishu 聊天。";
+    }
+    async handleCodexCommand(identity, argsRaw) {
+        const args = argsRaw.trim();
+        if (!args) {
+            return "可用子命令: new | resume | status | detach | stop | steer | plan | raw | model | permissions | review | approve | replay | log";
+        }
+        const [subcommand, ...rest] = args.split(/\s+/g);
+        const tail = rest.join(" ").trim();
+        switch (subcommand) {
+            case "new":
+                return this.handleNew(identity, tail || this.config.defaultWorkspaceDir);
+            case "resume":
+                return this.handleResume(identity, tail);
+            case "status":
+                return this.handleStatus(identity);
+            case "detach":
+                return this.handleDetach(identity);
+            case "stop":
+                return this.handleStop(identity);
+            case "steer":
+                return this.handleSteer(identity, tail);
+            case "plan":
+                return this.handlePlan(identity, tail);
+            case "raw":
+                return this.handleRaw(identity, tail);
+            case "model":
+                return this.handleModel(identity, tail);
+            case "permissions":
+                return this.handlePermissions(identity, tail);
+            case "review":
+                return this.handleReview(identity, tail);
+            case "approve":
+                return this.handleApprove(identity, tail);
+            case "replay":
+                return this.handleReplay(identity, tail);
+            case "log":
+                return `日志目录: ${path.join(this.config.dataDir, "threads")}`;
+            default:
+                return this.dispatchUserInput(identity, args);
+        }
+    }
+    async handleSteer(identity, text) {
+        if (!text)
+            return "用法: /codex steer <text>";
+        const state = await this.bindingStore.load(identity);
+        if (!state.threadId || !state.activeTurnId)
+            return "当前没有运行中的 turn。";
+        await this.client.turnSteer(state.threadId, state.activeTurnId, text);
+        await this.journalStore.appendEvent({
+            ts: Date.now(),
+            bindingKey: state.bindingKey,
+            threadId: state.threadId,
+            turnId: state.activeTurnId,
+            direction: "out",
+            raw: { method: "turn/steer", params: { input: text } }
+        });
+        return `已发送 steer 指令: ${text.slice(0, 100)}`;
+    }
+    async handlePlan(identity, goal) {
+        const input = goal ? `请先给出执行计划，再开始执行。\n\n目标：${goal}` : "请先给出执行计划，再开始执行。";
+        return this.dispatchUserInput(identity, input);
+    }
+    async handleNew(identity, workspaceRoot) {
+        const thread = (await this.client.threadStart(workspaceRoot, this.config.defaultModel));
+        const threadId = thread.threadId ?? "";
+        const state = await this.bindingStore.patch(identity, {
+            threadId,
+            workspaceRoot,
+            preferredModel: this.config.defaultModel,
+            status: "idle",
+            attachMode: this.config.attachModeDefault,
+            rawMode: this.config.rawModeDefault
+        });
+        await this.journalStore.writeMeta(threadId, {
+            workspaceRoot,
+            model: state.preferredModel,
+            createdAt: Date.now()
+        });
+        return `已创建 Codex 线程: ${threadId || "(未返回 threadId)"}`;
+    }
+    async handleResume(identity, threadId) {
+        if (!threadId)
+            return "用法: /codex resume <threadId>";
+        await this.client.threadResume(threadId);
+        await this.bindingStore.patch(identity, { threadId, status: "idle" });
+        return `已恢复线程: ${threadId}`;
+    }
+    async handleStatus(identity) {
+        const state = await this.bindingStore.load(identity);
+        return [
+            `bindingKey: ${state.bindingKey}`,
+            `status: ${state.status}`,
+            `threadId: ${state.threadId ?? "(none)"}`,
+            `workspace: ${state.workspaceRoot ?? "(none)"}`,
+            `model: ${state.preferredModel ?? this.config.defaultModel}`,
+            `rawMode: ${state.rawMode}`,
+            `attachMode: ${state.attachMode}`
+        ].join("\n");
+    }
+    async handleDetach(identity) {
+        await this.bindingStore.patch(identity, {
+            threadId: null,
+            activeTurnId: undefined,
+            status: "unbound"
+        });
+        return "已解绑当前聊天与 Codex 线程。";
+    }
+    async handleStop(identity) {
+        const state = await this.bindingStore.load(identity);
+        if (!state.threadId || !state.activeTurnId)
+            return "当前没有运行中的 turn。";
+        await this.client.turnInterrupt(state.threadId, state.activeTurnId);
+        await this.bindingStore.patch(identity, { status: "idle", activeTurnId: undefined });
+        return `已请求停止 turn: ${state.activeTurnId}`;
+    }
+    async handleRaw(identity, mode) {
+        if (!["off", "cli", "all"].includes(mode)) {
+            return "用法: /codex raw off|cli|all";
+        }
+        await this.bindingStore.patch(identity, { rawMode: mode });
+        return `raw 模式已更新为: ${mode}`;
+    }
+    async handleModel(identity, model) {
+        if (!model)
+            return "用法: /codex model <name>";
+        await this.bindingStore.patch(identity, { preferredModel: model });
+        return `默认模型已更新: ${model}`;
+    }
+    async handlePermissions(identity, mode) {
+        if (mode !== "default" && mode !== "full") {
+            return "用法: /codex permissions default|full";
+        }
+        const approvalMode = mode === "full" ? "fullAccess" : "default";
+        const state = await this.bindingStore.load(identity);
+        await this.bindingStore.save({ ...state, approvalMode, updatedAt: Date.now() });
+        return `权限模式已更新: ${approvalMode}`;
+    }
+    async handleReview(identity, focus) {
+        const state = await this.bindingStore.load(identity);
+        if (!state.threadId)
+            return "请先执行 /codex new 或 /codex resume";
+        await this.client.reviewStart(state.threadId, focus || undefined);
+        return "已提交 review 请求。";
+    }
+    async handleApprove(identity, tail) {
+        const [requestId, action, ...rest] = tail.split(/\s+/g).filter(Boolean);
+        if (!requestId || !action) {
+            return "用法: /codex approve <requestId> <allow-once|allow-always|deny|cancel|amend> [amendedCommand]";
+        }
+        const allowedActions = new Set(["allow-once", "allow-always", "deny", "cancel", "amend"]);
+        if (!allowedActions.has(action)) {
+            return "approve action 仅支持: allow-once | allow-always | deny | cancel | amend";
+        }
+        const amendedCommand = rest.join(" ").trim() || undefined;
+        await this.client.approve(requestId, action, amendedCommand);
+        const state = await this.bindingStore.load(identity);
+        if (state.threadId) {
+            await this.journalStore.appendEvent({
+                ts: Date.now(),
+                bindingKey: state.bindingKey,
+                threadId: state.threadId,
+                turnId: state.activeTurnId ?? "unknown",
+                direction: "out",
+                raw: { method: "approval/respond", params: { requestId, action, amendedCommand } }
+            });
+        }
+        return `已提交审批响应: ${action} (${requestId})`;
+    }
+    async handleReplay(identity, turnId) {
+        const state = await this.bindingStore.load(identity);
+        if (!state.threadId)
+            return "请先执行 /codex new 或 /codex resume";
+        const targetTurnId = turnId || state.activeTurnId;
+        if (!targetTurnId)
+            return "用法: /codex replay <turnId>";
+        return `turn 日志路径: ${path.join(this.config.dataDir, "threads", state.threadId, "turns", `${targetTurnId}.jsonl`)}`;
+    }
+    async dispatchUserInput(identity, text) {
+        return this.queue.enqueue(`${identity.channel}:${identity.accountId}:${identity.peerKey}`, async () => {
+            const state = await this.bindingStore.load(identity);
+            if (!state.threadId) {
+                return "当前未绑定线程，请先执行 /codex new";
+            }
+            const turnResult = (await this.client.turnStart(state.threadId, text, {
+                approvalMode: state.approvalMode
+            }));
+            const turnId = turnResult.turnId ?? "";
+            await this.bindingStore.patch(identity, {
+                status: "running",
+                activeTurnId: turnId
+            });
+            await this.journalStore.appendEvent({
+                ts: Date.now(),
+                bindingKey: state.bindingKey,
+                threadId: state.threadId,
+                turnId,
+                direction: "out",
+                raw: { method: "turn/start", params: { input: text } }
+            });
+            return `已发送到 Codex: ${text.slice(0, 100)}`;
+        });
+    }
+    async handleNotification(method, params) {
+        const bindingKey = typeof params.bindingKey === "string" ? params.bindingKey : undefined;
+        const threadId = typeof params.threadId === "string" ? params.threadId : undefined;
+        const turnId = typeof params.turnId === "string" ? params.turnId : "unknown";
+        if (bindingKey && threadId) {
+            const event = {
+                ts: Date.now(),
+                bindingKey,
+                threadId,
+                turnId,
+                direction: "in",
+                raw: { method, params }
+            };
+            await this.journalStore.appendEvent(event);
+            const maybeText = this.extractRenderableText(method, params);
+            if (maybeText) {
+                const state = await this.bindingStore.load(this.identityFromBindingKey(bindingKey));
+                if (this.shouldRenderRaw(state.rawMode, method)) {
+                    await this.renderer.push(bindingKey, maybeText, method === "turn/completed" || method === "error");
+                }
+            }
+        }
+    }
+    identityFromBindingKey(key) {
+        const [channel, accountId, peerKey] = key.split(":");
+        return { channel: channel ?? "feishu", accountId: accountId ?? "unknown", peerKey: peerKey ?? "unknown" };
+    }
+    shouldRenderRaw(rawMode, method) {
+        if (rawMode === "off")
+            return method === "error" || method === "turn/completed";
+        if (rawMode === "all")
+            return true;
+        // cli: only CLI-like text deltas and terminal events.
+        if (method === "error" || method === "turn/completed")
+            return true;
+        return method.includes("outputDelta") || method.includes("summaryTextDelta");
+    }
+    extractRenderableText(method, params) {
+        const delta = typeof params.delta === "string" ? params.delta : undefined;
+        const message = typeof params.message === "string" ? params.message : undefined;
+        if (method.includes("outputDelta") || method.includes("agentMessage") || method.includes("summaryTextDelta")) {
+            return delta ?? message;
+        }
+        if (method === "error") {
+            return `\n[error] ${message ?? "unknown error"}\n`;
+        }
+        if (method === "turn/completed") {
+            return "\n[turn completed]\n";
+        }
+        return undefined;
+    }
+}

package/dist/state/bindingStore.d.ts

@@ -0,0 +1,19 @@
+import type { AttachMode, RawMode } from "../config.js";
+import type { BindingState } from "./schemas.js";
+export interface BindingIdentity {
+    channel: string;
+    accountId: string;
+    peerKey: string;
+}
+export declare class BindingStore {
+    private readonly rootDir;
+    constructor(rootDir: string);
+    private get dir();
+    private fileForKey;
+    load(identity: BindingIdentity): Promise<BindingState>;
+    save(state: BindingState): Promise<void>;
+    patch(identity: BindingIdentity, patch: Partial<Pick<BindingState, "threadId" | "workspaceRoot" | "preferredModel" | "status" | "activeTurnId" | "controlMessageId" | "controlPinned">> & {
+        attachMode?: AttachMode;
+        rawMode?: RawMode;
+    }): Promise<BindingState>;
+}

package/dist/state/bindingStore.js

@@ -0,0 +1,58 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+function bindingKey(identity) {
+    return `${identity.channel}:${identity.accountId}:${identity.peerKey}`;
+}
+export class BindingStore {
+    rootDir;
+    constructor(rootDir) {
+        this.rootDir = rootDir;
+    }
+    get dir() {
+        return path.join(this.rootDir, "bindings");
+    }
+    fileForKey(key) {
+        return path.join(this.dir, `${encodeURIComponent(key)}.json`);
+    }
+    async load(identity) {
+        const key = bindingKey(identity);
+        const file = this.fileForKey(key);
+        try {
+            const raw = await readFile(file, "utf8");
+            return JSON.parse(raw);
+        }
+        catch {
+            const now = Date.now();
+            return {
+                bindingKey: key,
+                channel: "feishu",
+                accountId: identity.accountId,
+                peerKey: identity.peerKey,
+                threadId: null,
+                workspaceRoot: null,
+                preferredModel: null,
+                approvalMode: "default",
+                rawMode: "cli",
+                attachMode: "attached",
+                status: "unbound",
+                createdAt: now,
+                updatedAt: now
+            };
+        }
+    }
+    async save(state) {
+        await mkdir(this.dir, { recursive: true });
+        const file = this.fileForKey(state.bindingKey);
+        await writeFile(file, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+    }
+    async patch(identity, patch) {
+        const current = await this.load(identity);
+        const next = {
+            ...current,
+            ...patch,
+            updatedAt: Date.now()
+        };
+        await this.save(next);
+        return next;
+    }
+}

package/dist/state/journalStore.d.ts

@@ -0,0 +1,8 @@
+import type { JournalEnvelope } from "./schemas.js";
+export declare class JournalStore {
+    private readonly rootDir;
+    constructor(rootDir: string);
+    private threadDir;
+    writeMeta(threadId: string, meta: Record<string, unknown>): Promise<void>;
+    appendEvent(event: JournalEnvelope): Promise<void>;
+}

package/dist/state/journalStore.js

@@ -0,0 +1,21 @@
+import { appendFile, mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+export class JournalStore {
+    rootDir;
+    constructor(rootDir) {
+        this.rootDir = rootDir;
+    }
+    threadDir(threadId) {
+        return path.join(this.rootDir, "threads", threadId);
+    }
+    async writeMeta(threadId, meta) {
+        const dir = this.threadDir(threadId);
+        await mkdir(dir, { recursive: true });
+        await writeFile(path.join(dir, "meta.json"), `${JSON.stringify(meta, null, 2)}\n`, "utf8");
+    }
+    async appendEvent(event) {
+        const turnDir = path.join(this.threadDir(event.threadId), "turns");
+        await mkdir(turnDir, { recursive: true });
+        await appendFile(path.join(turnDir, `${event.turnId}.jsonl`), `${JSON.stringify(event)}\n`, "utf8");
+    }
+}

package/dist/state/schemas.d.ts

@@ -0,0 +1,30 @@
+export type ApprovalMode = "default" | "fullAccess";
+export type RawMode = "off" | "cli" | "all";
+export type AttachMode = "attached" | "toolOnly";
+export type BindingStatus = "unbound" | "idle" | "running" | "awaitingApproval" | "error" | "transportStale";
+export interface BindingState {
+    bindingKey: string;
+    channel: "feishu";
+    accountId: string;
+    peerKey: string;
+    threadId: string | null;
+    workspaceRoot: string | null;
+    preferredModel: string | null;
+    approvalMode: ApprovalMode;
+    rawMode: RawMode;
+    attachMode: AttachMode;
+    status: BindingStatus;
+    activeTurnId?: string;
+    controlMessageId?: string;
+    controlPinned?: boolean;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface JournalEnvelope {
+    ts: number;
+    bindingKey: string;
+    threadId: string;
+    turnId: string;
+    direction: "in" | "out";
+    raw: Record<string, unknown>;
+}

package/dist/state/schemas.js

@@ -0,0 +1 @@
+export {};

package/dist/transport/appServerClient.d.ts

@@ -0,0 +1,20 @@
+import type { LoggerLike } from "../utils/logger.js";
+import type { JsonRpcNotification } from "./protocol.js";
+export declare class AppServerClient {
+    private readonly transport;
+    constructor(command: string, args: string[], logger: LoggerLike);
+    onNotification(listener: (n: JsonRpcNotification) => void): void;
+    onExit(listener: (reason: unknown) => void): void;
+    initialize(clientName?: string): Promise<unknown>;
+    threadStart(workspaceRoot: string, model: string): Promise<unknown>;
+    threadResume(threadId: string): Promise<unknown>;
+    turnStart(threadId: string, text: string, options?: {
+        approvalMode?: "default" | "fullAccess";
+    }): Promise<unknown>;
+    turnSteer(threadId: string, turnId: string, text: string): Promise<unknown>;
+    turnInterrupt(threadId: string, turnId: string): Promise<unknown>;
+    reviewStart(threadId: string, focus?: string): Promise<unknown>;
+    approve(requestId: string, action: string, amendedCommand?: string): Promise<unknown>;
+    notify(method: string, params?: Record<string, unknown>): void;
+    stop(): void;
+}

package/dist/transport/appServerClient.js

@@ -0,0 +1,46 @@
+import { StdioTransport } from "./stdioTransport.js";
+export class AppServerClient {
+    transport;
+    constructor(command, args, logger) {
+        this.transport = new StdioTransport(command, args, logger);
+    }
+    onNotification(listener) {
+        this.transport.on("notification", listener);
+    }
+    onExit(listener) {
+        this.transport.on("exit", listener);
+    }
+    initialize(clientName = "openclaw-codex-feishu") {
+        return this.transport.request("initialize", {
+            clientName,
+            protocolVersion: "2026-03-01"
+        });
+    }
+    threadStart(workspaceRoot, model) {
+        return this.transport.request("thread/start", { workspaceRoot, model });
+    }
+    threadResume(threadId) {
+        return this.transport.request("thread/resume", { threadId });
+    }
+    turnStart(threadId, text, options) {
+        return this.transport.request("turn/start", { threadId, input: text, approvalMode: options?.approvalMode });
+    }
+    turnSteer(threadId, turnId, text) {
+        return this.transport.request("turn/steer", { threadId, turnId, input: text });
+    }
+    turnInterrupt(threadId, turnId) {
+        return this.transport.request("turn/interrupt", { threadId, turnId });
+    }
+    reviewStart(threadId, focus) {
+        return this.transport.request("review/start", { threadId, focus });
+    }
+    approve(requestId, action, amendedCommand) {
+        return this.transport.request("approval/respond", { requestId, action, amendedCommand });
+    }
+    notify(method, params) {
+        this.transport.notify(method, params);
+    }
+    stop() {
+        this.transport.stop();
+    }
+}

package/dist/transport/protocol.d.ts

@@ -0,0 +1,22 @@
+export interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    id: string;
+    method: string;
+    params?: Record<string, unknown>;
+}
+export interface JsonRpcResponse {
+    jsonrpc: "2.0";
+    id: string;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+export interface JsonRpcNotification {
+    jsonrpc: "2.0";
+    method: string;
+    params?: Record<string, unknown>;
+}
+export type JsonRpcInbound = JsonRpcResponse | JsonRpcNotification;

package/dist/transport/protocol.js

@@ -0,0 +1 @@
+export {};

package/dist/transport/stdioTransport.d.ts

@@ -0,0 +1,17 @@
+import { EventEmitter } from "node:events";
+import type { LoggerLike } from "../utils/logger.js";
+export declare class StdioTransport extends EventEmitter {
+    private readonly command;
+    private readonly args;
+    private readonly logger;
+    private child?;
+    private readonly pending;
+    private buffer;
+    constructor(command: string, args: string[], logger: LoggerLike);
+    start(): void;
+    stop(): void;
+    request(method: string, params?: Record<string, unknown>): Promise<unknown>;
+    notify(method: string, params?: Record<string, unknown>): void;
+    private flushLines;
+    private handleInbound;
+}

package/dist/transport/stdioTransport.js

@@ -0,0 +1,97 @@
+import { spawn } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { makeId } from "../utils/ids.js";
+export class StdioTransport extends EventEmitter {
+    command;
+    args;
+    logger;
+    child;
+    pending = new Map();
+    buffer = "";
+    constructor(command, args, logger) {
+        super();
+        this.command = command;
+        this.args = args;
+        this.logger = logger;
+    }
+    start() {
+        if (this.child && !this.child.killed)
+            return;
+        this.child = spawn(this.command, this.args, {
+            stdio: "pipe",
+            env: process.env
+        });
+        this.child.stdout.setEncoding("utf8");
+        this.child.stdout.on("data", (chunk) => {
+            this.buffer += chunk;
+            this.flushLines();
+        });
+        this.child.stderr.setEncoding("utf8");
+        this.child.stderr.on("data", (chunk) => {
+            this.logger.warn("codex-app-server stderr", chunk.trim());
+        });
+        this.child.on("exit", (code, signal) => {
+            this.logger.error(`codex-app-server exited code=${code} signal=${signal}`);
+            for (const [id, pending] of this.pending) {
+                pending.reject(new Error(`Transport closed before response for request ${id}`));
+            }
+            this.pending.clear();
+            this.emit("exit", { code, signal });
+        });
+    }
+    stop() {
+        this.child?.kill();
+        this.child = undefined;
+    }
+    async request(method, params) {
+        this.start();
+        const id = makeId("rpc");
+        const req = { jsonrpc: "2.0", id, method, params };
+        const raw = `${JSON.stringify(req)}\n`;
+        const promise = new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+        });
+        this.child?.stdin.write(raw);
+        return promise;
+    }
+    notify(method, params) {
+        this.start();
+        const raw = `${JSON.stringify({ jsonrpc: "2.0", method, params })}\n`;
+        this.child?.stdin.write(raw);
+    }
+    flushLines() {
+        while (true) {
+            const idx = this.buffer.indexOf("\n");
+            if (idx < 0)
+                break;
+            const line = this.buffer.slice(0, idx).trim();
+            this.buffer = this.buffer.slice(idx + 1);
+            if (!line)
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                this.handleInbound(parsed);
+            }
+            catch (error) {
+                this.logger.warn("Failed to parse app-server JSON line", { line, error });
+            }
+        }
+    }
+    handleInbound(inbound) {
+        if ("id" in inbound) {
+            const response = inbound;
+            const pending = this.pending.get(response.id);
+            if (!pending)
+                return;
+            this.pending.delete(response.id);
+            if (response.error) {
+                pending.reject(new Error(response.error.message));
+            }
+            else {
+                pending.resolve(response.result);
+            }
+            return;
+        }
+        this.emit("notification", inbound);
+    }
+}

package/dist/utils/ids.d.ts

@@ -0,0 +1 @@
+export declare function makeId(prefix: string): string;

package/dist/utils/ids.js

@@ -0,0 +1,4 @@
+export function makeId(prefix) {
+    const rand = Math.random().toString(36).slice(2, 10);
+    return `${prefix}_${Date.now().toString(36)}_${rand}`;
+}

package/dist/utils/keyedQueue.d.ts

@@ -0,0 +1,4 @@
+export declare class KeyedQueue {
+    private readonly tails;
+    enqueue<T>(key: string, task: () => Promise<T>): Promise<T>;
+}