coxpit 6.3.0 → 6.3.3

package/src/server.ts

@@ -7,7 +7,7 @@ import { randomBytes } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
 import Fastify, { type FastifyInstance, type FastifyReply } from 'fastify';
 import websocket from '@fastify/websocket';
-import { eq, inArray, and, like, desc } from 'drizzle-orm';
+import { eq, inArray, and, like, desc, asc, sql } from 'drizzle-orm';
 import { authGate } from './auth';
 import { loginPageHTML } from './login';
 import {
@@ -17,11 +17,12 @@ import {
 } from './authkey';
 import { config } from './config';
 import { readSettings, writeSettings } from './settings';
+import { readOpenTabs, writeOpenTabs, sanitizeOpenTabs } from './uistate';
 import { db } from './db';
 import { machines, repos, tasks, agentRuns, agentEvents, designCaptures, shareLinks, taskGroups, secrets } 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, launchGroupTask, isRunLive, liveInPlaceRun, askGroupCoordinator, computeRunOutputs, normalizeOutputs, listReclaimableWorktrees, pruneWorktrees, worktreeDisk, listOrphanTmux, killTmuxSessions, noopSignal, groupOverlap, landTarget, mergePreview, startLandResolve, listDocuments, verifyRun, verifyBase, openSessionAt, deleteSession, getScrollback, getRunPwd, getSessionChat } from './orchestrator';
+import { launchRun, cleanupRun, stopRun, getRunDiff, loadRunDocs, mergeRun, getRunTermInfo, steerRun, exportRun, prRun, integrateRuns, planFanout, reviewTask, syncRun, openWorkbench, spawnSubtasks, listSubtasks, resolveAgentToken, taskCloseRisk, launchGroupTask, isRunLive, liveInPlaceRun, askGroupCoordinator, computeRunOutputs, normalizeOutputs, listReclaimableWorktrees, pruneWorktrees, worktreeDisk, listOrphanTmux, killTmuxSessions, noopSignal, groupOverlap, landTarget, mergePreview, startLandResolve, listDocuments, verifyRun, verifyBase, openSessionAt, deleteSession, getScrollback, sendRunInput, getRunPwd, getSessionChat, tmuxNewSession, claudeTagEnvForRun } from './orchestrator';
 import { openTerm } from './term';
 import { attach as agentAttach, feed as agentFeed, input as agentInput, onExit as agentExit, detach as agentDetach, allAgentStates, spottedPorts } from './agentstate';
 import { scanListeners, scanPort, killPid, dropCache as dropListenerCache } from './procscan';
@@ -30,6 +31,7 @@ import { getProvider, listProviders } from './providers';
 import { remoteState, setServe, setFunnel } from './remote';
 import { BOARD_HTML } from './board';
 import { COCKPIT_HTML } from './cockpit';
+import { HUD_HTML } from './hud';
 import { listDir as fsListDir, readForView as fsReadForView, readRaw as fsReadRaw, writeText as fsWriteText, findFiles as fsFindFiles, uploadFile as fsUploadFile, withinFilesRoot } from './files';
 import { ensureWorkDoc, readWorkDoc, writeWorkDoc, removeWorkDoc, workDocPath, workDocSize } from './workdoc';
 
@@ -47,6 +49,12 @@ const VENDOR: Record<string, { pkg: string; rel: string; type: string }> = {
   'marked.js': { pkg: 'marked/package.json', rel: 'marked.min.js', type: 'text/javascript' },
 };
 
+// 버전 치환은 **모듈 로드 때 한 번** — config.version 은 부트 후 변하지 않고, cockpit.ts 는
+// 281KB 짜리 한 문자열이다. 요청마다 전역 정규식으로 다시 훑던 것을 상수로 굳혔다
+// (보드는 원래 상수를 그대로 내보낸다 — 세 페이지가 같은 방식이 됐다).
+const COCKPIT_PAGE = COCKPIT_HTML.replace(/__COXPIT_VER__/g, config.version);
+const HUD_PAGE = HUD_HTML.replace(/__COXPIT_VER__/g, config.version);
+
 // ─── 읽기 전용 공유 페이지 (서버 렌더 스냅샷 — 스크립트 0, 액션 0) ───────────
 const escH = (x: unknown): string =>
   String(x ?? '').replace(/[&<>"]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[c]!));
@@ -247,10 +255,19 @@ export async function buildServer(): Promise<FastifyInstance> {
     };
   });
 
