@intercom/cli 0.8.3 → 0.10.0

package/CHANGELOG.md

@@ -7,6 +7,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 View it from the CLI with `intercom changelog`.
 
+## [0.10.0] - 2026-08-17
+
+### Added
+
+- `fin procedures publish <id>` sets a procedure's state to live, and `fin procedures pause <id>` sets it to paused — a convenience for download, edit the state, and re-upload. Both accept `--note <text>` to label the save in `fin procedures versions <id>`. There is no `draft` verb: the upload endpoint rejects that state and directs you to `pause`.
+- `fin procedures versions <id>` lists a procedure's server-side version history, showing which version is live, which is draft, and who saved it. `fin procedures get <id> --version <version_id>` downloads any of those versions as re-uploadable YAML, so a local file can be diffed against what Fin is actually running.
+- `fin procedures upload <file> --note <text>` records a version note against the save, so the entry is identifiable in `fin procedures versions`. `--verify` compares what the server saved against the file you uploaded and exits non-zero listing any field that did not survive the round-trip (fields the server adds, like ids and defaults, are ignored) — useful when a setting silently resets on push.
+- `fin attributes get <name>` shows a single Fin custom attribute by name. `fin attributes download <file>` exports all attributes to a YAML file in the shape `fin attributes upload` accepts, completing the export/edit/re-import round-trip (attributes previously supported only `list` and `upload`).
+
+### Changed
+
+- `--dry-run` (`-n`) now prints the actual file payload for upload commands (`fin attributes upload`, `fin procedures upload`, `fin simulations upload`, `fin workflows upload`) instead of an opaque `[FormData]`. You can now preview the exact YAML that would be sent — including the routing `type:` the CLI adds for you — before uploading.
+
+## [0.9.0] - 2026-07-03
+
+### Added
+
+- `fin attributes upload <file>` creates or updates Fin custom attributes from a YAML file. Attributes were previously read-only (`list`). The file can be a list of attributes, a single attribute, or the full `type: attribute` / `attributes:` server shape — the CLI normalizes it and sets the routing type for you. Each attribute needs a dotted `name` (e.g. `user.order_status`) and a data `type` (`string`, `integer`, `decimal`, `float`, `boolean`, `list`, `date`, `object`, or `array`).
+- `fin procedures get <id> [output] --with-simulations` downloads a procedure's simulations alongside it. With the flag, `[output]` is a directory (default: current directory) and the CLI writes both `procedure.yaml` and `simulations.yaml`. Without it, `[output]` is a single file for the procedure YAML (previously `get` could only print to stdout).
+- `fin simulations upload <file>` re-uploads a simulation set (the `simulations.yaml` written by `fin procedures get --with-simulations`, or `fin simulations list` output), completing the export/edit/re-import round-trip for a procedure's tests.
+
 ## [0.8.3] - 2026-06-18
 
 ### Fixed

package/dist/index.js

@@ -84,6 +84,9 @@ var _dryRun = false;
 function setDryRun(enabled) {
   _dryRun = enabled;
 }
