agentlas 0.9.10 → 1.0.2

package/engine/runtimes/detect.cjs

@@ -0,0 +1,54 @@
+"use strict";
+/*
+ * runtimes/detect — 실행 가능한 런타임 탐지.
+ * 데스크탑 electron/runtime/detect.ts 와 동일한 어휘(RuntimeKind)를 쓴다:
+ *   claude-code | codex | gemini | kimi | grok | cursor | byok | ollama | lmstudio | mlx
+ * 여기서는 "실행 파일이 있는가"만 결정론적으로 본다. 모델 응답 여부는 판정하지 않는다
+ * (없으면 no_runtime 정직 정지 — 폴백 금지는 상위 계층의 계약).
+ */
+const { spawnSync } = require("node:child_process");
+
+const RUNTIME_BIN = {
+  "claude-code": "claude",
+  codex: "codex",
+  gemini: "gemini",
+  kimi: "kimi",
+  grok: "grok",
+  cursor: "cursor-agent",
+};
+
+const CLI_RUNTIMES = Object.keys(RUNTIME_BIN);
+
+function whichSync(bin) {
+  const cmd = process.platform === "win32" ? "where" : "which";
+  try {
+    const res = spawnSync(cmd, [bin], { encoding: "utf8", timeout: 4000 });
+    if (res.status === 0) {
+      const line = String(res.stdout || "").split(/\r?\n/).find((l) => l.trim());
+      return line ? line.trim() : null;
+    }
+  } catch { /* not found */ }
+  return null;
+}
+
+/** PATH에서 찾은 CLI 런타임 목록: [{kind, bin, path}] */
+function listAvailableCliRuntimes() {
+  const found = [];
+  for (const kind of CLI_RUNTIMES) {
+    const bin = RUNTIME_BIN[kind];
+    const p = whichSync(bin);
+    if (p) found.push({ kind, bin, path: p });
+  }
+  return found;
+}
+
+/** 공유 DB의 active_runtime 행(데스크탑이 마지막으로 확정한 런타임). 없으면 null. */
+function activeRuntimeRow(db) {
+  try {
+    return db.prepare("SELECT kind, backend, source, model, long_context FROM active_runtime WHERE id=1").get() || null;
+  } catch {
+    return null;
+  }
+}
+
+module.exports = { RUNTIME_BIN, CLI_RUNTIMES, whichSync, listAvailableCliRuntimes, activeRuntimeRow };

package/engine/runtimes/overrides.cjs

