@withone/cli 1.25.0 → 1.26.0

package/dist/{chunk-ONGJ2QKB.js → chunk-ZOIXA7MV.js}

@@ -914,7 +914,7 @@ async function executeSubflowStep(step, context, api, permissions, allowedAction
   if (flowStack.includes(resolvedKey)) {
     throw new Error(`Circular flow detected: ${[...flowStack, resolvedKey].join(" \u2192 ")}`);
   }
-  const { loadFlowWithMeta: loadFlowWithMeta2 } = await import("./flow-runner-MXRNWG4Y.js");
+  const { loadFlowWithMeta: loadFlowWithMeta2 } = await import("./flow-runner-3DCROTPW.js");
   const { flow: subFlow, rootDir: subRootDir } = loadFlowWithMeta2(resolvedKey);
   const subContext = await executeFlow(
     subFlow,
@@ -1027,6 +1027,12 @@ async function executeBashStep(step, context, options) {
     response: { stdout: stdout.trim(), stderr: stderr.trim(), exitCode: 0 }
   };
 }
+function describe(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return `array (${JSON.stringify(value)})`;
+  if (typeof value === "object") return `object (${JSON.stringify(value)})`;
+  return `${typeof value} (${JSON.stringify(value)})`;
+}
 function isMissing(value) {
   if (value === void 0 || value === null) return true;
   if (typeof value === "string" && value.length === 0) return true;
@@ -1218,18 +1224,68 @@ async function executeSteps(steps, context, api, permissions, allowedActionIds,
   return results;
 }
 async function executeFlow(flow, inputs, api, permissions, allowedActionIds, options = {}, resumeState, flowStack = []) {
-  for (const [name, decl] of Object.entries(flow.inputs)) {
-    if (decl.required !== false && inputs[name] === void 0 && decl.default === void 0) {
-      throw new Error(`Missing required input: "${name}" \u2014 ${decl.description || ""}`);
-    }
-  }
   const resolvedInputs = {};
   for (const [name, decl] of Object.entries(flow.inputs)) {
-    if (inputs[name] !== void 0) {
-      resolvedInputs[name] = inputs[name];
-    } else if (decl.default !== void 0) {
-      resolvedInputs[name] = decl.default;
+    const provided = inputs[name];
+    const isMissing2 = provided === void 0 || provided === null;
+    if (isMissing2) {
+      if (decl.required !== false && decl.default === void 0) {
+        throw new Error(`Missing required input: "${name}"${decl.description ? ` \u2014 ${decl.description}` : ""}`);
+      }
+      if (decl.default !== void 0) {
+        resolvedInputs[name] = decl.default;
+      }
+      continue;
+    }
+    let value = provided;
+    switch (decl.type) {
+      case "string":
+        if (typeof value !== "string") value = String(value);
+        break;
+      case "number":
+        if (typeof value === "string" && value.trim() !== "" && !Number.isNaN(Number(value))) {
+          value = Number(value);
+        }
+        if (typeof value !== "number" || Number.isNaN(value)) {
+          throw new Error(`Input "${name}" must be a number, got ${describe(provided)}`);
+        }
+        break;
+      case "boolean":
+        if (value === "true" || value === "1" || value === 1) value = true;
+        else if (value === "false" || value === "0" || value === 0) value = false;
+        if (typeof value !== "boolean") {
+          throw new Error(`Input "${name}" must be a boolean, got ${describe(provided)}`);
+        }
+        break;
+      case "array":
+        if (typeof value === "string") {
+          try {
+            value = JSON.parse(value);
+          } catch {
+          }
+        }
+        if (!Array.isArray(value)) {
+          throw new Error(`Input "${name}" must be an array, got ${describe(provided)}`);
+        }
+        break;
+      case "object":
+        if (typeof value === "string") {
+          try {
+            value = JSON.parse(value);
+          } catch {
+          }
+        }
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+          throw new Error(`Input "${name}" must be an object, got ${describe(provided)}`);
+        }
+        break;
+    }
+    if (Array.isArray(decl.enum) && decl.enum.length > 0) {
+      if (!decl.enum.some((allowed) => allowed === value)) {
+        throw new Error(`Input "${name}" must be one of ${JSON.stringify(decl.enum)}, got ${JSON.stringify(value)}`);
+      }
     }
+    resolvedInputs[name] = value;
   }
   const context = resumeState?.context || {
     input: resolvedInputs,
@@ -1237,6 +1293,7 @@ async function executeFlow(flow, inputs, api, permissions, allowedActionIds, opt
     steps: {},
     loop: {}
   };
+  context.input = resolvedInputs;
   const completedStepIds = resumeState ? new Set(resumeState.completedSteps) : void 0;
   if (options.dryRun && !options.mock) {
     options.onEvent?.({
@@ -1301,7 +1358,8 @@ var FLOW_SCHEMA = {
     required: { type: "boolean", required: false, description: "Whether this input must be provided" },
     default: { type: "unknown", required: false, description: "Default value if not provided" },
     description: { type: "string", required: false, description: "Human-readable description" },
-    connection: { type: "object", required: false, description: 'Connection metadata: { platform: "gmail" } \u2014 enables auto-resolution' }
+    connection: { type: "object", required: false, description: 'Connection metadata: { platform: "gmail" } \u2014 enables auto-resolution' },
+    enum: { type: "array", required: false, description: "Allowed values. Resolved input must equal one of these (post-coercion)." }
   },
   stepCommonFields: {
     id: { type: "string", required: true, description: "Unique step identifier (used in selectors)" },

package/dist/{flow-runner-MXRNWG4Y.js → flow-runner-3DCROTPW.js}

@@ -11,7 +11,7 @@ import {
   saveFlow,
   summarizeFlowInputs,
   walkSteps
-} from "./chunk-ONGJ2QKB.js";
+} from "./chunk-ZOIXA7MV.js";
 export {
   FlowRunner,
   collectStepTypes,

package/dist/index.js

@@ -16,7 +16,7 @@ import {
   loadFlowWithMeta,
   resolveFlowPath,
   saveFlow
-} from "./chunk-ONGJ2QKB.js";
+} from "./chunk-ZOIXA7MV.js";
 
 // src/index.ts
 import { createRequire as createRequire2 } from "module";
@@ -2281,6 +2281,11 @@ function validateFlowSchema(flow2) {
       if (!d.type || !FLOW_SCHEMA.validInputTypes.includes(d.type)) {
         errors.push({ path: `${prefix}.type`, message: `Input type must be one of: ${FLOW_SCHEMA.validInputTypes.join(", ")}` });
       }
+      if (d.enum !== void 0) {
+        if (!Array.isArray(d.enum) || d.enum.length === 0) {
+          errors.push({ path: `${prefix}.enum`, message: '"enum" must be a non-empty array of allowed values' });
+        }
+      }
       if (d.connection !== void 0) {
         if (!d.connection || typeof d.connection !== "object") {
           errors.push({ path: `${prefix}.connection`, message: "Connection metadata must be an object" });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@withone/cli",
-  "version": "1.25.0",
+  "version": "1.26.0",
   "description": "CLI for managing One",
   "type": "module",
   "files": [

package/skills/one/references/flows.md

@@ -186,9 +186,29 @@ one --agent flow execute <key> -i connectionKey=xxx -i param=value
 | `default` | Default value if not provided |
 | `description` | Human-readable description |
 | `connection` | `{ "platform": "gmail" }` — enables auto-resolution |
+| `enum` | Array of allowed values; rejected if input doesn't match (post-coercion) |
 
 Connection inputs with a `connection` field auto-resolve if the user has exactly one connection for that platform.
 
+**Validation, coercion, and enums.** At flow start the engine validates every declared input:
+
+1. **Required check** — `required: true` (the default) inputs without a value or `default` cause `Missing required input: "X"`.
+2. **Type coercion** — narrow, bidirectional fixes only:
+   - `number`: numeric strings (`"5"`) become `5`. Non-numeric strings throw.
+   - `boolean`: `"true"`/`"1"`/`1` → `true`; `"false"`/`"0"`/`0` → `false`. Anything else throws.
+   - `array` / `object`: JSON strings are parsed. Non-JSON throws.
+   - `string`: anything else is `String(value)`-coerced.
+3. **Enum check** — if `enum` is set, the (coerced) value must be `===` one of the allowed entries. Errors quote both the allowed list and the actual value.
+
+This eliminates the per-flow `if (!$.input.x) throw ...` boilerplate. Errors look like:
+
+```
+Input "tier" must be a number, got string ("lots")
+Input "stage" must be one of ["pre_seed","seed","series_a"], got "ipo"
+```
+
+The same checks run when a step calls a sub-flow, so type/enum guarantees hold across the call boundary.
+
 ## Selector Syntax
 
 | Pattern | Resolves To |