@vellumai/assistant 0.10.9-staging.1 → 0.10.9

package/src/runtime/routes/__tests__/gateway-status-routes.test.ts

@@ -0,0 +1,84 @@
+/**
+ * Unit tests for the gateway_status route handler.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { ServiceUnavailableError } from "../errors.js";
+
+let ipcResult: unknown = null;
+let ipcError: Error | undefined;
+let ipcCallCount = 0;
+
+const ipcGetVelayStatusMock = mock(async () => {
+  ipcCallCount += 1;
+  if (ipcError) throw ipcError;
+  return ipcResult;
+});
+
+mock.module("../../../ipc/gateway-client.js", () => ({
+  ipcGetVelayStatus: ipcGetVelayStatusMock,
+}));
+
+import { ROUTES } from "../gateway-status-routes.js";
+
+const gatewayStatusRoute = ROUTES.find(
+  (r) => r.operationId === "gateway_status",
+)!;
+
+describe("gateway_status route", () => {
+  beforeEach(() => {
+    ipcResult = null;
+    ipcError = undefined;
+    ipcCallCount = 0;
+    ipcGetVelayStatusMock.mockClear();
+  });
+
+  test("route is registered with correct operationId, method, and endpoint", () => {
+    expect(gatewayStatusRoute).toBeDefined();
+    expect(gatewayStatusRoute.operationId).toBe("gateway_status");
+    expect(gatewayStatusRoute.method).toBe("GET");
+    expect(gatewayStatusRoute.endpoint).toBe("gateway/status");
+  });
+
+  test("returns the tunnel URL when a tunnel is connected", async () => {
+    ipcResult = { connected: true, publicUrl: "https://abc123.vellum.ai" };
+
+    const result = await gatewayStatusRoute.handler({});
+
+    expect(result).toEqual({ tunnel: "https://abc123.vellum.ai" });
+  });
+
+  test("returns {} when the tunnel is disconnected", async () => {
+    ipcResult = { connected: false, publicUrl: null };
+
+    const result = await gatewayStatusRoute.handler({});
+
+    expect(result).toEqual({});
+  });
+
+  test("returns {} when connected but no public URL is registered yet", async () => {
+    ipcResult = { connected: true, publicUrl: null };
+
+    const result = await gatewayStatusRoute.handler({});
+
+    expect(result).toEqual({});
+  });
+
+  test("errors with 503 when the gateway is unreachable", async () => {
+    ipcResult = null;
+
+    await expect(gatewayStatusRoute.handler({})).rejects.toBeInstanceOf(
+      ServiceUnavailableError,
+    );
+  });
+
+  test("errors when the gateway IPC call throws (gateway not running)", async () => {
+    ipcError = new Error("Gateway IPC socket disconnected");
+
+    await expect(gatewayStatusRoute.handler({})).rejects.toBeInstanceOf(
+      ServiceUnavailableError,
+    );
+    expect(ipcCallCount).toBe(1);
+  });
+});

package/src/runtime/routes/__tests__/plugins-routes.test.ts

@@ -112,6 +112,24 @@ import {
   type UpgradePluginOptions,
 } from "../../../cli/lib/upgrade-plugin.js";
 
+// Spy on the route logger so tests can assert that a platform-catalog outage
+// is recorded before it is mapped to a client 503. The catalog fetcher and the
+// transport adapters swallow the failure otherwise (`RouteError` → wire error,
+// no capture), so the log line is the only trace an operator gets — assert it.
+const logErrorSpy = mock((..._args: unknown[]) => {});
+const logWarnSpy = mock((..._args: unknown[]) => {});
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () => ({
+    info: () => {},
+    warn: logWarnSpy,
+    error: logErrorSpy,
+    debug: () => {},
+    trace: () => {},
+    fatal: () => {},
+  }),
+}));
+
 // Mutable list returned by the mocked library function. Tests reassign
 // `installedFixture` before invoking the handler.
 let installedFixture: InstalledPluginInfo[] = [];
@@ -302,6 +320,11 @@ const broadcastMessageSpy = mock((_msg: unknown): void => {});
 
 mock.module("../../assistant-event-hub.js", () => ({
   broadcastMessage: broadcastMessageSpy,
+  // Stub the hub singleton so the (now dynamically imported) plugins-routes
+  // dependency graph links — some transitive importer statically imports this
+  // binding. No tested path calls it; publishing goes through the mocked
+  // `broadcastMessage` above.
+  assistantEventHub: {},
 }));
 
 // Make the valid-slug source deterministic: the real `getLocalCategorySlugs`
@@ -335,11 +358,15 @@ import {
   NotFoundError,
   ServiceUnavailableError,
 } from "../errors.js";
-import {
+// `plugins-routes.js` is dynamically imported AFTER the logger mock above so
+// its module-level `const log = getLogger(...)` binds to the mocked logger. A
+// static import evaluates before any `mock.module` runs and would capture the
+// real logger at module init (same reason as `request-logger.test.ts`).
+const {
   loadCategoryMapBounded,
   normalizeMarketplaceCategory,
-  ROUTES as PLUGINS_ROUTES,
-} from "../plugins-routes.js";
+  ROUTES: PLUGINS_ROUTES,
+}: typeof import("../plugins-routes.js") = await import("../plugins-routes.js");
 import type { RouteDefinition, RouteHandlerArgs } from "../types.js";
 import { RouteResponse } from "../types.js";
 
@@ -1099,6 +1126,7 @@ describe("GET /v1/plugins/search", () => {
   });
 
   test("PluginCatalogUnavailableError → ServiceUnavailableError (503)", async () => {
+    logErrorSpy.mockClear();
     getCatalogSpy.mockImplementation(async () => {
       throw new PluginCatalogUnavailableError(
         "GitHub contents listing failed for plugins @ main: HTTP 403",
@@ -1111,6 +1139,14 @@ describe("GET /v1/plugins/search", () => {
     await expect(
       invokeSearch({ queryParams: { q: "memory" } }),
     ).rejects.toBeInstanceOf(ServiceUnavailableError);
+
+    // The outage must be logged before it is mapped to a 503 — otherwise the
+    // transport adapters return the RouteError with no capture and the incident
+    // is invisible. The log carries the true upstream status the 503 collapses.
+    expect(logErrorSpy).toHaveBeenCalledTimes(1);
+    const [fields, msg] = logErrorSpy.mock.calls[0]!;
+    expect(msg).toBe("Platform plugin catalog unavailable");
+    expect(fields).toMatchObject({ operation: "search", upstreamStatus: 403 });
   });
 
   test("unknown errors → InternalError with original message preserved", async () => {
@@ -1579,6 +1615,7 @@ describe("POST /v1/plugins/install", () => {
   test("a catalog outage on the no-pin path → ServiceUnavailableError (503)", async () => {
     // A rate-limited or unavailable platform catalog (no stale fallback) is
     // transient — the route surfaces it as retryable, not a misleading 500.
+    logErrorSpy.mockClear();
     getCatalogSpy.mockImplementation(async () => {
       throw new PluginCatalogUnavailableError("HTTP 403", 403);
     });
@@ -1587,6 +1624,13 @@ describe("POST /v1/plugins/install", () => {
       invokeInstall({ body: { name: "caveman" } }),
     ).rejects.toBeInstanceOf(ServiceUnavailableError);
     expect(installSpy).not.toHaveBeenCalled();
+
+    // The outage is logged (operation "install") before the 503 mapping, so
+    // an install-path catalog failure is diagnosable rather than invisible.
+    expect(logErrorSpy).toHaveBeenCalledTimes(1);
+    const [fields, msg] = logErrorSpy.mock.calls[0]!;
+    expect(msg).toBe("Platform plugin catalog unavailable");
+    expect(fields).toMatchObject({ operation: "install", upstreamStatus: 403 });
   });
 
   test("a missing name short-circuits to BadRequestError without calling the lib", async () => {

package/src/runtime/routes/__tests__/user-routes-cli.test.ts

@@ -0,0 +1,154 @@
+/**
+ * Tests for the `assistant routes` discovery handlers (`user_routes_list`,
+ * `user_routes_inspect`).
+ *
+ * These assert the CLI's view of the route surface matches what the dispatcher
+ * serves: workspace routes appear at `/x/<path>`, plugin routes at
+ * `/x/plugins/<name>/<path>`, files shadowed by the reserved plugin prefix are
+ * excluded, and disabled plugins contribute nothing. Both handlers resolve
+ * through the shared `user-route-resolution` module the dispatcher uses.
+ */
+
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  getWorkspacePluginsDir,
+  getWorkspaceRoutesDir,
+} from "../../../util/platform.js";
+import type { RouteHandlerArgs } from "../types.js";
+import { ROUTES } from "../user-routes-cli.js";
+
+interface RouteEntry {
+  routePath: string;
+  methods: string[];
+  filePath: string;
+}
+
+const listHandler = ROUTES.find((r) => r.operationId === "user_routes_list")!
+  .handler as () => Promise<{ ok: true; routes: RouteEntry[] }>;
+const inspectHandler = ROUTES.find(
+  (r) => r.operationId === "user_routes_inspect",
+)!.handler as (args: RouteHandlerArgs) => Promise<{ route: RouteEntry }>;
+
+const GET_HANDLER = `export async function GET() { return Response.json({ ok: true }); }\n`;
+
+function writeWorkspaceRoute(relPath: string): void {
+  const full = join(getWorkspaceRoutesDir(), relPath);
+  mkdirSync(full.slice(0, full.lastIndexOf("/")), { recursive: true });
+  writeFileSync(full, GET_HANDLER);
+}
+
+function writePluginRoute(plugin: string, relPath: string): void {
+  const full = join(getWorkspacePluginsDir(), plugin, "routes", relPath);
+  mkdirSync(full.slice(0, full.lastIndexOf("/")), { recursive: true });
+  writeFileSync(full, GET_HANDLER);
+}
+
+function disablePlugin(plugin: string): void {
+  writeFileSync(join(getWorkspacePluginsDir(), plugin, ".disabled"), "");
+}
+
+beforeEach(() => {
+  mkdirSync(getWorkspaceRoutesDir(), { recursive: true });
+  mkdirSync(getWorkspacePluginsDir(), { recursive: true });
+});
+
+afterEach(() => {
+  rmSync(getWorkspaceRoutesDir(), { recursive: true, force: true });
+  rmSync(getWorkspacePluginsDir(), { recursive: true, force: true });
+});
+
+describe("routes list", () => {
+  test("lists workspace routes and plugin routes together", async () => {
+    writeWorkspaceRoute("ping.ts");
+    writePluginRoute("demo", "status.ts");
+    writePluginRoute("demo", "webhooks/incoming.ts");
+    writePluginRoute("demo", "index.ts");
+
+    const { routes } = await listHandler();
+    const byPath = new Map(routes.map((r) => [r.routePath, r]));
+
+    expect(byPath.has("/x/ping")).toBe(true);
+    expect(byPath.get("/x/ping")!.filePath).toBe("routes/ping.ts");
+
+    expect(byPath.has("/x/plugins/demo/status")).toBe(true);
+    expect(byPath.get("/x/plugins/demo/status")!.filePath).toBe(
+      "plugins/demo/routes/status.ts",
+    );
+    expect(byPath.has("/x/plugins/demo/webhooks/incoming")).toBe(true);
+    // routes/index.ts maps to the plugin namespace root.
+    expect(byPath.has("/x/plugins/demo")).toBe(true);
+  });
+
+  test("excludes workspace files shadowed by the reserved plugin prefix", async () => {
+    writeWorkspaceRoute("ping.ts");
+    // A workspace file under routes/plugins/ is unreachable (the dispatcher
+    // routes /x/plugins/* to plugin dirs), so it must not be listed.
+    writeWorkspaceRoute("plugins/foo.ts");
+
+    const { routes } = await listHandler();
+    const paths = routes.map((r) => r.routePath);
+
+    expect(paths).toContain("/x/ping");
+    expect(paths).not.toContain("/x/plugins/foo");
+  });
+
+  test("excludes disabled plugins' routes", async () => {
+    writePluginRoute("live", "status.ts");
+    writePluginRoute("dead", "status.ts");
+    disablePlugin("dead");
+
+    const { routes } = await listHandler();
+    const paths = routes.map((r) => r.routePath);
+
+    expect(paths).toContain("/x/plugins/live/status");
+    expect(paths).not.toContain("/x/plugins/dead/status");
+  });
+});
+
+describe("routes inspect", () => {
+  test("inspects a plugin route by sub-path and by /x/-prefixed path", async () => {
+    writePluginRoute("demo", "status.ts");
+
+    const bare = await inspectHandler({
+      body: { path: "plugins/demo/status" },
+    });
+    expect(bare.route.routePath).toBe("/x/plugins/demo/status");
+    expect(bare.route.methods).toEqual(["GET"]);
+    expect(bare.route.filePath).toBe("plugins/demo/routes/status.ts");
+
+    // The `/x/`-prefixed form that `routes list` prints is accepted too.
+    const prefixed = await inspectHandler({
+      body: { path: "/x/plugins/demo/status" },
+    });
+    expect(prefixed.route.routePath).toBe("/x/plugins/demo/status");
+  });
+
+  test("inspects a workspace route", async () => {
+    writeWorkspaceRoute("ping.ts");
+    const res = await inspectHandler({ body: { path: "ping" } });
+    expect(res.route.routePath).toBe("/x/ping");
+    expect(res.route.filePath).toBe("routes/ping.ts");
+  });
+
+  test("404s a shadowed, missing, or disabled route", async () => {
+    writeWorkspaceRoute("plugins/foo.ts"); // shadowed workspace file
+    writePluginRoute("dead", "status.ts");
+    disablePlugin("dead");
+
+    // Shadowed: resolves to plugin "foo" (which has no routes dir) → not found.
+    await expect(
+      inspectHandler({ body: { path: "plugins/foo" } }),
+    ).rejects.toThrow();
+    // Missing plugin.
+    await expect(
+      inspectHandler({ body: { path: "plugins/ghost/status" } }),
+    ).rejects.toThrow();
+    // Disabled plugin.
+    await expect(
+      inspectHandler({ body: { path: "plugins/dead/status" } }),
+    ).rejects.toThrow();
+  });
+});

