@nometria-ai/nom 0.1.0

package/src/commands/start.js

@@ -0,0 +1,26 @@
+/**
+ * nom start — Start a stopped instance via Deno functions.
+ */
+import { readConfig } from '../lib/config.js';
+import { requireApiKey } from '../lib/auth.js';
+import { apiRequest } from '../lib/api.js';
+
+export async function start(flags) {
+  const apiKey = requireApiKey();
+  const config = readConfig();
+  const appId = config.app_id || config.name;
+
+  const result = await apiRequest('/updateInstanceState', {
+    apiKey,
+    body: { app_id: appId, instance_state: 'start' },
+  });
+
+  if (flags.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  console.log(`\n  Instance starting...`);
+  if (result.url) console.log(`  URL: ${result.url}`);
+  console.log();
+}

package/src/commands/status.js

@@ -0,0 +1,33 @@
+/**
+ * nom status — Check deployment status via Deno functions.
+ */
+import { readConfig } from '../lib/config.js';
+import { requireApiKey } from '../lib/auth.js';
+import { apiRequest } from '../lib/api.js';
+
+export async function status(flags) {
+  const apiKey = requireApiKey();
+  const config = readConfig();
+  const appId = config.app_id || config.name;
+
+  const result = await apiRequest('/checkAwsStatus', {
+    apiKey,
+    body: { app_id: appId },
+  });
+
+  if (flags.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  const data = result.data || {};
+  console.log(`
+  App:       ${config.name || appId}
+  Status:    ${data.deploymentStatus || data.instanceState || result.status || 'unknown'}
+  URL:       ${data.deployUrl || '—'}
+  Platform:  ${config.platform}
+  Region:    ${config.region}
+  Instance:  ${data.instanceType || config.instanceType || '—'}
+  IP:        ${data.ipAddress || '—'}
+`);
+}

package/src/commands/stop.js

@@ -0,0 +1,24 @@
+/**
+ * nom stop — Stop a running instance via Deno functions.
+ */
+import { readConfig } from '../lib/config.js';
+import { requireApiKey } from '../lib/auth.js';
+import { apiRequest } from '../lib/api.js';
+
+export async function stop(flags) {
+  const apiKey = requireApiKey();
+  const config = readConfig();
+  const appId = config.app_id || config.name;
+
+  const result = await apiRequest('/updateInstanceState', {
+    apiKey,
+    body: { app_id: appId, instance_state: 'stop' },
+  });
+
+  if (flags.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  console.log(`\n  Instance stopped.\n`);
+}

package/src/commands/terminate.js

@@ -0,0 +1,33 @@
+/**
+ * nom terminate — Terminate (destroy) an instance via Deno functions.
+ */
+import { readConfig } from '../lib/config.js';
+import { requireApiKey } from '../lib/auth.js';
+import { apiRequest } from '../lib/api.js';
+import { confirm } from '../lib/prompt.js';
+
+export async function terminate(flags) {
+  const apiKey = requireApiKey();
+  const config = readConfig();
+  const appId = config.app_id || config.name;
+
+  if (!flags.yes && !flags.y) {
+    const ok = await confirm(`Terminate instance "${appId}"? This cannot be undone.`, false);
+    if (!ok) {
+      console.log('\n  Aborted.\n');
+      return;
+    }
+  }
+
+  const result = await apiRequest('/updateInstanceState', {
+    apiKey,
+    body: { app_id: appId, instance_state: 'terminate' },
+  });
+
+  if (flags.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  console.log(`\n  Instance terminated.\n`);
+}

package/src/commands/upgrade.js

@@ -0,0 +1,49 @@
+/**
+ * nom upgrade — Upgrade instance size via Deno functions.
+ */
+import { readConfig } from '../lib/config.js';
+import { requireApiKey } from '../lib/auth.js';
+import { apiRequest } from '../lib/api.js';
+
+const VALID_SIZES = ['2gb', '4gb', '8gb', '16gb'];
+
+export async function upgrade(flags, positionals) {
+  const apiKey = requireApiKey();
+  const config = readConfig();
+  const appId = config.app_id || config.name;
+
+  const instanceType = positionals[0];
+  if (!instanceType) {
+    console.log(`
+  Usage: nom upgrade <size>
+
+  Sizes: ${VALID_SIZES.join(', ')}
+`);
+    process.exit(1);
+  }
+
+  const size = instanceType.toLowerCase();
+  if (!VALID_SIZES.includes(size)) {
+    console.error(`\n  Invalid size "${instanceType}". Must be one of: ${VALID_SIZES.join(', ')}\n`);
+    process.exit(1);
+  }
+
+  const result = await apiRequest('/upgradeInstance', {
+    apiKey,
+    body: { app_id: appId, instance_type: size },
+  });
+
+  if (flags.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  if (result.success) {
+    console.log(`\n  Upgraded to ${size}`);
+    if (result.message) console.log(`  ${result.message}`);
+    console.log();
+  } else {
+    console.error(`\n  Upgrade failed: ${result.error || 'Unknown error'}\n`);
+    process.exit(1);
+  }
+}

package/src/commands/whoami.js

@@ -0,0 +1,18 @@
+/**
+ * nom whoami — Show current authenticated user via Deno functions.
+ */
+import { requireApiKey } from '../lib/auth.js';
+import { apiRequest } from '../lib/api.js';
+
+export async function whoami(flags) {
+  const apiKey = requireApiKey();
+  const result = await apiRequest('/cli/auth', {
+    body: { api_key: apiKey },
+  });
+
+  if (flags.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(`\n  Logged in as: ${result.email}\n`);
+  }
+}

package/src/lib/api.js

@@ -0,0 +1,85 @@
+/**
+ * HTTP client for the Deno function endpoints at app.ownmy.app.
+ * All CLI calls go through the Deno function layer, NOT the Python backend.
+ * Uses native fetch (Node 18+).
+ */
+
+const DEFAULT_API_URL = 'https://app.ownmy.app';
+
+function getBaseUrl() {
+  return process.env.NOMETRIA_API_URL || DEFAULT_API_URL;
+}
+
+/**
+ * Make a JSON POST request to a Deno function endpoint.
+ * The API key is included in the request body (not as a Bearer token),
+ * because CLI functions use body-based auth via cli_api_keys table.
+ */
+export async function apiRequest(path, { method = 'POST', body = {}, apiKey } = {}) {
+  const url = `${getBaseUrl()}${path}`;
+
+  // Include api_key in the body for CLI auth
+  const payload = apiKey ? { ...body, api_key: apiKey } : body;
+
+  const res = await fetch(url, {
+    method,
+    headers: {
+      'Content-Type': 'application/json',
+      'User-Agent': 'nom-cli',
+    },
+    body: JSON.stringify(payload),
+  });
+
+  if (!res.ok) {
+    let message = `API error: ${res.status}`;
+    try {
+      const raw = await res.json();
+      // server.js wraps errors in { data: { error: ... } }
+      const data = raw?.data || raw;
+      message = data.detail || data.message || data.error || message;
+    } catch { /* ignore parse errors */ }
+    const err = new Error(message);
+    err.status = res.status;
+    if (res.status === 401) err.code = 'ERR_AUTH';
+    throw err;
+  }
+
+  // server.js wraps all JSON responses in { data: ... } — unwrap automatically
+  const raw = await res.json();
+  return raw?.data !== undefined ? raw.data : raw;
+}
+
+/**
+ * Upload a file to the Deno /cli/upload endpoint using multipart form data.
+ * Returns the public URL of the uploaded file.
+ */
+export async function uploadFile(apiKey, fileBuffer, fileName = 'code.tar.gz') {
+  const url = `${getBaseUrl()}/cli/upload`;
+
+  // Use FormData for multipart upload
+  const { FormData, Blob } = globalThis;
+  const formData = new FormData();
+  formData.append('api_key', apiKey);
+  formData.append('file', new Blob([fileBuffer], { type: 'application/gzip' }), fileName);
+
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: { 'User-Agent': 'nom-cli' },
+    body: formData,
+  });
+
+  if (!res.ok) {
+    let message = `Upload failed: ${res.status}`;
+    try {
+      const raw = await res.json();
+      const data = raw?.data || raw;
+      message = data.error || message;
+    } catch { /* ignore */ }
+    throw new Error(message);
+  }
+
+  const raw = await res.json();
+  return raw?.data !== undefined ? raw.data : raw;
+}
+
+export { getBaseUrl };

package/src/lib/auth.js

@@ -0,0 +1,56 @@
+/**
+ * API key resolution: NOMETRIA_API_KEY env > ~/.nometria/credentials.json
+ */
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const CREDENTIALS_DIR = join(homedir(), '.nometria');
+const CREDENTIALS_FILE = join(CREDENTIALS_DIR, 'credentials.json');
+
+export function getApiKey() {
+  // Env var takes priority (API key format)
+  if (process.env.NOMETRIA_API_KEY) {
+    return process.env.NOMETRIA_API_KEY;
+  }
+  // Also accept JWT token from VS Code extension / Claude Code commands
+  if (process.env.NOMETRIA_TOKEN) {
+    return process.env.NOMETRIA_TOKEN;
+  }
+  // Fall back to stored credentials
+  if (existsSync(CREDENTIALS_FILE)) {
+    try {
+      const creds = JSON.parse(readFileSync(CREDENTIALS_FILE, 'utf8'));
+      if (creds.apiKey) return creds.apiKey;
+    } catch { /* ignore malformed file */ }
+  }
+  return null;
+}
+
+export function requireApiKey() {
+  const key = getApiKey();
+  if (!key) {
+    const err = new Error('Not authenticated');
+    err.code = 'ERR_AUTH';
+    throw err;
+  }
+  return key;
+}
+
+export function saveApiKey(apiKey) {
+  if (!existsSync(CREDENTIALS_DIR)) {
+    mkdirSync(CREDENTIALS_DIR, { recursive: true });
+  }
+  writeFileSync(CREDENTIALS_FILE, JSON.stringify({ apiKey }, null, 2) + '\n', {
+    mode: 0o600, // owner-only read/write
+  });
+  return CREDENTIALS_FILE;
+}
+
+export function clearApiKey() {
+  if (existsSync(CREDENTIALS_FILE)) {
+    writeFileSync(CREDENTIALS_FILE, JSON.stringify({}, null, 2) + '\n', {
+      mode: 0o600,
+    });
+  }
+}

package/src/lib/config.js

@@ -0,0 +1,93 @@
+/**
+ * Read and validate nometria.json config
+ */
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+const CONFIG_FILE = 'nometria.json';
+
+const VALID_PLATFORMS = ['aws', 'gcp', 'azure', 'digitalocean', 'hetzner', 'vercel', 'render'];
+const VALID_FRAMEWORKS = ['vite', 'nextjs', 'remix', 'static', 'node', 'deno'];
+const VALID_INSTANCE_TYPES = ['2gb', '4gb', '8gb', '16gb', '32gb'];
+
+export function readConfig(dir = process.cwd()) {
+  const configPath = join(dir, CONFIG_FILE);
+  if (!existsSync(configPath)) {
+    const err = new Error(`${CONFIG_FILE} not found in ${dir}`);
+    err.code = 'ERR_CONFIG';
+    throw err;
+  }
+  const raw = readFileSync(configPath, 'utf8');
+  const config = JSON.parse(raw);
+  return validate(config);
+}
+
+export function configExists(dir = process.cwd()) {
+  return existsSync(join(dir, CONFIG_FILE));
+}
+
+function validate(config) {
+  // "name" is required for CLI deploys; "app_id" alone is enough for linked apps
+  if (!config.name && !config.app_id) {
+    throw new Error('nometria.json: either "name" or "app_id" is required');
+  }
+  if (config.name) {
+    if (!/^[a-z0-9][a-z0-9-]*[a-z0-9]$/.test(config.name) && config.name.length > 1) {
+      if (!/^[a-z0-9-]+$/.test(config.name)) {
+        throw new Error('nometria.json: "name" must be lowercase alphanumeric with hyphens');
+      }
+    }
+  }
+
+  config.platform = config.platform || 'aws';
+  if (!VALID_PLATFORMS.includes(config.platform)) {
+    throw new Error(`nometria.json: "platform" must be one of: ${VALID_PLATFORMS.join(', ')}`);
+  }
+
+  if (config.framework && !VALID_FRAMEWORKS.includes(config.framework)) {
+    throw new Error(`nometria.json: "framework" must be one of: ${VALID_FRAMEWORKS.join(', ')}`);
+  }
+
+  config.instanceType = config.instanceType || '4gb';
+  if (!VALID_INSTANCE_TYPES.includes(config.instanceType)) {
+    throw new Error(`nometria.json: "instanceType" must be one of: ${VALID_INSTANCE_TYPES.join(', ')}`);
+  }
+
+  config.region = config.region || 'us-east-1';
+  config.ignore = config.ignore || [];
+  config.build = config.build || {};
+  config.env = config.env || {};
+
+  // Optional fields from IDE extension linking
+  // app_id, migration_id, api_url are preserved but not required for CLI init
+  return config;
+}
+
+export function updateConfig(dir, updates) {
+  const configPath = join(dir, CONFIG_FILE);
+  let config = {};
+  if (existsSync(configPath)) {
+    config = JSON.parse(readFileSync(configPath, 'utf8'));
+  }
+  Object.assign(config, updates);
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+}
+
+export function resolveEnv(envConfig) {
+  const resolved = {};
+  for (const [key, value] of Object.entries(envConfig)) {
+    if (typeof value === 'string' && value.startsWith('@env:')) {
+      const envVar = value.slice(5);
+      const envValue = process.env[envVar];
+      if (!envValue) {
+        throw new Error(`Environment variable ${envVar} is not set (referenced by ${key})`);
+      }
+      resolved[key] = envValue;
+    } else {
+      resolved[key] = value;
+    }
+  }
+  return resolved;
+}
+
+export { CONFIG_FILE, VALID_PLATFORMS, VALID_FRAMEWORKS, VALID_INSTANCE_TYPES };

package/src/lib/detect.js

@@ -0,0 +1,88 @@
+/**
+ * Auto-detect project framework and build settings.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join, basename } from 'node:path';
+
+const DETECTORS = [
+  {
+    framework: 'nextjs',
+    files: ['next.config.js', 'next.config.mjs', 'next.config.ts'],
+    build: { command: 'npm run build', output: '.next' },
+  },
+  {
+    framework: 'remix',
+    files: ['remix.config.js', 'remix.config.ts'],
+    build: { command: 'npm run build', output: 'build' },
+  },
+  {
+    framework: 'vite',
+    files: ['vite.config.js', 'vite.config.ts', 'vite.config.mjs'],
+    build: { command: 'npm run build', output: 'dist' },
+  },
+  {
+    framework: 'static',
+    files: ['index.html'],
+    build: { command: null, output: '.' },
+  },
+];
+
+export function detectFramework(dir = process.cwd()) {
+  // Check package.json scripts for hints
+  const pkgPath = join(dir, 'package.json');
+  let pkg = null;
+  if (existsSync(pkgPath)) {
+    try {
+      pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    } catch { /* ignore */ }
+  }
+
+  // Check for framework config files
+  for (const detector of DETECTORS) {
+    for (const file of detector.files) {
+      if (existsSync(join(dir, file))) {
+        return {
+          framework: detector.framework,
+          build: { ...detector.build },
+        };
+      }
+    }
+  }
+
+  // Check package.json dependencies
+  if (pkg) {
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (deps['next']) return { framework: 'nextjs', build: { command: 'npm run build', output: '.next' } };
+    if (deps['@remix-run/node']) return { framework: 'remix', build: { command: 'npm run build', output: 'build' } };
+    if (deps['vite']) return { framework: 'vite', build: { command: 'npm run build', output: 'dist' } };
+  }
+
+  // Check if it looks like a Node.js project
+  if (pkg && (pkg.main || pkg.scripts?.start)) {
+    return { framework: 'node', build: { command: null, output: '.' } };
+  }
+
+  return { framework: 'static', build: { command: null, output: '.' } };
+}
+
+export function detectPackageManager(dir = process.cwd()) {
+  if (existsSync(join(dir, 'pnpm-lock.yaml'))) return 'pnpm';
+  if (existsSync(join(dir, 'yarn.lock'))) return 'yarn';
+  if (existsSync(join(dir, 'bun.lockb'))) return 'bun';
+  return 'npm';
+}
+
+export function getProjectName(dir = process.cwd()) {
+  const pkgPath = join(dir, 'package.json');
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+      if (pkg.name) {
+        // Strip scope and sanitize
+        return pkg.name.replace(/^@[^/]+\//, '').replace(/[^a-z0-9-]/g, '-');
+      }
+    } catch { /* ignore */ }
+  }
+  // Use directory name
+  return basename(dir).replace(/[^a-z0-9-]/gi, '-').toLowerCase();
+}

