@vellumai/assistant 0.12.2 → 0.12.3-staging.2

package/src/workspace/migrations/157-add-desktop-files-launcher.ts

@@ -0,0 +1,94 @@
+import {
+  linkSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+import type { WorkspaceMigration } from "./types.js";
+
+export const addDesktopFilesLauncherMigration: WorkspaceMigration = {
+  id: "157-add-desktop-files-launcher",
+  description: "Add Files to existing virtual desktop docks",
+  retryFailedCheckpoint: true,
+  run(workspaceDir): void {
+    const configDir = join(workspaceDir, "data", "desktop-panel");
+    const settingsPath = join(configDir, "glib-2.0", "settings", "keyfile");
+    let settings: string;
+    try {
+      settings = readFileSync(settingsPath, "utf8");
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+        return;
+      }
+      throw err;
+    }
+
+    const section =
+      /(?:^|\n)\[net\/launchpad\/plank\/docks\/dock1\]\r?\n([^]*?)(?=\n\[|$)/;
+    const match = settings.match(section);
+    if (!match) {
+      return;
+    }
+    const pins = /^(dock-items\s*=\s*)(?:@as\s+)?\[([^\r\n]*)\](\r?)$/m;
+    const existing = match[1]!.match(pins);
+    if (existing && !existing[2]!.includes("'files.dockitem'")) {
+      const items = existing[2]!.trim();
+      let updatedItems: string;
+      if (items.includes("'chrome.dockitem'")) {
+        updatedItems = items.replace(
+          "'chrome.dockitem'",
+          "'chrome.dockitem', 'files.dockitem'",
+        );
+      } else if (items.includes("'terminal.dockitem'")) {
+        updatedItems = items.replace(
+          "'terminal.dockitem'",
+          "'files.dockitem', 'terminal.dockitem'",
+        );
+      } else {
+        updatedItems = `${items}${items ? ", " : ""}'files.dockitem'`;
+      }
+      const updated = match[0].replace(
+        pins,
+        () => `${existing[1]}[${updatedItems}]${existing[3]}`,
+      );
+      settings = settings.replace(section, () => updated);
+    } else if (!existing) {
+      settings = settings.replace(
+        section,
+        () =>
+          `${match[0]}${match[0].endsWith("\n") ? "" : "\n"}dock-items=['files.dockitem']\n`,
+      );
+    }
+
+    const launchersDir = join(configDir, "plank", "dock1", "launchers");
+    mkdirSync(launchersDir, { recursive: true });
+    const launcher = pathToFileURL(
+      join(configDir, "applications", "thunar.desktop"),
+    ).href;
+    const pinPath = join(launchersDir, "files.dockitem");
+    const pinTemporaryPath = `${pinPath}.migration.tmp`;
+    try {
+      writeFileSync(
+        pinTemporaryPath,
+        `[PlankDockItemPreferences]\nLauncher=${launcher}\n`,
+        { flush: true },
+      );
+      linkSync(pinTemporaryPath, pinPath);
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code !== "EEXIST") {
+        throw err;
+      }
+    } finally {
+      rmSync(pinTemporaryPath, { force: true });
+    }
+    const temporaryPath = `${settingsPath}.files-migration.tmp`;
+    writeFileSync(temporaryPath, settings, { flush: true });
+    renameSync(temporaryPath, settingsPath);
+  },
+  down(): void {},
+};

package/src/workspace/migrations/__tests__/156-extract-workspace-mcp-json.test.ts

@@ -3,9 +3,12 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { describe, expect, test } from "bun:test";
 
-import { extractWorkspaceMcpJsonMigration } from "../156-extract-workspace-mcp-json.js";
 import { WORKSPACE_MIGRATIONS } from "../registry.js";
 
+const extractWorkspaceMcpJsonMigration = WORKSPACE_MIGRATIONS.find(
+  (migration) => migration.id === "156-extract-workspace-mcp-json",
+)!;
+
 const MIGRATION_156_SCHEMA_URL =
   "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json";
 
