@hayasaka7/haya-pet 0.1.0

package/packages/cli-core/test/companion-launcher.test.mjs

@@ -0,0 +1,98 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import { ensureCompanionConnection } from "../src/companion-launcher.js";
+
+const noSleep = async () => {};
+
+test("connects without launching when the companion is already running", async () => {
+  let launched = 0;
+  const client = { id: "existing" };
+  const result = await ensureCompanionConnection({
+    connect: async () => client,
+    launch: async () => { launched += 1; },
+    sleep: noSleep
+  });
+  assert.equal(result.client, client);
+  assert.equal(result.started, false);
+  assert.equal(launched, 0);
+});
+
+test("launches the companion then connects after it comes up", async () => {
+  let launched = 0;
+  let attempts = 0;
+  const client = { id: "fresh" };
+  const result = await ensureCompanionConnection({
+    // First check fails (not running); after launch, the 3rd connect succeeds.
+    connect: async () => {
+      attempts += 1;
+      if (attempts <= 3) {
+        throw new Error("ECONNREFUSED");
+      }
+      return client;
+    },
+    launch: async () => { launched += 1; },
+    attempts: 10,
+    intervalMs: 1,
+    sleep: noSleep
+  });
+  assert.equal(result.client, client);
+  assert.equal(result.started, true);
+  assert.equal(launched, 1, "launches exactly once");
+});
+
+test("does not launch when autoStart is disabled", async () => {
+  let launched = 0;
+  const result = await ensureCompanionConnection({
+    connect: async () => { throw new Error("no daemon"); },
+    launch: async () => { launched += 1; },
+    autoStart: false,
+    sleep: noSleep
+  });
+  assert.equal(result.client, null);
+  assert.equal(result.started, false);
+  assert.equal(launched, 0);
+});
+
+test("times out gracefully when the companion never comes up", async () => {
+  let launched = 0;
+  const result = await ensureCompanionConnection({
+    connect: async () => { throw new Error("never listening"); },
+    launch: async () => { launched += 1; },
+    attempts: 4,
+    intervalMs: 1,
+    sleep: noSleep
+  });
+  assert.equal(result.client, null);
+  assert.equal(result.started, false);
+  assert.equal(result.timedOut, true);
+  assert.equal(launched, 1);
+});
+
+test("degrades gracefully when launching throws (e.g. electron missing)", async () => {
+  const result = await ensureCompanionConnection({
+    connect: async () => { throw new Error("no daemon"); },
+    launch: async () => { throw new Error("electron not installed"); },
+    sleep: noSleep
+  });
+  assert.equal(result.client, null);
+  assert.equal(result.started, false);
+  assert.ok(result.error instanceof Error);
+});
+
+test("stops polling as soon as a connection succeeds", async () => {
+  let connectCalls = 0;
+  const client = { id: "x" };
+  await ensureCompanionConnection({
+    connect: async () => {
+      connectCalls += 1;
+      if (connectCalls === 1) throw new Error("not yet"); // initial check
+      if (connectCalls === 2) return client;              // first poll succeeds
+      throw new Error("should not poll again");
+    },
+    launch: async () => {},
+    attempts: 10,
+    intervalMs: 1,
+    sleep: noSleep
+  });
+  assert.equal(connectCalls, 2);
+});

package/packages/cli-core/test/run-command.test.mjs

