reasonix 0.46.1 → 0.47.1

package/dist/cli/{desktop-5ONTRU3C.js → desktop-EG6P5SF2.js}

@@ -2,16 +2,16 @@
 import { createRequire as __cr } from 'node:module'; if (typeof globalThis.require === 'undefined') { globalThis.require = __cr(import.meta.url); }
 import {
   createMcpRuntime
-} from "./chunk-JVQT5IYP.js";
+} from "./chunk-YFP3MYMY.js";
 import {
   buildCodeToolset
-} from "./chunk-7YW6TPXK.js";
+} from "./chunk-XD6P7AFH.js";
 import {
   Eventizer,
   autoResolveVerdict
-} from "./chunk-HNXDZGC6.js";
-import "./chunk-NCBP5D6E.js";
-import "./chunk-YRLC2EDF.js";
+} from "./chunk-ZXSCAODE.js";
+import "./chunk-DQ6K5ZQ7.js";
+import "./chunk-EQATK2L2.js";
 import {
   CacheFirstLoop,
   ImmutablePrefix,
@@ -19,39 +19,39 @@ import {
   listFilesWithStatsAsync,
   parseAtQuery,
   rankPickerCandidates
-} from "./chunk-ZOQHVQON.js";
-import "./chunk-TDSBASOF.js";
-import "./chunk-EAOL43HB.js";
-import "./chunk-WQ6ZRDQM.js";
+} from "./chunk-JBH5RM7X.js";
+import "./chunk-6QC5RQLE.js";
+import "./chunk-HUILPCYX.js";
+import "./chunk-HIYTRCSW.js";
 import {
   MemoryStore,
   codeSystemPrompt
-} from "./chunk-DHRVZJ2D.js";
+} from "./chunk-BQ6HC66J.js";
 import {
   canonicalPresetName,
   resolvePreset
-} from "./chunk-2425HK6U.js";
+} from "./chunk-LGEKVMMV.js";
 import {
   countTokensBounded
 } from "./chunk-6OWJV3YW.js";
 import {
   DeepSeekClient,
   pickPrimaryBalance
-} from "./chunk-MIIZJD5O.js";
+} from "./chunk-DWPAKZTY.js";
 import "./chunk-25T6CVUP.js";
 import {
   loadDotenv
 } from "./chunk-2UQP6H6T.js";
-import "./chunk-XPAUNFOL.js";
+import "./chunk-KVZZ5U75.js";
 import {
   pauseGate
-} from "./chunk-JVFEJAJX.js";
+} from "./chunk-TRSAHHCL.js";
 import {
   SkillStore
-} from "./chunk-TEUDEGX2.js";
+} from "./chunk-FY4S7TJZ.js";
 import "./chunk-PLHAZOLZ.js";
