@nometria-ai/nom 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Nometria
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,112 @@
+# nom
+
+Deploy any project to any cloud from your terminal. One command, zero config.
+
+```bash
+npx @nometria-ai/nom deploy
+```
+
+## Quick Start
+
+```bash
+# 1. Authenticate
+npx @nometria-ai/nom login
+
+# 2. Set up your project
+npx @nometria-ai/nom init
+
+# 3. Deploy
+npx @nometria-ai/nom deploy
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `nom login` | Authenticate with your API key |
+| `nom init` | Create a `nometria.json` config file |
+| `nom deploy` | Deploy to production |
+| `nom preview` | Create a staging preview |
+| `nom status` | Check deployment status |
+| `nom logs` | View deployment logs |
+| `nom logs -f` | Stream logs in real-time |
+| `nom whoami` | Show current authenticated user |
+
+## Configuration
+
+`nom init` creates a `nometria.json` in your project root:
+
+```json
+{
+  "name": "my-app",
+  "framework": "vite",
+  "platform": "aws",
+  "region": "us-east-1",
+  "instanceType": "4gb",
+  "build": {
+    "command": "npm run build",
+    "output": "dist"
+  },
+  "env": {
+    "DATABASE_URL": "@env:DATABASE_URL"
+  },
+  "ignore": []
+}
+```
+
+### Fields
+
+| Field | Description | Default |
+|-------|-------------|---------|
+| `name` | Project name (becomes `{name}.ownmy.app`) | from package.json |
+| `framework` | `vite`, `nextjs`, `remix`, `static`, `node` | auto-detected |
+| `platform` | `aws`, `gcp`, `azure`, `digitalocean`, `hetzner`, `vercel` | `aws` |
+| `region` | Cloud region | `us-east-1` |
+| `instanceType` | `2gb`, `4gb`, `8gb`, `16gb` | `4gb` |
+| `build.command` | Build command | auto-detected |
+| `build.output` | Build output directory | auto-detected |
+| `env` | Environment variables. Use `@env:VAR` to read from local env | `{}` |
+| `ignore` | Extra patterns to exclude from upload | `[]` |
+
+## Authentication
+
+Get an API key at [ownmy.app/settings/api-keys](https://ownmy.app/settings/api-keys).
+
+```bash
+# Option 1: Login command (stores in ~/.nometria/credentials.json)
+nom login
+
+# Option 2: Environment variable
+export NOMETRIA_API_KEY=nometria_sk_...
+```
+
+## Environment Variables
+
+Use the `@env:` prefix in `nometria.json` to reference local environment variables. These are resolved at deploy time and never stored in the config file:
+
+```json
+{
+  "env": {
+    "DATABASE_URL": "@env:DATABASE_URL",
+    "API_SECRET": "@env:MY_API_SECRET"
+  }
+}
+```
+
+## Supported Platforms
+
+- **AWS** (EC2 + Route53)
+- **Google Cloud** (Compute Engine)
+- **Azure** (Virtual Machines)
+- **DigitalOcean** (Droplets)
+- **Hetzner** (Cloud Servers)
+- **Vercel** (Serverless)
+
+## Requirements
+
+- Node.js 18+
+- `tar` command (available by default on macOS/Linux/WSL)
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@nometria-ai/nom",
+  "version": "0.1.0",
+  "description": "Deploy any project to any cloud from your terminal. One command, zero config.",
+  "type": "module",
+  "bin": {
+    "nom": "./src/cli.js"
+  },
+  "files": [
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test tests/*.test.js"
+  },
+  "keywords": [
+    "deploy",
+    "cloud",
+    "aws",
+    "vercel",
+    "gcp",
+    "azure",
+    "digitalocean",
+    "hetzner",
+    "cli",
+    "nometria",
+    "hosting",
+    "devops"
+  ],
+  "license": "MIT",
+  "author": "Nometria <hello@nometria.com>",
+  "homepage": "https://github.com/nometria/deploy-cli#readme",
+  "bugs": {
+    "url": "https://github.com/nometria/deploy-cli/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nometria/deploy-cli.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/cli.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+/**
+ * nom — Deploy any project to any cloud from your terminal.
+ *
+ * Commands:
+ *   nom init      Create a nometria.json config file
+ *   nom deploy    Deploy to production (default)
+ *   nom preview   Deploy a staging preview
+ *   nom status    Check deployment status
+ *   nom logs      View deployment logs
+ *   nom login     Authenticate with your API key
+ *   nom whoami    Show current authenticated user
+ */
+
+import { parseArgs } from 'node:util';
+import { init } from './commands/init.js';
+import { deploy } from './commands/deploy.js';
+import { preview } from './commands/preview.js';
+import { status } from './commands/status.js';
+import { logs } from './commands/logs.js';
+import { login } from './commands/login.js';
+import { whoami } from './commands/whoami.js';
+import { github } from './commands/github.js';
+import { start } from './commands/start.js';
+import { stop } from './commands/stop.js';
+import { terminate } from './commands/terminate.js';
+import { upgrade } from './commands/upgrade.js';
+import { domain } from './commands/domain.js';
+import { env } from './commands/env.js';
+import { scan } from './commands/scan.js';
+import { setup } from './commands/setup.js';
+
+const { values, positionals } = parseArgs({
+  allowPositionals: true,
+  options: {
+    help:    { type: 'boolean', short: 'h', default: false },
+    version: { type: 'boolean', short: 'v', default: false },
+    yes:     { type: 'boolean', short: 'y', default: false },
+    follow:  { type: 'boolean', short: 'f', default: false },
+    json:      { type: 'boolean', default: false },
+    from:      { type: 'string' },
+    'api-key': { type: 'boolean', default: false },
+    token:     { type: 'boolean', default: false },
+    message:   { type: 'string', short: 'm' },
+  },
+  strict: false,
+});
+
+if (values.version) {
+  const { readFileSync } = await import('node:fs');
+  const { fileURLToPath } = await import('node:url');
+  const { dirname, join } = await import('node:path');
+  const dir = dirname(fileURLToPath(import.meta.url));
+  const pkg = JSON.parse(readFileSync(join(dir, '..', 'package.json'), 'utf8'));
+  console.log(pkg.version);
+  process.exit(0);
+}
+
+const command = positionals[0] || 'deploy';
+
+if (values.help) {
+  printHelp();
+  process.exit(0);
+}
+
+const commands = {
+  init,
+  deploy,
+  preview,
+  status,
+  logs,
+  login,
+  whoami,
+  github,
+  start,
+  stop,
+  terminate,
+  upgrade,
+  domain,
+  env,
+  scan,
+  setup,
+};
+
+const handler = commands[command];
+if (!handler) {
+  console.error(`Unknown command: ${command}`);
+  printHelp();
+  process.exit(1);
+}
+
+try {
+  await handler(values, positionals.slice(1));
+} catch (err) {
+  if (err.code === 'ERR_AUTH') {
+    console.error(`\n  Not authenticated. Run: nom login\n`);
+  } else if (err.code === 'ERR_CONFIG') {
+    console.error(`\n  No nometria.json found. Run: nom init\n`);
+  } else {
+    console.error(`\n  Error: ${err.message}\n`);
+    if (process.env.NOM_DEBUG) console.error(err.stack);
+  }
+  process.exit(1);
+}
+
+function printHelp() {
+  console.log(`
+  nom — Deploy any project to any cloud.
+
+  Usage:
+    nom [command] [options]
+
+  Commands:
+    init                Create a nometria.json config file
+    deploy              Deploy to production (default)
+    preview             Deploy a staging preview
+    status              Check deployment status
+    logs [-f]           View deployment logs
+    login               Sign in via browser (or --api-key)
+    whoami              Show current user
+
+    github connect      Connect GitHub for auto-deploy
+    github status       Check GitHub connection
+    github repos        List connected repos
+    github push [-m]    Push changes to GitHub
+
+    start               Start a stopped instance
+    stop                Stop a running instance
+    terminate           Terminate instance permanently
+    upgrade <size>      Upgrade instance (2gb/4gb/8gb/16gb)
+
+    domain add <domain> Add custom domain
+    env set KEY=VALUE   Set environment variables
+    env list            List environment variables
+    env delete KEY      Delete environment variable
+    scan                Run AI security scan
+
+  Options:
+    -h, --help       Show this help
+    -v, --version    Show version
+    -y, --yes        Skip confirmation prompts
+    -f, --follow     Follow logs in real-time
+    -m, --message    Commit message (for github push)
+    --json           Output as JSON
+    --api-key        Login with API key paste instead of browser
+    --from <url>     Deploy from a GitHub URL
+
+  Examples:
+    nom login                    Sign in via browser
+    nom init                     Set up a new project
+    nom deploy                   Deploy current directory
+    nom github connect           Connect GitHub for auto-deploy
+    nom status                   Check deployment status
+    nom logs -f                  Stream live logs
+    nom upgrade 8gb              Upgrade instance to 8gb
+    nom env set DB_URL=postgres://...
+    nom scan                     Run AI security scan
+    nom setup                    Generate AI tool configs (Cursor, Copilot, etc.)
+
+  Environment:
+    NOMETRIA_API_KEY    API key (overrides stored credentials)
+    NOM_DEBUG           Enable debug output
+`);
+}

package/src/commands/deploy.js

@@ -0,0 +1,157 @@
+/**
+ * nom deploy — Build, upload, and deploy to production.
+ * All calls go through Deno functions at app.ownmy.app.
+ */
+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 { requireApiKey } from '../lib/auth.js';
+import { apiRequest, uploadFile } from '../lib/api.js';
+import { createTarball } from '../lib/tar.js';
+import { createSpinner } from '../lib/spinner.js';
+import { confirm } from '../lib/prompt.js';
+
+export async function deploy(flags) {
+  const apiKey = requireApiKey();
+  const config = readConfig();
+  const envVars = resolveEnv(config.env);
+  const appName = config.name || config.app_id;
+  const isResync = !!config.app_id;
+
+  if (isResync) {
+    console.log(`\n  Resyncing ${appName} on ${config.platform} (${config.region})\n`);
+  } else {
+    console.log(`\n  Deploying ${appName} to ${config.platform} (${config.region})\n`);
+  }
+
+  // Step 1: Build
+  if (config.build?.command) {
+    const spinner = createSpinner('Building').start();
+    try {
+      execSync(config.build.command, {
+        cwd: process.cwd(),
+        stdio: 'pipe',
+        env: { ...process.env, NODE_ENV: 'production' },
+      });
+      spinner.succeed('Built successfully');
+    } catch (err) {
+      spinner.fail('Build failed');
+      console.error(`\n${err.stderr?.toString() || err.message}\n`);
+      process.exit(1);
+    }
+  }
+
+  // Step 2: Create archive
+  const archiveSpinner = createSpinner('Creating archive').start();
+  let tarball;
+  try {
+    tarball = createTarball(process.cwd(), config.ignore);
+    archiveSpinner.succeed(`Archive created (${tarball.sizeFormatted})`);
+  } catch (err) {
+    archiveSpinner.fail('Failed to create archive');
+    throw err;
+  }
+
+  // Step 3: Upload to Supabase storage via Deno function
+  const uploadSpinner = createSpinner('Uploading').start();
+  let uploadResult;
+  try {
+    uploadResult = await uploadFile(apiKey, tarball.buffer, `${appName}.tar.gz`);
+    uploadSpinner.succeed(`Uploaded (${tarball.sizeFormatted})`);
+  } catch (err) {
+    uploadSpinner.fail('Upload failed');
+    throw err;
+  }
+
+  // Step 4: Trigger deploy via Deno function
+  const deploySpinner = createSpinner(isResync ? 'Resyncing' : 'Deploying').start();
+  let deployResult;
+  try {
+    deployResult = await apiRequest('/cli/deploy', {
+      apiKey,
+      body: {
+        app_name: appName,
+        upload_url: uploadResult.upload_url,
+        platform: config.platform,
+        region: config.region,
+        instance_type: config.instanceType || '4gb',
+        env_vars: envVars,
+        framework: config.framework,
+        ...(config.app_id ? { app_id: config.app_id } : {}),
+      },
+    });
+  } catch (err) {
+    deploySpinner.fail(isResync ? 'Resync failed' : 'Deploy request failed');
+    throw err;
+  }
+
+  // Step 5: Poll for status via Deno function
+  const deployId = deployResult.deploy_id || appName;
+  let finalStatus;
+  while (true) {
+    await sleep(3000);
+    try {
+      const statusResult = await apiRequest('/checkAwsStatus', {
+        apiKey,
+        body: { app_id: deployId },
+      });
+      const deployStatus = statusResult.data?.deploymentStatus;
+      const instanceState = statusResult.data?.instanceState;
+      const topStatus = statusResult.status;
+      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') {
+        finalStatus = statusResult;
+        deploySpinner.succeed(isResync ? 'Resynced successfully' : 'Deployed successfully');
+        break;
+      }
+      if (st === 'failed') {
+        deploySpinner.fail(`${isResync ? 'Resync' : 'Deploy'} failed: ${statusResult.data?.errorMessage || 'unknown error'}`);
+        process.exit(1);
+      }
+    } catch {
+      // Keep polling on transient errors
+    }
+  }
+
+  // Step 6: Write app_id and migration_id back to nometria.json
+  const updates = {};
+  if (!config.app_id && deployId) updates.app_id = deployId;
+  if (deployResult.migration_id && !config.migration_id) updates.migration_id = deployResult.migration_id;
+  if (Object.keys(updates).length > 0) {
+    try { updateConfig(process.cwd(), updates); } catch { /* non-fatal */ }
+  }
+
+  // Step 7: Print result
+  const url = finalStatus.data?.deployUrl || finalStatus.url || `https://${appName}.ownmy.app`;
+  console.log(`
+  Live at:    ${url}
+  Dashboard:  https://ownmy.app/apps/${appName}
+`);
+
+  // Step 8: Auto-detect git repo and offer GitHub connection
+  if (!flags.yes) {
+    const hasGit = existsSync(join(process.cwd(), '.git'));
+    if (hasGit) {
+      try {
+        const ghStatus = await apiRequest('/getUserGithubConnection', {
+          apiKey,
+          body: {},
+        });
+        if (!ghStatus.connected) {
+          const connectGh = await confirm('This project is a git repo. Connect GitHub for auto-deploy?');
+          if (connectGh) {
+            console.log('  Run: nom github connect\n');
+          }
+        }
+      } catch { /* non-fatal — github status check failed */ }
+    }
+  }
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}

