clawmini 0.0.7 → 0.0.9

package/e2e/routers/slash-restart-adapter.test.ts

@@ -0,0 +1,96 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  TestEnvironment,
+  type ChatMessage,
+  type SystemMessage,
+} from '../_helpers/test-environment.js';
+
+async function waitUntil(
+  cond: () => boolean,
+  timeoutMs: number,
+  intervalMs = 100
+): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (cond()) return true;
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  return cond();
+}
+
+function readPackageVersion(): string {
+  const pkgPath = path.resolve(__dirname, '../../package.json');
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8')) as { version: string };
+  return pkg.version;
+}
+
+function isSystemReplyContaining(text: string) {
+  return (m: ChatMessage): m is SystemMessage =>
+    m.role === 'system' && typeof m.content === 'string' && m.content.includes(text);
+}
+
+// Distinct from slash-restart.test.ts which only inspects the chat log on
+// disk. The pending-replies → drainPendingReplies path is justified by the
+// claim that adapters reconnect to the tRPC subscription with a
+// lastMessageId cursor and replay the post-restart SystemMessage. This test
+// exercises that path end-to-end through tRPC.
+describe('/restart adapter delivery e2e', () => {
+  let env: TestEnvironment;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-slash-restart-adapter');
+    await env.setup();
+    await env.init();
+  }, 30000);
+
+  afterAll(async () => {
+    await env.teardown();
+  }, 30000);
+
+  it('replays the post-restart SystemMessage to a tRPC subscriber that reconnects with lastMessageId', async () => {
+    const { code } = await env.runCli(['serve', '--detach']);
+    expect(code).toBe(0);
+
+    const socketPath = env.getClawminiPath('daemon.sock');
+    expect(await waitUntil(() => fs.existsSync(socketPath), 10000)).toBe(true);
+
+    // Subscribe BEFORE sending /restart so we get the ack on the live stream.
+    const sub1 = await env.connect('default');
+
+    await env.sendMessage('/restart', { noWait: true });
+
+    const ack = await sub1.waitForMessage(
+      isSystemReplyContaining('Restarting clawmini...'),
+      15000
+    );
+    expect(ack.id).toBeTruthy();
+
+    // Drop the first subscription before the daemon goes down so we
+    // explicitly model an adapter that reconnected. The httpSubscriptionLink
+    // would otherwise try to auto-reconnect on its own and cloud the test.
+    await sub1.disconnect();
+
+    // Wait for the daemon to actually restart (socket disappears, then comes
+    // back). Old daemon dies → socket gone; supervisor's restartService spins
+    // up a new daemon that re-binds the socket.
+    expect(await waitUntil(() => !fs.existsSync(socketPath), 30000)).toBe(true);
+    expect(await waitUntil(() => fs.existsSync(socketPath), 60000)).toBe(true);
+
+    // Reconnect with the lastMessageId cursor — exactly what the adapter
+    // forwarder does when it re-establishes its subscription. The catch-up
+    // path in waitForMessages should yield the post-restart SystemMessage
+    // that drainPendingReplies appended on daemon startup.
+    const sub2 = await env.connect('default', { lastMessageId: ack.id });
+
+    const expectedVersion = readPackageVersion();
+    const restartedMsg = await sub2.waitForMessage(
+      isSystemReplyContaining(`Clawmini restarted (v${expectedVersion}).`),
+      30000
+    );
+    expect(restartedMsg.role).toBe('system');
+
+    await sub2.disconnect();
+  }, 120000);
+});

