elanous 0.2.6 → 0.2.8

package/src/error-report/report.ts

@@ -0,0 +1,200 @@
+// ER1 — 액티브 덤퍼 «보내는 쪽». 사용자 기기에서 오류가 나면 운영이 알게 한다(대표 10-01 22:0x).
+// 계약 v1 = TC 10-01 22:16(채널 #20798 · ER2): POST https://hooks.elanous.ai/v1/reports · ≤64KiB · consent:true 필수 ·
+// installId = 무작위 UUID · email/telegramUser 는 «신원도 함께» 동의 때만 · nexus.instance 는 해시 12자 · dedupe 는 수신기가 만든다.
+// 규칙: 비밀·홈 경로를 지운 뒤에만 보낸다 · 실패하면 한 부만 남겨 다음 시작 때 한 번(하루 최대 한 번) · 절대 던지지 않는다.
+import { createHash, randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { arch, homedir, platform } from 'node:os';
+import { join } from 'node:path';
+import { debug } from '../debug/log.js';
+import { getElanousConfigDir } from '../elanous-config-dir.js';
+import { codeRevision, packageVersion } from '../version/code-revision.js';
+import { getUserConfig } from '../user-config.js';
+
+export const ERROR_REPORT_URL = 'https://hooks.elanous.ai/v1/reports';
+const MAX_BYTES = 64 * 1024;
+const MAX_MESSAGE = 2_000;
+const MAX_STACK = 8_000;
+const SEND_TIMEOUT_MS = 5_000;
+const RETRY_GAP_MS = 24 * 60 * 60_000;
+const SAME_ERROR_GAP_MS = 60 * 60_000;
+
+export type ReportSurface = 'tui' | 'pwa' | 'cli' | 'daemon';
+
+export interface ErrorReportInput { code: string; message: string; stack?: string; surface: ReportSurface }
+
+export interface ErrorReport {
+  kind: 'error-report'; v: 1; code: string; message: string; stack?: string;
+  app: { version: string; sha: string; surface: ReportSurface; os: string; arch: string };
+  nexus: { alive: boolean; version?: string; instance?: string };
+  who: { installId: string; email?: string; telegramUser?: string };
+  at: string; consent: true;
+}
+
+export interface ErrorReportSettings { enabled: boolean; identity: boolean; email?: string; telegramUser?: string }
+
+export interface ErrorReportDeps {
+  configDir?: () => string;
+  settings?: () => ErrorReportSettings;
+  nexusMeta?: () => Promise<ErrorReport['nexus']>;
+  fetchImpl?: typeof fetch;
+  now?: () => number;
+  /** Tests and the isolated test universe never reach the network. */
+  enabledByEnvironment?: () => boolean;
+}
+
+/** Secrets and the home directory out, before anything leaves the machine. */
+export function scrubText(text: string, home = homedir()): string {
+  let out = text;
+  if (home && home.length > 1) out = out.split(home).join('~');
+  return out
+    .replace(/\/(Users|home)\/[^/\s'"`]+/g, '/$1/~')
+    .replace(/\b(?:elt|els|ghp|gho|ghs|github_pat|xox[abpr]|sk(?:-proj|-ant)?)[-_][A-Za-z0-9_\-]{8,}/g, '[redacted]')
+    .replace(/\b(Bearer|token|apiKey|api_key|password|secret)\b(\s*[:=]\s*|\s+)["']?[^\s"',;]{6,}/gi, '$1$2[redacted]')
+    .replace(/\b\d{6,}:[A-Za-z0-9_-]{30,}\b/g, '[redacted]') // telegram bot token shape
+    .replace(/[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g, '[email]');
+}
+
+/** Frames keep only `file:line:col` — never the directory. */
+export function stripStackPaths(stack: string): string {
+  return stack.split('\n').map((line) => line.replace(/\(?((?:file:\/\/)?\/?[^\s()]*[/\\])([^/\\\s()]+:\d+(?::\d+)?)\)?/g, (_m, _dir: string, tail: string) => `(${tail})`)).join('\n');
+}
+
+/** One random id per install (never derived from the machine or account). */
+export function installId(configDir: string): string {
+  const file = join(configDir, 'install-id');
+  try {
+    const existing = readFileSync(file, 'utf8').trim();
+    if (/^[0-9a-f-]{36}$/.test(existing)) return existing;
+  } catch { /* first time */ }
+  const id = randomUUID();
+  try { mkdirSync(configDir, { recursive: true }); writeFileSync(file, `${id}\n`, { mode: 0o600 }); } catch { /* id still usable this run */ }
+  return id;
+}
+
+export function hash12(value: string): string {
+  return createHash('sha256').update(value).digest('hex').slice(0, 12);
+}
+
+function cut(text: string, max: number): string { return text.length > max ? `${text.slice(0, max - 1)}…` : text; }
+
+export function buildErrorReport(input: ErrorReportInput, ctx: { installId: string; settings: ErrorReportSettings; nexus: ErrorReport['nexus']; at: string }): ErrorReport {
+  const code = input.code.toLowerCase().replace(/[^a-z0-9-]/g, '-').slice(0, 64) || 'unknown';
+  const report: ErrorReport = {
+    kind: 'error-report', v: 1, code,
+    message: cut(scrubText(input.message), MAX_MESSAGE),
+    ...(input.stack ? { stack: cut(scrubText(stripStackPaths(input.stack)), MAX_STACK) } : {}),
+    app: { version: packageVersion(), sha: codeRevision() ?? 'unknown', surface: input.surface, os: platform(), arch: arch() },
+    nexus: ctx.nexus,
+    who: {
+      installId: ctx.installId,
+      ...(ctx.settings.identity && ctx.settings.email ? { email: ctx.settings.email } : {}),
+      ...(ctx.settings.identity && ctx.settings.telegramUser ? { telegramUser: ctx.settings.telegramUser } : {}),
+    },
+    at: ctx.at,
+    consent: true,
+  };
+  // Hard cap: drop the stack first, then shorten the message.
+  if (Buffer.byteLength(JSON.stringify(report)) > MAX_BYTES) delete report.stack;
+  if (Buffer.byteLength(JSON.stringify(report)) > MAX_BYTES) report.message = cut(report.message, 500);
+  return report;
+}
+
+function defaultSettings(): ErrorReportSettings {
+  try {
+    const er = getUserConfig().errorReports;
+    return { enabled: er?.enabled !== false, identity: er?.identity === true, ...(er?.email ? { email: er.email } : {}), ...(er?.telegramUser ? { telegramUser: er.telegramUser } : {}) };
+  } catch { return { enabled: false, identity: false }; }
+}
+
+async function defaultNexusMeta(): Promise<ErrorReport['nexus']> {
+  try {
+    const { resolveDaemonEndpoint } = await import('../nexus/daemon-endpoint.js');
+    const base = resolveDaemonEndpoint({ purpose: 'watch' })?.baseUrl;
+    const instance = hash12(getElanousConfigDir());
+    if (!base) return { alive: false, instance };
+    const response = await fetch(`${base}/v1/health`, { signal: AbortSignal.timeout(1_000) });
+    const body = await response.json().catch(() => ({})) as { version?: unknown };
+    return { alive: response.ok, ...(typeof body.version === 'string' ? { version: body.version } : {}), instance };
+  } catch { return { alive: false }; }
+}
+
+/** Never from `bun test`, and never from the isolated test universe (its config dir lives under a test root). */
+function defaultEnabledByEnvironment(): boolean {
+  if (process.env.NODE_ENV === 'test' || process.env.BUN_TEST) return false;
+  try { return !/[/\\](?:test|\.elanous-test)[/\\]?/.test(getElanousConfigDir()); } catch { return false; }
+}
+
+const lastSent = new Map<string, number>();
+
+export type ReportOutcome = { sent: true; reportId?: string } | { sent: false; reason: string };
+
+/** Send one report — never throws, never blocks the caller beyond the send timeout. */
+export async function reportError(input: ErrorReportInput, deps: ErrorReportDeps = {}): Promise<ReportOutcome> {
+  try {
+    if (!(deps.enabledByEnvironment ?? defaultEnabledByEnvironment)()) return { sent: false, reason: 'environment' };
+    const settings = (deps.settings ?? defaultSettings)();
+    if (!settings.enabled) return { sent: false, reason: 'disabled' };
+    const now = (deps.now ?? Date.now)();
+    const key = `${input.code}\u0000${input.message.slice(0, 200)}`;
+    const previous = lastSent.get(key);
+    if (previous !== undefined && now - previous < SAME_ERROR_GAP_MS) return { sent: false, reason: 'recently-sent' };
+    lastSent.set(key, now);
+    const configDir = (deps.configDir ?? getElanousConfigDir)();
+    const report = buildErrorReport(input, {
+      installId: installId(configDir), settings, nexus: await (deps.nexusMeta ?? defaultNexusMeta)(), at: new Date(now).toISOString(),
+    });
+    return await post(report, configDir, deps);
+  } catch (error) {
+    debug.log('error-report', 'failed', { reason: error instanceof Error ? error.message.slice(0, 120) : 'unknown' });
+    return { sent: false, reason: 'internal' };
+  }
+}
+
+async function post(report: ErrorReport, configDir: string, deps: ErrorReportDeps): Promise<ReportOutcome> {
+  try {
+    const response = await (deps.fetchImpl ?? fetch)(ERROR_REPORT_URL, {
+      method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(report), signal: AbortSignal.timeout(SEND_TIMEOUT_MS),
+    });
+    if (response.status >= 200 && response.status < 300) {
+      const body = await response.json().catch(() => ({})) as { reportId?: unknown };
+      const reportId = typeof body.reportId === 'string' ? body.reportId : undefined;
+      debug.log('error-report', 'sent', { code: report.code, surface: report.app.surface, ...(reportId ? { reportId } : {}) });
+      return { sent: true, ...(reportId ? { reportId } : {}) };
+    }
+    keepPending(report, configDir, deps);
+    debug.log('error-report', 'not-sent', { code: report.code, status: response.status });
+    return { sent: false, reason: `http-${response.status}` };
+  } catch (error) {
+    keepPending(report, configDir, deps);
+    debug.log('error-report', 'not-sent', { code: report.code, reason: error instanceof Error ? error.name : 'network' });
+    return { sent: false, reason: 'network' };
+  }
+}
+
+function pendingFile(configDir: string): string { return join(configDir, 'error-reports', 'pending.json'); }
+
+/** Keep exactly one unsent report (the newest) for a later retry. */
+function keepPending(report: ErrorReport, configDir: string, deps: ErrorReportDeps): void {
+  try {
+    mkdirSync(join(configDir, 'error-reports'), { recursive: true, mode: 0o700 });
+    writeFileSync(pendingFile(configDir), JSON.stringify({ report, lastTry: (deps.now ?? Date.now)() }), { mode: 0o600 });
+  } catch { /* nothing else to do */ }
+}
+
+/** At start-up: retry the one kept report, at most once a day. */
+export async function retryPendingErrorReport(deps: ErrorReportDeps = {}): Promise<ReportOutcome> {
+  try {
+    if (!(deps.enabledByEnvironment ?? defaultEnabledByEnvironment)()) return { sent: false, reason: 'environment' };
+    if (!(deps.settings ?? defaultSettings)().enabled) return { sent: false, reason: 'disabled' };
+    const configDir = (deps.configDir ?? getElanousConfigDir)();
+    const file = pendingFile(configDir);
+    if (!existsSync(file)) return { sent: false, reason: 'none' };
+    const kept = JSON.parse(readFileSync(file, 'utf8')) as { report: ErrorReport; lastTry: number };
+    if ((deps.now ?? Date.now)() - kept.lastTry < RETRY_GAP_MS) return { sent: false, reason: 'too-soon' };
+    const outcome = await post(kept.report, configDir, deps);
+    if (outcome.sent) rmSync(file, { force: true });
+    return outcome;
+  } catch { return { sent: false, reason: 'internal' }; }
+}
+

package/src/exec-requests/planner.ts

@@ -0,0 +1,146 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parse as parseYaml } from 'yaml';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { defaultGraphsDir } from '../self-implement/graph-templates.js';
+import { handleGraphsGet } from '../nexus/api/graphs-api.js';
+import { debug } from '../debug/log.js';
+
+export interface InstalledGraph {
+  id: string;
+  title: string;
+  description: string;
+  path: string;
+  /** 플러그인 그래프가 받는 입력 키(`examples/*.json` 표본에서) — COO 가 inputs 를 채울 수 있게. */
+  inputKeys?: string[];
+}
+export interface ExecPlanItem {
+  seat: string;
+  title: string;
+  graphId: string;
+  inputs: Record<string, unknown>;
+  reason?: string;
+  /** A5b — indexes of earlier items whose results this item needs (it starts after they finish). */
+  after?: number[];
+}
+
+/** 설치된 플러그인의 실행 그래프 — `<state>/plugins/<market>/<name>/<version>/graphs/{recipes.yaml, <id>.yaml}`
+ *  (`src/plugins/install/plugin-install.ts` 설치 경로). 이름마다 가장 새 버전 하나 · 제목·설명은 그래프 `loop` 가 없으면
+ *  `plugin.json` 의 name·description(COO 가 «무엇을 하는 그래프인지» 알게). 2026-10-01 실측: 이것을 안 봐서
+ *  한 줄이 자리로 나뉘어도 «맞는 설치 그래프 없음»이었다. */
+export function installedPluginGraphs(pluginsRoot = join(elanousStateRoot(), 'plugins')): { graphs: InstalledGraph[]; errors: string[] } {
+  const graphs: InstalledGraph[] = [];
+  const errors: string[] = [];
+  const dirs = (path: string): string[] => {
+    try { return readdirSync(path, { withFileTypes: true }).filter(e => e.isDirectory() && !e.name.startsWith('.')).map(e => e.name); }
+    catch { return []; }
+  };
+  for (const market of dirs(pluginsRoot)) {
+    for (const name of dirs(join(pluginsRoot, market))) {
+      const versions = dirs(join(pluginsRoot, market, name)).sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
+      const version = versions[0];
+      if (!version) continue;
+      const root = join(pluginsRoot, market, name, version);
+      const graphsDir = join(root, 'graphs');
+      if (!existsSync(join(graphsDir, 'recipes.yaml'))) continue;
+      let meta: { name?: string; description?: string } = {};
+      try { meta = JSON.parse(readFileSync(join(root, 'plugin.json'), 'utf8')) as typeof meta; } catch { errors.push(`${market}/${name}@${version}: plugin.json unreadable`); }
+      // 입력 키 — 플러그인이 입력 스키마를 따로 선언하지 않아 `examples/*.json` 첫 표본의 키를 쓴다(값은 가상이라 안 싣는다).
+      // 2026-10-01 실측: 키를 몰라 COO 가 `inputs:{}` 로 맡겼고 geo-check 가 «brand is required» 로 첫 노드에서 떨어졌다.
+      let inputKeys: string[] | undefined;
+      try {
+        const sample = readdirSync(join(root, 'examples')).filter(f => f.endsWith('.json')).sort()[0];
+        if (sample) {
+          const parsed = JSON.parse(readFileSync(join(root, 'examples', sample), 'utf8')) as unknown;
+          if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) inputKeys = Object.keys(parsed);
+        }
+      } catch { /* 표본 없음 · 망가짐 = 키 모름 */ }
+      let files: string[] = [];
+      try { files = readdirSync(graphsDir).filter(f => /\.ya?ml$/.test(f) && f !== 'recipes.yaml'); } catch { errors.push(`${market}/${name}@${version}: graphs unreadable`); }
+      for (const file of files) {
+        const path = join(graphsDir, file);
+        try {
+          const doc = parseYaml(readFileSync(path, 'utf8')) as { graph_id?: string; loop?: { title?: string; description?: string } };
+          const id = doc?.graph_id;
+          if (!id || !/^[a-z0-9-]+$/.test(id)) continue;
+          graphs.push({ id, title: doc.loop?.title ?? meta.name ?? id, description: doc.loop?.description ?? meta.description ?? '', path, ...(inputKeys ? { inputKeys } : {}) });
+        } catch { errors.push(`${market}/${name}@${version}: ${file} malformed`); }
+      }
+    }
+  }
+  return { graphs, errors };
+}
+
+export async function installedGraphs(coreDir = defaultGraphsDir(), mineDir = join(elanousStateRoot(), 'graphs')): Promise<InstalledGraph[]> {
+  const base = await coreAndMineGraphs(coreDir, mineDir);
+  // 플러그인은 mine 과 같은 상태 뿌리 아래(<root>/graphs ↔ <root>/plugins) — 시험의 임시 mine 은 운영 플러그인을 안 본다.
+  const plugins = installedPluginGraphs(join(dirname(mineDir), 'plugins'));
+  const seen = new Set(base.map(g => g.id));
+  const extra = plugins.graphs.filter(g => !seen.has(g.id));
+  debug.log('exec-requests', 'catalog', { coreAndMine: base.length, plugins: extra.length, pluginErrors: plugins.errors.slice(0, 5) });
+  return [...base, ...extra];
+}
+
+async function coreAndMineGraphs(coreDir: string, mineDir: string): Promise<InstalledGraph[]> {
+  const catalog = handleGraphsGet('/v1/graphs', coreDir, { coreDir, mineDir });
+  if (!catalog.ok) throw new Error('installed graph catalog unavailable');
+  const { graphs } = await catalog.json() as { graphs: Array<{ id: string; source: 'core' | 'mine' }> };
+  return graphs.flatMap(({ id, source }) => {
+    const dir = source === 'core' ? coreDir : mineDir;
+    if (!/^[a-z0-9-]+$/.test(id) || !existsSync(join(dir, 'recipes.yaml'))) return [];
+    let names: string[];
+    try { names = readdirSync(dir).filter(name => /\.ya?ml$/.test(name)); }
+    catch { return []; }
+    for (const name of names) {
+      const path = join(dir, name);
+      try {
+        const doc = parseYaml(readFileSync(path, 'utf8')) as { graph_id?: string; loop?: { title?: string; description?: string } };
+        if (doc?.graph_id === id) return [{ id, title: doc.loop?.title ?? id, description: doc.loop?.description ?? '', path }];
+      } catch { /* A malformed file is not an executable graph. */ }
+    }
+    return [];
+  });
+}
+
+export function seatTitles(path = fileURLToPath(new URL('../../scripts/coord-tracks.json', import.meta.url))): string[] {
+  const data = JSON.parse(readFileSync(path, 'utf8')) as { tracks: Array<{ title?: string }> };
+  return data.tracks.flatMap(track => track.title ? [track.title] : []);
+}
+
+export async function judgeExecPlan(text: string, graphs: readonly InstalledGraph[], seats: readonly string[]): Promise<unknown> {
+  const prompt = `COO 역할. 요청을 실행 가능한 자리별 그래프로 나눠 맡겨라. JSON 배열만 출력: [{"seat":"자리","title":"할 일","graphId":"설치된 그래프 ID 또는 빈 문자열","inputs":{},"after":[]}]. 앞 항목의 결과가 있어야 할 수 있는 일(예: 점검·조사 «결과로» 쓰는 한 장 · 보고)은 after 에 그 앞 항목 번호(0부터)를 적는다 — 그 항목은 앞 항목이 끝난 뒤 그 결과를 받아 시작한다. 서로 기다릴 필요가 없으면 after 는 빈 배열. 자리 이름은 주어진 목록에서만, 그래프 ID는 설치된 목록에서만 고른다. 맞는 그래프가 없으면 graphId=""로 표시한다. 그래프에 inputKeys 가 있으면 inputs 를 그 키로만 채우되 한 줄에서 알 수 있는 값만 넣는다(모르는 값은 넣지 않는다). 그 그래프가 꼭 받아야 할 값(예: 브랜드 이름 · 사진 파일)을 한 줄에서 얻을 수 없으면 graphId=""로 두고 title 끝에 « — <무엇> 필요»를 적는다. 없는 그래프나 산출을 지어내지 마라. 바깥 게시·발행·광고·결제는 승인 노드를 거치기 전 실행하면 안 된다.\n자리: ${JSON.stringify(seats)}\n실행 가능한 그래프: ${JSON.stringify(graphs.map(({ id, title, description, inputKeys }) => ({ id, title, description, ...(inputKeys ? { inputKeys } : {}) })))}\n한 줄: ${JSON.stringify(text)}`;
+  const { streamLLM } = await import('../llm.js');
+  const { tierModel } = await import('../llm/model-defaults.js');
+  const raw = await streamLLM([{ role: 'user', content: prompt }], () => {}, { model: tierModel('best') });
+  return JSON.parse(raw.replace(/^```(?:json)?\s*|\s*```$/g, '').trim()) as unknown;
+}
+
+export async function planExecRequest(text: string, deps: {
+  graphs?: () => Promise<InstalledGraph[]>;
+  seats?: () => string[];
+  judge?: typeof judgeExecPlan;
+} = {}): Promise<ExecPlanItem[]> {
+  const graphs = await (deps.graphs ?? installedGraphs)();
+  const seats = (deps.seats ?? seatTitles)();
+  const raw = await (deps.judge ?? judgeExecPlan)(text, graphs, seats);
+  if (!Array.isArray(raw) || raw.length === 0) throw new Error('COO 계획이 비었거나 배열이 아닙니다');
+  const known = new Map(graphs.map(graph => [graph.id, graph]));
+  return raw.map((item: unknown, index: number) => {
+    if (!item || typeof item !== 'object' || Array.isArray(item)) throw new Error('COO 계획 항목 형식 오류');
+    const row = item as Record<string, unknown>;
+    if (typeof row.seat !== 'string' || !seats.includes(row.seat) || typeof row.title !== 'string' || !row.title.trim()
+      || typeof row.graphId !== 'string' || !row.inputs || typeof row.inputs !== 'object' || Array.isArray(row.inputs)) {
+      throw new Error('COO 계획 항목 형식 오류');
+    }
+    const after = Array.isArray(row.after)
+      ? [...new Set(row.after.filter((n): n is number => Number.isInteger(n) && (n as number) >= 0 && (n as number) < index))]
+      : [];
+    return {
+      seat: row.seat, title: row.title.trim(), graphId: row.graphId,
+      inputs: row.inputs as Record<string, unknown>,
+      ...(after.length ? { after } : {}),
+      ...(!known.has(row.graphId) ? { reason: `${row.seat}: 요청에 맞는 설치된 실행 그래프가 없습니다` } : {}),
+    };
+  });
+}