axmap-cli 1.5.0 → 1.6.0

package/src/external-console.mts

@@ -0,0 +1,128 @@
+/** Attach to an existing Windows console; never launch or resume a model. */
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import { createHash } from 'node:crypto'
+import { spawnSync } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+import { bridgeHome, repoKey, readJSON, writeJSON } from './bridge.mjs'
+import { nativeConsoleHelper } from './windows-console.mjs'
+import type { SessionRecord, RequestRecord, ConsoleSnapshot, HookInput, TranscriptEntry } from './session-types.mjs'
+
+const helper = fileURLToPath(new URL('../tools/windows-console.ps1', import.meta.url))
+export function consoleCall(pid: number, action?: 'snapshot' | 'send', payload?: Record<string, unknown>): ConsoleSnapshot
+export function consoleCall(pid: number, action: 'ancestor', payload?: Record<string, unknown>): ConsoleSnapshot | { ignored: true }
+export function consoleCall(pid: number, action = 'snapshot', payload: Record<string, unknown> = {}): ConsoleSnapshot | { ignored: true } {
+  if (process.platform !== 'win32') throw new Error('독립 agy 콘솔 연결은 현재 Windows에서 지원합니다.')
+  if (!Number.isSafeInteger(pid) || pid <= 0) throw new Error('양의 정수 PID가 필요합니다.')
+  const native = nativeConsoleHelper()
+  const r = spawnSync(native || 'powershell.exe', native ? [String(pid), action] : ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass',
+    '-File', helper, '-TargetPid', String(pid), '-Action', action], {
+    input: JSON.stringify(payload), encoding: 'utf8', windowsHide: true, timeout: 8000, maxBuffer: 1024 * 1024,
+  })
+  let data: (Omit<Partial<ConsoleSnapshot>, 'ignored'> & { error?: string; ignored?: boolean }) | undefined
+  try { data = JSON.parse(r.stdout) } catch { /* report the underlying failure */ }
+  if (r.error || r.status !== 0 || data?.error || !data) throw new Error(data?.error || r.error?.message || r.stderr?.trim() || '기존 콘솔 연결 실패')
+  if (action === 'ancestor' && data.ignored) return { ignored: true }
+  if (typeof data.pid !== 'number' || typeof data.startedAt !== 'string' || (action !== 'ancestor' && typeof data.screen !== 'string')) throw new Error('기존 콘솔 응답 형식이 올바르지 않습니다.')
+  return data as ConsoleSnapshot
+}
+function identityID({ pid, startedAt }: Pick<ConsoleSnapshot, 'pid' | 'startedAt'>): string {
+  const hex = createHash('sha256').update(`agy-console:${pid}:${startedAt}`).digest('hex')
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-a${hex.slice(17, 20)}-${hex.slice(20, 32)}`
+}
+const target = (id: string) => path.join(bridgeHome(), 'sessions', `${id}.json`)
+export function consoleIdle(screen: string): boolean {
+  // Use the last input box only. Old answers may contain quoted prompt boxes.
+  const borders = [...screen.matchAll(/^[─━]{10,}\r?$/gm)]
+  if (borders.length < 2) return false
+  const top = borders.at(-2), bottom = borders.at(-1)
+  if (!top || !bottom) return false
+  const input = screen.slice(top.index + top[0].length, bottom.index).trim()
+  const footer = screen.slice(bottom.index + bottom[0].length)
+  return input === '>' && /\? for shortcuts/.test(footer) && !/esc to cancel/i.test(footer)
+}
+export function attachConsole({ pid, cwd }: { pid: number; cwd: string }) {
+  const live = consoleCall(pid)
+  const id = identityID(live)
+  const previous = fs.existsSync(target(id)) ? readJSON<Partial<SessionRecord>>(target(id)) : {}
+  const repo = repoKey(cwd)
+  if (previous.repos && !previous.repos.includes(repo)) throw new Error('이 프로세스는 다른 저장소에 등록되어 있습니다.')
+  const idle = consoleIdle(live.screen)
+  const s: SessionRecord = { ...previous, id, provider: 'agy', transport: 'console', pid, startedAt: live.startedAt,
+    workspaces: previous.workspaces || [path.resolve(cwd)], repos: previous.repos || [repo],
+    state: idle ? 'idle' : 'unknown', fullyIdle: idle, registeredAt: new Date().toISOString(), event: previous.event || 'attach' }
+  writeJSON(target(id), s)
+  return { id, provider: s.provider, transport: s.transport, pid, state: s.state, workspaces: s.workspaces }
+}
+export function registerExternalHook(input: HookInput, event: string) {
+  if (!['SessionStart', 'PreInvocation', 'Stop'].includes(event)) throw new Error('지원하지 않는 훅 이벤트입니다.')
+  const identity = consoleCall(process.pid, 'ancestor')
+  if (identity.ignored) return {}
+  const id = identityID(identity)
+  const previous = fs.existsSync(target(id)) ? readJSON<Partial<SessionRecord>>(target(id)) : {}
+  const workspaces = input.workspacePaths || previous.workspaces
+  if (!Array.isArray(workspaces) || !workspaces.length || workspaces.some(p => !path.isAbsolute(p))) throw new Error('훅의 작업 저장소 경로가 없습니다.')
+  const conversationId = input.conversationId
+  if (typeof conversationId !== 'string' || !/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(conversationId)) throw new Error('훅의 대화 UUID가 없습니다.')
+  const transcript = path.join(process.env.AXMAP_AGY_HOME || path.join(os.homedir(), '.gemini', 'antigravity-cli'),
+    'brain', conversationId, '.system_generated', 'logs', 'transcript.jsonl')
+  if (path.resolve(input.transcriptPath || '') !== transcript) throw new Error('훅의 대화 기록 경로가 다릅니다.')
+  const idle = event === 'Stop' && input.fullyIdle === true
+  writeJSON(target(id), { ...previous, ...identity, id, provider: 'agy', transport: 'console', conversationId,
+    transcript, workspaces, repos: [...new Set(workspaces.map(repoKey))], model: input.modelName || previous.model,
+    event, state: idle ? 'idle' : 'running', fullyIdle: idle, registeredAt: new Date().toISOString() })
+  return { id }
+}
+export function externalStatus(session: Pick<SessionRecord, 'id'>) {
+  const s = readJSON<SessionRecord>(target(session.id))
+  const live = consoleCall(consolePID(s), 'snapshot', { startedAt: s.startedAt })
+  const state: 'idle' | 'unknown' = consoleIdle(live.screen) ? 'idle' : 'unknown'
+  writeJSON(target(s.id), { ...readJSON<SessionRecord>(target(s.id)), state, fullyIdle: state === 'idle' })
+  return { id: s.id, state }
+}
+function consolePID(s: SessionRecord): number {
+  if (!s.pid || !s.startedAt) throw new Error('등록된 콘솔 프로세스 신원이 없습니다.')
+  return s.pid
+}
+export function checkConsole(s: SessionRecord): ConsoleSnapshot {
+  const live = consoleCall(consolePID(s), 'snapshot', { startedAt: s.startedAt })
+  if (!consoleIdle(live.screen)) throw new Error('상대 콘솔이 빈 입력창에서 대기 중이지 않습니다. 입력을 보내지 않았습니다.')
+  return live
+}
+export function validateConsolePrompt(prompt: string, from: string): void {
+  if (/[\x00-\x08\x0b-\x1f\x7f]/.test(prompt.replace(/\r\n/g, '\n')) || /[\x00-\x1f\x7f]/.test(from)) throw new Error('콘솔 요청에는 제어 문자를 포함할 수 없습니다.')
+}
+export function findConsoleTranscript(s: SessionRecord, request: RequestRecord): SessionRecord {
+  if (s.transcript) return s
+  const brain = path.join(process.env.AXMAP_AGY_HOME || path.join(os.homedir(), '.gemini', 'antigravity-cli'), 'brain')
+  if (!fs.existsSync(brain)) return s
+  const marker = `[axMap request ${request.id}]`
+  const matches = []
+  for (const entry of fs.readdirSync(brain, { withFileTypes: true })) {
+    if (!entry.isDirectory() || !/^[0-9a-f-]{36}$/i.test(entry.name)) continue
+    const log = path.join(brain, entry.name, '.system_generated', 'logs', 'transcript.jsonl')
+    let stat
+    try { stat = fs.statSync(log) } catch { continue }
+    if (stat.mtimeMs < Date.parse(request.createdAt) || stat.size > 32 * 1024 * 1024) continue
+    const records = fs.readFileSync(log, 'utf8').split('\n').slice(0, -1)
+    if (records.some(line => {
+      try { const e = JSON.parse(line) as TranscriptEntry; return e.type === 'USER_INPUT' && String(e.content).includes(marker) }
+      catch { return false }
+    })) matches.push({ conversationId: entry.name, transcript: log })
+  }
+  if (matches.length !== 1) return s
+  const updated = { ...readJSON<SessionRecord>(target(s.id)), ...matches[0] }
+  writeJSON(target(s.id), updated)
+  return updated
+}
+export function submitConsole(s: SessionRecord, request: RequestRecord, preflight?: ConsoleSnapshot) {
+  validateConsolePrompt(request.prompt, request.from)
+  const live = preflight || checkConsole(s)
+  // Bracketed paste preserves multiline prompts and prevents embedded Enter keys
+  // from becoming separate submissions. Only the final CR submits the message.
+  const text = `\x1b[200~[axMap request ${request.id}]\n요청자: ${request.from}\n${request.prompt.replace(/\r\n/g, '\n')}\x1b[201~\r`
+  consoleCall(consolePID(s), 'send', { startedAt: s.startedAt, expectedScreen: live.screen, text })
+  writeJSON(target(s.id), { ...readJSON<SessionRecord>(target(s.id)), state: 'running', fullyIdle: false })
+  return { accepted: true, pid: s.pid }
+}

package/src/managed-session.mjs

@@ -1,178 +1,272 @@
+// Generated from src/managed-session.mts. Edit the .mts source and run npm run build.
 /** Explicitly launched persistent CLI sessions. No transcript scraping, global
  * hook edits, per-message process spawning, or inference while the queue is idle. */
-import fs from 'node:fs'
-import path from 'node:path'
-import net from 'node:net'
-import { spawn } from 'node:child_process'
-import { randomUUID, randomBytes, timingSafeEqual } from 'node:crypto'
-import { bridgeHome, repoKey, writeJSON } from './bridge.mjs'
-import { normalizeUsage, usageDelta } from './session-usage.mjs'
-
-const pipeFor = id => process.platform === 'win32' ? `\\\\.\\pipe\\axmap-${id}` : path.join(bridgeHome(), `${id}.sock`)
-const uuid = value => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value || '')
-
-export async function startManagedSession({ provider, executable = provider, prefix = [], args = null, model, role = '',
-  cwd = process.cwd(), maxTokens = 100000, timeoutMs = 120000, onEvent = () => {} }) {
-  if (!['codex', 'agy'].includes(provider)) throw new Error('지원하는 세션은 codex 또는 agy입니다.')
-  if (!Number.isSafeInteger(maxTokens) || maxTokens < 1 || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1) throw new Error('양의 토큰/시간 한도가 필요합니다.')
-  if (typeof role !== 'string' || role.length > 1000) throw new Error('역할은 1000자 이하여야 합니다.')
-  const id = randomUUID(), token = randomBytes(32).toString('hex')
-  const sessionPath = path.join(bridgeHome(), 'sessions', `${id}.json`)
-  const s = { id, token, provider, transport: 'stdio', role, model: model || null,
-    workspaces: [path.resolve(cwd)], repos: [repoKey(cwd)], state: 'starting', fullyIdle: false,
-    registeredAt: new Date().toISOString(), usage: null, usageKnown: true, maxTokens }
-  const jobs = new Map(), calls = new Map()
-  let child, sequence = 0, pending = null, closed = false, buffer = '', stderr = '', turnTimer
-  const save = () => { s.registeredAt = new Date().toISOString(); writeJSON(sessionPath, s) }
-  const emit = event => onEvent({ session: id, ...event })
-  const write = message => {
-    if (closed || !child?.stdin.writable) throw new Error('세션 입력 연결이 종료됐습니다.')
-    child.stdin.write(JSON.stringify(message) + '\n')
-  }
-  const rpc = (method, params) => new Promise((resolve, reject) => {
-    const callId = ++sequence
-    const timer = setTimeout(() => { calls.delete(callId); reject(new Error(`${method}: 응답 시간 초과`)) }, 15000)
-    calls.set(callId, { resolve, reject, timer })
-    try { write({ id: callId, method, params }) } catch (e) { clearTimeout(timer); calls.delete(callId); reject(e) }
-  })
-  const finish = (state, result, error, rawUsage) => {
-    if (!pending) return
-    clearTimeout(turnTimer)
-    const usage = normalizeUsage(provider, rawUsage)
-    Object.assign(pending, { state, result, error, usage: pending.baselineKnown ? usageDelta(usage, pending.baseline) : null,
-      completedAt: new Date().toISOString(), conversationId: s.conversationId })
-    delete pending.baseline
-    delete pending.baselineKnown
-    if (usage) s.usage = usage
-    s.usageKnown = usage !== null
-    emit({ event: 'result', request: { ...pending } })
-    pending = null; s.state = 'idle'; s.fullyIdle = true; delete s.pendingApproval; save()
-  }
-  const shutdown = reason => {
-    if (closed) return
-    finish('unknown', undefined, reason)
-    closed = true; clearTimeout(turnTimer)
-    for (const c of calls.values()) { clearTimeout(c.timer); c.reject(new Error(reason)) }
-    calls.clear()
-    s.state = 'closed'; s.fullyIdle = false; save()
-    child?.stdin.destroy(); child?.kill(); server.close()
-  }
-  const handle = message => {
-    const offered = Buffer.from(typeof message.token === 'string' ? message.token : '')
-    const expected = Buffer.from(token)
-    if (offered.length !== expected.length || !timingSafeEqual(offered, expected)) throw new Error('로컬 세션 인증 실패')
-    if (message.action === 'status') return { id, state: s.state, usage: s.usage, pendingApproval: s.pendingApproval }
-    if (message.action === 'result') {
-      const result = jobs.get(message.id)
-      if (!result) throw new Error('이 세션에 해당 요청이 없습니다.')
-      const { baseline, baselineKnown, ...publicResult } = result
-      return publicResult
-    }
-    if (message.action === 'answer') {
-      const approval = s.pendingApproval
-      if (!approval || String(approval.id) !== String(message.id)) throw new Error('현재 대기 중인 승인 요청이 아닙니다.')
-      if (!['accept', 'decline', 'cancel'].includes(message.decision)) throw new Error('이번 실행의 accept, decline 또는 cancel만 지원합니다.')
-      write({ id: approval.id, result: { decision: message.decision } })
-      delete s.pendingApproval; s.state = 'running'; save(); return { answered: true }
-    }
-    if (message.action !== 'submit') throw new Error('지원하지 않는 로컬 세션 요청입니다.')
-    if (closed || s.state !== 'idle' || pending) throw new Error('세션이 대기 중이 아닙니다. 요청을 전달하지 않았습니다.')
-    if (!s.usageKnown) throw new Error('직전 요청의 사용량을 확인하지 못했습니다. 새 연결에서 예산을 확인하세요.')
-    if (s.usage && s.usage.totalTokens >= maxTokens) throw new Error('세션 토큰 한도에 도달했습니다.')
-    const request = message.request
-    if (!uuid(request?.id) || request.to !== id || typeof request.prompt !== 'string' || !request.prompt.trim() || Buffer.byteLength(request.prompt) > 32768) throw new Error('요청 형식이 올바르지 않습니다.')
-    pending = { id: request.id, to: id, state: 'submitted', baseline: s.usage, baselineKnown: s.usageKnown, result: '' }
-    jobs.set(request.id, pending); s.state = 'running'; s.fullyIdle = false; save()
-    const prompt = `[axMap request ${request.id}]\n요청자: ${request.from || 'axmap'}\n${role ? `역할: ${role}\n` : ''}${request.prompt}`
-    turnTimer = setTimeout(() => shutdown('실행 시간 한도 초과. 완료 여부가 불명확하므로 자동 재시도하지 않습니다.'), timeoutMs)
-    if (provider === 'agy') write({ event: 'user', message: { content: prompt } })
-    else rpc('turn/start', { threadId: s.conversationId, input: [{ type: 'text', text: prompt }], effort: 'low' })
-      .then(r => { if (pending?.id === request.id) pending.turnId = r.turn.id })
-      .catch(e => shutdown(e.message))
-    return { accepted: true, session: id }
-  }
-  const server = net.createServer(socket => {
-    socket.setEncoding('utf8')
-    let input = '', handled = false
-    socket.setTimeout(15000, () => socket.destroy()); socket.on('error', () => {})
-    socket.on('data', chunk => {
-      if (handled) return
-      input += chunk
-      if (Buffer.byteLength(input) > 65536) return socket.destroy()
-      const end = input.indexOf('\n'); if (end < 0) return
-      handled = true
-      try { socket.end(JSON.stringify({ result: handle(JSON.parse(input.slice(0, end))) }) + '\n') }
-      catch (e) { socket.end(JSON.stringify({ error: e.message }) + '\n') }
-    })
-  })
-  fs.mkdirSync(bridgeHome(), { recursive: true, mode: 0o700 })
-  await new Promise((resolve, reject) => { server.once('error', reject); server.listen(pipeFor(id), resolve) })
-  if (process.platform !== 'win32') fs.chmodSync(pipeFor(id), 0o600)
-  save()
-  const cliArgs = args || (provider === 'codex' ? ['app-server', '--stdio']
-    : ['--input-format', 'stream-json', '--output-format', 'stream-json', '--disable-slash-commands', '--effort', 'low', ...(model ? ['--model', model] : [])])
-  child = spawn(executable, [...prefix, ...cliArgs], { cwd, windowsHide: true, stdio: ['pipe', 'pipe', 'pipe'],
-    env: { ...process.env, AXMAP_AGENT: `${provider}-${id.slice(0, 8)}`, AXMAP_SESSION: id } })
-  child.stdin.on('error', e => shutdown(e.message))
-  const exited = new Promise(resolve => {
-    child.once('error', e => { shutdown(e.message); resolve({ code: 1, error: e.message }) })
-    child.once('exit', (code, signal) => { shutdown(`CLI가 종료됐습니다 (${code ?? signal}). ${stderr.slice(-1000)}`); resolve({ code, signal }) })
-  })
-  child.stderr.on('data', chunk => { stderr = (stderr + chunk.toString('utf8')).slice(-8192) })
-  child.stdout.setEncoding('utf8')
-  child.stdout.on('data', chunk => {
-    buffer += chunk
-    if (Buffer.byteLength(buffer) > 4 * 1024 * 1024) return shutdown('CLI 응답 크기 제한 초과')
-    while (buffer.includes('\n') && !closed) {
-      const end = buffer.indexOf('\n'), line = buffer.slice(0, end); buffer = buffer.slice(end + 1)
-      if (!line.trim()) continue
-      try {
-        const m = JSON.parse(line)
-        if (provider === 'agy') {
-          if (m.event === 'init') { s.conversationId = m.conversation_id; s.state = 'idle'; s.fullyIdle = true; save(); emit({ event: 'ready', conversationId: s.conversationId }) }
-          if (m.event === 'result' && pending) {
-            const r = m.result
-            if (r.conversation_id !== s.conversationId) throw new Error('agy 대화 ID가 바뀌었습니다.')
-            finish(r.status === 'SUCCESS' ? 'completed' : 'failed', r.response, r.error, r.usage)
-          }
-          continue
+import fs from 'node:fs';
+import path from 'node:path';
+import net from 'node:net';
+import { spawn } from 'node:child_process';
+import { randomUUID, randomBytes, timingSafeEqual } from 'node:crypto';
+import { bridgeHome, repoKey, writeJSON } from './bridge.mjs';
+import { normalizeUsage, usageDelta } from './session-usage.mjs';
+import { errorMessage } from './session-types.mjs';
+const pipeFor = (id) => process.platform === 'win32' ? `\\\\.\\pipe\\axmap-${id}` : path.join(bridgeHome(), `${id}.sock`);
+const uuid = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value || '');
+export async function startManagedSession({ provider, executable = provider, prefix = [], args = null, model, role = '', cwd = process.cwd(), maxTokens = 100000, timeoutMs = 120000, onEvent = () => { } }) {
+    if (!['codex', 'agy'].includes(provider))
+        throw new Error('지원하는 세션은 codex 또는 agy입니다.');
+    if (!Number.isSafeInteger(maxTokens) || maxTokens < 1 || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1)
+        throw new Error('양의 토큰/시간 한도가 필요합니다.');
+    if (typeof role !== 'string' || role.length > 1000)
+        throw new Error('역할은 1000자 이하여야 합니다.');
+    const id = randomUUID(), token = randomBytes(32).toString('hex');
+    const sessionPath = path.join(bridgeHome(), 'sessions', `${id}.json`);
+    const s = { id, token, provider, transport: 'stdio', role, model: model || null,
+        workspaces: [path.resolve(cwd)], repos: [repoKey(cwd)], state: 'starting', fullyIdle: false,
+        registeredAt: new Date().toISOString(), usage: null, usageKnown: true, maxTokens };
+    const jobs = new Map();
+    const calls = new Map();
+    let child, sequence = 0, pending = null, closed = false, buffer = '', stderr = '', turnTimer;
+    const save = () => { s.registeredAt = new Date().toISOString(); writeJSON(sessionPath, s); };
+    const emit = (event) => onEvent({ session: id, ...event });
+    const write = (message) => {
+        if (closed || !child?.stdin.writable)
+            throw new Error('세션 입력 연결이 종료됐습니다.');
+        child.stdin.write(JSON.stringify(message) + '\n');
+    };
+    const rpc = (method, params) => new Promise((resolve, reject) => {
+        const callId = ++sequence;
+        const timer = setTimeout(() => { calls.delete(callId); reject(new Error(`${method}: 응답 시간 초과`)); }, 15000);
+        calls.set(callId, { resolve: value => resolve(value), reject, timer });
+        try {
+            write({ id: callId, method, params });
+        }
+        catch (e) {
+            clearTimeout(timer);
+            calls.delete(callId);
+            reject(e);
+        }
+    });
+    const finish = (state, result, error, rawUsage) => {
+        if (!pending)
+            return;
+        clearTimeout(turnTimer);
+        const usage = normalizeUsage(provider, rawUsage);
+        Object.assign(pending, { state, result, error, usage: pending.baselineKnown ? usageDelta(usage, pending.baseline) : null,
+            completedAt: new Date().toISOString(), conversationId: s.conversationId });
+        delete pending.baseline;
+        delete pending.baselineKnown;
+        if (usage)
+            s.usage = usage;
+        s.usageKnown = usage !== null;
+        emit({ event: 'result', request: { ...pending } });
+        pending = null;
+        s.state = 'idle';
+        s.fullyIdle = true;
+        delete s.pendingApproval;
+        save();
+    };
+    const shutdown = (reason) => {
+        if (closed)
+            return;
+        finish('unknown', undefined, reason);
+        closed = true;
+        clearTimeout(turnTimer);
+        for (const c of calls.values()) {
+            clearTimeout(c.timer);
+            c.reject(new Error(reason));
+        }
+        calls.clear();
+        s.state = 'closed';
+        s.fullyIdle = false;
+        save();
+        child?.stdin.destroy();
+        child?.kill();
+        server.close();
+    };
+    const handle = (message) => {
+        const offered = Buffer.from(typeof message.token === 'string' ? message.token : '');
+        const expected = Buffer.from(token);
+        if (offered.length !== expected.length || !timingSafeEqual(offered, expected))
+            throw new Error('로컬 세션 인증 실패');
+        if (message.action === 'status')
+            return { id, state: s.state, usage: s.usage, pendingApproval: s.pendingApproval };
+        if (message.action === 'result') {
+            const result = jobs.get(message.id);
+            if (!result)
+                throw new Error('이 세션에 해당 요청이 없습니다.');
+            const { baseline, baselineKnown, ...publicResult } = result;
+            return publicResult;
+        }
+        if (message.action === 'answer') {
+            const approval = s.pendingApproval;
+            if (!approval || String(approval.id) !== String(message.id))
+                throw new Error('현재 대기 중인 승인 요청이 아닙니다.');
+            if (!['accept', 'decline', 'cancel'].includes(message.decision))
+                throw new Error('이번 실행의 accept, decline 또는 cancel만 지원합니다.');
+            write({ id: approval.id, result: { decision: message.decision } });
+            delete s.pendingApproval;
+            s.state = 'running';
+            save();
+            return { answered: true };
         }
-        if (m.id !== undefined && !m.method) {
-          const call = calls.get(m.id)
-          if (call) { clearTimeout(call.timer); calls.delete(m.id); m.error ? call.reject(new Error(m.error.message)) : call.resolve(m.result) }
-          continue
+        if (message.action !== 'submit')
+            throw new Error('지원하지 않는 로컬 세션 요청입니다.');
+        if (closed || s.state !== 'idle' || pending)
+            throw new Error('세션이 대기 중이 아닙니다. 요청을 전달하지 않았습니다.');
+        if (!s.usageKnown)
+            throw new Error('직전 요청의 사용량을 확인하지 못했습니다. 새 연결에서 예산을 확인하세요.');
+        if (s.usage && s.usage.totalTokens >= maxTokens)
+            throw new Error('세션 토큰 한도에 도달했습니다.');
+        const request = message.request;
+        if (!uuid(request?.id) || request.to !== id || typeof request.prompt !== 'string' || !request.prompt.trim() || Buffer.byteLength(request.prompt) > 32768)
+            throw new Error('요청 형식이 올바르지 않습니다.');
+        pending = { id: request.id, to: id, state: 'submitted', baseline: s.usage, baselineKnown: s.usageKnown, result: '' };
+        jobs.set(request.id, pending);
+        s.state = 'running';
+        s.fullyIdle = false;
+        save();
+        const prompt = `[axMap request ${request.id}]\n요청자: ${request.from || 'axmap'}\n${role ? `역할: ${role}\n` : ''}${request.prompt}`;
+        turnTimer = setTimeout(() => shutdown('실행 시간 한도 초과. 완료 여부가 불명확하므로 자동 재시도하지 않습니다.'), timeoutMs);
+        if (provider === 'agy')
+            write({ event: 'user', message: { content: prompt } });
+        else
+            rpc('turn/start', { threadId: s.conversationId, input: [{ type: 'text', text: prompt }], effort: 'low' })
+                .then(r => { if (pending?.id === request.id)
+                pending.turnId = r.turn.id; })
+                .catch(e => shutdown(e.message));
+        return { accepted: true, session: id };
+    };
+    const server = net.createServer(socket => {
+        socket.setEncoding('utf8');
+        let input = '', handled = false;
+        socket.setTimeout(15000, () => socket.destroy());
+        socket.on('error', () => { });
+        socket.on('data', chunk => {
+            if (handled)
+                return;
+            input += chunk;
+            if (Buffer.byteLength(input) > 65536)
+                return socket.destroy();
+            const end = input.indexOf('\n');
+            if (end < 0)
+                return;
+            handled = true;
+            try {
+                socket.end(JSON.stringify({ result: handle(JSON.parse(input.slice(0, end))) }) + '\n');
+            }
+            catch (e) {
+                socket.end(JSON.stringify({ error: errorMessage(e) }) + '\n');
+            }
+        });
+    });
+    fs.mkdirSync(bridgeHome(), { recursive: true, mode: 0o700 });
+    await new Promise((resolve, reject) => { server.once('error', reject); server.listen(pipeFor(id), resolve); });
+    if (process.platform !== 'win32')
+        fs.chmodSync(pipeFor(id), 0o600);
+    save();
+    const cliArgs = args || (provider === 'codex' ? ['app-server', '--stdio']
+        : ['--input-format', 'stream-json', '--output-format', 'stream-json', '--disable-slash-commands', '--effort', 'low', ...(model ? ['--model', model] : [])]);
+    child = spawn(executable, [...prefix, ...cliArgs], { cwd, windowsHide: true, stdio: ['pipe', 'pipe', 'pipe'],
+        env: { ...process.env, AXMAP_AGENT: `${provider}-${id.slice(0, 8)}`, AXMAP_SESSION: id } });
+    child.stdin.on('error', e => shutdown(e.message));
+    const exited = new Promise(resolve => {
+        child.once('error', e => { shutdown(e.message); resolve({ code: 1, error: e.message }); });
+        child.once('exit', (code, signal) => { shutdown(`CLI가 종료됐습니다 (${code ?? signal}). ${stderr.slice(-1000)}`); resolve({ code, signal }); });
+    });
+    child.stderr.on('data', chunk => { stderr = (stderr + chunk.toString('utf8')).slice(-8192); });
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', chunk => {
+        buffer += chunk;
+        if (Buffer.byteLength(buffer) > 4 * 1024 * 1024)
+            return shutdown('CLI 응답 크기 제한 초과');
+        while (buffer.includes('\n') && !closed) {
+            const end = buffer.indexOf('\n'), line = buffer.slice(0, end);
+            buffer = buffer.slice(end + 1);
+            if (!line.trim())
+                continue;
+            try {
+                const m = JSON.parse(line);
+                if (provider === 'agy') {
+                    if (m.event === 'init') {
+                        s.conversationId = m.conversation_id;
+                        s.state = 'idle';
+                        s.fullyIdle = true;
+                        save();
+                        emit({ event: 'ready', conversationId: s.conversationId });
+                    }
+                    if (m.event === 'result' && pending) {
+                        const r = m.result;
+                        if (r.conversation_id !== s.conversationId)
+                            throw new Error('agy 대화 ID가 바뀌었습니다.');
+                        finish(r.status === 'SUCCESS' ? 'completed' : 'failed', r.response, r.error, r.usage);
+                    }
+                    continue;
+                }
+                if (m.id !== undefined && !m.method) {
+                    const call = calls.get(m.id);
+                    if (call) {
+                        clearTimeout(call.timer);
+                        calls.delete(m.id);
+                        m.error ? call.reject(new Error(m.error.message)) : call.resolve(m.result);
+                    }
+                    continue;
+                }
+                if (m.id !== undefined && m.method) {
+                    if (['item/commandExecution/requestApproval', 'item/fileChange/requestApproval'].includes(m.method)) {
+                        s.pendingApproval = { id: m.id, method: m.method, ...m.params };
+                        s.state = 'awaiting_user';
+                        save();
+                        emit({ event: 'awaiting_user', request: s.pendingApproval });
+                    }
+                    else {
+                        write({ id: m.id, error: { code: -32601, message: '이 연결에서 지원하지 않는 사용자 입력입니다. 대화형 CLI에서 처리하세요.' } });
+                    }
+                    continue;
+                }
+                if (m.params?.threadId !== s.conversationId)
+                    continue;
+                if (m.method === 'thread/tokenUsage/updated' && pending)
+                    pending.rawUsage = m.params?.tokenUsage?.total;
+                if (m.method === 'item/completed' && pending && m.params?.item?.type === 'agentMessage')
+                    pending.result = m.params.item.text;
+                if (m.method === 'turn/completed' && pending) {
+                    const r = m.params?.turn;
+                    if (!r)
+                        throw new Error('Codex 실행 결과가 없습니다.');
+                    if (pending.turnId && pending.turnId !== r.id)
+                        throw new Error('Codex 실행 ID가 다릅니다.');
+                    finish(r.status === 'completed' ? 'completed' : 'failed', pending.result, r.error?.message, pending.rawUsage);
+                }
+            }
+            catch (e) {
+                shutdown(`CLI 프로토콜 오류: ${errorMessage(e)}`);
+            }
         }
-        if (m.id !== undefined && m.method) {
-          if (['item/commandExecution/requestApproval', 'item/fileChange/requestApproval'].includes(m.method)) {
-            s.pendingApproval = { id: m.id, method: m.method, ...m.params }; s.state = 'awaiting_user'; save()
-            emit({ event: 'awaiting_user', request: s.pendingApproval })
-          } else { write({ id: m.id, error: { code: -32601, message: '이 연결에서 지원하지 않는 사용자 입력입니다. 대화형 CLI에서 처리하세요.' } }) }
-          continue
+    });
+    try {
+        if (provider === 'codex') {
+            await rpc('initialize', { clientInfo: { name: 'axmap', version: '1' } });
+            write({ method: 'initialized' });
+            const r = await rpc('thread/start', { cwd: path.resolve(cwd), ...(model ? { model } : {}),
+                sandbox: 'read-only', approvalPolicy: 'on-request' });
+            s.conversationId = r.thread.id;
+            s.model = r.model || model || null;
+            s.state = 'idle';
+            s.fullyIdle = true;
+            save();
+            emit({ event: 'ready', conversationId: s.conversationId });
         }
-        if (m.params?.threadId !== s.conversationId) continue
-        if (m.method === 'thread/tokenUsage/updated' && pending) pending.rawUsage = m.params.tokenUsage.total
-        if (m.method === 'item/completed' && pending && m.params.item.type === 'agentMessage') pending.result = m.params.item.text
-        if (m.method === 'turn/completed' && pending) {
-          const r = m.params.turn
-          if (pending.turnId && pending.turnId !== r.id) throw new Error('Codex 실행 ID가 다릅니다.')
-          finish(r.status === 'completed' ? 'completed' : 'failed', pending.result, r.error?.message, pending.rawUsage)
+        else {
+            const deadline = Date.now() + 30000;
+            while (s.state === 'starting' && !closed && Date.now() < deadline)
+                await new Promise(r => setTimeout(r, 25));
+            if (s.state !== 'idle')
+                throw new Error(`agy 시작 실패: ${stderr.slice(-1000) || s.state}`);
         }
-      } catch (e) { shutdown(`CLI 프로토콜 오류: ${e.message}`) }
     }
-  })
-  try {
-    if (provider === 'codex') {
-      await rpc('initialize', { clientInfo: { name: 'axmap', version: '1' } })
-      write({ method: 'initialized' })
-      const r = await rpc('thread/start', { cwd: path.resolve(cwd), ...(model ? { model } : {}),
-        sandbox: 'read-only', approvalPolicy: 'on-request' })
-      s.conversationId = r.thread.id; s.model = r.model || model || null; s.state = 'idle'; s.fullyIdle = true; save()
-      emit({ event: 'ready', conversationId: s.conversationId })
-    } else {
-      const deadline = Date.now() + 30000
-      while (s.state === 'starting' && !closed && Date.now() < deadline) await new Promise(r => setTimeout(r, 25))
-      if (s.state !== 'idle') throw new Error(`agy 시작 실패: ${stderr.slice(-1000) || s.state}`)
+    catch (e) {
+        shutdown(errorMessage(e));
+        throw e;
     }
-  } catch (e) { shutdown(e.message); throw e }
-  return { id, pid: child.pid, conversationId: s.conversationId, exited, close: () => shutdown('사용자가 관리형 연결을 종료했습니다.') }
+    return { id, pid: child.pid, conversationId: s.conversationId, exited, close: () => shutdown('사용자가 관리형 연결을 종료했습니다.') };
 }