chatroom-cli 1.0.65 → 1.0.66

package/dist/index.js

@@ -10192,6 +10192,464 @@ var init_config2 = __esm(() => {
   WEB_SERVER_PORT = parseInt(process.env.WEB_PORT || "3456", 10);
 });
 
+// src/infrastructure/agent-drivers/process-driver.ts
+import { spawn } from "node:child_process";
+function buildCombinedPrompt(rolePrompt, initialMessage) {
+  return `${rolePrompt}
+
+${initialMessage}`;
+}
+
+class ProcessDriver {
+  async start(options) {
+    const config3 = this.buildSpawnConfig(options);
+    console.log(`   Spawning ${this.harness} agent...`);
+    console.log(`   Working dir: ${options.workingDir}`);
+    if (options.harnessVersion) {
+      console.log(`   Harness version: v${options.harnessVersion.version} (major: ${options.harnessVersion.major})`);
+    }
+    if (options.model) {
+      console.log(`   Model: ${options.model}`);
+    }
+    try {
+      const childProcess = spawn(config3.command, config3.args, {
+        cwd: options.workingDir,
+        stdio: config3.stdio,
+        detached: true,
+        shell: false
+      });
+      if (config3.writePromptToStdin && config3.stdinPrompt) {
+        childProcess.stdin?.write(config3.stdinPrompt);
+        childProcess.stdin?.end();
+      }
+      config3.afterSpawn?.(childProcess);
+      childProcess.unref();
+      await new Promise((resolve) => setTimeout(resolve, 500));
+      if (childProcess.killed || childProcess.exitCode !== null) {
+        return {
+          success: false,
+          message: `Agent process exited immediately (exit code: ${childProcess.exitCode})`
+        };
+      }
+      const handle = {
+        harness: this.harness,
+        type: "process",
+        pid: childProcess.pid,
+        workingDir: options.workingDir
+      };
+      return {
+        success: true,
+        message: "Agent spawned successfully",
+        handle
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to spawn agent: ${error.message}`
+      };
+    }
+  }
+  async stop(handle) {
+    if (handle.type !== "process" || !handle.pid) {
+      throw new Error(`Cannot stop: handle has no PID (type=${handle.type})`);
+    }
+    process.kill(handle.pid, "SIGTERM");
+  }
+  async isAlive(handle) {
+    if (handle.type !== "process" || !handle.pid) {
+      return false;
+    }
+    try {
+      process.kill(handle.pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async recover(_workingDir) {
+    return [];
+  }
+  async listModels() {
+    return [];
+  }
+}
+var init_process_driver = () => {};
+
+// src/infrastructure/machine/types.ts
+var AGENT_HARNESSES, AGENT_HARNESS_COMMANDS, MACHINE_CONFIG_VERSION = "1";
+var init_types = __esm(() => {
+  AGENT_HARNESSES = ["opencode"];
+  AGENT_HARNESS_COMMANDS = {
+    opencode: "opencode"
+  };
+});
+
+// src/infrastructure/agent-drivers/opencode-process-driver.ts
+import { execSync } from "node:child_process";
+var OpenCodeProcessDriver;
+var init_opencode_process_driver = __esm(() => {
+  init_process_driver();
+  init_types();
+  OpenCodeProcessDriver = class OpenCodeProcessDriver extends ProcessDriver {
+    harness = "opencode";
+    capabilities = {
+      sessionPersistence: false,
+      abort: false,
+      modelSelection: true,
+      compaction: false,
+      eventStreaming: false,
+      messageInjection: false,
+      dynamicModelDiscovery: true
+    };
+    buildSpawnConfig(options) {
+      const command = AGENT_HARNESS_COMMANDS[this.harness];
+      const combinedPrompt = buildCombinedPrompt(options.rolePrompt, options.initialMessage);
+      const args = ["run"];
+      if (options.model) {
+        args.push("--model", options.model);
+      }
+      return {
+        command,
+        args,
+        stdio: ["pipe", "inherit", "inherit"],
+        writePromptToStdin: true,
+        stdinPrompt: combinedPrompt
+      };
+    }
+    async listModels() {
+      try {
+        const output = execSync("opencode models", {
+          stdio: ["pipe", "pipe", "pipe"],
+          timeout: 1e4
+        }).toString().trim();
+        if (!output)
+          return [];
+        return output.split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0);
+      } catch {
+        return [];
+      }
+    }
+  };
+});
+
+// src/infrastructure/agent-drivers/registry.ts
+class DefaultDriverRegistry {
+  drivers;
+  constructor(drivers) {
+    this.drivers = new Map;
+    for (const driver of drivers) {
+      this.drivers.set(driver.harness, driver);
+    }
+  }
+  get(harness) {
+    const driver = this.drivers.get(harness);
+    if (!driver) {
+      throw new Error(`No driver registered for harness: ${harness}`);
+    }
+    return driver;
+  }
+  all() {
+    return Array.from(this.drivers.values());
+  }
+  capabilities(harness) {
+    return this.get(harness).capabilities;
+  }
+}
+function getDriverRegistry() {
+  if (!registryInstance) {
+    registryInstance = new DefaultDriverRegistry([new OpenCodeProcessDriver]);
+  }
+  return registryInstance;
+}
+var registryInstance = null;
+var init_registry = __esm(() => {
+  init_opencode_process_driver();
+});
+
+// src/infrastructure/agent-drivers/index.ts
+var init_agent_drivers = __esm(() => {
+  init_registry();
+  init_process_driver();
+  init_process_driver();
+  init_opencode_process_driver();
+});
+
+// src/infrastructure/machine/detection.ts
+import { execSync as execSync2 } from "node:child_process";
+function commandExists(command) {
+  try {
+    const checkCommand = process.platform === "win32" ? `where ${command}` : `which ${command}`;
+    execSync2(checkCommand, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parseVersion(versionStr) {
+  const match = versionStr.match(/v?(\d+)\.(\d+)\.(\d+)/);
+  if (!match)
+    return null;
+  const major = parseInt(match[1], 10);
+  const version2 = `${match[1]}.${match[2]}.${match[3]}`;
+  return { version: version2, major };
+}
+function detectHarnessVersion(harness) {
+  const versionCommand = HARNESS_VERSION_COMMANDS[harness];
+  if (!versionCommand)
+    return null;
+  try {
+    const output = execSync2(versionCommand, {
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 5000
+    }).toString().trim();
+    return parseVersion(output);
+  } catch {
+    return null;
+  }
+}
+function detectHarnessVersions(harnesses) {
+  const versions = {};
+  for (const harness of harnesses) {
+    const version2 = detectHarnessVersion(harness);
+    if (version2) {
+      versions[harness] = version2;
+    }
+  }
+  return versions;
+}
+function detectAvailableHarnesses() {
+  const available = [];
+  for (const harness of AGENT_HARNESSES) {
+    const command = AGENT_HARNESS_COMMANDS[harness];
+    if (commandExists(command)) {
+      available.push(harness);
+    }
+  }
+  return available;
+}
+var HARNESS_VERSION_COMMANDS;
+var init_detection = __esm(() => {
+  init_types();
+  HARNESS_VERSION_COMMANDS = {
+    opencode: "opencode --version"
+  };
+});
+
+// src/infrastructure/machine/storage.ts
+import { randomUUID } from "node:crypto";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2, renameSync } from "node:fs";
+import { homedir as homedir2, hostname as hostname2 } from "node:os";
+import { join as join3 } from "node:path";
+function ensureConfigDir2() {
+  if (!existsSync2(CHATROOM_DIR2)) {
+    mkdirSync2(CHATROOM_DIR2, { recursive: true, mode: 448 });
+  }
+}
+function getMachineConfigPath() {
+  return join3(CHATROOM_DIR2, MACHINE_FILE);
+}
+function loadConfigFile() {
+  const configPath = getMachineConfigPath();
+  if (!existsSync2(configPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync3(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    console.warn(`⚠️  Failed to read machine config at ${configPath}: ${error.message}`);
+    console.warn(`   The machine will re-register with a new identity on next startup.`);
+    console.warn(`   If this is unexpected, check the file for corruption.`);
+    return null;
+  }
+}
+function saveConfigFile(configFile) {
+  ensureConfigDir2();
+  const configPath = getMachineConfigPath();
+  const tempPath = `${configPath}.tmp`;
+  const content = JSON.stringify(configFile, null, 2);
+  writeFileSync2(tempPath, content, { encoding: "utf-8", mode: 384 });
+  renameSync(tempPath, configPath);
+}
+function loadMachineConfig() {
+  const configFile = loadConfigFile();
+  if (!configFile)
+    return null;
+  const convexUrl = getConvexUrl();
+  return configFile.machines[convexUrl] ?? null;
+}
+function saveMachineConfig(config3) {
+  const configFile = loadConfigFile() ?? {
+    version: MACHINE_CONFIG_VERSION,
+    machines: {}
+  };
+  const convexUrl = getConvexUrl();
+  configFile.machines[convexUrl] = config3;
+  saveConfigFile(configFile);
+}
+function createNewEndpointConfig() {
+  const now = new Date().toISOString();
+  const availableHarnesses = detectAvailableHarnesses();
+  return {
+    machineId: randomUUID(),
+    hostname: hostname2(),
+    os: process.platform,
+    registeredAt: now,
+    lastSyncedAt: now,
+    availableHarnesses,
+    harnessVersions: detectHarnessVersions(availableHarnesses),
+    chatroomAgents: {}
+  };
+}
+function ensureMachineRegistered() {
+  let config3 = loadMachineConfig();
+  if (!config3) {
+    config3 = createNewEndpointConfig();
+    saveMachineConfig(config3);
+  } else {
+    const now = new Date().toISOString();
+    config3.availableHarnesses = detectAvailableHarnesses();
+    config3.harnessVersions = detectHarnessVersions(config3.availableHarnesses);
+    config3.lastSyncedAt = now;
+    config3.hostname = hostname2();
+    saveMachineConfig(config3);
+  }
+  return {
+    machineId: config3.machineId,
+    hostname: config3.hostname,
+    os: config3.os,
+    availableHarnesses: config3.availableHarnesses,
+    harnessVersions: config3.harnessVersions
+  };
+}
+function getMachineId() {
+  const config3 = loadMachineConfig();
+  return config3?.machineId ?? null;
+}
+function updateAgentContext(chatroomId, role, agentType, workingDir) {
+  const config3 = loadMachineConfig();
+  if (!config3) {
+    throw new Error("Machine not registered. Run ensureMachineRegistered() first.");
+  }
+  const now = new Date().toISOString();
+  if (!config3.chatroomAgents[chatroomId]) {
+    config3.chatroomAgents[chatroomId] = {};
+  }
+  config3.chatroomAgents[chatroomId][role] = {
+    agentType,
+    workingDir,
+    lastStartedAt: now
+  };
+  saveMachineConfig(config3);
+}
+function getAgentContext(chatroomId, role) {
+  const config3 = loadMachineConfig();
+  if (!config3) {
+    return null;
+  }
+  return config3.chatroomAgents[chatroomId]?.[role] ?? null;
+}
+var CHATROOM_DIR2, MACHINE_FILE = "machine.json";
+var init_storage2 = __esm(() => {
+  init_detection();
+  init_types();
+  init_client2();
+  CHATROOM_DIR2 = join3(homedir2(), ".chatroom");
+});
+
+// src/infrastructure/machine/daemon-state.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3, renameSync as renameSync2 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join4 } from "node:path";
+function agentKey(chatroomId, role) {
+  return `${chatroomId}/${role}`;
+}
+function ensureStateDir() {
+  if (!existsSync3(STATE_DIR)) {
+    mkdirSync3(STATE_DIR, { recursive: true, mode: 448 });
+  }
+}
+function stateFilePath(machineId) {
+  return join4(STATE_DIR, `${machineId}.json`);
+}
+function loadDaemonState(machineId) {
+  const filePath = stateFilePath(machineId);
+  if (!existsSync3(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync4(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function saveDaemonState(state) {
+  ensureStateDir();
+  const filePath = stateFilePath(state.machineId);
+  const tempPath = `${filePath}.tmp`;
+  const content = JSON.stringify(state, null, 2);
+  writeFileSync3(tempPath, content, { encoding: "utf-8", mode: 384 });
+  renameSync2(tempPath, filePath);
+}
+function loadOrCreate(machineId) {
+  return loadDaemonState(machineId) ?? {
+    version: STATE_VERSION,
+    machineId,
+    updatedAt: new Date().toISOString(),
+    agents: {}
+  };
+}
+function persistAgentPid(machineId, chatroomId, role, pid, harness) {
+  const state = loadOrCreate(machineId);
+  state.agents[agentKey(chatroomId, role)] = {
+    pid,
+    harness,
+    startedAt: new Date().toISOString()
+  };
+  state.updatedAt = new Date().toISOString();
+  saveDaemonState(state);
+}
+function clearAgentPid(machineId, chatroomId, role) {
+  const state = loadDaemonState(machineId);
+  if (!state)
+    return;
+  const key = agentKey(chatroomId, role);
+  if (!(key in state.agents))
+    return;
+  delete state.agents[key];
+  state.updatedAt = new Date().toISOString();
+  saveDaemonState(state);
+}
+function listAgentEntries(machineId) {
+  const state = loadDaemonState(machineId);
+  if (!state)
+    return [];
+  const results = [];
+  for (const [key, entry] of Object.entries(state.agents)) {
+    const separatorIndex = key.lastIndexOf("/");
+    if (separatorIndex === -1)
+      continue;
+    const chatroomId = key.substring(0, separatorIndex);
+    const role = key.substring(separatorIndex + 1);
+    results.push({ chatroomId, role, entry });
+  }
+  return results;
+}
+var CHATROOM_DIR3, STATE_DIR, STATE_VERSION = "1";
+var init_daemon_state = __esm(() => {
+  CHATROOM_DIR3 = join4(homedir3(), ".chatroom");
+  STATE_DIR = join4(CHATROOM_DIR3, "machines", "state");
+});
+
+// src/infrastructure/machine/index.ts
+var init_machine = __esm(() => {
+  init_types();
+  init_storage2();
+  init_daemon_state();
+});
+
 // src/commands/wait-for-task.ts
 var exports_wait_for_task = {};
 __export(exports_wait_for_task, {
@@ -10264,6 +10722,45 @@ async function waitForTask(chatroomId, options) {
     console.error(`❌ Chatroom ${chatroomId} not found or access denied`);
     process.exit(1);
   }
+  try {
+    const machineInfo = ensureMachineRegistered();
+    let availableModels = [];
+    try {
+      const registry = getDriverRegistry();
+      for (const driver of registry.all()) {
+        if (driver.capabilities.dynamicModelDiscovery) {
+          const models = await driver.listModels();
+          availableModels = availableModels.concat(models);
+        }
+      }
+    } catch {}
+    await client2.mutation(api.machines.register, {
+      sessionId,
+      machineId: machineInfo.machineId,
+      hostname: machineInfo.hostname,
+      os: machineInfo.os,
+      availableHarnesses: machineInfo.availableHarnesses,
+      harnessVersions: machineInfo.harnessVersions,
+      availableModels
+    });
+    const agentType = options.agentType ?? (machineInfo.availableHarnesses.length > 0 ? machineInfo.availableHarnesses[0] : undefined);
+    if (agentType) {
+      const workingDir = process.cwd();
+      updateAgentContext(chatroomId, role, agentType, workingDir);
+      await client2.mutation(api.machines.updateAgentConfig, {
+        sessionId,
+        machineId: machineInfo.machineId,
+        chatroomId,
+        role,
+        agentType,
+        workingDir
+      });
+    }
+  } catch (machineError) {
+    if (!silent) {
+      console.warn(`⚠️  Machine registration failed: ${machineError.message}`);
+    }
+  }
   const effectiveTimeout = timeout || DEFAULT_WAIT_TIMEOUT_MS;
   const readyUntil = Date.now() + effectiveTimeout;
   const connectionId = `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
@@ -10385,20 +10882,6 @@ ${"─".repeat(50)}`);
       status: "active",
       expiresAt: activeUntil
     });
-    if (message && message.type === "interrupt") {
-      const interruptTime = new Date().toISOString().replace("T", " ").substring(0, 19);
-      console.log(`
-${"─".repeat(50)}`);
-      console.log(`⚠️  RECONNECTION REQUIRED
-`);
-      console.log(`[${interruptTime}] Why: Interrupt message received from team`);
-      console.log(`Impact: You are no longer listening for tasks`);
-      console.log(`Action: Run this command immediately to resume availability
-`);
-      console.log(waitForTaskCommand({ chatroomId, role, cliEnvPrefix }));
-      console.log(`${"─".repeat(50)}`);
-      process.exit(0);
-    }
     const taskDeliveryPrompt = await client2.query(api.messages.getTaskDeliveryPrompt, {
       sessionId,
       chatroomId,
@@ -10551,8 +11034,10 @@ var init_wait_for_task = __esm(() => {
   init_env();
   init_api3();
   init_config2();
+  init_agent_drivers();
   init_storage();
   init_client2();
+  init_machine();
 });
 
 // src/commands/task-started.ts
@@ -11573,12 +12058,12 @@ __export(exports_file_content, {
   resolveContent: () => resolveContent,
   readFileContent: () => readFileContent
 });
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 import { resolve } from "path";
 function readFileContent(filePath, optionName) {
   const absolutePath = resolve(process.cwd(), filePath);
   try {
-    return readFileSync3(absolutePath, "utf-8");
+    return readFileSync5(absolutePath, "utf-8");
   } catch (err) {
     const nodeErr = err;
     throw new Error(`Cannot read file for --${optionName}: ${absolutePath}
@@ -12062,6 +12547,610 @@ var init_artifact = __esm(() => {
   init_file_content();
 });
 
+// src/commands/machine/pid.ts
+import { existsSync as existsSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2, mkdirSync as mkdirSync4 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join5 } from "node:path";
+function ensureChatroomDir() {
+  if (!existsSync4(CHATROOM_DIR4)) {
+    mkdirSync4(CHATROOM_DIR4, { recursive: true, mode: 448 });
+  }
+}
+function getPidFilePath() {
+  return join5(CHATROOM_DIR4, PID_FILE);
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readPid() {
+  const pidPath = getPidFilePath();
+  if (!existsSync4(pidPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync6(pidPath, "utf-8").trim();
+    const pid = parseInt(content, 10);
+    if (isNaN(pid) || pid <= 0) {
+      return null;
+    }
+    return pid;
+  } catch {
+    return null;
+  }
+}
+function writePid() {
+  ensureChatroomDir();
+  const pidPath = getPidFilePath();
+  writeFileSync4(pidPath, process.pid.toString(), "utf-8");
+}
+function removePid() {
+  const pidPath = getPidFilePath();
+  try {
+    if (existsSync4(pidPath)) {
+      unlinkSync2(pidPath);
+    }
+  } catch {}
+}
+function isDaemonRunning() {
+  const pid = readPid();
+  if (pid === null) {
+    return { running: false, pid: null };
+  }
+  if (isProcessRunning(pid)) {
+    return { running: true, pid };
+  }
+  removePid();
+  return { running: false, pid: null };
+}
+function acquireLock() {
+  const { running, pid } = isDaemonRunning();
+  if (running) {
+    console.error(`❌ Daemon already running (PID: ${pid})`);
+    return false;
+  }
+  writePid();
+  return true;
+}
+function releaseLock() {
+  removePid();
+}
+var CHATROOM_DIR4, PID_FILE = "daemon.pid";
+var init_pid = __esm(() => {
+  CHATROOM_DIR4 = join5(homedir4(), ".chatroom");
+});
+
+// src/commands/machine/daemon-start.ts
+import { execSync as execSync3 } from "node:child_process";
+import { stat } from "node:fs/promises";
+function parseMachineCommand(raw) {
+  switch (raw.type) {
+    case "ping":
+      return { _id: raw._id, type: "ping", payload: {}, createdAt: raw.createdAt };
+    case "status":
+      return { _id: raw._id, type: "status", payload: {}, createdAt: raw.createdAt };
+    case "start-agent": {
+      const { chatroomId, role, agentHarness } = raw.payload;
+      if (!chatroomId || !role || !agentHarness) {
+        console.error(`   ⚠️  Invalid start-agent command: missing chatroomId, role, or agentHarness`);
+        return null;
+      }
+      return {
+        _id: raw._id,
+        type: "start-agent",
+        payload: {
+          chatroomId,
+          role,
+          agentHarness,
+          model: raw.payload.model,
+          workingDir: raw.payload.workingDir
+        },
+        createdAt: raw.createdAt
+      };
+    }
+    case "stop-agent": {
+      const { chatroomId, role } = raw.payload;
+      if (!chatroomId || !role) {
+        console.error(`   ⚠️  Invalid stop-agent command: missing chatroomId or role`);
+        return null;
+      }
+      return {
+        _id: raw._id,
+        type: "stop-agent",
+        payload: { chatroomId, role },
+        createdAt: raw.createdAt
+      };
+    }
+    default:
+      return null;
+  }
+}
+function formatTimestamp() {
+  return new Date().toISOString().replace("T", " ").substring(0, 19);
+}
+function verifyPidOwnership(pid, expectedHarness) {
+  try {
+    process.kill(pid, 0);
+  } catch {
+    return false;
+  }
+  if (!expectedHarness) {
+    return true;
+  }
+  try {
+    const platform = process.platform;
+    let processName = "";
+    if (platform === "darwin" || platform === "linux") {
+      processName = execSync3(`ps -p ${pid} -o comm= 2>/dev/null`, {
+        encoding: "utf-8",
+        timeout: 3000
+      }).trim();
+    }
+    if (!processName) {
+      return true;
+    }
+    const harnessLower = expectedHarness.toLowerCase();
+    const procLower = processName.toLowerCase();
+    return procLower.includes(harnessLower) || procLower.includes("node") || procLower.includes("bun");
+  } catch {
+    return true;
+  }
+}
+async function clearAgentPidEverywhere(ctx, chatroomId, role) {
+  try {
+    await ctx.client.mutation(api.machines.updateSpawnedAgent, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      chatroomId,
+      role,
+      pid: undefined
+    });
+  } catch (e) {
+    console.log(`   ⚠️  Failed to clear PID in backend: ${e.message}`);
+  }
+  clearAgentPid(ctx.machineId, chatroomId, role);
+}
+async function recoverAgentState(ctx) {
+  const entries = listAgentEntries(ctx.machineId);
+  if (entries.length === 0) {
+    console.log(`   No agent entries found — nothing to recover`);
+    return;
+  }
+  let recovered = 0;
+  let cleared = 0;
+  for (const { chatroomId, role, entry } of entries) {
+    const { pid, harness } = entry;
+    const alive = verifyPidOwnership(pid, harness);
+    if (alive) {
+      console.log(`   ✅ Recovered: ${role} (PID ${pid}, harness: ${harness})`);
+      recovered++;
+    } else {
+      console.log(`   \uD83E\uDDF9 Stale PID ${pid} for ${role} — clearing`);
+      await clearAgentPidEverywhere(ctx, chatroomId, role);
+      cleared++;
+    }
+  }
+  console.log(`   Recovery complete: ${recovered} alive, ${cleared} stale cleared`);
+}
+function handlePing() {
+  console.log(`   ↪ Responding: pong`);
+  return { result: "pong", failed: false };
+}
+function handleStatus(ctx) {
+  const result = JSON.stringify({
+    hostname: ctx.config?.hostname,
+    os: ctx.config?.os,
+    availableHarnesses: ctx.config?.availableHarnesses,
+    chatroomAgents: Object.keys(ctx.config?.chatroomAgents ?? {})
+  });
+  console.log(`   ↪ Responding with status`);
+  return { result, failed: false };
+}
+async function handleStartAgent(ctx, command) {
+  const { chatroomId, role, agentHarness, model, workingDir } = command.payload;
+  console.log(`   ↪ start-agent command received`);
+  console.log(`      Chatroom: ${chatroomId}`);
+  console.log(`      Role: ${role}`);
+  console.log(`      Harness: ${agentHarness}`);
+  if (model) {
+    console.log(`      Model: ${model}`);
+  }
+  let agentContext = getAgentContext(chatroomId, role);
+  if (!agentContext && workingDir) {
+    console.log(`   No local agent context, using workingDir from command payload`);
+    updateAgentContext(chatroomId, role, agentHarness, workingDir);
+    agentContext = getAgentContext(chatroomId, role);
+  }
+  if (!agentContext) {
+    const msg = `No agent context found for ${chatroomId}/${role}`;
+    console.log(`   ⚠️  ${msg}`);
+    return { result: msg, failed: true };
+  }
+  console.log(`      Working dir: ${agentContext.workingDir}`);
+  try {
+    const dirStat = await stat(agentContext.workingDir);
+    if (!dirStat.isDirectory()) {
+      const msg = `Working directory is not a directory: ${agentContext.workingDir}`;
+      console.log(`   ⚠️  ${msg}`);
+      return { result: msg, failed: true };
+    }
+  } catch {
+    const msg = `Working directory does not exist: ${agentContext.workingDir}`;
+    console.log(`   ⚠️  ${msg}`);
+    return { result: msg, failed: true };
+  }
+  const convexUrl = getConvexUrl();
+  const initPromptResult = await ctx.client.query(api.messages.getInitPrompt, {
+    sessionId: ctx.sessionId,
+    chatroomId,
+    role,
+    convexUrl
+  });
+  if (!initPromptResult?.prompt) {
+    const msg = "Failed to fetch init prompt from backend";
+    console.log(`   ⚠️  ${msg}`);
+    return { result: msg, failed: true };
+  }
+  console.log(`   Fetched split init prompt from backend`);
+  const harnessVersion = ctx.config?.harnessVersions?.[agentHarness];
+  const registry = getDriverRegistry();
+  let driver;
+  try {
+    driver = registry.get(agentHarness);
+  } catch {
+    const msg = `No driver registered for harness: ${agentHarness}`;
+    console.log(`   ⚠️  ${msg}`);
+    return { result: msg, failed: true };
+  }
+  const startResult = await driver.start({
+    workingDir: agentContext.workingDir,
+    rolePrompt: initPromptResult.rolePrompt,
+    initialMessage: initPromptResult.initialMessage,
+    harnessVersion: harnessVersion ?? undefined,
+    model
+  });
+  if (startResult.success && startResult.handle) {
+    const msg = `Agent spawned (PID: ${startResult.handle.pid})`;
+    console.log(`   ✅ ${msg}`);
+    if (startResult.handle.pid) {
+      try {
+        await ctx.client.mutation(api.machines.updateSpawnedAgent, {
+          sessionId: ctx.sessionId,
+          machineId: ctx.machineId,
+          chatroomId,
+          role,
+          pid: startResult.handle.pid
+        });
+        console.log(`   Updated backend with PID: ${startResult.handle.pid}`);
+        persistAgentPid(ctx.machineId, chatroomId, role, startResult.handle.pid, agentHarness);
+      } catch (e) {
+        console.log(`   ⚠️  Failed to update PID in backend: ${e.message}`);
+      }
+    }
+    return { result: msg, failed: false };
+  }
+  console.log(`   ⚠️  ${startResult.message}`);
+  return { result: startResult.message, failed: true };
+}
+async function handleStopAgent(ctx, command) {
+  const { chatroomId, role } = command.payload;
+  console.log(`   ↪ stop-agent command received`);
+  console.log(`      Chatroom: ${chatroomId}`);
+  console.log(`      Role: ${role}`);
+  const configsResult = await ctx.client.query(api.machines.getAgentConfigs, {
+    sessionId: ctx.sessionId,
+    chatroomId
+  });
+  const targetConfig = configsResult.configs.find((c) => c.machineId === ctx.machineId && c.role.toLowerCase() === role.toLowerCase());
+  if (!targetConfig?.spawnedAgentPid) {
+    const msg = "No running agent found (no PID recorded)";
+    console.log(`   ⚠️  ${msg}`);
+    return { result: msg, failed: true };
+  }
+  const pidToKill = targetConfig.spawnedAgentPid;
+  const agentHarness = targetConfig.agentType || undefined;
+  console.log(`   Stopping agent with PID: ${pidToKill}`);
+  const stopHandle = {
+    harness: agentHarness || "opencode",
+    type: "process",
+    pid: pidToKill,
+    workingDir: ""
+  };
+  const registry = getDriverRegistry();
+  let stopDriver;
+  try {
+    stopDriver = agentHarness ? registry.get(agentHarness) : null;
+  } catch {
+    stopDriver = null;
+  }
+  const isAlive = stopDriver ? await stopDriver.isAlive(stopHandle) : verifyPidOwnership(pidToKill, agentHarness);
+  if (!isAlive) {
+    console.log(`   ⚠️  PID ${pidToKill} does not appear to belong to the expected agent`);
+    await clearAgentPidEverywhere(ctx, chatroomId, role);
+    console.log(`   Cleared stale PID`);
+    return {
+      result: `PID ${pidToKill} appears stale (process not found or belongs to different program)`,
+      failed: true
+    };
+  }
+  try {
+    if (stopDriver) {
+      await stopDriver.stop(stopHandle);
+    } else {
+      process.kill(pidToKill, "SIGTERM");
+    }
+    const msg = `Agent stopped (PID: ${pidToKill})`;
+    console.log(`   ✅ ${msg}`);
+    await clearAgentPidEverywhere(ctx, chatroomId, role);
+    console.log(`   Cleared PID`);
+    return { result: msg, failed: false };
+  } catch (e) {
+    const err = e;
+    if (err.code === "ESRCH") {
+      await clearAgentPidEverywhere(ctx, chatroomId, role);
+      const msg2 = "Process not found (may have already exited)";
+      console.log(`   ⚠️  ${msg2}`);
+      return { result: msg2, failed: true };
+    }
+    const msg = `Failed to stop agent: ${err.message}`;
+    console.log(`   ⚠️  ${msg}`);
+    return { result: msg, failed: true };
+  }
+}
+async function processCommand(ctx, command) {
+  console.log(`[${formatTimestamp()}] \uD83D\uDCE8 Command received: ${command.type}`);
+  try {
+    await ctx.client.mutation(api.machines.ackCommand, {
+      sessionId: ctx.sessionId,
+      commandId: command._id,
+      status: "processing"
+    });
+    let commandResult;
+    switch (command.type) {
+      case "ping":
+        commandResult = handlePing();
+        break;
+      case "status":
+        commandResult = handleStatus(ctx);
+        break;
+      case "start-agent":
+        commandResult = await handleStartAgent(ctx, command);
+        break;
+      case "stop-agent":
+        commandResult = await handleStopAgent(ctx, command);
+        break;
+      default: {
+        const _exhaustive = command;
+        commandResult = {
+          result: `Unknown command type: ${_exhaustive.type}`,
+          failed: true
+        };
+      }
+    }
+    const finalStatus = commandResult.failed ? "failed" : "completed";
+    await ctx.client.mutation(api.machines.ackCommand, {
+      sessionId: ctx.sessionId,
+      commandId: command._id,
+      status: finalStatus,
+      result: commandResult.result
+    });
+    if (commandResult.failed) {
+      console.log(`   ❌ Command failed: ${commandResult.result}`);
+    } else {
+      console.log(`   ✅ Command completed`);
+    }
+  } catch (error) {
+    console.error(`   ❌ Command failed: ${error.message}`);
+    try {
+      await ctx.client.mutation(api.machines.ackCommand, {
+        sessionId: ctx.sessionId,
+        commandId: command._id,
+        status: "failed",
+        result: error.message
+      });
+    } catch {}
+  }
+}
+async function initDaemon() {
+  if (!acquireLock()) {
+    process.exit(1);
+  }
+  const convexUrl = getConvexUrl();
+  const sessionId = getSessionId();
+  if (!sessionId) {
+    const otherUrls = getOtherSessionUrls();
+    console.error(`❌ Not authenticated for: ${convexUrl}`);
+    if (otherUrls.length > 0) {
+      console.error(`
+\uD83D\uDCA1 You have sessions for other environments:`);
+      for (const url of otherUrls) {
+        console.error(`   • ${url}`);
+      }
+    }
+    console.error(`
+Run: chatroom auth login`);
+    releaseLock();
+    process.exit(1);
+  }
+  const machineId = getMachineId();
+  if (!machineId) {
+    console.error(`❌ Machine not registered`);
+    console.error(`
+Run any chatroom command first to register this machine,`);
+    console.error(`for example: chatroom auth status`);
+    releaseLock();
+    process.exit(1);
+  }
+  const client2 = await getConvexClient();
+  const typedSessionId = sessionId;
+  try {
+    await client2.mutation(api.machines.updateDaemonStatus, {
+      sessionId: typedSessionId,
+      machineId,
+      connected: true
+    });
+  } catch (error) {
+    console.error(`❌ Failed to update daemon status: ${error.message}`);
+    releaseLock();
+    process.exit(1);
+  }
+  const config3 = loadMachineConfig();
+  const ctx = { client: client2, sessionId: typedSessionId, machineId, config: config3 };
+  console.log(`[${formatTimestamp()}] \uD83D\uDE80 Daemon started`);
+  console.log(`   Machine ID: ${machineId}`);
+  console.log(`   Hostname: ${config3?.hostname ?? "Unknown"}`);
+  console.log(`   Available harnesses: ${config3?.availableHarnesses.join(", ") || "none"}`);
+  console.log(`   PID: ${process.pid}`);
+  console.log(`
+[${formatTimestamp()}] \uD83D\uDD04 Recovering agent state...`);
+  try {
+    await recoverAgentState(ctx);
+  } catch (e) {
+    console.log(`   ⚠️  Recovery failed: ${e.message}`);
+    console.log(`   Continuing with fresh state`);
+  }
+  return ctx;
+}
+async function startCommandLoop(ctx) {
+  const shutdown = async () => {
+    console.log(`
+[${formatTimestamp()}] Shutting down...`);
+    try {
+      await ctx.client.mutation(api.machines.updateDaemonStatus, {
+        sessionId: ctx.sessionId,
+        machineId: ctx.machineId,
+        connected: false
+      });
+    } catch {}
+    releaseLock();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  process.on("SIGHUP", shutdown);
+  const wsClient2 = await getConvexWsClient();
+  const commandQueue = [];
+  const queuedCommandIds = new Set;
+  let drainingQueue = false;
+  const enqueueCommands = (commands) => {
+    for (const command of commands) {
+      const commandId = command._id.toString();
+      if (queuedCommandIds.has(commandId))
+        continue;
+      queuedCommandIds.add(commandId);
+      commandQueue.push(command);
+    }
+  };
+  const drainQueue = async () => {
+    if (drainingQueue)
+      return;
+    drainingQueue = true;
+    try {
+      while (commandQueue.length > 0) {
+        const command = commandQueue.shift();
+        const commandId = command._id.toString();
+        queuedCommandIds.delete(commandId);
+        try {
+          await processCommand(ctx, command);
+        } catch (error) {
+          console.error(`   ❌ Command processing failed: ${error.message}`);
+        }
+      }
+    } finally {
+      drainingQueue = false;
+    }
+  };
+  console.log(`
+Listening for commands...`);
+  console.log(`Press Ctrl+C to stop
+`);
+  wsClient2.onUpdate(api.machines.getPendingCommands, {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId
+  }, async (result) => {
+    if (!result.commands || result.commands.length === 0)
+      return;
+    const parsed = result.commands.map(parseMachineCommand).filter((c) => c !== null);
+    enqueueCommands(parsed);
+    await drainQueue();
+  });
+  return await new Promise(() => {});
+}
+async function daemonStart() {
+  const ctx = await initDaemon();
+  await startCommandLoop(ctx);
+}
+var init_daemon_start = __esm(() => {
+  init_pid();
+  init_api3();
+  init_agent_drivers();
+  init_storage();
+  init_client2();
+  init_machine();
+});
+
+// src/commands/machine/daemon-stop.ts
+async function daemonStop() {
+  const { running, pid } = isDaemonRunning();
+  if (!running) {
+    console.log(`⚪ Daemon is not running`);
+    return;
+  }
+  console.log(`Stopping daemon (PID: ${pid})...`);
+  try {
+    process.kill(pid, "SIGTERM");
+    await new Promise((resolve2) => setTimeout(resolve2, 1000));
+    try {
+      process.kill(pid, 0);
+      console.log(`Process did not exit gracefully, forcing...`);
+      process.kill(pid, "SIGKILL");
+    } catch {}
+    removePid();
+    console.log(`✅ Daemon stopped`);
+  } catch (error) {
+    console.error(`❌ Failed to stop daemon: ${error.message}`);
+    removePid();
+  }
+}
+var init_daemon_stop = __esm(() => {
+  init_pid();
+});
+
+// src/commands/machine/daemon-status.ts
+async function daemonStatus() {
+  const { running, pid } = isDaemonRunning();
+  if (running) {
+    console.log(`✅ Daemon is running`);
+    console.log(`   PID: ${pid}`);
+    console.log(`   PID file: ${getPidFilePath()}`);
+  } else {
+    console.log(`⚪ Daemon is not running`);
+    console.log(`
+To start the daemon:`);
+    console.log(`   chatroom machine daemon start`);
+  }
+}
+var init_daemon_status = __esm(() => {
+  init_pid();
+});
+
+// src/commands/machine/index.ts
+var exports_machine = {};
+__export(exports_machine, {
+  daemonStop: () => daemonStop,
+  daemonStatus: () => daemonStatus,
+  daemonStart: () => daemonStart
+});
+var init_machine2 = __esm(() => {
+  init_daemon_start();
+  init_daemon_stop();
+  init_daemon_status();
+});
+
 // src/commands/opencode-install.ts
 var exports_opencode_install = {};
 __export(exports_opencode_install, {
@@ -12069,8 +13158,8 @@ __export(exports_opencode_install, {
 });
 async function isChatroomInstalled() {
   try {
-    const { execSync } = await import("child_process");
-    execSync("chatroom --version", { stdio: "pipe" });
+    const { execSync: execSync4 } = await import("child_process");
+    execSync4("chatroom --version", { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -12765,8 +13854,23 @@ artifactCommand.command("view-many").description("View multiple artifacts").requ
     artifactIds: options.artifact || []
   });
 });
-var opencodeCommand = program2.command("opencode").description("OpenCode integration tools");
-opencodeCommand.command("install").description("Install chatroom as an OpenCode tool").option("--force", "Overwrite existing tool installation").action(async (options) => {
+var machineCommand = program2.command("machine").description("Machine daemon management for remote agent control");
+var daemonCommand = machineCommand.command("daemon").description("Manage the machine daemon");
+daemonCommand.command("start").description("Start the machine daemon to listen for remote commands").action(async () => {
+  await maybeRequireAuth();
+  const { daemonStart: daemonStart2 } = await Promise.resolve().then(() => (init_machine2(), exports_machine));
+  await daemonStart2();
+});
+daemonCommand.command("stop").description("Stop the running machine daemon").action(async () => {
+  const { daemonStop: daemonStop2 } = await Promise.resolve().then(() => (init_machine2(), exports_machine));
+  await daemonStop2();
+});
+daemonCommand.command("status").description("Check if the machine daemon is running").action(async () => {
+  const { daemonStatus: daemonStatus2 } = await Promise.resolve().then(() => (init_machine2(), exports_machine));
+  await daemonStatus2();
+});
+var opencodeCommand = program2.command("opencode").description("OpenCode integration harness");
+opencodeCommand.command("install").description("Install chatroom as an OpenCode harness").option("--force", "Overwrite existing harness installation").action(async (options) => {
   const { installTool: installTool2 } = await Promise.resolve().then(() => exports_opencode_install);
   await installTool2({ checkExisting: !options.force });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatroom-cli",
-  "version": "1.0.65",
+  "version": "1.0.66",
   "description": "CLI for multi-agent chatroom collaboration",
   "type": "module",
   "bin": {
@@ -34,7 +34,7 @@
     "convex"
   ],
   "author": "",
-  "license": "ISC",
+  "license": "Elastic-2.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/conradkoh/chatroom"