itwillsync 1.5.2 → 1.6.0

package/dist/hub/daemon.js

@@ -3649,10 +3649,11 @@ var require_websocket_server = __commonJS({
 });
 
 // src/daemon.ts
-import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, unlinkSync, existsSync as existsSync2, readdirSync, statSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join3, dirname as dirname2 } from "path";
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, unlinkSync, existsSync as existsSync3, readdirSync, statSync } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4, dirname as dirname3 } from "path";
 import { fileURLToPath } from "url";
+import { spawn } from "child_process";
 
 // src/auth.ts
 import { randomBytes, timingSafeEqual } from "crypto";
@@ -3840,6 +3841,25 @@ var SessionRegistry = class extends EventEmitter {
       this.healthCheckInterval = null;
     }
   }
+  /** Get deduplicated recent working directories from current + persisted sessions. */
+  getRecentDirectories() {
+    const dirMap = /* @__PURE__ */ new Map();
+    for (const s of this.sessions.values()) {
+      const existing = dirMap.get(s.cwd) ?? 0;
+      if (s.lastSeen > existing) {
+        dirMap.set(s.cwd, s.lastSeen);
+      }
+    }
+    if (this.store) {
+      for (const s of this.store.getAllSessions()) {
+        const existing = dirMap.get(s.cwd) ?? 0;
+        if (s.lastSeen > existing) {
+          dirMap.set(s.cwd, s.lastSeen);
+        }
+      }
+    }
+    return Array.from(dirMap.entries()).sort((a, b) => b[1] - a[1]).map(([cwd]) => cwd);
+  }
   clear() {
     const ids = Array.from(this.sessions.keys());
     this.sessions.clear();
@@ -3891,6 +3911,10 @@ var SessionStore = class {
       this.writeToDisk();
     }, 500);
   }