package/e2e/routers/slash-restart.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import { TestEnvironment } from '../_helpers/test-environment.js';
+
+async function waitUntil(
+  cond: () => boolean,
+  timeoutMs: number,
+  intervalMs = 100
+): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (cond()) return true;
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  return cond();
+}
+
+interface LogLine {
+  role?: string;
+  content?: string;
+}
+
+function readChatLog(filePath: string): LogLine[] {
+  if (!fs.existsSync(filePath)) return [];
+  return fs
+    .readFileSync(filePath, 'utf-8')
+    .split('\n')
+    .filter((line) => line.trim().length > 0)
+    .map((line) => {
+      try {
+        return JSON.parse(line) as LogLine;
+      } catch {
+        return {};
+      }
+    });
+}
+
+function readPid(pidPath: string): string {
+  return fs.readFileSync(pidPath, 'utf-8').trim().split(':')[0] ?? '';
+}
+
+function readPackageVersion(): string {
+  const pkgPath = path.resolve(__dirname, '../../package.json');
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8')) as { version: string };
+  return pkg.version;
+}
+
+describe('/restart router e2e', () => {
+  let env: TestEnvironment;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-slash-restart');
+    await env.setup();
+    await env.init();
+  }, 30000);
+
+  afterAll(async () => {
+    await env.teardown();
+  }, 30000);
+
+  it('restarts the daemon and posts a "restarted vX.Y.Z" reply', async () => {
+    const { code } = await env.runCli(['serve', '--detach']);
+    expect(code).toBe(0);
+
+    const pidPath = env.getClawminiPath('supervisor.pid');
+    const socketPath = env.getClawminiPath('daemon.sock');
+    expect(await waitUntil(() => fs.existsSync(pidPath), 5000)).toBe(true);
+    expect(await waitUntil(() => fs.existsSync(socketPath), 10000)).toBe(true);
+
+    const supervisorPidBefore = readPid(pidPath);
+    expect(supervisorPidBefore).toMatch(/^\d+$/);
+
+    await env.sendMessage('/restart', { noWait: true });
+
+    // The supervisor's pid file is preserved across a daemon-only restart.
+    // The daemon socket disappears (old daemon dies) and reappears (new
+    // daemon binds). Watch for the disappearance + reappearance to confirm
+    // we actually restarted, then check the post-restart reply landed.
+    const chatLog = env.getChatPath('default', 'chat.jsonl');
+    const expectedVersion = readPackageVersion();
+
+    const sawPostRestart = await waitUntil(() => {
+      const lines = readChatLog(chatLog);
+      return lines.some(
+        (l) =>
+          l.role === 'system' &&
+          typeof l.content === 'string' &&
+          l.content === `Clawmini restarted (v${expectedVersion}).`
+      );
+    }, 45000);
+    expect(sawPostRestart).toBe(true);
+
+    // Pre-restart ack should also be present.
+    const lines = readChatLog(chatLog);
+    expect(
+      lines.some(
+        (l) => typeof l.content === 'string' && l.content.includes('Restarting clawmini...')
+      )
+    ).toBe(true);
+
+    // Supervisor pid must be unchanged — only the child processes (daemon
+    // plus any adapters) were bounced.
+    expect(fs.existsSync(pidPath)).toBe(true);
+    expect(readPid(pidPath)).toBe(supervisorPidBefore);
+
+    // Daemon socket should be live again.
+    expect(fs.existsSync(socketPath)).toBe(true);
+
+    // Pending replies file must be drained.
+    const pendingPath = env.getClawminiPath('pending-replies.json');
+    expect(fs.existsSync(pendingPath)).toBe(false);
+  }, 90000);
+});

