coxpit 3.2.1 → 3.3.0

package/README.md

@@ -64,7 +64,7 @@ Your keys and login never touch coxpit's config or database.
 | env | default | what |
 |---|---|---|
 | `COXPIT_HOST` / `COXPIT_PORT` | `127.0.0.1` / `8210` | daemon bind |
-| `COXPIT_DB` | `./coxpit.db` | SQLite (libSQL) file |
+| `COXPIT_DB` | `~/.coxpit/coxpit.db` | SQLite (libSQL) file (a legacy `./coxpit.db` in the cwd is still honored) |
 | `COXPIT_AUTH_PASS` / `COXPIT_AUTH_USER` | — / `admin` | basic auth (empty pass = open; set it) |
 | `COXPIT_AUTH_DISABLED` | — | `1` disables auth (local dev only) |
 | `COXPIT_SSH_KEY` | — | private key for remote machines (else ssh defaults/agent) |
@@ -87,6 +87,8 @@ machines — git worktrees · tmux sessions · agent CLIs
 
 One daemon, one SQLite file, zero external services. Machines are reached over SSH; the local machine is just `sh`.
 
+**One daemon per machine.** Every install method shares `~/.coxpit/` — the daemon takes a lock there (`daemon.lock.json`) and refuses to start if another daemon already owns the database (running two would corrupt each other's live runs). The desktop app checks for a running daemon first and attaches to it (prompting for its basic auth if set); it only spawns its own embedded daemon when none is running. So npm CLI, launchd/systemd service, and the desktop app all see the same machines, tasks, and run history.
+
 ## Status
 
 `v3.0` — fleet, compare/merge, terminal, Design Mode, run destinations (merge · export · PR), swarm (plan fan-out + integrate with conflict-resolving agents), AI review, and sessions (work/ask + notifications) — all shipped and e2e-tested. Roadmap: ROADMAP.md.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coxpit",
-  "version": "3.2.1",
+  "version": "3.3.0",
   "description": "Self-hosted cockpit for running a fleet of AI coding agents across your own machines — parallel worktree runs, live board, compare & merge, web terminal, design capture.",
   "type": "module",
   "license": "MIT",
@@ -44,9 +44,9 @@
   "dependencies": {
     "@fastify/websocket": "^11",
     "@libsql/client": "^0.14",
-    "@xterm/addon-fit": "^0.11.0",
-    "@xterm/addon-unicode11": "^0.9.0",
-    "@xterm/xterm": "^6.0.0",
+    "@xterm/addon-fit": "^0.10.0",
+    "@xterm/addon-unicode11": "^0.8.0",
+    "@xterm/xterm": "^5.5.0",
     "dotenv": "^16",
     "drizzle-orm": "^0.38",
     "fastify": "^5",

package/src/config.ts

@@ -1,4 +1,7 @@
 import 'dotenv/config';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 
 // GUI 앱(Finder/데스크톱)에서 뜨면 PATH 가 최소(/usr/bin:/bin...)라 brew 로 설치한
 // 도구(claude·tmux·git)를 못 찾는다 — 표준 설치 경로를 부팅 시 1회 보강한다.
@@ -24,13 +27,30 @@ import 'dotenv/config';
   if (process.env.LC_ALL && !/utf-?8/i.test(process.env.LC_ALL)) delete process.env.LC_ALL;
 }
 
+// 기본 DB 경로 — npm/dmg 어느 설치든 같은 상태를 보도록 ~/.coxpit 로 통일한다.
+// 구버전(cwd 상대 ./coxpit.db)로 쌓아온 사용자는 그 파일이 존재하는 한 그대로 존중.
+function defaultDbPath(): string {
+  const legacy = path.resolve('./coxpit.db');
+  if (fs.existsSync(legacy)) {
+    console.log(`[coxpit] using legacy database at ${legacy} (move it to ~/.coxpit/coxpit.db to adopt the shared default)`);
+    return legacy;
+  }
+  const dir = path.join(os.homedir(), '.coxpit');
+  fs.mkdirSync(dir, { recursive: true });
+  return path.join(dir, 'coxpit.db');
+}
+
+const dbPath = process.env.COXPIT_DB || defaultDbPath();
+
 /** 런타임 설정. 시크릿은 전부 env 주입(번들 0). */
 export const config = {
   // UTF-8 보장된 로케일 — PTY/원격 셸에 명시 전달용
   lang: process.env.LANG!,
   host: process.env.COXPIT_HOST ?? '127.0.0.1',
   port: Number(process.env.COXPIT_PORT ?? 8210),
-  dbPath: process.env.COXPIT_DB ?? './coxpit.db',
+  dbPath,
+  // 단일 데몬 락 파일 — DB 와 같은 폴더(그 DB 를 지키는 락이므로)
+  lockPath: path.join(path.dirname(path.resolve(dbPath)), 'daemon.lock.json'),
   // 원격 머신 SSH 개인키 경로(선택). 없으면 ssh 기본 키/에이전트 사용.
   sshKey: process.env.COXPIT_SSH_KEY ?? '',
   // run 정착 시 POST 할 웹훅(선택) — 텔레그램 브릿지 등 사용자 연결용.

package/src/index.ts

@@ -1,8 +1,13 @@
 import { config } from './config';
 import { db, ensureSchema } from './db';
 import { machines } from './db/schema';
+import { acquireDaemonLock } from './lock';
+import { reconcileOrphanRuns } from './orchestrator';
 import { buildServer } from './server';
 
+// DB 를 열기 전에 단일 데몬 보장 — 이미 떠 있으면 그 URL 을 안내하고 종료.
+await acquireDaemonLock();
+
 await ensureSchema();
 
 // 첫 실행 시 로컬 머신 시드(데몬이 도는 이 기계).
@@ -10,5 +15,17 @@ if ((await db.select().from(machines)).length === 0) {
   await db.insert(machines).values({ slug: 'local', name: 'This machine', kind: 'local', online: true });
 }
 
+// 재시작으로 고아가 된 running run 정산(카드가 영원히 '진행 중'으로 남는 것 방지).
+const orphans = await reconcileOrphanRuns();
+if (orphans > 0) console.log(`[coxpit] settled ${orphans} orphaned run(s) from a previous daemon instance`);
+
 const app = await buildServer();
-await app.listen({ host: config.host, port: config.port });
+try {
+  await app.listen({ host: config.host, port: config.port });
+} catch (e) {
+  if ((e as NodeJS.ErrnoException)?.code === 'EADDRINUSE') {
+    console.error(`[coxpit] port ${config.port} is already in use — is another daemon (or app) running? Set COXPIT_PORT to change.`);
+    process.exit(1);
+  }
+  throw e;
+}

package/src/lock.ts

@@ -0,0 +1,74 @@
+import fs from 'node:fs';
+import { config } from './config';
+
+// 단일 데몬 락 — DB 폴더의 daemon.lock.json.
+// 두 데몬이 같은 DB 를 잡으면 부팅 시 reconcileOrphanRuns() 가 상대 데몬의
+// 살아있는 run 을 고아로 정산해버린다. 락 + 헬스 프로브로 원천 차단한다.
+
+interface LockInfo {
+  pid: number;
+  host: string;
+  port: number;
+}
+
+/** 해당 주소에 살아있는 coxpit 데몬이 있는지 확인 (/api/health 는 인증 면제). */
+export async function probeCoxpit(host: string, port: number, timeoutMs = 1500): Promise<boolean> {
+  try {
+    const ac = new AbortController();
+    const t = setTimeout(() => ac.abort(), timeoutMs);
+    const res = await fetch(`http://${host === '0.0.0.0' ? '127.0.0.1' : host}:${port}/api/health`, { signal: ac.signal });
+    clearTimeout(t);
+    if (!res.ok) return false;
+    const body = (await res.json()) as { name?: string };
+    return body?.name === 'coxpit';
+  } catch {
+    return false;
+  }
+}
+
+export function readLock(lockPath: string): LockInfo | null {
+  try {
+    const raw = JSON.parse(fs.readFileSync(lockPath, 'utf8')) as LockInfo;
+    return Number.isInteger(raw?.pid) && Number.isInteger(raw?.port) ? raw : null;
+  } catch {
+    return null;
+  }
+}
+
+function pidAlive(pid: number): boolean {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+/**
+ * 락 획득. 이미 살아있는 데몬이 같은 DB 를 잡고 있으면 안내 후 종료.
+ * 죽은 프로세스가 남긴 stale 락은 치우고 진행한다.
+ */
+export async function acquireDaemonLock(): Promise<void> {
+  const existing = readLock(config.lockPath);
+  if (existing && existing.pid !== process.pid) {
+    // pid 재사용 오탐을 피하려고 헬스 프로브를 진실로 삼는다.
+    const alive = pidAlive(existing.pid) && (await probeCoxpit(existing.host ?? '127.0.0.1', existing.port));
+    if (alive) {
+      const url = `http://${(existing.host ?? '127.0.0.1') === '0.0.0.0' ? '127.0.0.1' : existing.host}:${existing.port}/`;
+      console.error(
+        `[coxpit] another daemon already owns this database (pid ${existing.pid}, ${url}).\n` +
+        `[coxpit] open that URL instead, or stop it first — running two daemons on one DB corrupts live runs.`,
+      );
+      process.exit(1);
+    }
+    try { fs.unlinkSync(config.lockPath); } catch { /* gone */ }
+  }
+
+  fs.writeFileSync(config.lockPath, JSON.stringify({ pid: process.pid, host: config.host, port: config.port } satisfies LockInfo));
+
+  const release = () => {
+    try {
+      const cur = readLock(config.lockPath);
+      if (cur?.pid === process.pid) fs.unlinkSync(config.lockPath);
+    } catch { /* best effort */ }
+  };
+  process.on('exit', release);
+  for (const sig of ['SIGINT', 'SIGTERM'] as const) {
+    process.on(sig, () => { release(); process.exit(0); });
+  }
+}

package/src/orchestrator.ts

@@ -295,7 +295,17 @@ export async function getRunTermInfo(runId: number): Promise<{ machine: MachineT
  */
 export async function stopRun(runId: number): Promise<{ ok: boolean; detail: string }> {
   const child = liveChildren.get(runId);
-  if (!child) return { ok: false, detail: 'not running' };
+  if (!child) {
+    // 데몬 재시작 등으로 고아가 된 좀비 run — 프로세스는 없는데 DB 만 running.
+    // stop 요청을 정산으로 처리해 카드가 영원히 '진행 중'으로 남지 않게 한다.
+    const zr = (await db.select().from(agentRuns).where(eq(agentRuns.id, runId)).limit(1))[0];
+    if (zr && (zr.status === 'running' || zr.status === 'starting')) {
+      await setRun(runId, { status: 'stopped', endedAt: new Date(), exitSummary: 'orphaned (daemon restarted) — settled by stop' });
+      await recordEvent(runId, 'meta', JSON.stringify({ orphanSettled: true }));
+      return { ok: true, detail: 'no live process — settled as stopped' };
+    }
+    return { ok: false, detail: 'not running' };
+  }
   stoppedRuns.add(runId);
 
   // 원격이면 먼저 원격 프로세스를 pid 파일로 죽인다(ssh 채널만 끊으면 잔존 가능).
@@ -719,6 +729,21 @@ export async function prRun(runId: number): Promise<{ ok: boolean; detail: strin
 /**
  * worktree/브랜치/tmux 정리(태스크 종료·run 폐기 시).
  */
+/**
+ * 부팅 정산 — 데몬 재시작 후 살아있는 자식이 있을 수 없는데 DB 가 running/starting 인
+ * run(고아)을 failed 로 정리한다. workbench('open')는 에이전트가 없으므로 대상 아님.
+ */
+export async function reconcileOrphanRuns(): Promise<number> {
+  const stale = (await db.select().from(agentRuns)).filter(
+    (r) => r.status === 'running' || r.status === 'starting',
+  );
+  for (const r of stale) {
+    await setRun(r.id, { status: 'failed', endedAt: new Date(), exitSummary: 'orphaned by daemon restart' });
+    await recordEvent(r.id, 'error', 'daemon restarted while this run was live — settled as failed (worktree/branch preserved; diff still reviewable)');
+  }
+  return stale.length;
+}
+
 export async function cleanupRun(runId: number): Promise<{ ok: boolean; detail: string }> {
   const ctx = await loadContext(runId);
   const rr = await db.select().from(agentRuns).where(eq(agentRuns.id, runId)).limit(1);

package/src/server.ts

@@ -33,7 +33,7 @@ export async function buildServer(): Promise<FastifyInstance> {
   app.addHook('onRequest', authGate);
 
   // 무인증 헬스(외부 감시용)
-  app.get('/api/health', async () => ({ ok: true, name: 'coxpit', version: '3.2.1' }));
+  app.get('/api/health', async () => ({ ok: true, name: 'coxpit', version: '3.3.0' }));
 
   // 플릿 보드(단일 페이지). 인증 게이트 적용됨.
   app.get('/', async (_req, reply) => reply.type('text/html').send(BOARD_HTML));
@@ -502,7 +502,7 @@ export async function buildServer(): Promise<FastifyInstance> {
   // 라이브 스트림 좌석 — 오케스트레이터가 run/event 를 여기로 broadcast.
   app.get('/ws', { websocket: true }, (socket) => {
     addSink(socket);
-    socket.send(JSON.stringify({ type: 'hello', name: 'coxpit-fleet', version: '3.2.1' }));
+    socket.send(JSON.stringify({ type: 'hello', name: 'coxpit-fleet', version: '3.2.2' }));
     socket.on('close', () => removeSink(socket));
   });