@cobaltio/cobalt-js 9.2.0-beta.6 → 9.2.0

package/.claude/skills/method/SKILL.md

@@ -0,0 +1,282 @@
+---
+name: method
+description: Add a new public API method to the Cobalt SDK with types, JSDoc, and endpoint mapping. Use when adding new SDK functionality.
+metadata:
+  author: iamtraction
+  version: "1.0.0"
+  argument-hint: <method-name>
+---
+
+# Add SDK Method
+
+Add a new public API method to the Cobalt class with TypeScript types, JSDoc documentation, and backend endpoint mapping.
+
+## Usage
+
+The user provides a method name (e.g., "getWorkflows", "createConfig") and describes the backend endpoint it maps to.
+
+## Steps
+
+1. **Ask for details** if not provided: method name, HTTP method, endpoint URL, request payload shape, response shape, whether it supports pagination
+2. **Define TypeScript interfaces** — request payload and response types
+3. **Add JSDoc-documented method** to the `Cobalt` class
+4. **Build** to verify compilation
+
+## Implementation Order
+
+1. **Interfaces** — Define request/response types (before the class)
+2. **Method** — Add to `Cobalt` class with JSDoc
+3. **Build** — Run `npm run build` to generate `.js` and `.d.ts`
+
+## Interface Template
+
+```ts
+// Add before the Cobalt class in cobalt.ts
+
+/** The payload for creating a resource. */
+export interface CreateResourcePayload {
+    /** The resource name. */
+    name: string;
+    /** Optional description. */
+    description?: string;
+    /** Configuration object. */
+    config?: Record<string, unknown>;
+}
+
+/** A resource object. */
+export interface Resource {
+    /** The resource ID. */
+    _id: string;
+    /** The resource name. */
+    name: string;
+    /** The resource description. */
+    description?: string;
+    /** When the resource was created. */
+    createdAt: string;
+    /** When the resource was last updated. */
+    updatedAt: string;
+}
+```
+
+## Method Templates
+
+### GET Request (single item)
+
+```ts
+/**
+ * Returns the resource details for the specified resource ID.
+ * @param {String} id The resource ID.
+ * @returns {Promise<Resource>} The resource details.
+ */
+public async getResource(id: string): Promise<Resource> {
+    const res = await fetch(`${this.baseUrl}/api/v2/f-sdk/resource/${id}`, {
+        headers: {
+            authorization: `Bearer ${this.token}`,
+        },
+    });
+
+    if (res.status >= 400 && res.status < 600) {
+        const error = await res.json();
+        throw error;
+    }
+
+    return await res.json();
+}
+```
+
+### GET Request (list with optional overloads)
+
+```ts
+/**
+ * Returns the list of all resources.
+ * @returns {Promise<Resource[]>} The list of resources.
+ */
+public async getResources(): Promise<Resource[]>;
+/**
+ * Returns the resource details for the specified slug.
+ * @param {String} slug The resource slug.
+ * @returns {Promise<Resource>} The resource details.
+ */
+public async getResources(slug: string): Promise<Resource>;
+public async getResources(slug?: string): Promise<Resource | Resource[]> {
+    const res = await fetch(`${this.baseUrl}/api/v2/f-sdk/resource${slug ? `/${slug}` : ""}`, {
+        headers: {
+            authorization: `Bearer ${this.token}`,
+        },
+    });
+
+    if (res.status >= 400 && res.status < 600) {
+        const error = await res.json();
+        throw error;
+    }
+
+    return await res.json();
+}
+```
+
+### POST Request (with JSON body)
+
+```ts
+/**
+ * Creates a new resource with the specified configuration.
+ * @param {CreateResourcePayload} payload The resource configuration.
+ * @returns {Promise<Resource>} The created resource.
+ */
+public async createResource(payload: CreateResourcePayload): Promise<Resource> {
+    const res = await fetch(`${this.baseUrl}/api/v2/f-sdk/resource`, {
+        method: "POST",
+        headers: {
+            authorization: `Bearer ${this.token}`,
+            "content-type": "application/json",
+        },
+        body: JSON.stringify(payload),
+    });
+
+    if (res.status >= 400 && res.status < 600) {
+        const error = await res.json();
+        throw error;
+    }
+
+    return await res.json();
+}
+```
+
+### PUT Request (update)
+
+```ts
+/**
+ * Updates an existing resource.
+ * @param {String} id The resource ID.
+ * @param {Partial<CreateResourcePayload>} payload The fields to update.
+ * @returns {Promise<Resource>} The updated resource.
+ */
+public async updateResource(id: string, payload: Partial<CreateResourcePayload>): Promise<Resource> {
+    const res = await fetch(`${this.baseUrl}/api/v2/f-sdk/resource/${id}`, {
+        method: "PUT",
+        headers: {
+            authorization: `Bearer ${this.token}`,
+            "content-type": "application/json",
+        },
+        body: JSON.stringify(payload),
+    });
+
+    if (res.status >= 400 && res.status < 600) {
+        const error = await res.json();
+        throw error;
+    }
+
+    return await res.json();
+}
+```
+
+### DELETE Request
+
+```ts
+/**
+ * Deletes the specified resource.
+ * @param {String} id The resource ID.
+ * @returns {Promise<unknown>} The deletion result.
+ */
+public async deleteResource(id: string): Promise<unknown> {
+    const res = await fetch(`${this.baseUrl}/api/v2/f-sdk/resource/${id}`, {
+        method: "DELETE",
+        headers: {
+            authorization: `Bearer ${this.token}`,
+        },
+    });
+
+    if (res.status >= 400 && res.status < 600) {
+        const error = await res.json();
+        throw error;
+    }
+
+    return await res.json();
+}
+```
+
+### Paginated GET Request
+
+```ts
+/**
+ * Returns a paginated list of resources.
+ * @param {Object} [params] Pagination parameters.
+ * @param {Number} [params.page] The page number.
+ * @param {Number} [params.limit] The number of items per page.
+ * @returns {Promise<PaginatedResponse<Resource>>} The paginated list.
+ */
+public async listResources(params?: { page?: number; limit?: number }): Promise<PaginatedResponse<Resource>> {
+    const query = new URLSearchParams();
+    if (params?.page) query.set("page", String(params.page));
+    if (params?.limit) query.set("limit", String(params.limit));
+
+    const res = await fetch(`${this.baseUrl}/api/v2/f-sdk/resources?${query}`, {
+        headers: {
+            authorization: `Bearer ${this.token}`,
+        },
+    });
+
+    if (res.status >= 400 && res.status < 600) {
+        const error = await res.json();
+        throw error;
+    }
+
+    return await res.json();
+}
+```
+
+## Existing Patterns Reference
+
+### Error Handling Pattern (used by ALL methods)
+```ts
+if (res.status >= 400 && res.status < 600) {
+    const error = await res.json();
+    throw error;
+}
+```
+
+### Auth Header (used by ALL methods)
+```ts
+headers: {
+    authorization: `Bearer ${this.token}`,
+}
+```
+
+### Custom Headers (some methods pass app slug)
+```ts
+headers: {
+    authorization: `Bearer ${this.token}`,
+    "content-type": "application/json",
+    slug,  // Custom header for app context
+}
+```
+
+### PaginatedResponse Generic
+```ts
+interface PaginatedResponse<T> {
+    docs: T[];
+    totalDocs: number;
+    limit: number;
+    totalPages: number;
+    page: number;
+}
+```
+
+## Verification
+
+```bash
+npm run build     # Compile to cobalt.js + cobalt.d.ts
+npm run docs:llms # Generate TypeDoc (optional)
+```
+
+## Important
+
+- **Zero dependencies** — only use native `fetch`, no external HTTP libraries
+- **JSDoc on every method** — TypeDoc generates SDK documentation from these
+- **JSDoc on every interface field** — include description for each property
+- **Method overloads** — use TypeScript overloads for methods with optional parameters that change return type
+- **Error handling** — always check `res.status >= 400 && res.status < 600` and throw the parsed error
+- **`Bearer` auth** — all methods include `authorization: Bearer ${this.token}`
+- **Single file** — everything goes in `cobalt.ts`, no separate files
+- **Export interfaces** — all types are exported for consumer use
+- **Backward compatibility** — never rename or remove existing methods, use `@deprecated` JSDoc tag
+- **Build output** — `cobalt.js` (CommonJS) + `cobalt.d.ts` (type declarations)

