@agent-native/dispatch 0.6.1 → 0.8.0

package/src/actions/list-workspace-resources.ts

@@ -4,7 +4,7 @@ import { listWorkspaceResources } from "../server/lib/workspace-resources-store.
 
 export default defineAction({
   description:
-    "List all workspace-wide resources (skills, instructions, agents, and knowledge packs) that can be shared across apps.",
+    "List all workspace-wide resources (skills, instructions, agent profiles, and reference resources) that apps inherit at runtime.",
   schema: z.object({
     kind: z
       .enum(["skill", "instruction", "agent", "knowledge"])

package/src/actions/navigate.ts

@@ -5,6 +5,7 @@
  *
  * Usage:
  *   pnpm action navigate --view=overview
+ *   pnpm action navigate --view=dreams
  *   pnpm action navigate --view=<custom-dispatch-extension-id>
  *   pnpm action navigate --path=/some/route
  *
@@ -25,7 +26,7 @@ export default defineAction({
       .string()
       .optional()
       .describe(
-        "Named dispatch view to navigate to. Built-in views include overview, apps, metrics, new-app, vault, integrations, messaging, workspace, agents, destinations, identities, approvals, audit, thread-debug, and team. Generated Dispatch extension tabs can also use their nav item id.",
+        "Named dispatch view to navigate to. Built-in views include overview, apps, metrics, new-app, vault, integrations, messaging, workspace, agents, destinations, identities, approvals, audit, thread-debug, dreams, and team. Generated Dispatch extension tabs can also use their nav item id.",
       ),
     path: z.string().optional().describe("URL path to navigate to"),
   }),

package/src/actions/preview-dream-proposal.ts

@@ -0,0 +1,14 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { previewDreamProposal } from "../server/lib/dreams-store.js";
+
+export default defineAction({
+  description:
+    "Preview one Dispatch dream proposal before applying it, including target, current content, proposed content, and approval behavior.",
+  schema: z.object({
+    id: z.string().min(1).describe("Dream proposal id."),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  run: async ({ id }) => previewDreamProposal(id),
+});

package/src/actions/preview-workspace-resource-change.ts

@@ -0,0 +1,25 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { previewWorkspaceResourceChange } from "../server/lib/workspace-resources-store.js";
+
+export default defineAction({
+  description:
+    "Preview the impact of creating, updating, or deleting a workspace resource, including All-app reach, overrides, and whether Dispatch approval will be requested.",
+  schema: z.object({
+    operation: z
+      .enum(["create", "update", "delete"])
+      .optional()
+      .describe("Change operation to preview."),
+    resourceId: z.string().optional().describe("Existing resource id."),
+    path: z
+      .string()
+      .optional()
+      .describe("Resource path, such as context/brand.md."),
+    scope: z
+      .enum(["all", "selected"])
+      .optional()
+      .describe("Resulting resource scope after the change."),
+  }),
+  http: { method: "GET" },
+  run: async (args) => previewWorkspaceResourceChange(args),
+});

package/src/actions/reject-dream-proposal.ts

@@ -0,0 +1,12 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { rejectDreamProposal } from "../server/lib/dreams-store.js";
+
+export default defineAction({
+  description: "Reject one pending Dispatch dream proposal.",
+  schema: z.object({
+    id: z.string().min(1).describe("Dream proposal id."),
+    reason: z.string().optional().describe("Optional rejection reason."),
+  }),
+  run: async ({ id, reason }) => rejectDreamProposal(id, reason),
+});

package/src/actions/restore-starter-workspace-resources.ts

@@ -0,0 +1,17 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { restoreStarterWorkspaceResources } from "../server/lib/workspace-resources-store.js";
+
+export default defineAction({
+  description:
+    "Restore missing starter global workspace resources such as company, brand, messaging, guardrails, and company voice. Existing resources are left unchanged.",
+  schema: z.object({
+    paths: z
+      .array(z.string())
+      .optional()
+      .describe(
+        "Optional starter resource paths to restore. Omit to restore every missing starter resource.",
+      ),
+  }),
+  run: async (args) => restoreStarterWorkspaceResources(args),
+});

package/src/actions/send-code-agent-remote-command.ts

@@ -0,0 +1,59 @@
+import { defineAction } from "@agent-native/core";
+import { getRequestUserEmail } from "@agent-native/core/server";
+import { z } from "zod";
+import {
+  enqueueRemoteCodeCommand,
+  type RemoteCodeCommandEnvelope,
+} from "../server/lib/dispatch-remote-commands.js";
+
+const commandSchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("create"), prompt: z.string().min(1) }),
+  z.object({ type: z.literal("list") }),
+  z.object({ type: z.literal("status"), runRef: z.string().optional() }),
+  z.object({
+    type: z.literal("continue"),
+    runRef: z.string().min(1),
+    text: z.string().min(1),
+  }),
+  z.object({ type: z.literal("approve"), approvalId: z.string().min(1) }),
+  z.object({ type: z.literal("deny"), approvalId: z.string().min(1) }),
+  z.object({ type: z.literal("stop"), runRef: z.string().min(1) }),
+]);
+
+export default defineAction({
+  description:
+    "Route a command to the remote Agent-Native Code host through the integration relay.",
+  schema: z.object({
+    command: commandSchema,
+    source: z
+      .object({
+        platform: z.string().default("dispatch"),
+        externalThreadId: z.string().default("dispatch"),
+        senderId: z.string().optional(),
+        senderName: z.string().optional(),
+        messageId: z.string().optional(),
+        timestamp: z.number().optional(),
+      })
+      .optional(),
+  }),
+  run: async ({ command, source }) => {
+    const ownerEmail = getRequestUserEmail();
+    if (!ownerEmail) throw new Error("no authenticated user");
+
+    const envelope: RemoteCodeCommandEnvelope = {
+      kind: "code-agent",
+      ownerEmail,
+      command,
+      source: {
+        platform: source?.platform || "dispatch",
+        externalThreadId: source?.externalThreadId || "dispatch",
+        senderId: source?.senderId,
+        senderName: source?.senderName,
+        messageId: source?.messageId,
+        timestamp: source?.timestamp ?? Date.now(),
+      },
+    };
+
+    return enqueueRemoteCodeCommand(envelope);
+  },
+});

package/src/actions/set-dream-settings.spec.ts

@@ -0,0 +1,81 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  setDreamSettings: vi.fn(),
+}));
+
+vi.mock("../server/lib/dreams-store.js", () => ({
+  setDreamSettings: mocks.setDreamSettings,
+}));
+
+import action from "./set-dream-settings.js";
+
+describe("set-dream-settings action", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.setDreamSettings.mockImplementation(async (input) => ({
+      enabled: false,
+      schedule: "0 9 * * 1",
+      sourceId: "all",
+      sourceIds: [],
+      allSources: true,
+      query: null,
+      limit: 8,
+      sourceTimeoutMs: 30000,
+      sourceConcurrency: 2,
+      sourceStartStaggerMs: 250,
+      threadConcurrency: 3,
+      threadTimeoutMs: 8000,
+      minCandidateCount: 1,
+      ...input,
+    }));
+  });
+
+  it("coerces numeric fields and preserves explicit clears", async () => {
+    await action.run({
+      enabled: true,
+      schedule: "0 8 * * 2",
+      sourceId: "current",
+      sourceIds: [],
+      allSources: false,
+      query: "",
+      limit: "50",
+      sourceTimeoutMs: "60000",
+      sourceConcurrency: "8",
+      sourceStartStaggerMs: "5000",
+      threadConcurrency: "10",
+      threadTimeoutMs: "30000",
+      minCandidateCount: "0",
+    } as any);
+
+    expect(mocks.setDreamSettings).toHaveBeenCalledWith({
+      enabled: true,
+      schedule: "0 8 * * 2",
+      sourceId: "current",
+      sourceIds: [],
+      allSources: false,
+      query: "",
+      limit: 50,
+      sourceTimeoutMs: 60000,
+      sourceConcurrency: 8,
+      sourceStartStaggerMs: 5000,
+      threadConcurrency: 10,
+      threadTimeoutMs: 30000,
+      minCandidateCount: 0,
+    });
+  });
+
+  it("rejects out-of-range numeric settings before writing", async () => {
+    await expect(action.run({ limit: "0" } as any)).rejects.toThrow(
+      /Invalid action parameters/,
+    );
+    await expect(
+      action.run({ sourceTimeoutMs: "60001" } as any),
+    ).rejects.toThrow(/Invalid action parameters/);
+    await expect(
+      action.run({ threadTimeoutMs: "30001" } as any),
+    ).rejects.toThrow(/Invalid action parameters/);
+
+    expect(mocks.setDreamSettings).not.toHaveBeenCalled();
+  });
+});

