@littlebigbrain/create 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,55 @@
+Apache License
+
+Version 2.0, January 2004
+
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
+
+You must give any other recipients of the Work or Derivative Works a copy of this License; and
+
+You must cause any modified files to carry prominent notices stating that You changed the files; and
+
+You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
+
+If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS

package/README.md

@@ -1,3 +1,72 @@
-# Temporary Holding Version
+# @littlebigbrain/create
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Creates a project from a little big brain starter workflow template: a
+workflow that your `WorkflowWorker` runs on a graph, with its test, its
+samples and the scripts that run it.
+
+```sh
+npm create @littlebigbrain -- --template documents-link my-links
+cd my-links
+npm install
+npm test
+```
+
+## Templates
+
+| Template | Does |
+| --- | --- |
+| `documents-link` | Finds the identifiers the documents define and the spans that mention them, and links each mention to its entry |
+| `values-extract` | Fills properties of a class from the text of its instances, each value with a verbatim quote |
+| `ontology-fit` | Proposes the ontology changes the texts of a class support, as review items |
+
+A template id is the id of its starter workflow, with dashes for dots:
+`documents-link` is the code of `documents.link`.
+
+## The project
+
+| File | Holds |
+| --- | --- |
+| `src/workflow.ts` | The workflow, its settings, the triggered workflow that sends it the instances (`trigger()`) and the ontology it writes (`ontology()`) |
+| `src/*.ts` | The template's helpers and `samples.ts`, which puts the samples on a graph |
+| `src/workflow.test.ts`, `src/testing.ts` | The workflow on its samples, with mock models and no server |
+| `src/worker.ts`, `src/setup.ts`, `src/try.ts` | `npm start`, `npm run setup` and `npm run try` |
+| `samples/` | The samples and their answer key |
+
+`npm run try` creates a graph (`LBB_GRAPH`, default `try-<template>`), puts
+the samples on it and creates the workflow there. `npm run setup` creates the
+workflow on your own graph, and `npm start` serves it. All three read
+`LBB_URL` and `LBB_API_KEY`.
+
+## Options
+
+| Option | Meaning |
+| --- | --- |
+| `--template <name>` | The template (required) |
+| `--client <spec>` | The `@littlebigbrain/client` dependency of the project. Default: the version the templates are written for |
+| `[dir]` | The new project's directory. Default: the template's name. It must be empty or missing |
+
+## Development
+
+The package is developed in the little big brain monorepo, and the templates
+live in its `sdk/templates`. There the command reads them from that folder.
+`npm pack` copies them into the package (`prepack`) with the client version,
+and removes the copy afterwards.
+
+```sh
+node sdk/create/bin/create-littlebigbrain.mjs --template documents-link /tmp/my-links
+npm test -w @littlebigbrain/create
+```
+
+The test creates each project, compiles it against the workspace's client
+and runs its test.
+
+The public repository
+[littlebigbrains/lbb-typescript](https://github.com/littlebigbrains/lbb-typescript)
+holds the package in `create/`, with the templates and
+`templates/versions.json` already copied in. There `prepack` keeps that copy.
+A new version in `create/package.json` is published to npm by the
+repository's `release-create.yml` workflow.
+
+## License
+
+Apache-2.0

package/bin/create-littlebigbrain.mjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+// @ts-check
+// npm create @littlebigbrain -- --template documents-link [dir]
+import { main } from "../lib/create.mjs";
+
+main(process.argv.slice(2)).catch((error) => {
+  console.error(`create-littlebigbrain: ${error instanceof Error ? error.message : error}`);
+  process.exitCode = 1;
+});

package/lib/create.mjs

@@ -0,0 +1,238 @@
+// @ts-check
+// Create a project from a starter workflow template:
+//
+//   npm create @littlebigbrain -- --template documents-link [dir]
+//
+// The project holds the template's workflow, helpers, test and samples, and
+// the scripts that run it: `npm test` (the workflow on its samples, with mock
+// models), `npm run try` (the samples on a graph of your stack), `npm run
+// setup` and `npm start` (your graph). The templates come from `templates/`
+// in the package (copied there when it is packed) or, in the repository,
+// from `sdk/templates`.
+import { existsSync, readFileSync } from "node:fs";
+import { cp, mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+/** The templates a project can start from: the folder names under `sdk/templates`. */
+export const TEMPLATES = ["documents-link", "values-extract", "ontology-fit"];
+
+const PACKAGE = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+
+const USAGE = `Create a project from a little big brain starter workflow template.
+
+Usage:
+  npm create @littlebigbrain -- --template <name> [dir]
+
+Templates: ${TEMPLATES.join(", ")}
+
+Options:
+  --template <name>   the template (required)
+  --client <spec>     the @littlebigbrain/client dependency (default: ^<the current version>)
+  --help              this text`;
+
+/**
+ * The options of the command line.
+ * @param {string[]} argv
+ * @returns {{ template?: string, dir?: string, client?: string, help: boolean }}
+ */
+export function parseArgs(argv) {
+  /** @type {{ template?: string, dir?: string, client?: string, help: boolean }} */
+  const out = { help: false };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const [flag, inline] = arg.startsWith("--") ? arg.split(/=(.*)/s, 2) : [arg, undefined];
+    const value = () => {
+      const next = inline ?? argv[++i];
+      if (next === undefined || next.startsWith("--")) throw new Error(`${flag} needs a value`);
+      return next;
+    };
+    if (flag === "--help" || flag === "-h") out.help = true;
+    else if (flag === "--template" || flag === "-t") out.template = value();
+    else if (flag === "--client") out.client = value();
+    else if (flag.startsWith("-")) throw new Error(`unknown option ${flag}`);
+    else if (out.dir === undefined) out.dir = arg;
+    else throw new Error(`one directory, not ${out.dir} and ${arg}`);
+  }
+  return out;
+}
+
+/**
+ * The folder that holds the templates: the package's own copy, else the
+ * repository's `sdk/templates`.
+ * @param {string} [root] the package folder
+ */
+export function templatesRoot(root = PACKAGE) {
+  for (const candidate of [join(root, "templates"), join(root, "..", "templates")])
+    if (existsSync(join(candidate, "_shared", "testing.ts"))) return candidate;
+  throw new Error(`no templates in ${root}/templates or ${root}/../templates`);
+}
+
+/**
+ * The version of @littlebigbrain/client the templates are written for.
+ * @param {string} templates the templates folder
+ */
+export function clientVersion(templates) {
+  const packed = join(templates, "versions.json");
+  if (existsSync(packed)) return JSON.parse(readFileSync(packed, "utf8")).client;
+  const repo = join(templates, "..", "typescript", "package.json");
+  return JSON.parse(readFileSync(repo, "utf8")).version;
+}
+
+/** A package name from a directory name. @param {string} dir */
+const packageName = (dir) =>
+  basename(resolve(dir))
+    .toLowerCase()
+    .replace(/[^a-z0-9-._~]+/g, "-")
+    .replace(/^[-._]+|[-._]+$/g, "") || "workflow";
+
+/**
+ * A template's README as a section of the project's: no title, its headings
+ * one level down, and its links into the repository as plain text.
+ * @param {string} text
+ */
+const projectReadme = (text) =>
+  text
+    .replace(/\[([^\]]+)\]\((?:\.\.\/)+[^)]*\)/g, "$1")
+    .replace(/^# .*\n/, "")
+    .replace(/^(#{2,}) /gm, "#$1 ");
+
+/**
+ * Create the project of `template` in `dir`. Returns the files written,
+ * relative to `dir`, sorted.
+ * @param {{ template: string, dir: string, client?: string, root?: string }} options
+ * @returns {Promise<string[]>}
+ */
+export async function create({ template, dir, client, root = PACKAGE }) {
+  if (!TEMPLATES.includes(template))
+    throw new Error(`unknown template ${template}; the templates are ${TEMPLATES.join(", ")}`);
+  if (existsSync(dir) && (await readdir(dir)).length)
+    throw new Error(`${dir} is not empty: name a new directory`);
+  const templates = templatesRoot(root);
+  const from = join(templates, template);
+  const src = join(dir, "src");
+  await mkdir(src, { recursive: true });
+
+  // The template's code, its test and the test support, all under src/.
+  for (const file of await readdir(from)) {
+    if (!file.endsWith(".ts")) continue;
+    const text = await readFile(join(from, file), "utf8");
+    await writeFile(join(src, file), text.replaceAll("../_shared/testing.js", "./testing.js"));
+  }
+  await cp(join(templates, "_shared", "testing.ts"), join(src, "testing.ts"));
+  await cp(join(from, "samples"), join(dir, "samples"), { recursive: true });
+  for (const file of ["worker.ts", "setup.ts", "try.ts"]) {
+    const text = await readFile(join(root, "project", file), "utf8");
+    await writeFile(join(src, file), text.replaceAll("__TEMPLATE__", template));
+  }
+
+  const name = packageName(dir);
+  const pkg = {
+    name,
+    version: "0.1.0",
+    private: true,
+    type: "module",
+    scripts: {
+      start: "tsx src/worker.ts",
+      setup: "tsx src/setup.ts",
+      try: "tsx src/try.ts",
+      test: "tsx --test src/workflow.test.ts",
+      typecheck: "tsc --noEmit",
+    },
+    dependencies: { "@littlebigbrain/client": client ?? `^${clientVersion(templates)}` },
+    devDependencies: { "@types/node": "^22", tsx: "^4", typescript: "^5.6" },
+  };
+  await writeFile(join(dir, "package.json"), `${JSON.stringify(pkg, null, 2)}\n`);
+  const tsconfig = {
+    compilerOptions: {
+      target: "ES2022",
+      module: "NodeNext",
+      moduleResolution: "NodeNext",
+      lib: ["ES2022"],
+      strict: true,
+      noUncheckedIndexedAccess: true,
+      skipLibCheck: true,
+      types: ["node"],
+      noEmit: true,
+    },
+    include: ["src"],
+  };
+  await writeFile(join(dir, "tsconfig.json"), `${JSON.stringify(tsconfig, null, 2)}\n`);
+  await writeFile(join(dir, ".gitignore"), "node_modules/\ndist/\n.env\n");
+
+  const readme = await readFile(join(from, "README.md"), "utf8");
+  await writeFile(
+    join(dir, "README.md"),
+    `# ${name}
+
+The \`${template}\` starter workflow template of little big brain, as a
+project of its own: a workflow that your \`WorkflowWorker\` runs on a graph.
+
+## Commands
+
+\`\`\`sh
+npm install
+npm test                    # the workflow on its samples, with mock models: no server
+npm run try                 # the samples on a graph of your stack, and the workflow there
+npm run setup && npm start  # your graph: create the workflow, then serve it
+\`\`\`
+
+\`npm run try\`, \`npm run setup\` and \`npm start\` read \`LBB_URL\` (your
+stack's endpoint), \`LBB_API_KEY\` (a key of the stack) and \`LBB_GRAPH\` (the
+graph; \`npm run try\` creates it, default \`try-${template}\`). After
+\`npm run try\`, serve the workflow with \`LBB_GRAPH=try-${template} npm start\`.
+The server needs the workflow engine, and the models need a plan with managed
+models.
+
+## Files
+
+- \`src/workflow.ts\`: the workflow, its settings (\`defaults\`), the triggered
+  workflow that sends it the instances (\`trigger()\`) and the ontology it
+  writes (\`ontology()\`). Change it here.
+- \`src/workflow.test.ts\` and \`src/testing.ts\`: the test, and the mock of
+  the activities and the workflow engine it runs on.
+- \`src/samples.ts\` and \`samples/\`: the samples and what \`npm run try\` does
+  with them.
+- \`src/worker.ts\`, \`src/setup.ts\`, \`src/try.ts\`: the three commands.
+
+## The template
+
+${projectReadme(readme).trim()}
+`,
+  );
+  return listFiles(dir);
+}
+
+/** Every file under `dir`, relative and sorted. @param {string} dir @returns {Promise<string[]>} */
+async function listFiles(dir, prefix = "") {
+  /** @type {string[]} */
+  const out = [];
+  for (const entry of await readdir(join(dir, prefix), { withFileTypes: true })) {
+    const path = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) out.push(...(await listFiles(dir, path)));
+    else out.push(path);
+  }
+  return out.sort();
+}
+
+/**
+ * The command: parse the arguments, create the project, print the next steps.
+ * @param {string[]} argv
+ * @param {{ log?: (line: string) => void }} [io]
+ */
+export async function main(argv, io = {}) {
+  const log = io.log ?? ((line) => console.log(line));
+  const options = parseArgs(argv);
+  if (options.help || !options.template) {
+    log(USAGE);
+    if (!options.help) throw new Error("--template is required");
+    return;
+  }
+  const dir = options.dir ?? options.template;
+  const files = await create({ template: options.template, dir, client: options.client });
+  log(`Created ${dir} from the ${options.template} template (${files.length} files). Next:`);
+  log(`  cd ${dir}`);
+  log("  npm install");
+  log("  npm test");
+  log(`  LBB_URL=... LBB_API_KEY=... LBB_GRAPH=try-${options.template} npm run try`);
+}

package/package.json

@@ -1,6 +1,48 @@
 {
   "name": "@littlebigbrain/create",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Create a project from a little big brain starter workflow template: npm create @littlebigbrain",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/littlebigbrains/lbb-typescript.git",
+    "directory": "create"
+  },
+  "homepage": "https://docs.littlebigbrain.com/guides/workflow-templates/",
+  "bugs": "https://github.com/littlebigbrains/lbb-typescript/issues",
+  "keywords": [
+    "little-big-brain",
+    "workflow",
+    "template",
+    "create"
+  ],
+  "type": "module",
+  "bin": {
+    "create-littlebigbrain": "bin/create-littlebigbrain.mjs"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "project",
+    "templates",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "prepack": "node scripts/copy-templates.mjs",
+    "postpack": "node scripts/copy-templates.mjs --clean",
+    "typecheck": "tsc -p tsconfig.json",
+    "test": "node --test \"test/*.test.mjs\"",
+    "test:coverage": "npm test"
+  },
+  "devDependencies": {
+    "@types/node": "^22",
+    "typescript": "^5.6"
+  }
+}

package/project/setup.ts

@@ -0,0 +1,18 @@
+// Create the workflow on your graph: add the classes and properties it writes, then create the
+// triggered workflow that sends it the instances of the class it watches. Each call is safe to
+// repeat.
+//
+//   LBB_URL=... LBB_API_KEY=... LBB_GRAPH=... npm run setup
+import { LbbClient, lbbActivities } from "@littlebigbrain/client";
+import { ontology, trigger } from "./workflow.js";
+
+const graph = process.env.LBB_GRAPH ?? "main";
+const client = new LbbClient({
+  baseUrl: process.env.LBB_URL ?? "http://127.0.0.1:7400",
+  apiKey: process.env.LBB_API_KEY,
+  graph,
+});
+await lbbActivities(client).evolve(ontology());
+const created = await client.workflows.starters.use(trigger());
+console.log(`Created ${created.name} on the graph ${graph}: ${created.status.state}.`);
+console.log(`Serve it with LBB_GRAPH=${graph} npm start.`);

package/project/try.ts

@@ -0,0 +1,30 @@
+// Try the workflow on its samples: create a graph (default try-__TEMPLATE__), put the samples on
+// it, and create the workflow there. Then serve it with npm start and the same LBB_GRAPH.
+//
+//   LBB_URL=... LBB_API_KEY=... LBB_GRAPH=try-__TEMPLATE__ npm run try
+import { fileURLToPath } from "node:url";
+import { LbbClient, LbbError, lbbActivities } from "@littlebigbrain/client";
+import { loadSamples } from "./samples.js";
+import { ontology, trigger } from "./workflow.js";
+
+const graph = process.env.LBB_GRAPH ?? "try-__TEMPLATE__";
+const client = new LbbClient({
+  baseUrl: process.env.LBB_URL ?? "http://127.0.0.1:7400",
+  apiKey: process.env.LBB_API_KEY,
+  graph,
+});
+try {
+  await client.graph(graph).create();
+  console.log(`Created the graph ${graph}`);
+} catch (error) {
+  // 409: the graph exists already.
+  if (!(error instanceof LbbError && error.status === 409)) throw error;
+}
+await lbbActivities(client).evolve(ontology());
+await loadSamples(client, fileURLToPath(new URL("../samples/", import.meta.url)));
+const created = await client.workflows.starters.use(trigger());
+console.log(`Created ${created.name} on the graph ${graph}: ${created.status.state}.`);
+console.log(`Serve it with LBB_GRAPH=${graph} npm start, and follow it with:`);
+console.log(
+  `  curl "$LBB_URL/v1/workflows/triggered?graph=${graph}&starter=workflow&name=${created.name}" -H "Authorization: Bearer $LBB_API_KEY"`,
+);

package/project/worker.ts

@@ -0,0 +1,23 @@
+// Serve the workflow: the worker claims the turns of its trigger messages and runs them, one at a
+// time. Run more workers for more at once.
+//
+//   LBB_URL=... LBB_API_KEY=... LBB_GRAPH=... npm start
+import { LbbClient, WorkflowWorker, lbbActivities } from "@littlebigbrain/client";
+import { createWorkflow } from "./workflow.js";
+
+const graph = process.env.LBB_GRAPH ?? "main";
+const client = new LbbClient({
+  baseUrl: process.env.LBB_URL ?? "http://127.0.0.1:7400",
+  apiKey: process.env.LBB_API_KEY,
+  graph,
+});
+const workflow = createWorkflow(lbbActivities(client));
+const stop = new AbortController();
+process.once("SIGINT", () => stop.abort());
+process.once("SIGTERM", () => stop.abort());
+console.log(
+  `Serving ${workflow.name}@${workflow.version} for the graph ${graph}. Stop with Ctrl-C.`,
+);
+await new WorkflowWorker(client, [workflow], {
+  worker: process.env.LBB_WORKER_ID ?? `${workflow.name}-1`,
+}).run({ signal: stop.signal });