@lucenaone/coder 1.1.6 → 1.1.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucenaone/coder",
-  "version": "1.1.6",
+  "version": "1.1.17",
   "description": "Private tunnel for connecting LucenaCoder.com to your local folder. Always remains folder scoped while providing full terminal access.",
   "type": "module",
   "bin": {

package/src/agent.js

@@ -8,10 +8,13 @@ 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';
+import { storeProToken } from './pro-token.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}';
@@ -143,6 +146,11 @@ export class LucenaAgent {
       if (typeof data.stripCwd === 'boolean') {
         this.stripCwd = data.stripCwd;
       }
+
+      if (data.proToken) {
+        await storeProToken({ tokenForPro: data.proToken, email: data.proEmail });
+        console.log(`  ${'\x1b[36m'}PRO token stored. Future runs can auto-launch.${'\x1b[0m'}`);
+      }
       
       // Index is guaranteed ready (awaited in start()), push immediately
       if (this.indexData) {
@@ -210,16 +218,24 @@ 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);
       case 'mkdir': return this.mkdirCmd(command);
       case 'search': return this.searchCodebase(command);
+      case 'store_pro_token': return this.storeProTokenCmd(command);
       case 'ping': return this.pushResponse(messageId, 'pong', '');
       default: return this.pushResponse(messageId, 'error', `Unknown command type: ${type}`);
     }
   }
 
+  async storeProTokenCmd({ messageId, tokenForPro, email }) {
+    if (!tokenForPro) return this.pushResponse(messageId, 'error', 'tokenForPro is required');
+    await storeProToken({ tokenForPro, email });
+    this.pushResponse(messageId, 'done', 'PRO token stored');
+  }
+
   pushResponse(messageId, type, text, extra = {}) {
     const responsesRef = ref(this.db, `tunnels/${this.tunnelId}/responses`);
     push(responsesRef, {
@@ -272,7 +288,7 @@ export class LucenaAgent {
 
   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');
@@ -296,6 +312,38 @@ export class LucenaAgent {
     }
   }
 
+  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 }) {
     const fullPath = getJailedPath(this.cwd, filePath);
     try {
@@ -314,7 +362,7 @@ export class LucenaAgent {
 
   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 });
@@ -329,7 +377,7 @@ export class LucenaAgent {
 
   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}`);
@@ -390,22 +438,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
       }
     });
   }
@@ -426,3 +475,25 @@ 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/main.js

@@ -1,6 +1,7 @@
 // src/main.js — CLI entry point for the Lucena agent
 import { LucenaAgent } from './agent.js';
-import { basename } from 'path';
+import { spawn } from 'child_process';
+import { validateStoredProToken } from './pro-token.js';
 
 
 // Standard ANSI Terminal Colors
@@ -35,13 +36,28 @@ ${c.dim}  =========================================${c.reset}
   to your local folders.
 `;
 
+function openBrowser(url) {
+  const command = process.platform === 'darwin'
+    ? 'open'
+    : process.platform === 'win32'
+      ? 'cmd'
+      : 'xdg-open';
+  const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+  const child = spawn(command, args, { detached: true, stdio: 'ignore' });
+  child.unref();
+}
+
 export async function main() {
   const cwd = process.cwd();
+  const proStatus = await validateStoredProToken();
 
   console.log(BANNER);
   console.log(`  ${c.cyan}📍 Scoped to:${c.reset} ${cwd}`);
   console.log(`  ${c.yellow}🛡️  Safe Mode:${c.reset} ON by default (All edits require approval)`);
   console.log(`               ${c.dim}Optionally switch to YOLO on LucenaCoder.com${c.reset}\n`);
+  if (proStatus.valid) {
+    console.log(`  ${c.cyan}PRO detected.${c.reset} Browser auto-launch enabled.\n`);
+  }
 
   const agent = new LucenaAgent(cwd);
 
@@ -72,11 +88,22 @@ export async function main() {
     const urlBoxWidth = urlLabel.length + webUrl.length + 5;
     const urlBorder = '─'.repeat(urlBoxWidth);
     
+    if (proStatus.valid) {
+      try {
+        openBrowser(webUrl);
+        console.log(`\n  ${c.green}✔ Opening LucenaCoder...${c.reset}`);
+      } catch {
+        console.log(`\n  ${c.yellow}Could not auto-open your browser.${c.reset}`);
+      }
+    }
+
     console.log(`\n  ${c.dim}┌${urlBorder}┐${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}`);
+
+    if (!proStatus.valid) {
+      console.log(`\n  ${c.dim}Open the URL above in your browser to connect.${c.reset}`);
+    }
     console.log(`  ${c.dim}Press Ctrl+C to disconnect${c.reset}\n`);
   } catch (err) {
     console.error(`\n  ${c.yellow}✖ Failed to start tunnel: ${err.message}${c.reset}\n`);

package/src/pro-token.js

@@ -0,0 +1,47 @@
+import { mkdir, readFile, writeFile } from 'fs/promises';
+import { dirname, join } from 'path';
+import { homedir } from 'os';
+
+const TOKEN_PATH = join(homedir(), '.lucenacoder', 'pro.json');
+const VALIDATE_URL = process.env.LUCENA_VALIDATE_PRO_URL || 'https://lucenacoder.com/api/pro/validate-token';
+
+export async function readStoredProToken() {
+  try {
+    const raw = await readFile(TOKEN_PATH, 'utf-8');
+    const data = JSON.parse(raw);
+    if (!data?.tokenForPro) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+
+export async function storeProToken({ tokenForPro, email }) {
+  if (!tokenForPro) return null;
+  const data = {
+    tokenForPro,
+    email: email || '',
+    savedAt: new Date().toISOString(),
+  };
+  await mkdir(dirname(TOKEN_PATH), { recursive: true });
+  await writeFile(TOKEN_PATH, JSON.stringify(data, null, 2), 'utf-8');
+  return data;
+}
+
+export async function validateStoredProToken() {
+  const stored = await readStoredProToken();
+  if (!stored?.tokenForPro) return { valid: false };
+
+  try {
+    const response = await fetch(VALIDATE_URL, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ tokenForPro: stored.tokenForPro }),
+    });
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok || !payload.valid) return { valid: false, stored };
+    return { valid: true, stored, ...payload };
+  } catch {
+    return { valid: false, stored };
+  }
+}