@boardwalk-labs/cli 0.1.9 → 0.1.10

package/README.md

@@ -44,7 +44,7 @@ boardwalk dev ./index.ts --stream phase,log
 
 ## Deploying
 
-- **`deploy <file|dir> --org <slug>`** — create/update the workflow (idempotent by `meta.name`).
+- **`deploy <file|dir> --org <slug>`** — create/update the workflow (idempotent by `meta.slug`).
   `--dry-run` prints the plan only.
 - **`run <file|dir> --org <slug>`** — deploy the current source, trigger a **real run on the
   platform**, and wait for it to finish. `--no-wait` triggers and exits.
@@ -59,7 +59,7 @@ your `meta` — the CLI never sends a hand-built manifest.
 
 The first `deploy`/`run` in a directory writes a gitignored `.boardwalk/project.json`
 with `{ orgSlug, workflowId }`. After that the workflow is identified by that stored **id**, so
-`--org` is optional and renaming `meta.name` or the entry file updates the same workflow instead of
+`--org` is optional and renaming `meta.slug` or the entry file updates the same workflow instead of
 forking a new one. On a fresh clone, pass `--org` once to re-link (it adopts an existing same-name
 workflow if present, else creates one).
 

package/dist/client.d.ts

@@ -1,7 +1,7 @@
 import type { FetchLike } from "./auth/pkce.js";
 export interface WorkflowSummary {
     id: string;
-    name: string;
+    slug: string;
     currentVersionId: string | null;
 }
 export interface DeployResult {

package/dist/commands/deploy.js

@@ -31,7 +31,7 @@ export async function runDeploy(opts, deps) {
     const dep = await deployWithLink(client, { orgSlug: opts.org, target: opts.file, prog });
     if (dep.gitignoreUpdated)
         log("  linked → .boardwalk/project.json (added .boardwalk/ to .gitignore)");
-    log(`✓ ${dep.outcome} "${prog.name}" version ${String(dep.versionNumber)} (${dep.workflowId})`);
+    log(`✓ ${dep.outcome} "${prog.slug}" version ${String(dep.versionNumber)} (${dep.workflowId})`);
 }
 /** Read-only preview of what `deploy` would do (no writes). */
 async function printPlan(client, opts, prog, log) {
@@ -41,12 +41,12 @@ async function printPlan(client, opts, prog, log) {
         return;
     }
     if (opts.org === undefined || opts.org.length === 0) {
-        log(`plan: CREATE "${prog.name}" (unlinked — pass --org to check for an existing match)`);
+        log(`plan: CREATE "${prog.slug}" (unlinked — pass --org to check for an existing match)`);
         return;
     }
-    const plan = planDeploy(await client.listWorkflows(opts.org), prog.name);
+    const plan = planDeploy(await client.listWorkflows(opts.org), prog.slug);
     log(plan.action === "create"
-        ? `plan: CREATE "${prog.name}" in org ${opts.org}`
-        : `plan: ADOPT existing "${prog.name}" (${plan.workflowId ?? "?"}) → new version`);
+        ? `plan: CREATE "${prog.slug}" in org ${opts.org}`
+        : `plan: ADOPT existing "${prog.slug}" (${plan.workflowId ?? "?"}) → new version`);
 }
 //# sourceMappingURL=deploy.js.map

package/dist/commands/dev.js

