myrlin-workbook 0.9.8 → 0.9.9

package/package.json

@@ -1,64 +1,64 @@
-{
-  "name": "myrlin-workbook",
-  "version": "0.9.8",
-  "description": "Browser-based project manager for Claude Code sessions - session discovery, multi-terminal, cost tracking, docs, and kanban board",
-  "main": "src/index.js",
-  "bin": {
-    "myrlin-workbook": "./src/gui.js",
-    "myrlin": "./src/gui.js",
-    "myrlin-tui": "./src/index.js",
-    "cwm": "./src/index.js"
-  },
-  "scripts": {
-    "start": "node src/index.js",
-    "demo": "node src/demo.js",
-    "gui": "node src/supervisor.js",
-    "gui:bare": "node src/gui.js",
-    "gui:demo": "node src/supervisor.js --demo",
-    "test": "node test/run.js",
-    "mcp:visual-qa": "node src/mcp/visual-qa.js",
-    "gui:cdp": "node src/supervisor.js --cdp",
-    "postinstall": "node scripts/postinstall.js",
-    "restart": "bash scripts/restart-gui.sh"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/therealarthur/myrlin-workbook.git"
-  },
-  "homepage": "https://github.com/therealarthur/myrlin-workbook",
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "keywords": [
-    "claude",
-    "workspace",
-    "manager",
-    "terminal",
-    "tui",
-    "ai",
-    "coding-assistant",
-    "session-manager",
-    "developer-tools",
-    "xterm",
-    "myrlin"
-  ],
-  "author": "Arthur",
-  "license": "AGPL-3.0-only",
-  "dependencies": {
-    "blessed": "^0.1.81",
-    "blessed-contrib": "^4.11.0",
-    "chalk": "^5.6.2",
-    "chrome-remote-interface": "^0.34.0",
-    "express": "^5.2.1",
-    "node-pty": "^1.1.0",
-    "ws": "^8.19.0"
-  },
-  "devDependencies": {
-    "@playwright/test": "^1.58.2",
-    "@xterm/addon-fit": "^0.11.0",
-    "@xterm/addon-web-links": "^0.12.0",
-    "@xterm/xterm": "^6.0.0",
-    "ffmpeg-static": "^5.3.0",
-    "sharp": "^0.34.5"
-  }
-}
+{
+  "name": "myrlin-workbook",
+  "version": "0.9.9",
+  "description": "Browser-based project manager for Claude Code sessions - session discovery, multi-terminal, cost tracking, docs, and kanban board",
+  "main": "src/index.js",
+  "bin": {
+    "myrlin-workbook": "./src/gui.js",
+    "myrlin": "./src/gui.js",
+    "myrlin-tui": "./src/index.js",
+    "cwm": "./src/index.js"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "demo": "node src/demo.js",
+    "gui": "node src/supervisor.js",
+    "gui:bare": "node src/gui.js",
+    "gui:demo": "node src/supervisor.js --demo",
+    "test": "node test/run.js",
+    "mcp:visual-qa": "node src/mcp/visual-qa.js",
+    "gui:cdp": "node src/supervisor.js --cdp",
+    "postinstall": "node scripts/postinstall.js",
+    "restart": "bash scripts/restart-gui.sh"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/therealarthur/myrlin-workbook.git"
+  },
+  "homepage": "https://github.com/therealarthur/myrlin-workbook",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "claude",
+    "workspace",
+    "manager",
+    "terminal",
+    "tui",
+    "ai",
+    "coding-assistant",
+    "session-manager",
+    "developer-tools",
+    "xterm",
+    "myrlin"
+  ],
+  "author": "Arthur",
+  "license": "AGPL-3.0-only",
+  "dependencies": {
+    "blessed": "^0.1.81",
+    "blessed-contrib": "^4.11.0",
+    "chalk": "^5.6.2",
+    "chrome-remote-interface": "^0.34.0",
+    "express": "^5.2.1",
+    "node-pty": "^1.1.0",
+    "ws": "^8.19.0"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.58.2",
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/addon-web-links": "^0.12.0",
+    "@xterm/xterm": "^6.0.0",
+    "ffmpeg-static": "^5.3.0",
+    "sharp": "^0.34.5"
+  }
+}

