@koda-sl/baker-cli 0.39.29 → 0.67.0-dev.3a23b0e68

package/dist/engine/index.d.ts

@@ -0,0 +1,422 @@
+import { z } from 'zod';
+
+type RawAssetOutput = {
+    kind: "image" | "video" | "audio" | "json" | "text" | "font";
+    url: string;
+    sha256: string;
+    mime: string;
+    metadata?: Record<string, unknown>;
+};
+type ExecRequest = {
+    nodeType: string;
+    nodeVersion: string;
+    params: unknown;
+    inputs: Record<string, unknown>;
+    /** Run-scoped dedupe key: the backend replays the stored response for a
+     * repeated key instead of re-dispatching to the provider (and re-charging). */
+    idempotency_key?: string;
+};
+type ExecResponse = {
+    outputs: Record<string, RawAssetOutput | RawAssetOutput[] | unknown>;
+    credits_charged?: number;
+    duration_ms?: number;
+};
+type ArtifactResponse = {
+    artifact: {
+        kind: string;
+        name: string;
+        version: string;
+        description?: string;
+        tags?: string[];
+        slots: Record<string, RawAssetOutput | RawAssetOutput[]>;
+    };
+    manifest_sha: string;
+};
+declare class BackendClient$1 {
+    private readonly http;
+    constructor(opts: {
+        baseUrl: string;
+        apiKey: string;
+        fetchFn?: typeof fetch;
+        timeoutMs?: number;
+        maxRetries?: number;
+    });
+    exec(req: ExecRequest, signal?: AbortSignal): Promise<ExecResponse>;
+    presignAssetUpload(sha256: string, mime: string, signal?: AbortSignal): Promise<{
+        putUrl: string;
+        publicUrl: string;
+    }>;
+    getArtifact(kind: string, name: string, version?: string, signal?: AbortSignal): Promise<ArtifactResponse>;
+}
+
+type ValidationIssue = {
+    path: string;
+    code: string;
+    message: string;
+    received?: unknown;
+    expected?: string;
+    did_you_mean?: string[];
+    node_id?: string;
+    node_type?: string;
+};
+declare class CanvasError extends Error {
+    constructor(message: string);
+}
+declare class ValidationError$1 extends CanvasError {
+    issues: ValidationIssue[];
+    constructor(issues: ValidationIssue[]);
+}
+
+declare const CanvasSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"baker-canvas/1">;
+    cache_salt: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        todo: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>>;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        when: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>>;
+    output: z.ZodOptional<z.ZodObject<{
+        node: z.ZodString;
+        output: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type Canvas = z.infer<typeof CanvasSchema>;
+
+declare const AssetRef: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    url: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+    sha256: z.ZodString;
+    mime: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    kind: z.ZodLiteral<"image">;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    url: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+    sha256: z.ZodString;
+    mime: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    kind: z.ZodLiteral<"video">;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    duration_ms: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    url: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+    sha256: z.ZodString;
+    mime: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    kind: z.ZodLiteral<"audio">;
+    duration_ms: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    url: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+    sha256: z.ZodString;
+    mime: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    kind: z.ZodLiteral<"json">;
+}, z.core.$strip>, z.ZodObject<{
+    url: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+    sha256: z.ZodString;
+    mime: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    kind: z.ZodLiteral<"text">;
+}, z.core.$strip>, z.ZodObject<{
+    url: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+    sha256: z.ZodString;
+    mime: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    kind: z.ZodLiteral<"font">;
+}, z.core.$strip>], "kind">;
+type AssetRef = z.infer<typeof AssetRef>;
+type AssetKind = AssetRef["kind"];
+
+type IngestRemoteArgs = {
+    kind: AssetKind;
+    url: string;
+    sha256: string;
+    mime: string;
+    metadata?: Record<string, unknown>;
+};
+interface AssetStore {
+    rootDir: string;
+    ingestBytes(args: {
+        bytes: Buffer;
+        kind: AssetKind;
+        mime: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<AssetRef>;
+    ingestRemote(args: IngestRemoteArgs): Promise<AssetRef>;
+    /** Local FS path for an asset by sha. Returns undefined if absent. */
+    pathFor(sha: string, mime: string): string;
+    exists(sha: string, mime: string): Promise<boolean>;
+    readBytes(sha: string, mime: string): Promise<Buffer>;
+}
+declare class LocalAssetStore$1 implements AssetStore {
+    rootDir: string;
+    private readonly fetchFn;
+    private readonly maxRemoteAssetBytes;
+    constructor(rootDir: string, fetchFn?: typeof fetch, opts?: {
+        maxRemoteAssetBytes?: number;
+    });
+    pathFor(sha: string, mime: string): string;
+    exists(sha: string, mime: string): Promise<boolean>;
+    readBytes(sha: string, mime: string): Promise<Buffer>;
+    ingestBytes(args: {
+        bytes: Buffer;
+        kind: AssetKind;
+        mime: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<AssetRef>;
+    ingestRemote(args: IngestRemoteArgs): Promise<AssetRef>;
+}
+
+type CacheEntry = {
+    cacheKey: string;
+    nodeType: string;
+    nodeVersion: string;
+    outputs: Record<string, unknown>;
+    refs: string[];
+    createdAt: number;
+};
+interface CacheStore {
+    rootDir: string;
+    get(cacheKey: string): Promise<CacheEntry | null>;
+    put(entry: CacheEntry): Promise<void>;
+}
+declare class LocalCacheStore$1 implements CacheStore {
+    rootDir: string;
+    constructor(rootDir: string);
+    private filePath;
+    get(cacheKey: string): Promise<CacheEntry | null>;
+    put(entry: CacheEntry): Promise<void>;
+}
+
+type LogFn = (line: string) => void;
+type ExecCtx = {
+    canvasRunId: string;
+    nodeId: string;
+    nodeType: string;
+    /** Content-addressed cache key for this node execution. Remote delegation
+     * derives its idempotency key from it so backend retries never double-charge. */
+    cacheKey?: string;
+    client: BackendClient$1;
+    assets: AssetStore;
+    log: LogFn;
+    signal?: AbortSignal;
+};
+
+type CostEstimate = {
+    credits: number;
+    seconds_estimate: number;
+};
+type CostFn<P> = (args: {
+    params: P;
+}) => CostEstimate;
+type ExecuteArgs<I, P> = {
+    inputs: I;
+    params: P;
+    ctx: ExecCtx;
+};
+/**
+ * Node-supplied extra validation hook. Runs after the node's static Zod
+ * schema passes — used by nodes whose param shape depends on external state
+ * (e.g. `hyperframe_render` consults the composition's meta.json).
+ * Returns issue messages keyed by the dotted param path to surface in
+ * `canvas validate` output. Empty array means OK.
+ */
+type ValidateExtraIssue = {
+    path: string;
+    message: string;
+};
+type ValidateExtraFn = (args: {
+    rawParams: unknown;
+    rawInputs: unknown;
+}) => Promise<ValidateExtraIssue[]> | ValidateExtraIssue[];
+/**
+ * Node-supplied cache-key extras hook. Returns extra fields the executor
+ * folds into the cache key alongside `params` — used by nodes whose output
+ * depends on external content (e.g. composition directory contents).
+ */
+type CacheKeyExtrasFn = (args: {
+    params: unknown;
+}) => Promise<Record<string, string>>;
+/**
+ * Per-output asset-kind declaration. Either a static map (most nodes — each
+ * named output produces a fixed kind) or a function of params (e.g. the
+ * `ingest` node, whose output kind is decided by `params.expect`).
+ *
+ * Validators and the dashboard read this to type the output port statically
+ * without running the node. Remote nodes also use it at runtime so the
+ * delegate ingestor knows how to wrap returned bytes.
+ */
+type OutputKindsSpec<P> = Record<string, AssetRef["kind"]> | ((params: P) => Record<string, AssetRef["kind"]>);
+type NodeDefinition<I = unknown, P = unknown, O = unknown> = {
+    id: string;
+    version: string;
+    category: string;
+    summary: string;
+    when_to_use?: string;
+    inputs: z.ZodType<I>;
+    params: z.ZodType<P>;
+    outputs: z.ZodType<O>;
+    /** "local" runs in-process; "remote" delegates to Convex via ctx.client */
+    location: "local" | "remote";
+    cost?: CostFn<P>;
+    validateExtra?: ValidateExtraFn;
+    cacheKeyExtras?: CacheKeyExtrasFn;
+    outputKinds?: OutputKindsSpec<P>;
+    execute: (args: ExecuteArgs<I, P>) => Promise<O>;
+};
+
+declare class NodeRegistry {
+    private readonly byId;
+    register(def: NodeDefinition): void;
+    registerAll(defs: readonly NodeDefinition[]): void;
+    get(id: string): NodeDefinition | undefined;
+    has(id: string): boolean;
+    ids(): string[];
+    all(): NodeDefinition[];
+}
+
+type RunResult = {
+    run_id: string;
+    output: AssetRef | AssetRef[] | unknown;
+    outputs_by_node: Record<string, Record<string, unknown>>;
+    stats: {
+        total_nodes: number;
+        cached_nodes: number;
+        total_credits: number;
+        duration_ms: number;
+    };
+    outputs_dir: string;
+};
+type RunOptions = {
+    signal?: AbortSignal;
+    run_id?: string;
+    cache_policy?: "read_write" | "bypass" | "read_only";
+};
+type EngineOptions = {
+    registry: NodeRegistry;
+    client: BackendClient$1;
+    assets: AssetStore;
+    cache: CacheStore;
+    outputsDir: string;
+    log?: LogFn;
+};
+declare class Engine$1 {
+    private readonly registry;
+    private readonly client;
+    private readonly assets;
+    private readonly cache;
+    private readonly outputsDir;
+    private readonly log;
+    constructor(opts: EngineOptions);
+    validate(canvas: unknown): {
+        ok: true;
+        canvas: Canvas;
+        estimatedCredits: number;
+    } | {
+        ok: false;
+        issues: ValidationIssue[];
+    };
+    /** Async variant — runs every node's `validateExtra` hook in addition to the shallow checks. */
+    validateDeep(canvas: unknown): Promise<({
+        ok: true;
+        canvas: Canvas;
+        estimatedCredits: number;
+    } | {
+        ok: false;
+        issues: ValidationIssue[];
+    }) & {
+        perNodeCredits?: Array<{
+            node_id: string;
+            node_type: string;
+            credits: number;
+        }>;
+    }>;
+    run(input: unknown, opts?: RunOptions): Promise<RunResult>;
+    private runLayers;
+    private writeFinal;
+    private executeOne;
+    private materializeNodeOutputs;
+}
+
+type ValidationResult = {
+    ok: true;
+    canvas: Canvas;
+    estimatedCredits: number;
+} | {
+    ok: false;
+    issues: ValidationIssue[];
+};
+type ValidationDeep = ValidationResult & {
+    /** Per-node credit estimate, in canvas order. Useful for `validate` cost previews. */
+    perNodeCredits?: Array<{
+        node_id: string;
+        node_type: string;
+        credits: number;
+    }>;
+};
+/**
+ * Async second pass that lets each node run its own `validateExtra` hook.
+ * Use this from `canvas validate` so composition-meta checks (and any
+ * future async validators) surface as standard validation issues.
+ *
+ * Returns the same result the sync pass would, with `perNodeCredits` added
+ * when the canvas is structurally OK.
+ */
+declare function validateCanvasDeep$1(input: unknown, registry: NodeRegistry): Promise<ValidationDeep>;
+
+type CatalogEntry = {
+    id: string;
+    version: string;
+    category: string;
+    summary: string;
+    when_to_use?: string;
+    location: "local" | "remote";
+    inputs: unknown;
+    params: unknown;
+    outputs: unknown;
+    cost_estimate_credits?: number;
+    runtime_estimate_seconds?: number;
+};
+type Catalog = {
+    schema: "baker-canvas-catalog/2";
+    generated_at: string;
+    categories: Record<string, string[]>;
+    entries: CatalogEntry[];
+};
+declare function generateCatalog$1(registry: NodeRegistry, opts?: {
+    generatedAt?: string;
+}): Catalog;
+
+declare const BackendClient: typeof BackendClient$1;
+declare const Engine: typeof Engine$1;
+declare const LocalAssetStore: typeof LocalAssetStore$1;
+declare const LocalCacheStore: typeof LocalCacheStore$1;
+declare const validateCanvasDeep: typeof validateCanvasDeep$1;
+declare const generateCatalog: typeof generateCatalog$1;
+declare const ValidationError: typeof ValidationError$1;
+/** Convenience: registry pre-loaded with every node ships with the engine. */
+declare function defaultRegistry(): NodeRegistry;
+/** Build a ready-to-run engine using env vars + the project cwd. */
+declare function createEngineFromEnv(opts?: {
+    cwd?: string;
+    cacheDir?: string;
+    outputsDir?: string;
+    log?: (line: string) => void;
+}): Engine$1;
+
+export { BackendClient, Engine, LocalAssetStore, LocalCacheStore, ValidationError, createEngineFromEnv, defaultRegistry, generateCatalog, validateCanvasDeep };

package/dist/engine/index.js

@@ -0,0 +1,23 @@
+import {
+  BackendClient,
+  Engine,
+  LocalAssetStore,
+  LocalCacheStore,
+  ValidationError,
+  createEngineFromEnv,
+  defaultRegistry,
+  generateCatalog,
+  validateCanvasDeep
+} from "../chunk-5L2X6KDP.js";
+export {
+  BackendClient,
+  Engine,
+  LocalAssetStore,
+  LocalCacheStore,
+  ValidationError,
+  createEngineFromEnv,
+  defaultRegistry,
+  generateCatalog,
+  validateCanvasDeep
+};
+//# sourceMappingURL=index.js.map

package/dist/engine/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -1,36 +1,52 @@
 {
   "name": "@koda-sl/baker-cli",
-  "version": "0.39.29",
-  "description": "AI-agent-first CLI for interacting with Baker",
+  "version": "0.67.0-dev.3a23b0e68",
+  "description": "AI-agent-first CLI for interacting with Baker, including the Baker creative canvas.",
   "type": "module",
   "bin": {
     "baker": "dist/cli.js"
   },
+  "exports": {
+    ".": "./dist/cli.js",
+    "./engine": {
+      "types": "./dist/engine/index.d.ts",
+      "default": "./dist/engine/index.js"
+    }
+  },
   "files": [
-    "dist"
+    "dist",
+    "canvas"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "tsup",
     "dev": "tsx watch src/cli.ts",
     "typecheck": "tsc --noEmit",
+    "lint": "biome check src __tests__",
     "test": "vitest run"
   },
   "dependencies": {
     "@t3-oss/env-core": "^0.13.10",
     "citty": "^0.2.2",
+    "gsap": "^3.15.0",
     "image-size": "^2.0.2",
+    "playwright": "^1.58.2",
     "quantize": "^1.0.2",
     "sharp": "^0.34.5",
     "zod": "^4.3.6"
   },
   "devDependencies": {
+    "@baker/canvas-contract": "workspace:*",
     "@types/node": "25.3.0",
     "@types/quantize": "^1.0.2",
+    "tsup": "^8.5.0",
     "tsx": "^4.0.0",
     "typescript": "^5.9.3",
     "vite": "7.3.2",
     "vitest": "^4.1.8"
   },
+  "engines": {
+    "node": "22.x"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/koda-sl/baker.git",

package/dist/cli-version.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=cli-version.test.d.ts.map

package/dist/cli-version.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli-version.test.d.ts","sourceRoot":"","sources":["../src/cli-version.test.ts"],"names":[],"mappings":""}

package/dist/cli-version.test.js

@@ -1,13 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { describe, expect, it } from "vitest";
-import { getCliVersion } from "./version.js";
-const packageJsonPath = resolve(dirname(fileURLToPath(import.meta.url)), "../package.json");
-describe("CLI version metadata", () => {
-    it("uses package.json as the source of truth for baker --version", async () => {
-        const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
-        expect(packageJson).toMatchObject({ version: getCliVersion() });
-    });
-});
-//# sourceMappingURL=cli-version.test.js.map

package/dist/cli-version.test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli-version.test.js","sourceRoot":"","sources":["../src/cli-version.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE7C,MAAM,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,iBAAiB,CAAC,CAAC;AAE5F,QAAQ,CAAC,sBAAsB,EAAE,GAAG,EAAE;IACpC,EAAE,CAAC,8DAA8D,EAAE,KAAK,IAAI,EAAE;QAC5E,MAAM,WAAW,GAAY,IAAI,CAAC,KAAK,CAAC,MAAM,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC,CAAC;QAEjF,MAAM,CAAC,WAAW,CAAC,CAAC,aAAa,CAAC,EAAE,OAAO,EAAE,aAAa,EAAE,EAAE,CAAC,CAAC;IAClE,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/cli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/client.d.ts

@@ -1,12 +0,0 @@
-type ErrorCode = "UNAUTHORIZED" | "NOT_FOUND" | "VALIDATION_ERROR" | "RATE_LIMITED" | "INTERNAL_ERROR" | "NETWORK_ERROR" | "TIMEOUT" | "IMAGE_PROCESSING_ERROR";
-export declare class ApiError extends Error {
-    code: ErrorCode;
-    constructor(code: ErrorCode, message: string);
-}
-export declare function validateConvexId(id: string): void;
-export declare function apiGet<T>(path: string, params?: Record<string, string>): Promise<T>;
-export declare function apiPost<T>(path: string, body: unknown, opts?: {
-    timeoutMs?: number;
-}): Promise<T>;
-export {};
-//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AA6BA,KAAK,SAAS,GACV,cAAc,GACd,WAAW,GACX,kBAAkB,GAClB,cAAc,GACd,gBAAgB,GAChB,eAAe,GACf,SAAS,GACT,wBAAwB,CAAC;AAE7B,qBAAa,QAAS,SAAQ,KAAK;IACjC,IAAI,EAAE,SAAS,CAAC;gBAEJ,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM;CAK7C;AAqBD,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAIjD;AAsDD,wBAAsB,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CA4BzF;AAED,wBAAsB,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAuBvG"}