@notis_ai/cli 0.2.0-beta.16.1

package/src/runtime/app-platform.js

@@ -0,0 +1,624 @@
+/**
+ * App platform utilities for the Notis CLI.
+ *
+ * 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.
+ */
+
+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 { 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 MANIFEST_FILE = join(OUTPUT_DIR, 'manifest.json');
+let appConfigImportNonce = 0;
+
+// ---------------------------------------------------------------------------
+// Project directory resolution
+// ---------------------------------------------------------------------------
+
+export function resolveProjectDir(inputDir = '.') {
+  return resolve(process.cwd(), inputDir);
+}
+
+// ---------------------------------------------------------------------------
+// Config loading
+// ---------------------------------------------------------------------------
+
+/**
+ * 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.
+ */
+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;
+
+  for (const name of configPaths) {
+    const candidate = join(projectDir, name);
+    if (existsSync(candidate)) {
+      configPath = candidate;
+      break;
+    }
+  }
+
+  if (!configPath) {
+    throw usageError('No notis.config.ts found in project directory.');
+  }
+
+  // For .js/.mjs files, import directly. For .ts, we need transpilation.
+  if (configPath.endsWith('.ts')) {
+    const source = readFileSync(configPath, 'utf-8');
+    const jsSource = transpileTsConfigSource(source, configPath);
+
+    const tmpPath = join(dirname(configPath), '._notis_config_tmp.mjs');
+    mkdirSync(dirname(tmpPath), { recursive: true });
+    writeFileSync(tmpPath, jsSource);
+    try {
+      const mod = await import(`file://${tmpPath}?v=${appConfigImportNonce++}`);
+      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');
+        unlinkSync(tmpPath);
+      } catch {}
+    }
+  }
+
+  const mod = await import(`file://${configPath}`);
+  return mod.default || mod;
+}
+
+// ---------------------------------------------------------------------------
+// Project validation
+// ---------------------------------------------------------------------------
+
+export function detectProjectProblems(projectDir) {
+  const problems = [];
+
+  if (!existsSync(join(projectDir, 'package.json'))) {
+    problems.push('Missing package.json');
+  }
+
+  const hasViteConfig = ['vite.config.ts', 'vite.config.js', 'vite.config.mjs']
+    .some((name) => existsSync(join(projectDir, name)));
+  if (!hasViteConfig) {
+    problems.push('Missing vite.config file');
+  }
+
+  if (!existsSync(join(projectDir, 'app'))) {
+    problems.push('Missing app/ directory');
+  }
+
+  const hasNotisConfig = ['notis.config.ts', 'notis.config.js', 'notis.config.mjs']
+    .some((name) => existsSync(join(projectDir, name)));
+  if (!hasNotisConfig) {
+    problems.push('Missing notis.config.ts');
+  }
+
+  return problems;
+}
+
+export function detectProjectWarnings(projectDir, appConfig = null) {
+  const warnings = [];
+
+  if (!existsSync(join(projectDir, 'components.json'))) {
+    warnings.push('Missing components.json -- shadcn is not configured.');
+  }
+
+  const hasTailwind = ['tailwind.config.ts', 'tailwind.config.js', 'tailwind.config.cjs']
+    .some((name) => existsSync(join(projectDir, name)));
+  if (!hasTailwind) {
+    warnings.push('Missing Tailwind config.');
+  }
+
+  if (appConfig && (!Array.isArray(appConfig.databases) || appConfig.databases.length === 0)) {
+    warnings.push('No database references declared in notis.config.ts.');
+  }
+
+  return warnings;
+}
+
+// ---------------------------------------------------------------------------
+// Build
+// ---------------------------------------------------------------------------
+
+export async function runProjectScript({ projectDir, scriptName, env = {}, stdio = 'inherit' }) {
+  await new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn('npm', ['run', scriptName], {
+      cwd: projectDir,
+      stdio,
+      env: { ...process.env, ...env },
+    });
+    child.on('error', rejectPromise);
+    child.on('exit', (code) => {
+      if (code === 0) {
+        resolvePromise();
+        return;
+      }
+      rejectPromise(new Error(`npm run ${scriptName} failed with exit code ${code}`));
+    });
+  });
+}
+
+/**
+ * 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.
+ */
+function autoDetectRoutes(projectDir) {
+  const appDir = join(projectDir, 'app');
+  const routes = [];
+
+  function scan(dir, pathPrefix) {
+    if (!existsSync(dir)) return;
+    const entries = readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (entry.name.startsWith('_') || entry.name.startsWith('.')) continue;
+
+      if (entry.isDirectory()) {
+        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);
+        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),
+        });
+      }
+    }
+  }
+
+  scan(appDir, '');
+  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);
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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 databases = appConfig.databases || [];
+
+  return {
+    version: 1,
+    spec_version: 3,
+    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/.
+ */
+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
+  await runProjectScript({
+    projectDir,
+    scriptName: 'build',
+  });
+
+  // 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.');
+  }
+
+  // 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) };
+}
+
+/**
+ * Read the manifest from a built project.
+ */
+export function readManifest(projectDir) {
+  const manifestPath = join(projectDir, MANIFEST_FILE);
+  if (!existsSync(manifestPath)) {
+    throw usageError('No manifest found. Run "notis apps build" first.');
+  }
+  return JSON.parse(readFileSync(manifestPath, 'utf-8'));
+}
+
+// ---------------------------------------------------------------------------
+// Linking
+// ---------------------------------------------------------------------------
+
+export function readLinkedState(projectDir) {
+  const statePath = join(projectDir, STATE_FILE);
+  if (!existsSync(statePath)) return null;
+  return JSON.parse(readFileSync(statePath, 'utf-8'));
+}
+
+export function writeLinkedState(projectDir, state) {
+  const statePath = join(projectDir, STATE_FILE);
+  mkdirSync(dirname(statePath), { recursive: true });
+  writeFileSync(statePath, JSON.stringify(state, null, 2) + '\n');
+}
+
+export function requireLinkedAppId(projectDir, explicitAppId) {
+  if (explicitAppId) return explicitAppId;
+  const state = readLinkedState(projectDir);
+  if (state?.app_id) return state.app_id;
+  throw usageError('This project is not linked to a Notis app. Run "notis apps link <app-id> ." first.');
+}
+
+// ---------------------------------------------------------------------------
+// Scaffolding
+// ---------------------------------------------------------------------------
+
+/**
+ * Scaffold a new Notis app project from the SDK template.
+ */
+export function scaffoldProject({ projectDir, appName }) {
+  const templateDir = resolve(
+    dirname(fileURLToPath(import.meta.url)),
+    '../../template',
+  );
+
+  if (!existsSync(templateDir)) {
+    throw usageError(`SDK template not found at ${templateDir}. Ensure @notis_ai/cli is installed correctly.`);
+  }
+
+  mkdirSync(projectDir, { recursive: true });
+  cpSync(templateDir, projectDir, { recursive: true });
+
+  // Update package.json with the app name
+  const pkgPath = join(projectDir, 'package.json');
+  if (existsSync(pkgPath)) {
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    pkg.name = appName.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-');
+    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+  }
+
+  // Update notis.config.ts with the app name
+  const configPath = join(projectDir, 'notis.config.ts');
+  if (existsSync(configPath)) {
+    let config = readFileSync(configPath, 'utf-8');
+    config = config.replace(/'My Notis App'/, `'${appName.replace(/'/g, "\\'")}'`);
+    writeFileSync(configPath, config);
+  }
+
+  return { projectDir };
+}
+
+// ---------------------------------------------------------------------------
+// Deploy helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Collect all files from .notis/output/ as base64-encoded entries for upload.
+ */
+export function collectArtifactFiles(projectDir) {
+  const outputDir = join(projectDir, OUTPUT_DIR);
+  if (!existsSync(outputDir)) {
+    throw usageError('No build output found. Run "notis apps build" first.');
+  }
+
+  const files = {};
+
+  function walk(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()) {
+        walk(fullPath, relPath);
+      } else {
+        files[relPath] = readFileSync(fullPath).toString('base64');
+      }
+    }
+  }
+
+  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 };
+}