ultraclaude-agent 0.0.3

package/__tests__/sync.test.ts

@@ -0,0 +1,169 @@
+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: {
+    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',
+    projectIdFile: '.claude/ultra/project-id',
+  },
+}));
+
+// 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('sync — syncMarkdownFile', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    mockFetch.mockReset();
+    tempDir = await mkdtemp(join(tmpdir(), 'agent-sync-test-'));
+    await mkdir(join(tempDir, 'documentation'), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('pushes changed sections to the server', async () => {
+    const { syncMarkdownFile } = await import('../src/sync.js');
+
+    const mdContent = '# Title\n\nSome content.\n\n## Section\n\nMore content.';
+    const filePath = join(tempDir, 'documentation', 'test.md');
+    await writeFile(filePath, mdContent);
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ data: [] }),
+    });
+
+    // First push — all sections are new
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ data: { upserted: 2 } }),
+    });
+
+    const count = await syncMarkdownFile('test-project-id', tempDir, filePath);
+    expect(count).toBe(2);
+
+    // Verify the POST request
+    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);
+    expect(body.file).toBe('test.md');
+    expect(body.sections).toHaveLength(2);
+    expect(body.sections[0].slug).toBe('title');
+    expect(body.sections[1].slug).toBe('title/section');
+  });
+
+  it('queues changes when server is unreachable', async () => {
+    // Re-import to get fresh module state
+    const sync = await import('../src/sync.js');
+
+    const mdContent = '# Title\n\nContent.';
+    const filePath = join(tempDir, 'documentation', 'test2.md');
+    await writeFile(filePath, mdContent);
+
+    mockFetch.mockRejectedValueOnce(new Error('Network error'));
+
+    const count = await sync.syncMarkdownFile('test-project-id', tempDir, filePath);
+    expect(count).toBe(0); // Nothing pushed
+    expect(sync.getQueueSize()).toBeGreaterThan(0);
+  });
+});
+
+describe('sync — syncJsonFile', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    mockFetch.mockReset();
+    tempDir = await mkdtemp(join(tmpdir(), 'agent-sync-json-test-'));
+    await mkdir(join(tempDir, 'documentation'), { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('pushes JSON files with full content', async () => {
+    const { syncJsonFile } = await import('../src/sync.js');
+
+    const jsonContent = JSON.stringify({ status: 'active', tasks: 5 });
+    const filePath = join(tempDir, 'documentation', 'status.json');
+    await writeFile(filePath, jsonContent);
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ data: { stored: 1 } }),
+    });
+
+    const pushed = await syncJsonFile('test-project-id', tempDir, filePath);
+    expect(pushed).toBe(true);
+  });
+});
+
+describe('sync — createProjectOnServer', () => {
+  beforeEach(() => {
+    mockFetch.mockReset();
+  });
+
+  it('creates a project and returns the ID', async () => {
+    const { createProjectOnServer } = await import('../src/sync.js');
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ data: { id: 'new-project-uuid' } }),
+    });
+
+    const result = await createProjectOnServer('My Project', 'my-project');
+    expect(result).toEqual({ id: 'new-project-uuid' });
+  });
+
+  it('returns null on server error', async () => {
+    const { createProjectOnServer } = await import('../src/sync.js');
+
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      status: 500,
+    });
+
+    const result = await createProjectOnServer('Bad Project', 'bad-project');
+    expect(result).toBeNull();
+  });
+});

package/__tests__/usage-sync.test.ts

