@versot/vaguspi 0.1.3 → 0.1.4

package/dist/bin.js

@@ -8,7 +8,8 @@ import { parseArgs } from "node:util";
 import { existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync6, readdirSync as readdirSync3, statSync as statSync3 } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { homedir as homedir2 } from "node:os";
-import { join as join8, normalize, resolve as resolve3, sep as sep2 } from "node:path";
+import { join as join8, normalize, resolve as resolve3, sep as sep3 } from "node:path";
+import { EnvHttpProxyAgent, setGlobalDispatcher } from "undici";
 
 // packages/host/config/dist/config-store.js
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
@@ -301,8 +302,9 @@ var VagModelsStore = class {
 // packages/host/engine/dist/vagus-engine.js
 import { createAgentSession, DefaultResourceLoader, ModelRuntime, SessionManager as SessionManager2, SettingsManager } from "@earendil-works/pi-coding-agent";
 import { homedir } from "node:os";
-import { basename, dirname as dirname3, isAbsolute as isAbsolute2, join as join5, resolve } from "node:path";
-import { appendFileSync as appendFileSync2, copyFileSync as copyFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync4, renameSync, rmSync, statSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { basename, dirname as dirname3, isAbsolute as isAbsolute2, join as join5, resolve, sep } from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { appendFileSync as appendFileSync2, copyFileSync as copyFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync4, renameSync, rmSync, rmdirSync, statSync, unlinkSync, writeFileSync as writeFileSync3 } from "node:fs";
 
 // packages/host/engine/dist/display-utils.js
 import * as Diff from "diff";
@@ -1696,9 +1698,17 @@ var VagusEngine = class {
   closeSessionForCwd(cwd) {
     for (const [sid, session] of this.sessions) {
       if (session.sessionManager?.getCwd() === cwd) {
-        session.dispose();
+        process.stderr.write(`vagus: disposing session ${sid} (cwd=${cwd})
+`);
+        try {
+          session.dispose();
+        } catch (err) {
+          process.stderr.write(`vagus: dispose threw: ${err instanceof Error ? err.stack : String(err)}
+`);
+        }
         this.sessions.delete(sid);
-        void this.options.bus.emit("session.closed", { type: "session.closed", sessionId: sid });
+        void this.options.bus.emit("session.closed", { type: "session.closed", sessionId: sid }).catch(() => {
+        });
       }
     }
   }
@@ -1760,6 +1770,37 @@ var VagusEngine = class {
     }
   }
   /** Restores an archived project: moves its session files back under `sessions/`. */
+  /** Restores an archived project by its encoded dir name (unique identity). */
+  async unarchiveProjectByDir(dirKey) {
+    if (!dirKey || dirKey.includes("/") || dirKey.includes("\\") || dirKey.includes(".."))
+      return;
+    const agentDir = this.agentDirPath();
+    const src = join5(agentDir, "archived", dirKey);
+    if (!existsSync3(src))
+      return;
+    let cwd;
+    try {
+      cwd = this.sessionCwd(readdirSync2(src).filter((f) => f.endsWith(".jsonl"))[0] ? join5(src, readdirSync2(src).filter((f) => f.endsWith(".jsonl"))[0]) : "");
+    } catch {
+      cwd = void 0;
+    }
+    if (cwd) {
+      this.closeSessionForCwd(cwd);
+      const dst = join5(agentDir, "sessions", this.encodeCwd(cwd));
+      mkdirSync4(dst, { recursive: true });
+      for (const entry of readdirSync2(src)) {
+        if (!entry.endsWith(".jsonl"))
+          continue;
+        const from = join5(src, entry);
+        try {
+          if (statSync(from).isFile())
+            renameSync(from, join5(dst, entry));
+        } catch {
+        }
+      }
+      this.rmDirSafe(src);
+    }
+  }
   async restoreProject(cwd) {
     const agentDir = this.agentDirPath();
     const src = join5(agentDir, "archived", this.encodeCwd(cwd));
@@ -1778,16 +1819,99 @@ var VagusEngine = class {
       } catch {
       }
     }
-    rmSync(src, { recursive: true, force: true });
+    this.rmDirSafe(src);
+  }
+  /** Permanently deletes an archived project dir by its encoded dir name.
+   *  dirKey (not cwd) is the identity — cwds can repeat across archive dirs. */
+  async deleteArchivedProjectByDir(dirKey) {
+    if (!dirKey || dirKey.includes("/") || dirKey.includes("\\") || dirKey.includes(".."))
+      return;
+    const agentDir = this.agentDirPath();
+    const dir = join5(agentDir, "archived", dirKey);
+    process.stderr.write(`vagus: deleteArchivedProjectByDir dirKey=${dirKey}
+`);
+    const prefix = dir + sep;
+    for (const [sid, session] of this.sessions) {
+      const file = session.sessionManager?.getSessionFile();
+      if (file && (file === dir || file.startsWith(prefix))) {
+        try {
+          session.dispose();
+        } catch {
+        }
+        this.sessions.delete(sid);
+        void this.options.bus.emit("session.closed", { type: "session.closed", sessionId: sid }).catch(() => {
+        });
+      }
+    }
+    process.stderr.write(`vagus: sessions closed, removing dir...
+`);
+    this.rmDirSafe(dir);
+    process.stderr.write(`vagus: archived dir removed OK
+`);
   }
   /** Permanently deletes an archived project's session dir (JSONL). */
   async deleteArchivedProject(cwd) {
     const agentDir = this.agentDirPath();
     const dir = join5(agentDir, "archived", this.encodeCwd(cwd));
+    process.stderr.write(`vagus: deleteArchivedProject cwd=${cwd} dir=${dir}
+`);
     this.closeSessionForCwd(cwd);
-    rmSync(dir, { recursive: true, force: true });
+    process.stderr.write(`vagus: sessions closed, removing dir...
+`);
+    this.rmDirSafe(dir);
+    process.stderr.write(`vagus: archived dir removed OK
+`);
+  }
+  /**
+   * rmSync(recursive) has crashed the daemon natively (0xC0000409 fastfail)
+   * on Windows when deleting archived dirs with non-ASCII names — JS guards
+   * cannot catch a native abort. Delete file-by-file instead: plain unlink
+   * calls are individually catchable and skip whatever is locked/unreadable.
+   *
+   * Iterative (explicit stack, deepest-first) — no JS recursion limit, so
+   * arbitrarily deep trees are safe.
+   */
+  rmDirSafe(root) {
+    const pendingDirs = [{ path: root, expanded: false }];
+    while (pendingDirs.length > 0) {
+      const top = pendingDirs[pendingDirs.length - 1];
+      if (top.expanded) {
+        pendingDirs.pop();
+        try {
+          rmdirSync(top.path);
+        } catch (err) {
+          process.stderr.write(`vagus: rmDirSafe rmdir failed ${top.path}: ${err instanceof Error ? err.message : String(err)}
+`);
+        }
+        continue;
+      }
+      let entries;
+      try {
+        entries = readdirSync2(top.path);
+      } catch {
+        pendingDirs.pop();
+        continue;
+      }
+      top.expanded = true;
+      for (const entry of entries) {
+        const full = join5(top.path, entry);
+        try {
+          if (statSync(full).isDirectory()) {
+            pendingDirs.push({ path: full, expanded: false });
+          } else {
+            unlinkSync(full);
+          }
+        } catch (err) {
+          process.stderr.write(`vagus: rmDirSafe skipped ${full}: ${err instanceof Error ? err.message : String(err)}
+`);
+        }
+      }
+    }
   }
   /** Lists archived projects with their sessions (scans the `archived/` dir). */
+  /** Lists archived projects with their sessions (scans the `archived/` dir).
+   *  dirKey is the encoded directory name — the unique identity of an archived
+   *  group (cwd from session headers can repeat across dirs). */
   async listArchivedProjects() {
     const agentDir = this.agentDirPath();
     const root = join5(agentDir, "archived");
@@ -1805,6 +1929,7 @@ var VagusEngine = class {
           continue;
         out.push({
           cwd,
+          dirKey: entry,
           sessions: infos.map((i) => ({
             id: i.id,
             path: i.path,
@@ -1887,6 +2012,54 @@ var VagusEngine = class {
     const result = await session.navigateTree(targetId, options);
     return { editorText: result.editorText, cancelled: result.cancelled };
   }
+  /**
+   * Creates a new session forked from a specific user message.
+   * The new session contains only the conversation up to and including that
+   * user message — everything after it is dropped. The original session is
+   * untouched. Returns the new session's info (sessionId, sessionFile, cwd).
+   */
+  async forkSession(sessionId, entryId) {
+    const session = this.requireSession(sessionId);
+    const sourceFile = session.sessionManager?.getSessionFile();
+    if (!sourceFile)
+      throw new Error("source session has no file path");
+    if (!existsSync3(sourceFile))
+      throw new Error(`source session file not found: ${sourceFile}`);
+    const raw = readFileSync4(sourceFile, "utf8");
+    const lines = raw.split("\n").filter((l) => l.trim().length > 0);
+    const entries = lines.map((l) => JSON.parse(l));
+    const header = entries[0];
+    if (!header || header.type !== "session")
+      throw new Error("source session has no header");
+    const targetIdx = entries.findIndex((e) => e.id === entryId);
+    if (targetIdx < 0)
+      throw new Error(`entry ${entryId} not found in source session`);
+    let endIdx = targetIdx - 1;
+    if (endIdx < 1)
+      endIdx = 1;
+    const cwd = session.sessionManager.getCwd() || this.options.cwd;
+    const sessionDir = dirname3(sourceFile);
+    mkdirSync4(sessionDir, { recursive: true });
+    const newSessionId = randomUUID2();
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const fileTimestamp = timestamp.replace(/[:.]/g, "-");
+    const newSessionFile = join5(sessionDir, `${fileTimestamp}_${newSessionId}.jsonl`);
+    const newHeader = {
+      type: "session",
+      version: header.version ?? 1,
+      id: newSessionId,
+      timestamp,
+      cwd,
+      parentSession: sourceFile
+    };
+    const outLines = [JSON.stringify(newHeader)];
+    for (let i = 1; i <= endIdx; i++) {
+      outLines.push(JSON.stringify(entries[i]));
+    }
+    writeFileSync3(newSessionFile, outLines.join("\n") + "\n", "utf8");
+    const manager = SessionManager2.open(newSessionFile);
+    return this.startSession({ cwd, sessionManager: manager });
+  }
   /**
    * Exports the active branch to JSONL (/export). Returns the output path.
    */
@@ -6562,7 +6735,7 @@ import { WebSocketServer as WsServer } from "ws";
 
 // packages/host/rpc/dist/static-server.js
 import { createReadStream, existsSync as existsSync4, statSync as statSync2 } from "node:fs";
-import { extname, join as join6, resolve as resolve2, sep } from "node:path";
+import { extname, join as join6, resolve as resolve2, sep as sep2 } from "node:path";
 var MIME_TYPES = {
   ".html": "text/html; charset=utf-8",
   ".js": "text/javascript; charset=utf-8",
@@ -6581,7 +6754,7 @@ function resolveStaticFile(rootDir, pathname) {
   const root = resolve2(rootDir);
   const name = pathname === "/" ? "index.html" : pathname;
   const candidate = resolve2(join6(root, name));
-  if (candidate !== root && !candidate.startsWith(root + sep)) {
+  if (candidate !== root && !candidate.startsWith(root + sep2)) {
     return void 0;
   }
   if (existsSync4(candidate)) {
@@ -6906,6 +7079,28 @@ function requireString(value, label) {
   }
   return value;
 }
+function applyHttpProxy() {
+  try {
+    let proxy;
+    const settingsFile = join8(piAgentDir(), "settings.json");
+    if (existsSync6(settingsFile)) {
+      const s = JSON.parse(readFileSync6(settingsFile, "utf8"));
+      if (typeof s.httpProxy === "string" && s.httpProxy.trim()) proxy = s.httpProxy.trim();
+    }
+    proxy ??= process.env.HTTPS_PROXY ?? process.env.HTTP_PROXY;
+    if (proxy) {
+      const normalized = /^https?:\/\//.test(proxy) ? proxy : `http://${proxy}`;
+      process.env.HTTPS_PROXY = normalized;
+      process.env.HTTP_PROXY = normalized;
+      setGlobalDispatcher(new EnvHttpProxyAgent());
+      process.stderr.write(`vagus: http proxy enabled \u2192 ${normalized}
+`);
+    }
+  } catch (err) {
+    process.stderr.write(`vagus: proxy setup skipped: ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+}
 function probeRequestFor(apiType, url, apiKey, modelId) {
   const headers = { "Content-Type": "application/json" };
   const base = url.replace(/\/chat\/completions$/, "");
@@ -6939,6 +7134,7 @@ function builtinExtensionPaths() {
   return out;
 }
 async function runDaemon() {
+  applyHttpProxy();
   const stateDir = defaultStateDir();
   mkdirSync6(stateDir, { recursive: true });
   const config = new ConfigStore({ dir: stateDir });
@@ -6997,19 +7193,21 @@ async function runDaemon() {
       return host.archiveProject(cwd);
     });
     srv.registerMethod("project.unarchive", (params) => {
-      const cwd = requireString(params?.cwd, "cwd");
-      return host.restoreProject(cwd);
+      const { cwd, dirKey } = params ?? {};
+      if (typeof dirKey === "string" && dirKey) return host.unarchiveProjectByDir(dirKey);
+      return host.restoreProject(requireString(cwd, "cwd"));
     });
     srv.registerMethod("project.archived", () => host.listArchivedProjects());
     srv.registerMethod("project.delete", (params) => {
-      const cwd = requireString(params?.cwd, "cwd");
-      return host.deleteArchivedProject(cwd);
+      const { cwd, dirKey } = params ?? {};
+      if (typeof dirKey === "string" && dirKey) return host.deleteArchivedProjectByDir(dirKey);
+      return host.deleteArchivedProject(requireString(cwd, "cwd"));
     });
     srv.registerMethod("project.roots", () => {
       const home = homedir2();
       const places = [
         { name: "Home", path: home, isDirectory: true },
-        { name: "Root", path: sep2, isDirectory: true }
+        { name: "Root", path: sep3, isDirectory: true }
       ];
       const candidates = ["Desktop", "Downloads", "Documents", "Pictures", "Music", "Videos"];
       for (const name of candidates) {
@@ -7382,6 +7580,10 @@ async function runDaemon() {
       const { sessionId } = params ?? {};
       return host.listForkPoints(requireString(sessionId, "sessionId"));
     });
+    srv.registerMethod("session.fork", async (params) => {
+      const { sessionId, entryId } = params ?? {};
+      return host.forkSession(requireString(sessionId, "sessionId"), requireString(entryId, "entryId"));
+    });
     srv.registerMethod("session.tree", (params) => {
       const { sessionId } = params ?? {};
       return host.getSessionTree(requireString(sessionId, "sessionId"));
@@ -7484,9 +7686,12 @@ async function runDaemon() {
     wsHost.broadcast(event);
   });
   let shuttingDown = false;
-  const shutdown = () => {
+  const shutdown = (signal) => {
     if (shuttingDown) return;
     shuttingDown = true;
+    process.stderr.write(`vagus: daemon shutting down (${signal})
+${new Error("shutdown trace").stack}
+`);
     void (async () => {
       try {
         wsHost.close();
@@ -7497,11 +7702,27 @@ async function runDaemon() {
       }
     })();
   };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("beforeExit", (code) => {
+    process.stderr.write(`vagus: daemon beforeExit (event loop empty), code=${code}
+`);
+  });
+  process.on("exit", (code) => {
+    process.stderr.write(`vagus: daemon exit, code=${code}
+`);
+  });
   transport.start();
   process.stderr.write(`pi-web daemon ready (state: ${stateDir})
 `);
+  process.on("uncaughtException", (err) => {
+    process.stderr.write(`vagus: uncaught exception: ${err?.stack ?? String(err)}
+`);
+  });
+  process.on("unhandledRejection", (reason) => {
+    process.stderr.write(`vagus: unhandled rejection: ${reason instanceof Error ? reason.stack ?? reason.message : String(reason)}
+`);
+  });
   return new Promise(() => {
   });
 }
@@ -7514,8 +7735,38 @@ import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // apps/cli/src/daemon.ts
 import { spawn } from "node:child_process";
+import { execSync } from "node:child_process";
 import { existsSync as existsSync7 } from "node:fs";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
+function detectSystemProxy() {
+  try {
+    if (process.platform === "win32") {
+      const key = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings";
+      const out = execSync(`reg query "${key}" /v ProxyEnable`, { encoding: "utf8", timeout: 2e3 });
+      if (!/0x1/.test(out)) return void 0;
+      const srv = execSync(`reg query "${key}" /v ProxyServer`, { encoding: "utf8", timeout: 2e3 });
+      const m = srv.match(/ProxyServer\s+REG_SZ\s+(\S+)/);
+      if (!m?.[1]) return void 0;
+      let addr;
+      if (m[1].includes("=")) {
+        const https = m[1].split(";").find((p) => p.startsWith("https="));
+        addr = (https ?? m[1].split(";")[0])?.split("=")[1] || void 0;
+      } else {
+        addr = m[1];
+      }
+      return addr && /^https?:\/\//.test(addr) ? addr : addr ? `http://${addr}` : void 0;
+    }
+    if (process.platform === "darwin") {
+      const out = execSync("scutil --proxy", { encoding: "utf8", timeout: 2e3 });
+      const enabled = /HTTPSEnable\s*:\s*1/.test(out);
+      const host = out.match(/HTTPSProxy\s*:\s*(\S+)/)?.[1];
+      const port = out.match(/HTTPSPort\s*:\s*(\d+)/)?.[1];
+      return enabled && host && port ? `http://${host}:${port}` : void 0;
+    }
+  } catch {
+  }
+  return void 0;
+}
 function daemonEntryPath() {
   const base = fileURLToPath2(new URL("./bin", import.meta.url));
   const source = `${base}.ts`;
@@ -7524,9 +7775,27 @@ function daemonEntryPath() {
 function spawnDaemon(options = {}) {
   const entry = daemonEntryPath();
   const args = entry.endsWith(".ts") ? ["--import", "tsx", entry, "daemon"] : [entry, "daemon"];
+  const injected = {};
+  injected.NODE_USE_ENV_PROXY = "1";
+  if (!process.env.HTTPS_PROXY && !process.env.HTTP_PROXY) {
+    const sysProxy = detectSystemProxy();
+    if (sysProxy) {
+      injected.HTTPS_PROXY = sysProxy;
+      injected.HTTP_PROXY = sysProxy;
+      injected.NO_PROXY = process.env.NO_PROXY ?? "localhost,127.0.0.1";
+      process.stderr.write(`vagus: following system proxy \u2192 ${sysProxy}
+`);
+    } else {
+      process.stderr.write(`vagus: no system proxy detected (direct connections)
+`);
+    }
+  } else if (process.env.HTTPS_PROXY || process.env.HTTP_PROXY) {
+    process.stderr.write(`vagus: proxy env already set (HTTPS_PROXY=${process.env.HTTPS_PROXY ?? process.env.HTTP_PROXY})
+`);
+  }
   return spawn(process.execPath, args, {
     stdio: options.stdio ?? ["pipe", "pipe", "pipe"],
-    env: { ...process.env, ...options.env }
+    env: { ...process.env, ...injected, ...options.env }
   });
 }
 
@@ -7579,6 +7848,9 @@ async function runWeb() {
   child.on("exit", (code, signal) => {
     if (!opened && code !== 0) {
       process.stderr.write(`pi-web: daemon exited (code ${code ?? "?"}, signal ${signal ?? "none"}) before the UI was ready.
+`);
+    } else {
+      process.stderr.write(`pi-web: daemon exited (code ${code ?? "?"}, signal ${signal ?? "none"}).
 `);
     }
     process.exit(code ?? 0);