npm - coxpit - Versions diffs - 3.2.2 → 3.4.0 - Mend

coxpit 3.2.2 → 3.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/README.md CHANGED Viewed

@@ -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) |
@@ -75,6 +75,16 @@ Your keys and login never touch coxpit's config or database.
 Running on the open internet? Put it behind your own front door (Tailscale, Cloudflare Access, a reverse proxy with TLS) and keep basic auth on — it exposes shells.
+## Platform support
+| platform | daemon | agent runs |
+|---|---|---|
+| macOS / Linux | ✅ first-class | ✅ |
+| Windows (WSL2) | ✅ run the daemon inside WSL | ✅ |
+| Windows (native) | ⚠️ board + remote machines only | ❌ needs a POSIX shell + tmux |
+On Windows, install the daemon inside WSL2 (`npm i -g coxpit`) — WSL2 forwards `localhost`, so the Windows desktop app detects the WSL daemon and attaches to it automatically. A native Windows daemon still serves the board and can drive **remote** (ssh) machines, but the local machine will fail its readiness checks (no tmux).
 ## Architecture
 ```
@@ -87,6 +97,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 CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "coxpit",
-  "version": "3.2.2",
+  "version": "3.4.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/board.ts CHANGED Viewed

@@ -37,6 +37,9 @@ export const BOARD_HTML = /* html */ `<!doctype html>
   .brand{display:flex;align-items:baseline;gap:9px;font-family:var(--mono)}
   .brand .mark{color:var(--brand);font-size:15px;font-weight:700;letter-spacing:.01em}
   .brand .sub{color:var(--faint);font-size:11px;text-transform:uppercase;letter-spacing:.14em}
+  .daemon-badge{font-family:var(--mono);font-size:10.5px;color:var(--faint);padding:3px 9px;
+    border:1px solid var(--line);border-radius:999px;background:var(--surface);cursor:default}
+  .daemon-badge b{color:var(--muted);font-weight:500}
   .ws{display:flex;align-items:center;gap:7px;font-family:var(--mono);font-size:11px;color:var(--muted);
     padding:4px 10px;border:1px solid var(--line);border-radius:999px;background:var(--surface)}
   .dot{width:7px;height:7px;border-radius:50%;background:var(--s-failed);transition:background .3s}
@@ -155,6 +158,7 @@ export const BOARD_HTML = /* html */ `<!doctype html>
   @media (prefers-reduced-motion:reduce){.chip.running i{animation:none}.card:hover{transform:none}}
   .meta{display:flex;gap:16px;padding:0 14px 10px;font-family:var(--mono);font-size:11px;color:var(--faint)}
   .meta b{color:var(--muted);font-weight:500;font-variant-numeric:tabular-nums}
+  .meta .resumable{color:var(--brand);opacity:.75}
   .log{border-top:1px solid var(--line);background:#0e1118;padding:10px 14px;font-family:var(--mono);
     font-size:11px;height:150px;overflow:auto;display:flex;flex-direction:column;gap:4px}
   .ev{display:flex;gap:9px;align-items:baseline;min-width:0}
@@ -302,6 +306,7 @@ export const BOARD_HTML = /* html */ `<!doctype html>
 <body>
 <header>
   <div class="brand"><span class="mark">coxpit</span><span class="sub">fleet console</span></div>
+  <span class="daemon-badge" id="daemonBadge" style="display:none"></span>
   <div class="ws"><span class="dot" id="wsdot"></span><span id="wstext">connecting</span></div>
   <button class="btn-ghost sm" id="bell" title="notify when a run settles">🔕</button>
   <div class="machines" id="machines"></div>
