@openclaw-cloud/agent-controller 0.2.6 → 0.2.8

package/__tests__/handlers.test.ts

@@ -1,150 +0,0 @@
-import { handleExec } from '../src/handlers/exec';
-import { handleRestart } from '../src/handlers/restart';
-import { handleDeploy } from '../src/handlers/deploy';
-import { handleConfig } from '../src/handlers/config';
-import { handlePair } from '../src/handlers/pair';
-import { handleStop } from '../src/handlers/stop';
-import type { AgentCommand } from '../src/types';
-import childProcess from 'node:child_process';
-import fs from 'node:fs/promises';
-
-jest.mock('node:child_process');
-jest.mock('node:fs/promises');
-
-const mockExec = childProcess.exec as unknown as jest.Mock;
-
-function fakeExec(error: Error | null, stdout: string, stderr: string) {
-  mockExec.mockImplementation((_cmd: string, _opts: unknown, cb: Function) => {
-    cb(error, Buffer.from(stdout), Buffer.from(stderr));
-  });
-}
-
-describe('handleExec', () => {
-  beforeEach(() => jest.clearAllMocks());
-
-  it('executes a command and returns stdout', async () => {
-    fakeExec(null, 'hello\n', '');
-    const cmd: AgentCommand = { id: '1', type: 'exec', payload: { command: 'echo hello' } };
-    const res = await handleExec(cmd);
-    expect(res.success).toBe(true);
-    expect(res.data?.stdout).toBe('hello\n');
-    expect(res.data?.exitCode).toBe(0);
-  });
-
-  it('returns error when command fails', async () => {
-    const err = new Error('command failed');
-    (err as any).code = 127;
-    fakeExec(err, '', 'not found');
-    const cmd: AgentCommand = { id: '2', type: 'exec', payload: { command: 'bad' } };
-    const res = await handleExec(cmd);
-    expect(res.success).toBe(false);
-    expect(res.error).toBe('command failed');
-  });
-
-  it('rejects missing command payload', async () => {
-    const cmd: AgentCommand = { id: '3', type: 'exec', payload: {} };
-    const res = await handleExec(cmd);
-    expect(res.success).toBe(false);
-    expect(res.error).toContain('Missing');
-  });
-});
-
-describe('handleRestart', () => {
-  beforeEach(() => jest.clearAllMocks());
-
-  it('calls openclaw gateway restart', async () => {
-    fakeExec(null, 'restarted', '');
-    const cmd: AgentCommand = { id: '4', type: 'restart', payload: {} };
-    const res = await handleRestart(cmd);
-    expect(res.success).toBe(true);
-    expect(mockExec).toHaveBeenCalledWith('openclaw gateway restart', expect.any(Object), expect.any(Function));
-  });
-
-  it('returns error on restart failure', async () => {
-    fakeExec(new Error('restart failed'), '', 'err');
-    const cmd: AgentCommand = { id: '5', type: 'restart', payload: {} };
-    const res = await handleRestart(cmd);
-    expect(res.success).toBe(false);
-  });
-});
-
-describe('handleDeploy', () => {
-  beforeEach(() => jest.clearAllMocks());
-
-  it('installs and restarts on success', async () => {
-    let callCount = 0;
-    mockExec.mockImplementation((_cmd: string, _opts: unknown, cb: Function) => {
-      callCount++;
-      cb(null, Buffer.from(`step${callCount}`), Buffer.from(''));
-    });
-    const cmd: AgentCommand = { id: '6', type: 'deploy', payload: {} };
-    const res = await handleDeploy(cmd);
-    expect(res.success).toBe(true);
-    expect(mockExec).toHaveBeenCalledTimes(2);
-  });
-
-  it('fails if install fails', async () => {
-    fakeExec(new Error('npm error'), '', 'err');
-    const cmd: AgentCommand = { id: '7', type: 'deploy', payload: {} };
-    const res = await handleDeploy(cmd);
-    expect(res.success).toBe(false);
-    expect(res.error).toContain('Install failed');
-  });
-});
-
-describe('handleConfig', () => {
-  beforeEach(() => jest.clearAllMocks());
-
-  it('writes config and restarts', async () => {
-    (fs.mkdir as jest.Mock).mockResolvedValue(undefined);
-    (fs.writeFile as jest.Mock).mockResolvedValue(undefined);
-    fakeExec(null, 'ok', '');
-    const cmd: AgentCommand = { id: '8', type: 'config', payload: { filename: 'test.yml', content: 'key: val' } };
-    const res = await handleConfig(cmd);
-    expect(res.success).toBe(true);
-    expect(fs.writeFile).toHaveBeenCalled();
-  });
-
-  it('rejects missing payload', async () => {
-    const cmd: AgentCommand = { id: '9', type: 'config', payload: {} };
-    const res = await handleConfig(cmd);
-    expect(res.success).toBe(false);
-    expect(res.error).toContain('Missing');
-  });
-});
-
-describe('handlePair', () => {
-  it('returns paired response', async () => {
-    const cmd: AgentCommand = { id: '10', type: 'pair', payload: { token: 'abc', targetId: 'target-1' } };
-    const res = await handlePair(cmd);
-    expect(res.success).toBe(true);
-    expect(res.data?.paired).toBe(true);
-    expect(res.data?.targetId).toBe('target-1');
-  });
-
-  it('rejects missing pair params', async () => {
-    const cmd: AgentCommand = { id: '11', type: 'pair', payload: {} };
-    const res = await handlePair(cmd);
-    expect(res.success).toBe(false);
-  });
-});
-
-describe('handleStop', () => {
-  beforeEach(() => {
-    jest.useFakeTimers();
-    jest.spyOn(process, 'exit').mockImplementation(() => undefined as never);
-  });
-  afterEach(() => {
-    jest.useRealTimers();
-    jest.restoreAllMocks();
-  });
-
-  it('returns success and schedules shutdown', async () => {
-    const cmd: AgentCommand = { id: '12', type: 'stop', payload: {} };
-    const res = await handleStop(cmd);
-    expect(res.success).toBe(true);
-    expect(res.data?.message).toContain('gracefully');
-    jest.advanceTimersByTime(600);
-    expect(process.exit).toHaveBeenCalledWith(0);
-  });
-});