package/src/actions/set-dream-settings.ts

@@ -0,0 +1,44 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { setDreamSettings } from "../server/lib/dreams-store.js";
+
+export default defineAction({
+  description:
+    "Update recurring Dispatch dream settings without immediately running or applying a dream pass.",
+  schema: z.object({
+    enabled: z
+      .boolean()
+      .optional()
+      .describe("Whether recurring dreams are on."),
+    schedule: z
+      .string()
+      .optional()
+      .describe('Five-field cron schedule, for example "0 9 * * 1".'),
+    sourceId: z
+      .string()
+      .optional()
+      .describe(
+        "Thread debug source id. Use 'all' for every connected source.",
+      ),
+    sourceIds: z
+      .array(z.string().min(1))
+      .optional()
+      .describe("Optional explicit source ids to scan together."),
+    allSources: z.coerce
+      .boolean()
+      .optional()
+      .describe("Scan every connected thread-debug source."),
+    query: z
+      .string()
+      .optional()
+      .describe("Optional search term for recurring dream passes."),
+    limit: z.coerce.number().int().min(1).max(50).optional(),
+    sourceTimeoutMs: z.coerce.number().int().min(1000).max(60000).optional(),
+    sourceConcurrency: z.coerce.number().int().min(1).max(8).optional(),
+    sourceStartStaggerMs: z.coerce.number().int().min(0).max(5000).optional(),
+    threadConcurrency: z.coerce.number().int().min(1).max(10).optional(),
+    threadTimeoutMs: z.coerce.number().int().min(1000).max(30000).optional(),
+    minCandidateCount: z.coerce.number().int().min(0).max(50).optional(),
+  }),
+  run: async (input) => setDreamSettings(input),
+});

