@vellumai/assistant 0.8.9-staging.3 → 0.8.9-staging.5

package/src/__tests__/plugin-external-api.test.ts

@@ -0,0 +1,68 @@
+/**
+ * Tests for the `globalThis.__vellumPluginRuntime` bridge.
+ *
+ * The bridge exists so workspace-local plugins (`<workspaceDir>/plugins/*`)
+ * can register with the daemon's bundled module instances even when the
+ * daemon is a `bun --compile` binary. Absolute-path imports against a
+ * compiled binary load fresh disk copies into a disjoint module graph; the
+ * bridge sidesteps that by attaching a stable handle to globalThis.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  getPluginRuntime,
+  installPluginRuntime,
+  uninstallPluginRuntimeForTests,
+} from "../plugins/external-api.js";
+import { registerPlugin } from "../plugins/registry.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { getSecureKeyAsync } from "../security/secure-keys.js";
+
+describe("plugin external-api bridge", () => {
+  beforeEach(() => {
+    uninstallPluginRuntimeForTests();
+  });
+
+  afterEach(() => {
+    uninstallPluginRuntimeForTests();
+  });
+
+  test("installs a runtime handle on globalThis", () => {
+    expect(getPluginRuntime()).toBeUndefined();
+    installPluginRuntime();
+    const runtime = getPluginRuntime();
+    expect(runtime).toBeDefined();
+    expect(runtime?.version).toBe(1);
+  });
+
+  test("exposes the canonical registerPlugin / hub / secrets references", () => {
+    installPluginRuntime();
+    const runtime = getPluginRuntime();
+    expect(runtime?.registerPlugin).toBe(registerPlugin);
+    expect(runtime?.assistantEventHub).toBe(assistantEventHub);
+    expect(runtime?.getSecureKeyAsync).toBe(getSecureKeyAsync);
+  });
+
+  test("plugins can read the runtime via the documented globalThis key", () => {
+    installPluginRuntime();
+    // Mirror the access pattern documented for plugin authors.
+    const runtime = (
+      globalThis as { __vellumPluginRuntime?: { version: number } }
+    ).__vellumPluginRuntime;
+    expect(runtime).toBeDefined();
+    expect(runtime?.version).toBe(1);
+  });
+
+  test("install is idempotent — repeat calls preserve the same handle", () => {
+    installPluginRuntime();
+    const first = getPluginRuntime();
+    installPluginRuntime();
+    installPluginRuntime();
+    expect(getPluginRuntime()).toBe(first);
+  });
+
+  test("getPluginRuntime returns undefined when the bridge is not installed", () => {
+    expect(getPluginRuntime()).toBeUndefined();
+  });
+});

package/src/__tests__/published-app-updater.test.ts

@@ -0,0 +1,138 @@
+/**
+ * Tests that the auto-redeploy path deploys the app's *effective* HTML
+ * (dist/index.html for multifile apps) rather than the empty `htmlDefinition`.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { AppDefinition } from "../memory/app-store.js";
+
+// ── Mocks ───────────────────────────────────────────────────────────────
+
+let mockApp: AppDefinition | null = null;
+let mockIsMultifile = false;
+let mockEffectiveHtml = "";
+// A directory that does not exist on disk, so the multifile dist-existence
+// guard reads `false` from the real fs without mocking node:fs (which would
+// leak across test files).
+let mockAppDir = "/tmp/__vellum_test_nonexistent__/app-1";
+
+mock.module("../memory/app-store.js", () => ({
+  getApp: () => mockApp,
+  getAppDirPath: () => mockAppDir,
+  isMultifileApp: () => mockIsMultifile,
+  resolveEffectiveAppHtml: () => mockEffectiveHtml,
+}));
+
+let mockPublishedPage: {
+  id: string;
+  projectSlug?: string;
+  htmlHash: string;
+} | null = null;
+const updatePublishedPageSpy = mock(() => {});
+
+mock.module("../memory/published-pages-store.js", () => ({
+  getActivePublishedPageByAppId: () => mockPublishedPage,
+  updatePublishedPage: updatePublishedPageSpy,
+}));
+
+const deploySpy = mock(async (_args: { html: string; name: string }) => ({
+  deploymentId: "dep-1",
+  url: "https://example.vercel.app",
+}));
+
+mock.module("../services/vercel-deploy.js", () => ({
+  deployHtmlToVercel: deploySpy,
+}));
+
+// credentialBroker.serverUse invokes execute(token) and reports success.
+mock.module("../tools/credentials/broker.js", () => ({
+  credentialBroker: {
+    serverUse: async ({
+      execute,
+    }: {
+      execute: (token: string) => Promise<unknown>;
+    }) => {
+      await execute("test-token");
+      return { success: true };
+    },
+  },
+}));
+
+const { updatePublishedAppDeployment } =
+  await import("../services/published-app-updater.js");
+
+function makeApp(overrides: Partial<AppDefinition> = {}): AppDefinition {
+  return {
+    id: "app-1",
+    name: "App",
+    schemaJson: "{}",
+    htmlDefinition: "",
+    createdAt: 1,
+    updatedAt: 2,
+    ...overrides,
+  };
+}
+
+// ── Tests ───────────────────────────────────────────────────────────────
+
+describe("updatePublishedAppDeployment", () => {
+  beforeEach(() => {
+    mockApp = makeApp();
+    mockIsMultifile = false;
+    mockEffectiveHtml = "";
+    mockPublishedPage = { id: "pp-1", projectSlug: "slug", htmlHash: "old" };
+    mockAppDir = "/tmp/__vellum_test_nonexistent__/app-1";
+    deploySpy.mockClear();
+    updatePublishedPageSpy.mockClear();
+  });
+
+  test("deploys the resolved effective HTML, not the empty htmlDefinition", async () => {
+    // htmlDefinition is "" (as it is for every multifile app); the real
+    // content comes from resolveEffectiveAppHtml. isMultifile=false here keeps
+    // the dist guard out of the way so the assertion targets the html source.
+    mockApp = makeApp({ htmlDefinition: "" });
+    mockEffectiveHtml = "<html><body>real app</body></html>";
+
+    await updatePublishedAppDeployment("app-1");
+
+    expect(deploySpy).toHaveBeenCalledTimes(1);
+    expect(deploySpy.mock.calls[0][0].html).toBe(
+      "<html><body>real app</body></html>",
+    );
+  });
+
+  test("skips deploy when a multifile app has no compiled output", async () => {
+    mockIsMultifile = true;
+    mockApp = makeApp({ formatVersion: 2 });
+    mockEffectiveHtml = "<p>App compilation failed.</p>";
+    // mockAppDir does not exist → dist/index.html is absent.
+
+    await updatePublishedAppDeployment("app-1");
+
+    expect(deploySpy).not.toHaveBeenCalled();
+  });
+
+  test("skips deploy when content hash is unchanged", async () => {
+    const html = "<html>same</html>";
+    mockEffectiveHtml = html;
+    const { createHash } = await import("node:crypto");
+    mockPublishedPage = {
+      id: "pp-1",
+      htmlHash: createHash("sha256").update(html).digest("hex"),
+    };
+
+    await updatePublishedAppDeployment("app-1");
+
+    expect(deploySpy).not.toHaveBeenCalled();
+  });
+
+  test("skips deploy when the app has no active published page", async () => {
+    mockPublishedPage = null;
+    mockEffectiveHtml = "<html>x</html>";
+
+    await updatePublishedAppDeployment("app-1");
+
+    expect(deploySpy).not.toHaveBeenCalled();
+  });
+});

package/src/api/responses/memory-v3-selection-log.ts

@@ -1,7 +1,7 @@
 /**
  * Wire contract for the memory v3 selection set surfaced in the inspector's
  * Memory tab. Mirrors the return value of `getMemoryV3SelectionForInspector`
- * in `assistant/src/memory/v3/selection-log-store.ts`.
+ * in `assistant/src/plugins/defaults/memory-v3-shadow/selection-log-store.ts`.
  *
  * Canonical wire-contract source. Assistant code imports the types directly
  * from this file via relative paths; external consumers (web client, gateway,
@@ -12,19 +12,27 @@
  * `live` / `shadow` reflect the CURRENT `memory-v3-live` / `memory-v3-shadow`
  * flag state, not the per-turn history (the selection rows don't record which
  * mode was active when they were written). When `live` is true the rendered
- * `injectedText` block was actually injected into the turn; when only `shadow`
- * is true it is the block that WOULD have been injected. For stable-flag
- * shadow validation these coincide; recording per-turn `injected` is a
- * documented follow-up.
+ * `injectedText` reflects the live selection; when only `shadow` is true it is
+ * the block that WOULD have been injected.
+ *
+ * `injectedText` is APPROXIMATE, not a verbatim record. It is re-rendered from
+ * the persisted selection rows, which store slug/source/pinned but NOT the
+ * matched-section identity. A page that live injection sent as a single matched
+ * section is re-rendered here as its FULL page (the section ordinal isn't
+ * persisted), so the text can differ from what was actually sent to the model.
+ * The selected slug set is exact — only the rendered text is full-page
+ * approximate. Persisting the per-turn injected section is a documented
+ * follow-up.
  */
 
 import { z } from "zod";
 
 /**
  * One selected page in the v3 set. `source` is the lane that surfaced it —
- * the daemon emits `l1+l2`, `core+l2`, `needle`, or `carry-forward` — but the
- * schema stays a permissive string so a new lane label doesn't break parsing
- * on the FE. `pinned` marks a slug carried forward across turns.
+ * the daemon emits `needle`, `dense`, `edge`, or `carry-forward` — but the
+ * schema stays a permissive string so a new lane label (or a historical
+ * pre-lane row) doesn't break parsing on the FE. `pinned` marks a slug carried
+ * forward across turns.
  */
 export const MemoryV3SelectionRowSchema = z.object({
   slug: z.string(),
@@ -36,8 +44,9 @@ export type MemoryV3SelectionRow = z.infer<typeof MemoryV3SelectionRowSchema>;
 
 /**
  * Memory v3 selection log shape. `injectedText` is the rendered
- * `<memory>…</memory>` block for the selection (actual when `live`, would-be
- * when `shadow`-only).
+ * `<memory>…</memory>` block for the selection — APPROXIMATE: re-rendered from
+ * the persisted rows, with full pages where live injection used a matched
+ * section (the section identity isn't persisted). See the file header.
  */
 export const MemoryV3SelectionLogSchema = z.object({
   turn: z.number(),