package/e2e/routers/slash-shutdown.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import fs from 'node:fs';
+import { TestEnvironment } from '../_helpers/test-environment.js';
+
+async function waitUntil(
+  cond: () => boolean,
+  timeoutMs: number,
+  intervalMs = 100
+): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (cond()) return true;
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  return cond();
+}
+
+describe('/shutdown router e2e', () => {
+  let env: TestEnvironment;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-slash-shutdown');
+    await env.setup();
+    await env.init();
+  }, 30000);
+
+  afterAll(async () => {
+    await env.teardown();
+  }, 30000);
+
+  it('tears down the supervisor when /shutdown is sent', async () => {
+    const { code } = await env.runCli(['serve', '--detach']);
+    expect(code).toBe(0);
+
+    const pidPath = env.getClawminiPath('supervisor.pid');
+    const socketPath = env.getClawminiPath('daemon.sock');
+    const controlPath = env.getClawminiPath('super.sock');
+    expect(await waitUntil(() => fs.existsSync(pidPath), 5000)).toBe(true);
+    expect(await waitUntil(() => fs.existsSync(socketPath), 10000)).toBe(true);
+    expect(await waitUntil(() => fs.existsSync(controlPath), 10000)).toBe(true);
+
+    await env.sendMessage('/shutdown', { noWait: true });
+
+    // The supervisor exits asynchronously after ack — wait for it to clean up.
+    expect(await waitUntil(() => !fs.existsSync(pidPath), 30000)).toBe(true);
+    expect(await waitUntil(() => !fs.existsSync(socketPath), 30000)).toBe(true);
+    expect(await waitUntil(() => !fs.existsSync(controlPath), 30000)).toBe(true);
+
+    // The synthetic ack should have been recorded in the chat log before the
+    // daemon went away.
+    const chatLog = env.getChatPath('default', 'chat.jsonl');
+    const content = fs.readFileSync(chatLog, 'utf-8');
+    expect(content).toContain('Shutting down clawmini supervisor');
+  }, 60000);
+});

package/e2e/routers/slash-stop.test.ts