package/src/actions/set-vault-access-settings.ts

@@ -0,0 +1,16 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+import { setVaultAccessSettings } from "../server/lib/vault-store.js";
+
+export default defineAction({
+  description:
+    "Set the Dispatch vault access mode. Use all-apps for the default workspace-wide mode or manual to require explicit per-app grants.",
+  schema: z.object({
+    mode: z
+      .enum(["all-apps", "manual"])
+      .describe(
+        "all-apps shares every vault key with every app; manual requires grants",
+      ),
+  }),
+  run: async (args) => setVaultAccessSettings(args),
+});

package/src/actions/start-workspace-app-creation.ts

@@ -23,6 +23,14 @@ export default defineAction({
       .optional()
       .nullable()
       .describe("Template to start from"),
+    description: z
+      .string()
+      .max(500)
+      .optional()
+      .nullable()
+      .describe(
+        "Concise AI-generated description of the app based on the user's prompt. Dispatch saves this while the app is being created.",
+      ),
     secretIds: z
       .array(z.string())
       .max(100)

package/src/actions/sync-vault-to-app.ts

@@ -4,7 +4,7 @@ import { syncGrantsToApp } from "../server/lib/vault-store.js";
 
 export default defineAction({
   description:
-    "Push all granted secrets to an app by calling its env-vars endpoint. Returns the list of synced credential keys.",
+    "Push vault secrets to an app by calling its env-vars endpoint. In all-apps mode this syncs every vault key; in manual mode it syncs active grants.",
   schema: z.object({
     appId: z
       .string()

package/src/actions/update-workspace-app-metadata.ts

@@ -0,0 +1,32 @@
+import { defineAction } from "@agent-native/core";
+import { getWorkspaceAppIdValidationError } from "@agent-native/core/shared";
+import { z } from "zod";
+import { updateWorkspaceAppMetadata } from "../server/lib/app-creation-store.js";
+
+export default defineAction({
+  description:
+    "Update the human-editable display name and description Dispatch uses for a workspace app. These details are also used as connected-agent/A2A context.",
+  schema: z.object({
+    appId: z
+      .string()
+      .max(64)
+      .refine((appId) => !getWorkspaceAppIdValidationError(appId), {
+        message:
+          "Use a non-reserved app id with lowercase letters, numbers, and hyphens.",
+      })
+      .describe("Workspace app id, matching the apps/<id> folder"),
+    name: z
+      .string()
+      .max(120)
+      .optional()
+      .nullable()
+      .describe("Human-readable app name"),
+    description: z
+      .string()
+      .max(500)
+      .optional()
+      .nullable()
+      .describe("Human-readable app description"),
+  }),
+  run: async (args) => updateWorkspaceAppMetadata(args),
+});

package/src/actions/update-workspace-resource.ts

@@ -4,7 +4,7 @@ import { updateWorkspaceResource } from "../server/lib/workspace-resources-store
 
 export default defineAction({
   description:
-    "Update a workspace resource's name, description, content, or scope.",
+    "Update a workspace resource's name, description, content, or scope. When Dispatch approval policy is enabled, changes that affect All-app resources queue an approval request before taking effect.",
   schema: z.object({
     id: z.string().describe("Resource ID"),
     name: z.string().optional().describe("New name"),

package/src/actions/view-screen.ts

@@ -16,16 +16,40 @@ import {
   listSecrets,
   listGrants,
   listRequests,
+  getVaultAccessSettings,
 } from "../server/lib/vault-store.js";
 import { listWorkspaceApps } from "../server/lib/app-creation-store.js";
 import { listDispatchUsageMetrics } from "../server/lib/usage-metrics-store.js";
-import { listWorkspaceResourceOptions } from "../server/lib/workspace-resources-store.js";
+import {
+  listWorkspaceResourceOptions,
+  listWorkspaceResourcesForApp,
+} from "../server/lib/workspace-resources-store.js";
 import {
   getAgentThreadDebug,
   listThreadDebugSources,
   searchAgentThreads,
 } from "../server/lib/thread-debug-store.js";
 
+async function runLocalDispatchAction(
+  name: string,
+  args: Record<string, unknown>,
+) {
+  const modulePath = `./${name}.js`;
+  const module = (await import(/* @vite-ignore */ modulePath)) as {
+    default?: {
+      run: (args: Record<string, unknown>) => unknown | Promise<unknown>;
+    };
+  };
+  if (!module.default) throw new Error(`Dispatch action not found: ${name}`);
+  return module.default.run(stripUndefined(args));
+}
+
+function stripUndefined(args: Record<string, unknown>) {
+  return Object.fromEntries(
+    Object.entries(args).filter(([, value]) => value !== undefined),
+  );
+}
+
 export default defineAction({
   description:
     "See what the user is currently looking at in the dispatch UI, including navigation state and a compact operational summary.",
@@ -56,9 +80,32 @@ export default defineAction({
       navigation?.view === "apps" ||
       navigation?.view === "new-app"
     ) {
-      screen.workspaceApps = await listWorkspaceApps({
+      const workspaceApps = await listWorkspaceApps({
         includeAgentCards: true,
       });
+      screen.workspaceApps = workspaceApps;
+      if (navigation?.view === "apps") {
+        screen.workspaceAppResources = await Promise.all(
+          workspaceApps
+            .filter((app) => !app.isDispatch)
+            .slice(0, 12)
+            .map(async (app) => {
+              const result = await listWorkspaceResourcesForApp(app.id);
+              return {
+                appId: app.id,
+                appName: app.name,
+                counts: result.counts,
+                resources: result.resources.map((resource) => ({
+                  name: resource.name,
+                  path: resource.path,
+                  kind: resource.kind,
+                  source: resource.source,
+                  autoLoaded: resource.autoLoaded,
+                })),
+              };
+            }),
+        );
+      }
     }
     if (navigation?.view === "metrics") {
       try {
@@ -78,11 +125,13 @@ export default defineAction({
       }
     }
     if (navigation?.view === "vault" || navigation?.view === "new-app") {
-      const [secrets, grants, requests] = await Promise.all([
+      const [secrets, grants, requests, access] = await Promise.all([
         listSecrets(),
         listGrants(),
         listRequests({ status: "pending" }),
+        getVaultAccessSettings(),
       ]);
+      screen.vaultAccessMode = access.mode;
       screen.vaultSecrets = secrets.map((s) => ({
         id: s.id,
         name: s.name,
@@ -96,6 +145,16 @@ export default defineAction({
     }
     if (navigation?.view === "workspace" || navigation?.view === "new-app") {
       screen.workspaceResources = await listWorkspaceResourceOptions();
+      screen.workspaceResourceEffectiveContext = {
+        action: "get-workspace-resource-effective-context",
+        description:
+          "Preview workspace -> organization/app -> personal precedence for a resource path and optional app/user. All-app resources are inherited at runtime; selected resources are app-specific exceptions.",
+      };
+      screen.workspaceResourceImpactPreview = {
+        action: "preview-workspace-resource-change",
+        description:
+          "Preview All-app reach, overrides, and approval behavior before creating, updating, or deleting a workspace resource.",
+      };
     }
     if (navigation?.view === "thread-debug") {
       try {
@@ -133,6 +192,38 @@ export default defineAction({
           error instanceof Error ? error.message : String(error);
       }
     }
+    if (navigation?.view === "dreams") {
+      try {
+        const nav = navigation as Record<string, any>;
+        const [sources, candidates, dreams, settings] = await Promise.all([
+          listThreadDebugSources(),
+          runLocalDispatchAction("list-dream-candidates", {
+            sourceId: nav.sourceId,
+            ownerEmail: nav.ownerEmail,
+            limit: 10,
+          }),
+          runLocalDispatchAction("list-dreams", {
+            status: nav.status,
+            limit: 10,
+          }),
+          runLocalDispatchAction("get-dream-settings", {}),
+        ]);
+        screen.dreamSources = sources;
+        screen.dreamCandidates = candidates;
+        screen.latestDreams = dreams;
+        screen.dreamSettings = settings;
+
+        const dreamId = nav.dreamId ?? nav.id;
+        if (dreamId) {
+          screen.dreamDetail = await runLocalDispatchAction("get-dream", {
+            id: dreamId,
+          });
+        }
+      } catch (error) {
+        screen.dreamsError =
+          error instanceof Error ? error.message : String(error);
+      }
+    }
 
     if (Object.keys(screen).length === 0) {
       return "No application state found. Is the app running?";

package/src/components/app-keys-popover.tsx

@@ -89,6 +89,12 @@ function AppKeysPanel({ appId, appName }: { appId: string; appName: string }) {
     isLoading: grantsLoading,
     refetch: refetchGrants,
   } = useActionQuery("list-vault-grants", { appId });
+  const { data: accessSettings, isLoading: accessLoading } = useActionQuery(
+    "get-vault-access-settings",
+    {},
+  );
+  const accessMode =
+    (accessSettings as any)?.mode === "manual" ? "manual" : "all-apps";
 
   const grantBySecretId = useMemo(() => {
     const map = new Map<string, VaultGrant>();
@@ -135,11 +141,13 @@ function AppKeysPanel({ appId, appName }: { appId: string; appName: string }) {
     onError: (err) => toast.error(`Sync failed: ${String(err)}`),
   });
 
-  const isLoading = secretsLoading || grantsLoading;
+  const isLoading = secretsLoading || grantsLoading || accessLoading;
   const grantedCount = grantBySecretId.size;
   const typedSecrets = secrets as VaultSecret[];
+  const allApps = accessMode !== "manual";
 
   const toggleSecret = (secret: VaultSecret) => {
+    if (allApps) return;
     if (pendingSecretIds.has(secret.id)) return;
     const existing = grantBySecretId.get(secret.id);
     markPending(secret.id, true);
@@ -159,14 +167,20 @@ function AppKeysPanel({ appId, appName }: { appId: string; appName: string }) {
             Keys for {appName}
           </p>
           <p className="text-[11px] text-muted-foreground">
-            {grantedCount} of {typedSecrets.length} granted
+            {allApps
+              ? `${typedSecrets.length} available`
+              : `${grantedCount} of ${typedSecrets.length} granted`}
           </p>
         </div>
         <Button
           type="button"
           variant="outline"
           size="sm"
-          disabled={syncMutation.isPending || grantedCount === 0}
+          disabled={
+            syncMutation.isPending ||
+            typedSecrets.length === 0 ||
+            (!allApps && grantedCount === 0)
+          }
           onClick={() => syncMutation.mutate({ appId })}
           className="h-7 px-2"
         >
@@ -201,17 +215,17 @@ function AppKeysPanel({ appId, appName }: { appId: string; appName: string }) {
           </p>
         ) : (
           typedSecrets.map((secret) => {
-            const granted = grantBySecretId.has(secret.id);
+            const granted = allApps || grantBySecretId.has(secret.id);
             const pending = pendingSecretIds.has(secret.id);
             return (
               <button
                 key={secret.id}
                 type="button"
                 aria-pressed={granted}
-                disabled={pending}
+                disabled={pending || allApps}
                 onClick={() => toggleSecret(secret)}
                 className={`flex w-full items-start gap-3 rounded-md px-2.5 py-2 text-left text-sm disabled:cursor-not-allowed disabled:opacity-60 ${
-                  pending ? "" : "cursor-pointer"
+                  pending || allApps ? "" : "cursor-pointer"
                 } ${
                   granted
                     ? "border border-primary/45 bg-primary/5"
@@ -232,7 +246,9 @@ function AppKeysPanel({ appId, appName }: { appId: string; appName: string }) {
                     {secret.credentialKey}
                   </span>
                   <span className="block truncate text-xs text-muted-foreground/70">
-                    {secret.provider || secret.name || "Vault secret"}
+                    {allApps
+                      ? "Available to this app"
+                      : secret.provider || secret.name || "Vault secret"}
                   </span>
                 </span>
               </button>

package/src/components/approval-value-block.spec.tsx

@@ -0,0 +1,59 @@
+// @vitest-environment happy-dom
+import React, { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  ApprovalValueBlock,
+  approvalValuePreview,
+  parseApprovalValue,
+} from "./approval-value-block";
+
+describe("approval value display", () => {
+  let container: HTMLDivElement;
+  let root: Root;
+
+  beforeEach(() => {
+    vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+    container = document.createElement("div");
+    document.body.appendChild(container);
+    root = createRoot(container);
+  });
+
+  afterEach(() => {
+    act(() => root.unmount());
+    container.remove();
+    vi.unstubAllGlobals();
+  });
+
+  it("parses serialized approval values and preserves plain strings", () => {
+    expect(
+      parseApprovalValue('{"scope":"all","path":"context/brand.md"}'),
+    ).toEqual({
+      scope: "all",
+      path: "context/brand.md",
+    });
+    expect(parseApprovalValue("plain text")).toBe("plain text");
+    expect(parseApprovalValue(null)).toBeNull();
+  });
+
+  it("formats before/after payloads for readable approval review", () => {
+    expect(approvalValuePreview(null)).toBe("None");
+    expect(approvalValuePreview("plain text")).toBe("plain text");
+    expect(approvalValuePreview({ scope: "all" })).toBe(
+      JSON.stringify({ scope: "all" }, null, 2),
+    );
+
+    act(() => {
+      root.render(
+        <ApprovalValueBlock
+          label="After"
+          value={{ path: "context/brand.md", scope: "all" }}
+        />,
+      );
+    });
+
+    expect(container.textContent).toContain("After");
+    expect(container.textContent).toContain('"path": "context/brand.md"');
+    expect(container.textContent).toContain('"scope": "all"');
+  });
+});