coxpit 4.3.1 → 4.6.0

package/src/db/index.ts

@@ -98,4 +98,5 @@ export async function ensureSchema(): Promise<void> {
   try { await client.execute("ALTER TABLE agent_runs ADD COLUMN model TEXT NOT NULL DEFAULT ''"); } catch { /* exists */ }
   try { await client.execute('ALTER TABLE tasks ADD COLUMN group_id INTEGER'); } catch { /* exists */ }
   try { await client.execute('ALTER TABLE tasks ADD COLUMN closed_at INTEGER'); } catch { /* exists */ }
+  try { await client.execute("ALTER TABLE task_groups ADD COLUMN coord_session_id TEXT NOT NULL DEFAULT ''"); } catch { /* exists */ }
 }

package/src/db/schema.ts

@@ -37,6 +37,7 @@ export const taskGroups = sqliteTable('task_groups', {
   id: integer('id').primaryKey({ autoIncrement: true }),
   kind: text('kind').notNull().default('goal'), // 'goal' | 'swarm'
   title: text('title').notNull(),
+  coordSessionId: text('coord_session_id').notNull().default(''), // L2 — 읽기전용 Ask 코디네이터의 재개 세션(--resume 키)
   createdAt: integer('created_at', { mode: 'timestamp' }),
 });
 

package/src/orchestrator.ts

@@ -59,6 +59,11 @@ export function resolveAgentToken(token: string): number | null {
   return agentTokens.get(token) ?? null;
 }
 
+/** run 이 지금 살아 있는가(자식 프로세스 보유). aggregate 뷰의 live/steerable 판정용. */
+export function isRunLive(runId: number): boolean {
+  return liveChildren.has(runId);
+}
+
 /** 에이전트 프롬프트에 붙는 능력 고지 — 독립 하위작업을 병렬 서브런으로 뺄 수 있다.
  * 파일 기반: 기본 권한(claude acceptEdits · codex workspace-write)이 네트워크를 막아도
  * 파일 쓰기는 되므로, spawn 요청을 워크트리의 .coxpit/spawn.json 으로 받는다. */
@@ -668,6 +673,25 @@ export async function openWorkbench(repoId: number, title: string): Promise<{
   return { ok: true, detail: 'workbench open', taskId: task.id, runId };
 }
 
