@jami-studio/dispatch 0.13.14

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

@@ -0,0 +1,15 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+
+import { syncGrantsToApp } from "../server/lib/vault-store.js";
+
+export default defineAction({
+  description:
+    "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()
+      .describe("App ID to sync secrets to, e.g. mail, calendar, analytics"),
+  }),
+  run: async (args) => syncGrantsToApp(args.appId),
+});

package/src/actions/unarchive-workspace-app.ts

@@ -0,0 +1,17 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+
+import { unarchiveWorkspaceApp } from "../server/lib/app-creation-store.js";
+
+export default defineAction({
+  description:
+    "Restore a previously archived workspace app to the Apps list for the current viewer.",
+  schema: z.object({
+    appId: z
+      .string()
+      .min(1)
+      .max(64)
+      .describe("Workspace app id (matches the apps/<id>/ folder)"),
+  }),
+  run: async (input) => unarchiveWorkspaceApp({ appId: input.appId }),
+});

package/src/actions/update-vault-secret.ts

@@ -0,0 +1,49 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+
+import { updateSecret } from "../server/lib/vault-store.js";
+
+export default defineAction({
+  description:
+    "Update an existing vault secret's label, credential key, value, provider, or description. Admin only.",
+  schema: z
+    .object({
+      id: z.string().min(1).describe("Secret ID"),
+      credentialKey: z
+        .string()
+        .trim()
+        .min(1)
+        .optional()
+        .describe("Environment variable name, e.g. GOOGLE_CLIENT_ID"),
+      value: z.string().min(1).optional().describe("New secret value"),
+      name: z
+        .string()
+        .trim()
+        .min(1)
+        .optional()
+        .describe("Human-readable label for this secret"),
+      provider: z
+        .string()
+        .nullable()
+        .optional()
+        .describe("Provider grouping tag, e.g. google, sendgrid, slack"),
+      description: z
+        .string()
+        .nullable()
+        .optional()
+        .describe("Optional description"),
+    })
+    .refine(
+      ({ credentialKey, value, name, provider, description }) =>
+        credentialKey !== undefined ||
+        value !== undefined ||
+        name !== undefined ||
+        provider !== undefined ||
+        description !== undefined,
+      "At least one secret field must be updated",
+    ),
+  // Carries a secret `value`. Record THAT the secret changed, never the value —
+  // keep the audit trail from becoming a second credential store.
+  audit: { recordInputs: false },
+  run: async (args) => updateSecret(args.id, args),
+});

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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,20 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+
+import { updateWorkspaceResource } from "../server/lib/workspace-resources-store.js";
+
+export default defineAction({
+  description:
+    "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"),
+    description: z.string().optional().describe("New description"),
+    content: z.string().optional().describe("New content"),
+    scope: z.enum(["all", "selected"]).optional().describe("New scope"),
+  }),
+  run: async (args) => {
+    const { id, ...rest } = args;
+    return updateWorkspaceResource(id, rest);
+  },
+});

package/src/actions/upsert-destination.ts

@@ -0,0 +1,30 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+
+import { upsertDestination } from "../server/lib/dispatch-store.js";
+
+export default defineAction({
+  description:
+    "Create or update a saved messaging destination for proactive Slack, Telegram, or email sends.",
+  schema: z.object({
+    id: z.string().optional(),
+    name: z.string().describe("Friendly destination name"),
+    platform: z
+      .enum(["slack", "telegram", "email"])
+      .describe("Destination platform"),
+    destination: z
+      .string()
+      .describe(
+        "Channel ID, chat ID, email address, or other platform destination id",
+      ),
+    threadRef: z
+      .string()
+      .optional()
+      .describe("Optional thread or topic reference"),
+    notes: z
+      .string()
+      .optional()
+      .describe("Optional notes about this destination"),
+  }),
+  run: async (args) => upsertDestination(args),
+});

package/src/actions/view-screen.ts

