@kamilio/wire 0.1.9 → 0.1.10

package/node_modules/toolcraft/dist/testing/harness.js

@@ -0,0 +1,490 @@
+import { stripAnsi } from "toolcraft-design";
+import { ApprovalDeclinedError, ToolcraftBugError, UserError, assertCommandRequirements, resolveCommandSecrets } from "../index.js";
+import { approvalStateMachine } from "../human-in-loop/state-machine.js";
+import { invokeWithHumanInLoop } from "../human-in-loop/gate.js";
+import { createRuntimeLogger } from "../runtime-logging.js";
+import { createEnv, createFs, validateServices } from "../runtime/io.js";
+import { filterSchemaForScope } from "../schema-scope.js";
+import { validateObjectSchema } from "../sdk.js";
+import { throwValidationErrors } from "../validation-errors.js";
+import { fakeFetch } from "./fakes.js";
+import { createMemoryFs } from "./memory-fs.js";
+import { runParity } from "./parity.js";
+import { createRenderCapture } from "./render-capture.js";
+import { createManagedStream } from "../stream.js";
+import { runCLI } from "../cli.js";
+function isHandlerFs(value) {
+    return typeof value.readFile === "function";
+}
+function asMemoryFs(value) {
+    if (value === undefined || !isHandlerFs(value)) {
+        return createMemoryFs(value);
+    }
+    if ("snapshot" in value && "changes" in value) {
+        return value;
+    }
+    const handlerFs = createFs(value);
+    const changes = [];
+    return {
+        readFile: (path, encoding) => handlerFs.readFile(path, encoding),
+        exists: (path) => handlerFs.exists(path),
+        lstat: (path) => handlerFs.lstat(path),
+        async writeFile(path, contents, options) {
+            await handlerFs.writeFile(path, contents, options);
+            changes.push({ op: "writeFile", path });
+        },
+        async rename(fromPath, toPath) {
+            await handlerFs.rename(fromPath, toPath);
+            changes.push({ op: "rename", path: fromPath, to: toPath });
+        },
+        async unlink(path) {
+            await handlerFs.unlink(path);
+            changes.push({ op: "unlink", path });
+        },
+        snapshot: () => ({}),
+        changes: () => changes.map((change) => ({ ...change }))
+    };
+}
+function hasOwnMcpProxyConfig(group) {
+    const symbol = Object.getOwnPropertySymbols(group).find((candidate) => candidate.description === "toolcraft.group.config");
+    if (symbol === undefined) {
+        return false;
+    }
+    const config = group[symbol];
+    return config?.mcp !== undefined;
+}
+function findChild(group, segment) {
+    return group.children.find((child) => child.name === segment || child.aliases.includes(segment));
+}
+function resolveCommand(root, requestedPath) {
+    const path = requestedPath[0] === root.name ? requestedPath.slice(1) : requestedPath;
+    let group = root;
+    const canonicalPath = [];
+    for (let index = 0; index < path.length; index += 1) {
+        if (hasOwnMcpProxyConfig(group)) {
+            throw new UserError(`Commands under MCP proxy group "${group.name}" need a live server.`);
+        }
+        const segment = path[index];
+        const child = findChild(group, segment);
+        if (child === undefined) {
+            throw new UserError(`Unknown command path "${requestedPath.join(" ")}".`);
+        }
+        canonicalPath.push(child.name);
+        if (child.kind === "command") {
+            if (index !== path.length - 1) {
+                throw new UserError(`Command "${canonicalPath.join(" ")}" has no child commands.`);
+            }
+            return { command: child, path: canonicalPath };
+        }
+        group = child;
+    }
+    if (hasOwnMcpProxyConfig(group)) {
+        throw new UserError(`Commands under MCP proxy group "${group.name}" need a live server.`);
+    }
+    if (group.default !== undefined) {
+        return { command: group.default, path: [...canonicalPath, group.default.name] };
+    }
+    throw new UserError(`Command path "${requestedPath.join(" ")}" resolves to a group.`);
+}
+function createSealedEnv(declarations, env, secrets) {
+    const values = { ...(env ?? {}) };
+    for (const [name, value] of Object.entries(secrets ?? {})) {
+        const definition = declarations[name];
+        if (definition !== undefined) {
+            values[definition.env] = value;
+        }
+    }
+    return Object.freeze(values);
+}
+function isHumanInLoopPending(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        value.status === "pending-approval");
+}
+function createTaskList() {
+    const tasksById = new Map();
+    const tasks = {
+        name: "approvals",
+        stateMachine: approvalStateMachine,
+        async all() {
+            return [...tasksById.values()];
+        },
+        async get(id) {
+            const task = tasksById.get(id);
+            if (task === undefined) {
+                throw new Error(`Unknown task ${id}`);
+            }
+            return task;
+        },
+        async create(input) {
+            const id = input.id ?? String(tasksById.size + 1);
+            const task = {
+                list: "approvals",
+                id,
+                qualifiedId: `approvals:${id}`,
+                name: input.name,
+                state: approvalStateMachine.initial,
+                description: input.description ?? "",
+                metadata: input.metadata ?? {}
+            };
+            tasksById.set(id, task);
+            return task;
+        },
+        async update(id, patch) {
+            const task = await tasks.get(id);
+            Object.assign(task, patch);
+            return task;
+        },
+        async fire(id) {
+            return tasks.get(id);
+        },
+        async canFire() {
+            return false;
+        },
+        async events() {
+            return [];
+        },
+        async delete(id) {
+            tasksById.delete(id);
+        },
+        async move(id) {
+            return tasks.get(id);
+        },
+        async reorder(ids) {
+            return Promise.all(ids.map((id) => tasks.get(id)));
+        }
+    };
+    return {
+        list: () => tasks,
+        async lists() {
+            return ["approvals"];
+        },
+        async allTasks() {
+            return tasks.all();
+        },
+        async get(qualifiedId) {
+            return tasks.get(qualifiedId.split(":").at(-1) ?? qualifiedId);
+        },
+        async moveBetweenLists(qualifiedId) {
+            return this.get(qualifiedId);
+        }
+    };
+}
+export function createCommandTestHarness(root, options = {}) {
+    const services = options.services ?? {};
+    validateServices(services);
+    const memoryFs = asMemoryFs(options.fs);
+    const runtimeFetch = Array.isArray(options.fetch)
+        ? fakeFetch(options.fetch)
+        : (options.fetch ?? fakeFetch([]));
+    const cumulativeTimeline = [];
+    let sequence = 0;
+    const append = (runTimeline, event) => {
+        const sequenced = { seq: ++sequence, ...event };
+        runTimeline.push(sequenced);
+        cumulativeTimeline.push(sequenced);
+    };
+    return {
+        fs: memoryFs,
+        timeline: cumulativeTimeline,
+        async cli(args, cliOptions = {}) {
+            let stdout = "";
+            const previousExitCode = process.exitCode;
+            process.exitCode = undefined;
+            try {
+                await runCLI(root, {
+                    argv: ["node", root.name, ...args],
+                    controls: { output: { formats: cliOptions.formats } },
+                    services,
+                    env: Object.fromEntries(Object.entries(options.env ?? {}).flatMap(([key, value]) => value === undefined ? [] : [[key, value]])),
+                    fs: memoryFs,
+                    fetch: runtimeFetch,
+                    apiVersion: options.apiVersion,
+                    logLevel: options.logLevel,
+                    outputEmitter(entry) {
+                        stdout += entry;
+                    }
+                });
+                return {
+                    exitCode: process.exitCode ?? 0,
+                    stdout,
+                    stderr: ""
+                };
+            }
+            finally {
+                process.exitCode = previousExitCode;
+            }
+        },
+        async stream(requestedPath, inputParams = {}, streamOptions = {}) {
+            const events = [];
+            const statuses = [];
+            try {
+                const resolved = resolveCommand(root, requestedPath);
+                const command = resolved.command;
+                if (command.stream === undefined) {
+                    throw new UserError(`Command "${resolved.path.join(".")}" is not a stream.`);
+                }
+                const sealedEnv = createSealedEnv(command.secrets, options.env, options.secrets);
+                const commandSecrets = resolveCommandSecrets(command, sealedEnv);
+                const diagnostics = createRuntimeLogger({
+                    level: options.logLevel ?? "debug",
+                    logger: () => undefined
+                });
+                const baseContext = {
+                    ...(options.services ?? {}),
+                    secrets: commandSecrets,
+                    fetch: runtimeFetch,
+                    fs: memoryFs,
+                    env: createEnv(sealedEnv),
+                    diagnostics,
+                    progress() { }
+                };
+                await assertCommandRequirements(command, { ...baseContext, params: undefined }, {
+                    apiVersion: options.apiVersion,
+                    env: sealedEnv
+                });
+                const schema = filterSchemaForScope(command.params, "sdk");
+                if (schema === undefined || schema.kind !== "object") {
+                    throw new ToolcraftBugError(`command "${command.name}" must define an object params schema for SDK.`);
+                }
+                const errors = [];
+                const params = validateObjectSchema(schema, inputParams, "", errors);
+                throwValidationErrors(errors);
+                const stream = createManagedStream({
+                    eventSchema: command.stream.event,
+                    signal: streamOptions.signal,
+                    onStatus: (event) => statuses.push(event),
+                    async create(signal, status) {
+                        return await command.handler({
+                            ...baseContext,
+                            params,
+                            signal,
+                            status,
+                            async refreshSecrets() {
+                                return resolveCommandSecrets(command, sealedEnv);
+                            }
+                        });
+                    }
+                });
+                const limit = streamOptions.limit ?? Number.POSITIVE_INFINITY;
+                try {
+                    for await (const event of stream) {
+                        events.push(event);
+                        if (events.length >= limit) {
+                            break;
+                        }
+                    }
+                }
+                finally {
+                    await stream.cancel();
+                }
+                return { ok: true, events, statuses };
+            }
+            catch (error) {
+                return { ok: false, events, statuses, error };
+            }
+        },
+        async parity(requestedPath, inputParams = {}) {
+            const resolved = resolveCommand(root, requestedPath);
+            const sealedEnv = createSealedEnv(resolved.command.secrets, options.env, options.secrets);
+            return runParity(root, resolved, inputParams, {
+                services,
+                env: Object.fromEntries(Object.entries(sealedEnv).flatMap(([key, value]) => value === undefined ? [] : [[key, value]])),
+                fs: memoryFs,
+                fetch: runtimeFetch,
+                apiVersion: options.apiVersion
+            });
+        },
+        async run(requestedPath, inputParams = {}) {
+            const logs = [];
+            const progress = [];
+            const confirmations = [];
+            const timeline = [];
+            const rendered = {};
+            const initialChangeCount = memoryFs.changes().length;
+            let stage = "resolve";
+            let value;
+            const result = (overrides = {}) => ({
+                ok: false,
+                value,
+                error: undefined,
+                failedAt: stage,
+                pending: false,
+                logs,
+                progress,
+                confirmations,
+                timeline,
+                fsChanges: memoryFs.changes().slice(initialChangeCount),
+                rendered,
+                ...overrides
+            });
+            try {
+                const resolved = resolveCommand(root, requestedPath);
+                const command = resolved.command;
+                const commandPath = resolved.path.join(".");
+                stage = "secrets";
+                const sealedEnv = createSealedEnv(command.secrets, options.env, options.secrets);
+                const commandSecrets = resolveCommandSecrets(command, sealedEnv);
+                const diagnostics = createRuntimeLogger({
+                    level: options.logLevel ?? "debug",
+                    logger: (event) => logs.push(event)
+                });
+                const instrumentedFs = {
+                    readFile: (path, encoding) => memoryFs.readFile(path, encoding),
+                    exists: (path) => memoryFs.exists(path),
+                    lstat: (path) => memoryFs.lstat(path),
+                    async writeFile(path, contents, fsOptions) {
+                        await memoryFs.writeFile(path, contents, fsOptions);
+                        append(timeline, { kind: "fs", op: "writeFile", path });
+                    },
+                    async rename(fromPath, toPath) {
+                        await memoryFs.rename(fromPath, toPath);
+                        append(timeline, { kind: "fs", op: "rename", path: fromPath });
+                    },
+                    async unlink(path) {
+                        await memoryFs.unlink(path);
+                        append(timeline, { kind: "fs", op: "unlink", path });
+                    }
+                };
+                const instrumentedFetch = async (input, init) => {
+                    const request = new Request(input, init);
+                    append(timeline, {
+                        kind: "fetch",
+                        method: request.method,
+                        url: request.url
+                    });
+                    return runtimeFetch(request);
+                };
+                const instrumentedServices = Object.fromEntries(Object.entries(services).map(([serviceName, service]) => {
+                    if ((typeof service !== "object" || service === null) &&
+                        typeof service !== "function") {
+                        return [serviceName, service];
+                    }
+                    return [
+                        serviceName,
+                        new Proxy(service, {
+                            get(target, property, receiver) {
+                                const member = Reflect.get(target, property, receiver);
+                                if (typeof member !== "function") {
+                                    return member;
+                                }
+                                return (...args) => {
+                                    append(timeline, {
+                                        kind: "service",
+                                        service: serviceName,
+                                        method: String(property),
+                                        args
+                                    });
+                                    return Reflect.apply(member, receiver, args);
+                                };
+                            }
+                        })
+                    ];
+                }));
+                const baseContext = {
+                    ...instrumentedServices,
+                    secrets: commandSecrets,
+                    fetch: instrumentedFetch,
+                    fs: instrumentedFs,
+                    env: createEnv(new Proxy(sealedEnv, {
+                        get(target, property, receiver) {
+                            if (typeof property === "string") {
+                                append(timeline, { kind: "env", key: property });
+                            }
+                            return Reflect.get(target, property, receiver);
+                        }
+                    })),
+                    diagnostics,
+                    progress(message) {
+                        progress.push(message);
+                        append(timeline, { kind: "progress", message });
+                    }
+                };
+                stage = "requirements";
+                await assertCommandRequirements(command, { ...baseContext, params: undefined }, { apiVersion: options.apiVersion, env: sealedEnv });
+                stage = "params";
+                const schema = filterSchemaForScope(command.params, "sdk");
+                if (schema === undefined || schema.kind !== "object") {
+                    throw new ToolcraftBugError(`command "${command.name}" must define an object params schema for SDK.`);
+                }
+                const errors = [];
+                const params = validateObjectSchema(schema, inputParams, "", errors);
+                throwValidationErrors(errors);
+                const decide = async (request) => {
+                    confirmations.push(request);
+                    const approved = options.confirmations === "decline"
+                        ? false
+                        : typeof options.confirmations === "function"
+                            ? await options.confirmations(request)
+                            : true;
+                    append(timeline, { kind: "confirm", message: request.message, approved });
+                    return approved;
+                };
+                stage = "confirm";
+                if (command.confirm && !command.humanInLoop) {
+                    if (!(await decide({ message: "Proceed?" }))) {
+                        throw new ApprovalDeclinedError({ commandPath });
+                    }
+                }
+                const provider = {
+                    id: "toolcraft-test-harness",
+                    async requestApproval(request) {
+                        return (await decide({
+                            message: request.message,
+                            declineInputPrompt: request.declineInputPrompt
+                        }))
+                            ? { outcome: "approved" }
+                            : { outcome: "declined" };
+                    }
+                };
+                const commandWithTrackedHandler = {
+                    ...command,
+                    async handler(context) {
+                        stage = "handler";
+                        return command.handler(context);
+                    }
+                };
+                const invoked = await invokeWithHumanInLoop(commandWithTrackedHandler, { ...baseContext, params }, { provider, taskList: createTaskList() }, commandPath, {
+                    spawnRunner: false,
+                    async enqueueApproval({ tasks, payload }) {
+                        const approvalId = `test-harness:${payload.commandPath}`;
+                        const pending = {
+                            status: "pending-approval",
+                            approvalId,
+                            message: payload.message,
+                            enqueuedAt: ""
+                        };
+                        await tasks.create({
+                            id: approvalId,
+                            name: payload.commandPath,
+                            metadata: { ...payload, approvalId, enqueuedAt: "" }
+                        });
+                        return { approvalId, pending };
+                    }
+                });
+                value = invoked;
+                if (isHumanInLoopPending(invoked)) {
+                    return result({ ok: true, failedAt: undefined, pending: true });
+                }
+                stage = "render";
+                if (command.render?.rich) {
+                    const capture = createRenderCapture();
+                    command.render.rich(invoked, capture.primitives);
+                    rendered.rich = capture.output();
+                }
+                if (command.render?.markdown) {
+                    const capture = createRenderCapture("md");
+                    rendered.markdown = stripAnsi(command.render.markdown(invoked, capture.primitives));
+                }
+                if (command.render?.json) {
+                    const capture = createRenderCapture("json");
+                    rendered.json = command.render.json(invoked, capture.primitives);
+                }
+                return result({ ok: true, failedAt: undefined });
+            }
+            catch (error) {
+                return result({ error });
+            }
+        }
+    };
+}