+/**
+ * 그룹에 속한 태스크 1개를 만들고 run 1개를 발사한다(공용 helper).
+ * planFanout(plan 형제) 과 /api/groups/:id/spawn(＋New attempt) 이 공유하는
+ * "태스크 생성(groupId 각인) → run 생성 → 브로드캐스트 → launchRun" 몸통.
+ */
+export async function launchGroupTask(
+  groupId: number, repoId: number, title: string, prompt: string, real: boolean,
+): Promise<{ id: number; title: string; runId: number }> {
+  const rp = await db.select().from(repos).where(eq(repos.id, repoId)).limit(1);
+  const machineId = rp[0]!.machineId;
+  const tIns = await db.insert(tasks).values({ repoId, title: title.slice(0, 140), prompt, groupId }).returning();
+  const task = tIns[0]!;
+  const rIns = await db.insert(agentRuns).values({ taskId: task.id, machineId, agent: 'claude-code', status: 'pending' }).returning();
+  const run = rIns[0]!;
+  broadcast({ type: 'run', runId: run.id, taskId: task.id, status: 'pending', agent: run.agent, branch: '', filesChanged: 0 });
+  void launchRun(run.id, real);
+  return { id: task.id, title: task.title, runId: run.id };
+}
+
 /**
  * Plan fan-out — 스웜의 입구. 목표 하나를 받아 플래너 에이전트가 repo 를 읽고
  * 독립 실행 가능한 하위 태스크들로 분해 → 각 태스크를 count 1 로 자동 발사한다.
@@ -728,13 +752,7 @@ export async function planFanout(repoId: number, goal: string, real: boolean): P
 
   const created: Array<{ id: number; title: string; runId: number }> = [];
   for (const t of plan) {
-    const tIns = await db.insert(tasks).values({ repoId, title: t.title, prompt: t.prompt, groupId }).returning();
-    const task = tIns[0]!;
-    const rIns = await db.insert(agentRuns).values({ taskId: task.id, machineId: m.id, agent: 'claude-code', status: 'pending' }).returning();
-    const run = rIns[0]!;
-    broadcast({ type: 'run', runId: run.id, taskId: task.id, status: 'pending', agent: run.agent, branch: '', filesChanged: 0 });
-    void launchRun(run.id, real);
-    created.push({ id: task.id, title: t.title, runId: run.id });
+    created.push(await launchGroupTask(groupId, repoId, t.title, t.prompt, real));
   }
   return { ok: true, detail: `${created.length} task(s) launched`, tasks: created };
 }
@@ -795,6 +813,117 @@ export async function reviewTask(taskId: number, real: boolean): Promise<{ ok: b
   }
 }
 
+/**
+ * Ask 코디네이터 — 읽기 전용, 재개 가능한 그룹 스코프 Q&A.
+ * 그룹의 형제 run 들에서 {title,status,agent,filesChanged} + 정착 run 의 bounded diff 요약을
+ * 모아 컨텍스트로 주고, 질문에 답만 한다. worktree 를 열지도, run 을 발사하지도, 파일을 쓰지도,
+ * steer 하지도 않는다 — getRunDiff(읽기)와 텍스트 반환뿐. (reviewTask 를 대화형·재개형으로 변형)
+ *
+ * 세션: 첫 호출은 1회용(`bin -p <prompt> --output-format json`)으로 session_id 를 캡처해
+ * task_groups.coord_session_id 에 저장. 이후 호출은 provider.resumeCmd 로 진짜 대화를 잇는다.
+ * 드라이(real=false / COXPIT_AGENT_REAL off)는 결정적 mock + 합성 세션 id 반환(크레딧 0, e2e 안전).
+ */
+export async function askGroupCoordinator(
+  groupId: number, message: string, real: boolean,
+): Promise<{ ok: boolean; detail: string; answer?: string }> {
+  const gr = await db.select().from(taskGroups).where(eq(taskGroups.id, groupId)).limit(1);
+  const group = gr[0];
+  if (!group) return { ok: false, detail: 'group not found' };
+  const msg = message.trim();
+  if (!msg) return { ok: false, detail: 'empty message' };
+
+  // 그룹의 형제 run 들(태스크 조인) — bounded 컨텍스트만.
+  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);
+
+  // repo/machine 은 그룹의 아무 태스크에서 상속(형제는 같은 repo 공유). read-only 는 repo 본체에서.
+  const anyTask = rows[0]?.task ?? gts[0];
+  let machine: MachineTarget | null = null;
+  let repoPath = '';
+  if (anyTask) {
+    const rp = await db.select().from(repos).where(eq(repos.id, anyTask.repoId)).limit(1);
+    const repo = rp[0];
+    if (repo) {
+      repoPath = repo.path;
+      const mr = await db.select().from(machines).where(eq(machines.id, repo.machineId)).limit(1);
+      const m = mr[0];
+      if (m) machine = { slug: m.slug, kind: m.kind, address: m.address, sshUser: m.sshUser };
+    }
+  }
+
+  // bounded 컨텍스트: run 요약 + 정착 run 의 diff 요약(각 ~1500자, 합 ~12k 상한).
+  const SETTLED = ['done', 'failed', 'stopped', 'merged'];
+  const sections: string[] = [];
+  let budget = 12000;
+  for (const { run, task } of rows) {
+    let sec = `### run r${run.id} — ${task.title.slice(0, 80)}\n`
+      + `status: ${run.status} · agent: ${run.agent} · files changed: ${run.filesChanged}`;
+    if (SETTLED.includes(run.status) && budget > 0) {
+      const d = await getRunDiff(run.id).catch(() => ({ ok: false, diff: '', stat: '' }));
+      const raw = (d.ok ? (d.diff || d.stat || '(no changes)') : '(worktree gone — diff unavailable)');
+      const cap = Math.min(1500, Math.max(0, budget));
+      const clip = raw.slice(0, cap);
+      budget -= clip.length;
+      sec += `\nDiff summary:\n\`\`\`diff\n${clip}\n\`\`\``;
+    }
+    sections.push(sec);
+  }
+
+  const preamble =
+    `You are a READ-ONLY coordinator for a goal with these parallel attempts. `
+    + `Answer the question about their state and diffs. Do NOT propose running commands, `
+    + `do NOT modify files, do NOT suggest editing anything — you can only observe and explain.`;
+  const context = `Goal: ${group.title}\n\n${sections.join('\n\n') || '(no runs yet)'}`;
+
+  // 드라이: 결정적 mock 답변 + 합성 세션 id(첫 호출 시 저장, 이후 재사용). e2e 크레딧 0.
+  if (!real) {
+    const done = rows.filter((r) => SETTLED.includes(r.run.status)).length;
+    const running = rows.filter((r) => r.run.status === 'running').length;
+    const answer = `[dry coordinator] ${rows.length} attempt(s) · ${done} settled · ${running} running.\n`
+      + `Q: ${msg.slice(0, 120)}\n`
+      + `(rehearsal answer — read-only; run with Real agent for a substantive reply.)`;
+    if (!group.coordSessionId) {
+      const synth = 'dry-coord-' + randomBytes(6).toString('hex');
+      await db.update(taskGroups).set({ coordSessionId: synth }).where(eq(taskGroups.id, groupId));
+    }
+    return { ok: true, detail: 'rehearsal answer', answer };
+  }
+
+  if (!machine || !repoPath) return { ok: false, detail: 'group has no repo to run the coordinator from' };
+
+  // 첫 호출 = 1회용(session_id 캡처), 이후 = resume(대화 이어가기). 둘 다 파일 미변경 read-only.
+  const provider = getProvider('claude-code');
+  let cmd: string;
+  const resuming = !!group.coordSessionId;
+  if (resuming) {
+    // resume 은 stream-json 을 내지만 여기선 마지막 result 만 필요 — json 으로 강제 재래핑 불가하므로
+    // 세션 id 는 이미 있으니 resumeCmd(대화)로 잇고, 최종 텍스트는 result 라인에서 추출한다.
+    cmd = `cd ${shq(repoPath)} && ${provider.resumeCmd(group.coordSessionId, `${preamble}\n\n${context}\n\nQuestion: ${msg}`)} --output-format json`;
+  } else {
+    const oneShot = `${preamble}\n\n${context}\n\nQuestion: ${msg}`;
+    cmd = `cd ${shq(repoPath)} && ${config.agent.bin} -p ${shq(oneShot)} --output-format json`;
+  }
+  const r = await runShellOn(machine, cmd, 300000);
+  if (!r.ok) return { ok: false, detail: 'coordinator failed: ' + (r.stderr || r.stdout).trim().slice(0, 300) };
+  try {
+    const envelope = JSON.parse(r.stdout.trim()) as { result?: string; session_id?: string };
+    const answer = (envelope.result ?? '').trim();
+    if (!answer) throw new Error('empty answer');
+    // 첫 호출에서만 세션 각인(이후엔 유지). resume 응답도 같은 세션이라 덮어써도 무해.
+    if (typeof envelope.session_id === 'string' && envelope.session_id && envelope.session_id !== group.coordSessionId) {
+      await db.update(taskGroups).set({ coordSessionId: envelope.session_id }).where(eq(taskGroups.id, groupId));
+    }
+    return { ok: true, detail: resuming ? 'resumed' : 'answered', answer };
+  } catch (e) {
+    return { ok: false, detail: 'could not parse coordinator answer: ' + String(e).slice(0, 200) };
+  }
+}
+
 export interface IntegrateResult {
   runId: number;
   status: 'merged' | 'conflict' | 'skipped';

package/src/providers.ts

@@ -76,9 +76,20 @@ const claudeProvider: Provider = {
       if (obj.type) kind = obj.type;
       if (obj.type === 'system' && typeof obj.session_id === 'string') ev.sessionId = obj.session_id;
       if (obj.type === 'result') ev.resultText = typeof obj.result === 'string' ? obj.result : s;
-      // 2000자 초과 이벤트는 자르면 JSON 이 깨져 잔해가 화면에 노출된다 —
-      // 저장 전에 "요지만 남긴" 유효 JSON 으로 압축한다.
-      if (s.length > 2000) {
+      // system 이벤트는 full fidelity 가 필요 없다 — 길이와 무관하게 항상 컴팩트 재직렬화로
+      // 통일하고 그 시점에 model 의 ANSI 이스케이프를 소독한다(예: 'claude-opus-4-8\x1b[1m').
+      // session_id 캡처는 위에서 이미 ev 에 담았으므로 stored 축약과 무관.
+      // ESC(\x1b) 를 포함해 SGR 시퀀스 전체를 제거 — spec 예시 정규식은 ESC 를 남겨
+      //   'm\x1b[1mx' → 'm\x1bx' 로 잔해가 남아 DoD("ESC 부재")를 못 지킨다. ESC 도 소비한다.
+      const stripAnsi = (x: string) => x.replace(/\x1b?\[[0-9;]*m/g, '');
+      if (obj.type === 'system') {
+        stored = JSON.stringify({
+          type: 'system', subtype: obj.subtype,
+          model: typeof obj.model === 'string' ? stripAnsi(obj.model) : obj.model,
+        });
+      } else if (s.length > 2000) {
+        // 2000자 초과 이벤트는 자르면 JSON 이 깨져 잔해가 화면에 노출된다 —
+        // 저장 전에 "요지만 남긴" 유효 JSON 으로 압축한다.
         if (obj.type === 'assistant' && obj.message) {
           const content = (obj.message.content ?? [])
             .filter((c) => c.type === 'text' || c.type === 'tool_use')
@@ -88,8 +99,6 @@ const claudeProvider: Provider = {
           stored = JSON.stringify({ type: 'assistant', message: { content } }).slice(0, 2000);
         } else if (obj.type === 'user') {
           stored = JSON.stringify({ type: 'user' }); // tool 결과 회신 — 표시 안 함
-        } else if (obj.type === 'system') {
-          stored = JSON.stringify({ type: 'system', subtype: obj.subtype, model: obj.model });
         } else if (obj.type === 'result') {
           stored = JSON.stringify({ type: 'result', result: (obj.result ?? '').slice(0, 1500) });
         } else {

package/src/remote.ts

@@ -0,0 +1,148 @@
+// Remote access detection — read the LOCAL machine's Tailscale state and whether
+// Serve/Funnel already point at our port. This is the whole v4.5 backend surface.
+//
+// GUARDRAIL (non-negotiable): coxpit never hosts a relay and never issues a
+// coxpit-branded public URL. It DETECTS the user's own Tailscale and DRIVES it
+// (serve/funnel), or hands a copy-paste recipe. We never bundle tailscale or
+// cloudflared — absent tools degrade to `missing` + a recipe, never to a coxpit
+// tunnel. All truth is read live from the CLI; nothing is persisted in the DB.
+
+import { runShellOn, shq, type MachineTarget } from './exec';
+
+export interface RemoteState {
+  tailscale: 'missing' | 'stopped' | 'running';
+  dnsName?: string;        // trailing dot stripped (e.g. host.tailnet.ts.net)
+  tailnetSuffix?: string;  // MagicDNS suffix (e.g. tailnet.ts.net)
+  serve: boolean;          // is serve active for OUR port?
+  funnel: boolean;         // is funnel active for OUR port?
+  binPath?: string;        // resolved tailscale bin
+}
+
+// Serve/Funnel are always driven against the local machine (the daemon host) —
+// we cannot reach into a remote node's Tailscale from here.
+const LOCAL: MachineTarget = { slug: 'local', kind: 'local', address: '', sshUser: '' };
+
+// mac app bundles the CLI here; Linux/most installs put `tailscale` on PATH.
+const MAC_APP_BIN = '/Applications/Tailscale.app/Contents/MacOS/Tailscale';
+
+/** Resolve the tailscale binary: PATH first, else the macOS app bundle. '' = none. */
+async function resolveBin(): Promise<string> {
+  const onPath = await runShellOn(LOCAL, 'command -v tailscale 2>/dev/null || true', 6000);
+  const p = onPath.stdout.trim().split('\n').pop()?.trim() ?? '';
+  if (p) return p;
+  const app = await runShellOn(LOCAL, `test -x ${shq(MAC_APP_BIN)} && echo yes || true`, 6000);
+  if (app.stdout.includes('yes')) return MAC_APP_BIN;
+  return '';
+}
+
+/** Does a serve/funnel status JSON (shape varies by version) target http://…:<port>? */
+function jsonTargetsPort(raw: string, port: number): boolean {
+  // Rather than chase the (version-dependent) nested shape, look for any proxy
+  // target string that names our loopback port. `serve status --json` embeds
+  // upstreams as `http://127.0.0.1:<port>` / `http://localhost:<port>`.
+  try {
+    JSON.parse(raw); // ensure it IS json (caller falls back to text grep otherwise)
+  } catch {
+    throw new Error('not json');
+  }
+  return textTargetsPort(raw, port);
+}
+
+/** Plain-text fallback: any `:<port>` upstream mention (defensive across versions). */
+function textTargetsPort(raw: string, port: number): boolean {
+  const p = String(port);
+  return raw.includes('127.0.0.1:' + p)
+    || raw.includes('localhost:' + p)
+    || raw.includes('0.0.0.0:' + p)
+    || raw.includes('[::1]:' + p);
+}
+
+/** Is serve/funnel active for our port? Try `<sub> status --json`, else `<sub> status`. */
+async function subStateForPort(bin: string, sub: 'serve' | 'funnel', port: number): Promise<boolean> {
+  const j = await runShellOn(LOCAL, `${shq(bin)} ${sub} status --json 2>/dev/null || true`, 8000);
+  const jout = j.stdout.trim();
+  if (jout) {
+    try {
+      return jsonTargetsPort(jout, port);
+    } catch { /* not json — fall through to text grep */ }
+  }
+  const t = await runShellOn(LOCAL, `${shq(bin)} ${sub} status 2>/dev/null || true`, 8000);
+  return textTargetsPort(t.stdout, port);
+}
+
+/**
+ * Live Tailscale state for `port`, best-effort. Any failure downgrades to
+ * missing/stopped — this must never throw into the request handler.
+ */
+export async function remoteState(port: number): Promise<RemoteState> {
+  const off: RemoteState = { tailscale: 'missing', serve: false, funnel: false };
+  try {
+    const bin = await resolveBin();
+    if (!bin) return off;
+
+    const st = await runShellOn(LOCAL, `${shq(bin)} status --json 2>/dev/null || true`, 8000);
+    const out = st.stdout.trim();
+    if (!out) return { tailscale: 'stopped', serve: false, funnel: false, binPath: bin };
+
+    let self: { DNSName?: string } | undefined;
+    let magic = '';
+    let backendState = '';
+    try {
+      const j = JSON.parse(out) as {
+        Self?: { DNSName?: string };
+        MagicDNSSuffix?: string;
+        BackendState?: string;
+      };
+      self = j.Self;
+      magic = String(j.MagicDNSSuffix ?? '');
+      backendState = String(j.BackendState ?? '');
+    } catch {
+      // Non-JSON (e.g. "Logged out." / "stopped") — treat as not running.
+      return { tailscale: 'stopped', serve: false, funnel: false, binPath: bin };
+    }
+
+    // Logged out / stopped backends have no usable name.
+    if (/stopped|NoState|NeedsLogin|Logged out/i.test(backendState) || !self?.DNSName) {
+      return { tailscale: 'stopped', serve: false, funnel: false, binPath: bin };
+    }
+
+    const dnsName = String(self.DNSName).replace(/\.$/, ''); // strip trailing dot
+    const tailnetSuffix = magic.replace(/\.$/, '') || undefined;
+
+    const [serve, funnel] = await Promise.all([
+      subStateForPort(bin, 'serve', port),
+      subStateForPort(bin, 'funnel', port),
+    ]);
+
+    return { tailscale: 'running', dnsName, tailnetSuffix, serve, funnel, binPath: bin };
+  } catch {
+    return off;
+  }
+}
+
+/** Turn Serve on/off for our port (tailnet-only, HTTPS — safe by default). */
+export async function setServe(port: number, on: boolean): Promise<RemoteState> {
+  const bin = await resolveBin();
+  if (bin) {
+    const cmd = on
+      ? `${shq(bin)} serve --bg ${String(port)}`
+      : `${shq(bin)} serve reset`;
+    await runShellOn(LOCAL, cmd, 20000);
+  }
+  return remoteState(port);
+}
+
+/**
+ * Turn Funnel on/off for our port (PUBLIC internet). The NO_AUTH guard lives in
+ * the route (Funnel with no basic auth = open shells); this just drives the CLI.
+ */
+export async function setFunnel(port: number, on: boolean): Promise<RemoteState> {
+  const bin = await resolveBin();
+  if (bin) {
+    const cmd = on
+      ? `${shq(bin)} funnel --bg ${String(port)}`
+      : `${shq(bin)} funnel reset`;
+    await runShellOn(LOCAL, cmd, 20000);
+  }
+  return remoteState(port);
+}