+function isDryRun() {
+  return _dryRun;
+}
 var IntercomClient = class _IntercomClient {
   token;
   authType;
@@ -153,10 +156,18 @@ var IntercomClient = class _IntercomClient {
     const url = `${this.baseUrl}${path}`;
     if (_dryRun) {
       console.error(`> ${method} ${url}`);
-      if (body) {
-        console.error(
-          `> Body: ${body instanceof FormData ? "[FormData]" : JSON.stringify(body)}`
-        );
+      if (body instanceof FormData) {
+        for (const [name, value] of body.entries()) {
+          if (typeof value === "string") {
+            console.error(`> ${name}: ${value}`);
+          } else {
+            const fileName = "name" in value ? value.name : "file";
+            console.error(`> ${name} (${fileName}):
+${await value.text()}`);
+          }
+        }
+      } else if (body) {
+        console.error(`> Body: ${JSON.stringify(body)}`);
       }
       return {};
     }
@@ -2569,9 +2580,49 @@ Examples:
 import { writeFile as writeFile3 } from "fs/promises";
 
 // src/commands/fin/procedures.ts
-import { readFile as readFile2 } from "fs/promises";
-import { basename } from "path";
+import { readFile as readFile2, mkdir as mkdir2 } from "fs/promises";
+import { basename, join as join3 } from "path";
 import AdmZip from "adm-zip";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+
+// src/utils/yaml-drift.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function scalarsMatch(sent, saved) {
+  if (sent == null && saved == null) {
+    return true;
+  }
+  if (sent == null || saved == null) {
+    return false;
+  }
+  if (typeof saved === "object") {
+    return false;
+  }
+  return String(sent) === String(saved);
+}
+function findDrift(sent, saved, path = "") {
+  const here = path || ".";
+  if (Array.isArray(sent)) {
+    if (!Array.isArray(saved) || saved.length !== sent.length) {
+      return [here];
+    }
+    return sent.flatMap((item, index) => findDrift(item, saved[index], `${path}[${index}]`));
+  }
+  if (isRecord(sent)) {
+    if (!isRecord(saved)) {
+      return [here];
+    }
+    return Object.entries(sent).flatMap(
+      ([key, value]) => findDrift(value, saved[key], path ? `${path}.${key}` : key)
+    );
+  }
+  return scalarsMatch(sent, saved) ? [] : [here];
+}
+
+// src/commands/fin/procedures.ts
+var STATE_LIVE = "live";
+var STATE_PAUSED = "paused";
 function registerProceduresCommand(fin) {
   const procedures = fin.command("procedures").description("Manage Fin SDK procedures");
   procedures.command("list").description("List procedures from the Fin SDK manifest").option("--json", "Output as JSON").option("--verbose", "Show HTTP request/response details").action(async function() {
@@ -2591,27 +2642,212 @@ function registerProceduresCommand(fin) {
       return table({ columns: ["ID", "NAME"], rows });
     }, items);
   });
-  procedures.command("get <id>").description("Download a procedure by ID and print its YAML content").option("--verbose", "Show HTTP request/response details").action(async function(id) {
+  procedures.command("get <id> [output]").description("Download a procedure by ID as YAML (writes to [output], or stdout)").option("--with-simulations", "Also download the procedure's simulations").option("--version <version_id>", "Download a historical version instead of the current one").option("--verbose", "Show HTTP request/response details").addHelpText(
+    "after",
+    `
+Examples:
+  $ intercom fin procedures get proc-1                       # print YAML to stdout
+  $ intercom fin procedures get proc-1 procedure.yaml        # write YAML to a file
+  $ intercom fin procedures get proc-1 ./out --with-simulations
+      # writes ./out/procedure.yaml and ./out/simulations.yaml
+  $ intercom fin procedures versions proc-1                  # find a version ID
+  $ intercom fin procedures get proc-1 --version 4821        # print that version's YAML
+
+With --with-simulations, [output] is treated as a directory (default: current
+directory). Without it, [output] is a single file for the procedure YAML.
+
+--version downloads the re-uploadable YAML of a historical version, so you can
+diff a local file against what is live (\`intercom fin procedures versions <id>\`
+shows which version that is). Simulations are not versioned, so --version and
+--with-simulations cannot be combined.
+
+Re-import the pieces with \`intercom fin procedures upload <procedure.yaml>\`
+and \`intercom fin simulations upload <simulations.yaml>\`.`
+  ).action(async function(id, output) {
     const opts = this.optsWithGlobals();
+    if (opts.version && opts.withSimulations) {
+      throw new CLIError("--version cannot be combined with --with-simulations (simulations are not versioned)");
+    }
     const client = await resolveClient(opts);
-    const buffer = await client.getBuffer(`/fin-sdk/procedures/${id}/download`);
-    const zip = new AdmZip(buffer);
-    const entry = zip.getEntries().find((e) => e.entryName.endsWith("procedure.yaml"));
-    if (!entry) {
-      throw new Error("procedure.yaml not found in downloaded ZIP");
+    const procedureYaml = opts.version ? await getVersionYaml(client, id, opts.version) : await getCurrentYaml(client, id);
+    let simulationsYaml;
+    if (opts.withSimulations) {
+      simulationsYaml = await client.getText(`/fin-sdk/procedures/${id}/simulations`);
+    }
+    if (opts.withSimulations) {
+      const dir = output ?? ".";
+      await mkdir2(dir, { recursive: true });
+      const procedurePath = join3(dir, "procedure.yaml");
+      const simulationsPath = join3(dir, "simulations.yaml");
+      await atomicWriteFile(procedurePath, procedureYaml, 420);
+      await atomicWriteFile(simulationsPath, simulationsYaml ?? "", 420);
+      console.error(`Wrote procedure ${id} to ${procedurePath}`);
+      console.error(`Wrote simulations to ${simulationsPath}`);
+      return;
+    }
+    if (output) {
+      await atomicWriteFile(output, procedureYaml, 420);
+      console.error(`Wrote procedure ${id} to ${output}`);
+    } else {
+      console.log(procedureYaml);
     }
-    console.log(zip.readAsText(entry));
   });
-  procedures.command("upload <file>").description("Upload a procedure file to Fin SDK").option("--json", "Output as JSON").option("--jq <expr>", "Filter JSON output with jq expression").option("--verbose", "Show HTTP request/response details").action(async function(filePath) {
+  procedures.command("upload <file>").description("Upload a procedure file to Fin SDK").option("--note <text>", "Version note to record against this save").option("--verify", "Fail if the saved procedure differs from the file uploaded").option("--json", "Output as JSON").option("--jq <expr>", "Filter JSON output with jq expression").option("--verbose", "Show HTTP request/response details").addHelpText(
+    "after",
+    `
+Examples:
+  $ intercom fin procedures upload procedure.yaml
+  $ intercom fin procedures upload procedure.yaml --note "tightened refund wording"
+  $ intercom fin procedures upload procedure.yaml --verify
+
+--note labels this save in the procedure's version history, so it is
+identifiable in \`intercom fin procedures versions <id>\` instead of appearing
+as an unlabelled entry.
+
+--verify compares the procedure the server saved against the file just uploaded
+and exits non-zero listing any field that did not survive the round-trip. Fields
+the server adds (ids, defaults) are ignored; only content that was sent and came
+back missing or changed is reported.`
+  ).action(async function(filePath) {
     const opts = this.optsWithGlobals();
     const client = await resolveClient(opts);
     const fileContent = await readFile2(filePath);
     const formData = new FormData();
     const blob = new Blob([fileContent], { type: "application/x-yaml" });
     formData.append("file_data", blob, basename(filePath));
+    if (opts.note) {
+      formData.append("version_note", opts.note);
+    }
     const result = await client.postFormData("/fin-sdk/upload", formData);
     render(result, opts, () => formatJson(result));
+    if (opts.verify) {
+      verifySaved(filePath, fileContent.toString("utf8"), result);
+    }
   });
+  procedures.command("publish <id>").description("Set a procedure's state to live").option("--note <text>", "Version note to record against this save").option("--json", "Output as JSON").option("--jq <expr>", "Filter JSON output with jq expression").option("--verbose", "Show HTTP request/response details").addHelpText(
+    "after",
+    `
+Examples:
+  $ intercom fin procedures publish proc-1
+  $ intercom fin procedures publish proc-1 --note "tightened refund wording"
+
+This is a convenience for download \u2192 set state \u2192 upload. If another operator
+edits the procedure between the download and upload, those edits will be
+overwritten (the server does not expose a concurrency token).
+
+--note labels this save in \`intercom fin procedures versions <id>\`.`
+  ).action(async function(id) {
+    const opts = this.optsWithGlobals();
+    await setProcedureState(id, STATE_LIVE, opts);
+  });
+  procedures.command("pause <id>").description("Set a procedure's state to paused").option("--note <text>", "Version note to record against this save").option("--json", "Output as JSON").option("--jq <expr>", "Filter JSON output with jq expression").option("--verbose", "Show HTTP request/response details").addHelpText(
+    "after",
+    `
+Examples:
+  $ intercom fin procedures pause proc-1
+  $ intercom fin procedures pause proc-1 --note "pausing during refund policy review"
+
+This is a convenience for download \u2192 set state \u2192 upload. If another operator
+edits the procedure between the download and upload, those edits will be
+overwritten (the server does not expose a concurrency token).
+
+pause is the way to deactivate a procedure: the server rejects an uploaded
+\`state: draft\` outright, so there is no separate "unpublish to draft" command.
+
+--note labels this save in \`intercom fin procedures versions <id>\`.`
+  ).action(async function(id) {
+    const opts = this.optsWithGlobals();
+    await setProcedureState(id, STATE_PAUSED, opts);
+  });
+  procedures.command("versions <id>").description("List a procedure's server-side version history (which one is live)").option("--json", "Output as JSON").option("--jq <expr>", "Filter JSON output with jq expression").option("--verbose", "Show HTTP request/response details").addHelpText(
+    "after",
+    `
+Examples:
+  $ intercom fin procedures versions proc-1
+  $ intercom fin procedures versions proc-1 --jq '.entity_version_id'
+
+STATUS is the server's own vocabulary: live is what Fin is running now, draft is
+unpublished, previously_live is superseded. Download any of them with
+\`intercom fin procedures get <id> --version <VERSION>\`.`
+  ).action(async function(id) {
+    const opts = this.optsWithGlobals();
+    const client = await resolveClient(opts);
+    const result = await client.get(`/fin-sdk/procedures/${id}/versions`);
+    const items = result.versions ?? [];
+    render(items, opts, () => {
+      if (items.length === 0) {
+        return "No versions found.";
+      }
+      const rows = items.map((v) => ({
+        VERSION: String(v.entity_version_id ?? ""),
+        STATUS: String(v.status ?? ""),
+        CREATED: String(v.created_at ?? ""),
+        AUTHOR: String(v.author?.name ?? ""),
+        NOTE: String(v.note ?? "")
+      }));
+      return table({ columns: ["VERSION", "STATUS", "CREATED", "AUTHOR", "NOTE"], rows });
+    }, items);
+  });
+}
+async function setProcedureState(id, state, opts) {
+  const client = await resolveClient(opts);
+  if (isDryRun()) {
+    console.error(`> would set procedure ${id} state to ${state}`);
+    return;
+  }
+  const procedureYaml = await getCurrentYaml(client, id);
+  let parsed;
+  try {
+    parsed = parseYaml(procedureYaml);
+  } catch (err) {
+    throw new CLIError(
+      `server returned unparseable YAML for procedure ${id}: ${err.message}`
+    );
+  }
+  parsed.state = state;
+  const formData = new FormData();
+  const blob = new Blob([stringifyYaml(parsed)], { type: "application/x-yaml" });
+  formData.append("file_data", blob, `procedure-${id}.yaml`);
+  if (opts.note) {
+    formData.append("version_note", opts.note);
+  }
+  const result = await client.postFormData("/fin-sdk/upload", formData);
+  render(result, opts, () => formatJson(result));
+}
+async function getCurrentYaml(client, id) {
+  const buffer = await client.getBuffer(`/fin-sdk/procedures/${id}/download`);
+  const zip = new AdmZip(buffer);
+  const entry = zip.getEntries().find((e) => e.entryName.endsWith("procedure.yaml"));
+  if (!entry) {
+    throw new CLIError("procedure.yaml not found in downloaded ZIP");
+  }
+  return zip.readAsText(entry);
+}
+async function getVersionYaml(client, id, versionId) {
+  const result = await client.get(
+    `/fin-sdk/procedures/${id}/versions/${versionId}`
+  );
+  const content = result.content;
+  if (content == null) {
+    throw new CLIError(`Procedure version ${versionId} returned no content`);
+  }
+  return typeof content === "string" ? content : stringifyYaml(content);
+}
+function verifySaved(filePath, sentYaml, result) {
+  if (typeof result.new_file_content !== "string") {
+    throw new CLIError("Cannot verify: the server did not return the saved procedure");
+  }
+  const drift = findDrift(parseYaml(sentYaml), parseYaml(result.new_file_content));
+  if (drift.length === 0) {
+    console.error(`Verified: the saved procedure matches ${filePath}`);
+    return;
+  }
+  for (const path of drift) {
+    console.error(`  ${path}`);
+  }
+  throw new CLIError(
+    `${drift.length} field(s) did not survive the upload (listed above). Compare with \`intercom fin procedures get ${result.id ?? "<id>"}\`.`
+  );
 }
 
 // src/commands/fin/data-connectors.ts
@@ -2766,13 +3002,39 @@ Optional fields: state (live or paused, default: paused), audiences`
 }
 
 // src/commands/fin/attributes.ts
+import { readFile as readFile3 } from "fs/promises";
+import { basename as basename2 } from "path";
+import { parse as parseYaml2, stringify as stringifyYaml2 } from "yaml";
+var ATTRIBUTE_TYPE = "attribute";
+async function fetchAttributes(client) {
+  const result = await client.get("/fin-sdk/attributes");
+  return Array.isArray(result) ? result : result.attributes ?? [];
+}
+function buildAttributesUploadBody(raw) {
+  let parsed;
+  try {
+    parsed = parseYaml2(raw);
+  } catch {
+    return raw;
+  }
+  if (Array.isArray(parsed)) {
+    return stringifyYaml2({ type: ATTRIBUTE_TYPE, attributes: parsed });
+  }
+  if (parsed == null || typeof parsed !== "object") {
+    return raw;
+  }
+  const obj = parsed;
+  if (Array.isArray(obj.attributes)) {
+    return stringifyYaml2({ ...obj, type: ATTRIBUTE_TYPE });
+  }
+  return stringifyYaml2({ type: ATTRIBUTE_TYPE, attributes: [obj] });
+}
 function registerAttributesCommand(fin) {
   const attributes = fin.command("attributes").description("Manage Fin SDK attributes");
   attributes.command("list").description("List Fin SDK attributes").option("--json", "Output as JSON").option("--verbose", "Show HTTP request/response details").action(async function() {
     const opts = this.optsWithGlobals();
     const client = await resolveClient(opts);
-    const result = await client.get("/fin-sdk/attributes");
-    const items = Array.isArray(result) ? result : result.attributes ?? [];
+    const items = await fetchAttributes(client);
     render(items, opts, () => {
       if (items.length === 0) {
         return "No attributes found.";
@@ -2785,6 +3047,75 @@ function registerAttributesCommand(fin) {
       return table({ columns: ["NAME", "TYPE", "DESCRIPTION"], rows });
     }, items);
   });
+  attributes.command("get <name>").description("Show a single Fin SDK attribute by name").option("--json", "Output as JSON").option("--jq <expr>", "Filter JSON output with jq expression").option("--verbose", "Show HTTP request/response details").action(async function(name) {
+    const opts = this.optsWithGlobals();
+    const client = await resolveClient(opts);
+    const items = await fetchAttributes(client);
+    const match = items.find((item) => item.name === name);
+    if (!match) {
+      throw new NotFoundError(`No Fin attribute named "${name}".`);
+    }
+    render(
+      match,
+      opts,
+      () => detail({
+        "Name": match.name != null ? String(match.name) : void 0,
+        "Type": match.type != null ? String(match.type) : void 0,
+        "Description": match.description != null ? String(match.description) : void 0
+      })
+    );
+  });
+  attributes.command("download <file>").description("Download all Fin SDK attributes to a YAML file").option("--verbose", "Show HTTP request/response details").action(async function(filePath) {
+    const opts = this.optsWithGlobals();
+    const client = await resolveClient(opts);
+    const items = await fetchAttributes(client);
+    const yaml = stringifyYaml2({ type: ATTRIBUTE_TYPE, attributes: items });
+    await atomicWriteFile(filePath, yaml, 420);
+    console.error(`Wrote ${items.length} attribute${items.length === 1 ? "" : "s"} to ${filePath}`);
+  });
+  attributes.command("upload <file>").description("Upload attributes from a YAML file (creates or updates)").option("--json", "Output as JSON").option("--jq <expr>", "Filter JSON output with jq expression").option("--verbose", "Show HTTP request/response details").addHelpText(
+    "after",
+    `
+The file holds one or more attributes. The CLI wraps them in the bulk shape the
+server expects and sets the routing type for you, so any of these work:
+
+  # a list of attributes
+  - name: user.order_status   # name must contain a dot
+    type: string              # data type: string, integer, decimal, float,
+    description: Order state   #   boolean, list, date, object, or array
+
+  # ...or a single attribute
+  name: company.tier
+  type: string
+
+  # ...or the full server shape
+  type: attribute
+  attributes:
+    - name: user.order_status
+      type: string
+
+Examples:
+  $ intercom fin attributes upload ./attributes.yaml
+  $ intercom fin attributes upload ./attributes.yaml --json`
+  ).action(async function(filePath) {
+    const opts = this.optsWithGlobals();
+    const client = await resolveClient(opts);
+    const fileContent = await readFile3(filePath, "utf8");
+    const yamlBody = buildAttributesUploadBody(fileContent);
+    const formData = new FormData();
+    const blob = new Blob([yamlBody], { type: "application/x-yaml" });
+    formData.append("file_data", blob, basename2(filePath));
+    const result = await client.postFormData("/fin-sdk/upload", formData);
+    render(
+      result,
+      opts,
+      () => detail({
+        "ID": result.id != null ? String(result.id) : void 0,
+        "Type": result.type != null ? String(result.type) : void 0,
+        "Message": result.message != null ? String(result.message) : void 0
+      })
+    );
+  });
 }
 
 // src/commands/fin/audiences.ts
@@ -2809,16 +3140,16 @@ function registerAudiencesCommand(fin) {
 }
 
 // src/commands/fin/workflows.ts
-import { readFile as readFile3 } from "fs/promises";
-import { basename as basename2 } from "path";
-import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
-var STATE_LIVE = "live";
-var STATE_PAUSED = "paused";
+import { readFile as readFile4 } from "fs/promises";
+import { basename as basename3 } from "path";
+import { parse as parseYaml3, stringify as stringifyYaml3 } from "yaml";
+var STATE_LIVE2 = "live";
+var STATE_PAUSED2 = "paused";
 var WORKFLOW_TYPE = "workflow";
 function ensureWorkflowType(raw) {
   let parsed;
   try {
-    parsed = parseYaml(raw);
+    parsed = parseYaml3(raw);
   } catch {
     return raw;
   }
@@ -2830,7 +3161,7 @@ function ensureWorkflowType(raw) {
     return raw;
   }
   obj.type = WORKFLOW_TYPE;
-  return stringifyYaml(obj);
+  return stringifyYaml3(obj);
 }
 function registerWorkflowsCommand(fin) {
   const workflows = fin.command("workflows").description("Manage Fin SDK workflows");
@@ -2867,7 +3198,7 @@ The YAML it prints is ready to edit and re-upload with
     const client = await resolveClient(opts);
     const text = await client.getText(`/fin-sdk/workflows/${id}`);
     if (opts.json || opts.jq || opts.agent) {
-      const parsed = parseYaml(text);
+      const parsed = parseYaml3(text);
       render(parsed, opts, () => formatJson(parsed));
       return;
     }
@@ -2892,11 +3223,11 @@ The YAML file's id field determines whether this creates or updates:
   ).action(async function(filePath) {
     const opts = this.optsWithGlobals();
     const client = await resolveClient(opts);
-    const fileContent = await readFile3(filePath, "utf8");
+    const fileContent = await readFile4(filePath, "utf8");
     const yamlBody = ensureWorkflowType(fileContent);
     const formData = new FormData();
     const blob = new Blob([yamlBody], { type: "application/x-yaml" });
-    formData.append("file_data", blob, basename2(filePath));
+    formData.append("file_data", blob, basename3(filePath));
     const result = await client.postFormData("/fin-sdk/upload", formData);
     render(
       result,
@@ -2925,13 +3256,13 @@ overwritten (the server does not expose a concurrency token).`
     const text = await client.getText(`/fin-sdk/workflows/${id}`);
     let parsed;
     try {
-      parsed = parseYaml(text);
+      parsed = parseYaml3(text);
     } catch (err) {
       throw new Error(`server returned unparseable YAML for workflow ${id}: ${err.message}`);
     }
     parsed.type = WORKFLOW_TYPE;
-    parsed.state = STATE_LIVE;
-    const yamlBody = stringifyYaml(parsed);
+    parsed.state = STATE_LIVE2;
+    const yamlBody = stringifyYaml3(parsed);
     const formData = new FormData();
     const blob = new Blob([yamlBody], { type: "application/x-yaml" });
     formData.append("file_data", blob, `workflow-${id}.yaml`);
@@ -2962,13 +3293,13 @@ overwritten (the server does not expose a concurrency token).`
     const text = await client.getText(`/fin-sdk/workflows/${id}`);
     let parsed;
     try {
-      parsed = parseYaml(text);
+      parsed = parseYaml3(text);
     } catch (err) {
       throw new Error(`server returned unparseable YAML for workflow ${id}: ${err.message}`);
     }
     parsed.type = WORKFLOW_TYPE;
-    parsed.state = STATE_PAUSED;
-    const yamlBody = stringifyYaml(parsed);
+    parsed.state = STATE_PAUSED2;
+    const yamlBody = stringifyYaml3(parsed);
     const formData = new FormData();
     const blob = new Blob([yamlBody], { type: "application/x-yaml" });
     formData.append("file_data", blob, `workflow-${id}.yaml`);
@@ -2986,6 +3317,27 @@ overwritten (the server does not expose a concurrency token).`
 }
 
 // src/commands/fin/simulations.ts
+import { readFile as readFile5 } from "fs/promises";
+import { basename as basename4 } from "path";
+import { parse as parseYaml4, stringify as stringifyYaml4 } from "yaml";
+var SIMULATION_SET_TYPE = "simulation_set";
+function ensureSimulationSetType(raw) {
+  let parsed;
+  try {
+    parsed = parseYaml4(raw);
+  } catch {
+    return raw;
+  }
+  if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return raw;
+  }
+  const obj = parsed;
+  if (obj.type != null && obj.type !== "") {
+    return raw;
+  }
+  obj.type = SIMULATION_SET_TYPE;
+  return stringifyYaml4(obj);
+}
 function registerSimulationsCommand(fin) {
   const simulations = fin.command("simulations").description("Manage Fin SDK simulations");
   simulations.command("list <procedure_id>").description("List simulations for a procedure (displays YAML)").option("--verbose", "Show HTTP request/response details").action(async function(procedureId) {
@@ -2994,6 +3346,36 @@ function registerSimulationsCommand(fin) {
     const text = await client.getText(`/fin-sdk/procedures/${procedureId}/simulations`);
     console.log(text);
   });
+  simulations.command("upload <file>").description("Upload a simulation set YAML file for its procedure").option("--json", "Output as JSON").option("--jq <expr>", "Filter JSON output with jq expression").option("--verbose", "Show HTTP request/response details").addHelpText(
+    "after",
+    `
+The file is a simulation set carrying its own procedure_id, as produced by
+\`intercom fin procedures get <id> ./out --with-simulations\` (writes
+./out/simulations.yaml) or \`intercom fin simulations list <procedure_id>\`.
+This completes the export/edit/re-import round-trip for a procedure's tests.
+
+Example:
+  $ intercom fin simulations upload ./out/simulations.yaml`
+  ).action(async function(filePath) {
+    const opts = this.optsWithGlobals();
+    const client = await resolveClient(opts);
+    const fileContent = await readFile5(filePath, "utf8");
+    const yamlBody = ensureSimulationSetType(fileContent);
+    const formData = new FormData();
+    const blob = new Blob([yamlBody], { type: "application/x-yaml" });
+    formData.append("file_data", blob, basename4(filePath));
+    const result = await client.postFormData("/fin-sdk/upload", formData);
+    render(
+      result,
+      opts,
+      () => detail({
+        "ID": result.id != null ? String(result.id) : void 0,
+        "Procedure ID": result.procedure_id != null ? String(result.procedure_id) : void 0,
+        "Type": result.type != null ? String(result.type) : void 0,
+        "Message": result.message != null ? String(result.message) : void 0
+      })
+    );
+  });
   simulations.command("run <procedure_id> [test_id]").description("Run one or all simulations for a procedure").option("--json", "Output as JSON").option("--verbose", "Show HTTP request/response details").action(async function(procedureId, testId) {
     const opts = this.optsWithGlobals();
     const client = await resolveClient(opts);
@@ -3223,8 +3605,8 @@ Fin is live on workspace ${appId}`);
 }
 
 // src/commands/fin/monitors.ts
-import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
-import { join as join3, relative, dirname } from "path";
+import { mkdir as mkdir3, writeFile as writeFile2 } from "fs/promises";
+import { join as join4, relative, dirname } from "path";
 import { stringify } from "yaml";
 async function resolveMonitorId(client, nameOrId) {
   if (/^\d+$/.test(nameOrId)) {
@@ -3305,14 +3687,14 @@ Examples:
       );
       return;
     }
-    const outputPath = opts.output ?? join3(
+    const outputPath = opts.output ?? join4(
       process.cwd(),
       "src",
       "qa",
       "bulk-actions",
       "flagged-conversations.yaml"
     );
-    await mkdir2(dirname(outputPath), { recursive: true });
+    await mkdir3(dirname(outputPath), { recursive: true });
     await writeFile2(outputPath, buildWorkingSetYaml(result, since), "utf-8");
     const relPath = relative(process.cwd(), outputPath);
     console.log(
@@ -3330,8 +3712,8 @@ Examples:
 }
 
 // src/commands/fin/conversation.ts
-import { readFile as readFile4 } from "fs/promises";
-import { join as join4 } from "path";
+import { readFile as readFile6 } from "fs/promises";
+import { join as join5 } from "path";
 import { parse } from "yaml";
 var PLACEHOLDER_MESSAGE = "Your message here \u2014 this will be sent to all conversations listed below.";
 function validateWorkingSet(ws) {
@@ -3381,7 +3763,7 @@ function registerConversationCommand(fin) {
   ).option(
     "--file <path>",
     "Path to the working set YAML file",
-    join4(process.cwd(), "src", "qa", "bulk-actions", "flagged-conversations.yaml")
+    join5(process.cwd(), "src", "qa", "bulk-actions", "flagged-conversations.yaml")
   ).option("--dry-run", "Preview actions without sending").option("--yes", "Skip confirmation prompt (required in TTY mode)").option(
     "--json",
     "Output result as JSON"
@@ -3395,7 +3777,7 @@ Examples:
   $ fin conversation bulk-send --json`
   ).action(async function() {
     const opts = this.optsWithGlobals();
-    const filePath = opts.file ?? join4(
+    const filePath = opts.file ?? join5(
       process.cwd(),
       "src",
       "qa",
@@ -3404,7 +3786,7 @@ Examples:
     );
     let raw;
     try {
-      raw = await readFile4(filePath, "utf-8");
+      raw = await readFile6(filePath, "utf-8");
     } catch (err) {
       const e = err;
       if (e.code === "ENOENT") {
@@ -3565,7 +3947,7 @@ Examples:
 
 // src/commands/setup.ts
 import { readdirSync, readFileSync as readFileSync4, statSync } from "fs";
-import { join as join5, basename as basename3 } from "path";
+import { join as join6, basename as basename5 } from "path";
 function isGreenfield(opts) {
   return !!(opts.email && opts.name && (process.env.INTERCOM_PASSWORD || opts.passwordStdin));
 }
@@ -3623,8 +4005,8 @@ function buildPlan(opts) {
     }
     if (mdFiles.length > 0) {
       const articleCommands = mdFiles.map((file) => {
-        const title = basename3(file, ".md").replace(/-/g, " ").replace(/\b\w/g, (c2) => c2.toUpperCase());
-        return `intercom articles create -f title="${title}" -F body=@${join5(opts.articlesFrom, file)} -f author_id=$(intercom me --json | jq -r .id)`;
+        const title = basename5(file, ".md").replace(/-/g, " ").replace(/\b\w/g, (c2) => c2.toUpperCase());
+        return `intercom articles create -f title="${title}" -F body=@${join6(opts.articlesFrom, file)} -f author_id=$(intercom me --json | jq -r .id)`;
       });
       steps.push({
         step: stepNum++,
@@ -3690,8 +4072,8 @@ async function runPostAuthSteps(client, opts, results, appId) {
     let created = 0;
     let skipped = 0;
     for (const file of mdFiles) {
-      const title = basename3(file, ".md").replace(/-/g, " ").replace(/\b\w/g, (c2) => c2.toUpperCase());
-      const body = readFileSync4(join5(opts.articlesFrom, file), "utf-8");
+      const title = basename5(file, ".md").replace(/-/g, " ").replace(/\b\w/g, (c2) => c2.toUpperCase());
+      const body = readFileSync4(join6(opts.articlesFrom, file), "utf-8");
       if (existingTitles.has(title)) {
         skipped++;
       } else {
@@ -4168,7 +4550,7 @@ function registerPricingCommand(program) {
 }
 
 // src/commands/config.ts
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 var SUPPORTED_KEYS = ["default_workspace", "timeout"];
 function configDir() {
   return process.env.INTERCOM_CONFIG_DIR ?? defaultConfigDir();
@@ -4257,7 +4639,7 @@ function registerConfigCommand(program) {
     console.log(`Set ${key} = ${value}`);
   });
   cmd.command("path").description("Show configuration file path").action(async function() {
-    console.log(join6(configDir(), "config.json"));
+    console.log(join7(configDir(), "config.json"));
   });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intercom/cli",
-  "version": "0.8.3",
+  "version": "0.10.0",
   "description": "CLI tool for managing Intercom workspaces",
   "type": "module",
   "packageManager": "pnpm@10.23.0",
@@ -41,9 +41,5 @@
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
     "vitest": "^4.1.0"
-  },
-  "pnpm": {
-    "overrides": {},
-    "onlyBuiltDependencies": []
   }
 }