package/src/index.js

@@ -13,6 +13,7 @@ const { getStore } = require('./state/store');
 const { getNotificationManager } = require('./core/notifications');
 const { markStaleSessionsStopped } = require('./core/recovery');
 const { createApp } = require('./ui/app');
+const { getDataDir } = require('./utils/data-dir');
 
 function main() {
   const args = process.argv.slice(2);
@@ -26,7 +27,7 @@ function main() {
   if (isReset) {
     const fs = require('fs');
     const path = require('path');
-    const stateFile = path.join(__dirname, '..', 'state', 'workspaces.json');
+    const stateFile = path.join(getDataDir(), 'workspaces.json');
     if (fs.existsSync(stateFile)) {
       fs.unlinkSync(stateFile);
       console.log('State cleared. Restart without --reset.');

package/src/state/docs-manager.js

@@ -11,8 +11,9 @@
 
 const fs = require('fs');
 const path = require('path');
+const { getDataDir } = require('../utils/data-dir');
 
-const DOCS_DIR = path.join(__dirname, '..', '..', 'state', 'docs');
+const DOCS_DIR = path.join(getDataDir(), 'docs');
 
 /**
  * Ensure the state/docs/ directory exists.

package/src/state/store.js

@@ -1,7 +1,8 @@
 /**
  * Core state store for Claude Workspace Manager
  * Handles JSON persistence, CRUD operations, and state transitions.
- * All state is persisted to ./state/workspaces.json
+ * All state is persisted to ~/.myrlin/workspaces.json so that every
+ * launch method (npm run gui, npx, global install) shares the same data.
  */
 
 const fs = require('fs');
@@ -10,8 +11,12 @@ const crypto = require('crypto');
 const { EventEmitter } = require('events');
 const docsManager = require('./docs-manager');
 const { expandHome } = require('../utils/path-utils');
+const { getDataDir, migrateFromLegacy } = require('../utils/data-dir');
 
-const STATE_DIR = path.join(__dirname, '..', '..', 'state');
+// Legacy project-local state dir (for migration on first run)
+const LEGACY_STATE_DIR = path.join(__dirname, '..', '..', 'state');
+
+const STATE_DIR = getDataDir();
 const BACKUP_DIR = path.join(STATE_DIR, 'backups');
 const STATE_FILE = path.join(STATE_DIR, 'workspaces.json');
 const BACKUP_FILE = path.join(STATE_DIR, 'workspaces.backup.json');
@@ -57,6 +62,8 @@ class Store extends EventEmitter {
     if (!fs.existsSync(STATE_DIR)) {
       fs.mkdirSync(STATE_DIR, { recursive: true });
     }
+    // Migrate legacy project-local state to ~/.myrlin/ on first run
+    migrateFromLegacy(LEGACY_STATE_DIR);
     docsManager.ensureDocsDir();
     // Create a timestamped backup BEFORE loading (preserves last known good state)
     this.createTimestampedBackup();
@@ -161,18 +168,61 @@ class Store extends EventEmitter {
   /**
    * Save state to disk (with backup).
    * Uses write-to-temp-then-rename for atomic writes on crash.
+   * Verifies written data after rename to detect zero-fill corruption.
    */
   save() {
     try {
-      // Backup current file before overwriting
+      // Only backup current file if it contains real data (not zero-filled)
       if (fs.existsSync(STATE_FILE)) {
-        fs.copyFileSync(STATE_FILE, BACKUP_FILE);
+        if (this._isFileValid(STATE_FILE)) {
+          fs.copyFileSync(STATE_FILE, BACKUP_FILE);
+        } else {
+          console.warn('[Store] Skipping backup of corrupt primary file');
+        }
       }
       // Atomic write: write to PID-unique temp file, then rename over the target.
       // PID suffix prevents collisions when TUI and GUI write concurrently.
+      const json = JSON.stringify(this._state, null, 2);
       const tmpFile = STATE_FILE + '.' + process.pid + '.tmp';
-      fs.writeFileSync(tmpFile, JSON.stringify(this._state, null, 2), 'utf-8');
+      fs.writeFileSync(tmpFile, json, 'utf-8');
+
+      // Verify the temp file before renaming: re-read and check for zero-fill
+      // corruption (Windows write-cache failure mode)
+      const written = fs.readFileSync(tmpFile, 'utf-8');
+      if (!written.trim() || written.charCodeAt(0) === 0) {
+        console.error('[Store] CORRUPTION DETECTED: temp file is zero-filled, aborting save');
+        try { fs.unlinkSync(tmpFile); } catch (_) {}
+        this.emit('error', { type: 'save_corruption', error: 'Written file was zero-filled' });
+        return;
+      }
+      // Sanity check: verify it parses as valid JSON with workspaces
+      try {
+        const check = JSON.parse(written);
+        if (!check.workspaces) {
+          throw new Error('Missing workspaces key');
+        }
+      } catch (parseErr) {
+        console.error('[Store] CORRUPTION DETECTED: temp file not valid JSON, aborting save');
+        try { fs.unlinkSync(tmpFile); } catch (_) {}
+        this.emit('error', { type: 'save_corruption', error: parseErr.message });
+        return;
+      }
+
       fs.renameSync(tmpFile, STATE_FILE);
+
+      // Post-rename verification: re-read the final file to catch filesystem-level corruption
+      try {
+        const final = fs.readFileSync(STATE_FILE, 'utf-8');
+        if (!final.trim() || final.charCodeAt(0) === 0) {
+          console.error('[Store] POST-RENAME CORRUPTION: primary file is zero-filled after rename');
+          // Restore from backup if available
+          if (fs.existsSync(BACKUP_FILE) && this._isFileValid(BACKUP_FILE)) {
+            fs.copyFileSync(BACKUP_FILE, STATE_FILE);
+            console.warn('[Store] Restored primary from backup after corruption');
+          }
+        }
+      } catch (_) {}
+
       this._recordDiskMtime();
       this._dirty = false;
     } catch (err) {
@@ -180,6 +230,27 @@ class Store extends EventEmitter {
     }
   }
 
+  /**
+   * Check if a file contains real data (not zero-filled or empty).
+   * Returns false for zero-filled files, empty files, or unreadable files.
+   * @param {string} filePath - Path to check
+   * @returns {boolean} true if the file has valid non-zero content
+   */
+  _isFileValid(filePath) {
+    try {
+      const buf = fs.readFileSync(filePath);
+      if (buf.length === 0) return false;
+      // Check first 64 bytes for any non-zero content
+      const checkLen = Math.min(buf.length, 64);
+      for (let i = 0; i < checkLen; i++) {
+        if (buf[i] !== 0) return true;
+      }
+      return false;
+    } catch (_) {
+      return false;
+    }
+  }
+
   /**
    * Create a timestamped backup. Called on server startup to preserve
    * state before any mutations. Keeps up to MAX_TIMESTAMPED_BACKUPS files.
@@ -187,6 +258,11 @@ class Store extends EventEmitter {
   createTimestampedBackup() {
     try {
       if (!fs.existsSync(STATE_FILE)) return;
+      // Never back up a corrupt/zero-filled file
+      if (!this._isFileValid(STATE_FILE)) {
+        console.warn('[Store] Skipping timestamped backup: primary file is corrupt/zero-filled');
+        return;
+      }
       if (!fs.existsSync(BACKUP_DIR)) {
         fs.mkdirSync(BACKUP_DIR, { recursive: true });
       }
@@ -208,12 +284,54 @@ class Store extends EventEmitter {
   }
 
   /**
-   * Debounced save - batches rapid changes
+   * Async save - performs all disk I/O off the event loop.
+   * Falls back to sync save() on error.
+   */
+  async saveAsync() {
+    try {
+      const json = JSON.stringify(this._state, null, 2);
+      const tmpFile = STATE_FILE + '.' + process.pid + '.tmp';
+
+      // Backup current file if it exists and is valid
+      if (fs.existsSync(STATE_FILE) && this._isFileValid(STATE_FILE)) {
+        await fs.promises.copyFile(STATE_FILE, BACKUP_FILE);
+      }
+
+      await fs.promises.writeFile(tmpFile, json, 'utf-8');
+
+      // Verify temp file before rename
+      const written = await fs.promises.readFile(tmpFile, 'utf-8');
+      if (!written.trim() || written.charCodeAt(0) === 0) {
+        console.error('[Store] CORRUPTION DETECTED in async save, aborting');
+        try { await fs.promises.unlink(tmpFile); } catch (_) {}
+        return;
+      }
+      try {
+        const check = JSON.parse(written);
+        if (!check.workspaces) throw new Error('Missing workspaces key');
+      } catch (parseErr) {
+        console.error('[Store] CORRUPTION DETECTED: invalid JSON in async save');
+        try { await fs.promises.unlink(tmpFile); } catch (_) {}
+        return;
+      }
+
+      await fs.promises.rename(tmpFile, STATE_FILE);
+      this._recordDiskMtime();
+      this._dirty = false;
+    } catch (err) {
+      console.error('[Store] Async save failed, falling back to sync:', err.message);
+      this.save();
+    }
+  }
+
+  /**
+   * Debounced save - batches rapid changes, uses async I/O
+   * to avoid blocking the event loop during frequent updates.
    */
   _debouncedSave() {
     this._dirty = true;
     if (this._saveTimer) clearTimeout(this._saveTimer);
-    this._saveTimer = setTimeout(() => this.save(), 150);
+    this._saveTimer = setTimeout(() => this.saveAsync(), 150);
   }
 
   // ─── Getters ─────────────────────────────────────────────

package/src/web/public/app.js

@@ -7420,6 +7420,27 @@ class CWMApp {
     }
   }
 
+  /**
+   * Throttled versions of loadSessions and loadStats to prevent
+   * rapid-fire SSE events from triggering dozens of API calls.
+   * At most one call per 500ms for sessions, 2000ms for stats.
+   */
+  _throttledLoadSessions() {
+    if (this._loadSessionsTimer) return;
+    this._loadSessionsTimer = setTimeout(() => {
+      this._loadSessionsTimer = null;
+      this.loadSessions().then(() => { if (this._smOpen) this.renderSessionManager(); });
+    }, 500);
+  }
+
+  _throttledLoadStats() {
+    if (this._loadStatsTimer) return;
+    this._loadStatsTimer = setTimeout(() => {
+      this._loadStatsTimer = null;
+      this.loadStats();
+    }, 2000);
+  }
+
   handleSSEEvent(data) {
     // Queue events while a modal is open to prevent UI glitches and race conditions
     if (this._modalOpen) {
@@ -7431,30 +7452,30 @@ class CWMApp {
     switch (data.type) {
       case 'session:started':
         this.showToast(`Session "${data.name || 'unknown'}" started`, 'success');
-        this.loadSessions().then(() => { if (this._smOpen) this.renderSessionManager(); });
-        this.loadStats();
+        this._throttledLoadSessions();
+        this._throttledLoadStats();
         break;
       case 'session:stopped':
         this.showToast(`Session "${data.name || 'unknown'}" stopped`, 'info');
-        this.loadSessions().then(() => { if (this._smOpen) this.renderSessionManager(); });
-        this.loadStats();
+        this._throttledLoadSessions();
+        this._throttledLoadStats();
         break;
       case 'session:error':
         this.showToast(`Session "${data.name || 'unknown'}" encountered an error`, 'error');
-        this.loadSessions().then(() => { if (this._smOpen) this.renderSessionManager(); });
-        this.loadStats();
+        this._throttledLoadSessions();
+        this._throttledLoadStats();
         break;
       case 'session:created':
       case 'session:deleted':
       case 'session:updated':
-        this.loadSessions().then(() => { if (this._smOpen) this.renderSessionManager(); });
-        this.loadStats();
+        this._throttledLoadSessions();
+        this._throttledLoadStats();
         break;
       case 'workspace:created':
       case 'workspace:deleted':
       case 'workspace:updated':
         this.loadWorkspaces();
-        this.loadStats();
+        this._throttledLoadStats();
         break;
       case 'stats:updated':
         if (data.stats) {
@@ -9035,6 +9056,11 @@ class CWMApp {
      ═══════════════════════════════════════════════════════════ */
 
   openTerminalInPane(slotIdx, sessionId, sessionName, spawnOpts) {
+    // Check localStorage for a previously saved name for this session
+    const savedTitle = this.getProjectSessionTitle(sessionId);
+    if (savedTitle && (!sessionName || sessionName === sessionId)) {
+      sessionName = savedTitle;
+    }
     console.log('[DnD] openTerminalInPane slot:', slotIdx, 'session:', sessionId, 'name:', sessionName);
     // If the target slot already has an active terminal, find the next empty slot
     if (this.terminalPanes[slotIdx]) {
@@ -10097,6 +10123,8 @@ class CWMApp {
         this.terminalPanes.forEach(tp => {
           if (tp) tp.safeFit();
         });
+        // Persist split ratios for this tab group
+        this.saveTerminalLayout();
       };
 
       document.addEventListener('mousemove', onMove);
@@ -11475,6 +11503,10 @@ class CWMApp {
             this.syncSessionTitle(sessionId, newName);
           }
 
+          // Always persist to localStorage keyed by the terminal's sessionId
+          // so ad-hoc sessions (not in store, not in projects) keep their names
+          this.syncSessionTitle(sessionId, newName);
+
           // Update TerminalPane instance
           const tp = this.terminalPanes[slotIdx];
           if (tp) tp.sessionName = newName;
@@ -11567,6 +11599,14 @@ class CWMApp {
         }
       });
     }
+
+    // Restore split ratios for the active tab group
+    if (group && group.gridColSizes) {
+      this._gridColSizes = [...group.gridColSizes];
+    }
+    if (group && group.gridRowSizes) {
+      this._gridRowSizes = [...group.gridRowSizes];
+    }
     this._layoutRestored = true;
   }
 
@@ -11923,6 +11963,19 @@ class CWMApp {
 
     this._activeGroupId = groupId;
 
+    // ── Restore this tab group's split ratios (or reset to equal) ──
+    const targetGroup = this._tabGroups.find(g => g.id === groupId);
+    if (targetGroup && targetGroup.gridColSizes) {
+      this._gridColSizes = [...targetGroup.gridColSizes];
+    } else {
+      this._gridColSizes = [1, 1];
+    }
+    if (targetGroup && targetGroup.gridRowSizes) {
+      this._gridRowSizes = [...targetGroup.gridRowSizes];
+    } else {
+      this._gridRowSizes = [1, 1];
+    }
+
     // ── Restore target group: try cache first, fall back to fresh connections ──
     const cached = this._groupPaneCache[groupId];
     if (cached) {
@@ -12008,6 +12061,10 @@ class CWMApp {
         });
       }
     }
+
+    // Persist this tab group's split ratios so switching tabs restores layout
+    group.gridColSizes = [...this._gridColSizes];
+    group.gridRowSizes = [...this._gridRowSizes];
   }
 
   /**

package/src/web/server.js

@@ -19,6 +19,70 @@ const { getStore } = require('../state/store');
 const { launchSession, stopSession, restartSession } = require('../core/session-manager');
 const { backupFrontend, restoreFrontend, getBackupStatus } = require('./backup');
 const td = require('../core/td-adapter');
+const { getDataDir } = require('../utils/data-dir');
+const { Worker } = require('worker_threads');
+
+// ─── Cost Worker Thread ──────────────────────────────────
+// Offloads JSONL parsing to a background thread to prevent
+// terminal I/O freezes during cost calculation.
+let _costWorker = null;
+let _costWorkerId = 0;
+const _costWorkerCallbacks = new Map();
+
+/**
+ * Get or create the cost calculation worker thread.
+ * Lazy-initialized on first cost request.
+ * @returns {Worker} The cost worker thread
+ */
+function getCostWorker() {
+  if (_costWorker) return _costWorker;
+  _costWorker = new Worker(path.join(__dirname, 'cost-worker.js'));
+  _costWorker.on('message', (msg) => {
+    const cb = _costWorkerCallbacks.get(msg.id);
+    if (cb) {
+      _costWorkerCallbacks.delete(msg.id);
+      if (msg.error) cb.reject(new Error(msg.error));
+      else cb.resolve(msg.result);
+    }
+  });
+  _costWorker.on('error', (err) => {
+    console.error('[CostWorker] Error:', err.message);
+  });
+  _costWorker.on('exit', (code) => {
+    console.warn('[CostWorker] Exited with code', code);
+    _costWorker = null;
+    // Reject any pending callbacks
+    for (const [id, cb] of _costWorkerCallbacks) {
+      cb.reject(new Error('Worker exited'));
+      _costWorkerCallbacks.delete(id);
+    }
+  });
+  return _costWorker;
+}
+
+/**
+ * Calculate session cost asynchronously via the worker thread.
+ * Falls back to sync calculation if the worker fails.
+ * @param {string} jsonlPath - Path to the JSONL file
+ * @returns {Promise<object>} Cost breakdown
+ */
+function calculateSessionCostAsync(jsonlPath) {
+  return new Promise((resolve, reject) => {
+    const id = ++_costWorkerId;
+    _costWorkerCallbacks.set(id, { resolve, reject });
+    try {
+      getCostWorker().postMessage({
+        id,
+        jsonlPath,
+        pricing: TOKEN_PRICING,
+        defaultPricing: DEFAULT_PRICING,
+      });
+    } catch (err) {
+      _costWorkerCallbacks.delete(id);
+      reject(err);
+    }
+  });
+}
 
 /**
  * Resolve the td binary path in priority order:
@@ -2561,17 +2625,27 @@ app.get('/api/sessions/:id/cost', requireAuth, (req, res) => {
       return res.json(cached.result);
     }
 
-    const costData = calculateSessionCost(jsonlPath);
-    const result = {
-      sessionId: req.params.id,
-      resumeSessionId,
-      ...costData,
-    };
-
-    // Store in cache
-    _costCache.set(resumeSessionId, { mtimeMs, timestamp: now, result });
-
-    return res.json(result);
+    // Use worker thread for async cost calculation to avoid blocking terminal I/O
+    calculateSessionCostAsync(jsonlPath).then((costData) => {
+      const result = {
+        sessionId: req.params.id,
+        resumeSessionId,
+        ...costData,
+      };
+      // Store in cache
+      _costCache.set(resumeSessionId, { mtimeMs, timestamp: now, result });
+      res.json(result);
+    }).catch((err) => {
+      // Fallback to sync calculation if worker fails
+      try {
+        const costData = calculateSessionCost(jsonlPath);
+        const result = { sessionId: req.params.id, resumeSessionId, ...costData };
+        _costCache.set(resumeSessionId, { mtimeMs, timestamp: now, result });
+        res.json(result);
+      } catch (syncErr) {
+        res.status(500).json({ error: 'Failed to calculate cost: ' + syncErr.message });
+      }
+    });
   } catch (err) {
     return res.status(500).json({ error: 'Failed to calculate cost: ' + err.message });
   }
@@ -4881,7 +4955,7 @@ function attachStoreEvents() {
 //  LAYOUT PERSISTENCE
 // ──────────────────────────────────────────────────────────
 
-const LAYOUT_FILE = path.join(__dirname, '..', '..', 'state', 'layout.json');
+const LAYOUT_FILE = path.join(getDataDir(), 'layout.json');
 
 /**
  * GET /api/layout
@@ -4905,9 +4979,9 @@ app.get('/api/layout', requireAuth, (req, res) => {
  */
 app.put('/api/layout', requireAuth, (req, res) => {
   try {
-    const stateDir = path.join(__dirname, '..', '..', 'state');
-    if (!fs.existsSync(stateDir)) {
-      fs.mkdirSync(stateDir, { recursive: true });
+    const dataDir = getDataDir();
+    if (!fs.existsSync(dataDir)) {
+      fs.mkdirSync(dataDir, { recursive: true });
     }
     fs.writeFileSync(LAYOUT_FILE, JSON.stringify(req.body, null, 2), 'utf-8');
     return res.json({ success: true });
@@ -6292,7 +6366,7 @@ app.delete('/api/tunnels/:id', requireAuth, (req, res) => {
 //  NAMED TUNNEL (Cloudflare token-based, persistent domain)
 // ──────────────────────────────────────────────────────────
 
-const NAMED_TUNNEL_HOME_CONFIG = path.join(os.homedir(), '.myrlin', 'config.json');
+const NAMED_TUNNEL_HOME_CONFIG = path.join(getDataDir(), 'config.json');
 const NAMED_TUNNEL_LOCAL_CONFIG = path.join(__dirname, '..', '..', 'state', 'config.json');
 
 function readMyrlinConfig() {