@zapier/zapier-sdk 0.70.4 → 0.71.0

package/dist/plugins/api/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/api/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAUtD,MAAM,WAAW,gBAAiB,SAAQ,cAAc;CAAG;AAE3D,eAAO,MAAM,SAAS;aACH;QAAE,OAAO,EAAE,cAAc,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;CA+C7C,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/api/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAUtD,MAAM,WAAW,gBAAiB,SAAQ,cAAc;CAAG;AAE3D,eAAO,MAAM,SAAS;aACH;QAAE,OAAO,EAAE,cAAc,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;CAiD7C,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC"}

package/dist/plugins/api/index.js

@@ -4,7 +4,7 @@ import { resolveCredentials } from "../../credentials";
 import { ZAPIER_BASE_URL, ZAPIER_MAX_CONCURRENT_REQUESTS, ZAPIER_MAX_NETWORK_RETRIES, ZAPIER_MAX_NETWORK_RETRY_DELAY_MS, } from "../../constants";
 export const apiPlugin = definePlugin((sdk) => {
     // Extract all options - everything passed to the plugin
-    const { fetch: customFetch = globalThis.fetch, baseUrl = ZAPIER_BASE_URL, credentials, token, onEvent, debug = false, maxNetworkRetries = ZAPIER_MAX_NETWORK_RETRIES, maxNetworkRetryDelayMs = ZAPIER_MAX_NETWORK_RETRY_DELAY_MS, maxConcurrentRequests = ZAPIER_MAX_CONCURRENT_REQUESTS, approvalTimeoutMs, maxApprovalRetries, approvalMode, callerPackage, } = sdk.context.options;
+    const { fetch: customFetch = globalThis.fetch, baseUrl = ZAPIER_BASE_URL, credentials, token, onEvent, debug = false, maxNetworkRetries = ZAPIER_MAX_NETWORK_RETRIES, maxNetworkRetryDelayMs = ZAPIER_MAX_NETWORK_RETRY_DELAY_MS, maxConcurrentRequests = ZAPIER_MAX_CONCURRENT_REQUESTS, approvalTimeoutMs, maxApprovalRetries, approvalMode, openAutoModeApprovalsInBrowser, callerPackage, } = sdk.context.options;
     // Create the API client - it will handle token resolution internally
     const api = createZapierApi({
         baseUrl,
@@ -19,6 +19,7 @@ export const apiPlugin = definePlugin((sdk) => {
         approvalTimeoutMs,
         maxApprovalRetries,
         approvalMode,
+        openAutoModeApprovalsInBrowser,
         callerPackage,
     });
     return {

package/dist/plugins/codeSubstrate/deleteWorkflow/index.d.ts

@@ -37,7 +37,7 @@ export declare const deleteWorkflowPlugin: (sdk: {
         triggers: {
             selected_api: string;
             action: string;
-            status: "pending" | "active" | "unclaimed" | "releasing" | "released" | "failed";
+            status: "failed" | "pending" | "active" | "unclaimed" | "releasing" | "released";
             authentication_id?: string | null | undefined;
             params?: Record<string, unknown> | undefined;
         }[];

package/dist/plugins/codeSubstrate/disableWorkflow/index.d.ts

@@ -37,7 +37,7 @@ export declare const disableWorkflowPlugin: (sdk: {
         triggers: {
             selected_api: string;
             action: string;
-            status: "pending" | "active" | "unclaimed" | "releasing" | "released" | "failed";
+            status: "failed" | "pending" | "active" | "unclaimed" | "releasing" | "released";
             authentication_id?: string | null | undefined;
             params?: Record<string, unknown> | undefined;
         }[];

package/dist/plugins/codeSubstrate/enableWorkflow/index.d.ts

@@ -37,7 +37,7 @@ export declare const enableWorkflowPlugin: (sdk: {
         triggers: {
             selected_api: string;
             action: string;
-            status: "pending" | "active" | "unclaimed" | "releasing" | "released" | "failed";
+            status: "failed" | "pending" | "active" | "unclaimed" | "releasing" | "released";
             authentication_id?: string | null | undefined;
             params?: Record<string, unknown> | undefined;
         }[];

package/dist/plugins/codeSubstrate/getDurableRun/schemas.d.ts

@@ -6,8 +6,8 @@ export declare const OperationTypeSchema: z.ZodUnion<readonly [z.ZodEnum<{
 }>, z.ZodString]>;
 export type OperationType = z.infer<typeof OperationTypeSchema>;
 export declare const OperationStatusSchema: z.ZodUnion<readonly [z.ZodEnum<{
-    pending: "pending";
     failed: "failed";
+    pending: "pending";
     exhausted: "exhausted";
     completed: "completed";
 }>, z.ZodString]>;
@@ -22,8 +22,8 @@ export declare const OperationSchema: z.ZodObject<{
         callback: "callback";
     }>, z.ZodString]>;
     status: z.ZodUnion<readonly [z.ZodEnum<{
-        pending: "pending";
         failed: "failed";
+        pending: "pending";
         exhausted: "exhausted";
         completed: "completed";
     }>, z.ZodString]>;
@@ -80,8 +80,8 @@ export declare const ExecutionSummarySchema: z.ZodObject<{
             callback: "callback";
         }>, z.ZodString]>;
         status: z.ZodUnion<readonly [z.ZodEnum<{
-            pending: "pending";
             failed: "failed";
+            pending: "pending";
             exhausted: "exhausted";
             completed: "completed";
         }>, z.ZodString]>;
@@ -151,8 +151,8 @@ export declare const GetDurableRunResponseSchema: z.ZodObject<{
                 callback: "callback";
             }>, z.ZodString]>;
             status: z.ZodUnion<readonly [z.ZodEnum<{
-                pending: "pending";
                 failed: "failed";
+                pending: "pending";
                 exhausted: "exhausted";
                 completed: "completed";
             }>, z.ZodString]>;

package/dist/plugins/codeSubstrate/getWorkflow/index.d.ts

@@ -37,7 +37,7 @@ export declare const getWorkflowPlugin: (sdk: {
         triggers: {
             selected_api: string;
             action: string;
-            status: "pending" | "active" | "unclaimed" | "releasing" | "released" | "failed";
+            status: "failed" | "pending" | "active" | "unclaimed" | "releasing" | "released";
             authentication_id?: string | null | undefined;
             params?: Record<string, unknown> | undefined;
         }[];
@@ -69,7 +69,7 @@ export declare const getWorkflowPlugin: (sdk: {
             triggers: {
                 selected_api: string;
                 action: string;
-                status: "pending" | "active" | "unclaimed" | "releasing" | "released" | "failed";
+                status: "failed" | "pending" | "active" | "unclaimed" | "releasing" | "released";
                 authentication_id?: string | null | undefined;
                 params?: Record<string, unknown> | undefined;
             }[];

package/dist/plugins/codeSubstrate/getWorkflow/schemas.d.ts

@@ -62,12 +62,12 @@ export declare const GetWorkflowResponseSchema: z.ZodObject<{
         authentication_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         status: z.ZodEnum<{
+            failed: "failed";
             pending: "pending";
             active: "active";
             unclaimed: "unclaimed";
             releasing: "releasing";
             released: "released";
-            failed: "failed";
         }>;
     }, z.core.$strip>>;
     created_at: z.ZodString;

package/dist/plugins/codeSubstrate/getWorkflowRun/index.d.ts

@@ -37,7 +37,7 @@ export declare const getWorkflowRunPlugin: (sdk: {
         triggers: {
             selected_api: string;
             action: string;
-            status: "pending" | "active" | "unclaimed" | "releasing" | "released" | "failed";
+            status: "failed" | "pending" | "active" | "unclaimed" | "releasing" | "released";
             authentication_id?: string | null | undefined;
             params?: Record<string, unknown> | undefined;
         }[];

package/dist/plugins/codeSubstrate/getWorkflowVersion/index.d.ts

@@ -37,7 +37,7 @@ export declare const getWorkflowVersionPlugin: (sdk: {
         triggers: {
             selected_api: string;
             action: string;
-            status: "pending" | "active" | "unclaimed" | "releasing" | "released" | "failed";
+            status: "failed" | "pending" | "active" | "unclaimed" | "releasing" | "released";
             authentication_id?: string | null | undefined;
             params?: Record<string, unknown> | undefined;
         }[];

package/dist/plugins/codeSubstrate/listWorkflowRuns/index.d.ts

@@ -37,7 +37,7 @@ export declare const listWorkflowRunsPlugin: (sdk: {
         triggers: {
             selected_api: string;
             action: string;
-            status: "pending" | "active" | "unclaimed" | "releasing" | "released" | "failed";
+            status: "failed" | "pending" | "active" | "unclaimed" | "releasing" | "released";
             authentication_id?: string | null | undefined;
             params?: Record<string, unknown> | undefined;
         }[];

package/dist/plugins/codeSubstrate/listWorkflowVersions/index.d.ts

@@ -37,7 +37,7 @@ export declare const listWorkflowVersionsPlugin: (sdk: {
         triggers: {
             selected_api: string;
             action: string;
-            status: "pending" | "active" | "unclaimed" | "releasing" | "released" | "failed";
+            status: "failed" | "pending" | "active" | "unclaimed" | "releasing" | "released";
             authentication_id?: string | null | undefined;
             params?: Record<string, unknown> | undefined;
         }[];

package/dist/plugins/codeSubstrate/listWorkflows/index.d.ts

@@ -41,7 +41,7 @@ export declare const listWorkflowsPlugin: (sdk: {
         triggers: {
             selected_api: string;
             action: string;
-            status: "pending" | "active" | "unclaimed" | "releasing" | "released" | "failed";
+            status: "failed" | "pending" | "active" | "unclaimed" | "releasing" | "released";
             authentication_id?: string | null | undefined;
             params?: Record<string, unknown> | undefined;
         }[];

package/dist/plugins/codeSubstrate/listWorkflows/schemas.d.ts

@@ -14,12 +14,12 @@ export declare const WorkflowItemSchema: z.ZodObject<{
         authentication_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         status: z.ZodEnum<{
+            failed: "failed";
             pending: "pending";
             active: "active";
             unclaimed: "unclaimed";
             releasing: "releasing";
             released: "released";
-            failed: "failed";
         }>;
     }, z.core.$strip>>;
     created_at: z.ZodString;
@@ -55,12 +55,12 @@ export declare const ListWorkflowsApiResponseSchema: z.ZodObject<{
             authentication_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             status: z.ZodEnum<{
+                failed: "failed";
                 pending: "pending";
                 active: "active";
                 unclaimed: "unclaimed";
                 releasing: "releasing";
                 released: "released";
-                failed: "failed";
             }>;
         }, z.core.$strip>>;
         created_at: z.ZodString;

package/dist/plugins/codeSubstrate/publishWorkflowVersion/index.d.ts

@@ -37,7 +37,7 @@ export declare const publishWorkflowVersionPlugin: (sdk: {
         triggers: {
             selected_api: string;
             action: string;
-            status: "pending" | "active" | "unclaimed" | "releasing" | "released" | "failed";
+            status: "failed" | "pending" | "active" | "unclaimed" | "releasing" | "released";
             authentication_id?: string | null | undefined;
             params?: Record<string, unknown> | undefined;
         }[];

package/dist/plugins/codeSubstrate/shared-schemas.d.ts

@@ -13,12 +13,12 @@ export declare const WorkflowVersionTriggerConfigSchema: z.ZodObject<{
     params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
 export declare const WorkflowTriggerStatusSchema: z.ZodEnum<{
+    failed: "failed";
     pending: "pending";
     active: "active";
     unclaimed: "unclaimed";
     releasing: "releasing";
     released: "released";
-    failed: "failed";
 }>;
 export declare const WorkflowTriggerSchema: z.ZodObject<{
     selected_api: z.ZodString;
@@ -26,12 +26,12 @@ export declare const WorkflowTriggerSchema: z.ZodObject<{
     authentication_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     status: z.ZodEnum<{
+        failed: "failed";
         pending: "pending";
         active: "active";
         unclaimed: "unclaimed";
         releasing: "releasing";
         released: "released";
-        failed: "failed";
     }>;
 }, z.core.$strip>;
 //# sourceMappingURL=shared-schemas.d.ts.map

package/dist/plugins/codeSubstrate/triggerWorkflow/index.d.ts

@@ -37,7 +37,7 @@ export declare const triggerWorkflowPlugin: (sdk: {
         triggers: {
             selected_api: string;
             action: string;
-            status: "pending" | "active" | "unclaimed" | "releasing" | "released" | "failed";
+            status: "failed" | "pending" | "active" | "unclaimed" | "releasing" | "released";
             authentication_id?: string | null | undefined;
             params?: Record<string, unknown> | undefined;
         }[];

package/dist/plugins/codeSubstrate/updateWorkflow/index.d.ts

@@ -37,7 +37,7 @@ export declare const updateWorkflowPlugin: (sdk: {
         triggers: {
             selected_api: string;
             action: string;
-            status: "pending" | "active" | "unclaimed" | "releasing" | "released" | "failed";
+            status: "failed" | "pending" | "active" | "unclaimed" | "releasing" | "released";
             authentication_id?: string | null | undefined;
             params?: Record<string, unknown> | undefined;
         }[];

package/dist/plugins/createConnection/index.d.ts

@@ -0,0 +1,189 @@
+import { type CreateConnectionItem } from "./schemas";
+export declare const createConnectionPlugin: (sdk: {
+    getConnectionStartUrl: (options?: {
+        app: string;
+    } | undefined) => Promise<{
+        data: import("../getConnectionStartUrl/schemas").GetConnectionStartUrlItem;
+    }>;
+} & {
+    context: {
+        meta: {
+            getConnectionStartUrl: import("kitcore").PluginMeta<unknown>;
+        };
+    };
+} & {
+    waitForNewConnection: (options?: {
+        app: string;
+        startedAt: number;
+        timeoutMs?: number | undefined;
+        pollIntervalMs?: number | undefined;
+    } | undefined) => Promise<{
+        data: import("../waitForNewConnection/schemas").WaitForNewConnectionItem;
+    }>;
+} & {
+    context: {
+        meta: {
+            waitForNewConnection: import("kitcore").PluginMeta<unknown>;
+        };
+    };
+} & {
+    getApp: (options?: {
+        app: string;
+    } | {
+        appKey: string;
+    } | undefined) => Promise<{
+        data: {
+            slug: string;
+            title: string;
+            key: string;
+            implementation_id: string;
+            description?: string | undefined;
+            is_hidden?: boolean | undefined;
+            auth_type?: string | undefined;
+            actions?: {
+                read?: number | undefined;
+                read_bulk?: number | undefined;
+                write?: number | undefined;
+                search?: number | undefined;
+                search_or_write?: number | undefined;
+                search_and_write?: number | undefined;
+                filter?: number | undefined;
+            } | undefined;
+            is_deprecated?: boolean | undefined;
+            is_beta?: boolean | undefined;
+            is_premium?: boolean | undefined;
+            age_in_days?: number | undefined;
+            banner?: string | undefined;
+            categories?: {
+                id: number;
+                name: string;
+                slug: string;
+            }[] | undefined;
+            images?: {
+                url_16x16?: string | undefined;
+                url_32x32?: string | undefined;
+                url_64x64?: string | undefined;
+                url_128x128?: string | undefined;
+            } | undefined;
+            popularity?: number | undefined;
+            has_filters?: boolean | undefined;
+            has_reads?: boolean | undefined;
+            has_searches?: boolean | undefined;
+            has_searches_or_writes?: boolean | undefined;
+            has_upfront_fields?: boolean | undefined;
+            has_writes?: boolean | undefined;
+            is_built_in?: boolean | undefined;
+            is_featured?: boolean | undefined;
+            is_invite?: boolean | undefined;
+            is_public?: boolean | undefined;
+            is_upcoming?: boolean | undefined;
+            visibility?: string | undefined;
+            primary_color?: string | undefined;
+            secondary_color?: string | undefined;
+            classification?: string | undefined;
+            api_docs_url?: string | undefined;
+            image?: string | undefined;
+            version?: string | undefined;
+        };
+    }>;
+} & {
+    context: {
+        meta: {
+            getApp: import("kitcore").PluginMeta<unknown>;
+        };
+    };
+} & {
+    listApps: (options?: ({
+        search?: string | undefined;
+        apps?: string[] | undefined;
+        appKeys?: string[] | undefined;
+        pageSize?: number | undefined;
+        maxItems?: number | undefined;
+        cursor?: string | undefined;
+    } & {
+        cursor?: string;
+        pageSize?: number;
+        maxItems?: number;
+    }) | undefined) => import("kitcore").PaginatedSdkResult<{
+        slug: string;
+        title: string;
+        key: string;
+        implementation_id: string;
+        description?: string | undefined;
+        is_hidden?: boolean | undefined;
+        auth_type?: string | undefined;
+        actions?: {
+            read?: number | undefined;
+            read_bulk?: number | undefined;
+            write?: number | undefined;
+            search?: number | undefined;
+            search_or_write?: number | undefined;
+            search_and_write?: number | undefined;
+            filter?: number | undefined;
+        } | undefined;
+        is_deprecated?: boolean | undefined;
+        is_beta?: boolean | undefined;
+        is_premium?: boolean | undefined;
+        age_in_days?: number | undefined;
+        banner?: string | undefined;
+        categories?: {
+            id: number;
+            name: string;
+            slug: string;
+        }[] | undefined;
+        images?: {
+            url_16x16?: string | undefined;
+            url_32x32?: string | undefined;
+            url_64x64?: string | undefined;
+            url_128x128?: string | undefined;
+        } | undefined;
+        popularity?: number | undefined;
+        has_filters?: boolean | undefined;
+        has_reads?: boolean | undefined;
+        has_searches?: boolean | undefined;
+        has_searches_or_writes?: boolean | undefined;
+        has_upfront_fields?: boolean | undefined;
+        has_writes?: boolean | undefined;
+        is_built_in?: boolean | undefined;
+        is_featured?: boolean | undefined;
+        is_invite?: boolean | undefined;
+        is_public?: boolean | undefined;
+        is_upcoming?: boolean | undefined;
+        visibility?: string | undefined;
+        primary_color?: string | undefined;
+        secondary_color?: string | undefined;
+        classification?: string | undefined;
+        api_docs_url?: string | undefined;
+        image?: string | undefined;
+        version?: string | undefined;
+    }>;
+} & {
+    context: {
+        meta: {
+            listApps: import("kitcore").PluginMeta<unknown>;
+        };
+    };
+} & {
+    context: import("../eventEmission").EventEmissionContext;
+} & {
+    context: {
+        meta: Record<string, import("kitcore").PluginMeta>;
+    };
+}) => {
+    createConnection: (options?: {
+        app: string;
+        browser: "never" | "auto" | "always";
+        timeoutMs?: number | undefined;
+        pollIntervalMs?: number | undefined;
+    } | undefined) => Promise<{
+        data: CreateConnectionItem;
+    }>;
+} & {
+    context: {
+        meta: {
+            createConnection: import("kitcore").PluginMeta<unknown>;
+        };
+    };
+};
+export type CreateConnectionPluginProvides = ReturnType<typeof createConnectionPlugin>;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/createConnection/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/createConnection/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAIL,KAAK,oBAAoB,EAC1B,MAAM,WAAW,CAAC;AAWnB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAyBX,oBAAoB;;;;;;;;CAqD3C,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG,UAAU,CACrD,OAAO,sBAAsB,CAC9B,CAAC"}

package/dist/plugins/createConnection/index.js

@@ -0,0 +1,71 @@
+import { definePlugin, createPluginMethod } from "kitcore";
+import { setMethodMetadata } from "../eventEmission/method-metadata";
+import { appKeyResolver } from "../../resolvers";
+import openUrl from "../../utils/open-url";
+import { shouldOpenBrowser } from "../../utils/should-open-browser";
+import { CreateConnectionSchema, CreateConnectionItemSchema, } from "./schemas";
+export const createConnectionPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
+    name: "createConnection",
+    categories: ["connection"],
+    type: "create",
+    itemType: "Connection",
+    inputSchema: CreateConnectionSchema,
+    outputSchema: CreateConnectionItemSchema,
+    resolvers: { app: appKeyResolver },
+    formatter: {
+        format: (item) => ({
+            title: `Connection created: ${item.title || item.id}`,
+            id: item.id,
+            details: [
+                { text: `App: ${item.app}`, style: "normal" },
+                { text: `ID:  ${item.id}`, style: "accent" },
+            ],
+        }),
+    },
+    handler: async ({ sdk: inner, options, }) => {
+        const { data: start } = await inner.getConnectionStartUrl({
+            app: options.app,
+        });
+        // Tag this method's scope so eventEmission's onMethodEnd hook
+        // emits the MethodCalled event with `selected_api` set. The inner
+        // call sets metadata in its own scope, so we set it again here for
+        // createConnection's outer scope.
+        setMethodMetadata({ selectedApi: start.app });
+        // console.error (stderr) so JSON output on stdout (CLI --json flag)
+        // stays parseable, and so this works without bare `process` access in
+        // browser bundles — matching open-approval.ts. Always printed: a
+        // failed / skipped browser-open falls back to user copy-paste, so this
+        // is the load-bearing contract.
+        console.error(`\nOpen this URL to complete the connection:\n  ${start.url}\n`);
+        const shouldOpen = options.browser === "always" ||
+            (options.browser === "auto" && shouldOpenBrowser());
+        if (shouldOpen) {
+            try {
+                // Resolves once the OS handler is launched, not when the user
+                // finishes auth — that's waitForNewConnection's job.
+                await openUrl(start.url);
+            }
+            catch {
+                // openUrl can throw on unsupported platforms or when no handler is
+                // available. The URL is already printed to stderr, so the user can
+                // copy it.
+            }
+        }
+        const { data: fresh } = await inner.waitForNewConnection({
+            app: start.app,
+            // Server-stamped mint time: measured on the same clock as a
+            // connection's `date`, so the freshness check is immune to
+            // client/server clock skew.
+            startedAt: start.startedAt,
+            timeoutMs: options.timeoutMs,
+            pollIntervalMs: options.pollIntervalMs,
+        });
+        return {
+            data: CreateConnectionItemSchema.parse({
+                id: fresh.id,
+                app: start.app,
+                title: fresh.title ?? null,
+            }),
+        };
+    },
+}));

package/dist/plugins/createConnection/schemas.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const CreateConnectionSchema: z.ZodObject<{
+    app: z.ZodString & {
+        _def: z.core.$ZodStringDef & import("kitcore").PositionalMetadata;
+    };
+    browser: z.ZodDefault<z.ZodEnum<{
+        never: "never";
+        auto: "auto";
+        always: "always";
+    }>>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    pollIntervalMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type CreateConnectionOptions = z.infer<typeof CreateConnectionSchema>;
+export declare const CreateConnectionItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    app: z.ZodString;
+    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type CreateConnectionItem = z.infer<typeof CreateConnectionItemSchema>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/createConnection/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/createConnection/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;iBA4BhC,CAAC;AAEJ,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE7E,eAAO,MAAM,0BAA0B;;;;iBAoBK,CAAC;AAE7C,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}

package/dist/plugins/createConnection/schemas.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { AppPropertySchema } from "../../types/properties";
+export const CreateConnectionSchema = z
+    .object({
+    app: AppPropertySchema,
+    browser: z
+        .enum(["auto", "always", "never"])
+        .default("auto")
+        .describe("When to auto-open the URL in a browser. `auto` (default) opens in local sessions and skips opening in CI / SSH / headless-Linux. `always` forces the open attempt. `never` skips it. The URL is always printed to stderr regardless — a failed or skipped open degrades gracefully to copy-paste."),
+    timeoutMs: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("How long to wait for the user to complete the connection flow before giving up. Default 5 minutes (300_000)."),
+    pollIntervalMs: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("Delay before the first poll request, in ms. Default 3 seconds (3_000). Subsequent polling cadence is managed by the SDK's polling primitive (backoff with sane defaults)."),
+})
+    .describe("Create a new app connection, end-to-end. Mints the start URL via `get-connection-start-url`, prints it to stderr, opportunistically opens it in a browser when it looks safe to do so (skipping CI / SSH / headless-Linux by default — pass `--browser always` to force, `--browser never` to suppress), then polls via `wait-for-new-connection` until the user completes OAuth and the new connection appears. Returns the connection.\n\nThis is the right command for most callers. Reach for the lower-level building blocks when you want either of: (a) hand off the URL and *not* block on completion — call `get-connection-start-url` alone, no `wait-for-new-connection` needed, or (b) do something custom between minting the URL and waiting — call `get-connection-start-url`, do your work (email or DM the URL, render a QR code, etc.), then `wait-for-new-connection`.");
+export const CreateConnectionItemSchema = z
+    .object({
+    id: z
+        .string()
+        .describe("The new connection's ID. Public UUID when available, falling back to the numeric ID."),
+    app: z
+        .string()
+        .describe("Versionless app key the connection was created for (e.g., 'SlackCLIAPI')."),
+    title: z
+        .string()
+        .nullable()
+        .optional()
+        .describe("Human-readable connection title set by the auth flow, when available."),
+})
+    .describe("The newly created connection.");