@withone/cli 1.49.0 → 1.50.0

package/README.md

@@ -179,7 +179,7 @@ Opens your browser, you authorize, done. The CLI polls until the connection is l
 
 ### `one list`
 
-List your active connections with their status and connection keys.
+List your active connections with their status, connection keys, and what your access config lets you run on each.
 
 ```bash
 one list
@@ -193,6 +193,37 @@ one list
 
 You need the connection key (rightmost column) when executing actions.
 
+**Access reporting.** Every connection carries an `access` field describing what the current [access control](#one-config) config permits — so an agent knows its reach up front instead of discovering it as a failure mid-workflow. Three policies:
+
+| Policy | Means | Shown when |
+|--------|-------|-----------|
+| `{"policy": "full"}` | Every action on the connection | Default (admin, no action allowlist) |
+| `{"policy": "methods", "methods": ["GET"]}` | Only actions with those HTTP methods | Permission level is `read` or `write` |
+| `{"policy": "actions", "actions": [{"actionId": "...", "title": "...", "method": "..."}]}` | Only these specific actions | An action allowlist is configured |
+
+An action allowlist wins over the permission level (and is then method-filtered by it). When the policy is `actions`, those actions are exactly what may run — no `actions search` needed.
+
+```jsonc
+// one --agent list
+{
+  "total": 2,
+  "showing": 2,
+  "connections": [
+    {
+      "platform": "gmail",
+      "state": "operational",
+      "key": "live::gmail::default::abc123",
+      "access": { "policy": "methods", "methods": ["GET"] }
+    }
+  ],
+  "accessHint": "Permission level \"read\": only GET actions will execute."
+}
+```
+
+`knowledgeOnly: true` appears when knowledge-only mode is on (execution disabled), and `unresolvedActionIds` lists any allowlisted action ids that could not be looked up. In human output, an `Access` column and a summary note appear only when access is actually scoped.
+
+This mirrors the `access` field on the One MCP server's `list_one_integrations` tool, so both surfaces report access the same way.
+
 ### `one connection delete <connection-key>`
 
 Remove a connection by its key.
@@ -576,6 +607,8 @@ one config
 
 Settings propagate automatically to all installed agent configs.
 
+Run [`one list`](#one-list) to see the effect: each connection reports an `access` field describing exactly what these settings let you run on it.
+
 #### `one config skills status` / `one config skills sync`
 
 `one init` copies the packaged skill files (`SKILL.md`, `references/`) into `~/.agents/skills/one/` and symlinks per-agent paths to that canonical directory. When the CLI self-updates, the skill files in the canonical dir would normally stay frozen at the version that was installed. To prevent stale docs, every CLI command checks a `.one-cli-version` marker in the canonical dir and silently refreshes the skill files if they don't match the running CLI version. No user action required.

package/dist/{chunk-2TWFL3CS.js → chunk-D6W756DN.js}

@@ -2319,7 +2319,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-IBB42ED2.js");
+  const { loadFlowWithMeta: loadFlowWithMeta2 } = await import("./flow-runner-YDKAYGZW.js");
   const { flow: subFlow, rootDir: subRootDir } = loadFlowWithMeta2(resolvedKey);
   const subContext = await executeFlow(
     subFlow,
@@ -3238,11 +3238,11 @@ export {
   ApiError,
   OneApi,
   TimeoutError,
+  PERMISSION_METHODS,
   filterByPermissions,
   isMethodAllowed,
   isActionAllowed,
   buildActionKnowledgeWithGuidance,
-  validateActionInput,
   knowledgeCachePath,
   searchCachePath,
   readCache,
@@ -3256,6 +3256,7 @@ export {
   clearEntry,
   makeCacheEntry,
   resolveActionDetails,
+  validateActionInput,
   FLOW_SCHEMA,
   getStepTypeDescriptor,
   getNestedStepsKeys,

package/dist/{flow-runner-IBB42ED2.js → flow-runner-YDKAYGZW.js}

@@ -12,7 +12,7 @@ import {
   stripStepsAlias,
   summarizeFlowInputs,
   walkSteps
-} from "./chunk-2TWFL3CS.js";
+} from "./chunk-D6W756DN.js";
 import "./chunk-44CV5IMX.js";
 import "./chunk-SO323PZP.js";
 export {

package/dist/index.js

@@ -3,6 +3,7 @@ import {
   FLOW_SCHEMA,
   FlowRunner,
   OneApi,
+  PERMISSION_METHODS,
   TimeoutError,
   buildActionKnowledgeWithGuidance,
   buildCacheMeta,
@@ -31,7 +32,7 @@ import {
   validateActionInput,
   walkSteps,
   writeCache
-} from "./chunk-2TWFL3CS.js";
+} from "./chunk-D6W756DN.js";
 import {
   memSqlCommand
 } from "./chunk-4WWK3GO5.js";
@@ -1942,6 +1943,54 @@ function maskApiKey(key) {
 import * as p4 from "@clack/prompts";
 import pc4 from "picocolors";
 
+// src/lib/access.ts
+async function resolveAllowedActions(api, actionIds) {
+  if (actionIds.includes("*")) return [];
+  const resolved = await Promise.all(
+    actionIds.map(async (actionId) => {
+      try {
+        const { details } = await resolveActionDetails(api, actionId, { warn: () => {
+        } });
+        if (!details.connectionPlatform) return null;
+        return {
+          actionId,
+          title: details.title,
+          method: details.method,
+          platform: details.connectionPlatform
+        };
+      } catch {
+        return null;
+      }
+    })
+  );
+  return resolved.filter((a) => a !== null);
+}
+function computeConnectionAccess(platform, permissions, allowedActionIds, grantedActions) {
+  if (!allowedActionIds.includes("*")) {
+    const actions2 = grantedActions.filter((a) => a.platform === platform).map(({ actionId, title, method }) => ({ actionId, title, method }));
+    return { policy: "actions", actions: actions2 };
+  }
+  const methods = PERMISSION_METHODS[permissions];
+  if (methods !== null) {
+    return { policy: "methods", methods };
+  }
+  return { policy: "full" };
+}
+function formatAccess(access, maxActions = 2) {
+  switch (access.policy) {
+    case "full":
+      return "full";
+    case "methods":
+      return access.methods.join(", ");
+    case "actions": {
+      if (access.actions.length === 0) return "none";
+      const shown = access.actions.slice(0, maxActions).map((a) => `${a.title} (${a.method})`);
+      const rest = access.actions.length - shown.length;
+      return rest > 0 ? `${shown.join(", ")} +${rest} more` : shown.join(", ");
+    }
+  }
+}
+
 // src/lib/platforms.ts
 function findPlatform(platforms, query) {
   const normalizedQuery = query.toLowerCase().trim();
@@ -2155,8 +2204,16 @@ async function connectionListCommand(options) {
   try {
     const allConnections = await api.listConnections();
     const ac = getAccessControlFromAllSources();
+    const permissions = ac.permissions || "admin";
     const allowedKeys = ac.connectionKeys || ["*"];
+    const actionIds = ac.actionIds || ["*"];
+    const knowledgeOnly = ac.knowledgeAgent || false;
     const accessFiltered = allowedKeys.includes("*") ? allConnections : allConnections.filter((conn) => allowedKeys.includes(conn.key));
+    const resolvedActions = await resolveAllowedActions(api, actionIds);
+    const unresolvedActionIds = actionIds.includes("*") ? [] : actionIds.filter((id) => !resolvedActions.some((a) => a.actionId === id));
+    const grantedActions = resolvedActions.filter((a) => isMethodAllowed(a.method, permissions));
+    const accessFor = (platform) => computeConnectionAccess(platform, permissions, actionIds, grantedActions);
+    const hintText = accessHint(permissions, actionIds, knowledgeOnly);
     const searchQuery = options?.search?.toLowerCase();
     const filtered = searchQuery ? accessFiltered.filter((conn) => conn.platform.toLowerCase().includes(searchQuery)) : accessFiltered;
     const limitArg = options?.limit ? parseInt(options.limit, 10) : void 0;
@@ -2172,8 +2229,12 @@ async function connectionListCommand(options) {
           state: conn.state,
           key: conn.key,
           ...conn.name && { name: conn.name },
-          ...conn.tags?.length && { tags: conn.tags }
+          ...conn.tags?.length && { tags: conn.tags },
+          access: accessFor(conn.platform)
         })),
+        ...knowledgeOnly && { knowledgeOnly: true },
+        ...unresolvedActionIds.length > 0 && { unresolvedActionIds },
+        ...hintText && { accessHint: hintText },
         ...limited.length < filtered.length && {
           hint: `Showing ${limited.length} of ${filtered.length} connections. Use --search <query> to filter by platform or --limit <n> to see more.`
         }
@@ -2206,20 +2267,34 @@ Add one with: ${pc4.cyan("one connection add gmail")}`,
       platform: conn.platform,
       state: conn.state,
       key: conn.key,