package/.claude/skills/review-pr/SKILL.md

@@ -0,0 +1,80 @@
+---
+name: review-pr
+description: Review a pull request for code quality, patterns consistency, and potential issues. Use when asked to review a PR by number or URL.
+metadata:
+  author: iamtraction
+  version: "1.0.0"
+  argument-hint: <pr-number-or-url>
+---
+
+# Review Pull Request
+
+Perform a thorough code review of a GitHub pull request.
+
+## Usage
+
+The user provides a PR number or URL (e.g., `123`, `https://github.com/gocobalt/cobalt-js/pull/123`).
+
+## Steps
+
+1. **Fetch PR details** using `gh pr view {number} --json title,body,files,additions,deletions,baseRefName,headRefName`
+2. **Fetch the diff** using `gh pr diff {number}`
+3. **Analyze every changed file** against the checklist below
+4. **Output a structured review** with findings grouped by severity
+
+## Review Checklist
+
+### SDK Design
+- Zero runtime dependencies maintained — no new `dependencies` added to package.json
+- Public API backward compatible — no breaking changes without major version bump
+- Deprecated methods/fields marked with `@deprecated` JSDoc, not removed
+- New public methods have JSDoc with `@param` and `@returns`
+- New interfaces/types exported correctly
+- Error handling follows existing pattern: throw parsed JSON for 4xx/5xx responses
+- Native `fetch` API used — no axios, node-fetch, or other HTTP libraries
+- OAuth popup flow: no changes that break `window.open()` + polling pattern
+
+### Code Quality
+- TypeScript strict mode passes — no `any` types unless truly unavoidable
+- All public methods have explicit return types
+- No unused imports or dead code
+- No hardcoded URLs — base URL comes from constructor option
+- Bearer token attached to all requests via `Authorization` header
+- Pagination support: `page`/`limit` parameters where applicable
+
+### Backward Compatibility
+- Existing method signatures unchanged (or new optional params added at the end)
+- Existing interfaces only extended, never fields removed
+- `connected` and `auth_type` fields preserved (deprecated, not removed)
+- AuthType enum values unchanged
+
+### Security
+- No secrets or tokens in code
+- No `eval()`, `Function()`, or dynamic code execution
+- Token not logged or exposed in error messages
+
+### Naming & Style
+- 4 spaces indentation, double quotes, semicolons
+- camelCase for methods/variables, PascalCase for interfaces/types/enums
+- Method names follow existing patterns: `get*`, `create*`, `update*`, `delete*`, `execute*`
+
+## Output Format
+
+```
+## PR Review: #{number} — {title}
+
+### Summary
+Brief description of what the PR does.
+
+### Critical Issues
+- **[file:line]** Description of critical issue
+
+### Suggestions
+- **[file:line]** Description of improvement suggestion
+
+### Nits
+- **[file:line]** Minor style/preference issue
+
+### Positive Notes
+- Things done well worth calling out
+```