package/__tests__/heartbeat.test.ts

@@ -1,124 +0,0 @@
-import os from 'node:os';
-
-import { getMetrics, getLastMessageAt, startHeartbeat } from '../src/heartbeat';
-import type { AgentApi } from '../src/api';
-
-jest.mock('node:fs/promises', () => ({
-  readdir: jest.fn(),
-  stat: jest.fn(),
-}));
-
-import fsMock from 'node:fs/promises';
-const fsPromises = fsMock as jest.Mocked<typeof fsMock>;
-
-describe('getLastMessageAt', () => {
-  const origEnv = process.env.OPENCLAW_STATE_DIR;
-
-  afterEach(() => {
-    process.env.OPENCLAW_STATE_DIR = origEnv;
-    jest.clearAllMocks();
-  });
-
-  it('returns null when sessions directory does not exist', async () => {
-    fsPromises.readdir.mockRejectedValue(Object.assign(new Error('ENOENT'), { code: 'ENOENT' }));
-    const result = await getLastMessageAt();
-    expect(result).toBeNull();
-  });
-
-  it('returns null when no .jsonl files are present', async () => {
-    fsPromises.readdir.mockResolvedValue(['session.txt', 'other.json'] as unknown as Awaited<ReturnType<typeof fsPromises.readdir>>);
-    const result = await getLastMessageAt();
-    expect(result).toBeNull();
-  });
-
-  it('returns ISO string of the most recent mtime when .jsonl files are present', async () => {
-    process.env.OPENCLAW_STATE_DIR = '/test/state';
-    fsPromises.readdir.mockResolvedValue(['a.jsonl', 'b.jsonl'] as unknown as Awaited<ReturnType<typeof fsPromises.readdir>>);
-    const t1 = new Date('2024-01-01T10:00:00.000Z').getTime();
-    const t2 = new Date('2024-01-02T12:00:00.000Z').getTime();
-    fsPromises.stat
-      .mockResolvedValueOnce({ mtime: new Date(t1) } as unknown as Awaited<ReturnType<typeof fsPromises.stat>>)
-      .mockResolvedValueOnce({ mtime: new Date(t2) } as unknown as Awaited<ReturnType<typeof fsPromises.stat>>);
-    const result = await getLastMessageAt();
-    expect(result).toBe('2024-01-02T12:00:00.000Z');
-  });
-
-  it('does not throw on any error', async () => {
-    fsPromises.readdir.mockRejectedValue(new Error('unexpected'));
-    await expect(getLastMessageAt()).resolves.toBeNull();
-  });
-});
-
-describe('getMetrics', () => {
-  it('returns cpu, mem, uptime', () => {
-    const metrics = getMetrics();
-    expect(metrics).toHaveProperty('cpu');
-    expect(metrics).toHaveProperty('mem');
-    expect(metrics).toHaveProperty('uptime');
-    expect(typeof metrics.cpu).toBe('number');
-    expect(typeof metrics.mem).toBe('number');
-    expect(typeof metrics.uptime).toBe('number');
-    expect(metrics.cpu).toBeGreaterThanOrEqual(0);
-    expect(metrics.cpu).toBeLessThanOrEqual(1);
-    expect(metrics.mem).toBeGreaterThanOrEqual(0);
-    expect(metrics.mem).toBeLessThanOrEqual(1);
-  });
-});
-
-function makeApi(publishHeartbeat = jest.fn().mockResolvedValue(undefined)): AgentApi {
-  return {
-    get: jest.fn(),
-    post: jest.fn(),
-    publishResponse: jest.fn(),
-    publishHeartbeat,
-  } as unknown as AgentApi;
-}
-
-describe('startHeartbeat', () => {
-  beforeEach(() => {
-    jest.useFakeTimers();
-  });
-
-  afterEach(() => {
-    jest.useRealTimers();
-  });
-
-  it('publishes heartbeat immediately and at intervals', async () => {
-    const publishHeartbeat = jest.fn().mockResolvedValue(undefined);
-    const api = makeApi(publishHeartbeat);
-
-    const timer = startHeartbeat({ api, agentId: 'agent-42' });
-    // Flush microtasks so async getLastMessageAt() resolves before api.publishHeartbeat is called
-    await Promise.resolve();
-    await Promise.resolve();
-
-    // Immediate call
-    expect(publishHeartbeat).toHaveBeenCalledTimes(1);
-    expect(publishHeartbeat).toHaveBeenCalledWith(
-      'agent-42',
-      expect.objectContaining({
-        agentId: 'agent-42',
-        type: 'heartbeat',
-      }),
-    );
-
-    // After 30s
-    jest.advanceTimersByTime(30_000);
-    await Promise.resolve();
-    await Promise.resolve();
-    expect(publishHeartbeat).toHaveBeenCalledTimes(2);
-
-    clearInterval(timer);
-  });
-
-  it('handles publish errors gracefully', () => {
-    const consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
-    const api = makeApi(jest.fn().mockRejectedValue(new Error('network fail')));
-
-    const timer = startHeartbeat({ api, agentId: 'agent-42' });
-
-    // Should not throw
-    clearInterval(timer);
-    consoleSpy.mockRestore();
-  });
-});