package/src/runtime/routes/app-management-routes.ts

@@ -8,6 +8,7 @@ import {
   mkdirSync,
   readdirSync,
   readFileSync,
+  statSync,
   writeFileSync,
 } from "node:fs";
 import { stat, unlink } from "node:fs/promises";
@@ -22,15 +23,16 @@ import {
   createAppRecord,
   deleteApp,
   deleteAppRecord,
-  getApp,
+  type EnumeratedApp,
   getAppDirPath,
   getAppPreview,
-  isMultifileApp,
+  isPluginAppId,
   listApps,
   listAppsByConversation,
+  listPluginApps,
   queryAppRecords,
-  resolveAppDir,
-  resolveEffectiveAppHtml,
+  resolveAppSource,
+  resolveEffectiveAppHtmlFromDir,
   updateApp,
   updateAppRecord,
 } from "../../apps/app-store.js";
@@ -75,7 +77,7 @@ function getSharedAppsDir(): string {
 // Extracted business logic
 // ---------------------------------------------------------------------------
 
-function listAppsFiltered(apps?: AppDefinition[]): Array<{
+interface AppListItem {
   id: string;
   name: string;
   description?: string;
@@ -84,21 +86,44 @@ function listAppsFiltered(apps?: AppDefinition[]): Array<{
   updatedAt: number;
   version: string;
   contentId: string;
-}> {
-  return (apps ?? listApps()).map((a) => {
-    const version = a.version ?? "1.0.0";
-    const contentId = computeContentId(a.name);
-    return {
-      id: a.id,
-      name: a.name,
-      description: a.description,
-      icon: a.icon,
-      createdAt: a.createdAt,
-      updatedAt: a.updatedAt,
-      version,
-      contentId,
-    };
-  });
+  /** "workspace" or "plugin:<name>" — identifies where the app comes from. */
+  origin: string;
+}
+
+function workspaceAppItem(a: AppDefinition): AppListItem {
+  return {
+    id: a.id,
+    name: a.name,
+    description: a.description,
+    icon: a.icon,
+    createdAt: a.createdAt,
+    updatedAt: a.updatedAt,
+    version: a.version ?? "1.0.0",
+    contentId: computeContentId(a.name),
+    origin: "workspace",
+  };
+}
+
+function pluginAppItem(app: EnumeratedApp): AppListItem {
+  // Plugin apps carry no stored timestamps; use the source dir mtime so the
+  // library can still order them sensibly.
+  let mtime = 0;
+  try {
+    mtime = statSync(app.sourcePath).mtimeMs;
+  } catch {
+    // Directory vanished between enumeration and stat — leave mtime at 0.
+  }
+  const pluginName =
+    app.origin.kind === "plugin" ? app.origin.pluginName : "unknown";
+  return {
+    id: app.id,
+    name: app.name,
+    createdAt: mtime,
+    updatedAt: mtime,
+    version: "1.0.0",
+    contentId: computeContentId(app.name),
+    origin: `plugin:${pluginName}`,
+  };
 }
 
 function getAppDataResult(
@@ -507,9 +532,17 @@ async function importBundle(
 function handleListApps({ queryParams }: RouteHandlerArgs) {
   const conversationId = queryParams?.conversationId;
   if (conversationId) {
-    return { apps: listAppsFiltered(listAppsByConversation(conversationId)) };
+    // Conversation scoping is a workspace-app concept; plugin apps are not
+    // associated with conversations, so they are omitted from this view.
+    return {
+      apps: listAppsByConversation(conversationId).map(workspaceAppItem),
+    };
   }
-  return { apps: listAppsFiltered() };
+  const apps: AppListItem[] = [
+    ...listApps().map(workspaceAppItem),
+    ...listPluginApps().map(pluginAppItem),
+  ];
+  return { apps };
 }
 
 async function handleOpenBundle({ body }: RouteHandlerArgs) {
@@ -607,6 +640,7 @@ function handleQueryAppData({ pathParams, queryParams }: RouteHandlerArgs) {
 
 function handleMutateAppData({ pathParams, body }: RouteHandlerArgs) {
   const appId = pathParams?.id as string;
+  assertNotPluginApp(appId, "modify a plugin app's data");
   const method = (body?.method as string) ?? "create";
   const result = getAppDataResult(
     method,
@@ -619,16 +653,19 @@ function handleMutateAppData({ pathParams, body }: RouteHandlerArgs) {
 
 async function handleOpenApp({ pathParams }: RouteHandlerArgs) {
   const appId = pathParams?.id as string;
-  const app = getApp(appId);
-  if (!app) {
+  const source = resolveAppSource(appId);
+  if (!source) {
     throw new NotFoundError(`App not found: ${appId}`);
   }
 
-  if (isMultifileApp(app)) {
-    const appDir = getAppDirPath(appId);
-    const distIndex = join(appDir, "dist", "index.html");
+  // Multifile workspace apps auto-compile on open when their dist is missing.
+  // Plugin apps are not compiled here — a compile cache for plugin sources is a
+  // follow-up — so a multifile plugin app without a prebuilt dist/ renders its
+  // fallback message.
+  if (source.formatVersion === 2 && source.origin.kind === "workspace") {
+    const distIndex = join(source.sourceDir, "dist", "index.html");
     if (!existsSync(distIndex)) {
-      const result = await compileApp(appDir);
+      const result = await compileApp(source.sourceDir);
       if (!result.ok) {
         log.warn(
           { appId, errors: result.errors },
@@ -637,13 +674,36 @@ async function handleOpenApp({ pathParams }: RouteHandlerArgs) {
       }
     }
   }
-  const html = resolveEffectiveAppHtml(app);
-  const { dirName } = resolveAppDir(app.id);
-  return { appId: app.id, dirName, name: app.name, html };
+
+  const html = resolveEffectiveAppHtmlFromDir(
+    source.sourceDir,
+    source.formatVersion,
+  );
+  return {
+    appId: source.id,
+    dirName: source.dirName,
+    name: source.name,
+    html,
+  };
+}
+
+/**
+ * Reject a mutation targeting a plugin-bundled app. Plugin apps are owned by
+ * their plugin and are read-only over this surface — their source is not
+ * user-editable and their lifecycle is the plugin's.
+ */
+function assertNotPluginApp(appId: string, action: string): void {
+  if (isPluginAppId(appId)) {
+    throw new BadRequestError(
+      `Plugin-bundled apps are read-only; cannot ${action}. This app is owned by its plugin.`,
+    );
+  }
 }
 
 function handleDeleteApp({ pathParams, headers }: RouteHandlerArgs) {
-  deleteApp(pathParams?.id as string);
+  const appId = pathParams?.id as string;
+  assertNotPluginApp(appId, "delete a plugin app");
+  deleteApp(appId);
   publishAppsChanged(getOriginClientId(headers));
   return { success: true };
 }
@@ -656,6 +716,7 @@ function handleGetPreview({ pathParams }: RouteHandlerArgs) {
 
 function handleUpdatePreview({ pathParams, body }: RouteHandlerArgs) {
   const appId = pathParams?.id as string;
+  assertNotPluginApp(appId, "update a plugin app's preview");
   if (!body?.preview) {
     throw new BadRequestError("preview is required");
   }
@@ -665,6 +726,7 @@ function handleUpdatePreview({ pathParams, body }: RouteHandlerArgs) {
 
 async function handleBundle({ pathParams }: RouteHandlerArgs) {
   const appId = pathParams?.id as string;
+  assertNotPluginApp(appId, "bundle a plugin app");
   const result = await packageApp(appId);
   return {
     type: "bundle_app_response",
@@ -676,6 +738,7 @@ async function handleBundle({ pathParams }: RouteHandlerArgs) {
 
 async function handleShareCloud({ pathParams }: RouteHandlerArgs) {
   const appId = pathParams?.id as string;
+  assertNotPluginApp(appId, "share a plugin app");
   const result = await packageApp(appId);
   const bundleData = readFileSync(result.bundlePath);
   const { shareToken } = createSharedAppLink(bundleData, result.manifest);
@@ -721,6 +784,7 @@ export const ROUTES: RouteDefinition[] = [
           updatedAt: z.number(),
           version: z.string(),
           contentId: z.string(),
+          origin: z.string(),
         }),
       ),
     }),

package/src/runtime/routes/app-routes.ts

@@ -9,10 +9,8 @@ import JSZip from "jszip";
 import { z } from "zod";
 
 import {
-  getApp,
-  getAppDirPath,
-  isMultifileApp,
-  readAppFileBytes,
+  readAppFileBytesFromDir,
+  resolveAppSource,
 } from "../../apps/app-store.js";
 import {
   createSharedAppLink,
@@ -78,11 +76,11 @@ function servePageHeaders({
   pathParams,
 }: ResponseHeaderArgs): Record<string, string> {
   const appId = pathParams?.appId as string;
-  const app = getApp(appId);
+  const source = resolveAppSource(appId);
   // Multifile apps use external scripts — no 'unsafe-inline' for script-src.
   // Legacy apps contain inline event handlers that require 'unsafe-inline'.
   const scriptSrc =
-    app && isMultifileApp(app) ? "'self'" : "'self' 'unsafe-inline'";
+    source && source.formatVersion === 2 ? "'self'" : "'self' 'unsafe-inline'";
   return {
     "Content-Type": "text/html; charset=utf-8",
     "Content-Security-Policy": buildCsp(scriptSrc),
@@ -95,18 +93,18 @@ function servePageHeaders({
 
 function handleServePage({ pathParams }: RouteHandlerArgs): string {
   const appId = pathParams?.appId as string;
-  const app = getApp(appId);
-  if (!app) {
+  const source = resolveAppSource(appId);
+  if (!source) {
     throw new NotFoundError("App not found");
   }
 
   // Multifile apps serve the compiled dist/index.html directly.
-  if (isMultifileApp(app)) {
-    return serveMultifileApp(appId, app.name);
+  if (source.formatVersion === 2) {
+    return serveMultifileApp(source.id, source.sourceDir, source.name);
   }
 
   const css = loadDesignSystemCss();
-  const escapedName = app.name.replace(
+  const escapedName = source.name.replace(
     /[<>&"]/g,
     (c) => HTML_ESCAPE_MAP[c] ?? c,
   );
@@ -114,9 +112,13 @@ function handleServePage({ pathParams }: RouteHandlerArgs): string {
   // Per-response nonce for inline <style> and <script> tags.
   const nonce = randomBytes(16).toString("base64");
 
+  // Single-file apps serve their root index.html.
+  const indexPath = join(source.sourceDir, "index.html");
+  const rawHtml = existsSync(indexPath) ? readFileSync(indexPath, "utf-8") : "";
+
   // Inject the nonce into any inline <script> tags from the app HTML definition
   // so they are allowed by the nonce-based CSP without 'unsafe-inline'.
-  const noncedHtml = app.htmlDefinition.replace(
+  const noncedHtml = rawHtml.replace(
     /<script(?=[\s>])/gi,
     `<script nonce="${nonce}"`,
   );
@@ -139,8 +141,12 @@ ${noncedHtml}
  * Serve compiled output for multifile TSX apps.
  * Falls back to a "not compiled yet" message if dist/index.html is missing.
  */
-function serveMultifileApp(appId: string, appName: string): string {
-  const distDir = join(getAppDirPath(appId), "dist");
+function serveMultifileApp(
+  appId: string,
+  appDir: string,
+  appName: string,
+): string {
+  const distDir = join(appDir, "dist");
   const indexPath = join(distDir, "index.html");
 
   if (!existsSync(indexPath)) {
@@ -236,7 +242,12 @@ function handleServeDistFile({ pathParams }: RouteHandlerArgs): Uint8Array {
     throw new BadRequestError("Invalid filename");
   }
 
-  const filePath = join(getAppDirPath(appId), "dist", filename);
+  const source = resolveAppSource(appId);
+  if (!source) {
+    throw new NotFoundError("App not found");
+  }
+
+  const filePath = join(source.sourceDir, "dist", filename);
   if (!existsSync(filePath)) {
     throw new NotFoundError("File not found");
   }
@@ -250,7 +261,7 @@ const MAX_APP_ASSET_BYTES = 25 * 1024 * 1024;
 /**
  * Serve a bundled file from anywhere in an app's directory (e.g.
  * `assets/intro.mp4`), for binary media an app can't practically inline as a
- * data-URI. `readAppFileBytes` runs the app-store path validation
+ * data-URI. `readAppFileBytesFromDir` runs the app-store path validation
  * (rejects `..`, absolute paths, symlink escapes, and the protected
  * `records/` directory), so authors bundle assets under the app dir and load
  * them via `window.vellum.asset(path)`.
@@ -272,9 +283,14 @@ function handleServeAppAsset({ pathParams }: RouteHandlerArgs): Uint8Array {
     throw new BadRequestError("Invalid asset path");
   }
 
+  const source = resolveAppSource(appId);
+  if (!source) {
+    throw new NotFoundError("Asset not found");
+  }
+
   let bytes: Buffer;
   try {
-    bytes = readAppFileBytes(appId, assetPath);
+    bytes = readAppFileBytesFromDir(source.sourceDir, assetPath);
   } catch (err) {
     const message = err instanceof Error ? err.message : "";
     if (message.includes("not found")) {