@capstone-nomos/cli 0.1.3 → 0.1.4

package/dist/bridge/claude-args.js

@@ -40,6 +40,14 @@ export const ALLOWED_BASH_PREFIXES = [
     'npm run test',
     'npx vitest',
     'node --test',
+    // 시험 실행기(운영 테스트 4-4: python이 막혀 BE가 시험을 한 번도 못 돌리고 거부만 13번). 설치는 Executor가 미리 한다 — 설치 명령은 열지 않는다.
+    'pnpm test',
+    'pnpm run test',
+    'yarn test',
+    'python -m pytest',
+    'python -m unittest',
+    'python3 -m pytest',
+    'python3 -m unittest',
 ];
 export function allowedBashRules() {
     return ALLOWED_BASH_PREFIXES.map((prefix) => `Bash(${prefix}:*)`);

package/dist/bridge/nomos-client.js

@@ -95,6 +95,16 @@ export class NomosClient {
     async describeSelf() {
         return (await this.request('GET', '/api/agents/me'));
     }
+    // 룸: Claude 실행 시작·끝, 실행 중 도구 사용(종류와 대상만).
+    async startRun(taskId) {
+        await this.request('POST', `/api/tasks/${taskId}/runs/start`);
+    }
+    async endRun(taskId, body) {
+        return (await this.request('POST', `/api/tasks/${taskId}/runs/end`, body));
+    }
+    async postActivity(taskId, items) {
+        await this.request('POST', `/api/tasks/${taskId}/activity`, { items });
+    }
     async reportBranch(taskId, branchName) {
         await this.request('PATCH', `/api/tasks/${taskId}/branch`, { branchName });
     }

package/dist/executor/activity.js

@@ -0,0 +1,192 @@
+import path from 'node:path';
+const MAX_TARGET = 300;
+function clip(text) {
+    const oneLine = text.split(/\r?\n/)[0].trim();
+    return oneLine.length > MAX_TARGET ? `${oneLine.slice(0, MAX_TARGET - 1)}…` : oneLine;
+}
+// 작업공간 안의 경로는 상대 경로로(슬래시 통일), 밖이면 그대로. 노트북의 사용자 폴더 이름이 룸에 찍히지 않게 한다.
+function relative(cwd, p) {
+    if (typeof p !== 'string' || p === '')
+        return null;
+    const abs = path.resolve(cwd, p);
+    const rel = path.relative(cwd, abs);
+    if (rel === '')
+        return '.';
+    if (rel.startsWith('..') || path.isAbsolute(rel))
+        return path.basename(abs);
+    return rel.split(path.sep).join('/');
+}
+// 명령 안의 작업공간 절대 경로를 '.'으로 바꾼다 — 모델이 `git -C "C:/Users/<이름>/.nomos/..."`처럼 쓰면 사용자 폴더 이름이 룸에 찍힌다(실측).
+function hideWorkspace(command, cwd) {
+    const forms = new Set([cwd, cwd.split(path.sep).join('/'), cwd.split('/').join('\\')]);
+    let out = command;
+    for (const form of [...forms].sort((a, b) => b.length - a.length)) {
+        if (form)
+            out = out.split(form).join('.');
+    }
+    return out;
+}
+// 도구 하나 → 활동 한 줄. 룸에 보일 필요가 없는 것(NOMOS 도구 — 제출·노트는 서버 이벤트로 이미 보인다, 할 일 목록)은 null.
+export function toActivity(tool, input, cwd) {
+    // ToolSearch는 Claude Code가 도구 정의를 불러오는 내부 동작이다(실측: 실행마다 첫 줄로 찍혔다).
+    if (tool.startsWith('mcp__nomos__') || ['TodoWrite', 'AskUserQuestion', 'ToolSearch'].includes(tool))
+        return null;
+    const file = (key) => relative(cwd, input[key]);
+    let item = null;
+    switch (tool) {
+        case 'Read': {
+            const f = file('file_path');
+            item = f ? { kind: 'read', target: f } : null;
+            break;
+        }
+        case 'Edit':
+        case 'MultiEdit': {
+            const f = file('file_path');
+            item = f ? { kind: 'edit', target: f } : null;
+            break;
+        }
+        case 'NotebookEdit': {
+            const f = file('notebook_path');
+            item = f ? { kind: 'edit', target: f } : null;
+            break;
+        }
+        case 'Write': {
+            const f = file('file_path');
+            item = f ? { kind: 'write', target: f } : null;
+            break;
+        }
+        case 'Bash':
+            item = typeof input.command === 'string' && input.command.trim() ? { kind: 'run', target: hideWorkspace(input.command, cwd) } : null;
+            break;
+        case 'Grep':
+        case 'Glob':
+            item = typeof input.pattern === 'string' && input.pattern ? { kind: 'search', target: input.pattern } : null;
+            break;
+        default:
+            item = { kind: 'other', target: tool };
+    }
+    return item ? { kind: item.kind, target: clip(item.target) } : null;
+}
+// stream-json 한 줄 → 그 줄에 든 도구 호출들. 형식이 다르거나 깨진 줄은 조용히 건너뛴다(룸 표시가 실행을 막으면 안 된다).
+export function activityFromStreamLine(line, cwd) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('{'))
+        return [];
+    let msg;
+    try {
+        msg = JSON.parse(trimmed);
+    }
+    catch {
+        return [];
+    }
+    if (msg.type !== 'assistant' || !Array.isArray(msg.message?.content))
+        return [];
+    const items = [];
+    for (const block of msg.message.content) {
+        if (block.type !== 'tool_use' || typeof block.name !== 'string')
+            continue;
+        const item = toActivity(block.name, (block.input ?? {}), cwd);
+        if (item)
+            items.push(item);
+    }
+    return items;
+}
+// 활동을 모아 2초마다 한 번에 보낸다. 보내기 실패는 기록만 하고 넘어간다 — 룸 표시가 태스크 실행을 멈추면 안 된다.
+export class ActivityReporter {
+    client;
+    taskId;
+    log;
+    queue = [];
+    timer = null;
+    sending = Promise.resolve();
+    warned = false;
+    constructor(client, taskId, log, intervalMs = 2_000) {
+        this.client = client;
+        this.taskId = taskId;
+        this.log = log;
+        this.timer = setInterval(() => void this.flush(), intervalMs);
+        this.timer.unref();
+    }
+    push(items) {
+        this.queue.push(...items);
+    }
+    flush() {
+        this.sending = this.sending.then(async () => {
+            while (this.queue.length > 0) {
+                const batch = this.queue.splice(0, 50);
+                try {
+                    await this.client.postActivity(this.taskId, batch);
+                }
+                catch (err) {
+                    if (!this.warned) {
+                        this.warned = true;
+                        this.log(`룸 활동 보고 실패(실행은 계속한다): ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                }
+            }
+        });
+        return this.sending;
+    }
+    async close() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+        await this.flush();
+    }
+}
+// 실행이 제출 없이 끝났을 때 대표에게 보일 사유를 모은다 — 거부된 쉘 명령과 모델의 마지막 말.
+// 거부는 Claude Code가 돌려준 도구 결과(is_error)의 문구로 가른다("requires approval" 등). 문구가 바뀌면 빠질 수 있으나 판정이 아니라 안내라 괜찮다.
+const DENIAL = /requires (manual )?approval|permission|not allowed|denied/i;
+const SHELL_TOOLS = new Set(['Bash', 'PowerShell']);
+export class RunObserver {
+    cwd;
+    commands = new Map();
+    denied = [];
+    lastText = null;
+    resultText = null;
+    constructor(cwd) {
+        this.cwd = cwd;
+    }
+    observe(line) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('{'))
+            return;
+        let msg;
+        try {
+            msg = JSON.parse(trimmed);
+        }
+        catch {
+            return;
+        }
+        if (msg.type === 'result' && typeof msg.result === 'string')
+            this.resultText = msg.result;
+        if (!Array.isArray(msg.message?.content))
+            return;
+        for (const block of msg.message.content) {
+            if (msg.type === 'assistant' && block.type === 'text' && typeof block.text === 'string' && block.text.trim()) {
+                this.lastText = block.text;
+            }
+            if (msg.type === 'assistant' && block.type === 'tool_use' && typeof block.name === 'string' && SHELL_TOOLS.has(block.name)) {
+                const command = block.input?.command;
+                if (typeof block.id === 'string' && typeof command === 'string')
+                    this.commands.set(block.id, command);
+            }
+            if (msg.type === 'user' && block.type === 'tool_result' && block.is_error === true && typeof block.tool_use_id === 'string') {
+                const command = this.commands.get(block.tool_use_id);
+                const content = typeof block.content === 'string' ? block.content : JSON.stringify(block.content ?? '');
+                if (command !== undefined && DENIAL.test(content)) {
+                    const shown = clip(hideWorkspace(command, this.cwd));
+                    if (!this.denied.includes(shown) && this.denied.length < 20)
+                        this.denied.push(shown);
+                }
+            }
+        }
+    }
+    summary() {
+        const text = this.resultText ?? this.lastText;
+        return {
+            lastMessage: text ? hideWorkspace(text, this.cwd).trim().slice(0, 2000) : null,
+            deniedCommands: [...this.denied],
+        };
+    }
+}

package/dist/executor/cli.js

@@ -21,9 +21,11 @@ import os from 'node:os';
 import path from 'node:path';
 import { createInterface } from 'node:readline/promises';
 import { writeBriefingNotes } from '../bridge/briefing-notes.js';
-import { buildMcpConfig } from '../bridge/claude-args.js';
+import { ALLOWED_BASH_PREFIXES, buildMcpConfig } from '../bridge/claude-args.js';
+import { prepareDependencies } from './setup.js';
 import { credentialsPath, readCredentials, updateAccessToken, writeCredentials, } from '../bridge/credentials.js';
 import { NomosApiError, NomosClient } from '../bridge/nomos-client.js';
+import { ActivityReporter, activityFromStreamLine, RunObserver } from './activity.js';
 import { connect, DEFAULT_SERVER, serverCalls } from './connect.js';
 import { deviceLogin } from './device-login.js';
 import { cliVersion, mcpServerPath } from './paths.js';
@@ -79,13 +81,41 @@ async function handleTask(client, projectId, task) {
     writeFileSync(mcpConfigPath, 
     // 작업공간 경로를 넘겨야 submit_artifact가 이 worktree의 태스크 브랜치를 push한다.
     buildMcpConfig({ serverPath: mcpServerPath(), workspaceDir: workspace.dir }));
+    // 룸: 실행 시작을 알리고, 도는 동안 도구 사용을 보낸다. 룸 보고가 실패해도 실행은 그대로 간다(옛 서버에는 이 API가 없다).
+    const runOpen = await client
+        .startRun(task.id)
+        .then(() => true)
+        .catch((err) => {
+        log(`룸에 실행 시작을 알리지 못했다(실행은 계속한다): ${err instanceof Error ? err.message : String(err)}`);
+        return false;
+    });
+    const reporter = runOpen ? new ActivityReporter(client, task.id, log) : null;
+    const observer = new RunObserver(workspace.dir);
+    // 의존성은 모델이 아니라 여기서 설치한다(설치 스크립트 끔). 실패해도 진행한다 — 프롬프트에 결과를 적는다.
+    const setup = await prepareDependencies(workspace.dir, log);
     const before = headSha(workspace.dir);
     const result = await runClaude({
         workspaceDir: workspace.dir,
-        prompt: buildTaskPrompt(briefing, workspace.branch),
+        prompt: buildTaskPrompt(briefing, workspace.branch, { allowedCommands: ALLOWED_BASH_PREFIXES, setup: setup.steps }),
         mcpConfigPath,
+        pathPrepend: setup.venvBin,
+        onStdoutLine: (line) => {
+            observer.observe(line);
+            reporter?.push(activityFromStreamLine(line, workspace.dir));
+        },
     });
     const committed = headSha(workspace.dir) !== before;
+    if (reporter) {
+        await reporter.close();
+        // 제출했는지는 서버가 태스크 상태로 판단해 룸에 남긴다("끝났지만 제출하지 않았다"가 대표에게 보인다).
+        await client
+            .endRun(task.id, { outcome: result.outcome, committed, durationMs: result.durationMs, exitCode: result.exitCode, ...observer.summary() })
+            .then((r) => {
+            if (r.blocked)
+                log('제출 없이 끝나 태스크가 멈춤(BLOCKED)으로 바뀌었다 — 대표가 원인을 해결하고 재개하면 다시 가져간다');
+        })
+            .catch((err) => log(`룸에 실행 종료를 알리지 못했다: ${err instanceof Error ? err.message : String(err)}`));
+    }
     // 자동 재시도는 넣지 않는다. tasks.retry_count는 서버가 관리하는 값이고,
     // Executor가 멋대로 돌리면 M4(재작업률)가 오염된다.
     if (result.outcome === 'completed' && committed) {

package/dist/executor/prompt.js

@@ -1,4 +1,4 @@
-export function buildTaskPrompt(briefing, branch) {
+export function buildTaskPrompt(briefing, branch, environment) {
     const { task, repo, spec } = briefing;
     const sections = [];
     sections.push([
@@ -35,6 +35,21 @@ export function buildTaskPrompt(briefing, branch) {
         '- 다음 사람이 알아야 할 결정이나 함정이 있으면 publish_note로 남긴다. 다른 사람도 따라야 할 결정(계약·형식)은 DECIDED로 남긴다 — 프로젝트 전체에 전달된다.',
         '- 다른 에이전트의 잘못을 노트에 적지 않는다. 그건 raise_dispute의 몫이다.',
     ].join('\n'));
+    if (environment) {
+        const installed = environment.setup.length === 0
+            ? '- 설치할 의존성 파일(package.json·requirements.txt 등)이 없었다.'
+            : environment.setup.map((s) => `- ${s.ok ? '설치됨' : '설치 실패'}: ${s.command}`).join('\n');
+        sections.push([
+            '# 작업 환경',
+            '- 쉘 명령은 Bash 도구로, 아래 접두사로 시작하는 것만 쓸 수 있다. 그 밖의 명령과 PowerShell은 승인할 사람이 없어 **자동으로 거부된다** — 바꿔 가며 다시 시도하지 않는다.',
+            ...environment.allowedCommands.map((c) => `  - ${c}`),
+            '- 명령은 한 번에 하나씩 쓴다. `&&`·`;`·`|`로 잇거나 리다이렉트하면 거부된다.',
+            '- 파일을 보거나 찾을 때는 쉘(ls·cat·find) 대신 Read·Glob·Grep 도구를 쓴다. 작업 폴더 밖은 볼 수 없다.',
+            '- 의존성은 NOMOS가 미리 설치해 두었다. 직접 설치(npm install·pip install)는 할 수 없다. 새 의존성이 필요하면 매니페스트(package.json·requirements.txt)만 고치고 GOTCHA 노트에 남긴다.',
+            installed,
+            '- 환경이 막혀 태스크를 끝낼 수 없으면 지어내거나 시험 없이 통과했다고 하지 않는다. 할 수 있는 만큼 하고, 막힌 이유를 마지막 메시지에 분명히 적고 끝낸다 — 그 문장이 대표에게 그대로 전달되고 대표가 해결한 뒤 다시 시작된다.',
+        ].join('\n'));
+    }
     sections.push(`# 지금 할 일\n태스크 ${task.id}를 claim_task로 받고 위 규칙에 따라 진행하라.`);
     return sections.join('\n\n');
 }

package/dist/executor/runner.js

@@ -15,6 +15,11 @@ export function resolveClaudeCommand(args) {
     }
     return { command: 'claude', commandArgs: args };
 }
+// Windows는 환경변수 이름이 대소문자를 가리지 않아 Path로 들어 있는 경우가 많다 — 있는 이름을 그대로 쓴다.
+export function withPathPrepended(env, dir) {
+    const key = Object.keys(env).find((k) => k.toUpperCase() === 'PATH') ?? 'PATH';
+    return { ...env, [key]: env[key] ? `${dir}${path.delimiter}${env[key]}` : dir };
+}
 export async function runClaude(input) {
     const args = buildClaudeArgs({
         prompt: input.prompt,
@@ -30,10 +35,30 @@ export async function runClaude(input) {
         const child = spawn(command, commandArgs, {
             cwd: input.workspaceDir,
             stdio: ['ignore', 'pipe', 'pipe'],
+            ...(input.pathPrepend ? { env: withPathPrepended(process.env, input.pathPrepend) } : {}),
         });
         const chunks = [];
         const collect = (c) => chunks.push(c.toString());
-        child.stdout.on('data', collect);
+        let partial = '';
+        const emitLines = (c) => {
+            if (!input.onStdoutLine)
+                return;
+            partial += c.toString();
+            const lines = partial.split('\n');
+            partial = lines.pop() ?? '';
+            for (const line of lines) {
+                try {
+                    input.onStdoutLine(line);
+                }
+                catch {
+                    // 룸 표시 실패가 실행을 멈추면 안 된다.
+                }
+            }
+        };
+        child.stdout.on('data', (c) => {
+            collect(c);
+            emitLines(c);
+        });
         child.stderr.on('data', collect);
         let timedOut = false;
         const timer = setTimeout(() => {

package/dist/executor/setup.js

@@ -0,0 +1,71 @@
+import { exec as execShell, execFile } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+// 의존성 설치는 모델이 아니라 Executor가 Claude를 띄우기 전에 한다(운영 테스트 4-4).
+// 모델에게 `npm install`·`pip install`을 열면 설치 스크립트(postinstall·setup.py)가 임의 코드를 돌려 Edit 금지 규칙(.env·contracts)을 우회할 수 있다.
+// 그래서 여기서도 스크립트를 끈다: npm 계열은 --ignore-scripts, pip는 바이너리 휠만(--only-binary :all: — 소스 빌드는 코드 실행이다).
+// 설치가 실패해도 태스크는 진행한다 — 모델은 설치 없이 할 수 있는 만큼 하고, 못 한 것은 멈춤 사유(거부 명령)로 드러난다.
+const run = promisify(execFile);
+const runShell = promisify(execShell);
+const INSTALL_TIMEOUT_MS = 5 * 60 * 1000;
+// 작업공간에 만든 파이썬 가상환경 이름. info/exclude에 들어 있어 커밋에 섞이지 않는다(workspace.ts).
+export const VENV_DIR = '.nomos-venv';
+const NODE_MANAGERS = new Set(['npm', 'pnpm', 'yarn']);
+const defaultExec = async (cmd, args, cwd) => {
+    // Windows에서 npm·pnpm·yarn은 .cmd라 셸 없이 못 띄운다. 그 셋은 명령 이름과 인자가 전부 이 파일의 고정 문자열이라 셸에 넘겨도 주입될 값이 없다.
+    // 파이썬은 실행 파일 경로(공백이 들어갈 수 있다)를 직접 띄우므로 셸을 쓰지 않는다.
+    const options = { cwd, timeout: INSTALL_TIMEOUT_MS, windowsHide: true, maxBuffer: 16 * 1024 * 1024 };
+    if (process.platform === 'win32' && NODE_MANAGERS.has(cmd)) {
+        await runShell([cmd, ...args].join(' '), options);
+        return;
+    }
+    await run(cmd, args, options);
+};
+function pythonBin(dir) {
+    return process.platform === 'win32' ? path.join(dir, VENV_DIR, 'Scripts') : path.join(dir, VENV_DIR, 'bin');
+}
+// 어떤 설치를 할지(순수 함수). 잠금 파일이 있으면 그대로 재현(ci/frozen), 없으면 package.json만으로 설치하되 잠금 파일을 만들지 않는다
+// (만들면 작업공간에 새 파일이 생겨 모델이 커밋에 섞는다).
+export function planSetup(has) {
+    const steps = [];
+    if (has('pnpm-lock.yaml'))
+        steps.push({ manager: 'pnpm', cmd: 'pnpm', args: ['install', '--frozen-lockfile', '--ignore-scripts'] });
+    else if (has('yarn.lock'))
+        steps.push({ manager: 'yarn', cmd: 'yarn', args: ['install', '--frozen-lockfile', '--ignore-scripts'] });
+    else if (has('package-lock.json'))
+        steps.push({ manager: 'npm', cmd: 'npm', args: ['ci', '--ignore-scripts', '--no-audit', '--no-fund'] });
+    else if (has('package.json')) {
+        steps.push({ manager: 'npm', cmd: 'npm', args: ['install', '--ignore-scripts', '--no-package-lock', '--no-audit', '--no-fund'] });
+    }
+    if (has('requirements.txt')) {
+        steps.push({ manager: 'python', cmd: process.platform === 'win32' ? 'python' : 'python3', args: ['-m', 'venv', VENV_DIR] });
+        steps.push({ manager: 'pip', cmd: 'venv-python', args: ['-m', 'pip', 'install', '--only-binary', ':all:', '--disable-pip-version-check', '-r', 'requirements.txt'] });
+    }
+    return steps;
+}
+export async function prepareDependencies(dir, log, exec = defaultExec) {
+    const plan = planSetup((file) => existsSync(path.join(dir, file)));
+    const steps = [];
+    let venvBin = null;
+    for (const step of plan) {
+        const cmd = step.cmd === 'venv-python' ? path.join(pythonBin(dir), 'python') : step.cmd;
+        // venv를 못 만들었으면 pip도 건너뛴다.
+        if (step.cmd === 'venv-python' && venvBin === null)
+            continue;
+        const command = `${step.cmd === 'venv-python' ? 'python' : step.cmd} ${step.args.join(' ')}`;
+        try {
+            await exec(cmd, step.args, dir);
+            steps.push({ manager: step.manager, command, ok: true });
+            if (step.manager === 'python')
+                venvBin = pythonBin(dir);
+            log(`의존성 설치: ${command} — OK`);
+        }
+        catch (err) {
+            const detail = err instanceof Error ? err.message.split('\n')[0].slice(0, 200) : String(err);
+            steps.push({ manager: step.manager, command, ok: false, detail });
+            log(`의존성 설치 실패(태스크는 진행한다): ${command} — ${detail}`);
+        }
+    }
+    return { steps, venvBin };
+}

package/dist/executor/workspace.js

@@ -68,7 +68,16 @@ export function prepareWorkspace(input) {
 }
 // Executor가 작업공간에 쓰는 파일(MCP 설정·실행 로그·브리핑 노트·정책 표시·settings.json)이 모델의 `git add`에 섞이지 않게 한다.
 // 커밋에 섞이면 신고 경로와 실제 diff가 어긋나 V3가 FAIL을 낸다. info/exclude는 레포 공통이라 모든 worktree에 걸린다.
-export const NOMOS_LOCAL_FILES = ['/.nomos-mcp.json', '/.nomos-run.log', '/.nomos-briefing.json', '/.claude/.nomos-policy.json', '/.claude/settings.json'];
+// node_modules·.nomos-venv는 Executor가 미리 설치한 의존성(setup.ts) — 레포에 .gitignore가 없어도 커밋에 섞이지 않게.
+export const NOMOS_LOCAL_FILES = [
+    '/.nomos-mcp.json',
+    '/.nomos-run.log',
+    '/.nomos-briefing.json',
+    '/.claude/.nomos-policy.json',
+    '/.claude/settings.json',
+    '/node_modules/',
+    '/.nomos-venv/',
+];
 export function excludeNomosFiles(repoPath) {
     try {
         const commonDir = path.resolve(repoPath, git(repoPath, ['rev-parse', '--git-common-dir']));

package/package.json

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