package/__tests__/onboarding.test.ts

@@ -1,55 +0,0 @@
-import { handleOnboardingComplete } from '../src/handlers/onboarding';
-import type { AgentCommand } from '../src/types';
-import childProcess from 'node:child_process';
-
-jest.mock('node:child_process');
-
-const mockExec = childProcess.exec as unknown as jest.Mock;
-
-function fakeExec(error: Error | null, stdout = '', stderr = '') {
-  mockExec.mockImplementation((_cmd: string, _opts: unknown, cb: Function) => {
-    cb(error, Buffer.from(stdout), Buffer.from(stderr));
-  });
-}
-
-const baseCmd: AgentCommand = { id: '1', type: 'onboarding_complete', payload: { agentId: 'agent-123' } };
-
-describe('handleOnboardingComplete', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it('triggers "openclaw gateway restart" and returns success', async () => {
-    fakeExec(null, 'restarted', '');
-    const res = await handleOnboardingComplete(baseCmd);
-    expect(res.success).toBe(true);
-    expect(res.id).toBe('1');
-    expect(res.type).toBe('onboarding_complete');
-    expect(mockExec).toHaveBeenCalledWith(
-      'openclaw gateway restart',
-      expect.any(Object),
-      expect.any(Function),
-    );
-  });
-
-  it('returns success:false with error message when restart fails', async () => {
-    fakeExec(new Error('restart failed'), '', 'stderr output');
-    const res = await handleOnboardingComplete({ ...baseCmd, id: '2' });
-    expect(res.success).toBe(false);
-    expect(res.error).toBe('restart failed');
-    expect(res.id).toBe('2');
-  });
-
-  it('includes stdout and stderr in data', async () => {
-    fakeExec(null, 'gateway restarted ok', 'some warning');
-    const res = await handleOnboardingComplete(baseCmd);
-    expect(res.data?.stdout).toBe('gateway restarted ok');
-    expect(res.data?.stderr).toBe('some warning');
-  });
-
-  it('does not set error field on success', async () => {
-    fakeExec(null);
-    const res = await handleOnboardingComplete(baseCmd);
-    expect(res.error).toBeUndefined();
-  });
-});

