agentlas 0.9.10 → 1.0.2

package/engine/sessions/fences.cjs

@@ -0,0 +1,362 @@
+"use strict";
+/*
+ * sessions/fences — 에이전트 응답 속 숨은 펜스 프로토콜 파서 (Desktop runner 패리티).
+ *
+ * Desktop electron/mcp/client.ts 가 매 응답에서 파싱하는 4개 제어 블록의
+ * WIRE FORMAT 을 그대로 복제한다 (파싱만; 적용은 apply-fences.cjs):
+ *
+ *  1. `## Memory Events` + ```json 펜스  — electron/memory/events.ts
+ *     → engine/memory-cli/curate.cjs parseMemoryEventsCli 를 소비(재구현 금지).
+ *  2. `## Delegate` + ```json 펜스       — electron/mcp/delegate.ts parseDelegations
+ *     허용 형태: [{target,brief,allocation}] 배열 또는 {delegations:[...], synthesis}.
+ *  3. `## Automation` + ```json 펜스     — electron/automation-emitter.ts parseAutomations
+ *     [{name,prompt,agent?,hubAgent?,schedule: 문자열|{preset,time,tz,dow,day}|{cron,tz}, steps?}]
+ *     단, Desktop 은 잘못된 스케줄을 daily-09:00 으로 폴백하지만 터미널은
+ *     "스케줄을 추측하지 않는다" — 검증 실패는 errors 로 정직하게 거부한다.
+ *  4. <<agentlas-ask>>{json}<</agentlas-ask>> — renderer/lib/ask-question.ts extractQuestions
+ *     (여는/닫는 토큰이 다르다: 닫는 쪽은 <</agentlas-ask>>. 닫는 토큰이 없으면
+ *      스트리밍 중일 수 있으므로 본문에 그대로 둔다.)
+ *
+ * 모든 블록은 cleanText(영속/표시용)에서 제거된다 — 사용자는 제어 블록을 보지 않는다.
+ */
+
+const memoryCurate = require("../memory-cli/curate.cjs");
+const workloadRouting = require("../agentlas-workload-routing.cjs");
+const schedule = require("../automation/schedule.cjs");
+
+// Desktop electron/mcp/delegate.ts:13
+const DELEGATE_HEADING = "## Delegate";
+// Desktop electron/automation-emitter.ts:11
+const AUTOMATION_HEADING = "## Automation";
+// Desktop electron/confirm/index.ts:15-16 · renderer/lib/ask-question.ts:21-22
+const ASK_OPEN = "<<agentlas-ask>>";
+const ASK_CLOSE = "<</agentlas-ask>>";
+
+/* ── ## Delegate (delegate.ts parseDelegations 포팅) ─────────────────────── */
+
+function parseDelegateBlock(text) {
+  const idx = text.lastIndexOf(DELEGATE_HEADING);
+  if (idx < 0) return { delegations: [], synthesisAllocation: null, cleanedText: text.trim() };
+
+  const after = text.slice(idx + DELEGATE_HEADING.length);
+  const fence = after.match(/```(?:json)?\s*([\s\S]*?)```/);
+  let delegations = [];
+  let synthesisAllocation = null;
+  if (fence) {
+    try {
+      const data = JSON.parse(fence[1].trim());
+      const rawDelegations = Array.isArray(data)
+        ? data
+        : data && typeof data === "object" && Array.isArray(data.delegations)
+          ? data.delegations
+          : [];
+      if (!Array.isArray(data) && data && typeof data === "object" && data.synthesis) {
+        synthesisAllocation = workloadRouting.normalizeAllocation(data.synthesis, "synthesize");
+      }
+      delegations = rawDelegations
+        .map((d) => {
+          if (!d || typeof d !== "object") return null;
+          const target = typeof d.target === "string" ? d.target.trim() : "";
+          const brief = typeof d.brief === "string" ? d.brief.trim() : "";
+          // Desktop 계약: target 만 필수. allocation 은 정규화 실패 시 null 로 남고
+          // (레거시 텍스트 위임과 동일) 실행 측이 현재 모델 폴백 영수증을 남긴다.
+          return target
+            ? { target, brief, allocation: workloadRouting.normalizeAllocation(d.allocation, "delegate") }
+            : null;
+        })
+        .filter(Boolean);
+    } catch {
+      delegations = [];
+    }
+  }
+
+  let cut = text.length;
+  if (fence && fence.index != null) {
+    cut = idx + DELEGATE_HEADING.length + fence.index + fence[0].length;
+  } else {
+    cut = idx; // 펜스 없으면 dangling heading 도 제거 (Desktop 과 동일)
+  }
+  const cleanedText = (text.slice(0, idx) + text.slice(cut)).trim();
+  return { delegations, synthesisAllocation, cleanedText };
+}
+
+/* ── ## Automation (automation-emitter.ts parseAutomations 포팅, 정직 거부판) ── */
+
+const DOW_TOKEN = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+const PRESETS = new Set(["daily", "weekday", "weekly", "monthly", "hourly"]);
+
+// Desktop presetToLegacyToken(automation-emitter.ts:165) 과 동일한 미러 토큰.
+function presetToLegacyToken(preset, time, o) {
+  switch (preset) {
+    case "hourly":
+      return "hourly";
+    case "daily":
+      return `daily-${time}`;
+    case "weekday":
+      return `weekday-${time}`;
+    case "weekly": {
+      let dow = 1; // Desktop 기본값: 월요일 (스케줄 추측이 아니라 유효 프리셋 내 기본값)
+      if (typeof o.dow === "number") dow = o.dow;
+      else if (typeof o.dow === "string") {
+        const i = DOW_TOKEN.indexOf(o.dow.toLowerCase());
+        if (i >= 0) dow = i;
+      }
+      return `weekly-${DOW_TOKEN[dow] || "mon"}-${time}`;
+    }
+    case "monthly":
+      return `monthly-${o.day && o.day >= 1 ? o.day : 1}-${time}`;
+    default:
+      return `daily-${time}`;
+  }
+}
+
+/*
+ * 방출 스케줄 → 레거시 미러 토큰 + tz. Desktop resolveSchedule 과 wire 형태는
+ * 동일하지만 실패 정책이 다르다: Desktop 은 daily-09:00 폴백, 터미널은 null 반환
+ * (정직 거부 — 사용자가 시키지 않은 시각에 자동화를 돌리는 것이 침묵 폴백보다 나쁘다).
+ * 최종 검증은 engine/automation/schedule.cjs 로 한다.
+ */
+function resolveScheduleHonest(emitted, errors) {
+  // 레거시 문자열 형식 ("daily-09:00", "cron:* * * * *", 5필드 cron …)
+  if (typeof emitted === "string") {
+    const token = emitted.trim();
+    if (!token) {
+      errors.push("Automation schedule string was empty");
+      return null;
+    }
+    const spec = schedule.legacyScheduleSpec(token, null);
+    if (!spec || (spec.kind === "cron" && !schedule.nextCronRun(spec.expr, new Date(), spec.tz))) {
+      errors.push(`Unrecognized legacy schedule rejected: "${token}"`);
+      return null;
+    }
+    return { token, tz: "" };
+  }
+  if (!emitted || typeof emitted !== "object") {
+    errors.push("Automation schedule missing — refusing to guess one");
+    return null;
+  }
+
+  const tz = typeof emitted.tz === "string" && emitted.tz.trim() ? emitted.tz.trim() : "";
+
+  if (typeof emitted.cron === "string" && emitted.cron.trim()) {
+    const cron = emitted.cron.trim();
+    // nextCronRun 이 문법 + IANA tz 를 함께 검증한다 (croner validateCron 의 터미널 대응물).
+    if (!schedule.nextCronRun(cron, new Date(), tz || null)) {
+      errors.push(`Invalid cron expression rejected: "${cron}"`);
+      return null;
+    }
+    return { token: `cron:${cron}`, tz };
+  }
+
+  const preset = typeof emitted.preset === "string" ? emitted.preset.trim().toLowerCase() : "";
+  if (!PRESETS.has(preset)) {
+    errors.push(`Unknown schedule preset rejected: "${preset || "(none)"}"`);
+    return null;
+  }
+  // hourly 는 시각이 필요 없다. 그 외 프리셋은 HH:MM 필수 — 시각을 추측하지 않는다.
+  let time = "09:00";
+  if (preset !== "hourly") {
+    time = typeof emitted.time === "string" && /^\d{1,2}:\d{2}$/.test(emitted.time) ? emitted.time : "";
+    if (!time) {
+      errors.push(`Schedule preset "${preset}" missing valid "time" (HH:MM) — refusing to guess`);
+      return null;
+    }
+  }
+  const token = presetToLegacyToken(preset, time, emitted);
+  const spec = schedule.legacyScheduleSpec(token, tz || null);
+  if (!spec || (spec.kind === "cron" && !schedule.nextCronRun(spec.expr, new Date(), spec.tz))) {
+    // daily-99:99 같은 범위 밖 시각이 여기서 걸린다.
+    errors.push(`Could not compile schedule preset "${preset}" time "${time}"`);
+    return null;
+  }
+  return { token, tz };
+}
+
+function parseAutomationBlock(text) {
+  const idx = text.lastIndexOf(AUTOMATION_HEADING);
+  if (idx < 0) return { automations: [], cleanedText: text.trim(), errors: [] };
+
+  const after = text.slice(idx + AUTOMATION_HEADING.length);
+  const fence = after.match(/```(?:json)?\s*([\s\S]*?)```/);
+  const errors = [];
+  let automations = [];
+
+  if (fence) {
+    try {
+      const data = JSON.parse(fence[1].trim());
+      if (Array.isArray(data)) {
+        automations = data
+          .map((d) => {
+            if (!d || typeof d !== "object") {
+              errors.push("Automation entry was not an object");
+              return null;
+            }
+            const name = typeof d.name === "string" ? d.name.trim() : "";
+            const prompt = typeof d.prompt === "string" ? d.prompt.trim() : "";
+            const agent = typeof d.agent === "string" ? d.agent.trim() : "";
+            const hubAgent = typeof d.hubAgent === "string" ? d.hubAgent.trim() : "";
+            if (!name || !prompt) {
+              errors.push(`Automation "${name || "(unnamed)"}" missing name/prompt`);
+              return null;
+            }
+            const resolved = resolveScheduleHonest(d.schedule, errors);
+            if (!resolved) return null; // 정직 거부 — 스케줄 추측 금지
+            // steps[] 는 wire 패리티로 보존만 한다. Desktop 은 stepsToGraph 로
+            // 그래프를 합성하지만 터미널 데몬은 prompt_template 단일 실행이다 —
+            // 그래프 합성을 위장하지 않는다(비합성은 apply 쪽 영수증에 표기).
+            const steps = Array.isArray(d.steps) && d.steps.length
+              ? d.steps.filter((s) => !!s && typeof s === "object")
+              : undefined;
+            return {
+              name,
+              schedule: resolved.token,
+              prompt,
+              ...(agent ? { agent } : {}),
+              ...(hubAgent ? { hubAgent } : {}),
+              tz: resolved.tz,
+              ...(steps ? { steps } : {}),
+            };
+          })
+          .filter(Boolean);
+      } else {
+        errors.push("Automation block was not a JSON array");
+      }
+    } catch (err) {
+      errors.push(`Automation JSON parse failed: ${(err && err.message) || String(err)}`);
+    }
+  } else {
+    errors.push("Automation heading present but no JSON fence found");
+  }
+
+  let cut = text.length;
+  if (fence && fence.index != null) {
+    cut = idx + AUTOMATION_HEADING.length + fence.index + fence[0].length;
+  } else {
+    cut = idx;
+  }
+  const cleanedText = (text.slice(0, idx) + text.slice(cut)).trim();
+  return { automations, cleanedText, errors };
+}
+
+/* ── <<agentlas-ask>> (renderer/lib/ask-question.ts extractQuestions 포팅) ── */
+
+function tryParseAsk(body) {
+  // body 가 ```json 펜스로 감싸진 경우도 허용 (Desktop confirm/index.ts:77-80 동일)
+  const stripped = body
+    .replace(/^```(?:json)?\s*/i, "")
+    .replace(/```$/i, "")
+    .trim();
+  let o;
+  try {
+    o = JSON.parse(stripped);
+  } catch {
+    return null;
+  }
+  if (!o || typeof o !== "object") return null;
+  const question = typeof o.question === "string" ? o.question.trim() : "";
+  if (!question) return null;
+  const optionsRaw = Array.isArray(o.options) ? o.options : [];
+  const options = [];
+  for (const opt of optionsRaw) {
+    if (!opt || typeof opt !== "object") continue;
+    const label = typeof opt.label === "string" ? opt.label.trim() : "";
+    if (!label) continue;
+    const description = typeof opt.description === "string" ? opt.description.trim() : "";
+    options.push({
+      label: label.slice(0, 200),
+      ...(description ? { description: description.slice(0, 1000) } : {}),
+    });
+    if (options.length >= 8) break; // Desktop confirm/index.ts:99 상한
+  }
+  if (options.length < 2) return null; // Desktop 계약: 선택지 2개 미만은 유효 질문 아님
+  return {
+    question: question.slice(0, 4000),
+    ...(typeof o.header === "string" && o.header.trim() ? { header: o.header.trim().slice(0, 200) } : {}),
+    multiSelect: o.multiSelect === true,
+    options,
+  };
+}
+
+function extractAsks(text) {
+  if (!text.includes(ASK_OPEN)) return { text, asks: [] };
+  const asks = [];
+  let remaining = text;
+  let buf = "";
+  for (;;) {
+    const open = remaining.indexOf(ASK_OPEN);
+    if (open < 0) {
+      buf += remaining;
+      break;
+    }
+    buf += remaining.slice(0, open);
+    const afterOpen = remaining.slice(open + ASK_OPEN.length);
+    const close = afterOpen.indexOf(ASK_CLOSE);
+    if (close < 0) {
+      // 닫는 토큰이 아직 없다 — 스트리밍 중 미완성일 수 있으니 본문에 그대로 둔다.
+      buf += remaining.slice(open);
+      break;
+    }
+    const parsed = tryParseAsk(afterOpen.slice(0, close).trim());
+    if (parsed) asks.push(parsed);
+    // 파싱 실패해도 닫힌 펜스는 본문에서 제거 — malformed JSON raw 를 사용자에게 노출하지 않는다.
+    remaining = afterOpen.slice(close + ASK_CLOSE.length);
+  }
+  return { text: buf, asks };
+}
+
+/* ── 통합 진입점 ─────────────────────────────────────────────────────────── */
+
+/**
+ * @returns {{
+ *   cleanText: string,           // 4개 펜스가 모두 제거된 표시/영속용 텍스트
+ *   memoryEvents: object[],      // parseMemoryEventsCli 원시 이벤트(게이트 전)
+ *   delegates: Array<{target,brief,allocation}>,
+ *   synthesisAllocation: object|null,
+ *   automations: Array<{name,schedule,prompt,agent?,hubAgent?,tz,steps?}>,
+ *   asks: Array<{question,header?,multiSelect,options}>,
+ *   errors: string[]             // 자동화 검증 실패 등 — 조용히 드롭하지 않고 표면화
+ * }}
+ */
+function parseReplyFences(text) {
+  const raw = String(text || "");
+  const errors = [];
+
+  // 1. Memory Events — 큐레이트 모듈의 파서를 소비(포맷 정본은 그쪽).
+  const mem = memoryCurate.parseMemoryEventsCli(raw);
+  let working = mem.cleaned;
+
+  // 2. Delegate
+  const del = parseDelegateBlock(working);
+  working = del.cleanedText;
+
+  // 3. Automation
+  const auto = parseAutomationBlock(working);
+  working = auto.cleanedText;
+  errors.push(...auto.errors);
+
+  // 4. Ask
+  const ask = extractAsks(working);
+  working = ask.text;
+
+  return {
+    cleanText: working.trim(),
+    memoryEvents: mem.events,
+    delegates: del.delegations,
+    synthesisAllocation: del.synthesisAllocation,
+    automations: auto.automations,
+    asks: ask.asks,
+    errors,
+  };
+}
+
+module.exports = {
+  DELEGATE_HEADING,
+  AUTOMATION_HEADING,
+  ASK_OPEN,
+  ASK_CLOSE,
+  parseReplyFences,
+  // 테스트/재사용용 개별 파서
+  parseDelegateBlock,
+  parseAutomationBlock,
+  extractAsks,
+};