-      tags: conn.tags?.length ? conn.tags.join(", ") : ""
+      tags: conn.tags?.length ? conn.tags.join(", ") : "",
+      access: formatAccess(accessFor(conn.platform))
     }));
     const hasTags = rows.some((r) => r.tags);
+    const hasScopedAccess = rows.some((r) => r.access !== "full");
     printTable(
       [
         { key: "status", label: "" },
         { key: "platform", label: "Platform" },
         { key: "state", label: "Status" },
         { key: "key", label: "Connection Key", color: pc4.dim },
-        ...hasTags ? [{ key: "tags", label: "Tags", color: pc4.dim }] : []
+        ...hasTags ? [{ key: "tags", label: "Tags", color: pc4.dim }] : [],
+        ...hasScopedAccess ? [{ key: "access", label: "Access", color: pc4.yellow }] : []
       ],
       rows
     );
     console.log();
+    if (hintText) {
+      const lines = [hintText];
+      if (unresolvedActionIds.length > 0) {
+        lines.push(
+          `Could not resolve ${unresolvedActionIds.length} allowlisted action id(s): ${unresolvedActionIds.join(", ")}`
+        );
+      }
+      p4.note(`${wrapText(lines.join("\n"))}
+
+Change it with: ${pc4.cyan("one config")}`, "Access");
+    }
     if (displayed.length < filtered.length) {
       p4.note(
         `Showing ${displayed.length} of ${filtered.length}. Increase --limit or run without it to see all.`,
@@ -2292,6 +2367,37 @@ async function connectionDeleteCommand(connectionKey, options) {
     error(`Error: ${error2 instanceof Error ? error2.message : "Unknown error"}`);
   }
 }
+function accessHint(permissions, actionIds, knowledgeOnly) {
+  const parts = [];
+  if (!actionIds.includes("*")) {
+    parts.push(
+      "Action-scoped: each connection's `access.actions` are the only actions you may run \u2014 use them directly, no `actions search` needed."
+    );
+  } else if (permissions !== "admin") {
+    const methods = PERMISSION_METHODS[permissions]?.join(", ") ?? "";
+    parts.push(`Permission level "${permissions}": only ${methods} actions will execute.`);
+  }
+  if (knowledgeOnly) {
+    parts.push("Knowledge-only mode: `actions execute` is disabled \u2014 read knowledge and write code instead.");
+  }
+  return parts.length > 0 ? parts.join(" ") : null;
+}
+function wrapText(text5, width = 72) {
+  return text5.split("\n").map((paragraph) => {
+    const lines = [];
+    let line = "";
+    for (const word of paragraph.split(/\s+/)) {
+      if (line && line.length + 1 + word.length > width) {
+        lines.push(line);
+        line = word;
+      } else {
+        line = line ? `${line} ${word}` : word;
+      }
+    }
+    if (line) lines.push(line);
+    return lines.join("\n");
+  }).join("\n");
+}
 function getStatusIndicator(state) {
   switch (state) {
     case "operational":
@@ -9777,7 +9883,7 @@ Search for actions, read their docs, and execute them. This is the core workflow
 
 **Quick start:**
 \`\`\`bash
-one --agent connection list                                    # See connected platforms
+one --agent connection list                                    # See connected platforms + your access on each
 one --agent connection delete <connection-key>                 # Remove a connection
 one --agent actions search <platform> "<query>" -t execute     # Find an action
 one --agent actions knowledge <platform> <actionId>            # Read docs (REQUIRED)
@@ -9866,6 +9972,7 @@ Request specific sections:
 - Always use the **exact action ID** from search results \u2014 don't guess
 - Always read **knowledge** before executing any action
 - Connection keys come from \`one connection list\` \u2014 don't hardcode them
+- \`connection list\` also reports an \`access\` field per connection (\`full\` / \`methods\` / \`actions\`) \u2014 read it before planning so you don't propose an action the access config will reject
 - Skills stay in lockstep with the CLI version automatically \u2014 every command checks a \`.one-cli-version\` marker in the canonical skill dir and refreshes the files if the CLI has been upgraded. Check manually with \`one config skills status\`; force a resync with \`one config skills sync\`
 `;
 var GUIDE_ACTIONS = `# One Actions \u2014 Reference
@@ -9880,7 +9987,17 @@ Always follow this sequence. Never skip the knowledge step.
 one --agent connection list
 \`\`\`
 
-Returns platforms, status, connection keys, and tags.
+Returns platforms, status, connection keys, tags, and an \`access\` field per connection describing what the current access config lets you run there:
+
+| \`access\` | Meaning |
+|----------|---------|
+| \`{"policy": "full"}\` | Every action on the connection |
+| \`{"policy": "methods", "methods": ["GET"]}\` | Only actions with these HTTP methods will execute |
+| \`{"policy": "actions", "actions": [{"actionId", "title", "method"}]}\` | Only these exact actions \u2014 use them directly, skip \`actions search\` |
+
+Also present when relevant: \`knowledgeOnly: true\` (execution disabled \u2014 read knowledge and write code instead), \`unresolvedActionIds\` (allowlisted ids that could not be looked up), and \`accessHint\` (a one-line summary of the restriction).
+
+Read \`access\` before planning \u2014 it prevents proposing an action the config will reject. Change it with \`one config\`.
 
 ### 1b. Delete a Connection
 
@@ -11456,7 +11573,7 @@ program.name("one").option("--agent", "Machine-readable JSON output (no colors,
     one whoami                            Show current user, organization, and project
 
   Workflow (use these in order):
-    1. one list                           List your connected platforms and connection keys
+    1. one list                           List connected platforms, keys, and your access on each
     2. one actions search <platform> <q>  Search for actions using natural language
     3. one actions knowledge <plat> <id>  Get full docs for an action (ALWAYS do this before execute)
     4. one actions execute <p> <id> <key> Execute the action
@@ -11714,7 +11831,7 @@ var connection = program.command("connection").description("Manage connections")
 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) => {
+connection.command("list").alias("ls").description("List your connections and what your access config lets you run on each").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);
 });
 connection.command("delete <connection-key>").alias("rm").description("Delete a connection").option("-f, --force", "Skip confirmation prompt").action(async (connectionKey, options) => {

package/package.json

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

package/skills/one/SKILL.md

@@ -45,7 +45,21 @@ Always follow this sequence when the user wants to do something on a connected p
 one --agent connection list
 ```
 
-Returns connected platforms with their connection keys (needed for execution) and platform names in kebab-case (needed for searching).
+Returns connected platforms with their connection keys (needed for execution), platform names in kebab-case (needed for searching), and an `access` field per connection telling you what you may run there.
+
+**Read `access` before you plan a workflow** — it saves you from discovering a restriction as a 403 halfway through:
+
+| `access` | What it means |
+|----------|---------------|
+| `{"policy": "full"}` | Every action on this connection is available |
+| `{"policy": "methods", "methods": ["GET"]}` | Only actions with these HTTP methods will execute — don't propose writes |
+| `{"policy": "actions", "actions": [...]}` | Only these exact actions may run. Each has `actionId`, `title`, `method` — **use them directly and skip `actions search`** |
+
+Two more fields appear only when relevant:
+- `"knowledgeOnly": true` — `actions execute` is disabled. Read knowledge and write integration code instead of executing.
+- `"unresolvedActionIds": [...]` — allowlisted ids that couldn't be looked up; treat them as unavailable and tell the user.
+
+An empty `actions` array means the allowlist grants nothing on that connection — say so rather than searching for alternatives.
 
 ### 1b. Delete a connection