@kamilio/wire 0.1.0

package/node_modules/toolcraft/dist/number-schema.d.ts

@@ -0,0 +1,3 @@
+import type { NumberSchema } from "toolcraft-schema";
+export declare function isValidNumberSchemaValue(value: unknown, schema: NumberSchema): value is number;
+export declare function getExpectedNumberDescription(schema: NumberSchema): string;

package/node_modules/toolcraft/dist/number-schema.js

@@ -0,0 +1,15 @@
+export function isValidNumberSchemaValue(value, schema) {
+    return (typeof value === "number" &&
+        Number.isFinite(value) &&
+        (schema.jsonType !== "integer" || Number.isInteger(value)) &&
+        (schema.minimum === undefined || value >= schema.minimum) &&
+        (schema.maximum === undefined || value <= schema.maximum));
+}
+export function getExpectedNumberDescription(schema) {
+    const type = schema.jsonType === "integer" ? "an integer" : "a number";
+    const bounds = [
+        schema.minimum === undefined ? undefined : `greater than or equal to ${schema.minimum}`,
+        schema.maximum === undefined ? undefined : `less than or equal to ${schema.maximum}`
+    ].filter((bound) => bound !== undefined);
+    return bounds.length === 0 ? type : `${type} ${bounds.join(" and ")}`;
+}

package/node_modules/toolcraft/dist/package-metadata.d.ts

@@ -0,0 +1,10 @@
+export interface PackageMetadata {
+    name?: string;
+    path: string;
+    version?: string;
+}
+type PackageMetadataInput = string | URL;
+export declare function findPackageMetadata(from: PackageMetadataInput): PackageMetadata | undefined;
+export declare function packageMetadata(from?: PackageMetadataInput): PackageMetadata;
+export declare function findEntrypointPackageMetadata(entrypoint: string | undefined): PackageMetadata | undefined;
+export {};

package/node_modules/toolcraft/dist/package-metadata.js

@@ -0,0 +1,62 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function pathFromInput(from) {
+    if (from instanceof URL) {
+        return fileURLToPath(from);
+    }
+    if (from.startsWith("file:")) {
+        return fileURLToPath(from);
+    }
+    return path.resolve(from);
+}
+function getSearchDirectory(from) {
+    const resolved = pathFromInput(from);
+    try {
+        return statSync(resolved).isDirectory() ? resolved : path.dirname(resolved);
+    }
+    catch {
+        return path.dirname(resolved);
+    }
+}
+function readPackageMetadata(packageJsonPath) {
+    const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    const metadata = { path: packageJsonPath };
+    if (typeof parsed.name === "string") {
+        metadata.name = parsed.name;
+    }
+    if (typeof parsed.version === "string") {
+        metadata.version = parsed.version;
+    }
+    return metadata;
+}
+export function findPackageMetadata(from) {
+    let current = getSearchDirectory(from);
+    while (true) {
+        const packageJsonPath = path.join(current, "package.json");
+        if (existsSync(packageJsonPath)) {
+            return readPackageMetadata(packageJsonPath);
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return undefined;
+        }
+        current = parent;
+    }
+}
+export function packageMetadata(from = process.cwd()) {
+    const metadata = findPackageMetadata(from);
+    if (metadata === undefined) {
+        throw new Error(`No package.json found from ${pathFromInput(from)}.`);
+    }
+    return metadata;
+}
+export function findEntrypointPackageMetadata(entrypoint) {
+    if (entrypoint === undefined || entrypoint.length === 0) {
+        return undefined;
+    }
+    if (!path.isAbsolute(entrypoint) && !entrypoint.startsWith("file:")) {
+        return undefined;
+    }
+    return findPackageMetadata(entrypoint);
+}

package/node_modules/toolcraft/dist/redaction.d.ts

