contextswitch 0.1.5 → 0.1.7

package/dist/{chunk-756VUR5T.js → chunk-GBKMEML7.js}

@@ -1,9 +1,10 @@
 import {
+  debug,
   paths
-} from "./chunk-A7YXSI66.js";
+} from "./chunk-F36TGFK2.js";
 
 // src/core/process.ts
-import { execSync, spawn } from "child_process";
+import { execFileSync, execSync, spawn } from "child_process";
 import { platform } from "os";
 import { existsSync, readFileSync, writeFileSync, unlinkSync } from "fs";
 import { join } from "path";
@@ -47,9 +48,11 @@ var ProcessManager = class {
         const basename = command.split("/").pop() || "";
         const isClaudeBinary = basename === "claude" || basename === "claude.exe";
         if (isClaudeBinary) {
+          debug("process", `Found Claude process: PID=${pid} cmd=${command} args=${args.join(" ")}`);
           processes.push({ pid, command, args });
         }
       }
+      debug("process", `Unix process scan found ${processes.length} Claude process(es)`);
       return processes;
     } catch (error) {
       console.error(`Unix process detection failed: ${error}`);
@@ -73,11 +76,17 @@ var ProcessManager = class {
         const match = line.match(/^"?(\d+)"?,"?(.*?)"?$/);
         if (match) {
           const pid = parseInt(match[1], 10);
+          if (!Number.isInteger(pid) || pid <= 0) continue;
           const commandLine = match[2] || "";
-          if (commandLine.includes("claude") && !commandLine.includes("cs switch")) {
+          if (commandLine.includes("cs switch")) continue;
+          const exe = commandLine.split(/[\s"]+/)[0] || "";
+          const bin = exe.split(/[/\\]/).pop() || "";
+          const isClaudeBinary = bin === "claude" || bin === "claude.exe";
+          if (isClaudeBinary) {
+            debug("process", `Found Claude process: PID=${pid} cmd=${commandLine}`);
             processes.push({
               pid,
-              command: "claude",
+              command: exe,
               args: commandLine.split(" ").slice(1)
             });
           }
@@ -93,6 +102,10 @@ var ProcessManager = class {
    * Kill a process by PID
    */
   killProcess(pid, force = false) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+      debug("process", `Invalid PID: ${pid}`);
+      return false;
+    }
     try {
       if (this.platform === "win32") {
         const flag = force ? "/F" : "";
@@ -114,124 +127,119 @@ var ProcessManager = class {
     if (processes.length === 0) {
       return;
     }
+    debug("process", `Found ${processes.length} Claude process(es) to terminate`);
     console.log(`Found ${processes.length} Claude process(es) to terminate`);
     for (const proc of processes) {
+      debug("process", `Sending SIGTERM to PID ${proc.pid}`);
       this.killProcess(proc.pid, false);
     }
     await new Promise((resolve) => setTimeout(resolve, Math.min(timeout, 1e3)));
     const remaining = this.findClaudeProcesses();
     for (const proc of remaining) {
+      debug("process", `Force killing PID ${proc.pid} (still alive after grace period)`);
       console.log(`Force killing process ${proc.pid}`);
       this.killProcess(proc.pid, true);
     }
   }
   /**
-   * Spawn Claude with specific arguments
+   * Spawn a shell script in a terminal.
+   * @param mode - 'window' (new window), 'tab' (new tab), or 'inline' (current terminal)
    */
-  spawnClaude(args, options) {
-    const claudeCmd = this.findClaudeExecutable();
-    if (!claudeCmd) {
-      throw new Error("Claude CLI not found. Please ensure it is installed and in your PATH.");
+  spawnTerminalScript(script, _cwd, mode = "window") {
+    const scriptFile = join(paths.baseDir, `launch-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.sh`);
+    debug("process", `Writing launch script to ${scriptFile} (mode: ${mode})`);
+    debug("process", `Script contents:
+${script}`);
+    writeFileSync(scriptFile, script, { mode: 493 });
+    if (mode === "inline") {
+      debug("process", "Running inline \u2014 taking over current terminal");
+      try {
+        execFileSync("bash", [scriptFile], { stdio: "inherit" });
+      } catch {
+      }
+      return 0;
     }
     if (this.platform === "darwin") {
-      const cwd = options?.cwd || process.cwd();
-      const claudeCommand = `cd "${cwd}" && ${claudeCmd} ${args.join(" ")}`;
-      const script = `tell app "Terminal" to do script "${claudeCommand.replace(/"/g, '\\"')}"`;
-      const terminalProcess = spawn("osascript", ["-e", script], {
+      const escapedPath = scriptFile.replace(/"/g, '\\"');
+      let appleScript;
+      if (mode === "tab") {
+        appleScript = [
+          'tell application "Terminal"',
+          "  activate",
+          `  tell application "System Events" to keystroke "t" using command down`,
+          `  do script "bash \\"${escapedPath}\\"" in front window`,
+          "end tell"
+        ].join("\n");
+      } else {
+        appleScript = `tell app "Terminal" to do script "bash \\"${escapedPath}\\""`;
+      }
+      const proc2 = spawn("osascript", ["-e", appleScript], {
         detached: true,
         stdio: "ignore"
       });
-      terminalProcess.unref();
-      return terminalProcess.pid || 0;
+      proc2.unref();
+      return proc2.pid || 0;
     }
     if (this.platform === "linux") {
-      const cwd = options?.cwd || process.cwd();
-      const claudeCommand = `${claudeCmd} ${args.join(" ")}`;
+      const tabFlag = mode === "tab";
       const terminals = ["gnome-terminal", "xterm", "konsole", "xfce4-terminal"];
       for (const term of terminals) {
         try {
-          const termProcess = spawn(term, ["--", "bash", "-c", `cd "${cwd}" && ${claudeCommand}`], {
+          const args = term === "gnome-terminal" && tabFlag ? ["--tab", "--", "bash", scriptFile] : ["--", "bash", scriptFile];
+          const proc2 = spawn(term, args, {
             detached: true,
             stdio: "ignore"
           });
-          termProcess.unref();
-          return termProcess.pid || 0;
+          proc2.unref();
+          return proc2.pid || 0;
         } catch {
         }
       }
     }
     if (this.platform === "win32") {
-      const cwd = options?.cwd || process.cwd();
-      const gitBash = this.findGitBash();
-      if (gitBash) {
-        const claudeCommand = `cd "${String(cwd).replace(/\\/g, "/")}" && ${claudeCmd} ${args.join(" ")}`;
-        const cmdProcess = spawn("cmd.exe", ["/c", "start", "", gitBash, "-c", claudeCommand], {
+      const psScriptFile = scriptFile.replace(/\.sh$/, ".ps1");
+      const psScript = this.convertToPowerShell(script);
+      writeFileSync(psScriptFile, psScript, { mode: 493 });
+      debug("process", `PowerShell script:
+${psScript}`);
+      const useTab = mode === "tab";
+      try {
+        const wtArgs = useTab ? ["-w", "0", "nt", "powershell", "-ExecutionPolicy", "Bypass", "-File", psScriptFile] : ["powershell", "-ExecutionPolicy", "Bypass", "-File", psScriptFile];
+        const proc2 = spawn("wt.exe", wtArgs, {
           detached: true,
           stdio: "ignore",
           windowsHide: false
         });
-        cmdProcess.unref();
-        return cmdProcess.pid || 0;
-      } else {
-        const claudeCommand = `cd /d "${cwd}" && ${claudeCmd} ${args.join(" ")}`;
-        const cmdProcess = spawn("cmd.exe", ["/c", "start", "cmd.exe", "/k", claudeCommand], {
+        proc2.unref();
+        debug("process", "Launched via Windows Terminal (wt.exe)");
+        return proc2.pid || 0;
+      } catch {
+        debug("process", "Windows Terminal not available, falling back");
+      }
+      try {
+        const proc2 = spawn("cmd.exe", ["/c", "start", "powershell", "-ExecutionPolicy", "Bypass", "-File", psScriptFile], {
           detached: true,
           stdio: "ignore",
           windowsHide: false
         });
-        cmdProcess.unref();
-        return cmdProcess.pid || 0;
-      }
-    }
-    const claudeProcess = spawn(claudeCmd, args, {
-      detached: true,
-      stdio: "ignore",
-      ...options
-    });
-    claudeProcess.unref();
-    return claudeProcess.pid || 0;
-  }
-  /**
-   * Spawn a shell script in a new terminal window
-   */
-  spawnTerminalScript(script, _cwd) {
-    const scriptFile = join(paths.baseDir, "launch.sh");
-    writeFileSync(scriptFile, script, { mode: 493 });
-    if (this.platform === "darwin") {
-      const escapedPath = scriptFile.replace(/"/g, '\\"');
-      const appleScript = `tell app "Terminal" to do script "bash \\"${escapedPath}\\""`;
-      const proc2 = spawn("osascript", ["-e", appleScript], {
-        detached: true,
-        stdio: "ignore"
-      });
-      proc2.unref();
-      return proc2.pid || 0;
-    }
-    if (this.platform === "linux") {
-      const terminals = ["gnome-terminal", "xterm", "konsole", "xfce4-terminal"];
-      for (const term of terminals) {
-        try {
-          const proc2 = spawn(term, ["--", "bash", scriptFile], {
-            detached: true,
-            stdio: "ignore"
-          });
-          proc2.unref();
-          return proc2.pid || 0;
-        } catch {
-        }
+        proc2.unref();
+        debug("process", "Launched via PowerShell (cmd start)");
+        return proc2.pid || 0;
+      } catch {
+        debug("process", "PowerShell launch failed, trying Git Bash");
       }
-    }
-    if (this.platform === "win32") {
       const gitBash = this.findGitBash();
-      const bashCmd = gitBash || "bash";
-      const scriptPath = scriptFile.replace(/\\/g, "/");
-      const proc2 = spawn("cmd.exe", ["/c", "start", "", bashCmd, scriptPath], {
-        detached: true,
-        stdio: "ignore",
-        windowsHide: false
-      });
-      proc2.unref();
-      return proc2.pid || 0;
+      if (gitBash) {
+        const scriptPath = scriptFile.replace(/\\/g, "/");
+        const proc2 = spawn("cmd.exe", ["/c", "start", "", gitBash, scriptPath], {
+          detached: true,
+          stdio: "ignore",
+          windowsHide: false
+        });
+        proc2.unref();
+        debug("process", "Launched via Git Bash");
+        return proc2.pid || 0;
+      }
     }
     const proc = spawn("bash", [scriptFile], {
       detached: true,
@@ -249,6 +257,114 @@ var ProcessManager = class {
   /**
    * Find Git Bash executable on Windows
    */
+  /**
+   * Convert a simple bash launch script to PowerShell.
+   * Handles: cd, export, exec, echo, if/fi, and comments.
+   */
+  convertToPowerShell(bashScript) {
+    const lines = bashScript.split("\n");
+    const psLines = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("#!/")) continue;
+      if (trimmed.startsWith("#")) {
+        psLines.push(trimmed);
+        continue;
+      }
+      if (trimmed === "") {
+        psLines.push("");
+        continue;
+      }
+      const cdMatch = trimmed.match(/^cd\s+(.+)$/);
+      if (cdMatch) {
+        const dir = cdMatch[1].replace(/^'|'$/g, "").replace(/'\\''/g, "'");
+        psLines.push(`Set-Location "${dir}"`);
+        continue;
+      }
+      const exportMatch = trimmed.match(/^export\s+([A-Za-z_][A-Za-z0-9_]*)="(.*)"$/);
+      if (exportMatch) {
+        psLines.push(`$env:${exportMatch[1]} = "${exportMatch[2]}"`);
+        continue;
+      }
+      if (trimmed.startsWith("exec ")) {
+        const cmd = trimmed.slice(5);
+        const parts = this.parseBashCommand(cmd);
+        psLines.push(`& ${parts.map((p) => `"${p}"`).join(" ")}`);
+        continue;
+      }
+      if (trimmed.startsWith("echo ")) {
+        const msg = trimmed.slice(5).replace(/^"|"$/g, "").replace(/^'|'$/g, "");
+        psLines.push(`Write-Host "${msg}"`);
+        continue;
+      }
+      if (trimmed.match(/^if\s+\[.*\];\s*then$/)) {
+        psLines.push("if ($LASTEXITCODE -ne 0) {");
+        continue;
+      }
+      if (trimmed === "fi") {
+        psLines.push("}");
+        continue;
+      }
+      if (trimmed === "RESUME_EXIT=$?") {
+        psLines.push("# Exit code captured automatically as $LASTEXITCODE");
+        continue;
+      }
+      const cmdLine = trimmed;
+      if (cmdLine.match(/^'?[A-Za-z\/\\:]/)) {
+        const parts = this.parseBashCommand(cmdLine);
+        psLines.push(`& ${parts.map((p) => `"${p}"`).join(" ")}`);
+        continue;
+      }
+      psLines.push(`# ${trimmed}`);
+    }
+    return psLines.join("\r\n");
+  }
+  /**
+   * Parse a bash command with shell-escaped single-quoted arguments into parts.
+   */
+  parseBashCommand(cmd) {
+    const parts = [];
+    let current = "";
+    let inSingleQuote = false;
+    let i = 0;
+    while (i < cmd.length) {
+      const ch = cmd[i];
+      if (inSingleQuote) {
+        if (ch === "'") {
+          if (cmd.slice(i, i + 4) === "'\\''") {
+            current += "'";
+            i += 4;
+            continue;
+          }
+          inSingleQuote = false;
+          i++;
+          continue;
+        }
+        current += ch;
+        i++;
+      } else {
+        if (ch === "'") {
+          inSingleQuote = true;
+          i++;
+          continue;
+        }
+        if (ch === " " || ch === "	") {
+          if (current.length > 0) {
+            parts.push(current);
+            current = "";
+          }
+          i++;
+          continue;
+        }
+        current += ch;
+        i++;
+      }
+    }
+    if (current.length > 0) {
+      parts.push(current);
+    }
+    return parts;
+  }
   findGitBash() {
     if (this.platform !== "win32") return null;
     const candidates = [
@@ -280,12 +396,15 @@ var ProcessManager = class {
       if (this.platform === "win32") {
         const output = execSync("where claude", { encoding: "utf-8" }).trim();
         const firstLine = output.split("\n")[0];
+        debug("process", `Found Claude via 'where': ${firstLine}`);
         return firstLine || null;
       } else {
         const output = execSync("which claude", { encoding: "utf-8" }).trim();
+        debug("process", `Found Claude via 'which': ${output}`);
         return output || null;
       }
     } catch {
+      debug("process", "Claude not found via PATH, checking common install locations");
       const commonPaths = this.platform === "win32" ? [
         join(process.env.LOCALAPPDATA || "", "Programs", "Claude Code", "claude.exe"),
         join(process.env.PROGRAMFILES || "C:\\Program Files", "Claude Code", "claude.exe"),
@@ -299,9 +418,11 @@ var ProcessManager = class {
       ];
       for (const candidatePath of commonPaths) {
         if (candidatePath && existsSync(candidatePath)) {
+          debug("process", `Found Claude at fallback path: ${candidatePath}`);
           return candidatePath;
         }
       }
+      debug("process", "Claude executable not found anywhere");
       return null;
     }
   }
@@ -340,6 +461,9 @@ var ProcessManager = class {
    * Check if a process is still running
    */
   isProcessRunning(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+      return false;
+    }
     try {
       if (this.platform === "win32") {
         const output = execSync(`tasklist /FI "PID eq ${pid}"`, { encoding: "utf-8" });

package/dist/{chunk-GHF4FLJV.js → chunk-GDWJEQJQ.js}

@@ -1,9 +1,9 @@
 import {
   configManager
-} from "./chunk-YMFZWGZO.js";
+} from "./chunk-72MK25T3.js";
 import {
   paths
-} from "./chunk-A7YXSI66.js";
+} from "./chunk-F36TGFK2.js";
 
 // src/commands/archive.ts
 import picocolors from "picocolors";
@@ -26,18 +26,18 @@ async function archiveCommand(domainName) {
     if (!existsSync(archiveDir)) {
       mkdirSync(archiveDir, { recursive: true });
     }
+    const domain = configManager.loadDomain(domainName);
     const timestamp = /* @__PURE__ */ new Date();
     const archiveMetadata = {
       domain: domainName,
       session,
       timestamp: timestamp.toISOString(),
-      config: configManager.loadDomain(domainName)
+      config: domain
     };
     const dateStr = timestamp.toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, -5);
     const archiveName = `${dateStr}.json`;
     const archivePath = join(archiveDir, archiveName);
     writeFileSync(archivePath, JSON.stringify(archiveMetadata, null, 2), "utf-8");
-    const domain = configManager.loadDomain(domainName);
     if (domain.claudeConfig?.memory) {
       const memoryArchiveDir = join(archiveDir, dateStr, "memory");
       mkdirSync(memoryArchiveDir, { recursive: true });
@@ -56,11 +56,10 @@ async function archiveCommand(domainName) {
     console.log(pc.green(`\u2705 Session archived successfully`));
     console.log(pc.gray(`Archive: ${archivePath}`));
     console.log(pc.gray(`Size: ${sizeKB} KB`));
-    const { SessionManager } = await import("./session-IWXAKW6Z.js");
+    const { SessionManager } = await import("./session-H5HPE5OT.js");
     console.log(pc.gray(`Session age: ${SessionManager.getSessionAge(session.started)}`));
   } catch (error) {
-    console.error(pc.red(`\u274C Failed to archive session: ${error}`));
-    process.exit(1);
+    throw new Error(`Failed to archive session: ${error}`);
   }
 }
 function listArchives(domainName) {

package/dist/{chunk-KBKALWDX.js → chunk-MGIXKKM6.js}

@@ -59,6 +59,9 @@ var SessionManager = class {
       return `${hours} hour${hours === 1 ? "" : "s"}`;
     }
     const minutes = Math.floor(diffMs / (1e3 * 60));
+    if (minutes === 0) {
+      return "just now";
+    }
     return `${minutes} minute${minutes === 1 ? "" : "s"}`;
   }
   /**