coxpit 4.3.1 → 4.6.0

package/src/server.ts

@@ -13,10 +13,11 @@ import { db } from './db';
 import { machines, repos, tasks, agentRuns, agentEvents, designCaptures, shareLinks, taskGroups } from './db/schema';
 import { BOOKMARKLET_JS } from './design';
 import { runShellOn, shq } from './exec';
-import { launchRun, cleanupRun, stopRun, getRunDiff, loadRunDocs, mergeRun, getRunTermInfo, steerRun, exportRun, prRun, integrateRuns, planFanout, reviewTask, syncRun, openWorkbench, spawnSubtasks, listSubtasks, resolveAgentToken, taskCloseRisk } from './orchestrator';
+import { launchRun, cleanupRun, stopRun, getRunDiff, loadRunDocs, mergeRun, getRunTermInfo, steerRun, exportRun, prRun, integrateRuns, planFanout, reviewTask, syncRun, openWorkbench, spawnSubtasks, listSubtasks, resolveAgentToken, taskCloseRisk, launchGroupTask, isRunLive, askGroupCoordinator } from './orchestrator';
 import { openTerm } from './term';
 import { addSink, removeSink, broadcast } from './hub';
 import { getProvider, listProviders } from './providers';
+import { remoteState, setServe, setFunnel } from './remote';
 import { BOARD_HTML } from './board';
 
 const require_ = createRequire(import.meta.url);
@@ -202,7 +203,11 @@ export async function buildServer(): Promise<FastifyInstance> {
       runs: rns.map((r) => ({ ...r, events: (byRun.get(r.id) ?? []).slice(-EVENT_CAP) })),
       counts: { activeTasks: activeTasks.length, closedTasks: closedCount },
       // 보드 헤더 "어느 데몬에 붙어 있나" 표시용 (인증 뒤라 dbPath 노출 가능)
-      daemon: { version: config.version, pid: process.pid, port: config.port, dbPath: config.dbPath },
+      // authOpen = 비밀번호 미설정 → Funnel(공개) 가드가 켜져야 함(원격접근 카드용)
+      daemon: {
+        version: config.version, pid: process.pid, port: config.port, dbPath: config.dbPath,
+        authOpen: config.auth.disabled || config.auth.pass === '',
+      },
       providers: listProviders(),
     };
   });
