@lucenaone/coder 1.0.0

package/README.md

@@ -0,0 +1,33 @@
+# 🌴 Lucena Coder Local Tunnel
+
+**The official local connection agent for [LucenaCoder.com](https://lucenacoder.com).**
+
+Create a private, secure tunnel connecting your browser-based AI coding assistant directly to your local filesystem. 
+
+## Quick Start
+
+Navigate to the project folder you want the AI to work on, and run the tunnel:
+
+```bash
+cd your-project
+npx lucenacoder
+```
+
+## How it Works
+
+1. **Run the Command**: The agent connects to the Lucena real-time relay.
+2. **Get your Tunnel ID**: The terminal will print a secure `Tunnel ID`. 
+3. **Connect**: Paste this ID into your LucenaCoder.com workspace.
+4. **Code**: The AI can now read files, propose edits, and run terminal commands **strictly scoped** to that folder.
+
+## 🛡️ Built for Safety
+
+Giving an AI access to your machine should be done securely. 
+
+* **Folder Scoped**: The tunnel is strictly jailed to the directory where you executed the command. It cannot access files outside of this workspace.
+* **Safe Mode by Default**: Every file edit and terminal command requires your explicit approval before executing. 
+* **YOLO Mode**: Fully trust the AI for a specific task? You can optionally toggle YOLO mode from the web interface for hands-free, autonomous coding.
+
+## Requirements
+
+- Node.js 18+

package/bin/lucena.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { main } from '../src/main.js';
+main().catch((err) => {
+  console.error('\n  ✖ ' + (err.message || err));
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@lucenaone/coder",
+  "version": "1.0.0",
+  "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"
+  },
+  "scripts": {
+    "start": "node bin/lucena.js"
+  },
+  "dependencies": {
+    "firebase": "^11.0.0",
+    "chokidar": "^4.0.0"
+  },
+  "keywords": ["lucena", "lucenacoder", "tunnel", "lucenaone"],
+  "author": "LucenaOne",
+  "license": "MIT"
+}

package/src/agent.js

@@ -0,0 +1,265 @@
+import { initializeApp } from 'firebase/app';
+import { getDatabase, ref, push, set, onChildAdded, onDisconnect, serverTimestamp, remove, get } from 'firebase/database';
+import { spawn } 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 } from 'path';
+import { existsSync } from 'fs';
+import { FIREBASE_CONFIG } from './config.js';
+
+const IGNORED_PATTERNS = [
+  'node_modules', '.git', '.next', '.wrangler', '.DS_Store',
+  'dist', 'build', '.cache', '.turbo', '.vercel', '.firebase', 'Users'
+];
+
+// ── The CLI Jailer ──
+function getJailedPath(baseDir, rawPath) {
+  let p = rawPath.replace(/\\/g, '/');
+  
+  // If the AI hallucinates the absolute path of the workspace, dynamically strip it out
+  const normalizedBase = baseDir.replace(/\\/g, '/');
+  if (p.startsWith(normalizedBase)) {
+    p = p.slice(normalizedBase.length);
+  }
+  
+  // Strip leading slashes to force relative resolution
+  p = p.replace(/^\/+/, '');
+  
+  const parts = p.split('/').filter(part => part !== '.' && part !== '');
+  const safeParts = [];
+  
+  for (const part of parts) {
+    if (part === '..') safeParts.pop(); // Traversal clamping
+    else safeParts.push(part);
+  }
+  
+  return resolve(baseDir, safeParts.join('/'));
+}
+
+export class LucenaAgent {
+  constructor(cwd) {
+    this.cwd = resolve(cwd);
+    this.tunnelId = crypto.randomUUID();
+    this.app = null;
+    this.db = null;
+    this.watcher = null;
+    this.activeCommands = new Map();
+    this.connected = false;
+  }
+
+  async start() {
+    this.app = initializeApp(FIREBASE_CONFIG, `agent-${this.tunnelId}`);
+    this.db = getDatabase(this.app);
+    const tunnelRef = ref(this.db, `tunnels/${this.tunnelId}`);
+
+    await set(tunnelRef, {
+      meta: {
+        createdAt: serverTimestamp(),
+        cwd: this.cwd,
+        cwdName: basename(this.cwd),
+        status: 'active',
+        pid: process.pid,
+        platform: process.platform
+      }
+    });
+
+    onChildAdded(ref(this.db, `.info`), () => {}); 
+    const presenceRef = ref(this.db, `tunnels/${this.tunnelId}/meta/online`);
+    await set(presenceRef, true);
+    onDisconnect(presenceRef).set(false);
+    onDisconnect(ref(this.db, `tunnels/${this.tunnelId}/meta/status`)).set('disconnected');
+
+    const commandsRef = ref(this.db, `tunnels/${this.tunnelId}/commands`);
+    onChildAdded(commandsRef, async (snapshot) => {
+      const command = snapshot.val();
+      if (!command) return;
+      remove(snapshot.ref);
+
+      try {
+        await this.handleCommand(command);
+      } catch (err) {
+        this.pushResponse(command.messageId, 'error', err.message);
+      }
+    });
+
+    this.startWatcher();
+    this.connected = true;
+    return this.tunnelId;
+  }
+
+  async handleCommand(command) {
+    const { type, messageId } = command;
+    switch (type) {
+      case 'execute': return this.executeCommand(command);
+      case 'read_file': return this.readFileCmd(command);
+      case 'write_file': return this.writeFileCmd(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 'ping': return this.pushResponse(messageId, 'pong', '');
+      default: return this.pushResponse(messageId, 'error', `Unknown command type: ${type}`);
+    }
+  }
+
+  pushResponse(messageId, type, text, extra = {}) {
+    const responsesRef = ref(this.db, `tunnels/${this.tunnelId}/responses`);
+    push(responsesRef, {
+      messageId,
+      type,
+      text,
+      timestamp: serverTimestamp(),
+      ...extra
+    });
+  }
+
+  async executeCommand({ messageId, command }) {
+    const child = spawn('sh', ['-c', command], { cwd: this.cwd });
+
+    child.stdout.on('data', (data) => this.pushResponse(messageId, 'output', data.toString()));
+    child.stderr.on('data', (data) => this.pushResponse(messageId, 'output', data.toString()));
+    child.on('close', (code) => {
+      this.pushResponse(messageId, 'done', '', { exitCode: code ?? 0 });
+      this.activeCommands.delete(messageId);
+    });
+
+    this.activeCommands.set(messageId, child);
+  }
+
+  async readFileCmd({ messageId, path: filePath }) {
+    const fullPath = getJailedPath(this.cwd, filePath);
+    try {
+      const content = await readFile(fullPath, 'utf-8');
+      this.pushResponse(messageId, 'output', content);
+      this.pushResponse(messageId, 'done', '');
+    } catch (err) {
+      this.pushResponse(messageId, 'error', err.message);
+    }
+  }
+
+  async writeFileCmd({ messageId, path: filePath, content }) {
+    const fullPath = getJailedPath(this.cwd, filePath);
+    try {
+      await mkdir(dirname(fullPath), { recursive: true });
+      await writeFile(fullPath, content, 'utf-8');
+      this.pushResponse(messageId, 'done', `Wrote ${fullPath}`);
+    } catch (err) {
+      this.pushResponse(messageId, 'error', err.message);
+    }
+  }
+
+  async listDir({ messageId, path: dirPath }) {
+    const fullPath = getJailedPath(this.cwd, dirPath || '.');
+    try {
+      const entries = await readdir(fullPath, { withFileTypes: true });
+      const listing = entries
+        .filter(e => !IGNORED_PATTERNS.includes(e.name))
+        .map(e => `${e.isDirectory() ? 'dir' : 'file'}\t${e.name}`)
+        .join('\n');
+      this.pushResponse(messageId, 'done', listing || '(empty)');
+    } catch (err) {
+      this.pushResponse(messageId, 'error', err.message);
+    }
+  }
+
+  async statFile({ messageId, path: filePath }) {
+    const fullPath = getJailedPath(this.cwd, filePath);
+    try {
+      const s = await stat(fullPath);
+      this.pushResponse(messageId, 'done', JSON.stringify({
+        size: s.size,
+        isFile: s.isFile(),
+        isDir: s.isDirectory(),
+        modified: s.mtime,
+        created: s.birthtime
+      }));
+    } catch (err) {
+      this.pushResponse(messageId, 'error', err.message);
+    }
+  }
+
+  async deleteFile({ messageId, path: filePath }) {
+    const fullPath = getJailedPath(this.cwd, filePath);
+    try {
+      if ((await stat(fullPath)).isDirectory()) {
+        await rm(fullPath, { recursive: true });
+      } else {
+        await unlink(fullPath);
+      }
+      this.pushResponse(messageId, 'done', `Deleted ${fullPath}`);
+    } catch (err) {
+      this.pushResponse(messageId, 'error', err.message);
+    }
+  }
+
+  async mkdirCmd({ messageId, path: dirPath }) {
+    const fullPath = getJailedPath(this.cwd, dirPath);
+    try {
+      await mkdir(fullPath, { recursive: true });
+      this.pushResponse(messageId, 'done', `Created ${fullPath}`);
+    } catch (err) {
+      this.pushResponse(messageId, 'error', 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 });
+
+      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', output || 'No matches found');
+      });
+    } catch (err) {
+      this.pushResponse(messageId, 'error', err.message);
+    }
+  }
+
+  startWatcher() {
+    this.watcher = watch(this.cwd, {
+      ignored: (path) => IGNORED_PATTERNS.some(p => path.includes(p)),
+      persistent: true,
+      ignoreInitial: true
+    });
+
+    this.watcher.on('all', (event, filePath) => {
+      const relPath = relative(this.cwd, filePath);
+      
+      // Stop anything escaping local disk
+      if (!relPath || relPath.startsWith('..') || isAbsolute(relPath)) {
+        return; 
+      }
+
+      const changesRef = ref(this.db, `tunnels/${this.tunnelId}/fileChanges`);
+      push(changesRef, {
+        event,
+        path: relPath,
+        timestamp: serverTimestamp()
+      });
+    });
+  }
+
+  async shutdown() {
+    for (const [messageId, child] of this.activeCommands) {
+      child.kill('SIGTERM');
+      this.pushResponse(messageId, 'error', 'Command killed: tunnel shutting down');
+    }
+    this.activeCommands.clear();
+
+    if (this.watcher) await this.watcher.close();
+    if (this.db) {
+      await set(ref(this.db, `tunnels/${this.tunnelId}/meta/online`), false);
+      await set(ref(this.db, `tunnels/${this.tunnelId}/meta/status`), 'disconnected');
+    }
+
+    this.connected = false;
+  }
+}