@@ -0,0 +1,232 @@
+import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import {
+  TestEnvironment,
+  type ChatSubscription,
+  commandWith,
+} from '../_helpers/test-environment.js';
+
+function pidIsAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Polls for a PID file written by the spawned shell. Returns the PID once
+// the file exists and contains a valid integer (avoids a flush race between
+// `echo $$ > pid` and our read).
+async function waitForPidFile(filePath: string, timeoutMs: number): Promise<number> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (fs.existsSync(filePath)) {
+      const content = fs.readFileSync(filePath, 'utf8').trim();
+      if (/^\d+$/.test(content)) return parseInt(content, 10);
+    }
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  throw new Error(`Timed out waiting for pid file ${filePath}`);
+}
+
+describe('/stop Router E2E', () => {
+  let env: TestEnvironment;
+  let chat: ChatSubscription | undefined;
+  const tmpDirs: string[] = [];
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-slash-stop');
+    await env.setup();
+    await env.setupSubagentEnv();
+  }, 30000);
+
+  afterAll(async () => {
+    for (const dir of tmpDirs) {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+    await env.teardown();
+  }, 30000);
+  afterEach(() => env.disconnectAll());
+
+  function makeTmp(label: string): string {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), `claw-stop-${label}-`));
+    tmpDirs.push(dir);
+    return dir;
+  }
+
+  it('aborts the in-flight task and suppresses its command log', async () => {
+    await env.runCli(['agents', 'add', 'stop-agent']);
+    // Output lands only after the sleep, so if /stop aborts correctly, DONE
+    // must never appear in the chat.
+    env.writeAgentSettings('stop-agent', {
+      commands: { new: 'sleep 3 && echo DONE' },
+    });
+
+    await env.addChat('stop-chat', 'stop-agent');
+    chat = await env.connect('stop-chat');
+
+    await env.sendMessage('long', { chat: 'stop-chat', noWait: true });
+    // Give the scheduler a moment to dispatch into runCommand/spawn.
+    await new Promise((r) => setTimeout(r, 500));
+
+    await env.sendMessage('/stop', { chat: 'stop-chat', noWait: true });
+
+    // The slash-stop router replies with this synthetic message before aborting.
+    await chat.waitForMessage(
+      (m) => typeof m.content === 'string' && m.content.includes('Stopping current task...'),
+      5000
+    );
+
+    // Wait past the original sleep window so any surviving task would have
+    // produced output by now.
+    await new Promise((r) => setTimeout(r, 3500));
+    const leaked = chat.messageBuffer.some(commandWith('DONE'));
+    expect(leaked).toBe(false);
+  }, 20000);
+
+  it('leaves the session usable for subsequent messages', async () => {
+    await env.runCli(['agents', 'add', 'stop-recovery-agent']);
+    env.writeAgentSettings('stop-recovery-agent', {
+      commands: { new: 'sleep 3 && echo DONE' },
+    });
+
+    await env.addChat('stop-recovery-chat', 'stop-recovery-agent');
+    chat = await env.connect('stop-recovery-chat');
+
+    await env.sendMessage('long', { chat: 'stop-recovery-chat', noWait: true });
+    await new Promise((r) => setTimeout(r, 500));
+    await env.sendMessage('/stop', { chat: 'stop-recovery-chat', noWait: true });
+    await chat.waitForMessage(
+      (m) => typeof m.content === 'string' && m.content.includes('Stopping current task...'),
+      5000
+    );
+
+    // Swap in a fast-returning command so the follow-up test completes quickly.
+    env.writeAgentSettings('stop-recovery-agent', {
+      commands: { new: 'echo RECOVERED' },
+    });
+
+    await env.sendMessage('after', { chat: 'stop-recovery-chat' });
+    const ok = await chat.waitForMessage(commandWith('RECOVERED'), 10000);
+    expect(ok.exitCode).toBe(0);
+  }, 25000);
+
+  // The subagent tests below use file-based markers (a pid file written
+  // before sleep, a leak file touched after sleep) instead of relying on
+  // chat-buffer absence. This addresses three weak signals in the older
+  // version of this test:
+  //   1. Subagent might never have started — a no-op spawn would pass
+  //      trivially. waitForPidFile asserts the subagent actually ran.
+  //   2. Output suppression for unrelated reasons could mask a live
+  //      subagent — the leak file is written by the OS regardless of
+  //      whether output is plumbed back to the chat.
+  //   3. A 500ms dispatch + 3.5s wait for a 3s sleep gives only ~500ms
+  //      margin under load. The 5s sleep + 8s wait gives 3s of slack and
+  //      uses a pid-file gate instead of a fixed pre-/stop sleep.
+  // pidIsAlive is a corroborating signal — kernels reap killed shells fast
+  // enough that within 8s `process.kill(pid, 0)` reliably throws ESRCH.
+
+  it('aborts an active async subagent: process dies and leak marker is never written', async () => {
+    const tmp = makeTmp('async');
+    await env.addChat('stop-sub-async', 'debug-agent');
+    chat = await env.connect('stop-sub-async');
+
+    const cmd = `echo $$ > ${tmp}/pid && sleep 5 && touch ${tmp}/leaked`;
+    await env.sendMessage(`clawmini-lite.js subagents spawn --async '${cmd}'`, {
+      chat: 'stop-sub-async',
+      agent: 'debug-agent',
+    });
+
+    const pid = await waitForPidFile(path.join(tmp, 'pid'), 10000);
+    expect(pidIsAlive(pid)).toBe(true);
+
+    await env.sendMessage('/stop', { chat: 'stop-sub-async', noWait: true });
+    await chat.waitForMessage(
+      (m) => typeof m.content === 'string' && m.content.includes('Stopping current task...'),
+      5000
+    );
+
+    await new Promise((r) => setTimeout(r, 8000));
+    expect(fs.existsSync(path.join(tmp, 'leaked'))).toBe(false);
+    expect(pidIsAlive(pid)).toBe(false);
+  }, 30000);
+
+  it('aborts an active sync subagent and leaves the parent session usable', async () => {
+    const tmp = makeTmp('sync');
+    await env.addChat('stop-sub-sync', 'debug-agent');
+    chat = await env.connect('stop-sub-sync');
+
+    // No --async flag: the parent's lite invocation blocks on subagentWait,
+    // so use noWait on sendMessage to avoid blocking the test runner too.
+    const cmd = `echo $$ > ${tmp}/pid && sleep 5 && touch ${tmp}/leaked`;
+    await env.sendMessage(`clawmini-lite.js subagents spawn '${cmd}'`, {
+      chat: 'stop-sub-sync',
+      agent: 'debug-agent',
+      noWait: true,
+    });
+
+    const pid = await waitForPidFile(path.join(tmp, 'pid'), 10000);
+    expect(pidIsAlive(pid)).toBe(true);
+
+    await env.sendMessage('/stop', { chat: 'stop-sub-sync', noWait: true });
+    await chat.waitForMessage(
+      (m) => typeof m.content === 'string' && m.content.includes('Stopping current task...'),
+      5000
+    );
+
+    await new Promise((r) => setTimeout(r, 8000));
+    expect(fs.existsSync(path.join(tmp, 'leaked'))).toBe(false);
+    expect(pidIsAlive(pid)).toBe(false);
+
+    // Recovery: a sync spawn can wedge the parent if /stop fails to unblock
+    // the parent's subagentWait poll. A follow-up message proves it didn't.
+    await env.sendMessage('echo RECOVERED_SYNC', {
+      chat: 'stop-sub-sync',
+      agent: 'debug-agent',
+    });
+    const ok = await chat.waitForMessage(commandWith('RECOVERED_SYNC'), 10000);
+    expect(ok.exitCode).toBe(0);
+  }, 30000);
+
+  it('aborts nested subagents at depth 2: both layers die and neither leaks', async () => {
+    const tmp = makeTmp('nested');
+    await env.addChat('stop-sub-nested', 'debug-agent');
+    chat = await env.connect('stop-sub-nested');
+
+    // Quoting note: this command is re-eval'd at three levels (parent
+    // shell, subagent A's shell, subagent B's shell). The inner `\$\$`
+    // survives the parent's outer single quotes literally, then loses one
+    // backslash inside subagent A's double-quoted invocation of lite, so
+    // subagent B finally sees a bare `$$` that expands to its own PID.
+    const inner = `echo \\$\\$ > ${tmp}/B.pid && sleep 5 && touch ${tmp}/B.leaked`;
+    const outer =
+      `echo $$ > ${tmp}/A.pid && ` +
+      `clawmini-lite.js subagents spawn --async "${inner}" && ` +
+      `sleep 5 && touch ${tmp}/A.leaked`;
+
+    await env.sendMessage(`clawmini-lite.js subagents spawn --async '${outer}'`, {
+      chat: 'stop-sub-nested',
+      agent: 'debug-agent',
+    });
+
+    const aPid = await waitForPidFile(path.join(tmp, 'A.pid'), 15000);
+    const bPid = await waitForPidFile(path.join(tmp, 'B.pid'), 15000);
+    expect(pidIsAlive(aPid)).toBe(true);
+    expect(pidIsAlive(bPid)).toBe(true);
+
+    await env.sendMessage('/stop', { chat: 'stop-sub-nested', noWait: true });
+    await chat.waitForMessage(
+      (m) => typeof m.content === 'string' && m.content.includes('Stopping current task...'),
+      5000
+    );
+
+    await new Promise((r) => setTimeout(r, 8000));
+    expect(fs.existsSync(path.join(tmp, 'A.leaked'))).toBe(false);
+    expect(fs.existsSync(path.join(tmp, 'B.leaked'))).toBe(false);
+    expect(pidIsAlive(aPid)).toBe(false);
+    expect(pidIsAlive(bPid)).toBe(false);
+  }, 40000);
+});

