@zapier/zapier-sdk-cli 0.59.1 → 0.59.2

package/dist/src/utils/auth/client-credentials.js

@@ -1,67 +0,0 @@
-import { storeClientCredentials } from "../../login/credentials-store";
-import { withRetry } from "../retry";
-// "external" allows SDK operations (listing, running actions, etc.);
-// "credentials" allows managing client credentials (list, create, delete).
-const CREDENTIALS_SCOPES = ["external", "credentials"];
-/**
- * The canonical empty approvals policy. Attaching this to a credential at
- * creation time tells the server that requests made with these credentials
- * are subject to approval. Server-side enforcement decides which specific
- * requests trigger the approval flow; the SDK only attaches the policy.
- */
-export const EMPTY_POLICY = {
-    version: 2,
-    statements: [],
-};
-async function createCredentialsOnServer(api, name, policy) {
-    // The server wraps the credential in `{ data: { ... } }`; mirror the
-    // shape the SDK's own createClientCredentials plugin reads.
-    const response = await api.post("/api/v0/client-credentials", {
-        name,
-        allowed_scopes: CREDENTIALS_SCOPES,
-        ...(policy !== undefined && { policy }),
-    }, { authRequired: true, requiredScopes: ["credentials"] });
-    return {
-        clientId: response.data.client_id,
-        clientSecret: response.data.client_secret,
-    };
-}
-async function deleteCredentialsOnServer(api, clientId) {
-    await api.delete(`/api/v0/client-credentials/${clientId}`, undefined, {
-        authRequired: true,
-        requiredScopes: ["credentials"],
-    });
-}
-/**
- * Create a client credential server-side and persist it locally. If the
- * local store fails after the server-side credential is created, attempt
- * to roll back the orphan; if that rollback also fails, surface a
- * manual-fix message and re-throw the original store error.
- */
-export async function setupClientCredentials({ api, name, credentialsBaseUrl, policy, }) {
-    const { clientId, clientSecret } = await createCredentialsOnServer(api, name, policy);
-    try {
-        await withRetry({
-            action: () => storeClientCredentials({
-                name,
-                clientId,
-                clientSecret,
-                scopes: [...CREDENTIALS_SCOPES],
-                baseUrl: credentialsBaseUrl,
-            }),
-        });
-    }
-    catch (storeErr) {
-        try {
-            await withRetry({
-                action: () => deleteCredentialsOnServer(api, clientId),
-            });
-        }
-        catch {
-            console.error(`Failed to roll back orphaned credential ${clientId}. ` +
-                `Delete it manually with: zapier-sdk delete-client-credentials ${clientId}`);
-        }
-        throw storeErr;
-    }
-    return { clientId };
-}

package/dist/src/utils/auth/oauth-callback.d.ts

@@ -1,6 +0,0 @@
-import type { OauthTransaction } from "./oauth-transaction";
-export declare function getCallbackCode({ callbackUrl, transaction, recoveryMessage, }: {
-    callbackUrl: string;
-    transaction: Pick<OauthTransaction, "redirectUri" | "state">;
-    recoveryMessage?: string;
-}): string;

package/dist/src/utils/auth/oauth-callback.js

@@ -1,28 +0,0 @@
-import { ZapierCliValidationError } from "../errors";
-export function getCallbackCode({ callbackUrl, transaction, recoveryMessage, }) {
-    let parsed;
-    try {
-        parsed = new URL(callbackUrl.trim());
-    }
-    catch {
-        throw new ZapierCliValidationError("Paste the final OAuth callback URL from your browser.");
-    }
-    const expected = new URL(transaction.redirectUri);
-    if (parsed.protocol !== "http:" ||
-        parsed.hostname !== expected.hostname ||
-        parsed.pathname !== expected.pathname ||
-        parsed.port !== expected.port) {
-        throw new ZapierCliValidationError(`Expected the final OAuth callback URL to start with ${transaction.redirectUri}.`);
-    }
-    if (parsed.searchParams.get("state") !== transaction.state) {
-        throw new ZapierCliValidationError(`OAuth state mismatch.${recoveryMessage ? ` ${recoveryMessage}` : ""}`);
-    }
-    if (parsed.searchParams.has("error")) {
-        throw new ZapierCliValidationError(`Authorization denied: ${parsed.searchParams.get("error_description") ?? parsed.searchParams.get("error")}.${recoveryMessage ? ` ${recoveryMessage}` : ""}`);
-    }
-    const code = parsed.searchParams.get("code");
-    if (!code) {
-        throw new ZapierCliValidationError("No authorization code found in the pasted callback URL.");
-    }
-    return code;
-}

