@vellumai/assistant 0.12.1-dev.202609141913.5e16607 → 0.12.1-staging.2

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

@@ -1,214 +0,0 @@
-import { existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-import { getLogger } from "../../util/logger.js";
-import type { WorkspaceMigration } from "./types.js";
-
-const WORKSPACE_MCP_FILENAME = "mcp.json";
-
-// Inlined Agent Plugins 1.0.0 schema URL so this migration stays
-// self-contained if the production constant later changes or moves.
-const AGENT_PLUGINS_MCP_SCHEMA_URL =
-  "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json";
-
-const log = getLogger("workspace-migration-156");
-
-/**
- * Move user-owned MCP servers from `config.json` into a spec-pure
- * `/workspace/mcp.json`. Presence of a server is what starts it. Headers
- * that were still on a transport are copied onto the spec entry so the
- * credential-store migration can lift them on the next MCP reload.
- */
-export const extractWorkspaceMcpJsonMigration: WorkspaceMigration = {
-  id: "156-extract-workspace-mcp-json",
-  description:
-    "Extract workspace MCP servers from config.json into a spec-pure mcp.json",
-  run(workspaceDir: string): void {
-    const configPath = join(workspaceDir, "config.json");
-    if (!existsSync(configPath)) {
-      return;
-    }
-
-    const config = readJsonObject(configPath);
-    if (config === null) {
-      return;
-    }
-
-    if (!Object.hasOwn(config, "mcp")) {
-      return;
-    }
-
-    const extracted = extractSpecServers(config.mcp);
-    const mcpPath = join(workspaceDir, WORKSPACE_MCP_FILENAME);
-    const existing = readExistingMcpServers(mcpPath);
-    const merged: Record<string, unknown> = {
-      ...extracted,
-      ...existing.servers,
-    };
-
-    if (Object.keys(merged).length > 0 || existing.present) {
-      const document = {
-        $schema: existing.schema ?? AGENT_PLUGINS_MCP_SCHEMA_URL,
-        mcpServers: merged,
-      };
-      atomicWrite(mcpPath, document);
-    }
-
-    delete config.mcp;
-    atomicWrite(configPath, config);
-    log.info("Extracted workspace MCP servers into mcp.json");
-  },
-  retryFailedCheckpoint: true,
-  down(_workspaceDir: string): void {
-    // Forward-only: mcp.json is the store. Putting servers back under
-    // config.json would just be extracted again on the next load.
-  },
-};
-
-function extractSpecServers(mcp: unknown): Record<string, unknown> {
-  const block = readObject(mcp);
-  if (block === null) {
-    return {};
-  }
-
-  const servers: Record<string, unknown> = {};
-  const rawServers = block.servers;
-  if (Array.isArray(rawServers)) {
-    for (const entry of rawServers) {
-      const object = readObject(entry);
-      if (object === null) {
-        continue;
-      }
-      const name = object.name;
-      if (typeof name !== "string" || name.trim().length === 0) {
-        continue;
-      }
-      const spec = toSpecServer(object);
-      if (spec !== null) {
-        servers[name] = spec;
-      }
-    }
-    return servers;
-  }
-
-  const serverMap = readObject(rawServers);
-  if (serverMap === null) {
-    return {};
-  }
-  for (const [id, entry] of Object.entries(serverMap)) {
-    if (id.trim().length === 0) {
-      continue;
-    }
-    const object = readObject(entry);
-    if (object === null) {
-      continue;
-    }
-    const spec = toSpecServer(object);
-    if (spec !== null) {
-      servers[id] = spec;
-    }
-  }
-  return servers;
-}
-
-function toSpecServer(entry: Record<string, unknown>): Record<string, unknown> | null {
-  const transport = readObject(entry.transport);
-  if (transport === null) {
-    return null;
-  }
-  const type = transport.type;
-  if (type === "stdio") {
-    if (typeof transport.command !== "string" || transport.command.length === 0) {
-      return null;
-    }
-    const spec: Record<string, unknown> = {
-      type: "stdio",
-      command: transport.command,
-    };
-    if (
-      Array.isArray(transport.args) &&
-      transport.args.length > 0 &&
-      transport.args.every((arg) => typeof arg === "string")
-    ) {
-      spec.args = transport.args;
-    }
-    const env = readStringRecord(transport.env);
-    if (env !== null) {
-      spec.env = env;
-    }
-    return spec;
-  }
-  if (type === "sse" || type === "streamable-http" || type === "http") {
-    if (typeof transport.url !== "string" || transport.url.length === 0) {
-      return null;
-    }
-    const spec: Record<string, unknown> = {
-      type: type === "http" ? "streamable-http" : type,
-      url: transport.url,
-    };
-    const headers = readStringRecord(transport.headers);
-    if (headers !== null) {
-      spec.headers = headers;
-    }
-    return spec;
-  }
-  return null;
-}
-
-function readExistingMcpServers(path: string): {
-  present: boolean;
-  schema?: string;
-  servers: Record<string, unknown>;
-} {
-  if (!existsSync(path)) {
-    return { present: false, servers: {} };
-  }
-  const document = readJsonObject(path);
-  if (document === null) {
-    return { present: true, servers: {} };
-  }
-  const servers = readObject(document.mcpServers);
-  return {
-    present: true,
-    schema:
-      typeof document.$schema === "string" ? document.$schema : undefined,
-    servers: servers ?? {},
-  };
-}
-
-function readJsonObject(path: string): Record<string, unknown> | null {
-  try {
-    const raw = JSON.parse(readFileSync(path, "utf-8"));
-    return readObject(raw);
-  } catch {
-    return null;
-  }
-}
-
-function atomicWrite(path: string, value: unknown): void {
-  const tmpPath = `${path}.migration-156.tmp`;
-  writeFileSync(tmpPath, JSON.stringify(value, null, 2) + "\n");
-  renameSync(tmpPath, path);
-}
-
-function readObject(value: unknown): Record<string, unknown> | null {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    return null;
-  }
-  return value as Record<string, unknown>;
-}
-
-function readStringRecord(value: unknown): Record<string, string> | null {
-  const object = readObject(value);
-  if (object === null) {
-    return null;
-  }
-  const result: Record<string, string> = {};
-  for (const [key, entry] of Object.entries(object)) {
-    if (typeof entry !== "string") {
-      return null;
-    }
-    result[key] = entry;
-  }
-  return Object.keys(result).length > 0 ? result : null;
-}

