@notis_ai/cli 0.2.0-beta.16.1 → 0.2.0

package/src/runtime/app-platform.js

@@ -3,23 +3,22 @@
  *
  * Handles project scaffolding, validation, building, and linking. This is the
  * CLI-side counterpart to @notis/sdk -- it reads notis.config.ts, runs the
- * Vite build, and packages the bundle for deployment.
+ * Next.js build, and packages the artifact for deployment.
  */
 
 import { spawn } from 'node:child_process';
 import { existsSync, mkdirSync, readFileSync, writeFileSync, cpSync, readdirSync } from 'node:fs';
-import { createRequire } from 'node:module';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { createHash } from 'node:crypto';
 
 import { usageError } from './errors.js';
 
 const NOTIS_DIR = '.notis';
 const STATE_FILE = join(NOTIS_DIR, 'state.json');
 const OUTPUT_DIR = join(NOTIS_DIR, 'output');
-const BUNDLE_DIR = join(OUTPUT_DIR, 'bundle');
+const SITE_DIR = join(OUTPUT_DIR, 'site');
 const MANIFEST_FILE = join(OUTPUT_DIR, 'manifest.json');
-let appConfigImportNonce = 0;
 
 // ---------------------------------------------------------------------------
 // Project directory resolution
@@ -35,29 +34,9 @@ export function resolveProjectDir(inputDir = '.') {
 
 /**
  * Load and parse notis.config.ts from a project directory. Uses a simple
- * approach: we read the file, transpile with the project's TypeScript compiler
- * when available, then evaluate as ESM.
+ * approach: we read the file, transpile with a basic regex to strip types,
+ * and evaluate. For production use this should use tsx or similar.
  */
-function transpileTsConfigSource(source, configPath) {
-  const requireFromConfig = createRequire(`file://${configPath}`);
-  try {
-    const ts = requireFromConfig('typescript');
-    const transpiled = ts.transpileModule(source, {
-      compilerOptions: {
-        module: ts.ModuleKind.ESNext,
-        target: ts.ScriptTarget.ES2020,
-      },
-      fileName: configPath,
-    });
-    return transpiled.outputText;
-  } catch {
-    return source
-      .replace(/import\s+type\s+[\s\S]*?from\s+['"][^'"]*['"]\s*;?/g, '')
-      .replace(/import\s*{[\s\S]*?\bdefineNotisApp\b[\s\S]*?}\s+from\s+['"]@notis\/sdk\/config['"]\s*;?/g, '')
-      .replace(/defineNotisApp\s*\(/, '(');
-  }
-}
-
 export async function loadAppConfig(projectDir) {
   const configPaths = ['notis.config.ts', 'notis.config.js', 'notis.config.mjs'];
   let configPath = null;
@@ -75,24 +54,24 @@ export async function loadAppConfig(projectDir) {
   }
 
   // For .js/.mjs files, import directly. For .ts, we need transpilation.
+  // In the CLI context, we use a simple approach: read the file, strip TS
+  // syntax, and eval. This avoids requiring tsx as a dependency.
   if (configPath.endsWith('.ts')) {
     const source = readFileSync(configPath, 'utf-8');
-    const jsSource = transpileTsConfigSource(source, configPath);
+    // Strip import type annotations and type declarations
+    const jsSource = source
+      .replace(/import\s+type\s+{[^}]*}\s+from\s+['"][^'"]*['"]\s*;?/g, '')
+      .replace(/import\s+{[^}]*}\s+from\s+['"][^'"]*['"]\s*;?/g, '')
+      .replace(/export\s+default\s+/, 'export default ')
+      .replace(/defineNotisApp\s*\(/, '(');
 
-    const tmpPath = join(dirname(configPath), '._notis_config_tmp.mjs');
+    // Write a temporary .mjs file and import it
+    const tmpPath = join(projectDir, '.notis', '_config_tmp.mjs');
     mkdirSync(dirname(tmpPath), { recursive: true });
     writeFileSync(tmpPath, jsSource);
     try {
-      const mod = await import(`file://${tmpPath}?v=${appConfigImportNonce++}`);
+      const mod = await import(`file://${tmpPath}`);
       return mod.default || mod;
-    } catch (error) {
-      if (error instanceof SyntaxError) {
-        throw usageError(
-          `Failed to parse ${configPath}. Install project dependencies (including typescript) ` +
-          'or convert the config to plain JavaScript.',
-        );
-      }
-      throw error;
     } finally {
       try {
         const { unlinkSync } = await import('node:fs');
@@ -116,10 +95,10 @@ export function detectProjectProblems(projectDir) {
     problems.push('Missing package.json');
   }
 
-  const hasViteConfig = ['vite.config.ts', 'vite.config.js', 'vite.config.mjs']
+  const hasNextConfig = ['next.config.ts', 'next.config.mjs', 'next.config.js']
     .some((name) => existsSync(join(projectDir, name)));
-  if (!hasViteConfig) {
-    problems.push('Missing vite.config file');
+  if (!hasNextConfig) {
+    problems.push('Missing next.config file');
   }
 
   if (!existsSync(join(projectDir, 'app'))) {
@@ -149,7 +128,7 @@ export function detectProjectWarnings(projectDir, appConfig = null) {
   }
 
   if (appConfig && (!Array.isArray(appConfig.databases) || appConfig.databases.length === 0)) {
-    warnings.push('No database references declared in notis.config.ts.');
+    warnings.push('No databases declared in notis.config.ts.');
   }
 
   return warnings;
@@ -177,31 +156,6 @@ export async function runProjectScript({ projectDir, scriptName, env = {}, stdio
   });
 }
 
-/**
- * Derive an export name from a route path.
- * '/' -> 'index', '/inbox' -> 'inbox', '/my-tasks' -> 'myTasks'
- */
-function exportNameFromPath(routePath) {
-  if (routePath === '/') return 'index';
-  const slug = routePath.replace(/^\//, '').replace(/\//g, '-');
-  const identifier = slug
-    .split(/[^A-Za-z0-9_$]+/)
-    .filter(Boolean)
-    .map((part, index) => {
-      const lower = part.toLowerCase();
-      if (index === 0) return lower;
-      return lower.charAt(0).toUpperCase() + lower.slice(1);
-    })
-    .join('');
-  if (!identifier) return 'route';
-  return /^[A-Za-z_$]/.test(identifier) ? identifier : `r${identifier}`;
-}
-
-function slugFromPath(routePath) {
-  if (routePath === '/') return 'index';
-  return routePath.replace(/^\//, '').replace(/\//g, '-');
-}
-
 /**
  * Auto-detect routes from the app/ directory by scanning for page.tsx files.
  */
@@ -220,13 +174,13 @@ function autoDetectRoutes(projectDir) {
         scan(join(dir, entry.name), `${pathPrefix}/${entry.name}`);
       } else if (entry.name === 'page.tsx' || entry.name === 'page.jsx' || entry.name === 'page.js') {
         const routePath = pathPrefix || '/';
-        const slug = slugFromPath(routePath);
+        const slug = routePath === '/' ? 'index' : routePath.replace(/^\//, '').replace(/\//g, '-');
         routes.push({
           path: routePath,
           slug,
           name: slug === 'index' ? 'Home' : slug.replace(/-/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase()),
           default: routePath === '/',
-          export_name: exportNameFromPath(routePath),
+          entry_html: routePath === '/' ? 'index.html' : `${routePath.replace(/^\//, '')}/index.html`,
         });
       }
     }
@@ -236,109 +190,89 @@ function autoDetectRoutes(projectDir) {
   return routes;
 }
 
-function resolveConfiguredRoutes(appConfig, projectDir) {
-  const configuredRoutes = Array.isArray(appConfig.routes) ? appConfig.routes : [];
-  const routes = configuredRoutes.map((route) => ({
-    ...route,
-    slug: route.slug || slugFromPath(route.path),
-    export_name: route.exportName || route.export_name || exportNameFromPath(route.path),
-  }));
-  return routes.length > 0 ? routes : autoDetectRoutes(projectDir);
+function slugFromPath(routePath) {
+  if (routePath === '/') return 'index';
+  return routePath.replace(/^\//, '').replace(/\//g, '-');
 }
 
-/**
- * Generate the _entry.tsx file that re-exports each route's page component.
- */
-function generateEntryFile(projectDir, routes) {
-  const entryDir = join(projectDir, NOTIS_DIR);
-  mkdirSync(entryDir, { recursive: true });
-
-  // Also re-export the layout if it exists
-  const lines = [];
-  const layoutPath = join(projectDir, 'app', 'layout.tsx');
-  if (existsSync(layoutPath)) {
-    lines.push(`export { default as __AppShell } from '../app/layout';`);
-  }
-
-  for (const route of routes) {
-    const pagePath = route.path === '/' ? '../app/page' : `../app${route.path}/page`;
-    lines.push(`export { default as ${route.export_name} } from '${pagePath}';`);
-  }
-
-  const entryPath = join(entryDir, '_entry.tsx');
-  writeFileSync(entryPath, lines.join('\n') + '\n');
-  return entryPath;
+function entryHtmlFromPath(routePath) {
+  if (routePath === '/') return 'index.html';
+  return `${routePath.replace(/^\//, '')}/index.html`;
 }
 
 /**
  * Generate the manifest from app config and build output.
  */
 function generateManifest(appConfig, projectDir) {
-  const routes = resolveConfiguredRoutes(appConfig, projectDir).map((route) => {
-    const entry = {
-      path: route.path,
-      slug: route.slug || slugFromPath(route.path),
-      name: route.name,
-      icon: route.icon || null,
-      default: route.default || false,
-      export_name: route.exportName || route.export_name || exportNameFromPath(route.path),
-      collection: route.collection || null,
-    };
-    if (route.tool_access) {
-      entry.tool_access = route.tool_access;
-    }
-    return entry;
-  });
+  const routes = (appConfig.routes || autoDetectRoutes(projectDir)).map((route) => ({
+    path: route.path,
+    slug: route.slug || slugFromPath(route.path),
+    name: route.name,
+    icon: route.icon || null,
+    default: route.default || false,
+    entry_html: route.entry_html || entryHtmlFromPath(route.path),
+    collection: route.collection || null,
+  }));
 
-  const databases = appConfig.databases || [];
+  const databases = (appConfig.databases || []).map((db) => ({
+    slug: db.slug,
+    title: db.title,
+    description: db.description || null,
+    icon: db.icon || null,
+    properties: (db.properties || []).map((prop) => ({
+      name: prop.name,
+      type: prop.type,
+      description: prop.description || null,
+      options: prop.options
+        ? prop.options.map((opt) => typeof opt === 'string' ? { name: opt } : opt)
+        : null,
+    })),
+  }));
 
   return {
     version: 1,
-    spec_version: 3,
+    spec_version: 2,
     app: {
       name: appConfig.name,
       description: appConfig.description || null,
       icon: appConfig.icon || null,
     },
     routes,
-    bundle: {
-      js: 'bundle/app.js',
-      css: 'bundle/app.css',
-    },
     databases,
     tools: appConfig.tools || [],
   };
 }
 
 /**
- * Build the app bundle: generate entry file, run `vite build`, package into .notis/output/.
+ * Build the app artifact: run `next build`, then package into .notis/output/.
  */
 export async function buildArtifact(projectDir) {
   const appConfig = await loadAppConfig(projectDir);
 
-  // Auto-detect or use configured routes
-  const detectedRoutes = resolveConfiguredRoutes(appConfig, projectDir);
-
-  // Generate the entry file that re-exports all route page components
-  generateEntryFile(projectDir, detectedRoutes);
-
-  // Run Vite build
+  // Run the Next.js build
   await runProjectScript({
     projectDir,
     scriptName: 'build',
+    env: {
+      NOTIS_BUILD: '1',
+      NOTIS_APP_BASE_PATH: '/__NOTIS_APP_BASE__',
+      NOTIS_ASSET_PREFIX: '/__NOTIS_ASSET_BASE__',
+    },
   });
 
-  // Verify output
-  const bundleDir = join(projectDir, BUNDLE_DIR);
-  const jsPath = join(bundleDir, 'app.js');
-  if (!existsSync(jsPath)) {
-    throw usageError('Vite build did not produce .notis/output/bundle/app.js. Check your vite.config.ts.');
+  // Copy the static export into .notis/output/site/
+  const nextOutDir = join(projectDir, 'out');
+  if (!existsSync(nextOutDir)) {
+    throw usageError('Next.js build did not produce an `out/` directory. Ensure `output: "export"` is set (withNotis does this automatically).');
   }
 
+  const outputSiteDir = join(projectDir, SITE_DIR);
+  mkdirSync(outputSiteDir, { recursive: true });
+  cpSync(nextOutDir, outputSiteDir, { recursive: true });
+
   // Generate manifest
   const manifest = generateManifest(appConfig, projectDir);
   const manifestPath = join(projectDir, MANIFEST_FILE);
-  mkdirSync(dirname(manifestPath), { recursive: true });
   writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
 
   return { manifest, outputDir: join(projectDir, OUTPUT_DIR) };
@@ -388,11 +322,11 @@ export function requireLinkedAppId(projectDir, explicitAppId) {
 export function scaffoldProject({ projectDir, appName }) {
   const templateDir = resolve(
     dirname(fileURLToPath(import.meta.url)),
-    '../../template',
+    '../../../../packages/notis-sdk/template',
   );
 
   if (!existsSync(templateDir)) {
-    throw usageError(`SDK template not found at ${templateDir}. Ensure @notis_ai/cli is installed correctly.`);
+    throw usageError(`SDK template not found at ${templateDir}. Ensure @notis/sdk is installed.`);
   }
 
   mkdirSync(projectDir, { recursive: true });
@@ -448,177 +382,3 @@ export function collectArtifactFiles(projectDir) {
   walk(outputDir, '');
   return files;
 }
-
-// ---------------------------------------------------------------------------
-// Direct deploy (bypasses backend server)
-// ---------------------------------------------------------------------------
-
-/**
- * Resolve Supabase credentials from the server/.env file in the repo workspace.
- * Falls back to environment variables.
- */
-function resolveSupabaseCredentials() {
-  const envPaths = [
-    resolve(process.cwd(), 'server/.env'),
-    resolve(process.cwd(), '../server/.env'),
-    resolve(process.cwd(), '../../server/.env'),
-  ];
-
-  let supabaseUrl = process.env.SUPABASE_URL;
-  let supabaseSubdomain = process.env.SUPABASE_SUBDOMAIN;
-  let supabaseKey = process.env.SUPABASE_SERVICE_ROLE_KEY || process.env.SUPABASE_SERVICE_KEY;
-
-  for (const envPath of envPaths) {
-    if (existsSync(envPath)) {
-      const content = readFileSync(envPath, 'utf-8');
-      for (const line of content.split('\n')) {
-        const trimmed = line.trim();
-        if (trimmed.startsWith('#') || !trimmed.includes('=')) continue;
-        const eqIdx = trimmed.indexOf('=');
-        const key = trimmed.slice(0, eqIdx).trim();
-        let value = trimmed.slice(eqIdx + 1).trim();
-        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
-          value = value.slice(1, -1);
-        }
-        if (key === 'SUPABASE_URL' && !supabaseUrl) supabaseUrl = value;
-        if (key === 'SUPABASE_SUBDOMAIN' && !supabaseSubdomain) supabaseSubdomain = value;
-        if ((key === 'SUPABASE_SERVICE_ROLE_KEY' || key === 'SUPABASE_SERVICE_KEY') && !supabaseKey) supabaseKey = value;
-      }
-      break;
-    }
-  }
-
-  // Derive URL from subdomain if needed
-  if (!supabaseUrl && supabaseSubdomain) {
-    supabaseUrl = `https://${supabaseSubdomain}.supabase.co`;
-  }
-
-  if (!supabaseUrl || !supabaseKey) {
-    throw usageError(
-      'Cannot resolve Supabase credentials for direct deploy. ' +
-      'Ensure server/.env exists with SUPABASE_SUBDOMAIN (or SUPABASE_URL) and SUPABASE_SERVICE_KEY, ' +
-      'or set them as environment variables.',
-    );
-  }
-
-  return { supabaseUrl, supabaseKey };
-}
-
-/**
- * Upload a file to Supabase Storage with upsert.
- */
-async function uploadToStorage(supabaseUrl, supabaseKey, bucket, storagePath, content, contentType) {
-  const url = `${supabaseUrl}/storage/v1/object/${bucket}/${storagePath}`;
-  const response = await fetch(url, {
-    method: 'POST',
-    headers: {
-      'Authorization': `Bearer ${supabaseKey}`,
-      'Content-Type': contentType,
-      'x-upsert': 'true',
-    },
-    body: content,
-  });
-
-  if (!response.ok) {
-    const text = await response.text().catch(() => '');
-    throw new Error(`Storage upload failed (${response.status}): ${text}`);
-  }
-}
-
-/**
- * Get the current app manifest version from the apps table.
- */
-async function getAppCurrentVersion(supabaseUrl, supabaseKey, appId) {
-  const encodedAppId = encodeURIComponent(appId);
-  const url = `${supabaseUrl}/rest/v1/apps?id=eq.${encodedAppId}&select=manifest`;
-  const response = await fetch(url, {
-    headers: {
-      'Authorization': `Bearer ${supabaseKey}`,
-      'apikey': supabaseKey,
-    },
-  });
-  if (!response.ok) throw new Error(`Failed to get app version: ${response.status}`);
-  const rows = await response.json();
-  if (!rows.length) throw usageError(`App ${appId} not found.`);
-  const manifest = rows[0].manifest || {};
-  return { currentVersion: manifest.version || 0, manifest };
-}
-
-/**
- * Update the app manifest in the apps table.
- */
-async function updateAppVersion(supabaseUrl, supabaseKey, appId, newVersion, manifest) {
-  const encodedAppId = encodeURIComponent(appId);
-  const url = `${supabaseUrl}/rest/v1/apps?id=eq.${encodedAppId}`;
-  const response = await fetch(url, {
-    method: 'PATCH',
-    headers: {
-      'Authorization': `Bearer ${supabaseKey}`,
-      'apikey': supabaseKey,
-      'Content-Type': 'application/json',
-      'Prefer': 'return=minimal',
-    },
-    body: JSON.stringify({
-      manifest: { ...manifest, version: newVersion },
-      updated_at: new Date().toISOString(),
-    }),
-  });
-  if (!response.ok) {
-    const text = await response.text().catch(() => '');
-    throw new Error(`Failed to update app version: ${response.status} ${text}`);
-  }
-}
-
-const CONTENT_TYPE_MAP = {
-  '.js': 'application/javascript',
-  '.css': 'text/css',
-  '.json': 'application/json',
-  '.html': 'text/html',
-};
-
-/**
- * Deploy app bundle directly to Supabase storage, bypassing the backend server.
- */
-export async function directDeploy(projectDir, appId) {
-  const { supabaseUrl, supabaseKey } = resolveSupabaseCredentials();
-  const manifest = readManifest(projectDir);
-
-  // Get current version and increment
-  const { currentVersion } = await getAppCurrentVersion(supabaseUrl, supabaseKey, appId);
-  const newVersion = currentVersion + 1;
-
-  // Upload all files from the output directory
-  const outputDir = join(projectDir, OUTPUT_DIR);
-  const bucket = 'app-code';
-
-  async function uploadDir(dir, prefix) {
-    const entries = readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = join(dir, entry.name);
-      const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
-      if (entry.isDirectory()) {
-        await uploadDir(fullPath, relPath);
-      } else {
-        const ext = entry.name.includes('.') ? '.' + entry.name.split('.').pop() : '';
-        const contentType = CONTENT_TYPE_MAP[ext] || 'application/octet-stream';
-        const content = readFileSync(fullPath);
-        const storagePath = `${appId}/v${newVersion}/${relPath}`;
-        await uploadToStorage(supabaseUrl, supabaseKey, bucket, storagePath, content, contentType);
-      }
-    }
-  }
-
-  await uploadDir(outputDir, '');
-
-  // Update the app record -- include storage_prefix so the portal can resolve bundle URLs
-  const storagePrefix = `${appId}/v${newVersion}/`;
-  const deployManifest = {
-    ...manifest,
-    version: newVersion,
-    storage_bucket: bucket,
-    storage_prefix: storagePrefix,
-  };
-  await updateAppVersion(supabaseUrl, supabaseKey, appId, newVersion, deployManifest);
-
-  return { version: newVersion };
-}