@@ -339,7 +344,8 @@ export async function buildServer(): Promise<FastifyInstance> {
     if (!m) return reply.code(404).send({ error: 'machine not found' });
 
     // 기본 브랜치는 "지금 체크아웃된 브랜치"가 아니라 repo 의 진짜 기본값:
-    // origin/HEAD → 로컬 main/master → 현재 HEAD 순으로 감지.
+    // origin/HEAD → 로컬 main/master → 현재 HEAD(symbolic-ref, unborn 무에러) 순으로 감지.
+    // 마지막 세그먼트는 커밋 존재 여부(--verify HEAD) — 커밋 0개 repo 는 등록 거절.
     const g = `git -C ${shq(path)}`;
     const cmd =
       `${g} rev-parse --is-inside-work-tree 2>&1` +
@@ -348,7 +354,9 @@ export async function buildServer(): Promise<FastifyInstance> {
       ` && echo '---C---'` +
       ` && { ${g} show-ref --verify -q refs/heads/main && echo main || { ${g} show-ref --verify -q refs/heads/master && echo master; } || true; }` +
       ` && echo '---D---'` +
-      ` && ${g} rev-parse --abbrev-ref HEAD 2>&1`;
+      ` && { ${g} symbolic-ref --short HEAD 2>/dev/null || true; }` +   // unborn 에서도 무에러
+      ` && echo '---E---'` +
+      ` && { ${g} rev-parse --verify -q HEAD >/dev/null 2>&1 && echo yes || echo no; }`;
     const r = await runShellOn(m, cmd);
     const isRepo = r.ok && /(^|\n)true(\n|$)/.test(r.stdout);
     if (!isRepo) {
@@ -359,9 +367,17 @@ export async function buildServer(): Promise<FastifyInstance> {
     }
     const seg = (a: string, b: string): string =>
       ((r.stdout.split(a)[1] ?? '').split(b)[0] ?? '').trim();
+    const hasCommit = (r.stdout.split('---E---')[1] ?? '').trim() === 'yes';
+    if (!hasCommit) {
+      return reply.code(400).send({
+        error: 'this repository has no commits yet',
+        code: 'NO_COMMITS',
+        hint: 'make an initial commit first — or use Start a new project to have coxpit do it',
+      });
+    }
     const originHead = seg('---B---', '---C---').replace(/^origin\//, '');
     const localMain = seg('---C---', '---D---');
-    const headNow = (r.stdout.split('---D---')[1] ?? '').trim();
+    const headNow = seg('---D---', '---E---');
     const branch = originHead || localMain || headNow || 'main';
     const name = (b.name ?? '').trim() || path.split('/').filter(Boolean).pop() || path;
 
@@ -372,6 +388,63 @@ export async function buildServer(): Promise<FastifyInstance> {
     return reply.code(201).send({ ok: true, repo: ins[0] });
   });
 
+  // greenfield — "Start a new project": 빈/미존재/커밋없는 경로에만 git init + 빈 초기 커밋을
+  // 심고 등록한다. coxpit 이 git init 을 하는 유일한 자리 — 파일 있는 폴더는 절대 건드리지 않는다.
+  app.post('/api/repos/new', async (req, reply) => {
+    const b = (req.body ?? {}) as { machineSlug?: string; path?: string; name?: string };
+    const machineSlug = (b.machineSlug ?? '').trim();
+    const path = (b.path ?? '').trim();
+    if (!machineSlug || !path) return reply.code(400).send({ error: 'machineSlug and path required' });
+    if (!path.startsWith('/')) return reply.code(400).send({ error: 'path must be absolute' });
+
+    const mr = await db.select().from(machines).where(eq(machines.slug, machineSlug)).limit(1);
+    const m = mr[0];
+    if (!m) return reply.code(404).send({ error: 'machine not found' });
+
+    const g = `git -C ${shq(path)}`;
+    const probe =
+      `if [ ! -e ${shq(path)} ]; then echo MISSING;` +
+      ` elif [ ! -d ${shq(path)} ]; then echo NOTDIR;` +
+      ` elif [ -d ${shq(path)}/.git ]; then { ${g} rev-parse --verify -q HEAD >/dev/null 2>&1 && echo REPO_HAS_COMMITS || echo REPO_EMPTY; };` +
+      ` elif [ -z "$(ls -A ${shq(path)} 2>/dev/null)" ]; then echo EMPTYDIR;` +
+      ` else echo NONEMPTY; fi`;
+    const pr = await runShellOn(m, probe, 20000);
+    if (!pr.ok) return reply.code(400).send({ error: 'could not inspect path', detail: (pr.stdout || pr.stderr).trim().slice(0, 400) });
+    const kind = pr.stdout.trim().split('\n').pop()?.trim() ?? '';
+
+    if (kind === 'NOTDIR') return reply.code(400).send({ error: 'path is not a directory' });
+    if (kind === 'REPO_HAS_COMMITS') return reply.code(409).send({ error: 'already a repository with commits — use Register' });
+    if (kind === 'NONEMPTY') return reply.code(409).send({ error: 'folder is not empty — greenfield never touches existing files' });
+    if (kind !== 'MISSING' && kind !== 'EMPTYDIR' && kind !== 'REPO_EMPTY') {
+      return reply.code(400).send({ error: 'could not classify path', detail: (pr.stdout || pr.stderr).trim().slice(0, 400) });
+    }
+
+    // init(필요 시) + 빈 초기 커밋 — 이 커밋이 worktree 가 브랜치할 base.
+    // mergeRun 과 동일 관례: coxpit ident, gpgsign off.
+    const seed =
+      `mkdir -p ${shq(path)} && cd ${shq(path)}` +
+      ` && { [ -d .git ] || git init -b main; }` +
+      ` && git -c user.name='coxpit' -c user.email='coxpit@local' -c commit.gpgsign=false` +
+      ` commit --allow-empty -m 'coxpit: initial commit'`;
+    const sr = await runShellOn(m, seed, 20000);
+    if (!sr.ok) return reply.code(422).send({ error: 'could not initialize the project', detail: (sr.stdout || sr.stderr).trim().slice(0, 400) });
+
+    // REPO_EMPTY 는 기존 unborn 브랜치가 master 일 수 있음 — seed 후 실제 브랜치를 읽는다.
+    // init 케이스는 항상 main.
+    let branch = 'main';
+    if (kind === 'REPO_EMPTY') {
+      const br = await runShellOn(m, `git -C ${shq(path)} symbolic-ref --short HEAD 2>/dev/null || echo main`, 10000);
+      branch = br.stdout.trim().split('\n').pop()?.trim() || 'main';
+    }
+    const name = (b.name ?? '').trim() || path.split('/').filter(Boolean).pop() || path;
+
+    const ins = await db.insert(repos).values({
+      machineId: m.id, path, name, defaultBranch: branch,
+    }).returning();
+
+    return reply.code(201).send({ ok: true, repo: ins[0] });
+  });
+
   // repo 삭제 — 열린 태스크가 있으면 거부(이력 보호).
   app.delete('/api/repos/:id', async (req, reply) => {
     const id = Number((req.params as { id: string }).id);
@@ -408,13 +481,19 @@ export async function buildServer(): Promise<FastifyInstance> {
     const q = (req.query ?? {}) as { path?: string };
     const start = q.path && q.path.startsWith('/') ? q.path : homedir();
     const p = presolve(start);
-    let dirs: Array<{ name: string; isRepo: boolean }> = [];
+    let dirs: Array<{ name: string; isRepo: boolean; isEmpty: boolean }> = [];
     let error: string | undefined;
     try {
       const entries = await readdir(p, { withFileTypes: true });
       for (const e of entries) {
         if (!e.isDirectory() || e.name.startsWith('.')) continue;
-        dirs.push({ name: e.name, isRepo: existsSync(pjoin(p, e.name, '.git')) });
+        const full = pjoin(p, e.name);
+        const isRepo = existsSync(pjoin(full, '.git'));
+        // 빈 폴더면 greenfield "Start here" 대상 — 서버 EMPTYDIR 판정(ls -A)과 동일하게
+        // 모든 엔트리(닷파일 포함) 0개일 때만. repo 폴더는 Register 로 다루므로 계산 생략.
+        let isEmpty = false;
+        if (!isRepo) { try { isEmpty = (await readdir(full)).length === 0; } catch { isEmpty = false; } }
+        dirs.push({ name: e.name, isRepo, isEmpty });
         if (dirs.length >= 300) break;
       }
       dirs.sort((a, b) => (b.isRepo ? 1 : 0) - (a.isRepo ? 1 : 0) || a.name.localeCompare(b.name));
@@ -466,6 +545,28 @@ export async function buildServer(): Promise<FastifyInstance> {
   app.get('/design/bookmarklet.js', async (_req, reply) =>
     reply.type('text/javascript').header('cache-control', 'no-store').send(BOOKMARKLET_JS));
 
+  // ─── Remote access (v4.5) ──────────────────────────────────────
+  // coxpit DETECTS the user's own Tailscale and DRIVES serve/funnel — it never
+  // hosts a relay or issues a coxpit-branded URL. Truth is read live from the
+  // CLI each call (no DB state). Owner-only (behind the normal authGate).
+  app.get('/api/remote', async () => remoteState(config.port));
+
+  // Serve = tailnet-only HTTPS (safe by default) — no auth guard needed.
+  app.post('/api/remote/serve', async (req) => {
+    const b = (req.body ?? {}) as { on?: boolean };
+    return setServe(config.port, b.on === true);
+  });
+
+  // Funnel = PUBLIC internet. Refuse to expose shells without a password:
+  // Funnel has no Tailscale-side auth, so coxpit's basic auth is the only gate.
+  app.post('/api/remote/funnel', async (req, reply) => {
+    const b = (req.body ?? {}) as { on?: boolean };
+    if (b.on === true && (config.auth.disabled || config.auth.pass === '')) {
+      return reply.code(409).send({ error: 'set a password first', code: 'NO_AUTH' });
+    }
+    return setFunnel(config.port, b.on === true);
+  });
+
   // ─── Task ──────────────────────────────────────────────────────
   app.get('/api/tasks', async (req) => {
     const q = (req.query ?? {}) as { repo?: string };
@@ -660,6 +761,113 @@ export async function buildServer(): Promise<FastifyInstance> {
     return reply.code(202).send(res);
   });
 
+  // ─── Goal workroom (v4.6 L1) — 한 그룹(goal/swarm)을 한 방에서 몰기 ────────
+  // steerable = 정착(done/failed/stopped) + sessionId 보유 + worktree 살아있음.
+  // (steerRun 전제 그대로 — 라이브 run 은 steer 불가, 드라이런은 세션 없음.)
+  const groupRuns = async (groupId: number): Promise<{
+    group: typeof taskGroups.$inferSelect;
+    rows: Array<{ run: typeof agentRuns.$inferSelect; task: typeof tasks.$inferSelect }>;
+  } | null> => {
+    const gr = await db.select().from(taskGroups).where(eq(taskGroups.id, groupId)).limit(1);
+    if (!gr[0]) return null;
+    const gts = await db.select().from(tasks).where(eq(tasks.groupId, groupId));
+    const rows: Array<{ run: typeof agentRuns.$inferSelect; task: typeof tasks.$inferSelect }> = [];
+    for (const t of gts) {
+      const trs = await db.select().from(agentRuns).where(eq(agentRuns.taskId, t.id));
+      for (const run of trs) rows.push({ run, task: t });
+    }
+    rows.sort((a, b) => a.run.id - b.run.id);
+    return { group: gr[0], rows };
+  };
+  const isSteerable = (r: typeof agentRuns.$inferSelect): boolean =>
+    !isRunLive(r.id) && ['done', 'failed', 'stopped'].includes(r.status) && !!r.sessionId && !!r.worktreePath;
+
+  // B1 — 애그리게이트 뷰(방의 chips + 최근 타임라인). 페이로드 다이어트: 최근 200 이벤트만.
+  app.get('/api/groups/:id', async (req, reply) => {
+    const id = Number((req.params as { id: string }).id);
+    const g = await groupRuns(id);
+    if (!g) return reply.code(404).send({ error: 'group not found' });
+    const runs = g.rows.map(({ run, task }) => ({
+      runId: run.id, taskId: task.id, title: task.title, status: run.status,
+      agent: run.agent, model: run.model, branch: run.branch, filesChanged: run.filesChanged,
+      live: isRunLive(run.id), steerable: isSteerable(run),
+    }));
+    const runIds = g.rows.map((x) => x.run.id);
+    // 이벤트: 그룹 run 전체에서 최근 200개(id 순, 오래된 것 먼저 — 방 피드는 append-only).
+    const evs = runIds.length
+      ? (await db.select().from(agentEvents).where(inArray(agentEvents.runId, runIds)))
+          .sort((a, b) => a.id - b.id).slice(-200)
+      : [];
+    return {
+      group: { id: g.group.id, kind: g.group.kind, title: g.group.title, coordSessionId: g.group.coordSessionId },
+      runs,
+      events: evs.map((e) => ({ runId: e.runId, kind: e.kind, payload: e.payload, ts: e.ts })),
+    };
+  });
+
+  // B2 — "＋ New attempt": 그룹에 새 시도(들)를 발사. repo 는 그룹의 기존 태스크에서 상속.
+  app.post('/api/groups/:id/spawn', async (req, reply) => {
+    const id = Number((req.params as { id: string }).id);
+    const b = (req.body ?? {}) as { title?: string; prompt?: string; count?: number; real?: boolean };
+    const prompt = (b.prompt ?? '').trim();
+    if (!prompt) return reply.code(400).send({ error: 'prompt required' });
+    const g = await groupRuns(id);
+    if (!g) return reply.code(404).send({ error: 'group not found' });
+    if (!g.rows[0]) return reply.code(409).send({ error: 'group has no tasks to inherit a repo from' });
+    const repoId = g.rows[0].task.repoId; // 형제는 같은 repo 를 공유
+    const title = (b.title ?? '').trim() || prompt.slice(0, 40);
+    const count = Math.max(1, Math.min(5, Number(b.count) || 1));
+    const created: Array<{ id: number; title: string; runId: number }> = [];
+    for (let i = 0; i < count; i++) {
+      created.push(await launchGroupTask(id, repoId, title, prompt, b.real === true));
+    }
+    return reply.code(201).send({ ok: true, tasks: created });
+  });
+
+  // B3 — "→ Broadcast": 그룹의 정착·steerable run 전부에 후속 지시. 라이브/드라이는 정직하게 skip.
+  app.post('/api/groups/:id/steer', async (req, reply) => {
+    const id = Number((req.params as { id: string }).id);
+    const b = (req.body ?? {}) as { message?: string; mode?: string };
+    const message = (b.message ?? '').trim();
+    if (!message) return reply.code(400).send({ error: 'message required' });
+    const g = await groupRuns(id);
+    if (!g) return reply.code(404).send({ error: 'group not found' });
+    const mode = b.mode === 'ask' ? 'ask' : 'work';
+    let steered = 0;
+    const skipped: Array<{ runId: number; reason: string }> = [];
+    let running = 0, noSession = 0;
+    // 그룹 규모가 작아 순차 for 루프로 충분(폭주 fan-out 없음).
+    for (const { run } of g.rows) {
+      const res = await steerRun(run.id, message, mode);
+      if (res.ok) { steered++; continue; }
+      skipped.push({ runId: run.id, reason: res.detail });
+      if (/still running/.test(res.detail)) running++;
+      else if (/no agent session/.test(res.detail)) noSession++;
+    }
+    const parts = [`${steered} steered`];
+    if (running) parts.push(`${running} still running (steer after they settle)`);
+    if (noSession) parts.push(`${noSession} no session`);
+    const otherSkips = skipped.length - running - noSession;
+    if (otherSkips > 0) parts.push(`${otherSkips} skipped`);
+    return { ok: true, steered, skipped, detail: parts.join(' · ') };
+  });
+  // NOTE(v4.6): queuing a broadcast to apply to running runs once they settle is
+  // explicitly out of scope for L1 — running runs are reported as skipped, not queued.
+
+  // B4 (L2) — "? Ask": 그룹 스코프 읽기 전용 코디네이터. run 발사·steer·파일 쓰기 절대 없음.
+  // askGroupCoordinator 는 getRunDiff(읽기)와 텍스트 반환뿐 — launch/steer/write 경로를 부르지 않는다.
+  app.post('/api/groups/:id/ask', async (req, reply) => {
+    const id = Number((req.params as { id: string }).id);
+    const b = (req.body ?? {}) as { message?: string; real?: boolean };
+    const message = (b.message ?? '').trim();
+    if (!message) return reply.code(400).send({ error: 'message required' });
+    const g = await groupRuns(id);
+    if (!g) return reply.code(404).send({ error: 'group not found' });
+    const res = await askGroupCoordinator(id, message, b.real === true);
+    if (!res.ok) return reply.code(422).send({ error: res.detail });
+    return { ok: true, answer: res.answer };
+  });
+
   // 통합 — 여러 run(태스크 무관)을 base 에 순차 머지, 충돌은 통합 에이전트 자동 발사.
   app.post('/api/integrate', async (req, reply) => {
     const b = (req.body ?? {}) as { runIds?: number[]; real?: boolean };