agentlas 1.0.28 → 1.0.35

package/engine/core/desktop-core.cjs

@@ -0,0 +1,170 @@
+"use strict";
+/*
+ * core/desktop-core — 데스크탑의 이미-컴파일된 코어를 터미널이 **재사용**한다 (2026-08-06).
+ *
+ * 배경(오너: "더 어려운 Electron 을 만들었는데 왜 더 쉬운 터미널을 못 만드냐 — 그래프 하나
+ * 문제가 아니다"): 정상 패턴은 CLI 를 먼저 만들고 그 위에 GUI 를 얹는 것이다. Agentlas 는
+ * 거꾸로 갔고, 터미널이 데스크탑 엔진을 손으로 재구현한 별도 사본이라 늘 뒤처졌다. 근본
+ * 수리는 기능을 하나씩 베끼는 게 아니라 **데스크탑의 컴파일된 코어를 그대로 불러 쓰는 것**이다.
+ *
+ * 그 코어(electron/workflow/run-graph.js + electron/mcp/* + electron/store/*)는 Electron 의존이
+ * 0이라(실측: `from "electron"`·BrowserWindow·app 전무, store/db 의 유일한 app.getPath 는
+ * AGENTLAS_STORE_PATH 로 이미 오버라이드 가능) 순수 Node 에서 그대로 require 된다.
+ *
+ * 이 로더는 컴파일된 코어의 위치를 찾아, **공유 DB 경로를 코어가 읽기 전에** 세팅하고 로드한다.
+ * 찾지 못하면 null 을 준다 — 호출부가 정직하게 멈춘다(가짜 성공 금지).
+ *
+ * 해석 순서:
+ *   1. env AGENTLAS_DESKTOP_CORE — 코어 루트(…/dist/electron 를 담는 디렉터리, 즉 dist)
+ *   2. 벤더본: <pkg>/engine/vendor/desktop-core/dist  (pack 시 복사되는 자립본)
+ *   3. 개발(동일 저장소 체크아웃): <pkg>/../agentlas_desktop/dist
+ */
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { dbPath, packageRoot, userDataDir } = require("./paths.cjs");
+
+/*
+ * 재사용 코어를 electron 없이 돌리는 셰임(2026-08-06).
+ * 재사용 클로저(200파일)의 electron 사용은 거의 전부 app.getPath(...) — 디렉터리 해석뿐이고,
+ * 나머지(BrowserWindow·dialog·session)는 헤드리스 실행 경로에서 쓰이지 않는다. 그래서 작은
+ * 가짜 electron 을 require 훅으로 돌려주면, electron 도 데스크탑 앱도 설치하지 않은 순수 Node
+ * 에서 데스크탑 코어가 그대로 돈다. GUI 전용 심볼은 실제로 불릴 때만 "CLI 에선 불가"로 던진다
+ * (조용히 no-op 하지 않는다 — 가짜 성공 금지).
+ */
+function makeElectronShim() {
+  const base = userDataDir();
+  const paths = {
+    userData: base,
+    appData: path.dirname(base),
+    home: os.homedir(),
+    temp: os.tmpdir(),
+    downloads: path.join(os.homedir(), "Downloads"),
+    documents: path.join(os.homedir(), "Documents"),
+    logs: path.join(base, "logs"),
+    sessionData: base,
+    exe: process.execPath,
+    module: process.execPath,
+  };
+  const app = {
+    getPath: (name) => paths[name] || base,
+    getName: () => "agentlas",
+    getVersion: () => { try { return require(path.join(packageRoot(), "package.json")).version; } catch { return "0.0.0"; } },
+    getLocale: () => "en-US",
+    isReady: () => true,
+    whenReady: () => Promise.resolve(),
+    isPackaged: true,
+    on() { return app; }, once() { return app; }, off() { return app; },
+    quit() {}, exit() {}, setPath() {},
+  };
+  const notAvailable = (what) => () => { throw new Error(`electron.${what} is not available in the Agentlas CLI (headless).`); };
+  const safeStorage = { isEncryptionAvailable: () => false, encryptString: notAvailable("safeStorage.encryptString"), decryptString: notAvailable("safeStorage.decryptString") };
+  class Notification { constructor() {} show() {} close() {} static isSupported() { return false; } }
+  const gui = new Proxy({}, { get: (_t, prop) => notAvailable(String(prop)) });
+  return { app, safeStorage, Notification, BrowserWindow: gui, dialog: gui, shell: gui, session: gui, ipcMain: gui, nativeTheme: {}, powerMonitor: gui };
+}
+
+function candidateRoots() {
+  const roots = [];
+  if (process.env.AGENTLAS_DESKTOP_CORE) roots.push(process.env.AGENTLAS_DESKTOP_CORE);
+  roots.push(path.join(packageRoot(), "engine", "vendor", "desktop-core", "dist"));
+  // 코덱스 CLI 패턴: 무거운 실행부는 git/npm 패키지에 미리 담지 않고, 처음 필요할 때만 내려받아
+  // 로컬에 캐시한다(userDataDir 아래) — 다음부턴 이 경로가 바로 잡힌다.
+  try { const cached = require("./desktop-core-fetch.cjs").cachedCoreRoot(); if (cached) roots.push(cached); } catch { /* 매니페스트 없음 */ }
+  roots.push(path.resolve(packageRoot(), "..", "agentlas_desktop", "dist"));
+  return roots;
+}
+
+/** 컴파일된 코어의 dist 루트를 찾는다(run-graph.js 존재로 판정). 없으면 null. */
+function findCoreRoot() {
+  for (const root of candidateRoots()) {
+    try {
+      if (fs.existsSync(path.join(root, "electron", "workflow", "run-graph.js"))) return root;
+    } catch { /* 다음 후보 */ }
+  }
+  return null;
+}
+
+/*
+ * 재사용 코어가 네이티브 모듈(better-sqlite3·keytar)을 **터미널 것**으로 쓰게 한다.
+ * 데스크탑 node_modules 의 것은 Electron ABI 로 빌드돼 순수 Node 와 호환되지 않는다
+ * (NODE_MODULE_VERSION 불일치). require 를 한 번 가로채 터미널의 바인딩으로 돌린다 — 같은
+ * 패키지의 ABI 만 맞추는 것이라 안전. ★다운로드 캐시(userDataDir 아래)는 터미널 패키지 트리
+ * 밖이라 node_modules 디렉터리 walk-up으로 자연 해결되지 않는다 — 이 훅이 위치와 무관하게 잡는다.
+ */
+let _nativeHookInstalled = false;
+function installNativeModuleHook() {
+  if (_nativeHookInstalled) return;
+  const Module = require("node:module");
+  const terminalBetterSqlite3 = require("better-sqlite3"); // 터미널 ABI 로 빌드된 것
+  let terminalKeytar = null;
+  try { terminalKeytar = require("keytar"); } catch { /* optionalDependency — 없을 수 있다 */ }
+  const electronShim = makeElectronShim();                 // electron 없이 코어를 돌리는 셰임
+  const orig = Module._load;
+  Module._load = function (request, parent, isMain) {
+    if (request === "better-sqlite3") return terminalBetterSqlite3;
+    if (request === "keytar" && terminalKeytar) return terminalKeytar;
+    if (request === "electron") return electronShim;
+    return orig.apply(this, arguments);
+  };
+  _nativeHookInstalled = true;
+}
+
+let _cache = undefined;
+
+/**
+ * 재사용 코어를 로드한다. 반환: { root, require(rel), runGraph, ... } 또는 null.
+ *  · require(rel): 코어 안의 임의 컴파일 모듈을 상대경로로 로드(예: "store/automations").
+ *  · runGraph: electron/workflow/run-graph.js 의 runGraph(automation, graph, opts).
+ * 공유 DB(AGENTLAS_STORE_PATH)를 코어 로드 전에 반드시 세팅한다 — store/db 가 모듈 로드 시 읽는다.
+ */
+function loadDesktopCore() {
+  if (_cache !== undefined) return _cache;
+  const root = findCoreRoot();
+  if (!root) { _cache = null; return null; }
+  installNativeModuleHook();
+  // 코어의 store 가 이 값을 모듈 로드 시점에 읽는다 — require 이전에 세팅해야 한다.
+  if (!process.env.AGENTLAS_STORE_PATH) process.env.AGENTLAS_STORE_PATH = dbPath();
+  const req = (rel) => require(path.join(root, "electron", rel.replace(/\.js$/, "") + ".js"));
+  let kernel;
+  try {
+    // 데스크탑은 app.whenReady 에서 initStore() 를 부른다 — 터미널도 코어를 쓰기 전에 부른다.
+    // initStore 가 스키마 마이그레이션까지 소유하므로(데스크탑과 같은 정본 스키마) 공유 DB 는
+    // 언제나 코어가 기대하는 모양이 된다. 이것이 "재구현"이 아니라 "재사용"의 핵심.
+    req("store/db").initStore();
+    kernel = req("workflow/run-graph");
+  } catch (e) { _cache = { root, error: e }; return _cache; }
+  _cache = {
+    root,
+    require: req,
+    initStore: req("store/db").initStore,
+    getDb: req("store/db").getDb,
+    runGraph: kernel.runGraph,
+    graphFailureOf: kernel.graphFailureOf,
+    planGraphLoops: kernel.planGraphLoops,
+  };
+  return _cache;
+}
+
+/** 재사용 코어가 이 머신에서 가용한가(정직한 가부). */
+function desktopCoreAvailable() {
+  const c = loadDesktopCore();
+  return !!(c && c.runGraph && !c.error);
+}
+
+/**
+ * 로컬에서 코어를 못 찾으면(개발용 형제 저장소도, 캐시도 없음) 필요한 순간에만 내려받는다
+ * (코덱스 CLI 패턴 — 조용히 안 받는다, onNotice 로 사용자에게 알린다). 매니페스트가 없으면
+ * (그래프 실행 기능이 이 배포에 아직 안 실렸으면) null 을 준다 — 정직한 실패.
+ */
+async function loadDesktopCoreAsync({ onNotice } = {}) {
+  const sync = loadDesktopCore();
+  if (sync && sync.runGraph && !sync.error) return sync;
+  const { fetchDesktopCore } = require("./desktop-core-fetch.cjs");
+  const dist = await fetchDesktopCore({ onNotice });
+  if (!dist) return null;
+  _cache = undefined; // 방금 캐시가 채워졌으니 후보 목록을 다시 계산해 태운다.
+  return loadDesktopCore();
+}
+
+module.exports = { findCoreRoot, loadDesktopCore, loadDesktopCoreAsync, desktopCoreAvailable };