package/engine/sessions/orchestrator.cjs

@@ -0,0 +1,170 @@
+"use strict";
+/*
+ * sessions/orchestrator — 오르카 계층: 멀티세션 스폰/전환/스티어/킬/브로드캐스트.
+ *
+ * 세션 번호는 s1, s2, … 로 붙는다(사람이 한 키로 지목할 수 있는 안정 번호).
+ * 활성 세션 하나만 터미널에 스트리밍되고, 나머지는 백그라운드에서 이벤트를
+ * 링버퍼에 쌓는다. 백그라운드 세션의 턴 종료는 'notice' 이벤트로 전면 세션에
+ * 한 줄 알림된다.
+ *
+ * 동시 실행 상한: AGENTLAS_MAX_PARALLEL (기본 4). 상한 초과 스폰은 대기가 아니라
+ * 정직한 거부 — 사용자가 세션을 정리하거나 상한을 올리게 안내한다.
+ */
+const { EventEmitter } = require("node:events");
+const { Session } = require("./session.cjs");
+
+function maxParallel() {
+  const n = Number(process.env.AGENTLAS_MAX_PARALLEL);
+  return Number.isInteger(n) && n > 0 ? Math.min(n, 16) : 4;
+}
+
+class Orchestrator extends EventEmitter {
+  constructor({ db, lang }) {
+    super();
+    this.db = db;
+    this.lang = lang || "en";
+    this.sessions = new Map(); // "s1" -> Session
+    this._seq = 0;
+    this.activeKey = null;
+  }
+
+  _nextKey() {
+    this._seq += 1;
+    return `s${this._seq}`;
+  }
+
+  runningCount() {
+    let n = 0;
+    for (const s of this.sessions.values()) if (s.isBusy()) n += 1;
+    return n;
+  }
+
+  /**
+   * 세션 생성(+선택적 즉시 실행). parentKey를 주면 그 세션의 서브에이전트
+   * (division 챗)로 붙는다.
+   */
+  spawn({ agent, runtime, permission, cwd, title, parentKey, activate = true, spawnImpl, timeoutConfig, chatId }) {
+    const parent = parentKey ? this.sessions.get(parentKey) || null : null;
+    const session = new Session({
+      db: this.db,
+      agent,
+      runtime,
+      permission,
+      cwd,
+      lang: this.lang,
+      parent,
+      title,
+      spawnImpl,
+      timeoutConfig,
+      chatId,
+    });
+    const key = this._nextKey();
+    session.key = key;
+    session.orchestrator = this; // apply-fences 가 ## Delegate 스폰 시 쓰는 오르카 역참조
+    this.sessions.set(key, session);
+    if (parent) parent.children.push(key);
+
+    session.on("event", (ev) => {
+      this.emit("session-event", { key, session, ev });
+      if (ev.type === "turn-end" && this.activeKey !== key) {
+        this.emit("notice", {
+          key,
+          session,
+          text: ev.ok
+            ? `${key} ${session.agent.slug}: done`
+            : `${key} ${session.agent.slug}: ${ev.error || "failed"}`,
+          ok: !!ev.ok,
+        });
+      }
+    });
+
+    if (activate || !this.activeKey) this.activeKey = key;
+    this.emit("sessions-changed");
+    return session;
+  }
+
+  /** 실행 요청 — 동시 상한을 넘으면 스폰하지 않고 정직하게 throw. */
+  sendTo(key, prompt) {
+    const session = this.sessions.get(key);
+    if (!session) throw new Error(`no such session: ${key}`);
+    if (!session.isBusy() && this.runningCount() >= maxParallel()) {
+      throw new Error(`parallel limit ${maxParallel()} reached (running: ${this.runningCount()}). /kill or raise AGENTLAS_MAX_PARALLEL`);
+    }
+    return session.send(prompt);
+  }
+
+  active() {
+    return this.activeKey ? this.sessions.get(this.activeKey) || null : null;
+  }
+
+  setActive(key) {
+    if (!this.sessions.has(key)) throw new Error(`no such session: ${key}`);
+    this.activeKey = key;
+    this.emit("sessions-changed");
+    return this.sessions.get(key);
+  }
+
+  kill(key) {
+    const session = this.sessions.get(key);
+    if (!session) throw new Error(`no such session: ${key}`);
+    session.kill();
+    this.emit("sessions-changed");
+  }
+
+  remove(key) {
+    const session = this.sessions.get(key);
+    if (!session) return;
+    if (session.isBusy()) session.kill();
+    this.sessions.delete(key);
+    if (this.activeKey === key) {
+      const rest = [...this.sessions.keys()];
+      this.activeKey = rest.length ? rest[rest.length - 1] : null;
+    }
+    this.emit("sessions-changed");
+  }
+
+  broadcast(prompt) {
+    const sent = [];
+    for (const [key, session] of this.sessions) {
+      if (session.status === "killed") continue;
+      this.sendTo(key, prompt);
+      sent.push(key);
+    }
+    return sent;
+  }
+
+  /** 세션 표: [{key, active, agent, status, elapsed, lastLine, parentKey, depth}] */
+  list() {
+    const rows = [];
+    const walk = (key, depth) => {
+      const s = this.sessions.get(key);
+      if (!s) return;
+      rows.push({
+        key,
+        active: key === this.activeKey,
+        agent: s.agent.slug,
+        status: s.status,
+        busy: s.isBusy(),
+        elapsedMs: s.startedAt ? (s.endedAt || Date.now()) - s.startedAt : 0,
+        lastLine: s.lastLine,
+        parentKey: s.parent ? s.parent.key : null,
+        depth,
+        queued: s.queue.length,
+      });
+      for (const c of s.children) walk(c, depth + 1);
+    };
+    for (const [key, s] of this.sessions) {
+      if (!s.parent) walk(key, 0);
+    }
+    return rows;
+  }
+
+  /** 모든 세션 종료(REPL 종료 시). */
+  shutdown() {
+    for (const s of this.sessions.values()) {
+      if (s.isBusy()) s.kill();
+    }
+  }
+}
+
+module.exports = { Orchestrator, maxParallel };