package/node_modules/toolcraft/dist/testing/hosted-oauth-storage.d.ts

@@ -0,0 +1,6 @@
+import type { HostedOAuthStorage } from "../http-hosted-oauth.js";
+export interface HostedOAuthStorageConformanceOptions<TCredential> {
+    createStorage(): HostedOAuthStorage<TCredential> | Promise<HostedOAuthStorage<TCredential>>;
+    credentials: readonly [TCredential, TCredential];
+}
+export declare function verifyHostedOAuthStorage<TCredential>(options: HostedOAuthStorageConformanceOptions<TCredential>): Promise<void>;

package/node_modules/toolcraft/dist/testing/hosted-oauth-storage.js

@@ -0,0 +1,140 @@
+import { isDeepStrictEqual } from "node:util";
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(`Hosted OAuth storage conformance failed: ${message}`);
+}
+export async function verifyHostedOAuthStorage(options) {
+    const storage = await options.createStorage();
+    const [firstCredential, secondCredential] = options.credentials;
+    const firstSubject = await storage.resolveSubject("provider", "account-a");
+    const repeatedSubject = await storage.resolveSubject("provider", "account-a");
+    const secondSubject = await storage.resolveSubject("provider", "account-b");
+    const otherProviderSubject = await storage.resolveSubject("other-provider", "account-a");
+    assert(firstSubject === repeatedSubject, "subject resolution must be stable");
+    assert(firstSubject !== secondSubject, "different provider accounts must resolve independently");
+    assert(firstSubject !== otherProviderSubject, "provider namespaces must resolve independently");
+    await storage.credentials.set(firstSubject, firstCredential);
+    assert(isDeepStrictEqual(await storage.credentials.get(firstSubject), firstCredential), "credentials must round-trip");
+    await storage.credentials.update(firstSubject, () => secondCredential);
+    assert(isDeepStrictEqual(await storage.credentials.get(firstSubject), secondCredential), "credential updates must persist");
+    let releaseFirstUpdate;
+    let markFirstUpdateStarted;
+    const firstUpdateStarted = new Promise((resolve) => {
+        markFirstUpdateStarted = resolve;
+    });
+    const releaseFirst = new Promise((resolve) => {
+        releaseFirstUpdate = resolve;
+    });
+    const firstUpdate = storage.credentials.update(firstSubject, async (current) => {
+        assert(isDeepStrictEqual(current, secondCredential), "credential updates must read current data");
+        markFirstUpdateStarted?.();
+        await releaseFirst;
+        return firstCredential;
+    });
+    await firstUpdateStarted;
+    let secondUpdateStarted = false;
+    const secondUpdate = storage.credentials.update(firstSubject, (current) => {
+        secondUpdateStarted = true;
+        assert(isDeepStrictEqual(current, firstCredential), "credential updates must execute atomically");
+        return secondCredential;
+    });
+    const updates = Promise.all([firstUpdate, secondUpdate]);
+    await Promise.resolve();
+    assert(!secondUpdateStarted, "credential updates must be serialized");
+    releaseFirstUpdate?.();
+    await updates;
+    assert(isDeepStrictEqual(await storage.credentials.get(firstSubject), secondCredential), "serialized credential updates must persist");
+    await storage.credentials.delete(firstSubject);
+    assert((await storage.credentials.get(firstSubject)) === undefined, "credential deletion must persist");
+    const transaction = {
+        id: "interaction-1",
+        clientId: "client-1",
+        redirectUri: "https://client.example/callback",
+        codeChallenge: "challenge",
+        resource: "https://resource.example/mcp",
+        scopes: ["mcp"],
+        createdAt: 1,
+        expiresAt: 2
+    };
+    await storage.interactions.set(transaction);
+    assert(isDeepStrictEqual(await storage.interactions.get(transaction.id), transaction), "interactions must round-trip");
+    await storage.interactions.delete(transaction.id);
+    assert((await storage.interactions.get(transaction.id)) === undefined, "interaction deletion must persist");
+    const firstKey = await storage.signingKey();
+    const secondKey = await storage.signingKey();
+    assert(firstKey.keyId === secondKey.keyId && isDeepStrictEqual(firstKey.publicJwk, secondKey.publicJwk), "signing keys must remain stable");
+    const restartedStorage = await options.createStorage();
+    if (storage.capabilities.stableKeys) {
+        const restartedKey = await restartedStorage.signingKey();
+        assert(firstKey.keyId === restartedKey.keyId &&
+            isDeepStrictEqual(firstKey.publicJwk, restartedKey.publicJwk), "stable signing keys must survive adapter restart");
+    }
+    if (storage.capabilities.durable) {
+        assert((await restartedStorage.resolveSubject("provider", "account-a")) === firstSubject, "durable subject resolution must survive adapter restart");
+    }
+    const store = storage.authorizationServer;
+    const client = { id: "client-1", redirectUris: ["https://client.example/callback"], createdAt: 1 };
+    await store.putClient(client);
+    assert(isDeepStrictEqual(await store.getClient(client.id), client), "clients must round-trip");
+    await store.putAuthorizationTransaction(transaction);
+    assert(isDeepStrictEqual(await store.takeAuthorizationTransaction(transaction.id), transaction) &&
+        (await store.takeAuthorizationTransaction(transaction.id)) === undefined, "authorization transactions must be consumed atomically");
+    const grant = {
+        id: "grant-1",
+        clientId: client.id,
+        subject: firstSubject,
+        resource: transaction.resource,
+        scopes: ["mcp", "offline_access"],
+        createdAt: 1
+    };
+    const code = {
+        tokenHash: "code-1",
+        grantId: grant.id,
+        clientId: client.id,
+        subject: firstSubject,
+        redirectUri: transaction.redirectUri,
+        codeChallenge: transaction.codeChallenge,
+        resource: transaction.resource,
+        scopes: grant.scopes,
+        expiresAt: 10
+    };
+    await store.putAuthorizationCode(code);
+    assert(isDeepStrictEqual(await store.takeAuthorizationCode(code.tokenHash), code) &&
+        (await store.takeAuthorizationCode(code.tokenHash)) === undefined, "authorization codes must be consumed atomically");
+    await store.putGrant(grant);
+    assert(isDeepStrictEqual(await store.getGrant(grant.id), grant), "grants must round-trip");
+    const accessToken = {
+        tokenHash: "access-1",
+        tokenId: "token-1",
+        grantId: grant.id,
+        subject: firstSubject,
+        clientId: client.id,
+        resource: transaction.resource,
+        expiresAt: 10
+    };
+    await store.putAccessToken(accessToken);
+    assert(isDeepStrictEqual(await store.getAccessToken(accessToken.tokenHash), accessToken), "access tokens must round-trip");
+    await store.revokeToken(accessToken.tokenHash, 5);
+    assert((await store.getAccessToken(accessToken.tokenHash))?.revokedAt === 5, "access-token revocation must persist");
+    const refreshToken = {
+        tokenHash: "refresh-1",
+        familyId: "family-1",
+        grantId: grant.id,
+        clientId: client.id,
+        subject: firstSubject,
+        resource: transaction.resource,
+        scopes: grant.scopes,
+        createdAt: 1,
+        expiresAt: 10,
+        status: "active"
+    };
+    await store.putRefreshToken(refreshToken);
+    const rotation = await store.rotateRefreshToken(refreshToken.tokenHash, "refresh-2", 2, 20);
+    assert(rotation.status === "rotated" && isDeepStrictEqual(rotation.previous, refreshToken), "refresh tokens must rotate atomically");
+    assert((await store.rotateRefreshToken(refreshToken.tokenHash, "refresh-3", 3, 20)).status ===
+        "replay", "refresh-token replay must be detected");
+    await store.revokeGrant(grant.id, 6);
+    assert((await store.getGrant(grant.id))?.revokedAt === 6, "grant revocation must persist");
+    await storage.healthCheck?.();
+    await storage.cleanup?.(Date.now());
+}

