@vellumai/assistant 0.12.1-staging.1 → 0.12.1

package/src/daemon/__tests__/skill-memory-refresh-mtime.test.ts

@@ -1,133 +0,0 @@
-import { mkdirSync, mkdtempSync, rmSync, utimesSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  mock,
-  test,
-} from "bun:test";
-
-const WORKSPACE_DIR = mkdtempSync(join(tmpdir(), "skill-md-mtime-refresh-"));
-process.env.VELLUM_WORKSPACE_DIR = WORKSPACE_DIR;
-
-const seedGraphCalls: number[] = [];
-const seedV2Calls: number[] = [];
-
-mock.module("../../config/loader.js", () => ({
-  getConfig: () => ({}),
-}));
-
-mock.module("../../plugins/defaults/memory/graph/capability-seed.js", () => ({
-  seedSkillGraphNodes: () => {
-    seedGraphCalls.push(Date.now());
-  },
-  seedUninstalledCatalogSkillMemories: async () => {},
-}));
-
-mock.module(
-  "../../plugins/defaults/memory/substrate/boot-maintenance.js",
-  () => ({
-    maybeSeedCapabilitySkills: () => {
-      seedV2Calls.push(Date.now());
-    },
-    maybeSeedCliCommandCards: () => {},
-  }),
-);
-
-const {
-  _resetSkillMdMtimeStateForTests,
-  maybeRefreshSkillCapabilityMemoriesFromMtime,
-  refreshSkillCapabilityMemories,
-  startWorkspaceSkillMdMtimePoll,
-  stopWorkspaceSkillMdMtimePoll,
-} = await import("../skill-memory-refresh.js");
-
-const SKILLS_DIR = join(WORKSPACE_DIR, "skills");
-
-function writeSkill(id: string): string {
-  const dir = join(SKILLS_DIR, id);
-  mkdirSync(dir, { recursive: true });
-  const skillMd = join(dir, "SKILL.md");
-  writeFileSync(
-    skillMd,
-    `---\nname: ${id}\ndescription: ${id}\n---\nbody\n`,
-  );
-  return skillMd;
-}
-
-describe("maybeRefreshSkillCapabilityMemoriesFromMtime", () => {
-  beforeEach(() => {
-    rmSync(SKILLS_DIR, { recursive: true, force: true });
-    mkdirSync(SKILLS_DIR, { recursive: true });
-    seedGraphCalls.length = 0;
-    seedV2Calls.length = 0;
-    _resetSkillMdMtimeStateForTests();
-  });
-
-  afterEach(() => {
-    _resetSkillMdMtimeStateForTests();
-  });
-
-  test("first call reseeds, a second call with unchanged SKILL.md does not", () => {
-    writeSkill("alpha");
-    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(true);
-    expect(seedGraphCalls).toHaveLength(1);
-    expect(seedV2Calls).toHaveLength(1);
-
-    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(false);
-    expect(seedGraphCalls).toHaveLength(1);
-  });
-
-  test("explicit refresh remembers the signature so the next poll is a no-op", () => {
-    writeSkill("alpha");
-    refreshSkillCapabilityMemories();
-    expect(seedGraphCalls).toHaveLength(1);
-    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(false);
-  });
-
-  test("SKILL.md mtime change reseeds", () => {
-    const skillMd = writeSkill("alpha");
-    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(true);
-
-    const later = new Date(Date.now() + 5_000);
-    utimesSync(skillMd, later, later);
-    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(true);
-    expect(seedGraphCalls).toHaveLength(2);
-  });
-
-  test("TOOLS.json change without a SKILL.md mtime change does not reseed", () => {
-    writeSkill("alpha");
-    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(true);
-
-    writeFileSync(
-      join(SKILLS_DIR, "alpha", "TOOLS.json"),
-      JSON.stringify({ version: 1, tools: [] }),
-    );
-    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(false);
-    expect(seedGraphCalls).toHaveLength(1);
-  });
-
-  test("adding or removing a skill directory reseeds", () => {
-    writeSkill("alpha");
-    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(true);
-
-    writeSkill("bravo");
-    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(true);
-
-    rmSync(join(SKILLS_DIR, "bravo"), { recursive: true, force: true });
-    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(true);
-    expect(seedGraphCalls).toHaveLength(3);
-  });
-
-  test("startWorkspaceSkillMdMtimePoll runs once immediately and is idempotent", () => {
-    writeSkill("alpha");
-    startWorkspaceSkillMdMtimePoll();
-    expect(seedGraphCalls).toHaveLength(1);
-    startWorkspaceSkillMdMtimePoll();
-    expect(seedGraphCalls).toHaveLength(1);
-    stopWorkspaceSkillMdMtimePoll();
-  });
-});

package/src/daemon/app-change-notify.ts

@@ -1,45 +0,0 @@
-/**
- * Fan out an app change to open conversation surfaces, connected clients,
- * and the publish pipeline.
- *
- * Compilation is the caller's responsibility. This module only notifies:
- * it must not call `compileApp()` because that begins with `rm -rf dist/`
- * and would race a compile already in flight.
- */
-
-import { broadcastMessage } from "../runtime/assistant-event-hub.js";
-import { publishAppsChanged } from "../runtime/sync/resource-sync-events.js";
-import { updatePublishedAppDeployment } from "../services/published-app-updater.js";
-import type { Conversation } from "./conversation.js";
-import { allConversations } from "./conversation-registry.js";
-import { refreshSurfacesForApp } from "./conversation-surfaces.js";
-
-export function broadcastAppFilesChanged(appId: string): void {
-  broadcastMessage({ type: "app_files_changed", appId });
-  publishAppsChanged();
-}
-
-/**
- * Refresh every in-memory conversation that has this app open, then broadcast
- * and re-deploy. Pass `alsoRefresh` when the calling conversation might not
- * yet be in the registry (tool post-execution hooks).
- */
-export function notifyAppSurfacesChanged(
-  appId: string,
-  opts?: { fileChange?: boolean; status?: string },
-  alsoRefresh?: Conversation,
-): void {
-  const seen = new Set<string>();
-  if (alsoRefresh) {
-    refreshSurfacesForApp(alsoRefresh, appId, opts);
-    seen.add(alsoRefresh.conversationId);
-  }
-  for (const conversation of allConversations()) {
-    if (seen.has(conversation.conversationId)) {
-      continue;
-    }
-    refreshSurfacesForApp(conversation, appId, opts);
-  }
-  broadcastAppFilesChanged(appId);
-  void updatePublishedAppDeployment(appId);
-}

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

@@ -1,119 +0,0 @@
-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;
-  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,
-  });
-  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

@@ -1,71 +0,0 @@
-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({ DownloadRestrictions: 1 }));
-
-  writeDesktopChromePolicy(directory);
-  const content = readFileSync(path, "utf8");
-  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

@@ -1,42 +0,0 @@
-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) {
-    return;
-  }
-
-  // This suppresses command-line warnings; Chrome's sandbox stays unchanged.
-  policy.CommandLineFlagSecurityWarningsEnabled = 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-dependencies.test.ts

@@ -1,102 +0,0 @@
-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();
-  });
-});