@@ -761,6 +766,8 @@ function cardHTML(r){
     + '<div class="meta"><span>branch <b>'+esc(r.branch||'—')+'</b></span>'
     + '<span>files <b>'+(r.filesChanged??0)+'</b></span>'
     + '<span>'+esc(r.agent||'')+'</span>'
+    + (r.sessionId && ['done','failed','stopped'].includes(r.status)
+        ? '<span class="resumable" title="agent session preserved — open the run and Send a next instruction to continue">↻ resumable</span>' : '')
     + (r.prUrl ? '<a href="'+esc(r.prUrl)+'" target="_blank" rel="noopener" style="margin-left:auto">PR ↗</a>' : '')
     + '</div>'
     + '<div class="log">'+evs+'</div></div>';
@@ -781,6 +788,14 @@ async function hydrate(){
   (r.tasks||[]).forEach(t => tasks.set(t.id, t));
   runs.clear();
   (r.runs||[]).forEach(rn => runs.set(rn.id, { ...rn, events: rn.events||[] }));
+  if (r.daemon) {
+    const d = r.daemon;
+    const db = String(d.dbPath||'').replace(/^\\/(?:Users|home)\\/[^/]+/, '~');
+    const el = $('daemonBadge');
+    el.innerHTML = 'daemon <b>v'+esc(String(d.version||'?'))+'</b> · :'+esc(String(d.port||'?'));
+    el.title = 'pid '+d.pid+' · db '+db;
+    el.style.display = '';
+  }
   paintSidebar(); render();
 }
 function paintSidebar(){

package/src/config.ts CHANGED Viewed

@@ -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,40 @@ 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();
+// 버전 SSOT = package.json (하드코딩 문자열 이중화 방지)
+const pkgVersion: string = (() => {
+  try {
+    return JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version ?? '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+})();
 /** 런타임 설정. 시크릿은 전부 env 주입(번들 0). */
 export const config = {
+  version: pkgVersion,
   // 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 CHANGED Viewed

@@ -1,9 +1,23 @@
 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';
+// Windows 네이티브는 에이전트 실행 계층(sh·tmux·git worktree over sh)이 성립하지 않는다.
+// 보드/원격 머신 관제는 되지만 로컬 run 은 불가 — WSL 데몬을 안내한다.
+if (process.platform === 'win32') {
+  console.warn(
+    '[coxpit] Windows detected: local agent runs need a POSIX shell + tmux, which Windows lacks.\n' +
+    '[coxpit] Run the daemon inside WSL2 (npm i -g coxpit) and connect from the browser or desktop app,\n' +
+    '[coxpit] or register remote (ssh) machines only — the local machine will fail readiness checks.',
+  );
+}
+// DB 를 열기 전에 단일 데몬 보장 — 이미 떠 있으면 그 URL 을 안내하고 종료.
+await acquireDaemonLock();
 await ensureSchema();
 // 첫 실행 시 로컬 머신 시드(데몬이 도는 이 기계).
@@ -16,4 +30,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 ADDED Viewed

@@ -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 CHANGED Viewed

@@ -42,6 +42,25 @@ async function setRun(runId: number, patch: Partial<typeof agentRuns.$inferInser
 const liveChildren = new Map<number, ChildProcess>();
 const stoppedRuns = new Set<number>();
+/**
+ * 원격 에이전트 kill 스크립트 — pid 파일 기준.
+ * $$ 가 그룹 리더가 아닐 수 있어 ps 로 실제 pgid 를 조회해 그룹째 죽인다
+ * (pkill -P 폴백은 직계 자식만 잡아 에이전트가 띄운 손자 프로세스가 잔존했음).
+ * TERM 후에도 살아 있으면 KILL 로 에스컬레이션, 끝나면 pid 파일 제거.
+ */
+function remoteKillScript(worktreePath: string): string {
+  const pidFile = shq(`${worktreePath}/.coxpit-agent.pid`);
+  return (
+    `P=$(cat ${pidFile} 2>/dev/null); [ -n "$P" ] && {` +
+    ` PG=$(ps -o pgid= -p "$P" 2>/dev/null | tr -d ' ');` +
+    ` kill -TERM -"\${PG:-$P}" 2>/dev/null || { pkill -TERM -P "$P" 2>/dev/null; kill -TERM "$P" 2>/dev/null; };` +
+    ` sleep 2;` +
+    ` kill -0 "$P" 2>/dev/null && { kill -KILL -"\${PG:-$P}" 2>/dev/null || { pkill -KILL -P "$P" 2>/dev/null; kill -KILL "$P" 2>/dev/null; }; };` +
+    ` rm -f ${pidFile};` +
+    ` } ; true`
+  );
+}
 interface RunContext {
   runId: number;
   machine: MachineTarget;
@@ -313,13 +332,8 @@ export async function stopRun(runId: number): Promise<{ ok: boolean; detail: str
   const rr = await db.select().from(agentRuns).where(eq(agentRuns.id, runId)).limit(1);
   const run = rr[0];
   if (ctx && run && ctx.machine.kind !== 'local' && ctx.machine.address !== '' && run.worktreePath) {
-    const pidFile = shq(`${run.worktreePath}/.coxpit-agent.pid`);
-    // 그룹 kill(-P, sshd 는 커맨드 셸을 세션리더로 띄워 성립) → 실패 시 자식(pkill -P)+본체 순.
-    await runShellOn(
-      ctx.machine,
-      `P=$(cat ${pidFile} 2>/dev/null) && { kill -TERM -"$P" 2>/dev/null || { pkill -TERM -P "$P" 2>/dev/null; kill -TERM "$P" 2>/dev/null; }; } || true`,
-      8000,
-    );
+    // pgid 조회 그룹 kill + TERM→KILL 에스컬레이션(스크립트 내 sleep 2 포함 — 타임아웃 여유).
+    await runShellOn(ctx.machine, remoteKillScript(run.worktreePath), 15000);
   }
   // 로컬(또는 ssh 채널) 프로세스 그룹 종료 — sh 손자(실제 에이전트) 포함.
@@ -749,6 +763,10 @@ export async function cleanupRun(runId: number): Promise<{ ok: boolean; detail:
   const rr = await db.select().from(agentRuns).where(eq(agentRuns.id, runId)).limit(1);
   const run = rr[0];
   if (!ctx || !run || !run.worktreePath) return { ok: false, detail: 'no worktree' };
+  // 원격에 잔존 에이전트가 있으면 worktree 제거 전에 죽인다(파일 잠금·좀비 방지).
+  if (ctx.machine.kind !== 'local' && ctx.machine.address !== '') {
+    await runShellOn(ctx.machine, remoteKillScript(run.worktreePath), 15000);
+  }
   await runShellOn(ctx.machine, `tmux kill-session -t ${shq(`=coxpit-r${runId}`)} 2>/dev/null || true`, 8000);
   const rm = await runShellOn(
     ctx.machine,

package/src/server.ts CHANGED Viewed

@@ -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: config.version }));
   // 플릿 보드(단일 페이지). 인증 게이트 적용됨.
   app.get('/', async (_req, reply) => reply.type('text/html').send(BOARD_HTML));
@@ -57,6 +57,8 @@ export async function buildServer(): Promise<FastifyInstance> {
     return {
       machines: ms, repos: rs, tasks: ts, captures: dcs,
       runs: rns.map((r) => ({ ...r, events: byRun.get(r.id) ?? [] })),
+      // 보드 헤더 "어느 데몬에 붙어 있나" 표시용 (인증 뒤라 dbPath 노출 가능)
+      daemon: { version: config.version, pid: process.pid, port: config.port, dbPath: config.dbPath },
     };
   });
@@ -502,7 +504,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.2' }));
+    socket.send(JSON.stringify({ type: 'hello', name: 'coxpit-fleet', version: config.version }));
     socket.on('close', () => removeSink(socket));
   });