package/src/workspace/migrations/__tests__/155-move-front-model-config-to-voice.test.ts

@@ -1,102 +0,0 @@
-import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { describe, expect, test } from "bun:test";
-
-import { moveFrontModelConfigToVoiceMigration } from "../155-move-front-model-config-to-voice.js";
-
-function workspaceWith(config: unknown): string {
-  const dir = mkdtempSync(join(tmpdir(), "move-front-model-"));
-  writeFileSync(join(dir, "config.json"), JSON.stringify(config, null, 2));
-  return dir;
-}
-
-function readConfig(dir: string): Record<string, unknown> {
-  return JSON.parse(readFileSync(join(dir, "config.json"), "utf8")) as Record<
-    string,
-    unknown
-  >;
-}
-
-describe("155-move-front-model-config-to-voice", () => {
-  test("moves liveVoice.frontModel under voice and leaves the rest of liveVoice", () => {
-    const dir = workspaceWith({
-      liveVoice: {
-        vad: { silenceThresholdMs: 900 },
-        frontModel: {
-          endpointDecisionTimeoutMs: 300,
-          progress: { idleIntervalMs: 4_000 },
-        },
-      },
-    });
-
-    moveFrontModelConfigToVoiceMigration.run(dir);
-
-    expect(readConfig(dir)).toEqual({
-      liveVoice: { vad: { silenceThresholdMs: 900 } },
-      voice: {
-        frontModel: {
-          endpointDecisionTimeoutMs: 300,
-          progress: { idleIntervalMs: 4_000 },
-        },
-      },
-    });
-  });
-
-  test("an existing voice.frontModel wins field by field", () => {
-    const dir = workspaceWith({
-      liveVoice: {
-        frontModel: {
-          endpointDecisionTimeoutMs: 300,
-          endpointMaxExtensions: 1,
-          progress: { idleIntervalMs: 4_000, minGapMs: 2_000 },
-        },
-      },
-      voice: {
-        frontModel: {
-          endpointDecisionTimeoutMs: 800,
-          progress: { idleIntervalMs: 7_000 },
-        },
-      },
-    });
-
-    moveFrontModelConfigToVoiceMigration.run(dir);
-
-    expect(readConfig(dir)).toEqual({
-      liveVoice: {},
-      voice: {
-        frontModel: {
-          endpointDecisionTimeoutMs: 800,
-          endpointMaxExtensions: 1,
-          progress: { idleIntervalMs: 7_000, minGapMs: 2_000 },
-        },
-      },
-    });
-  });
-
-  test("a config without the old key is left untouched", () => {
-    const dir = workspaceWith({ liveVoice: { archiveAudio: true } });
-    const before = readFileSync(join(dir, "config.json"), "utf8");
-
-    moveFrontModelConfigToVoiceMigration.run(dir);
-
-    expect(readFileSync(join(dir, "config.json"), "utf8")).toBe(before);
-  });
-
-  test("is idempotent", () => {
-    const dir = workspaceWith({
-      liveVoice: { frontModel: { endpointExtensionMs: 2_000 } },
-    });
-
-    moveFrontModelConfigToVoiceMigration.run(dir);
-    const once = readConfig(dir);
-    moveFrontModelConfigToVoiceMigration.run(dir);
-
-    expect(readConfig(dir)).toEqual(once);
-  });
-
-  test("a missing config file is a no-op", () => {
-    const dir = mkdtempSync(join(tmpdir(), "move-front-model-empty-"));
-    expect(() => moveFrontModelConfigToVoiceMigration.run(dir)).not.toThrow();
-  });
-});

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

