myrlin-workbook 0.9.5 → 0.9.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myrlin-workbook",
-  "version": "0.9.5",
+  "version": "0.9.7",
   "description": "Browser-based project manager for Claude Code sessions - session discovery, multi-terminal, cost tracking, docs, and kanban board",
   "main": "src/index.js",
   "bin": {

package/src/core/session-manager.js

@@ -1,183 +1,184 @@
-/**
- * Session Manager - Manages Claude Code session lifecycle
- * Handles launching, stopping, and restarting session processes.
- * Supports Windows (cmd.exe), macOS, and Linux/WSL.
- */
-
-const { spawn } = require('child_process');
-const { getStore } = require('../state/store');
-
-/**
- * Allowlist of known-safe login shells.
- * Used to validate process.env.SHELL on non-Windows platforms to prevent
- * arbitrary binary execution if the environment is compromised.
- */
-const ALLOWED_SHELLS = [
-  '/bin/bash', '/usr/bin/bash',
-  '/bin/sh', '/usr/bin/sh',
-  '/bin/zsh', '/usr/bin/zsh',
-  '/bin/fish', '/usr/bin/fish',
-  '/bin/dash', '/usr/bin/dash',
-  '/bin/ash',
-];
-
-/**
- * Get a safe shell path for the current platform.
- * Validates process.env.SHELL against an allowlist; falls back to /bin/bash.
- * @returns {string} Absolute path to a safe shell binary
- */
-function getSafeShell() {
-  const envShell = process.env.SHELL;
-  if (envShell && ALLOWED_SHELLS.includes(envShell)) {
-    return envShell;
-  }
-  return '/bin/bash';
-}
-
-/**
- * Launch a Claude Code session by spawning a new detached process.
- * On Windows, opens a new cmd.exe console window.
- * On Linux/macOS, spawns a detached shell process (primarily used by TUI;
- * the web GUI uses PTY terminals via pty-manager.js instead).
- * Updates the store with the new PID and sets status to 'running'.
- * @param {string} sessionId - The session ID to launch
- * @returns {{ success: boolean, pid?: number, error?: string }}
- */
-function launchSession(sessionId) {
-  const store = getStore();
-  const session = store.getSession(sessionId);
-
-  if (!session) {
-    return { success: false, error: `Session ${sessionId} not found` };
-  }
-
-  if (session.status === 'running' && session.pid) {
-    return { success: false, error: `Session ${sessionId} is already running (PID: ${session.pid})` };
-  }
-
-  try {
-    const baseCommand = session.command || 'claude';
-    const bypassFlag = session.bypassPermissions ? ' --dangerously-skip-permissions' : '';
-    const command = baseCommand + bypassFlag;
-    const workingDir = session.workingDir || process.cwd();
-
-    let child;
-    if (process.platform === 'win32') {
-      // Windows: open a new console window via `cmd /c start cmd /k`
-      child = spawn('cmd', ['/c', 'start', 'cmd', '/k', command], {
-        detached: true,
-        stdio: 'ignore',
-        cwd: workingDir,
-        shell: false,
-      });
-    } else {
-      // Linux/macOS/WSL: spawn a detached login shell
-      // Note: without a TTY, interactive CLI tools will exit immediately.
-      // The web GUI uses pty-manager.js (with a real PTY) for terminal sessions.
-      // This code path is kept for TUI compatibility and headless/scripted launches.
-      const shell = getSafeShell();
-      child = spawn(shell, ['-l', '-c', command], {
-        detached: true,
-        stdio: 'ignore',
-        cwd: workingDir,
-      });
-    }
-
-    const pid = child.pid;
-
-    // Unref so the parent process can exit independently
-    child.unref();
-
-    store.updateSessionStatus(sessionId, 'running', pid);
-    store.addSessionLog(sessionId, `Session launched with PID ${pid} (command: ${command})`);
-
-    return { success: true, pid, process: child };
-  } catch (err) {
-    store.updateSessionStatus(sessionId, 'error', null);
-    store.addSessionLog(sessionId, `Failed to launch session: ${err.message}`);
-    return { success: false, error: err.message };
-  }
-}
-
-/**
- * Stop a running session by killing its process.
- * Updates the store status to 'stopped'.
- * @param {string} sessionId - The session ID to stop
- * @returns {{ success: boolean, error?: string }}
- */
-function stopSession(sessionId) {
-  const store = getStore();
-  const session = store.getSession(sessionId);
-
-  if (!session) {
-    return { success: false, error: `Session ${sessionId} not found` };
-  }
-
-  if (session.status !== 'running' || !session.pid) {
-    store.updateSessionStatus(sessionId, 'stopped', null);
-    return { success: true };
-  }
-
-  try {
-    process.kill(session.pid);
-    store.updateSessionStatus(sessionId, 'stopped', null);
-    store.addSessionLog(sessionId, `Session stopped (PID ${session.pid} killed)`);
-    return { success: true };
-  } catch (err) {
-    // Process may already be dead - that's fine, mark as stopped anyway
-    store.updateSessionStatus(sessionId, 'stopped', null);
-    store.addSessionLog(sessionId, `Session stop - process already exited (${err.message})`);
-    return { success: true };
-  }
-}
-
-/**
- * Restart a session by stopping it first, then relaunching.
- * @param {string} sessionId - The session ID to restart
- * @returns {{ success: boolean, pid?: number, error?: string }}
- */
-function restartSession(sessionId) {
-  const store = getStore();
-  const session = store.getSession(sessionId);
-
-  if (!session) {
-    return { success: false, error: `Session ${sessionId} not found` };
-  }
-
-  store.addSessionLog(sessionId, 'Restarting session...');
-
-  const stopResult = stopSession(sessionId);
-  if (!stopResult.success) {
-    return { success: false, error: `Failed to stop before restart: ${stopResult.error}` };
-  }
-
-  return launchSession(sessionId);
-}
-
-/**
- * Get process info for a session.
- * @param {string} sessionId - The session ID
- * @returns {{ pid: number|null, status: string, command: string }|null}
- */
-function getSessionProcess(sessionId) {
-  const store = getStore();
-  const session = store.getSession(sessionId);
-
-  if (!session) {
-    return null;
-  }
-
-  return {
-    pid: session.pid,
-    status: session.status,
-    command: session.command || 'claude',
-    workingDir: session.workingDir || '',
-  };
-}
-
-module.exports = {
-  launchSession,
-  stopSession,
-  restartSession,
-  getSessionProcess,
-};
+/**
+ * Session Manager - Manages Claude Code session lifecycle
+ * Handles launching, stopping, and restarting session processes.
+ * Supports Windows (cmd.exe), macOS, and Linux/WSL.
+ */
+
+const { spawn } = require('child_process');
+const { getStore } = require('../state/store');
+const { expandHome } = require('../utils/path-utils');
+
+/**
+ * Allowlist of known-safe login shells.
+ * Used to validate process.env.SHELL on non-Windows platforms to prevent
+ * arbitrary binary execution if the environment is compromised.
+ */
+const ALLOWED_SHELLS = [
+  '/bin/bash', '/usr/bin/bash',
+  '/bin/sh', '/usr/bin/sh',
+  '/bin/zsh', '/usr/bin/zsh',
+  '/bin/fish', '/usr/bin/fish',
+  '/bin/dash', '/usr/bin/dash',
+  '/bin/ash',
+];
+
+/**
+ * Get a safe shell path for the current platform.
+ * Validates process.env.SHELL against an allowlist; falls back to /bin/bash.
+ * @returns {string} Absolute path to a safe shell binary
+ */
+function getSafeShell() {
+  const envShell = process.env.SHELL;
+  if (envShell && ALLOWED_SHELLS.includes(envShell)) {
+    return envShell;
+  }
+  return '/bin/bash';
+}
+
+/**
+ * Launch a Claude Code session by spawning a new detached process.
+ * On Windows, opens a new cmd.exe console window.
+ * On Linux/macOS, spawns a detached shell process (primarily used by TUI;
+ * the web GUI uses PTY terminals via pty-manager.js instead).
+ * Updates the store with the new PID and sets status to 'running'.
+ * @param {string} sessionId - The session ID to launch
+ * @returns {{ success: boolean, pid?: number, error?: string }}
+ */
+function launchSession(sessionId) {
+  const store = getStore();
+  const session = store.getSession(sessionId);
+
+  if (!session) {
+    return { success: false, error: `Session ${sessionId} not found` };
+  }
+
+  if (session.status === 'running' && session.pid) {
+    return { success: false, error: `Session ${sessionId} is already running (PID: ${session.pid})` };
+  }
+
+  try {
+    const baseCommand = session.command || 'claude';
+    const bypassFlag = session.bypassPermissions ? ' --dangerously-skip-permissions' : '';
+    const command = baseCommand + bypassFlag;
+    const workingDir = expandHome(session.workingDir) || process.cwd();
+
+    let child;
+    if (process.platform === 'win32') {
+      // Windows: open a new console window via `cmd /c start cmd /k`
+      child = spawn('cmd', ['/c', 'start', 'cmd', '/k', command], {
+        detached: true,
+        stdio: 'ignore',
+        cwd: workingDir,
+        shell: false,
+      });
+    } else {
+      // Linux/macOS/WSL: spawn a detached login shell
+      // Note: without a TTY, interactive CLI tools will exit immediately.
+      // The web GUI uses pty-manager.js (with a real PTY) for terminal sessions.
+      // This code path is kept for TUI compatibility and headless/scripted launches.
+      const shell = getSafeShell();
+      child = spawn(shell, ['-l', '-c', command], {
+        detached: true,
+        stdio: 'ignore',
+        cwd: workingDir,
+      });
+    }
+
+    const pid = child.pid;
+
+    // Unref so the parent process can exit independently
+    child.unref();
+
+    store.updateSessionStatus(sessionId, 'running', pid);
+    store.addSessionLog(sessionId, `Session launched with PID ${pid} (command: ${command})`);
+
+    return { success: true, pid, process: child };
+  } catch (err) {
+    store.updateSessionStatus(sessionId, 'error', null);
+    store.addSessionLog(sessionId, `Failed to launch session: ${err.message}`);
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * Stop a running session by killing its process.
+ * Updates the store status to 'stopped'.
+ * @param {string} sessionId - The session ID to stop
+ * @returns {{ success: boolean, error?: string }}
+ */
+function stopSession(sessionId) {
+  const store = getStore();
+  const session = store.getSession(sessionId);
+
+  if (!session) {
+    return { success: false, error: `Session ${sessionId} not found` };
+  }
+
+  if (session.status !== 'running' || !session.pid) {
+    store.updateSessionStatus(sessionId, 'stopped', null);
+    return { success: true };
+  }
+
+  try {
+    process.kill(session.pid);
+    store.updateSessionStatus(sessionId, 'stopped', null);
+    store.addSessionLog(sessionId, `Session stopped (PID ${session.pid} killed)`);
+    return { success: true };
+  } catch (err) {
+    // Process may already be dead - that's fine, mark as stopped anyway
+    store.updateSessionStatus(sessionId, 'stopped', null);
+    store.addSessionLog(sessionId, `Session stop - process already exited (${err.message})`);
+    return { success: true };
+  }
+}
+
+/**
+ * Restart a session by stopping it first, then relaunching.
+ * @param {string} sessionId - The session ID to restart
+ * @returns {{ success: boolean, pid?: number, error?: string }}
+ */
+function restartSession(sessionId) {
+  const store = getStore();
+  const session = store.getSession(sessionId);
+
+  if (!session) {
+    return { success: false, error: `Session ${sessionId} not found` };
+  }
+
+  store.addSessionLog(sessionId, 'Restarting session...');
+
+  const stopResult = stopSession(sessionId);
+  if (!stopResult.success) {
+    return { success: false, error: `Failed to stop before restart: ${stopResult.error}` };
+  }
+
+  return launchSession(sessionId);
+}
+
+/**
+ * Get process info for a session.
+ * @param {string} sessionId - The session ID
+ * @returns {{ pid: number|null, status: string, command: string }|null}
+ */
+function getSessionProcess(sessionId) {
+  const store = getStore();
+  const session = store.getSession(sessionId);
+
+  if (!session) {
+    return null;
+  }
+
+  return {
+    pid: session.pid,
+    status: session.status,
+    command: session.command || 'claude',
+    workingDir: session.workingDir || '',
+  };
+}
+
+module.exports = {
+  launchSession,
+  stopSession,
+  restartSession,
+  getSessionProcess,
+};

package/src/state/store.js

@@ -9,6 +9,7 @@ const path = require('path');
 const crypto = require('crypto');
 const { EventEmitter } = require('events');
 const docsManager = require('./docs-manager');
+const { expandHome } = require('../utils/path-utils');
 
 const STATE_DIR = path.join(__dirname, '..', '..', 'state');
 const BACKUP_DIR = path.join(STATE_DIR, 'backups');
@@ -320,7 +321,7 @@ class Store extends EventEmitter {
       id,
       name,
       workspaceId,
-      workingDir,
+      workingDir: expandHome(workingDir) || '',
       topic,
       command,
       resumeSessionId,

package/src/utils/path-utils.js

@@ -0,0 +1,23 @@
+/**
+ * Path utilities for cross-platform path handling
+ */
+
+const os = require('os');
+
+/**
+ * Expand ~ to home directory
+ * Supports: ~, ~/path, ~\path
+ * @param {string} filepath
+ * @returns {string}
+ */
+function expandHome(filepath) {
+  if (!filepath || typeof filepath !== 'string') {
+    return filepath;
+  }
+  if (filepath === '~' || filepath.startsWith('~/') || filepath.startsWith('~\\')) {
+    return filepath.replace('~', os.homedir());
+  }
+  return filepath;
+}
+
+module.exports = { expandHome };

package/src/web/public/app.js

@@ -1820,7 +1820,7 @@ class CWMApp {
     this.showApp();
     this.initDragAndDrop();
     this.initTerminalResize();
-    this.initTerminalGroups();
+    await this.initTerminalGroups();
     this.initTerminalPaneSwipe();
     this.initNotesEditor();
     this.initAIInsights();
@@ -11521,15 +11521,16 @@ class CWMApp {
      PHASE 4: TERMINAL TAB GROUPS
      ═══════════════════════════════════════════════════════════ */
 
-  initTerminalGroups() {
+  async initTerminalGroups() {
     // Load layout from server
     this._tabGroups = [];
     this._tabFolders = []; // Tab group folders: { id, name, color, collapsed }
     this._activeGroupId = null;
     this._layoutSaveTimer = null;
+    this._layoutRestored = false;
 
-    // Load saved layout
-    this.loadTerminalLayout();
+    // Load saved layout (must complete before SSE or other init touches panes)
+    await this.loadTerminalLayout();
   }
 
   async loadTerminalLayout() {
@@ -11557,11 +11558,12 @@ class CWMApp {
     const group = this._tabGroups.find(g => g.id === this._activeGroupId);
     if (group && group.panes && group.panes.length > 0) {
       group.panes.forEach(p => {
-        if (p.sessionId) {
+        if (p.sessionId && !this.terminalPanes[p.slot]) {
           this.openTerminalInPane(p.slot, p.sessionId, p.sessionName || 'Terminal', p.spawnOpts || {});
         }
       });
     }
+    this._layoutRestored = true;
   }
 
   /**
@@ -11959,11 +11961,11 @@ class CWMApp {
         }
       });
     } else {
-      // No cache — create fresh connections (first time opening this group)
+      // No cache, create fresh connections (first time opening this group)
       const group = this._tabGroups.find(g => g.id === groupId);
       if (group && group.panes) {
         group.panes.forEach(p => {
-          if (p.sessionId) {
+          if (p.sessionId && !this.terminalPanes[p.slot]) {
             this.openTerminalInPane(p.slot, p.sessionId, p.sessionName || 'Terminal', p.spawnOpts || {});
           }
         });

package/src/web/server.js

@@ -1141,9 +1141,15 @@ app.get('/api/discover', requireAuth, (req, res) => {
         dirExists = fs.existsSync(realPath);
       } catch (_) {}
 
+      // Generate a display name that handles failed CJK decoding gracefully
+      const displayName = getProjectDisplayName(entry.name, realPath);
+      const failedDecode = isLikelyFailedCJKDecode(entry.name);
+
       projects.push({
         encodedName: entry.name,
         realPath,
+        displayName,
+        failedDecode,
         dirExists,
         hasClaudeMd,
         sessionCount: sessionFiles.length,
@@ -1268,10 +1274,67 @@ function greedyFsWalk(root, tokens) {
   return resolved;
 }
 
+/**
+ * Read the original path from a jsonl file's cwd field.
+ * This contains the full path with Chinese characters, unlike the encoded directory name.
+ * Only reads the first 4KB to avoid loading large files into memory.
+ *
+ * @param {string} projectDir - Absolute path to the project dir
+ * @returns {string|null} The original path from cwd field, or null if not found
+ */
+function getOriginalPathFromJsonl(projectDir) {
+  try {
+    const files = fs.readdirSync(projectDir);
+    // Find the first .jsonl file (skip subdirectories)
+    const jsonlFile = files.find(f => {
+      if (!f.endsWith('.jsonl')) return false;
+      try {
+        return !fs.statSync(path.join(projectDir, f)).isDirectory();
+      } catch (_) {
+        return false;
+      }
+    });
+    if (!jsonlFile) return null;
+
+    const jsonlPath = path.join(projectDir, jsonlFile);
+
+    // Only read first 4KB to find cwd field (avoids loading large files)
+    const fd = fs.openSync(jsonlPath, 'r');
+    const buffer = Buffer.alloc(4096);
+    let content;
+    try {
+      const bytesRead = fs.readSync(fd, buffer, 0, 4096, 0);
+      content = buffer.toString('utf-8', 0, bytesRead);
+    } finally {
+      fs.closeSync(fd);
+    }
+
+    // Parse first 3 lines to find cwd field
+    const lines = content.split('\n').slice(0, 3);
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const record = JSON.parse(line);
+        if (record.cwd && typeof record.cwd === 'string') {
+          return record.cwd;
+        }
+      } catch (_) {
+        // Skip invalid JSON lines
+        continue;
+      }
+    }
+  } catch (_) {
+    // Silently fail and return null
+  }
+  return null;
+}
+
 /**
  * Resolve the real filesystem path for a Claude projects directory.
- * Reads originalPath from sessions-index.json when available (reliable on
- * all platforms), falling back to decodeClaudePath for legacy/Windows dirs.
+ * Tries sources in order of reliability:
+ * 1. sessions-index.json (reliable on all platforms)
+ * 2. jsonl file's cwd field (contains original Chinese path)
+ * 3. decodeClaudePath (legacy fallback)
  *
  * @param {string} projectDir - Absolute path to the project dir under ~/.claude/projects/
  * @param {string} encodedName - The encoded directory name (e.g. "-Users-jane-project")
@@ -1279,6 +1342,7 @@ function greedyFsWalk(root, tokens) {
  */
 function resolveProjectPath(projectDir, encodedName) {
   try {
+    // 1. Try sessions-index.json first
     const indexPath = path.join(projectDir, 'sessions-index.json');
     if (fs.existsSync(indexPath)) {
       const index = JSON.parse(fs.readFileSync(indexPath, 'utf-8'));
@@ -1290,9 +1354,79 @@ function resolveProjectPath(projectDir, encodedName) {
       }
     }
   } catch (_) {}
+
+  // 2. Try to read from jsonl file's cwd field (for Chinese paths)
+  const jsonlPath = getOriginalPathFromJsonl(projectDir);
+  if (jsonlPath) return jsonlPath;
+
+  // 3. Fall back to decoding the directory name
   return decodeClaudePath(encodedName);
 }
 
+/**
+ * Regex to match CJK characters (Chinese, Japanese, Korean).
+ * Covers: Hiragana, Katakana, CJK Extension A, CJK Unified Ideographs,
+ * Hangul Syllables, and Fullwidth/Halfwidth forms.
+ */
+const CJK_REGEX = /[\u3040-\u309F\u30A0-\u30FF\u3400-\u4DBF\u4E00-\u9FFF\uAC00-\uD7AF\uFF00-\uFFEF]/;
+
+/**
+ * Extract a readable display name from an encoded directory name.
+ * When realPath contains CJK characters (from jsonl cwd field), use it directly.
+ * Otherwise, fall back to extracting from realPath or showing drive info.
+ *
+ * @param {string} encodedName - The encoded directory name (e.g. "D--Projects-CU------")
+ * @param {string} realPath - The decoded path from resolveProjectPath
+ * @returns {string} A human-readable display name
+ */
+function getProjectDisplayName(encodedName, realPath) {
+  // If realPath contains CJK characters, it came from jsonl cwd - use it directly
+  if (realPath && CJK_REGEX.test(realPath)) {
+    const parts = realPath.split(/[\\/]/).filter(Boolean);
+    return parts.length > 0 ? parts[parts.length - 1] : encodedName;
+  }
+
+  // Check if the encoded name has failed CJK encoding indicators
+  // Claude Code replaces CJK characters with "-" during encoding
+  // This creates long sequences of "-" in the encoded name (e.g., "CU------" where 6 dashes = 3 CJK chars)
+  const longDashSequence = encodedName.match(/-{3,}/);
+  if (longDashSequence) {
+    // Extract drive letter and the rest (supports A-Z and a-z)
+    const driveMatch = encodedName.match(/^([A-Za-z])--(.*)/);
+    if (driveMatch) {
+      const drive = driveMatch[1];
+      const rest = driveMatch[2];
+      // Try to extract meaningful parts (non-dash sequences)
+      const parts = rest.split('-').filter(p => p.length > 0);
+      // Take the last meaningful part as project name
+      const name = parts.length > 0 ? parts[parts.length - 1] : encodedName;
+      return `[${drive}:] ${name}`;
+    }
+  }
+
+  // Default: extract the last path component from realPath
+  if (realPath) {
+    const parts = realPath.split(/[\\/]/).filter(Boolean);
+    return parts.length > 0 ? parts[parts.length - 1] : encodedName;
+  }
+
+  return encodedName;
+}
+
+/**
+ * Check if an encoded directory name likely contains CJK characters that were
+ * replaced with dashes during encoding.
+ * Returns true if the name contains long sequences of consecutive dashes.
+ *
+ * @param {string} encodedName - The encoded directory name
+ * @returns {boolean} True if encoding likely replaced CJK characters
+ */
+function isLikelyFailedCJKDecode(encodedName) {
+  if (!encodedName) return false;
+  // Long sequences of dashes (3 or more) indicate CJK chars were replaced
+  return /-{3,}/.test(encodedName);
+}
+
 // ──────────────────────────────────────────────────────────
 //  Session Auto-Title
 // ──────────────────────────────────────────────────────────
@@ -1745,7 +1879,7 @@ app.post('/api/search-conversations', requireAuth, async (req, res) => {
 
       const projectDir = path.join(claudeProjectsDir, dir.name);
       const realPath = resolveProjectPath(projectDir, dir.name);
-      const projectName = realPath.split('\\').pop() || realPath.split('/').pop() || dir.name;
+      const projectName = getProjectDisplayName(dir.name, realPath);
 
       let jsonlFiles;
       try {
@@ -1926,8 +2060,7 @@ app.post('/api/ai/find-session', requireAuth, async (req, res) => {
       discoveredProjects = dirs.map(d => {
         const projectDir = path.join(claudeProjectsDir, d.name);
         const realPath = resolveProjectPath(projectDir, d.name);
-        const pathParts = realPath.replace(/\\/g, '/').split('/').filter(Boolean);
-        const name = pathParts[pathParts.length - 1] || d.name;
+        const name = getProjectDisplayName(d.name, realPath);
         let sessionCount = 0;
         let lastActive = null;
         try {
@@ -6353,7 +6486,7 @@ function getSearchableFiles() {
 
       const projectDir = path.join(claudeDir, entry.name);
       const realPath = resolveProjectPath(projectDir, entry.name);
-      const projectName = realPath.split('\\').pop() || realPath.split('/').pop() || entry.name;
+      const projectName = getProjectDisplayName(entry.name, realPath);
 
       try {
         const dirFiles = fs.readdirSync(projectDir).filter(f => f.endsWith('.jsonl'));