ultraclaude-agent 0.0.21 → 0.0.23

package/__tests__/status-command.test.ts

@@ -0,0 +1,479 @@
+/**
+ * Tests for Task 2: Status Command Improvements and lastSyncAt Fix
+ *
+ * Success criteria verified:
+ * 1. status shows version with staleness warning when running old code
+ *    → getDaemonStatus() returns version field; CLI compares against installed version
+ * 2. Uptime displayed as human-readable duration
+ *    → startedAt ISO string present in DaemonStatus for CLI to compute formatDuration()
+ * 3. Service type shown (systemd/launchd/manual)
+ *    → getServiceType() — see status-service-type.test.ts
+ * 4. lastSyncAt in status.json updates within 10s of a file push
+ *    → onPushSuccess callback → updateProjectSyncState → getDaemonStatus reflects update
+ * 5. Relative timestamps used for sync times ("5m ago")
+ *    → lastSyncAt surfaces as ISO string in DaemonStatus.projects; CLI formats via formatRelativeTime()
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// ─── Top-level mocks (hoisted — must not use vi.doMock inside tests) ──────────
+
+// chokidar
+const mockWatcher = {
+  on: vi.fn().mockReturnThis(),
+  close: vi.fn().mockResolvedValue(undefined),
+};
+vi.mock('chokidar', () => ({
+  default: { watch: vi.fn().mockReturnValue(mockWatcher) },
+}));
+
+// config
+const mockLoadCredentials = vi.fn();
+const mockLoadAllCredentials = vi.fn();
+const mockLoadRegistry = vi.fn();
+const mockWritePid = vi.fn().mockResolvedValue(undefined);
+const mockRemovePid = vi.fn().mockResolvedValue(undefined);
+const mockMigrateOldConfigDir = vi.fn().mockResolvedValue(false);
+const mockGetProjectAccount = vi.fn().mockResolvedValue(null);
+const mockGetDefaultAccount = vi.fn().mockResolvedValue('user-1');
+const mockLoadServerConfig = vi.fn().mockResolvedValue({
+  defaultAccount: '',
+  autoAssignNewProjects: true,
+  projectAccounts: {},
+});
+const mockResolveServerPaths = vi.fn().mockReturnValue({
+  accountsDir: '/tmp/accounts',
+  configFile: '/tmp/config.json',
+  statusFile: '/tmp/status.json',
+  logDir: '/tmp/logs',
+});
+
+vi.mock('../src/config.js', () => ({
+  loadCredentials: (...args: unknown[]) => mockLoadCredentials(...args),
+  loadAllCredentials: (...args: unknown[]) => mockLoadAllCredentials(...args),
+  loadServerConfig: (...args: unknown[]) => mockLoadServerConfig(...args),
+  getServerUrl: (creds: { serverUrl: string } | null) =>
+    creds?.serverUrl ?? 'http://localhost:3000',
+  loadRegistry: (...args: unknown[]) => mockLoadRegistry(...args),
+  getProjectId: vi.fn().mockResolvedValue('proj-1'),
+  writeProjectId: vi.fn().mockResolvedValue(undefined),
+  writePid: (...args: unknown[]) => mockWritePid(...args),
+  removePid: (...args: unknown[]) => mockRemovePid(...args),
+  migrateOldConfigDir: (...args: unknown[]) => mockMigrateOldConfigDir(...args),
+  getProjectAccount: (...args: unknown[]) => mockGetProjectAccount(...args),
+  setProjectAccount: vi.fn().mockResolvedValue(undefined),
+  getDefaultAccount: (...args: unknown[]) => mockGetDefaultAccount(...args),
+  resolveServerPaths: (...args: unknown[]) => mockResolveServerPaths(...args),
+  isDaemonRunning: vi.fn().mockReturnValue(false),
+  paths: {
+    claudeProjects: '/tmp/test-claude-projects',
+    projectIdFile: '.claude/ultra/project-id',
+    oldConfigDir: '/tmp/test-old-config',
+  },
+}));
+
+// sync
+vi.mock('../src/sync.js', () => ({
+  createProjectOnServer: vi.fn().mockResolvedValue({ id: 'proj-1' }),
+  initialSync: vi.fn().mockResolvedValue(undefined),
+  fetchManifest: vi.fn().mockResolvedValue({ success: true, data: [] }),
+  stopSync: vi.fn(),
+  pushVersionMetadata: vi.fn().mockResolvedValue(undefined),
+  syncFile: vi.fn().mockResolvedValue(undefined),
+  deleteFiles: vi.fn().mockResolvedValue(undefined),
+}));
+
+// watcher — captures onPushSuccess/onPushError for later invocation
+let capturedOnPushSuccess: ((path: string) => void) | undefined;
+let capturedOnPushError: ((path: string) => void) | undefined;
+const mockStartProjectWatcher = vi.fn().mockImplementation(
+  (opts: {
+    onPushSuccess?: (path: string) => void;
+    onPushError?: (path: string) => void;
+    projectId: string;
+    projectPath: string;
+    credentials: unknown;
+  }) => {
+    capturedOnPushSuccess = opts.onPushSuccess;
+    capturedOnPushError = opts.onPushError;
+    return {
+      projectId: opts.projectId,
+      projectPath: opts.projectPath,
+      credentials: opts.credentials,
+      close: vi.fn().mockResolvedValue(undefined),
+    };
+  },
+);
+vi.mock('../src/watcher.js', () => ({
+  startProjectWatcher: (...args: unknown[]) => mockStartProjectWatcher(...args),
+  getCurrentBranch: vi.fn().mockReturnValue('main'),
+}));
+
+// usage-sync
+vi.mock('../src/usage-sync.js', () => ({
+  startUsageWatcher: vi.fn().mockReturnValue({
+    close: vi.fn().mockResolvedValue(undefined),
+  }),
+}));
+
+// socket-client
+vi.mock('../src/socket-client.js', () => ({
+  init: vi.fn(),
+  addAccount: vi.fn(),
+  removeAccount: vi.fn(),
+  disconnectAll: vi.fn(),
+  getConnectedUserIds: vi.fn().mockReturnValue([]),
+}));
+
+// status
+const mockStartStatusLoop = vi.fn().mockReturnValue({ stop: vi.fn() });
+const mockReadStatusFile = vi.fn().mockResolvedValue(null);
+vi.mock('../src/status.js', () => ({
+  startStatusLoop: (...args: unknown[]) => mockStartStatusLoop(...args),
+  readStatusFile: (...args: unknown[]) => mockReadStatusFile(...args),
+  removeStatusFile: vi.fn().mockResolvedValue(undefined),
+  writeStatusFile: vi.fn().mockResolvedValue(undefined),
+}));
+
+// service
+vi.mock('../src/service.js', () => ({
+  isServiceActive: vi.fn().mockResolvedValue(null),
+  isServiceInstalled: vi.fn().mockResolvedValue(false),
+  installService: vi.fn().mockResolvedValue(undefined),
+  uninstallService: vi.fn().mockResolvedValue(undefined),
+  SERVICE_NAME: 'ultraclaude-dashboard-agent',
+  LAUNCHD_LABEL: 'com.ultraclaude.dashboard-agent',
+  getServiceType: vi.fn().mockResolvedValue('manual'),
+}));
+
+// 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(),
+    fatal: vi.fn(),
+  },
+}));
+
+const testCreds = {
+  apiKey: 'test-key',
+  userId: 'user-1',
+  serverUrl: 'http://localhost:3000',
+  email: 'alice@example.com',
+};
+
+function setupStandardMocks() {
+  mockLoadCredentials.mockResolvedValue(testCreds);
+  mockLoadAllCredentials.mockResolvedValue(new Map([['user-1', testCreds]]));
+  mockLoadRegistry.mockResolvedValue({ projects: [] });
+}
+
+// ─── Criterion 1 & 3: getDaemonStatus() version field ─────────────────────────
+
+describe('getDaemonStatus() — version field (criterion: staleness warning)', () => {
+  beforeEach(() => {
+    capturedOnPushSuccess = undefined;
+    capturedOnPushError = undefined;
+    vi.clearAllMocks();
+    setupStandardMocks();
+  });
+
+  it('includes version when running in-process', async () => {
+    vi.resetModules();
+    const { startDaemon, getDaemonStatus, stopDaemon } = await import('../src/daemon.js');
+
+    const result = await startDaemon();
+    expect(result.success).toBe(true);
+
+    const status = await getDaemonStatus('http://localhost:3000');
+
+    // Must include version — CLI compares against package.json to show staleness warning
+    expect(status.version).toBeDefined();
+    expect(typeof status.version).toBe('string');
+    expect(status.version!.length).toBeGreaterThan(0);
+
+    await stopDaemon();
+  });
+
+  it('version matches LOADED_VERSION constant', async () => {
+    vi.resetModules();
+    const { startDaemon, getDaemonStatus, stopDaemon, LOADED_VERSION } =
+      await import('../src/daemon.js');
+
+    await startDaemon();
+    const status = await getDaemonStatus('http://localhost:3000');
+    expect(status.version).toBe(LOADED_VERSION);
+
+    await stopDaemon();
+  });
+
+  it('reads version from status.json for external daemon (staleness detection)', async () => {
+    // Simulate external daemon that was started with an OLD version
+    mockReadStatusFile.mockResolvedValue({
+      pid: 99999,
+      startedAt: new Date(Date.now() - 3600_000).toISOString(),
+      version: '0.0.1', // old daemon version
+      projectCount: 0,
+      projects: [],
+    });
+
+    vi.resetModules();
+    const { getDaemonStatus } = await import('../src/daemon.js');
+
+    // Not running in-process → reads from status.json
+    const status = await getDaemonStatus('http://localhost:3000');
+    expect(status.running).toBe(true);
+
+    // Criterion: CLI compares status.version against installed version for staleness warning
+    // getDaemonStatus must surface the daemon's own version from status.json
+    expect(status.version).toBe('0.0.1');
+  });
+
+  it('buildStatusData() passed to startStatusLoop includes version field', async () => {
+    vi.resetModules();
+    const { startDaemon, stopDaemon, LOADED_VERSION } = await import('../src/daemon.js');
+
+    await startDaemon();
+
+    // The callback was registered with the status loop
+    expect(mockStartStatusLoop).toHaveBeenCalled();
+    const [, getStatusFn] = mockStartStatusLoop.mock.calls[0] as [
+      string,
+      () => { version?: string; pid: number; startedAt: string },
+    ];
+
+    const data = getStatusFn();
+
+    // version must be written to status.json via the status loop
+    expect(data.version).toBe(LOADED_VERSION);
+
+    await stopDaemon();
+  });
+});
+
+// ─── Criterion 2: startedAt for uptime calculation ────────────────────────────
+
+describe('getDaemonStatus() — startedAt field (criterion: human-readable uptime)', () => {
+  beforeEach(() => {
+    capturedOnPushSuccess = undefined;
+    vi.clearAllMocks();
+    setupStandardMocks();
+  });
+
+  it('includes startedAt ISO string for uptime calculation', async () => {
+    const beforeStart = Date.now();
+
+    vi.resetModules();
+    const { startDaemon, getDaemonStatus, stopDaemon } = await import('../src/daemon.js');
+    await startDaemon();
+
+    const status = await getDaemonStatus('http://localhost:3000');
+
+    // startedAt must be present — CLI uses `Date.now() - new Date(status.startedAt).getTime()`
+    // to compute uptime and then calls formatDuration() for human-readable output
+    expect(status.startedAt).toBeDefined();
+    expect(status.startedAt).not.toBeNull();
+
+    const startedAtMs = new Date(status.startedAt!).getTime();
+    expect(startedAtMs).toBeGreaterThanOrEqual(beforeStart);
+    expect(startedAtMs).toBeLessThanOrEqual(Date.now() + 1000);
+
+    await stopDaemon();
+  });
+
+  it('startedAt is written to status.json in buildStatusData()', async () => {
+    vi.resetModules();
+    const { startDaemon, stopDaemon } = await import('../src/daemon.js');
+    await startDaemon();
+
+    const [, getStatusFn] = mockStartStatusLoop.mock.calls[0] as [
+      string,
+      () => { startedAt: string },
+    ];
+    const data = getStatusFn();
+
+    // startedAt must be a valid ISO string
+    expect(data.startedAt).toBeDefined();
+    expect(() => new Date(data.startedAt)).not.toThrow();
+    expect(new Date(data.startedAt).getTime()).toBeGreaterThan(0);
+
+    await stopDaemon();
+  });
+});
+
+// ─── Criterion 4 & 5: lastSyncAt updates on file push ─────────────────────────
+
+describe('lastSyncAt — updates on every successful file push', () => {
+  beforeEach(() => {
+    capturedOnPushSuccess = undefined;
+    capturedOnPushError = undefined;
+    vi.clearAllMocks();
+    mockLoadCredentials.mockResolvedValue(testCreds);
+    mockLoadAllCredentials.mockResolvedValue(new Map([['user-1', testCreds]]));
+    mockLoadRegistry.mockResolvedValue({
+      projects: [{ path: '/test/my-project', name: 'my-project' }],
+    });
+  });
+
+  it('onPushSuccess callback updates lastSyncAt in daemon state', async () => {
+    vi.resetModules();
+    const { startDaemon, getDaemonStatus, stopDaemon } = await import('../src/daemon.js');
+    await startDaemon();
+
+    // Callback must have been captured during startDaemon → ensureProject
+    expect(capturedOnPushSuccess).toBeDefined();
+
+    const beforePush = Date.now();
+    capturedOnPushSuccess!('/test/my-project');
+
+    // After callback fires, getDaemonStatus must reflect updated lastSyncAt
+    const status = await getDaemonStatus('http://localhost:3000');
+    const project = status.projects.find((p) => p.path === '/test/my-project');
+
+    expect(project).toBeDefined();
+    expect(project!.lastSyncAt).not.toBeNull();
+
+    const syncTime = new Date(project!.lastSyncAt!).getTime();
+    expect(syncTime).toBeGreaterThanOrEqual(beforePush);
+    expect(syncTime).toBeLessThanOrEqual(Date.now() + 100);
+
+    await stopDaemon();
+  });
+
+  it('lastSyncAt advances on second push (not just initial sync)', async () => {
+    vi.resetModules();
+    const { startDaemon, getDaemonStatus, stopDaemon, updateProjectSyncState } =
+      await import('../src/daemon.js');
+    await startDaemon();
+
+    // Set a known "first sync" time in the past (30 seconds ago)
+    const firstSyncTime = new Date(Date.now() - 30_000);
+    updateProjectSyncState('/test/my-project', { lastSyncAt: firstSyncTime });
+
+    const firstStatus = await getDaemonStatus('http://localhost:3000');
+    const firstProject = firstStatus.projects.find((p) => p.path === '/test/my-project');
+    expect(firstProject?.lastSyncAt).toBe(firstSyncTime.toISOString());
+
+    // Simulate a SECOND file push completing successfully
+    const beforeSecondPush = Date.now();
+    capturedOnPushSuccess!('/test/my-project');
+
+    const secondStatus = await getDaemonStatus('http://localhost:3000');
+    const secondProject = secondStatus.projects.find((p) => p.path === '/test/my-project');
+
+    // lastSyncAt must have advanced beyond the 30-second-old timestamp
+    expect(secondProject?.lastSyncAt).not.toBe(firstSyncTime.toISOString());
+    const newTime = new Date(secondProject!.lastSyncAt!).getTime();
+    expect(newTime).toBeGreaterThanOrEqual(beforeSecondPush);
+
+    await stopDaemon();
+  });
+
+  it('onPushError does NOT update lastSyncAt', async () => {
+    vi.resetModules();
+    const { startDaemon, getDaemonStatus, stopDaemon, updateProjectSyncState } =
+      await import('../src/daemon.js');
+    await startDaemon();
+
+    // Set initial sync time
+    const initialSyncTime = new Date(Date.now() - 60_000);
+    updateProjectSyncState('/test/my-project', { lastSyncAt: initialSyncTime });
+
+    // Fire an error (file push failed)
+    capturedOnPushError!('/test/my-project');
+
+    const status = await getDaemonStatus('http://localhost:3000');
+    const project = status.projects.find((p) => p.path === '/test/my-project');
+
+    // lastSyncAt should NOT change on error — only errorCount increases
+    expect(project?.lastSyncAt).toBe(initialSyncTime.toISOString());
+    expect(project?.errorCount).toBeGreaterThan(0);
+
+    await stopDaemon();
+  });
+
+  it('lastSyncAt surfaces in buildStatusData for status.json write', async () => {
+    vi.resetModules();
+    const { startDaemon, stopDaemon, updateProjectSyncState } =
+      await import('../src/daemon.js');
+    await startDaemon();
+
+    // Set a known sync time
+    const syncTime = new Date(Date.now() - 5 * 60 * 1000); // 5 minutes ago
+    updateProjectSyncState('/test/my-project', { lastSyncAt: syncTime });
+
+    // The status loop callback returns current state
+    const [, getStatusFn] = mockStartStatusLoop.mock.calls[0] as [
+      string,
+      () => { projects: Array<{ path: string; lastSyncAt: string | null }> },
+    ];
+    const data = getStatusFn();
+
+    const project = data.projects.find((p) => p.path === '/test/my-project');
+    // lastSyncAt written to status.json (which status command reads for "5m ago" display)
+    expect(project?.lastSyncAt).toBe(syncTime.toISOString());
+
+    await stopDaemon();
+  });
+
+  it('watcher onPushSuccess is wired up in ensureProject', async () => {
+    vi.resetModules();
+    const { startDaemon, stopDaemon } = await import('../src/daemon.js');
+    await startDaemon();
+
+    // startProjectWatcher must have been called with onPushSuccess and onPushError callbacks
+    expect(mockStartProjectWatcher).toHaveBeenCalled();
+    const callOpts = mockStartProjectWatcher.mock.calls[0]![0] as {
+      onPushSuccess?: unknown;
+      onPushError?: unknown;
+    };
+    expect(typeof callOpts.onPushSuccess).toBe('function');
+    expect(typeof callOpts.onPushError).toBe('function');
+
+    await stopDaemon();
+  });
+});
+
+// ─── StatusFileData type validation ────────────────────────────────────────────
+
+describe('StatusFileData — version field in schema', () => {
+  it('StatusFileData type allows optional version field', async () => {
+    // Import the type and verify the version field is present in the interface
+    // This is a compile-time check made runtime via code inspection
+    const statusModule = await import('../src/status.js');
+
+    // The module exports must exist (this validates the module loads correctly)
+    expect(typeof statusModule.startStatusLoop).toBe('function');
+    expect(typeof statusModule.writeStatusFile).toBe('function');
+    expect(typeof statusModule.readStatusFile).toBe('function');
+
+    // Write a StatusFileData object WITH version — must not throw type error
+    // (TypeScript type checking validates this at compile time; test confirms shape)
+    const dataWithVersion = {
+      pid: 123,
+      startedAt: new Date().toISOString(),
+      version: '1.2.3',
+      projectCount: 0,
+      projects: [],
+    };
+
+    const dataWithoutVersion = {
+      pid: 123,
+      startedAt: new Date().toISOString(),
+      projectCount: 0,
+      projects: [],
+    };
+
+    // Both shapes are valid (version is optional for backwards compat)
+    expect(dataWithVersion.version).toBe('1.2.3');
+    expect('version' in dataWithoutVersion).toBe(false);
+  });
+});

package/__tests__/status-service-type.test.ts

@@ -0,0 +1,177 @@
+/**
+ * Tests for getServiceType() — Task 2 criterion: "Service type shown (systemd/launchd/manual)"
+ *
+ * getServiceType() is in service.ts and exported. It calls isServiceActive() and
+ * isServiceInstalled() which shell out to systemctl / launchctl / schtasks.
+ * We mock the underlying os/child_process/config to control what each returns.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mock child_process execFile — controls what systemctl/launchctl return
+const mockExecFile = vi.fn();
+vi.mock('node:child_process', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:child_process')>();
+  return { ...actual, execFile: (...args: unknown[]) => mockExecFile(...args) };
+});
+
+// Mock node:util promisify — returns mockExecFile directly
+vi.mock('node:util', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:util')>();
+  return { ...actual, promisify: () => mockExecFile };
+});
+
+// Mock node:fs/promises — for fileExists (isServiceInstalled)
+const mockAccess = vi.fn();
+vi.mock('node:fs/promises', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:fs/promises')>();
+  return {
+    ...actual,
+    writeFile: vi.fn().mockResolvedValue(undefined),
+    mkdir: vi.fn().mockResolvedValue(undefined),
+    unlink: vi.fn().mockResolvedValue(undefined),
+    access: (...args: unknown[]) => mockAccess(...args),
+  };
+});
+
+// Mock node:os platform — controlled per-test
+const mockPlatform = vi.fn().mockReturnValue('linux');
+vi.mock('node:os', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:os')>();
+  return {
+    ...actual,
+    platform: () => mockPlatform(),
+    homedir: () => '/home/testuser',
+  };
+});
+
+// Mock config — provides fileExists used by isServiceInstalled
+const mockFileExists = vi.fn();
+vi.mock('../src/config.js', () => ({
+  resolveServerPaths: () => ({
+    accountsDir: '/tmp/accounts',
+    configFile: '/tmp/config.json',
+    statusFile: '/tmp/status.json',
+    logDir: '/tmp/logs',
+  }),
+  fileExists: (...args: unknown[]) => mockFileExists(...args),
+  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(),
+    fatal: vi.fn(),
+  },
+}));
+
+describe('getServiceType() — service management label for status display', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockPlatform.mockReturnValue('linux');
+    // Default: no service active, not installed
+    mockExecFile.mockRejectedValue(new Error('not active'));
+    mockFileExists.mockResolvedValue(false);
+  });
+
+  it('returns "systemd (active)" when systemd is active on Linux', async () => {
+    mockPlatform.mockReturnValue('linux');
+    // systemctl --user is-active → "active"
+    mockExecFile.mockResolvedValue({ stdout: 'active\n', stderr: '' });
+
+    vi.resetModules();
+    const { getServiceType } = await import('../src/service.js');
+    const result = await getServiceType();
+    expect(result).toBe('systemd (active)');
+  });
+
+  it('returns "systemd (installed)" when installed but not active on Linux', async () => {
+    mockPlatform.mockReturnValue('linux');
+    // systemctl → not active
+    mockExecFile.mockRejectedValue(new Error('inactive'));
+    // but service file exists
+    mockFileExists.mockResolvedValue(true);
+
+    vi.resetModules();
+    const { getServiceType } = await import('../src/service.js');
+    const result = await getServiceType();
+    expect(result).toBe('systemd (installed)');
+  });
+
+  it('returns "manual" when no service detected on Linux', async () => {
+    mockPlatform.mockReturnValue('linux');
+    // systemctl → not active
+    mockExecFile.mockRejectedValue(new Error('not found'));
+    // service file does not exist
+    mockFileExists.mockResolvedValue(false);
+
+    vi.resetModules();
+    const { getServiceType } = await import('../src/service.js');
+    const result = await getServiceType();
+    expect(result).toBe('manual');
+  });
+
+  it('returns "launchd (active)" when launchd lists the service on macOS', async () => {
+    mockPlatform.mockReturnValue('darwin');
+    // launchctl list → includes the service label
+    mockExecFile.mockResolvedValue({
+      stdout: 'PID\tStatus\tLabel\n12345\t0\tcom.ultraclaude.dashboard-agent\n',
+      stderr: '',
+    });
+
+    vi.resetModules();
+    const { getServiceType } = await import('../src/service.js');
+    const result = await getServiceType();
+    expect(result).toBe('launchd (active)');
+  });
+
+  it('returns "launchd (installed)" when plist exists but not in launchctl list on macOS', async () => {
+    mockPlatform.mockReturnValue('darwin');
+    // launchctl list → does NOT include our service
+    mockExecFile.mockResolvedValue({ stdout: 'some other services\n', stderr: '' });
+    // plist file exists
+    mockFileExists.mockResolvedValue(true);
+
+    vi.resetModules();
+    const { getServiceType } = await import('../src/service.js');
+    const result = await getServiceType();
+    expect(result).toBe('launchd (installed)');
+  });
+
+  it('returns "manual" when no service detected on macOS', async () => {
+    mockPlatform.mockReturnValue('darwin');
+    // launchctl fails
+    mockExecFile.mockRejectedValue(new Error('launchctl failed'));
+    // plist file does not exist
+    mockFileExists.mockResolvedValue(false);
+
+    vi.resetModules();
+    const { getServiceType } = await import('../src/service.js');
+    const result = await getServiceType();
+    expect(result).toBe('manual');
+  });
+
+  it('returns "manual" on unsupported platform', async () => {
+    mockPlatform.mockReturnValue('freebsd');
+    mockFileExists.mockResolvedValue(false);
+
+    vi.resetModules();
+    const { getServiceType } = await import('../src/service.js');
+    const result = await getServiceType();
+    expect(result).toBe('manual');
+  });
+});