@@ -23,15 +26,6 @@ function readJson(dir: string, name: string): Record<string, unknown> {
 }
 
 describe("156-extract-workspace-mcp-json", () => {
-  test("has the next migration id and is registered last", () => {
-    expect(extractWorkspaceMcpJsonMigration.id).toBe(
-      "156-extract-workspace-mcp-json",
-    );
-    expect(WORKSPACE_MIGRATIONS.at(-1)?.id).toBe(
-      "156-extract-workspace-mcp-json",
-    );
-  });
-
   test("moves servers into a spec-pure mcp.json and drops mcp from config", () => {
     const dir = workspaceWith({
       llm: { activeProfile: "balanced" },

package/src/workspace/migrations/__tests__/157-add-desktop-files-launcher.test.ts

@@ -0,0 +1,113 @@
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { afterEach, expect, test } from "bun:test";
+
+import { writeDesktopPanelConfig } from "../../../desktop/desktop-panel-config.js";
+import { WORKSPACE_MIGRATIONS } from "../registry.js";
+
+const migration = WORKSPACE_MIGRATIONS.find(
+  (entry) => entry.id === "157-add-desktop-files-launcher",
+)!;
+
+const workspaces: string[] = [];
+afterEach(() => {
+  for (const workspace of workspaces.splice(0)) {
+    rmSync(workspace, { recursive: true, force: true });
+  }
+});
+
+function setup() {
+  const workspace = mkdtempSync(join(tmpdir(), "desktop-files-migration-"));
+  workspaces.push(workspace);
+  const configDir = join(workspace, "data", "desktop-panel");
+  const settingsPath = join(configDir, "glib-2.0", "settings", "keyfile");
+  return { workspace, configDir, settingsPath };
+}
+
+test("upgrades a customized dock idempotently and respects later unpinning", () => {
+  const { workspace, configDir, settingsPath } = setup();
+  mkdirSync(dirname(settingsPath), { recursive: true });
+  const original =
+    "[unrelated]\nvalue=keep\n\n[net/launchpad/plank/docks/dock1]\ndock-items=['chrome.dockitem', 'terminal.dockitem', 'custom.dockitem']\nicon-size=64\n\n[another]\ndock-items=['other.dockitem']\n";
+  writeFileSync(settingsPath, original);
+  migration.run(workspace);
+  const upgraded = readFileSync(settingsPath, "utf8");
+  expect(upgraded).toBe(
+    original.replace(
+      "'chrome.dockitem', 'terminal.dockitem'",
+      "'chrome.dockitem', 'files.dockitem', 'terminal.dockitem'",
+    ),
+  );
+  migration.run(workspace);
+  expect(readFileSync(settingsPath, "utf8")).toBe(upgraded);
+  const pin = join(configDir, "plank", "dock1", "launchers", "files.dockitem");
+  expect(readFileSync(pin, "utf8")).toContain("/applications/thunar.desktop");
+  rmSync(pin);
+  writeFileSync(settingsPath, original);
+  writeDesktopPanelConfig({
+    configDir,
+    chromiumPath: "/opt/chrome/chrome",
+    chromiumProfileDir: join(workspace, "profile"),
+    terminalPath: "/usr/bin/wezterm",
+    fileManagerPath: "/usr/bin/thunar",
+    workspaceDir: workspace,
+  });
+  expect(existsSync(pin)).toBe(false);
+  expect(readFileSync(settingsPath, "utf8")).toBe(original);
+  expect(existsSync(join(configDir, "applications", "thunar.desktop"))).toBe(
+    true,
+  );
+});
+
+test.each(["[]", "@as []"])(
+  "upgrades an empty dock (%s) and recovers an existing pin",
+  (items) => {
+    const { workspace, configDir, settingsPath } = setup();
+    mkdirSync(dirname(settingsPath), { recursive: true });
+    writeFileSync(
+      settingsPath,
+      `[net/launchpad/plank/docks/dock1]\ndock-items=${items}\n`,
+    );
+    const pin = join(
+      configDir,
+      "plank",
+      "dock1",
+      "launchers",
+      "files.dockitem",
+    );
+    mkdirSync(dirname(pin), { recursive: true });
+    writeFileSync(pin, "user launcher");
+    migration.run(workspace);
+    expect(readFileSync(settingsPath, "utf8")).toContain(
+      "dock-items=['files.dockitem']",
+    );
+    expect(readFileSync(pin, "utf8")).toBe("user launcher");
+  },
+);
+
+test("does not initialize a desktop for workspaces without one", () => {
+  const { workspace, configDir } = setup();
+  migration.run(workspace);
+  expect(existsSync(configDir)).toBe(false);
+});
+
+test("adds an implicit dock pin list inside the correct settings section", () => {
+  const { workspace, settingsPath } = setup();
+  mkdirSync(dirname(settingsPath), { recursive: true });
+  writeFileSync(
+    settingsPath,
+    "[unrelated]\nvalue=keep\n[net/launchpad/plank/docks/dock1]\nicon-size=64\n[next]\nvalue=also-keep\n",
+  );
+  migration.run(workspace);
+  expect(readFileSync(settingsPath, "utf8")).toBe(
+    "[unrelated]\nvalue=keep\n[net/launchpad/plank/docks/dock1]\nicon-size=64\ndock-items=['files.dockitem']\n\n[next]\nvalue=also-keep\n",
+  );
+});

package/src/workspace/migrations/registry.ts

@@ -154,6 +154,7 @@ import { stripMcpPolicyFieldsMigration } from "./153-strip-mcp-policy-fields.js"
 import { repairRetiredCodexGpt54ModelIdsMigration } from "./154-repair-retired-codex-gpt-5-4-model-ids.js";
 import { moveFrontModelConfigToVoiceMigration } from "./155-move-front-model-config-to-voice.js";
 import { extractWorkspaceMcpJsonMigration } from "./156-extract-workspace-mcp-json.js";
+import { addDesktopFilesLauncherMigration } from "./157-add-desktop-files-launcher.js";
 import { migrateToWorkspaceVolumeMigration } from "./migrate-to-workspace-volume.js";
 import type { WorkspaceMigration } from "./types.js";
 
@@ -323,4 +324,5 @@ export const WORKSPACE_MIGRATIONS: WorkspaceMigration[] = [
   repairRetiredCodexGpt54ModelIdsMigration,
   moveFrontModelConfigToVoiceMigration,
   extractWorkspaceMcpJsonMigration,
+  addDesktopFilesLauncherMigration,
 ];

package/src/__tests__/computer-use-window-schema.test.ts

@@ -1,24 +0,0 @@
-import { readFileSync } from "node:fs";
-import { expect, test } from "bun:test";
-
-import { computerUseObserveTool } from "../tools/computer-use/definitions.js";
-
-test("window observation schema matches the skill manifest", () => {
-  const manifest = JSON.parse(
-    readFileSync(
-      new URL(
-        "../config/bundled-skills/computer-use/TOOLS.json",
-        import.meta.url,
-      ),
-      "utf8",
-    ),
-  );
-  expect(
-    manifest.tools.find(
-      (tool: { name: string }) => tool.name === "computer_use_observe",
-    ).input_schema,
-  ).toEqual(computerUseObserveTool.input_schema);
-  expect(
-    computerUseObserveTool.input_schema.properties.capture_window_id,
-  ).toMatchObject({ type: "integer", minimum: 1, maximum: 4294967295 });
-});

package/src/api/events/heartbeat-alert.ts

@@ -1,20 +0,0 @@
-/**
- * `heartbeat_alert` SSE event.
- *
- * Server → client alert raised by the heartbeat monitor when a checked
- * condition needs the user's attention. Carries a `title` and `body`.
- *
- * Canonical wire-contract source. Daemon code imports the type
- * directly from this file; external consumers import via
- * `@vellumai/assistant-api`.
- */
-
-import { z } from "zod";
-
-export const HeartbeatAlertEventSchema = z.object({
-  type: z.literal("heartbeat_alert"),
-  title: z.string(),
-  body: z.string(),
-});
-
-export type HeartbeatAlertEvent = z.infer<typeof HeartbeatAlertEventSchema>;

package/src/daemon/message-types/web-activity.ts

@@ -1,65 +0,0 @@
-// Shared structured result types for web-search and web-fetch tool activity.
-//
-// These types describe live (SSE-time) metadata that producers (search/fetch
-// tool executors) emit and consumers (clients) render alongside the existing
-// `result: string` payload. Persistence to conversation history is out of
-// scope for this plan; the metadata is live-only.
-
-export type WebSearchProviderId =
-  | "anthropic-native"
-  | "brave"
-  | "perplexity"
-  | "tavily"
-  | "keenable"
-  | "firecrawl"
-  | "fastcrw";
-
-/** Provider that backed a `web_fetch` call. `default` is the built-in fetcher. */
-export type WebFetchProviderId = "default" | "firecrawl" | "fastcrw";
-
-export interface WebSearchResultItem {
-  rank: number; // 1-indexed
-  title: string;
-  url: string;
-  domain: string; // lowercased host
-  faviconUrl?: string;
-  snippet?: string; // not populated for anthropic-native (content encrypted)
-  age?: string; // Brave-only freshness hint
-  score?: number; // Tavily-only
-}
-
-export interface WebSearchMetadata {
-  query: string;
-  provider: WebSearchProviderId;
-  resultCount: number;
-  durationMs: number;
-  results: WebSearchResultItem[];
-  /** Present when search itself failed; results[] will be empty. */
-  errorMessage?: string;
-}
-
-export interface WebFetchMetadata {
-  url: string;
-  finalUrl: string;
-  /** Provider that served the fetch. Defaults to the built-in fetcher. */
-  provider?: WebFetchProviderId;
-  status: number;
-  contentType?: string;
-  byteCount: number;
-  charCount: number;
-  truncated: boolean;
-  title?: string;
-  domain: string;
-  faviconUrl?: string;
-  redirectCount: number;
-  durationMs: number;
-  errorMessage?: string;
-  /** Set when extracted text is dramatically smaller than raw HTML — likely a JS-rendered SPA whose meaningful content the static fetcher missed. */
-  mayRequireJavaScript?: boolean;
-}
-
-/** Discriminated container so future tools can add their own metadata. */
-export interface ToolActivityMetadata {
-  webSearch?: WebSearchMetadata;
-  webFetch?: WebFetchMetadata;
-}

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

@@ -1,131 +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();
-  });
-});
-
-test("browser and viewer share installation while a cancelled waiter stops immediately", async () => {
-  const f = setup();
-  const abort = new AbortController();
-  const browser = f.installer
-    .ensureReady(abort.signal)
-    .catch((error: unknown) => error);
-  const viewer = f.installer.ensureReady();
-  await flush();
-  expect(f.install).toHaveBeenCalledTimes(1);
-  abort.abort();
-  expect(await browser).toBeInstanceOf(Error);
-  expect(f.installer.getStatus().state).toBe("installing");
-  f.finish();
-  await viewer;
-  expect(f.installer.getStatus().state).toBe("ready");
-});
-
-test("failed setup reports the stage without running an automatic retry", async () => {
-  const f = setup();
-  const result = f.installer.ensureReady().catch((error: Error) => error);
-  await flush();
-  f.progress();
-  f.fail();
-  const error = await result;
-  expect(error).toBeInstanceOf(Error);
-  expect((error as Error).message).toContain("failed during chrome");
-  expect(f.install).toHaveBeenCalledTimes(1);
-});