moving

packages/hive-mind-hooks-claude-desktop/tests/install.test.ts

@@ -0,0 +1,155 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { existsSync } from 'node:fs';
+import {
+  mkdir,
+  mkdtemp,
+  readFile,
+  readdir,
+  rm,
+  writeFile,
+} from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { install, MCP_SERVER_NAME } from '../src/install.js';
+import { resolvePaths } from '../src/paths.js';
+
+interface TestEnv {
+  home: string;
+  mcpEntry: string;
+}
+
+async function bootstrap(initial?: Record<string, unknown>): Promise<TestEnv> {
+  const home = await mkdtemp(join(tmpdir(), 'hm-claude-desktop-install-'));
+  const mcpEntry = join(home, 'memory-mcp.js');
+  await writeFile(mcpEntry, 'export {};\n', 'utf-8');
+  if (initial !== undefined) {
+    const paths = resolvePaths({ home, platform: 'linux' });
+    await mkdir(paths.claudeConfigDir, { recursive: true });
+    await writeFile(paths.configPath, JSON.stringify(initial, null, 2) + '\n', 'utf-8');
+  }
+  return { home, mcpEntry };
+}
+
+function installOpts(env: TestEnv, mcpEntry = env.mcpEntry) {
+  return {
+    home: env.home,
+    platform: 'linux' as const,
+    mcpEntry,
+  };
+}
+
+describe('install (claude-desktop)', () => {
+  const homes: string[] = [];
+
+  afterEach(async () => {
+    for (const home of homes.splice(0)) {
+      await rm(home, { recursive: true, force: true });
+    }
+  });
+
+  it('creates a config and ownership pointer on a fresh install', async () => {
+    const env = await bootstrap();
+    homes.push(env.home);
+
+    const result = await install({
+      ...installOpts(env),
+      cliPath: ' /opt/hive-mind-cli/dist/index.js ',
+    });
+    const config = JSON.parse(await readFile(result.paths.configPath, 'utf-8')) as {
+      mcpServers: Record<string, { command: string; args: string[] }>;
+    };
+    const pointer = JSON.parse(await readFile(result.pointerPath, 'utf-8')) as Record<string, unknown>;
+
+    expect(result.createdByUs).toBe(true);
+    expect(result.backupPath).toBeNull();
+    expect(config.mcpServers[MCP_SERVER_NAME]).toEqual({
+      command: process.env.WAGGLE_HOOK_NODE_PATH?.trim() || process.execPath,
+      args: [env.mcpEntry],
+    });
+    expect(Object.keys(config.mcpServers[MCP_SERVER_NAME])).toEqual(['command', 'args']);
+    expect(pointer['created_by_us']).toBe(true);
+    expect(pointer['settings_backup']).toBeNull();
+    expect(pointer['hooks_dir']).toBeNull();
+    expect(pointer['installed_hooks']).toEqual(['mcp:waggle-memory']);
+    expect(pointer['cli_path']).toBe('/opt/hive-mind-cli/dist/index.js');
+  });
+
+  it('backs up a pre-existing config byte-identically and preserves other servers', async () => {
+    const existingServer = {
+      command: 'python',
+      args: ['server.py'],
+      env: { KEEP_ME: 'yes' },
+    };
+    const env = await bootstrap({
+      theme: 'dark',
+      mcpServers: { userServer: existingServer },
+    });
+    homes.push(env.home);
+    const paths = resolvePaths({ home: env.home, platform: 'linux' });
+    const originalBytes = await readFile(paths.configPath);
+
+    const result = await install(installOpts(env));
+    const config = JSON.parse(await readFile(paths.configPath, 'utf-8')) as {
+      theme: string;
+      mcpServers: Record<string, unknown>;
+    };
+
+    expect(result.createdByUs).toBe(false);
+    expect(result.backupPath).not.toBeNull();
+    expect(await readFile(result.backupPath as string)).toEqual(originalBytes);
+    expect(config.theme).toBe('dark');
+    expect(config.mcpServers['userServer']).toEqual(existingServer);
+    expect(config.mcpServers[MCP_SERVER_NAME]).toBeDefined();
+  });
+
+  it("refuses to clobber a foreign 'waggle-memory' entry without a pointer", async () => {
+    const foreignEntry = { command: 'node', args: ['/user/server.js'] };
+    const env = await bootstrap({ mcpServers: { [MCP_SERVER_NAME]: foreignEntry } });
+    homes.push(env.home);
+
+    await expect(install(installOpts(env))).rejects.toThrow(
+      /was not installed by this tool; remove or rename it first/,
+    );
+    const paths = resolvePaths({ home: env.home, platform: 'linux' });
+    const config = JSON.parse(await readFile(paths.configPath, 'utf-8')) as {
+      mcpServers: Record<string, unknown>;
+    };
+    expect(config.mcpServers[MCP_SERVER_NAME]).toEqual(foreignEntry);
+    expect(existsSync(paths.pointerPath)).toBe(false);
+  });
+
+  it('replaces its entry on reinstall without replacing the original backup or ownership', async () => {
+    const env = await bootstrap({ mcpServers: { userServer: { command: 'user', args: [] } } });
+    homes.push(env.home);
+    const first = await install(installOpts(env));
+    const firstPointer = JSON.parse(await readFile(first.pointerPath, 'utf-8')) as Record<string, unknown>;
+    const replacementEntry = join(env.home, 'memory-mcp-v2.js');
+    await writeFile(replacementEntry, 'export const version = 2;\n', 'utf-8');
+
+    const second = await install(installOpts(env, replacementEntry));
+    const secondPointer = JSON.parse(await readFile(second.pointerPath, 'utf-8')) as Record<string, unknown>;
+    const config = JSON.parse(await readFile(second.paths.configPath, 'utf-8')) as {
+      mcpServers: Record<string, { args: string[] }>;
+    };
+    const backups = (await readdir(second.paths.claudeConfigDir))
+      .filter((name) => name.includes('hive-mind-backup'));
+
+    expect(config.mcpServers[MCP_SERVER_NAME].args).toEqual([replacementEntry]);
+    expect(Object.keys(config.mcpServers).filter((name) => name === MCP_SERVER_NAME)).toHaveLength(1);
+    expect(second.backupPath).toBe(first.backupPath);
+    expect(secondPointer['settings_backup']).toBe(firstPointer['settings_backup']);
+    expect(secondPointer['created_by_us']).toBe(firstPointer['created_by_us']);
+    expect(backups).toHaveLength(1);
+  });
+
+  it('throws when the MCP entry cannot be resolved', async () => {
+    const env = await bootstrap();
+    homes.push(env.home);
+
+    await expect(install({
+      home: env.home,
+      platform: 'linux',
+      mcpEntry: '   ',
+    })).rejects.toThrow(/cannot resolve waggle-memory-mcp\/dist\/index\.js/);
+  });
+});