@kamilio/wire 0.1.8 → 0.1.10

package/node_modules/toolcraft/node_modules/mcp-oauth/dist/client/loopback-authorization.js

@@ -1,207 +0,0 @@
-import http from "node:http";
-import { parseAuthorizationState } from "./authorization-state.js";
-export async function createLoopbackAuthorizationSession(options = {}) {
-    const callbackPath = options.callbackPath ?? "/callback";
-    const server = options.createServer ? options.createServer() : http.createServer();
-    const port = await startServer(server);
-    const redirectUri = `http://127.0.0.1:${port}${callbackPath}`;
-    return {
-        redirectUri,
-        async waitForCode(authorizationUrl) {
-            return waitForAuthorizationCode(server, authorizationUrl, options, callbackPath);
-        },
-        close() {
-            server.closeAllConnections?.();
-            server.close();
-        }
-    };
-}
-async function startServer(server) {
-    return new Promise((resolve, reject) => {
-        const handleError = (error) => {
-            server.off("error", handleError);
-            reject(error);
-        };
-        server.once("error", handleError);
-        server.listen(0, "127.0.0.1", () => {
-            server.off("error", handleError);
-            const address = server.address();
-            resolve(address.port);
-        });
-    });
-}
-function waitForAuthorizationCode(server, authorizationUrl, options, callbackPath) {
-    const expectedAuthorization = readExpectedAuthorizationCallback(authorizationUrl);
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        const settle = (fn) => {
-            if (!settled) {
-                settled = true;
-                fn();
-            }
-        };
-        server.on("request", (req, res) => {
-            const url = new URL(req.url ?? "/", "http://127.0.0.1");
-            if (url.pathname !== callbackPath) {
-                res.writeHead(404);
-                res.end("Not found");
-                return;
-            }
-            const callbackParameters = {
-                code: url.searchParams.get("code"),
-                error: url.searchParams.get("error"),
-                errorDescription: url.searchParams.get("error_description"),
-                state: url.searchParams.get("state"),
-                iss: url.searchParams.get("iss")
-            };
-            try {
-                validateAuthorizationCallbackBinding(callbackParameters, expectedAuthorization);
-            }
-            catch (error) {
-                res.writeHead(400);
-                res.end(error instanceof Error ? error.message : "Invalid OAuth callback");
-                settle(() => reject(error instanceof Error ? error : new Error(String(error))));
-                return;
-            }
-            const authorizationError = callbackParameters.error;
-            if (authorizationError !== null) {
-                const description = callbackParameters.errorDescription ?? authorizationError;
-                res.writeHead(400);
-                res.end(`Authorization failed: ${description}`);
-                settle(() => reject(createAuthorizationError(authorizationError, description)));
-                return;
-            }
-            try {
-                const code = validateAuthorizationCallbackParameters(callbackParameters, expectedAuthorization);
-                res.writeHead(200, { "Content-Type": "text/html" });
-                res.end(buildSuccessPage(options.landingPage));
-                settle(() => resolve(code));
-            }
-            catch (error) {
-                res.writeHead(400);
-                res.end(error instanceof Error ? error.message : "Invalid OAuth callback");
-                settle(() => reject(error instanceof Error ? error : new Error(String(error))));
-            }
-        });
-        if (options.readLine !== undefined) {
-            options
-                .readLine()
-                .then((input) => {
-                const callbackParameters = extractCallbackParametersFromInput(input);
-                if (callbackParameters === null) {
-                    settle(() => reject(new Error("OAuth callback missing authorization code")));
-                    return;
-                }
-                try {
-                    validateAuthorizationCallbackBinding(callbackParameters, expectedAuthorization);
-                    if (callbackParameters.error !== null) {
-                        const description = callbackParameters.errorDescription ?? callbackParameters.error;
-                        throw createAuthorizationError(callbackParameters.error, description);
-                    }
-                    const code = validateAuthorizationCallbackParameters(callbackParameters, expectedAuthorization);
-                    settle(() => resolve(code));
-                }
-                catch (error) {
-                    settle(() => reject(error instanceof Error ? error : new Error(String(error))));
-                }
-            })
-                .catch((error) => {
-                settle(() => reject(error instanceof Error ? error : new Error(String(error))));
-            });
-        }
-        if (options.openBrowser !== undefined) {
-            options.openBrowser(authorizationUrl).catch((error) => {
-                settle(() => reject(error));
-            });
-        }
-    });
-}
-export function extractCodeFromInput(input) {
-    return extractCallbackParametersFromInput(input)?.code ?? null;
-}
-function extractCallbackParametersFromInput(input) {
-    const trimmed = input.replaceAll("\r", "").replaceAll("\n", "").trim();
-    if (trimmed.length === 0) {
-        return null;
-    }
-    try {
-        const url = new URL(trimmed);
-        return {
-            code: url.searchParams.get("code"),
-            error: url.searchParams.get("error"),
-            errorDescription: url.searchParams.get("error_description"),
-            state: url.searchParams.get("state"),
-            iss: url.searchParams.get("iss")
-        };
-    }
-    catch {
-        return {
-            code: trimmed,
-            error: null,
-            errorDescription: null,
-            state: null,
-            iss: null
-        };
-    }
-}
-function readExpectedAuthorizationCallback(authorizationUrl) {
-    const url = new URL(authorizationUrl);
-    const state = url.searchParams.get("state");
-    const parsedState = parseAuthorizationState(state);
-    return {
-        state,
-        issuer: parsedState?.issuer ?? null,
-        requireIssuer: parsedState?.requireIssuer ?? false
-    };
-}
-function validateAuthorizationCallbackParameters(callback, expected) {
-    validateAuthorizationCallbackBinding(callback, expected);
-    if (callback.code === null || callback.code.length === 0) {
-        throw new Error("OAuth callback missing authorization code");
-    }
-    return callback.code;
-}
-function validateAuthorizationCallbackBinding(callback, expected) {
-    if (expected.state !== null) {
-        if (callback.state === null || callback.state.length === 0) {
-            throw new Error("OAuth callback missing state");
-        }
-        if (callback.state !== expected.state) {
-            throw new Error("OAuth callback state mismatch");
-        }
-    }
-    if (expected.requireIssuer) {
-        if (callback.iss === null || callback.iss.length === 0) {
-            throw new Error("OAuth callback missing issuer");
-        }
-    }
-    if (callback.iss !== null &&
-        callback.iss.length > 0 &&
-        expected.issuer !== null &&
-        callback.iss !== expected.issuer) {
-        throw new Error("OAuth callback issuer mismatch");
-    }
-}
-function createAuthorizationError(error, description) {
-    return new Error(`OAuth authorization failed: ${error} — ${description}`);
-}
-function escapeHtml(text) {
-    return text
-        .replaceAll("&", "&")
-        .replaceAll("<", "&lt;")
-        .replaceAll(">", "&gt;")
-        .replaceAll('"', "&quot;");
-}
-export function buildSuccessPage(landingPage) {
-    const title = landingPage?.title ?? "Connected";
-    const body = landingPage?.body ?? "You can close this tab and return to your terminal.";
-    return [
-        "<!DOCTYPE html>",
-        `<html><head><meta charset=utf-8><title>${escapeHtml(title)}</title></head>`,
-        '<body style="font-family:system-ui,sans-serif;display:flex;align-items:center;justify-content:center;min-height:100vh;margin:0">',
-        '<div style="text-align:center">',
-        `<h1>${escapeHtml(title)}</h1>`,
-        `<p style="color:#666">${escapeHtml(body)}</p>`,
-        "</div></body></html>"
-    ].join("");
-}

