@agent-native/core 0.152.1 → 0.153.1

package/corpus/templates/dispatch/.agents/skills/turn-into-app/references/spreadsheet-source.md

@@ -0,0 +1,148 @@
+# Spreadsheet source review
+
+Use this reference after a workbook upload or Google Sheets link is supplied to
+`/turn-into-app`. It defines the bounded review contract before app creation.
+
+## 1. Establish the source boundary
+
+Record the source before interpreting it:
+
+| Field        | Record                                                                            |
+| ------------ | --------------------------------------------------------------------------------- |
+| Source kind  | `xlsx`, `xls`, `csv`, or Google Sheets URL                                        |
+| Provenance   | Original file name or spreadsheet ID and URL; never credentials or workbook bytes |
+| Access       | Upload preview, authenticated provider read, or unavailable                       |
+| Coverage     | Worksheet names, selected range(s), row/column bounds, and sample counts          |
+| Completeness | Complete within the requested bound, partial, truncated, unreadable, or empty     |
+| Refresh      | One-time snapshot or live refreshable source                                      |
+
+For an uploaded XLS/XLSX file, the framework preview contains worksheet names,
+dimensions, and representative displayed values within bounds. It does not
+currently preserve cell fills or font colors in that text preview. Treat the
+original workbook as the formatting authority only when a tool actually returns
+cell formatting metadata. Never describe a text-only upload as style-verified.
+
+For a Google Sheets URL:
+
+1. Parse the spreadsheet ID and preserve the original URL as provenance.
+2. Use the authenticated `google_drive` provider path. Inspect
+   `provider-api-catalog` first, use `provider-api-docs` if the endpoint or
+   fields are uncertain, and then call `provider-api-request`.
+3. Read spreadsheet metadata and only bounded worksheet/range data. Request
+   formatting metadata when the I/O decision depends on colors, including
+   `userEnteredFormat.backgroundColor` and
+   `userEnteredFormat.textFormat.foregroundColor` where the provider supports
+   it. Do not use a public export URL to bypass access.
+4. Preserve the spreadsheet ID, worksheet title, A1 range, account/connection
+   choice without secrets, row limits, and refresh behavior in the brief.
+
+Keep provider responses bounded. For large sheets, stage or save the response
+and reduce it with the available dataset/code tools. A failed page, truncated
+response, or unavailable connection is not an empty sheet.
+
+## 2. Infer cells and ranges, then show the evidence
+
+Classify source material into three separate buckets. Include representative
+cell addresses or ranges and the evidence behind each classification.
+
+| Bucket             | Default signal                                                                                                     | App treatment                                                          |
+| ------------------ | ------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------- |
+| Inputs             | Yellow cell background, editable assumptions, user-entered constants, or labels such as `assumption` / `driver`    | Editable controls or bounded source parameters                         |
+| Outputs            | Blue text, formula-derived result cells, summary blocks, or labels such as `forecast` / `recommendation`           | Read-only results, charts, recommendations, exports, or review actions |
+| Static historicals | Black text used intentionally for prior-period/source records, raw rows, or labels such as `actual` / `historical` | Read-only context; never turn into editable inputs by default          |
+
+These are conventions, not permission to guess. A default black font with no
+explicit style metadata is not enough to label a range as historical. Resolve
+conflicts using labels, formulas, neighboring headers, repeated patterns, and
+the user's stated goal. If the evidence still conflicts, lower confidence and
+ask the user to confirm the proposed mapping.
+
+Keep source cells and app behavior distinct:
+
+- `Source inputs` are the workbook cells or ranges the user is expected to
+  change or refresh.
+- `Source outputs` are the workbook cells or ranges the source already derives
+  or presents.
+- `Static historicals` are context the app may filter, compare, or summarize,
+  but should not edit.
+- `App outputs` are the new app's visible results, saved records, exports,
+  alerts, or downstream handoffs. Do not invent these until the repeatable job
+  or user confirmation makes them clear.
+
+## 3. Offer candidate apps, not a tab dump
+
+Group related worksheets into candidate repeatable jobs. A candidate should
+have a recognizable user, trigger, inputs, transformation or judgment, and
+outputs. Utility tabs such as lookups, raw imports, instructions, pivots, and
+calculation helpers can support a candidate without becoming destinations.
+
+Present a compact Q&A review with multi-select options. In generated app code,
+use `askUserQuestion` from `@agent-native/core/client/agent-chat` with
+`allowMultiple: true`, stable candidate IDs as option values, and
+`allowFreeText: true` for corrections. It renders inline in the agent panel;
+do not build a custom modal. Each option should fit in a scannable row or
+choice card:
+
+```text
+Candidate: Pipeline forecast
+Uses: Assumptions, Historical Pipeline, Forecast
+Inputs: yellow assumptions in Assumptions!B4:B12 (high confidence)
+Outputs: blue forecast summary in Forecast!B3:H10 (medium confidence)
+Historical context: Historical Pipeline!A1:K500
+Question: Confirm that forecast assumptions should be editable?
+```
+
+Mark the strongest recommendation with `recommended: true`, but do not silently
+select it. Let the user select none, one, or several candidates, correct a
+proposed tab/range, or answer the unresolved question. Keep each question to
+2-4 grouped candidate jobs; for a larger workbook, group related tabs into
+jobs rather than showing a tab dump or asking a separate question for every
+worksheet. If there is only one high-confidence candidate, keep the review
+compact and ask for confirmation only when the I/O mapping or source access is
+unclear.
+
+When several candidates are selected, pass a stable candidate ID, display name,
+source worksheet/ranges, I/O mapping, confidence, and confirmation status for
+each. The generated app should expose them as separate named left-navigation
+destinations or tabs, not merge them into an opaque dashboard and not create a
+separate workspace app for every worksheet.
+
+## 4. Confirm before building or publishing
+
+The confirmation view is a source-integrity checkpoint, not a product-design
+questionnaire. Show:
+
+- the source file or spreadsheet ID and snapshot/live choice;
+- selected candidate destinations and their source tabs/ranges;
+- editable inputs, read-only outputs, and static historical context;
+- the evidence and confidence for each mapping;
+- truncation, unreadable, missing-connection, and refresh limitations;
+- the app outputs/actions that will be created.
+
+Use clear actions such as `Confirm and build`, `Edit mapping`, and `Use a
+different source`. If the host has a structured question or multi-select UI,
+use it. Otherwise, ask one concise assistant message that presents the same
+options and requires an explicit confirmation/correction before handoff.
+
+After confirmation, the online host may call
+`start-workspace-app-creation`; the Builder run itself remains autonomous and
+must record any remaining non-blocking assumptions. In a local generated app,
+persist the confirmation state in SQL/application state and keep the user on
+the review surface while the agent builds. Never claim a full import, live
+refresh, or output write until the corresponding source/action has succeeded.
+
+## 5. Failure and recovery states
+
+Keep these states distinct in the review and in the handoff:
+
+- `unreadable` - parser/provider could not read the source;
+- `partial` - only some worksheets, ranges, rows, or pages were read;
+- `truncated` - the bounded preview ended before full coverage;
+- `empty` - the requested readable range contains no values;
+- `not-connected` - authenticated Google access is required but unavailable;
+- `confirmed` - the user approved the candidate and I/O mapping.
+
+For unreadable or not-connected sources, request a CSV/XLSX export or the
+required connection. For partial or truncated sources, continue only with a
+clearly bounded snapshot or ask for a narrower range. Do not coerce any of
+these states into a successful empty source.