package/src/lib/prompt.js

@@ -0,0 +1,76 @@
+/**
+ * Interactive prompts using native readline.
+ */
+import { createInterface } from 'node:readline';
+
+function createReadline() {
+  return createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+}
+
+export function ask(question, defaultValue = '') {
+  return new Promise((resolve) => {
+    const rl = createReadline();
+    const suffix = defaultValue ? ` (${defaultValue})` : '';
+    rl.question(`  ${question}${suffix}: `, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue);
+    });
+  });
+}
+
+export function askSecret(question) {
+  return new Promise((resolve) => {
+    const rl = createReadline();
+    // Mute output for secret input
+    const originalWrite = process.stdout.write.bind(process.stdout);
+    rl.question(`  ${question}: `, (answer) => {
+      process.stdout.write = originalWrite;
+      console.log(); // newline after hidden input
+      rl.close();
+      resolve(answer.trim());
+    });
+    // Hide typed characters
+    process.stdout.write = (chunk) => {
+      if (typeof chunk === 'string' && !chunk.includes(question)) {
+        return originalWrite('*');
+      }
+      return originalWrite(chunk);
+    };
+  });
+}
+
+export function choose(question, options, defaultIndex = 0) {
+  return new Promise((resolve) => {
+    console.log(`\n  ${question}\n`);
+    options.forEach((opt, i) => {
+      const marker = i === defaultIndex ? '>' : ' ';
+      console.log(`  ${marker} ${i + 1}. ${opt}`);
+    });
+    const rl = createReadline();
+    rl.question(`\n  Choose [${defaultIndex + 1}]: `, (answer) => {
+      rl.close();
+      const idx = answer.trim() ? parseInt(answer) - 1 : defaultIndex;
+      if (idx >= 0 && idx < options.length) {
+        resolve(options[idx]);
+      } else {
+        resolve(options[defaultIndex]);
+      }
+    });
+  });
+}
+
+export function confirm(question, defaultYes = true) {
+  return new Promise((resolve) => {
+    const rl = createReadline();
+    const hint = defaultYes ? 'Y/n' : 'y/N';
+    rl.question(`  ${question} (${hint}): `, (answer) => {
+      rl.close();
+      const a = answer.trim().toLowerCase();
+      if (!a) return resolve(defaultYes);
+      resolve(a === 'y' || a === 'yes');
+    });
+  });
+}