package/node_modules/toolcraft/node_modules/mcp-oauth/dist/client/pkce.js

@@ -1,7 +0,0 @@
-import crypto from "node:crypto";
-export function generateCodeVerifier() {
-    return crypto.randomBytes(32).toString("base64url");
-}
-export function generateCodeChallenge(verifier) {
-    return crypto.createHash("sha256").update(verifier).digest("base64url");
-}

package/node_modules/toolcraft/node_modules/mcp-oauth/dist/client/types.d.ts

@@ -1,113 +0,0 @@
-import type http from "node:http";
-import type { CreateSecretStoreInput } from "auth-store";
-export type OAuthMetadataFetch = (input: string | URL, init?: RequestInit) => Promise<Response>;
-export interface OAuthProtectedResourceMetadata extends Record<string, unknown> {
-    resource: string;
-    authorization_servers: string[];
-}
-export interface OAuthAuthorizationServerMetadata extends Record<string, unknown> {
-    issuer: string;
-    authorization_endpoint: string;
-    token_endpoint: string;
-    registration_endpoint?: string;
-    response_types_supported: string[];
-    code_challenge_methods_supported: string[];
-    authorization_response_iss_parameter_supported?: boolean;
-}
-export interface OAuthDiscoveryResult {
-    resource: string;
-    resourceMetadataUrl: string;
-    resourceMetadata: OAuthProtectedResourceMetadata;
-    authorizationServer: string;
-    authorizationServerMetadataUrl: string;
-    authorizationServerMetadata: OAuthAuthorizationServerMetadata;
-}
-export interface OAuthUnauthorizedChallenge {
-    scheme: "Bearer";
-    params: Record<string, string>;
-    raw: string;
-}
-export interface OAuthClientProvider {
-    authorizeRequest?(input: {
-        requestUrl: URL;
-        headers: Headers;
-        fetch: OAuthMetadataFetch;
-    }): Promise<void> | void;
-    handleUnauthorized(input: {
-        requestUrl: URL;
-        response: Response;
-        challenge: OAuthUnauthorizedChallenge | null;
-        discovery: OAuthDiscoveryResult;
-        fetch: OAuthMetadataFetch;
-    }): Promise<{
-        action: "retry";
-    } | {
-        action: "fail";
-        error?: Error;
-    }> | {
-        action: "retry";
-    } | {
-        action: "fail";
-        error?: Error;
-    };
-}
-export interface OAuthClientMetadata {
-    clientName?: string;
-    scope?: string;
-    softwareId?: string;
-    softwareVersion?: string;
-}
-export interface StoredOAuthTokens {
-    accessToken: string;
-    refreshToken?: string;
-    tokenType: "Bearer";
-    expiresAt: number | null;
-    scope?: string;
-}
-export interface StoredOAuthSession {
-    resource: string;
-    authorizationServer: string;
-    client: {
-        clientId: string;
-        clientSecret?: string;
-    };
-    tokens?: StoredOAuthTokens;
-    discovery: {
-        resourceMetadataUrl: string;
-        resourceMetadata: Record<string, unknown>;
-        authorizationServerMetadata: Record<string, unknown>;
-    };
-}
-export interface OAuthSessionStore {
-    load(resource: string): Promise<StoredOAuthSession | null>;
-    save(resource: string, session: StoredOAuthSession): Promise<void>;
-    clear(resource: string): Promise<void>;
-}
-export interface DefaultOAuthClientProviderOptions {
-    client: {
-        mode: "dynamic";
-        clientId?: string;
-        clientSecret?: string;
-        metadata?: OAuthClientMetadata;
-    } | {
-        mode: "static";
-        clientId: string;
-        clientSecret?: string;
-        metadata?: OAuthClientMetadata;
-    };
-    browser: {
-        openBrowser(url: string): Promise<void>;
-        readLine?: () => Promise<string>;
-        createServer?: () => http.Server;
-        landingPage?: {
-            title: string;
-            body: string;
-        };
-    };
-    sessionStore?: OAuthSessionStore;
-    authStore?: CreateSecretStoreInput;
-    now?: () => number;
-}
-export type OAuthClientProviderOptions = {
-    provider: OAuthClientProvider;
-} | DefaultOAuthClientProviderOptions;

