@offsida/sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Offsida
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './zod.js';
+export type * from '@offsida/types';

package/dist/index.js

@@ -0,0 +1,5 @@
+// The authoring entry: the Zod-inferring `define*` helpers plus a re-export of the
+// contract types, so an author needs a single import (`@offsida/sdk`). Prefer raw
+// JSON Schema over Zod? Import the types from here (or `@offsida/types`) and write
+// `... satisfies IntegrationPackage` by hand.
+export * from './zod.js';

package/dist/zod.d.ts

@@ -0,0 +1,50 @@
+import { z, type ZodType } from 'zod';
+import type { ActionCtx, AuthDescriptor, ConfigFieldDefinition, OAuthDescriptor, IntegrationPackage, JsonSchema, TriggerDefinition } from '@offsida/types';
+type SchemaInput = ZodType | JsonSchema;
+export type ZodAction<I = unknown> = {
+    title?: string;
+    requires?: string[];
+    inputSchema?: SchemaInput;
+    outputSchema?: SchemaInput;
+    run(input: I, ctx: ActionCtx): unknown | Promise<unknown>;
+};
+export type ZodConnectionDefinition = {
+    name: string;
+    title?: string;
+    description?: string;
+    secretsSchema: SchemaInput;
+    auth?: AuthDescriptor;
+    oauth?: OAuthDescriptor;
+    test?(creds: unknown, ctx: ActionCtx): unknown | Promise<unknown>;
+    authorize?(ctx: {
+        config: unknown;
+        input?: unknown;
+    }): unknown | Promise<unknown>;
+    exchange?(ctx: {
+        config: unknown;
+        clientSecret?: string;
+        input?: unknown;
+    }, args: unknown): unknown | Promise<unknown>;
+    refresh?(ctx: {
+        config: unknown;
+        clientSecret?: string;
+        input?: unknown;
+    }, args: unknown): unknown | Promise<unknown>;
+};
+export type ZodIntegrationPackage = {
+    connections?: ZodConnectionDefinition[];
+    actions?: Record<string, ZodAction>;
+    triggers?: TriggerDefinition[];
+    config?: ConfigFieldDefinition[];
+};
+export declare function definePackage(pkg: ZodIntegrationPackage): IntegrationPackage;
+export declare function defineAction<S extends ZodType>(a: {
+    title?: string;
+    requires?: string[];
+    inputSchema?: S;
+    outputSchema?: SchemaInput;
+    run(input: z.infer<S>, ctx: ActionCtx): unknown | Promise<unknown>;
+}): ZodAction<z.infer<S>>;
+export declare function defineConnection(c: ZodConnectionDefinition): ZodConnectionDefinition;
+export declare function defineTrigger(t: TriggerDefinition): TriggerDefinition;
+export {};

package/dist/zod.js

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+function isZod(v) {
+    return !!v && typeof v === 'object' && typeof v.safeParse === 'function';
+}
+function toJsonSchema(s) {
+    if (s === undefined)
+        return undefined;
+    if (isZod(s))
+        return z.toJSONSchema(s, { target: 'draft-2020-12' });
+    return s;
+}
+export function definePackage(pkg) {
+    return {
+        connections: pkg.connections?.map((c) => ({ ...c, secretsSchema: toJsonSchema(c.secretsSchema) })),
+        actions: pkg.actions
+            ? Object.fromEntries(Object.entries(pkg.actions).map(([name, a]) => [
+                name,
+                { ...a, inputSchema: toJsonSchema(a.inputSchema), outputSchema: toJsonSchema(a.outputSchema) },
+            ]))
+            : undefined,
+        triggers: pkg.triggers,
+        config: pkg.config,
+    };
+}
+// Typed action helper — infers run()'s input type from a Zod inputSchema.
+export function defineAction(a) {
+    return a;
+}
+export function defineConnection(c) {
+    return c;
+}
+export function defineTrigger(t) {
+    return t;
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@offsida/sdk",
+  "version": "0.1.0",
+  "type": "module",
+  "sideEffects": false,
+  "description": "Authoring helpers for Offsida integration packages — define connections, actions, and triggers with Zod schemas.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mark-ironbarklabs/offsida.web.git",
+    "directory": "lib/offsida/sdk"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@offsida/types": "0.1.0"
+  },
+  "peerDependencies": {
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.3",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.6",
+    "zod": "^4.4.3"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}