@@ -0,0 +1,139 @@
+"use strict";
+/*
+ * runtimes/overrides — 에이전트별 런타임 오버라이드 (공유 테이블 agent_runtime_overrides).
+ *
+ * 데스크탑 electron/store/agent-runtime-overrides.ts 와 같은 행 모양을 읽는다:
+ *   (scope, target_id, label, kind, backend, source, model, effort, long_context, updated_at)
+ * 스키마 소유권은 데스크탑에 있으므로 여기서는 방어적으로만 읽는다(tableExists/
+ * columnExists) — 구버전 DB에서 열이 없으면 "오버라이드 없음"으로 조용히 전진.
+ *
+ * 해석 사다리(오너 계약): 명시(--runtime) > 에이전트별 오버라이드 > prefs >
+ * active_runtime > detected. resolve.cjs 는 건드리지 않는다 — 이 모듈이
+ * 오버라이드 층만 앞에 얹고 나머지는 resolve.cjs 에 위임한다.
+ */
+const { tableExists, columnExists } = require("../core/db.cjs");
+const { RUNTIME_BIN, whichSync } = require("./detect.cjs");
+const { resolveRuntime, EXECUTABLE_KINDS } = require("./resolve.cjs");
+
+const OVERRIDE_TABLE = "agent_runtime_overrides";
+// 데스크탑 VALID_SCOPES 동형. v2 터미널 호출자는 주로 'agent'지만 firm/division도 읽을 수 있다.
+const VALID_SCOPES = new Set(["agent", "firm", "division"]);
+
+function cleanText(value) {
+  const trimmed = typeof value === "string" ? value.trim() : "";
+  return trimmed ? trimmed : null;
+}
+
+/** 방어적 행 → 오버라이드 정규화 (데스크탑 toOverride 동형). */
+function rowToOverride(row) {
+  if (!row || !row.kind) return null;
+  return {
+    scope: row.scope,
+    targetId: row.target_id,
+    label: cleanText(row.label),
+    selection: {
+      kind: String(row.kind),
+      backend: cleanText(row.backend) || undefined,
+      source: cleanText(row.source) || undefined,
+      model: cleanText(row.model) || undefined,
+      effort: cleanText(row.effort) || undefined,
+      longContext: Boolean(row.long_context),
+    },
+    updatedAt: row.updated_at || null,
+  };
+}
+
+/** 임의 scope 오버라이드 읽기. 테이블/필수 열이 없으면 null (구버전 DB 전진 호환). */
+function readRuntimeOverride(db, scope, targetId) {
+  if (!db || !VALID_SCOPES.has(scope)) return null;
+  const id = cleanText(targetId);
+  if (!id) return null;
+  if (!tableExists(db, OVERRIDE_TABLE)) return null;
+  // 필수 열만 확인한다. label/effort 등 부가 열은 SELECT * 결과에서 없으면 undefined로 흡수.
+  if (!columnExists(db, OVERRIDE_TABLE, "scope") || !columnExists(db, OVERRIDE_TABLE, "target_id") || !columnExists(db, OVERRIDE_TABLE, "kind")) {
+    return null;
+  }
+  try {
+    const row = db.prepare(`SELECT * FROM ${OVERRIDE_TABLE} WHERE scope=? AND target_id=?`).get(scope, id);
+    return rowToOverride(row);
+  } catch {
+    return null;
+  }
+}
+
+/** 에이전트별 오버라이드 (데스크탑 getAgentRuntimeOverride('agent', id) 동형). */
+function readAgentRuntimeOverride(db, agentId) {
+  return readRuntimeOverride(db, "agent", agentId);
+}
+
+/** 데스크탑 findAgentRuntimeOverride 동형 — targets 우선순위(예: agent > division > firm). */
+function findRuntimeOverride(db, targets) {
+  for (const target of Array.isArray(targets) ? targets : []) {
+    if (!target || !target.targetId) continue;
+    const found = readRuntimeOverride(db, target.scope, target.targetId);
+    if (found) return found;
+  }
+  return null;
+}
+
+/**
+ * 오버라이드를 얹은 런타임 해석.
+ * @param {object} p { db, prefs, explicit, agentId, targets?, deps? }
+ *   targets: [{scope,targetId}] — 주면 agentId 대신 이 우선순위로 오버라이드를 찾는다
+ *            (firm 경로: agent > division > firm).
+ *   deps: 테스트 주입 { which, resolve } — 상용 호출자는 사용하지 않는다.
+ * @returns resolveRuntime 반환형 + source:"agent-override" 또는
+ *          { ..., unavailableOverride } (오버라이드가 있으나 이 머신/v2에서 실행 불가 —
+ *          조용히 무시하지 않고 사유를 실어 보내며, 호출자가 note를 출력해야 한다)
+ */
+function resolveRuntimeForAgent({ db, prefs, explicit, agentId, targets, deps } = {}) {
+  const resolveImpl = (deps && deps.resolve) || resolveRuntime;
+  // 명시(--runtime)가 항상 이긴다 — 오버라이드는 "사용자가 고르지 않았을 때"의 기본값이다.
+  if (explicit) return resolveImpl({ db, prefs, explicit });
+
+  const override = targets && targets.length
+    ? findRuntimeOverride(db, targets)
+    : agentId
+      ? readAgentRuntimeOverride(db, agentId)
+      : null;
+  if (override) {
+    const kind = override.selection.kind;
+    // v2 스트리밍 드라이버가 있는 CLI 런타임만 실제 실행 대상이다. byok/ollama/kimi
+    // 오버라이드는 데스크탑에서는 유효하지만 터미널 v2 실행 사다리에는 아직 없다 —
+    // 조용히 다른 런타임으로 둔갑시키지 않고 unavailableOverride로 정직하게 알린다.
+    if (EXECUTABLE_KINDS.has(kind)) {
+      const which = (deps && deps.which) || whichSync;
+      const bin = which(RUNTIME_BIN[kind]);
+      if (bin) {
+        return {
+          kind,
+          bin,
+          model: override.selection.model,
+          effort: override.selection.effort,
+          source: "agent-override",
+          override,
+        };
+      }
+    }
+    const resolved = resolveImpl({ db, prefs, explicit: null });
+    return { ...resolved, unavailableOverride: override };
+  }
+  return resolveImpl({ db, prefs, explicit: null });
+}
+
+/** 오버라이드 실행 불가 시 사용자에게 출력할 한 줄 (데스크탑 문구 동형). */
+function unavailableOverrideNote(runtime, lang) {
+  if (!runtime || !runtime.unavailableOverride) return "";
+  const kind = runtime.unavailableOverride.selection.kind;
+  return lang === "ko"
+    ? `지정 런타임(${kind})을 이 환경에서 실행할 수 없어 기본 런타임(${runtime.kind})으로 실행합니다.`
+    : `Assigned runtime (${kind}) is unavailable here — using the default runtime (${runtime.kind}).`;
+}
+
+module.exports = {
+  readAgentRuntimeOverride,
+  readRuntimeOverride,
+  findRuntimeOverride,
+  resolveRuntimeForAgent,
+  unavailableOverrideNote,
+};