@@ -0,0 +1,291 @@
+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'),
+  paths: {
+    configDir: '/tmp/test-config',
+    credentials: '/tmp/test-config/credentials.json',
+    pid: '/tmp/test-config/daemon.pid',
+    logDir: '/tmp/test-config/logs',
+    claudeProjects: '/tmp/test-projects',
+    projectIdFile: '.claude/ultra/project-id',
+  },
+}));
+
+// 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(),
+  },
+}));
+
+// We need to mock the paths used by usage-sync.ts to point to our temp dir
+let tempDir: string;
+let usageStatusPath: string;
+let accountsDir: string;
+
+// Dynamic mock for the homedir-based paths
+vi.mock('node:os', async (importOriginal) => {
+  const original = await importOriginal<typeof import('node:os')>();
+  return {
+    ...original,
+    homedir: () => tempDir,
+  };
+});
+
+describe('usage-sync — syncUsageData', () => {
+  beforeEach(async () => {
+    mockFetch.mockReset();
+    tempDir = await mkdtemp(join(tmpdir(), 'usage-sync-test-'));
+    usageStatusPath = join(tempDir, '.claude', 'ultra', 'usage-status.json');
+    accountsDir = join(tempDir, '.claude', 'ultra', 'accounts');
+    await mkdir(join(tempDir, '.claude', 'ultra'), { recursive: true });
+  });
+
+  afterEach(async () => {
+    // Reset module state between tests
+    vi.resetModules();
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('reads and merges usage-status.json with account registry', async () => {
+    // Write usage status
+    await writeFile(usageStatusPath, JSON.stringify({
+      accounts: {
+        'dawid-duniec-at-axb-co': {
+          account_id: 'dawid-duniec-at-axb-co',
+          rate_limits: {
+            five_hour: { used_percentage: 42, resets_at: 1775329200 },
+            seven_day: { used_percentage: 18, resets_at: 1775894400 },
+          },
+          updated_at: '2026-04-04T16:13:01Z',
+        },
+      },
+      updated_at: '2026-04-04T16:13:01Z',
+    }));
+
+    // Write account registry
+    await mkdir(accountsDir, { recursive: true });
+    await writeFile(join(accountsDir, 'dawid-duniec-at-axb-co.json'), JSON.stringify({
+      account_id: 'dawid-duniec-at-axb-co',
+      email: 'dawid.duniec@axb.co',
+      orgName: 'AXB',
+      subscriptionType: 'team',
+    }));
+
+    // Mock successful response
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve({ data: { ok: true, upserted: 1 } }),
+    });
+
+    const { syncUsageData } = await import('../src/usage-sync.js');
+    await syncUsageData();
+
+    expect(mockFetch).toHaveBeenCalledOnce();
+    const [url, options] = mockFetch.mock.calls[0]!;
+    expect(url).toBe('http://localhost:3000/api/sync/usage');
+    expect(options.method).toBe('POST');
+
+    const body = JSON.parse(options.body);
+    expect(body.accounts['dawid-duniec-at-axb-co']).toMatchObject({
+      account_id: 'dawid-duniec-at-axb-co',
+      email: 'dawid.duniec@axb.co',
+      org_name: 'AXB',
+      subscription_type: 'team',
+      rate_limits: {
+        five_hour: { used_percentage: 42, resets_at: 1775329200 },
+        seven_day: { used_percentage: 18, resets_at: 1775894400 },
+      },
+      updated_at: '2026-04-04T16:13:01Z',
+    });
+  });
+
+  it('handles missing usage-status.json gracefully', async () => {
+    // Don't create the file
+    const { syncUsageData } = await import('../src/usage-sync.js');
+    await syncUsageData();
+
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('handles empty usage-status.json gracefully', async () => {
+    await writeFile(usageStatusPath, '');
+
+    const { syncUsageData } = await import('../src/usage-sync.js');
+    await syncUsageData();
+
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('handles malformed JSON in usage-status.json gracefully', async () => {
+    await writeFile(usageStatusPath, '{not valid json!!!');
+
+    const { syncUsageData } = await import('../src/usage-sync.js');
+    await syncUsageData();
+
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('handles missing accounts/ directory — sends data without account details', async () => {
+    // Write usage status but NO accounts/ directory
+    await writeFile(usageStatusPath, JSON.stringify({
+      accounts: {
+        'test-user-at-example-com': {
+          account_id: 'test-user-at-example-com',
+          rate_limits: {
+            five_hour: { used_percentage: 80, resets_at: 1775329200 },
+            seven_day: { used_percentage: 50, resets_at: 1775894400 },
+          },
+          updated_at: '2026-04-04T16:13:01Z',
+        },
+      },
+      updated_at: '2026-04-04T16:13:01Z',
+    }));
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve({ data: { ok: true, upserted: 1 } }),
+    });
+
+    const { syncUsageData } = await import('../src/usage-sync.js');
+    await syncUsageData();
+
+    expect(mockFetch).toHaveBeenCalledOnce();
+    const body = JSON.parse(mockFetch.mock.calls[0]![1].body);
+    const account = body.accounts['test-user-at-example-com'];
+    expect(account.account_id).toBe('test-user-at-example-com');
+    // No account registry → optional fields should be undefined
+    expect(account.email).toBeUndefined();
+    expect(account.org_name).toBeUndefined();
+    expect(account.subscription_type).toBeUndefined();
+    // Rate limits should still be present
+    expect(account.rate_limits.five_hour.used_percentage).toBe(80);
+  });
+
+  it('handles missing individual account file — other accounts still sent', async () => {
+    await writeFile(usageStatusPath, JSON.stringify({
+      accounts: {
+        'user-a-at-example-com': {
+          account_id: 'user-a-at-example-com',
+          rate_limits: {
+            five_hour: { used_percentage: 10, resets_at: 1775329200 },
+            seven_day: { used_percentage: 5, resets_at: 1775894400 },
+          },
+          updated_at: '2026-04-04T16:13:01Z',
+        },
+        'user-b-at-example-com': {
+          account_id: 'user-b-at-example-com',
+          rate_limits: {
+            five_hour: { used_percentage: 90, resets_at: 1775329200 },
+            seven_day: { used_percentage: 70, resets_at: 1775894400 },
+          },
+          updated_at: '2026-04-04T16:13:01Z',
+        },
+      },
+      updated_at: '2026-04-04T16:13:01Z',
+    }));
+
+    // Only create account file for user-a
+    await mkdir(accountsDir, { recursive: true });
+    await writeFile(join(accountsDir, 'user-a-at-example-com.json'), JSON.stringify({
+      account_id: 'user-a-at-example-com',
+      email: 'user-a@example.com',
+      orgName: 'OrgA',
+      subscriptionType: 'pro',
+    }));
+
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve({ data: { ok: true, upserted: 2 } }),
+    });
+
+    const { syncUsageData } = await import('../src/usage-sync.js');
+    await syncUsageData();
+
+    expect(mockFetch).toHaveBeenCalledOnce();
+    const body = JSON.parse(mockFetch.mock.calls[0]![1].body);
+
+    // user-a has registry data
+    expect(body.accounts['user-a-at-example-com'].email).toBe('user-a@example.com');
+    expect(body.accounts['user-a-at-example-com'].org_name).toBe('OrgA');
+
+    // user-b has no registry data but is still included
+    expect(body.accounts['user-b-at-example-com'].account_id).toBe('user-b-at-example-com');
+    expect(body.accounts['user-b-at-example-com'].email).toBeUndefined();
+    expect(body.accounts['user-b-at-example-com'].rate_limits.five_hour.used_percentage).toBe(90);
+  });
+
+  it('stores retry payload on network failure', async () => {
+    await writeFile(usageStatusPath, JSON.stringify({
+      accounts: {
+        'test-at-example-com': {
+          account_id: 'test-at-example-com',
+          rate_limits: {
+            five_hour: { used_percentage: 50, resets_at: 1775329200 },
+            seven_day: { used_percentage: 25, resets_at: 1775894400 },
+          },
+          updated_at: '2026-04-04T16:13:01Z',
+        },
+      },
+      updated_at: '2026-04-04T16:13:01Z',
+    }));
+
+    // Simulate network failure
+    mockFetch.mockRejectedValueOnce(new Error('Network error'));
+
+    const { syncUsageData } = await import('../src/usage-sync.js');
+    await syncUsageData();
+
+    // fetch was called (and failed)
+    expect(mockFetch).toHaveBeenCalledOnce();
+
+    // On second call with success, retry should work
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve({ data: { ok: true, upserted: 1 } }),
+    });
+
+    // Call sync again (simulating a new file change that supersedes retry)
+    await syncUsageData();
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+  });
+
+  it('handles empty accounts object in usage-status.json', async () => {
+    await writeFile(usageStatusPath, JSON.stringify({
+      accounts: {},
+      updated_at: '2026-04-04T16:13:01Z',
+    }));
+
+    const { syncUsageData } = await import('../src/usage-sync.js');
+    await syncUsageData();
+
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+});

package/__tests__/version-check.test.ts

@@ -0,0 +1,128 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+// Mock fetch globally
+const mockFetch = vi.fn();
+vi.stubGlobal('fetch', mockFetch);
+
+// Mock node:fs/promises for reading package.json
+const mockReadFile = vi.fn();
+vi.mock('node:fs/promises', () => ({
+  readFile: (...args: unknown[]) => mockReadFile(...args),
+}));
+
+// Capture log calls
+const mockLogInfo = vi.fn();
+vi.mock('../src/logger.js', () => ({
+  logger: {
+    child: () => ({
+      info: mockLogInfo,
+      warn: vi.fn(),
+      error: vi.fn(),
+      debug: vi.fn(),
+    }),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn(),
+  },
+}));
+
+// Mock other daemon dependencies to avoid side effects
+vi.mock('chokidar', () => ({
+  default: { watch: vi.fn().mockReturnValue({ on: vi.fn().mockReturnThis(), close: vi.fn() }) },
+}));
+vi.mock('../src/config.js', () => ({
+  paths: { configDir: '/tmp', credentials: '/tmp/creds', pid: '/tmp/pid', logDir: '/tmp/logs', claudeProjects: '/tmp/projects', projectIdFile: '.claude/ultra/project-id' },
+  loadCredentials: vi.fn().mockResolvedValue(null),
+  loadRegistry: vi.fn().mockResolvedValue({ projects: [] }),
+  getProjectId: vi.fn(),
+  writeProjectId: vi.fn(),
+  writePid: vi.fn(),
+  removePid: vi.fn(),
+}));
+vi.mock('../src/watcher.js', () => ({ startProjectWatcher: vi.fn() }));
+vi.mock('../src/sync.js', () => ({ createProjectOnServer: vi.fn(), initialSync: vi.fn(), stopSync: vi.fn() }));
+vi.mock('../src/usage-sync.js', () => ({ startUsageWatcher: vi.fn().mockReturnValue({ close: vi.fn() }) }));
+
+describe('checkForUpdate', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockReadFile.mockResolvedValue(JSON.stringify({ version: '0.0.1' }));
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('logs notice when local version is older than npm latest', async () => {
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: async () => ({ version: '0.1.0' }),
+    });
+
+    const { checkForUpdate } = await import('../src/daemon.js');
+    await checkForUpdate();
+
+    expect(mockLogInfo).toHaveBeenCalledWith(
+      { current: '0.0.1', latest: '0.1.0' },
+      expect.stringContaining('Update available'),
+    );
+  });
+
+  it('does not log when local version equals npm latest', async () => {
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: async () => ({ version: '0.0.1' }),
+    });
+
+    vi.resetModules();
+    const { checkForUpdate } = await import('../src/daemon.js');
+    await checkForUpdate();
+
+    expect(mockLogInfo).not.toHaveBeenCalled();
+  });
+
+  it('does not log when local version is newer than npm latest', async () => {
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: async () => ({ version: '0.0.1' }),
+    });
+    mockReadFile.mockResolvedValue(JSON.stringify({ version: '0.1.0' }));
+
+    vi.resetModules();
+    const { checkForUpdate } = await import('../src/daemon.js');
+    await checkForUpdate();
+
+    expect(mockLogInfo).not.toHaveBeenCalled();
+  });
+
+  it('silently handles network errors', async () => {
+    mockFetch.mockRejectedValue(new Error('network error'));
+
+    vi.resetModules();
+    const { checkForUpdate } = await import('../src/daemon.js');
+
+    await expect(checkForUpdate()).resolves.toBeUndefined();
+    expect(mockLogInfo).not.toHaveBeenCalled();
+  });
+
+  it('silently handles non-ok responses', async () => {
+    mockFetch.mockResolvedValue({ ok: false, status: 404 });
+
+    vi.resetModules();
+    const { checkForUpdate } = await import('../src/daemon.js');
+
+    await expect(checkForUpdate()).resolves.toBeUndefined();
+    expect(mockLogInfo).not.toHaveBeenCalled();
+  });
+
+  it('silently handles fetch timeout (abort)', async () => {
+    mockFetch.mockRejectedValue(new DOMException('Aborted', 'AbortError'));
+
+    vi.resetModules();
+    const { checkForUpdate } = await import('../src/daemon.js');
+
+    await expect(checkForUpdate()).resolves.toBeUndefined();
+    expect(mockLogInfo).not.toHaveBeenCalled();
+  });
+});

package/dist/auth.d.ts

@@ -0,0 +1,10 @@
+import type { AgentCredentials } from '@ultra-claude/shared';
+/**
+ * Run the browser-based login flow.
+ * 1. Start a localhost HTTP server on a random port
+ * 2. Open browser to the server's daemon-login page with callback URL
+ * 3. Wait for the server to redirect back with the API key
+ * 4. Save credentials and close the server
+ */
+export declare function login(serverUrl?: string): Promise<AgentCredentials>;
+//# sourceMappingURL=auth.d.ts.map

package/dist/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../src/auth.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAI7D;;;;;;GAMG;AACH,wBAAsB,KAAK,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA6GzE"}