tines 0.0.242 → 0.0.244

package/dist/index.js

@@ -4243,8 +4243,8 @@ function createApiClient(options) {
     getPublicationResult: (candidateId) => get(
       `/api/v1/publications/${encodeURIComponent(candidateId)}/result`
     ),
-    listPublications: (workflow2) => get(
-      `/api/v1/publications${query({ workflow: workflow2 })}`
+    listPublications: (workflow2, page) => get(
+      `/api/v1/publications${query({ workflow: workflow2, ...page })}`
     ),
     withdrawPublication: (snapshotId) => request(
       "POST",
@@ -4453,11 +4453,12 @@ async function* listPages(fetchPage, opts = {}) {
   const maxItems = opts.maxItems ?? MAX_ALL_PAGES_ITEMS;
   const seen = /* @__PURE__ */ new Set();
   const seenCursors = /* @__PURE__ */ new Set();
+  const identify = opts.identify ?? ((item) => item.id);
   let cursor;
   for (; ; ) {
     const res = await fetchPage({ limit: pageSize, cursor });
-    const fresh = res.items.filter((item) => !seen.has(item.id));
-    for (const item of fresh) seen.add(item.id);
+    const fresh = res.items.filter((item) => !seen.has(identify(item)));
+    for (const item of fresh) seen.add(identify(item));
     if (seen.size > maxItems) {
       throw new Error(
         `list has more than ${maxItems} items \u2014 narrow it with filters, or page manually with --cursor`
@@ -5549,21 +5550,35 @@ var PACKAGE_CHOICES_MAX_BYTES = 512 * 1024;
 var PUBLIC_WORKFLOW_MAX_BYTES = 1048576;
 var PUBLICATION_CANDIDATE_TTL_MS = 15 * 60 * 1e3;
 var SNAPSHOT_ID = /^[A-Za-z0-9_-]{20,100}$/;
-function parsePublicSnapshotReference(value, configuredOrigin) {
-  if (SNAPSHOT_ID.test(value)) return value;
+function parsePublicSnapshotUrl(value) {
   let url;
   try {
     url = new URL(value);
   } catch {
-    throw new Error("Expected a publication ID or canonical public URL");
+    throw new Error("Expected a canonical public URL");
   }
-  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.hash)
-    throw new Error("Invalid public publication URL");
-  if (configuredOrigin && url.origin !== new URL(configuredOrigin).origin)
+  if (!["http:", "https:"].includes(url.protocol))
+    throw new Error("Invalid public publication URL: must use HTTP or HTTPS");
+  if (url.username || url.password)
+    throw new Error("Invalid public publication URL: must not contain credentials");
+  if (url.hash) throw new Error("Invalid public publication URL: must not contain a fragment");
+  if (url.search)
+    throw new Error("Invalid public publication URL: must not contain query parameters");
+  const match = /^\/p\/([A-Za-z0-9_-]{20,100})(?:\/download)?$/.exec(url.pathname) ?? /^\/api\/v1\/publications\/public\/([A-Za-z0-9_-]{20,100})\/download$/.exec(url.pathname);
+  if (!match) throw new Error("Invalid public publication URL: expected a canonical path");
+  const origin = url.origin;
+  return {
+    snapshotId: match[1],
+    publicUrl: `${origin}/p/${match[1]}`,
+    downloadUrl: `${origin}/api/v1/publications/public/${match[1]}/download`
+  };
+}
+function parsePublicSnapshotReference(value, configuredOrigin) {
+  if (SNAPSHOT_ID.test(value)) return value;
+  const parsed = parsePublicSnapshotUrl(value);
+  if (configuredOrigin && new URL(parsed.publicUrl).origin !== new URL(configuredOrigin).origin)
     throw new Error("external_source_requires_download");
-  const match = /^\/p\/([A-Za-z0-9_-]{20,100})(?:\/download)?$/.exec(url.pathname);
-  if (!match || url.search) throw new Error("Invalid public publication URL");
-  return match[1];
+  return parsed.snapshotId;
 }
 
 // ../shared/src/usage.ts
@@ -6125,10 +6140,14 @@ more results: rerun with --all-pages, or resume with --cursor ${res.next_cursor}
     );
   }
 }
-async function fetchList(opts, fetchPage) {
+async function fetchList(opts, fetchPage, identify) {
   if (opts.allPages) {
     return {
-      items: await listAll(fetchPage, { pageSize: opts.limit, maxItems: opts.maxItems }),
+      items: await listAll(fetchPage, {
+        pageSize: opts.limit,
+        maxItems: opts.maxItems,
+        identify: identify ?? ((item) => item.id)
+      }),
       next_cursor: null
     };
   }
@@ -12937,7 +12956,7 @@ async function askToInstall(plan) {
     rl.close();
   }
 }
-async function recoverOrInstall(api, raw, plan) {
+async function recoverOrInstall(api, rawOrLoader, plan) {
   const checked = (receipt) => {
     if (receipt.id !== plan.plan_id || receipt.document_digest !== plan.document_digest || receipt.plan_digest !== plan.plan_digest)
       throw new Error("recovered workflow package receipt does not match the saved plan");
@@ -12948,6 +12967,7 @@ async function recoverOrInstall(api, raw, plan) {
   } catch (error) {
     if (!(error instanceof ApiError) || error.status !== 404) throw error;
   }
+  const raw = typeof rawOrLoader === "function" ? await rawOrLoader() : rawOrLoader;
   const request = {
     document_json: raw,
     plan_token: plan.plan_token,
@@ -12971,7 +12991,6 @@ import { lookup as dnsLookup } from "node:dns/promises";
 import { request as httpRequest } from "node:http";
 import { request as httpsRequest } from "node:https";
 import { isIP } from "node:net";
-var SNAPSHOT_PATH = /^\/p\/[A-Za-z0-9_-]{20,100}(?:\/download)?$/;
 var MAX_REDIRECTS = 3;
 var DEFAULT_TIMEOUT_MS = 3e4;
 function mappedIpv4(address) {
@@ -13038,40 +13057,51 @@ function isPublicAddress(address) {
   }
   return false;
 }
-function validateHop(url, initial) {
+function validateHop(url) {
   if (!["http:", "https:"].includes(url.protocol))
     throw new Error("publication URL must use HTTPS");
   if (url.username || url.password) throw new Error("publication URL must not contain credentials");
   if (url.hash) throw new Error("publication URL must not contain a fragment");
   if (url.search) throw new Error("publication URL must not contain query parameters");
-  if (initial && !SNAPSHOT_PATH.test(url.pathname))
-    throw new Error("expected a canonical public snapshot or download URL");
 }
-async function pinnedAddress(url, lookup) {
+async function pinnedAddresses(url, lookup) {
   const hostname4 = url.hostname.replace(/^\[|\]$/g, "");
   const literalFamily = isIP(hostname4);
   const addresses = literalFamily ? [{ address: hostname4, family: literalFamily }] : await lookup(hostname4, { all: true, verbatim: true });
-  if (!addresses.length) throw new Error(`publication host ${url.hostname} did not resolve`);
-  const loopbackDevelopment = url.protocol === "http:" && (url.hostname === "localhost" || addresses.every(({ address }) => isLoopback(address)));
+  if (!addresses.length || addresses.some(({ address, family }) => isIP(address) !== family || ![4, 6].includes(family)))
+    throw new Error(`publication host ${url.hostname} did not resolve to valid addresses`);
+  const literalLoopback = Boolean(literalFamily && isLoopback(hostname4));
+  const loopbackDevelopment = url.protocol === "http:" && (url.hostname === "localhost" || literalLoopback) && addresses.every(({ address }) => isLoopback(address));
   if (url.protocol === "http:" && !loopbackDevelopment)
     throw new Error(
       "publication URL must use HTTPS (HTTP is allowed only for loopback development)"
     );
   if (!loopbackDevelopment && addresses.some(({ address }) => !isPublicAddress(address)))
     throw new Error("publication URL resolves to a private or reserved address");
-  return addresses[0];
+  return addresses;
+}
+function pinnedLookup(addresses) {
+  return (_hostname, opts, callback) => {
+    const family = typeof opts.family === "number" ? opts.family : 0;
+    const matching = family === 4 || family === 6 ? addresses.filter((item) => item.family === family) : addresses;
+    if (!matching.length)
+      return callback(new Error(`publication host has no IPv${family} address`));
+    if (opts.all) return callback(null, matching);
+    return callback(null, matching[0].address, matching[0].family);
+  };
 }
 async function readHop(url, options) {
-  const pinned = await pinnedAddress(url, options.lookup);
+  const pinned = await pinnedAddresses(url, options.lookup);
   return new Promise((resolve2, reject) => {
     const request = (url.protocol === "https:" ? httpsRequest : httpRequest)(
       url,
       {
         method: "GET",
         headers: { accept: "application/json" },
-        lookup: (_hostname, _opts, callback) => callback(null, pinned.address, pinned.family)
+        lookup: pinnedLookup(pinned)
       },
       (response) => {
+        let responseFailure;
         const status = response.statusCode ?? 0;
         if (status >= 300 && status < 400) {
           response.resume();
@@ -13101,10 +13131,16 @@ async function readHop(url, options) {
         const chunks = [];
         response.on("data", (chunk) => {
           size += chunk.length;
-          if (size > options.maxBytes)
-            response.destroy(new Error("publication download is too large"));
-          else chunks.push(chunk);
+          if (size > options.maxBytes) {
+            responseFailure = new Error("publication download is too large");
+            response.destroy(responseFailure);
+          } else chunks.push(chunk);
         });
+        response.on(
+          "aborted",
+          () => reject(responseFailure ?? new Error("publication download was aborted"))
+        );
+        response.on("error", reject);
         response.on("end", () => {
           try {
             resolve2({
@@ -13128,17 +13164,11 @@ async function readHop(url, options) {
   });
 }
 async function fetchPublicWorkflowPackage(value, options = {}) {
-  let url;
-  try {
-    url = new URL(value);
-  } catch {
-    throw new Error("expected a canonical public snapshot or download URL");
-  }
-  validateHop(url, true);
-  if (!url.pathname.endsWith("/download")) url.pathname += "/download";
-  const sourceUrl = url.toString();
+  const parsed = parsePublicSnapshotUrl(value);
+  let url = new URL(parsed.downloadUrl);
+  const sourceUrl = parsed.downloadUrl;
   for (let redirects = 0; ; redirects += 1) {
-    validateHop(url, false);
+    validateHop(url);
     const result = await readHop(url, {
       lookup: options.lookup ?? dnsLookup,
       timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
@@ -13170,6 +13200,44 @@ function readPublicationProof(path2) {
     die("invalid workflow publication proof file");
   return saved;
 }
+function withWorkflowExportSelectors(cmd) {
+  return cmd.option("--project <id-or-name>", "source project for selected project-bound configuration").option("--schedule <id>", "include this source schedule ID (repeatable)", collect2, []).option("--tier <state-ref=tier>", "include a state tier preference (repeatable)", collect2, []).option("--project-routing", "make every --tier selector project scoped").option("--inputs <file>", "JSON object containing input declarations and text uses");
+}
+function hasWorkflowExportSelectors(opts) {
+  return Boolean(
+    opts.project || opts.schedule.length || opts.tier.length || opts.projectRouting || opts.inputs
+  );
+}
+async function resolveWorkflowExportSelection(api, workflowRef, opts) {
+  const all = await listAll((page) => api.listWorkflows(page));
+  const workflow2 = pickWorkflow(all, workflowRef);
+  const sourceProject = opts.project ? await resolveProject(api, opts.project) : void 0;
+  if ((opts.schedule.length || opts.projectRouting) && !sourceProject)
+    die("--project is required with --schedule or --project-routing");
+  const tiers = [];
+  for (const selector of opts.tier) {
+    const separator = selector.lastIndexOf("=");
+    if (separator < 1) die(`invalid --tier "${selector}"; expected <state-ref>=<tier>`);
+    const tier = selector.slice(separator + 1);
+    if (!["smartest", "balanced", "cheapest"].includes(tier))
+      die(`invalid tier "${tier}"; expected smartest, balanced, or cheapest`);
+    tiers.push({
+      state_id: await resolveExportState(api, selector.slice(0, separator)),
+      tier,
+      project_scoped: Boolean(opts.projectRouting)
+    });
+  }
+  const authoring = opts.inputs ? readStrictObject(opts.inputs, "inputs file") : void 0;
+  return {
+    workflow: workflow2,
+    options: {
+      source_project_id: sourceProject?.id,
+      schedule_ids: opts.schedule,
+      tiers,
+      authoring
+    }
+  };
+}
 async function confirmPublicationAction(question) {
   const rl = createInterface5({ input: process.stdin, output: process.stderr });
   try {
@@ -13519,14 +13587,18 @@ function registerPackageCommands(workflows) {
     if (!result.valid) process.exitCode = 1;
   });
   withCommon(
-    workflows.command("publish [workflow]").description("Prepare or commit one exact immutable public workflow snapshot").option(
-      "--from <file>",
-      "prepare from an existing workflow package instead of an owned workflow"
-    ).option("--proof-out <file>", "save the complete prepared proof with mode 0600").option("--proof <file>", "commit a previously saved exact proof").option("--display-name <name>", "public attribution name (never an email)").option("--license <license>", "reuse license (currently MIT)", "MIT").option("--license-year <year>", "MIT copyright year", String((/* @__PURE__ */ new Date()).getFullYear())).option("--confirm <review-digest>", "exact digest of the reviewed proof").option("--sharing-rights", "confirm rights to every bundled declaration and file").option("--recover", "reconcile this same candidate after a lost response").option("--repo <local-id>", "confirm one bundled repository ID (repeatable)", collect2, [])
+    withWorkflowExportSelectors(
+      workflows.command("publish [workflow]").description("Prepare or commit one exact immutable public workflow snapshot").option(
+        "--from <file>",
+        "prepare from an existing workflow package instead of an owned workflow"
+      ).option("--proof-out <file>", "save the complete prepared proof with mode 0600").option("--proof <file>", "commit a previously saved exact proof").option("--display-name <name>", "public attribution name (never an email)").option("--license <license>", "reuse license (currently MIT)", "MIT").option("--license-year <year>", "MIT copyright year", String((/* @__PURE__ */ new Date()).getFullYear())).option("--confirm <review-digest>", "exact digest of the reviewed proof").option("--sharing-rights", "confirm rights to every bundled declaration and file").option("--recover", "reconcile this same candidate after a lost response").option("--repo <local-id>", "confirm one bundled repository ID (repeatable)", collect2, [])
+    )
   ).action(
     async (workflow2, opts) => {
       const apiBase = normalizeUrl(resolveUrl(opts));
       const api = client(opts);
+      if ((opts.from || opts.proof) && hasWorkflowExportSelectors(opts))
+        die("workflow selectors cannot be combined with --from or --proof");
       if (opts.proof) {
         if (workflow2 || opts.from || opts.proofOut || opts.displayName)
           die(
@@ -13540,11 +13612,13 @@ function registerPackageCommands(workflows) {
           die(`confirmation digest does not match reviewed proof ${proof2.review_digest}`);
         if (!process.stdin.isTTY && (opts.confirm !== proof2.review_digest || !opts.sharingRights))
           die(`non-interactive publish requires --confirm ${proof2.review_digest} --sharing-rights`);
-        if (process.stdin.isTTY && !opts.confirm) {
+        if (process.stdin.isTTY && opts.confirm !== proof2.review_digest) {
           process.stderr.write(`${JSON.stringify(proof2, null, 2)}
 `);
           if (!await confirmPublicationAction("Publish these exact immutable bytes?"))
             die("publication declined");
+        }
+        if (process.stdin.isTTY && !opts.sharingRights) {
           if (!await confirmPublicationAction("Do you have sharing rights for every bundled item?"))
             die("publication declined");
         }
@@ -13573,11 +13647,16 @@ function registerPackageCommands(workflows) {
       if (opts.license !== "MIT") die("--license currently supports only MIT");
       const year = Number(opts.licenseYear);
       if (!Number.isSafeInteger(year)) die("--license-year must be an integer");
-      const source = opts.from ? { kind: "file", document_json: readPackageSource(opts.from) } : {
-        kind: "owned_workflow",
-        workflow_id: (await resolveWorkflow(api, workflow2)).id,
-        options: { schedule_ids: [], tiers: [] }
-      };
+      let source;
+      if (opts.from) source = { kind: "file", document_json: readPackageSource(opts.from) };
+      else {
+        const selected = await resolveWorkflowExportSelection(api, workflow2, opts);
+        source = {
+          kind: "owned_workflow",
+          workflow_id: selected.workflow.id,
+          options: selected.options
+        };
+      }
       const proof = await api.preparePublication({
         prepare_request_id: crypto.randomUUID(),
         source,
@@ -13591,22 +13670,26 @@ function registerPackageCommands(workflows) {
       }
     }
   );
-  withCommon(
+  withList(
     workflows.command("publications").description("List your public workflow snapshots").option("--workflow <id>", "filter by owned source workflow ID")
   ).action(async (opts) => {
-    const result = await client(opts).listPublications(opts.workflow);
-    if (opts.json) printJson(result);
-    else if (!result.items.length) console.log("no public snapshots");
-    else
+    const result = await fetchList(
+      opts,
+      (page) => client(opts).listPublications(opts.workflow, page),
+      (item) => item.candidate_id
+    );
+    printList(result, opts, (items) => {
+      if (!items.length) return console.log("no public snapshots");
       table([
         ["NAME", "STATUS", "PUBLISHED", "SNAPSHOT"],
-        ...result.items.map((item) => [
+        ...items.map((item) => [
           item.metadata.display_name,
           item.owner_state === "published" && item.host_state === "active" ? "hosted" : "unavailable",
           new Date(item.published_at).toISOString(),
           item.snapshot_id
         ])
       ]);
+    });
   });
   withCommon(
     workflows.command("unpublish <public-url-or-id>").description("Withdraw a hosted public snapshot").option("-y, --yes", "skip the explicit withdrawal prompt")
@@ -13633,44 +13716,16 @@ function registerPackageCommands(workflows) {
     else console.log(`restored ${result.receipt.public_url}`);
   });
   withCommon(
-    workflows.command("export <workflow-id-or-unambiguous-name>").description("Export a canonical workflow package JSON document").option("--project <id-or-name>", "source project for selected project-bound configuration").option("--schedule <id>", "include this source schedule ID (repeatable)", collect2, []).option(
-      "--tier <state-ref=tier>",
-      "include a state tier preference (repeatable)",
-      collect2,
-      []
-    ).option("--project-routing", "make every --tier selector project scoped").option("--inputs <file>", "JSON object containing input declarations and text uses")
-  ).action(
-    async (ref, opts) => {
-      const api = client(opts);
-      const all = await listAll((page) => api.listWorkflows(page));
-      const workflow2 = pickWorkflow(all, ref);
-      const sourceProject = opts.project ? await resolveProject(api, opts.project) : void 0;
-      if ((opts.schedule.length || opts.projectRouting) && !sourceProject)
-        die("--project is required with --schedule or --project-routing");
-      const tiers = [];
-      for (const selector of opts.tier) {
-        const separator = selector.lastIndexOf("=");
-        if (separator < 1) die(`invalid --tier "${selector}"; expected <state-ref>=<tier>`);
-        const tier = selector.slice(separator + 1);
-        if (!["smartest", "balanced", "cheapest"].includes(tier))
-          die(`invalid tier "${tier}"; expected smartest, balanced, or cheapest`);
-        tiers.push({
-          state_id: await resolveExportState(api, selector.slice(0, separator)),
-          tier,
-          project_scoped: Boolean(opts.projectRouting)
-        });
-      }
-      const authoring = opts.inputs ? readStrictObject(opts.inputs, "inputs file") : void 0;
-      const document = await api.exportWorkflowPackage(workflow2.id, {
-        source_project_id: sourceProject?.id,
-        schedule_ids: opts.schedule,
-        tiers,
-        authoring
-      });
-      process.stdout.write(`${canonicalWorkflowPackage(document)}
+    withWorkflowExportSelectors(
+      workflows.command("export <workflow-id-or-unambiguous-name>").description("Export a canonical workflow package JSON document")
+    )
+  ).action(async (ref, opts) => {
+    const api = client(opts);
+    const selected = await resolveWorkflowExportSelection(api, ref, opts);
+    const document = await api.exportWorkflowPackage(selected.workflow.id, selected.options);
+    process.stdout.write(`${canonicalWorkflowPackage(document)}
 `);
-    }
-  );
+  });
   withCommon(
     workflows.command("validate <file>").description("Validate a workflow package file (use - for stdin)").option("--public", "apply the stricter text-only public-hosting policy")
   ).action(async (path2, opts) => {
@@ -13739,39 +13794,45 @@ function registerPackageCommands(workflows) {
         );
       const apiBase = normalizeUrl(resolveUrl(opts));
       const api = client(opts);
-      const source = publicationSource(path2, apiBase);
-      let raw;
+      let loadSource;
       let plan;
       let planPath = opts.plan;
       if (planPath) {
         const saved = readWorkflowPackagePlan(planPath);
         if (normalizeUrl(saved.api_base) !== apiBase)
           die(`plan belongs to ${saved.api_base}, not ${apiBase}`);
-        if (saved.remote_source) {
-          if (source.kind !== "remote")
-            die("saved remote plan must be installed from its public source URL");
-          const fetched = await fetchPublicWorkflowPackage(path2);
-          if (fetched.sourceUrl !== saved.remote_source.url || workflowPackageBytesSha256(fetched.raw) !== saved.remote_source.bytes_sha256)
-            die("public source changed since preview; create and review a fresh plan");
-          raw = fetched.raw;
-        } else if (saved.plan.source?.kind === "hosted_publication") {
-          if (source.kind !== "hosted" || source.snapshotId !== saved.plan.source.snapshot_id)
-            die("saved hosted plan belongs to a different public snapshot");
-          await api.getPublicSnapshotStatus(source.snapshotId);
-          raw = canonicalWorkflowPackage(saved.plan.document);
-        } else {
-          if (source.kind !== "file") die("saved file plan must be installed from its file");
-          raw = readPackageSource(path2);
-        }
-        const { document } = await packageDocument(raw);
-        if (saved.document_digest !== document.digest || saved.plan.document_digest !== document.digest || canonicalWorkflowPackage(saved.plan.document) !== canonicalWorkflowPackage(document))
-          die(
-            `package digest ${document.digest} does not match saved plan ${saved.document_digest}`
-          );
         plan = saved.plan;
+        loadSource = async () => {
+          const source = publicationSource(path2, apiBase);
+          let raw;
+          if (saved.remote_source) {
+            if (source.kind !== "remote")
+              die("saved remote plan must be installed from its public source URL");
+            const fetched = await fetchPublicWorkflowPackage(path2);
+            if (fetched.sourceUrl !== saved.remote_source.url || workflowPackageBytesSha256(fetched.raw) !== saved.remote_source.bytes_sha256)
+              die("public source changed since preview; create and review a fresh plan");
+            raw = fetched.raw;
+          } else if (saved.plan.source?.kind === "hosted_publication") {
+            if (source.kind !== "hosted" || source.snapshotId !== saved.plan.source.snapshot_id)
+              die("saved hosted plan belongs to a different public snapshot");
+            await api.getPublicSnapshotStatus(source.snapshotId);
+            raw = canonicalWorkflowPackage(saved.plan.document);
+          } else {
+            if (source.kind !== "file") die("saved file plan must be installed from its file");
+            raw = readPackageSource(path2);
+          }
+          const { document } = await packageDocument(raw);
+          if (saved.document_digest !== document.digest || saved.plan.document_digest !== document.digest || canonicalWorkflowPackage(saved.plan.document) !== canonicalWorkflowPackage(document))
+            die(
+              `package digest ${document.digest} does not match saved plan ${saved.document_digest}`
+            );
+          return raw;
+        };
       } else {
+        const source = publicationSource(path2, apiBase);
         const choices = opts.choices ? readStrictObject(opts.choices, "choices file") : void 0;
         let remoteSource;
+        let raw;
         if (source.kind === "hosted") {
           plan = await api.prepareHostedWorkflowPackage(source.snapshotId, choices);
           raw = canonicalWorkflowPackage(plan.document);
@@ -13791,6 +13852,7 @@ function registerPackageCommands(workflows) {
         planPath = source.kind === "file" ? `${path2}.plan.json` : "workflow-publication.plan.json";
         saveWorkflowPackagePlan(planPath, apiBase, plan, remoteSource);
         console.error(`saved retryable signed plan to ${planPath}`);
+        loadSource = async () => raw;
       }
       if (opts.confirm !== void 0 && opts.confirm !== plan.plan_digest)
         die(`confirmation digest does not match reviewed plan ${plan.plan_digest}`);
@@ -13802,7 +13864,7 @@ function registerPackageCommands(workflows) {
         process.stderr.write(`${formatWorkflowPackageReview(plan)}
 `);
       }
-      const receipt = await recoverOrInstall(api, raw, plan);
+      const receipt = await recoverOrInstall(api, loadSource, plan);
       if (opts.json) printJson(receipt);
       else {
         console.log(`installed workflow package (${receipt.id})`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tines",
-  "version": "0.0.242",
+  "version": "0.0.244",
   "description": "CLI for Tines, an orchestration layer for AI agents",
   "repository": {
     "type": "git",