@jami-studio/dispatch 0.13.14

package/src/components/workspace-resource-effective-stack.tsx

@@ -0,0 +1,142 @@
+import { useActionQuery } from "@agent-native/core/client";
+
+import { cn } from "../lib/utils";
+import { Badge } from "./ui/badge";
+
+export function appAvailabilityLabel(value?: string) {
+  switch (value) {
+    case "all-apps":
+      return "Inherited by all apps";
+    case "selected-granted":
+      return "Granted to this app";
+    case "selected-not-granted":
+      return "Not granted";
+    case "selected-no-app":
+      return "Select app";
+    case "path-not-managed":
+      return "Not managed";
+    default:
+      return "Checking";
+  }
+}
+
+export function appLayerState(layer: any): {
+  label: string;
+  className: string;
+} {
+  if (layer.effective) {
+    return {
+      label: "Wins",
+      className: "border-green-500/30 bg-green-500/10 text-green-700",
+    };
+  }
+  if (layer.overridden) {
+    return {
+      label: "Overridden",
+      className: "border-amber-500/30 bg-amber-500/10 text-amber-700",
+    };
+  }
+  return {
+    label: "Missing",
+    className: "text-muted-foreground",
+  };
+}
+
+export function formatResourceTimestamp(value?: number | null): string {
+  if (!value) return "not present";
+  return new Date(value).toLocaleString();
+}
+
+export function AppResourceEffectiveStack({
+  appId,
+  resource,
+}: {
+  appId: string;
+  resource: any;
+}) {
+  const { data: context, isLoading } = useActionQuery(
+    "get-workspace-resource-effective-context",
+    { resourceId: resource.id, appId },
+    { enabled: !!resource.id },
+  );
+  const layers = ((context as any)?.layers ?? []) as any[];
+  const active = (context as any)?.effectiveResource;
+  const availability = (context as any)?.availability;
+
+  if (isLoading && !context) {
+    return (
+      <div className="mt-3 rounded-lg border bg-muted/20 p-3">
+        <div className="h-3 w-44 animate-pulse rounded bg-muted-foreground/10" />
+        <div className="mt-3 grid gap-2 sm:grid-cols-3">
+          <div className="h-20 animate-pulse rounded-md bg-muted-foreground/10" />
+          <div className="h-20 animate-pulse rounded-md bg-muted-foreground/10" />
+          <div className="h-20 animate-pulse rounded-md bg-muted-foreground/10" />
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="mt-3 rounded-lg border bg-muted/20 p-3">
+      <div className="flex flex-wrap items-start justify-between gap-2">
+        <div className="min-w-0">
+          <div className="text-xs font-semibold uppercase text-muted-foreground">
+            Effective context stack
+          </div>
+          <div className="mt-1 truncate font-mono text-[11px] text-muted-foreground">
+            {resource.path}
+          </div>
+        </div>
+        <Badge variant="outline">{appAvailabilityLabel(availability)}</Badge>
+      </div>
+
+      <div className="mt-3 grid gap-2 sm:grid-cols-3">
+        {layers.map((layer) => {
+          const state = appLayerState(layer);
+          return (
+            <div
+              key={layer.scope}
+              className={cn("rounded-md border bg-background/70 p-2", {
+                "border-green-500/30 bg-green-500/10": layer.effective,
+              })}
+            >
+              <div className="flex items-start justify-between gap-2">
+                <span className="text-xs font-medium text-foreground">
+                  {layer.label}
+                </span>
+                <Badge variant="outline" className={state.className}>
+                  {state.label}
+                </Badge>
+              </div>
+              <div className="mt-1 truncate font-mono text-[10px] text-muted-foreground">
+                {layer.owner}
+              </div>
+              {layer.resource ? (
+                <div className="mt-2 text-[11px] text-muted-foreground">
+                  Updated {formatResourceTimestamp(layer.resource.updatedAt)}
+                </div>
+              ) : (
+                <div className="mt-2 text-[11px] text-muted-foreground">
+                  No file at this layer
+                </div>
+              )}
+            </div>
+          );
+        })}
+      </div>
+
+      <div className="mt-3 rounded-md bg-background/70 px-3 py-2 text-xs text-muted-foreground">
+        {active ? (
+          <>
+            Winning layer:{" "}
+            <span className="font-mono text-foreground">
+              {active.owner}/{active.path}
+            </span>
+          </>
+        ) : (
+          "No active resource exists for this path yet."
+        )}
+      </div>
+    </div>
+  );
+}

package/src/components/workspace-resource-impact-preview.spec.tsx

@@ -0,0 +1,148 @@
+// @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 {
+  ImpactPreview,
+  workspaceResourceMutationMessage,
+} from "./workspace-resource-impact-preview";
+
+const queryState = vi.hoisted(() => ({
+  result: { data: null as any, isLoading: false },
+  calls: [] as any[],
+}));
+
+vi.mock("@agent-native/core/client", () => ({
+  useActionQuery: (...args: any[]) => {
+    queryState.calls.push(args);
+    return queryState.result;
+  },
+}));
+
+describe("ImpactPreview", () => {
+  let container: HTMLDivElement;
+  let root: Root;
+
+  beforeEach(() => {
+    vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+    queryState.calls = [];
+    queryState.result = { data: null, isLoading: false };
+    container = document.createElement("div");
+    document.body.appendChild(container);
+    root = createRoot(container);
+  });
+
+  afterEach(() => {
+    act(() => root.unmount());
+    container.remove();
+    vi.unstubAllGlobals();
+  });
+
+  it("renders All-app approval impact and override details", () => {
+    queryState.result = {
+      isLoading: false,
+      data: {
+        affectsAllApps: true,
+        affectedApps: { count: 4 },
+        approval: { willRequestApproval: true },
+        overrides: {
+          count: 2,
+          items: [
+            {
+              scope: "shared",
+              owner: "__shared__",
+              label: "Organization/app override",
+              updatedAt: 1,
+            },
+            {
+              scope: "personal",
+              owner: "person@example.test",
+              label: "Personal override (person@example.test)",
+              updatedAt: 2,
+            },
+          ],
+        },
+      },
+    };
+
+    act(() => {
+      root.render(
+        <ImpactPreview
+          operation="update"
+          resourceId="resource_1"
+          scope="all"
+        />,
+      );
+    });
+
+    expect(queryState.calls[0]).toEqual([
+      "preview-workspace-resource-change",
+      {
+        operation: "update",
+        resourceId: "resource_1",
+        path: undefined,
+        scope: "all",
+      },
+      { enabled: true },
+    ]);
+    expect(container.textContent).toContain("All apps impact");
+    expect(container.textContent).toContain("Approval required");
+    expect(container.textContent).toContain("2 overrides");
+    expect(container.textContent).toContain(
+      "This change applies to every workspace app (4 discovered).",
+    );
+    expect(container.textContent).toContain(
+      "It will be queued for approval before it takes effect.",
+    );
+    expect(container.textContent).toContain("Organization/app override");
+    expect(container.textContent).toContain(
+      "Personal override (person@example.test)",
+    );
+  });
+
+  it("renders selected-only changes as immediate", () => {
+    queryState.result = {
+      isLoading: false,
+      data: {
+        affectsAllApps: false,
+        affectedApps: { count: null },
+        approval: { willRequestApproval: false },
+        overrides: { count: 0, items: [] },
+      },
+    };
+
+    act(() => {
+      root.render(
+        <ImpactPreview
+          operation="create"
+          path="context/private-launch.md"
+          scope="selected"
+        />,
+      );
+    });
+
+    expect(container.textContent).toContain("Selected only");
+    expect(container.textContent).toContain(
+      "This change only applies to explicitly granted apps.",
+    );
+    expect(container.textContent).toContain(
+      "It will take effect immediately when saved.",
+    );
+  });
+
+  it("uses approval-request mutation copy only for workspace resource approvals", () => {
+    expect(
+      workspaceResourceMutationMessage(
+        { status: "pending", changeType: "workspace-resource.update" },
+        "Resource updated",
+      ),
+    ).toBe("Approval requested");
+    expect(
+      workspaceResourceMutationMessage(
+        { status: "pending", changeType: "dream-proposal.apply" },
+        "Resource updated",
+      ),
+    ).toBe("Resource updated");
+  });
+});

