@vellumai/assistant 0.12.2-staging.2 → 0.12.2-staging.3

package/src/monitoring/mount-watch.ts

@@ -0,0 +1,348 @@
+/**
+ * Mount-table watcher for the assistant container, polled by the resource
+ * monitor.
+ *
+ * The monitor process shares the assistant container's mount namespace, so
+ * `/proc/self/mountinfo` is exactly that container's mounts (workspace and
+ * data PVC binds, plus any virtiofs handles). Gateway and CES sidecar mounts
+ * are out of scope. The watcher keeps a baseline and logs only when the
+ * watched set actually changes: a virtiofs bind that disappears, a fstype
+ * swap, or a statfs size collapse on `/workspace` or `/data`.
+ *
+ * Windows and macOS have no `/proc/self/mountinfo`; those platforms no-op.
+ */
+
+import { readFileSync, statfsSync } from "node:fs";
+
+import type { MonitoringConfig } from "../config/schemas/monitoring.js";
+import { getLogger } from "../util/logger.js";
+
+const log = getLogger("mount-watch");
+
+/** Assistant-container PVC bind targets in the managed pod template. */
+export const ASSISTANT_VOLUME_MOUNT_POINTS = ["/workspace", "/data"] as const;
+
+const VIRTIOFS_TYPES = new Set(["virtiofs", "fuse.virtiofs"]);
+
+export interface MountInfoEntry {
+  mountId: string;
+  parentId: string;
+  majorMinor: string;
+  root: string;
+  mountPoint: string;
+  mountOptions: string;
+  fsType: string;
+  source: string;
+  superOptions: string;
+}
+
+export interface PathFsSnapshot {
+  path: string;
+  /** `statfs.f_type`; null when the path could not be measured. */
+  type: number | null;
+  blockSize: number | null;
+  blocks: number | null;
+  files: number | null;
+  /** Present when the path exists but `statfs` failed. */
+  error?: string;
+}
+
+export interface MountSnapshot {
+  mounts: MountInfoEntry[];
+  paths: PathFsSnapshot[];
+}
+
+export interface MountDiff {
+  added: MountInfoEntry[];
+  removed: MountInfoEntry[];
+  changed: Array<{ previous: MountInfoEntry; current: MountInfoEntry }>;
+  pathChanges: Array<{ previous: PathFsSnapshot; current: PathFsSnapshot }>;
+}
+
+export interface CollectMountSnapshotOptions {
+  platform?: NodeJS.Platform;
+  readMountinfo?: () => string;
+  statPath?: (path: string) => PathFsSnapshot;
+  watchedMountPoints?: readonly string[];
+}
+
+export interface MountWatchHandle {
+  stop: () => void;
+}
+
+/**
+ * Kernel mountinfo encodes space/tab/newline in paths as octal escapes
+ * (`\040`, `\011`, `\012`) and a backslash as `\\`.
+ */
+export function unescapeMountField(value: string): string {
+  return value
+    .replace(/\\([0-7]{3})/g, (_match, oct: string) =>
+      String.fromCharCode(parseInt(oct, 8)),
+    )
+    .replace(/\\\\/g, "\\");
+}
+
+/**
+ * Parse `/proc/self/mountinfo` into structured entries. Malformed lines are
+ * skipped rather than failing the pass.
+ */
+export function parseMountinfo(raw: string): MountInfoEntry[] {
+  const entries: MountInfoEntry[] = [];
+  for (const line of raw.split("\n")) {
+    if (line.length === 0) {
+      continue;
+    }
+    const separator = line.indexOf(" - ");
+    if (separator < 0) {
+      continue;
+    }
+    const left = line.slice(0, separator).split(" ");
+    const right = line.slice(separator + 3).split(" ");
+    if (left.length < 6 || right.length < 3) {
+      continue;
+    }
+    entries.push({
+      mountId: left[0],
+      parentId: left[1],
+      majorMinor: left[2],
+      root: unescapeMountField(left[3]),
+      mountPoint: unescapeMountField(left[4]),
+      mountOptions: left[5],
+      fsType: unescapeMountField(right[0]),
+      source: unescapeMountField(right[1]),
+      superOptions: right.slice(2).join(" "),
+    });
+  }
+  return entries;
+}
+
+export function isWatchedMount(
+  entry: MountInfoEntry,
+  watchedMountPoints: readonly string[] = ASSISTANT_VOLUME_MOUNT_POINTS,
+): boolean {
+  if (VIRTIOFS_TYPES.has(entry.fsType)) {
+    return true;
+  }
+  return watchedMountPoints.some(
+    (point) => entry.mountPoint === point || entry.mountPoint.startsWith(`${point}/`),
+  );
+}
+
+function mountIdentity(entry: MountInfoEntry): string {
+  return entry.mountPoint;
+}
+
+function mountSignature(entry: MountInfoEntry): string {
+  return [
+    entry.fsType,
+    entry.source,
+    entry.majorMinor,
+    entry.root,
+    entry.mountOptions,
+    entry.superOptions,
+  ].join("\0");
+}
+
+function pathSignature(snapshot: PathFsSnapshot): string {
+  return [
+    String(snapshot.type),
+    String(snapshot.blockSize),
+    String(snapshot.blocks),
+    String(snapshot.files),
+    snapshot.error ?? "",
+  ].join("\0");
+}
+
+export function diffMountSnapshots(
+  previous: MountSnapshot,
+  current: MountSnapshot,
+): MountDiff {
+  const prevByPoint = new Map(
+    previous.mounts.map((entry) => [mountIdentity(entry), entry]),
+  );
+  const currentByPoint = new Map(
+    current.mounts.map((entry) => [mountIdentity(entry), entry]),
+  );
+
+  const added: MountInfoEntry[] = [];
+  const removed: MountInfoEntry[] = [];
+  const changed: Array<{ previous: MountInfoEntry; current: MountInfoEntry }> =
+    [];
+
+  for (const [point, entry] of currentByPoint) {
+    const prior = prevByPoint.get(point);
+    if (prior == null) {
+      added.push(entry);
+      continue;
+    }
+    if (mountSignature(prior) !== mountSignature(entry)) {
+      changed.push({ previous: prior, current: entry });
+    }
+  }
+  for (const [point, entry] of prevByPoint) {
+    if (!currentByPoint.has(point)) {
+      removed.push(entry);
+    }
+  }
+
+  const prevPaths = new Map(previous.paths.map((row) => [row.path, row]));
+  const pathChanges: Array<{
+    previous: PathFsSnapshot;
+    current: PathFsSnapshot;
+  }> = [];
+  for (const row of current.paths) {
+    const prior = prevPaths.get(row.path);
+    if (prior != null && pathSignature(prior) !== pathSignature(row)) {
+      pathChanges.push({ previous: prior, current: row });
+    }
+  }
+
+  return { added, removed, changed, pathChanges };
+}
+
+export function mountDiffIsEmpty(diff: MountDiff): boolean {
+  return (
+    diff.added.length === 0 &&
+    diff.removed.length === 0 &&
+    diff.changed.length === 0 &&
+    diff.pathChanges.length === 0
+  );
+}
+
+function defaultReadMountinfo(): string {
+  return readFileSync("/proc/self/mountinfo", "utf8");
+}
+
+function defaultStatPath(path: string): PathFsSnapshot {
+  try {
+    const stats = statfsSync(path);
+    return {
+      path,
+      type: Number(stats.type),
+      blockSize: Number(stats.bsize),
+      blocks: Number(stats.blocks),
+      files: Number(stats.files),
+    };
+  } catch {
+    return {
+      path,
+      type: null,
+      blockSize: null,
+      blocks: null,
+      files: null,
+      error: "statfs-failed",
+    };
+  }
+}
+
+/**
+ * Snapshot the assistant container's watched mounts. Returns null on Windows
+ * and macOS, or when `/proc/self/mountinfo` is unreadable.
+ */
+export function collectMountSnapshot(
+  options: CollectMountSnapshotOptions = {},
+): MountSnapshot | null {
+  const platform = options.platform ?? process.platform;
+  if (platform === "win32" || platform === "darwin") {
+    return null;
+  }
+
+  const watchedMountPoints =
+    options.watchedMountPoints ?? ASSISTANT_VOLUME_MOUNT_POINTS;
+  const readMountinfo = options.readMountinfo ?? defaultReadMountinfo;
+  const statPath = options.statPath ?? defaultStatPath;
+
+  let raw: string;
+  try {
+    raw = readMountinfo();
+  } catch {
+    return null;
+  }
+
+  const mounts = parseMountinfo(raw)
+    .filter((entry) => isWatchedMount(entry, watchedMountPoints))
+    .sort((a, b) => a.mountPoint.localeCompare(b.mountPoint));
+
+  const paths = watchedMountPoints.map((path) => statPath(path));
+
+  return { mounts, paths };
+}
+
+function summarizeEntry(entry: MountInfoEntry): Record<string, string> {
+  return {
+    mountPoint: entry.mountPoint,
+    fsType: entry.fsType,
+    source: entry.source,
+    majorMinor: entry.majorMinor,
+  };
+}
+
+function summarizePath(snapshot: PathFsSnapshot): Record<string, unknown> {
+  return {
+    path: snapshot.path,
+    type: snapshot.type,
+    blockSize: snapshot.blockSize,
+    blocks: snapshot.blocks,
+    files: snapshot.files,
+    ...(snapshot.error != null ? { error: snapshot.error } : {}),
+  };
+}
+
+export function logMountDiff(diff: MountDiff): void {
+  log.warn(
+    {
+      added: diff.added.map(summarizeEntry),
+      removed: diff.removed.map(summarizeEntry),
+      changed: diff.changed.map((row) => ({
+        previous: summarizeEntry(row.previous),
+        current: summarizeEntry(row.current),
+      })),
+      pathChanges: diff.pathChanges.map((row) => ({
+        previous: summarizePath(row.previous),
+        current: summarizePath(row.current),
+      })),
+    },
+    "Assistant container mount table changed",
+  );
+}
+
+/**
+ * Start the mount poller. The first pass establishes a silent baseline so a
+ * healthy boot does not log; later passes warn only when the watched mounts
+ * or `/workspace`/`/data` statfs values change.
+ *
+ * The timer is unref'd: the resource sampler is the monitor process's
+ * keep-alive, and this loop must not extend its life on its own.
+ */
+export function startMountWatch(
+  config: MonitoringConfig,
+  options: CollectMountSnapshotOptions = {},
+): MountWatchHandle {
+  let previous: MountSnapshot | null = null;
+
+  const poll = () => {
+    try {
+      const snapshot = collectMountSnapshot(options);
+      if (snapshot == null) {
+        return;
+      }
+      if (previous != null) {
+        const diff = diffMountSnapshots(previous, snapshot);
+        if (!mountDiffIsEmpty(diff)) {
+          logMountDiff(diff);
+        }
+      }
+      previous = snapshot;
+    } catch (err) {
+      log.warn({ err }, "Mount-watch poll failed");
+    }
+  };
+
+  poll();
+  const timer = setInterval(poll, config.mountWatchIntervalMs);
+  timer.unref?.();
+
+  return {
+    stop: () => clearInterval(timer),
+  };
+}