package/.claude/skills/style/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: style
+description: Code style and formatting conventions for this codebase. Reference this when writing or reviewing code to ensure consistency.
+metadata:
+  author: iamtraction
+  version: "1.0.0"
+  user-invocable: false
+---
+
+# Code Style Guide
+
+These conventions apply to all code written in this codebase. Follow them when creating, modifying, or reviewing code.
+
+## Formatting
+
+- **Indentation:** 4 spaces — never tabs
+- **Quotes:** Double quotes for strings
+- **Semicolons:** Always
+- **Line endings:** Unix (LF)
+- **Trailing commas:** Use trailing commas in multiline arrays, objects, function parameters, and imports
+- **Blank lines:** One blank line between top-level declarations (imports, interfaces, functions, exports). No multiple consecutive blank lines.
+- **Braces:** Opening brace on the same line (`if (...) {`), closing brace on its own line
+- **Bracket spacing:** Spaces inside object braces — `{ key: value }`, not `{key: value}`
+- **Template literals:** Prefer template literals over string concatenation
+
+## Naming
+
+- **Functions/variables:** camelCase — `getApp`, `executeWorkflow`, `configId`
+- **Constants:** SCREAMING_SNAKE_CASE for true constants
+- **Interfaces/Types:** PascalCase, no `I` prefix — `Application`, `Config`, `Execution`
+- **Enums:** PascalCase name, PascalCase members — `AuthType.OAuth2`, `AuthStatus.Active`
+- **Booleans:** Prefix with `is`, `has`, `can`, `should` — `isConnected`, `hasToken`
+
+## TypeScript
+
+- **Strict typing:** Avoid `any` — use `unknown` when the type is genuinely unknown, then narrow
+- **Interfaces over types:** Prefer `interface` for object shapes, `type` for unions, intersections, and utility types
+- **Explicit return types:** Add them for all public methods — this is a published SDK, types are the API contract
+- **Non-null assertions:** Avoid `!` — prefer optional chaining (`?.`) and nullish coalescing (`??`)
+
+## SDK-Specific Conventions
+
+- **Zero dependencies:** This SDK has no runtime dependencies. Do not add any. Use native `fetch` API.
+- **Single class:** All public API lives on the `Cobalt` class. Keep it that way.
+- **Backward compatibility:** Mark deprecated fields/methods with `@deprecated` JSDoc tag — never remove them without a major version bump
+- **Error propagation:** Throw parsed JSON error responses for 4xx/5xx — don't catch and transform in the SDK. Let consumers handle errors.
+- **JSDoc on all public methods:** Every public method must have a JSDoc block with `@param` and `@returns` tags. This generates the TypeDoc documentation.
+
+## Functions
+
+- **Method style:** Use class methods for the `Cobalt` class
+- **Private methods:** Mark with `private` keyword — `private oauth(...)`, `private keybased(...)`
+- **Async/await:** All API calls are async — use `async`/`await`, never raw `.then()` chains in new code
+- **Early returns:** Prefer early returns to reduce nesting
+
+## Error Handling
+
+- **Fetch errors:** Check `res.status >= 400 && res.status < 600`, parse JSON, throw it
+- **No try/catch in SDK methods** — let errors propagate to the consumer
+- **OAuth polling:** Catch errors in the polling interval and log to console — don't reject the promise on transient failures
+
+## Comments
+
+- **JSDoc for all public API** — every exported method, interface, enum, and type
+- **No obvious comments** — don't describe what the code does when it's self-evident
+- **Why, not what** — comment the reasoning, not the mechanics
+- **No commented-out code** — delete it; git has history

