@daileyos/cli 0.1.0

package/src/commands/billing.ts

@@ -0,0 +1,75 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { api } from '../api.js';
+import { formatTable, handleJson, withErrorHandler } from '../util.js';
+
+export function registerBillingCommands(program: Command): void {
+  const billing = program
+    .command('billing')
+    .description('Show current plan and usage')
+    .option('--json', 'Output as JSON')
+    .action(
+      withErrorHandler(async (opts: { json?: boolean }) => {
+        const spinner = ora('Fetching billing info...').start();
+        const data = await api<Record<string, unknown>>('/billing');
+        spinner.stop();
+
+        handleJson(opts.json, data);
+
+        console.log(chalk.bold('Billing Overview:'));
+        for (const [key, value] of Object.entries(data)) {
+          if (typeof value !== 'object') {
+            console.log(`  ${chalk.blue(key + ':')}  ${value}`);
+          }
+        }
+      }),
+    );
+
+  billing
+    .command('invoices')
+    .description('List invoice history')
+    .option('--json', 'Output as JSON')
+    .action(
+      withErrorHandler(async (opts: { json?: boolean }) => {
+        const spinner = ora('Fetching invoices...').start();
+        const data = await api<{ invoices: Record<string, string>[] }>('/billing/invoices');
+        spinner.stop();
+
+        handleJson(opts.json, data.invoices);
+
+        console.log(chalk.bold('Invoices:'));
+        console.log(
+          formatTable(data.invoices ?? [], [
+            { key: 'id', label: 'ID' },
+            { key: 'date', label: 'Date' },
+            { key: 'amount', label: 'Amount' },
+            { key: 'status', label: 'Status' },
+          ]),
+        );
+      }),
+    );
+
+  billing
+    .command('estimate')
+    .description('Estimate cost for scaling')
+    .option('--action <action>', 'Action to estimate', 'scale')
+    .option('--replicas <n>', 'Number of replicas', '3')
+    .option('--json', 'Output as JSON')
+    .action(
+      withErrorHandler(async (opts: { action: string; replicas: string; json?: boolean }) => {
+        const spinner = ora('Calculating estimate...').start();
+        const data = await api<Record<string, unknown>>('/billing/estimate', {
+          params: { action: opts.action, replicas: opts.replicas },
+        });
+        spinner.stop();
+
+        handleJson(opts.json, data);
+
+        console.log(chalk.bold('Cost Estimate:'));
+        for (const [key, value] of Object.entries(data)) {
+          console.log(`  ${chalk.blue(key + ':')}  ${value}`);
+        }
+      }),
+    );
+}

package/src/commands/db.ts

