@kamilio/wire 0.1.0

package/node_modules/toolcraft/dist/error-report.d.ts

@@ -0,0 +1,39 @@
+import type { Command } from "./index.js";
+export type ErrorReportsOption = boolean | {
+    dir?: string;
+};
+export interface ErrorReportContext {
+    argv?: readonly string[];
+    command?: Command<any, any, any, any>;
+    commandPath?: string;
+    env?: Record<string, string | undefined>;
+    error: unknown;
+    errorReports?: ErrorReportsOption;
+    params?: unknown;
+    projectRoot?: string;
+    secrets?: Record<string, string | undefined>;
+    version?: string;
+}
+export interface ErrorReportResult {
+    absolutePath: string;
+    displayPath: string;
+}
+interface HttpErrorLike {
+    name: "HttpError";
+    message: string;
+    request: {
+        method: string;
+        url: string;
+        headers: Record<string, string>;
+        body?: unknown;
+    };
+    response: {
+        status: number;
+        statusText: string;
+        headers: Record<string, string>;
+        body: unknown;
+    };
+}
+declare function hasHttpContext(error: unknown): error is HttpErrorLike;
+export declare function writeErrorReport(context: ErrorReportContext): Promise<ErrorReportResult | undefined>;
+export { hasHttpContext };

package/node_modules/toolcraft/dist/error-report.js

