@withone/cli 1.45.0 → 1.45.1

package/README.md

@@ -268,7 +268,7 @@ one actions execute stripe <actionId> <connectionKey> \
 | `--mock` | Return example response without making an API call |
 | `--skip-validation` | Skip input validation against the action schema |
 | `--output <path>` | Save response to a file (for binary downloads) |
-| `--no-cache` | Fetch action details fresh instead of from the local cache (execution itself is never cached) |
+| `--no-cache` | Bypass the cached action details and re-fetch them; the fresh details still refresh the cache (execution itself is never cached) |
 
 The CLI validates required parameters (path variables, query params, body fields) against the action schema before executing. Missing params return a clear error with the flag name and description. Pass `--skip-validation` to bypass.
 

package/dist/{chunk-UXKF6AEG.js → chunk-DZK56R5R.js}

@@ -672,29 +672,32 @@ function isActionDetailsEntry(entry) {
 }
 async function resolveActionDetails(api, actionId, opts = {}) {
   const useCache = opts.useCache !== false;
+  const warn = opts.warn ?? ((m) => {
+    process.stderr.write(m);
+  });
   const cachePath = knowledgeCachePath(actionId);
   const raw = useCache ? readCache(cachePath) : null;
   const cached = isActionDetailsEntry(raw) ? raw : null;
   if (cached && isFresh(cached)) {
-    return { details: cached.data, cacheHit: true, entry: cached };
+    return { details: cached.data, cacheHit: true, stale: false, entry: cached };
   }
   try {
     const result = await api.getActionDetailsWithMeta(actionId, cached?.etag ?? void 0);
     if (result.status === 304 && cached) {
       cached.cachedAt = (/* @__PURE__ */ new Date()).toISOString();
       writeCache(cachePath, cached);
-      return { details: cached.data, cacheHit: true, entry: cached };
+      return { details: cached.data, cacheHit: true, stale: false, entry: cached };
     }
     const entry = makeCacheEntry(actionId, result.data, result.etag);
     writeCache(cachePath, entry);
-    return { details: result.data, cacheHit: false, entry };
+    return { details: result.data, cacheHit: false, stale: false, entry };
   } catch (fetchError) {
     if (cached) {
-      process.stderr.write(
+      warn(
         `Warning: serving cached action details (network unavailable, cached ${formatAge(getAge(cached))} ago)
 `
       );
-      return { details: cached.data, cacheHit: true, entry: cached };
+      return { details: cached.data, cacheHit: true, stale: true, entry: cached };
     }
     throw fetchError;
   }
@@ -1268,7 +1271,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-FQVTF36N.js");
+  const { loadFlowWithMeta: loadFlowWithMeta2 } = await import("./flow-runner-6KN2ZVXB.js");
   const { flow: subFlow, rootDir: subRootDir } = loadFlowWithMeta2(resolvedKey);
   const subContext = await executeFlow(
     subFlow,

package/dist/{flow-runner-FQVTF36N.js → flow-runner-6KN2ZVXB.js}

@@ -11,7 +11,7 @@ import {
   saveFlow,
   summarizeFlowInputs,
   walkSteps
-} from "./chunk-UXKF6AEG.js";
+} from "./chunk-DZK56R5R.js";
 import "./chunk-44CV5IMX.js";
 import "./chunk-TVIZC7AC.js";
 export {

package/dist/index.js

@@ -30,7 +30,7 @@ import {
   searchCachePath,
   validateActionInput,
   writeCache
-} from "./chunk-UXKF6AEG.js";
+} from "./chunk-DZK56R5R.js";
 import {
   memSqlCommand
 } from "./chunk-TLRJMJGU.js";
@@ -2382,7 +2382,8 @@ async function actionsSearchCommand(platform, query, options) {
   try {
     const agentType = knowledgeAgent ? "knowledge" : options.type || "execute";
     const useCache = options.cache !== false;
-    const cachePath = searchCachePath(platform, query, agentType || "knowledge");
+    const searchType = agentType || "knowledge";
+    const cachePath = searchCachePath(platform, query, searchType);
     const cached = useCache ? readCache(cachePath) : null;
     let cleanedActions;
     let cacheHit = false;
@@ -2413,8 +2414,8 @@ async function actionsSearchCommand(platform, query, options) {
             path: action.path
           }));
           writeCache(cachePath, makeCacheEntry(
-            `${platform}_${query}_${agentType || "knowledge"}`,
-            { actions: cleanedActions },
+            `${platform}_${query}_${searchType}`,
+            { actions: cleanedActions, platform, query, searchType },
             result.etag
           ));
         }
@@ -2596,7 +2597,7 @@ async function actionsExecuteCommand(platform, actionId, connectionKey, options)
   }
   const api = new OneApi(apiKey, getApiBase());
   const spinner5 = createSpinner();
-  spinner5.start("Loading action details...");
+  spinner5.start("Resolving action details...");
   try {
     const { details: actionDetails, cacheHit: preflightCacheHit } = await resolveActionDetails(api, actionId, { useCache: options.cache !== false });
     if (!isMethodAllowed(actionDetails.method, permissions)) {
@@ -2605,7 +2606,9 @@ async function actionsExecuteCommand(platform, actionId, connectionKey, options)
         `Method "${actionDetails.method}" is not allowed under "${permissions}" permission level.`
       );
     }