@@ -0,0 +1,237 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { api } from '../api.js';
+import { resolveProject, handleJson, withErrorHandler } from '../util.js';
+
+function printQueryRows(data: any): void {
+  console.log(chalk.gray(`${data.row_count} row(s) in ${data.duration_ms}ms`));
+  if (data.read_only) {
+    const note = data.auto_limited ? 'read-only mode, limit applied automatically' : 'read-only mode';
+    console.log(chalk.gray(`${note}\n`));
+  } else {
+    console.log();
+  }
+
+  if (!data.rows || data.rows.length === 0) {
+    return;
+  }
+
+  const keys = Object.keys(data.rows[0]);
+  const widths = keys.map((k) => Math.max(k.length, ...data.rows.map((r: any) => String(r[k] ?? 'NULL').length)));
+
+  console.log(keys.map((k, i) => chalk.bold(k.padEnd(widths[i]))).join('  '));
+  console.log(keys.map((_k, i) => '─'.repeat(widths[i])).join('  '));
+
+  for (const row of data.rows.slice(0, 50)) {
+    console.log(keys.map((k, i) => String(row[k] ?? chalk.gray('NULL')).padEnd(widths[i])).join('  '));
+  }
+
+  if (data.rows.length > 50) {
+    console.log(chalk.gray(`\n... and ${data.rows.length - 50} more rows`));
+  }
+}
+
+export function registerDbCommands(program: Command): void {
+  const db = program.command('db').description('Database management');
+
+  db.command('info <idOrName>')
+    .description('Show database connection info')
+    .option('--json', 'Output as JSON')
+    .action(
+      withErrorHandler(async (idOrName: unknown, opts: { json?: boolean }) => {
+        const project = await resolveProject(String(idOrName));
+        const spinner = ora('Fetching database info...').start();
+        const data = await api<Record<string, unknown>>(`/projects/${project.id}/database`);
+        spinner.stop();
+
+        handleJson(opts.json, data);
+
+        console.log(chalk.bold(`Database for ${project.name}:`));
+        const fields = ['host', 'port', 'database', 'username', 'status', 'size'];
+        for (const f of fields) {
+          if (data[f] !== undefined) {
+            console.log(`  ${chalk.blue(f + ':')}  ${data[f]}`);
+          }
+        }
+      }),
+    );
+
+  db.command('schema <idOrName>')
+    .description('Show database schema — tables, columns, indexes')
+    .option('--json', 'Output as JSON')
+    .action(
+      withErrorHandler(async (idOrName: unknown, opts: { json?: boolean }) => {
+        const project = await resolveProject(String(idOrName));
+        const spinner = ora('Fetching schema...').start();
+        const data = await api<any>(`/projects/${project.id}/database/schema`);
+        spinner.stop();
+
+        handleJson(opts.json, data);
+
+        console.log(chalk.bold(`Schema: ${data.database}`));
+        console.log(chalk.gray(`${data.tables?.length || 0} tables, ${data.total_rows || 0} rows, ${data.total_size_kb || 0} KB\n`));
+
+        for (const table of data.tables || []) {
+          console.log(chalk.bold.blue(`  ${table.name}`) + chalk.gray(` (${table.rows} rows, ${table.size_kb} KB)`));
+          for (const col of table.columns || []) {
+            const keyBadge = col.key === 'PRI' ? chalk.yellow(' PK') : col.key === 'UNI' ? chalk.cyan(' UQ') : col.key === 'MUL' ? chalk.gray(' IDX') : '';
+            const nullable = col.nullable ? chalk.gray(' NULL') : '';
+            const extra = col.extra ? chalk.gray(` ${col.extra}`) : '';
+            console.log(`    ${chalk.white(col.name.padEnd(25))} ${chalk.gray(col.type)}${keyBadge}${nullable}${extra}`);
+          }
+          console.log();
+        }
+      }),
+    );
+
+  db.command('query <idOrName> <sql>')
+    .description('Run a read-only SQL query against the project database')
+    .option('--json', 'Output as JSON')
+    .action(
+      withErrorHandler(async (idOrName: unknown, sql: unknown, opts: { json?: boolean }) => {
+        const project = await resolveProject(String(idOrName));
+        const spinner = ora('Executing query...').start();
+        const data = await api<any>(`/projects/${project.id}/database/query`, {
+          method: 'POST',
+          body: { sql: String(sql) },
+        });
+        spinner.stop();
+
+        if (data.error) {
+          console.error(chalk.red(`Error: ${data.error}`));
+          return;
+        }
+
+        handleJson(opts.json, data);
+        printQueryRows(data);
+      }),
+    );
+
+  db.command('recall <idOrName> <sql>')
+    .description('Recall records with an explicitly read-only SQL query')
+    .option('--limit <n>', 'Auto-limit SELECT/WITH queries without LIMIT (default: 100)')
+    .option('--json', 'Output as JSON')
+    .action(
+      withErrorHandler(async (idOrName: unknown, sql: unknown, opts: { json?: boolean; limit?: string }) => {
+        const project = await resolveProject(String(idOrName));
+        const spinner = ora('Recalling records...').start();
+        const body: Record<string, unknown> = { sql: String(sql) };
+        if (opts.limit) body.limit = Number(opts.limit);
+        const data = await api<any>(`/projects/${project.id}/database/recall`, {
+          method: 'POST',
+          body,
+        });
+        spinner.stop();
+
+        if (data.error) {
+          console.error(chalk.red(`Error: ${data.error}`));
+          return;
+        }
+
+        handleJson(opts.json, data);
+        printQueryRows(data);
+      }),
+    );
+
+  db.command('migrations <idOrName>')
+    .description('Show migration status for a project')
+    .option('--json', 'Output as JSON')
+    .action(
+      withErrorHandler(async (idOrName: unknown, opts: { json?: boolean }) => {
+        const project = await resolveProject(String(idOrName));
+        const spinner = ora('Checking migrations...').start();
+        const data = await api<any>(`/projects/${project.id}/database/migrations`);
+        spinner.stop();
+
+        handleJson(opts.json, data);
+
+        if (!data.has_migration_table) {
+          console.log(chalk.yellow('No _migrations table found.'));
+          console.log(chalk.gray('This project may not use the auto-migration pattern.'));
+          console.log(chalk.gray('Add a migrations/ directory with SQL files to enable auto-migrations.'));
+          return;
+        }
+
+        console.log(chalk.bold(`Migrations for ${project.name}:`));
+        console.log(chalk.gray(`${data.total_applied} applied\n`));
+
+        for (const m of data.applied || []) {
+          const date = m.applied_at ? new Date(m.applied_at).toLocaleString() : 'unknown';
+          console.log(`  ${chalk.green('✓')} ${m.name}  ${chalk.gray(date)}`);
+        }
+      }),
+    );
+
+  db.command('validate <idOrName> <sqlFile>')
+    .description('Validate a migration SQL file against the current schema')
+    .option('--json', 'Output as JSON')
+    .action(
+      withErrorHandler(async (idOrName: unknown, sqlFile: unknown, opts: { json?: boolean }) => {
+        const fs = await import('fs');
+        const filePath = String(sqlFile);
+
+        if (!fs.existsSync(filePath)) {
+          console.error(chalk.red(`File not found: ${filePath}`));
+          process.exit(1);
+        }
+
+        const sql = fs.readFileSync(filePath, 'utf8');
+        const project = await resolveProject(String(idOrName));
+        const spinner = ora('Validating migration...').start();
+        const data = await api<any>(`/projects/${project.id}/database/validate`, {
+          method: 'POST',
+          body: { sql },
+        });
+        spinner.stop();
+
+        handleJson(opts.json, data);
+
+        console.log(chalk.bold(data.summary));
+        console.log();
+
+        for (const stmt of data.statements || []) {
+          const icon = !stmt.valid ? chalk.red('✗') : stmt.warning ? chalk.yellow('⚠') : chalk.green('✓');
+          console.log(`  ${icon} ${chalk.gray(stmt.sql)}`);
+          if (stmt.error) console.log(`    ${chalk.red(stmt.error)}`);
+          if (stmt.warning) console.log(`    ${chalk.yellow(stmt.warning)}`);
+          if (stmt.info) console.log(`    ${chalk.gray(stmt.info)}`);
+        }
+      }),
+    );
+
+  db.command('connect <idOrName>')
+    .description('Show connection details for external database tools')
+    .action(
+      withErrorHandler(async (idOrName: unknown) => {
+        const project = await resolveProject(String(idOrName));
+        const spinner = ora('Fetching connection info...').start();
+        const data = await api<any>(`/projects/${project.id}/database`);
+        spinner.stop();
+
+        if (!data.database) {
+          console.log(chalk.yellow('This project does not have a database.'));
+          return;
+        }
+
+        console.log(chalk.bold('Database Connection Details'));
+        console.log(chalk.gray('Use these with Sequel Ace, TablePlus, DBeaver, or any MySQL client.\n'));
+
+        console.log(`  ${chalk.blue('Host:')}      ${data.host || 'auto-injected'}`);
+        console.log(`  ${chalk.blue('Port:')}      ${data.port || 3306}`);
+        console.log(`  ${chalk.blue('Database:')}  ${data.database}`);
+        console.log(`  ${chalk.blue('User:')}      ${data.username || data.user || 'see env vars'}`);
+        console.log(`  ${chalk.blue('Password:')}  ${chalk.gray('(available in your app as DB_PASSWORD env var)')}`);
+
+        console.log(chalk.gray('\nNote: Direct database access requires network connectivity'));
+        console.log(chalk.gray('to the Dailey infrastructure. Use the web console in the'));
+        console.log(chalk.gray('dashboard for browser-based access, or `dailey db query`'));
+        console.log(chalk.gray('for quick queries from the CLI.'));
+
+        console.log(chalk.bold('\nQuick queries:'));
+        console.log(chalk.gray(`  dailey db query ${String(idOrName)} "SELECT * FROM users LIMIT 10"`));
+        console.log(chalk.gray(`  dailey db schema ${String(idOrName)}`));
+        console.log(chalk.gray(`  dailey db migrations ${String(idOrName)}`));
+      }),
+    );
+}

