@vellumai/assistant 0.12.1 → 0.12.2-staging.2

package/src/daemon/skill-memory-refresh.ts

@@ -8,16 +8,24 @@ import {
   maybeSeedCapabilitySkills,
   maybeSeedCliCommandCards,
 } from "../plugins/defaults/memory/substrate/boot-maintenance.js";
+import { readWorkspaceSkillMdSignature } from "../skills/workspace-skill-md-signature.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("skill-memory-refresh");
 
+/** Poll interval for workspace `SKILL.md` mtimes. Stats only, no tree walk. */
+export const SKILL_MD_MTIME_POLL_MS = 1_500;
+
+let lastSignature: string | undefined;
+let pollTimer: ReturnType<typeof setInterval> | undefined;
+
 export function refreshSkillCapabilityMemories(
   config: AssistantConfig = getConfig(),
 ): void {
   seedSkillGraphNodes();
   maybeSeedCapabilitySkills(config);
   maybeSeedCliCommandCards(config);
+  lastSignature = readWorkspaceSkillMdSignature();
   void seedUninstalledCatalogSkillMemories()
     .then(() => {
       // Re-run after the async catalog fetch populates the cache so stale
@@ -31,3 +39,59 @@ export function refreshSkillCapabilityMemories(
       ),
     );
 }
+
+/**
+ * Reseed skill capability memories when the workspace `SKILL.md` set or
+ * mtimes have changed since the last refresh in this process. No-op when the
+ * signature is unchanged. First call in a process always reseeds so the
+ * memory worker, whose in-process skill cache starts empty, picks up the
+ * catalog without waiting for an install path.
+ */
+export function maybeRefreshSkillCapabilityMemoriesFromMtime(): boolean {
+  const signature = readWorkspaceSkillMdSignature();
+  if (lastSignature !== undefined && signature === lastSignature) {
+    return false;
+  }
+  if (lastSignature !== undefined) {
+    log.info("Workspace SKILL.md set changed, reseeding capability memories");
+  }
+  refreshSkillCapabilityMemories();
+  return true;
+}
+
+function pollOnce(): void {
+  try {
+    maybeRefreshSkillCapabilityMemoriesFromMtime();
+  } catch (err) {
+    log.warn({ err }, "SKILL.md mtime poll failed");
+  }
+}
+
+/**
+ * Start a per-process poll of workspace `SKILL.md` mtimes. Idempotent.
+ * The memory worker and the assistant each run this against their own
+ * in-process skill caches. Runs once immediately so a worker that has never
+ * seeded picks up the catalog without waiting a tick.
+ */
+export function startWorkspaceSkillMdMtimePoll(): void {
+  if (pollTimer !== undefined) {
+    return;
+  }
+  pollOnce();
+  pollTimer = setInterval(pollOnce, SKILL_MD_MTIME_POLL_MS);
+  pollTimer.unref?.();
+}
+
+export function stopWorkspaceSkillMdMtimePoll(): void {
+  if (pollTimer === undefined) {
+    return;
+  }
+  clearInterval(pollTimer);
+  pollTimer = undefined;
+}
+
+/** @internal Test-only: clear the in-process signature and poll timer. */
+export function _resetSkillMdMtimeStateForTests(): void {
+  lastSignature = undefined;
+  stopWorkspaceSkillMdMtimePoll();
+}

package/src/daemon/tool-side-effects.ts

@@ -18,17 +18,15 @@ import { invalidateEdgeIndex } from "../plugins/defaults/memory/substrate/edge-i
 import { invalidatePageIndex } from "../plugins/defaults/memory/substrate/page-index.js";
 import { getConceptsDir } from "../plugins/defaults/memory/substrate/page-store.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
-import {
-  publishAppsChanged,
-  publishDocumentsChanged,
-} from "../runtime/sync/resource-sync-events.js";
-import { updatePublishedAppDeployment } from "../services/published-app-updater.js";
+import { publishDocumentsChanged } from "../runtime/sync/resource-sync-events.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { getLogger } from "../util/logger.js";
 import { getWorkspaceDir } from "../util/platform.js";
-import { ensureAppSourceWatcher } from "./app-source-watcher.js";
+import {
+  broadcastAppFilesChanged,
+  notifyAppSurfacesChanged,
+} from "./app-change-notify.js";
 import type { Conversation } from "./conversation.js";
-import { refreshSurfacesForApp } from "./conversation-surfaces.js";
 import { isDoordashCommand, updateDoordashProgress } from "./doordash-steps.js";
 
 const log = getLogger("tool-side-effects");
@@ -54,7 +52,7 @@ export type PostExecutionHook = (
  * Compilation is the responsibility of the tool executor (see
  * `executeAppCreate`, `executeAppRefresh`): executors own the source→dist
  * transform and surface `compile_errors` in their result when it fails.
- * Post-execution hooks only observe the outcome and notify — they must
+ * Post-execution hooks only observe the outcome and notify. They must
  * not re-run a compile because `compileApp()` begins with `rm -rf dist/`
  * and would race with the executor's own output (LUM-1153).
  */
@@ -63,14 +61,7 @@ function notifyAppChanged(
   appId: string,
   opts?: { fileChange?: boolean; status?: string },
 ): void {
-  refreshSurfacesForApp(ctx, appId, opts);
-  broadcastAppFilesChanged(appId);
-  void updatePublishedAppDeployment(appId);
-}
-
-function broadcastAppFilesChanged(appId: string): void {
-  broadcastMessage({ type: "app_files_changed", appId });
-  publishAppsChanged();
+  notifyAppSurfacesChanged(appId, opts, ctx);
 }
 
 /**
@@ -128,8 +119,6 @@ registerHook("app_create", (_name, _input, result, { ctx }) => {
     log.warn({ err, appId }, "Failed to track conversation ID on app_create");
   }
 
-  ensureAppSourceWatcher();
-
   notifyAppChanged(ctx, appId);
 
   // Seed background icon generation from the created app's canonical record

package/src/desktop/__tests__/fake-desktop.ts

@@ -0,0 +1,122 @@
+import { join } from "node:path";
+
+import { sleep } from "../../util/retry.js";
+import {
+  type DesktopChild,
+  type DesktopChildRole,
+  type DesktopLoss,
+  DesktopSessionManager,
+  type DesktopSpawnRequest,
+} from "../desktop-session-manager.js";
+
+/** A child the test exits by hand. */
+class FakeChild implements DesktopChild {
+  private static nextPid = 1000;
+  readonly pid = FakeChild.nextPid++;
+  readonly exited: Promise<number>;
+  private settle!: (code: number) => void;
+
+  constructor(
+    readonly role: DesktopChildRole,
+    readonly request: DesktopSpawnRequest,
+  ) {
+    this.exited = new Promise((resolve) => {
+      this.settle = resolve;
+    });
+  }
+
+  kill(): void {}
+
+  exit(code = 0): void {
+    this.settle(code);
+  }
+}
+
+export const LINGER_MS = 20;
+export const KILL_GRACE_MS = 20;
+
+export interface FakeDesktopOptions {
+  profileDir: string;
+  /** Defaults inside `profileDir`, for tests that ignore the dock's config. */
+  panelConfigDir?: string;
+  /** Roles whose spawn throws, to exercise a start that fails partway. */
+  failSpawn?: DesktopChildRole[];
+  /** Binaries `which` cannot find. */
+  missingBinaries?: string[];
+  /** Whether a SIGTERM makes the fake child exit on its own. */
+  exitOnTerm?: boolean;
+  /** Whether a SIGKILL does; without either the child survives both. */
+  exitOnKill?: boolean;
+  sourceEnv?: NodeJS.ProcessEnv;
+  panelRestartDelayMs?: number;
+  renderWallpaper?: (width: number, height: number) => Promise<Buffer | null>;
+}
+
+export function newFakeDesktop(options: FakeDesktopOptions) {
+  const spawned: FakeChild[] = [];
+  const killed: { child: FakeChild; signal: string }[] = [];
+  let vncReady = true;
+  let chromiumPath: () => Promise<string> = async () => "/fake/chromium";
+  const manager = new DesktopSessionManager({
+    spawn: (role, request) => {
+      if (options.failSpawn?.includes(role)) {
+        throw new Error(`spawn ${role} failed`);
+      }
+      const child = new FakeChild(role, request);
+      spawned.push(child);
+      return child;
+    },
+    which: (binary) =>
+      options.missingBinaries?.includes(binary) ? null : `/usr/bin/${binary}`,
+    probeVncPort: async () => vncReady,
+    resolveChromePath: () => chromiumPath(),
+    renderWallpaper: options.renderWallpaper ?? (async () => null),
+    killProcessGroup: (child, signal) => {
+      killed.push({ child: child as FakeChild, signal });
+      const exits =
+        signal === "SIGTERM" ? options.exitOnTerm : options.exitOnKill;
+      if (exits) {
+        (child as FakeChild).exit(0);
+      }
+    },
+    lingerMs: LINGER_MS,
+    readyDeadlineMs: 30,
+    killGraceMs: KILL_GRACE_MS,
+    profileDir: options.profileDir,
+    panelConfigDir:
+      options.panelConfigDir ?? join(options.profileDir, "desktop-panel"),
+    sourceEnv: options.sourceEnv,
+    panelRestartDelayMs: options.panelRestartDelayMs,
+    writeWindowManagerConfig: (configDir) => join(configDir, "openbox.xml"),
+  });
+  return {
+    manager,
+    spawned,
+    killed,
+    /** Children that got a SIGTERM, in order. */
+    terminated: () =>
+      killed.filter((k) => k.signal === "SIGTERM").map((k) => k.child),
+    setVncReady: (ready: boolean) => {
+      vncReady = ready;
+    },
+    setChromiumPath: (resolve: () => Promise<string>) => {
+      chromiumPath = resolve;
+    },
+    child: (role: DesktopChildRole) =>
+      spawned.filter((c) => c.role === role).at(-1)!,
+    roles: () => spawned.map((c) => c.role),
+    count: (role: DesktopChildRole) =>
+      spawned.filter((c) => c.role === role).length,
+  };
+}
+
+/** Let one awaited step (a path resolution, an exit callback) land. */
+export const settle = (): Promise<void> => sleep(0);
+
+export function newViewer() {
+  const lost: DesktopLoss[] = [];
+  return {
+    lost,
+    viewer: { onDesktopLost: (loss: DesktopLoss) => lost.push(loss) },
+  };
+}

package/src/desktop/desktop-chrome-policy.test.ts

@@ -0,0 +1,79 @@
+import {
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, expect, test } from "bun:test";
+
+import { writeDesktopChromePolicy } from "./desktop-chrome-policy.js";
+
+const directories: string[] = [];
+function policyDirectory(): string {
+  const path = mkdtempSync(join(tmpdir(), "desktop-chrome-policy-"));
+  directories.push(path);
+  return path;
+}
+
+afterEach(() => {
+  for (const path of directories.splice(0)) {
+    rmSync(path, { recursive: true, force: true });
+  }
+});
+
+test("preserves unrelated policies and does not rewrite on repeated startup", () => {
+  const directory = policyDirectory();
+  const path = join(directory, "vellum-desktop.json");
+  const otherPath = join(directory, "organization.json");
+  const unrelated = '{ "HomepageLocation": "https://example.com" }\n';
+  writeFileSync(otherPath, unrelated);
+  writeFileSync(
+    path,
+    JSON.stringify({
+      CommandLineFlagSecurityWarningsEnabled: false,
+      DownloadRestrictions: 1,
+    }),
+  );
+  const original = statSync(path);
+
+  writeDesktopChromePolicy(directory);
+  const content = readFileSync(path, "utf8");
+  expect(statSync(path).ino).not.toBe(original.ino);
+  expect(JSON.parse(content).DownloadRestrictions).toBe(1);
+  expect(readFileSync(otherPath, "utf8")).toBe(unrelated);
+  expect(readdirSync(directory).sort()).toEqual([
+    "organization.json",
+    "vellum-desktop.json",
+  ]);
+
+  const before = statSync(path);
+  writeDesktopChromePolicy(directory);
+  expect(readFileSync(path, "utf8")).toBe(content);
+  expect(statSync(path).ino).toBe(before.ino);
+  expect(statSync(path).mtimeMs).toBe(before.mtimeMs);
+});
+
+test("creates missing policy directories for a fresh desktop", () => {
+  const directory = join(policyDirectory(), "policies", "managed");
+  writeDesktopChromePolicy(directory);
+  expect(readdirSync(directory)).toEqual(["vellum-desktop.json"]);
+  expect(statSync(join(directory, "vellum-desktop.json")).mode & 0o777).toBe(
+    0o644,
+  );
+});
+
+test.each(["{broken", "[]", "null", "false"])(
+  "leaves invalid existing policy content untouched: %s",
+  (content) => {
+    const directory = policyDirectory();
+    const path = join(directory, "vellum-desktop.json");
+    writeFileSync(path, content);
+    expect(() => writeDesktopChromePolicy(directory)).toThrow();
+    expect(readFileSync(path, "utf8")).toBe(content);
+    expect(readdirSync(directory)).toEqual(["vellum-desktop.json"]);
+  },
+);

package/src/desktop/desktop-chrome-policy.ts

@@ -0,0 +1,47 @@
+import {
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+
+export function writeDesktopChromePolicy(policyDir: string): void {
+  const path = join(policyDir, "vellum-desktop.json");
+  let policy: Record<string, unknown> = {};
+  try {
+    const value: unknown = JSON.parse(readFileSync(path, "utf8"));
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      throw new Error("Desktop Chrome policy must be a JSON object");
+    }
+    policy = value as Record<string, unknown>;
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
+      throw err;
+    }
+  }
+  if (
+    policy.CommandLineFlagSecurityWarningsEnabled === false &&
+    policy.PasswordManagerEnabled === false
+  ) {
+    return;
+  }
+
+  // This suppresses command-line warnings; Chrome's sandbox stays unchanged.
+  policy.CommandLineFlagSecurityWarningsEnabled = false;
+  // Suppress save prompts while keeping previously saved passwords usable.
+  policy.PasswordManagerEnabled = false;
+  mkdirSync(policyDir, { recursive: true });
+  const staging = mkdtempSync(join(policyDir, ".vellum-desktop-"));
+  try {
+    const temporaryPath = join(staging, "policy.json");
+    writeFileSync(temporaryPath, JSON.stringify(policy, null, 2) + "\n", {
+      mode: 0o644,
+    });
+    renameSync(temporaryPath, path);
+  } finally {
+    rmSync(staging, { recursive: true, force: true });
+  }
+}

package/src/desktop/desktop-chrome-session.ts

@@ -0,0 +1,37 @@
+import { readFileSync } from "node:fs";
+import { basename, join } from "node:path";
+
+export function shouldRestoreDesktopChromeSession(profileDir: string): boolean {
+  const lastUsed = readProfileMetadata(
+    join(profileDir, "Local State"),
+  )?.last_used;
+  const profileName =
+    typeof lastUsed === "string" &&
+    lastUsed !== "" &&
+    lastUsed !== "." &&
+    lastUsed !== ".." &&
+    basename(lastUsed) === lastUsed
+      ? lastUsed
+      : "Default";
+  return (
+    readProfileMetadata(join(profileDir, profileName, "Preferences"))
+      ?.exit_type === "Crashed"
+  );
+}
+
+function readProfileMetadata(
+  path: string,
+): { last_used?: unknown; exit_type?: unknown } | undefined {
+  try {
+    const value: unknown = JSON.parse(readFileSync(path, "utf8"));
+    if (value && typeof value === "object" && "profile" in value) {
+      const profile = value.profile;
+      if (profile && typeof profile === "object" && !Array.isArray(profile)) {
+        return profile;
+      }
+    }
+  } catch {
+    // Leave missing or unreadable session metadata to Chrome's normal startup.
+  }
+  return undefined;
+}

package/src/desktop/desktop-dependencies.test.ts

@@ -0,0 +1,102 @@
+import { describe, expect, mock, test } from "bun:test";
+
+import {
+  DesktopDependencyInstaller,
+  type DesktopSetupStatus,
+} from "./desktop-dependencies.js";
+
+const flush = async () => {
+  for (let i = 0; i < 10; i++) {
+    await Promise.resolve();
+  }
+};
+
+function setup() {
+  let ready = false;
+  let supported = true;
+  let finish!: () => void;
+  let fail!: (err: Error) => void;
+  let progress!: (stage: NonNullable<DesktopSetupStatus["stage"]>) => void;
+  const notify = mock(async () => {});
+  const install = mock((onStage: typeof progress) => {
+    progress = onStage;
+    return new Promise<void>((resolve, reject) => {
+      finish = () => {
+        ready = true;
+        resolve();
+      };
+      fail = reject;
+    });
+  });
+  const installer = new DesktopDependencyInstaller({
+    supported: () => supported,
+    ready: () => ready,
+    install,
+    notify,
+  });
+  return {
+    installer,
+    install,
+    notify,
+    finish: () => finish(),
+    fail: () => fail(new Error("download failed")),
+    progress: () => progress("chrome"),
+    restoreComponents: () => {
+      ready = true;
+    },
+    removeComponents: () => {
+      ready = false;
+    },
+    unsupported: () => {
+      supported = false;
+    },
+  };
+}
+
+describe("desktop dependency installation", () => {
+  test("status is read only and repeated starts share one install", async () => {
+    const f = setup();
+    expect(f.installer.getStatus().state).toBe("required");
+    expect(f.install).not.toHaveBeenCalled();
+    expect(f.installer.start().state).toBe("installing");
+    f.installer.start();
+    await flush();
+    expect(f.install).toHaveBeenCalledTimes(1);
+    f.progress();
+    expect(f.installer.getStatus()).toEqual({
+      state: "installing",
+      stage: "chrome",
+    });
+    f.finish();
+    await flush();
+    expect(f.installer.getStatus().state).toBe("ready");
+    f.installer.start();
+    expect(f.install).toHaveBeenCalledTimes(1);
+    expect(f.notify).toHaveBeenCalledTimes(3);
+    f.removeComponents();
+    expect(f.installer.getStatus().state).toBe("required");
+  });
+
+  test("a failed install releases the job and retries without starting a desktop", async () => {
+    const f = setup();
+    f.installer.start();
+    await flush();
+    f.restoreComponents();
+    f.fail();
+    await flush();
+    expect(f.installer.getStatus().state).toBe("failed");
+    f.installer.start();
+    await flush();
+    expect(f.install).toHaveBeenCalledTimes(2);
+    f.finish();
+    await flush();
+    expect(f.installer.getStatus().state).toBe("ready");
+  });
+
+  test("unsupported environments cannot trigger installation", () => {
+    const f = setup();
+    f.unsupported();
+    expect(f.installer.start().state).toBe("unsupported");
+    expect(f.install).not.toHaveBeenCalled();
+  });
+});