package/src/monitoring/worker.ts

@@ -49,6 +49,7 @@ import {
   type FileDescriptorMonitorHandle,
   startFileDescriptorMonitor,
 } from "./file-descriptors.js";
+import { type MountWatchHandle, startMountWatch } from "./mount-watch.js";
 import {
   type PluginAutoUpdateHandle,
   startPluginAutoUpdate,
@@ -99,6 +100,7 @@ async function main(): Promise<void> {
 
   let sampler: ResourceSamplerHandle | null = null;
   let fdMonitor: FileDescriptorMonitorHandle | null = null;
+  let mountWatch: MountWatchHandle | null = null;
   let sourceWatch: PluginSourceWatchHandle | null = null;
   let autoUpdate: PluginAutoUpdateHandle | null = null;
   let recovery: RecoveryHandle | null = null;
@@ -125,6 +127,7 @@ async function main(): Promise<void> {
     stopDbIntegritySampler();
     autoUpdate?.stop();
     sourceWatch?.stop();
+    mountWatch?.stop();
     fdMonitor?.stop();
     sampler?.stop();
     // Bounded final telemetry flush, mirroring the daemon's shutdown. This
@@ -170,6 +173,9 @@ async function main(): Promise<void> {
   // Descriptor exhaustion is per-process and slow-moving, so it polls on its
   // own timer rather than riding the memory sampler's 250ms tick.
   fdMonitor = startFileDescriptorMonitor(config.monitoring);
+  // Assistant-container mount table only (this process's mount namespace).
+  // Warns only when /workspace, /data, or a virtiofs bind actually changes.
+  mountWatch = startMountWatch(config.monitoring);
   sourceWatch = startPluginSourceWatch(
     config.monitoring.pluginSourceScanIntervalMs,
   );
@@ -211,6 +217,7 @@ async function main(): Promise<void> {
     recovery?.stop();
     autoUpdate?.stop();
     sourceWatch?.stop();
+    mountWatch?.stop();
     fdMonitor?.stop();
     sampler?.stop();
     stopDbIntegritySampler();
@@ -223,6 +230,7 @@ async function main(): Promise<void> {
     recovery?.stop();
     autoUpdate?.stop();
     sourceWatch?.stop();
+    mountWatch?.stop();
     fdMonitor?.stop();
     sampler?.stop();
     stopDbIntegritySampler();
@@ -234,6 +242,7 @@ async function main(): Promise<void> {
     recovery?.stop();
     autoUpdate?.stop();
     sourceWatch?.stop();
+    mountWatch?.stop();
     fdMonitor?.stop();
     sampler?.stop();
     stopDbIntegritySampler();

package/src/oauth/seed-providers.ts

@@ -1403,6 +1403,12 @@ export const PROVIDER_SEED_DATA: Record<
       "read_discounts",
       "write_discounts",
       "read_price_rules",
+      // write_themes covers listing, duplicating, and publishing themes.
+      // Writing theme files (settings, JSON templates, Liquid) also requires
+      // Shopify's theme-code exemption on the app itself, which is granted
+      // per app in the Shopify dashboard rather than through a scope.
+      "read_themes",
+      "write_themes",
     ],
     availableScopes: [
       {
@@ -1455,6 +1461,11 @@ export const PROVIDER_SEED_DATA: Record<
         scope: "write_price_rules",
         description: "Create and update price rules",
       },
+      { scope: "read_themes", description: "Read themes and theme files" },
+      {
+        scope: "write_themes",
+        description: "Create, publish, and edit themes and theme files",
+      },
       { scope: "read_files", description: "Read files uploaded to the store" },
       { scope: "write_files", description: "Upload and update files" },
       { scope: "read_gift_cards", description: "Read gift cards" },

package/src/onboarding/checkin-event.ts

@@ -69,7 +69,8 @@ export function buildCheckinTitle({
  * Google Calendar strips nearly all styling, so the body relies only on the
  * tags that survive (`<p>`, `<strong>`, `<a>`, emoji) and makes the CTA a bold
  * link rather than a styled button. The deep link opens a fresh conversation
- * (`uuid`) pre-seeded with the first-week prompt.
+ * (`uuid`) with the first-week prompt staged in the composer; the user sends
+ * it. A clicked link never auto-sends (`clients/web/src/utils/auto-send-prompt.ts`).
  */
 export function buildCheckinDescription(uuid: string): string {
   // `vref` is an app-owned attribution param, NOT a marketing `utm_*`: the

package/src/plugins/__tests__/installed-plugin-dirs.test.ts

@@ -45,10 +45,23 @@ beforeEach(() => {
 describe("listInstalledPluginDirs", () => {
   test("lists real plugin directories and skips dot entries", () => {
     makePluginDir(pluginsDir, "alpha");
+    const standard = join(pluginsDir, "standard");
+    mkdirSync(standard, { recursive: true });
+    writeFileSync(
+      join(standard, "plugin.json"),
+      JSON.stringify({
+        $schema: "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+        name: "standard",
+      }),
+    );
     makePluginDir(pluginsDir, ".hidden");
     mkdirSync(join(pluginsDir, "no-manifest"), { recursive: true });
 
-    expect(listInstalledPluginDirs().map((p) => p.name)).toEqual(["alpha"]);
+    expect(
+      listInstalledPluginDirs()
+        .map((p) => p.name)
+        .sort(),
+    ).toEqual(["alpha", "standard"]);
   });
 
   test("skips a symlinked plugin root that points outside the plugins dir", () => {

package/src/plugins/__tests__/mcp-servers.test.ts

@@ -24,17 +24,27 @@ import {
 function makePluginsDir(
   plugins: Record<
     string,
-    { mcpJson?: string; packageJson?: string; disabled?: boolean }
+    {
+      mcpJson?: string;
+      packageJson?: string | null;
+      pluginJson?: string;
+      disabled?: boolean;
+    }
   >,
 ): string {
   const root = mkdtempSync(join(tmpdir(), "vellum-plugin-mcp-"));
   for (const [name, spec] of Object.entries(plugins)) {
     const dir = join(root, name);
     mkdirSync(dir, { recursive: true });
-    writeFileSync(
-      join(dir, "package.json"),
-      spec.packageJson ?? JSON.stringify({ name, version: "1.0.0" }),
-    );
+    if (spec.packageJson !== null) {
+      writeFileSync(
+        join(dir, "package.json"),
+        spec.packageJson ?? JSON.stringify({ name, version: "1.0.0" }),
+      );
+    }
+    if (spec.pluginJson !== undefined) {
+      writeFileSync(join(dir, "plugin.json"), spec.pluginJson);
+    }
     if (spec.mcpJson !== undefined) {
       writeFileSync(join(dir, "mcp.json"), spec.mcpJson);
     }
@@ -137,6 +147,26 @@ describe("readPluginMcpServers", () => {
     });
   });
 
+  test("reads MCP servers from a standard-only plugin", () => {
+    const dir = makePluginsDir({
+      unabyss: {
+        packageJson: null,
+        pluginJson: JSON.stringify({
+          $schema: "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+          name: "unabyss",
+        }),
+        mcpJson: VALID_MANIFEST,
+      },
+    });
+
+    const { servers, issues } = readPluginMcpServers({
+      workspacePluginsDir: dir,
+    });
+
+    expect(issues).toEqual([]);
+    expect(servers.map((server) => server.id)).toEqual(["unabyss"]);
+  });
+
   test("defaults an omitted type to streamable-http", () => {
     const dir = makePluginsDir({
       openseo: {
@@ -205,7 +235,7 @@ describe("readPluginMcpServers", () => {
       workspacePluginsDir: root,
     });
     expect(servers).toEqual([]);
-    expect(issues[0].message).toContain("package.json");
+    expect(issues[0].message).toContain("selected plugin manifest");
   });
 
   test("ignores a directory whose package.json is unparseable", () => {
@@ -216,7 +246,7 @@ describe("readPluginMcpServers", () => {
       workspacePluginsDir: dir,
     });
     expect(servers).toEqual([]);
-    expect(issues[0].message).toContain("package.json");
+    expect(issues[0].message).toContain("selected plugin manifest");
   });
 
   test("ignores a directory whose package.json has no name", () => {
@@ -230,7 +260,7 @@ describe("readPluginMcpServers", () => {
       workspacePluginsDir: dir,
     });
     expect(servers).toEqual([]);
-    expect(issues[0].message).toContain("package.json");
+    expect(issues[0].message).toContain("selected plugin manifest");
   });
 
   test("skips plugins with no mcp.json without complaining", () => {