package/src/commands/deploy.ts

@@ -0,0 +1,91 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { api } from '../api.js';
+import { resolveProject, formatTable, handleJson, withErrorHandler } from '../util.js';
+
+export function registerDeployCommands(program: Command): void {
+  program
+    .command('deploy <idOrName>')
+    .description('Trigger a deploy (shows push instructions)')
+    .action(
+      withErrorHandler(async (idOrName: unknown) => {
+        const project = await resolveProject(String(idOrName));
+        console.log(chalk.bold(`Deploy "${project.name}"`));
+        console.log();
+        console.log(chalk.gray('Deploys are triggered automatically when you push to the configured branch.'));
+        console.log(chalk.gray('Push your code to trigger a new deployment:'));
+        console.log();
+        console.log(chalk.blue(`  git push origin ${project.branch || 'main'}`));
+        console.log();
+        console.log(chalk.gray(`View deploy history with: ${chalk.white(`dailey deploys ${project.name}`)}`));
+      }),
+    );
+
+  program
+    .command('logs <idOrName>')
+    .description('View pod logs')
+    .option('--tail <lines>', 'Number of lines to tail', '100')
+    .option('--json', 'Output as JSON')
+    .action(
+      withErrorHandler(async (idOrName: unknown, opts: { tail: string; json?: boolean }) => {
+        const project = await resolveProject(String(idOrName));
+        const spinner = ora('Fetching logs...').start();
+        const data = await api<{ logs: string[] }>(`/projects/${project.id}/logs`, {
+          params: { tail: opts.tail },
+        });
+        spinner.stop();
+
+        handleJson(opts.json, data.logs);
+
+        if (!data.logs || data.logs.length === 0) {
+          console.log(chalk.gray('No logs available.'));
+          return;
+        }
+
+        for (const line of data.logs) {
+          console.log(line);
+        }
+      }),
+    );
+
+  program
+    .command('deploys <idOrName>')
+    .description('List deploy history')
+    .option('--json', 'Output as JSON')
+    .action(
+      withErrorHandler(async (idOrName: unknown, opts: { json?: boolean }) => {
+        const project = await resolveProject(String(idOrName));
+        const spinner = ora('Fetching deploys...').start();
+        const data = await api<{ builds: Record<string, string>[] }>(`/projects/${project.id}/deploys`);
+        spinner.stop();
+
+        handleJson(opts.json, data.builds);
+
+        console.log(chalk.bold(`Deploys for ${project.name}:`));
+        console.log(
+          formatTable(data.builds, [
+            { key: 'id', label: 'Build ID' },
+            { key: 'status', label: 'Status' },
+            { key: 'commit', label: 'Commit' },
+            { key: 'created_at', label: 'Date' },
+          ]),
+        );
+      }),
+    );
+
+  program
+    .command('rollback <idOrName> <buildId>')
+    .description('Rollback to a previous build')
+    .action(
+      withErrorHandler(async (idOrName: unknown, buildId: unknown) => {
+        const project = await resolveProject(String(idOrName));
+        const spinner = ora('Rolling back...').start();
+        await api(`/projects/${project.id}/rollback`, {
+          method: 'POST',
+          body: { build_id: String(buildId) },
+        });
+        spinner.succeed(chalk.green(`Rolled back "${project.name}" to build ${buildId}.`));
+      }),
+    );
+}