package/corpus/templates/dispatch/.agents/skills/workspace-conventions/SKILL.md

@@ -0,0 +1,93 @@
+---
+name: workspace-conventions
+description: >-
+  Shared conventions for a multi-app Agent Native workspace: finding
+  version-matched framework docs and source, shared vs app-owned code, file and
+  blob storage, env and secrets, agent scratch files, and Dispatch Resources.
+  Use when working across workspace apps, storing files or credentials, or
+  looking up framework APIs.
+scope: dev
+---
+
+# Workspace Conventions
+
+The long-form detail behind the workspace `AGENTS.md` core rules. Read this
+before adding shared code, storing files or secrets, creating workspace
+resources, or looking up framework APIs.
+
+## Framework Docs Lookup
+
+Read `agent-native-docs` for the lookup workflow (`framework-search` first, then
+the focused `docs-search` / `source-search` readers, and the `rg` fallback).
+
+The workspace-specific slugs it does not list are `workspace` and
+`multi-app-workspace`. Feature flags and other specialized workflows are
+optional; read their skill only when the app uses them. Use package docs for framework APIs,
+the package corpus for reusable framework/template patterns, and this
+`AGENTS.md` plus `.agents/skills/` for workspace-specific conventions.
+
+Before building common workspace or agent UI, read `agent-native-toolkit` to
+inventory existing public kits and installed package seams. Read
+`customizing-agent-native` before adapting shared UI. Use the supported
+ladder: configure → compose → eject the smallest unit → propose a shared seam.
+Preview before `--apply`, commit `agent-native.ejections.json`, and never edit
+`node_modules` or eject protected runtime contracts.
+
+## Shared Conventions
+
+- All AI/LLM behavior goes through the app's agent chat. UI and server code
+  must not call model providers, AI SDK `generateText()` / `streamText()`, or
+  other inline LLM APIs directly. Use `sendToAgentChat()` for local app-agent
+  work, including hidden `context` and `submit: false` prefill/review flows.
+  Keep actions deterministic and focused. If a workflow is framed as research,
+  analysis, generation, recommendation, or synthesis, let the agent
+  orchestrate provider/data actions in the open AgentSidebar instead of hiding
+  the work in one opaque action or a separate follow-up textbox.
+  Only use `useAgentChatContext`, `setAgentChatContextItem`,
+  `listAgentChatContext`, `removeAgentChatContextItem`, and
+  `clearAgentChatContext` when UI needs two-way sync with staged context chips.
+  Read `.agents/skills/delegate-to-agent/SKILL.md` before building agent-driven
+  UI or "AI" features.
+- Put shared code in `packages/shared` only when multiple apps need it.
+- Keep app-specific screens, actions, state, and skills inside `apps/<app>`.
+- SQL is for structured records, metadata, references, and searchable text. Store
+  large files/blob payloads (base64, `data:` URLs, images, video/audio, PDFs,
+  ZIPs, screenshots, thumbnails, session replay chunks) in configured file/blob
+  storage and persist only URLs, ids, or handles.
+- Store shared runtime configuration in the workspace root `.env`; use
+  `apps/<app>/.env` only for app-specific overrides. Never hardcode API keys,
+  tokens, webhook URLs, signing secrets, private Builder/internal data, customer
+  data, or credential-looking literals in source, docs, prompts, fixtures,
+  application state, action responses, or generated app content. Use
+  secrets/OAuth/runtime configuration and obvious placeholders in examples.
+- Each app deploys its own `/*` page function, and that function ships whatever
+  the app's server bundle depends on — including a dependency only a background
+  job uses. Before an app takes on a heavy runtime (headless browser, ffmpeg,
+  media processing, ML), read `.agents/skills/performance/SKILL.md` §9 and keep
+  that work in a background function or job. A dependency belonging to one app
+  does not belong in `packages/shared`.
+- Prefer framework defaults until the workspace has a real custom rule,
+  component, plugin, action, or skill to share.
+- Keep the Workspace files view for user-authored or user-requested resources.
+  Agents may create hidden `agent_scratch` resources for temporary working
+  notes, scripts, task plans, or intermediate outputs, but should promote them
+  to normal workspace visibility only when the user explicitly asks to keep or
+  manage the file.
+- Runtime-editable global resources can be managed from Dispatch Resources.
+  Use `AGENTS.md` or `instructions/<slug>.md` for always-on guardrails,
+  `skills/<slug>/SKILL.md` for workspace skills, `context/<slug>.md` for
+  personas/positioning/messaging/company facts/brand guidelines, and
+  `agents/<slug>.md` for custom agent profiles. Scope them to All apps when
+  every workspace app should inherit them. All-app resources are inherited at
+  runtime; do not copy or sync them into individual apps.
+
+## Related Skills
+
+- **adding-workspace-apps** — Creating and mounting a new app under `apps/`.
+- **agent-native-docs** — The full docs and source-corpus lookup workflow.
+- **agent-native-toolkit** — Inventory of shared workspace and agent UI.
+- **customizing-agent-native** — The configure → compose → eject ladder.
+- **delegate-to-agent** — Routing every AI feature through the agent chat.
+- **performance** — Load cost, and (§9) cold-start artifact size per app.
+- **secrets** — Registering API keys and service credentials.
+- **storing-data** — Where structured data and large payloads belong.