package/dist/src/utils/auth/oauth-errors.d.ts

@@ -1,2 +0,0 @@
-export declare function redactSensitiveOauthErrorMessage(message: string): string;
-export declare function toRedactedOauthError(error: unknown): Error;

package/dist/src/utils/auth/oauth-errors.js

@@ -1,39 +0,0 @@
-import { ZapierCliValidationError } from "../errors";
-const SENSITIVE_OAUTH_FIELDS = [
-    "access_token",
-    "refresh_token",
-    "id_token",
-    "client_secret",
-    "code_verifier",
-    "code_challenge",
-];
-function getErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function toCamelCase(field) {
-    return field.replace(/_([a-z])/g, (_match, letter) => letter.toUpperCase());
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-const sensitiveOauthFieldPattern = Array.from(new Set(SENSITIVE_OAUTH_FIELDS.flatMap((field) => [field, toCamelCase(field)])))
-    .map(escapeRegExp)
-    .join("|");
-const sensitiveQueryParamPattern = new RegExp(`([?&])(${sensitiveOauthFieldPattern})(=)[^&#\\s"'<>]*`, "gi");
-export function redactSensitiveOauthErrorMessage(message) {
-    return message
-        .replace(sensitiveQueryParamPattern, (_match, prefix, key, separator) => `${prefix}${key}${separator}[REDACTED]`)
-        .replace(new RegExp(`"(${sensitiveOauthFieldPattern})"(\\s*:\\s*)"[^"]*"`, "g"), (_match, key, separator) => `"${key}"${separator}"[REDACTED]"`);
-}
-export function toRedactedOauthError(error) {
-    const message = redactSensitiveOauthErrorMessage(getErrorMessage(error));
-    if (error instanceof ZapierCliValidationError) {
-        return new ZapierCliValidationError(message);
-    }
-    if (error instanceof Error) {
-        const redactedError = new Error(message);
-        redactedError.name = error.name;
-        return redactedError;
-    }
-    return new ZapierCliValidationError(message);
-}

package/dist/src/utils/auth/oauth-flow.d.ts

@@ -1,37 +0,0 @@
-import { type PkceCredentials } from "../../login";
-import { buildBrowserAuthUrl, OAUTH_LOOPBACK_HOST, type OauthTokens } from "./oauth-transaction";
-export { buildBrowserAuthUrl, OAUTH_LOOPBACK_HOST };
-export type { OauthFlowEntryPoint, OauthTokens } from "./oauth-transaction";
-export type OauthFlowProgressEvent = {
-    type: "browser_opening";
-    url: string;
-} | {
-    type: "browser_opened";
-    url: string;
-} | {
-    type: "browser_open_failed";
-    url: string;
-    reason: string;
-} | {
-    type: "callback_waiting";
-} | {
-    type: "callback_accepted";
-} | {
-    type: "token_exchange_started";
-} | {
-    type: "token_exchange_completed";
-};
-export interface RunOauthFlowOptions {
-    timeoutMs?: number;
-    pkceCredentials?: PkceCredentials;
-    baseUrl?: string;
-    silent?: boolean;
-    onProgress?: (event: OauthFlowProgressEvent) => void;
-    recoveryMessage?: string;
-}
-interface RunSignupOauthFlowOptions extends RunOauthFlowOptions {
-    headless?: boolean;
-    interactive?: boolean;
-}
-export declare function runLoginOauthFlow(options: RunOauthFlowOptions): Promise<OauthTokens>;
-export declare function runSignupOauthFlow(options: RunSignupOauthFlowOptions): Promise<OauthTokens>;

package/dist/src/utils/auth/oauth-flow.js

@@ -1,313 +0,0 @@
-import express from "express";
-import { createInterface } from "node:readline/promises";
-import open from "open";
-import { LOGIN_PORTS, LOGIN_TIMEOUT_MS } from "../constants";
-import { ZapierCliUserCancellationError, ZapierCliValidationError, } from "../errors";
-import getCallablePromise from "../getCallablePromise";
-import log from "../log";
-import { spinPromise } from "../spinner";
-import { getCallbackCode } from "./oauth-callback";
-import { buildBrowserAuthUrl, exchangeOauthCode, OAUTH_LOOPBACK_HOST, prepareOauthTransaction, } from "./oauth-transaction";
-export { buildBrowserAuthUrl, OAUTH_LOOPBACK_HOST };
-class OauthFlowTimeoutError extends Error {
-    constructor(timeoutMs) {
-        super("OAuth flow timed out");
-        this.timeoutMs = timeoutMs;
-        this.name = "OauthFlowTimeoutError";
-    }
-}
-class OauthAuthorizationDeniedError extends Error {
-    constructor(reason) {
-        super("OAuth authorization denied");
-        this.reason = reason;
-        this.name = "OauthAuthorizationDeniedError";
-    }
-}
-function findAvailablePort() {
-    return new Promise((resolve, reject) => {
-        let portIndex = 0;
-        const tryPort = (port) => {
-            const server = express().listen(port, OAUTH_LOOPBACK_HOST, () => {
-                server.close();
-                resolve(port);
-            });
-            server.on("error", (err) => {
-                if (err.code === "EADDRINUSE" && portIndex < LOGIN_PORTS.length) {
-                    tryPort(LOGIN_PORTS[portIndex++]);
-                }
-                else if (err.code === "EADDRINUSE") {
-                    reject(new Error(`All configured OAuth callback ports are busy: ${LOGIN_PORTS.join(", ")}. Please try again later or close applications using these ports.`));
-                }
-                else {
-                    reject(err);
-                }
-            });
-        };
-        if (LOGIN_PORTS.length > 0)
-            tryPort(LOGIN_PORTS[portIndex++]);
-        else
-            reject(new Error("No OAuth callback ports configured"));
-    });
-}
-export async function runLoginOauthFlow(options) {
-    return runOauthFlowEntryPoint({
-        ...options,
-        entryPoint: "login",
-        authAction: "log in",
-        flowName: "Login",
-    });
-}
-export async function runSignupOauthFlow(options) {
-    if (options.headless) {
-        return runOauthFlowEntryPoint({
-            ...options,
-            entryPoint: "signup",
-            authAction: "sign up",
-            flowName: "Signup",
-            headless: true,
-        });
-    }
-    return runOauthFlowEntryPoint({
-        ...options,
-        entryPoint: "signup",
-        authAction: "sign up",
-        flowName: "Signup",
-    });
-}
-async function runOauthFlowEntryPoint({ flowName, ...options }) {
-    try {
-        return options.headless
-            ? await runHeadlessSignupOauthFlow(options)
-            : await runOauthFlow(options);
-    }
-    catch (error) {
-        if (error instanceof OauthFlowTimeoutError) {
-            throw new Error(withRecoveryMessage(`${flowName} timed out after ${Math.round(error.timeoutMs / 1000)} seconds.`, options.recoveryMessage));
-        }
-        if (error instanceof OauthAuthorizationDeniedError) {
-            throw new Error(withRecoveryMessage(`Authorization denied: ${error.reason}.`, options.recoveryMessage));
-        }
-        if (error instanceof ZapierCliUserCancellationError && !options.silent) {
-            log.info(`\n❌ ${flowName} cancelled by user`);
-        }
-        throw error;
-    }
-}
-function withRecoveryMessage(message, recoveryMessage) {
-    return recoveryMessage ? `${message} ${recoveryMessage}` : message;
-}
-async function runOauthFlow({ timeoutMs = LOGIN_TIMEOUT_MS, pkceCredentials, baseUrl, entryPoint, authAction, silent = false, onProgress, }) {
-    const port = await findAvailablePort();
-    if (!silent)
-        log.info(`Using port ${port} for OAuth callback`);
-    const transaction = await prepareOauthTransaction({
-        pkceCredentials,
-        baseUrl,
-        redirectUri: `http://${OAUTH_LOOPBACK_HOST}:${port}/oauth`,
-        entryPoint,
-    });
-    const code = await collectLocalCallbackCode({
-        transaction,
-        timeoutMs,
-        authAction,
-        silent,
-        onProgress,
-    });
-    onProgress?.({ type: "callback_accepted" });
-    if (!silent)
-        log.info("Exchanging authorization code for tokens...");
-    onProgress?.({ type: "token_exchange_started" });
-    const tokens = await exchangeOauthCode({ ...transaction, code });
-    if (!silent)
-        log.info("Token exchange completed successfully");
-    onProgress?.({ type: "token_exchange_completed" });
-    return tokens;
-}
-async function readHeadlessCallbackUrl({ timeoutMs, interactive, recoveryMessage, }) {
-    const timeoutMessage = withRecoveryMessage(`Signup timed out after ${Math.round(timeoutMs / 1000)} seconds.`, recoveryMessage);
-    const missingCallbackUrlMessage = withRecoveryMessage("Paste the final OAuth callback URL from your browser.", recoveryMessage);
-    // Keep TTY echo enabled for paste feedback; the PKCE code is single-use, verifier-protected, and exchanged immediately.
-    const rl = createInterface({ input: process.stdin, output: process.stderr });
-    const abortController = new AbortController();
-    const timeoutTimer = setTimeout(() => abortController.abort(), timeoutMs);
-    const readUrl = interactive
-        ? rl.question("Paste the final OAuth callback URL: ", {
-            signal: abortController.signal,
-        })
-        : new Promise((resolve, reject) => {
-            let settled = false;
-            const settleResolve = (value) => {
-                settled = true;
-                resolve(value);
-            };
-            const settleReject = (error) => {
-                if (settled)
-                    return;
-                settled = true;
-                reject(error);
-            };
-            abortController.signal.addEventListener("abort", () => settleReject(new Error(timeoutMessage)), { once: true });
-            rl.once("line", settleResolve);
-            rl.once("close", () => settleReject(new ZapierCliValidationError(missingCallbackUrlMessage)));
-            rl.once("error", settleReject);
-        });
-    try {
-        return await readUrl.catch((error) => {
-            if (error instanceof Error && error.name === "AbortError") {
-                throw new Error(timeoutMessage);
-            }
-            throw error;
-        });
-    }
-    finally {
-        clearTimeout(timeoutTimer);
-        rl.close();
-    }
-}
-async function runHeadlessSignupOauthFlow({ timeoutMs = LOGIN_TIMEOUT_MS, pkceCredentials, baseUrl, interactive = true, onProgress, recoveryMessage, }) {
-    const port = LOGIN_PORTS[0];
-    if (port === undefined) {
-        throw new Error("No OAuth callback ports configured");
-    }
-    const transaction = await prepareOauthTransaction({
-        pkceCredentials,
-        baseUrl,
-        redirectUri: `http://${OAUTH_LOOPBACK_HOST}:${port}/oauth`,
-        entryPoint: "signup",
-    });
-    console.log("Use this mode when signing up from a machine that has no browser.");
-    console.log("Open this signup URL in a browser on another machine:");
-    console.log(transaction.browserAuthUrl);
-    console.log(`When the browser lands on ${transaction.redirectUri} and cannot connect, paste the full final URL back here.`);
-    const callbackUrl = await readHeadlessCallbackUrl({
-        timeoutMs,
-        interactive,
-        recoveryMessage,
-    });
-    const code = getCallbackCode({
-        callbackUrl,
-        transaction,
-        recoveryMessage,
-    });
-    onProgress?.({ type: "callback_accepted" });
-    console.log("Exchanging authorization code for tokens...");
-    onProgress?.({ type: "token_exchange_started" });
-    const tokens = await exchangeOauthCode({ ...transaction, code });
-    onProgress?.({ type: "token_exchange_completed" });
-    return tokens;
-}
-async function collectLocalCallbackCode({ transaction, timeoutMs, authAction, silent, onProgress, }) {
-    const { promise, resolve, reject } = getCallablePromise();
-    const app = express();
-    app.get("/oauth", (req, res) => {
-        res.setHeader("Connection", "close");
-        if (req.query.state !== transaction.state) {
-            res.status(400).end("Invalid state. You can close this tab.");
-        }
-        else if (req.query.error) {
-            reject(new OauthAuthorizationDeniedError(String(req.query.error_description ?? req.query.error)));
-            res.end("Authorization was denied. You can close this tab.");
-        }
-        else if (!req.query.code) {
-            reject(new Error("No authorization code received"));
-            res.end("No authorization code received. You can close this tab.");
-        }
-        else {
-            resolve(String(req.query.code));
-            res.end("You can now close this tab and return to the CLI.");
-        }
-    });
-    const server = app.listen(Number(new URL(transaction.redirectUri).port), OAUTH_LOOPBACK_HOST);
-    const connections = new Set();
-    server.on("connection", (conn) => {
-        connections.add(conn);
-        conn.on("close", () => connections.delete(conn));
-    });
-    const cleanup = () => {
-        server.close();
-        reject(new ZapierCliUserCancellationError());
-    };
-    process.on("SIGINT", cleanup);
-    process.on("SIGTERM", cleanup);
-    let timeoutTimer;
-    try {
-        await waitForServerListening(server);
-        await openBrowser({ transaction, authAction, silent, onProgress });
-        const waitForCode = Promise.race([
-            promise,
-            new Promise((_resolve, rejectTimeout) => {
-                timeoutTimer = setTimeout(() => {
-                    rejectTimeout(new OauthFlowTimeoutError(timeoutMs));
-                }, timeoutMs);
-            }),
-        ]);
-        onProgress?.({ type: "callback_waiting" });
-        return silent
-            ? await waitForCode
-            : await spinPromise(waitForCode, `Waiting for you to ${authAction} and authorize`);
-    }
-    finally {
-        if (timeoutTimer)
-            clearTimeout(timeoutTimer);
-        process.off("SIGINT", cleanup);
-        process.off("SIGTERM", cleanup);
-        await closeServer({ server, connections, silent });
-    }
-}
-async function waitForServerListening(server) {
-    if (server.listening)
-        return;
-    await new Promise((resolve, reject) => {
-        const cleanup = () => {
-            server.off("listening", handleListening);
-            server.off("error", handleError);
-        };
-        const handleListening = () => {
-            cleanup();
-            resolve();
-        };
-        const handleError = (error) => {
-            cleanup();
-            reject(error);
-        };
-        server.once("listening", handleListening);
-        server.once("error", handleError);
-    });
-}
-async function openBrowser({ transaction, authAction, silent, onProgress, }) {
-    if (!silent) {
-        log.info(`Opening your browser to ${authAction}.`);
-        log.info("If it doesn't open, visit:", transaction.browserAuthUrl);
-    }
-    onProgress?.({ type: "browser_opening", url: transaction.browserAuthUrl });
-    try {
-        await open(transaction.browserAuthUrl);
-        onProgress?.({ type: "browser_opened", url: transaction.browserAuthUrl });
-    }
-    catch (err) {
-        const reason = err instanceof Error ? err.message : String(err);
-        if (!silent) {
-            log.info(`Browser did not open automatically to ${authAction}: ${reason}`);
-            log.info("Visit this URL manually:", transaction.browserAuthUrl);
-        }
-        onProgress?.({
-            type: "browser_open_failed",
-            url: transaction.browserAuthUrl,
-            reason,
-        });
-    }
-}
-async function closeServer({ server, connections, silent, }) {
-    await new Promise((resolve) => {
-        const timeout = setTimeout(() => {
-            if (!silent)
-                log.info("Server close timed out, forcing connection shutdown...");
-            connections.forEach((conn) => conn.destroy());
-            resolve();
-        }, 1000);
-        server.close(() => {
-            clearTimeout(timeout);
-            resolve();
-        });
-    });
-}

package/dist/src/utils/auth/oauth-transaction.d.ts

@@ -1,35 +0,0 @@
-import { type PkceCredentials } from "../../login";
-export declare const OAUTH_LOOPBACK_HOST = "localhost";
-export interface OauthTokens {
-    accessToken: string;
-    refreshToken: string;
-    expiresIn: number;
-}
-export type OauthFlowEntryPoint = "login" | "signup";
-interface PrepareOauthTransactionOptions {
-    pkceCredentials?: PkceCredentials;
-    baseUrl?: string;
-    redirectUri: string;
-    entryPoint?: OauthFlowEntryPoint;
-}
-export interface OauthTransaction {
-    browserAuthUrl: string;
-    clientId: string;
-    codeVerifier: string;
-    redirectUri: string;
-    state: string;
-    tokenUrl: string;
-}
-export declare function buildBrowserAuthUrl({ authorizeUrl, entryPoint, }: {
-    authorizeUrl: string;
-    entryPoint?: OauthFlowEntryPoint;
-}): string;
-export declare function prepareOauthTransaction({ pkceCredentials, baseUrl, redirectUri, entryPoint, }: PrepareOauthTransactionOptions): Promise<OauthTransaction>;
-export declare function exchangeOauthCode({ tokenUrl, code, redirectUri, clientId, codeVerifier, }: {
-    tokenUrl: string;
-    code: string;
-    redirectUri: string;
-    clientId: string;
-    codeVerifier: string;
-}): Promise<OauthTokens>;
-export {};

package/dist/src/utils/auth/oauth-transaction.js

@@ -1,69 +0,0 @@
-import crypto from "node:crypto";
-import pkceChallenge from "pkce-challenge";
-import { AUTH_MODE_HEADER } from "../constants";
-import api from "../api/client";
-import { getPkceLoginConfig } from "../../login";
-export const OAUTH_LOOPBACK_HOST = "localhost";
-export function buildBrowserAuthUrl({ authorizeUrl, entryPoint = "login", }) {
-    if (entryPoint === "login")
-        return authorizeUrl;
-    const parsedAuthorizeUrl = new URL(authorizeUrl);
-    const signupUrl = new URL("/sign-up", parsedAuthorizeUrl);
-    signupUrl.searchParams.set("skipOnboarding", "true");
-    signupUrl.searchParams.set("next", `${parsedAuthorizeUrl.pathname}${parsedAuthorizeUrl.search}`);
-    return signupUrl.toString();
-}
-function generateRandomString() {
-    const array = new Uint32Array(28);
-    crypto.getRandomValues(array);
-    return Array.from(array, (dec) => ("0" + dec.toString(16)).slice(-2)).join("");
-}
-function ensureOfflineAccess(scope) {
-    if (scope.includes("offline_access"))
-        return scope;
-    return `${scope} offline_access`;
-}
-export async function prepareOauthTransaction({ pkceCredentials, baseUrl, redirectUri, entryPoint = "login", }) {
-    const { clientId, tokenUrl, authorizeUrl } = getPkceLoginConfig({
-        credentials: pkceCredentials,
-        baseUrl,
-    });
-    const { code_verifier: codeVerifier, code_challenge: codeChallenge } = await pkceChallenge();
-    const state = generateRandomString();
-    const authUrl = `${authorizeUrl}?${new URLSearchParams({
-        response_type: "code",
-        client_id: clientId,
-        redirect_uri: redirectUri,
-        scope: ensureOfflineAccess(pkceCredentials?.scope || "internal credentials"),
-        state,
-        code_challenge: codeChallenge,
-        code_challenge_method: "S256",
-    }).toString()}`;
-    return {
-        browserAuthUrl: buildBrowserAuthUrl({ authorizeUrl: authUrl, entryPoint }),
-        clientId,
-        codeVerifier,
-        redirectUri,
-        state,
-        tokenUrl,
-    };
-}
-export async function exchangeOauthCode({ tokenUrl, code, redirectUri, clientId, codeVerifier, }) {
-    const { data } = await api.post(tokenUrl, {
-        grant_type: "authorization_code",
-        code,
-        redirect_uri: redirectUri,
-        client_id: clientId,
-        code_verifier: codeVerifier,
-    }, {
-        headers: {
-            [AUTH_MODE_HEADER]: "no",
-            "Content-Type": "application/x-www-form-urlencoded",
-        },
-    });
-    return {
-        accessToken: data.access_token,
-        refreshToken: data.refresh_token,
-        expiresIn: data.expires_in,
-    };
-}

package/dist/src/utils/cli-generator-utils.d.ts

@@ -1,14 +0,0 @@
-import { z } from "zod";
-import { type FunctionRegistryEntry } from "@zapier/zapier-sdk";
-export interface CliParameter {
-    name: string;
-    type: "string" | "number" | "boolean" | "array";
-    required: boolean;
-    description?: string;
-    default?: unknown;
-    choices?: string[];
-    hasResolver?: boolean;
-    isPositional?: boolean;
-}
-export declare function analyzeZodSchema(schema: z.ZodSchema, functionInfo?: FunctionRegistryEntry): CliParameter[];
-export declare function convertCliArgsToSdkParams(parameters: CliParameter[], positionalArgs: unknown[], options: Record<string, unknown>): Record<string, unknown>;