@@ -1,199 +0,0 @@
-import { existsSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
-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 MIGRATION_156_SCHEMA_URL =
-  "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json";
-
-function workspaceWith(config: unknown): string {
-  const dir = mkdtempSync(join(tmpdir(), "extract-workspace-mcp-"));
-  writeFileSync(join(dir, "config.json"), JSON.stringify(config, null, 2));
-  return dir;
-}
-
-function readJson(dir: string, name: string): Record<string, unknown> {
-  return JSON.parse(readFileSync(join(dir, name), "utf8")) as 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" },
-      mcp: {
-        servers: {
-          remote: {
-            transport: {
-              type: "streamable-http",
-              url: "https://example.com/mcp",
-            },
-          },
-          local: {
-            transport: {
-              type: "stdio",
-              command: "npx",
-              args: ["-y", "srv"],
-              env: { DATA_DIR: "/tmp" },
-            },
-          },
-        },
-      },
-    });
-
-    extractWorkspaceMcpJsonMigration.run(dir);
-
-    expect(readJson(dir, "config.json")).toEqual({
-      llm: { activeProfile: "balanced" },
-    });
-    expect(readJson(dir, "mcp.json")).toEqual({
-      $schema: MIGRATION_156_SCHEMA_URL,
-      mcpServers: {
-        remote: {
-          type: "streamable-http",
-          url: "https://example.com/mcp",
-        },
-        local: {
-          type: "stdio",
-          command: "npx",
-          args: ["-y", "srv"],
-          env: { DATA_DIR: "/tmp" },
-        },
-      },
-    });
-  });
-
-  test("copies leftover transport headers onto the spec entry", () => {
-    const dir = workspaceWith({
-      mcp: {
-        servers: {
-          remote: {
-            transport: {
-              type: "sse",
-              url: "https://example.com/sse",
-              headers: { Authorization: "Bearer leftover" },
-            },
-          },
-        },
-      },
-    });
-
-    extractWorkspaceMcpJsonMigration.run(dir);
-
-    expect(readJson(dir, "mcp.json")).toEqual({
-      $schema: MIGRATION_156_SCHEMA_URL,
-      mcpServers: {
-        remote: {
-          type: "sse",
-          url: "https://example.com/sse",
-          headers: { Authorization: "Bearer leftover" },
-        },
-      },
-    });
-  });
-
-  test("keeps existing mcp.json ids and fills only the missing ones", () => {
-    const dir = workspaceWith({
-      mcp: {
-        servers: {
-          fromConfig: {
-            transport: {
-              type: "streamable-http",
-              url: "https://config.example/mcp",
-            },
-          },
-          shared: {
-            transport: {
-              type: "streamable-http",
-              url: "https://config-loses.example/mcp",
-            },
-          },
-        },
-      },
-    });
-    writeFileSync(
-      join(dir, "mcp.json"),
-      JSON.stringify({
-        $schema: MIGRATION_156_SCHEMA_URL,
-        mcpServers: {
-          shared: {
-            type: "streamable-http",
-            url: "https://file-wins.example/mcp",
-          },
-        },
-      }),
-    );
-
-    extractWorkspaceMcpJsonMigration.run(dir);
-
-    expect(readJson(dir, "mcp.json")).toEqual({
-      $schema: MIGRATION_156_SCHEMA_URL,
-      mcpServers: {
-        fromConfig: {
-          type: "streamable-http",
-          url: "https://config.example/mcp",
-        },
-        shared: {
-          type: "streamable-http",
-          url: "https://file-wins.example/mcp",
-        },
-      },
-    });
-    expect(readJson(dir, "config.json")).toEqual({});
-  });
-
-  test("extracts a leftover array of servers", () => {
-    const dir = workspaceWith({
-      mcp: {
-        servers: [
-          {
-            name: "legacy",
-            transport: { type: "sse", url: "https://example.com/sse" },
-          },
-        ],
-      },
-    });
-
-    extractWorkspaceMcpJsonMigration.run(dir);
-
-    expect(readJson(dir, "mcp.json")).toEqual({
-      $schema: MIGRATION_156_SCHEMA_URL,
-      mcpServers: {
-        legacy: { type: "sse", url: "https://example.com/sse" },
-      },
-    });
-  });
-
-  test("is a no-op when mcp is already gone", () => {
-    const dir = workspaceWith({ llm: {} });
-    const before = readFileSync(join(dir, "config.json"), "utf8");
-
-    extractWorkspaceMcpJsonMigration.run(dir);
-
-    expect(readFileSync(join(dir, "config.json"), "utf8")).toBe(before);
-    expect(existsSync(join(dir, "mcp.json"))).toBe(false);
-  });
-
-  test("drops an empty mcp key without creating mcp.json", () => {
-    const dir = workspaceWith({ mcp: { servers: {} } });
-
-    extractWorkspaceMcpJsonMigration.run(dir);
-
-    expect(readJson(dir, "config.json")).toEqual({});
-    expect(existsSync(join(dir, "mcp.json"))).toBe(false);
-  });
-});