package/src/components/workspace-resource-impact-preview.tsx

@@ -0,0 +1,117 @@
+import { useActionQuery } from "@agent-native/core/client";
+
+import { Badge } from "./ui/badge";
+import { Skeleton } from "./ui/skeleton";
+import { formatResourceTimestamp } from "./workspace-resource-effective-stack";
+
+function isApprovalRequest(result: any): boolean {
+  return (
+    result?.status === "pending" &&
+    typeof result?.changeType === "string" &&
+    result.changeType.startsWith("workspace-resource.")
+  );
+}
+
+export function workspaceResourceMutationMessage(
+  result: any,
+  fallback: string,
+): string {
+  return isApprovalRequest(result) ? "Approval requested" : fallback;
+}
+
+export function ImpactPreview({
+  operation,
+  resourceId,
+  path,
+  scope,
+  enabled = true,
+}: {
+  operation: "create" | "update" | "delete";
+  resourceId?: string;
+  path?: string;
+  scope?: "all" | "selected";
+  enabled?: boolean;
+}) {
+  const { data: impact, isLoading } = useActionQuery(
+    "preview-workspace-resource-change",
+    {
+      operation,
+      resourceId,
+      path,
+      scope,
+    },
+    { enabled: enabled && Boolean(resourceId || path) },
+  );
+
+  if (!enabled || (!resourceId && !path)) return null;
+
+  if (isLoading) {
+    return (
+      <div className="rounded-lg border bg-muted/30 p-3">
+        <Skeleton className="h-4 w-40" />
+        <Skeleton className="mt-2 h-3 w-72" />
+      </div>
+    );
+  }
+
+  const data = impact as any;
+  if (!data) return null;
+  const affectsAllApps = data.affectsAllApps === true;
+  const appCount = data.affectedApps?.count;
+  const overrides = data.overrides ?? { count: 0, items: [] };
+  const willRequestApproval = data.approval?.willRequestApproval === true;
+
+  return (
+    <div className="rounded-lg border bg-muted/30 p-3 text-xs">
+      <div className="flex flex-wrap items-center gap-2">
+        <Badge variant={affectsAllApps ? "secondary" : "outline"}>
+          {affectsAllApps ? "All apps impact" : "Selected only"}
+        </Badge>
+        {willRequestApproval ? (
+          <Badge
+            variant="outline"
+            className="border-amber-500/30 bg-amber-500/10 text-amber-700 dark:text-amber-300"
+          >
+            Approval required
+          </Badge>
+        ) : null}
+        {overrides.count > 0 ? (
+          <Badge variant="outline">
+            {overrides.count} override{overrides.count === 1 ? "" : "s"}
+          </Badge>
+        ) : null}
+      </div>
+      <p className="mt-2 leading-relaxed text-muted-foreground">
+        {affectsAllApps
+          ? `This change applies to every workspace app${typeof appCount === "number" ? ` (${appCount} discovered)` : ""}.`
+          : "This change only applies to explicitly granted apps."}{" "}
+        {willRequestApproval
+          ? "It will be queued for approval before it takes effect."
+          : "It will take effect immediately when saved."}
+      </p>
+      {overrides.count > 0 ? (
+        <div className="mt-2 space-y-1">
+          {overrides.items.slice(0, 4).map((override: any) => (
+            <div
+              key={`${override.scope}:${override.owner}`}
+              className="flex items-center justify-between gap-3 rounded-md border bg-background px-2 py-1.5"
+            >
+              <span className="min-w-0 truncate text-muted-foreground">
+                {override.label}
+              </span>
+              <span className="shrink-0 font-mono text-[11px] text-muted-foreground">
+                {formatResourceTimestamp(override.updatedAt)}
+              </span>
+            </div>
+          ))}
+          {overrides.count > 4 ? (
+            <div className="text-muted-foreground">
+              +{overrides.count - 4} more override
+              {overrides.count - 4 === 1 ? "" : "s"}
+            </div>
+          ) : null}
+        </div>
+      ) : null}
+    </div>
+  );
+}