package/engine/runtimes/resolve.cjs

@@ -0,0 +1,64 @@
+"use strict";
+/*
+ * runtimes/resolve — 이번 실행에 쓸 런타임 확정.
+ * 사다리: 명시(--runtime) > prefs.runtime(실행 파일 존재 시) > 공유 DB active_runtime >
+ *         PATH에서 처음 발견된 CLI.
+ * 아무것도 없으면 no_runtime "정직 정지" — 키워드/저품질 폴백 금지(오너 결정).
+ */
+const { RUNTIME_BIN, whichSync, listAvailableCliRuntimes, activeRuntimeRow } = require("./detect.cjs");
+
+// native-host가 스트리밍 드라이버를 갖춘 런타임만 실행 대상으로 삼는다.
+// kimi/grok/cursor 드라이버가 포팅되면 여기에 추가한다 (조용한 오폭 방지).
+const EXECUTABLE_KINDS = new Set(["claude-code", "codex", "gemini"]);
+
+class NoRuntimeError extends Error {
+  constructor(message) {
+    super(message);
+    this.code = "no_runtime";
+  }
+}
+
+/**
+ * @returns {{kind, bin, model?, source}} source ∈ explicit|prefs|active|detected
+ * @throws NoRuntimeError
+ */
+function resolveRuntime({ db, prefs, explicit }) {
+  if (explicit) {
+    const bin = RUNTIME_BIN[explicit];
+    if (!bin) throw new NoRuntimeError(`unknown runtime: ${explicit}`);
+    if (!EXECUTABLE_KINDS.has(explicit)) {
+      throw new NoRuntimeError(`runtime '${explicit}' has no v2 streaming driver yet (available: ${[...EXECUTABLE_KINDS].join(", ")})`);
+    }
+    const p = whichSync(bin);
+    if (!p) throw new NoRuntimeError(`runtime '${explicit}' requested but '${bin}' is not on PATH`);
+    return { kind: explicit, bin: p, source: "explicit" };
+  }
+  const pref = prefs && prefs.runtime;
+  if (pref && EXECUTABLE_KINDS.has(pref)) {
+    const p = whichSync(RUNTIME_BIN[pref]);
+    if (p) return { kind: pref, bin: p, source: "prefs" };
+  }
+  if (db) {
+    const active = activeRuntimeRow(db);
+    if (active && EXECUTABLE_KINDS.has(active.kind)) {
+      const p = whichSync(RUNTIME_BIN[active.kind]);
+      if (p) return { kind: active.kind, bin: p, model: active.model || undefined, source: "active" };
+    }
+  }
+  const found = listAvailableCliRuntimes().filter((r) => EXECUTABLE_KINDS.has(r.kind));
+  if (found.length) return { kind: found[0].kind, bin: found[0].path, source: "detected" };
+  // 신규 사용자의 최빈 막다른 길: "설치하라"만 있고 방법이 없으면 여기서 이탈한다.
+  // 실제 설치 명령을 그대로 준다(데스크탑 온보딩의 "Claude Code 무료로 설치하기"와 동형).
+  throw new NoRuntimeError([
+    "no_runtime: no agent CLI is connected — Agentlas runs your agents on a CLI you already subscribe to.",
+    "",
+    "Install one, then rerun:",
+    "  npm i -g @anthropic-ai/claude-code    # Claude Code",
+    "  npm i -g @openai/codex                # Codex CLI",
+    "  npm i -g @google/gemini-cli           # Gemini CLI",
+    "",
+    "Already installed? Make sure its binary is on PATH (agentlas doctor shows what was detected).",
+  ].join("\n"));
+}
+
+module.exports = { resolveRuntime, NoRuntimeError, EXECUTABLE_KINDS };

package/engine/sessions/apply-fences.cjs

