loom-agent 1.2.36 → 1.3.2

package/src/connectors/deploy.js

@@ -0,0 +1,390 @@
+// Deployment connectors — Vercel, Netlify, Cloudflare Pages, Railway, Render, Fly.io
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { execSync, spawn } = require('child_process');
+
+const CONFIG_DIR = process.env.LOOM_CONFIG_DIR || path.join(require('os').homedir(), '.loom');
+const CONNECTORS_FILE = path.join(CONFIG_DIR, 'connectors.json');
+
+function loadConnectors() {
+    try {
+        if (fs.existsSync(CONNECTORS_FILE)) {
+            return JSON.parse(fs.readFileSync(CONNECTORS_FILE, 'utf8'));
+        }
+    } catch {}
+    return { supabase: {}, convex: {}, deploy: {} };
+}
+
+function saveConnectors(cfg) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(CONNECTORS_FILE, JSON.stringify(cfg, null, 2));
+}
+
+function getDeployConfig() {
+    const cfg = loadConnectors();
+    return cfg.deploy || {};
+}
+
+function setDeployConfig(config) {
+    const cfg = loadConnectors();
+    cfg.deploy = { ...cfg.deploy, ...config };
+    saveConnectors(cfg);
+}
+
+// Vercel deployment
+async function deployVercel(projectPath, options = {}) {
+    const config = getDeployConfig();
+    if (!config.vercel?.token) {
+        throw new Error('Vercel not configured. Run: loom connectors deploy vercel --token <token>');
+    }
+    
+    const vercelCli = path.join(projectPath, 'node_modules', '.bin', 'vercel');
+    const hasVercel = fs.existsSync(vercelCli) || await which('vercel');
+    
+    if (!hasVercel) {
+        // Install vercel CLI locally
+        execSync('npm install -D vercel', { cwd: projectPath, stdio: 'inherit' });
+    }
+    
+    const args = ['--token', config.vercel.token, '--yes'];
+    if (config.vercel.org) args.push('--scope', config.vercel.org);
+    if (options.prod) args.push('--prod');
+    if (options.buildCommand) args.push('--build-command', options.buildCommand);
+    if (options.outputDir) args.push('--output-dir', options.outputDir);
+    
+    const result = execSync(`vercel ${args.join(' ')}`, { 
+        cwd: projectPath, 
+        stdio: 'pipe',
+        env: { ...process.env, VERCEL_TOKEN: config.vercel.token }
+    });
+    
+    const output = result.toString();
+    const urlMatch = output.match(/https:\/\/[^\s]+/);
+    return { url: urlMatch ? urlMatch[0] : null, output };
+}
+
+// Netlify deployment
+async function deployNetlify(projectPath, options = {}) {
+    const config = getDeployConfig();
+    if (!config.netlify?.authToken) {
+        throw new Error('Netlify not configured. Run: loom connectors deploy netlify --auth-token <token>');
+    }
+    
+    const netlifyCli = path.join(projectPath, 'node_modules', '.bin', 'netlify');
+    const hasNetlify = fs.existsSync(netlifyCli) || await which('netlify');
+    
+    if (!hasNetlify) {
+        execSync('npm install -D netlify-cli', { cwd: projectPath, stdio: 'inherit' });
+    }
+    
+    const args = ['deploy', '--auth', config.netlify.authToken];
+    if (config.netlify.siteId) args.push('--site', config.netlify.siteId);
+    if (options.prod) args.push('--prod');
+    if (options.dir) args.push('--dir', options.dir);
+    
+    const result = execSync(`netlify ${args.join(' ')}`, { 
+        cwd: projectPath, 
+        stdio: 'pipe',
+        env: { ...process.env, NETLIFY_AUTH_TOKEN: config.netlify.authToken }
+    });
+    
+    const output = result.toString();
+    const urlMatch = output.match(/https:\/\/[^\s]+/);
+    return { url: urlMatch ? urlMatch[0] : null, output };
+}
+
+// Cloudflare Pages deployment
+async function deployCloudflarePages(projectPath, options = {}) {
+    const config = getDeployConfig();
+    if (!config.cloudflare?.apiToken || !config.cloudflare?.accountId) {
+        throw new Error('Cloudflare not configured. Run: loom connectors deploy cloudflare --api-token <token> --account-id <id>');
+    }
+    
+    const wranglerCli = path.join(projectPath, 'node_modules', '.bin', 'wrangler');
+    const hasWrangler = fs.existsSync(wranglerCli) || await which('wrangler');
+    
+    if (!hasWrangler) {
+        execSync('npm install -D wrangler', { cwd: projectPath, stdio: 'inherit' });
+    }
+    
+    // For Pages, use wrangler pages deploy
+    const args = ['pages', 'deploy', options.dir || '.', 
+        '--project-name', options.projectName || path.basename(projectPath),
+        '--branch', options.branch || 'main',
+        '--commit-hash', getGitHash(projectPath)];
+    
+    const result = execSync(`wrangler ${args.join(' ')}`, { 
+        cwd: projectPath, 
+        stdio: 'pipe',
+        env: { ...process.env, CF_API_TOKEN: config.cloudflare.apiToken, CF_ACCOUNT_ID: config.cloudflare.accountId }
+    });
+    
+    return { url: `https://${options.projectName}.pages.dev`, output: result.toString() };
+}
+
+// Railway deployment
+async function deployRailway(projectPath, options = {}) {
+    const config = getDeployConfig();
+    if (!config.railway?.token) {
+        throw new Error('Railway not configured. Run: loom connectors deploy railway --token <token>');
+    }
+    
+    const railwayCli = path.join(projectPath, 'node_modules', '.bin', 'railway');
+    const hasRailway = fs.existsSync(railwayCli) || await which('railway');
+    
+    if (!hasRailway) {
+        execSync('npm install -D @railway/cli', { cwd: projectPath, stdio: 'inherit' });
+    }
+    
+    const args = ['up', '--detach'];
+    if (config.railway.project) args.push('--project', config.railway.project);
+    if (config.railway.environment) args.push('--environment', config.railway.environment);
+    
+    const result = execSync(`railway ${args.join(' ')}`, { 
+        cwd: projectPath, 
+        stdio: 'pipe',
+        env: { ...process.env, RAILWAY_TOKEN: config.railway.token }
+    });
+    
+    return { url: null, output: result.toString() };
+}
+
+// Render deployment
+async function deployRender(projectPath, options = {}) {
+    const config = getDeployConfig();
+    if (!config.render?.apiKey) {
+        throw new Error('Render not configured. Run: loom connectors deploy render --api-key <key>');
+    }
+    
+    // Render uses API-based deployment
+    const response = await fetch('https://api.render.com/v1/services', {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${config.render.apiKey}`,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+            type: 'web_service',
+            name: options.name || path.basename(projectPath),
+            repo: options.repoUrl,
+            branch: options.branch || 'main',
+            buildCommand: options.buildCommand || 'npm run build',
+            startCommand: options.startCommand || 'npm start',
+            envVars: options.envVars || []
+        })
+    });
+    
+    if (!response.ok) throw new Error(`Render deployment failed: ${await response.text()}`);
+    return await response.json();
+}
+
+// Fly.io deployment
+async function deployFly(projectPath, options = {}) {
+    const config = getDeployConfig();
+    if (!config.fly?.token) {
+        throw new Error('Fly.io not configured. Run: loom connectors deploy fly --token <token>');
+    }
+    
+    const flyCli = path.join(projectPath, 'node_modules', '.bin', 'flyctl');
+    const hasFly = fs.existsSync(flyCli) || await which('flyctl');
+    
+    if (!hasFly) {
+        // Install flyctl
+        if (process.platform === 'win32') {
+            execSync('powershell -Command "iwr https://fly.io/install.ps1 -useb | iex"', { stdio: 'inherit' });
+        } else {
+            execSync('curl -L https://fly.io/install.sh | sh', { stdio: 'inherit' });
+        }
+    }
+    
+    // Ensure fly.toml exists
+    const flyToml = path.join(projectPath, 'fly.toml');
+    if (!fs.existsSync(flyToml)) {
+        const toml = `app = "${options.appName || path.basename(projectPath)}"
+primary_region = "${options.region || 'ord'}"
+[build]
+  dockerfile = "Dockerfile"
+[http_service]
+  internal_port = 8080
+  force_https = true
+  auto_stop_machines = true
+  auto_start_machines = true
+  min_machines_running = 0`;
+        fs.writeFileSync(flyToml, toml);
+    }
+    
+    const result = execSync(`flyctl deploy --access-token ${config.fly.token}`, { 
+        cwd: projectPath, 
+        stdio: 'pipe' 
+    });
+    
+    return { url: `https://${options.appName}.fly.dev`, output: result.toString() };
+}
+
+// Docker build helper
+function buildDockerImage(projectPath, tag, dockerfile = 'Dockerfile') {
+    const fullTag = tag || `loom-${path.basename(projectPath)}:${Date.now()}`;
+    execSync(`docker build -t ${fullTag} -f ${dockerfile} .`, { cwd: projectPath, stdio: 'inherit' });
+    return fullTag;
+}
+
+// Preview server (for local preview of built apps)
+function startPreviewServer(projectPath, options = {}) {
+    const port = options.port || 3000;
+    const previewDir = options.previewDir || path.join(projectPath, 'dist');
+    
+    if (!fs.existsSync(previewDir)) {
+        throw new Error('No build output found. Run build first.');
+    }
+    
+    const http = require('http');
+    const { createServer } = require('http');
+    const { readFileSync } = require('fs');
+    const { extname, join } = require('path');
+    
+    const mimeTypes = {
+        '.html': 'text/html',
+        '.js': 'application/javascript',
+        '.css': 'text/css',
+        '.json': 'application/json',
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.gif': 'image/gif',
+        '.svg': 'image/svg+xml',
+        '.ico': 'image/x-icon',
+        '.woff': 'font/woff',
+        '.woff2': 'font/woff2',
+        '.ttf': 'font/ttf',
+        '.eot': 'application/vnd.ms-fontobject'
+    };
+    
+    const server = createServer((req, res) => {
+        let filePath = join(previewDir, req.url === '/' ? 'index.html' : req.url);
+        
+        // SPA fallback
+        if (!fs.existsSync(filePath)) {
+            filePath = join(previewDir, 'index.html');
+        }
+        
+        try {
+            const content = readFileSync(filePath);
+            const ext = extname(filePath);
+            res.writeHead(200, { 'Content-Type': mimeTypes[ext] || 'application/octet-stream' });
+            res.end(content);
+        } catch {
+            res.writeHead(404);
+            res.end('Not found');
+        }
+    });
+    
+    return new Promise((resolve, reject) => {
+        server.listen(port, () => resolve({ server, port, url: `http://localhost:${port}` }));
+        server.on('error', reject);
+    });
+}
+
+// Stop preview server
+function stopPreviewServer(server) {
+    return new Promise((resolve) => {
+        server.close(() => resolve());
+    });
+}
+
+// Git helpers
+function getGitHash(projectPath) {
+    try {
+        return execSync('git rev-parse --short HEAD', { cwd: projectPath, stdio: 'pipe' }).toString().trim();
+    } catch {
+        return 'unknown';
+    }
+}
+
+function getGitBranch(projectPath) {
+    try {
+        return execSync('git rev-parse --abbrev-ref HEAD', { cwd: projectPath, stdio: 'pipe' }).toString().trim();
+    } catch {
+        return 'main';
+    }
+}
+
+function getGitRemoteUrl(projectPath) {
+    try {
+        return execSync('git config --get remote.origin.url', { cwd: projectPath, stdio: 'pipe' }).toString().trim();
+    } catch {
+        return null;
+    }
+}
+
+function which(cmd) {
+    return new Promise((resolve) => {
+        const whichCmd = process.platform === 'win32' ? 'where' : 'which';
+        const child = spawn(whichCmd, [cmd], { stdio: 'ignore' });
+        child.on('close', (code) => resolve(code === 0));
+    });
+}
+
+// Auto-detect framework and build
+async function detectAndBuild(projectPath) {
+    const pkgPath = path.join(projectPath, 'package.json');
+    if (!fs.existsSync(pkgPath)) {
+        throw new Error('No package.json found');
+    }
+    
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    
+    let framework = 'vite';
+    let buildCommand = pkg.scripts?.build || 'npm run build';
+    let outputDir = 'dist';
+    let devCommand = pkg.scripts?.dev || 'npm run dev';
+    
+    if (deps.next) {
+        framework = 'nextjs';
+        buildCommand = 'next build';
+        outputDir = '.next';
+        devCommand = 'next dev';
+    } else if (deps['@remix-run/react'] || deps['@remix-run/node']) {
+        framework = 'remix';
+        buildCommand = 'remix build';
+        outputDir = 'build';
+    } else if (deps.astro) {
+        framework = 'astro';
+        buildCommand = 'astro build';
+        outputDir = 'dist';
+    } else if (deps.nuxt) {
+        framework = 'nuxt';
+        buildCommand = 'nuxt build';
+        outputDir = '.output/public';
+    } else if (deps.svelte || deps['@sveltejs/kit']) {
+        framework = 'svelte';
+        buildCommand = 'vite build';
+        outputDir = 'build';
+    }
+    
+    // Run build
+    execSync(buildCommand, { cwd: projectPath, stdio: 'inherit' });
+    
+    return { framework, buildCommand, outputDir, devCommand };
+}
+
+module.exports = {
+    loadConnectors,
+    saveConnectors,
+    getDeployConfig,
+    setDeployConfig,
+    deployVercel,
+    deployNetlify,
+    deployCloudflarePages,
+    deployRailway,
+    deployRender,
+    deployFly,
+    buildDockerImage,
+    startPreviewServer,
+    stopPreviewServer,
+    getGitHash,
+    getGitBranch,
+    getGitRemoteUrl,
+    detectAndBuild,
+    which
+};

package/src/connectors/index.js

@@ -0,0 +1,23 @@
+// Connectors registry — unified interface for all external services
+const supabase = require('./supabase');
+const convex = require('./convex');
+const deploy = require('./deploy');
+
+module.exports = {
+    supabase,
+    convex,
+    deploy,
+    // Unified config management
+    loadAll: () => {
+        return {
+            supabase: supabase.getSupabaseConfig(),
+            convex: convex.getConvexConfig(),
+            deploy: deploy.getDeployConfig()
+        };
+    },
+    saveAll: (config) => {
+        if (config.supabase) supabase.setSupabaseConfig(config.supabase);
+        if (config.convex) convex.setConvexConfig(config.convex);
+        if (config.deploy) deploy.setDeployConfig(config.deploy);
+    }
+};

package/src/connectors/supabase.js

@@ -0,0 +1,279 @@
+// Supabase connector — auth, database, storage, edge functions, realtime
+const { createClient } = require('@supabase/supabase-js');
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+const CONFIG_DIR = process.env.LOOM_CONFIG_DIR || path.join(require('os').homedir(), '.loom');
+const CONNECTORS_FILE = path.join(CONFIG_DIR, 'connectors.json');
+
+function loadConnectors() {
+    try {
+        if (fs.existsSync(CONNECTORS_FILE)) {
+            return JSON.parse(fs.readFileSync(CONNECTORS_FILE, 'utf8'));
+        }
+    } catch {}
+    return { supabase: {}, convex: {}, deploy: {} };
+}
+
+function saveConnectors(cfg) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(CONNECTORS_FILE, JSON.stringify(cfg, null, 2));
+}
+
+function getSupabaseConfig() {
+    const cfg = loadConnectors();
+    return cfg.supabase || {};
+}
+
+function setSupabaseConfig(config) {
+    const cfg = loadConnectors();
+    cfg.supabase = { ...cfg.supabase, ...config };
+    saveConnectors(cfg);
+}
+
+function createSupabaseClient(overrideConfig = {}) {
+    const config = { ...getSupabaseConfig(), ...overrideConfig };
+    if (!config.url || !config.anonKey) {
+        throw new Error('Supabase not configured. Run: loom connectors supabase --url <url> --anon-key <key>');
+    }
+    return createClient(config.url, config.anonKey, {
+        auth: { persistSession: false, autoRefreshToken: false },
+        ...config.options
+    });
+}
+
+// Auth helpers
+async function signUp(email, password, metadata = {}) {
+    const supabase = createSupabaseClient();
+    const { data, error } = await supabase.auth.signUp({ email, password, options: { data: metadata } });
+    if (error) throw error;
+    return data;
+}
+
+async function signIn(email, password) {
+    const supabase = createSupabaseClient();
+    const { data, error } = await supabase.auth.signInWithPassword({ email, password });
+    if (error) throw error;
+    return data;
+}
+
+async function signOut() {
+    const supabase = createSupabaseClient();
+    const { error } = await supabase.auth.signOut();
+    if (error) throw error;
+}
+
+async function getSession() {
+    const supabase = createSupabaseClient();
+    const { data: { session } } = await supabase.auth.getSession();
+    return session;
+}
+
+async function getUser() {
+    const supabase = createSupabaseClient();
+    const { data: { user } } = await supabase.auth.getUser();
+    return user;
+}
+
+async function resetPassword(email) {
+    const supabase = createSupabaseClient();
+    const { error } = await supabase.auth.resetPasswordForEmail(email);
+    if (error) throw error;
+}
+
+// Database helpers (PostgreSQL via Supabase)
+async function query(table, options = {}) {
+    const supabase = createSupabaseClient();
+    let query = supabase.from(table).select(options.select || '*');
+    
+    if (options.filter) {
+        for (const [col, val] of Object.entries(options.filter)) {
+            query = query.eq(col, val);
+        }
+    }
+    if (options.order) {
+        query = query.order(options.order.column, { ascending: options.order.ascending !== false });
+    }
+    if (options.limit) {
+        query = query.limit(options.limit);
+    }
+    if (options.range) {
+        query = query.range(options.range.from, options.range.to);
+    }
+    
+    const { data, error } = await query;
+    if (error) throw error;
+    return data;
+}
+
+async function insert(table, records, returning = true) {
+    const supabase = createSupabaseClient();
+    const { data, error } = await supabase.from(table).insert(records).select(returning ? '*' : '');
+    if (error) throw error;
+    return data;
+}
+
+async function update(table, filter, updates) {
+    const supabase = createSupabaseClient();
+    let query = supabase.from(table).update(updates);
+    for (const [col, val] of Object.entries(filter)) {
+        query = query.eq(col, val);
+    }
+    const { data, error } = await query.select('*');
+    if (error) throw error;
+    return data;
+}
+
+async function remove(table, filter) {
+    const supabase = createSupabaseClient();
+    let query = supabase.from(table).delete();
+    for (const [col, val] of Object.entries(filter)) {
+        query = query.eq(col, val);
+    }
+    const { error } = await query;
+    if (error) throw error;
+}
+
+async function rpc(functionName, params = {}) {
+    const supabase = createSupabaseClient();
+    const { data, error } = await supabase.rpc(functionName, params);
+    if (error) throw error;
+    return data;
+}
+
+// Storage helpers
+async function upload(bucket, path, fileBody, options = {}) {
+    const supabase = createSupabaseClient();
+    const { data, error } = await supabase.storage.from(bucket).upload(path, fileBody, options);
+    if (error) throw error;
+    return data;
+}
+
+async function download(bucket, path) {
+    const supabase = createSupabaseClient();
+    const { data, error } = await supabase.storage.from(bucket).download(path);
+    if (error) throw error;
+    return data;
+}
+
+async function removeFile(bucket, paths) {
+    const supabase = createSupabaseClient();
+    const { error } = await supabase.storage.from(bucket).remove(Array.isArray(paths) ? paths : [paths]);
+    if (error) throw error;
+}
+
+async function getPublicUrl(bucket, path) {
+    const supabase = createSupabaseClient();
+    const { data } = supabase.storage.from(bucket).getPublicUrl(path);
+    return data.publicUrl;
+}
+
+async function listFiles(bucket, folder = '') {
+    const supabase = createSupabaseClient();
+    const { data, error } = await supabase.storage.from(bucket).list(folder);
+    if (error) throw error;
+    return data;
+}
+
+// Edge Functions
+async function invokeFunction(functionName, payload = {}) {
+    const supabase = createSupabaseClient();
+    const { data, error } = await supabase.functions.invoke(functionName, { body: payload });
+    if (error) throw error;
+    return data;
+}
+
+// Realtime subscriptions
+function subscribe(table, event, callback, filter = {}) {
+    const supabase = createSupabaseClient();
+    let channel = supabase.channel(`loom:${table}:${event}`);
+    
+    if (event === '*') {
+        channel = channel.on('postgres_changes', { event: '*', schema: 'public', table, filter: filter.column ? `${filter.column}=eq.${filter.value}` : undefined }, callback);
+    } else {
+        channel = channel.on('postgres_changes', { event, schema: 'public', table, filter: filter.column ? `${filter.column}=eq.${filter.value}` : undefined }, callback);
+    }
+    
+    channel.subscribe();
+    return () => { supabase.removeChannel(channel); };
+}
+
+// Project scaffolding helpers
+async function scaffoldProject(projectName, template = 'react') {
+    const projectPath = path.join(process.cwd(), projectName);
+    fs.mkdirSync(projectPath, { recursive: true });
+    
+    const templates = {
+        react: {
+            'package.json': JSON.stringify({
+                name: projectName,
+                version: '0.0.1',
+                private: true,
+                scripts: {
+                    dev: 'vite',
+                    build: 'vite build',
+                    preview: 'vite preview'
+                },
+                dependencies: { react: '^18.3.0', 'react-dom': '^18.3.0' },
+                devDependencies: { vite: '^5.0.0', '@vitejs/plugin-react': '^4.0.0' }
+            }, null, 2),
+            'vite.config.js': `import { defineConfig } from 'vite'\nimport react from '@vitejs/plugin-react'\nexport default defineConfig({ plugins: [react()], server: { port: 3000, host: true } })`,
+            'index.html': `<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>${projectName}</title></head><body><div id="root"></div><script type="module" src="/src/main.jsx"></script></body></html>`,
+            'src/main.jsx': `import React from 'react'\nimport ReactDOM from 'react-dom/client'\nimport App from './App'\nimport './index.css'\nReactDOM.createRoot(document.getElementById('root')).render(<React.StrictMode><App /></React.StrictMode>)`,
+            'src/App.jsx': `function App() { return <div style={{padding: '2rem', fontFamily: 'system-ui'}}><h1>${projectName}</h1><p>Powered by Loom + Supabase</p></div> }\nexport default App`,
+            'src/index.css': `* { box-sizing: border-box; } body { margin: 0; font-family: system-ui; background: #fafafa; }`
+        },
+        nextjs: {
+            'package.json': JSON.stringify({
+                name: projectName,
+                version: '0.0.1',
+                private: true,
+                scripts: { dev: 'next dev', build: 'next build', start: 'next start' },
+                dependencies: { next: '^14.0.0', react: '^18.3.0', 'react-dom': '^18.3.0' }
+            }, null, 2),
+            'next.config.js': `/** @type {import('next').NextConfig} */\nconst nextConfig = {}\nmodule.exports = nextConfig`,
+            'app/page.js': `export default function Home() { return <main style={{padding: '2rem'}}><h1>${projectName}</h1><p>Next.js + Supabase</p></main> }`,
+            'app/layout.js': `export default function RootLayout({children}) { return <html lang="en"><body>{children}</body></html> }`
+        },
+        vue: {
+            'package.json': JSON.stringify({
+                name: projectName,
+                version: '0.0.1',
+                private: true,
+                scripts: { dev: 'vite', build: 'vite build', preview: 'vite preview' },
+                dependencies: { vue: '^3.4.0' },
+                devDependencies: { vite: '^5.0.0', '@vitejs/plugin-vue': '^5.0.0' }
+            }, null, 2),
+            'vite.config.js': `import { defineConfig } from 'vite'\nimport vue from '@vitejs/plugin-vue'\nexport default defineConfig({ plugins: [vue()], server: { port: 3000, host: true } })`,
+            'index.html': `<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><title>${projectName}</title></head><body><div id="app"></div><script type="module" src="/src/main.js"></script></body></html>`,
+            'src/main.js': `import { createApp } from 'vue'\nimport App from './App.vue'\nimport './style.css'\ncreateApp(App).mount('#app')`,
+            'src/App.vue': `<template><div style="padding: 2rem; font-family: system-ui"><h1>${projectName}</h1><p>Vue + Supabase</p></div></template><script setup></script><style>* { box-sizing: border-box; } body { margin: 0; }</style>`,
+            'src/style.css': `* { box-sizing: border-box; } body { margin: 0; font-family: system-ui; background: #fafafa; }`
+        }
+    };
+    
+    const tpl = templates[template] || templates.react;
+    for (const [file, content] of Object.entries(tpl)) {
+        const fullPath = path.join(projectPath, file);
+        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+        fs.writeFileSync(fullPath, content);
+    }
+    
+    // Initialize git
+    try { require('child_process').execSync('git init', { cwd: projectPath, stdio: 'ignore' }); } catch {}
+    
+    return projectPath;
+}
+
+module.exports = {
+    createSupabaseClient,
+    getSupabaseConfig,
+    setSupabaseConfig,
+    signUp, signIn, signOut, getSession, getUser, resetPassword,
+    query, insert, update, remove, rpc,
+    upload, download, removeFile, getPublicUrl, listFiles,
+    invokeFunction, subscribe,
+    scaffoldProject,
+    loadConnectors, saveConnectors
+};