@capstone-nomos/cli 0.1.0 → 0.1.1

package/dist/bridge/nomos-client.js

@@ -84,6 +84,11 @@ export class NomosClient {
         return data.tasks;
     }
     // 프롬프트와 .claude/settings.json을 만드는 데 필요한 것 한 번에.
+    // 지금 가져갈 수 있는 태스크(서버가 역할·선행·시작 여부로 거른 것). 웹소켓 푸시와 같은 목록이다.
+    async listClaimableTasks() {
+        const data = (await this.request('GET', '/api/agents/me/tasks'));
+        return data.tasks;
+    }
     async getBriefing(taskId) {
         return (await this.request('GET', `/api/tasks/${taskId}/briefing`));
     }
@@ -93,6 +98,17 @@ export class NomosClient {
     async reportBranch(taskId, branchName) {
         await this.request('PATCH', `/api/tasks/${taskId}/branch`, { branchName });
     }
+    // 중계 모드 PM 작업(대표 노트북의 pm-worker만).
+    async nextPmJob() {
+        const data = (await this.request('GET', '/api/pm/jobs/next'));
+        return data.job;
+    }
+    async submitPmJobResult(jobId, result) {
+        await this.request('POST', `/api/pm/jobs/${jobId}/result`, result);
+    }
+    async failPmJob(jobId, message) {
+        await this.request('POST', `/api/pm/jobs/${jobId}/failure`, { message });
+    }
     async request(method, path, body) {
         const first = await this.send(method, path, body);
         if (!needsRefresh(first))

package/dist/executor/cli.js

@@ -12,6 +12,7 @@
 //   executor once              READY 태스크 하나만 처리하고 종료 (개발·데모용)
 //   executor start             10초 폴링
 //   executor clean             worktree 정리
+//   nomos pm-worker            (대표 전용, 서버가 PM_PROVIDER=relay일 때) PM의 모델 호출을 이 노트북의 Claude Code로 대신 실행
 //
 // 서버를 옮길 때 baseUrl만 바꾸면 안 된다. 토큰은 발급한 서버의 서명 키와 그 DB의 agents 행에 묶여 있어
 // 다른 서버에서는 전부 401이다. 원격에 가입해 받은 연결 키로 login을 다시 해야 한다.
@@ -21,17 +22,20 @@ import path from 'node:path';
 import { createInterface } from 'node:readline/promises';
 import { buildMcpConfig } from '../bridge/claude-args.js';
 import { credentialsPath, readCredentials, updateAccessToken, writeCredentials, } from '../bridge/credentials.js';
-import { NomosClient } from '../bridge/nomos-client.js';
+import { NomosApiError, NomosClient } from '../bridge/nomos-client.js';
 import { connect, DEFAULT_SERVER, serverCalls } from './connect.js';
 import { deviceLogin } from './device-login.js';
 import { cliVersion, mcpServerPath } from './paths.js';
 import { checkTools } from './preflight.js';
+import { handleNextPmJob } from './pm-worker.js';
 import { buildTaskPrompt } from './prompt.js';
 import { runClaude } from './runner.js';
+import { streamTaskSource } from './stream-source.js';
 import { pollingTaskSource } from './task-source.js';
 import { runLint, runSpecTests } from './verify.js';
 import { ensureRepo } from './repo-checkout.js';
 import { cleanWorkspaces, headSha, prepareWorkspace } from './workspace.js';
+// 푸시가 오지 않아도 이 간격으로 한 번씩 다시 본다(끊겼을 때는 이 간격으로 폴링한다).
 const POLL_INTERVAL_MS = 10_000;
 function log(line) {
     process.stdout.write(`[nomos] ${line}\n`);
@@ -124,10 +128,10 @@ async function reportBridgeStages(client, taskId, workspaceDir, specTests) {
 async function once() {
     const client = createClient();
     const self = await client.describeSelf();
-    const source = pollingTaskSource(client, self.projectId);
+    const source = pollingTaskSource(client);
     const [task] = await source.nextTasks(1);
     if (!task) {
-        log('READY 태스크가 없다');
+        log('지금 가져갈 수 있는 태스크가 없다(프로젝트 시작 전이거나, 선행 태스크가 끝나지 않았거나, READY가 없다)');
         return;
     }
     await handleTask(client, self.projectId, task);
@@ -135,28 +139,42 @@ async function once() {
 async function start() {
     const client = createClient();
     const self = await client.describeSelf();
-    const source = pollingTaskSource(client, self.projectId);
+    // 서버 푸시(웹소켓)로 받는다. 끊겨 있는 동안은 같은 목록을 HTTP로 읽는다.
+    const source = streamTaskSource({
+        baseUrl: readCredentials().baseUrl,
+        accessToken: () => readCredentials().accessToken,
+        refresh: async () => {
+            if ((await serverCalls({ read: readCredentials, updateAccessToken }).refresh()) === 'rejected') {
+                throw new Error('refresh token이 거부됐다 — connect를 다시 실행하라');
+            }
+        },
+        fallback: () => pollingTaskSource(client).nextTasks(Number.MAX_SAFE_INTEGER),
+        log,
+    });
     log(`시작 — 프로젝트 ${self.projectId}, 역할 ${self.teamRole}, 동시 실행 ${self.maxConcurrent} (${source.kind})`);
     const inFlight = new Set();
+    // 태스크 하나가 끝나면 자리가 난다 — 다음 푸시나 간격을 기다리지 않고 바로 다시 본다.
+    let finished = () => { };
     for (;;) {
         try {
             const capacity = self.maxConcurrent - inFlight.size;
             if (capacity > 0) {
-                for (const task of await source.nextTasks(capacity)) {
-                    // 이미 처리 중인 태스크는 건너뛴다. 폴링은 같은 목록을 여러 번 준다.
-                    if (inFlight.has(task.id))
-                        continue;
+                // 처리 중인 것도 목록에 남아 있을 수 있으니(수령 전) 그만큼 더 받아 거른다.
+                for (const task of (await source.nextTasks(capacity + inFlight.size)).filter((t) => !inFlight.has(t.id)).slice(0, capacity)) {
                     inFlight.add(task.id);
                     void handleTask(client, self.projectId, task)
                         .catch((err) => log(`태스크 ${task.id} 실패: ${err instanceof Error ? err.message : String(err)}`))
-                        .finally(() => inFlight.delete(task.id));
+                        .finally(() => {
+                        inFlight.delete(task.id);
+                        finished();
+                    });
                 }
             }
         }
         catch (err) {
-            log(`폴링 실패: ${err instanceof Error ? err.message : String(err)}`);
+            log(`태스크 목록 실패: ${err instanceof Error ? err.message : String(err)}`);
         }
-        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+        await Promise.race([source.waitForChange(POLL_INTERVAL_MS), new Promise((resolve) => (finished = resolve))]);
     }
 }
 // 토큰이 헤더로 다니므로 원격은 https만 받는다. 로컬 개발 서버만 예외다.
@@ -311,6 +329,24 @@ async function refresh() {
         log(`재발급은 됐지만 아직 프로젝트에 배정되지 않은 것 같다: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
+const PM_POLL_INTERVAL_MS = 3_000;
+async function pmWorker() {
+    const client = createClient();
+    log('pm-worker 시작 — 대표가 PM에 계획을 요청하면 여기서 claude가 돈다 (Ctrl+C로 종료)');
+    for (;;) {
+        try {
+            if (await handleNextPmJob(client, log))
+                continue;
+        }
+        catch (err) {
+            // 설정이 틀린 경우는 기다려도 풀리지 않는다 — 바로 멈춘다.
+            if (err instanceof NomosApiError && (err.code === 'PM_RELAY_DISABLED' || err.code === 'NOT_REPRESENTATIVE'))
+                throw err;
+            log(`폴링 실패: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, PM_POLL_INTERVAL_MS));
+    }
+}
 async function main() {
     const command = process.argv[2];
     if (command === 'connect')
@@ -329,6 +365,8 @@ async function main() {
         return once();
     if (command === 'start')
         return start();
+    if (command === 'pm-worker')
+        return pmWorker();
     if (command === 'clean') {
         const { pruned, removed } = cleanWorkspaces();
         log(`worktree prune: ${pruned.join(', ') || '없음'} / 삭제: ${removed ?? '없음'}`);
@@ -340,6 +378,7 @@ async function main() {
         '  doctor                                       설치 상태 점검',
         '  login [주소] [--name 이름] [--connect-key]   로그인만',
         '  refresh | once | start | clean | --version',
+        '  pm-worker                                    (대표 전용, 서버가 PM_PROVIDER=relay일 때) PM 모델 호출을 이 노트북의 Claude Code로',
         '',
     ].join('\n'));
     process.exitCode = 1;

package/dist/executor/pm-worker.js

@@ -0,0 +1,110 @@
+import { spawn } from 'node:child_process';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { resolveClaudeCommand } from './runner.js';
+// 지침·프롬프트는 길어서(이전 초안이 붙는 수정 요청) 명령줄로 넘기지 않는다 — Windows 명령줄은 32k자에서 잘린다.
+// 지침은 파일, 프롬프트는 stdin. 도구는 전부 끄고(--tools ""), 사용자 MCP·세션 기록도 쓰지 않는다.
+export function buildPmClaudeArgs(job, systemPromptFile) {
+    return [
+        '-p',
+        '--output-format',
+        'json',
+        '--model',
+        job.request.model,
+        '--effort',
+        job.request.effort,
+        '--system-prompt-file',
+        systemPromptFile,
+        '--json-schema',
+        JSON.stringify(job.request.jsonSchema),
+        '--tools',
+        '',
+        '--strict-mcp-config',
+        '--no-session-persistence',
+    ];
+}
+// 출력 → 서버에 돌려줄 결과. 실패면 { error }.
+export function toJobResult(out, requestedModel) {
+    if (out.is_error)
+        return { error: `claude reported an error (${out.subtype ?? 'unknown'}): ${(out.result ?? '').slice(0, 500)}` };
+    const text = out.structured_output !== undefined && out.structured_output !== null
+        ? JSON.stringify(out.structured_output)
+        : (out.result ?? '');
+    if (!text)
+        return { error: 'claude returned no output' };
+    // 실제로 응답한 모델: 출력이 가장 많은 모델(부수 호출에 작은 모델이 섞일 수 있다).
+    const served = Object.entries(out.modelUsage ?? {}).sort((a, b) => (b[1].outputTokens ?? 0) - (a[1].outputTokens ?? 0))[0]?.[0] ?? requestedModel;
+    // stop_reason은 그대로 넘긴다. Claude Code는 구조화 출력을 도구 호출로 내므로 정상 완료도 'tool_use'로 온다(실측) —
+    // 서버는 refusal·max_tokens만 따로 다루므로 그대로 둬도 흐름은 같고, 기록은 실제 값이 남는다.
+    return {
+        stopReason: out.stop_reason ?? null,
+        servedModel: served,
+        text,
+        usage: {
+            inputTokens: out.usage?.input_tokens ?? 0,
+            outputTokens: out.usage?.output_tokens ?? 0,
+            cacheWriteTokens: out.usage?.cache_creation_input_tokens ?? 0,
+            cacheReadTokens: out.usage?.cache_read_input_tokens ?? 0,
+        },
+    };
+}
+const spawnClaude = (args, stdin, cwd) => {
+    const { command, commandArgs } = resolveClaudeCommand(args);
+    return new Promise((resolve, reject) => {
+        // shell을 쓰지 않는다 — 인자가 명령으로 해석되지 않게(runner.ts와 같은 이유).
+        const child = spawn(command, commandArgs, { cwd, stdio: ['pipe', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (c) => (stdout += c.toString()));
+        child.stderr.on('data', (c) => (stderr += c.toString()));
+        child.once('error', reject);
+        child.once('close', (exitCode) => resolve({ exitCode, stdout, stderr }));
+        child.stdin.end(stdin);
+    });
+};
+export async function runPmJob(job, run = spawnClaude) {
+    // 빈 임시 폴더에서 돈다 — 레포·CLAUDE.md를 읽지 않게. 끝나면 지운다(지침 사본이 남지 않게).
+    const dir = mkdtempSync(path.join(os.tmpdir(), 'nomos-pm-'));
+    try {
+        const systemFile = path.join(dir, 'system.md');
+        writeFileSync(systemFile, job.request.system, 'utf8');
+        const { exitCode, stdout, stderr } = await run(buildPmClaudeArgs(job, systemFile), job.request.user, dir);
+        let out;
+        try {
+            out = JSON.parse(stdout);
+        }
+        catch {
+            return { error: `claude exited ${exitCode} without JSON output: ${(stderr || stdout).slice(0, 500)}` };
+        }
+        return toJobResult(out, job.request.model);
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+// 작업 하나를 가져와 처리한다. 처리했으면 true.
+export async function handleNextPmJob(client, log, run = spawnClaude) {
+    const job = (await client.nextPmJob());
+    if (!job)
+        return false;
+    log(`PM 작업 ${job.id} (계획 ${job.planId}, ${job.purpose}) — claude 실행 중`);
+    const started = Date.now();
+    let result;
+    try {
+        result = await runPmJob(job, run);
+    }
+    catch (err) {
+        result = { error: err instanceof Error ? err.message : String(err) };
+    }
+    const sec = Math.round((Date.now() - started) / 1000);
+    if ('error' in result) {
+        log(`실패(${sec}s): ${result.error}`);
+        await client.failPmJob(job.id, result.error.slice(0, 2000));
+    }
+    else {
+        log(`완료(${sec}s, 출력 ${result.usage.outputTokens} 토큰) — 서버로 보냄`);
+        await client.submitPmJobResult(job.id, result);
+    }
+    return true;
+}

package/dist/executor/stream-source.js

@@ -0,0 +1,114 @@
+export const AGENT_STREAM_PATH = '/api/agents/stream';
+export function streamUrl(baseUrl) {
+    const url = new URL(AGENT_STREAM_PATH, baseUrl);
+    url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+    return url.toString();
+}
+export function streamTaskSource(deps) {
+    const WS = deps.WebSocketImpl ?? globalThis.WebSocket;
+    const backoff = deps.backoff ?? { initialMs: 1000, maxMs: 30_000 };
+    let latest = [];
+    let connected = false;
+    let closed = false;
+    let delay = backoff.initialMs;
+    let refreshedInARow = false;
+    let ws = null;
+    let reconnectTimer = null;
+    const waiters = new Set();
+    const wake = () => {
+        for (const w of waiters)
+            w();
+        waiters.clear();
+    };
+    const schedule = () => {
+        if (closed)
+            return;
+        reconnectTimer = setTimeout(connect, delay);
+        delay = Math.min(delay * 2, backoff.maxMs);
+    };
+    function connect() {
+        reconnectTimer = null;
+        if (closed)
+            return;
+        const socket = new WS(streamUrl(deps.baseUrl));
+        ws = socket;
+        socket.onopen = () => socket.send(JSON.stringify({ type: 'auth', token: deps.accessToken() }));
+        socket.onmessage = (ev) => {
+            let msg;
+            try {
+                msg = JSON.parse(String(ev.data));
+            }
+            catch {
+                return;
+            }
+            if (msg.type === 'ready') {
+                connected = true;
+                delay = backoff.initialMs;
+                refreshedInARow = false;
+                deps.log(`서버 푸시 연결됨 — 프로젝트 ${msg.projectId ?? '?'}`);
+            }
+            else if (msg.type === 'tasks') {
+                latest = msg.tasks ?? [];
+                wake();
+            }
+            else if (msg.type === 'error') {
+                deps.log(`서버 푸시 거부: ${msg.code ?? '?'} ${msg.message ?? ''}`.trim());
+            }
+        };
+        socket.onerror = () => { };
+        socket.onclose = (ev) => {
+            const wasConnected = connected;
+            connected = false;
+            ws = null;
+            if (closed)
+                return;
+            if (ev.code === 4403) {
+                deps.log('이 에이전트는 프로젝트 멤버가 아니다 — 푸시를 멈춘다(폴링으로 계속 확인한다)');
+                wake();
+                return;
+            }
+            if (ev.code === 4401 && !refreshedInARow) {
+                refreshedInARow = true;
+                deps
+                    .refresh()
+                    .then(() => connect())
+                    .catch((err) => deps.log(`토큰 재발급 실패 — 푸시를 멈춘다: ${err instanceof Error ? err.message : String(err)}`));
+                return;
+            }
+            if (wasConnected)
+                deps.log(`서버 푸시 끊김(${ev.code}) — 다시 연결한다. 그동안은 폴링한다`);
+            wake();
+            schedule();
+        };
+    }
+    connect();
+    return {
+        kind: 'push',
+        get connected() {
+            return connected;
+        },
+        async nextTasks(limit) {
+            // 연결돼 있으면 받은 스냅샷, 아니면 같은 목록을 HTTP로.
+            const tasks = connected ? latest : await deps.fallback();
+            return tasks.slice(0, limit);
+        },
+        waitForChange(maxMs) {
+            return new Promise((resolve) => {
+                const done = () => {
+                    clearTimeout(timer);
+                    waiters.delete(done);
+                    resolve();
+                };
+                const timer = setTimeout(done, maxMs);
+                waiters.add(done);
+            });
+        },
+        close() {
+            closed = true;
+            if (reconnectTimer)
+                clearTimeout(reconnectTimer);
+            ws?.close(1000, 'bye');
+            wake();
+        },
+    };
+}

package/dist/executor/task-source.js

@@ -1,10 +1,12 @@
-// 서버가 에이전트 토큰을 보고 자기 역할로 필터해 준다 — 여기서 역할을 다시 거르지 않는다.
-export function pollingTaskSource(client, projectId) {
+// 서버가 이 에이전트의 역할·선행·프로젝트 시작 여부로 거른 목록(GET /api/agents/me/tasks)을 읽는다 — 여기서 다시 거르지 않는다.
+export function pollingTaskSource(client) {
     return {
         kind: 'polling',
         async nextTasks(limit) {
-            const rows = await client.listTasks(projectId, { state: 'READY', limit });
-            return rows;
+            const rows = await client.listClaimableTasks();
+            return rows.slice(0, limit);
         },
+        waitForChange: (maxMs) => new Promise((resolve) => setTimeout(resolve, maxMs)),
+        close: () => { },
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capstone-nomos/cli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "NOMOS 에이전트 CLI — 노트북의 Claude Code를 NOMOS 서버에 연결하고 배정된 태스크를 실행한다",
   "type": "module",
   "bin": {