@lucenaone/coder 1.1.16 → 1.1.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucenaone/coder",
-  "version": "1.1.16",
+  "version": "1.1.18",
   "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,6 +8,7 @@ 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',
@@ -67,6 +68,7 @@ export class LucenaAgent {
     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.browserConnected = false;
     this.shell = new LucenaShell(this.cwd);
   }
 
@@ -108,6 +110,9 @@ export class LucenaAgent {
       this.indexData = result;
       const { stats } = result;
       process.stdout.write(`\r  ${'\x1b[32m'}✔ Indexed ${stats.filesParsed} files — ${stats.symbolCount} symbols, ${stats.stringCount} strings${'\x1b[0m'}  \n`);
+      if (this.browserConnected && this.db) {
+        this.pushIndexSnapshot(result);
+      }
       return result;
     }).catch((err) => {
       console.warn(`\n  ${'\x1b[33m'}⚠ Indexing failed: ${err.message}${'\x1b[0m'}`);
@@ -140,13 +145,18 @@ export class LucenaAgent {
       const data = snapshot.val();
       if (!data) return;
       remove(snapshot.ref);
+      this.browserConnected = true;
       
       // Browser tells us whether to strip cwd from output
       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) {
         this.pushIndexSnapshot(this.indexData);
       }
@@ -168,10 +178,6 @@ export class LucenaAgent {
     this.startWatcher();
     this.connected = true;
 
-    // ── Wait for indexing to finish before opening the browser ──
-    // This guarantees the snapshot is ready the instant the browser connects
-    await this.indexPromise;
-
     return this.tunnelId;
   }
 
@@ -218,11 +224,18 @@ export class LucenaAgent {
       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, {

package/src/main.js

@@ -1,5 +1,7 @@
 // src/main.js — CLI entry point for the Lucena agent
 import { LucenaAgent } from './agent.js';
+import { spawn } from 'child_process';
+import { registerProTunnel, validateStoredProToken } from './pro-token.js';
 import { basename } from 'path';
 
 
@@ -35,18 +37,45 @@ ${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();
+  let activeTunnelId = null;
 
   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);
 
   const shutdown = async () => {
     console.log(`\n  ${c.dim}Shutting down tunnel...${c.reset}`);
+    if (proStatus.valid && activeTunnelId) {
+      await registerProTunnel({
+        tokenForPro: proStatus.stored?.tokenForPro,
+        tunnelId: activeTunnelId,
+        cwdName: basename(cwd),
+        platform: process.platform,
+        pid: process.pid,
+        status: 'disconnected',
+        online: false,
+      });
+    }
     await agent.shutdown();
     process.exit(0);
   };
@@ -56,6 +85,21 @@ export async function main() {
 
   try {
     const tunnelId = await agent.start();
+    activeTunnelId = tunnelId;
+    if (proStatus.valid) {
+      const registered = await registerProTunnel({
+        tokenForPro: proStatus.stored?.tokenForPro,
+        tunnelId,
+        cwdName: basename(cwd),
+        platform: process.platform,
+        pid: process.pid,
+      });
+      if (registered.ok) {
+        console.log(`  ${c.cyan}RemoteControl registered.${c.reset} This run is visible on rc.lucenacoder.com.`);
+      } else {
+        console.log(`  ${c.yellow}RemoteControl registration failed.${c.reset} ${registered.error || 'Run will not appear in the remote list.'}`);
+      }
+    }
     console.log(`  ${c.green}✔ Tunnel active!${c.reset}\n`);
     
     const idLabel = "Tunnel ID:";
@@ -72,11 +116,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,75 @@
+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';
+const REGISTER_TUNNEL_URL = process.env.LUCENA_REGISTER_TUNNEL_URL || 'https://lucenacoder.com/api/remote/register-tunnel';
+
+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 };
+  }
+}
+
+export async function registerProTunnel({ tokenForPro, tunnelId, cwdName, platform, pid, source = 'local-npx', status = 'active', online = true }) {
+  if (!tokenForPro || !tunnelId) return { ok: false };
+
+  try {
+    const response = await fetch(REGISTER_TUNNEL_URL, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        tokenForPro,
+        tunnelId,
+        cwdName,
+        displayName: cwdName,
+        platform,
+        pid,
+        source,
+        status,
+        online,
+      }),
+    });
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok) return { ok: false, ...payload };
+    return { ok: true, ...payload };
+  } catch {
+    return { ok: false };
+  }
+}