@minnai/create-aura-app 0.0.2

package/templates/starter/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ]
+}

package/templates/starter/tsconfig.node.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "ES2023",
+    "lib": ["ES2023"],
+    "module": "ESNext",
+    "types": ["node"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["vite.config.ts"]
+}

package/templates/starter/verify_backend.ts

@@ -0,0 +1,42 @@
+
+const apiUrl = 'https://auraproxy-7bpt7e5tua-uc.a.run.app';
+
+async function testBackend() {
+    console.log(`Testing backend at: ${apiUrl}/api/chat/reflect`);
+
+    // Mimic the payload from useControllerLogic.ts
+    const payload = {
+        message: "Hello, can you hear me? This is a test.",
+        messages: [],
+        available_airs: [],
+        open_airs: [],
+        additional_context: {}
+    };
+
+    try {
+        const start = Date.now();
+        const res = await fetch(`${apiUrl}/api/chat/reflect`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(payload)
+        });
+
+        const duration = Date.now() - start;
+        console.log(`Response status: ${res.status}`);
+        console.log(`Duration: ${duration}ms`);
+
+        if (!res.ok) {
+            const text = await res.text();
+            console.error("Error response:", text);
+            process.exit(1);
+        }
+
+        const data = await res.json();
+        console.log("Success! Response data:", JSON.stringify(data, null, 2));
+    } catch (err) {
+        console.error("Fetch failed:", err);
+        process.exit(1);
+    }
+}
+
+testBackend();

package/templates/starter/vite.config.ts