package/.claude/skills/verify/SKILL.md

@@ -0,0 +1,85 @@
+---
+name: verify
+description: Verify code quality, catch bugs, and validate implementation against codebase patterns. Use for testing, linting, type-checking, and manual review.
+metadata:
+  author: iamtraction
+  version: "1.0.0"
+  argument-hint: <file-path-or-feature>
+---
+
+# Verify & Test
+
+Perform comprehensive verification of code changes.
+
+## Usage
+
+The user provides a file path, feature name, or asks to verify recent changes. If no argument, verify all uncommitted changes.
+
+## Verification Steps
+
+### 1. Static Analysis
+Run these checks and report results:
+```bash
+npm run build         # TypeScript compilation → cobalt.js + cobalt.d.ts
+```
+
+### 2. Type Safety Review
+- Check for `any` types that should be properly typed
+- Verify all public methods have explicit return types
+- Ensure interface fields match the backend API responses
+- Verify generic type parameters on Promise return types
+- Check that deprecated fields are still present with `@deprecated` JSDoc
+
+### 3. SDK Design Compliance
+Verify the code follows SDK conventions:
+- **Zero dependencies**: No runtime dependencies added
+- **Native fetch**: No HTTP libraries — uses `fetch` API only
+- **Single class**: All public API on the `Cobalt` class
+- **Error handling**: 4xx/5xx → parse JSON → throw (no swallowing errors)
+- **JSDoc on all public methods**: `@param`, `@returns` tags
+- **Backward compatibility**: No removed methods/fields, no changed signatures
+
+### 4. Runtime Safety Review
+Check for common issues:
+- **Missing error checks** — `res.status >= 400` not checked after fetch
+- **OAuth polling** — `setInterval` properly cleaned up with `clearInterval`
+- **Popup handling** — `window.open` result checked for null (popup blocked)
+- **Token usage** — `this.token` attached to all requests
+- **Base URL** — uses `this.baseUrl`, no hardcoded URLs
+
+### 5. Backward Compatibility Check
+- Existing method signatures unchanged
+- Existing interfaces only extended (no field removal)
+- Enum values unchanged
+- `getApp()` overload still works for both single and all apps
+
+## Output Format
+
+```
+## Verification Report
+
+### Build: PASS/FAIL
+Details...
+
+### Type Safety: X issues found
+- [file:line] Description
+
+### SDK Design: X issues found
+- [file:line] Description
+
+### Runtime Safety: X issues found
+- [file:line] Description
+
+### Backward Compatibility: X issues found
+- [file:line] Description
+
+### Overall: PASS / NEEDS FIXES
+Summary and recommended actions.
+```
+
+## Important
+
+- Always run `npm run build` — don't skip compilation check
+- Verify both `cobalt.js` and `cobalt.d.ts` are generated correctly
+- Be specific about issues — include file paths and line numbers
+- Breaking changes require major version bump — flag them as critical