package/src/commands/domains.ts

@@ -0,0 +1,62 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { api } from '../api.js';
+import { resolveProject, formatTable, handleJson, withErrorHandler } from '../util.js';
+
+export function registerDomainCommands(program: Command): void {
+  const domains = program.command('domains').description('Manage custom domains');
+
+  domains
+    .command('list <idOrName>')
+    .description('List custom domains')
+    .option('--json', 'Output as JSON')
+    .action(
+      withErrorHandler(async (idOrName: unknown, opts: { json?: boolean }) => {
+        const project = await resolveProject(String(idOrName));
+        const spinner = ora('Fetching domains...').start();
+        const data = await api<{ domains: Record<string, string>[] }>(`/projects/${project.id}/domains`);
+        spinner.stop();
+
+        handleJson(opts.json, data.domains);
+
+        console.log(chalk.bold(`Domains for ${project.name}:`));
+        console.log(
+          formatTable(data.domains, [
+            { key: 'domain', label: 'Domain' },
+            { key: 'status', label: 'Status' },
+          ]),
+        );
+      }),
+    );
+
+  domains
+    .command('add <idOrName> <domain>')
+    .description('Add a custom domain')
+    .action(
+      withErrorHandler(async (idOrName: unknown, domain: unknown) => {
+        const project = await resolveProject(String(idOrName));
+        const spinner = ora(`Adding domain ${domain}...`).start();
+        await api(`/projects/${project.id}/domains`, {
+          method: 'POST',
+          body: { domain: String(domain) },
+        });
+        spinner.succeed(chalk.green(`Added domain "${domain}" to "${project.name}".`));
+      }),
+    );
+
+  domains
+    .command('remove <idOrName> <domain>')
+    .description('Remove a custom domain')
+    .action(
+      withErrorHandler(async (idOrName: unknown, domain: unknown) => {
+        const project = await resolveProject(String(idOrName));
+        const spinner = ora(`Removing domain ${domain}...`).start();
+        await api(`/projects/${project.id}/domains`, {
+          method: 'DELETE',
+          body: { domain: String(domain) },
+        });
+        spinner.succeed(chalk.green(`Removed domain "${domain}" from "${project.name}".`));
+      }),
+    );
+}

