@cursorpool-dev/cli 0.5.6

package/test/restore.test.ts

@@ -0,0 +1,211 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, normalize } from 'node:path';
+import test from 'node:test';
+import { CURSOR_POOL_AGENT_EXEC_PROVIDER_REGISTER_ANCHOR } from '../../patcher/src/marker';
+import { patchCursorAgentExec } from '../../patcher/src/patchCursorAgentExec';
+import {
+  installIdForAppPath,
+  readInstallRecord,
+  writeInstallRecord,
+  type InstallRecord,
+} from '../src/installRecord';
+import { restore } from '../src/restore';
+import { trialIdForAppPath, writeTrialRecord } from '../src/trial';
+
+const targetRelativePath =
+  'Contents/Resources/app/extensions/cursor-agent-exec/dist/main.js';
+
+async function createFixtureApp() {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-cli-restore-'));
+  const appPath = join(tempDir, 'Cursor.app');
+  const targetPath = join(appPath, targetRelativePath);
+  const targetContent = `function main() { return "agent"; }\n${CURSOR_POOL_AGENT_EXEC_PROVIDER_REGISTER_ANCHOR}\nmain();\n`;
+  await mkdir(join(appPath, 'Contents/Resources/app/extensions/cursor-agent-exec/dist'), {
+    recursive: true,
+  });
+  await writeFile(
+    join(appPath, 'Contents/Resources/app/product.json'),
+    JSON.stringify({
+      version: '3.5.38',
+      commit: '009bb5a3600dd98fe1c1f25798f767f686e14750',
+    }),
+    'utf8',
+  );
+  await writeFile(targetPath, targetContent, 'utf8');
+
+  return {
+    appPath,
+    tempDir,
+    targetPath,
+    targetContent,
+    backupDir: join(tempDir, 'backups'),
+    trialRecordDir: join(tempDir, 'trials'),
+  };
+}
+
+test('restore reports ok and replaces patched fixture bytes with backup bytes', async () => {
+  const fixture = await createFixtureApp();
+
+  try {
+    await patchCursorAgentExec(fixture.appPath, { backupDir: fixture.backupDir });
+
+    const output = await restore({
+      appPath: fixture.appPath,
+      backupDir: fixture.backupDir,
+    });
+
+    assert.match(output, /mode: disposable/);
+    assert.match(output, /restore: ok/);
+    assert.equal(await readFile(fixture.targetPath, 'utf8'), fixture.targetContent);
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('restore discovers backup directory from the trial record', async () => {
+  const fixture = await createFixtureApp();
+
+  try {
+    await patchCursorAgentExec(fixture.appPath, { backupDir: fixture.backupDir });
+    await writeTrialRecord(
+      {
+        trialId: trialIdForAppPath(fixture.appPath),
+        appPath: fixture.appPath,
+        cursorVersion: '3.5.38',
+        cursorCommit: '009bb5a3600dd98fe1c1f25798f767f686e14750',
+        targetRelativePath,
+        originalSha256: 'fixture-original-sha',
+        compatSupportStatus: 'supported',
+        runtimeFile: join(fixture.tempDir, 'runtime.json'),
+        backupDir: fixture.backupDir,
+        extensionInstallPath: join(fixture.tempDir, 'extensions/cursor-pool-status'),
+        extensionState: 'bundled',
+        createdAt: '2026-05-30T00:00:00.000Z',
+        updatedAt: '2026-05-30T00:00:01.000Z',
+      },
+      { trialRecordDir: fixture.trialRecordDir },
+    );
+
+    const output = await restore({
+      appPath: fixture.appPath,
+      trialRecordDir: fixture.trialRecordDir,
+    });
+
+    assert.match(output, /mode: disposable/);
+    assert.match(output, /restore: ok/);
+    assert.equal(await readFile(fixture.targetPath, 'utf8'), fixture.targetContent);
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+function createInstallRecordFixture(
+  fixture: Awaited<ReturnType<typeof createFixtureApp>>,
+  overrides: Partial<InstallRecord> = {},
+): InstallRecord {
+  const now = '2026-05-30T00:00:00.000Z';
+  return {
+    installId: installIdForAppPath(fixture.appPath),
+    mode: 'real',
+    appPath: fixture.appPath,
+    cursorVersion: '3.5.38',
+    cursorCommit: '009bb5a3600dd98fe1c1f25798f767f686e14750',
+    targetRelativePath,
+    originalSha256: 'fixture-original-sha',
+    compatSupportStatus: 'supported',
+    runtimeFile: join(fixture.tempDir, 'runtime.json'),
+    backupDir: fixture.backupDir,
+    extensionInstallPath: join(fixture.tempDir, 'extensions/cursor-pool-status'),
+    extensionState: 'bundled',
+    cliVersion: '0.0.0',
+    extensionVersion: '0.0.0',
+    serviceVersion: '0.0.0',
+    lastOperation: 'install',
+    lastOperationStatus: 'ok',
+    createdAt: now,
+    updatedAt: now,
+    ...overrides,
+  };
+}
+
+test('real-mode restore uses install record backup and keeps install record', async () => {
+  const fixture = await createFixtureApp();
+  const installRecordFile = join(fixture.tempDir, 'install.json');
+  const runtimeFile = join(fixture.tempDir, 'runtime.json');
+
+  try {
+    await patchCursorAgentExec(fixture.appPath, { backupDir: fixture.backupDir });
+    const record = createInstallRecordFixture(fixture, { runtimeFile });
+    await writeInstallRecord(record, { installRecordFile });
+
+    const output = await restore({
+      realAppPath: fixture.appPath,
+      installRecordFile,
+      yes: true,
+    });
+
+    assert.match(output, /mode: real/);
+    assert.match(output, /install-record: recorded/);
+    assert.match(output, /restore: ok/);
+    assert.equal(await readFile(fixture.targetPath, 'utf8'), fixture.targetContent);
+    assert.deepEqual(await readInstallRecord({ installRecordFile }), record);
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('real-mode restore rejects mismatched install record app path before mutation', async () => {
+  const fixture = await createFixtureApp();
+  const otherFixture = await createFixtureApp();
+  const installRecordFile = join(fixture.tempDir, 'install.json');
+
+  try {
+    await patchCursorAgentExec(fixture.appPath, { backupDir: fixture.backupDir });
+    const patchedBytes = await readFile(fixture.targetPath, 'utf8');
+    const wrongRecord = createInstallRecordFixture(otherFixture);
+    await writeInstallRecord(wrongRecord, { installRecordFile });
+
+    await assert.rejects(
+      restore({
+        realAppPath: fixture.appPath,
+        installRecordFile,
+        yes: true,
+      }),
+      new RegExp(`Install record does not match Cursor app: ${normalize(fixture.appPath)}`),
+    );
+
+    assert.equal(await readFile(fixture.targetPath, 'utf8'), patchedBytes);
+    assert.deepEqual(await readInstallRecord({ installRecordFile }), wrongRecord);
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+    await rm(otherFixture.tempDir, { recursive: true, force: true });
+  }
+});
+
+test('real-mode restore rejects missing confirmation before mutation', async () => {
+  const fixture = await createFixtureApp();
+  const installRecordFile = join(fixture.tempDir, 'install.json');
+
+  try {
+    await patchCursorAgentExec(fixture.appPath, { backupDir: fixture.backupDir });
+    const patchedBytes = await readFile(fixture.targetPath, 'utf8');
+    const record = createInstallRecordFixture(fixture);
+    await writeInstallRecord(record, { installRecordFile });
+
+    await assert.rejects(
+      restore({
+        realAppPath: fixture.appPath,
+        installRecordFile,
+        isInteractive: false,
+      }),
+      /Pass --yes to confirm restore for real Cursor/,
+    );
+
+    assert.equal(await readFile(fixture.targetPath, 'utf8'), patchedBytes);
+    assert.deepEqual(await readInstallRecord({ installRecordFile }), record);
+  } finally {
+    await rm(fixture.tempDir, { recursive: true, force: true });
+  }
+});

package/test/serviceCommands.test.ts

@@ -0,0 +1,135 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import { readRuntimeInfo } from '../../service/src/runtime';
+import { startServer } from '../../service/src/server';
+import { startLocalServiceCommand, stopLocalServiceCommand } from '../src/serviceCommands';
+import { writeClientConfig } from '../../shared/src/clientConfig';
+
+test('startLocalServiceCommand starts the local service and reports runtime paths', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-service-command-'));
+  const runtimeFile = join(tempDir, 'runtime.json');
+  const logFile = join(tempDir, 'service.log');
+
+  try {
+    const output = await startLocalServiceCommand({
+      runtimeFile,
+      serviceLogFile: logFile,
+    });
+    const runtime = await readRuntimeInfo({ runtimeFile });
+
+    assert.ok(runtime);
+    assert.match(output, /service: started 127\.0\.0\.1:\d+/);
+    assert.match(output, new RegExp(`runtime: ${runtimeFile.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`));
+    assert.match(output, new RegExp(`log: ${logFile.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`));
+  } finally {
+    await stopLocalServiceCommand({ runtimeFile });
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('startLocalServiceCommand passes API base URL to detached service', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-service-command-'));
+  const runtimeFile = join(tempDir, 'runtime.json');
+  const logFile = join(tempDir, 'service.log');
+  const calls: Record<string, unknown>[] = [];
+
+  try {
+    const output = await startLocalServiceCommand({
+      runtimeFile,
+      serviceLogFile: logFile,
+      apiBaseUrl: 'http://127.0.0.1:8765',
+      startDetachedService: async (options) => {
+        calls.push(options);
+        return { host: '127.0.0.1', port: 8766, runtimeId: 'runtime-1' };
+      },
+    });
+
+    assert.match(output, /service: started 127\.0\.0\.1:8766/);
+    assert.equal(calls[0]?.apiBaseUrl, 'http://127.0.0.1:8765');
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('startLocalServiceCommand falls back to persisted API base URL', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-service-command-'));
+  const runtimeFile = join(tempDir, 'runtime.json');
+  const logFile = join(tempDir, 'service.log');
+  const configFile = join(tempDir, 'client-config.json');
+  const calls: Record<string, unknown>[] = [];
+
+  try {
+    await writeClientConfig({ apiBaseUrl: 'https://platform.example.test' }, { configFile });
+    const output = await startLocalServiceCommand({
+      runtimeFile,
+      serviceLogFile: logFile,
+      configFile,
+      startDetachedService: async (options) => {
+        calls.push(options);
+        return { host: '127.0.0.1', port: 8766, runtimeId: 'runtime-1' };
+      },
+    });
+
+    assert.match(output, /service: started 127\.0\.0\.1:8766/);
+    assert.equal(calls[0]?.apiBaseUrl, 'https://platform.example.test');
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('startLocalServiceCommand reports already-running without restarting a healthy service', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-service-command-'));
+  const runtimeFile = join(tempDir, 'runtime.json');
+  const logFile = join(tempDir, 'service.log');
+  const service = await startServer({ runtimeFile });
+
+  try {
+    const output = await startLocalServiceCommand({
+      runtimeFile,
+      serviceLogFile: logFile,
+      startDetachedService: async () => {
+        throw new Error('must not restart a healthy service');
+      },
+    });
+
+    assert.match(output, new RegExp(`service: already-running ${service.host}:${service.port}`));
+    assert.match(output, new RegExp(`runtime: ${runtimeFile.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`));
+    assert.match(output, new RegExp(`log: ${logFile.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`));
+  } finally {
+    await service.stop();
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('stopLocalServiceCommand stops a healthy local service', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-service-command-'));
+  const runtimeFile = join(tempDir, 'runtime.json');
+  await startServer({ runtimeFile });
+
+  try {
+    const output = await stopLocalServiceCommand({ runtimeFile });
+
+    assert.match(output, /service: stopped/);
+    assert.match(output, new RegExp(`runtime: ${runtimeFile.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`));
+  } finally {
+    await stopLocalServiceCommand({ runtimeFile });
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('stopLocalServiceCommand is idempotent when no service is running', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-service-command-'));
+  const runtimeFile = join(tempDir, 'runtime.json');
+
+  try {
+    const output = await stopLocalServiceCommand({ runtimeFile });
+
+    assert.match(output, /service: not-running/);
+    assert.match(output, new RegExp(`runtime: ${runtimeFile.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`));
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});

package/test/serviceProcess.test.ts

@@ -0,0 +1,280 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import test from 'node:test';
+import { readRuntimeInfo } from '../../service/src/runtime';
+import { startServer } from '../../service/src/server';
+import { startDetachedService, stopRuntimeService, waitForRuntimeHealth } from '../src/serviceProcess';
+
+const cliRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+
+test('startDetachedService starts a service discoverable by runtime file', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-detached-service-'));
+  const runtimeFile = join(tempDir, 'runtime.json');
+  const logFile = join(tempDir, 'service.log');
+
+  try {
+    const started = await startDetachedService({ runtimeFile, logFile });
+    assert.equal(started.host, '127.0.0.1');
+    assert.equal(typeof started.port, 'number');
+
+    const runtime = await readRuntimeInfo({ runtimeFile });
+    assert.deepEqual(runtime, started);
+    assert.equal(await waitForRuntimeHealth(runtimeFile), true);
+
+    assert.equal(await stopRuntimeService(runtimeFile), true);
+    assert.equal(await waitForRuntimeHealth(runtimeFile), false);
+    await stat(logFile);
+  } finally {
+    await stopRuntimeService(runtimeFile);
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('startDetachedService reuses an existing healthy runtime instead of starting another service', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-detached-service-reuse-'));
+  const runtimeFile = join(tempDir, 'runtime.json');
+  const logFile = join(tempDir, 'service.log');
+  const existingService = await startServer({ runtimeFile });
+
+  try {
+    const started = await startDetachedService({
+      runtimeFile,
+      logFile,
+      serviceEntry: join(tempDir, 'missing-entry.ts'),
+      startupTimeoutMs: 250,
+    });
+
+    assert.deepEqual(started, {
+      host: existingService.host,
+      port: existingService.port,
+      runtimeId: existingService.runtimeId,
+    });
+    assert.deepEqual(await readRuntimeInfo({ runtimeFile }), started);
+  } finally {
+    await existingService.stop();
+    await stopRuntimeService(runtimeFile);
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('startDetachedService coalesces concurrent starts for the same runtime file', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-detached-service-concurrent-'));
+  const runtimeFile = join(tempDir, 'runtime.json');
+  const logFile = join(tempDir, 'service.log');
+
+  try {
+    const [first, second] = await Promise.all([
+      startDetachedService({ runtimeFile, logFile }),
+      startDetachedService({ runtimeFile, logFile }),
+    ]);
+
+    assert.deepEqual(first, second);
+    assert.deepEqual(await readRuntimeInfo({ runtimeFile }), first);
+
+    const log = await readFile(logFile, 'utf8');
+    const runtimeIds = new Set(
+      log
+        .split('\n')
+        .filter((line) => line.trim().startsWith('{'))
+        .map((line) => JSON.parse(line) as { runtimeId?: unknown })
+        .map((runtime) => runtime.runtimeId)
+        .filter((runtimeId): runtimeId is string => typeof runtimeId === 'string'),
+    );
+    assert.deepEqual([...runtimeIds], [first.runtimeId]);
+  } finally {
+    await stopRuntimeService(runtimeFile);
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('startDetachedService default entry works from package-local cwd', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-detached-service-cwd-'));
+  const runtimeFile = join(tempDir, 'runtime.json');
+  const logFile = join(tempDir, 'service.log');
+  const previousCwd = process.cwd();
+  process.chdir(cliRoot);
+
+  try {
+    const started = await startDetachedService({ runtimeFile, logFile });
+    assert.equal(started.host, '127.0.0.1');
+    assert.equal(await waitForRuntimeHealth(runtimeFile), true);
+    assert.equal(await stopRuntimeService(runtimeFile), true);
+  } finally {
+    process.chdir(previousCwd);
+    await stopRuntimeService(runtimeFile);
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('startDetachedService reuses an existing healthy runtime even when the requested entry is missing', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-detached-service-'));
+  const runtimeFile = join(tempDir, 'runtime.json');
+  const logFile = join(tempDir, 'service.log');
+  const staleService = await startServer({ runtimeFile });
+
+  try {
+    const started = await startDetachedService({
+        runtimeFile,
+        logFile,
+        serviceEntry: join(tempDir, 'missing-entry.ts'),
+        startupTimeoutMs: 250,
+      });
+
+    const runtime = await readRuntimeInfo({ runtimeFile });
+    assert.deepEqual(runtime, started);
+    assert.deepEqual(started, {
+      host: staleService.host,
+      port: staleService.port,
+      runtimeId: staleService.runtimeId,
+    });
+  } finally {
+    await staleService.stop();
+    await stopRuntimeService(runtimeFile);
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('startDetachedService reuses an existing healthy tilde runtime', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-detached-service-'));
+  const originalHome = process.env.HOME;
+  process.env.HOME = tempDir;
+  const runtimeFile = '~/.cursor-pool/runtime.json';
+  const logFile = join(tempDir, 'service.log');
+  const staleService = await startServer({ runtimeFile });
+
+  try {
+    const started = await startDetachedService({
+        runtimeFile,
+        logFile,
+        serviceEntry: join(tempDir, 'missing-entry.ts'),
+        startupTimeoutMs: 250,
+      });
+
+    const runtime = await readRuntimeInfo({ runtimeFile });
+    assert.deepEqual(runtime, started);
+    assert.deepEqual(started, {
+      host: staleService.host,
+      port: staleService.port,
+      runtimeId: staleService.runtimeId,
+    });
+  } finally {
+    await staleService.stop();
+    await stopRuntimeService(runtimeFile);
+    if (originalHome === undefined) {
+      delete process.env.HOME;
+    } else {
+      process.env.HOME = originalHome;
+    }
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('stopRuntimeService does not stop service when runtimeId differs', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-detached-service-'));
+  const runtimeFile = join(tempDir, 'runtime.json');
+  const service = await startServer({ runtimeFile });
+
+  try {
+    await writeFile(
+      runtimeFile,
+      `${JSON.stringify({
+        host: service.host,
+        port: service.port,
+        runtimeId: 'wrong-runtime-id',
+      })}\n`,
+      'utf8',
+    );
+
+    assert.equal(await stopRuntimeService(runtimeFile), false);
+
+    const health = await fetch(`http://${service.host}:${service.port}/health`);
+    assert.equal(health.ok, true);
+    const body = (await health.json()) as { ok?: unknown; runtimeId?: unknown };
+    assert.equal(body.ok, true);
+    assert.equal(body.runtimeId, service.runtimeId);
+  } finally {
+    await service.stop();
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('startDetachedService rejects spawn errors with context', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-detached-service-'));
+
+  try {
+    await assert.rejects(
+      startDetachedService({
+        runtimeFile: join(tempDir, 'runtime.json'),
+        logFile: join(tempDir, 'service.log'),
+        command: join(tempDir, 'missing-command'),
+        startupTimeoutMs: 250,
+      }),
+      /Failed to start detached service process/,
+    );
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('startDetachedService terminates a non-starting process on timeout', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-detached-service-'));
+  const runtimeFile = join(tempDir, 'runtime.json');
+  const entryFile = join(tempDir, 'hanging-entry.ts');
+  const pidFile = join(tempDir, 'service.pid');
+
+  await writeFile(
+    entryFile,
+    `import { writeFileSync } from 'node:fs';\nwriteFileSync(${JSON.stringify(pidFile)}, String(process.pid));\nsetInterval(() => {}, 1000);\n`,
+    'utf8',
+  );
+
+  try {
+    await assert.rejects(
+      startDetachedService({
+        runtimeFile,
+        logFile: join(tempDir, 'service.log'),
+        serviceEntry: entryFile,
+        startupTimeoutMs: 500,
+      }),
+      /Detached service failed to become healthy/,
+    );
+
+    const pid = Number(await import('node:fs/promises').then(({ readFile }) => readFile(pidFile, 'utf8')));
+    assert.ok(Number.isInteger(pid));
+    await assert.rejects(
+      import('node:process').then(({ kill }) => kill(pid, 0)),
+      /ESRCH/,
+    );
+  } finally {
+    await stopRuntimeService(runtimeFile);
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('startDetachedService expands tilde in logFile', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'cursor-pool-detached-service-'));
+  const originalHome = process.env.HOME;
+  process.env.HOME = tempDir;
+  const runtimeFile = join(tempDir, 'runtime.json');
+
+  try {
+    await startDetachedService({
+      runtimeFile,
+      logFile: '~/cursor-pool/service.log',
+    });
+
+    await stat(join(tempDir, 'cursor-pool/service.log'));
+    assert.equal(await stopRuntimeService(runtimeFile), true);
+  } finally {
+    await stopRuntimeService(runtimeFile);
+    if (originalHome === undefined) {
+      delete process.env.HOME;
+    } else {
+      process.env.HOME = originalHome;
+    }
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});