@@ -0,0 +1,188 @@
+"use strict";
+/*
+ * sessions/apply-fences — 파싱된 펜스 프로토콜을 실제 부작용으로 적용한다.
+ * (파싱은 fences.cjs, 적용은 여기 — Desktop client.ts 의 실행 절반에 해당.)
+ *
+ * 정책 (비협상 불변식과 동일 선상):
+ *  - memoryEvents: curate.cjs 의 결정적 게이트가 결정한다(큐레이터는 제안만).
+ *    read 권한 턴은 어떤 durable 쓰기도 없다 — 영수증 이벤트만 남는다.
+ *  - delegates: 오케스트레이터 동시 상한을 존중한다. 상한 초과는 조용한 큐잉이
+ *    아니라 정직한 'delegate-refused' 이벤트다.
+ *  - automations: 스케줄 검증 실패는 파서에서 이미 거부됐고, 여기서는 next_run_at
+ *    계산 불가/권한 부족/division 재귀를 정직하게 거부한다. Desktop 도 division
+ *    챗의 자동화 등록을 막는다(자동화가 자동화를 낳는 재귀 방지, client.ts:3493).
+ *  - asks: 세션 이벤트로만 표면화한다. UI 는 REPL 렌더러 소관.
+ */
+
+const memoryCurate = require("../memory-cli/curate.cjs");
+const automationStore = require("../automation/store.cjs");
+const schedule = require("../automation/schedule.cjs");
+
+/**
+ * @param {import('./session.cjs').Session} session 방금 턴을 끝낸 세션
+ * @param {object} parsed parseReplyFences 결과
+ * @param {{orch?: object}} opts orch 미지정 시 session.orchestrator 사용
+ * @returns 적용 영수증 { asks, memory, automations, delegates, refused }
+ */
+function applyReplyFences(session, parsed, opts = {}) {
+  const orch = opts.orch || session.orchestrator || null;
+  const record = (ev) => session._record({ at: Date.now(), ...ev });
+  const receipts = { asks: 0, memory: null, automations: [], delegates: [], refused: [] };
+  const canWrite = session.permission !== "read";
+
+  // 파서가 표면화한 오류(잘못된 스케줄 등) — 조용히 삼키지 않는다.
+  for (const err of parsed.errors || []) {
+    record({ type: "fence-error", text: err });
+  }
+
+  /* ── asks → 세션 이벤트 (REPL 렌더러가 표면화) ───────────────────────── */
+  for (const ask of parsed.asks || []) {
+    record({ type: "ask", payload: ask });
+    receipts.asks += 1;
+  }
+
+  /* ── memoryEvents → curate 게이트 (제안 ≠ 승인) ─────────────────────── */
+  if (Array.isArray(parsed.memoryEvents) && parsed.memoryEvents.length) {
+    // 프로젝트 경계: 명시 초기화된(.agentlas 존재) 폴더만 project 스코프 대상 —
+    // 임의 cwd 에 .agentlas 스캐폴딩을 만들지 않는다(session.cjs 프롬프트 증강과 동일 기준).
+    let projectPath = null;
+    try {
+      const fs = require("node:fs");
+      const path = require("node:path");
+      projectPath = fs.existsSync(path.join(session.cwd, ".agentlas")) ? session.cwd : null;
+    } catch { projectPath = null; }
+    const ctx = {
+      permission: session.permission,
+      projectPath,
+      agentId: session.agent.id,
+      curatedMemories: [],
+    };
+    // 게이트 로직을 복제하지 않기 위해 이벤트를 정확한 wire 블록으로 재구성해
+    // curateCliReply 에 그대로 통과시킨다(시크릿/스코프/중복/권한 게이트 전부 재사용).
+    const heading = memoryCurate.loadArch().eventsHeading;
+    const block = `${heading}\n\`\`\`json\n${JSON.stringify(parsed.memoryEvents)}\n\`\`\``;
+    try {
+      memoryCurate.curateCliReply(session.db, block, ctx);
+    } catch { /* 게이트 실패가 턴 자체를 죽이면 안 된다 */ }
+    receipts.memory = {
+      candidates: parsed.memoryEvents.length,
+      written: ctx.curatedMemories.length,
+      permission: session.permission,
+    };
+    // read 권한 턴 = durable 쓰기 0 — 영수증 이벤트만 남는다.
+    record({ type: "memory-curated", ...receipts.memory });
+  }
+
+  /* ── automations → automation/store.cjs addAutomation ────────────────── */
+  for (const a of parsed.automations || []) {
+    if (!canWrite) {
+      // Desktop automationPermissionRequired(client.ts:3500) 과 동일한 정직 거부.
+      const refusal = { type: "automation-refused", name: a.name, reason: "write permission required" };
+      record(refusal);
+      receipts.refused.push(refusal);
+      continue;
+    }
+    if (session.parent || session.chatKind === "division") {
+      // division 서브세션(자동화 marker 세션 포함)의 자동화 등록 금지 — 자동화가
+      // 자동화를 만드는 재귀 방지. 데스크탑 client.ts:3493(chat.kind !== 'division')과 동형:
+      // parent 없는 자동화 실행 세션도 division 챗이므로 반드시 이 가드에 걸려야 한다.
+      const refusal = { type: "automation-refused", name: a.name, reason: "division session may not register automations" };
+      record(refusal);
+      receipts.refused.push(refusal);
+      continue;
+    }
+    // 파서가 이미 스케줄을 검증했지만, next_run_at 이 실제로 계산되는지 최종 확인.
+    // 시계 없는 행(next_run_at NULL)은 앱 스케줄러가 영영 안 깨운다 — 등록 거부가 정직.
+    const next = schedule.nextAutomationRun({ schedule: a.schedule, timezone: a.tz || null });
+    if (!next) {
+      const refusal = { type: "automation-refused", name: a.name, reason: `schedule "${a.schedule}" has no next run` };
+      record(refusal);
+      receipts.refused.push(refusal);
+      continue;
+    }
+    try {
+      const id = automationStore.addAutomation(session.db, {
+        name: a.name,
+        targetType: "agent",
+        targetId: session.agent.id, // 실행 주체 = 이 세션의 에이전트
+        cron: a.schedule, // 레거시 미러 토큰(schedule 열) — daemon 이 legacyScheduleSpec 으로 해석
+        prompt: a.prompt,
+        tz: a.tz || null,
+      }, next);
+      const receipt = {
+        type: "automation-registered",
+        id,
+        name: a.name,
+        schedule: a.schedule,
+        nextRunAt: next.toISOString(),
+        // steps[] 는 wire 로 받았지만 터미널은 그래프 합성이 없다 — 위장하지 않고 표기.
+        ...(a.steps ? { stepsIgnored: a.steps.length } : {}),
+      };
+      record(receipt);
+      receipts.automations.push(receipt);
+    } catch (e) {
+      const refusal = { type: "automation-refused", name: a.name, reason: (e && e.message) || String(e) };
+      record(refusal);
+      receipts.refused.push(refusal);
+    }
+  }
+
+  /* ── delegates → 오케스트레이터로 division 서브세션 스폰 ─────────────── */
+  // 상한은 lazy require — session.cjs ↔ orchestrator.cjs 로드 사이클 방지.
+  const { maxParallel } = require("./orchestrator.cjs");
+  for (const d of parsed.delegates || []) {
+    if (!orch || !session.key) {
+      const refusal = { type: "delegate-refused", target: d.target, reason: "no orchestrator attached to this session" };
+      record(refusal);
+      receipts.refused.push(refusal);
+      continue;
+    }
+    const brief = (d.brief || "").trim();
+    if (!brief) {
+      const refusal = { type: "delegate-refused", target: d.target, reason: "empty delegate brief" };
+      record(refusal);
+      receipts.refused.push(refusal);
+      continue;
+    }
+    if (orch.runningCount() >= maxParallel()) {
+      // 상한 초과 = 대기가 아니라 정직한 거부(오케스트레이터 정책과 동일).
+      const refusal = {
+        type: "delegate-refused",
+        target: d.target,
+        reason: `parallel limit ${maxParallel()} reached (running: ${orch.runningCount()})`,
+      };
+      record(refusal);
+      receipts.refused.push(refusal);
+      continue;
+    }
+    // 부모의 런타임/권한/작업폴더를 물려받는 division 자식. spawnImpl/timeoutConfig
+    // 전달은 계약 테스트(오프라인 fake spawn)를 위해 필요하고 프로덕션에선 null 이다.
+    const child = orch.spawn({
+      agent: session.agent,
+      runtime: session.runtime,
+      permission: session.permission,
+      cwd: session.cwd,
+      parentKey: session.key,
+      activate: false,
+      title: `delegate: ${d.target}`,
+      spawnImpl: session._spawnImpl,
+      timeoutConfig: session._timeoutConfig,
+    });
+    try {
+      const promise = orch.sendTo(child.key, brief);
+      const receipt = { type: "delegate-spawned", key: child.key, target: d.target, allocation: d.allocation || null };
+      record(receipt);
+      receipts.delegates.push({ key: child.key, target: d.target, promise });
+    } catch (e) {
+      // sendTo 의 상한 판정이 최종 권위다(스폰 사이 레이스) — 스폰만 된 유령 세션은 제거.
+      orch.remove(child.key);
+      const refusal = { type: "delegate-refused", target: d.target, reason: (e && e.message) || String(e) };
+      record(refusal);
+      receipts.refused.push(refusal);
+    }
+  }
+
+  return receipts;
+}
+
+module.exports = { applyReplyFences };