package/src/commands/env.ts

@@ -0,0 +1,69 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { api } from '../api.js';
+import { resolveProject, formatTable, handleJson, withErrorHandler } from '../util.js';
+
+export function registerEnvCommands(program: Command): void {
+  const env = program.command('env').description('Manage environment variables');
+
+  env
+    .command('list <idOrName>')
+    .description('List environment variables')
+    .option('--json', 'Output as JSON')
+    .action(
+      withErrorHandler(async (idOrName: unknown, opts: { json?: boolean }) => {
+        const project = await resolveProject(String(idOrName));
+        const spinner = ora('Fetching env vars...').start();
+        const data = await api<{ env_vars: Record<string, string>[] }>(`/projects/${project.id}/env`);
+        spinner.stop();
+
+        handleJson(opts.json, data.env_vars);
+
+        console.log(chalk.bold(`Environment variables for ${project.name}:`));
+        console.log(
+          formatTable(data.env_vars, [
+            { key: 'key', label: 'Key' },
+            { key: 'updated_at', label: 'Updated' },
+          ]),
+        );
+        console.log(chalk.gray('\nValues stay hidden here by design. Update them with `dailey env set`.'));
+      }),
+    );
+
+  env
+    .command('set <idOrName> <keyValue>')
+    .description('Set an environment variable (KEY=VALUE)')
+    .action(
+      withErrorHandler(async (idOrName: unknown, keyValue: unknown) => {
+        const kv = String(keyValue);
+        const eqIdx = kv.indexOf('=');
+        if (eqIdx === -1) {
+          console.error(chalk.red('Format must be KEY=VALUE'));
+          process.exit(1);
+        }
+        const key = kv.slice(0, eqIdx);
+        const value = kv.slice(eqIdx + 1);
+
+        const project = await resolveProject(String(idOrName));
+        const spinner = ora(`Setting ${key}...`).start();
+        await api(`/projects/${project.id}/env`, {
+          method: 'POST',
+          body: { key, value },
+        });
+        spinner.succeed(chalk.green(`Set ${key} on "${project.name}".`));
+      }),
+    );
+
+  env
+    .command('unset <idOrName> <key>')
+    .description('Remove an environment variable')
+    .action(
+      withErrorHandler(async (idOrName: unknown, key: unknown) => {
+        const project = await resolveProject(String(idOrName));
+        const spinner = ora(`Removing ${key}...`).start();
+        await api(`/projects/${project.id}/env/${String(key)}`, { method: 'DELETE' });
+        spinner.succeed(chalk.green(`Removed ${key} from "${project.name}".`));
+      }),
+    );
+}