sim 2.1.5-dev.77.1 → 2.1.5-dev.79.1

package/dist/index.js

@@ -6971,7 +6971,7 @@ var V2_OPERATIONS = {
       rowId: { kind: "string", describe: "Row whose runs should be canceled for row scope." },
       filter: {
         kind: "unknown",
-        describe: 'Recursive predicate tree. Each group node is exactly one non-empty `all` or `any` array whose members are further groups or `{ field, op, value }` conditions; the root must be a group, not a bare condition. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
+        describe: 'A single `{ field, op, value }` condition or a recursive `all`/`any` group; either form is normalized to a grouped predicate after validation. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
       },
       excludeRowIds: { kind: "array", describe: "Rows excluded from an all-scope cancellation." }
     }
@@ -7535,7 +7535,7 @@ var V2_OPERATIONS = {
       description: { kind: "string", describe: "Optional credential description." },
       id: {
         kind: "string",
-        describe: "Required only when provider discovery requests a client-generated ID."
+        describe: "Optional client-generated credential ID. The server mints one when it is omitted, so no provider requires it. A `slack-custom-bot` credential may supply one so its Slack Request URL, which embeds the ID, can be configured before the credential exists; every other provider ignores it."
       },
       credentials: {
         kind: "string",
@@ -7611,7 +7611,7 @@ var V2_OPERATIONS = {
       rowIds: { kind: "array", describe: "Explicit row subset to run." },
       filter: {
         kind: "unknown",
-        describe: 'Recursive predicate tree. Each group node is exactly one non-empty `all` or `any` array whose members are further groups or `{ field, op, value }` conditions; the root must be a group, not a bare condition. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
+        describe: 'A single `{ field, op, value }` condition or a recursive `all`/`any` group; either form is normalized to a grouped predicate after validation. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
       },
       excludeRowIds: { kind: "array", describe: "Rows excluded from a select-all run scope." },
       limit: { kind: "object", describe: "Optional cap on eligible rows to run." }
@@ -8133,7 +8133,7 @@ var V2_OPERATIONS = {
       workspaceId: { kind: "string", required: true, describe: "Unique workspace identifier." },
       filter: {
         kind: "unknown",
-        describe: 'Recursive predicate tree. Each group node is exactly one non-empty `all` or `any` array whose members are further groups or `{ field, op, value }` conditions; the root must be a group, not a bare condition. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
+        describe: 'A single `{ field, op, value }` condition or a recursive `all`/`any` group; either form is normalized to a grouped predicate after validation. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
       },
       limit: { kind: "integer", describe: "Maximum matching rows to delete." },
       rowIds: { kind: "array", describe: "Explicit row identifiers to delete." }
@@ -8605,7 +8605,26 @@ var V2_OPERATIONS = {
       segmentCount: {
         kind: "integer",
         default: 72,
-        describe: "Number of equal time buckets to divide the window into, from 1 to 500. Exactly this many buckets are always returned. Buckets are never narrower than one minute, so on a short window the series extends past the end of the window rather than being compressed, and the trailing buckets are empty."
+        describe: "Number of equal time buckets to divide the window into, from 1 to 500. It is the ceiling on how many buckets a series carries: with `includeEmpty=true` exactly this many are returned, otherwise only the buckets holding at least one run. Buckets are never narrower than one minute, so on a short window the series extends past the end of the window rather than being compressed, and the trailing buckets are empty."
+      },
+      includeEmpty: {
+        kind: "enum",
+        values: [
+          "true",
+          "1",
+          "yes",
+          "on",
+          "y",
+          "enabled",
+          "false",
+          "0",
+          "no",
+          "off",
+          "n",
+          "disabled"
+        ],
+        default: false,
+        describe: "Whether buckets with no runs are included in every series. Off by default, so each series carries only the buckets that hold at least one run; set it to publish exactly `segmentCount` buckets per series, empty ones included. The listed spellings are the whole accepted vocabulary and are case-sensitive; any other value is rejected."
       }
     }
   },
@@ -10841,7 +10860,7 @@ var V2_OPERATIONS = {
       q: { kind: "string", required: true, describe: "Case-insensitive cell substring to find." },
       predicate: {
         kind: "unknown",
-        describe: 'Recursive predicate tree. Each group node is exactly one non-empty `all` or `any` array whose members are further groups or `{ field, op, value }` conditions; the root must be a group, not a bare condition. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
+        describe: 'A single `{ field, op, value }` condition or a recursive `all`/`any` group; either form is normalized to a grouped predicate after validation. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
       },
       sort: { kind: "array", describe: "Ordered table-row sort specification." }
     }
@@ -11283,7 +11302,7 @@ var V2_OPERATIONS = {
       filter: {
         kind: "unknown",
         required: true,
-        describe: 'Recursive predicate tree. Each group node is exactly one non-empty `all` or `any` array whose members are further groups or `{ field, op, value }` conditions; the root must be a group, not a bare condition. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
+        describe: 'A single `{ field, op, value }` condition or a recursive `all`/`any` group; either form is normalized to a grouped predicate after validation. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
       },
       data: {
         kind: "object",
@@ -12236,7 +12255,7 @@ var CLI_CONTRACT = {
   },
   deleteTableView: { confirm: "This deletes the saved view and its filters." },
   deleteWorkflowGroup: {
-    confirm: "This deletes the group, every column it fed, and the values in them.",
+    confirm: "This deletes the group AND its output columns with all of their row data; the workflow it pointed at is untouched.",
     fields: [
       { header: "id" },
       { header: "deleted", format: "bool" },
@@ -13102,7 +13121,7 @@ var CLI_CONTRACT = {
       selectedOutputs: {
         name: "select-output",
         list: true,
-        describe: "Include blockId or blockId.path values in JSON or YAML output; block names are not resolved on a finished run"
+        describe: "Include blockName.path or blockId.path values (e.g. agent_1.content) in JSON or YAML output; names resolve against the workflow’s current blocks, and missing paths are omitted"
       }
     },
     fields: [
@@ -14072,6 +14091,22 @@ function countOf(value) {
 function lengthOf(value) {
   return Array.isArray(value) ? value.length : 0;
 }
+var RESULT_NOTES = {
+  replaceWorkflowChatDeployment: (payload, body) => {
+    const authType = payload.authType ?? body?.authType ?? "public";
+    return authType === "public" ? "note: auth type is public — anyone with the link can chat; pass --auth-type password|email to restrict it." : null;
+  }
+};
+function writeResultNote(operation, payload, body) {
+  const note = RESULT_NOTES[operation];
+  if (!note)
+    return;
+  const record = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+  const message = note(record, body);
+  if (message)
+    process.stderr.write(source_default.dim(`${message}
+`));
+}
 function bulkFailureMessage(operation, payload, body) {
   const check = BULK_OUTCOME_CHECKS[operation];
   if (!check)
@@ -14197,6 +14232,7 @@ async function executeOperation(operation, commandSpec, operationSpec, invocatio
   });
   const payload = result?.data ?? result;
   renderResult(operation, profile.output, payload, commandSpec, { expandedTrace: requestFlags.trace === true }, result);
+  writeResultNote(operation, payload, request.body);
   const failure = runFailureMessage(operation, payload) ?? bulkFailureMessage(operation, payload, request.body);
   if (failure)
     throw new SimApiError(failure, 0);
@@ -16026,6 +16062,118 @@ function attachWorkflowRunFollow(workflows) {
   run.option("--manual", "Run the current saved workflow state instead of the active deployment").option("--trigger <blockId>", "Enter the run through this runnable trigger; runs the current saved workflow state (implies --manual)").option("--mock-payload", "Use the selected trigger's server-derived mock payload; runs the current saved workflow state (implies --manual)").option("--from-block <blockId>", "Run manually from this saved workflow block").option("--source-run <runId>", "Prior run whose persisted state supplies upstream outputs (requires --from-block)").option("--follow", "Stream the run as it happens; progress on stderr, result on stdout. The stream reports only success and output, so the result omits the run id and timings a non-streaming run returns").option("--include-thinking", "Show model reasoning while following (requires --follow)").option("--include-tool-calls", "Show tool calls while following (requires --follow)").action(followOrDelegate(previous));
 }
 
+// src/commands/protocol/workflow-run-get.ts
+var BLOCK_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var SELECT_OUTPUT_FLAG = "select-output";
+function normalizeBlockName(name) {
+  return name.toLowerCase().replace(/\s+/g, "").replace(/\./g, "");
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function loadWorkflowBlocks(client, workflowId) {
+  const operation = V2_OPERATIONS.getWorkflowState;
+  const raw = await client.request(resolvePath(operation.path, { workflowId }), {
+    method: operation.method
+  });
+  const state = isRecord2(raw) && isRecord2(raw.data) ? raw.data : raw;
+  const blocks = isRecord2(state) && isRecord2(state.blocks) ? Object.entries(state.blocks) : [];
+  return blocks.map(([key, block]) => ({
+    id: isRecord2(block) && typeof block.id === "string" ? block.id : key,
+    name: isRecord2(block) && typeof block.name === "string" ? block.name : ""
+  }));
+}
+function splitSelector(selector) {
+  const dot = selector.indexOf(".");
+  return dot === -1 ? { head: selector, path: "" } : { head: selector.slice(0, dot), path: selector.slice(dot) };
+}
+function isIdHeaded(selector) {
+  return BLOCK_ID.test(splitSelector(selector).head);
+}
+function resolveSelection(typed, blocks, workflowId) {
+  const resolved = [];
+  const typedBy = new Map;
+  const unresolved = [];
+  for (const selector of typed) {
+    const { head, path } = splitSelector(selector);
+    let blockId = head;
+    if (!BLOCK_ID.test(head)) {
+      const wanted = normalizeBlockName(head);
+      const matches = blocks.filter((block) => block.id === head || normalizeBlockName(block.name) === wanted);
+      if (matches.length === 0) {
+        unresolved.push(selector);
+        continue;
+      }
+      if (matches.length > 1) {
+        throw new SimApiError(`--${SELECT_OUTPUT_FLAG} ${selector} names ${matches.length} blocks (${matches.map((block) => block.id).join(", ")}); pass the block id instead`, 0);
+      }
+      blockId = matches[0].id;
+    }
+    const rewritten = `${blockId}${path}`;
+    resolved.push(rewritten);
+    if (!typedBy.has(rewritten))
+      typedBy.set(rewritten, selector);
+  }
+  if (unresolved.length > 0) {
+    const names = blocks.map((block) => block.name).filter((name) => name !== "");
+    throw new SimApiError(`--${SELECT_OUTPUT_FLAG} did not resolve to any block on this run: ${unresolved.join(", ")}. Pass a block id or its name — "blockId", "blockId.path", "blockName" or "blockName.path"; names match ignoring case, spaces and dots. Blocks on workflow ${workflowId}: ${names.length > 0 ? names.join(", ") : "none"}.`, 0);
+  }
+  return { resolved, typedBy };
+}
+function keyByTyped(payload, typedBy) {
+  if (!isRecord2(payload) || !isRecord2(payload.blockOutputs))
+    return payload;
+  const blockOutputs = {};
+  for (const [key, value] of Object.entries(payload.blockOutputs)) {
+    blockOutputs[typedBy.get(key) ?? key] = value;
+  }
+  return { ...payload, blockOutputs };
+}
+async function readRunByName(runId, typed, command) {
+  const flags = command.optsWithGlobals();
+  const { client, profile } = clientFrom(command);
+  const operation = V2_OPERATIONS.getWorkflowRun;
+  const spec = CLI_CONTRACT.getWorkflowRun ?? {};
+  buildRequest("getWorkflowRun", [runId], flags, profile.workspaceId);
+  const workflowId = String(flags.workflow);
+  const selection = resolveSelection(typed, await loadWorkflowBlocks(client, workflowId), workflowId);
+  const request = buildRequest("getWorkflowRun", [runId], { ...flags, selectOutput: selection.resolved }, profile.workspaceId);
+  let result;
+  try {
+    result = await client.request(request.path, {
+      method: operation.method,
+      headers: request.headers,
+      query: request.query,
+      body: request.body
+    });
+  } catch (error) {
+    throw retypeApiError(error, "getWorkflowRun", spec, operation);
+  }
+  renderResult("getWorkflowRun", profile.output, keyByTyped(result?.data ?? result, selection.typedBy), spec, {}, result);
+}
+function attachWorkflowRunGet(runs) {
+  const get = runs.commands.find((command) => command.name() === "get");
+  const held = get?._actionHandler;
+  if (!get || typeof held !== "function") {
+    throw new Error("workflows runs get must be registered before block names can be attached to it");
+  }
+  const previous = held;
+  get.action(async (runId, _options, command) => {
+    const raw = command.optsWithGlobals().selectOutput;
+    if (raw === undefined) {
+      await previous(command.processedArgs);
+      return;
+    }
+    const typed = readListValues(raw, SELECT_OUTPUT_FLAG);
+    command.setOptionValue("selectOutput", typed);
+    if (typed.every(isIdHeaded)) {
+      await previous(command.processedArgs);
+      return;
+    }
+    await readRunByName(runId, typed, command);
+  });
+}
+
 // src/commands/protocol/workflow-run-wait.ts
 var TERMINAL_STATUSES = new Set(["completed", "failed", "cancelled"]);
 var WAIT_EXIT_CODES = {
@@ -16040,21 +16188,21 @@ var MAX_POLL_DELAY_MS = 15000;
 var POLL_BACKOFF_FACTOR = 2;
 var DEFAULT_WAIT_TIMEOUT_SECONDS = 3600;
 var WAIT_TIMEOUT_FLAG = "--wait-timeout <seconds>";
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function optionalString(value) {
   return typeof value === "string" && value !== "" ? value : null;
 }
 function runData(raw) {
-  return isRecord2(raw) && isRecord2(raw.data) ? raw.data : raw;
+  return isRecord3(raw) && isRecord3(raw.data) ? raw.data : raw;
 }
 function readRun(raw) {
-  const run = isRecord2(raw) && isRecord2(raw.data) ? raw.data : raw;
-  if (!isRecord2(run) || typeof run.status !== "string") {
+  const run = isRecord3(raw) && isRecord3(raw.data) ? raw.data : raw;
+  if (!isRecord3(run) || typeof run.status !== "string") {
     throw new SimApiError("Run status response carried no status.", 0);
   }
-  const paused = isRecord2(run.paused) ? run.paused : null;
+  const paused = isRecord3(run.paused) ? run.paused : null;
   return {
     status: run.status,
     pauseKind: paused ? optionalString(paused.pauseKind) : null,
@@ -16191,7 +16339,9 @@ function attachProtocolCommands(program2) {
     createFolder: "createWorkflowFolder"
   });
   attachWorkflowRunFollow(workflows);
-  attachWorkflowRunWait(group(workflows, "runs"));
+  const runs = group(workflows, "runs");
+  attachWorkflowRunGet(runs);
+  attachWorkflowRunWait(runs);
   attachLogsFollow(group(program2, "logs"));
   attachChat(program2);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sim",
-  "version": "2.1.5-dev.77.1",
+  "version": "2.1.5-dev.79.1",
   "description": "Sim CLI - talk to the Sim API from your terminal",
   "type": "module",
   "bin": {