@@ -70,7 +70,7 @@ export async function runDev(opts, deps = {}) {
     });
     try {
         const workflow = engine.deploy(program);
-        const run = engine.start(workflow.name, input);
+        const run = engine.start(workflow.slug, input);
         runId = run.id;
         const result = await engine.wait(run.id);
         if (result.status === "completed")

package/dist/commands/run.js

@@ -66,7 +66,7 @@ export async function runRun(opts, deps) {
     const dep = await deployWithLink(client, { orgSlug: opts.org, target: opts.file, prog });
     if (dep.gitignoreUpdated)
         log("  linked → .boardwalk/project.json (added .boardwalk/ to .gitignore)");
-    log(`✓ ${dep.outcome} "${prog.name}" version ${String(dep.versionNumber)}`);
+    log(`✓ ${dep.outcome} "${prog.slug}" version ${String(dep.versionNumber)}`);
     const input = parseInput(opts.input);
     const run = await client.triggerRun(dep.orgSlug, dep.workflowId, input);
     log(`▶ run ${run.id} triggered (${run.status})`);

package/dist/deployment.d.ts

@@ -1,7 +1,7 @@
 import { type BuiltArtifact } from "./artifact.js";
 import type { BoardwalkClient, WorkflowSummary } from "./client.js";
 export interface PreparedProgram {
-    name: string;
+    slug: string;
     /** Entry module inside the artifact (e.g. `index.mjs`). */
     entry: string;
     /** The built, content-addressed program artifact (tarball + digest + metadata). */
@@ -9,17 +9,17 @@ export interface PreparedProgram {
 }
 /**
  * Resolve a target path to its deployable artifact: build the program (bundle + assets → tarball,
- * content-addressed) and extract `meta.name` from the bundled entry for the deploy identity.
+ * content-addressed) and extract `meta.slug` from the bundled entry for the deploy identity.
  */
 export declare function loadProgram(file: string): Promise<PreparedProgram>;
 export interface DeployPlan {
     action: "create" | "update";
-    name: string;
+    slug: string;
     /** Present only for `update` — the existing workflow id to PUT. */
     workflowId?: string;
 }
-/** Decide create vs update by matching the program name against the org's existing workflows. */
-export declare function planDeploy(existing: readonly WorkflowSummary[], name: string): DeployPlan;
+/** Decide create vs update by matching the program slug against the org's existing workflows. */
+export declare function planDeploy(existing: readonly WorkflowSummary[], slug: string): DeployPlan;
 export interface DeployResultSummary {
     workflowId: string;
     orgSlug: string;

package/dist/deployment.js

@@ -15,19 +15,19 @@ import { buildArtifact } from "./artifact.js";
 import { projectDirFor, readLink, writeLink } from "./project.js";
 /**
  * Resolve a target path to its deployable artifact: build the program (bundle + assets → tarball,
- * content-addressed) and extract `meta.name` from the bundled entry for the deploy identity.
+ * content-addressed) and extract `meta.slug` from the bundled entry for the deploy identity.
  */
 export async function loadProgram(file) {
     const artifact = await buildArtifact(file);
-    const name = extractWorkflowSlug(artifact.entrySource, artifact.entry);
-    return { name, entry: artifact.entry, artifact };
+    const slug = extractWorkflowSlug(artifact.entrySource, artifact.entry);
+    return { slug, entry: artifact.entry, artifact };
 }
-/** Decide create vs update by matching the program name against the org's existing workflows. */
-export function planDeploy(existing, name) {
-    const match = existing.find((w) => w.name === name);
+/** Decide create vs update by matching the program slug against the org's existing workflows. */
+export function planDeploy(existing, slug) {
+    const match = existing.find((w) => w.slug === slug);
     return match !== undefined
-        ? { action: "update", name, workflowId: match.id }
-        : { action: "create", name };
+        ? { action: "update", slug, workflowId: match.id }
+        : { action: "create", slug };
 }
 /** The artifact reference recorded on the version (everything but the bytes, which go to storage). */
 function refOf(artifact) {
@@ -56,7 +56,7 @@ export async function deployWithLink(client, ctx) {
     // Unlinked: adopt an existing workflow with the same name, if any (so a second machine re-links
     // instead of creating a duplicate). Otherwise we'll create below.
     if (workflowId === null) {
-        const match = (await client.listWorkflows(orgSlug)).find((w) => w.name === ctx.prog.name);
+        const match = (await client.listWorkflows(orgSlug)).find((w) => w.slug === ctx.prog.slug);
         if (match !== undefined) {
             workflowId = match.id;
             outcome = "adopted";

package/dist/dev/engine.d.ts

@@ -12,7 +12,7 @@ export interface DevEngine {
     onEvent(listener: (event: RunEvent) => void): () => void;
     /** Deploy the bundled program; returns the derived workflow name. */
     deploy(program: string): {
-        name: string;
+        slug: string;
     };
     /** Queue + dispatch a run; returns its id immediately. */
     start(workflowName: string, input: JsonValue | undefined): {

package/dist/dev/engine.js

@@ -23,7 +23,7 @@ export const createDevEngine = (opts) => {
         }),
         deploy: (program) => {
             const workflow = engine.deployWorkflow({ program });
-            return { name: workflow.name };
+            return { slug: workflow.slug };
         },
         start: (workflowName, input) => {
             const run = engine.startRun(workflowName, input !== undefined ? { input } : {});

package/dist/project.js

@@ -2,7 +2,7 @@
 // Project link — the Vercel-style tie between a local workflow directory and its deployed workflow.
 //
 // `<projectDir>/.boardwalk/project.json` (gitignored) stores `{ orgSlug, workflowId }`. Once linked,
-// `deploy`/`run` update the workflow BY ID — so renaming `meta.name` (or the entry file) just
+// `deploy`/`run` update the workflow BY ID — so renaming `meta.slug` (or the entry file) just
 // updates the same workflow instead of forking a new one, and `--org` is no longer needed. The id is
 // environment-specific (a dev workflow id ≠ prod), so the link is gitignored, not committed.
 //

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boardwalk-labs/cli",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "The boardwalk CLI: author, validate, run, and deploy Boardwalk workflows.",
   "license": "MIT",
   "repository": {
@@ -35,7 +35,7 @@
     "boardwalk": "tsx src/index.ts"
   },
   "dependencies": {
-    "@boardwalk-labs/engine": "^0.1.4",
+    "@boardwalk-labs/engine": "^0.1.5",
     "@boardwalk-labs/workflow": "^0.1.5",
     "commander": "^13.1.0",
     "env-paths": "^3.0.0",