@@ -0,0 +1,4 @@
+export declare function isSensitiveName(name: string): boolean;
+export declare function redactSecretLikeFields(value: unknown, name?: string): unknown;
+export declare function redactHttpBody(body: unknown): unknown;
+export declare function redactHttpHeaderValue(name: string, value: string): string;

package/node_modules/toolcraft/dist/redaction.js

@@ -0,0 +1,70 @@
+const REDACTED_VALUE = "<redacted>";
+const SENSITIVE_NAME_PARTS = ["password", "token", "apikey", "secret"];
+const AUTHORIZATION_HEADER_NAMES = new Set(["authorization", "proxyauthorization"]);
+const SECRET_HEADER_NAMES = new Set(["cookie", "setcookie"]);
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeName(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+export function isSensitiveName(name) {
+    const normalized = normalizeName(name);
+    return SENSITIVE_NAME_PARTS.some((candidate) => normalized.includes(candidate));
+}
+function redactSecretLikeFieldsValue(value, name, seen) {
+    if (name.length > 0 && isSensitiveName(name)) {
+        return REDACTED_VALUE;
+    }
+    if (Array.isArray(value)) {
+        if (seen.has(value)) {
+            return "[Circular]";
+        }
+        seen.add(value);
+        return value.map((entry) => redactSecretLikeFieldsValue(entry, name, seen));
+    }
+    if (isPlainObject(value)) {
+        if (seen.has(value)) {
+            return "[Circular]";
+        }
+        seen.add(value);
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+            key,
+            redactSecretLikeFieldsValue(entry, key, seen)
+        ]));
+    }
+    return value;
+}
+export function redactSecretLikeFields(value, name = "") {
+    return redactSecretLikeFieldsValue(value, name, new WeakSet());
+}
+function parseJsonObjectOrArray(value) {
+    const trimmed = value.trim();
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        return isPlainObject(parsed) || Array.isArray(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function redactHttpBody(body) {
+    if (typeof body === "string") {
+        const parsed = parseJsonObjectOrArray(body);
+        return parsed === undefined ? body : redactSecretLikeFields(parsed);
+    }
+    return redactSecretLikeFields(body);
+}
+export function redactHttpHeaderValue(name, value) {
+    const normalized = normalizeName(name);
+    if (AUTHORIZATION_HEADER_NAMES.has(normalized)) {
+        return "Bearer ****";
+    }
+    if (SECRET_HEADER_NAMES.has(normalized) || isSensitiveName(name)) {
+        return REDACTED_VALUE;
+    }
+    return value;
+}

package/node_modules/toolcraft/dist/renderer.d.ts

@@ -0,0 +1,11 @@
+import type { Command, RenderPrimitives } from "./index.js";
+export type OutputMode = "rich" | "md" | "json";
+type WriteStream = "stdout" | "stderr";
+type WriteFn = (chunk: string, stream?: WriteStream) => void;
+export interface RenderResultStatus {
+    mcpError: boolean;
+}
+export declare function renderObjectTable(result: Record<string, unknown>, primitives: RenderPrimitives): string;
+export declare function renderArrayTable(result: Array<Record<string, unknown>>, primitives: RenderPrimitives): string;
+export declare function renderResult(command: Command<any, any, any, any>, result: unknown, output: OutputMode, primitives: RenderPrimitives, write?: WriteFn): RenderResultStatus;
+export {};

package/node_modules/toolcraft/dist/renderer.js

@@ -0,0 +1,348 @@
+import YAML from "yaml";
+import { renderDetailCard } from "toolcraft-design";
+function isObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isMcpCallToolResult(value) {
+    if (!isObject(value)) {
+        return false;
+    }
+    const hasContent = Array.isArray(value.content);
+    const hasStructured = value.structuredContent !== undefined;
+    if (!hasContent && !hasStructured) {
+        return false;
+    }
+    return Object.keys(value).every((key) => key === "content" || key === "structuredContent" || key === "isError" || key === "_meta");
+}
+function isMcpTextContent(value) {
+    return isObject(value) && value.type === "text" && typeof value.text === "string";
+}
+function extractMcpPayload(envelope) {
+    const structuredContent = envelope.structuredContent;
+    if (isObject(structuredContent) && "result" in structuredContent) {
+        return structuredContent.result;
+    }
+    if (structuredContent !== undefined) {
+        return structuredContent;
+    }
+    if (Array.isArray(envelope.content)) {
+        const text = envelope.content
+            .filter(isMcpTextContent)
+            .map((block) => block.text)
+            .join("\n");
+        return text.length > 0 ? text : undefined;
+    }
+    return undefined;
+}
+function unwrapMcpEnvelope(result) {
+    if (!isMcpCallToolResult(result)) {
+        return { result, mcpError: false };
+    }
+    return {
+        result: extractMcpPayload(result),
+        mcpError: result.isError === true,
+    };
+}
+function isArrayOfObjects(value) {
+    return Array.isArray(value) && value.every((entry) => isObject(entry));
+}
+function isNonEmptyArrayOfObjects(value) {
+    return Array.isArray(value) && value.length > 0 && value.every((entry) => isObject(entry));
+}
+function stringifyValue(value) {
+    if (value === undefined) {
+        return "";
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    return stringifyJson(value);
+}
+function stringifyJson(value, spaces) {
+    try {
+        return JSON.stringify(value, (_key, currentValue) => (typeof currentValue === "bigint" ? currentValue.toString() : currentValue), spaces) ?? String(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function humanizeKey(key) {
+    let output = "";
+    let capitalizeNext = true;
+    for (const char of key) {
+        if (char === "_" || char === "-") {
+            output += " ";
+            capitalizeNext = false;
+            continue;
+        }
+        if (char >= "A" && char <= "Z" && output.length > 0 && !output.endsWith(" ")) {
+            output += " ";
+        }
+        if (capitalizeNext) {
+            output += char.toUpperCase();
+            capitalizeNext = false;
+            continue;
+        }
+        output += char;
+    }
+    return output;
+}
+function detailRows(result, depth = 0) {
+    const rows = [];
+    for (const [key, value] of Object.entries(result)) {
+        const label = `${"  ".repeat(depth)}${humanizeKey(key)}`;
+        if (isObject(value)) {
+            if (Object.keys(value).length === 0) {
+                rows.push({ label, value: "{}" });
+                continue;
+            }
+            rows.push({ label, value: "" });
+            rows.push(...detailRows(value, depth + 1));
+            continue;
+        }
+        if (isNonEmptyArrayOfObjects(value)) {
+            rows.push({ label, value: "" });
+            rows.push(...arrayObjectDetailRows(value, depth + 1));
+            continue;
+        }
+        rows.push({ label, value: displayScalar(value) });
+    }
+    return rows;
+}
+function arrayObjectDetailRows(value, depth) {
+    return value.flatMap((entry, index) => {
+        if (value.length === 1) {
+            return detailRows(entry, depth);
+        }
+        return [
+            { label: `${"  ".repeat(depth)}${index + 1}`, value: "" },
+            ...detailRows(entry, depth + 1)
+        ];
+    });
+}
+function displayScalar(value) {
+    if (typeof value === "boolean") {
+        return value ? "Yes" : "No";
+    }
+    if (Array.isArray(value) && value.every((entry) => !isObject(entry) && !Array.isArray(entry))) {
+        return value.map((entry) => displayScalar(entry)).join(", ") || "—";
+    }
+    return stringifyValue(value) || "—";
+}
+function isUrl(value) {
+    return typeof value === "string" && (value.startsWith("https://") || value.startsWith("http://"));
+}
+function compactUrl(value) {
+    try {
+        const url = new URL(value);
+        const tail = url.pathname.split("/").filter(Boolean).at(-1);
+        return tail ? `${url.hostname}/…/${tail}` : url.hostname;
+    }
+    catch {
+        return value;
+    }
+}
+function displayRowValue(value) {
+    return isUrl(value) ? compactUrl(value) : displayScalar(value);
+}
+function directScalarRows(result) {
+    return Object.entries(result)
+        .filter(([, value]) => !isObject(value) && !Array.isArray(value))
+        .map(([key, value]) => ({ label: humanizeKey(key), value: displayRowValue(value) }));
+}
+function directObjectSections(result) {
+    return Object.entries(result)
+        .filter(([, value]) => isObject(value))
+        .map(([key, value]) => ({ title: humanizeKey(key), rows: detailRows(value) }))
+        .filter((section) => section.rows.length > 0);
+}
+function directArrayObjectSections(result) {
+    return Object.entries(result).flatMap(([key, value]) => {
+        if (!isNonEmptyArrayOfObjects(value)) {
+            return [];
+        }
+        const title = humanizeKey(key);
+        return value
+            .map((entry, index) => ({
+            title: value.length === 1 ? title : `${title} ${index + 1}`,
+            rows: detailRows(entry)
+        }))
+            .filter((section) => section.rows.length > 0);
+    });
+}
+function renderObjectCard(result, primitives, title) {
+    const scalarRows = directScalarRows(result);
+    const nestedSections = directObjectSections(result);
+    const arrayObjectSections = directArrayObjectSections(result);
+    const listRows = Object.entries(result)
+        .filter(([, value]) => Array.isArray(value) && !isNonEmptyArrayOfObjects(value))
+        .map(([key, value]) => ({ label: humanizeKey(key), value: displayScalar(value) }));
+    return renderDetailCard({
+        theme: primitives.getTheme(),
+        title,
+        sections: [
+            { rows: scalarRows },
+            ...nestedSections,
+            { title: "Lists", rows: listRows },
+            ...arrayObjectSections
+        ]
+    });
+}
+function richResultTitle(command) {
+    const description = command.description?.trim();
+    if (description && !description.includes("\n") && description.length <= 64) {
+        return description;
+    }
+    return command.name ? humanizeKey(command.name) : "Result";
+}
+export function renderObjectTable(result, primitives) {
+    const rows = detailRows(result);
+    if (rows.length === 0) {
+        return "{}";
+    }
+    return primitives.renderTable({
+        theme: primitives.getTheme(),
+        variant: "detail",
+        columns: [
+            {
+                name: "label",
+                title: "Label",
+                alignment: "left",
+                maxLen: Math.max("Label".length, ...rows.map((row) => row.label.length)),
+            },
+            {
+                name: "value",
+                title: "Value",
+                alignment: "left",
+                maxLen: Math.max("Value".length, ...rows.map((row) => row.value.length)),
+            },
+        ],
+        rows,
+    });
+}
+function renderObjectMarkdown(result) {
+    return Object.entries(result)
+        .map(([key, value]) => `- ${key}: ${stringifyValue(value)}`)
+        .join("\n");
+}
+function getColumnNames(rows) {
+    const names = new Set();
+    for (const row of rows) {
+        for (const name of Object.keys(row)) {
+            names.add(name);
+        }
+    }
+    return [...names];
+}
+export function renderArrayTable(result, primitives) {
+    if (result.length === 0) {
+        return "[]";
+    }
+    const columnNames = getColumnNames(result);
+    return primitives.renderTable({
+        theme: primitives.getTheme(),
+        columns: columnNames.map((name) => ({
+            name,
+            title: name,
+            alignment: "left",
+            maxLen: Math.max(name.length, ...result.map((row) => Object.prototype.hasOwnProperty.call(row, name) ? stringifyValue(row[name]).length : 0)),
+        })),
+        rows: result.map((row) => Object.fromEntries(columnNames.map((name) => [
+            name,
+            Object.prototype.hasOwnProperty.call(row, name) ? stringifyValue(row[name]) : ""
+        ]))),
+    });
+}
+function renderArrayMarkdown(result) {
+    if (result.length === 0) {
+        return "[]";
+    }
+    const columnNames = getColumnNames(result);
+    const header = `| ${columnNames.join(" | ")} |`;
+    const separator = `| ${columnNames.map(() => ":---").join(" | ")} |`;
+    const rows = result.map((row) => `| ${columnNames
+        .map((name) => Object.prototype.hasOwnProperty.call(row, name)
+        ? stringifyValue(row[name]).replaceAll("|", "\\|")
+        : "")
+        .join(" | ")} |`);
+    return [header, separator, ...rows].join("\n");
+}
+function autoRender(command, result, output, primitives) {
+    if (result === null || result === undefined) {
+        if (output === "json") {
+            return stringifyJson({ ok: true }, 2);
+        }
+        return "Done.";
+    }
+    if (typeof result === "string") {
+        if (output === "json") {
+            return stringifyJson({ result }, 2);
+        }
+        return result;
+    }
+    if (output === "rich" && Array.isArray(result) && result.every((value) => typeof value === "string")) {
+        return result.join("\n");
+    }
+    if (isObject(result)) {
+        if (output === "md") {
+            return renderObjectMarkdown(result);
+        }
+        if (output === "json") {
+            return stringifyJson(result, 2);
+        }
+        return renderObjectCard(result, primitives, richResultTitle(command));
+    }
+    if (isArrayOfObjects(result)) {
+        if (output === "md") {
+            return renderArrayMarkdown(result);
+        }
+        if (output === "json") {
+            return stringifyJson(result, 2);
+        }
+        return renderArrayTable(result, primitives);
+    }
+    if (output === "rich") {
+        return YAML.stringify(result);
+    }
+    return stringifyJson(result, 2);
+}
+export function renderResult(command, result, output, primitives, write = (chunk, stream = "stdout") => {
+    if (stream === "stderr") {
+        process.stderr.write(chunk);
+        return;
+    }
+    process.stdout.write(chunk);
+}) {
+    const unwrapped = unwrapMcpEnvelope(result);
+    result = unwrapped.result;
+    if (unwrapped.mcpError) {
+        const payload = autoRender(command, result, output, primitives);
+        if (payload.length > 0) {
+            write(`${payload}\n`, "stderr");
+        }
+        return { mcpError: true };
+    }
+    if (output === "json" && command.render?.json) {
+        const payload = command.render.json(result, primitives);
+        if (payload !== undefined) {
+            write(`${stringifyJson(payload, 2)}\n`);
+        }
+        return { mcpError: false };
+    }
+    if (output === "md" && command.render?.markdown) {
+        const payload = command.render.markdown(result, primitives);
+        if (typeof payload === "string" && payload.length > 0) {
+            write(`${payload}\n`);
+        }
+        return { mcpError: false };
+    }
+    if (output === "rich" && command.render?.rich) {
+        command.render.rich(result, primitives);
+        return { mcpError: false };
+    }
+    const payload = autoRender(command, result, output, primitives);
+    if (payload.length > 0) {
+        write(`${payload}\n`);
+    }
+    return { mcpError: false };
+}

package/node_modules/toolcraft/dist/runtime-logging.d.ts

@@ -0,0 +1,19 @@
+export type LogLevel = "silent" | "error" | "warn" | "info" | "debug" | "trace";
+export interface DiagnosticLogEvent {
+    level: Exclude<LogLevel, "silent">;
+    message: string;
+    category?: "runtime" | "http" | "auth" | "retry" | "progress";
+    data?: Record<string, unknown>;
+}
+export interface RuntimeLogger {
+    level: LogLevel;
+    emit(event: DiagnosticLogEvent): void;
+}
+export type RuntimeLoggerInput = RuntimeLogger | ((event: DiagnosticLogEvent) => void);
+export declare const LOG_LEVELS: readonly ["silent", "error", "warn", "info", "debug", "trace"];
+export declare function isLogLevel(value: string): value is LogLevel;
+export declare function shouldEmitDiagnostic(eventLevel: LogLevel, configuredLevel: LogLevel): boolean;
+export declare function createRuntimeLogger(options?: {
+    level?: LogLevel;
+    logger?: RuntimeLoggerInput;
+}): RuntimeLogger;

package/node_modules/toolcraft/dist/runtime-logging.js

@@ -0,0 +1,42 @@
+const LOG_LEVEL_RANK = {
+    silent: 0,
+    error: 1,
+    warn: 2,
+    info: 3,
+    debug: 4,
+    trace: 5
+};
+export const LOG_LEVELS = Object.freeze([
+    "silent",
+    "error",
+    "warn",
+    "info",
+    "debug",
+    "trace"
+]);
+export function isLogLevel(value) {
+    return LOG_LEVELS.includes(value);
+}
+export function shouldEmitDiagnostic(eventLevel, configuredLevel) {
+    if (eventLevel === "silent" || configuredLevel === "silent") {
+        return false;
+    }
+    return LOG_LEVEL_RANK[eventLevel] <= LOG_LEVEL_RANK[configuredLevel];
+}
+export function createRuntimeLogger(options = {}) {
+    const level = options.level ?? "warn";
+    const sink = options.logger;
+    return {
+        level,
+        emit(event) {
+            if (!shouldEmitDiagnostic(event.level, level)) {
+                return;
+            }
+            if (typeof sink === "function") {
+                sink(event);
+                return;
+            }
+            sink?.emit(event);
+        }
+    };
+}

package/node_modules/toolcraft/dist/schema-scope.d.ts

@@ -0,0 +1,4 @@
+import type { AnySchema } from "toolcraft-schema";
+type SchemaScope = "cli" | "mcp" | "sdk";
+export declare function filterSchemaForScope(schema: AnySchema, scope: SchemaScope): AnySchema | undefined;
+export {};

package/node_modules/toolcraft/dist/schema-scope.js

@@ -0,0 +1,55 @@
+export function filterSchemaForScope(schema, scope) {
+    if (schema.scope !== undefined && !schema.scope.includes(scope)) {
+        return undefined;
+    }
+    switch (schema.kind) {
+        case "optional": {
+            const inner = filterSchemaForScope(schema.inner, scope);
+            if (inner === undefined) {
+                return undefined;
+            }
+            if (inner.requiredScopes?.includes(scope)) {
+                return inner;
+            }
+            return { ...schema, inner };
+        }
+        case "array": {
+            const item = filterSchemaForScope(schema.item, scope);
+            return item === undefined ? undefined : { ...schema, item };
+        }
+        case "string":
+        case "number":
+        case "boolean":
+        case "enum":
+        case "json":
+            return schema;
+        case "record": {
+            const value = filterSchemaForScope(schema.value, scope);
+            return value === undefined ? undefined : { ...schema, value };
+        }
+        case "oneOf":
+            return {
+                ...schema,
+                branches: Object.fromEntries(Object.entries(schema.branches).flatMap(([name, branch]) => {
+                    const filtered = filterSchemaForScope(branch, scope);
+                    return filtered?.kind === "object" ? [[name, filtered]] : [];
+                }))
+            };
+        case "union":
+            return {
+                ...schema,
+                branches: schema.branches.flatMap((branch) => {
+                    const filtered = filterSchemaForScope(branch, scope);
+                    return filtered?.kind === "object" ? [filtered] : [];
+                })
+            };
+        case "object":
+            return {
+                ...schema,
+                shape: Object.fromEntries(Object.entries(schema.shape).flatMap(([key, childSchema]) => {
+                    const filtered = filterSchemaForScope(childSchema, scope);
+                    return filtered === undefined ? [] : [[key, filtered]];
+                }))
+            };
+    }
+}

package/node_modules/toolcraft/dist/sdk.compile-check.d.ts

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