@capybara-hq/testing 0.0.0-stage → 0.1.0-rc.1

package/dist/fake-channel.js

@@ -0,0 +1,325 @@
+import { createHash, createHmac, randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+/** 校验应用凭据时一律拒绝的密钥。 */
+export const FAKE_CHANNEL_BAD_SECRET = "bad-secret";
+const readBody = (req) => new Promise((resolve) => {
+    let body = "";
+    req.on("data", (c) => {
+        body += c.toString();
+    });
+    req.on("end", () => resolve(body));
+});
+const json = (res, status, body) => {
+    res.writeHead(status, { "content-type": "application/json" });
+    res.end(JSON.stringify(body));
+};
+/** 启动假 IM 平台（监听 127.0.0.1 随机端口）。 */
+export async function startFakeChannelServer(opts = {}) {
+    const dedupe = opts.dedupeSends ?? true;
+    const streams = [];
+    const sent = [];
+    const updated = [];
+    const duplicateSends = [];
+    const posts = [];
+    const users = new Map();
+    const books = new Map();
+    const codes = new Map();
+    const byKey = new Map();
+    const failures = [];
+    const delays = [];
+    const live = new Map();
+    const peaks = new Map();
+    let failStatus = null;
+    let seq = 0;
+    let base = "";
+    const activeOf = (id) => [...live.keys()].filter((s) => s.connectionId === id);
+    const pidOf = (req) => Number(req.headers["x-pid"]);
+    const connect = (req, res, u) => {
+        if (failStatus !== null) {
+            res.writeHead(failStatus).end();
+            return;
+        }
+        const s = {
+            connectionId: u.searchParams.get("connection") ?? "",
+            appId: String(req.headers["x-app-id"] ?? ""),
+            pid: pidOf(req),
+            openedAt: Date.now(),
+            closedAt: undefined,
+        };
+        streams.push(s);
+        live.set(s, res);
+        peaks.set(s.connectionId, Math.max(peaks.get(s.connectionId) ?? 0, activeOf(s.connectionId).length));
+        res.writeHead(200, { "content-type": "application/x-ndjson" });
+        res.write("\n");
+        const close = () => {
+            if (s.closedAt === undefined)
+                s.closedAt = Date.now();
+            live.delete(s);
+        };
+        req.on("close", close);
+        res.on("close", close);
+    };
+    const sendOrUpdate = async (req, res, path) => {
+        const body = await readBody(req);
+        const f = failures.find((x) => x.path === path && x.left > 0);
+        if (f) {
+            f.left--;
+            if (f.delayMs !== undefined)
+                await new Promise((r) => setTimeout(r, f.delayMs));
+            json(res, f.status, { retryAfterMs: f.retryAfterMs ?? null, reason: f.reason ?? null });
+            return;
+        }
+        const b = JSON.parse(body);
+        const key = b.idempotencyKey ? `${b.appId}\u0000${b.idempotencyKey}` : undefined;
+        const seen = path === "/send" && key !== undefined ? byKey.get(key) : undefined;
+        const messageId = b.messageId ?? seen ?? `om_${++seq}`;
+        const rec = { ...b, messageId, pid: pidOf(req), at: Date.now() };
+        if (path === "/update")
+            updated.push(rec);
+        else if (seen !== undefined && dedupe)
+            duplicateSends.push(rec);
+        else {
+            sent.push(rec);
+            if (key !== undefined && seen === undefined)
+                byKey.set(key, messageId);
+        }
+        const hasCards = (b.message?.cards?.length ?? 0) > 0;
+        const d = delays.find((x) => x.path === path && x.left > 0 && (!x.onlyCards || hasCards));
+        if (d) {
+            d.left--;
+            await new Promise((r) => setTimeout(r, d.delayMs));
+        }
+        json(res, 200, { messageId });
+    };
+    const authorize = (res, u) => {
+        const redirect = u.searchParams.get("redirect_uri");
+        const state = u.searchParams.get("state") ?? "";
+        if (redirect === null) {
+            json(res, 400, { error: "invalid_request" });
+            return;
+        }
+        const back = new URL(redirect);
+        back.searchParams.set("state", state);
+        const user = users.get(u.searchParams.get("as") ?? "");
+        if (user === undefined) {
+            back.searchParams.set("error", "access_denied");
+        }
+        else {
+            const code = `fc_${randomBytes(16).toString("hex")}`;
+            codes.set(code, {
+                user,
+                nonce: u.searchParams.get("nonce") ?? "",
+                clientId: u.searchParams.get("client_id") ?? "",
+                challenge: u.searchParams.get("code_challenge"),
+            });
+            back.searchParams.set("code", code);
+        }
+        res.writeHead(302, { location: back.toString() }).end();
+    };
+    const token = async (req, res) => {
+        const b = JSON.parse((await readBody(req)) || "{}");
+        const c = b.code === undefined ? undefined : codes.get(b.code);
+        if (b.code !== undefined)
+            codes.delete(b.code);
+        if (c === undefined || c.clientId !== b.clientId) {
+            json(res, 400, { error: "invalid_grant" });
+            return;
+        }
+        if (c.challenge !== null &&
+            (b.codeVerifier === undefined ||
+                createHash("sha256").update(b.codeVerifier).digest("base64url") !== c.challenge)) {
+            json(res, 400, { error: "invalid_grant" });
+            return;
+        }
+        if (b.clientSecret === FAKE_CHANNEL_BAD_SECRET) {
+            json(res, 401, { error: "invalid_client" });
+            return;
+        }
+        json(res, 200, { user: c.user, nonce: c.nonce });
+    };
+    const directory = async (req, res, b) => {
+        const u = new URL(req.url ?? "/", "http://x");
+        const cursor = u.searchParams.get("cursor");
+        const page = cursor === null ? 0 : Number(cursor);
+        b.requests.push({ page, pid: pidOf(req) });
+        if (page === 0 && b.hold)
+            await b.hold;
+        if (b.failOnPage === page) {
+            res.writeHead(500).end();
+            return;
+        }
+        const start = page * b.pageSize;
+        const members = b.members.slice(start, start + b.pageSize);
+        const more = start + b.pageSize < b.members.length;
+        json(res, 200, { members, ...(more && { next: String(page + 1) }) });
+    };
+    const server = createServer((req, res) => {
+        void (async () => {
+            const u = new URL(req.url ?? "/", "http://x");
+            const route = `${req.method} ${u.pathname}`;
+            if (route === "GET /connect")
+                return connect(req, res, u);
+            if (route === "POST /send" || route === "POST /update") {
+                return sendOrUpdate(req, res, u.pathname);
+            }
+            if (route === "POST /bot/verify") {
+                const b = JSON.parse((await readBody(req)) || "{}");
+                if (!b.appId || !b.appSecret || b.appSecret === FAKE_CHANNEL_BAD_SECRET) {
+                    return json(res, 401, { error: "invalid app credentials" });
+                }
+                return json(res, 200, {
+                    botUserId: `bot-${b.appId}`,
+                    botName: "Fake Bot",
+                    tenantId: b.tenant ?? "t1",
+                });
+            }
+            if (route === "GET /oauth/authorize")
+                return authorize(res, u);
+            if (route === "POST /oauth/token")
+                return token(req, res);
+            if (route === "POST /posts") {
+                const body = JSON.parse((await readBody(req)) || "{}");
+                posts.push({ body, pid: pidOf(req), at: Date.now() });
+                return json(res, 200, { id: `post_${posts.length}` });
+            }
+            const m = /^\/d\/([^/]+)\/members$/.exec(u.pathname);
+            const b = m && req.method === "GET" ? books.get(m[1]) : undefined;
+            if (b)
+                return directory(req, res, b);
+            res.writeHead(404).end();
+        })().catch(() => {
+            if (!res.headersSent)
+                res.writeHead(500);
+            res.end();
+        });
+    });
+    await new Promise((r) => server.listen(0, "127.0.0.1", r));
+    base = `http://127.0.0.1:${server.address().port}`;
+    return {
+        url: base,
+        streams,
+        sent,
+        updated,
+        duplicateSends,
+        posts,
+        users,
+        failNext(path, status, count = 1, retryAfterMs, reason, delayMs) {
+            failures.push({
+                path,
+                status,
+                left: count,
+                ...(retryAfterMs !== undefined && { retryAfterMs }),
+                ...(reason !== undefined && { reason }),
+                ...(delayMs !== undefined && { delayMs }),
+            });
+        },
+        delayNext(path, delayMs, opts = {}) {
+            delays.push({ path, delayMs, left: opts.count ?? 1, onlyCards: opts.onlyCards ?? false });
+        },
+        failConnect(status) {
+            failStatus = status;
+        },
+        active: activeOf,
+        maxConcurrent: (id) => peaks.get(id) ?? 0,
+        push(connectionId, event) {
+            const targets = activeOf(connectionId);
+            for (const s of targets)
+                live.get(s)?.write(`${JSON.stringify(event)}\n`);
+            return targets.length;
+        },
+        book(key) {
+            let b = books.get(key);
+            if (!b) {
+                const requests = [];
+                b = {
+                    url: `${base}/d/${key}`,
+                    members: [],
+                    pageSize: 100,
+                    failOnPage: null,
+                    hold: null,
+                    requests,
+                    starts: () => requests.filter((r) => r.page === 0).length,
+                };
+                books.set(key, b);
+            }
+            return b;
+        },
+        finalText(s) {
+            return (updated.filter((x) => x.messageId === s.messageId).at(-1)?.message.text ?? s.message.text);
+        },
+        async stop() {
+            for (const res of live.values())
+                res.destroy();
+            live.clear();
+            server.closeAllConnections();
+            await new Promise((r) => server.close(() => r()));
+        },
+    };
+}
+const senderOf = (externalId, tenantId, profile = {}) => ({
+    externalId,
+    tenantId,
+    ...(profile.displayName !== undefined && { displayName: profile.displayName }),
+    ...(profile.avatarUrl !== undefined && { avatarUrl: profile.avatarUrl }),
+});
+/** 私聊文本消息（chat id 为 `dm-<externalId>`）；`profile` 给了就带上发言人的显示名 / 头像。 */
+export function fakeDm(messageId, externalId, text, tenantId = "t1", profile) {
+    return {
+        type: "message",
+        messageId,
+        target: { chatId: `dm-${externalId}`, chatType: "dm" },
+        sender: senderOf(externalId, tenantId, profile),
+        text,
+        mentionsBot: false,
+    };
+}
+/** 群聊文本消息（默认 chat `grp-1`、@ 了机器人）。 */
+export function fakeGroupMessage(messageId, externalId, text, opts = {}) {
+    return {
+        type: "message",
+        messageId,
+        target: {
+            chatId: opts.chatId ?? "grp-1",
+            chatType: "group",
+            ...(opts.threadId !== undefined && { threadId: opts.threadId }),
+        },
+        sender: senderOf(externalId, opts.tenantId ?? "t1", opts),
+        text,
+        mentionsBot: opts.mentionsBot ?? true,
+    };
+}
+/** 卡片按钮操作；`target` 取卡片所在的消息目标（群里带 threadId）。 */
+export function fakeCardAction(messageId, externalId, action, target, tenantId = "t1", profile) {
+    return {
+        type: "card_action",
+        messageId,
+        target,
+        sender: senderOf(externalId, tenantId, profile),
+        action,
+    };
+}
+/** 通讯录成员（租户 t1；邮箱缺省 `<id>@corp.example`、已验证）。 */
+export function fakeDirectoryMember(externalId, over = {}) {
+    return {
+        externalId,
+        tenantId: "t1",
+        email: `${externalId}@corp.example`,
+        emailVerified: true,
+        displayName: externalId,
+        active: true,
+        ...over,
+    };
+}
+/** Signature header of the fake platform's webhooks (`sha256=<hex HMAC-SHA256 of the raw body>`). */
+export const FAKE_WEBHOOK_SIGNATURE_HEADER = "x-fake-signature";
+/**
+ * Signs a fake-platform webhook body the way the `fake-im` test plugin verifies it: returns the
+ * value for {@link FAKE_WEBHOOK_SIGNATURE_HEADER}, `sha256=` + hex HMAC-SHA256(secret, body).
+ */
+export function signFakeWebhook(body, secret) {
+    return `sha256=${createHmac("sha256", secret).update(body).digest("hex")}`;
+}
+/** Body of a fake-platform webhook that delivers events (`fake-im` answers with its ack). */
+export const fakeWebhookEvents = (events) => JSON.stringify({ type: "events", events });
+/** Body of a fake-platform URL verification request (`fake-im` echoes `{ challenge }`). */
+export const fakeWebhookChallenge = (challenge) => JSON.stringify({ type: "challenge", challenge });

package/dist/fake-e2b.d.ts

@@ -0,0 +1,104 @@
+/**
+ * 可编程的假 E2B（`plugins/sandbox-e2b` 测试用），协议按 `e2b` JS SDK 2.58.0 与 E2B 文档（2026-10-21 核实）：
+ *
+ * - **控制面 API**（请求头 `X-API-KEY`，不符 → 401 `{code, message}`）：
+ *   `POST /v2/sandboxes`（建沙箱，回 201 `{sandboxID, templateID, envdVersion, envdAccessToken, domain}`）、
+ *   `GET /v2/sandboxes?metadata=<urlencoded k=v>&state=running,paused&limit=&nextToken=`（按元数据列出，
+ *   分页游标在响应头 `x-next-token`）、`POST /v2/sandboxes/{id}/connect`（运行中 200、暂停的恢复后 201、
+ *   不存在 404；`timeout` 只延长不缩短）、`POST /sandboxes/{id}/pause`（204；已暂停 409；不存在 404）、
+ *   `DELETE /sandboxes/{id}`（204；不存在 404）。
+ * - **envd**（同一个地址；按请求头 `E2b-Sandbox-Id` 路由，`X-Access-Token` 须与建沙箱时给的一致；沙箱不存在或
+ *   已暂停时与 E2B 的边缘代理一样回 502）：`POST /files?path=&username=`（multipart 字段 `file`）、
+ *   Connect 协议的 `POST /process.Process/Start`（`application/connect+json` 服务端流：start / data / end 事件，
+ *   结尾帧 flags `0x02`）与 `POST /process.Process/SendSignal`（一元 JSON，按 pid 杀进程组；不存在 404
+ *   `{code: "not_found"}`）。用户来自 `Authorization: Basic base64(<user>:)`（命令）或 `username`（上传）。
+ *
+ * **命令真的在本机跑**：每个沙箱一个临时目录作根，参数、工作目录、环境变量里以 `/workspace`、`/skills`、`/tmp`、
+ * `/opt/capybara` 开头的路径映射到根下；`setsid` / `runuser` / `timeout`（本机没有 GNU timeout 时）由垫片代替（只 exec 后面的命令，不切换用户——
+ * 本机只有一个用户，权限隔离测不了，测试改为核对请求里的用户）。进程以新会话启动（与 setsid 等价），
+ * 客户端断开**不会**结束进程（与 envd 一致），只有 SendSignal、杀进程脚本或删沙箱才会。
+ *
+ * `connect` 带 `memory: false`（SDK 的 `onResume: "reboot"`）时结束该沙箱的全部进程（冷启动）。
+ * SendSignal 只杀指定进程（不是进程组）。
+ *
+ * {@link FakeE2BServer.failNext} 让匹配的下一个请求返回指定状态；{@link FakeE2BServer.hangNext} 让它一直不回
+ * （测中止）；{@link FakeE2BServer.expire} 让沙箱直接消失（过期 / 被别处删掉）。
+ */
+export interface FakeE2BOptions {
+    /** 期望的 API key（默认随机生成，见 {@link FakeE2BServer.apiKey}）。 */
+    apiKey?: string;
+    /** 列表接口每页条数（默认 100；测分页时调小）。 */
+    pageSize?: number;
+    /** create / connect 返回的沙箱 `domain`（默认 null，即用客户端配置的域名）。 */
+    domain?: string | null;
+}
+export interface FakeE2BSandbox {
+    id: string;
+    templateID: string;
+    metadata: Record<string, string>;
+    state: "running" | "paused";
+    /** 当前的超时（秒）：建沙箱时给的，connect 只会把它调大。 */
+    timeout: number;
+    autoPause: boolean;
+    /** 建沙箱请求体里的出站设置（原样记录）。 */
+    allowInternetAccess?: boolean;
+    network?: unknown;
+    envdAccessToken: string;
+    /** 本机上的根目录。 */
+    root: string;
+}
+/** 服务收到的一次请求。 */
+export interface FakeE2BCall {
+    method: string;
+    path: string;
+    query: Record<string, string>;
+    /** JSON 请求体（Connect 流请求为解出的第一条消息；上传为 null）。 */
+    body: unknown;
+    /** envd 请求：目标沙箱。 */
+    sandboxId?: string;
+    /** envd 请求：以哪个用户（Basic 认证或 `username`）。 */
+    user?: string | undefined;
+}
+export interface FakeE2BMatch {
+    method?: string;
+    path: RegExp;
+    /** 再按请求细看（Connect 流请求的 `body` 是解出的第一条消息）。 */
+    when?: (call: FakeE2BCall) => boolean;
+}
+export interface FakeE2BServer {
+    /** 控制面 API 与 envd 共用的地址 `http://127.0.0.1:<port>`。 */
+    url: string;
+    apiKey: string;
+    sandboxes: Map<string, FakeE2BSandbox>;
+    calls: FakeE2BCall[];
+    /**
+     * 下一个匹配的请求回 `status`：默认 E2B 的错误格式 JSON `{code: status, message}`；`raw` 时回纯文本
+     * （模拟前面的代理 / 错配地址回的裸错误）。
+     */
+    failNext(match: FakeE2BMatch, status: number, message?: string, opts?: {
+        raw?: boolean;
+    }): void;
+    /** 以 `memory: false` connect（冷启动，进程全部结束）的次数，按沙箱 id。 */
+    reboots: Map<string, number>;
+    /** 下一个匹配的请求一直不回，直到客户端断开。 */
+    hangNext(match: FakeE2BMatch): void;
+    /**
+     * 为 true 时 create / connect 的响应不带 `envdAccessToken`（模拟没拿到令牌：测提供方是否 fail closed）；
+     * envd 照样要求令牌。
+     */
+    withholdAccessToken: boolean;
+    /** 沙箱直接消失（杀掉它的进程、删掉根目录）。 */
+    expire(id: string): Promise<void>;
+    /** 沙箱内路径在本机上的位置。 */
+    hostPath(id: string, sandboxPath: string): string;
+    /** 沙箱里还在跑的进程（由 Start 启动、尚未退出的）。 */
+    running(id: string): {
+        pid: number;
+        args: string[];
+    }[];
+    /** 进程组是否还有存活的进程（含被杀进程脚本漏掉的子进程）。 */
+    alive(pid: number): boolean;
+    close(): Promise<void>;
+}
+/** 起一个假 E2B。 */
+export declare function startFakeE2B(opts?: FakeE2BOptions): Promise<FakeE2BServer>;