@@ -0,0 +1,249 @@
+/**
+ * See what the user is currently looking at on screen.
+ *
+ * Reads and returns the current navigation state from application state.
+ *
+ * Usage:
+ *   pnpm action view-screen
+ */
+
+import { defineAction } from "@agent-native/core";
+import { readAppState } from "@agent-native/core/application-state";
+import { z } from "zod";
+
+import { listWorkspaceApps } from "../server/lib/app-creation-store.js";
+import { listOverview } from "../server/lib/dispatch-store.js";
+import {
+  getAgentThreadDebug,
+  listThreadDebugSources,
+  searchAgentThreads,
+} from "../server/lib/thread-debug-store.js";
+import { listDispatchUsageMetrics } from "../server/lib/usage-metrics-store.js";
+import {
+  listVaultOverview,
+  listSecrets,
+  listGrants,
+  listRequests,
+  getVaultAccessSettings,
+} from "../server/lib/vault-store.js";
+import {
+  listWorkspaceResourceOptions,
+  listWorkspaceResourcesForApp,
+} from "../server/lib/workspace-resources-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.",
+  schema: z.object({}),
+  http: false,
+  run: async () => {
+    const [navigation, overview, vaultOverview] = await Promise.all([
+      readAppState("navigation"),
+      listOverview(),
+      listVaultOverview(),
+    ]);
+
+    const screen: Record<string, unknown> = {
+      counts: { ...overview.counts, ...vaultOverview },
+      approvalPolicy: overview.settings,
+    };
+    if (navigation) screen.navigation = navigation;
+    if (navigation?.view === "chat") {
+      screen.chatSurface = {
+        view: "full-page Dispatch chat",
+        purpose:
+          "Create apps, manage workspace resources, route work to connected agents, and continue Dispatch conversations.",
+      };
+    }
+    if (navigation?.view === "overview") {
+      screen.recentAudit = overview.recentAudit.slice(0, 5);
+      screen.recentApprovals = overview.recentApprovals.slice(0, 5);
+    }
+    if (navigation?.view === "destinations") {
+      screen.recentDestinations = overview.recentDestinations;
+    }
+    if (navigation?.view === "agents") {
+      const [connectedAgents, mcpAccess] = await Promise.all([
+        runLocalDispatchAction("list-connected-agents", {}),
+        runLocalDispatchAction("list-mcp-app-access", {}),
+      ]);
+      screen.connectedAgents = connectedAgents;
+      screen.mcpAppAccess = mcpAccess;
+    }
+    if (
+      navigation?.view === "overview" ||
+      navigation?.view === "metrics" ||
+      navigation?.view === "apps" ||
+      navigation?.view === "new-app"
+    ) {
+      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 {
+        const metrics = await listDispatchUsageMetrics({ sinceDays: 30 });
+        screen.usageMetrics = {
+          billing: metrics.billing,
+          totals: metrics.totals,
+          byApp: metrics.byApp.slice(0, 8),
+          byUser: metrics.byUser.slice(0, 8),
+          appAccess: metrics.appAccess
+            .filter((app) => !app.isDispatch)
+            .slice(0, 8),
+        };
+      } catch (error) {
+        screen.usageMetricsError =
+          error instanceof Error ? error.message : String(error);
+      }
+    }
+    if (navigation?.view === "vault" || navigation?.view === "new-app") {
+      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,
+        credentialKey: s.credentialKey,
+        provider: s.provider,
+      }));
+      screen.vaultActiveGrants = grants
+        .filter((g) => g.status === "active")
+        .map((g) => ({ secretId: g.secretId, appId: g.appId }));
+      screen.vaultPendingRequests = requests;
+    }
+    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 {
+        const nav = navigation as Record<string, any>;
+        screen.threadDebugSources = await listThreadDebugSources();
+        if (nav.query) {
+          screen.threadDebugResults = await searchAgentThreads({
+            sourceId: nav.sourceId,
+            query: nav.query,
+            ownerEmail: nav.ownerEmail,
+            limit: 10,
+          });
+        }
+        if (nav.threadId) {
+          const detail = await getAgentThreadDebug({
+            sourceId: nav.sourceId,
+            threadId: nav.threadId,
+            ownerEmail: nav.ownerEmail,
+            maxRuns: 5,
+            maxEvents: 80,
+            maxTraceSpans: 50,
+          });
+          screen.threadDebugSelection = {
+            source: detail.source,
+            thread: detail.thread,
+            messageCount: detail.messages.length,
+            runCount: detail.runs.length,
+            debug: detail.debug,
+            debugRuns: (detail as any).debugRuns?.slice(-5) ?? [],
+            messages: detail.messages.slice(-6),
+          };
+        }
+      } catch (error) {
+        screen.threadDebugError =
+          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?";
+    }
+    return JSON.stringify(screen, null, 2);
+  },
+});