ultraclaude-agent 0.0.17 → 0.0.19

package/__tests__/daemon-reconcile.test.ts

@@ -86,6 +86,15 @@ vi.mock('../src/usage-sync.js', () => ({
   }),
 }));
 
+// Mock socket-client
+vi.mock('../src/socket-client.js', () => ({
+  init: vi.fn(),
+  addAccount: vi.fn(),
+  removeAccount: vi.fn(),
+  disconnectAll: vi.fn(),
+  getConnectedUserIds: vi.fn().mockReturnValue([]),
+}));
+
 // Mock logger
 vi.mock('../src/logger.js', () => ({
   logger: {

package/__tests__/daemon.test.ts

@@ -84,6 +84,15 @@ vi.mock('../src/usage-sync.js', () => ({
   }),
 }));
 
+// Mock socket-client
+vi.mock('../src/socket-client.js', () => ({
+  init: vi.fn(),
+  addAccount: vi.fn(),
+  removeAccount: vi.fn(),
+  disconnectAll: vi.fn(),
+  getConnectedUserIds: vi.fn().mockReturnValue([]),
+}));
+
 // Mock logger
 vi.mock('../src/logger.js', () => ({
   logger: {

package/__tests__/pid-detection.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { spawn } from 'node:child_process';
+import { isDaemonRunning, isPidAlive, verifyProcessIdentity, cleanStalePidFile } from '../src/config.js';
+
+// Mock removePid (called internally by cleanStalePidFile)
+vi.mock('node:fs/promises', async () => {
+  const actual = await vi.importActual<typeof import('node:fs/promises')>('node:fs/promises');
+  return {
+    ...actual,
+    unlink: vi.fn().mockResolvedValue(undefined),
+  };
+});
+
+describe('Process identity verification', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('isDaemonRunning returns false for a dead PID', () => {
+    // Use a PID that's almost certainly not running (very high number)
+    const result = isDaemonRunning(99999999);
+    expect(result).toBe(false);
+  });
+
+  it('isPidAlive returns true for the current process', () => {
+    const result = isPidAlive(process.pid);
+    expect(result).toBe(true);
+  });
+
+  it('isDaemonRunning returns false for a live non-agent process', async () => {
+    // Spawn a simple sleep process — definitely not ultraclaude-agent
+    const child = spawn('sleep', ['30'], { stdio: 'ignore' });
+
+    try {
+      expect(child.pid).toBeDefined();
+      const pid = child.pid!;
+
+      // PID should be alive
+      expect(isPidAlive(pid)).toBe(true);
+
+      // But isDaemonRunning should return false (not our daemon)
+      expect(isDaemonRunning(pid)).toBe(false);
+
+      // verifyProcessIdentity should also return false
+      expect(verifyProcessIdentity(pid)).toBe(false);
+    } finally {
+      child.kill('SIGTERM');
+    }
+  });
+
+  it('verifyProcessIdentity returns false for a dead PID', () => {
+    expect(verifyProcessIdentity(99999999)).toBe(false);
+  });
+
+  describe('cleanStalePidFile', () => {
+    it('logs a warning about stale PID', async () => {
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      await cleanStalePidFile('https://test.example.com', 12345);
+
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('PID 12345 is alive but is not ultraclaude-agent'),
+      );
+
+      warnSpy.mockRestore();
+    });
+  });
+});

package/__tests__/socket-client.test.ts

@@ -0,0 +1,210 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mock socket.io-client
+const mockOn = vi.fn().mockReturnThis();
+const mockDisconnect = vi.fn().mockReturnThis();
+const mockSocket = {
+  on: mockOn,
+  disconnect: mockDisconnect,
+  id: 'mock-socket-id',
+  connected: true,
+};
+const mockIo = vi.fn().mockReturnValue(mockSocket);
+
+vi.mock('socket.io-client', () => ({
+  io: (...args: unknown[]) => mockIo(...args),
+}));
+
+// Mock logger
+vi.mock('../src/logger.js', () => ({
+  logger: {
+    child: () => ({
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      debug: vi.fn(),
+    }),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn(),
+  },
+}));
+
+describe('socket-client', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Each test gets a fresh socket mock
+    mockIo.mockReturnValue({
+      on: mockOn,
+      disconnect: mockDisconnect,
+      id: 'mock-socket-id',
+      connected: true,
+    });
+  });
+
+  // Re-import module fresh for each describe block to reset module state
+  async function loadModule() {
+    vi.resetModules();
+    return import('../src/socket-client.js');
+  }
+
+  describe('init', () => {
+    it('creates one socket per credential entry', async () => {
+      const mod = await loadModule();
+      const creds = new Map([
+        ['user-1', { apiKey: 'key-1' }],
+        ['user-2', { apiKey: 'key-2' }],
+      ]);
+
+      mod.init('http://localhost:3000', creds);
+
+      expect(mockIo).toHaveBeenCalledTimes(2);
+      expect(mockIo).toHaveBeenCalledWith('http://localhost:3000', {
+        transports: ['websocket'],
+        path: '/socket.io',
+        auth: { token: 'key-1' },
+        forceNew: true,
+      });
+      expect(mockIo).toHaveBeenCalledWith('http://localhost:3000', {
+        transports: ['websocket'],
+        path: '/socket.io',
+        auth: { token: 'key-2' },
+        forceNew: true,
+      });
+    });
+
+    it('is idempotent — disconnects existing sockets before creating new ones', async () => {
+      const mod = await loadModule();
+
+      // First init
+      mod.init('http://localhost:3000', new Map([['user-1', { apiKey: 'key-1' }]]));
+      expect(mockIo).toHaveBeenCalledTimes(1);
+
+      // Second init — should disconnect first socket, then create new one
+      mod.init('http://localhost:3000', new Map([['user-1', { apiKey: 'key-new' }]]));
+      expect(mockDisconnect).toHaveBeenCalled();
+      expect(mockIo).toHaveBeenCalledTimes(2);
+    });
+
+    it('registers connect, disconnect, and connect_error handlers', async () => {
+      const mod = await loadModule();
+      mod.init('http://localhost:3000', new Map([['user-1', { apiKey: 'key-1' }]]));
+
+      const registeredEvents = mockOn.mock.calls.map((call: unknown[]) => call[0]);
+      expect(registeredEvents).toContain('connect');
+      expect(registeredEvents).toContain('disconnect');
+      expect(registeredEvents).toContain('connect_error');
+    });
+  });
+
+  describe('addAccount', () => {
+    it('creates a new connection', async () => {
+      const mod = await loadModule();
+      mod.addAccount('http://localhost:3000', 'user-1', 'key-1');
+
+      expect(mockIo).toHaveBeenCalledTimes(1);
+      expect(mockIo).toHaveBeenCalledWith('http://localhost:3000', {
+        transports: ['websocket'],
+        path: '/socket.io',
+        auth: { token: 'key-1' },
+        forceNew: true,
+      });
+      expect(mod.getConnectedUserIds()).toEqual(['user-1']);
+    });
+
+    it('disconnects existing socket before replacing with new one', async () => {
+      const firstSocket = {
+        on: vi.fn().mockReturnThis(),
+        disconnect: vi.fn().mockReturnThis(),
+        id: 'first-socket',
+        connected: true,
+      };
+      const secondSocket = {
+        on: vi.fn().mockReturnThis(),
+        disconnect: vi.fn().mockReturnThis(),
+        id: 'second-socket',
+        connected: true,
+      };
+      mockIo.mockReturnValueOnce(firstSocket).mockReturnValueOnce(secondSocket);
+
+      const mod = await loadModule();
+      mod.addAccount('http://localhost:3000', 'user-1', 'key-1');
+      mod.addAccount('http://localhost:3000', 'user-1', 'key-new');
+
+      expect(firstSocket.disconnect).toHaveBeenCalled();
+      expect(mockIo).toHaveBeenCalledTimes(2);
+      expect(mod.getConnectedUserIds()).toEqual(['user-1']);
+    });
+  });
+
+  describe('removeAccount', () => {
+    it('disconnects and removes socket', async () => {
+      const socket = {
+        on: vi.fn().mockReturnThis(),
+        disconnect: vi.fn().mockReturnThis(),
+        id: 'socket-1',
+        connected: true,
+      };
+      mockIo.mockReturnValue(socket);
+
+      const mod = await loadModule();
+      mod.addAccount('http://localhost:3000', 'user-1', 'key-1');
+      expect(mod.getConnectedUserIds()).toEqual(['user-1']);
+
+      mod.removeAccount('user-1');
+      expect(socket.disconnect).toHaveBeenCalled();
+      expect(mod.getConnectedUserIds()).toEqual([]);
+    });
+
+    it('is a no-op for unknown userId', async () => {
+      const mod = await loadModule();
+      mod.removeAccount('nonexistent');
+      expect(mod.getConnectedUserIds()).toEqual([]);
+    });
+  });
+
+  describe('disconnectAll', () => {
+    it('disconnects all sockets and clears the map', async () => {
+      const socket1 = {
+        on: vi.fn().mockReturnThis(),
+        disconnect: vi.fn().mockReturnThis(),
+        id: 'socket-1',
+      };
+      const socket2 = {
+        on: vi.fn().mockReturnThis(),
+        disconnect: vi.fn().mockReturnThis(),
+        id: 'socket-2',
+      };
+      mockIo.mockReturnValueOnce(socket1).mockReturnValueOnce(socket2);
+
+      const mod = await loadModule();
+      mod.addAccount('http://localhost:3000', 'user-1', 'key-1');
+      mod.addAccount('http://localhost:3000', 'user-2', 'key-2');
+      expect(mod.getConnectedUserIds()).toHaveLength(2);
+
+      mod.disconnectAll();
+      expect(socket1.disconnect).toHaveBeenCalled();
+      expect(socket2.disconnect).toHaveBeenCalled();
+      expect(mod.getConnectedUserIds()).toEqual([]);
+    });
+  });
+
+  describe('getConnectedUserIds', () => {
+    it('returns empty array when no sockets exist', async () => {
+      const mod = await loadModule();
+      expect(mod.getConnectedUserIds()).toEqual([]);
+    });
+
+    it('returns all user IDs with active socket entries', async () => {
+      const mod = await loadModule();
+      mod.addAccount('http://localhost:3000', 'user-1', 'key-1');
+      mod.addAccount('http://localhost:3000', 'user-2', 'key-2');
+
+      const ids = mod.getConnectedUserIds();
+      expect(ids).toHaveLength(2);
+      expect(ids).toContain('user-1');
+      expect(ids).toContain('user-2');
+    });
+  });
+});

package/__tests__/sync-reorder.test.ts

@@ -0,0 +1,242 @@
+/**
+ * B-001 regression test: Section reordering triggers sync push with updated positions.
+ *
+ * When sections are reordered in a markdown file (positions change but content stays
+ * the same), the diff logic must detect the position change and push the updated sections.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { join } from 'node:path';
+import { mkdtemp, writeFile, mkdir, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+
+// Mock fetch globally
+const mockFetch = vi.fn();
+vi.stubGlobal('fetch', mockFetch);
+
+// Mock config module
+vi.mock('../src/config.js', () => ({
+  loadCredentials: vi.fn().mockResolvedValue({
+    apiKey: 'test-api-key',
+    userId: 'test-user',
+    serverUrl: 'http://localhost:3000',
+  }),
+  getServerUrl: vi.fn().mockReturnValue('http://localhost:3000'),
+  getProjectId: vi.fn().mockResolvedValue('test-project-id'),
+  writeProjectId: vi.fn().mockResolvedValue(undefined),
+  paths: {
+    claudeProjects: '/tmp/test-claude-projects',
+    projectIdFile: '.claude/ultra/project-id',
+    oldConfigDir: '/tmp/test-old-config',
+  },
+}));
+
+// Mock logger
+vi.mock('../src/logger.js', () => ({
+  logger: {
+    child: () => ({
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      debug: vi.fn(),
+    }),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn(),
+  },
+}));
+
+const testCreds = { apiKey: 'test-api-key', userId: 'test-user', serverUrl: 'http://localhost:3000' };
+
+describe('B-001 regression — section reordering triggers sync push', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    vi.resetModules();
+    mockFetch.mockReset();
+    tempDir = await mkdtemp(join(tmpdir(), 'agent-reorder-test-'));
+    await mkdir(join(tempDir, 'documentation'), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('pushes sections with updated positions when sections are reordered', async () => {
+    const { syncMarkdownFile } = await import('../src/sync.js');
+
+    const filePath = join(tempDir, 'documentation', 'test.md');
+
+    // Step 1: Initial push with sections A, B, C at positions 0, 1, 2
+    const initialContent = '# A\n\nContent A.\n\n# B\n\nContent B.\n\n# C\n\nContent C.';
+    await writeFile(filePath, initialContent);
+
+    // First call pushes all sections (cache is empty)
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ data: { upserted: 3 } }),
+    });
+
+    const firstCount = await syncMarkdownFile('test-project-id', tempDir, filePath, testCreds);
+    expect(firstCount).toBe(3);
+
+    // Verify positions in first push
+    const firstPostCall = mockFetch.mock.calls.find(
+      (call: unknown[]) =>
+        (call[1] as { method: string }).method === 'POST' &&
+        (call[0] as string).includes('/api/sync/sections'),
+    );
+    expect(firstPostCall).toBeDefined();
+    const firstBody = JSON.parse((firstPostCall![1] as { body: string }).body);
+    expect(firstBody.sections).toHaveLength(3);
+    expect(firstBody.sections[0].slug).toBe('a');
+    expect(firstBody.sections[0].position).toBe(0);
+    expect(firstBody.sections[1].slug).toBe('b');
+    expect(firstBody.sections[1].position).toBe(1);
+    expect(firstBody.sections[2].slug).toBe('c');
+    expect(firstBody.sections[2].position).toBe(2);
+
+    mockFetch.mockReset();
+
+    // Step 2: Reorder sections to B, A, C (same content, different positions)
+    const reorderedContent = '# B\n\nContent B.\n\n# A\n\nContent A.\n\n# C\n\nContent C.';
+    await writeFile(filePath, reorderedContent);
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ data: { upserted: 2 } }),
+    });
+
+    const secondCount = await syncMarkdownFile('test-project-id', tempDir, filePath, testCreds);
+
+    // Step 3: Assert the second call pushes sections with updated positions
+    // B moved from position 1 → 0, A moved from position 0 → 1
+    // C stayed at position 2 — should NOT be pushed
+    expect(secondCount).toBe(2);
+
+    const secondPostCall = mockFetch.mock.calls.find(
+      (call: unknown[]) =>
+        (call[1] as { method: string }).method === 'POST' &&
+        (call[0] as string).includes('/api/sync/sections'),
+    );
+    expect(secondPostCall).toBeDefined();
+    const secondBody = JSON.parse((secondPostCall![1] as { body: string }).body);
+
+    // Only A and B should be pushed (position changed), not C
+    expect(secondBody.sections).toHaveLength(2);
+
+    const pushedSlugs = secondBody.sections.map((s: { slug: string }) => s.slug).sort();
+    expect(pushedSlugs).toEqual(['a', 'b']);
+
+    // Verify the pushed positions are correct
+    const sectionA = secondBody.sections.find((s: { slug: string }) => s.slug === 'a');
+    const sectionB = secondBody.sections.find((s: { slug: string }) => s.slug === 'b');
+    expect(sectionB.position).toBe(0); // B is now first
+    expect(sectionA.position).toBe(1); // A is now second
+  });
+
+  it('does not push sections when neither content nor position changed', async () => {
+    const { syncMarkdownFile } = await import('../src/sync.js');
+
+    const filePath = join(tempDir, 'documentation', 'test.md');
+    const content = '# A\n\nContent A.\n\n# B\n\nContent B.';
+    await writeFile(filePath, content);
+
+    // First push
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ data: { upserted: 2 } }),
+    });
+    await syncMarkdownFile('test-project-id', tempDir, filePath, testCreds);
+    mockFetch.mockReset();
+
+    // Second push — same content, same order
+    const secondCount = await syncMarkdownFile('test-project-id', tempDir, filePath, testCreds);
+
+    // No sections changed — no POST should be made
+    expect(secondCount).toBe(0);
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('manifest load → first sync (no push, positions populated) → reorder detected', async () => {
+    // This is the critical B-001 scenario:
+    // 1. Daemon starts, loads manifest (hashes only, no positions)
+    // 2. First sync: content unchanged → no push, but positions must be populated
+    // 3. User reorders sections → position change detected → push triggered
+
+    const filePath = join(tempDir, 'documentation', 'test.md');
+    const content = '# A\n\nContent A.\n\n# B\n\nContent B.';
+    await writeFile(filePath, content);
+
+    // Step 0: Compute real content hashes by doing a throwaway sync in an isolated module
+    vi.resetModules();
+    const probe = await import('../src/sync.js');
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ data: { upserted: 2 } }),
+    });
+    await probe.syncMarkdownFile('test-project-id', tempDir, filePath, testCreds);
+    const probeCall = mockFetch.mock.calls.find(
+      (call: unknown[]) =>
+        (call[1] as { method: string }).method === 'POST' &&
+        (call[0] as string).includes('/api/sync/sections'),
+    );
+    const probeBody = JSON.parse((probeCall![1] as { body: string }).body);
+    const hashA = probeBody.sections.find((s: { slug: string }) => s.slug === 'a').content_hash;
+    const hashB = probeBody.sections.find((s: { slug: string }) => s.slug === 'b').content_hash;
+
+    // Step 1: Fresh daemon startup — load manifest with real hashes
+    mockFetch.mockReset();
+    vi.resetModules();
+    const fresh = await import('../src/sync.js');
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({
+        data: {
+          files: {
+            'test.md': {
+              hash: null,
+              sections: { a: hashA, b: hashB },
+            },
+          },
+        },
+      }),
+    });
+    await fresh.loadManifestIntoCache('test-project-id', testCreds);
+    mockFetch.mockReset();
+
+    // Step 2: First sync — hashes match manifest, no push expected.
+    // But positions must be populated so future reorders are detectable.
+    const firstCount = await fresh.syncMarkdownFile('test-project-id', tempDir, filePath, testCreds);
+    expect(firstCount).toBe(0);
+    expect(mockFetch).not.toHaveBeenCalled();
+
+    // Step 3: Reorder sections (B, A) — same content, different positions
+    const reordered = '# B\n\nContent B.\n\n# A\n\nContent A.';
+    await writeFile(filePath, reordered);
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ data: { upserted: 2 } }),
+    });
+
+    const reorderCount = await fresh.syncMarkdownFile('test-project-id', tempDir, filePath, testCreds);
+
+    // Both sections must be pushed — positions changed
+    expect(reorderCount).toBe(2);
+
+    const postCall = mockFetch.mock.calls.find(
+      (call: unknown[]) =>
+        (call[1] as { method: string }).method === 'POST' &&
+        (call[0] as string).includes('/api/sync/sections'),
+    );
+    expect(postCall).toBeDefined();
+    const body = JSON.parse((postCall![1] as { body: string }).body);
+    const sectionA = body.sections.find((s: { slug: string }) => s.slug === 'a');
+    const sectionB = body.sections.find((s: { slug: string }) => s.slug === 'b');
+    expect(sectionB.position).toBe(0); // B moved to first
+    expect(sectionA.position).toBe(1); // A moved to second
+  });
+});

package/__tests__/usage-sync.test.ts

@@ -14,6 +14,14 @@ vi.mock('../src/config.js', () => ({
     userId: 'test-user',
     serverUrl: 'http://localhost:3000',
   }),
+  loadAllCredentials: vi.fn().mockResolvedValue(new Map([
+    ['test-user', {
+      apiKey: 'test-api-key',
+      userId: 'test-user',
+      email: 'test@example.com',
+      serverUrl: 'http://localhost:3000',
+    }],
+  ])),
   getServerUrl: vi.fn().mockReturnValue('http://localhost:3000'),
   paths: {
     claudeProjects: '/tmp/test-projects',