@withone/cli 1.47.5 → 1.47.7

package/README.md

@@ -168,10 +168,15 @@ Connect a new platform via OAuth.
 one add shopify
 one add hubspot
 one add gmail
+one add gmail --tag work        # tag the connection
 ```
 
 Opens your browser, you authorize, done. The CLI polls until the connection is live. Platform names are lowercase (with dashes for multi-word names) - run `one platforms` to see them all.
 
+| Flag | What it does |
+|------|-------------|
+| `--tag <name>` | Tag the new connection once it's created. Lets sync/flow profiles target a specific connection via `"connection": { "platform": "gmail", "tag": "work" }` when you have several connections for one platform (e.g. personal vs work Gmail). |
+
 ### `one list`
 
 List your active connections with their status and connection keys.

package/dist/{chunk-DMLYQFMV.js → chunk-KWGN3RJR.js}

@@ -106,6 +106,16 @@ var OneApi = class {
   async deleteConnection(id) {
     await this.requestFull({ path: `/vault/connections/${id}`, method: "DELETE" });
   }
+  /**
+   * Set the tag set on a connection (replaces existing tags). Backs
+   * `one add <platform> --tag <name>`, which tags a connection right after
+   * the OAuth flow creates it so sync/flow profiles can reference it via
+   * `connection: { platform, tag }` when several connections share a platform.
+   * Maps to `PATCH /v1/vault/connections/{id}` (UpdateConnection { tags }).
+   */
+  async updateConnectionTags(id, tags) {
+    await this.requestFull({ path: `/vault/connections/${id}`, method: "PATCH", body: { tags } });
+  }
   /**
    * Resolve a late-bound `ConnectionRef` to a current `Connection`. Pass
    * `cache` (a pre-fetched connection list) when resolving many refs in a
@@ -1279,7 +1289,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-V5FALC6N.js");
+  const { loadFlowWithMeta: loadFlowWithMeta2 } = await import("./flow-runner-7VRNSKWU.js");
   const { flow: subFlow, rootDir: subRootDir } = loadFlowWithMeta2(resolvedKey);
   const subContext = await executeFlow(
     subFlow,
@@ -1493,16 +1503,17 @@ async function executeSingleStep(step, context, api, permissions, allowedActionI
   }
   const startTime = Date.now();
   let lastError;
-  const maxAttempts = step.onError?.strategy === "retry" && step.onError.retries ? step.onError.retries + 1 : 1;
+  const onError = step.onError ?? context._defaultOnError;
+  const maxAttempts = onError?.strategy === "retry" && onError.retries ? onError.retries + 1 : 1;
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     try {
       if (attempt > 1) {
-        const delay = computeRetryDelay(step.onError, attempt);
+        const delay = computeRetryDelay(onError, attempt);
         options.onEvent?.({
           event: "step:retry",
           stepId: step.id,
           attempt,
-          maxRetries: step.onError.retries,
+          maxRetries: onError.retries,
           delayMs: delay
         });
         await sleep2(delay);
@@ -1589,8 +1600,8 @@ async function executeSingleStep(step, context, api, permissions, allowedActionI
       if (attempt === maxAttempts) {
         break;
       }
-      if (step.onError?.strategy === "retry" && (step.onError.retryOn || step.onError.failFastOn)) {
-        const decision = shouldRetryError(lastError, step.onError);
+      if (onError?.strategy === "retry" && (onError.retryOn || onError.failFastOn)) {
+        const decision = shouldRetryError(lastError, onError);
         if (!decision.retry) {
           options.onEvent?.({
             event: "step:retry-skip",
@@ -1604,7 +1615,7 @@ async function executeSingleStep(step, context, api, permissions, allowedActionI
     }
   }
   const errorMessage = lastError?.message || "Unknown error";
-  const strategy = step.onError?.strategy || "fail";
+  const strategy = onError?.strategy || "fail";
   const retriesUsed = Math.max(0, maxAttempts - 1);
   const isTimeout = lastError instanceof StepTimeoutError;
   const errorCode = lastError?.errorCode;
@@ -1619,7 +1630,7 @@ async function executeSingleStep(step, context, api, permissions, allowedActionI
     context.steps[step.id] = result;
     return result;
   }
-  if (strategy === "fallback" && step.onError?.fallbackStepId) {
+  if (strategy === "fallback" && onError?.fallbackStepId) {
     const result = {
       status: isTimeout ? "timeout" : "failed",
       error: errorMessage,
@@ -1740,6 +1751,7 @@ async function executeFlow(flow, inputs, api, permissions, allowedActionIds, opt
     loop: {}
   };
   context.input = resolvedInputs;
+  context._defaultOnError = flow.defaultOnError;
   const completedStepIds = resumeState ? new Set(resumeState.completedSteps) : void 0;
   if (options.dryRun && !options.mock) {
     options.onEvent?.({
@@ -1797,7 +1809,8 @@ var FLOW_SCHEMA = {
     description: { type: "string", required: false, description: "What this flow does" },
     version: { type: "string", required: false, description: "Semver or arbitrary version string" },
     inputs: { type: "object", required: true, description: "Input declarations (Record<string, InputDeclaration>)" },
-    steps: { type: "array", required: true, description: "Ordered array of steps", stepsArray: true }
+    steps: { type: "array", required: true, description: "Ordered array of steps", stepsArray: true },
+    defaultOnError: { type: "object", required: false, description: 'Default error strategy inherited by every step without its own `onError` (e.g. { "strategy": "continue" }). A step opts out with its own `onError`.' }
   },
   inputFields: {
     type: { type: "string", required: true, description: "Data type: string, number, boolean, object, array", enum: ["string", "number", "boolean", "object", "array"] },

package/dist/{flow-runner-V5FALC6N.js → flow-runner-7VRNSKWU.js}

@@ -12,7 +12,7 @@ import {
   stripStepsAlias,
   summarizeFlowInputs,
   walkSteps
-} from "./chunk-DMLYQFMV.js";
+} from "./chunk-KWGN3RJR.js";
 import "./chunk-44CV5IMX.js";
 import "./chunk-K6MWE2ZH.js";
 export {

package/dist/index.js

@@ -30,7 +30,7 @@ import {
   searchCachePath,
   validateActionInput,
   writeCache
-} from "./chunk-DMLYQFMV.js";
+} from "./chunk-KWGN3RJR.js";
 import {
   memSqlCommand
 } from "./chunk-QV3Y5N5G.js";
@@ -2012,7 +2012,7 @@ function stripAnsi(str) {
 }
 
 // src/commands/connection.ts
-async function connectionAddCommand(platformArg) {
+async function connectionAddCommand(platformArg, options) {
   if (isAgentMode()) {
     error("This command requires interactive input. Run without --agent.");
   }
@@ -2107,7 +2107,22 @@ ${url}`);
   try {
     const connection2 = await api.waitForConnection(platform, 5 * 60 * 1e3, 5e3);
     pollSpinner.stop(`${platform} connected!`);
-    p4.log.success(`${pc4.green("\u2713")} ${connection2.platform} is now available to your AI agents.`);
+    const tag = options?.tag?.trim();
+    if (tag) {
+      const tagSpinner = p4.spinner();
+      tagSpinner.start(`Tagging connection "${tag}"...`);
+      try {
+        await api.updateConnectionTags(connection2.id, [tag]);
+        tagSpinner.stop(`Tagged "${tag}"`);
+      } catch (err) {
+        tagSpinner.stop("Could not set tag");
+        p4.log.warn(
+          `Connected, but tagging failed: ${err instanceof Error ? err.message : "Unknown error"}
+The connection is usable; set the tag later in the dashboard or retry.`
+        );
+      }
+    }
+    p4.log.success(`${pc4.green("\u2713")} ${connection2.platform} is now available to your AI agents.${tag ? ` (tag: ${tag})` : ""}`);
     p4.outro("Connection complete!");
   } catch (error2) {
     pollSpinner.stop("Connection timed out");
@@ -3086,6 +3101,16 @@ function validateFlowSchema(flow2) {
   if (f.version !== void 0 && typeof f.version !== "string") {
     errors.push({ path: "version", message: '"version" must be a string' });
   }
+  if (f.defaultOnError !== void 0) {
+    if (!f.defaultOnError || typeof f.defaultOnError !== "object" || Array.isArray(f.defaultOnError)) {
+      errors.push({ path: "defaultOnError", message: '"defaultOnError" must be an object (e.g. { "strategy": "continue" })' });
+    } else {
+      const oe = f.defaultOnError;
+      if (!FLOW_SCHEMA.errorStrategies.includes(oe.strategy)) {
+        errors.push({ path: "defaultOnError.strategy", message: `Error strategy must be one of: ${FLOW_SCHEMA.errorStrategies.join(", ")}` });
+      }
+    }
+  }
   if (!f.inputs || typeof f.inputs !== "object" || Array.isArray(f.inputs)) {
     errors.push({ path: "inputs", message: 'Flow must have an "inputs" object' });
   } else {
@@ -11285,8 +11310,8 @@ config.command("reset").description("Remove the project config for the current d
   }
 });
 var connection = program.command("connection").description("Manage connections");
-connection.command("add [platform]").alias("a").description("Add a new connection").action(async (platform) => {
-  await connectionAddCommand(platform);
+connection.command("add [platform]").alias("a").description("Add a new connection").option("--tag <name>", "Tag the new connection (disambiguates multiple connections per platform in sync/flow profiles)").action(async (platform, options) => {
+  await connectionAddCommand(platform, { tag: options.tag });
 });
 connection.command("list").alias("ls").description("List your connections").option("-s, --search <query>", "Filter connections by platform name").option("-l, --limit <n>", "Max connections to return (agent mode default: 20)").action(async (options) => {
   await connectionListCommand(options);
@@ -11450,8 +11475,8 @@ program.command("whoami").description("Show the user, organization, and project
   console.log(`  ${pc14.dim("API:")} ${apiBase}`);
   console.log();
 });
-program.command("add [platform]").description("Shortcut for: connection add").action(async (platform) => {
-  await connectionAddCommand(platform);
+program.command("add [platform]").description("Shortcut for: connection add").option("--tag <name>", "Tag the new connection (disambiguates multiple connections per platform in sync/flow profiles)").action(async (platform, options) => {
+  await connectionAddCommand(platform, { tag: options.tag });
 });
 program.command("list").alias("ls").description("Shortcut for: connection list").option("-s, --search <query>", "Filter connections by platform name").option("-l, --limit <n>", "Max connections to return (agent mode default: 20)").action(async (options) => {
   await connectionListCommand(options);

package/package.json

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

package/skills/one/SKILL.md

@@ -251,7 +251,7 @@ Without declared paths, the default walker concatenates every string in the reco
 
 **Sync rejects custom actions** — profiles must use passthrough. `sync init` only surfaces passthrough models; `sync run` aborts if the list or enrich action is tagged `custom`. If no passthrough exists, compose a flow instead.
 
-**Connections are late-bound** — profiles use `"connection": { "platform": "<name>" }`, not literal `connectionKey` strings. The key is resolved at sync time, so `one add <platform>` (re-auth) doesn't break the profile. For multi-account platforms, add `"tag": "<connection-tag>"` to disambiguate. Don't hardcode connection keys in profiles.
+**Connections are late-bound** — profiles use `"connection": { "platform": "<name>" }`, not literal `connectionKey` strings. The key is resolved at sync time, so `one add <platform>` (re-auth) doesn't break the profile. For multi-account platforms, add `"tag": "<connection-tag>"` to disambiguate, and create the tagged connection with `one add <platform> --tag <name>`. Don't hardcode connection keys in profiles.
 
 **Advanced features** (enrich, transform, exclude, identityKey, hooks, --full-refresh, alternative backends, embedding tuning): run `one guide memory` or `one guide sync` for the full reference.
 
@@ -267,8 +267,9 @@ One also supports more advanced patterns. Read the relevant reference file befor
 If the user needs a platform that isn't connected yet, tell them to run:
 ```bash
 one add <platform>
+one add <platform> --tag <name>   # tag it (for multiple connections per platform)
 ```
-This is interactive and opens the browser for OAuth. After connecting, the platform will appear in `one --agent connection list`.
+This is interactive and opens the browser for OAuth. After connecting, the platform will appear in `one --agent connection list`. Use `--tag` when the user has (or will have) more than one connection for the same platform so sync/flow profiles can target a specific one via `"connection": { "platform": "<name>", "tag": "<name>" }`.
 
 ## Removing Connections
 

package/skills/one/references/flows.md

@@ -566,6 +566,22 @@ the outputSchema declaration.
 
 Strategies: `fail` (default), `continue`, `retry`, `fallback`.
 
+**Flow-level default (cli#93).** Set `defaultOnError` at the top of the flow and every step without its own `onError` inherits it — handy when most steps should `continue` (e.g. rendering/formatting pipelines) and you don't want to repeat it N times. A step opts out by declaring its own `onError`:
+
+```json
+{
+  "key": "render-report",
+  "defaultOnError": { "strategy": "continue" },
+  "steps": [
+    { "id": "critical", "onError": { "strategy": "fail" }, ... },   // stays fatal
+    { "id": "chart", ... },                                          // inherits continue
+    { "id": "thumbnail", ... }                                       // inherits continue
+  ]
+}
+```
+
+Scoped per-flow: a sub-flow uses its own `defaultOnError`, not the parent's.
+
 **Retry backoff.** By default each retry waits exactly `retryDelayMs`. For rate-limited APIs add `"backoff": "exponential"` (or `"exponential-jitter"`) and an optional `"maxDelayMs"` cap (defaults to 30000):
 
 ```json