package/.github/workflows/npm-publish.yml

@@ -11,24 +11,23 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
+      - uses: actions/checkout@v6
+      - uses: actions/setup-node@v6
         with:
-          node-version: 16
+          node-version: 24
       - run: |
           echo 'NPM Token ${secrets.NPM_TOKEN}'
           npm ci
           npm test
-          
 
   publish-npm:
     needs: build
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
+      - uses: actions/checkout@v6
+      - uses: actions/setup-node@v6
         with:
-          node-version: 16
+          node-version: 24
           registry-url: https://registry.npmjs.org/
       - run: npm ci
       - run: npm publish

package/CLAUDE.md

@@ -2,36 +2,116 @@
 
 This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
 
+## Project Overview
+
+Cobalt JS SDK (`@cobaltio/cobalt-js`) — a zero-dependency TypeScript frontend SDK for integrating with the Cobalt platform. Provides methods for application connection (OAuth2 + key-based), configuration management, workflow execution, and execution monitoring. Published to npm as a public package. Single-file library (`cobalt.ts`, ~970 lines).
+
 ## Commands
 
 ```bash
-npm run build      # Compile cobalt.ts → cobalt.js + cobalt.d.ts
-npm run docs       # Generate HTML docs (docs/) from cobalt.ts via TypeDoc
-npm run docs:llms  # Generate docs/llms.txt in LLM-friendly markdown format
+npm run build          # Compile TypeScript (tsc) → cobalt.js + cobalt.d.ts
+npm run docs           # Generate TypeDoc HTML documentation
+npm run docs:llms      # Generate LLM-optimized markdown docs (docs/llms.txt)
 ```
 
-There is no test suite (`npm test` only prints a warning).
+No test runner is configured. No runtime dependencies.
+
+## Build Output
+
+- `cobalt.js` — Compiled CommonJS module (main entry point)
+- `cobalt.d.ts` — TypeScript type definitions
+- `docs/` — Generated TypeDoc documentation (HTML + `llms.txt`)
+
+Published to npm (`@cobaltio/cobalt-js`) and served via jsDelivr CDN.
 
 ## Architecture
 
-This is a single-file TypeScript SDK (`cobalt.ts`) that compiles to `cobalt.js` + `cobalt.d.ts`. All source changes belong in `cobalt.ts`; the `.js` and `.d.ts` files are auto-generated and committed alongside (consumers use the compiled output directly).
+### Single-Class Design
+The entire SDK is a single `Cobalt` class using native `fetch` API. No external dependencies.
+
+### Authentication
+- Bearer token auth via `Authorization` header on all requests
+- Token set via constructor option or `cobalt.token = "..."` after initialization
+- Default base URL: `https://api.gocobalt.io` (configurable via `baseUrl` option)
+
+### Public API
+
+**Constructor:**
+```typescript
+const cobalt = new Cobalt({ token?: string, baseUrl?: string })
+```
+
+**Application Management:**
+- `getApp(): Promise<Application[]>` — Get all enabled apps
+- `getApp(slug: string): Promise<Application>` — Get specific app
+- `getApps(): Promise<Application[]>` — Alias for getApp()
+
+**Connection:**
+- `connect({ slug, type?, payload? }): Promise<boolean>` — Connect app (OAuth2 popup or key-based POST)
+- `disconnect(slug, type?): Promise<unknown>` — Disconnect app
+
+**Configuration:**
+- `config(payload): Promise<Config>` — Create/get config
+- `getConfigs(slug): Promise<{ config_id }[]>` — List configs
+- `getConfig(slug, configId?): Promise<Config>` — Get specific config
+- `updateConfig(payload): Promise<Config>` — Update config
+- `deleteConfig(slug, configId?): Promise<unknown>` — Delete config
+- `getConfigField(slug, fieldId, workflowId?): Promise<Config>` — Get field
+- `updateConfigField(slug, fieldId, value, workflowId?): Promise<Config>` — Update field
+- `deleteConfigField(slug, fieldId, workflowId?): Promise<unknown>` — Delete field
+- `getFieldOptions(lhs, slug, fieldId, workflowId?): Promise<RuleOptions>` — Rule engine options
+
+**Workflows:**
+- `getWorkflows(params?): Promise<PaginatedResponse<PublicWorkflow>>` — List workflows
+- `createWorkflow(params): Promise<PublicWorkflow>` — Create workflow
+- `deleteWorkflow(workflowId): Promise<unknown>` — Delete workflow
+- `getWorkflowPayload(workflowId): Promise<WorkflowPayloadResponse>` — Get payload schema
+- `executeWorkflow(options): Promise<unknown>` — Execute workflow
+
+**Executions:**
+- `getExecutions({ page?, limit? }?): Promise<PaginatedResponse<Execution>>` — List executions
+- `getExecution(executionId): Promise<Execution>` — Get execution details
+
+### Key Types
+
+```typescript
+enum AuthType { OAuth2 = "oauth2", KeyBased = "keybased" }
+enum AuthStatus { Active = "active", Expired = "expired" }
+```
+
+**Application** — app_id, name, slug, icon, tags, auth_type_options, connected_accounts (with status)
+**Config** — slug, config_id, fields (ConfigField[]), workflows (ConfigWorkflow[]), field_errors
+**Execution** — status (COMPLETED/RUNNING/ERRORED/STOPPED/STOPPING/TIMED_OUT), nodes with node_status, completion_percentage
+
+### OAuth Flow
+- Opens popup via `window.open(oauthUrl)`
+- Polls `/api/v2/f-sdk/application/{slug}` every 3 seconds
+- Resolves when `connected_accounts` shows active OAuth connection or window closes
+
+### Error Handling
+All 4xx/5xx HTTP responses throw the parsed JSON error response. No try/catch in SDK — errors propagate to caller.
 
