coxpit 3.2.2 → 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.2",
+  "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",

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,9 +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();
 
 // 첫 실행 시 로컬 머신 시드(데몬이 도는 이 기계).
@@ -16,4 +20,12 @@ 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/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.2' }));
+  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));