package/src/config.js

@@ -0,0 +1,10 @@
+// src/config.js — Realtime Relay
+export const FIREBASE_CONFIG = {
+  apiKey: "AIzaSyBn8sdlbO2dJH1RQYqoQVfN5r0Wq3l6M8E",
+  authDomain: "poweredbyevok.firebaseapp.com",
+  databaseURL: "https://lucena-tunnel.firebaseio.com",
+  projectId: "poweredbyevok",
+  storageBucket: "poweredbyevok.appspot.com",
+  messagingSenderId: "726544861905",
+  appId: "1:726544861905:web:20e5e35a0d6069ee2913f0"
+};

package/src/main.js

@@ -0,0 +1,84 @@
+// src/main.js — CLI entry point for the Lucena agent
+import { LucenaAgent } from './agent.js';
+import { basename } from 'path';
+import { exec } from 'child_process';
+
+// Standard ANSI Terminal Colors
+const c = {
+  cyan: '\x1b[36m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  dim: '\x1b[90m',
+  bold: '\x1b[1m',
+  reset: '\x1b[0m'
+};
+
+const BANNER = `
+${c.green}⠀⠀⠀⠀⠀⠀⠀⣀⣀⣀⣀⣀⣀⡀
+⠀⠀⠀⠀⠀⠀⠀⠀⠉⠙⠻⢿⣿⣿⣷⣄
+⠀⠀⠀⠀⠀⠀⣀⣤⣶⣶⣦⣄⠙⣿⣿⣿⣇⣠⣶⣾⣿⣷⣶⣶⠄
+⠀⠀⠀⠀⣠⣾⣿⣿⣿⣿⣿⣿⣷⣼⣿⣿⣿⣿⣿⣿⣿⠟⠋
+⠀⠀⠀⠘⠛⠉⠉⠉⠁⠉⠉⠛⢿⣿⣿⣿⣿⣿⣿⣷⣶⣶⣤⣀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣴⣿⠿⠛⢿⣿⣿⣿⣿⣟⠛⠻⢿⣷⣦⡀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣾⡿⠁⠀⠀⢸⣿⣿⡿⠻⣿⣷⡀⠀⠉⠻⢷
+⠀⠀⠀⠀⠀⠀⠀⠀⢠⣿⡿⠁⠀⠀⠀⠸⣿⡿⠁⠀⠈⢿⣇${c.reset}
+${c.dim}⠀⠀⠀⠀⠀⠀⠀⢠⣿⣿⠁${c.reset}${c.green}⠀⠀⠀⠀⠀⠉⠀⠀⠀⠀⠀⠏${c.reset}
+${c.dim}⠀⠀⠀⠀⠀⠀⢠⣿⣿⠇${c.reset}       ${c.bold}L U C E N A${c.reset}
+${c.dim}⠀⠀⠀⠀⠀⢀⣾⣿⡟${c.reset}        ${c.bold} C O D E R${c.reset}
+${c.dim}⠀⠀⠀⠀⠀⣼⣿⣿⠃${c.reset}        ${c.cyan}${c.bold} L O C A L${c.reset}
+${c.dim}⠀⠀⠀⠀⢠⣿⣿⡟${c.reset}         ${c.cyan}${c.bold}T U N N E L${c.reset}
+${c.dim}⠀⠀⠀⠀⣼⣿⣿⠃${c.reset}
+${c.dim}⠀⠀⠀⠀⠈⠛⠉${c.reset}
+
+${c.dim}  =========================================${c.reset}
+  Connect your LucenaCoder.com session
+  to your local folders.
+`;
+
+export async function main() {
+  const cwd = process.cwd();
+
+  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`);
+  console.log(`  Starting tunnel...`);
+
+  const agent = new LucenaAgent(cwd);
+
+  const shutdown = async () => {
+    console.log(`\n  ${c.dim}Shutting down tunnel...${c.reset}`);
+    await agent.shutdown();
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  try {
+    const tunnelId = await agent.start();
+    console.log(`\n  ${c.green}✔ Tunnel active!${c.reset}\n`);
+    
+    const idLabel = "Tunnel ID:";
+    const boxWidth = idLabel.length + tunnelId.length + 5;
+    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}└${border}┘${c.reset}`);
+
+    const webUrl = `https://lucenacoder.com/?tunnel=${tunnelId}`;
+    console.log(`\n  ${c.dim}Opening browser to your workspace...${c.reset}`);
+    
+    const startCmd = process.platform === 'darwin' ? 'open' 
+                   : process.platform === 'win32' ? 'start' 
+                   : 'xdg-open';
+                   
+    exec(`${startCmd} "${webUrl}"`);
+    
+    console.log(`\n  ${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`);
+    process.exit(1);
+  }
+}