@@ -0,0 +1,432 @@
+import { mkdir, realpath, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+import { CommanderError } from "commander";
+import { ApprovalDeclinedError } from "./human-in-loop/types.js";
+import { findProjectRoot } from "./mcp-proxy.js";
+import { findPackageMetadata } from "./package-metadata.js";
+import { isSensitiveName, redactHttpBody, redactHttpHeaderValue } from "./redaction.js";
+import { UserError } from "./user-error.js";
+const ERROR_REPORTS_ENV = "TOOLCRAFT_ERROR_REPORTS";
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function unwrapOptional(schema) {
+    if (schema.kind === "optional") {
+        return unwrapOptional(schema.inner);
+    }
+    return schema;
+}
+function hasHttpContext(error) {
+    return (error instanceof Error &&
+        error.name === "HttpError" &&
+        isPlainObject(error.request) &&
+        isPlainObject(error.response));
+}
+function isSkippedError(error) {
+    if (error instanceof ApprovalDeclinedError) {
+        return true;
+    }
+    if (error instanceof CommanderError &&
+        (error.code === "commander.helpDisplayed" || error.code === "commander.version")) {
+        return true;
+    }
+    return error instanceof UserError && error.cause === undefined && !hasHttpContext(error);
+}
+function reportsEnabled(option, env) {
+    if (env[ERROR_REPORTS_ENV] === "1") {
+        return true;
+    }
+    return option !== undefined && option !== false;
+}
+function resolveReportDir(option, projectRoot) {
+    const configuredDir = typeof option === "object" ? option.dir : undefined;
+    if (configuredDir === undefined || configuredDir.length === 0) {
+        return path.join(projectRoot, ".toolcraft", "errors");
+    }
+    return path.isAbsolute(configuredDir) ? configuredDir : path.join(projectRoot, configuredDir);
+}
+function reportDirMustStayWithinProject(option) {
+    const configuredDir = typeof option === "object" ? option.dir : undefined;
+    return configuredDir === undefined || configuredDir.length === 0 || !path.isAbsolute(configuredDir);
+}
+function isWithinDirectory(parent, child) {
+    const relative = path.relative(parent, child);
+    return relative === "" || (!path.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path.sep}`));
+}
+async function assertReportDirWithinProject(projectRoot, reportDir) {
+    if (!isWithinDirectory(path.resolve(projectRoot), path.resolve(reportDir))) {
+        throw new Error("Error report directory resolves outside project root.");
+    }
+    const [canonicalProjectRoot, canonicalReportDir] = await Promise.all([
+        realpath(projectRoot),
+        realpath(reportDir)
+    ]);
+    if (!isWithinDirectory(canonicalProjectRoot, canonicalReportDir)) {
+        throw new Error("Error report directory resolves outside project root.");
+    }
+}
+function resolveProjectRoot(projectRoot) {
+    if (projectRoot !== undefined) {
+        return projectRoot;
+    }
+    return findProjectRoot() ?? os.tmpdir();
+}
+function formatTimestamp(date) {
+    const isoMinute = date.toISOString().slice(0, 16);
+    const colonIndex = isoMinute.indexOf(":");
+    if (colonIndex === -1) {
+        return isoMinute;
+    }
+    return `${isoMinute.slice(0, colonIndex)}${isoMinute.slice(colonIndex + 1)}`;
+}
+function slugifyCommandPath(commandPath) {
+    const source = commandPath === undefined || commandPath.length === 0 ? "root" : commandPath;
+    let output = "";
+    let previousWasDash = false;
+    for (const char of source) {
+        const lower = char.toLowerCase();
+        const isWord = (lower >= "a" && lower <= "z") || (lower >= "0" && lower <= "9");
+        if (isWord) {
+            output += lower;
+            previousWasDash = false;
+            continue;
+        }
+        if (!previousWasDash) {
+            output += "-";
+            previousWasDash = true;
+        }
+    }
+    while (output.startsWith("-")) {
+        output = output.slice(1);
+    }
+    while (output.endsWith("-")) {
+        output = output.slice(0, -1);
+    }
+    return output.length === 0 ? "root" : output;
+}
+function relativeDisplayPath(projectRoot, absolutePath) {
+    const relative = path.relative(projectRoot, absolutePath);
+    return relative.length === 0 || relative.startsWith("..") ? absolutePath : relative;
+}
+function redactValue(value) {
+    if (value === undefined) {
+        return "<unset>";
+    }
+    return `<set, ${value.length} chars>`;
+}
+function collectStringLeaves(value, output) {
+    if (typeof value === "string") {
+        if (value.length > 0) {
+            output.add(value);
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            collectStringLeaves(entry, output);
+        }
+        return;
+    }
+    if (isPlainObject(value)) {
+        for (const entry of Object.values(value)) {
+            collectStringLeaves(entry, output);
+        }
+    }
+}
+function schemaSecretValue(schema) {
+    const unwrapped = unwrapOptional(schema);
+    if (unwrapped.kind === "string" || unwrapped.kind === "number") {
+        return unwrapped.secret;
+    }
+    return undefined;
+}
+function shouldRedactParam(name, schema) {
+    const secret = schemaSecretValue(schema);
+    if (secret !== undefined) {
+        return secret;
+    }
+    return isSensitiveName(name);
+}
+function redactParamsValue(value, schema, name) {
+    if (shouldRedactParam(name, schema)) {
+        return "<redacted>";
+    }
+    const unwrapped = unwrapOptional(schema);
+    if (unwrapped.kind === "object" && isPlainObject(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, childValue]) => {
+            const childSchema = unwrapped.shape[key];
+            return [
+                key,
+                childSchema === undefined ? childValue : redactParamsValue(childValue, childSchema, key)
+            ];
+        }));
+    }
+    if (unwrapped.kind === "array" && Array.isArray(value)) {
+        return value.map((entry) => redactParamsValue(entry, unwrapped.item, name));
+    }
+    return value;
+}
+function redactParams(params, command) {
+    if (command === undefined) {
+        return params;
+    }
+    return redactParamsValue(params, command.params, "");
+}
+function collectSensitiveParamValues(value, schema, name, output) {
+    if (shouldRedactParam(name, schema)) {
+        collectStringLeaves(value, output);
+        return;
+    }
+    const unwrapped = unwrapOptional(schema);
+    if (unwrapped.kind === "object" && isPlainObject(value)) {
+        for (const [key, childValue] of Object.entries(value)) {
+            const childSchema = unwrapped.shape[key];
+            if (childSchema !== undefined) {
+                collectSensitiveParamValues(childValue, childSchema, key, output);
+            }
+        }
+        return;
+    }
+    if (unwrapped.kind === "array" && Array.isArray(value)) {
+        for (const entry of value) {
+            collectSensitiveParamValues(entry, unwrapped.item, name, output);
+        }
+    }
+}
+function createReportStringRedactor(context, env) {
+    const values = new Set();
+    for (const value of Object.values(context.secrets ?? {})) {
+        if (value !== undefined && value.length > 0) {
+            values.add(value);
+        }
+    }
+    for (const [name, secret] of Object.entries(context.command?.secrets ?? {})) {
+        const value = context.secrets?.[name] ?? env[secret.env];
+        if (value !== undefined && value.length > 0) {
+            values.add(value);
+        }
+    }
+    if (context.command !== undefined) {
+        collectSensitiveParamValues(context.params, context.command.params, "", values);
+    }
+    const orderedValues = [...values].sort((left, right) => right.length - left.length);
+    return (value) => {
+        let redacted = value;
+        for (const secretValue of orderedValues) {
+            redacted = redacted.split(secretValue).join("<redacted>");
+        }
+        return redacted;
+    };
+}
+function commandSecretEnvNames(secrets) {
+    if (secrets === undefined) {
+        return [];
+    }
+    return Object.values(secrets).map((secret) => secret.env);
+}
+function redactArgv(argv, options) {
+    if (argv === undefined) {
+        return [];
+    }
+    const secretValues = new Set(Object.values(options.secrets ?? {}).filter((value) => value !== undefined && value.length > 0));
+    const secretNames = new Set([
+        ...Object.keys(options.secrets ?? {}),
+        ...commandSecretEnvNames(options.command?.secrets)
+    ]);
+    const output = [];
+    let redactNext = false;
+    for (const arg of argv) {
+        if (redactNext) {
+            output.push("<redacted>");
+            redactNext = false;
+            continue;
+        }
+        const equalsIndex = arg.indexOf("=");
+        const optionName = equalsIndex === -1 ? arg : arg.slice(0, equalsIndex);
+        const normalizedOptionName = optionName.replaceAll("-", "");
+        const sensitiveByName = isSensitiveName(normalizedOptionName) ||
+            [...secretNames].some((name) => normalizedOptionName.toLowerCase().includes(name.toLowerCase()));
+        if (equalsIndex !== -1 && sensitiveByName) {
+            output.push(`${optionName}=<redacted>`);
+            continue;
+        }
+        if (arg.startsWith("-") && sensitiveByName) {
+            output.push(arg);
+            redactNext = true;
+            continue;
+        }
+        let redactedArg = arg;
+        for (const secretValue of secretValues) {
+            redactedArg = redactedArg.split(secretValue).join("<redacted>");
+        }
+        output.push(redactedArg);
+    }
+    return output;
+}
+function stableJson(value) {
+    return JSON.stringify(value, null, 2) ?? "undefined";
+}
+function redactStructuredErrorField(name, value, redactString) {
+    if (typeof value === "string") {
+        const redactedHeaderValue = redactHttpHeaderValue(name, value);
+        if (redactedHeaderValue !== value) {
+            return redactedHeaderValue;
+        }
+        if (isSensitiveName(name)) {
+            return "<redacted>";
+        }
+        return redactString(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => redactStructuredErrorField(name, entry, redactString));
+    }
+    if (isPlainObject(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+            key,
+            redactStructuredErrorField(key, entry, redactString)
+        ]));
+    }
+    return value;
+}
+function ownStructuredFields(error, redactString) {
+    const fields = {};
+    for (const key of Object.keys(error)) {
+        if (key === "name" || key === "message" || key === "stack" || key === "cause") {
+            continue;
+        }
+        Object.defineProperty(fields, key, {
+            value: redactStructuredErrorField(key, error[key], redactString),
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    }
+    return fields;
+}
+function formatStackChain(error, redactString) {
+    const lines = [];
+    let current = error;
+    let index = 0;
+    while (current !== undefined) {
+        if (current instanceof Error) {
+            const stack = current.stack ?? String(current);
+            lines.push(redactString(index === 0 ? stack : `Caused by: ${stack}`));
+            current = current.cause;
+        }
+        else {
+            const message = String(current);
+            lines.push(redactString(index === 0 ? message : `Caused by: ${message}`));
+            current = undefined;
+        }
+        index += 1;
+    }
+    return lines.join("\n");
+}
+function formatHeaderValue(name, value, redactString) {
+    return redactString(redactHttpHeaderValue(name, value));
+}
+function formatHeaders(headers, redactString) {
+    return Object.entries(headers)
+        .map(([name, value]) => `${name}: ${formatHeaderValue(name, value, redactString)}`)
+        .join("\n");
+}
+function formatBody(body, redactString) {
+    const redactedBody = redactHttpBody(body);
+    if (typeof redactedBody === "string") {
+        return redactString(redactedBody);
+    }
+    return redactString(stableJson(redactedBody));
+}
+function formatHttpTranscript(error, redactString) {
+    const requestLines = [
+        `${error.request.method} ${error.request.url}`,
+        formatHeaders(error.request.headers, redactString)
+    ].filter((line) => line.length > 0);
+    if (error.request.body !== undefined) {
+        requestLines.push("", formatBody(error.request.body, redactString));
+    }
+    return [
+        "Request:",
+        ...requestLines,
+        "",
+        "Response:",
+        `${error.response.status} ${error.response.statusText}`,
+        formatHeaders(error.response.headers, redactString),
+        "",
+        formatBody(error.response.body, redactString)
+    ].join("\n");
+}
+function resolveToolcraftVersion(version) {
+    return (version ??
+        findPackageMetadata(new URL("./error-report.ts", import.meta.url))?.version ??
+        "unknown");
+}
+function buildReport(context) {
+    const env = context.env ?? process.env;
+    const error = context.error;
+    const redactString = createReportStringRedactor(context, env);
+    const errorName = error instanceof Error ? error.name : typeof error;
+    const errorMessage = redactString(error instanceof Error ? error.message : String(error));
+    const structuredFields = error instanceof Error ? ownStructuredFields(error, redactString) : {};
+    const secretLines = Object.entries(context.command?.secrets ?? {}).map(([name, secret]) => {
+        const value = context.secrets?.[name] ?? env[secret.env];
+        return `${secret.env}=${redactValue(value)}`;
+    });
+    const lines = [
+        "Toolcraft Error Report",
+        "",
+        "Runtime",
+        `toolcraft version: ${resolveToolcraftVersion(context.version)}`,
+        `node version: ${process.version}`,
+        `platform: ${process.platform} ${process.arch}`,
+        "",
+        "Argv",
+        redactString(stableJson(redactArgv(context.argv, { command: context.command, secrets: context.secrets }))),
+        "",
+        "Resolved Secrets",
+        ...(secretLines.length === 0 ? ["<none>"] : secretLines),
+        "",
+        "Command Path",
+        context.commandPath === undefined || context.commandPath.length === 0
+            ? "root"
+            : context.commandPath,
+        "",
+        "Parsed Params",
+        redactString(stableJson(redactParams(context.params, context.command))),
+        "",
+        "Error",
+        `name: ${errorName}`,
+        `message: ${errorMessage}`,
+        "structured fields:",
+        redactString(stableJson(structuredFields)),
+        "",
+        "Stack",
+        formatStackChain(error, redactString)
+    ];
+    if (hasHttpContext(error)) {
+        lines.push("", "HTTP Transcript", formatHttpTranscript(error, redactString));
+    }
+    return `${lines.join("\n")}\n`;
+}
+export async function writeErrorReport(context) {
+    const env = context.env ?? process.env;
+    if (!reportsEnabled(context.errorReports, env) || isSkippedError(context.error)) {
+        return undefined;
+    }
+    const projectRoot = resolveProjectRoot(context.projectRoot);
+    const reportDir = resolveReportDir(context.errorReports, projectRoot);
+    const fileName = `${formatTimestamp(new Date())}-${slugifyCommandPath(context.commandPath)}-${randomUUID()}.log`;
+    const absolutePath = path.join(reportDir, fileName);
+    await mkdir(reportDir, { recursive: true });
+    if (reportDirMustStayWithinProject(context.errorReports)) {
+        await assertReportDirWithinProject(projectRoot, reportDir);
+    }
+    await writeFile(absolutePath, buildReport(context));
+    return {
+        absolutePath,
+        displayPath: relativeDisplayPath(projectRoot, absolutePath)
+    };
+}
+export { hasHttpContext };

package/node_modules/toolcraft/dist/http-errors.d.ts

@@ -0,0 +1,57 @@
+export interface HttpErrorRequest {
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    body?: unknown;
+}
+export interface HttpErrorResponse {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: unknown;
+}
+export declare class HttpError extends Error {
+    readonly status: number;
+    readonly statusText: string;
+    readonly code?: string;
+    readonly requestId?: string;
+    readonly request: HttpErrorRequest;
+    readonly response: HttpErrorResponse;
+    get body(): unknown;
+    constructor(args: {
+        request: HttpErrorRequest;
+        response: HttpErrorResponse;
+        code?: string;
+        requestId?: string;
+        message?: string;
+    });
+}
+export declare class ClientError extends HttpError {
+}
+export declare class BadRequestError extends ClientError {
+}
+export declare class AuthenticationError extends ClientError {
+}
+export declare class PermissionDeniedError extends ClientError {
+}
+export declare class NotFoundError extends ClientError {
+}
+export declare class ConflictError extends ClientError {
+}
+export declare class UnprocessableEntityError extends ClientError {
+}
+export declare class RateLimitError extends ClientError {
+}
+export declare class ServerError extends HttpError {
+}
+export declare class InternalServerError extends ServerError {
+}
+export declare class ServiceUnavailableError extends ServerError {
+}
+export declare function createHttpError(args: {
+    request: HttpErrorRequest;
+    response: HttpErrorResponse;
+    code?: string;
+    requestId?: string;
+    message?: string;
+}): HttpError;

package/node_modules/toolcraft/dist/http-errors.js

@@ -0,0 +1,72 @@
+export class HttpError extends Error {
+    status;
+    statusText;
+    code;
+    requestId;
+    request;
+    response;
+    get body() {
+        return this.response.body;
+    }
+    constructor(args) {
+        super(args.message ??
+            `${args.request.method} ${args.request.url} → ${args.response.status} ${args.response.statusText}`);
+        this.name = new.target.name;
+        this.status = args.response.status;
+        this.statusText = args.response.statusText;
+        this.code = args.code;
+        this.requestId = args.requestId;
+        this.request = args.request;
+        this.response = args.response;
+    }
+}
+export class ClientError extends HttpError {
+}
+export class BadRequestError extends ClientError {
+}
+export class AuthenticationError extends ClientError {
+}
+export class PermissionDeniedError extends ClientError {
+}
+export class NotFoundError extends ClientError {
+}
+export class ConflictError extends ClientError {
+}
+export class UnprocessableEntityError extends ClientError {
+}
+export class RateLimitError extends ClientError {
+}
+export class ServerError extends HttpError {
+}
+export class InternalServerError extends ServerError {
+}
+export class ServiceUnavailableError extends ServerError {
+}
+export function createHttpError(args) {
+    const ErrorClass = getHttpErrorClass(args.response.status);
+    return new ErrorClass(args);
+}
+function getHttpErrorClass(status) {
+    switch (status) {
+        case 400:
+            return BadRequestError;
+        case 401:
+            return AuthenticationError;
+        case 403:
+            return PermissionDeniedError;
+        case 404:
+            return NotFoundError;
+        case 409:
+            return ConflictError;
+        case 422:
+            return UnprocessableEntityError;
+        case 429:
+            return RateLimitError;
+        case 500:
+            return InternalServerError;
+        case 503:
+            return ServiceUnavailableError;
+        default:
+            return status >= 400 && status < 500 ? ClientError : status >= 500 ? ServerError : HttpError;
+    }
+}

package/node_modules/toolcraft/dist/human-in-loop/approval-tasks.d.ts

@@ -0,0 +1,32 @@
+import type { OpenTaskListOptions, TaskList, Tasks } from "@poe-code/task-list";
+import type { HumanInLoopPending, HumanInLoopRuntimeOptions } from "./types.js";
+export interface ApprovalPayload {
+    approvalId?: string;
+    commandPath: string;
+    params: Record<string, unknown>;
+    message: string;
+    declineInputPrompt?: string | null;
+    enqueuedAt?: string;
+    pid?: number | null;
+    result?: unknown;
+    error?: unknown;
+}
+export declare function ensureApprovalList(runtimeOptions: HumanInLoopRuntimeOptions | undefined, deps?: {
+    create?: boolean;
+    openTaskList?: (options: OpenTaskListOptions) => Promise<TaskList>;
+}): Promise<{
+    taskList: TaskList;
+    listName: string;
+    tasks: Tasks;
+}>;
+export declare function enqueueApproval(ctx: {
+    tasks: Tasks;
+    payload: ApprovalPayload;
+}): Promise<{
+    approvalId: string;
+    pending: HumanInLoopPending;
+}>;
+export declare function loadApproval(ctx: {
+    tasks: Tasks;
+    approvalId: string;
+}): Promise<ApprovalPayload | undefined>;