elanous 0.2.0 → 0.2.4

package/src/task-orchestrator/surfaces/idea-approval-pr.ts

@@ -0,0 +1,118 @@
+import { PR_LABELS } from '../../github/pr-labels.js';
+import type { Task } from '../types.js';
+
+export type IdeaApprovalGh = (args: string[]) => Promise<string>;
+
+interface ApprovalInput {
+  task: Task;
+  runId?: string;
+  prUrl: string;
+  ok: boolean;
+}
+
+const missing = '해설에 없음';
+const summaryEnd = '<!-- elanous:approval-summary-end -->';
+const approvalLabel = PR_LABELS.find((label) => label.axis === 'state' && label.name.endsWith(':idea-approval'))!.name;
+const intakeLabel = PR_LABELS.find((label) => label.axis === 'origin' && label.name.endsWith(':from-intake'))!.name;
+
+function approvalDetails({ task, runId, prUrl, ok }: ApprovalInput): { markdown: string; missingFields: string[] } {
+  const lines = task.description.split(/\r?\n/);
+  const field = (name: string) => lines.find((line) => line.trim().startsWith(`${name}:`))?.trim().slice(name.length + 1).trim();
+  const firstSection = lines.findIndex((line) => /^(수용기준|원문):/.test(line.trim()));
+  const why = field('why') ?? lines.slice(0, firstSection < 0 ? lines.length : firstSection)
+    .filter((line) => line.trim()).join('\n').trim();
+  const criteria = field('수용기준');
+  const source = field('원문') ?? (task.generatedBy?.kind === 'external' ? task.generatedBy.url : undefined)
+    ?? task.description.match(/https?:\/\/[^\s)]+/)?.[0];
+  const missingFields: string[] = [];
+  const value = (name: string, text?: string) => {
+    if (text) return text;
+    missingFields.push(name);
+    return missing;
+  };
+  const markdown = [
+    '## 승인 요약',
+    `**한 줄** — ${value('한 줄', task.title)}`,
+    `**원문 (출발점)** — ${value('원문', source)} · 작성자: ${value('작성자')} · 저장 시각: ${value('저장 시각')} · 원문 요지: ${value('원문 요지')}`,
+    `**SCQA** — S ${value('S')} · C ${value('C', why)} · Q ${value('Q')} · A ${value('A', criteria)}`,
+    `**과정** — 저장: ${value('저장')} → 흡수: ${value('흡수', task.generatedBy?.kind === 'external' ? task.generatedBy.ref : undefined)} → 사전 아이디어: ${value('사전 아이디어')} → 중복 확인: ${value('중복 확인')} → 결정: ${value('결정')} → 골: ${value('골', criteria)} → 런: ${value('런', runId)} → 시험 결과: ${value('시험 결과', ok ? undefined : '런 실패')}`,
+    `**머지하면 좋아지는 것** — 바로: ${value('바로', criteria)} · 다음 결정: ${value('다음 결정')}`,
+    `**바뀌는 것 / 위험** — 파일 범위: ${value('파일 범위')} · 운영 동작 변화: ${value('운영 동작 변화')} · 한계: ${value('한계')} · PR: ${prUrl}`,
+  ].join('\n');
+  return { markdown, missingFields };
+}
+
+export function buildApprovalSummary(input: ApprovalInput): string {
+  return approvalDetails(input).markdown;
+}
+
+export async function finalize(input: ApprovalInput & { gh: IdeaApprovalGh }): Promise<{
+  pr: string; labeled: boolean; ready: boolean; summaryChars: number; missingFields: string[];
+}> {
+  const { task, gh } = input;
+  if (task.generatedBy?.kind !== 'external' || task.generatedBy.provider !== 'intake' || !task.generatedBy.ref.trim()) {
+    throw new Error('intake origin and ledger ref required');
+  }
+  const url = new URL(input.prUrl);
+  const match = url.protocol === 'https:' && url.hostname === 'github.com' && !url.search && !url.hash
+    && url.pathname.match(/^\/[^/]+\/[^/]+\/pull\/(\d+)\/?$/);
+  if (!match) throw new Error(`invalid GitHub PR URL: ${input.prUrl}`);
+  const pr = match[1]!;
+  if (!input.ok) return { pr, labeled: false, ready: false, summaryChars: 0, missingFields: [] };
+  // Pass the full PR URL, not its number: the tool cwd may point at another repository.
+  const target = input.prUrl;
+  const raw = await gh(['pr', 'view', target, '--json', 'body,isDraft,labels']);
+  const view: { body?: unknown; isDraft?: boolean; labels?: { name: string }[] } = JSON.parse(raw);
+  if (typeof view.body !== 'string') throw new Error('PR body missing');
+  const { markdown, missingFields } = approvalDetails(input);
+  const marker = `아이디어: ${task.generatedBy.ref}`;
+  const existing = view.body;
+  let original = existing.startsWith('아이디어: ')
+    ? existing.replace(/^아이디어: [^\n]*\n+/, '')
+    : existing;
+  if (original.startsWith('## 승인 요약\n')) {
+    const headings = ['한 줄', '원문 (출발점)', 'SCQA', '과정', '머지하면 좋아지는 것', '바뀌는 것 / 위험'];
+    let cursor = '## 승인 요약\n'.length;
+    for (const heading of headings) {
+      const headingLine = `**${heading}** — `;
+      const at = original.indexOf(headingLine, cursor);
+      if (at < cursor || (at > 0 && original[at - 1] !== '\n')) throw new Error('PR approval summary incomplete');
+      // The next heading must be separated only by summary text, not a new Markdown section.
+      if (/^#{1,6} /m.test(original.slice(cursor, at))) throw new Error('PR approval summary incomplete');
+      cursor = at + headingLine.length;
+    }
+    const markerAt = original.indexOf(`\n\n${summaryEnd}\n\n`, cursor);
+    if (markerAt >= 0) {
+      if (!original.slice(cursor, markerAt).trim()) throw new Error('PR approval summary incomplete');
+      original = original.slice(markerAt + summaryEnd.length + 4);
+    } else {
+      const rest = original.indexOf('\n\n', cursor);
+      if (rest < 0) throw new Error('PR approval summary incomplete');
+      const finalField = original.slice(cursor, rest);
+      if (finalField.includes('\n') || (finalField.trim() && !/· PR: https:\/\/github\.com\/[^\s]+$/.test(finalField))) {
+        throw new Error('PR approval summary incomplete');
+      }
+      const remaining = original.slice(rest + 2);
+      if (!remaining || remaining.includes('\n\n') || remaining.includes(summaryEnd)) {
+        throw new Error('PR approval summary incomplete');
+      }
+      original = remaining;
+    }
+  }
+  const desired = `${marker}\n\n${markdown}\n\n${summaryEnd}\n\n${original}`;
+  if (existing !== desired) await gh(['pr', 'edit', target, '--body', desired]);
+  if (view.isDraft !== false) await gh(['pr', 'ready', target]);
+  const labels = new Set(view.labels?.map((label) => label.name) ?? []);
+  const conflicting = PR_LABELS.filter((label) =>
+    ((label.axis === 'state' && label.name !== approvalLabel)
+      || (label.axis === 'origin' && label.name !== intakeLabel))
+    && labels.has(label.name),
+  );
+  if (!labels.has(approvalLabel) || !labels.has(intakeLabel) || conflicting.length > 0) {
+    await gh([
+      'pr', 'edit', target, '--add-label', approvalLabel, '--add-label', intakeLabel,
+      ...conflicting.flatMap((label) => ['--remove-label', label.name]),
+    ]);
+  }
+  return { pr, labeled: true, ready: true, summaryChars: markdown.length, missingFields };
+}

package/src/task-orchestrator/surfaces/index.ts

@@ -6,7 +6,7 @@
  * Missing callables → the adapter is simply not registered (dispatcher
  * will emit `deferred: [{reason: 'no-adapter'}]` for those kinds).
  */
-import type { SurfaceRegistry } from '../surface-registry.js';
+import type { SurfaceRegistry, SurfaceAdapter } from '../surface-registry.js';
 import type { TaskSurfaceKind } from '../types.js';
 import { TASK_SURFACE_KINDS } from '../types.js';
 
@@ -25,6 +25,7 @@ import { createShowroomAdapter, type ShowroomLaneCallable } from './showroom-sur
 
 export interface SurfaceAdapterDeps {
   llmDirect?: LlmDirectCallable;
+  externalExec?: SurfaceAdapter;
   skill?: SkillCallable;
   chatPrompt?: ChatPromptCallable;
   terminalPane?: TerminalPaneCallable;
@@ -65,8 +66,8 @@ export function registerSurfaceAdapters(
   for (const kind of TASK_SURFACE_KINDS) {
     switch (kind) {
       case 'llm-direct':
-        if (deps.llmDirect) {
-          commit(kind, createLlmDirectAdapter({ callable: deps.llmDirect, now: deps.now }));
+        if (deps.externalExec ?? deps.llmDirect) {
+          commit(kind, deps.externalExec ?? createLlmDirectAdapter({ callable: deps.llmDirect!, now: deps.now }));
           registered.push(kind);
         }
         break;

package/src/task-orchestrator/surfaces/pod-account-broker.ts

@@ -5,24 +5,79 @@
 //    «모른다»라서 뒤로 보내되 빼지 않는다(못 읽었다고 갈 곳을 없애지 않는다 — 회전 규칙과 같다).
 // ⛔ `--pod-account` 를 명시하면 브로커를 쓰지 않는다 — 사람의 의도가 이긴다.
 
-import type { RotationCandidate } from '../../oauth/codex-account-rotation.js';
+import { codexAccountThresholdPercent, type RotationCandidate } from '../../oauth/codex-account-rotation.js';
 
 export const POD_ACCOUNT_EXCLUDE_AT_PERCENT = 95;
 
-export interface PodAccountPlan { usable: string[]; excluded: Array<{ name: string; why: string }> }
+export interface PodAccountPlan { usable: string[]; excluded: Array<{ name: string; why: string }>; /** 크레딧으로 쓰는 계정(구독 잔량 0 · 대표 허가) — 로그에 «크레딧» 으로 보이게. */ creditAccounts?: string[] }
 
-export function planPodAccounts(candidates: readonly RotationCandidate[], excludeAt = POD_ACCOUNT_EXCLUDE_AT_PERCENT): PodAccountPlan {
+export type PodProviderPlan =
+  | { provider: 'openai-codex'; accounts: string[]; excluded: PodAccountPlan['excluded']; grokSubscriptionEligible: boolean; creditAccounts?: string[] }
+  | { provider: 'grok'; excluded: PodAccountPlan['excluded']; grokSubscriptionEligible: boolean }
+  | { provider: null; reasons: string[]; grokSubscriptionEligible: boolean };
+
+/** Pod 의 codex → grok 선택. 자격 종류는 과금 동의와 별도로 판단한다. */
+export function planPodProvider(input: {
+  codexCandidates: readonly RotationCandidate[];
+  grokSubscription: boolean;
+  grokApiKey: boolean;
+  grokApiKeyOptIn: boolean;
+  excludeAt?: number;
+  thresholdPercentByAccount?: Readonly<Record<string, unknown>>;
+  /** 대표 크레딧 허가(`llm.codexCreditsAllowed`) — 구독 잔량 계정이 없으면 찬 계정을 크레딧으로 쓴다. */
+  creditsAllowed?: boolean;
+}): PodProviderPlan {
+  const accounts = planPodAccounts(input.codexCandidates, {
+    excludeAt: input.excludeAt,
+    thresholdPercentByAccount: input.thresholdPercentByAccount,
+    creditsAllowed: input.creditsAllowed,
+  });
+  if (accounts.usable.length) return { provider: 'openai-codex', accounts: accounts.usable, excluded: accounts.excluded, grokSubscriptionEligible: input.grokSubscription, ...(accounts.creditAccounts ? { creditAccounts: accounts.creditAccounts } : {}) };
+  if (input.grokSubscription || (input.grokApiKey && input.grokApiKeyOptIn)) return { provider: 'grok', excluded: accounts.excluded, grokSubscriptionEligible: input.grokSubscription };
+  return {
+    provider: null,
+    grokSubscriptionEligible: false,
+    reasons: [
+      `codex: ${accounts.excluded.map((e) => `${e.name}(${e.why})`).join(' · ') || '계정 0개'}`,
+      `grok: 구독 자격 없음 · ${input.grokApiKey ? 'API 키 opt-in 꺼짐' : 'API 키 없음'}`,
+    ],
+  };
+}
+
+export function planPodAccounts(
+  candidates: readonly RotationCandidate[],
+  options: number | {
+    thresholdPercentByAccount?: Readonly<Record<string, unknown>>;
+    excludeAt?: number;
+    creditsAllowed?: boolean;
+  } = {},
+): PodAccountPlan {
+  const { thresholdPercentByAccount, excludeAt = POD_ACCOUNT_EXCLUDE_AT_PERCENT, creditsAllowed = false } =
+    typeof options === 'number' ? { excludeAt: options } : options;
   const excluded: PodAccountPlan['excluded'] = [];
   const known: RotationCandidate[] = [];
   const unknown: RotationCandidate[] = [];
   for (const c of candidates) {
+    const threshold = typeof options === 'number'
+      ? excludeAt
+      : codexAccountThresholdPercent(c.name, { thresholdPercent: excludeAt, thresholdPercentByAccount });
     if (c.reached === true) { excluded.push({ name: c.name, why: 'quota reached' }); continue; }
-    if (c.usedPercent !== undefined && c.usedPercent >= excludeAt) { excluded.push({ name: c.name, why: `used ${c.usedPercent}% ≥ ${excludeAt}%` }); continue; }
+    if (c.usedPercent !== undefined && c.usedPercent >= threshold) { excluded.push({ name: c.name, why: `used ${c.usedPercent}% ≥ ${threshold}%` }); continue; }
     (c.usedPercent === undefined ? unknown : known).push(c);
   }
   known.sort((a, b) => (a.usedPercent! - b.usedPercent!) || a.name.localeCompare(b.name));
   unknown.sort((a, b) => a.name.localeCompare(b.name));
-  return { usable: [...known, ...unknown].map((c) => c.name), excluded };
+  const usable = [...known, ...unknown].map((c) => c.name);
+  // 대표 크레딧 허가: 구독 잔량이 남은 계정이 «하나도» 없을 때만 찬 계정을 크레딧으로 쓴다(사용률 낮은 순) — 잔량 계정이 있으면 그쪽이 먼저다.
+  if (usable.length === 0 && creditsAllowed) {
+    const credit = candidates
+      .filter((c) => excluded.some((e) => e.name === c.name))
+      // 크레딧 잔액이 많은 계정부터(09-28 · 한 계정 크레딧만 타던 것) — 잔액을 모르면 사용률 낮은 순.
+      .sort((a, b) => ((b.creditBalance ?? -1) - (a.creditBalance ?? -1)) || ((a.usedPercent ?? 100) - (b.usedPercent ?? 100)) || a.name.localeCompare(b.name))
+      .map((c) => c.name);
+    return { usable: credit, excluded: [], creditAccounts: credit };
+  }
+  return { usable, excluded };
 }
 
 /** Job 마다 다음 계정 — 잔량 순으로 돌려 가며. 쓸 계정이 없으면 만들 때 이유를 대고 던진다. */

package/src/task-orchestrator/surfaces/pod-artifact-return.ts

@@ -0,0 +1,136 @@
+import { lstatSync, mkdirSync, writeFileSync } from 'node:fs';
+import { isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { gunzipSync } from 'node:zlib';
+import { debug } from '../../debug/log.js';
+
+const FILE_LIMIT = 5 * 1024 * 1024;
+const TOTAL_LIMIT = 20 * 1024 * 1024;
+
+type Artifact = { path: string; bytes: Buffer };
+type Incomplete = { path: string; reason: string };
+type ParseResult = Artifact[] | { error: Incomplete[]; artifacts: Artifact[] };
+
+function safeRelativePath(path: string): boolean {
+  return Boolean(path) && !path.includes('\0') && !isAbsolute(path) && !path.startsWith('\\') &&
+    !/^[A-Za-z]:/.test(path) && !path.includes('\\') &&
+    path.split('/').every((part) => part !== '' && part !== '.' && part !== '..');
+}
+
+function decodePath(token: string): string {
+  if (!/^[A-Za-z0-9_-]+$/.test(token)) throw new Error('invalid base64url path');
+  const raw = Buffer.from(token, 'base64url');
+  if (raw.toString('base64url') !== token) throw new Error('invalid base64url path');
+  const path = raw.toString('utf8');
+  if (!Buffer.from(path, 'utf8').equals(raw)) throw new Error('invalid UTF-8 path');
+  return path;
+}
+
+/** Reassemble each file independently; a bad file never discards its neighbors. */
+export function parsePodArtifactChunks(logs: string): ParseResult {
+  const groups = new Map<string, { total: number; chunks: Map<number, string>; reason?: string }>();
+  for (const line of logs.split(/\r?\n/)) {
+    if (!line.startsWith('ELANOUS_POD_ARTIFACT ')) continue;
+    const match = /^ELANOUS_POD_ARTIFACT (\S+) (\d+)\/(\d+) ([A-Za-z0-9+/=]+)$/.exec(line);
+    const token = match?.[1] ?? /^ELANOUS_POD_ARTIFACT (\S+)/.exec(line)?.[1];
+    if (!token) continue;
+    const group = groups.get(token) ?? { total: match ? Number(match[3]) : 0, chunks: new Map<number, string>() };
+    groups.set(token, group);
+    if (!match) { group.reason = 'malformed chunk'; continue; }
+    const part = Number(match[2]);
+    const total = Number(match[3]);
+    const chunk = match[4]!;
+    if (!Number.isSafeInteger(part) || !Number.isSafeInteger(total) || part < 1 || total < 1 || part > total ||
+        chunk.length > 8000 || group.total !== total || group.chunks.has(part)) {
+      group.reason = 'invalid or duplicate chunk';
+    } else {
+      group.chunks.set(part, chunk);
+    }
+  }
+  const artifacts: Artifact[] = [];
+  const error: Incomplete[] = [];
+  let bytesSoFar = 0;
+  for (const [token, group] of groups) {
+    let path = token;
+    let reason = group.reason;
+    try {
+      path = decodePath(token);
+      if (!safeRelativePath(path)) throw new Error('unsafe relative path');
+      if (!reason && group.chunks.size !== group.total) reason = 'missing chunk';
+      if (!reason) {
+        let encoded = '';
+        for (let i = 1; i <= group.total; i++) {
+          const chunk = group.chunks.get(i);
+          if (!chunk) { reason = 'missing chunk'; break; }
+          encoded += chunk;
+          if (encoded.length > 8 * 1024 * 1024) { reason = 'file too large'; break; }
+        }
+        if (!reason) {
+          const compressed = Buffer.from(encoded, 'base64');
+          if (compressed.toString('base64') !== encoded) throw new Error('invalid base64');
+          const bytes = gunzipSync(compressed, { maxOutputLength: FILE_LIMIT + 1 });
+          if (bytes.length > FILE_LIMIT) reason = 'file too large';
+          else if (bytesSoFar + bytes.length > TOTAL_LIMIT) reason = 'total too large';
+          else { artifacts.push({ path, bytes }); bytesSoFar += bytes.length; }
+        }
+      }
+    } catch (e) { reason = e instanceof Error ? e.message : String(e); }
+    if (reason) error.push({ path, reason });
+  }
+  return error.length ? { error, artifacts } : artifacts;
+}
+
+/** Reject symlink parents as well as lexical traversal; never replace a host file. */
+export function collectPodArtifacts(logs: string, { dir, job, log = (c, e, d) => debug.log(c, e, d) }: {
+  dir: string;
+  job: string;
+  log?: (category: string, event: string, data: Record<string, unknown>) => void;
+}): void {
+  const parsed = parsePodArtifactChunks(logs);
+  const podLogsPath = 'pod-logs/logs.jsonl';
+  let podLogsReturned = false;
+  let podLogsMissingReason = logs.split(/\r?\n/).find((line) => line.startsWith(`ELANOUS_POD_ARTIFACT_SKIPPED ${podLogsPath} `))
+    ? 'artifact skipped (size limit or encoding failure)'
+    : logs.split(/\r?\n/).find((line) => line.startsWith('ELANOUS_POD_LOGS_UNAVAILABLE '))?.slice('ELANOUS_POD_LOGS_UNAVAILABLE '.length) || 'absent';
+  const truncated = logs.split(/\r?\n/).find((line) => line.startsWith('ELANOUS_POD_LOGS_TRUNCATED '));
+  if (truncated) {
+    const [, originalBytes, keptBytes] = truncated.split(' ');
+    log('self-implement.pod', 'pod-logs-truncated', { job, originalBytes: Number(originalBytes), keptBytes: Number(keptBytes) });
+  }
+  for (const { path, reason } of Array.isArray(parsed) ? [] : parsed.error) {
+    log('self-implement.pod', 'artifact-collect-incomplete', { job, path, reason });
+    if (path === podLogsPath) podLogsMissingReason = reason;
+  }
+  for (const { path, bytes } of Array.isArray(parsed) ? parsed : parsed.artifacts) {
+    try {
+      if (!safeRelativePath(path)) throw new Error('unsafe relative path');
+      if (!/^[a-z0-9-]+$/.test(job)) throw new Error('unsafe job name');
+      const root = resolve(dir);
+      mkdirSync(root, { recursive: true });
+      if (lstatSync(root).isSymbolicLink()) throw new Error('symlink parent');
+      const destination = resolve(root, job, path);
+      if (!destination.startsWith(root + sep) || relative(root, destination).startsWith('..')) throw new Error('unsafe relative path');
+      const parts = relative(root, destination).split(sep);
+      let parent = root;
+      for (const part of parts.slice(0, -1)) {
+        if (lstatSync(parent, { throwIfNoEntry: false })?.isSymbolicLink()) throw new Error('symlink parent');
+        parent = join(parent, part);
+        const existing = lstatSync(parent, { throwIfNoEntry: false });
+        if (existing?.isSymbolicLink()) throw new Error('symlink parent');
+        if (!existing) mkdirSync(parent);
+        if (!lstatSync(parent).isDirectory()) throw new Error('non-directory parent');
+      }
+      writeFileSync(destination, bytes, { flag: 'wx' });
+      log('self-implement.pod', 'artifact-collected', { job, path, bytes: bytes.length });
+      if (path === podLogsPath) {
+        podLogsReturned = true;
+        log('self-implement.pod', 'pod-logs-returned', { job, path: destination, lines: bytes.length ? bytes.toString('utf8').split('\n').length - (bytes.at(-1) === 10 ? 1 : 0) : 0 });
+      }
+    } catch (e) {
+      const reason = (e as NodeJS.ErrnoException).code === 'EEXIST' ? 'exists' : e instanceof Error ? e.message : String(e);
+      if ((e as NodeJS.ErrnoException).code === 'EEXIST') log('self-implement.pod', 'artifact-collect-skipped', { job, path, reason });
+      else log('self-implement.pod', 'artifact-collect-incomplete', { job, path, reason });
+      if (path === podLogsPath) podLogsMissingReason = reason;
+    }
+  }
+  if (!podLogsReturned) log('self-implement.pod', 'pod-logs-missing', { job, reason: podLogsMissingReason });
+}