@agent-native/dispatch 0.29.4 → 0.30.0

package/src/server/lib/app-creation-store.ts

@@ -14,9 +14,13 @@ import {
   resolveBuilderCredentialsDetailed,
   runBuilderAgent,
 } from "@agent-native/core/server";
+import { getOrgSetting } from "@agent-native/core/settings";
 import { getSetting, putSetting } from "@agent-native/core/settings";
 import { assertValidWorkspaceAppId } from "@agent-native/core/shared";
+import { resolveAccess } from "@agent-native/core/sharing";
 
+// Register the workspace-app shareable resource before any access lookup.
+import "../../db/index.js";
 import { isWorkspaceSsoAppUrl } from "../../shared/workspace-sso.js";
 import { identityKeyForIncoming } from "./dispatch-integrations.js";
 import {
@@ -43,10 +47,12 @@ const APP_CREATION_SETTINGS_AUTHORIZATION_MESSAGE =
 const APP_CREATION_SETTINGS_REQUIRED_MESSAGE =
   "An organization owner or admin must configure the Builder workspace project before members can create apps.";
 const WORKSPACE_APP_METADATA_SETTINGS_KEY = "workspace-app-metadata";
+const WORKSPACE_APP_DEFAULT_VISIBILITY_KEY = "workspace-app-default-visibility";
 const WORKSPACE_APPS_ENV_KEY = "AGENT_NATIVE_WORKSPACE_APPS_JSON";
 const WORKSPACE_APPS_MANIFEST_FILE = "workspace-apps.json";
 const WORKSPACE_APPS_GATEWAY_PATH = "/_workspace/apps";
 const WORKSPACE_APPS_GATEWAY_TIMEOUT_MS = 2_500;
+const WORKSPACE_APP_ACCESS_CONCURRENCY = 8;
 const MAX_PENDING_APPS = 50;
 const PENDING_WORKSPACE_APP_TTL_MS = 7 * 24 * 60 * 60 * 1_000;
 const AGENT_CARD_PATH = "/.well-known/agent-card.json";
@@ -79,6 +85,7 @@ class AppCreationSettingsAuthorizationError extends Error {
 }
 
 type WorkspaceAppAudience = "internal" | "public";
+type WorkspaceAppVisibility = "private" | "org";
 
 export interface WorkspaceAppSummary {
   id: string;
@@ -96,6 +103,7 @@ export interface WorkspaceAppSummary {
   branchName?: string | null;
   createdAt?: string | null;
   createdBy?: string | null;
+  visibility?: WorkspaceAppVisibility;
   owner?: string | null;
   teams?: string[];
   agentCardUrl?: string | null;
@@ -174,6 +182,8 @@ interface WorkspaceAppMetadataOverride {
   sourcePrompt?: string;
   updatedAt?: string;
   updatedBy?: string;
+  createdBy?: string;
+  visibility?: WorkspaceAppVisibility;
 }
 
 interface WorkspaceAppMetadataSettings {
@@ -337,6 +347,7 @@ function parseWorkspaceAppMetadataSettings(
     const sourcePrompt = cleanOptionalText(item.sourcePrompt);
     const updatedAt = cleanOptionalText(item.updatedAt);
     const updatedBy = cleanOptionalText(item.updatedBy);
+    const createdBy = cleanOptionalText(item.createdBy);
 
     if (name) override.name = name;
     if (description) override.description = description;
@@ -344,6 +355,10 @@ function parseWorkspaceAppMetadataSettings(
     if (sourcePrompt) override.sourcePrompt = sourcePrompt;
     if (updatedAt) override.updatedAt = updatedAt;
     if (updatedBy) override.updatedBy = updatedBy;
+    if (createdBy) override.createdBy = createdBy;
+    if (item.visibility === "private" || item.visibility === "org") {
+      override.visibility = item.visibility;
+    }
 
     if (Object.keys(override).length > 0) apps[id.trim()] = override;
   }
@@ -365,6 +380,8 @@ async function writeWorkspaceAppMetadataOverride(input: {
   generated?: boolean;
   sourcePrompt?: string | null;
   updatedBy?: string | null;
+  createdBy?: string | null;
+  visibility?: WorkspaceAppVisibility | null;
 }): Promise<WorkspaceAppMetadataSettings> {
   const key = workspaceAppMetadataSettingsKey();
   const current = parseWorkspaceAppMetadataSettings(
@@ -380,6 +397,7 @@ async function writeWorkspaceAppMetadataOverride(input: {
   const description = cleanOptionalText(input.description);
   const sourcePrompt = cleanOptionalText(input.sourcePrompt);
   const updatedBy = cleanOptionalText(input.updatedBy);
+  const createdBy = cleanOptionalText(input.createdBy);
 
   if (name) next.name = name;
   else delete next.name;
@@ -389,6 +407,8 @@ async function writeWorkspaceAppMetadataOverride(input: {
   else if (input.generated === false) delete next.generated;
   if (sourcePrompt) next.sourcePrompt = sourcePrompt;
   if (updatedBy) next.updatedBy = updatedBy;
+  if (createdBy) next.createdBy = createdBy;
+  if (input.visibility) next.visibility = input.visibility;
 
   current.apps[appId] = next;
   await putSetting(key, { apps: current.apps });
@@ -408,17 +428,23 @@ function applyWorkspaceAppMetadataOverride(
   const shouldApplyName = !!name && !generated;
   const shouldApplyDescription =
     !!description && (!generated || !cleanOptionalText(app.description));
-  if (!shouldApplyName && !shouldApplyDescription) return app;
+  const visibility = override.visibility;
+  if (!shouldApplyName && !shouldApplyDescription && !visibility) return app;
 
   return {
     ...app,
     ...(shouldApplyName ? { name } : {}),
     ...(shouldApplyDescription ? { description } : {}),
-    ...(app.status === "pending" && !app.createdBy && override.updatedBy
-      ? { createdBy: override.updatedBy }
+    ...(visibility ? { visibility } : {}),
+    ...(app.status === "pending" &&
+    !app.createdBy &&
+    (override.createdBy || override.updatedBy)
+      ? { createdBy: override.createdBy ?? override.updatedBy }
       : {}),
-    ...(app.status === "pending" && !app.owner && override.updatedBy
-      ? { owner: override.updatedBy }
+    ...(app.status === "pending" &&
+    !app.owner &&
+    (override.createdBy || override.updatedBy)
+      ? { owner: override.createdBy ?? override.updatedBy }
       : {}),
   };
 }
@@ -1002,6 +1028,198 @@ async function maybeIncludeAgentCards(
   );
 }
 
+async function workspaceAppDefaultVisibility(): Promise<WorkspaceAppVisibility> {
+  const orgId = currentOrgId();
+  if (!orgId) return "org";
+  const setting = await getOrgSetting(
+    orgId,
+    WORKSPACE_APP_DEFAULT_VISIBILITY_KEY,
+  );
+  if (setting === null) return "org";
+  if (setting.visibility === "private" || setting.visibility === "org") {
+    return setting.visibility;
+  }
+  throw new Error(
+    "Workspace app default visibility is invalid; refusing to widen access.",
+  );
+}
+
+function appRecordTimestamp(value: string | null | undefined): number {
+  const parsed = value ? Date.parse(value) : NaN;
+  return Number.isFinite(parsed) ? parsed : Date.now();
+}
+
+/**
+ * Persist creator and visibility separately from the deploy manifest. The
+ * manifest describes code; this SQL record is the access-control source of
+ * truth shared by Dispatch and the mounted app's auth guard.
+ */
+async function ensureWorkspaceAppRecords(
+  apps: WorkspaceAppSummary[],
+): Promise<WorkspaceAppSummary[]> {
+  const readyApps = apps.filter(
+    (app) => app.status !== "pending" && !app.isDispatch,
+  );
+  if (readyApps.length === 0) return apps;
+
+  const orgId = currentOrgId();
+  const metadata = await readWorkspaceAppMetadataSettings();
+  const defaultVisibility = await workspaceAppDefaultVisibility();
+  const db = getDbExec();
+  const records = new Map<
+    string,
+    {
+      ownerEmail: string;
+      orgId: string | null;
+      visibility: WorkspaceAppVisibility;
+    }
+  >();
+
+  try {
+    const existingRecords = new Map<
+      string,
+      { owner_email?: unknown; org_id?: unknown; visibility?: unknown }
+    >();
+    for (let start = 0; start < readyApps.length; start += 500) {
+      const ids = readyApps.slice(start, start + 500).map((app) => app.id);
+      const result = await db.execute({
+        sql: `SELECT id, owner_email, org_id, visibility
+              FROM workspace_apps
+              WHERE id IN (${ids.map(() => "?").join(", ")})`,
+        args: ids,
+      });
+      for (const row of result.rows) {
+        const id = cleanOptionalText((row as Record<string, unknown>).id);
+        if (id) {
+          existingRecords.set(id, row as Record<string, unknown>);
+        }
+      }
+    }
+
+    for (const app of readyApps) {
+      const existing = existingRecords.get(app.id);
+      if (!existing) {
+        const override = metadata.apps[app.id];
+        // Never infer ownership from the person who happened to list apps.
+        // Legacy manifests without trusted creation metadata remain
+        // ownerless until an admin-controlled migration/claim flow exists.
+        const ownerEmail =
+          cleanOptionalText(override?.createdBy) ??
+          cleanOptionalText(app.createdBy) ??
+          "";
+        const hasTrustedCreationMetadata = Boolean(ownerEmail);
+        const visibility: WorkspaceAppVisibility =
+          override?.visibility === "private"
+            ? "private"
+            : override?.visibility === "org"
+              ? "org"
+              : hasTrustedCreationMetadata
+                ? defaultVisibility
+                : "org";
+        const createdAt = appRecordTimestamp(app.createdAt);
+        await db.execute({
+          sql: `INSERT INTO workspace_apps
+                (id, owner_email, org_id, visibility, name, description, path, created_at, updated_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          args: [
+            app.id,
+            ownerEmail,
+            orgId,
+            visibility,
+            app.name,
+            app.description || null,
+            app.path,
+            createdAt,
+            Date.now(),
+          ],
+        });
+        records.set(app.id, { ownerEmail, orgId, visibility });
+      } else {
+        records.set(app.id, {
+          ownerEmail:
+            typeof existing.owner_email === "string"
+              ? existing.owner_email
+              : "",
+          orgId:
+            (typeof existing.org_id === "string"
+              ? existing.org_id
+              : ""
+            ).trim() || null,
+          visibility: existing.visibility === "private" ? "private" : "org",
+        });
+      }
+    }
+  } catch (error) {
+    console.warn("[dispatch] workspace app access records unavailable", error);
+    return apps;
+  }
+
+  return apps.map((app) => {
+    const record = records.get(app.id);
+    return record ? { ...app, visibility: record.visibility } : app;
+  });
+}
+
+async function filterWorkspaceAppsByAccess(
+  apps: WorkspaceAppSummary[],
+): Promise<WorkspaceAppSummary[]> {
+  let userEmail: string;
+  try {
+    userEmail = currentOwnerEmail();
+  } catch {
+    // coercion-ok: anonymous requests fail closed by receiving no app metadata.
+    // App metadata is access-controlled. An anonymous request must not receive
+    // the full registry simply because there is no caller to resolve.
+    return [];
+  }
+  const orgId = currentOrgId() ?? undefined;
+  const visibleIds = new Set<string>();
+  const candidates: WorkspaceAppSummary[] = [];
+  for (const app of apps) {
+    if (app.status === "pending" || app.isDispatch) {
+      visibleIds.add(app.id);
+      continue;
+    }
+    candidates.push(app);
+  }
+
+  for (
+    let start = 0;
+    start < candidates.length;
+    start += WORKSPACE_APP_ACCESS_CONCURRENCY
+  ) {
+    const batch = candidates.slice(
+      start,
+      start + WORKSPACE_APP_ACCESS_CONCURRENCY,
+    );
+    const decisions = await Promise.all(
+      batch.map(async (app) => {
+        try {
+          const access = await resolveAccess(
+            "workspace-app",
+            app.id,
+            { userEmail, orgId },
+            { skipResourceBody: true },
+          );
+          return { app, allowed: Boolean(access) };
+        } catch (error) {
+          // Rolling deployments may discover an app before the additive access
+          // migrations have run. A missing schema is not an authorization
+          // result: returning the candidate would expose private metadata
+          // during a migration failure.
+          console.warn("[dispatch] workspace app access lookup failed", error);
+          return { app, allowed: false };
+        }
+      }),
+    );
+    for (const decision of decisions) {
+      if (decision.allowed) visibleIds.add(decision.app.id);
+    }
+  }
+
+  return apps.filter((app) => visibleIds.has(app.id));
+}
+
 async function recordPendingWorkspaceApp(input: {
   appId: string;
   projectId: string | null;
@@ -1054,6 +1272,7 @@ async function recordPendingWorkspaceApp(input: {
     generated: true,
     sourcePrompt: input.sourcePrompt,
     updatedBy: currentOwnerEmail(),
+    createdBy: currentOwnerEmail(),
   });
 
   await recordAudit({
@@ -1413,12 +1632,15 @@ export async function updateWorkspaceAppMetadata(input: {
 export async function listWorkspaceApps(
   options: ListWorkspaceAppsOptions = {},
 ): Promise<WorkspaceAppSummary[]> {
+  const finalize = async (apps: WorkspaceAppSummary[]) => {
+    const annotated = await applyArchivedAndPending(apps, options);
+    const recorded = await ensureWorkspaceAppRecords(annotated);
+    const visible = await filterWorkspaceAppsByAccess(recorded);
+    return maybeIncludeAgentCards(visible, options);
+  };
   const gatewayApps = await readWorkspaceAppsFromGateway();
   if (gatewayApps) {
-    return maybeIncludeAgentCards(
-      await applyArchivedAndPending(gatewayApps, options),
-      options,
-    );
+    return finalize(gatewayApps);
   }
 
   const workspaceRoot = findWorkspaceRoot();
@@ -1427,49 +1649,34 @@ export async function listWorkspaceApps(
       ? readWorkspaceAppsFromFilesystem(workspaceRoot)
       : null;
   if (localFilesystemApps) {
-    return maybeIncludeAgentCards(
-      await applyArchivedAndPending(localFilesystemApps, options),
-      options,
-    );
+    return finalize(localFilesystemApps);
   }
 
   const manifestApps =
     readWorkspaceAppsFromEnv() ?? readWorkspaceAppsFromManifestFile();
   if (manifestApps) {
-    return maybeIncludeAgentCards(
-      await applyArchivedAndPending(manifestApps, options),
-      options,
-    );
+    return finalize(manifestApps);
   }
 
   if (!workspaceRoot) {
-    return maybeIncludeAgentCards(
-      await applyArchivedAndPending(
-        [
-          {
-            id: "dispatch",
-            name: "Dispatch",
-            description: "Workspace control plane",
-            path: "/dispatch",
-            url: workspaceAppUrl("/dispatch"),
-            isDispatch: true,
-            audience: DEFAULT_WORKSPACE_APP_AUDIENCE,
-            publicPaths: [],
-            protectedPaths: [],
-            status: "ready",
-          },
-        ],
-        options,
-      ),
-      options,
-    );
+    return finalize([
+      {
+        id: "dispatch",
+        name: "Dispatch",
+        description: "Workspace control plane",
+        path: "/dispatch",
+        url: workspaceAppUrl("/dispatch"),
+        isDispatch: true,
+        audience: DEFAULT_WORKSPACE_APP_AUDIENCE,
+        publicPaths: [],
+        protectedPaths: [],
+        status: "ready",
+      },
+    ]);
   }
 
   const apps = readWorkspaceAppsFromFilesystem(workspaceRoot) ?? [];
-  return maybeIncludeAgentCards(
-    await applyArchivedAndPending(apps, options),
-    options,
-  );
+  return finalize(apps);
 }
 
 /**
@@ -1644,6 +1851,22 @@ export async function scaffoldWorkspaceAppFromTemplate(input: {
     metadata: { template },
   });
 
+  await ensureWorkspaceAppRecords([
+    {
+      id: appId,
+      name: titleCase(appId),
+      description: "",
+      path: `/${appId}`,
+      url: workspaceAppUrl(`/${appId}`),
+      isDispatch: false,
+      audience: DEFAULT_WORKSPACE_APP_AUDIENCE,
+      publicPaths: [],
+      protectedPaths: [],
+      status: "ready",
+      createdBy: currentOwnerEmail(),
+    },
+  ]);
+
   return { appId, template, output };
 }