@wangyaoshen/remux 0.3.8-dev.a8ceb0c

package/tests/message-routing.test.js

@@ -0,0 +1,305 @@
+/**
+ * Tests that verify WebSocket message routing never leaks control-plane
+ * JSON into terminal PTY output, and that workspace CRUD operations
+ * produce visible results through the correct message flow.
+ *
+ * Red-line tests:
+ * 1. Server: JSON control messages must never reach pty.write()
+ * 2. Client: enveloped (v:1) messages must never reach term.write()
+ * 3. Client: known control-type JSON from scrollback must be stripped
+ * 4. Store: createNote/listNotes round-trip returns the created note
+ * 5. Store: createTopic/listTopics round-trip returns the created topic
+ * 6. Inspect: ANSI cleanup removes ^L (form-feed) character
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import Database from "better-sqlite3";
+import {
+  _resetDbForTest,
+  closeDb,
+  createNote,
+  listNotes,
+  createTopic,
+  listTopics,
+  listDevices,
+  createDevice,
+} from "../src/store.ts";
+
+/** Create an in-memory SQLite DB with the full schema. */
+function createTestDb() {
+  const db = new Database(":memory:");
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (name TEXT PRIMARY KEY, created_at INTEGER NOT NULL);
+    CREATE TABLE IF NOT EXISTS tabs (
+      id INTEGER PRIMARY KEY, session_name TEXT NOT NULL, title TEXT NOT NULL DEFAULT 'Tab',
+      scrollback BLOB, ended INTEGER NOT NULL DEFAULT 0,
+      FOREIGN KEY (session_name) REFERENCES sessions(name) ON DELETE CASCADE
+    );
+    CREATE TABLE IF NOT EXISTS devices (
+      id TEXT PRIMARY KEY, name TEXT NOT NULL, fingerprint TEXT NOT NULL,
+      trust TEXT NOT NULL DEFAULT 'untrusted', created_at INTEGER NOT NULL, last_seen INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS pair_codes (
+      code TEXT PRIMARY KEY, created_by TEXT NOT NULL, expires_at INTEGER NOT NULL,
+      FOREIGN KEY (created_by) REFERENCES devices(id) ON DELETE CASCADE
+    );
+    CREATE TABLE IF NOT EXISTS settings (key TEXT PRIMARY KEY, value TEXT);
+    CREATE TABLE IF NOT EXISTS push_subscriptions (
+      device_id TEXT PRIMARY KEY, endpoint TEXT NOT NULL, p256dh TEXT NOT NULL,
+      auth TEXT NOT NULL, created_at INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS topics (
+      id TEXT PRIMARY KEY, session_name TEXT NOT NULL, title TEXT NOT NULL,
+      created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS runs (
+      id TEXT PRIMARY KEY, topic_id TEXT REFERENCES topics(id), session_name TEXT NOT NULL,
+      tab_id INTEGER, command TEXT, exit_code INTEGER, started_at INTEGER NOT NULL,
+      ended_at INTEGER, status TEXT DEFAULT 'running'
+    );
+    CREATE TABLE IF NOT EXISTS artifacts (
+      id TEXT PRIMARY KEY, run_id TEXT REFERENCES runs(id), topic_id TEXT REFERENCES topics(id),
+      session_name TEXT, type TEXT NOT NULL, title TEXT, content TEXT, created_at INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS approvals (
+      id TEXT PRIMARY KEY, run_id TEXT REFERENCES runs(id), topic_id TEXT REFERENCES topics(id),
+      title TEXT NOT NULL, description TEXT, status TEXT DEFAULT 'pending',
+      created_at INTEGER NOT NULL, resolved_at INTEGER
+    );
+    CREATE VIRTUAL TABLE IF NOT EXISTS fts_index USING fts5(
+      entity_type, entity_id, title, content, tokenize='porter unicode61'
+    );
+    CREATE TABLE IF NOT EXISTS memory_notes (
+      id TEXT PRIMARY KEY, content TEXT NOT NULL, pinned INTEGER DEFAULT 0,
+      created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL, session_name TEXT
+    );
+    CREATE TABLE IF NOT EXISTS commands (
+      id TEXT PRIMARY KEY, session_name TEXT NOT NULL, tab_id INTEGER NOT NULL,
+      command TEXT, exit_code INTEGER, cwd TEXT, started_at INTEGER NOT NULL, ended_at INTEGER
+    );
+  `);
+  return db;
+}
+
+// ── RED LINE 1: Notes CRUD round-trip ──────────────────────────────
+
+describe("workspace notes: create and list round-trip", () => {
+  let db;
+  beforeEach(() => { db = createTestDb(); _resetDbForTest(db); });
+  afterEach(() => { closeDb(); });
+
+  it("createNote returns a note and listNotes returns it", () => {
+    const note = createNote("test note content");
+    expect(note).toBeDefined();
+    expect(note.id).toBeTruthy();
+    expect(note.content).toBe("test note content");
+    expect(note.pinned).toBe(false);
+
+    const notes = listNotes();
+    expect(notes.length).toBe(1);
+    expect(notes[0].id).toBe(note.id);
+    expect(notes[0].content).toBe("test note content");
+  });
+
+  it("multiple notes are listed and all present", () => {
+    createNote("first");
+    createNote("second");
+    createNote("third");
+
+    const notes = listNotes();
+    expect(notes.length).toBe(3);
+    const contents = notes.map(n => n.content);
+    expect(contents).toContain("first");
+    expect(contents).toContain("second");
+    expect(contents).toContain("third");
+  });
+});
+
+// ── RED LINE 2: Topics CRUD round-trip ─────────────────────────────
+
+describe("workspace topics: create and list round-trip", () => {
+  let db;
+  beforeEach(() => { db = createTestDb(); _resetDbForTest(db); });
+  afterEach(() => { closeDb(); });
+
+  it("createTopic returns a topic and listTopics returns it", () => {
+    const topic = createTopic("test-session", "Test Topic");
+    expect(topic).toBeDefined();
+    expect(topic.id).toBeTruthy();
+    expect(topic.title).toBe("Test Topic");
+
+    const topics = listTopics("test-session");
+    expect(topics.length).toBe(1);
+    expect(topics[0].id).toBe(topic.id);
+    expect(topics[0].title).toBe("Test Topic");
+  });
+});
+
+// ── RED LINE 3: Devices CRUD round-trip ────────────────────────────
+
+describe("devices: create and list round-trip", () => {
+  let db;
+  beforeEach(() => { db = createTestDb(); _resetDbForTest(db); });
+  afterEach(() => { closeDb(); });
+
+  it("createDevice and listDevices round-trip", () => {
+    // createDevice(fingerprint, trust, name)
+    const device = createDevice("fp-abc123", "trusted", "Test Device");
+    expect(device).toBeDefined();
+    expect(device.name).toBe("Test Device");
+
+    const devices = listDevices();
+    expect(devices.length).toBe(1);
+    expect(devices[0].name).toBe("Test Device");
+    expect(devices[0].trust).toBe("trusted");
+  });
+});
+
+// ── RED LINE 4: ANSI cleanup strips form-feed ──────────────────────
+
+describe("inspect ANSI cleanup", () => {
+  it("form-feed character (0x0c) is stripped from inspect output", () => {
+    // Simulate the ANSI stripping regex from ws-handler inspect fallback
+    const rawText = "\x0cwangyaoshen@mac ~ % echo hello\nhello\nwangyaoshen@mac ~ % ";
+    const cleaned = rawText
+      .replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "")
+      .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "")
+      .replace(/\x1b[PX^_][^\x1b]*\x1b\\/g, "")
+      .replace(/\x1b[()][A-Z0-9]/g, "")
+      .replace(/\x1b[A-Z=><78]/gi, "")
+      .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, "")
+      .replace(/\x7f/g, "");
+
+    expect(cleaned).not.toContain("\x0c");
+    expect(cleaned).toContain("echo hello");
+    expect(cleaned).toContain("hello");
+  });
+});
+
+// ── RED LINE 5: Client message routing logic ───────────────────────
+
+describe("client-side message routing", () => {
+  // Simulate the client's ws.onmessage routing logic
+  function routeMessage(data) {
+    const result = { writtenToTerm: false, handled: false, warned: false };
+
+    if (typeof data === "string" && data[0] === "{") {
+      try {
+        const parsed = JSON.parse(data);
+        const msg = parsed.v === 1 ? { type: parsed.type, ...parsed.payload } : parsed;
+
+        if (msg.type === "ping") { result.handled = true; return result; }
+        if (msg.type === "state") { result.handled = true; return result; }
+        if (msg.type === "attached") { result.handled = true; return result; }
+        if (msg.type === "note_list") { result.handled = true; return result; }
+        if (msg.type === "topic_list") { result.handled = true; return result; }
+        if (msg.type === "device_list") { result.handled = true; return result; }
+        // ... other known types would go here ...
+
+        // Unrecognized enveloped message — block from terminal
+        if (parsed.v === 1) {
+          result.warned = true;
+          return result;
+        }
+        // Non-enveloped JSON — falls through to term.write (could be PTY output)
+      } catch {}
+    }
+
+    result.writtenToTerm = true;
+    return result;
+  }
+
+  it("enveloped ping is handled, not written to terminal", () => {
+    const r = routeMessage('{"v":1,"type":"ping","payload":{}}');
+    expect(r.handled).toBe(true);
+    expect(r.writtenToTerm).toBe(false);
+  });
+
+  it("enveloped note_list is handled, not written to terminal", () => {
+    const r = routeMessage('{"v":1,"type":"note_list","payload":{"notes":[]}}');
+    expect(r.handled).toBe(true);
+    expect(r.writtenToTerm).toBe(false);
+  });
+
+  it("unrecognized enveloped message is warned, not written to terminal", () => {
+    const r = routeMessage('{"v":1,"type":"unknown_future_type","payload":{}}');
+    expect(r.warned).toBe(true);
+    expect(r.writtenToTerm).toBe(false);
+  });
+
+  it("non-enveloped JSON (PTY echo) is written to terminal", () => {
+    // User ran: echo '{"type":"foo"}'
+    const r = routeMessage('{"type":"foo"}');
+    expect(r.writtenToTerm).toBe(true);
+  });
+
+  it("plain terminal text is written to terminal", () => {
+    const r = routeMessage("wangyaoshen@mac ~ % ");
+    expect(r.writtenToTerm).toBe(true);
+  });
+
+  it("non-enveloped control-type JSON from PTY scrollback is written to terminal (regression risk)", () => {
+    // This is the known issue: if PTY scrollback contains {"type":"list_devices"},
+    // it will be written to terminal because it's not enveloped (v:1).
+    // The CLIENT cannot distinguish this from legitimate PTY output like
+    // echo '{"type":"list_devices"}'. The fix must be SERVER-side (prevent
+    // control messages from ever reaching PTY).
+    const r = routeMessage('{"type":"list_devices"}');
+    expect(r.writtenToTerm).toBe(true); // Expected: falls through (non-enveloped)
+  });
+});
+
+// ── RED LINE 6: Server-side JSON routing never reaches PTY ─────────
+
+describe("server-side JSON routing", () => {
+  // Simulate the server's ws.on("message") routing logic
+  function routeServerMessage(msg) {
+    const result = { handledAsControl: false, writtenToPty: false };
+
+    if (msg.startsWith("{")) {
+      try {
+        JSON.parse(msg); // Parse to validate
+        // In real code: handlers for each type + return at line 991
+        result.handledAsControl = true;
+        return result; // The return at line 991 prevents PTY write
+      } catch {
+        // not valid JSON — fall through to PTY
+      }
+    }
+
+    // Raw terminal input → PTY
+    result.writtenToPty = true;
+    return result;
+  }
+
+  it("list_topics JSON is handled as control, not written to PTY", () => {
+    const r = routeServerMessage('{"type":"list_topics","sessionName":"main"}');
+    expect(r.handledAsControl).toBe(true);
+    expect(r.writtenToPty).toBe(false);
+  });
+
+  it("list_devices JSON is handled as control, not written to PTY", () => {
+    const r = routeServerMessage('{"type":"list_devices"}');
+    expect(r.handledAsControl).toBe(true);
+    expect(r.writtenToPty).toBe(false);
+  });
+
+  it("create_note JSON is handled as control, not written to PTY", () => {
+    const r = routeServerMessage('{"type":"create_note","content":"test"}');
+    expect(r.handledAsControl).toBe(true);
+    expect(r.writtenToPty).toBe(false);
+  });
+
+  it("plain text is written to PTY", () => {
+    const r = routeServerMessage("hello world");
+    expect(r.writtenToPty).toBe(true);
+    expect(r.handledAsControl).toBe(false);
+  });
+
+  it("invalid JSON starting with { falls through to PTY", () => {
+    const r = routeServerMessage("{not valid json");
+    expect(r.writtenToPty).toBe(true);
+  });
+});

package/tests/pty-daemon.test.js

@@ -0,0 +1,346 @@
+/**
+ * Tests for PTY daemon TLV protocol, frame codec, and daemon lifecycle.
+ */
+import { describe, it, expect, beforeAll, afterAll, afterEach } from "vitest";
+import { spawn } from "child_process";
+import net from "net";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const DAEMON_SCRIPT = path.join(__dirname, "..", "pty-daemon.js");
+
+// TLV tags (mirrored from pty-daemon.ts)
+const TAG_PTY_OUTPUT = 0x01;
+const TAG_CLIENT_INPUT = 0x02;
+const TAG_RESIZE = 0x03;
+const TAG_STATUS_REQ = 0x04;
+const TAG_STATUS_RES = 0x05;
+const TAG_SNAPSHOT_REQ = 0x06;
+const TAG_SNAPSHOT_RES = 0x07;
+const TAG_SHUTDOWN = 0xff;
+
+function encodeFrame(tag, payload) {
+  const data =
+    typeof payload === "string" ? Buffer.from(payload, "utf8") : payload;
+  const frame = Buffer.alloc(5 + data.length);
+  frame[0] = tag;
+  frame.writeUInt32BE(data.length, 1);
+  data.copy(frame, 5);
+  return frame;
+}
+
+function parseFrames(buf) {
+  const frames = [];
+  let offset = 0;
+  while (offset + 5 <= buf.length) {
+    const tag = buf[offset];
+    const length = buf.readUInt32BE(offset + 1);
+    if (offset + 5 + length > buf.length) break;
+    const payload = buf.subarray(offset + 5, offset + 5 + length);
+    frames.push({ tag, payload });
+    offset += 5 + length;
+  }
+  return frames;
+}
+
+function waitForSocket(socketPath, timeout = 5000) {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    const check = () => {
+      if (fs.existsSync(socketPath)) {
+        resolve();
+        return;
+      }
+      if (Date.now() - start > timeout) {
+        reject(new Error(`Socket ${socketPath} not created within ${timeout}ms`));
+        return;
+      }
+      setTimeout(check, 100);
+    };
+    check();
+  });
+}
+
+function connectToDaemon(socketPath) {
+  return new Promise((resolve, reject) => {
+    const client = net.createConnection(socketPath, () => resolve(client));
+    client.on("error", reject);
+  });
+}
+
+function collectFrames(client, timeout = 2000) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    const handler = (data) => chunks.push(data);
+    client.on("data", handler);
+    setTimeout(() => {
+      client.removeListener("data", handler);
+      const all = Buffer.concat(chunks);
+      resolve(parseFrames(all));
+    }, timeout);
+  });
+}
+
+function sendAndReceive(client, frame, timeout = 2000) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    const handler = (data) => chunks.push(data);
+    client.on("data", handler);
+    client.write(frame);
+    setTimeout(() => {
+      client.removeListener("data", handler);
+      const all = Buffer.concat(chunks);
+      resolve(parseFrames(all));
+    }, timeout);
+  });
+}
+
+describe("TLV Frame Codec", () => {
+  it("encodes and decodes a simple frame", () => {
+    const frame = encodeFrame(TAG_PTY_OUTPUT, "hello");
+    expect(frame.length).toBe(5 + 5); // 5 header + 5 payload
+    expect(frame[0]).toBe(TAG_PTY_OUTPUT);
+    expect(frame.readUInt32BE(1)).toBe(5);
+    expect(frame.subarray(5).toString()).toBe("hello");
+
+    const parsed = parseFrames(frame);
+    expect(parsed).toHaveLength(1);
+    expect(parsed[0].tag).toBe(TAG_PTY_OUTPUT);
+    expect(parsed[0].payload.toString()).toBe("hello");
+  });
+
+  it("encodes empty payload", () => {
+    const frame = encodeFrame(TAG_STATUS_REQ, Buffer.alloc(0));
+    expect(frame.length).toBe(5);
+    expect(frame.readUInt32BE(1)).toBe(0);
+  });
+
+  it("parses multiple frames in a single buffer", () => {
+    const f1 = encodeFrame(TAG_PTY_OUTPUT, "first");
+    const f2 = encodeFrame(TAG_CLIENT_INPUT, "second");
+    const combined = Buffer.concat([f1, f2]);
+    const parsed = parseFrames(combined);
+    expect(parsed).toHaveLength(2);
+    expect(parsed[0].tag).toBe(TAG_PTY_OUTPUT);
+    expect(parsed[1].tag).toBe(TAG_CLIENT_INPUT);
+    expect(parsed[1].payload.toString()).toBe("second");
+  });
+
+  it("handles incomplete frame gracefully", () => {
+    const frame = encodeFrame(TAG_PTY_OUTPUT, "hello");
+    // Truncate the frame
+    const partial = frame.subarray(0, 7);
+    const parsed = parseFrames(partial);
+    expect(parsed).toHaveLength(0);
+  });
+});
+
+describe("PTY Daemon Lifecycle", () => {
+  let daemon;
+  let socketPath;
+
+  beforeAll(() => {
+    socketPath = `/tmp/remux-test-daemon-${process.pid}-${Date.now()}.sock`;
+  });
+
+  afterEach(() => {
+    if (daemon && !daemon.killed) {
+      daemon.kill("SIGTERM");
+      daemon = null;
+    }
+    try {
+      fs.unlinkSync(socketPath);
+    } catch {}
+  });
+
+  it("starts daemon and accepts connection", async () => {
+    daemon = spawn(process.execPath, [
+      DAEMON_SCRIPT,
+      "--socket", socketPath,
+      "--shell", "/bin/sh",
+      "--cols", "80",
+      "--rows", "24",
+      "--cwd", "/tmp",
+      "--tab-id", "test-1",
+    ], { stdio: "pipe" });
+
+    await waitForSocket(socketPath);
+    const client = await connectToDaemon(socketPath);
+
+    // Send a command to provoke output
+    client.write(encodeFrame(TAG_CLIENT_INPUT, "echo DAEMON_ALIVE\n"));
+    const frames = await collectFrames(client, 2000);
+
+    // Should have received PTY output
+    const outputText = frames
+      .filter((f) => f.tag === TAG_PTY_OUTPUT)
+      .map((f) => f.payload.toString())
+      .join("");
+    expect(outputText).toContain("DAEMON_ALIVE");
+
+    client.end();
+  }, 10000);
+
+  it("responds to status request", async () => {
+    daemon = spawn(process.execPath, [
+      DAEMON_SCRIPT,
+      "--socket", socketPath,
+      "--shell", "/bin/sh",
+      "--cols", "100",
+      "--rows", "30",
+      "--cwd", "/tmp",
+      "--tab-id", "test-2",
+    ], { stdio: "pipe" });
+
+    await waitForSocket(socketPath);
+    const client = await connectToDaemon(socketPath);
+    // Wait for initial output
+    await new Promise((r) => setTimeout(r, 500));
+
+    const frames = await sendAndReceive(
+      client,
+      encodeFrame(TAG_STATUS_REQ, Buffer.alloc(0)),
+      1500,
+    );
+
+    const statusFrame = frames.find((f) => f.tag === TAG_STATUS_RES);
+    expect(statusFrame).toBeDefined();
+
+    const status = JSON.parse(statusFrame.payload.toString());
+    expect(status.alive).toBe(true);
+    expect(status.tabId).toBe("test-2");
+    expect(typeof status.pid).toBe("number");
+    expect(status.pid).toBeGreaterThan(0);
+
+    client.end();
+  }, 10000);
+
+  it("forwards input to PTY and receives output", async () => {
+    daemon = spawn(process.execPath, [
+      DAEMON_SCRIPT,
+      "--socket", socketPath,
+      "--shell", "/bin/sh",
+      "--cols", "80",
+      "--rows", "24",
+      "--cwd", "/tmp",
+      "--tab-id", "test-3",
+    ], { stdio: "pipe" });
+
+    await waitForSocket(socketPath);
+    const client = await connectToDaemon(socketPath);
+    await new Promise((r) => setTimeout(r, 500));
+
+    // Send a command
+    client.write(encodeFrame(TAG_CLIENT_INPUT, "echo REMUX_TEST_OK\n"));
+    const frames = await collectFrames(client, 2000);
+
+    // Should have received output containing our echo
+    const outputText = frames
+      .filter((f) => f.tag === TAG_PTY_OUTPUT)
+      .map((f) => f.payload.toString())
+      .join("");
+
+    expect(outputText).toContain("REMUX_TEST_OK");
+
+    client.end();
+  }, 10000);
+
+  it("returns scrollback on snapshot request", async () => {
+    daemon = spawn(process.execPath, [
+      DAEMON_SCRIPT,
+      "--socket", socketPath,
+      "--shell", "/bin/sh",
+      "--cols", "80",
+      "--rows", "24",
+      "--cwd", "/tmp",
+      "--tab-id", "test-4",
+    ], { stdio: "pipe" });
+
+    await waitForSocket(socketPath);
+    const client = await connectToDaemon(socketPath);
+    await new Promise((r) => setTimeout(r, 500));
+
+    // Write something to terminal
+    client.write(encodeFrame(TAG_CLIENT_INPUT, "echo SNAPSHOT_TEST\n"));
+    await new Promise((r) => setTimeout(r, 1000));
+
+    // Request snapshot
+    const frames = await sendAndReceive(
+      client,
+      encodeFrame(TAG_SNAPSHOT_REQ, Buffer.alloc(0)),
+      1500,
+    );
+
+    const snapshotFrame = frames.find((f) => f.tag === TAG_SNAPSHOT_RES);
+    expect(snapshotFrame).toBeDefined();
+    expect(snapshotFrame.payload.toString()).toContain("SNAPSHOT_TEST");
+
+    client.end();
+  }, 10000);
+
+  it("shuts down on TAG_SHUTDOWN", async () => {
+    daemon = spawn(process.execPath, [
+      DAEMON_SCRIPT,
+      "--socket", socketPath,
+      "--shell", "/bin/sh",
+      "--cols", "80",
+      "--rows", "24",
+      "--cwd", "/tmp",
+      "--tab-id", "test-5",
+    ], { stdio: "pipe" });
+
+    await waitForSocket(socketPath);
+    const client = await connectToDaemon(socketPath);
+    await new Promise((r) => setTimeout(r, 500));
+
+    // Send shutdown
+    client.write(encodeFrame(TAG_SHUTDOWN, Buffer.alloc(0)));
+
+    // Wait for daemon to exit
+    await new Promise((resolve) => {
+      daemon.on("exit", resolve);
+      setTimeout(resolve, 3000); // timeout safety
+    });
+
+    // Socket file should be cleaned up
+    await new Promise((r) => setTimeout(r, 500));
+    expect(fs.existsSync(socketPath)).toBe(false);
+  }, 10000);
+
+  it("survives client disconnect (daemon stays alive)", async () => {
+    daemon = spawn(process.execPath, [
+      DAEMON_SCRIPT,
+      "--socket", socketPath,
+      "--shell", "/bin/sh",
+      "--cols", "80",
+      "--rows", "24",
+      "--cwd", "/tmp",
+      "--tab-id", "test-6",
+    ], { stdio: "pipe" });
+
+    await waitForSocket(socketPath);
+
+    // Connect and disconnect
+    const client1 = await connectToDaemon(socketPath);
+    await new Promise((r) => setTimeout(r, 500));
+    client1.end();
+    await new Promise((r) => setTimeout(r, 500));
+
+    // Daemon should still be alive — reconnect
+    const client2 = await connectToDaemon(socketPath);
+    const frames = await sendAndReceive(
+      client2,
+      encodeFrame(TAG_STATUS_REQ, Buffer.alloc(0)),
+      1500,
+    );
+
+    const statusFrame = frames.find((f) => f.tag === TAG_STATUS_RES);
+    expect(statusFrame).toBeDefined();
+    const status = JSON.parse(statusFrame.payload.toString());
+    expect(status.alive).toBe(true);
+
+    client2.end();
+  }, 10000);
+});