package/src/config.ts

@@ -0,0 +1,35 @@
+/**
+ * Configuration shape for `setupDispatch(config)`. Captures every workspace
+ * customization point we identified during the framework→workspace drift
+ * audit so consumers can express their environment without forking source.
+ */
+
+export interface DispatchAuthConfig {
+  /**
+   * When true, only Google OAuth is shown on the login screen and other
+   * providers are hidden. Used by Builder's own workspace, which enforces
+   * Google SSO for its org.
+   */
+  googleOnly?: boolean;
+  /** Marketing/branding copy passed straight through to `createAuthPlugin`. */
+  marketing?: Record<string, unknown>;
+}
+
+export interface DispatchIntegrationsConfig {
+  /**
+   * Append or replace the integrations agent's system-prompt guidance.
+   * Pass a string to replace the default; pass a function to mutate it.
+   */
+  systemPrompt?: string | ((defaultPrompt: string) => string);
+}
+
+export interface DispatchConfig {
+  auth?: DispatchAuthConfig;
+  /**
+   * App IDs to hide from `list-connected-agents` results. Used to filter
+   * out first-party Builder apps (calls, issues, macros, …) from the
+   * Connected Agents list when those apps aren't shipped to end users.
+   */
+  hiddenAgentIds?: string[];
+  integrations?: DispatchIntegrationsConfig;
+}