-import "./chunk-JLQDNLZF.js";
-import "./chunk-C72TNHDE.js";
+import "./chunk-T5A7EY6B.js";
+import "./chunk-GH7DC2Y5.js";
 import "./chunk-S4XVGLRW.js";
 import {
   deleteSession,
@@ -59,12 +59,14 @@ import {
   loadSessionMessages,
   loadSessionMeta,
   patchSessionMeta,
+  sessionPath,
   timestampSuffix
-} from "./chunk-E7TAHQ4A.js";
-import "./chunk-WRONKNIH.js";
-import "./chunk-M4E5JK6S.js";
-import "./chunk-6VANO7KB.js";
+} from "./chunk-RRXUIPWG.js";
+import "./chunk-DN4B5S6Y.js";
+import "./chunk-QCFLPSPH.js";
+import "./chunk-NRQ5UP5T.js";
 import {
+  describeQQAccess,
   isPlausibleKey,
   loadApiKey,
   loadBaseUrl,
@@ -72,6 +74,7 @@ import {
   loadEditMode,
   loadEditor,
   loadPreset,
+  loadQQConfig,
   loadReasoningEffort,
   loadRecentWorkspaces,
   loadResolvedSkillPaths,
@@ -85,10 +88,11 @@ import {
   saveEditMode,
   saveEditor,
   savePreset,
+  saveQQConfig,
   saveReasoningEffort,
   saveWorkspaceDir,
   writeConfig
-} from "./chunk-DGA5QYFM.js";
+} from "./chunk-6CRPCJAU.js";
 import {
   VERSION
 } from "./chunk-XXC2BYTV.js";
@@ -101,6 +105,109 @@ import { readFile } from "fs/promises";
 import { isAbsolute, join, resolve } from "path";
 import { stdin } from "process";
 import { createInterface } from "readline";
+
+// src/desktop/login-shell-path.ts
+import { spawnSync } from "child_process";
+var cached;
+function resolveLoginShellPath(opts = {}) {
+  if (cached !== void 0) return cached.value;
+  cached = { value: null };
+  if (process.platform === "win32") return null;
+  const shell = process.env.SHELL || "/bin/bash";
+  const marker = "__REASONIX_PATH__=";
+  try {
+    const result = spawnSync(shell, ["-ilc", `printf '${marker}%s\\n' "$PATH"`], {
+      encoding: "utf8",
+      timeout: opts.timeoutMs ?? 2e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    if (result.status !== 0 && result.signal === null) return null;
+    const stdout = result.stdout ?? "";
+    const idx = stdout.lastIndexOf(marker);
+    if (idx < 0) return null;
+    const tail = stdout.slice(idx + marker.length);
+    const newline = tail.indexOf("\n");
+    const path = (newline >= 0 ? tail.slice(0, newline) : tail).trim();
+    if (!path || !path.includes("/")) return null;
+    cached.value = path;
+    return path;
+  } catch {
+    return null;
+  }
+}
+function augmentProcessPath() {
+  const loginPath = resolveLoginShellPath();
+  if (!loginPath) return { added: [] };
+  const current = process.env.PATH ?? "";
+  const seen = new Set(
+    current.split(":").map((s) => s.trim()).filter(Boolean)
+  );
+  const additions = [];
+  for (const entry of loginPath.split(":")) {
+    const t = entry.trim();
+    if (!t || seen.has(t)) continue;
+    seen.add(t);
+    additions.push(t);
+  }
+  if (additions.length === 0) return { added: [] };
+  process.env.PATH = additions.concat(current ? [current] : []).join(":");
+  return { added: additions };
+}
+
+// src/desktop/qq-settings.ts
+function trimOptional(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function toPreview(appId) {
+  if (!appId) return void 0;
+  return appId.length > 6 ? `${appId.slice(0, 6)}...` : appId;
+}
+function toAccess(config) {
+  return describeQQAccess({
+    ownerOpenId: config.ownerOpenId,
+    allowlist: config.allowlist
+  });
+}
+function loadDesktopQQState(path) {
+  const config = loadQQConfig(path);
+  const configured = Boolean(config.appId && config.appSecret);
+  const enabled = config.enabled === true;
+  return {
+    ...config,
+    sandbox: config.sandbox ?? false,
+    enabled,
+    configured,
+    // Never true — the desktop process doesn't host a QQChannel (#1317).
+    connected: false,
+    enabledForCli: configured && enabled,
+    appIdPreview: toPreview(config.appId),
+    access: toAccess(config)
+  };
+}
+function saveDesktopQQSettings(patch, path) {
+  const existing = loadQQConfig(path);
+  saveQQConfig(
+    {
+      ...existing,
+      appId: trimOptional(patch.appId),
+      appSecret: trimOptional(patch.appSecret),
+      sandbox: patch.sandbox
+    },
+    path
+  );
+  return loadDesktopQQState(path);
+}
+function setDesktopQQEnabled(enabled, path) {
+  const existing = loadQQConfig(path);
+  if (enabled && !(existing.appId && existing.appSecret)) {
+    throw new Error("QQ App ID and App Secret are required.");
+  }
+  saveQQConfig({ ...existing, enabled }, path);
+  return loadDesktopQQState(path);
+}
+
+// src/cli/commands/desktop.ts
 function emit(ev, tabId) {
   const payload = tabId ? { ...ev, tabId } : ev;
   writeSync(1, Buffer.from(`${JSON.stringify(payload)}
@@ -179,6 +286,9 @@ function emitSettings(tab) {
     tab.id
   );
 }
+function emitQQSettings(tab) {
+  emit({ type: "$qq_settings", ...loadDesktopQQState() }, tab.id);
+}
 async function emitBalance(tab) {
   if (!tab.runtime) return;
   const bal = await tab.runtime.loop.client.getBalance().catch(() => null);
@@ -415,9 +525,17 @@ function installDesktopCrashGuards(stderr = process.stderr) {
 }
 async function desktopCommand(opts) {
   loadDotenv();
+  const augmented = augmentProcessPath();
+  if (augmented.added.length > 0) {
+    process.stderr.write(
+      `[desktop] augmented PATH with ${augmented.added.length} login-shell entries
+`
+    );
+  }
   installDesktopCrashGuards();
   const tabs = /* @__PURE__ */ new Map();
   const tabContext = new AsyncLocalStorage();
+  let lastActiveTabId = "";
   function activeRunningTab() {
     const id = tabContext.getStore();
     return id ? tabs.get(id) : void 0;
@@ -519,7 +637,13 @@ async function desktopCommand(opts) {
   }
   function persistOpenTabs() {
     try {
-      saveDesktopOpenTabs(Array.from(tabs.values()).map((t) => t.rootDir));
+      saveDesktopOpenTabs(
+        Array.from(tabs.values()).map((t) => ({
+          dir: t.rootDir,
+          session: t.currentSession || void 0,
+          active: t.id === lastActiveTabId
+        }))
+      );
     } catch {
     }
   }
@@ -622,6 +746,7 @@ async function desktopCommand(opts) {
     emitSessions(tab);
     emitSettings(tab);
     emitSkills(tab);
+    persistOpenTabs();
   }
   function forgetGate(id) {
     for (const t of tabs.values()) {
@@ -849,14 +974,44 @@ async function desktopCommand(opts) {
     if (tab) tab.pendingGateIds.delete(req.id);
     pauseGate.cancel(req.id);
   });
-  function bootstrapTab(initialDir) {
+  function bootstrapTab(initialDir, restore) {
     const tab = createTabSkeleton(initialDir);
-    emit({ type: "$tab_opened", workspaceDir: tab.rootDir }, tab.id);
+    let restoredMessages;
+    if (restore?.session) {
+      try {
+        if (existsSync(sessionPath(restore.session))) {
+          const msgs = buildLoadedMessages(loadSessionMessages(restore.session));
+          if (msgs.length > 0) {
+            tab.currentSession = restore.session;
+            restoredMessages = msgs;
+          }
+        }
+      } catch {
+      }
+    }
+    emit({ type: "$tab_opened", workspaceDir: tab.rootDir, active: restore?.active }, tab.id);
     emitSessions(tab);
     emitSettings(tab);
     emitMcpSpecs(tab);
     emitSkills(tab);
     emitMemory(tab);
+    emitQQSettings(tab);
+    if (restoredMessages) {
+      const meta = loadSessionMeta(tab.currentSession);
+      emit(
+        {
+          type: "$session_loaded",
+          name: tab.currentSession,
+          messages: restoredMessages,
+          carryover: {
+            totalCostUsd: meta.totalCostUsd ?? 0,
+            cacheHitTokens: meta.cacheHitTokens ?? 0,
+            cacheMissTokens: meta.cacheMissTokens ?? 0
+          }
+        },
+        tab.id
+      );
+    }
     if (!loadApiKey()) emit({ type: "$needs_setup", reason: "no_api_key" }, tab.id);
     void emitBalance(tab);
     void initTabToolset(tab).then(() => {
@@ -867,18 +1022,18 @@ async function desktopCommand(opts) {
     });
     return tab;
   }
-  const savedTabDirs = opts.dir ? [] : loadDesktopOpenTabs().filter((d) => {
+  const savedTabs = opts.dir ? [] : loadDesktopOpenTabs().filter((t) => {
     try {
-      return existsSync(d) && statSync(d).isDirectory();
+      return existsSync(t.dir) && statSync(t.dir).isDirectory();
     } catch {
       return false;
     }
   });
-  first = bootstrapTab(savedTabDirs[0]);
-  for (const d of savedTabDirs.slice(1)) {
-    if (resolve(d) === first.rootDir) continue;
-    bootstrapTab(d);
-  }
+  first = bootstrapTab(savedTabs[0]?.dir, savedTabs[0]);
+  const restored = [first];
+  for (const t of savedTabs.slice(1)) restored.push(bootstrapTab(t.dir, t));
+  const activeIdx = savedTabs.findIndex((t) => t.active);
+  lastActiveTabId = ((activeIdx >= 0 ? restored[activeIdx] : first) ?? first).id;
   persistOpenTabs();
   const rl = createInterface({ input: stdin });
   rl.on("line", (line) => {
@@ -893,13 +1048,21 @@ async function desktopCommand(opts) {
     }
     if (msg.cmd === "tab_open") {
       try {
-        bootstrapTab(msg.workspaceDir);
+        const opened = bootstrapTab(msg.workspaceDir, { active: true });
+        lastActiveTabId = opened.id;
         persistOpenTabs();
       } catch (err) {
         emit({ type: "$error", message: `tab_open failed: ${err.message}` });
       }
       return;
     }
+    if (msg.cmd === "tab_activate") {
+      if (tabs.has(msg.tabId)) {
+        lastActiveTabId = msg.tabId;
+        persistOpenTabs();
+      }
+      return;
+    }
     if (msg.cmd === "confirm_response") {
       forgetGate(msg.id);
       pauseGate.resolve(msg.id, msg.response);
@@ -977,7 +1140,10 @@ async function desktopCommand(opts) {
     }
     const tab = msg.tabId ? tabs.get(msg.tabId) : first;
     if (!tab) {
-      emit({ type: "$error", message: `unknown tab: ${msg.tabId}` });
+      process.stderr.write(
+        `rpc dispatch: unknown tabId=${msg.tabId} for cmd=${msg.cmd} \u2014 dropping
+`
+      );
       return;
     }
     if (msg.cmd === "abort") {
@@ -1088,12 +1254,26 @@ ${found.body}${argsLine}`;
         abortTurn(tab);
         cancelPendingGates(tab);
         tab.currentSession = msg.name;
+        persistOpenTabs();
         if (tab.runtime) tab.runtime = buildRuntimeFor(tab);
+        const loadedMessages = buildLoadedMessages(records);
+        if (loadedMessages.length === 0) {
+          let sizeBytes = 0;
+          try {
+            sizeBytes = statSync(sessionPath(msg.name)).size;
+          } catch {
+          }
+          process.stderr.write(
+            `session_load: "${msg.name}" returned 0 messages (file size=${sizeBytes}B) \u2014 empty or unreadable jsonl
+`
+          );
+          emit({ type: "$session_empty", name: msg.name, sizeBytes }, tab.id);
+        }
         emit(
           {
             type: "$session_loaded",
             name: msg.name,
-            messages: buildLoadedMessages(records),
+            messages: loadedMessages,
             carryover: {
               totalCostUsd: meta.totalCostUsd ?? 0,
               cacheHitTokens: meta.cacheHitTokens ?? 0,
@@ -1103,6 +1283,8 @@ ${found.body}${argsLine}`;
           tab.id
         );
       } catch (err) {
+        process.stderr.write(`session_load: "${msg.name}" threw \u2014 ${err.message}
+`);
         emit({ type: "$error", message: `session_load failed: ${err.message}` }, tab.id);
       }
       return;
@@ -1111,6 +1293,7 @@ ${found.body}${argsLine}`;
       abortTurn(tab);
       cancelPendingGates(tab);
       tab.currentSession = mintSessionFor(tab.rootDir);
+      persistOpenTabs();
       if (tab.runtime) tab.runtime = buildRuntimeFor(tab);
       emitSessions(tab);
       return;
@@ -1119,6 +1302,10 @@ ${found.body}${argsLine}`;
       emitSettings(tab);
       return;
     }
+    if (msg.cmd === "qq_status_get") {
+      emitQQSettings(tab);
+      return;
+    }
     if (msg.cmd === "settings_save") {
       try {
         if (msg.reasoningEffort !== void 0) {
@@ -1158,6 +1345,68 @@ ${found.body}${argsLine}`;
       }
       return;
     }
+    if (msg.cmd === "qq_config_save") {
+      try {
+        saveDesktopQQSettings(
+          {
+            appId: msg.appId,
+            appSecret: msg.appSecret,
+            sandbox: msg.sandbox
+          },
+          void 0
+        );
+        emitQQSettings(tab);
+      } catch (err) {
+        emit(
+          { type: "$error", message: `qq_config_save failed: ${err.message}` },
+          tab.id
+        );
+      }
+      return;
+    }
+    if (msg.cmd === "qq_connect") {
+      try {
+        const current = loadQQConfig();
+        setDesktopQQEnabled(true);
+        emit(
+          {
+            type: "status",
+            id: Date.now(),
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            turn: 0,
+            text: `QQ enabled for CLI (${current.sandbox ? "sandbox" : "production"}) \u2014 start the bot by running \`reasonix\` in a terminal`
+          },
+          tab.id
+        );
+        emitQQSettings(tab);
+      } catch (err) {
+        emit({ type: "$error", message: `qq_connect failed: ${err.message}` }, tab.id);
+        emitQQSettings(tab);
+      }
+      return;
+    }
+    if (msg.cmd === "qq_disconnect") {
+      try {
+        setDesktopQQEnabled(false);
+        emit(
+          {
+            type: "status",
+            id: Date.now(),
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            turn: 0,
+            text: "QQ disabled for CLI (next `reasonix` terminal session won't auto-start the bot)"
+          },
+          tab.id
+        );
+        emitQQSettings(tab);
+      } catch (err) {
+        emit(
+          { type: "$error", message: `qq_disconnect failed: ${err.message}` },
+          tab.id
+        );
+      }
+      return;
+    }
     if (msg.cmd === "mention_query") {
       const nonce = msg.nonce;
       const query = msg.query;
@@ -1230,6 +1479,42 @@ ${found.body}${argsLine}`;
       });
       return;
     }
+    if (msg.cmd === "compact_history") {
+      if (!tab.runtime) return;
+      void tab.runtime.loop.compactHistory().catch((err) => {
+        emit({ type: "$error", message: `/compact failed: ${err.message}` }, tab.id);
+      });
+      return;
+    }
+    if (msg.cmd === "retry") {
+      if (!tab.runtime) return;
+      const prev = tab.runtime.loop.retryLastUser();
+      if (prev) {
+        emit({ type: "$retry_result", text: prev }, tab.id);
+      }
+      return;
+    }
+    if (msg.cmd === "btw") {
+      if (!tab.runtime) return;
+      const question = msg.text.trim();
+      if (!question) return;
+      void (async () => {
+        try {
+          const reply = await tab.runtime.loop.client.chat({
+            model: tab.currentModel,
+            messages: [
+              { role: "system", content: tab.system },
+              { role: "user", content: question }
+            ]
+          });
+          const answer = (typeof reply.content === "string" ? reply.content.trim() : "") || "(no answer)";
+          emit({ type: "$btw_result", question, answer }, tab.id);
+        } catch (err) {
+          emit({ type: "$error", message: `/btw failed: ${err.message}` }, tab.id);
+        }
+      })();
+      return;
+    }
     if (msg.cmd === "user_input") {
       if (!tab.runtime) {
         emit(
@@ -1252,4 +1537,4 @@ export {
   desktopCommand,
   installDesktopCrashGuards
 };
-//# sourceMappingURL=desktop-5ONTRU3C.js.map
+//# sourceMappingURL=desktop-EG6P5SF2.js.map