agentlas 0.9.10 → 1.0.2

package/engine/agentlas-native-host.cjs

@@ -12,7 +12,7 @@
  *
  * 스키마는 실측으로 확인됨 (cli/agentlas.cjs 상단 주석 참고).
  */
-const { spawn } = require("node:child_process");
+const { execFileSync, spawn } = require("node:child_process");
 const crypto = require("node:crypto");
 const fs = require("node:fs");
 const os = require("node:os");
@@ -821,6 +821,7 @@ function runNativeTurn(req) {
     let child;
     try {
       const spawnImpl = req.spawn || spawn;
+      const groupedChild = process.platform !== "win32" && spawnImpl === spawn;
       const childEnv = launchReq.prepareRuntimeEnv === false
         ? (launchReq.env || process.env)
         : runtimeEnvForKind(kind, launchReq.env || process.env, launchReq);
@@ -828,7 +829,16 @@ function runNativeTurn(req) {
         cwd,
         stdio: ["ignore", "pipe", "pipe"],
         env: childEnv,
+        detached: groupedChild,
+        windowsHide: true,
       });
+      child.__agentlasNativeChild = spawnImpl === spawn;
+      child.__agentlasGroupedChild = groupedChild;
+      // 세션 계층(오르카)이 실행 중 중단(kill)을 하려면 child 핸들이 필요하다.
+      // 커스텀 spawn 주입 방식은 위 트리킬 플래그를 깨므로 훅으로 노출한다.
+      if (typeof req.onSpawn === "function") {
+        try { req.onSpawn(child); } catch { /* observer 실패가 턴을 죽이면 안 됨 */ }
+      }
     } catch (e) {
       ui.error(uiText(ui, "runtime.failed", kind, e.message));
       return resolve({ text: "", session: st.session, error: e.message });
@@ -840,6 +850,7 @@ function runNativeTurn(req) {
     let totalTimer = null;
     let killTimer = null;
     let forceTimer = null;
+    let verifyTimer = null;
     let removeLineReader = () => {};
     let stderrBuf = "";
     const clearWatchdogs = () => {
@@ -847,7 +858,8 @@ function runNativeTurn(req) {
       if (totalTimer) clearTimeout(totalTimer);
       if (killTimer) clearTimeout(killTimer);
       if (forceTimer) clearTimeout(forceTimer);
-      idleTimer = totalTimer = killTimer = forceTimer = null;
+      if (verifyTimer) clearTimeout(verifyTimer);
+      idleTimer = totalTimer = killTimer = forceTimer = verifyTimer = null;
     };
     const cleanup = () => {
       clearWatchdogs();
@@ -866,7 +878,29 @@ function runNativeTurn(req) {
       ui.stopSpinner();
       const text = (st.finalText || st.text || "").trim();
       if (st.usage) ui.cost(st.usage);
-      finish({ text, session: st.session, usage: st.usage, error: termination ? termination.message : "native runtime stopped" });
+      finish({
+        text,
+        session: st.session,
+        usage: st.usage,
+        error: termination ? termination.message : "native runtime stopped",
+        terminationVerified: Boolean(termination?.verified),
+      });
+    };
+    const verifyTermination = () => {
+      if (settled || !termination) return;
+      if (verifyTimer) return;
+      if (child.__agentlasNativeChild === true && !(termination.pids || []).length) return;
+      const alive = activeNativeProcessIds(termination.pids || []);
+      if (Array.isArray(alive) && !alive.length) {
+        termination.verified = true;
+        terminationResult();
+        return;
+      }
+      for (const pid of alive || termination.pids || []) signalNativePid(pid, "SIGKILL");
+      verifyTimer = setTimeout(() => {
+        verifyTimer = null;
+        verifyTermination();
+      }, 25);
     };
     const requestStop = (reason) => {
       if (termination || settled) return;
@@ -878,11 +912,17 @@ function runNativeTurn(req) {
       if (idleTimer) clearTimeout(idleTimer);
       if (totalTimer) clearTimeout(totalTimer);
       idleTimer = totalTimer = null;
-      try { child.kill("SIGTERM"); } catch { /* ignore */ }
+      const forcedTree = forceStopNativeProcessTree(child);
+      if (forcedTree.length) {
+        termination.pids = forcedTree;
+        verifyTermination();
+        return;
+      }
+      terminateNativeChild(child, "SIGTERM");
       if (settled) return;
       killTimer = setTimeout(() => {
         if (settled) return;
-        try { child.kill("SIGKILL"); } catch { /* ignore */ }
+        terminateNativeChild(child, "SIGKILL");
         if (settled) return;
         forceTimer = setTimeout(terminationResult, Math.max(250, Math.min(1_000, timeout.killGraceMs)));
       }, timeout.killGraceMs);
@@ -920,7 +960,7 @@ function runNativeTurn(req) {
     child.on("error", (err) => {
       if (settled) return;
       if (termination) {
-        terminationResult();
+        verifyTermination();
         return;
       }
       ui.stopSpinner();
@@ -930,7 +970,7 @@ function runNativeTurn(req) {
     child.on("close", (code) => {
       if (settled) return;
       if (termination) {
-        terminationResult();
+        verifyTermination();
         return;
       }
       ui.streamEnd();
@@ -940,7 +980,7 @@ function runNativeTurn(req) {
       if (st.error && !st.errorShown) {
         // claude `result` is_error 등 — 이전에 표시되지 않은 에러를 노출
         ui.error(String(st.error));
-      } else if (code !== 0 && !text) {
+      } else if (code !== 0) {
         // Runtime Doctor — 아는 시스템 원인(미인증 OAuth MCP 플러그인 등)이면 즉시 수리하고
         // 1회 자동 재시도한다(2026-07-08 notion@openai-curated가 codex 전멸시킨 사고).
         if (!req._doctorRetried) {
@@ -966,7 +1006,10 @@ function runNativeTurn(req) {
         ui.warn(uiText(ui, "runtime.noOutput", kind) + (errTail ? ` (${errTail.slice(-200)})` : ""));
       }
       if (st.usage) ui.cost(st.usage);
-      finish({ text, session: st.session, usage: st.usage, error: st.error });
+      const exitError = code === 0
+        ? st.error
+        : st.error || `${kind} exited with code ${code == null ? "unknown" : code}`;
+      finish({ text, session: st.session, usage: st.usage, error: exitError });
     });
 
     armIdle();
@@ -978,6 +1021,150 @@ function runNativeTurn(req) {
   });
 }
 
+function nativeProcessRows() {
+  if (process.platform === "win32") return [];
+  try {
+    const output = execFileSync("/bin/ps", ["-axo", "pid=,ppid=,stat="], {
+      encoding: "utf8",
+      maxBuffer: 4 * 1024 * 1024,
+      timeout: 1_000,
+    });
+    return String(output || "").split(/\r?\n/).map((line) => {
+      const match = line.trim().match(/^(\d+)\s+(\d+)\s+(\S+)/);
+      return match
+        ? { pid: Number(match[1]), ppid: Number(match[2]), stat: match[3] }
+        : null;
+    }).filter(Boolean);
+  } catch {
+    return null;
+  }
+}
+
+function nativeProcessTreeIds(rootPid, rows = nativeProcessRows()) {
+  if (!Number.isInteger(rootPid) || rootPid <= 1 || !Array.isArray(rows)) return [];
+  const children = new Map();
+  for (const row of rows) {
+    if (!children.has(row.ppid)) children.set(row.ppid, []);
+    children.get(row.ppid).push(row.pid);
+  }
+  const ordered = [];
+  const seen = new Set();
+  const visit = (pid) => {
+    if (seen.has(pid)) return;
+    seen.add(pid);
+    for (const childPid of children.get(pid) || []) visit(childPid);
+    ordered.push(pid);
+  };
+  visit(rootPid);
+  return ordered;
+}
+
+function activeNativeProcessIds(pids, rows = nativeProcessRows()) {
+  if (!Array.isArray(pids) || !pids.length) return [];
+  if (!Array.isArray(rows)) return null;
+  const wanted = new Set(pids);
+  return rows
+    .filter((row) => wanted.has(row.pid) && !String(row.stat || "").startsWith("Z"))
+    .map((row) => row.pid);
+}
+
+function signalNativePid(pid, signal) {
+  if (!Number.isInteger(pid) || pid <= 1) return false;
+  try {
+    process.kill(pid, signal);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function forceStopNativeProcessTree(child) {
+  if (
+    process.platform === "win32" &&
+    child?.__agentlasNativeChild === true &&
+    Number.isInteger(child.pid) &&
+    child.pid > 1
+  ) {
+    try {
+      execFileSync("taskkill", ["/pid", String(child.pid), "/t", "/f"], {
+        stdio: "ignore",
+        timeout: 5_000,
+        windowsHide: true,
+      });
+      return [child.pid];
+    } catch {
+      return [];
+    }
+  }
+  if (
+    !child ||
+    child.__agentlasGroupedChild !== true ||
+    !Number.isInteger(child.pid) ||
+    child.pid <= 1
+  ) return [];
+
+  // Native model CLIs may place tool shells in their own process groups. A
+  // group-only kill can therefore close the model process while a Bash tool
+  // keeps writing in the background. Freeze the whole observed ancestry first
+  // so no descendant can advance, take one more snapshot for races, then kill
+  // every owned process. The caller does not report cancellation until all
+  // captured non-zombie PIDs are gone.
+  const firstRows = nativeProcessRows();
+  if (!Array.isArray(firstRows)) return [];
+  const first = nativeProcessTreeIds(child.pid, firstRows);
+  for (const pid of first) signalNativePid(pid, "SIGSTOP");
+  const secondRows = nativeProcessRows();
+  const second = Array.isArray(secondRows) ? nativeProcessTreeIds(child.pid, secondRows) : [];
+  const all = [...new Set([...first, ...second])];
+  for (const pid of second) signalNativePid(pid, "SIGSTOP");
+  for (const pid of all) signalNativePid(pid, "SIGKILL");
+  return all;
+}
+
+function terminateNativeChild(child, signal = "SIGTERM") {
+  if (!child) return false;
+  let signalled = false;
+  if (
+    process.platform !== "win32" &&
+    child.__agentlasGroupedChild === true &&
+    Number.isInteger(child.pid) &&
+    child.pid > 1
+  ) {
+    try {
+      process.kill(-child.pid, signal);
+      signalled = true;
+    } catch {
+      // The group may already be gone while the direct child is still
+      // observable. Fall through to the direct-child signal.
+    }
+  }
+  if (!signalled) {
+    try {
+      signalled = child.kill(signal);
+    } catch {
+      signalled = false;
+    }
+  }
+  if (
+    process.platform === "win32" &&
+    signal === "SIGKILL" &&
+    Number.isInteger(child.pid) &&
+    child.pid > 1
+  ) {
+    try {
+      const killer = spawn("taskkill", ["/pid", String(child.pid), "/t", "/f"], {
+        stdio: "ignore",
+        windowsHide: true,
+      });
+      killer.unref();
+      signalled = true;
+    } catch {
+      // Direct child.kill above remains the best available fallback.
+    }
+  }
+  return signalled;
+}
+
 module.exports = {
   runNativeTurn,
   summarizeToolInput,
@@ -997,4 +1184,8 @@ module.exports = {
   codexMcpArgs,
   nativeTimeoutConfig,
   directNativeTimeoutConfig,
+  nativeProcessTreeIds,
+  activeNativeProcessIds,
+  forceStopNativeProcessTree,
+  terminateNativeChild,
 };

package/engine/agentlas-onboard.cjs

@@ -1,71 +1,163 @@
 "use strict";
 /*
- * First-run onboarding wizard (openclaw-style): language → default runtime → default permission.
+ * First-run onboarding wizard (openclaw-style): language → default runtime → safe default permission.
  * Runs once; result is saved to cli-prefs.json. Re-run anytime with `agentlas setup`.
  */
 const i18n = require("./agentlas-i18n.cjs");
 const banner = require("./agentlas-banner.cjs");
+const { visWidth, wrapWidth } = require("./agentlas-composer.cjs");
 
 // req = { ui, rl, helpers }  → Promise<{ onboarded, lang, runtime, permission }>
 async function runOnboard({ ui, rl, helpers }) {
   const H = helpers;
   const c = ui.c;
-  const ask = (q) => new Promise((res) => rl.question(q, (a) => res((a || "").trim())));
+  const contentWidth = () => Math.max(20, (ui.out.columns || 80) - 5);
+  const printIndented = (value, paint = (text) => text, indent = "   ") => {
+    const room = Math.max(2, (ui.out.columns || 80) - visWidth(indent));
+    for (const line of wrapWidth(value, room)) ui.line(indent + paint(line));
+  };
+  const printSaved = (value) => {
+    const lines = wrapWidth(value, Math.max(2, (ui.out.columns || 80) - 6));
+    ui.ok(lines[0] || "");
+    for (const line of lines.slice(1)) ui.line("    " + c.text(line));
+  };
+  const optionLine = (index, label, isDefault = false) => {
+    const suffix = isDefault ? `  ${ui.t("wiz.default")}` : "";
+    const prefix = `${index}  `;
+    const continuation = " ".repeat(visWidth(prefix));
+    const lines = wrapWidth(`${label}${suffix}`, Math.max(2, contentWidth() - visWidth(prefix)));
+    lines.forEach((line, lineIndex) => {
+      ui.line("     " + c.text((lineIndex === 0 ? prefix : continuation) + line));
+    });
+  };
+  const pendingLines = [];
+  let lineWaiter = null;
+  const onLine = (line) => {
+    if (lineWaiter) {
+      const resolve = lineWaiter;
+      lineWaiter = null;
+      resolve((line || "").trim());
+    } else {
+      // A pasted multi-line setup response can arrive in one terminal data
+      // burst before the next prompt is installed. Preserve those later lines.
+      pendingLines.push((line || "").trim());
+    }
+  };
+  rl.on("line", onLine);
+  const ask = (q) => {
+    if (pendingLines.length) return Promise.resolve(pendingLines.shift());
+    return new Promise((resolve) => {
+      lineWaiter = resolve;
+      rl.setPrompt(q);
+      rl.prompt();
+    });
+  };
+  let localSigintArmedUntil = 0;
+  const ownsSigint = rl.listenerCount("SIGINT") === 0;
+  const onSigint = () => {
+    const now = Date.now();
+    if (now < localSigintArmedUntil) {
+      ui.line(ui.c.dim(ui.t("bye")));
+      process.exit(0);
+    }
+    localSigintArmedUntil = now + 3_000;
+    ui.warn(ui.t("ctrlcAgain"));
+  };
+  if (ownsSigint) rl.on("SIGINT", onSigint);
   const pickNum = async (n) => {
-    // loop until a valid 1..n number; empty → 1 (first option as default)
+    // Empty keeps the explicitly labelled first option. In a TTY, Up/Down
+    // places a real numeric choice into the readline field so arrows and
+    // number entry share the same validation path.
+    let selected = 1;
+    printIndented(ui.t("wiz.nav"), c.dim);
     for (;;) {
+      let settled = false;
+      let arrowWriteScheduled = false;
+      const flushArrowWrite = () => {
+        arrowWriteScheduled = false;
+        if (settled || rl.closed) return;
+        rl.write(null, { ctrl: true, name: "u" });
+        rl.write(String(selected));
+      };
+      const onKeypress = (_str, key = {}) => {
+        if (key.name === "return" || key.name === "enter") {
+          // readline may emit `line` before the coalesced setImmediate write.
+          // Commit the final arrow target synchronously before Enter reaches
+          // readline's own key handler.
+          if (arrowWriteScheduled) flushArrowWrite();
+          return;
+        }
+        if (key.name !== "up" && key.name !== "down") return;
+        selected = key.name === "up"
+          ? (selected - 2 + n) % n + 1
+          : selected % n + 1;
+        if (arrowWriteScheduled) return;
+        arrowWriteScheduled = true;
+        setImmediate(() => {
+          if (arrowWriteScheduled) flushArrowWrite();
+        });
+      };
+      if (rl.terminal && rl.input) rl.input.prependListener("keypress", onKeypress);
       const a = await ask("   " + c.emerald(ui.t("wiz.pick")));
-      if (a === "") return 1;
+      settled = true;
+      if (rl.input) rl.input.removeListener("keypress", onKeypress);
+      if (a === "") return selected;
       if (/^\d+$/.test(a)) {
         const i = parseInt(a, 10);
         if (i >= 1 && i <= n) return i;
       }
+      ui.warn(ui.t("wiz.invalid", String(n)));
     }
   };
 
-  // small mascot + header
-  ui.line("");
-  banner.renderMascot(ui);
-  ui.line("   " + c.bold(c.emerald("Agentlas")) + c.dim(" · setup"));
-  ui.line("   " + c.dim(ui.t("wiz.welcome")));
+  try {
+    // small mascot + header
+    ui.line("");
+    banner.renderMascot(ui);
+    ui.line("   " + c.bold(c.emerald("Agentlas")) + c.dim(" · setup"));
+    printIndented(ui.t("wiz.welcome"), c.dim);
 
   // Step 1 — language
   ui.line("");
-  ui.line("   " + c.bold(ui.t("wiz.langQ")));
-  i18n.LANGS.forEach((l, i) => ui.line("     " + c.faint(String(i + 1)) + "  " + c.text(l.label)));
+  printIndented(ui.t("wiz.langQ"), c.bold);
+  i18n.LANGS.forEach((l, i) => optionLine(i + 1, l.label, i === 0));
   const li = await pickNum(i18n.LANGS.length);
   const lang = i18n.LANGS[li - 1].code;
   ui.lang = lang; // localize the rest of the wizard
 
   // Step 2 — default runtime
   ui.line("");
-  ui.line("   " + c.bold(ui.t("wiz.runtimeQ")));
+  printIndented(ui.t("wiz.runtimeQ"), c.bold);
   const cliKinds = ["claude-code", "codex", "gemini"];
   const rtOpts = [{ value: "auto", label: ui.t("wiz.runtimeAuto") }];
   for (const k of cliKinds) {
     const has = !!H.which(H.RUNTIME_BIN[k]);
     rtOpts.push({ value: k, label: `${k}  (${has ? ui.t("wiz.runtimeInstalled") : ui.t("wiz.runtimeMissing")})` });
   }
-  rtOpts.forEach((o, i) => ui.line("     " + c.faint(String(i + 1)) + "  " + c.text(o.label)));
+  rtOpts.forEach((o, i) => optionLine(i + 1, o.label, i === 0));
   const ri = await pickNum(rtOpts.length);
   const runtime = rtOpts[ri - 1].value;
 
   // Step 3 — default permission
   ui.line("");
-  ui.line("   " + c.bold(ui.t("wiz.permQ")));
+  printIndented(ui.t("wiz.permQ"), c.bold);
   const permOpts = [
     { v: "read", l: ui.t("wiz.permRead") },
     { v: "write", l: ui.t("wiz.permWrite") },
-    { v: "full", l: ui.t("wiz.permFull") },
   ];
-  permOpts.forEach((o, i) => ui.line("     " + c.faint(String(i + 1)) + "  " + c.text(o.l)));
+  permOpts.forEach((o, i) => optionLine(i + 1, o.l, i === 0));
   const pi = await pickNum(permOpts.length);
   const permission = permOpts[pi - 1].v;
 
-  ui.line("");
-  ui.ok(ui.t("wiz.saved"));
-  ui.line("   " + c.faint(ui.t("wiz.changeLang")));
-  return { onboarded: true, lang, runtime, permission };
+    ui.line("");
+    printSaved(ui.t("wiz.saved"));
+    printIndented(ui.t("wiz.changeLang"), c.faint);
+    return { onboarded: true, lang, runtime, permission };
+  } finally {
+    rl.removeListener("line", onLine);
+    if (ownsSigint) rl.removeListener("SIGINT", onSigint);
+    lineWaiter = null;
+  }
 }
 
 module.exports = { runOnboard };

package/engine/agentlas-permissions.cjs

@@ -14,34 +14,34 @@ const COPY = {
     read: {
       label: "read only",
       short: "inspect only",
-      description: "inspect files and reason; runtime tools cannot change the workspace",
+      description: "inspect only; workspace writes blocked",
     },
     write: {
       label: "workspace write",
       short: "edit workspace",
-      description: "read and edit the current workspace inside the runtime sandbox",
+      description: "workspace + runtime temp writes; external MCP off",
     },
     full: {
       label: "unrestricted",
       short: "unrestricted",
-      description: "bypass runtime approvals and sandboxing; use only in a trusted environment",
+      description: "bypass approvals and sandbox; trusted use only",
     },
   },
   ko: {
     read: {
       label: "읽기 전용",
       short: "조회만",
-      description: "파일을 읽고 판단하지만 런타임 도구가 작업 공간을 변경할 수 없음",
+      description: "조회만; 작업 공간 쓰기 차단",
     },
     write: {
       label: "작업 공간 쓰기",
       short: "작업 공간 편집",
-      description: "런타임 샌드박스 안에서 현재 작업 공간을 읽고 편집",
+      description: "작업 공간·런타임 임시 경로 쓰기; 외부 MCP 꺼짐",
     },
     full: {
       label: "무제한 권한",
       short: "무제한",
-      description: "런타임 승인과 샌드박스를 우회함; 신뢰할 수 있는 환경에서만 사용",
+      description: "승인과 샌드박스를 우회; 신뢰 환경 전용",
     },
   },
 };
@@ -52,6 +52,13 @@ function normalize(value, fallback = "read") {
   return LEVELS.includes(fallback) ? fallback : "read";
 }
 
+function persistent(value, fallback = "write") {
+  const level = normalize(value, fallback);
+  if (level !== "full") return level;
+  const safeFallback = normalize(fallback, "write");
+  return safeFallback === "full" ? "write" : safeFallback;
+}
+
 function next(value) {
   const current = normalize(value);
   return LEVELS[(LEVELS.indexOf(current) + 1) % LEVELS.length];
@@ -87,4 +94,4 @@ function createCycleController(options = {}) {
   };
 }
 
-module.exports = { LEVELS, normalize, next, copy, createCycleController };
+module.exports = { LEVELS, normalize, persistent, next, copy, createCycleController };

package/engine/agentlas-sqlite-policy.cjs

@@ -0,0 +1,34 @@
+"use strict";
+
+// Terminal processes may share the Desktop application's SQLite file. Keep
+// lock waits bounded, and acquire writer authority before a transaction reads
+// state that it may subsequently update. A deferred read-to-write upgrade can
+// fail immediately with SQLITE_BUSY even when busy_timeout is configured.
+const SQLITE_BUSY_TIMEOUT_MS = 15_000;
+
+function configureSqliteConnection(db) {
+  if (!db) throw new TypeError("SQLite connection is required");
+  if (typeof db.pragma === "function") {
+    db.pragma(`busy_timeout = ${SQLITE_BUSY_TIMEOUT_MS}`);
+  } else if (typeof db.exec === "function") {
+    db.exec(`PRAGMA busy_timeout = ${SQLITE_BUSY_TIMEOUT_MS}`);
+  } else {
+    throw new TypeError("SQLite connection must expose pragma() or exec()");
+  }
+  return db;
+}
+
+function runWriteTransaction(db, fn, ...args) {
+  if (!db || typeof db.transaction !== "function") return fn(...args);
+  const transaction = db.transaction(fn);
+  if (typeof transaction.immediate === "function") {
+    return transaction.immediate(...args);
+  }
+  return transaction(...args);
+}
+
+module.exports = {
+  SQLITE_BUSY_TIMEOUT_MS,
+  configureSqliteConnection,
+  runWriteTransaction,
+};