@@ -0,0 +1,177 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
+import { test } from "../../../test/harness.mjs";
+import { runGenericCommand } from "../src/run-command.js";
+
+function createClock(start = 1000, step = 10) {
+  let current = start;
+  return () => {
+    const value = current;
+    current += step;
+    return value;
+  };
+}
+
+test("emits generic command lifecycle messages and preserves exit code", async () => {
+  const messages = [];
+  const cwd = process.cwd();
+
+  const result = await runGenericCommand({
+    command: process.execPath,
+    args: ["-e", "setTimeout(() => process.exit(7), 40)"],
+    cwd,
+    clientId: "generic",
+    clientDisplayName: "Generic",
+    sessionId: "sess_test",
+    heartbeatIntervalMs: 5,
+    now: createClock(),
+    stdio: "ignore",
+    send: async (message) => {
+      messages.push(message);
+    }
+  });
+
+  assert.equal(result.exitCode, 7);
+  assert.equal(result.sessionId, "sess_test");
+
+  assert.equal(messages[0].type, "register");
+  assert.equal(messages[0].sessionId, "sess_test");
+  assert.equal(messages[0].clientId, "generic");
+  assert.equal(messages[0].clientDisplayName, "Generic");
+  assert.equal(messages[0].cwd, cwd);
+  assert.equal(messages[0].projectName, basename(cwd));
+  assert.equal(messages[0].pid, result.pid);
+
+  const stateMessage = messages.find((message) => message.type === "state");
+  assert.equal(stateMessage.state, "idle");
+  assert.equal(stateMessage.source, "wrapper");
+  assert.equal(stateMessage.summary, "session started");
+
+  assert.ok(messages.some((message) => message.type === "heartbeat"));
+
+  const unregister = messages[messages.length - 1];
+  assert.equal(unregister.type, "unregister");
+  assert.equal(unregister.sessionId, "sess_test");
+  assert.equal(unregister.exitCode, 7);
+});
+
+test("launches a Windows .cmd shim via the shell and reports a valid pid", async () => {
+  if (process.platform !== "win32") {
+    return; // shell resolution of .cmd shims is Windows-specific
+  }
+
+  const dir = mkdtempSync(join(tmpdir(), "haya-pet-cmd-"));
+  const cmdPath = join(dir, "fake-cli.cmd");
+  writeFileSync(cmdPath, "@echo off\r\nexit /b 5\r\n");
+
+  try {
+    const messages = [];
+    const result = await runGenericCommand({
+      command: cmdPath,
+      args: [],
+      cwd: process.cwd(),
+      sessionId: "sess_cmd",
+      heartbeatIntervalMs: 50,
+      now: createClock(),
+      stdio: "ignore",
+      send: async (message) => messages.push(message)
+    });
+
+    assert.equal(result.exitCode, 5);
+    const register = messages.find((message) => message.type === "register");
+    assert.ok(register, "should send a register message");
+    assert.ok(Number.isInteger(register.pid) && register.pid > 0, "pid must be a positive integer");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("observe mode infers state from PTY output via the observer", async () => {
+  const messages = [];
+  const ESC = String.fromCharCode(27);
+
+  const result = await runGenericCommand({
+    command: "claude",
+    args: [],
+    cwd: process.cwd(),
+    clientId: "claude-code",
+    clientDisplayName: "Claude Code",
+    sessionId: "sess_obs",
+    heartbeatIntervalMs: 1000,
+    now: createClock(),
+    observe: true,
+    send: async (message) => messages.push(message),
+    // Injected PTY: emits a tool-use line (with ANSI noise), then exits 0.
+    spawnPty: async ({ onData }) => {
+      onData(`${ESC}[mRunning tests${ESC}[0m\r\n`);
+      return {
+        pid: 4321,
+        exit: new Promise((resolve) => setTimeout(() => resolve({ exitCode: 0 }), 10)),
+        write() {},
+        kill() {}
+      };
+    }
+  });
+
+  assert.equal(result.exitCode, 0);
+  assert.equal(result.pid, 4321);
+
+  const register = messages.find((m) => m.type === "register");
+  assert.equal(register.pid, 4321);
+
+  const inferred = messages.find((m) => m.type === "state" && m.source === "pty_output");
+  assert.ok(inferred, "should emit a state inferred from PTY output");
+  assert.equal(inferred.state, "running_tool");
+
+  assert.equal(messages.at(-1).type, "unregister");
+});
+
+test("maps successful generic command exit to a success state before unregister", async () => {
+  const messages = [];
+
+  const result = await runGenericCommand({
+    command: process.execPath,
+    args: ["-e", "process.exit(0)"],
+    cwd: process.cwd(),
+    sessionId: "sess_success",
+    heartbeatIntervalMs: 50,
+    now: createClock(),
+    stdio: "ignore",
+    send: async (message) => {
+      messages.push(message);
+    }
+  });
+
+  assert.equal(result.exitCode, 0);
+
+  const finalState = messages.filter((message) => message.type === "state").at(-1);
+  assert.equal(finalState.state, "success");
+  assert.equal(finalState.summary, "process exited successfully");
+  assert.equal(messages.at(-1).type, "unregister");
+});
+
+test("maps failed generic command exit to a failed state before unregister", async () => {
+  const messages = [];
+
+  const result = await runGenericCommand({
+    command: process.execPath,
+    args: ["-e", "process.exit(3)"],
+    cwd: process.cwd(),
+    sessionId: "sess_failed",
+    heartbeatIntervalMs: 50,
+    now: createClock(),
+    stdio: "ignore",
+    send: async (message) => {
+      messages.push(message);
+    }
+  });
+
+  assert.equal(result.exitCode, 3);
+
+  const finalState = messages.filter((message) => message.type === "state").at(-1);
+  assert.equal(finalState.state, "failed");
+  assert.equal(finalState.summary, "process exited with code 3");
+  assert.equal(messages.at(-1).exitCode, 3);
+});

package/packages/cli-core/test/strip-ansi.test.mjs

@@ -0,0 +1,27 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import { stripAnsi } from "../src/strip-ansi.js";
+
+const ESC = String.fromCharCode(27); // 
+const BEL = String.fromCharCode(7); // 
+
+test("strips CSI cursor/clear sequences", () => {
+  assert.equal(stripAnsi(`${ESC}[2J${ESC}[H${ESC}[mrunning tests\r\n`), "running tests\r\n");
+});
+
+test("strips OSC title sequences", () => {
+  assert.equal(stripAnsi(`${ESC}]0;C:\\cmd.exe${BEL}plain text`), "plain text");
+});
+
+test("strips color codes but keeps the words", () => {
+  assert.equal(stripAnsi(`${ESC}[31mError:${ESC}[0m boom`), "Error: boom");
+});
+
+test("leaves plain text untouched", () => {
+  assert.equal(stripAnsi("waiting for approval"), "waiting for approval");
+});
+
+test("handles real ConPTY-style output", () => {
+  const raw = `${ESC}[?25l${ESC}[2J${ESC}[mApplying patch to src/index.js\r\n${ESC}]0;cmd${BEL}${ESC}[?25h`;
+  assert.ok(stripAnsi(raw).includes("Applying patch to src/index.js"));
+});

package/packages/daemon-core/src/daemon-runtime.js

@@ -0,0 +1,49 @@
+import { createSessionRegistry } from "../../session-core/src/registry.js";
+import { attachProtocolStream } from "./ipc-transport.js";
+
+export function createDaemonRuntime(options = {}) {
+  const registry = options.registry ?? createSessionRegistry(options.registryOptions);
+  const onSessionChanged = options.onSessionChanged ?? noop;
+  const onProtocolError = options.onProtocolError ?? noop;
+
+  return {
+    registry,
+
+    handleMessage(message) {
+      const session = registry.applyMessage(message);
+      onSessionChanged(session);
+      return session;
+    },
+
+    attachStream(stream) {
+      return attachProtocolStream(stream, {
+        onMessage: (message) => {
+          this.handleMessage(message);
+        },
+        onError: onProtocolError
+      });
+    },
+
+    getSession(sessionId) {
+      return registry.getSession(sessionId);
+    },
+
+    listSessions() {
+      return registry.listSessions();
+    },
+
+    getPrioritySession(priorityOptions = {}) {
+      return registry.getPrioritySession(priorityOptions);
+    },
+
+    markStaleSessions(now) {
+      const staleSessions = registry.markStaleSessions(now);
+      for (const session of staleSessions) {
+        onSessionChanged(session);
+      }
+      return staleSessions;
+    }
+  };
+}
+
+function noop() {}

package/packages/daemon-core/src/ipc-server.js

@@ -0,0 +1,180 @@
+import { mkdir } from "node:fs/promises";
+import net from "node:net";
+import { dirname } from "node:path";
+import { attachProtocolStream, writeProtocolMessage } from "./ipc-transport.js";
+
+export async function createIpcServer(options = {}) {
+  const {
+    endpoint,
+    platform = process.platform,
+    onMessage,
+    onProtocolError = noop
+  } = options;
+
+  if (typeof onMessage !== "function") {
+    throw new TypeError("onMessage must be a function");
+  }
+
+  const sockets = new Set();
+  const server = net.createServer((socket) => {
+    sockets.add(socket);
+    socket.on("close", () => sockets.delete(socket));
+    attachProtocolStream(socket, {
+      onMessage,
+      onError: onProtocolError
+    });
+  });
+
+  const listenOptions = await resolveListenOptions(endpoint, platform);
+  await listen(server, listenOptions);
+
+  return {
+    endpoint: getServerEndpoint(server, listenOptions),
+    server,
+
+    async close() {
+      for (const socket of sockets) {
+        socket.destroy();
+      }
+
+      await closeServer(server);
+    }
+  };
+}
+
+export async function createIpcClient(options = {}) {
+  const { endpoint } = options;
+  const socket = net.createConnection(toConnectionOptions(endpoint));
+  await waitForConnect(socket);
+
+  return {
+    socket,
+
+    async send(message) {
+      if (!writeProtocolMessage(socket, message)) {
+        await once(socket, "drain");
+      }
+    },
+
+    async close() {
+      if (socket.destroyed) {
+        return;
+      }
+
+      socket.end();
+      await once(socket, "close");
+    }
+  };
+}
+
+async function resolveListenOptions(endpoint, platform) {
+  if (platform === "test") {
+    return {
+      type: "tcp",
+      host: "127.0.0.1",
+      port: 0,
+      name: endpoint
+    };
+  }
+
+  if (typeof endpoint !== "string" || endpoint.trim() === "") {
+    throw new Error("endpoint must be a non-empty string");
+  }
+
+  if (!endpoint.startsWith("\\\\.\\")) {
+    await mkdir(dirname(endpoint), { recursive: true });
+  }
+
+  return {
+    type: "path",
+    path: endpoint
+  };
+}
+
+function getServerEndpoint(server, listenOptions) {
+  if (listenOptions.type === "tcp") {
+    const address = server.address();
+    return {
+      type: "tcp",
+      host: address.address,
+      port: address.port
+    };
+  }
+
+  return listenOptions.path;
+}
+
+function toConnectionOptions(endpoint) {
+  if (typeof endpoint === "string") {
+    return { path: endpoint };
+  }
+
+  if (endpoint?.type === "tcp") {
+    return {
+      host: endpoint.host,
+      port: endpoint.port
+    };
+  }
+
+  if (Number.isInteger(endpoint?.port)) {
+    return endpoint;
+  }
+
+  throw new Error("Unsupported IPC endpoint");
+}
+
+function listen(server, listenOptions) {
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(toServerListenOptions(listenOptions), () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+}
+
+function toServerListenOptions(listenOptions) {
+  if (listenOptions.type === "tcp") {
+    return {
+      host: listenOptions.host,
+      port: listenOptions.port
+    };
+  }
+
+  return listenOptions.path;
+}
+
+function waitForConnect(socket) {
+  return new Promise((resolve, reject) => {
+    socket.once("error", reject);
+    socket.once("connect", () => {
+      socket.off("error", reject);
+      resolve();
+    });
+  });
+}
+
+function closeServer(server) {
+  return new Promise((resolve, reject) => {
+    if (!server.listening) {
+      resolve();
+      return;
+    }
+
+    server.close((error) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve();
+      }
+    });
+  });
+}
+
+function once(emitter, eventName) {
+  return new Promise((resolve) => {
+    emitter.once(eventName, resolve);
+  });
+}
+
+function noop() {}

package/packages/daemon-core/src/ipc-transport.js

@@ -0,0 +1,70 @@
+import { assertProtocolMessage } from "../../protocol/src/messages.js";
+
+export function encodeProtocolMessage(message) {
+  assertProtocolMessage(message);
+  return `${JSON.stringify(message)}\n`;
+}
+
+export function writeProtocolMessage(writable, message) {
+  return writable.write(encodeProtocolMessage(message));
+}
+
+export function createProtocolMessageReader({ onMessage, onError = defaultErrorHandler } = {}) {
+  if (typeof onMessage !== "function") {
+    throw new TypeError("onMessage must be a function");
+  }
+
+  let buffer = "";
+
+  return {
+    push(chunk) {
+      buffer += chunk.toString("utf8");
+
+      let newlineIndex = buffer.indexOf("\n");
+      while (newlineIndex !== -1) {
+        const line = buffer.slice(0, newlineIndex);
+        buffer = buffer.slice(newlineIndex + 1);
+        readFrame(line, onMessage, onError);
+        newlineIndex = buffer.indexOf("\n");
+      }
+    },
+
+    flush() {
+      if (buffer.trim() !== "") {
+        readFrame(buffer, onMessage, onError);
+      }
+      buffer = "";
+    }
+  };
+}
+
+export function attachProtocolStream(readable, options) {
+  const reader = createProtocolMessageReader(options);
+  readable.on("data", (chunk) => reader.push(chunk));
+  readable.on("end", () => reader.flush());
+  return reader;
+}
+
+function readFrame(line, onMessage, onError) {
+  if (line.trim() === "") {
+    return;
+  }
+
+  let message;
+  try {
+    message = JSON.parse(line);
+  } catch (error) {
+    onError(new Error(`Invalid protocol JSON frame: ${error.message}`));
+    return;
+  }
+
+  try {
+    onMessage(assertProtocolMessage(message));
+  } catch (error) {
+    onError(error);
+  }
+}
+
+function defaultErrorHandler(error) {
+  throw error;
+}

package/packages/daemon-core/src/singleton.js

@@ -0,0 +1,46 @@
+// Daemon singleton enforcement helpers (product plan section 39). The pure
+// decision logic here lets the Electron main process and tests share the same
+// stale-lock detection without touching the filesystem.
+
+export function serializeLock({ pid, startedAt, endpoint }) {
+  return `${JSON.stringify({ pid, startedAt, endpoint })}\n`;
+}
+
+export function parseLock(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return undefined;
+  }
+
+  if (!isPlainObject(parsed)) {
+    return undefined;
+  }
+
+  if (!Number.isInteger(parsed.pid) || parsed.pid <= 0) {
+    return undefined;
+  }
+
+  if (!Number.isFinite(parsed.startedAt) || typeof parsed.endpoint !== "string") {
+    return undefined;
+  }
+
+  return { pid: parsed.pid, startedAt: parsed.startedAt, endpoint: parsed.endpoint };
+}
+
+export function resolveSingletonAction({ lock, isAlive }) {
+  if (typeof isAlive !== "function") {
+    throw new TypeError("isAlive must be a function");
+  }
+
+  if (!lock) {
+    return "acquire";
+  }
+
+  return isAlive(lock.pid) ? "forward" : "reclaim";
+}
+
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}