package/node_modules/toolcraft/dist/testing/index.d.ts

@@ -0,0 +1,5 @@
+export { createCommandTestHarness, type CommandTestHarness, type ConfirmationRequest, type EffectEvent, type HarnessCLIOptions, type HarnessCLIResult, type HarnessOptions, type PipelineStage, type RunResult, type StreamRunResult } from "./harness.js";
+export { fakeFetch, fakeService, type FetchRoute, type ServiceCall } from "./fakes.js";
+export { createMemoryFs, type FsChange, type MemoryFs } from "./memory-fs.js";
+export type { ParityResult, SurfaceOutcome } from "./parity.js";
+export { verifyHostedOAuthStorage, type HostedOAuthStorageConformanceOptions } from "./hosted-oauth-storage.js";

package/node_modules/toolcraft/dist/testing/index.js

@@ -0,0 +1,4 @@
+export { createCommandTestHarness } from "./harness.js";
+export { fakeFetch, fakeService } from "./fakes.js";
+export { createMemoryFs } from "./memory-fs.js";
+export { verifyHostedOAuthStorage } from "./hosted-oauth-storage.js";

package/node_modules/toolcraft/dist/testing/memory-fs.d.ts

@@ -0,0 +1,11 @@
+import type { HandlerFs } from "../index.js";
+export type FsChange = {
+    op: "writeFile" | "rename" | "unlink";
+    path: string;
+    to?: string;
+};
+export interface MemoryFs extends HandlerFs {
+    snapshot(): Record<string, string>;
+    changes(): FsChange[];
+}
+export declare function createMemoryFs(files?: Record<string, string>): MemoryFs;