package/e2e/routers/slash-upgrade.test.ts

@@ -0,0 +1,88 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import fs from 'node:fs';
+import { TestEnvironment } from '../_helpers/test-environment.js';
+
+async function waitUntil(
+  cond: () => boolean,
+  timeoutMs: number,
+  intervalMs = 100
+): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (cond()) return true;
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  return cond();
+}
+
+interface LogLine {
+  role?: string;
+  content?: string;
+}
+
+function readChatLog(filePath: string): LogLine[] {
+  if (!fs.existsSync(filePath)) return [];
+  return fs
+    .readFileSync(filePath, 'utf-8')
+    .split('\n')
+    .filter((line) => line.trim().length > 0)
+    .map((line) => {
+      try {
+        return JSON.parse(line) as LogLine;
+      } catch {
+        return {};
+      }
+    });
+}
+
+describe('/upgrade router e2e (dev checkout path)', () => {
+  let env: TestEnvironment;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-slash-upgrade');
+    await env.setup();
+    await env.init();
+  }, 30000);
+
+  afterAll(async () => {
+    await env.teardown();
+  }, 30000);
+
+  // We deliberately don't exercise the actual `npm install -g` path in e2e —
+  // it would mutate the host's globally installed clawmini. Instead we verify
+  // the safety branch: when the running binary is *not* under `npm root -g`
+  // (which is always true in the e2e harness, since dist/cli/index.mjs lives
+  // in the repo), /upgrade must reply with a refusal and leave the
+  // supervisor running.
+  it('refuses the upgrade and keeps the supervisor running when not installed via npm', async () => {
+    const { code } = await env.runCli(['serve', '--detach']);
+    expect(code).toBe(0);
+
+    const pidPath = env.getClawminiPath('supervisor.pid');
+    const socketPath = env.getClawminiPath('daemon.sock');
+    expect(await waitUntil(() => fs.existsSync(pidPath), 5000)).toBe(true);
+    expect(await waitUntil(() => fs.existsSync(socketPath), 10000)).toBe(true);
+
+    await env.sendMessage('/upgrade', { noWait: true });
+
+    const chatLog = env.getChatPath('default', 'chat.jsonl');
+    const sawRefusal = await waitUntil(() => {
+      const lines = readChatLog(chatLog);
+      return lines.some(
+        (l) =>
+          typeof l.content === 'string' &&
+          l.content.includes('Cannot upgrade') &&
+          l.content.includes('not installed via')
+      );
+    }, 15000);
+    expect(sawRefusal).toBe(true);
+
+    // Supervisor and daemon must both still be alive.
+    expect(fs.existsSync(pidPath)).toBe(true);
+    expect(fs.existsSync(socketPath)).toBe(true);
+
+    // No pending reply was queued for an upgrade that never happened.
+    const pendingPath = env.getClawminiPath('pending-replies.json');
+    expect(fs.existsSync(pendingPath)).toBe(false);
+  }, 30000);
+});

