ultraclaude-agent 0.0.21 → 0.0.23

package/__tests__/daemon-reconcile.test.ts

@@ -77,6 +77,7 @@ vi.mock('../src/sync.js', () => ({
 const mockStartProjectWatcher = vi.fn();
 vi.mock('../src/watcher.js', () => ({
   startProjectWatcher: (...args: unknown[]) => mockStartProjectWatcher(...args),
+  getCurrentBranch: vi.fn().mockReturnValue('main'),
 }));
 
 // Mock usage-sync

package/__tests__/daemon.test.ts

@@ -75,6 +75,7 @@ vi.mock('../src/sync.js', () => ({
 const mockStartProjectWatcher = vi.fn();
 vi.mock('../src/watcher.js', () => ({
   startProjectWatcher: (...args: unknown[]) => mockStartProjectWatcher(...args),
+  getCurrentBranch: vi.fn().mockReturnValue('main'),
 }));
 
 // Mock usage-sync

package/__tests__/hide-branches.test.ts

@@ -0,0 +1,129 @@
+/**
+ * Tests for hideBranches() in sync.ts (Plan 032, Task 1).
+ *
+ * Verifies branch hide notification is sent correctly to the server.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// 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('hideBranches', () => {
+  beforeEach(() => {
+    vi.resetModules();
+    mockFetch.mockReset();
+  });
+
+  it('POSTs to /api/sync/branch-hide with projectId and branches', async () => {
+    const { hideBranches } = await import('../src/sync.js');
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ data: {} }),
+    });
+
+    const result = await hideBranches('proj-uuid', ['feature/old', 'plan/done'], testCreds);
+    expect(result).toBe(true);
+
+    expect(mockFetch).toHaveBeenCalledOnce();
+    const [url, options] = mockFetch.mock.calls[0] as [string, RequestInit];
+    expect(url).toContain('/api/sync/branch-hide');
+    expect(options.method).toBe('POST');
+
+    const body = JSON.parse(options.body as string) as { projectId: string; branches: string[] };
+    expect(body.projectId).toBe('proj-uuid');
+    expect(body.branches).toEqual(['feature/old', 'plan/done']);
+
+    const headers = options.headers as Record<string, string>;
+    expect(headers['Idempotency-Key']).toBeDefined();
+    expect(headers['Idempotency-Key']).toMatch(
+      /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+    );
+  });
+
+  it('returns false when server returns error', async () => {
+    const { hideBranches } = await import('../src/sync.js');
+
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 500,
+    });
+
+    const result = await hideBranches('proj-uuid', ['feature/old'], testCreds);
+    expect(result).toBe(false);
+  });
+
+  it('returns false when network is unreachable', async () => {
+    const { hideBranches } = await import('../src/sync.js');
+
+    mockFetch.mockRejectedValueOnce(new Error('Network error'));
+
+    const result = await hideBranches('proj-uuid', ['feature/old'], testCreds);
+    expect(result).toBe(false);
+  });
+
+  it('returns false when server returns 404 (project not found)', async () => {
+    const { hideBranches } = await import('../src/sync.js');
+
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 404,
+    });
+
+    const result = await hideBranches('proj-uuid', ['main'], testCreds);
+    expect(result).toBe(false);
+  });
+
+  it('sends multiple branches in a single request', async () => {
+    const { hideBranches } = await import('../src/sync.js');
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ data: {} }),
+    });
+
+    const branches = ['feature/a', 'feature/b', 'plan/001', 'plan/002'];
+    await hideBranches('proj-uuid', branches, testCreds);
+
+    const body = JSON.parse((mockFetch.mock.calls[0] as [string, RequestInit])[1].body as string) as { branches: string[] };
+    expect(body.branches).toHaveLength(4);
+    expect(body.branches).toEqual(branches);
+  });
+});

package/__tests__/logger-multistream.test.ts

@@ -0,0 +1,151 @@
+/**
+ * Tests for unified logging setup (initMultistreamLogger / initFileLogger).
+ * Plan 030 Task 1 regression: "daemon.log contains structured JSON in both foreground and background mode"
+ * and "Foreground mode also outputs to stdout".
+ *
+ * Verifies that:
+ * - initMultistreamLogger sets up pino with BOTH file (JSON) and stdout (pretty) transports
+ * - initFileLogger sets up pino with ONLY a file (JSON) transport
+ * - Both write to daemon.log in the correct log directory
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+// Mock pino so we don't spin up real worker-thread file transports
+const mockTransport = vi.fn();
+const mockPinoInstance = {
+  info: vi.fn(),
+  warn: vi.fn(),
+  error: vi.fn(),
+  debug: vi.fn(),
+  child: vi.fn().mockReturnThis(),
+};
+
+const mockPino = vi.fn().mockReturnValue(mockPinoInstance);
+(mockPino as unknown as { transport: typeof mockTransport }).transport = mockTransport;
+mockTransport.mockReturnValue('mock-transport');
+
+vi.mock('pino', () => ({
+  default: Object.assign(mockPino, { transport: mockTransport }),
+}));
+
+// Mock resolveServerPaths to return controlled paths
+const mockResolveServerPaths = vi.fn().mockReturnValue({
+  logDir: '/tmp/test-logs',
+  accountsDir: '/tmp/accounts',
+  configFile: '/tmp/config.json',
+  statusFile: '/tmp/status.json',
+  pidFile: '/tmp/daemon.pid',
+});
+
+vi.mock('../src/config.js', () => ({
+  resolveServerPaths: (...args: unknown[]) => mockResolveServerPaths(...args),
+}));
+
+describe('logger — initMultistreamLogger (foreground mode)', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockTransport.mockReturnValue('mock-transport');
+    (mockPino as unknown as { transport: typeof mockTransport }).transport = mockTransport;
+    mockPino.mockReturnValue(mockPinoInstance);
+  });
+
+  afterEach(() => {
+    vi.resetModules();
+  });
+
+  it('calls pino.transport with two targets (file + stdout)', async () => {
+    const { initMultistreamLogger } = await import('../src/logger.js');
+    initMultistreamLogger('http://localhost:3000');
+
+    expect(mockTransport).toHaveBeenCalledOnce();
+    const transportArgs = mockTransport.mock.calls[0]![0] as { targets: Array<{ target: string; options?: Record<string, unknown> }> };
+    expect(transportArgs).toHaveProperty('targets');
+    expect(transportArgs.targets).toHaveLength(2);
+  });
+
+  it('includes pino/file target writing to daemon.log', async () => {
+    const { initMultistreamLogger } = await import('../src/logger.js');
+    initMultistreamLogger('http://localhost:3000');
+
+    const transportArgs = mockTransport.mock.calls[0]![0] as { targets: Array<{ target: string; options?: Record<string, unknown> }> };
+    const fileTarget = transportArgs.targets.find((t) => t.target === 'pino/file');
+    expect(fileTarget).toBeDefined();
+    expect(fileTarget!.options?.destination).toMatch(/daemon\.log$/);
+  });
+
+  it('includes pino-pretty target writing to stdout (destination: 1)', async () => {
+    const { initMultistreamLogger } = await import('../src/logger.js');
+    initMultistreamLogger('http://localhost:3000');
+
+    const transportArgs = mockTransport.mock.calls[0]![0] as { targets: Array<{ target: string; options?: Record<string, unknown> }> };
+    const prettyTarget = transportArgs.targets.find((t) => t.target === 'pino-pretty');
+    expect(prettyTarget).toBeDefined();
+    expect(prettyTarget!.options?.destination).toBe(1); // stdout fd
+  });
+
+  it('creates the pino logger with the transport stream', async () => {
+    const { initMultistreamLogger } = await import('../src/logger.js');
+    initMultistreamLogger('http://localhost:3000');
+
+    // pino() should have been called with the transport returned by pino.transport()
+    expect(mockPino).toHaveBeenCalledWith(
+      expect.objectContaining({ level: expect.any(String) }),
+      'mock-transport',
+    );
+  });
+
+  it('writes to log dir from resolveServerPaths', async () => {
+    const { initMultistreamLogger } = await import('../src/logger.js');
+    initMultistreamLogger('http://localhost:3000');
+
+    expect(mockResolveServerPaths).toHaveBeenCalledWith('http://localhost:3000');
+
+    const transportArgs = mockTransport.mock.calls[0]![0] as { targets: Array<{ target: string; options?: { destination?: string } }> };
+    const fileTarget = transportArgs.targets.find((t) => t.target === 'pino/file');
+    expect(fileTarget?.options?.destination).toContain('/tmp/test-logs');
+  });
+});
+
+describe('logger — initFileLogger (background mode)', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockTransport.mockReturnValue('mock-transport');
+    (mockPino as unknown as { transport: typeof mockTransport }).transport = mockTransport;
+    mockPino.mockReturnValue(mockPinoInstance);
+  });
+
+  afterEach(() => {
+    vi.resetModules();
+  });
+
+  it('calls pino.transport with a single pino/file target (no stdout)', async () => {
+    const { initFileLogger } = await import('../src/logger.js');
+    initFileLogger('http://localhost:3000');
+
+    expect(mockTransport).toHaveBeenCalledOnce();
+    const transportArgs = mockTransport.mock.calls[0]![0] as { target?: string; targets?: unknown[] };
+
+    // Single target form (not array) — background daemon writes only to file
+    expect(transportArgs.target).toBe('pino/file');
+    expect(transportArgs.targets).toBeUndefined();
+  });
+
+  it('writes to daemon.log in log directory', async () => {
+    const { initFileLogger } = await import('../src/logger.js');
+    initFileLogger('http://localhost:3000');
+
+    const transportArgs = mockTransport.mock.calls[0]![0] as { options?: { destination?: string } };
+    expect(transportArgs.options?.destination).toMatch(/daemon\.log$/);
+  });
+
+  it('creates pino instance with the file transport', async () => {
+    const { initFileLogger } = await import('../src/logger.js');
+    initFileLogger('http://localhost:3000');
+
+    expect(mockPino).toHaveBeenCalledWith(
+      expect.objectContaining({ level: expect.any(String) }),
+      'mock-transport',
+    );
+  });
+});

package/__tests__/repl-reset.test.ts

@@ -93,6 +93,9 @@ vi.mock('../src/sync.js', () => ({
   initialSync: vi.fn().mockResolvedValue(undefined),
   createSnapshot: vi.fn().mockResolvedValue(true),
 }));
+vi.mock('../src/watcher.js', () => ({
+  getCurrentBranch: vi.fn().mockReturnValue('main'),
+}));
 
 vi.mock('../src/logger.js', () => ({
   logger: {

package/__tests__/repl-status-account.test.ts

@@ -73,6 +73,9 @@ vi.mock('../src/sync.js', () => ({
   initialSync: vi.fn().mockResolvedValue(undefined),
   createSnapshot: vi.fn().mockResolvedValue(true),
 }));
+vi.mock('../src/watcher.js', () => ({
+  getCurrentBranch: vi.fn().mockReturnValue('main'),
+}));
 vi.mock('../src/logger.js', () => ({
   logger: {
     child: () => ({ info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() }),

package/__tests__/repl.test.ts

@@ -91,6 +91,11 @@ vi.mock('../src/sync.js', () => ({
   createSnapshot: (...args: unknown[]) => mockCreateSnapshot(...args),
 }));
 
+// Mock watcher (getCurrentBranch is imported by repl.ts)
+vi.mock('../src/watcher.js', () => ({
+  getCurrentBranch: vi.fn().mockReturnValue('main'),
+}));
+
 // Mock logger
 vi.mock('../src/logger.js', () => ({
   logger: {
@@ -775,7 +780,7 @@ describe('repl — start/stop/status/push/snapshot commands', () => {
     try {
       await startRepl(SERVER_URL);
       await runCommand('push');
-      expect(mockInitialSync).toHaveBeenCalledWith('proj-uuid-1', '/home/user/projects/my-app', alice);
+      expect(mockInitialSync).toHaveBeenCalledWith('proj-uuid-1', '/home/user/projects/my-app', alice, 'main');
     } finally {
       consoleSpy.mockRestore();
     }
@@ -824,7 +829,7 @@ describe('repl — start/stop/status/push/snapshot commands', () => {
       expect(mockCreateSnapshot).toHaveBeenCalledWith(
         'proj-uuid-1',
         expect.stringContaining('release v1.0'),
-        undefined, undefined, alice,
+        'main', undefined, undefined, alice,
       );
     } finally {
       consoleSpy.mockRestore();

package/__tests__/snapshot-sync.test.ts

@@ -65,7 +65,7 @@ describe('createSnapshot — Idempotency-Key header (Fix A)', () => {
       json: async () => ({ data: { id: 'snap-uuid' } }),
     });
 
-    await createSnapshot('proj-uuid', 'test snapshot', 'abc123', 'git_commit', testCreds);
+    await createSnapshot('proj-uuid', 'test snapshot', 'main', 'abc123', 'git_commit', testCreds);
 
     expect(mockFetch).toHaveBeenCalledOnce();
     const [, options] = mockFetch.mock.calls[0];
@@ -86,7 +86,7 @@ describe('createSnapshot — Idempotency-Key header (Fix A)', () => {
     });
 
     // No credentials provided — uses apiRequestWithDiskCredentials
-    await createSnapshot('proj-uuid', 'test snapshot');
+    await createSnapshot('proj-uuid', 'test snapshot', 'main');
 
     expect(mockFetch).toHaveBeenCalledOnce();
     const [, options] = mockFetch.mock.calls[0];
@@ -269,7 +269,7 @@ describe('flushQueue — corrupted item isolation (Fix C)', () => {
     await writeFile(filePath, '# Valid\n\nContent.');
 
     mockFetch.mockRejectedValueOnce(new Error('Network error'));
-    await syncMarkdownFile('test-project', tempDir, filePath, testCreds);
+    await syncMarkdownFile('test-project', tempDir, filePath, testCreds, 'main');
     expect(getQueueSize()).toBe(1);
 
     // Now corrupt the queued item's payload by directly manipulating the queue
@@ -280,7 +280,7 @@ describe('flushQueue — corrupted item isolation (Fix C)', () => {
     await writeFile(filePath2, '# Valid2\n\nContent2.');
 
     mockFetch.mockRejectedValueOnce(new Error('Network error'));
-    await syncMarkdownFile('test-project', tempDir, filePath2, testCreds);
+    await syncMarkdownFile('test-project', tempDir, filePath2, testCreds, 'main');
     expect(getQueueSize()).toBe(2);
 
     // On flush, make first apiRequest call throw unexpectedly (simulating corrupted processing)
@@ -315,7 +315,7 @@ describe('flushQueue — corrupted item isolation (Fix C)', () => {
 
     // Queue an item
     mockFetch.mockRejectedValueOnce(new Error('Network error'));
-    await syncMarkdownFile('test-project', tempDir, filePath, testCreds);
+    await syncMarkdownFile('test-project', tempDir, filePath, testCreds, 'main');
     expect(getQueueSize()).toBe(1);
 
     // On flush, return 400 (permanent failure) — item should be dropped
@@ -361,7 +361,7 @@ describe('regression — syncMarkdownFile still sends Idempotency-Key', () => {
       json: async () => ({ data: { upserted: 1 } }),
     });
 
-    await syncMarkdownFile('test-project', tempDir, filePath, testCreds);
+    await syncMarkdownFile('test-project', tempDir, filePath, testCreds, 'main');
 
     const postCall = mockFetch.mock.calls.find(
       (call: unknown[]) =>