package/__tests__/package-install.test.ts

@@ -1,109 +0,0 @@
-import { handlePackageInstall } from '../src/handlers/package-install';
-import type { AgentCommand } from '../src/types';
-import childProcess from 'node:child_process';
-
-jest.mock('node:child_process');
-
-const mockExec = childProcess.exec as unknown as jest.Mock;
-
-function fakeExec(error: Error | null) {
-  mockExec.mockImplementation((_cmd: string, _opts: unknown, cb: Function) => {
-    cb(error, Buffer.from(''), Buffer.from(''));
-  });
-}
-
-const baseCmd: AgentCommand = { id: '1', type: 'package_install', payload: {} };
-
-describe('handlePackageInstall', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it('returns success with empty installed when no packages provided', async () => {
-    const cmd: AgentCommand = { ...baseCmd, payload: { packages: {} } };
-    const res = await handlePackageInstall(cmd);
-    expect(res.success).toBe(true);
-    expect(res.data?.installed).toEqual({ apt: [], npm: [], pip: [] });
-    expect(res.data?.errors).toEqual([]);
-    expect(mockExec).not.toHaveBeenCalled();
-  });
-
-  it('returns success with empty installed when packages key is missing', async () => {
-    const cmd: AgentCommand = { ...baseCmd, payload: {} };
-    const res = await handlePackageInstall(cmd);
-    expect(res.success).toBe(true);
-    expect(res.data?.installed).toEqual({ apt: [], npm: [], pip: [] });
-    expect(mockExec).not.toHaveBeenCalled();
-  });
-
-  it('installs apt packages and runs apt-get install -y per package', async () => {
-    fakeExec(null);
-    const cmd: AgentCommand = { ...baseCmd, payload: { packages: { apt: ['curl', 'git'] } } };
-    const res = await handlePackageInstall(cmd);
-    expect(res.success).toBe(true);
-    expect((res.data?.installed as any).apt).toEqual(['curl', 'git']);
-    expect(mockExec).toHaveBeenCalledWith('apt-get install -y curl', expect.any(Object), expect.any(Function));
-    expect(mockExec).toHaveBeenCalledWith('apt-get install -y git', expect.any(Object), expect.any(Function));
-  });
-
-  it('installs npm packages with npm install -g', async () => {
-    fakeExec(null);
-    const cmd: AgentCommand = { ...baseCmd, payload: { packages: { npm: ['typescript'] } } };
-    const res = await handlePackageInstall(cmd);
-    expect(res.success).toBe(true);
-    expect((res.data?.installed as any).npm).toEqual(['typescript']);
-    expect(mockExec).toHaveBeenCalledWith('npm install -g typescript', expect.any(Object), expect.any(Function));
-  });
-
-  it('installs pip packages with pip install', async () => {
-    fakeExec(null);
-    const cmd: AgentCommand = { ...baseCmd, payload: { packages: { pip: ['requests'] } } };
-    const res = await handlePackageInstall(cmd);
-    expect(res.success).toBe(true);
-    expect((res.data?.installed as any).pip).toEqual(['requests']);
-    expect(mockExec).toHaveBeenCalledWith('pip install requests', expect.any(Object), expect.any(Function));
-  });
-
-  it('continues with other packages when one npm package fails (partial failure)', async () => {
-    let call = 0;
-    mockExec.mockImplementation((_cmd: string, _opts: unknown, cb: Function) => {
-      call === 0
-        ? cb(new Error('package not found'), Buffer.from(''), Buffer.from(''))
-        : cb(null, Buffer.from(''), Buffer.from(''));
-      call++;
-    });
-    const cmd: AgentCommand = { ...baseCmd, payload: { packages: { npm: ['bad-pkg', 'typescript'] } } };
-    const res = await handlePackageInstall(cmd);
-    expect(res.success).toBe(false);
-    expect((res.data?.installed as any).npm).toEqual(['typescript']);
-    expect((res.data?.errors as any[]).length).toBe(1);
-    expect((res.data?.errors as any[])[0].name).toBe('bad-pkg');
-    expect((res.data?.errors as any[])[0].error).toContain('package not found');
-  });
-
-  it('collects errors across all package types when all fail', async () => {
-    fakeExec(new Error('install failed'));
-    const cmd: AgentCommand = {
-      ...baseCmd,
-      payload: { packages: { apt: ['pkg1'], npm: ['pkg2'], pip: ['pkg3'] } },
-    };
-    const res = await handlePackageInstall(cmd);
-    expect(res.success).toBe(false);
-    expect((res.data?.errors as any[]).length).toBe(3);
-    expect((res.data?.installed as any)).toEqual({ apt: [], npm: [], pip: [] });
-  });
-
-  it('succeeds with success:true when all packages across all types install', async () => {
-    fakeExec(null);
-    const cmd: AgentCommand = {
-      ...baseCmd,
-      payload: { packages: { apt: ['curl'], npm: ['ts-node'], pip: ['boto3'] } },
-    };
-    const res = await handlePackageInstall(cmd);
-    expect(res.success).toBe(true);
-    expect((res.data?.errors as any[]).length).toBe(0);
-    expect((res.data?.installed as any).apt).toEqual(['curl']);
-    expect((res.data?.installed as any).npm).toEqual(['ts-node']);
-    expect((res.data?.installed as any).pip).toEqual(['boto3']);
-  });
-});

