@lucenaone/coder 1.1.5 → 1.1.16

package/package.json

@@ -1,17 +1,25 @@
 {
   "name": "@lucenaone/coder",
-  "version": "1.1.5",
+  "version": "1.1.16",
   "description": "Private tunnel for connecting LucenaCoder.com to your local folder. Always remains folder scoped while providing full terminal access.",
   "type": "module",
   "bin": {
     "lucenacoder": "./bin/lucena.js"
   },
+  "files": [
+    "bin",
+    "src",
+    "grammars",
+    "README.md"
+  ],
   "scripts": {
     "start": "node bin/lucena.js"
   },
   "dependencies": {
     "chokidar": "^4.0.0",
+    "execa": "^9.6.1",
     "firebase": "^11.0.0",
+    "shell-quote": "^1.8.4",
     "web-tree-sitter": "^0.26.9"
   },
   "keywords": [

package/src/agent.js

@@ -1,18 +1,23 @@
 import { initializeApp } from 'firebase/app';
 import { getDatabase, ref, push, set, onChildAdded, onDisconnect, serverTimestamp, remove, get } from 'firebase/database';
-import { spawn } from 'child_process';
+import { spawn, spawnSync } from 'child_process';
 import { watch } from 'chokidar';
 import { readFile, writeFile, mkdir, readdir, stat, unlink, rm } from 'fs/promises';
 import { join, resolve, dirname, basename, relative, isAbsolute, extname } from 'path';
 import { existsSync, mkdirSync, writeFileSync } from 'fs';
 import { FIREBASE_CONFIG } from './config.js';
 import { buildIndex, reindexFile } from './cli-indexer.js';
+import { LucenaShell } from './lucena-shell.js';
 
 const IGNORED_PATTERNS = [
   'node_modules', '.git', '.next', '.wrangler', '.DS_Store',
-  'dist', 'build', '.cache', '.turbo', '.vercel', '.firebase'
+  'dist', 'build', '.cache', '.turbo', '.vercel', '.firebase',
+  '.venv', 'venv', '__pycache__', '.pytest_cache', '.mypy_cache',
+  'coverage', '.coverage', 'target', 'out', '.gradle'
 ];
 
+const SEARCH_GLOB = '*.{js,jsx,ts,tsx,json,md,css,html,py,rb,go,rs}';
+
 // ── The CLI Jailer ──
 function getJailedPath(baseDir, rawPath) {
   let p = rawPath.replace(/\\/g, '/');
@@ -59,8 +64,15 @@ export class LucenaAgent {
     this.watcher = null;
     this.activeCommands = new Map();
     this.connected = false;
+    this.stripCwd = true; // Default: strip absolute paths (Browser Mode safety)
     this.indexData = null; // Pre-built index from CLI-side parsing
     this.indexPromise = null; // The in-flight indexing promise
+    this.shell = new LucenaShell(this.cwd);
+  }
+
+  /** Conditionally strip cwd — only in Browser Mode */
+  _sanitize(text) {
+    return this.stripCwd ? stripCwd(this.cwd, text) : text;
   }
 
   _scaffoldWorkspaceBrain() {
@@ -129,6 +141,11 @@ export class LucenaAgent {
       if (!data) return;
       remove(snapshot.ref);
       
+      // Browser tells us whether to strip cwd from output
+      if (typeof data.stripCwd === 'boolean') {
+        this.stripCwd = data.stripCwd;
+      }
+      
       // Index is guaranteed ready (awaited in start()), push immediately
       if (this.indexData) {
         this.pushIndexSnapshot(this.indexData);
@@ -144,7 +161,7 @@ export class LucenaAgent {
       try {
         await this.handleCommand(command);
       } catch (err) {
-        this.pushResponse(command.messageId, 'error', stripCwd(this.cwd, err.message));
+        this.pushResponse(command.messageId, 'error', this._sanitize(err.message));
       }
     });
 
@@ -195,6 +212,7 @@ export class LucenaAgent {
       case 'execute': return this.executeCommand(command);
       case 'read_file': return this.readFileCmd(command);
       case 'write_file': return this.writeFileCmd(command);
+      case 'list_files': return this.listFiles(command);
       case 'list_dir': return this.listDir(command);
       case 'stat': return this.statFile(command);
       case 'delete_file': return this.deleteFile(command);
@@ -216,15 +234,26 @@ export class LucenaAgent {
     });
   }
 
-  async executeCommand({ messageId, command }) {
-    const child = spawn('sh', ['-c', command], { cwd: this.cwd });
+  async executeCommand({ messageId, command, mode = 'safe', approved = false, outsideWorkspaceApproved = false }) {
+    let child;
 
-    child.stdout.on('data', (data) => {
-      this.pushResponse(messageId, 'output', stripCwd(this.cwd, data.toString()));
+    try {
+      child = this.shell.execute(command, { mode, approved, outsideWorkspaceApproved });
+    } catch (err) {
+      return this.pushResponse(messageId, 'error', this._sanitize(err.message));
+    }
+
+    child.stdout?.on('data', (data) => {
+      this.pushResponse(messageId, 'output', this._sanitize(data.toString()));
     });
-    child.stderr.on('data', (data) => {
-      this.pushResponse(messageId, 'output', stripCwd(this.cwd, data.toString()));
+    child.stderr?.on('data', (data) => {
+      this.pushResponse(messageId, 'output', this._sanitize(data.toString()));
     });
+
+    // Immediately close stdin so commands that try to read it get EOF
+    // instead of hanging until the 60s timeout
+    try { child.stdin?.end(); } catch { /* already closed */ }
+
     child.on('close', (code) => {
       this.pushResponse(messageId, 'done', '', { exitCode: code ?? 0 });
       this.activeCommands.delete(messageId);
@@ -240,19 +269,19 @@ export class LucenaAgent {
       this.pushResponse(messageId, 'output', content);
       this.pushResponse(messageId, 'done', '');
     } catch (err) {
-      this.pushResponse(messageId, 'error', stripCwd(this.cwd, err.message));
+      this.pushResponse(messageId, 'error', this._sanitize(err.message));
     }
   }
 
   async writeFileCmd({ messageId, path: filePath, content }) {
     const fullPath = getJailedPath(this.cwd, filePath);
-    const relPath = '/' + relative(this.cwd, fullPath);
+    const relPath = toBrowserPath(relative(this.cwd, fullPath));
     try {
       await mkdir(dirname(fullPath), { recursive: true });
       await writeFile(fullPath, content, 'utf-8');
       this.pushResponse(messageId, 'done', `Wrote ${relPath}`);
     } catch (err) {
-      this.pushResponse(messageId, 'error', stripCwd(this.cwd, err.message));
+      this.pushResponse(messageId, 'error', this._sanitize(err.message));
     }
   }
 
@@ -266,8 +295,40 @@ export class LucenaAgent {
         .join('\n');
       this.pushResponse(messageId, 'done', listing || '(empty)');
     } catch (err) {
-      this.pushResponse(messageId, 'error', stripCwd(this.cwd, err.message));
+      this.pushResponse(messageId, 'error', this._sanitize(err.message));
+    }
+  }
+
+  async listFiles({ messageId }) {
+    try {
+      const files = await this.walkFiles(this.cwd);
+      this.pushResponse(messageId, 'done', JSON.stringify(files));
+    } catch (err) {
+      this.pushResponse(messageId, 'error', this._sanitize(err.message));
+    }
+  }
+
+  async walkFiles(dirPath, relativeDir = '') {
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    const files = [];
+
+    for (const entry of entries) {
+      if (IGNORED_PATTERNS.includes(entry.name)) continue;
+
+      const relPath = relativeDir ? `${relativeDir}/${entry.name}` : entry.name;
+      const fullPath = join(dirPath, entry.name);
+
+      if (entry.isDirectory()) {
+        files.push(...await this.walkFiles(fullPath, relPath));
+      } else if (entry.isFile()) {
+        files.push({
+          path: relPath,
+          lineCount: await countTextFileLines(fullPath),
+        });
+      }
     }
+
+    return files;
   }
 
   async statFile({ messageId, path: filePath }) {
@@ -282,13 +343,13 @@ export class LucenaAgent {
         created: s.birthtime
       }));
     } catch (err) {
-      this.pushResponse(messageId, 'error', stripCwd(this.cwd, err.message));
+      this.pushResponse(messageId, 'error', this._sanitize(err.message));
     }
   }
 
   async deleteFile({ messageId, path: filePath }) {
     const fullPath = getJailedPath(this.cwd, filePath);
-    const relPath = '/' + relative(this.cwd, fullPath);
+    const relPath = toBrowserPath(relative(this.cwd, fullPath));
     try {
       if ((await stat(fullPath)).isDirectory()) {
         await rm(fullPath, { recursive: true });
@@ -297,41 +358,64 @@ export class LucenaAgent {
       }
       this.pushResponse(messageId, 'done', `Deleted ${relPath}`);
     } catch (err) {
-      this.pushResponse(messageId, 'error', stripCwd(this.cwd, err.message));
+      this.pushResponse(messageId, 'error', this._sanitize(err.message));
     }
   }
 
   async mkdirCmd({ messageId, path: dirPath }) {
     const fullPath = getJailedPath(this.cwd, dirPath);
-    const relPath = '/' + relative(this.cwd, fullPath);
+    const relPath = toBrowserPath(relative(this.cwd, fullPath));
     try {
       await mkdir(fullPath, { recursive: true });
       this.pushResponse(messageId, 'done', `Created ${relPath}`);
     } catch (err) {
-      this.pushResponse(messageId, 'error', stripCwd(this.cwd, err.message));
+      this.pushResponse(messageId, 'error', this._sanitize(err.message));
     }
   }
 
   async searchCodebase({ messageId, query, directory }) {
     const searchDir = getJailedPath(this.cwd, directory || '.');
     try {
-      const child = spawn('grep', [
-        '-rn', '--include=*.{js,jsx,ts,tsx,json,md,css,html,py,rb,go,rs}',
-        query, searchDir
-      ], { cwd: this.cwd });
+      const child = this._createSearchProcess(query, searchDir);
 
       let output = '';
       child.stdout.on('data', (d) => { output += d.toString(); });
       child.stderr.on('data', (d) => { output += d.toString(); });
 
       child.on('close', (code) => {
-        this.pushResponse(messageId, 'done', stripCwd(this.cwd, output) || 'No matches found');
+        this.pushResponse(messageId, 'done', this._sanitize(output) || 'No matches found');
+      });
+      child.on('error', (err) => {
+        this.pushResponse(messageId, 'error', this._sanitize(err.message));
       });
     } catch (err) {
-      this.pushResponse(messageId, 'error', stripCwd(this.cwd, err.message));
+      this.pushResponse(messageId, 'error', this._sanitize(err.message));
     }
   }
 
+  _createSearchProcess(query, searchDir) {
+    try {
+      const rg = spawnSync('rg', ['--version'], { cwd: this.cwd, encoding: 'utf8' });
+      if (rg.status === 0) {
+        return spawn('rg', ['-n', '--glob', SEARCH_GLOB, query, searchDir], { cwd: this.cwd });
+      }
+    } catch {
+      // Fall back to the OS-native search tool below.
+    }
+
+    if (process.platform === 'win32') {
+      return spawn('findstr', ['/s', '/n', `/c:${query}`, join(searchDir, '*')], {
+        cwd: this.cwd,
+        shell: true,
+      });
+    }
+
+    return spawn('grep', [
+      '-rn', `--include=${SEARCH_GLOB}`,
+      query, searchDir
+    ], { cwd: this.cwd });
+  }
+
   startWatcher() {
     this.watcher = watch(this.cwd, {
       ignored: (path) => IGNORED_PATTERNS.some(p => path.includes(p)),
@@ -341,22 +425,23 @@ export class LucenaAgent {
 
     this.watcher.on('all', (event, filePath) => {
       const relPath = relative(this.cwd, filePath);
+      const normalizedRelPath = relPath.replace(/\\/g, '/');
       
       // Stop anything escaping local disk
-      if (!relPath || relPath.startsWith('..') || isAbsolute(relPath)) {
+      if (!normalizedRelPath || normalizedRelPath.startsWith('..') || isAbsolute(relPath)) {
         return; 
       }
 
       const changesRef = ref(this.db, `tunnels/${this.tunnelId}/fileChanges`);
       push(changesRef, {
         event,
-        path: relPath,
+        path: normalizedRelPath,
         timestamp: serverTimestamp()
       });
 
       // ── Push incremental index delta for changed files ──
       if (event === 'change' || event === 'add') {
-        this.pushIndexDelta(relPath).catch(() => {}); // Non-blocking, non-fatal
+        this.pushIndexDelta(normalizedRelPath).catch(() => {}); // Non-blocking, non-fatal
       }
     });
   }
@@ -376,4 +461,26 @@ export class LucenaAgent {
 
     this.connected = false;
   }
-}
+}
+
+function toBrowserPath(pathValue) {
+  return '/' + String(pathValue || '').replace(/\\/g, '/');
+}
+
+async function countTextFileLines(fullPath) {
+  if (!isTextLikeFile(fullPath)) return null;
+
+  try {
+    const info = await stat(fullPath);
+    if (info.size > 5 * 1024 * 1024) return null;
+    const content = await readFile(fullPath, 'utf-8');
+    if (!content) return 0;
+    return content.split('\n').length;
+  } catch {
+    return null;
+  }
+}
+
+function isTextLikeFile(filePath) {
+  return /\.(cjs|css|csv|go|html?|js|jsx|json|mdx?|mjs|py|rb|rs|sql|svg|ts|tsx|txt|xml|ya?ml)$/i.test(filePath);
+}

package/src/lucena-shell.js

@@ -0,0 +1,303 @@
+import { execaCommand } from 'execa';
+import { parse } from 'shell-quote';
+import { isAbsolute, resolve, relative } from 'path';
+
+const READ_ONLY_COMMANDS = new Set([
+  'awk', 'basename', 'cat', 'cd', 'curl', 'cut', 'dirname', 'echo', 'false', 'find',
+  'grep', 'head', 'ls', 'pwd', 'rg', 'sed', 'sort', 'tail', 'test', 'true',
+  'uniq', 'wc', 'which',
+  'dir', 'type', 'findstr', 'where', 'tree', 'more', 'clip', 'ver', 'vol',
+  'hostname', 'systeminfo',
+  'get-childitem', 'get-content', 'select-string', 'get-location',
+  'get-command', 'get-process', 'get-service', 'get-item', 'get-itemproperty',
+  'test-path', 'get-help', 'write-output', 'write-host',
+]);
+
+const READ_ONLY_GIT_SUBCOMMANDS = new Set([
+  'branch', 'diff', 'grep', 'log', 'ls-files', 'rev-parse', 'show', 'status',
+]);
+
+const CHAIN_OPERATORS = new Set(['&&', '||', ';', '|']);
+const WRITE_OPERATORS = new Set(['>', '>>', '<>', '>|', '<<', '<<-', '<<<']);
+const COMMANDS_WITH_PATH_OPERANDS = new Set([
+  'cat', 'chmod', 'chown', 'cp', 'find', 'grep', 'head', 'ls', 'mkdir', 'mv',
+  'rm', 'rmdir', 'sed', 'tail', 'touch', 'wc',
+]);
+
+export class LucenaShell {
+  constructor(workspaceRoot) {
+    this.workspaceRoot = resolve(workspaceRoot);
+    this.cwd = this.workspaceRoot;
+  }
+
+  analyze(rawCommand) {
+    const sanitized = sanitizeCommand(rawCommand);
+    const analysis = {
+      command: sanitized.command,
+      rejected: false,
+      rejectReason: '',
+      isReadOnly: true,
+      needsApproval: false,
+      touchesOutsideWorkspace: false,
+      reasons: [],
+      segments: [],
+    };
+
+    if (!sanitized.ok) {
+      return {
+        ...analysis,
+        rejected: true,
+        rejectReason: sanitized.reason,
+        isReadOnly: false,
+        needsApproval: true,
+      };
+    }
+
+    if (!sanitized.command) return analysis;
+
+    if (/`|\$\(/.test(sanitized.command)) {
+      analysis.isReadOnly = false;
+      analysis.needsApproval = true;
+      analysis.reasons.push('uses command substitution');
+    }
+
+    let tokens;
+    try {
+      tokens = parse(sanitized.command);
+    } catch (err) {
+      return {
+        ...analysis,
+        rejected: true,
+        rejectReason: err.message || 'Command could not be parsed.',
+        isReadOnly: false,
+        needsApproval: true,
+      };
+    }
+
+    let current = [];
+    for (const token of tokens) {
+      if (isOperator(token) && CHAIN_OPERATORS.has(token.op)) {
+        this._addSegmentAnalysis(analysis, current);
+        current = [];
+        continue;
+      }
+
+      if (isOperator(token) && WRITE_OPERATORS.has(token.op)) {
+        analysis.isReadOnly = false;
+        analysis.needsApproval = true;
+        analysis.reasons.push(`uses shell redirection (${token.op})`);
+      }
+
+      if (isOperator(token) && token.op === '&') {
+        analysis.isReadOnly = false;
+        analysis.needsApproval = true;
+        analysis.reasons.push('runs a background process');
+      }
+
+      current.push(token);
+    }
+    this._addSegmentAnalysis(analysis, current);
+
+    analysis.reasons = [...new Set(analysis.reasons)];
+    return analysis;
+  }
+
+  canExecute(rawCommand, options = {}) {
+    const mode = options.mode === 'yolo' ? 'yolo' : 'safe';
+    const approved = options.approved === true;
+    const outsideWorkspaceApproved = options.outsideWorkspaceApproved === true;
+    const analysis = this.analyze(rawCommand);
+
+    if (analysis.rejected) {
+      return { ok: false, analysis, reason: analysis.rejectReason };
+    }
+
+    if (analysis.isReadOnly) {
+      return { ok: true, analysis };
+    }
+
+    if (mode === 'safe' && !approved) {
+      return {
+        ok: false,
+        analysis,
+        reason: `Safe Mode blocked a mutating command. Approval is required. ${formatReasons(analysis.reasons)}`,
+      };
+    }
+
+    if (mode === 'yolo' && analysis.touchesOutsideWorkspace && !outsideWorkspaceApproved) {
+      return {
+        ok: false,
+        analysis,
+        reason: `YOLO Mode blocked an outside-workspace mutation. Approval is required. ${formatReasons(analysis.reasons)}`,
+      };
+    }
+
+    return { ok: true, analysis };
+  }
+
+  execute(rawCommand, options = {}) {
+    const decision = this.canExecute(rawCommand, options);
+    if (!decision.ok) {
+      const err = new Error(decision.reason);
+      err.analysis = decision.analysis;
+      throw err;
+    }
+
+    return execaCommand(decision.analysis.command, {
+      cwd: this.cwd,
+      shell: true,
+      reject: false,
+      preferLocal: true,
+      stdin: 'pipe',
+      env: {
+        LUCENA_WORKSPACE_ROOT: this.workspaceRoot,
+      },
+    });
+  }
+
+  _addSegmentAnalysis(analysis, tokens) {
+    const words = tokens.filter((token) => typeof token === 'string');
+    if (words.length === 0) return;
+
+    let index = 0;
+    while (words[index] && /^[A-Za-z_][A-Za-z0-9_]*=/.test(words[index])) {
+      index++;
+    }
+
+    const command = stripQuotes(words[index] || '').toLowerCase();
+    if (!command) return;
+
+    const segment = {
+      command,
+      words,
+      isReadOnly: true,
+      touchesOutsideWorkspace: false,
+    };
+    analysis.segments.push(segment);
+
+    if (command === 'cd') {
+      const target = words[index + 1] ? stripQuotes(words[index + 1]) : this.workspaceRoot;
+      const nextCwd = resolvePath(this.cwd, target);
+      if (!isInside(this.workspaceRoot, nextCwd)) {
+        segment.touchesOutsideWorkspace = true;
+        analysis.touchesOutsideWorkspace = true;
+        analysis.reasons.push(`changes directory outside workspace (${displayPath(this.workspaceRoot, nextCwd)})`);
+      }
+      return;
+    }
+
+    if (command === 'git') {
+      const subcommand = stripQuotes(words[index + 1] || '').toLowerCase();
+      if (!READ_ONLY_GIT_SUBCOMMANDS.has(subcommand)) {
+        markMutating(analysis, segment, subcommand ? `git ${subcommand} may modify state` : 'git command is incomplete');
+      }
+    } else if (command === 'curl' && words.slice(index + 1).some(isCurlWriteOption)) {
+      markMutating(analysis, segment, 'curl output options may write files');
+    } else if (command === 'sed' && words.some((word) => /^-.*i/.test(stripQuotes(word)))) {
+      markMutating(analysis, segment, 'sed in-place editing may modify files');
+    } else if (!READ_ONLY_COMMANDS.has(command)) {
+      markMutating(analysis, segment, `${command} is not classified as read-only`);
+    }
+
+    if (segment.isReadOnly) return;
+
+    const pathOperands = collectPathOperands(command, words.slice(index + 1));
+    if (pathOperands.length === 0 && !isInside(this.workspaceRoot, this.cwd)) {
+      segment.touchesOutsideWorkspace = true;
+      analysis.touchesOutsideWorkspace = true;
+      analysis.reasons.push('mutates from a working directory outside the workspace');
+      return;
+    }
+
+    for (const operand of pathOperands) {
+      const absolutePath = resolvePath(this.cwd, operand);
+      if (!isInside(this.workspaceRoot, absolutePath)) {
+        segment.touchesOutsideWorkspace = true;
+        analysis.touchesOutsideWorkspace = true;
+        analysis.reasons.push(`references outside-workspace path (${displayPath(this.workspaceRoot, absolutePath)})`);
+      }
+    }
+  }
+}
+
+function sanitizeCommand(rawCommand) {
+  const command = String(rawCommand || '').replace(/\r\n?/g, '\n').trim();
+
+  if (!command) return { ok: true, command };
+  if (command.length > 8000) {
+    return { ok: false, command, reason: 'Command is too long.' };
+  }
+  if (/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/.test(command)) {
+    return { ok: false, command, reason: 'Command contains unsupported control characters.' };
+  }
+
+  return { ok: true, command };
+}
+
+function isOperator(token) {
+  return token && typeof token === 'object' && typeof token.op === 'string';
+}
+
+function markMutating(analysis, segment, reason) {
+  segment.isReadOnly = false;
+  analysis.isReadOnly = false;
+  analysis.needsApproval = true;
+  analysis.reasons.push(reason);
+}
+
+function collectPathOperands(command, args) {
+  if (!COMMANDS_WITH_PATH_OPERANDS.has(command)) return [];
+  const operands = [];
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = stripQuotes(args[i]);
+    if (!arg || arg === '--') continue;
+
+    if (arg.startsWith('-')) {
+      if (optionConsumesNext(command, arg)) i++;
+      continue;
+    }
+
+    if (looksLikePath(arg)) operands.push(arg);
+  }
+
+  return operands;
+}
+
+function optionConsumesNext(command, option) {
+  if (command === 'find' && ['-name', '-path', '-type', '-maxdepth', '-mindepth'].includes(option)) return true;
+  if (command === 'grep' && ['-e', '-f', '--exclude', '--include'].includes(option)) return true;
+  return false;
+}
+
+function isCurlWriteOption(word) {
+  const option = stripQuotes(word);
+  return option === '-o' || option === '-O' || option === '-J' || option === '--output' || option === '--remote-name' || option === '--remote-header-name' || option.startsWith('--output=');
+}
+
+function looksLikePath(value) {
+  if (!value) return false;
+  if (value.includes('*') || value.includes('?') || value.includes('[')) return true;
+  return value === '.' || value === '..' || value.startsWith('/') || value.startsWith('./') || value.startsWith('../') || value.includes('/');
+}
+
+function resolvePath(cwd, value) {
+  return isAbsolute(value) ? resolve(value) : resolve(cwd, value);
+}
+
+function isInside(root, candidate) {
+  const rel = relative(root, candidate);
+  return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
+}
+
+function displayPath(root, absolutePath) {
+  return isInside(root, absolutePath) ? `/${relative(root, absolutePath)}` : absolutePath;
+}
+
+function stripQuotes(value) {
+  return String(value).replace(/^["']|["']$/g, '');
+}
+
+function formatReasons(reasons) {
+  return reasons.length ? `Reasons: ${reasons.join('; ')}.` : '';
+}

package/src/main.js

@@ -63,7 +63,7 @@ export async function main() {
     const border = '─'.repeat(boxWidth);
     
     console.log(`  ${c.dim}┌${border}┐${c.reset}`);
-    console.log(`  ${c.dim}│${c.reset}  ${c.dim}${idLabel}${c.reset} ${c.bold}${c.cyan}${tunnelId}${c.reset}  ${c.dim}│${c.reset}`);
+    console.log(`  ${c.dim}│${c.reset}  ${idLabel}${c.reset} ${c.bold}${tunnelId}${c.reset}  ${c.dim}│${c.reset}`);
     console.log(`  ${c.dim}└${border}┘${c.reset}`);
 
     const webUrl = `https://lucenacoder.com/?tunnel=${tunnelId}`;
@@ -73,7 +73,7 @@ export async function main() {
     const urlBorder = '─'.repeat(urlBoxWidth);
     
     console.log(`\n  ${c.dim}┌${urlBorder}┐${c.reset}`);
-    console.log(`  ${c.dim}│${c.reset}  ${c.dim}${urlLabel}${c.reset} ${c.cyan}${webUrl}${c.reset}  ${c.dim}│${c.reset}`);
+    console.log(`  ${c.dim}│${c.reset}  ${urlLabel}${c.reset} ${c.bold}${webUrl}${c.reset}  ${c.dim}│${c.reset}`);
     console.log(`  ${c.dim}└${urlBorder}┘${c.reset}`);
     
     console.log(`\n  ${c.dim}Open the URL above in your browser to connect.${c.reset}`);
@@ -82,4 +82,4 @@ export async function main() {
     console.error(`\n  ${c.yellow}✖ Failed to start tunnel: ${err.message}${c.reset}\n`);
     process.exit(1);
   }
-}
+}

package/.WorkspaceBrain/workspace.json

@@ -1,4 +0,0 @@
-{
-  "name": "lucenacoder",
-  "createdAt": "2026-05-24T01:17:13.939Z"
-}