@nometria-ai/nom 0.2.2 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nometria-ai/nom",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Deploy any project to any cloud from your terminal. One command, zero config.",
   "type": "module",
   "bin": {

package/src/commands/deploy.js

@@ -6,6 +6,7 @@ import { execSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { readConfig, resolveEnv, updateConfig } from '../lib/config.js';
+import { detectServices } from '../lib/detect.js';
 import { requireApiKey } from '../lib/auth.js';
 import { apiRequest, uploadFile } from '../lib/api.js';
 import { createTarball } from '../lib/tar.js';
@@ -19,6 +20,17 @@ export async function deploy(flags) {
   const appName = config.name || config.app_id;
   const isResync = !!config.app_id;
 
+  // Auto-detect services if not in config (so nometria.json includes it in tarball)
+  if (!config.services) {
+    const { services, docker_compose } = detectServices(process.cwd());
+    if (services.length > 0 || docker_compose) {
+      const updates = {};
+      if (services.length > 0) updates.services = services;
+      if (docker_compose) updates.docker_compose = true;
+      try { updateConfig(process.cwd(), updates); Object.assign(config, updates); } catch { /* non-fatal */ }
+    }
+  }
+
   if (isResync) {
     console.log(`\n  Resyncing ${appName} on ${config.platform} (${config.region})\n`);
   } else {
@@ -99,16 +111,19 @@ export async function deploy(flags) {
       const deployStatus = statusResult.data?.deploymentStatus;
       const instanceState = statusResult.data?.instanceState;
       const topStatus = statusResult.status;
+      // Display status: prefer deploymentStatus (accurate), fall back to instanceState
       const st = deployStatus || instanceState || topStatus || 'unknown';
       deploySpinner.update(`${isResync ? 'Resyncing' : 'Deploying'} — ${st}`);
 
-      // "completed"/"running" from deploymentStatus/instanceState, or "deployed" from top-level
-      if (st === 'completed' || st === 'running' || topStatus === 'deployed' || instanceState === 'running') {
+      // Only trust deploymentStatus for completion — instanceState='running' just means
+      // EC2 booted, not that the deploy script finished.
+      const isDone = deployStatus === 'completed' || deployStatus === 'running' || topStatus === 'deployed';
+      if (isDone) {
         finalStatus = statusResult;
         deploySpinner.succeed(isResync ? 'Resynced successfully' : 'Deployed successfully');
         break;
       }
-      if (st === 'failed') {
+      if (deployStatus === 'failed' || st === 'failed') {
         deploySpinner.fail(`${isResync ? 'Resync' : 'Deploy'} failed: ${statusResult.data?.errorMessage || 'unknown error'}`);
         process.exit(1);
       }

package/src/commands/init.js

@@ -3,7 +3,7 @@
  */
 import { writeFileSync } from 'node:fs';
 import { join, basename } from 'node:path';
-import { detectFramework, detectPackageManager } from '../lib/detect.js';
+import { detectFramework, detectPackageManager, detectServices } from '../lib/detect.js';
 import { configExists, CONFIG_FILE, VALID_PLATFORMS } from '../lib/config.js';
 import { ask, choose, confirm } from '../lib/prompt.js';
 
@@ -30,10 +30,18 @@ export async function init(flags) {
 
   console.log('\n  Setting up your project for deployment\n');
 
-  // Detect framework
+  // Detect framework and services
   const detected = detectFramework(dir);
   const pkgManager = detectPackageManager(dir);
-  console.log(`  Detected: ${detected.framework} (${pkgManager})\n`);
+  const { services, docker_compose } = detectServices(dir);
+  console.log(`  Detected: ${detected.framework} (${pkgManager})`);
+  if (services.length > 0) {
+    console.log(`  Services: ${services.map(s => `${s.name} (${s.type})`).join(', ')}`);
+  }
+  if (docker_compose) {
+    console.log(`  Docker Compose: yes`);
+  }
+  console.log();
 
   // Project name
   const dirName = basename(dir).replace(/[^a-z0-9-]/gi, '-').toLowerCase();
@@ -73,6 +81,8 @@ export async function init(flags) {
     },
     env: {},
     ignore: [],
+    ...(services.length > 0 ? { services } : {}),
+    ...(docker_compose ? { docker_compose: true } : {}),
   };
 
   const configPath = join(dir, CONFIG_FILE);

package/src/lib/detect.js

@@ -1,7 +1,7 @@
 /**
  * Auto-detect project framework and build settings.
  */
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join, basename } from 'node:path';
 
 const DETECTORS = [
@@ -72,6 +72,123 @@ export function detectPackageManager(dir = process.cwd()) {
   return 'npm';
 }
 
+// ── Frontend/backend indicator deps ────────────────────────────────────────
+const FRONTEND_INDICATORS = new Set([
+  'react', 'react-dom', 'vue', 'svelte', '@sveltejs/kit', 'next', 'nuxt',
+  '@angular/core', 'vite', 'solid-js', 'astro', '@remix-run/react',
+]);
+const FRONTEND_CONFIG_FILES = [
+  'vite.config.js', 'vite.config.ts', 'vite.config.mjs',
+  'next.config.js', 'next.config.mjs', 'next.config.ts',
+  'svelte.config.js', 'nuxt.config.ts', 'angular.json', 'astro.config.mjs',
+];
+const BACKEND_INDICATORS = new Set([
+  'express', 'fastify', 'hono', 'koa', '@nestjs/core', '@hapi/hapi',
+  'restify', 'polka', 'micro', 'moleculer',
+]);
+
+/**
+ * Classify a directory as frontend, backend, or unknown based on its package.json
+ * and config files.
+ */
+function classifyServiceDir(dir) {
+  const pkgPath = join(dir, 'package.json');
+  if (!existsSync(pkgPath)) return null;
+
+  let pkg;
+  try { pkg = JSON.parse(readFileSync(pkgPath, 'utf8')); } catch { return null; }
+
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  const depNames = Object.keys(deps);
+
+  // Check for frontend config files
+  const hasFrontendConfig = FRONTEND_CONFIG_FILES.some(f => existsSync(join(dir, f)));
+  const hasFrontendDep = depNames.some(d => FRONTEND_INDICATORS.has(d));
+  const hasBackendDep = depNames.some(d => BACKEND_INDICATORS.has(d));
+
+  let type = 'unknown';
+  if (hasFrontendConfig || (hasFrontendDep && !hasBackendDep)) {
+    type = 'frontend';
+  } else if (hasBackendDep || (pkg.scripts?.start && !hasFrontendDep)) {
+    type = 'backend';
+  }
+
+  // Detect build command
+  let build = null;
+  if (pkg.scripts?.build) {
+    const pm = detectPackageManager(dir);
+    build = `${pm} run build`;
+  }
+
+  // Detect start command
+  let start = null;
+  if (pkg.scripts?.start) {
+    const pm = detectPackageManager(dir);
+    start = `${pm} run start`;
+  }
+
+  // Try to detect port from scripts.start or common env patterns
+  let port = null;
+  const startScript = pkg.scripts?.start || '';
+  const portMatch = startScript.match(/(?:--port|PORT=|:)\s*(\d{4,5})/);
+  if (portMatch) port = parseInt(portMatch[1], 10);
+
+  return { type, build, start, port };
+}
+
+/**
+ * Detect multi-service project structure.
+ * Scans subdirs for package.json, classifies as frontend/backend,
+ * and checks for docker-compose.yml.
+ *
+ * Returns { services: [...], docker_compose: boolean }
+ * services is empty for single-root projects (existing flow handles those).
+ */
+export function detectServices(dir = process.cwd()) {
+  const result = { services: [], docker_compose: false };
+
+  // Check for docker-compose
+  if (existsSync(join(dir, 'docker-compose.yml')) || existsSync(join(dir, 'docker-compose.yaml'))) {
+    result.docker_compose = true;
+  }
+
+  // If root has package.json AND no subdirs with package.json → single-root project
+  const hasRootPkg = existsSync(join(dir, 'package.json'));
+
+  // Scan immediate subdirs for package.json
+  let entries;
+  try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return result; }
+
+  const subdirServices = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+
+    const subdir = join(dir, entry.name);
+    const info = classifyServiceDir(subdir);
+    if (!info) continue;
+
+    subdirServices.push({
+      name: entry.name,
+      path: entry.name,
+      type: info.type,
+      ...(info.build ? { build: info.build } : {}),
+      ...(info.start ? { start: info.start } : {}),
+      ...(info.port ? { port: info.port } : {}),
+    });
+  }
+
+  // Only populate services for multi-folder projects
+  if (subdirServices.length > 0) {
+    // Sort: frontends first, then backends, then unknown
+    const order = { frontend: 0, backend: 1, unknown: 2 };
+    subdirServices.sort((a, b) => (order[a.type] ?? 2) - (order[b.type] ?? 2));
+    result.services = subdirServices;
+  }
+
+  return result;
+}
+
 export function getProjectName(dir = process.cwd()) {
   const pkgPath = join(dir, 'package.json');
   if (existsSync(pkgPath)) {