package/__tests__/pair.test.ts

@@ -1,60 +0,0 @@
-import { handlePair } from '../src/handlers/pair';
-import type { AgentCommand } from '../src/types';
-
-describe('handlePair', () => {
-  const originalEnv = process.env;
-
-  beforeEach(() => {
-    process.env = { ...originalEnv, AGENT_ID: 'agent-uuid-123' };
-  });
-
-  afterEach(() => {
-    process.env = originalEnv;
-  });
-
-  it('rejects when token is missing', async () => {
-    const cmd: AgentCommand = { id: '1', type: 'pair', payload: { targetId: 'target-1' } };
-    const res = await handlePair(cmd);
-    expect(res.success).toBe(false);
-    expect(res.error).toContain('Missing');
-  });
-
-  it('rejects when targetId is missing', async () => {
-    const cmd: AgentCommand = { id: '2', type: 'pair', payload: { token: 'abc' } };
-    const res = await handlePair(cmd);
-    expect(res.success).toBe(false);
-    expect(res.error).toContain('Missing');
-  });
-
-  it('rejects when both token and targetId are missing', async () => {
-    const cmd: AgentCommand = { id: '3', type: 'pair', payload: {} };
-    const res = await handlePair(cmd);
-    expect(res.success).toBe(false);
-    expect(res.error).toContain('Missing');
-  });
-
-  it('returns paired:true with targetId and agentId from env', async () => {
-    const cmd: AgentCommand = {
-      id: '4',
-      type: 'pair',
-      payload: { token: 'my-token', targetId: 'target-42' },
-    };
-    const res = await handlePair(cmd);
-    expect(res.success).toBe(true);
-    expect(res.data?.paired).toBe(true);
-    expect(res.data?.targetId).toBe('target-42');
-    expect(res.data?.agentId).toBe('agent-uuid-123');
-  });
-
-  it('returns agentId as undefined when AGENT_ID env var is not set', async () => {
-    delete process.env.AGENT_ID;
-    const cmd: AgentCommand = {
-      id: '5',
-      type: 'pair',
-      payload: { token: 'tok', targetId: 'target-1' },
-    };
-    const res = await handlePair(cmd);
-    expect(res.success).toBe(true);
-    expect(res.data?.agentId).toBeUndefined();
-  });
-});

