ultraclaude-agent 0.0.9 → 0.0.12

package/__tests__/config-windows.test.ts

@@ -1,8 +1,7 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
 // We need to test the platform-conditional path logic in config.ts.
-// Since CONFIG_DIR is resolved at module load time, we must reset modules between tests
-// and mock os.platform() before each import.
+// Since resolveConfigDir now takes a serverUrl parameter, we test it directly.
 
 const mockPlatform = vi.fn();
 vi.mock('node:os', () => ({
@@ -17,23 +16,29 @@ vi.mock('node:fs/promises', () => ({
   unlink: vi.fn().mockResolvedValue(undefined),
   access: vi.fn().mockRejectedValue(new Error('ENOENT')),
   readdir: vi.fn().mockResolvedValue([]),
+  rename: vi.fn().mockResolvedValue(undefined),
 }));
 
+const TEST_SERVER_URL = 'https://dashboard.ultra-claude.dev';
+const TEST_SERVER_KEY = 'dashboard.ultra-claude.dev';
+
 describe('config — path resolution', () => {
   beforeEach(() => {
     vi.clearAllMocks();
   });
 
-  it('uses APPDATA path on Windows when APPDATA env is set', async () => {
+  it('uses APPDATA path on Windows with server-specific subdir when APPDATA env is set', async () => {
     mockPlatform.mockReturnValue('win32');
     const originalAppData = process.env.APPDATA;
     process.env.APPDATA = 'C:\\Users\\test\\AppData\\Roaming';
 
     vi.resetModules();
-    const { paths } = await import('../src/config.js');
+    const { resolveConfigDir } = await import('../src/config.js');
+    const result = resolveConfigDir(TEST_SERVER_URL);
 
-    expect(paths.configDir).toContain('ultraclaude-agent');
-    expect(paths.configDir).toMatch(/AppData[/\\]Roaming[/\\]ultraclaude-agent/);
+    expect(result).toContain('ultraclaude-agent');
+    expect(result).toContain(TEST_SERVER_KEY);
+    expect(result).toMatch(/AppData[/\\]Roaming[/\\]ultraclaude-agent/);
 
     // Restore
     if (originalAppData === undefined) {
@@ -49,12 +54,14 @@ describe('config — path resolution', () => {
     delete process.env.APPDATA;
 
     vi.resetModules();
-    const { paths } = await import('../src/config.js');
+    const { resolveConfigDir } = await import('../src/config.js');
+    const result = resolveConfigDir(TEST_SERVER_URL);
 
-    expect(paths.configDir).toContain('ultraclaude-agent');
+    expect(result).toContain('ultraclaude-agent');
+    expect(result).toContain(TEST_SERVER_KEY);
     // Falls back to homedir/AppData/Roaming
-    expect(paths.configDir).toMatch(/testuser/);
-    expect(paths.configDir).toMatch(/AppData/);
+    expect(result).toMatch(/testuser/);
+    expect(result).toMatch(/AppData/);
 
     // Restore
     if (originalAppData !== undefined) {
@@ -62,32 +69,48 @@ describe('config — path resolution', () => {
     }
   });
 
-  it('uses ~/.claude/ultra/dashboard path on Linux', async () => {
+  it('uses ~/.claude/ultra/agent/{server-key}/ path on Linux', async () => {
     mockPlatform.mockReturnValue('linux');
 
     vi.resetModules();
-    const { paths } = await import('../src/config.js');
+    const { resolveConfigDir } = await import('../src/config.js');
 
-    expect(paths.configDir).toBe('/home/testuser/.claude/ultra/dashboard');
+    expect(resolveConfigDir(TEST_SERVER_URL)).toBe(
+      `/home/testuser/.claude/ultra/agent/${TEST_SERVER_KEY}`,
+    );
   });
 
-  it('uses ~/.claude/ultra/dashboard path on macOS', async () => {
+  it('uses ~/.claude/ultra/agent/{server-key}/ path on macOS', async () => {
     mockPlatform.mockReturnValue('darwin');
 
     vi.resetModules();
-    const { paths } = await import('../src/config.js');
+    const { resolveConfigDir } = await import('../src/config.js');
+
+    expect(resolveConfigDir(TEST_SERVER_URL)).toBe(
+      `/home/testuser/.claude/ultra/agent/${TEST_SERVER_KEY}`,
+    );
+  });
+
+  it('includes port in server key for non-standard port', async () => {
+    mockPlatform.mockReturnValue('linux');
+
+    vi.resetModules();
+    const { resolveConfigDir } = await import('../src/config.js');
 
-    expect(paths.configDir).toBe('/home/testuser/.claude/ultra/dashboard');
+    expect(resolveConfigDir('http://localhost:3000')).toBe(
+      '/home/testuser/.claude/ultra/agent/localhost-3000',
+    );
   });
 
-  it('derives credentials, pid, and logDir from configDir', async () => {
+  it('derives credentials, pid, and logDir from server-specific configDir', async () => {
     mockPlatform.mockReturnValue('linux');
 
     vi.resetModules();
-    const { paths } = await import('../src/config.js');
+    const { resolveServerPaths } = await import('../src/config.js');
+    const sp = resolveServerPaths(TEST_SERVER_URL);
 
-    expect(paths.credentials).toBe('/home/testuser/.claude/ultra/dashboard/credentials.json');
-    expect(paths.pid).toBe('/home/testuser/.claude/ultra/dashboard/daemon.pid');
-    expect(paths.logDir).toBe('/home/testuser/.claude/ultra/dashboard/logs');
+    expect(sp.credentials).toBe(`/home/testuser/.claude/ultra/agent/${TEST_SERVER_KEY}/credentials.json`);
+    expect(sp.pid).toBe(`/home/testuser/.claude/ultra/agent/${TEST_SERVER_KEY}/daemon.pid`);
+    expect(sp.logDir).toBe(`/home/testuser/.claude/ultra/agent/${TEST_SERVER_KEY}/logs`);
   });
 });

package/__tests__/config.test.ts

@@ -0,0 +1,369 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { join } from 'node:path';
+import { mkdtemp, writeFile, mkdir, rm, readFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+
+// These tests exercise the real config.ts functions against the real filesystem
+// (using temp dirs), no mocking of fs.
+
+// Mock node:os for homedir/platform control in path resolution tests
+const mockPlatform = vi.fn().mockReturnValue('linux');
+const mockHomedir = vi.fn().mockReturnValue('/home/testuser');
+
+vi.mock('node:os', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:os')>();
+  return {
+    ...actual,
+    homedir: () => mockHomedir(),
+    platform: () => mockPlatform(),
+  };
+});
+
+describe('config — serverUrlToKey', () => {
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  it('strips protocol and returns hostname for standard HTTPS port', async () => {
+    const { serverUrlToKey } = await import('../src/config.js');
+    expect(serverUrlToKey('https://dashboard.ultra-claude.dev')).toBe('dashboard.ultra-claude.dev');
+  });
+
+  it('strips protocol and returns hostname for standard HTTP port', async () => {
+    const { serverUrlToKey } = await import('../src/config.js');
+    expect(serverUrlToKey('http://example.com')).toBe('example.com');
+  });
+
+  it('includes non-standard port with dash separator', async () => {
+    const { serverUrlToKey } = await import('../src/config.js');
+    expect(serverUrlToKey('http://localhost:3000')).toBe('localhost-3000');
+  });
+
+  it('handles HTTPS with explicit non-standard port', async () => {
+    const { serverUrlToKey } = await import('../src/config.js');
+    expect(serverUrlToKey('https://10.0.0.1:8080')).toBe('10.0.0.1-8080');
+  });
+
+  it('strips trailing slash', async () => {
+    const { serverUrlToKey } = await import('../src/config.js');
+    expect(serverUrlToKey('https://dashboard.ultra-claude.dev/')).toBe('dashboard.ultra-claude.dev');
+  });
+
+  it('ignores explicit standard port (443 for HTTPS)', async () => {
+    const { serverUrlToKey } = await import('../src/config.js');
+    // URL class strips default ports automatically
+    expect(serverUrlToKey('https://dashboard.ultra-claude.dev:443')).toBe('dashboard.ultra-claude.dev');
+  });
+
+  it('ignores explicit standard port (80 for HTTP)', async () => {
+    const { serverUrlToKey } = await import('../src/config.js');
+    expect(serverUrlToKey('http://example.com:80')).toBe('example.com');
+  });
+});
+
+describe('config — resolveConfigDir', () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.clearAllMocks();
+  });
+
+  it('resolves to ~/.claude/ultra/agent/{server-key}/ on Linux', async () => {
+    mockPlatform.mockReturnValue('linux');
+    mockHomedir.mockReturnValue('/home/testuser');
+
+    const { resolveConfigDir } = await import('../src/config.js');
+    expect(resolveConfigDir('https://dashboard.ultra-claude.dev')).toBe(
+      '/home/testuser/.claude/ultra/agent/dashboard.ultra-claude.dev',
+    );
+  });
+
+  it('resolves with port for non-standard port', async () => {
+    mockPlatform.mockReturnValue('linux');
+    mockHomedir.mockReturnValue('/home/testuser');
+
+    const { resolveConfigDir } = await import('../src/config.js');
+    expect(resolveConfigDir('http://localhost:3000')).toBe(
+      '/home/testuser/.claude/ultra/agent/localhost-3000',
+    );
+  });
+
+  it('resolves to APPDATA path on Windows', async () => {
+    mockPlatform.mockReturnValue('win32');
+    const originalAppData = process.env.APPDATA;
+    process.env.APPDATA = 'C:\\Users\\test\\AppData\\Roaming';
+
+    const { resolveConfigDir } = await import('../src/config.js');
+    const result = resolveConfigDir('https://dashboard.ultra-claude.dev');
+    expect(result).toContain('ultraclaude-agent');
+    expect(result).toContain('dashboard.ultra-claude.dev');
+
+    if (originalAppData === undefined) {
+      delete process.env.APPDATA;
+    } else {
+      process.env.APPDATA = originalAppData;
+    }
+  });
+});
+
+describe('config — resolveServerPaths', () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.clearAllMocks();
+    mockPlatform.mockReturnValue('linux');
+    mockHomedir.mockReturnValue('/home/testuser');
+  });
+
+  it('derives credentials, pid, and logDir from server-specific configDir', async () => {
+    const { resolveServerPaths } = await import('../src/config.js');
+    const sp = resolveServerPaths('https://dashboard.ultra-claude.dev');
+
+    expect(sp.configDir).toBe('/home/testuser/.claude/ultra/agent/dashboard.ultra-claude.dev');
+    expect(sp.credentials).toBe('/home/testuser/.claude/ultra/agent/dashboard.ultra-claude.dev/credentials.json');
+    expect(sp.pid).toBe('/home/testuser/.claude/ultra/agent/dashboard.ultra-claude.dev/daemon.pid');
+    expect(sp.logDir).toBe('/home/testuser/.claude/ultra/agent/dashboard.ultra-claude.dev/logs');
+  });
+});
+
+describe('config — getProjectId (server-keyed)', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    vi.resetModules();
+    tempDir = await mkdtemp(join(tmpdir(), 'config-test-'));
+    await mkdir(join(tempDir, '.claude', 'ultra'), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  // --- REPRODUCTION TEST ---
+  // This is the core bug: a bare UUID in project-id should NOT be returned
+  // when querying for a specific server.
+  it('REPRODUCTION: bare UUID in project-id returns null (not the wrong servers ID)', async () => {
+    const { getProjectId } = await import('../src/config.js');
+
+    // Simulate old format: bare UUID written by previous agent version
+    await writeFile(
+      join(tempDir, '.claude', 'ultra', 'project-id'),
+      '550e8400-e29b-41d4-a716-446655440000',
+    );
+
+    // Querying for any server should return null — the bare UUID has no server association
+    const result = await getProjectId(tempDir, 'https://dashboard.ultra-claude.dev');
+    expect(result).toBeNull();
+  });
+
+  it('returns correct ID for matching server from JSON map', async () => {
+    const { getProjectId } = await import('../src/config.js');
+
+    const map = {
+      'dashboard.ultra-claude.dev': 'prod-uuid-123',
+      'localhost-3000': 'dev-uuid-456',
+    };
+    await writeFile(join(tempDir, '.claude', 'ultra', 'project-id'), JSON.stringify(map));
+
+    expect(await getProjectId(tempDir, 'https://dashboard.ultra-claude.dev')).toBe('prod-uuid-123');
+    expect(await getProjectId(tempDir, 'http://localhost:3000')).toBe('dev-uuid-456');
+  });
+
+  it('returns null for unknown server in JSON map', async () => {
+    const { getProjectId } = await import('../src/config.js');
+
+    const map = { 'localhost-3000': 'dev-uuid-456' };
+    await writeFile(join(tempDir, '.claude', 'ultra', 'project-id'), JSON.stringify(map));
+
+    expect(await getProjectId(tempDir, 'https://other-server.dev')).toBeNull();
+  });
+
+  it('returns null when project-id file does not exist', async () => {
+    const { getProjectId } = await import('../src/config.js');
+    expect(await getProjectId(tempDir, 'https://dashboard.ultra-claude.dev')).toBeNull();
+  });
+
+  it('deletes old format bare UUID file and returns null', async () => {
+    const { getProjectId } = await import('../src/config.js');
+    const filePath = join(tempDir, '.claude', 'ultra', 'project-id');
+
+    await writeFile(filePath, '550e8400-e29b-41d4-a716-446655440000');
+
+    const result = await getProjectId(tempDir, 'https://dashboard.ultra-claude.dev');
+    expect(result).toBeNull();
+
+    // File should be deleted
+    await expect(readFile(filePath, 'utf8')).rejects.toThrow();
+  });
+
+  it('deletes corrupt (non-JSON) file and returns null', async () => {
+    const { getProjectId } = await import('../src/config.js');
+    const filePath = join(tempDir, '.claude', 'ultra', 'project-id');
+
+    await writeFile(filePath, 'this is not json or a uuid');
+
+    const result = await getProjectId(tempDir, 'https://dashboard.ultra-claude.dev');
+    expect(result).toBeNull();
+
+    // File should be deleted
+    await expect(readFile(filePath, 'utf8')).rejects.toThrow();
+  });
+
+  it('deletes file with quoted UUID string (JSON string) and returns null', async () => {
+    const { getProjectId } = await import('../src/config.js');
+    const filePath = join(tempDir, '.claude', 'ultra', 'project-id');
+
+    // A quoted UUID is valid JSON (parses to a string), but it's the old format
+    await writeFile(filePath, '"550e8400-e29b-41d4-a716-446655440000"');
+
+    const result = await getProjectId(tempDir, 'https://dashboard.ultra-claude.dev');
+    expect(result).toBeNull();
+
+    // File should be deleted
+    await expect(readFile(filePath, 'utf8')).rejects.toThrow();
+  });
+
+  it('deletes file with JSON array and returns null', async () => {
+    const { getProjectId } = await import('../src/config.js');
+    const filePath = join(tempDir, '.claude', 'ultra', 'project-id');
+
+    await writeFile(filePath, '["not", "a", "map"]');
+
+    const result = await getProjectId(tempDir, 'https://dashboard.ultra-claude.dev');
+    expect(result).toBeNull();
+
+    await expect(readFile(filePath, 'utf8')).rejects.toThrow();
+  });
+
+  it('handles empty file gracefully', async () => {
+    const { getProjectId } = await import('../src/config.js');
+    const filePath = join(tempDir, '.claude', 'ultra', 'project-id');
+
+    await writeFile(filePath, '');
+
+    const result = await getProjectId(tempDir, 'https://dashboard.ultra-claude.dev');
+    expect(result).toBeNull();
+  });
+});
+
+describe('config — writeProjectId (server-keyed)', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    vi.resetModules();
+    tempDir = await mkdtemp(join(tmpdir(), 'config-write-test-'));
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('creates new JSON map when file does not exist', async () => {
+    const { writeProjectId } = await import('../src/config.js');
+
+    await writeProjectId(tempDir, 'https://dashboard.ultra-claude.dev', 'new-uuid');
+
+    const content = JSON.parse(await readFile(join(tempDir, '.claude', 'ultra', 'project-id'), 'utf8'));
+    expect(content).toEqual({ 'dashboard.ultra-claude.dev': 'new-uuid' });
+  });
+
+  it('updates existing JSON map preserving other server entries', async () => {
+    const { writeProjectId } = await import('../src/config.js');
+
+    // Write first entry
+    await writeProjectId(tempDir, 'http://localhost:3000', 'dev-uuid');
+
+    // Write second entry for different server
+    await writeProjectId(tempDir, 'https://dashboard.ultra-claude.dev', 'prod-uuid');
+
+    const content = JSON.parse(await readFile(join(tempDir, '.claude', 'ultra', 'project-id'), 'utf8'));
+    expect(content).toEqual({
+      'localhost-3000': 'dev-uuid',
+      'dashboard.ultra-claude.dev': 'prod-uuid',
+    });
+  });
+
+  it('overwrites entry for same server', async () => {
+    const { writeProjectId } = await import('../src/config.js');
+
+    await writeProjectId(tempDir, 'http://localhost:3000', 'old-uuid');
+    await writeProjectId(tempDir, 'http://localhost:3000', 'new-uuid');
+
+    const content = JSON.parse(await readFile(join(tempDir, '.claude', 'ultra', 'project-id'), 'utf8'));
+    expect(content).toEqual({ 'localhost-3000': 'new-uuid' });
+  });
+
+  it('recovers from corrupt file by starting fresh map', async () => {
+    const { writeProjectId } = await import('../src/config.js');
+
+    // Write corrupt content
+    await mkdir(join(tempDir, '.claude', 'ultra'), { recursive: true });
+    await writeFile(join(tempDir, '.claude', 'ultra', 'project-id'), 'not json at all');
+
+    // Should overwrite with a fresh map
+    await writeProjectId(tempDir, 'https://dashboard.ultra-claude.dev', 'fresh-uuid');
+
+    const content = JSON.parse(await readFile(join(tempDir, '.claude', 'ultra', 'project-id'), 'utf8'));
+    expect(content).toEqual({ 'dashboard.ultra-claude.dev': 'fresh-uuid' });
+  });
+});
+
+describe('config — migrateOldConfigDir', () => {
+  let tempHome: string;
+
+  beforeEach(async () => {
+    vi.resetModules();
+    vi.clearAllMocks();
+    mockPlatform.mockReturnValue('linux');
+
+    tempHome = await mkdtemp(join(tmpdir(), 'config-migrate-test-'));
+    mockHomedir.mockReturnValue(tempHome);
+  });
+
+  afterEach(async () => {
+    await rm(tempHome, { recursive: true, force: true });
+  });
+
+  it('migrates old config dir to server-specific dir', async () => {
+    const { migrateOldConfigDir } = await import('../src/config.js');
+
+    // Create old dir with a credentials file
+    const oldDir = join(tempHome, '.claude', 'ultra', 'dashboard');
+    await mkdir(oldDir, { recursive: true });
+    await writeFile(join(oldDir, 'credentials.json'), '{"test": true}');
+
+    const migrated = await migrateOldConfigDir('https://dashboard.ultra-claude.dev');
+    expect(migrated).toBe(true);
+
+    // Old dir should be gone, new dir should exist with the file
+    const newDir = join(tempHome, '.claude', 'ultra', 'agent', 'dashboard.ultra-claude.dev');
+    const content = await readFile(join(newDir, 'credentials.json'), 'utf8');
+    expect(content).toBe('{"test": true}');
+
+    // Old dir should not exist
+    await expect(readFile(join(oldDir, 'credentials.json'), 'utf8')).rejects.toThrow();
+  });
+
+  it('returns false when old dir does not exist', async () => {
+    const { migrateOldConfigDir } = await import('../src/config.js');
+    const migrated = await migrateOldConfigDir('https://dashboard.ultra-claude.dev');
+    expect(migrated).toBe(false);
+  });
+
+  it('returns false when new dir already exists (no overwrite)', async () => {
+    const { migrateOldConfigDir } = await import('../src/config.js');
+
+    // Create both old and new dirs
+    const oldDir = join(tempHome, '.claude', 'ultra', 'dashboard');
+    const newDir = join(tempHome, '.claude', 'ultra', 'agent', 'dashboard.ultra-claude.dev');
+    await mkdir(oldDir, { recursive: true });
+    await mkdir(newDir, { recursive: true });
+    await writeFile(join(oldDir, 'credentials.json'), '{"old": true}');
+    await writeFile(join(newDir, 'credentials.json'), '{"new": true}');
+
+    const migrated = await migrateOldConfigDir('https://dashboard.ultra-claude.dev');
+    expect(migrated).toBe(false);
+
+    // New dir should be untouched
+    const content = await readFile(join(newDir, 'credentials.json'), 'utf8');
+    expect(content).toBe('{"new": true}');
+  });
+});

package/__tests__/daemon.test.ts

@@ -18,31 +18,34 @@ const mockGetProjectId = vi.fn();
 const mockWriteProjectId = vi.fn();
 const mockWritePid = vi.fn().mockResolvedValue(undefined);
 const mockRemovePid = vi.fn().mockResolvedValue(undefined);
+const mockMigrateOldConfigDir = vi.fn().mockResolvedValue(false);
 
 vi.mock('../src/config.js', () => ({
   loadCredentials: (...args: unknown[]) => mockLoadCredentials(...args),
+  getServerUrl: (creds: { serverUrl: string } | null) =>
+    creds?.serverUrl ?? 'https://dashboard.ultra-claude.dev',
   loadRegistry: (...args: unknown[]) => mockLoadRegistry(...args),
   getProjectId: (...args: unknown[]) => mockGetProjectId(...args),
   writeProjectId: (...args: unknown[]) => mockWriteProjectId(...args),
   writePid: (...args: unknown[]) => mockWritePid(...args),
   removePid: (...args: unknown[]) => mockRemovePid(...args),
+  migrateOldConfigDir: (...args: unknown[]) => mockMigrateOldConfigDir(...args),
   paths: {
-    configDir: '/tmp/test-config',
-    credentials: '/tmp/test-config/credentials.json',
-    pid: '/tmp/test-config/daemon.pid',
-    logDir: '/tmp/test-config/logs',
-    registry: '/tmp/test-registry.json',
+    claudeProjects: '/tmp/test-claude-projects',
     projectIdFile: '.claude/ultra/project-id',
+    oldConfigDir: '/tmp/test-old-config',
   },
 }));
 
 // Mock sync
 const mockCreateProjectOnServer = vi.fn();
 const mockInitialSync = vi.fn().mockResolvedValue(undefined);
+const mockFetchManifest = vi.fn();
 const mockStopSync = vi.fn();
 vi.mock('../src/sync.js', () => ({
   createProjectOnServer: (...args: unknown[]) => mockCreateProjectOnServer(...args),
   initialSync: (...args: unknown[]) => mockInitialSync(...args),
+  fetchManifest: (...args: unknown[]) => mockFetchManifest(...args),
   stopSync: (...args: unknown[]) => mockStopSync(...args),
 }));
 
@@ -52,6 +55,13 @@ vi.mock('../src/watcher.js', () => ({
   startProjectWatcher: (...args: unknown[]) => mockStartProjectWatcher(...args),
 }));
 
+// Mock usage-sync
+vi.mock('../src/usage-sync.js', () => ({
+  startUsageWatcher: vi.fn().mockReturnValue({
+    close: vi.fn().mockResolvedValue(undefined),
+  }),
+}));
+
 // Mock logger
 vi.mock('../src/logger.js', () => ({
   logger: {
@@ -65,6 +75,7 @@ vi.mock('../src/logger.js', () => ({
     warn: vi.fn(),
     error: vi.fn(),
     debug: vi.fn(),
+    fatal: vi.fn(),
   },
 }));
 
@@ -76,6 +87,8 @@ describe('daemon', () => {
       projectPath: '/test/project',
       close: vi.fn().mockResolvedValue(undefined),
     });
+    // Default: manifest validation succeeds (project exists on server)
+    mockFetchManifest.mockResolvedValue({ success: true, data: [] });
   });
 
   it('starts daemon and initializes watchers for registered projects', async () => {
@@ -93,7 +106,8 @@ describe('daemon', () => {
     const result = await startDaemon();
 
     expect(result.success).toBe(true);
-    expect(mockWritePid).toHaveBeenCalled();
+    expect(mockWritePid).toHaveBeenCalledWith('http://localhost:3000');
+    expect(mockGetProjectId).toHaveBeenCalledWith('/test/project', 'http://localhost:3000');
     expect(mockStartProjectWatcher).toHaveBeenCalledWith({
       projectId: 'proj-1',
       projectPath: '/test/project',
@@ -101,7 +115,7 @@ describe('daemon', () => {
     expect(mockInitialSync).toHaveBeenCalledWith('proj-1', '/test/project');
 
     await stopDaemon();
-    expect(mockRemovePid).toHaveBeenCalled();
+    expect(mockRemovePid).toHaveBeenCalledWith('http://localhost:3000');
   });
 
   it('returns NOT_LOGGED_IN error if not logged in', async () => {
@@ -135,7 +149,55 @@ describe('daemon', () => {
     await startDaemon();
 
     expect(mockCreateProjectOnServer).toHaveBeenCalledWith('New Project', 'new-project');
-    expect(mockWriteProjectId).toHaveBeenCalledWith('/test/new-project', 'new-id');
+    expect(mockWriteProjectId).toHaveBeenCalledWith('/test/new-project', 'http://localhost:3000', 'new-id');
+
+    await stopDaemon();
+  });
+
+  it('re-creates project when server returns 404 (stale project-id)', async () => {
+    mockLoadCredentials.mockResolvedValue({
+      apiKey: 'test-key',
+      userId: 'test-user',
+      serverUrl: 'http://localhost:3000',
+    });
+    mockLoadRegistry.mockResolvedValue({
+      projects: [{ path: '/test/stale-project', name: 'Stale Project' }],
+    });
+    // getProjectId returns a stale ID
+    mockGetProjectId.mockResolvedValue('stale-uuid');
+    // But the server says project not found
+    mockFetchManifest.mockResolvedValue({
+      success: false,
+      error: 'PROJECT_NOT_FOUND',
+      message: 'Project not found',
+    });
+    mockCreateProjectOnServer.mockResolvedValue({ id: 'fresh-uuid' });
+
+    vi.resetModules();
+    const { startDaemon, stopDaemon } = await import('../src/daemon.js');
+    await startDaemon();
+
+    // Should create a new project on the server
+    expect(mockCreateProjectOnServer).toHaveBeenCalledWith('Stale Project', 'stale-project');
+    // Should write the new ID
+    expect(mockWriteProjectId).toHaveBeenCalledWith('/test/stale-project', 'http://localhost:3000', 'fresh-uuid');
+
+    await stopDaemon();
+  });
+
+  it('migrates old config dir on startup', async () => {
+    mockLoadCredentials.mockResolvedValue({
+      apiKey: 'test-key',
+      userId: 'test-user',
+      serverUrl: 'http://localhost:3000',
+    });
+    mockLoadRegistry.mockResolvedValue({ projects: [] });
+
+    vi.resetModules();
+    const { startDaemon, stopDaemon } = await import('../src/daemon.js');
+    await startDaemon();
+
+    expect(mockMigrateOldConfigDir).toHaveBeenCalledWith('http://localhost:3000');
 
     await stopDaemon();
   });

package/__tests__/service-windows.test.ts

@@ -28,12 +28,19 @@ vi.mock('node:fs/promises', () => ({
 
 // Mock config
 vi.mock('../src/config.js', () => ({
+  resolveServerPaths: (serverUrl: string) => {
+    const key = new URL(serverUrl).host.replace(':', '-');
+    return {
+      configDir: `/tmp/test-config/${key}`,
+      credentials: `/tmp/test-config/${key}/credentials.json`,
+      pid: `/tmp/test-config/${key}/daemon.pid`,
+      logDir: `/tmp/test-config/${key}/logs`,
+    };
+  },
   paths: {
-    configDir: '/tmp/test-config',
-    credentials: '/tmp/test-config/credentials.json',
-    pid: '/tmp/test-config/daemon.pid',
-    logDir: '/tmp/test-config/logs',
+    claudeProjects: '/home/testuser/.claude/projects',
     projectIdFile: '.claude/ultra/project-id',
+    oldConfigDir: '/home/testuser/.claude/ultra/dashboard',
   },
   fileExists: vi.fn().mockResolvedValue(false),
 }));
@@ -63,7 +70,7 @@ describe('service — Windows Task Scheduler', () => {
 
   it('installService on win32 calls schtasks /create with correct args', async () => {
     const { installService } = await import('../src/service.js');
-    await installService();
+    await installService('http://localhost:3000');
 
     expect(mockExecFile).toHaveBeenCalledWith(
       'schtasks.exe',
@@ -73,7 +80,7 @@ describe('service — Windows Task Scheduler', () => {
 
   it('installService on win32 passes /rl limited and /f flags', async () => {
     const { installService } = await import('../src/service.js');
-    await installService();
+    await installService('http://localhost:3000');
 
     const args = mockExecFile.mock.calls[0]![1] as string[];
     expect(args).toContain('/rl');