package/engine/graph/ask-model.cjs

@@ -0,0 +1,159 @@
+"use strict";
+/*
+ * 인터뷰 한 턴을 모델에게 묻는 최소 경로.
+ *
+ * 세션·영속·메모리 티켓 없이 **한 번 묻고 최종 텍스트만** 받는다. 인터뷰는 사람이 화면 앞에
+ * 앉아 기다리는 대화라, 채팅 세션의 부수효과(대화 저장·메모리 방출·펜스 처리)가 끼어들면
+ * 사용자가 요청하지 않은 기록이 남는다.
+ *
+ * 실패를 삼키지 않는다. 모델이 안 돌면 그 사실과 다음 행동을 그대로 돌려준다 —
+ * 조용히 빈 문자열을 주면 파서가 "읽지 못했습니다"로 바꿔 원인이 사라진다.
+ */
+const nativeHost = require("../agentlas-native-host.cjs");
+// ★resolveRuntime(resolve.cjs)이 아니라 resolveRuntimeForAgent를 쓴다.
+// resolveRuntime은 `role`을 **아예 읽지 않아서**, 사용자가 모델 역할에 gemini를 지정해 둬도
+// active_runtime(codex)으로 흘렀다(실측: 인터뷰가 사용자가 고르지 않은 런타임에서 돌았고,
+// 그쪽 사용 한도가 소진돼 있었다). 사용자가 정한 역할 사다리를 따르는 쪽이 정본이다.
+const { resolveRuntimeForAgent } = require("../runtimes/overrides.cjs");
+const { listAvailableCliRuntimes } = require("../runtimes/detect.cjs");
+
+/**
+ * native-host가 부르는 이벤트 싱크 — 인터뷰 중에는 화면에 아무것도 흘리지 않는다.
+ *
+ * ★메서드를 손으로 골라 적으면 안 된다. native-host가 부르는 이름이 하나라도 빠지면
+ * 턴 중간에 TypeError로 죽는다(실측: streamStart 누락으로 프로세스가 통째로 죽었다).
+ * 실제 EventSink의 표면을 그대로 덮어써서, 저쪽이 늘어나도 여기가 따라간다.
+ */
+function quietSink() {
+  const { EventSink } = require("../sessions/sink.cjs");
+  const sink = new EventSink(() => {}, () => {});
+  const quiet = Object.create(Object.getPrototypeOf(sink));
+  for (const name of Object.getOwnPropertyNames(Object.getPrototypeOf(sink))) {
+    if (name === "constructor") continue;
+    quiet[name] = () => {};
+  }
+  // native-host가 색/번역 헬퍼도 만진다.
+  quiet.c = new Proxy({}, { get: () => (text) => String(text ?? "") });
+  quiet.t = (_key, fallback) => String(fallback ?? "");
+  quiet.replaceTasks = () => {};
+  return quiet;
+}
+
+/**
+ * 인터뷰 한 턴을 묻는다.
+ *
+ * 사용자가 정한 역할(orchestrator)을 **먼저** 쓴다. 그게 실패하면 조용히 포기하지 않고
+ * 이 컴퓨터에 있는 다른 런타임으로 이어서 물어보되, **어느 것이 답했는지 말한다** —
+ * 조용히 다른 모델로 바꾸면 사용자는 자기가 고른 모델이 돈 줄 안다.
+ * 전부 실패하면 각각의 사유를 그대로 돌려준다(하나로 뭉뚱그리면 원인이 사라진다).
+ *
+ * @returns {Promise<{ok:true,text:string,runtime:string,fellBackFrom?:string}
+ *                  |{ok:false,reason:string,nextAction:string}>}
+ */
+async function askModel(ctx, prompt, opts = {}) {
+  const db = ctx.db();
+  let primary = null;
+  try {
+    primary = resolveRuntimeForAgent({
+      db,
+      prefs: ctx.prefs,
+      role: "orchestrator",
+      ...(opts.runtime ? { explicit: opts.runtime } : {}),
+      ...(opts.model ? { model: opts.model } : {}),
+    });
+  } catch (err) {
+    primary = null;
+    var primaryError = (err && err.message) || String(err);
+  }
+
+  // 시도 순서: 사용자가 정한 것 먼저, 그다음 이 컴퓨터에 있는 나머지.
+  const candidates = [];
+  if (primary && primary.kind && primary.bin) candidates.push(primary);
+  if (!opts.runtime) {
+    // listAvailableCliRuntimes()는 문자열이 아니라 {kind, bin, path} 객체를 돌려준다.
+    // 문자열로 읽으면 후보가 하나도 안 쌓여 폴백이 통째로 죽는다(실측).
+    // ★그리고 **실행 드라이버가 있는 종류만** 후보다 — detect는 grok/kimi/cursor도
+    //   광고하는데 native host에 드라이버가 없어, 후보 슬롯 하나가 "unknown runtime"으로
+    //   낭비됐다(실측 2026-08-06). 판별 기준은 목록 복제가 아니라 resolve의 정본을 쓴다.
+    const { CLI_EXECUTABLE_KINDS } = require("../runtimes/resolve.cjs");
+    for (const found of listAvailableCliRuntimes()) {
+      if (!found || !found.kind || !found.path) continue;
+      if (!CLI_EXECUTABLE_KINDS.has(found.kind)) continue;
+      if (candidates.some((c) => c.kind === found.kind)) continue;
+      candidates.push({ kind: found.kind, bin: found.path });
+    }
+  }
+  if (!candidates.length) {
+    return {
+      ok: false,
+      reason: primaryError
+        ? `실행할 AI 런타임을 찾지 못했습니다: ${primaryError}`
+        : "이 컴퓨터에서 쓸 수 있는 AI 런타임이 없습니다.",
+      nextAction: "`agentlas doctor`로 런타임 상태를 확인한 뒤 다시 시도해 주세요.",
+    };
+  }
+
+  const failures = [];
+  for (const runtime of candidates) {
+    let res;
+    try {
+      res = await nativeHost.runNativeTurn({
+        kind: runtime.kind,
+        bin: runtime.bin,
+        ui: quietSink(),
+        cwd: opts.cwd || process.cwd(),
+        prompt,
+        // 읽기 권한 — 인터뷰는 사람에게 묻고 형식을 만드는 일이라 파일을 바꿀 이유가 없다.
+        permission: "read",
+        session: {},
+        model: runtime.model,
+        effort: runtime.effort,
+        mcpServers: [],
+        mcpAllowlistMode: "exact",
+      });
+    } catch (err) {
+      failures.push(`${runtime.kind}: ${(err && err.message) || err}`);
+      continue;
+    }
+    const text = String((res && res.text) || "");
+    /*
+     * ★런타임이 실패를 **이미 표식으로 말하고 있었다** — 우리가 안 읽었을 뿐이다.
+     *
+     * 실측 2026-08-06: claude-code가 한도 소진 시 `--output-format stream-json`으로
+     * `{"type":"rate_limit_event",...,"status":"rejected"}` → `"error":"rate_limit"` →
+     * 최종 `{"is_error":true,"api_error_status":429}`를 보내고 종료코드 1로 끝난다.
+     * 네이티브 호스트는 그것을 읽어 `res.error`까지 정확히 채워 놓았다. 그런데 여기서
+     * **`text.trim()`을 먼저 보고 ok를 반환**하는 바람에 그 error는 한 번도 읽히지 않았고,
+     * `You've hit your weekly limit`이라는 사람용 문장이 산출물 행세를 했다. 살아 있는
+     * codex로 넘어가지도 않았다.
+     *
+     * 그래서 판별은 문구 추측이 아니라 **표식**으로 한다. 표식이 있으면 그 런타임은 실패다.
+     * (표식조차 없는 런타임을 위한 마지막 그물은 runtime-refusal.cjs 한 곳뿐이다.)
+     */
+    const marked = res && res.error ? String(res.error).replace(/\s+/g, " ").slice(0, 240) : null;
+    const { detectRuntimeRefusal } = require("../runtime-refusal.cjs");
+    const heur = marked ? null : detectRuntimeRefusal(text);
+    const notice = marked || (heur && heur.message);
+    if (notice) {
+      failures.push(`${runtime.kind}: ${notice}`);
+      continue;
+    }
+    if (text.trim()) {
+      const out = { ok: true, text, runtime: runtime.kind };
+      if (candidates[0] !== runtime) out.fellBackFrom = candidates[0].kind;
+      return out;
+    }
+    failures.push(res && res.error
+      ? `${runtime.kind}: ${String(res.error).replace(/\s+/g, " ").slice(0, 200)}`
+      : `${runtime.kind}: 빈 답`);
+  }
+
+  return {
+    ok: false,
+    reason: `AI가 답하지 못했습니다.\n  ${failures.join("\n  ")}`,
+    nextAction: "`agentlas doctor`로 런타임 상태를 확인하거나, 로그인이 필요한 런타임에 다시 로그인해 주세요.",
+  };
+}
+
+
+module.exports = { askModel };