package/src/commands/domain.js

@@ -0,0 +1,57 @@
+/**
+ * nom domain — Manage custom domains via Deno functions.
+ *
+ * Subcommands:
+ *   add <domain>  — Add a custom domain to the app
+ */
+import { readConfig } from '../lib/config.js';
+import { requireApiKey } from '../lib/auth.js';
+import { apiRequest } from '../lib/api.js';
+
+export async function domain(flags, positionals) {
+  const sub = positionals[0];
+
+  switch (sub) {
+    case 'add':
+      return domainAdd(flags, positionals);
+    default:
+      console.log(`
+  Usage: nom domain <command>
+
+  Commands:
+    add <domain>   Add a custom domain (e.g. nom domain add example.com)
+`);
+  }
+}
+
+async function domainAdd(flags, positionals) {
+  const apiKey = requireApiKey();
+  const config = readConfig();
+  const appId = config.app_id || config.name;
+
+  const customDomain = positionals[1];
+  if (!customDomain) {
+    console.error('\n  Usage: nom domain add <domain>\n');
+    process.exit(1);
+  }
+
+  const result = await apiRequest('/addCustomDomain', {
+    apiKey,
+    body: { app_id: appId, custom_domain: customDomain },
+  });
+
+  if (flags.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  if (result.success) {
+    console.log(`\n  Domain "${customDomain}" added.`);
+    if (result.cname) console.log(`  CNAME: ${result.cname}`);
+    if (result.instructions) console.log(`  ${result.instructions}`);
+    console.log();
+  } else {
+    console.error(`\n  Failed to add domain: ${result.error || 'Unknown error'}\n`);
+    process.exit(1);
+  }
+}

package/src/commands/env.js

@@ -0,0 +1,120 @@
+/**
+ * nom env — Manage environment variables via Deno functions.
+ *
+ * Subcommands:
+ *   set KEY=VALUE [KEY=VALUE ...]   Set environment variables
+ *   list                            List variable names
+ *   delete KEY [KEY ...]            Delete variables
+ */
+import { readConfig } from '../lib/config.js';
+import { requireApiKey } from '../lib/auth.js';
+import { apiRequest } from '../lib/api.js';
+
+export async function env(flags, positionals) {
+  const sub = positionals[0];
+
+  switch (sub) {
+    case 'set':
+      return envSet(flags, positionals.slice(1));
+    case 'list':
+      return envList(flags);
+    case 'delete':
+      return envDelete(flags, positionals.slice(1));
+    default:
+      console.log(`
+  Usage: nom env <command>
+
+  Commands:
+    set KEY=VALUE [...]   Set environment variables
+    list                  List variable names
+    delete KEY [...]      Delete variables
+`);
+  }
+}
+
+async function envSet(flags, pairs) {
+  const apiKey = requireApiKey();
+  const config = readConfig();
+  const appId = config.app_id || config.name;
+
+  if (!pairs.length) {
+    console.error('\n  Usage: nom env set KEY=VALUE [KEY=VALUE ...]\n');
+    process.exit(1);
+  }
+
+  const vars = {};
+  for (const pair of pairs) {
+    const eqIndex = pair.indexOf('=');
+    if (eqIndex === -1) {
+      console.error(`\n  Invalid format: "${pair}". Use KEY=VALUE.\n`);
+      process.exit(1);
+    }
+    const key = pair.slice(0, eqIndex);
+    const value = pair.slice(eqIndex + 1);
+    vars[key] = value;
+  }
+
+  const result = await apiRequest('/cli/env', {
+    apiKey,
+    body: { api_key: apiKey, app_id: appId, action: 'set', vars },
+  });
+
+  if (flags.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  const keys = Object.keys(vars);
+  console.log(`\n  Set ${keys.length} variable${keys.length === 1 ? '' : 's'}: ${keys.join(', ')}\n`);
+}
+
+async function envList(flags) {
+  const apiKey = requireApiKey();
+  const config = readConfig();
+  const appId = config.app_id || config.name;
+
+  const result = await apiRequest('/cli/env', {
+    apiKey,
+    body: { api_key: apiKey, app_id: appId, action: 'list' },
+  });
+
+  if (flags.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  const vars = result.keys || result.vars || [];
+  if (!vars.length) {
+    console.log('\n  No environment variables set.\n');
+    return;
+  }
+
+  console.log('\n  Environment variables:\n');
+  for (const name of vars) {
+    console.log(`  ${name}`);
+  }
+  console.log();
+}
+
+async function envDelete(flags, keys) {
+  const apiKey = requireApiKey();
+  const config = readConfig();
+  const appId = config.app_id || config.name;
+
+  if (!keys.length) {
+    console.error('\n  Usage: nom env delete KEY [KEY ...]\n');
+    process.exit(1);
+  }
+
+  const result = await apiRequest('/cli/env', {
+    apiKey,
+    body: { api_key: apiKey, app_id: appId, action: 'delete', vars: keys },
+  });
+
+  if (flags.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  console.log(`\n  Deleted ${keys.length} variable${keys.length === 1 ? '' : 's'}: ${keys.join(', ')}\n`);
+}