package/src/db/index.ts

@@ -0,0 +1,13 @@
+import { createGetDb } from "@agent-native/core/db";
+
+import * as schema from "./schema.js";
+
+export const getDb = createGetDb(schema);
+
+export function db() {
+  return getDb();
+}
+
+export { schema };
+export * from "./schema.js";
+export * from "./migrations.js";

package/src/db/migrations.spec.ts

@@ -0,0 +1,80 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const originalEnv = {
+  DATABASE_URL: process.env.DATABASE_URL,
+  DATABASE_AUTH_TOKEN: process.env.DATABASE_AUTH_TOKEN,
+};
+
+let tempDir: string | null = null;
+
+function restoreEnv() {
+  for (const [key, value] of Object.entries(originalEnv)) {
+    if (value === undefined) delete process.env[key];
+    else process.env[key] = value;
+  }
+}
+
+async function setupTempDb() {
+  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "dispatch-migrations-"));
+  process.env.DATABASE_URL = `file:${path.join(tempDir, "app.db")}`;
+  delete process.env.DATABASE_AUTH_TOKEN;
+  vi.resetModules();
+}
+
+beforeEach(async () => {
+  await setupTempDb();
+});
+
+afterEach(async () => {
+  try {
+    const { closeDbExec } = await import("@agent-native/core/db");
+    await closeDbExec();
+  } catch {}
+  restoreEnv();
+  if (tempDir) {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    tempDir = null;
+  }
+  vi.restoreAllMocks();
+});
+
+describe("dispatch migrations", () => {
+  it("quietly records source_health when the column already exists", async () => {
+    const [{ getDbExec, runMigrations }, { dispatchMigrations }] =
+      await Promise.all([
+        import("@agent-native/core/db"),
+        import("./migrations.js"),
+      ]);
+    const exec = getDbExec();
+    await exec.execute(`
+      CREATE TABLE dispatch_dreams (
+        id TEXT PRIMARY KEY,
+        source_health TEXT
+      )
+    `);
+    await exec.execute(
+      "CREATE TABLE dispatch_migrations (version INTEGER PRIMARY KEY)",
+    );
+    await exec.execute({
+      sql: "INSERT INTO dispatch_migrations VALUES (?)",
+      args: [3],
+    });
+
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    await runMigrations(dispatchMigrations, {
+      table: "dispatch_migrations",
+    })({});
+
+    expect(consoleError).not.toHaveBeenCalled();
+    const { rows } = await exec.execute(
+      "SELECT MAX(version) as version FROM dispatch_migrations",
+    );
+    expect(rows[0]?.version).toBe(4);
+  });
+});