+  // 서빙되는 한 장짜리 페이지는 **절대 캐시하지 않는다**. 세 페이지 전부 HTML 안에 JS 가 들어 있어서,
+  // 브라우저·PWA 가 옛 문서를 물고 있으면 고친 코드가 기기에 아예 도착하지 않는다(폰에서 "고쳤는데
+  // 그대로"의 진짜 원인). 버전이 박힌 /vendor/*·/brand/* 정적 자산은 그대로 캐시한다 — 여기만 no-store.
+  const freshPage = (reply: FastifyReply): FastifyReply =>
+    reply.header('cache-control', 'no-store').header('pragma', 'no-cache');
+
   // 플릿 보드(단일 페이지). 인증 게이트 적용됨(무인증 요청은 게이트가 login/setup 페이지로 응답).
-  app.get('/', async (_req, reply) => reply.type('text/html').send(BOARD_HTML));
+  app.get('/', async (_req, reply) => freshPage(reply).type('text/html').send(BOARD_HTML));
   // 터미널 우선 셸(병행 개발) — 백엔드는 보드와 공유. Phase 5에서 데스크톱 기본을 여기로 플립 예정.
-  app.get('/cockpit', async (_req, reply) => reply.type('text/html').send(COCKPIT_HTML.replace(/__COXPIT_VER__/g, config.version)));
+  app.get('/cockpit', async (_req, reply) => freshPage(reply).type('text/html').send(COCKPIT_PAGE));
+  // HUD(v5.28 K) — 플릿을 작게 다시 내놓는 한 장. 데스크톱의 떠 있는 작은 창이 이걸 띄운다.
+  // 서빙되는 **페이지**라 /cockpit 과 같은 게이트 뒤다(무인증 예외 아님 — 헬스가 아니다).
+  app.get('/hud', async (_req, reply) => freshPage(reply).type('text/html').send(HUD_PAGE));
 
   // ─── 접근키 인증(access-key) ────────────────────────────────────
   // 요청이 tunnel/https 를 탔나 — Secure 쿠키 여부 결정용.