package/node_modules/toolcraft/node_modules/mcp-oauth/dist/index.d.ts

@@ -1,10 +0,0 @@
-export { createAuthStoreSessionStore, } from "./client/auth-store-session-store.js";
-export { createDefaultOAuthClientProvider, createOAuthClientProvider, } from "./client/default-oauth-client-provider.js";
-export { buildSuccessPage, createLoopbackAuthorizationSession, extractCodeFromInput, } from "./client/loopback-authorization.js";
-export { generateCodeChallenge, generateCodeVerifier, } from "./client/pkce.js";
-export { OAuthError, } from "./client/token-endpoint.js";
-export { canonicalizeResourceIndicator, } from "./resource-indicator.js";
-export { createJwksTokenVerifier, } from "./server/jwks-token-verifier.js";
-export type { DefaultOAuthClientProviderOptions, OAuthAuthorizationServerMetadata, OAuthClientMetadata, OAuthClientProvider, OAuthClientProviderOptions, OAuthDiscoveryResult, OAuthMetadataFetch, OAuthProtectedResourceMetadata, OAuthSessionStore, OAuthUnauthorizedChallenge, StoredOAuthSession, StoredOAuthTokens, } from "./client/types.js";
-export type { JwksTokenVerifier, JwksTokenVerifierOptions, JwksVerifiedAccessToken, } from "./server/jwks-token-verifier.js";
-export type { LoopbackAuthorizationOptions, LoopbackAuthorizationSession, OAuthLandingPage, } from "./client/loopback-authorization.js";