package/corpus/templates/dispatch/actions/apply-workspace-connection-setup.ts

@@ -1,8 +1,16 @@
 import { defineAction } from "@agent-native/core";
 import { getWorkspaceConnectionProvider } from "@agent-native/core/connections";
+import {
+  credentialKeyMatches,
+  getWorkspaceConnection,
+} from "@agent-native/core/workspace-connections";
 import { z } from "zod";
 
-import upsertWorkspaceConnection from "./upsert-workspace-connection.js";
+import { assertWorkspaceConnectionManager } from "./connection-permissions.js";
+import upsertWorkspaceConnection, {
+  assertWorkspaceConnectionAllowedUserGroups,
+  assertWorkspaceConnectionAllowedUsers,
+} from "./upsert-workspace-connection.js";
 
 const statusSchema = z.enum([
   "connected",
@@ -73,8 +81,24 @@ export default defineAction({
     credentialRefs: z.array(credentialRefSchema).default([]),
     grantMode: z.enum(["all-apps", "selected-apps"]).default("selected-apps"),
     selectedApps: z.array(z.string()).default([]),
+    userGrantMode: z
+      .enum(["all-users", "selected-users"])
+      .optional()
+      .describe(
+        "Whether every workspace member or only selected members may use the connection.",
+      ),
+    selectedUsers: z
+      .array(z.string())
+      .optional()
+      .describe(
+        "Workspace member email addresses allowed to use the connection.",
+      ),
+    selectedUserGroups: z
+      .array(z.string())
+      .optional()
+      .describe("Workspace user group IDs allowed to use the connection."),
   }),
-  run: async (args) => {
+  run: async (args, ctx) => {
     const provider = getWorkspaceConnectionProvider(args.provider);
     if (!provider) {
       throw new Error(
@@ -96,11 +120,15 @@ export default defineAction({
           key,
       };
     });
-    const availableRefs = new Set(credentialRefs.map((ref) => ref.key));
     const missingRequiredRefs = provider.credentialKeys
       .filter((credential) => credential.required)
       .map((credential) => credential.key)
-      .filter((key) => !availableRefs.has(key));
+      .filter(
+        (key) =>
+          !credentialRefs.some((ref) =>
+            credentialKeyMatches(provider.id, key, ref.key),
+          ),
+      );
 
     if (missingRequiredRefs.length > 0) {
       throw new Error(
@@ -112,20 +140,74 @@ export default defineAction({
 
     const allowedApps =
       args.grantMode === "all-apps" ? [] : uniqueStrings(args.selectedApps);
+    await assertWorkspaceConnectionManager(ctx, allowedApps);
     if (args.grantMode === "selected-apps" && allowedApps.length === 0) {
       throw new Error("Choose at least one app or switch access to all apps.");
     }
+    const existingConnection = args.connectionId
+      ? await getWorkspaceConnection(args.connectionId)
+      : null;
+    const userGrantMode =
+      args.userGrantMode ??
+      (existingConnection?.allowedUsers?.length ||
+      existingConnection?.allowedUserGroups?.length
+        ? "selected-users"
+        : "all-users");
+    const allowedUsers =
+      userGrantMode === "all-users"
+        ? []
+        : uniqueStrings(
+            args.selectedUsers ?? existingConnection?.allowedUsers ?? [],
+          );
+    const allowedUserGroups =
+      userGrantMode === "all-users"
+        ? []
+        : Array.from(
+            new Set(
+              (
+                args.selectedUserGroups ??
+                existingConnection?.allowedUserGroups ??
+                []
+              )
+                .map((groupId) => groupId.trim())
+                .filter(Boolean),
+            ),
+          );
+    if (
+      userGrantMode === "selected-users" &&
+      allowedUsers.length === 0 &&
+      allowedUserGroups.length === 0
+    ) {
+      throw new Error(
+        "Choose at least one person or group, or switch access to all workspace members.",
+      );
+    }
 
-    return upsertWorkspaceConnection.run({
-      id: args.connectionId,
-      provider: provider.id,
-      label: args.label?.trim() || provider.label,
-      accountId: args.accountId?.trim() || null,
-      accountLabel: args.accountLabel?.trim() || null,
-      status: args.status,
-      scopes: uniqueStrings(args.scopes),
-      credentialRefs,
-      allowedApps,
-    });
+    const validatedAllowedUsers = await assertWorkspaceConnectionAllowedUsers(
+      allowedUsers,
+      ctx?.orgId,
+    );
+    const validatedAllowedUserGroups =
+      await assertWorkspaceConnectionAllowedUserGroups(
+        allowedUserGroups,
+        ctx?.orgId,
+      );
+
+    return upsertWorkspaceConnection.run(
+      {
+        id: args.connectionId,
+        provider: provider.id,
+        label: args.label?.trim() || provider.label,
+        accountId: args.accountId?.trim() || null,
+        accountLabel: args.accountLabel?.trim() || null,
+        status: args.status,
+        scopes: uniqueStrings(args.scopes),
+        credentialRefs,
+        allowedApps,
+        allowedUsers: validatedAllowedUsers,
+        allowedUserGroups: validatedAllowedUserGroups,
+      },
+      ctx,
+    );
   },
 });

package/corpus/templates/dispatch/actions/connection-permissions.ts

@@ -0,0 +1,77 @@
+import type { ActionRunContext } from "@agent-native/core/action";
+import {
+  assertWorkspaceUserGroupManager,
+  type WorkspaceConnection,
+} from "@agent-native/core/workspace-connections";
+
+import { dispatchAccess } from "../server/lib/app-roles.js";
+
+const DISPATCH_APP_ID = "dispatch";
+
+function normalizeAppIds(appIds: string[] | undefined): string[] {
+  return Array.from(
+    new Set(
+      (appIds ?? []).map((appId) => appId.trim().toLowerCase()).filter(Boolean),
+    ),
+  );
+}
+
+export function isDispatchOnlyConnectionScope(
+  allowedApps: string[] | undefined,
+): boolean {
+  const normalized = normalizeAppIds(allowedApps);
+  return normalized.length === 1 && normalized[0] === DISPATCH_APP_ID;
+}
+
+async function isDispatchAppAdmin(
+  ctx: ActionRunContext | undefined,
+): Promise<boolean> {
+  if (ctx?.appId !== DISPATCH_APP_ID || !ctx.userEmail || !ctx.orgId) {
+    return false;
+  }
+  const role = await dispatchAccess.resolve({
+    userEmail: ctx.userEmail,
+    orgId: ctx.orgId,
+  });
+  return role.status === "assigned" && role.role === "admin";
+}
+
+export async function assertWorkspaceConnectionManager(
+  ctx: ActionRunContext | undefined,
+  allowedApps: string[] | undefined,
+): Promise<void> {
+  if (
+    isDispatchOnlyConnectionScope(allowedApps) &&
+    (await isDispatchAppAdmin(ctx))
+  ) {
+    return;
+  }
+  await assertWorkspaceUserGroupManager(ctx?.orgId, ctx?.userEmail);
+}
+
+export async function assertWorkspaceConnectionDeleteManager(
+  ctx: ActionRunContext | undefined,
+  connection: WorkspaceConnection,
+): Promise<void> {
+  await assertWorkspaceConnectionManager(ctx, connection.allowedApps);
+}
+
+export async function assertWorkspaceConnectionGrantManager(
+  ctx: ActionRunContext | undefined,
+  connection: WorkspaceConnection,
+  appId: string | undefined,
+  granted: boolean,
+  accessMode: "all-apps" | "selected-apps" | undefined,
+): Promise<void> {
+  const normalizedAppId = appId?.trim().toLowerCase();
+  const normalizedAllowedApps = normalizeAppIds(connection.allowedApps);
+  const canEditOnlyDispatchGrant =
+    normalizedAppId === DISPATCH_APP_ID &&
+    accessMode !== "all-apps" &&
+    normalizedAllowedApps.includes(DISPATCH_APP_ID) &&
+    (granted || normalizedAllowedApps.length > 1);
+  await assertWorkspaceConnectionManager(
+    ctx,
+    canEditOnlyDispatchGrant ? [DISPATCH_APP_ID] : [],
+  );
+}

package/corpus/templates/dispatch/actions/delete-workspace-connection.ts

@@ -1,13 +1,23 @@
 import { defineAction } from "@agent-native/core";
-import { deleteWorkspaceConnection } from "@agent-native/core/workspace-connections";
+import {
+  deleteWorkspaceConnection,
+  getWorkspaceConnection,
+} from "@agent-native/core/workspace-connections";
 import { z } from "zod";
 
+import { assertWorkspaceConnectionDeleteManager } from "./connection-permissions.js";
+
 export default defineAction({
   description: "Delete a shared workspace integration connection.",
   schema: z.object({
     id: z.string().describe("Workspace connection ID to delete."),
   }),
-  run: async ({ id }) => {
+  run: async ({ id }, ctx) => {
+    const connection = await getWorkspaceConnection(id);
+    if (!connection) {
+      throw new Error(`Workspace connection "${id}" was not found.`);
+    }
+    await assertWorkspaceConnectionDeleteManager(ctx, connection);
     const deleted = await deleteWorkspaceConnection(id);
     if (!deleted) {
       throw new Error(`Workspace connection "${id}" was not found.`);

package/corpus/templates/dispatch/actions/list-workspace-user-groups.ts

@@ -0,0 +1,19 @@
+import { defineAction } from "@agent-native/core";
+import {
+  assertWorkspaceUserGroupManager,
+  listWorkspaceUserGroupsForOrg,
+} from "@agent-native/core/workspace-connections";
+import { z } from "zod";
+
+export default defineAction({
+  description:
+    "List reusable workspace user groups for assigning access to shared integrations.",
+  schema: z.object({}),
+  http: { method: "GET" },
+  readOnly: true,
+  run: async (_args, ctx) => {
+    await assertWorkspaceUserGroupManager(ctx?.orgId, ctx?.userEmail);
+    if (!ctx?.orgId) return [];
+    return listWorkspaceUserGroupsForOrg(ctx.orgId);
+  },
+});

package/corpus/templates/dispatch/actions/plan-workspace-connection-setup.ts

@@ -1,6 +1,7 @@
 import { defineAction } from "@agent-native/core";
 import { getWorkspaceConnectionProvider } from "@agent-native/core/connections";
 import {
+  credentialKeyMatches,
   getWorkspaceConnection,
   listWorkspaceConnectionGrants,
   summarizeWorkspaceConnectionProviderReadiness,
@@ -90,11 +91,15 @@ export default defineAction({
     }
 
     const existingRefs = connection?.credentialRefs ?? [];
-    const existingRefKeys = new Set(existingRefs.map((ref) => ref.key));
     const missingRequiredRefs = provider.credentialKeys
       .filter((credential) => credential.required)
       .map((credential) => credential.key)
-      .filter((key) => !existingRefKeys.has(key));
+      .filter(
+        (key) =>
+          !existingRefs.some((ref) =>
+            credentialKeyMatches(provider.id, key, ref.key),
+          ),
+      );
     const recommendedAppIds = uniqueStrings([
       "dispatch",
       ...provider.recommendedTemplateUses,
@@ -186,6 +191,8 @@ export default defineAction({
             status: connection.status,
             scopes: connection.scopes,
             allowedApps: connection.allowedApps,
+            allowedUsers: connection.allowedUsers ?? [],
+            allowedUserGroups: connection.allowedUserGroups ?? [],
             credentialRefs: existingRefs.map((ref) => ({
               key: ref.key,
               label: ref.label,

package/corpus/templates/dispatch/actions/set-workspace-connection-grant.ts

@@ -7,6 +7,8 @@ import {
 } from "@agent-native/core/workspace-connections";
 import { z } from "zod";
 
+import { assertWorkspaceConnectionGrantManager } from "./connection-permissions.js";
+
 const httpBoolean = z.preprocess((value) => {
   if (typeof value !== "string") return value;
   const normalized = value.trim().toLowerCase();
@@ -54,11 +56,18 @@ export default defineAction({
         "Known workspace app IDs. Used when converting an all-app connection into selected-app grants.",
       ),
   }),
-  run: async (args) => {
+  run: async (args, ctx) => {
     const connection = await getWorkspaceConnection(args.connectionId);
     if (!connection) {
       throw new Error(`Workspace connection "${args.connectionId}" not found.`);
     }
+    await assertWorkspaceConnectionGrantManager(
+      ctx,
+      connection,
+      args.appId,
+      args.granted,
+      args.accessMode,
+    );
 
     let allowedApps = connection.allowedApps;
     if (args.accessMode === "all-apps") {
@@ -77,8 +86,16 @@ export default defineAction({
 
       if (connection.allowedApps.length === 0 && !args.granted) {
         allowedApps = knownAppIds.filter((id) => id !== appId);
+      } else if (connection.allowedApps.length === 0 && args.granted) {
+        allowedApps = [appId];
       } else if (connection.allowedApps.length > 0 && !args.granted) {
-        allowedApps = connection.allowedApps.filter((id) => id !== appId);
+        const nextAllowedApps = connection.allowedApps.filter(
+          (id) => id !== appId,
+        );
+        allowedApps =
+          nextAllowedApps.length > 0
+            ? nextAllowedApps
+            : knownAppIds.filter((id) => id !== appId);
         await revokeWorkspaceConnectionGrant(connection.id, appId);
       } else if (connection.allowedApps.length > 0 && args.granted) {
         allowedApps = connection.allowedApps;
@@ -99,6 +116,8 @@ export default defineAction({
       scopes: connection.scopes,
       config: connection.config,
       allowedApps,
+      allowedUsers: connection.allowedUsers ?? [],
+      allowedUserGroups: connection.allowedUserGroups ?? [],
       credentialRefs: connection.credentialRefs,
       lastCheckedAt: connection.lastCheckedAt,
       lastError: connection.lastError,