@openworkflow/cli 0.1.0 → 0.2.1

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /* v8 ignore file -- @preserve */
-import { doctor, getVersion, init, workerStart } from "./commands.js";
+import { dashboard, doctor, getVersion, init, workerStart, } from "./commands.js";
 import { withErrorHandling } from "./errors.js";
 import { Command } from "commander";
 // openworkflow | ow
@@ -28,5 +28,9 @@ workerCmd
     .description("start a worker to process workflows")
     .option("-c, --concurrency <number>", "number of concurrent workflows to process", Number.parseInt)
     .action(withErrorHandling(workerStart));
+// dashboard
+program
+    .command("dashboard")
+    .description("start the dashboard to view workflow runs")
+    .action(withErrorHandling(dashboard));
 await program.parseAsync(process.argv);
-//# sourceMappingURL=cli.js.map

package/dist/commands.d.ts

@@ -13,6 +13,11 @@ export declare function doctor(): Promise<void>;
  * @param cliOptions - Worker config overrides
  */
 export declare function workerStart(cliOptions: WorkerConfig): Promise<void>;
+/**
+ * openworkflow dashboard
+ * Starts the dashboard by delegating to `@openworkflow/dashboard` via npx.
+ */
+export declare function dashboard(): Promise<void>;
 interface PackageJsonForDoctor {
     dependencies?: Record<string, string>;
     devDependencies?: Record<string, string>;
@@ -29,5 +34,11 @@ export declare function getConfigFileName(packageJson: Readonly<PackageJsonForDo
  * @returns The example workflow file name to create
  */
 export declare function getExampleWorkflowFileName(packageJson: Readonly<PackageJsonForDoctor> | null): string;
+/**
+ * Determine the client filename to write during init.
+ * @param packageJson - Parsed package.json (or null if missing)
+ * @returns The client file name to create
+ */
+export declare function getClientFileName(packageJson: Readonly<PackageJsonForDoctor> | null): string;
 export {};
 //# sourceMappingURL=commands.d.ts.map

package/dist/commands.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../commands.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAc,MAAM,aAAa,CAAC;AA8BvD;;;GAGG;AACH,wBAAgB,UAAU,IAAI,MAAM,CAoBnC;AAED,wBAAwB;AACxB,wBAAsB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAqH1C;AAED,0BAA0B;AAC1B,wBAAsB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAiD5C;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAAC,UAAU,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAqEzE;AA0dD,UAAU,oBAAoB;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC1C;AAsBD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,QAAQ,CAAC,oBAAoB,CAAC,GAAG,IAAI,GACjD,MAAM,CAMR;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,QAAQ,CAAC,oBAAoB,CAAC,GAAG,IAAI,GACjD,MAAM,CAKR"}
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../commands.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAc,MAAM,aAAa,CAAC;AAgCvD;;;GAGG;AACH,wBAAgB,UAAU,IAAI,MAAM,CAoBnC;AAED,wBAAwB;AACxB,wBAAsB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CA8H1C;AAED,0BAA0B;AAC1B,wBAAsB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAiD5C;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAAC,UAAU,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAqEzE;AAED;;;GAGG;AACH,wBAAsB,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CA0D/C;AAqfD,UAAU,oBAAoB;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC1C;AAsBD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,QAAQ,CAAC,oBAAoB,CAAC,GAAG,IAAI,GACjD,MAAM,CAMR;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,QAAQ,CAAC,oBAAoB,CAAC,GAAG,IAAI,GACjD,MAAM,CAKR;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,QAAQ,CAAC,oBAAoB,CAAC,GAAG,IAAI,GACjD,MAAM,CAKR"}

package/dist/commands.js

@@ -1,10 +1,11 @@
 import { loadConfig } from "./config.js";
 import { CLIError } from "./errors.js";
-import { HELLO_WORLD_WORKFLOW, POSTGRES_CONFIG, POSTGRES_PROD_SQLITE_DEV_CONFIG, SQLITE_CONFIG, } from "./templates.js";
+import { CONFIG, HELLO_WORLD_WORKFLOW, POSTGRES_CLIENT, POSTGRES_PROD_SQLITE_DEV_CLIENT, SQLITE_CLIENT, } from "./templates.js";
 import * as p from "@clack/prompts";
 import { consola } from "consola";
 import { config as loadDotenv } from "dotenv";
 import { createJiti } from "jiti";
+import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -85,7 +86,11 @@ export async function init() {
     const packageManager = pm?.name ?? "your package manager";
     spinner.stop(`Using ${packageManager}`);
     const packageJson = readPackageJsonForDoctor();
+    if (!packageJson) {
+        throw new CLIError("No package.json found.", "Please create a package.json file first by running `npm init` or `npm init -y`.");
+    }
     const configFileName = getConfigFileName(packageJson);
+    const clientFileName = getClientFileName(packageJson);
     const exampleWorkflowFileName = getExampleWorkflowFileName(packageJson);
     const shouldSetup = await p.confirm({
         message: `Install packages and set up project files (.env, .gitignore, package.json, ${configFileName}, openworkflow/${exampleWorkflowFileName})?`,
@@ -115,6 +120,7 @@ export async function init() {
         await addDependency(devDependencies, { silent: true, dev: true });
         spinner.stop(`Installed ${devDependencies.join(", ")}`);
     }
+    createClientFile(backendChoice, clientFileName);
     createExampleWorkflow(exampleWorkflowFileName);
     if (backendChoice === "sqlite" || backendChoice === "both") {
         updateGitignoreForSqlite();
@@ -125,7 +131,7 @@ export async function init() {
     addWorkerScriptToPackageJson();
     // write config file last, so canceling earlier doesn't leave a config file
     // which would prevent re-running init
-    createConfigFile(backendChoice, configFileName);
+    createConfigFile(configFileName);
     // wrap up
     p.note(`➡️ Start a worker with:\n$ ${packageManager === "npm" ? "npm run" : packageManager} worker\n\nOr directly with:\n$ ow worker start`, "Next steps");
     p.outro("✅ Setup complete!");
@@ -224,6 +230,51 @@ export async function workerStart(cliOptions) {
         throw error;
     }
 }
+/**
+ * openworkflow dashboard
+ * Starts the dashboard by delegating to `@openworkflow/dashboard` via npx.
+ */
+export async function dashboard() {
+    consola.start("Starting dashboard...");
+    const { configFile } = await loadConfigWithEnv();
+    if (!configFile) {
+        throw new CLIError("No config file found.", "Run `ow init` to create a config file before starting the dashboard.");
+    }
+    consola.info(`Using config: ${configFile}`);
+    // eslint-disable-next-line sonarjs/no-os-command-from-path
+    const child = spawn("npx", ["@openworkflow/dashboard"], {
+        stdio: "inherit",
+    });
+    await new Promise((resolve, reject) => {
+        /** remove signal handlers after the child exits */
+        function cleanupSignalHandlers() {
+            process.off("SIGINT", signalHandler);
+            process.off("SIGTERM", signalHandler);
+        }
+        child.on("error", (error) => {
+            cleanupSignalHandlers();
+            reject(new CLIError("Failed to start dashboard.", `Could not spawn npx: ${error.message}`));
+        });
+        child.on("exit", (code) => {
+            cleanupSignalHandlers();
+            if (code === 0 || code === null) {
+                resolve();
+            }
+            else {
+                reject(new CLIError("Dashboard exited with an error.", `Exit code: ${String(code)}`));
+            }
+        });
+        /**
+         * Graceful shutdown on signals.
+         * @param signal - Signal
+         */
+        function signalHandler(signal) {
+            child.kill(signal);
+        }
+        process.on("SIGINT", signalHandler);
+        process.on("SIGTERM", signalHandler);
+    });
+}
 // -----------------------------------------------------------------------------
 /**
  * Get workflow directories from config.
@@ -410,16 +461,21 @@ async function discoverWorkflowsInDirs(dirs, baseDir) {
  * @param backendChoice - The selected backend choice
  * @returns The config template string
  */
-function getConfigTemplate(backendChoice) {
+/**
+ * Get the client template for a backend choice.
+ * @param backendChoice - The selected backend choice
+ * @returns The client template string
+ */
+function getClientTemplate(backendChoice) {
     switch (backendChoice) {
         case "sqlite": {
-            return SQLITE_CONFIG;
+            return SQLITE_CLIENT;
         }
         case "postgres": {
-            return POSTGRES_CONFIG;
+            return POSTGRES_CLIENT;
         }
         case "both": {
-            return POSTGRES_PROD_SQLITE_DEV_CONFIG;
+            return POSTGRES_PROD_SQLITE_DEV_CLIENT;
         }
     }
 }
@@ -447,17 +503,37 @@ function getDevDependenciesToInstall() {
 }
 /**
  * Create config file.
- * @param backendChoice - The selected backend choice
  * @param configFileName - The config file name to write
  */
-function createConfigFile(backendChoice, configFileName) {
+function createConfigFile(configFileName) {
     const spinner = p.spinner();
     spinner.start("Writing config...");
-    const configTemplate = getConfigTemplate(backendChoice);
     const configDestPath = path.join(process.cwd(), configFileName);
-    writeFileSync(configDestPath, configTemplate, "utf8");
+    writeFileSync(configDestPath, CONFIG, "utf8");
     spinner.stop(`Config written to ${configDestPath}`);
 }
+/**
+ * Create client file.
+ * @param backendChoice - The selected backend choice
+ * @param clientFileName - The client filename to write
+ */
+function createClientFile(backendChoice, clientFileName) {
+    const spinner = p.spinner();
+    const workflowsDir = path.join(process.cwd(), "openworkflow");
+    if (!existsSync(workflowsDir)) {
+        mkdirSync(workflowsDir, { recursive: true });
+    }
+    const clientDestPath = path.join(workflowsDir, clientFileName);
+    if (existsSync(clientDestPath)) {
+        spinner.start("Checking client file...");
+        spinner.stop(`Client file already exists at ${clientDestPath}`);
+        return;
+    }
+    spinner.start("Creating client file...");
+    const clientTemplate = getClientTemplate(backendChoice);
+    writeFileSync(clientDestPath, clientTemplate, "utf8");
+    spinner.stop(`Created client file at ${clientDestPath}`);
+}
 /**
  * Create example workflow.
  * @param exampleWorkflowFileName - The example workflow filename to write
@@ -507,7 +583,7 @@ function addWorkerScriptToPackageJson() {
     try {
         const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
         packageJson.scripts ??= {};
-        packageJson.scripts["worker"] = "ow worker start";
+        packageJson.scripts["worker"] = "npx @openworkflow/cli worker start";
         writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf8");
         spinner.stop('Added "worker" script to package.json');
     }
@@ -613,6 +689,16 @@ export function getExampleWorkflowFileName(packageJson) {
     const extension = path.extname(configFileName) || ".js";
     return `hello-world${extension}`;
 }
+/**
+ * Determine the client filename to write during init.
+ * @param packageJson - Parsed package.json (or null if missing)
+ * @returns The client file name to create
+ */
+export function getClientFileName(packageJson) {
+    const configFileName = getConfigFileName(packageJson);
+    const extension = path.extname(configFileName) || ".js";
+    return `client${extension}`;
+}
 /**
  * Check whether a dependency is declared in package.json.
  * @param packageJson - Parsed package.json.
@@ -715,4 +801,3 @@ function mergeDefinedOptions(base, overrides) {
     }
     return merged;
 }
-//# sourceMappingURL=commands.js.map

package/dist/commands.test.js

@@ -1,4 +1,4 @@
-import { getConfigFileName, getExampleWorkflowFileName } from "./commands.js";
+import { getClientFileName, getConfigFileName, getExampleWorkflowFileName, } from "./commands.js";
 import { describe, expect, test } from "vitest";
 describe("getConfigFileName", () => {
     test("prefers TypeScript when it is in devDependencies", () => {
@@ -32,4 +32,21 @@ describe("getExampleWorkflowFileName", () => {
         expect(getExampleWorkflowFileName({ dependencies: {}, devDependencies: {} })).toBe("hello-world.js");
     });
 });
-//# sourceMappingURL=commands.test.js.map
+describe("getClientFileName", () => {
+    test("uses TypeScript when it is in devDependencies", () => {
+        expect(getClientFileName({
+            devDependencies: { typescript: "^5.0.0" },
+        })).toBe("client.ts");
+    });
+    test("uses TypeScript when it is in dependencies", () => {
+        expect(getClientFileName({
+            dependencies: { typescript: "^5.0.0" },
+        })).toBe("client.ts");
+    });
+    test("falls back to JavaScript when package.json is missing", () => {
+        expect(getClientFileName(null)).toBe("client.js");
+    });
+    test("falls back to JavaScript when package.json has no TypeScript", () => {
+        expect(getClientFileName({ dependencies: {}, devDependencies: {} })).toBe("client.js");
+    });
+});

package/dist/config.d.ts

@@ -1,4 +1,4 @@
-import { WorkerOptions } from "openworkflow";
+import type { WorkerOptions } from "openworkflow";
 import type { Backend } from "openworkflow/internal";
 export interface OpenWorkflowConfig {
     backend: Backend;
@@ -25,10 +25,12 @@ interface LoadedConfig {
 }
 /**
  * Load the OpenWorkflow config at openworkflow.config.{ts,mts,cts,js,mjs,cjs}.
- * @param rootDir - Optional root directory to search from (defaults to
- * process.cwd())
+ * Searches up the directory tree from the starting directory to find the
+ * nearest config file.
+ * @param startDir - Optional starting directory to search from (defaults to
+ * process.cwd()). Will search this directory and all parent directories.
  * @returns The loaded configuration and metadata
  */
-export declare function loadConfig(rootDir?: string): Promise<LoadedConfig>;
+export declare function loadConfig(startDir?: string): Promise<LoadedConfig>;
 export {};
 //# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../config.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAErD,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;AAE9D;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,kBAAkB,GAAG,kBAAkB,CAE3E;AAED,UAAU,YAAY;IACpB,MAAM,EAAE,kBAAkB,CAAC;IAC3B,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC;AAMD;;;;;GAKG;AACH,wBAAsB,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAkCxE"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../config.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAErD,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;AAE9D;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,kBAAkB,GAAG,kBAAkB,CAE3E;AAED,UAAU,YAAY;IACpB,MAAM,EAAE,kBAAkB,CAAC;IAC3B,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC;AAMD;;;;;;;GAOG;AACH,wBAAsB,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CA8CzE"}

package/dist/config.js

@@ -15,30 +15,42 @@ const CONFIG_EXTENSIONS = ["ts", "mts", "cts", "js", "mjs", "cjs"];
 const jiti = createJiti(import.meta.url);
 /**
  * Load the OpenWorkflow config at openworkflow.config.{ts,mts,cts,js,mjs,cjs}.
- * @param rootDir - Optional root directory to search from (defaults to
- * process.cwd())
+ * Searches up the directory tree from the starting directory to find the
+ * nearest config file.
+ * @param startDir - Optional starting directory to search from (defaults to
+ * process.cwd()). Will search this directory and all parent directories.
  * @returns The loaded configuration and metadata
  */
-export async function loadConfig(rootDir) {
-    const cwd = rootDir ?? process.cwd();
-    for (const ext of CONFIG_EXTENSIONS) {
-        const fileName = `${CONFIG_NAME}.${ext}`;
-        const filePath = path.join(cwd, fileName);
-        if (existsSync(filePath)) {
-            try {
-                const fileUrl = pathToFileURL(filePath).href;
-                const config = await jiti.import(fileUrl, {
-                    default: true,
-                });
-                return {
-                    config,
-                    configFile: filePath,
-                };
-            }
-            catch (error) {
-                throw new Error(`Failed to load config file ${filePath}: ${String(error)}`);
+export async function loadConfig(startDir) {
+    let currentDir = path.resolve(startDir ?? process.cwd());
+    // search up the directory tree
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    while (true) {
+        for (const ext of CONFIG_EXTENSIONS) {
+            const fileName = `${CONFIG_NAME}.${ext}`;
+            const filePath = path.join(currentDir, fileName);
+            if (existsSync(filePath)) {
+                try {
+                    const fileUrl = pathToFileURL(filePath).href;
+                    const config = await jiti.import(fileUrl, {
+                        default: true,
+                    });
+                    return {
+                        config,
+                        configFile: filePath,
+                    };
+                }
+                catch (error) {
+                    throw new Error(`Failed to load config file ${filePath}: ${String(error)}`);
+                }
             }
         }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            // reached filesystem root without finding config
+            break;
+        }
+        currentDir = parentDir;
     }
     return {
         // not great, but meant to match the c12 api since that is what was used in
@@ -48,4 +60,3 @@ export async function loadConfig(rootDir) {
         configFile: undefined, // no config found
     };
 }
-//# sourceMappingURL=config.js.map

package/dist/config.test.js

@@ -86,4 +86,3 @@ describe("loadConfig", () => {
         }
     });
 });
-//# sourceMappingURL=config.test.js.map

package/dist/errors.js

@@ -40,4 +40,3 @@ export function withErrorHandling(fn) {
         }
     };
 }
-//# sourceMappingURL=errors.js.map

package/dist/index.js

@@ -1,2 +1 @@
 export { defineConfig } from "./config.js";
-//# sourceMappingURL=index.js.map

package/dist/internal.d.ts

@@ -0,0 +1,2 @@
+export { loadConfig } from "./config.js";
+//# sourceMappingURL=internal.d.ts.map

package/dist/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../internal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC"}

package/dist/internal.js

@@ -0,0 +1 @@
+export { loadConfig } from "./config.js";

package/dist/templates.d.ts

@@ -1,5 +1,6 @@
-export declare const SQLITE_CONFIG = "import { BackendSqlite } from \"@openworkflow/backend-sqlite\";\nimport { defineConfig } from \"@openworkflow/cli\";\n\nexport default defineConfig({\n  // Use SQLite as the backend\n  backend: BackendSqlite.connect(\"openworkflow/backend.db\"),\n\n  // The directories where your workflows are defined\n  dirs: \"./openworkflow\",\n});\n";
-export declare const POSTGRES_CONFIG = "import { BackendPostgres } from \"@openworkflow/backend-postgres\";\nimport { defineConfig } from \"@openworkflow/cli\";\n\nexport default defineConfig({\n  // Use Postgres as the backend\n  backend: await BackendPostgres.connect(\n    process.env[\"OPENWORKFLOW_POSTGRES_URL\"],\n  ),\n\n  // The directories where your workflows are defined\n  dirs: \"./openworkflow\",\n});\n";
-export declare const POSTGRES_PROD_SQLITE_DEV_CONFIG = "import { BackendPostgres } from \"@openworkflow/backend-postgres\";\nimport { BackendSqlite } from \"@openworkflow/backend-sqlite\";\nimport { defineConfig } from \"@openworkflow/cli\";\n\nexport default defineConfig({\n  // Use Postgres as the backend in production, otherwise use SQLite\n  backend:\n    process.env[\"NODE_ENV\"] === \"production\"\n      ? await BackendPostgres.connect(process.env[\"OPENWORKFLOW_POSTGRES_URL\"])\n      : BackendSqlite.connect(\"openworkflow/backend.db\"),\n\n  // The directories where your workflows are defined\n  dirs: \"./openworkflow\",\n});\n";
-export declare const HELLO_WORLD_WORKFLOW = "import { defineWorkflow } from \"openworkflow\";\n\nexport const helloWorld = defineWorkflow(\n  { name: \"hello-world\" },\n  async ({ step }) => {\n    const greeting = await step.run({ name: \"greet\" }, () => {\n      return \"Hello, World!\";\n    });\n\n    await step.sleep(\"wait-a-bit\", \"1s\");\n\n    return { greeting };\n  },\n);\n";
+export declare const SQLITE_CLIENT = "import { BackendSqlite } from \"@openworkflow/backend-sqlite\";\nimport { OpenWorkflow } from \"openworkflow\";\n\nexport const backend = BackendSqlite.connect(\"openworkflow/backend.db\");\nexport const ow = new OpenWorkflow({ backend });\n";
+export declare const POSTGRES_CLIENT = "import { BackendPostgres } from \"@openworkflow/backend-postgres\";\nimport { OpenWorkflow } from \"openworkflow\";\n\nexport const backend = await BackendPostgres.connect(\n  process.env[\"OPENWORKFLOW_POSTGRES_URL\"],\n);\nexport const ow = new OpenWorkflow({ backend });\n";
+export declare const POSTGRES_PROD_SQLITE_DEV_CLIENT = "import { BackendPostgres } from \"@openworkflow/backend-postgres\";\nimport { BackendSqlite } from \"@openworkflow/backend-sqlite\";\nimport { OpenWorkflow } from \"openworkflow\";\n\nexport const backend =\n  process.env[\"NODE_ENV\"] === \"production\"\n    ? await BackendPostgres.connect(process.env[\"OPENWORKFLOW_POSTGRES_URL\"])\n    : BackendSqlite.connect(\"openworkflow/backend.db\");\nexport const ow = new OpenWorkflow({ backend });\n";
+export declare const CONFIG = "import { backend } from \"./openworkflow/client.js\";\nimport { defineConfig } from \"@openworkflow/cli\";\n\nexport default defineConfig({\n  backend,\n  dirs: \"./openworkflow\",\n});\n";
+export declare const HELLO_WORLD_WORKFLOW = "import { defineWorkflow } from \"openworkflow\";\n\n/**\n * Example workflow that greets the world.\n *\n * This workflow is auto-discovered by the CLI worker.\n * To trigger it, use ow.runWorkflow() from your app:\n * ```ts\n * import { ow } from \"./openworkflow/client.js\";\n * import { helloWorld } from \"./openworkflow/hello-world.js\";\n * const handle = await ow.runWorkflow(helloWorld.spec, {});\n * const result = await handle.result();\n * ```\n */\nexport const helloWorld = defineWorkflow(\n  { name: \"hello-world\" },\n  async ({ step }) => {\n    const greeting = await step.run({ name: \"greet\" }, () => {\n      return \"Hello, World!\";\n    });\n\n    await step.sleep(\"wait-a-bit\", \"1s\");\n\n    return { greeting };\n  },\n);\n";
 //# sourceMappingURL=templates.d.ts.map

package/dist/templates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../templates.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,uVAUzB,CAAC;AAEF,eAAO,MAAM,eAAe,+XAY3B,CAAC;AAEF,eAAO,MAAM,+BAA+B,glBAc3C,CAAC;AAEF,eAAO,MAAM,oBAAoB,8VAchC,CAAC"}
+{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../templates.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,sPAKzB,CAAC;AAEF,eAAO,MAAM,eAAe,wRAO3B,CAAC;AAEF,eAAO,MAAM,+BAA+B,mcAS3C,CAAC;AAEF,eAAO,MAAM,MAAM,gMAOlB,CAAC;AAEF,eAAO,MAAM,oBAAoB,wvBA0BhC,CAAC"}

package/dist/templates.js

@@ -1,44 +1,49 @@
-export const SQLITE_CONFIG = `import { BackendSqlite } from "@openworkflow/backend-sqlite";
-import { defineConfig } from "@openworkflow/cli";
-
-export default defineConfig({
-  // Use SQLite as the backend
-  backend: BackendSqlite.connect("openworkflow/backend.db"),
+export const SQLITE_CLIENT = `import { BackendSqlite } from "@openworkflow/backend-sqlite";
+import { OpenWorkflow } from "openworkflow";
 
-  // The directories where your workflows are defined
-  dirs: "./openworkflow",
-});
+export const backend = BackendSqlite.connect("openworkflow/backend.db");
+export const ow = new OpenWorkflow({ backend });
 `;
-export const POSTGRES_CONFIG = `import { BackendPostgres } from "@openworkflow/backend-postgres";
-import { defineConfig } from "@openworkflow/cli";
-
-export default defineConfig({
-  // Use Postgres as the backend
-  backend: await BackendPostgres.connect(
-    process.env["OPENWORKFLOW_POSTGRES_URL"],
-  ),
+export const POSTGRES_CLIENT = `import { BackendPostgres } from "@openworkflow/backend-postgres";
+import { OpenWorkflow } from "openworkflow";
 
-  // The directories where your workflows are defined
-  dirs: "./openworkflow",
-});
+export const backend = await BackendPostgres.connect(
+  process.env["OPENWORKFLOW_POSTGRES_URL"],
+);
+export const ow = new OpenWorkflow({ backend });
 `;
-export const POSTGRES_PROD_SQLITE_DEV_CONFIG = `import { BackendPostgres } from "@openworkflow/backend-postgres";
+export const POSTGRES_PROD_SQLITE_DEV_CLIENT = `import { BackendPostgres } from "@openworkflow/backend-postgres";
 import { BackendSqlite } from "@openworkflow/backend-sqlite";
+import { OpenWorkflow } from "openworkflow";
+
+export const backend =
+  process.env["NODE_ENV"] === "production"
+    ? await BackendPostgres.connect(process.env["OPENWORKFLOW_POSTGRES_URL"])
+    : BackendSqlite.connect("openworkflow/backend.db");
+export const ow = new OpenWorkflow({ backend });
+`;
+export const CONFIG = `import { backend } from "./openworkflow/client.js";
 import { defineConfig } from "@openworkflow/cli";
 
 export default defineConfig({
-  // Use Postgres as the backend in production, otherwise use SQLite
-  backend:
-    process.env["NODE_ENV"] === "production"
-      ? await BackendPostgres.connect(process.env["OPENWORKFLOW_POSTGRES_URL"])
-      : BackendSqlite.connect("openworkflow/backend.db"),
-
-  // The directories where your workflows are defined
+  backend,
   dirs: "./openworkflow",
 });
 `;
 export const HELLO_WORLD_WORKFLOW = `import { defineWorkflow } from "openworkflow";
 
+/**
+ * Example workflow that greets the world.
+ *
+ * This workflow is auto-discovered by the CLI worker.
+ * To trigger it, use ow.runWorkflow() from your app:
+ * \`\`\`ts
+ * import { ow } from "./openworkflow/client.js";
+ * import { helloWorld } from "./openworkflow/hello-world.js";
+ * const handle = await ow.runWorkflow(helloWorld.spec, {});
+ * const result = await handle.result();
+ * \`\`\`
+ */
 export const helloWorld = defineWorkflow(
   { name: "hello-world" },
   async ({ step }) => {
@@ -52,4 +57,3 @@ export const helloWorld = defineWorkflow(
   },
 );
 `;
-//# sourceMappingURL=templates.js.map

package/dist/templates.test.js

@@ -1,20 +1,26 @@
-import { POSTGRES_CONFIG, POSTGRES_PROD_SQLITE_DEV_CONFIG, SQLITE_CONFIG, } from "./templates.js";
+import { CONFIG_TEMPLATE, POSTGRES_CLIENT, POSTGRES_PROD_SQLITE_DEV_CLIENT, SQLITE_CLIENT, } from "./templates.js";
 import { describe, expect, test } from "vitest";
-describe("config templates", () => {
-    const templates = [
-        SQLITE_CONFIG,
-        POSTGRES_CONFIG,
-        POSTGRES_PROD_SQLITE_DEV_CONFIG,
-    ];
-    test("import defineConfig from the CLI entrypoint", () => {
-        for (const template of templates) {
-            expect(template).toContain('import { defineConfig } from "@openworkflow/cli";');
-        }
+describe("client templates", () => {
+    test("sqlite client exports backend and ow", () => {
+        expect(SQLITE_CLIENT).toContain("export const backend");
+        expect(SQLITE_CLIENT).toContain("new OpenWorkflow");
+        expect(SQLITE_CLIENT).toContain("BackendSqlite");
+    });
+    test("postgres client exports backend and ow", () => {
+        expect(POSTGRES_CLIENT).toContain("export const backend");
+        expect(POSTGRES_CLIENT).toContain("new OpenWorkflow");
+        expect(POSTGRES_CLIENT).toContain("BackendPostgres");
+    });
+    test("prod postgres dev sqlite client exports backend and ow", () => {
+        expect(POSTGRES_PROD_SQLITE_DEV_CLIENT).toContain("export const backend");
+        expect(POSTGRES_PROD_SQLITE_DEV_CLIENT).toContain("new OpenWorkflow");
+        expect(POSTGRES_PROD_SQLITE_DEV_CLIENT).toContain("BackendSqlite");
+        expect(POSTGRES_PROD_SQLITE_DEV_CLIENT).toContain("BackendPostgres");
     });
-    test("do not import the config subpath", () => {
-        for (const template of templates) {
-            expect(template).not.toContain('from "@openworkflow/cli/config";');
-        }
+});
+describe("config templates", () => {
+    test("config references backend from client file", () => {
+        expect(CONFIG_TEMPLATE).toContain('import { backend } from "./openworkflow/client.js"');
+        expect(CONFIG_TEMPLATE).toContain("backend,");
     });
 });
-//# sourceMappingURL=templates.test.js.map