-**Single class:** The entire SDK is one `Cobalt` class exported from `cobalt.ts`. It wraps REST API calls to `https://api.gocobalt.io` (configurable via `baseUrl`). Authentication uses a session token (`Bearer` header) that callers set via the constructor or `cobalt.token`.
+### Backend API Endpoints Used
+All requests include `Authorization: Bearer ${token}`:
+- Auth service: `/api/v3/org/basics`, `/api/v2/public/linked-account`
+- Apps: `/api/v2/f-sdk/application`, `/api/v1/{slug}/integrate`, `/api/v2/app/{slug}/save`
+- Config: `/api/v2/f-sdk/config`, `/api/v2/f-sdk/slug/{slug}/config/{configId}`, `/api/v2/public/config/field/{fieldId}`
+- Workflows: `/api/v2/public/workflow`, `/api/v2/public/workflow/{id}/execute`
+- Executions: `/api/v2/public/execution`
 
-**API patterns:**
-- All HTTP calls use native `fetch()`
-- Throws on HTTP 400+ responses
-- Endpoints are primarily `/api/v2/`, with some `/api/v3/` (e.g. `getAccountDetails`)
+### Browser & Node Compatibility
+- **Browser:** Uses native `fetch`, `window.open()` for OAuth popups, `setInterval` for polling
+- **Node.js:** Works in Node 18+ (native fetch). No browser APIs called in non-OAuth flows.
 
-**Key functional areas in `cobalt.ts`:**
-- Account: `getAccountDetails`, `updateAccount`
-- Apps/Auth configs: `getApp`, `getApps`, `getAuthConfigs`, `connect`, `disconnect`
-- Config (integration settings): `config`, `getConfigs`, `getConfig`, `updateConfig`, `deleteConfig`, and field-level CRUD
-- Workflows: `getWorkflows`, `createWorkflow`, `deleteWorkflow`, `getWorkflowPayload`, `executeWorkflow`
-- Executions: `getExecutions`, `getExecution`
+## TypeScript Configuration
 
-**Auth types:** `oauth2` (opens popup window) and `keybased` (submits credential fields). The `connect()` method dispatches to `private oauth()` or `private keybased()` based on `AuthType`.
+- Target: ES6, Module: CommonJS
+- Strict mode enabled
+- Declarations emitted (`cobalt.d.ts`)
+- LF line endings enforced
 
-## Distribution
+## Version History
 
-Published as `@cobaltio/cobalt-js` on npm. The CI workflow (`.github/workflows/npm-publish.yml`) publishes on GitHub release creation. The package targets CommonJS (`module: CommonJS`, `target: ES2020`) and is usable in both Node and browsers (via CDN).
+- **v9.x:** Added `getWorkflowPayload()`, `executeWorkflow()`, multi-auth support
+- **v8.x:** Introduced `AuthType` enum for multi-auth
+- Deprecated fields maintained for backward compatibility