package/__tests__/self-update.test.ts

@@ -1,123 +0,0 @@
-import { selfUpdate } from '../src/commands/self-update';
-import childProcess from 'node:child_process';
-
-jest.mock('node:child_process');
-
-const mockExec = childProcess.exec as unknown as jest.Mock;
-
-type ExecFakeResult = { error: Error | null; stdout: string };
-
-function fakeExecSequence(results: ExecFakeResult[]) {
-  let call = 0;
-  mockExec.mockImplementation((_cmd: string, _opts: unknown, cb: Function) => {
-    const result = results[call++] ?? { error: new Error('unexpected call'), stdout: '' };
-    cb(result.error, Buffer.from(result.stdout), Buffer.from(''));
-  });
-}
-
-describe('selfUpdate', () => {
-  let exitSpy: jest.SpyInstance;
-  let logSpy: jest.SpyInstance;
-  let errorSpy: jest.SpyInstance;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => undefined as never);
-    logSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
-    errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  it('prints "Already up to date" and does not exit when version matches', async () => {
-    fakeExecSequence([{ error: null, stdout: '1.2.3' }]);
-
-    await selfUpdate('1.2.3');
-
-    expect(mockExec).toHaveBeenCalledTimes(1);
-    expect(mockExec).toHaveBeenCalledWith(
-      'npm view @openclaw-cloud/agent-controller version',
-      expect.any(Object),
-      expect.any(Function),
-    );
-    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Already up to date'));
-    expect(exitSpy).not.toHaveBeenCalled();
-  });
-
-  it('installs latest and calls process.exit(0) when a new version is available', async () => {
-    fakeExecSequence([
-      { error: null, stdout: '1.3.0' },
-      { error: null, stdout: '' },
-    ]);
-
-    await selfUpdate('1.2.3');
-
-    expect(mockExec).toHaveBeenCalledTimes(2);
-    expect(mockExec).toHaveBeenNthCalledWith(
-      1,
-      'npm view @openclaw-cloud/agent-controller version',
-      expect.any(Object),
-      expect.any(Function),
-    );
-    expect(mockExec).toHaveBeenNthCalledWith(
-      2,
-      'npm install -g @openclaw-cloud/agent-controller@latest',
-      expect.any(Object),
-      expect.any(Function),
-    );
-    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Updating from 1.2.3 to 1.3.0'));
-    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Successfully updated to 1.3.0'));
-    expect(exitSpy).toHaveBeenCalledWith(0);
-  });
-
-  it('calls process.exit(1) when npm view fails', async () => {
-    fakeExecSequence([{ error: new Error('network error'), stdout: '' }]);
-
-    await selfUpdate('1.2.3');
-
-    expect(exitSpy).toHaveBeenCalledWith(1);
-    expect(errorSpy).toHaveBeenCalledWith(
-      expect.stringContaining('Failed to fetch latest version'),
-      'network error',
-    );
-    expect(mockExec).toHaveBeenCalledTimes(1);
-  });
-
-  it('calls process.exit(1) when npm install fails', async () => {
-    fakeExecSequence([
-      { error: null, stdout: '1.3.0' },
-      { error: new Error('npm install failed'), stdout: '' },
-    ]);
-
-    await selfUpdate('1.2.3');
-
-    expect(exitSpy).toHaveBeenCalledWith(1);
-    expect(errorSpy).toHaveBeenCalledWith(
-      expect.stringContaining('Update failed'),
-      'npm install failed',
-    );
-  });
-
-  it('logs current and latest versions before updating', async () => {
-    fakeExecSequence([
-      { error: null, stdout: '2.0.0' },
-      { error: null, stdout: '' },
-    ]);
-
-    await selfUpdate('1.0.0');
-
-    expect(logSpy).toHaveBeenCalledWith('Current version: 1.0.0');
-    expect(logSpy).toHaveBeenCalledWith('Latest version: 2.0.0');
-  });
-
-  it('trims whitespace from npm view output before comparing', async () => {
-    fakeExecSequence([{ error: null, stdout: '1.2.3\n' }]);
-
-    await selfUpdate('1.2.3');
-
-    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Already up to date'));
-    expect(exitSpy).not.toHaveBeenCalled();
-  });
-});