+  /** Get all persisted sessions (including ended). */
+  getAllSessions() {
+    return this.sessions;
+  }
   /** Flush any pending save immediately. */
   flush() {
     if (this.saveTimer) {
@@ -3923,6 +3947,58 @@ var SessionStore = class {
   }
 };
 
+// src/tool-history.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2, dirname as dirname2 } from "path";
+var MAX_ENTRIES = 20;
+function getHistoryPath() {
+  const dir = process.env.ITWILLSYNC_CONFIG_DIR || join2(homedir2(), ".itwillsync");
+  return join2(dir, "tool-history.json");
+}
+var ToolHistory = class {
+  tools = [];
+  constructor() {
+    this.load();
+  }
+  /** Get tool names sorted by most recently used. */
+  getTools() {
+    return this.tools.sort((a, b) => b.lastUsed - a.lastUsed).map((t) => t.name);
+  }
+  /** Record a tool usage (add or update lastUsed). */
+  recordUsage(toolName) {
+    const existing = this.tools.find((t) => t.name === toolName);
+    if (existing) {
+      existing.lastUsed = Date.now();
+    } else {
+      this.tools.push({ name: toolName, lastUsed: Date.now() });
+    }
+    if (this.tools.length > MAX_ENTRIES) {
+      this.tools.sort((a, b) => b.lastUsed - a.lastUsed);
+      this.tools = this.tools.slice(0, MAX_ENTRIES);
+    }
+    this.save();
+  }
+  load() {
+    const path = getHistoryPath();
+    if (!existsSync2(path)) return;
+    try {
+      const raw = readFileSync2(path, "utf-8");
+      const data = JSON.parse(raw);
+      if (Array.isArray(data.tools)) {
+        this.tools = data.tools;
+      }
+    } catch {
+    }
+  }
+  save() {
+    const path = getHistoryPath();
+    mkdirSync2(dirname2(path), { recursive: true });
+    const data = { tools: this.tools };
+    writeFileSync2(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  }
+};
+
 // src/internal-api.ts
 import { createServer } from "http";
 function createInternalApi(options) {
@@ -4100,8 +4176,9 @@ function readBody(req) {
 
 // src/server.ts
 import { createServer as createServer2 } from "http";
-import { readFile } from "fs/promises";
-import { join as join2, extname } from "path";
+import { readFile, readdir, stat, realpath } from "fs/promises";
+import { join as join3, extname } from "path";
+import { homedir as homedir3 } from "os";
 import { gzipSync } from "zlib";
 
 // ../../node_modules/.pnpm/ws@8.19.0/node_modules/ws/wrapper.mjs
@@ -4124,7 +4201,8 @@ var MIME_TYPES = {
 var COMPRESSIBLE = /* @__PURE__ */ new Set([".html", ".js", ".css", ".json", ".svg"]);
 var PING_INTERVAL_MS = 3e4;
 function createDashboardServer(options) {
-  const { registry, masterToken, dashboardPath, host, port, previewCollector } = options;
+  const { registry, masterToken, dashboardPath, host, port, previewCollector, toolHistory, onCreateSession } = options;
+  const homeDir = homedir3();
   const clients = /* @__PURE__ */ new Set();
   const aliveMap = /* @__PURE__ */ new WeakMap();
   const gzipCache = /* @__PURE__ */ new Map();
@@ -4171,10 +4249,49 @@ function createDashboardServer(options) {
       res.end(JSON.stringify({ sessions }));
       return;
     }
+    if (pathname === "/api/tool-history") {
+      const tools = toolHistory ? toolHistory.getTools() : [];
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ tools }));
+      return;
+    }
+    if (pathname === "/api/recent-dirs") {
+      const dirs = registry.getRecentDirectories();
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ dirs }));
+      return;
+    }
+    if (pathname === "/api/browse") {
+      const rawPath = url.searchParams.get("path") || "~";
+      const browsePath = rawPath.replace(/^~/, homeDir);
+      try {
+        const resolved = await realpath(browsePath);
+        if (!resolved.startsWith(homeDir)) {
+          res.writeHead(403, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Access denied" }));
+          return;
+        }
+        const dirStat = await stat(resolved);
+        if (!dirStat.isDirectory()) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Not a directory" }));
+          return;
+        }
+        const entries = await readdir(resolved, { withFileTypes: true });
+        const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort();
+        const displayPath = resolved.replace(homeDir, "~");
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ path: displayPath, resolvedPath: resolved, entries: dirs }));
+      } catch {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Cannot read directory" }));
+      }
+      return;
+    }
     await serveStaticFile(dashboardPath, pathname, req, res);
   });
   async function serveStaticFile(basePath, filePath, req, res) {
-    const fullPath = join2(basePath, filePath);
+    const fullPath = join3(basePath, filePath);
     const ext = extname(fullPath);
     const contentType = MIME_TYPES[ext] || "application/octet-stream";
     try {
@@ -4280,6 +4397,32 @@ function createDashboardServer(options) {
             }
             break;
           }
+          case "create-session": {
+            if (!onCreateSession) {
+              ws.send(JSON.stringify({ type: "session-create-error", error: "Session creation not available" }));
+              break;
+            }
+            const tool = (msg.tool || "").trim();
+            const rawCwd = (msg.cwd || "").trim();
+            if (!tool) {
+              ws.send(JSON.stringify({ type: "session-create-error", error: "Tool name is required" }));
+              break;
+            }
+            const cwd = rawCwd ? rawCwd.replace(/^~/, homeDir) : homeDir;
+            try {
+              const resolved = await realpath(cwd);
+              const dirStat = await stat(resolved);
+              if (!dirStat.isDirectory()) {
+                ws.send(JSON.stringify({ type: "session-create-error", error: "Not a directory" }));
+                break;
+              }
+              ws.send(JSON.stringify({ type: "session-creating", tool, cwd: rawCwd || "~" }));
+              onCreateSession(tool, resolved);
+            } catch (err) {
+              ws.send(JSON.stringify({ type: "session-create-error", error: err.message }));
+            }
+            break;
+          }
           case "get-metadata": {
             const session = registry.getById(msg.sessionId);
             if (!session) {
@@ -4549,20 +4692,33 @@ var HUB_EXTERNAL_PORT = 7962;
 var HUB_INTERNAL_PORT = 7963;
 var AUTO_SHUTDOWN_DELAY_MS = 3e4;
 function getHubDir() {
-  return process.env.ITWILLSYNC_CONFIG_DIR || join3(homedir2(), ".itwillsync");
+  return process.env.ITWILLSYNC_CONFIG_DIR || join4(homedir4(), ".itwillsync");
 }
 function getPidPath() {
-  return join3(getHubDir(), "hub.pid");
+  return join4(getHubDir(), "hub.pid");
 }
 function getHubConfigPath() {
-  return join3(getHubDir(), "hub.json");
+  return join4(getHubDir(), "hub.json");
+}
+function isValidToolName(tool) {
+  return /^[a-zA-Z0-9._-]+$/.test(tool) && tool.length > 0 && tool.length <= 100;
+}
+function spawnSession(tool, cwd, cliEntryPath) {
+  const child = spawn(process.execPath, [cliEntryPath, "--headless", "--", tool], {
+    cwd,
+    stdio: "ignore",
+    detached: true,
+    env: { ...process.env }
+  });
+  child.unref();
+  return child;
 }
 async function main() {
   const hubDir = getHubDir();
-  mkdirSync2(hubDir, { recursive: true });
+  mkdirSync3(hubDir, { recursive: true });
   const masterToken = generateToken();
   const startedAt = Date.now();
-  writeFileSync2(getPidPath(), String(process.pid), "utf-8");
+  writeFileSync3(getPidPath(), String(process.pid), "utf-8");
   const hubConfig = {
     masterToken,
     externalPort: HUB_EXTERNAL_PORT,
@@ -4570,28 +4726,30 @@ async function main() {
     pid: process.pid,
     startedAt
   };
-  writeFileSync2(getHubConfigPath(), JSON.stringify(hubConfig, null, 2) + "\n", "utf-8");
+  writeFileSync3(getHubConfigPath(), JSON.stringify(hubConfig, null, 2) + "\n", "utf-8");
   const sessionStore = new SessionStore();
   const registry = new SessionRegistry({ store: sessionStore });
   registry.startHealthChecks();
-  const logsDir = join3(hubDir, "logs");
-  if (existsSync2(logsDir)) {
+  const toolHistory = new ToolHistory();
+  const logsDir = join4(hubDir, "logs");
+  if (existsSync3(logsDir)) {
     const retentionMs = 30 * 864e5;
     const cutoff = Date.now() - retentionMs;
     try {
       for (const file of readdirSync(logsDir)) {
-        const filePath = join3(logsDir, file);
+        const filePath = join4(logsDir, file);
         try {
-          const stat = statSync(filePath);
-          if (stat.mtimeMs < cutoff) unlinkSync(filePath);
+          const stat2 = statSync(filePath);
+          if (stat2.mtimeMs < cutoff) unlinkSync(filePath);
         } catch {
         }
       }
     } catch {
     }
   }
-  const __dirname = dirname2(fileURLToPath(import.meta.url));
-  const dashboardPath = join3(__dirname, "dashboard");
+  const __dirname = dirname3(fileURLToPath(import.meta.url));
+  const dashboardPath = join4(__dirname, "dashboard");
+  const cliEntryPath = join4(__dirname, "..", "index.js");
   const internalApi = createInternalApi({
     registry,
     port: HUB_INTERNAL_PORT
@@ -4603,7 +4761,15 @@ async function main() {
     dashboardPath,
     host: "0.0.0.0",
     port: HUB_EXTERNAL_PORT,
-    previewCollector
+    previewCollector,
+    toolHistory,
+    onCreateSession: (tool, cwd) => {
+      if (!isValidToolName(tool)) {
+        throw new Error(`Invalid tool name: ${tool}`);
+      }
+      toolHistory.recordUsage(tool);
+      spawnSession(tool, cwd, cliEntryPath);
+    }
   });
   await Promise.all([
     internalApi.listen(),