package/node_modules/toolcraft/node_modules/mcp-oauth/dist/index.js

@@ -1,7 +0,0 @@
-export { createAuthStoreSessionStore, } from "./client/auth-store-session-store.js";
-export { createDefaultOAuthClientProvider, createOAuthClientProvider, } from "./client/default-oauth-client-provider.js";
-export { buildSuccessPage, createLoopbackAuthorizationSession, extractCodeFromInput, } from "./client/loopback-authorization.js";
-export { generateCodeChallenge, generateCodeVerifier, } from "./client/pkce.js";
-export { OAuthError, } from "./client/token-endpoint.js";
-export { canonicalizeResourceIndicator, } from "./resource-indicator.js";
-export { createJwksTokenVerifier, } from "./server/jwks-token-verifier.js";

package/node_modules/toolcraft/node_modules/mcp-oauth/dist/server/jwks-token-verifier.js

@@ -1,304 +0,0 @@
-import { decodeProtectedHeader, errors, importJWK, jwtVerify, } from "jose";
-import { canonicalizeResourceIndicator } from "../resource-indicator.js";
-const DEFAULT_ALLOWED_ALGORITHMS = [
-    "ES256",
-    "ES384",
-    "ES512",
-    "RS256",
-    "RS384",
-    "RS512",
-    "PS256",
-    "PS384",
-    "PS512",
-    "EdDSA",
-];
-function isTokenVerificationErrorShape(error) {
-    if (!(error instanceof Error)) {
-        return false;
-    }
-    const challengeError = error;
-    return challengeError.error === "invalid_token"
-        || challengeError.error === "insufficient_scope";
-}
-function isObjectRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isStringArray(value) {
-    return Array.isArray(value) && value.every((item) => typeof item === "string");
-}
-function getOwnEntry(record, key) {
-    return Object.prototype.hasOwnProperty.call(record, key)
-        ? record[key]
-        : undefined;
-}
-function getOwnString(record, key) {
-    const value = getOwnEntry(record, key);
-    return typeof value === "string" ? value : undefined;
-}
-function toUrl(value, label) {
-    try {
-        return new URL(String(value));
-    }
-    catch {
-        throw new Error(`${label} must be an absolute URL`);
-    }
-}
-function normalizeAudience(value) {
-    if (typeof value === "string") {
-        return [value];
-    }
-    return isStringArray(value) ? [...value] : [];
-}
-function normalizeVerifiedAudience(value, expectedResource) {
-    const audiences = normalizeAudience(value);
-    if (audiences.length !== 1) {
-        throw createInvalidTokenError("audience mismatch");
-    }
-    let normalizedAudience;
-    try {
-        normalizedAudience = canonicalizeResourceIndicator(audiences[0] ?? "");
-    }
-    catch {
-        throw createInvalidTokenError("audience mismatch");
-    }
-    if (normalizedAudience !== expectedResource) {
-        throw createInvalidTokenError("audience mismatch");
-    }
-    return [normalizedAudience];
-}
-function parseScopes(payload) {
-    const scope = getOwnString(payload, "scope");
-    const scopes = getOwnEntry(payload, "scopes");
-    const raw = scope !== undefined
-        ? scope
-        : typeof scopes === "string"
-            ? scopes
-            : null;
-    if (raw !== null) {
-        return raw
-            .split(" ")
-            .map((scope) => scope.trim())
-            .filter((scope) => scope.length > 0);
-    }
-    return isStringArray(scopes) ? [...scopes] : [];
-}
-function toVerifiedAccessToken(token, payload, audience = normalizeAudience(getOwnEntry(payload, "aud"))) {
-    const issuer = getOwnString(payload, "iss");
-    const expiresAt = getOwnEntry(payload, "exp");
-    const subject = getOwnString(payload, "sub");
-    const clientId = getOwnString(payload, "client_id");
-    return {
-        token,
-        issuer: issuer ?? "",
-        audience,
-        scopes: parseScopes(payload),
-        expiresAt: typeof expiresAt === "number" ? expiresAt : 0,
-        claims: { ...payload },
-        ...(subject !== undefined
-            ? {
-                subject,
-            }
-            : {}),
-        ...(clientId !== undefined
-            ? {
-                clientId,
-            }
-            : {}),
-    };
-}
-function createTokenVerificationError(input) {
-    return Object.assign(new Error(input.errorDescription ?? input.error), input);
-}
-function createInvalidTokenError(errorDescription) {
-    return createTokenVerificationError({
-        error: "invalid_token",
-        errorDescription,
-    });
-}
-function normalizeVerificationError(error) {
-    if (isTokenVerificationErrorShape(error)) {
-        return error;
-    }
-    if (error instanceof errors.JWTExpired) {
-        return createInvalidTokenError("token expired");
-    }
-    if (error instanceof errors.JWTClaimValidationFailed) {
-        if (error.claim === "aud") {
-            return createInvalidTokenError("audience mismatch");
-        }
-        if (error.claim === "iss") {
-            return createInvalidTokenError("issuer mismatch");
-        }
-        if (error.claim === "nbf") {
-            return createInvalidTokenError("token not active yet");
-        }
-        if (error.claim === "exp") {
-            return createInvalidTokenError("token expired");
-        }
-    }
-    if (error instanceof errors.JOSEAlgNotAllowed
-        || error instanceof errors.JOSENotSupported) {
-        return createInvalidTokenError("unsupported token algorithm");
-    }
-    if (error instanceof errors.JWKSNoMatchingKey
-        || error instanceof errors.JWKSMultipleMatchingKeys
-        || error instanceof errors.JWSSignatureVerificationFailed) {
-        return createInvalidTokenError("token signature invalid");
-    }
-    if (error instanceof errors.JWKSInvalid) {
-        return createInvalidTokenError("invalid JWKS document");
-    }
-    if (error instanceof errors.JWKSTimeout) {
-        return createInvalidTokenError("timed out loading JWKS");
-    }
-    if (error instanceof Error) {
-        return createInvalidTokenError(error.message);
-    }
-    return createInvalidTokenError("token verification failed");
-}
-async function loadJwks(jwksUrl, fetchImplementation) {
-    const response = await fetchImplementation(jwksUrl, {
-        headers: {
-            Accept: "application/json",
-        },
-    });
-    if (!response.ok) {
-        throw createInvalidTokenError(`unable to load JWKS (${response.status})`);
-    }
-    const payload = (await response.json());
-    const keys = isObjectRecord(payload) ? getOwnEntry(payload, "keys") : undefined;
-    if (!isObjectRecord(payload) || !Array.isArray(keys)) {
-        throw createInvalidTokenError("invalid JWKS document");
-    }
-    return { ...payload, keys };
-}
-function resolveAlgorithm(token, allowedAlgorithms) {
-    const header = decodeProtectedHeader(token);
-    const alg = getOwnString(header, "alg");
-    if (hasCriticalHeaderClaims(header)) {
-        throw createInvalidTokenError("unsupported critical token claims");
-    }
-    if (typeof alg !== "string"
-        || alg === "none"
-        || alg.startsWith("HS")
-        || !allowedAlgorithms.includes(alg)) {
-        throw createInvalidTokenError("unsupported token algorithm");
-    }
-    return alg;
-}
-function hasCriticalHeaderClaims(header) {
-    const criticalClaims = getOwnEntry(header, "crit");
-    return Array.isArray(criticalClaims) && criticalClaims.length > 0;
-}
-function isVerificationCandidate(key, alg, kid) {
-    const keyId = getOwnString(key, "kid");
-    const keyAlgorithm = getOwnString(key, "alg");
-    const keyUse = getOwnString(key, "use");
-    const keyOps = getOwnEntry(key, "key_ops");
-    if (kid !== undefined && keyId !== kid) {
-        return false;
-    }
-    if (keyAlgorithm !== undefined && keyAlgorithm !== alg) {
-        return false;
-    }
-    if (keyUse !== undefined && keyUse !== "sig") {
-        return false;
-    }
-    if (Array.isArray(keyOps) && !keyOps.includes("verify")) {
-        return false;
-    }
-    return true;
-}
-function shouldContinueWithNextKey(error) {
-    return error instanceof errors.JWSSignatureVerificationFailed;
-}
-async function verifyJwtAgainstJwks(input) {
-    const protectedHeader = decodeProtectedHeader(input.token);
-    const kid = getOwnString(protectedHeader, "kid");
-    const candidateKeys = input.jwks.keys.filter((key) => isVerificationCandidate(key, input.alg, kid));
-    if (candidateKeys.length === 0) {
-        throw createInvalidTokenError("token signature invalid");
-    }
-    let lastSignatureError;
-    for (const candidate of candidateKeys) {
-        try {
-            const key = await importJWK(candidate, input.alg);
-            return await jwtVerify(input.token, key, {
-                algorithms: [input.alg],
-                issuer: [...input.authorizationServers],
-                clockTolerance: input.clockSkewSeconds,
-            });
-        }
-        catch (error) {
-            if (shouldContinueWithNextKey(error)) {
-                lastSignatureError = error;
-                continue;
-            }
-            throw error;
-        }
-    }
-    throw lastSignatureError ?? createInvalidTokenError("token signature invalid");
-}
-export function createJwksTokenVerifier(options) {
-    const jwksUrl = toUrl(options.jwksUrl, "jwksUrl");
-    const clockSkewSeconds = options.clockSkewSeconds ?? 30;
-    const allowedAlgorithms = options.allowedAlgorithms ?? DEFAULT_ALLOWED_ALGORITHMS;
-    const jwksCacheTtlMs = options.jwksCacheTtlMs ?? 300_000;
-    const fetchImplementation = options.fetch ?? globalThis.fetch;
-    let cachedJwks;
-    let pendingJwks;
-    if (typeof fetchImplementation !== "function") {
-        throw new Error("fetch is not available; pass options.fetch explicitly");
-    }
-    async function getJwks() {
-        const now = Date.now();
-        if (cachedJwks !== undefined && cachedJwks.expiresAt > now) {
-            return cachedJwks.value;
-        }
-        if (pendingJwks !== undefined) {
-            return pendingJwks;
-        }
-        pendingJwks = loadJwks(jwksUrl, fetchImplementation)
-            .then((jwks) => {
-            cachedJwks = {
-                value: jwks,
-                expiresAt: Date.now() + jwksCacheTtlMs,
-            };
-            return jwks;
-        })
-            .finally(() => {
-            pendingJwks = undefined;
-        });
-        return pendingJwks;
-    }
-    return {
-        async verify(input) {
-            const expectedResource = canonicalizeResourceIndicator(input.resource);
-            const algorithm = resolveAlgorithm(input.token, allowedAlgorithms);
-            try {
-                const jwks = await getJwks();
-                const verified = await verifyJwtAgainstJwks({
-                    token: input.token,
-                    jwks,
-                    alg: algorithm,
-                    authorizationServers: input.authorizationServers,
-                    clockSkewSeconds,
-                });
-                const audience = normalizeVerifiedAudience(getOwnEntry(verified.payload, "aud"), expectedResource);
-                const accessToken = toVerifiedAccessToken(input.token, verified.payload, audience);
-                if (input.requiredScopes.length > 0
-                    && !input.requiredScopes.every((scope) => accessToken.scopes.includes(scope))) {
-                    throw createTokenVerificationError({
-                        error: "insufficient_scope",
-                        errorDescription: "insufficient scope",
-                        scope: [...input.requiredScopes],
-                    });
-                }
-                return accessToken;
-            }
-            catch (error) {
-                throw normalizeVerificationError(error);
-            }
-        },
-    };
-}

package/node_modules/toolcraft/node_modules/tiny-mcp-client/.turbo/turbo-build.log

@@ -1,7 +0,0 @@
-npm warn Unknown project config "link-workspace-packages". This will stop working in the next major version of npm. See `npm help npmrc` for supported config options.
-npm warn Unknown project config "package-manager-strict". This will stop working in the next major version of npm. See `npm help npmrc` for supported config options.
-npm warn Unknown project config "prefer-workspace-packages". This will stop working in the next major version of npm. See `npm help npmrc` for supported config options.
-
-> tiny-mcp-client@0.1.0 build
-> node ../../scripts/guard-package-dist.mjs && tsc
-