package/__tests__/stop.test.ts

@@ -1,38 +0,0 @@
-import { handleStop } from '../src/handlers/stop';
-import type { AgentCommand } from '../src/types';
-
-describe('handleStop', () => {
-  beforeEach(() => {
-    jest.useFakeTimers();
-    jest.spyOn(process, 'exit').mockImplementation(() => undefined as never);
-  });
-
-  afterEach(() => {
-    jest.useRealTimers();
-    jest.restoreAllMocks();
-  });
-
-  it('returns success response with graceful shutdown message', async () => {
-    const cmd: AgentCommand = { id: '1', type: 'stop', payload: {} };
-    const res = await handleStop(cmd);
-    expect(res.success).toBe(true);
-    expect(res.data?.message).toContain('gracefully');
-    expect(res.id).toBe('1');
-    expect(res.type).toBe('stop');
-  });
-
-  it('does not call process.exit before 500ms', async () => {
-    const cmd: AgentCommand = { id: '2', type: 'stop', payload: {} };
-    await handleStop(cmd);
-    jest.advanceTimersByTime(499);
-    expect(process.exit).not.toHaveBeenCalled();
-  });
-
-  it('calls process.exit(0) after 500ms', async () => {
-    const cmd: AgentCommand = { id: '3', type: 'stop', payload: {} };
-    await handleStop(cmd);
-    expect(process.exit).not.toHaveBeenCalled();
-    jest.advanceTimersByTime(500);
-    expect(process.exit).toHaveBeenCalledWith(0);
-  });
-});

package/jest.config.ts

@@ -1,16 +0,0 @@
-import type { Config } from 'jest';
-
-const config: Config = {
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-  roots: ['<rootDir>/__tests__'],
-  moduleFileExtensions: ['ts', 'js', 'json'],
-  transform: {
-    '^.+\\.ts$': ['ts-jest', { useESM: false, tsconfig: { module: 'commonjs' } }],
-  },
-  moduleNameMapper: {
-    '^(\\.{1,2}/.*)\\.js$': '$1',
-  },
-};
-
-export default config;