-    spinner5.stop(`Action: ${actionDetails.title} [${actionDetails.method}]`);
+    spinner5.stop(
+      `Action: ${actionDetails.title} [${actionDetails.method}]` + (preflightCacheHit ? pc6.dim(" (cached)") : "")
+    );
     const data = options.data ? parseJsonArg2(options.data, "--data") : void 0;
     const pathVariables = options.pathVars ? parseJsonArg2(options.pathVars, "--path-vars") : void 0;
     const queryParams = options.queryParams ? parseJsonArg2(options.queryParams, "--query-params") : void 0;
@@ -2830,6 +2833,7 @@ async function actionsExecuteParallelCommand() {
   const api = new OneApi(apiKey, getApiBase());
   const prepared = [];
   const errors = [];
+  const staleWarned = /* @__PURE__ */ new Set();
   for (let i = 0; i < segments.length; i++) {
     const seg = segments[i];
     const label = `${seg.platform}/${seg.actionId}`;
@@ -2843,7 +2847,14 @@ async function actionsExecuteParallelCommand() {
     let actionDetails;
     let preflightCacheHit = false;
     try {
-      const resolved = await resolveActionDetails(api, seg.actionId, { useCache: flags.useCache });
+      const resolved = await resolveActionDetails(api, seg.actionId, {
+        useCache: flags.useCache,
+        warn: (msg) => {
+          if (staleWarned.has(seg.actionId)) return;
+          staleWarned.add(seg.actionId);
+          process.stderr.write(msg);
+        }
+      });
       actionDetails = resolved.details;
       preflightCacheHit = resolved.cacheHit;
     } catch (err) {
@@ -9204,6 +9215,9 @@ async function cacheUpdateAllCommand() {
     error("Not configured. Run `one init` first.");
   }
   const api = new OneApi(apiKey, getApiBase());
+  const ac = getAccessControlFromAllSources();
+  const permissions = ac.permissions || "admin";
+  const actionIds = ac.actionIds || ["*"];
   const entries = listCacheEntries();
   if (entries.length === 0) {
     if (isAgentMode()) {
@@ -9226,8 +9240,36 @@ async function cacheUpdateAllCommand() {
         writeCache(e.filePath, newEntry);
         updated++;
       } else {
-        const refreshed = { ...e.entry, cachedAt: (/* @__PURE__ */ new Date()).toISOString() };
-        writeCache(e.filePath, refreshed);
+        const data = e.entry.data;
+        if (data?.platform && data?.query) {
+          const searchType = data.searchType ?? "knowledge";
+          const result = await api.searchActionsWithMeta(
+            data.platform,
+            data.query,
+            searchType,
+            e.entry.etag ?? void 0
+          );
+          if (result.status === 304) {
+            writeCache(e.filePath, { ...e.entry, cachedAt: (/* @__PURE__ */ new Date()).toISOString() });
+          } else {
+            let actions2 = result.data;
+            actions2 = filterByPermissions(actions2, permissions);
+            actions2 = actions2.filter((a) => isActionAllowed(a.systemId, actionIds));
+            const cleaned = actions2.map((a) => ({
+              actionId: a.systemId,
+              title: a.title,
+              method: a.method,
+              path: a.path
+            }));
+            writeCache(e.filePath, makeCacheEntry(
+              e.entry.key,
+              { actions: cleaned, platform: data.platform, query: data.query, searchType },
+              result.etag
+            ));
+          }
+        } else {
+          writeCache(e.filePath, { ...e.entry, cachedAt: (/* @__PURE__ */ new Date()).toISOString() });
+        }
         updated++;
       }
     } catch (err) {
@@ -9313,7 +9355,7 @@ one --agent actions execute <platform> <actionId> <key> -d '{}'  # Execute it
 - \`--mock\` \u2014 Return example response without making an API call (useful for building UI against a response shape)
 - \`--skip-validation\` \u2014 Skip input validation against the action schema
 - \`--output <path>\` \u2014 Save response to a file (for binary downloads like PDFs, images, documents)
-- \`--no-cache\` \u2014 Fetch action details fresh instead of from the local cache (execution itself is never cached)
+- \`--no-cache\` \u2014 Bypass the cached action details and re-fetch them; the fresh details still refresh the cache (execution itself is never cached)
 
 The CLI validates required parameters against the action schema before executing. If you're missing a required path variable, query param, or body field, you'll get a clear error listing what's missing and which flag to use. Pass \`--skip-validation\` to bypass.
 
@@ -9439,7 +9481,7 @@ one --agent actions execute <platform> <actionId> <connectionKey> [options]
 - \`--mock\` \u2014 Return example response without making an API call
 - \`--skip-validation\` \u2014 Skip input validation against the action schema
 - \`--output <path>\` \u2014 Save response to a file (for binary downloads like PDFs, images, documents)
-- \`--no-cache\` \u2014 Fetch action details fresh instead of from the local cache (execution itself is never cached)
+- \`--no-cache\` \u2014 Bypass the cached action details and re-fetch them; the fresh details still refresh the cache (execution itself is never cached)
 
 Execute reuses the action details cached by \`actions knowledge\` (method, path, schema), so in the standard search \u2192 knowledge \u2192 execute flow it makes a single API call \u2014 the action being executed. The live response is never cached. In \`--agent\` mode the response includes \`"_preflight": {"cache": "hit"|"miss"}\` showing whether the lookup was served from disk.
 
@@ -10961,13 +11003,13 @@ program.command("platforms").alias("p").description("List available platforms").
   await platformsCommand(options);
 });
 var actions = program.command("actions").alias("a").description("Search, explore, and execute platform actions (workflow: search \u2192 knowledge \u2192 execute)");
-actions.command("search <platform> <query>").description('Search for actions on a platform (e.g. one actions search gmail "send email")').option("-t, --type <type>", "execute (to run it) or knowledge (to learn about it). Default: knowledge").option("--no-cache", "Skip cache, fetch fresh from API").action(async (platform, query, options) => {
+actions.command("search <platform> <query>").description('Search for actions on a platform (e.g. one actions search gmail "send email")').option("-t, --type <type>", "execute (to run it) or knowledge (to learn about it). Default: knowledge").option("--no-cache", "Bypass the cache and re-fetch from the API (the fresh response still refreshes the cache)").action(async (platform, query, options) => {
   await actionsSearchCommand(platform, query, options);
 });
-actions.command("knowledge <platform> <actionId>").alias("k").description("Get full docs for an action \u2014 MUST call before execute to know required params").option("--no-cache", "Skip cache, fetch fresh from API").option("--cache-status", "Print cache metadata without fetching").action(async (platform, actionId, options) => {
+actions.command("knowledge <platform> <actionId>").alias("k").description("Get full docs for an action \u2014 MUST call before execute to know required params").option("--no-cache", "Bypass the cache and re-fetch from the API (the fresh response still refreshes the cache)").option("--cache-status", "Print cache metadata without fetching").action(async (platform, actionId, options) => {
   await actionsKnowledgeCommand(platform, actionId, options);
 });
-actions.command("execute [platform] [actionId] [connectionKey]").alias("x").allowUnknownOption(true).allowExcessArguments(true).description("Execute an action (or multiple with --parallel, separated by --)").option("-d, --data <json>", "Request body as JSON").option("--path-vars <json>", "Path variables as JSON").option("--query-params <json>", "Query parameters as JSON").option("--headers <json>", "Additional headers as JSON").option("--form-data", "Send as multipart/form-data").option("--form-url-encoded", "Send as application/x-www-form-urlencoded").option("--dry-run", "Show request that would be sent without executing").option("--mock", "Return example response without making an API call").option("--skip-validation", "Skip input validation against the action schema").option("--no-cache", "Fetch action details fresh instead of using the local cache (execution itself is never cached)").option("--output <path>", "Save binary response to a file (for non-JSON responses like file downloads)").option("--parallel", "Execute multiple actions concurrently (separate actions with --)").option("--max-concurrency <n>", "Max concurrent actions when using --parallel (default: 5)", "5").action(async (platform, actionId, connectionKey, options) => {
+actions.command("execute [platform] [actionId] [connectionKey]").alias("x").allowUnknownOption(true).allowExcessArguments(true).description("Execute an action (or multiple with --parallel, separated by --)").option("-d, --data <json>", "Request body as JSON").option("--path-vars <json>", "Path variables as JSON").option("--query-params <json>", "Query parameters as JSON").option("--headers <json>", "Additional headers as JSON").option("--form-data", "Send as multipart/form-data").option("--form-url-encoded", "Send as application/x-www-form-urlencoded").option("--dry-run", "Show request that would be sent without executing").option("--mock", "Return example response without making an API call").option("--skip-validation", "Skip input validation against the action schema").option("--no-cache", "Bypass the cached action details and re-fetch them (the fresh details still refresh the cache; execution itself is never cached)").option("--output <path>", "Save binary response to a file (for non-JSON responses like file downloads)").option("--parallel", "Execute multiple actions concurrently (separate actions with --)").option("--max-concurrency <n>", "Max concurrent actions when using --parallel (default: 5)", "5").action(async (platform, actionId, connectionKey, options) => {
   if (options.parallel) {
     await actionsExecuteParallelCommand();
     return;

package/package.json

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

package/skills/one/SKILL.md

@@ -90,7 +90,7 @@ Options:
 - `--mock` — Return example response without making an API call (useful for building UI)
 - `--skip-validation` — Skip input validation against the action schema
 - `--output <path>` — Save response to a file (for binary downloads like PDFs, images, documents)
-- `--no-cache` — Fetch action details fresh instead of from the local cache (execution itself is never cached)
+- `--no-cache` — Bypass the cached action details and re-fetch them; the fresh details still refresh the cache (execution itself is never cached)
 
 The CLI validates required parameters before executing. Missing params return a structured error with the flag name, parameter name, and description. Pass `--skip-validation` to bypass.