@celilo/e2e 0.10.2 → 0.10.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celilo/e2e",
-  "version": "0.10.2",
+  "version": "0.10.3",
   "description": "E2E test infrastructure for Celilo-deployed applications. Provides a simulated internet with DNS hierarchy, ACME server, firewalls, and target machines in Docker.",
   "type": "module",
   "main": "./src/index.ts",

package/simulators/signal-cli/server.ts

@@ -113,6 +113,14 @@ function handleSend(id: unknown, params: Record<string, unknown>): Response {
   if (recipients.length === 0) return rpcError(id, -32602, 'No recipient given');
 
   for (const recipient of recipients) {
+    // The linked account is ALWAYS a valid recipient: messaging yourself is
+    // note-to-self, a first-class Signal feature and the default
+    // single-operator setup (design R2) — the route points at the very number
+    // the transport is a secondary device of. Rejecting it as "unregistered"
+    // is something no real daemon does, and it made the note-to-self ack path
+    // untestable end to end: the page could not be sent, so no token ever
+    // reached the operator to reply with.
+    if (recipient === ACCOUNT) continue;
     // Push back like Signal: an unregistered number is a hard failure, not a
     // silent no-op.
     if (KNOWN_RECIPIENTS.size > 0 && !KNOWN_RECIPIENTS.has(recipient)) {

package/src/container-manager.ts

@@ -75,6 +75,56 @@ const activeProjects: Set<string> = new Set();
  * MUST stay fully synchronous: it runs from an `exit` handler, where the
  * event loop is already closed and any async work is silently dropped.
  */
+/**
+ * The commands that remove a per-test project WITHOUT needing its compose file.
+ * Pure (Rule 10.1) so the no-compose-dependency property is testable.
+ *
+ * `docker compose -p <project> down` — what this used to run — resolves the
+ * project from a compose file in the CURRENT DIRECTORY. An exit handler has no
+ * reliable cwd, so compose exited "no configuration file provided", the error
+ * was swallowed by the surrounding catch, and nothing was removed. The handler
+ * fired correctly and tore down nothing.
+ *
+ * Removing by name needs only the project name, which we already have.
+ * Per-test projects are `celilo-e2e-<timestamp>`; the shared project is
+ * `celilo-e2e-shared`, which contains no timestamp and so is never matched —
+ * shared infra stays up, as it must.
+ */
+export function projectTeardownCommands(project: string): {
+  listContainers: string;
+  listNetworks: string;
+} {
+  return {
+    listContainers: `docker ps -aq --filter name=${project}`,
+    listNetworks: `docker network ls --format {{.Name}} --filter name=${project}`,
+  };
+}
+
+/** Force-remove a project's containers and networks by name. Never throws. */
+function forceRemoveProject(project: string): void {
+  const cmds = projectTeardownCommands(project);
+  try {
+    const ids = execSync(cmds.listContainers, { timeout: 15_000, stdio: 'pipe' })
+      .toString()
+      .split('\n')
+      .filter(Boolean);
+    if (ids.length > 0) {
+      execSync(`docker rm -f ${ids.join(' ')}`, { timeout: 30_000, stdio: 'pipe' });
+    }
+  } catch {}
+  try {
+    const nets = execSync(cmds.listNetworks, { timeout: 15_000, stdio: 'pipe' })
+      .toString()
+      .split('\n')
+      .filter(Boolean);
+    for (const net of nets) {
+      try {
+        execSync(`docker network rm ${net}`, { timeout: 10_000, stdio: 'pipe' });
+      } catch {}
+    }
+  } catch {}
+}
+
 function cleanupOnExit() {
   // `--keep` / `--reuse` mean the operator wants the stack to survive for
   // debugging — and they want it MOST after a failure, which is exactly the
@@ -82,12 +132,17 @@ function cleanupOnExit() {
   if (process.env.CELILO_E2E_KEEP === '1' || process.env.CELILO_E2E_REUSE === '1') return;
 
   for (const project of activeProjects) {
+    // Compose first when it can work — it also drops volumes and orphans — but
+    // it is best-effort, so never rely on it having done anything.
     try {
-      execSync(`docker compose -p ${project} down --volumes --remove-orphans`, {
+      execSync(`docker compose -f ${COMPOSE_FILE} -p ${project} down --volumes --remove-orphans`, {
+        cwd: PACKAGE_ROOT,
         timeout: 30_000,
         stdio: 'pipe',
       });
     } catch {}
+    // Authoritative: needs no compose file, no cwd, no working directory state.
+    forceRemoveProject(project);
   }
   activeProjects.clear();
   try {

package/src/exit-cleanup.test.ts

@@ -15,6 +15,7 @@ import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { expect, test } from 'bun:test';
+import { projectTeardownCommands } from './container-manager';
 
 const SRC = readFileSync(
   join(dirname(fileURLToPath(import.meta.url)), 'container-manager.ts'),
@@ -39,6 +40,31 @@ test('cleanup honors --keep / --reuse so a failed run stays debuggable', () => {
   expect(body).toContain('CELILO_E2E_REUSE');
 });
 
+// The first version of this fix wired the handler correctly and still leaked,
+// because the teardown it ran was `docker compose -p <project> down` with no
+// `-f` and no cwd. Compose resolves the project from a compose file in the
+// CURRENT DIRECTORY; an exit handler has no reliable cwd, so it exited "no
+// configuration file provided", the surrounding catch swallowed it, and nothing
+// was removed. Asserting the hook exists was not enough — assert it can work.
+test('teardown does not depend on a compose file being findable', () => {
+  const cmds = projectTeardownCommands('celilo-e2e-1785546029645');
+  for (const cmd of Object.values(cmds)) {
+    expect(cmd).not.toContain('docker compose');
+    expect(cmd).toContain('celilo-e2e-1785546029645');
+  }
+});
+
+test('teardown cannot match the shared project', () => {
+  // Per-test projects carry a timestamp; `celilo-e2e-shared` does not, so a
+  // name filter for one can never match the other. Shared infra must survive —
+  // it is torn down separately, and removing it mid-suite breaks every
+  // subsequent test.
+  const cmds = projectTeardownCommands('celilo-e2e-1785546029645');
+  for (const cmd of Object.values(cmds)) {
+    expect(cmd).not.toContain('celilo-e2e-shared');
+  }
+});
+
 test("the premise holds: process.exit() fires 'exit' but NOT 'beforeExit'", async () => {
   // The whole fix rests on this runtime behavior. If it ever changes, the
   // reasoning above is void and this should fail loudly rather than silently