@@ -0,0 +1,286 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import path from 'path';
+import fs from 'fs';
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [
+    react(),
+    {
+      name: 'save-code-plugin',
+      configureServer(server: any) {
+        server.middlewares.use((req: any, res: any, next: any) => {
+          if (req.method === 'POST' && req.url === '/api/save-code') {
+            let body = '';
+            req.on('data', (chunk: any) => body += chunk);
+            req.on('end', () => {
+              try {
+                const { filePath, content } = JSON.parse(body);
+                const absolutePath = path.resolve(__dirname, filePath);
+                if (!absolutePath.startsWith(__dirname)) {
+                  throw new Error("Invalid path");
+                }
+                fs.writeFileSync(absolutePath, content, 'utf8');
+                res.statusCode = 200;
+                res.setHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify({ success: true }));
+              } catch (err: any) {
+                res.statusCode = 500;
+                res.setHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify({ success: false, error: err.message }));
+              }
+            });
+          } else if (req.method === 'GET' && req.url?.startsWith('/api/list-files')) {
+            const url = new URL(req.url, `http://${req.headers.host}`);
+            const airId = url.searchParams.get('airId');
+            if (!airId) {
+              res.statusCode = 400;
+              res.end("Missing airId");
+              return;
+            }
+
+            const airDir = path.resolve(__dirname, 'src/airs', airId);
+            if (!fs.existsSync(airDir)) {
+              res.statusCode = 200;
+              res.setHeader('Content-Type', 'application/json');
+              res.end(JSON.stringify({ files: [] }));
+              return;
+            }
+
+            const getFiles = (dir: string): string[] => {
+              let results: string[] = [];
+              if (!fs.existsSync(dir)) return [];
+              const list = fs.readdirSync(dir);
+              list.forEach(file => {
+                const filePath = path.join(dir, file);
+                const stat = fs.statSync(filePath);
+                if (stat && stat.isDirectory()) {
+                  results = results.concat(getFiles(filePath));
+                } else {
+                  // Return path relative to project root, prefixed with /
+                  const relativePath = path.relative(__dirname, filePath).replace(/\\/g, '/');
+                  results.push(relativePath.startsWith('/') ? relativePath : '/' + relativePath);
+                }
+              });
+              return results;
+            };
+
+            const files = getFiles(airDir);
+            res.statusCode = 200;
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify({ files }));
+          } else if (req.method === 'POST' && req.url === '/api/scaffold-air') {
+            let body = '';
+            req.on('data', (chunk: any) => body += chunk);
+            req.on('end', () => {
+              try {
+                const { airId, name } = JSON.parse(body);
+                if (!airId || !name) throw new Error("Missing airId or name");
+
+                const airDir = path.resolve(__dirname, 'src/airs', airId);
+                if (fs.existsSync(airDir)) throw new Error("AIR already exists");
+
+                fs.mkdirSync(airDir, { recursive: true });
+                fs.mkdirSync(path.join(airDir, 'ui'), { recursive: true });
+
+                const templates: Record<string, string> = {
+                  'manifest.ts': `export const ${name.replace(/[^a-zA-Z0-9]/g, '')}Manifest = {
+    id: '${airId}',
+    meta: {
+        title: '${name}',
+        icon: '🚀',
+        description: 'A brand new custom AIR.',
+        width: 400,
+        height: 500
+    }
+};`,
+                  'logic.ts': `import { useState } from 'react';
+
+export function use${name.replace(/[^a-zA-Z0-9]/g, '')}Logic(props: any) {
+    const [count, setCount] = useState(0);
+    const increment = () => setCount(prev => prev + 1);
+    
+    return { count, increment };
+}`,
+                  'resources.ts': `export const resources = {};`,
+                  'ui/index.tsx': `import React from 'react';
+
+export default function UI({ count, onIncrement }: any) {
+    return (
+        <div style={{ padding: 20, textAlign: 'center' }}>
+            <h2>${name} UI</h2>
+            <p>Count: {count}</p>
+            <button 
+                onClick={onIncrement}
+                style={{
+                    padding: '10px 20px',
+                    background: '#007aff',
+                    color: 'white',
+                    border: 'none',
+                    borderRadius: 8,
+                    cursor: 'pointer'
+                }}
+            >
+                Increment
+            </button>
+        </div>
+    );
+}`,
+                  'index.tsx': `import React from 'react';
+import { ${name.replace(/[^a-zA-Z0-9]/g, '')}Manifest } from './manifest';
+import { resources } from './resources';
+import UI from './ui';
+import { use${name.replace(/[^a-zA-Z0-9]/g, '')}Logic } from './logic';
+
+const Component: React.FC<any> = (props) => {
+    const logic = use${name.replace(/[^a-zA-Z0-9]/g, '')}Logic(props);
+    return <UI count={logic.count} onIncrement={logic.increment} />;
+};
+
+export default {
+    manifest: ${name.replace(/[^a-zA-Z0-9]/g, '')}Manifest,
+    resources,
+    component: Component
+};`
+                };
+
+                Object.entries(templates).forEach(([filename, content]) => {
+                  fs.writeFileSync(path.join(airDir, filename), content, 'utf8');
+                });
+
+                res.statusCode = 200;
+                res.setHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify({ success: true }));
+              } catch (err: any) {
+                res.statusCode = 500;
+                res.setHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify({ success: false, error: err.message }));
+              }
+            });
+          } else if (req.method === 'POST' && req.url?.startsWith('/api/storage/documents')) {
+            console.log(`[StorageMiddleware] Request Path: ${req.url}`);
+            let body = '';
+            req.on('data', (chunk: any) => body += chunk);
+            req.on('end', () => {
+              try {
+                const url = new URL(req.url, `http://${req.headers.host}`);
+                const pathParts = url.pathname.split('/');
+                const action = pathParts[4]; // create, update, get, list, delete
+                console.log(`[StorageMiddleware] Action: ${action}, Body: ${body.substring(0, 200)}`);
+                const { collection, id, data } = JSON.parse(body);
+
+                const storageDir = path.resolve(__dirname, 'temp_data_storage', collection);
+                if (!fs.existsSync(storageDir)) fs.mkdirSync(storageDir, { recursive: true });
+
+                if (action === 'get') {
+                  const filePath = path.join(storageDir, `${id}.json`);
+                  console.log(`[StorageMiddleware] GET File: ${filePath}`);
+                  if (fs.existsSync(filePath)) {
+                    res.end(fs.readFileSync(filePath, 'utf8'));
+                  } else {
+                    res.statusCode = 200; // Return 200 with null per Aura client expectation
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify(null));
+                  }
+                } else if (action === 'create' || action === 'update') {
+                  const docId = id || data.id || Math.random().toString(36).substr(2, 9);
+                  const filePath = path.join(storageDir, `${docId}.json`);
+                  const finalData = action === 'update' && fs.existsSync(filePath)
+                    ? { ...JSON.parse(fs.readFileSync(filePath, 'utf8')), ...data }
+                    : { ...data, id: docId };
+                  fs.writeFileSync(filePath, JSON.stringify(finalData, null, 2), 'utf8');
+                  res.end(JSON.stringify({ id: docId, success: true }));
+                } else if (action === 'list') {
+                  const files = fs.readdirSync(storageDir);
+                  const docs = files.map(f => JSON.parse(fs.readFileSync(path.join(storageDir, f), 'utf8')));
+                  res.end(JSON.stringify(docs));
+                } else if (action === 'delete') {
+                  const filePath = path.join(storageDir, `${id}.json`);
+                  console.log(`[StorageMiddleware] DELETE File: ${filePath}`);
+                  if (fs.existsSync(filePath)) {
+                    fs.unlinkSync(filePath);
+                  }
+                  res.end(JSON.stringify({ success: true }));
+                }
+              } catch (err: any) {
+                res.statusCode = 500;
+                res.end(JSON.stringify({ error: err.message }));
+              }
+            });
+          } else if (req.method === 'GET' && req.url?.startsWith('/api/get-file-path')) {
+            const url = new URL(req.url, `http://${req.headers.host}`);
+            const relativePath = url.searchParams.get('path');
+            if (!relativePath) {
+              res.statusCode = 400;
+              res.end(JSON.stringify({ error: "Missing path parameter" }));
+              return;
+            }
+
+            try {
+              const absolutePath = path.resolve(__dirname, relativePath);
+              // Security check
+              if (!absolutePath.startsWith(__dirname)) {
+                throw new Error("Invalid path - outside project directory");
+              }
+
+              // Convert to vscode:// URI format
+              // Windows: vscode://file/c:/path/to/file
+              // macOS/Linux: vscode://file//Users/path/to/file
+              const normalizedPath = absolutePath.replace(/\\/g, '/');
+              const vscodeUri = `vscode://file/${normalizedPath}`;
+
+              res.statusCode = 200;
+              res.setHeader('Content-Type', 'application/json');
+              res.end(JSON.stringify({
+                absolutePath: normalizedPath,
+                vscodeUri,
+                projectRoot: __dirname.replace(/\\/g, '/')
+              }));
+            } catch (err: any) {
+              res.statusCode = 500;
+              res.setHeader('Content-Type', 'application/json');
+              res.end(JSON.stringify({ error: err.message }));
+            }
+          } else if (req.url?.startsWith('/api/storage/objects')) {
+            const url = new URL(req.url, `http://${req.headers.host}`);
+            const objectPath = url.searchParams.get('path');
+            if (!objectPath) { res.statusCode = 400; res.end("Missing path"); return; }
+
+            const filePath = path.resolve(__dirname, 'temp_data_storage/objects', objectPath);
+            if (req.method === 'GET') {
+              if (fs.existsSync(filePath)) {
+                res.end(fs.readFileSync(filePath));
+              } else {
+                res.statusCode = 404;
+                res.end("Not found");
+              }
+            } else if (req.method === 'POST' || req.method === 'PUT') {
+              let buffer = Buffer.alloc(0);
+              req.on('data', (chunk: Buffer) => buffer = Buffer.concat([buffer, chunk]));
+              req.on('end', () => {
+                fs.mkdirSync(path.dirname(filePath), { recursive: true });
+                fs.writeFileSync(filePath, buffer);
+                res.end(JSON.stringify({ success: true }));
+              });
+            }
+          } else {
+            next();
+          }
+        });
+      }
+    }
+  ],
+  resolve: {
+    alias: {
+      // Alias @minnai/aura to the local source directory for verifying changes
+      '@minnai/aura': path.resolve(__dirname, '../../Aura/src'),
+      'react': path.resolve(__dirname, './node_modules/react'),
+      'react-dom': path.resolve(__dirname, './node_modules/react-dom'),
+    },
+    dedupe: ['react', 'react-dom']
+  },
+  server: {
+    port: 5175
+  }
+})