package/src/lib/spinner.js

@@ -0,0 +1,43 @@
+/**
+ * Simple terminal spinner — zero dependencies.
+ */
+
+const FRAMES = ['   ', '.  ', '.. ', '...'];
+
+export function createSpinner(message) {
+  let frameIndex = 0;
+  let interval = null;
+  let currentMessage = message;
+
+  return {
+    start() {
+      process.stdout.write(`  ${currentMessage} `);
+      interval = setInterval(() => {
+        frameIndex = (frameIndex + 1) % FRAMES.length;
+        process.stdout.write(`\r  ${currentMessage} ${FRAMES[frameIndex]}`);
+      }, 200);
+      return this;
+    },
+
+    update(msg) {
+      currentMessage = msg;
+    },
+
+    succeed(msg) {
+      clearInterval(interval);
+      process.stdout.write(`\r  ${msg || currentMessage} \n`);
+      return this;
+    },
+
+    fail(msg) {
+      clearInterval(interval);
+      process.stdout.write(`\r  ${msg || currentMessage} \n`);
+      return this;
+    },
+
+    stop() {
+      clearInterval(interval);
+      process.stdout.write('\n');
+    },
+  };
+}

package/src/lib/tar.js

@@ -0,0 +1,55 @@
+/**
+ * Create tar.gz archive from project directory.
+ * Uses system `tar` command (available on macOS/Linux/WSL).
+ */
+import { execSync } from 'node:child_process';
+import { mkdtempSync, statSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const DEFAULT_EXCLUDES = [
+  'node_modules',
+  '.git',
+  '.env',
+  '.env.*',
+  '.DS_Store',
+  '*.log',
+  '.next/cache',
+  '.turbo',
+  '.vercel',
+  '.nometria',
+];
+
+export function createTarball(dir, extraIgnore = []) {
+  const tmpDir = mkdtempSync(join(tmpdir(), 'nom-'));
+  const tarPath = join(tmpDir, 'code.tar.gz');
+
+  const excludes = [...DEFAULT_EXCLUDES, ...extraIgnore]
+    .map(p => `--exclude='${p}'`)
+    .join(' ');
+
+  try {
+    execSync(`tar czf "${tarPath}" ${excludes} -C "${dir}" .`, {
+      stdio: 'pipe',
+      maxBuffer: 100 * 1024 * 1024, // 100MB
+    });
+  } catch (err) {
+    throw new Error(`Failed to create archive: ${err.stderr?.toString() || err.message}`);
+  }
+
+  const stats = statSync(tarPath);
+  const buffer = readFileSync(tarPath);
+
+  return {
+    path: tarPath,
+    buffer,
+    size: stats.size,
+    sizeFormatted: formatBytes(stats.size),
+  };
+}
+
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}