package/{src/cli/e2e → e2e/sandbox}/environments.test.ts

@@ -1,25 +1,26 @@
 import { describe, it, expect, beforeAll, afterAll } from 'vitest';
 import path from 'node:path';
 import fs from 'node:fs';
-import { createE2EContext } from './utils.js';
+import { TestEnvironment } from '../_helpers/test-environment.js';
 
 describe('Environments E2E', () => {
-  const { runCli, e2eDir, setupE2E, teardownE2E } = createE2EContext('e2e-env');
+  let env: TestEnvironment;
 
   beforeAll(async () => {
-    await setupE2E();
-    await runCli(['init']);
+    env = new TestEnvironment('e2e-env');
+    await env.setup();
+    await env.init();
   }, 30000);
 
-  afterAll(teardownE2E, 30000);
+  afterAll(() => env.teardown(), 30000);
 
   it('should run environment up and down commands on daemon start and stop', async () => {
     // Create an environment with up and down commands
-    const envDir = path.join(e2eDir, '.clawmini', 'environments', 'test-env');
+    const envDir = path.join(env.e2eDir, '.clawmini', 'environments', 'test-env');
     fs.mkdirSync(envDir, { recursive: true });
 
-    const upHookPath = path.join(e2eDir, 'up-hook-run.txt');
-    const downHookPath = path.join(e2eDir, 'down-hook-run.txt');
+    const upHookPath = path.join(env.e2eDir, 'up-hook-run.txt');
+    const downHookPath = path.join(env.e2eDir, 'down-hook-run.txt');
 
     fs.writeFileSync(
       path.join(envDir, 'env.json'),
@@ -30,10 +31,10 @@ describe('Environments E2E', () => {
     );
 
     // Enable the environment
-    await runCli(['environments', 'enable', 'test-env']);
+    await env.runCli(['environments', 'enable', 'test-env']);
 
     // Start the daemon (should trigger up hook)
-    const { stdout: upStdout, code: upCode } = await runCli(['up']);
+    const { stdout: upStdout, code: upCode } = await env.runCli(['up']);
     expect(upCode).toBe(0);
     expect(upStdout).toMatch(
       /(Daemon is already running\.|Successfully started clawmini daemon\.)/
@@ -44,7 +45,7 @@ describe('Environments E2E', () => {
 
     // The daemon might have already been running since beforeAll init might start it.
     // So let's actually shut it down, then start it to be sure.
-    await runCli(['down']);
+    await env.runCli(['down']);
     await new Promise((resolve) => setTimeout(resolve, 1000));
 
     // Clear out files if they exist
@@ -52,13 +53,13 @@ describe('Environments E2E', () => {
     if (fs.existsSync(downHookPath)) fs.unlinkSync(downHookPath);
 
     // Start daemon
-    await runCli(['up']);
+    await env.runCli(['up']);
     await new Promise((resolve) => setTimeout(resolve, 1000));
     expect(fs.existsSync(upHookPath)).toBe(true);
     expect(fs.readFileSync(upHookPath, 'utf8').trim()).toBe('env-up');
 
     // Stop daemon
-    await runCli(['down']);
+    await env.runCli(['down']);
     await new Promise((resolve) => setTimeout(resolve, 1000));
     expect(fs.existsSync(downHookPath)).toBe(true);
     expect(fs.readFileSync(downHookPath, 'utf8').trim()).toBe('env-down');

package/eslint.config.js

@@ -55,5 +55,11 @@ export default defineConfig([
       'no-restricted-syntax': 'off',
     },
   },
+  {
+    files: ['templates/environments/**/*.{js,mjs,cjs}'],
+    languageOptions: {
+      globals: globals.node,
+    },
+  },
   eslintConfigPrettier,
 ]);

package/napkin.md

@@ -18,7 +18,7 @@
 - **shadcn-svelte commands:** Always use the `-y` flag when adding a component (e.g., `npx shadcn-svelte@latest add -y <component>`) to bypass the interactive prompt.\n- **Svelte Check:** Always run `npm run check -w web` instead of `npx svelte-check` to run Svelte diagnostics.
 - Added shadcn-svelte dialog for chat creation and replaced native window.prompt.
 - **E2E and Unit Test File Splitting:** When splitting `.test.ts` files, remember that `vi.mock()` must be at the top level of the file where the module is imported. Moving it to a shared setup utility will break mocking in Vitest.\nAlso, when splitting tests that share an environment setup (like E2E tests building dist), ensure tests run sequentially using `fileParallelism: false` in `vitest.config.ts` to prevent race conditions on shared global processes.
-- **E2E Tests Performance Optimization:** To make E2E tests run faster, moved the `npm run build` command out of the repeated E2E file setup and into a Vitest `globalSetup` hook (`src/cli/e2e/global-setup.ts`). Restored `fileParallelism: true` to `vitest.config.ts`, so test files run concurrently in workers while sharing a single initial build output. This dropped test suite execution time from ~50s down to ~18s.
+- **E2E Tests Performance Optimization:** To make E2E tests run faster, moved the `npm run build` command out of the repeated E2E file setup and into a Vitest `globalSetup` hook (`e2e/_helpers/global-setup.ts`). Restored `fileParallelism: true` to `vitest.config.ts`, so test files run concurrently in workers while sharing a single initial build output. This dropped test suite execution time from ~50s down to ~18s.
 - **TypeScript `noUncheckedIndexedAccess` with string chunking:** When accessing an element of a string array like `chunks[i]`, TypeScript with `noUncheckedIndexedAccess` enabled will infer the type as `string | undefined`. If you know the index is safe (like inside a traditional `for` loop `for (let i = 0; i < chunks.length; i++)`), explicitly cast it using `as string` (e.g., `chunks[i] as string`) when passing it to strict API objects.
 - **Fixing CI missing optional dependencies (e.g. `@rollup/rollup-linux-x64-gnu`)**: If GitHub Actions on Linux fails during `npm ci` because an optional dependency for Linux x64 is missing from `package-lock.json` (often created on macOS), run `rm -rf package-lock.json node_modules web/node_modules && npm install` to regenerate the lockfile with cross-platform optional dependencies included.
 - **When mocking state modules like state.js**, ensure `vi.mock('./state.js', ...)` is at the top level and includes the correct return shapes so subsequent tests relying on default properties (like `channelChatMap`) don't fail.