@@ -366,17 +383,31 @@ export async function buildServer(): Promise<FastifyInstance> {
     const activeTasks = allTasks.filter((t) => t.status !== 'closed');
     const closedCount = allTasks.length - activeTasks.length;
     const ts = view === 'all' ? allTasks : activeTasks;
-    const taskIds = new Set(ts.map((t) => t.id));
-    const allRuns = await db.select().from(agentRuns);
-    const rns = view === 'all' ? allRuns : allRuns.filter((r) => taskIds.has(r.taskId));
+    const taskIds = ts.map((t) => t.id);
+    // run 도 **보는 뷰만** 가져온다 — 전량 로드 후 JS 필터가 아니라 SQL WHERE.
+    // 정렬을 명시하는 건 필터가 끼어도 클라이언트가 받던 id 오름차순을 그대로 지키기 위함이다.
+    const rns: Array<typeof agentRuns.$inferSelect> = view === 'all'
+      ? await db.select().from(agentRuns).orderBy(asc(agentRuns.id))
+      : taskIds.length
+        ? await db.select().from(agentRuns).where(inArray(agentRuns.taskId, taskIds)).orderBy(asc(agentRuns.id))
+        : [];
     const runIds = rns.map((r) => r.id);
-    // 이벤트는 대상 run 으로 스코프한 뒤 로드(전량 로드 후 슬라이스 = 고치려는 그 버그).
-    const evs = runIds.length ? await db.select().from(agentEvents).where(inArray(agentEvents.runId, runIds)) : [];
+    // 이벤트는 run 당 최근 EVENT_CAP 개만 **SQL 에서** 잘라 온다. 전량 로드 후 JS 슬라이스가
+    // 정확히 고치려던 그 낭비다(활성 run 의 모든 이벤트 행을 메모리에 올렸다).
+    // 창 함수로 run 별 역순 번호를 매겨 상한 안쪽만 남기고, 클라이언트가 기대하는 id 오름차순으로 낸다.
+    const evs: Array<{ run_id: number; kind: string; payload: string }> = runIds.length
+      ? await db.all<{ run_id: number; kind: string; payload: string }>(sql`
+          SELECT id, run_id, kind, payload FROM (
+            SELECT id, run_id, kind, payload,
+                   ROW_NUMBER() OVER (PARTITION BY run_id ORDER BY id DESC) AS rn
+            FROM agent_events WHERE ${inArray(agentEvents.runId, runIds)}
+          ) WHERE rn <= ${EVENT_CAP} ORDER BY run_id ASC, id ASC`)
+      : [];
     const byRun = new Map<number, Array<{ kind: string; payload: string }>>();
     for (const e of evs) {
-      const arr = byRun.get(e.runId) ?? [];
+      const arr = byRun.get(e.run_id) ?? [];
       arr.push({ kind: e.kind, payload: e.payload });
-      byRun.set(e.runId, arr);
+      byRun.set(e.run_id, arr);
     }
     const taskOut = new Map(ts.map((t) => [t.id, t.outputs]));
     return {
@@ -384,7 +415,8 @@ export async function buildServer(): Promise<FastifyInstance> {
       runs: rns.map((r) => {
         const sig = noopSignal(r.status, r.filesChanged, r.exitSummary, taskOut.get(r.taskId) ?? '[]');
         // real 은 언제나 불리언으로 나간다 — 클라이언트는 real===false 하나만 보고 dry 칩을 그린다.
-        return { ...r, real: !!r.real, events: (byRun.get(r.id) ?? []).slice(-EVENT_CAP), noop: sig.noop, noopReason: sig.reason };
+        // events 는 이미 SQL 에서 EVENT_CAP 으로 잘려 왔다 — 여기서 또 자르지 않는다.
+        return { ...r, real: !!r.real, events: byRun.get(r.id) ?? [], noop: sig.noop, noopReason: sig.reason };
       }),
       counts: { activeTasks: activeTasks.length, closedTasks: closedCount },
       // 지금 터미널이 붙어 있는 run 의 에이전트 상태(runId → {state,detail,ts}).
@@ -478,6 +510,19 @@ export async function buildServer(): Promise<FastifyInstance> {
     return { ok: true };
   });
 
+  // ── 소유자 UI 상태 — 열어둔 탭 (ui-state.json) ───────────────────
+  // 탭 바를 **데몬**이 기억한다. 브라우저 저장소는 캐시 비우기·기기 교체·옛 페이지에 쉽게 날아가는데,
+  // 그동안 tmux 세션은 살아 있다 — 새로고침이 돌고 있는 일을 닫아버려선 안 된다.
+  app.get('/api/ui/opentabs', async () => readOpenTabs());
+  app.put('/api/ui/opentabs', async (req, reply) => {
+    try {
+      return { ok: true, ...writeOpenTabs(sanitizeOpenTabs(req.body)) };
+    } catch (e) {
+      // 디스크에 못 썼으면 조용히 성공한 척하지 않는다 — 클라이언트는 localStorage 사본으로 버틴다.
+      return reply.code(500).send({ error: `could not persist ui state: ${(e as Error).message}` });
+    }
+  });
+
   // 아카이브 — 닫힌 태스크 목록(최신순, 페이지네이션·필터). 카드가 아니라 한 줄 행.
   app.get('/api/archive', async (req) => {
     const q = (req.query ?? {}) as { offset?: string; limit?: string; q?: string; repo?: string; status?: string };
@@ -493,9 +538,22 @@ export async function buildServer(): Promise<FastifyInstance> {
     const grpTitle = new Map((await db.select().from(taskGroups)).map((g) => [g.id, g.title]));
     const total0 = closed.length;
     const page = closed.slice(offset, offset + limit);
+    // 페이지에 실릴 태스크의 run 을 **한 번에** 긁어 taskId 로 묶는다.
+    // 태스크마다 한 방씩 쏘던 N+1(50행 페이지 = 51 쿼리)을 한 쿼리로 접었다.
+    const pageIds = page.map((t) => t.id);
+    const runsByTask = new Map<number, Array<typeof agentRuns.$inferSelect>>();
+    if (pageIds.length) {
+      const pageRuns = await db.select().from(agentRuns)
+        .where(inArray(agentRuns.taskId, pageIds)).orderBy(asc(agentRuns.id));
+      for (const r of pageRuns) {
+        const arr = runsByTask.get(r.taskId) ?? [];
+        arr.push(r);
+        runsByTask.set(r.taskId, arr);
+      }
+    }
     const rows = [];
     for (const t of page) {
-      const rs = await db.select().from(agentRuns).where(eq(agentRuns.taskId, t.id));
+      const rs = runsByTask.get(t.id) ?? [];
       if (q.status && !rs.some((r) => r.status === q.status)) continue;
       rows.push({
         taskId: t.id, title: t.title, repoName: repoName.get(t.repoId) ?? '?',
@@ -1264,11 +1322,30 @@ export async function buildServer(): Promise<FastifyInstance> {
     const q = (req.query ?? {}) as { lines?: string };
     const rr = await db.select().from(agentRuns).where(eq(agentRuns.id, id)).limit(1);
     if (!rr[0]) return reply.code(404).send({ error: 'not found' });
-    const res = await getScrollback(id, Number(q.lines) || 3000);
+    const res = await getScrollback(id, Number(q.lines) || 0);   // lines 없으면 히스토리 전체
     if (!res.ok) return reply.code(422).send(res);
     return res;
   });
 
+  // 살아 있는 run 의 tmux 에 한 줄 써 넣기 (v5.28 K) — 위 scrollback 의 **쓰기 쌍둥이**.
+  // HUD 가 코크핏을 열지 않고 "대기 중인 에이전트"에게 답하는 길이다(steer 는 정착한 run 전용이라
+  // 프롬프트 앞에 서 있는 run 에는 쓸 수 없다). 보내는 것은 언제나 사람이 고른 문자열이다 —
+  // 서버는 에이전트의 질문을 읽지도, 답을 고르지도 않는다.
+  // 세션이 없으면(정리됐거나 애초에 없음) 409, 모르는 run 은 404.
+  app.post('/api/runs/:id/input', async (req, reply) => {
+    const id = Number((req.params as { id: string }).id);
+    if (!Number.isInteger(id)) return reply.code(400).send({ error: 'bad id' });
+    const b = (req.body ?? {}) as { text?: string };
+    const text = String(b.text ?? '');
+    if (!text.trim()) return reply.code(400).send({ error: 'text required' });
+    if (text.length > 4000) return reply.code(400).send({ error: 'text too long (max 4000)' });
+    const rr = await db.select().from(agentRuns).where(eq(agentRuns.id, id)).limit(1);
+    if (!rr[0]) return reply.code(404).send({ error: 'not found' });
+    const res = await sendRunInput(id, text);
+    if (!res.ok) return reply.code(409).send(res);
+    return res;
+  });
+
   // 페인이 지금 서 있는 폴더 (v5.28 D-fix) — 터미널이 찍은 상대경로를 무엇 기준으로 풀지.
   // 못 알아내면 200 + { ok:false, pwd:'' } — 클라이언트가 worktree 로 폴백한다(지어낸 경로는 없다).
   app.get('/api/runs/:id/pwd', async (req, reply) => {
@@ -1848,8 +1925,10 @@ export async function buildServer(): Promise<FastifyInstance> {
     if (!has.ok) {
       const rr = await db.select().from(agentRuns).where(eq(agentRuns.id, id)).limit(1);
       const wt = rr[0]?.worktreePath ?? '';
+      // 소생한 페인에서도 `claude` 가 이 세션의 대화로 묶이게 태깅 env 를 다시 얹는다(없으면 빈 문자열).
+      const tagEnv = claudeTagEnvForRun(info.machine, rr[0]?.claudeSessionId ?? '');
       const revive = wt
-        ? await runShellOn(info.machine, `export LANG=${shq(config.lang)}; test -d ${shq(wt)} && tmux new-session -d -s ${shq(info.session)} -c ${shq(wt)}`, 10000)
+        ? await runShellOn(info.machine, `export LANG=${shq(config.lang)}; test -d ${shq(wt)} && ${tmuxNewSession(`-d${tagEnv} -s ${shq(info.session)} -c ${shq(wt)}`)}`, 10000)
         : { ok: false } as { ok: boolean };
       if (!revive.ok) {
         socket.send(JSON.stringify({ t: 'err', d: `tmux session '${info.session}' gone and could not be revived (worktree missing?)` }));

package/src/uistate.ts

@@ -0,0 +1,65 @@
+import fs from 'node:fs';
+import { config } from './config';
+
+// 소유자 UI 상태 — 데이터 폴더(~/.coxpit)의 ui-state.json 한 장.
+// 왜 데몬이 기억하나: 열어둔 탭을 브라우저(localStorage)에만 두면 캐시를 비우거나, 기기를 바꾸거나,
+// 오래된 페이지가 떠 있기만 해도 통째로 사라진다 — tmux 세션은 멀쩡히 살아 있는데도.
+// 스키마를 늘리지 않는다: settings.json·auth.json 과 같은 자리의 작은 JSON 파일(선례 그대로).
+// 소유자 1인 도구라 사용자 구분은 없다.
+
+/** 탭 바에 열려 있던 run 탭 집합 + 마지막으로 보던 탭. */
+export interface OpenTabs {
+  ids: number[];
+  active: number | null;
+}
+export interface UiState {
+  openTabs?: OpenTabs;
+}
+
+/** 폰 DOM·복원 시간 보호 상한. 넘치면 **최근 것**을 남긴다. */
+export const MAX_OPEN_TABS = 24;
+
+function readUiState(): UiState {
+  try {
+    const raw = JSON.parse(fs.readFileSync(config.uiStatePath, 'utf8'));
+    return raw && typeof raw === 'object' ? (raw as UiState) : {};
+  } catch {
+    return {};   // 파일 없음·깨짐 = 빈 상태(기억해둔 게 없다)
+  }
+}
+
+/** 신뢰할 수 없는 입력(클라이언트 PUT·디스크 파일)을 정수 id 목록으로 정리한다. */
+export function sanitizeOpenTabs(raw: unknown): OpenTabs {
+  const o = (raw ?? {}) as { ids?: unknown; active?: unknown };
+  const ids: number[] = [];
+  if (Array.isArray(o.ids)) {
+    for (const v of o.ids) {
+      const n = Number(v);
+      if (Number.isInteger(n) && n > 0 && !ids.includes(n)) ids.push(n);
+    }
+  }
+  const a = Number(o.active);
+  return {
+    ids: ids.slice(-MAX_OPEN_TABS),
+    active: Number.isInteger(a) && a > 0 ? a : null,
+  };
+}
+
+/**
+ * `stored` = 데몬이 **한 번이라도** 탭 집합을 받아 적었는가.
+ * 빈 집합("전부 닫았다")과 미기록("아직 아무 말도 못 들었다")은 다르다 — 클라이언트는 후자일 때만
+ * 브라우저 사본을 씨앗으로 쓴다(1회 이관). 이 구분이 없으면 owner 가 닫은 탭이 되살아난다.
+ */
+export function readOpenTabs(): OpenTabs & { stored: boolean } {
+  const st = readUiState();
+  if (!st.openTabs) return { ids: [], active: null, stored: false };
+  return { ...sanitizeOpenTabs(st.openTabs), stored: true };
+}
+
+/** 부분 병합 저장 — 다른 UI 상태가 생겨도 이 쓰기가 덮지 않는다. */
+export function writeOpenTabs(next: OpenTabs): OpenTabs {
+  const clean = sanitizeOpenTabs(next);
+  const cur = readUiState();
+  fs.writeFileSync(config.uiStatePath, JSON.stringify({ ...cur, openTabs: clean }, null, 2) + '\n');
+  return clean;
+}