@daileyos/cli 0.1.0

package/src/commands/jobs.ts

@@ -0,0 +1,287 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { api } from '../api.js';
+import { formatTable, handleJson, resolveProject, withErrorHandler } from '../util.js';
+
+interface ProjectRef {
+  id: string;
+  name: string;
+  slug: string;
+}
+
+interface JobContract {
+  id: string;
+  name: string;
+  slug: string;
+  enabled: boolean;
+  trigger_count: number;
+  enabled_trigger_count: number;
+  created_at: string | null;
+  updated_at: string | null;
+}
+
+interface JobExecution {
+  id: string;
+  contract_id: string | null;
+  contract_name: string | null;
+  contract_slug: string | null;
+  status: string;
+  environment: string | null;
+  pool_slug: string | null;
+  attempt: number;
+  max_attempts: number;
+  created_by_principal: string | null;
+  created_at: string | null;
+  started_at: string | null;
+  finished_at: string | null;
+  exit_code: number | null;
+  error_summary: string | null;
+}
+
+interface JobListResponse {
+  project: ProjectRef;
+  available: boolean;
+  reason?: string;
+  app_id?: string;
+  contracts: JobContract[];
+  executions: JobExecution[];
+}
+
+interface JobDetailResponse {
+  project: ProjectRef;
+  app_id: string;
+  execution: {
+    id: string;
+    contract_id: string | null;
+    status: string;
+    environment: string | null;
+    pool_slug: string | null;
+    attempt: number;
+    max_attempts: number;
+    created_by_principal: string | null;
+    created_at: string | null;
+    started_at: string | null;
+    finished_at: string | null;
+    exit_code: number | null;
+    error_summary: string | null;
+    metering: unknown;
+  };
+  contract: {
+    id: string;
+    name: string;
+    slug: string;
+    enabled: boolean;
+    spec: unknown;
+    created_at: string | null;
+    updated_at: string | null;
+  } | null;
+  execution_spec: {
+    created_at: string | null;
+    updated_at: string | null;
+    execution: unknown;
+  } | null;
+}
+
+interface JobLogsResponse {
+  project: ProjectRef;
+  execution_id: string;
+  logs: Array<{
+    id: string;
+    stream: string | null;
+    line: string | null;
+    ts: string | null;
+  }>;
+}
+
+function formatTime(value: string | null | undefined): string {
+  if (!value) return '-';
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return value;
+  return date.toLocaleString();
+}
+
+function shortId(value: string | null | undefined): string {
+  if (!value) return '-';
+  return value.length > 12 ? value.slice(0, 12) : value;
+}
+
+function statusColor(status: string): (value: string) => string {
+  switch (status) {
+    case 'success':
+      return chalk.green;
+    case 'running':
+    case 'queued':
+      return chalk.blue;
+    case 'failed':
+    case 'timed_out':
+    case 'canceled':
+      return chalk.red;
+    default:
+      return chalk.yellow;
+  }
+}
+
+export function registerJobCommands(program: Command): void {
+  const jobs = program.command('jobs').description('Project-scoped Burst and Cron visibility');
+
+  jobs
+    .command('list <idOrName>')
+    .description('List job contracts and recent executions for a project')
+    .option('--status <status>', 'Filter executions by status')
+    .option('--limit <n>', 'Maximum number of executions to return', '25')
+    .option('--json', 'Output as JSON')
+    .action(
+      withErrorHandler(async (idOrName: unknown, opts: { status?: string; limit?: string; json?: boolean }) => {
+        const project = await resolveProject(String(idOrName));
+        const spinner = opts.json ? null : ora('Loading project jobs...').start();
+        const params: Record<string, string> = {
+          limit: String(opts.limit || '25'),
+        };
+        if (opts.status) {
+          params.status = opts.status;
+        }
+
+        const data = await api<JobListResponse>(`/projects/${project.id}/jobs`, { params });
+        spinner?.stop();
+
+        handleJson(opts.json, data);
+
+        console.log(chalk.bold(`Jobs: ${data.project.name}`));
+        console.log(chalk.gray(`${data.project.slug}${data.app_id ? ` • app ${data.app_id}` : ''}\n`));
+
+        if (!data.available) {
+          console.log(chalk.yellow(data.reason || 'Job history is not available for this project yet.'));
+          return;
+        }
+
+        console.log(chalk.bold('Contracts'));
+        console.log(formatTable(
+          data.contracts.map((contract) => ({
+            slug: contract.slug,
+            enabled: contract.enabled ? 'yes' : 'no',
+            triggers: `${contract.enabled_trigger_count}/${contract.trigger_count}`,
+            updated: formatTime(contract.updated_at),
+          })),
+          [
+            { key: 'slug', label: 'Contract' },
+            { key: 'enabled', label: 'Enabled' },
+            { key: 'triggers', label: 'Enabled/Total Triggers' },
+            { key: 'updated', label: 'Updated' },
+          ],
+        ));
+
+        console.log(`\n${chalk.bold('Executions')}`);
+        console.log(formatTable(
+          data.executions.map((execution) => ({
+            id: shortId(execution.id),
+            contract: execution.contract_slug || execution.contract_name || '-',
+            status: execution.status,
+            pool: execution.pool_slug || '-',
+            attempt: `${execution.attempt}/${execution.max_attempts || execution.attempt || 1}`,
+            created: formatTime(execution.created_at),
+          })),
+          [
+            { key: 'id', label: 'Execution' },
+            { key: 'contract', label: 'Contract' },
+            { key: 'status', label: 'Status' },
+            { key: 'pool', label: 'Pool' },
+            { key: 'attempt', label: 'Attempt' },
+            { key: 'created', label: 'Created' },
+          ],
+        ));
+      }),
+    );
+
+  jobs
+    .command('show <idOrName> <jobId>')
+    .description('Show detail for one execution')
+    .option('--json', 'Output as JSON')
+    .action(
+      withErrorHandler(async (idOrName: unknown, jobId: unknown, opts: { json?: boolean }) => {
+        const project = await resolveProject(String(idOrName));
+        const spinner = opts.json ? null : ora('Loading job detail...').start();
+        const data = await api<JobDetailResponse>(`/projects/${project.id}/jobs/${String(jobId)}`);
+        spinner?.stop();
+
+        handleJson(opts.json, data);
+
+        const statusPainter = statusColor(data.execution.status);
+        console.log(chalk.bold(`Job: ${data.project.name}`));
+        console.log(chalk.gray(`${data.project.slug} • ${data.execution.id}\n`));
+        console.log(`  ${chalk.blue('Status:')}      ${statusPainter(data.execution.status)}`);
+        console.log(`  ${chalk.blue('Contract:')}    ${data.contract?.slug || data.contract?.name || '-'}`);
+        console.log(`  ${chalk.blue('Pool:')}        ${data.execution.pool_slug || '-'}`);
+        console.log(`  ${chalk.blue('Environment:')} ${data.execution.environment || '-'}`);
+        console.log(`  ${chalk.blue('Attempt:')}     ${data.execution.attempt}/${data.execution.max_attempts || data.execution.attempt || 1}`);
+        console.log(`  ${chalk.blue('Created By:')}  ${data.execution.created_by_principal || '-'}`);
+        console.log(`  ${chalk.blue('Created:')}     ${formatTime(data.execution.created_at)}`);
+        console.log(`  ${chalk.blue('Started:')}     ${formatTime(data.execution.started_at)}`);
+        console.log(`  ${chalk.blue('Finished:')}    ${formatTime(data.execution.finished_at)}`);
+        console.log(`  ${chalk.blue('Exit Code:')}   ${data.execution.exit_code === null ? '-' : data.execution.exit_code}`);
+
+        if (data.execution.error_summary) {
+          console.log(`\n${chalk.red('Error Summary')}`);
+          console.log(`  ${data.execution.error_summary}`);
+        }
+
+        if (data.execution.metering) {
+          console.log(`\n${chalk.bold('Metering')}`);
+          console.log(JSON.stringify(data.execution.metering, null, 2));
+        }
+
+        if (data.contract?.spec) {
+          console.log(`\n${chalk.bold('Contract Spec')}`);
+          console.log(JSON.stringify(data.contract.spec, null, 2));
+        }
+
+        if (data.execution_spec?.execution) {
+          console.log(`\n${chalk.bold('Execution Spec')}`);
+          console.log(JSON.stringify(data.execution_spec.execution, null, 2));
+        }
+      }),
+    );
+
+  jobs
+    .command('logs <idOrName> <jobId>')
+    .description('Show logs for one execution')
+    .option('--limit <n>', 'Maximum number of log lines to return', '200')
+    .option('--since-ts <ts>', 'Only show logs after the given timestamp')
+    .option('--json', 'Output as JSON')
+    .action(
+      withErrorHandler(async (
+        idOrName: unknown,
+        jobId: unknown,
+        opts: { limit?: string; sinceTs?: string; json?: boolean },
+      ) => {
+        const project = await resolveProject(String(idOrName));
+        const spinner = opts.json ? null : ora('Loading job logs...').start();
+        const params: Record<string, string> = {
+          limit: String(opts.limit || '200'),
+        };
+        if (opts.sinceTs) {
+          params.since_ts = opts.sinceTs;
+        }
+
+        const data = await api<JobLogsResponse>(`/projects/${project.id}/jobs/${String(jobId)}/logs`, { params });
+        spinner?.stop();
+
+        handleJson(opts.json, data);
+
+        console.log(chalk.bold(`Logs: ${data.project.name}`));
+        console.log(chalk.gray(`${data.project.slug} • ${data.execution_id}\n`));
+
+        if (data.logs.length === 0) {
+          console.log(chalk.gray('No logs returned.'));
+          return;
+        }
+
+        for (const log of data.logs) {
+          const ts = formatTime(log.ts);
+          const stream = log.stream || 'log';
+          const line = log.line || '';
+          console.log(`${chalk.gray(ts)} ${chalk.blue(`[${stream}]`)} ${line}`);
+        }
+      }),
+    );
+}

package/src/commands/open.ts

@@ -0,0 +1,22 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import open from 'open';
+import { resolveProject, withErrorHandler } from '../util.js';
+
+export function registerOpenCommand(program: Command): void {
+  program
+    .command('open <idOrName>')
+    .description('Open project URL in browser')
+    .action(
+      withErrorHandler(async (idOrName: unknown) => {
+        const project = await resolveProject(String(idOrName));
+        const url = project.url as string | undefined;
+        if (!url) {
+          console.error(chalk.red(`No URL found for project "${project.name}".`));
+          process.exit(1);
+        }
+        console.log(chalk.blue(`Opening ${url}...`));
+        await open(url);
+      }),
+    );
+}

package/src/commands/platform.ts

@@ -0,0 +1,88 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { api } from '../api.js';
+import { handleJson, resolveProject, withErrorHandler } from '../util.js';
+
+interface PlatformCapability {
+  id: string;
+  label: string;
+  status: string;
+  summary: string;
+  interfaces?: string[];
+  details?: Record<string, unknown>;
+}
+
+interface PlatformOverview {
+  project: {
+    name: string;
+    slug: string;
+    status: string;
+    url: string;
+  };
+  safety: {
+    model: string;
+    guarantees: string[];
+    restrictions: string[];
+  };
+  capabilities: PlatformCapability[];
+  next_step?: string;
+}
+
+function statusColor(status: string): (value: string) => string {
+  if (status === 'configured') return chalk.green;
+  if (status === 'available') return chalk.blue;
+  return chalk.yellow;
+}
+
+export function registerPlatformCommands(program: Command): void {
+  const platform = program.command('platform').description('Project-scoped platform capabilities');
+
+  platform
+    .command('info <idOrName>')
+    .description('Show the safe platform capabilities available to a project')
+    .option('--json', 'Output as JSON')
+    .action(
+      withErrorHandler(async (idOrName: unknown, opts: { json?: boolean }) => {
+        const project = await resolveProject(String(idOrName));
+        const spinner = opts.json ? null : ora('Loading platform overview...').start();
+        const data = await api<PlatformOverview>(`/projects/${project.id}/platform`);
+        spinner?.stop();
+
+        handleJson(opts.json, data);
+
+        console.log(chalk.bold(`Platform: ${data.project.name}`));
+        console.log(chalk.gray(`${data.project.slug} • ${data.project.status} • ${data.project.url}\n`));
+
+        console.log(chalk.bold('Safety Model'));
+        console.log(`  ${chalk.blue('Mode:')} ${data.safety.model}`);
+        for (const line of data.safety.guarantees || []) {
+          console.log(`  ${chalk.green('✓')} ${line}`);
+        }
+        for (const line of data.safety.restrictions || []) {
+          console.log(`  ${chalk.yellow('!')} ${line}`);
+        }
+
+        console.log(`\n${chalk.bold('Capabilities')}`);
+        for (const capability of data.capabilities || []) {
+          const color = statusColor(capability.status);
+          console.log(`  ${color(capability.label)} ${chalk.gray(`[${capability.status}]`)}`);
+          console.log(`    ${capability.summary}`);
+          if (capability.interfaces && capability.interfaces.length > 0) {
+            console.log(`    Interfaces: ${capability.interfaces.join(', ')}`);
+          }
+          const details = capability.details || {};
+          for (const [key, value] of Object.entries(details)) {
+            if (value === null || value === undefined || value === '') continue;
+            if (Array.isArray(value) && value.length === 0) continue;
+            console.log(`    ${key}: ${Array.isArray(value) ? value.join(', ') : String(value)}`);
+          }
+        }
+
+        if (data.next_step) {
+          console.log(`\n${chalk.bold('Next Step')}`);
+          console.log(`  ${data.next_step}`);
+        }
+      }),
+    );
+}

package/src/commands/projects.ts

@@ -0,0 +1,115 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { createInterface } from 'node:readline';
+import { api } from '../api.js';
+import { resolveProject, formatTable, handleJson, withErrorHandler } from '../util.js';
+
+function ask(question: string): Promise<string> {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+
+export function registerProjectCommands(program: Command): void {
+  const projects = program
+    .command('projects')
+    .description('List all projects')
+    .option('--json', 'Output as JSON')
+    .action(
+      withErrorHandler(async (opts: { json?: boolean }) => {
+        const spinner = ora('Fetching projects...').start();
+        const data = await api<{ projects: Record<string, string>[] }>('/projects');
+        spinner.stop();
+
+        handleJson(opts.json, data.projects);
+
+        if (data.projects.length === 0) {
+          console.log(chalk.gray('No projects yet. Create one with `dailey projects create <name>`.'));
+          return;
+        }
+
+        console.log(
+          formatTable(data.projects, [
+            { key: 'id', label: 'ID' },
+            { key: 'name', label: 'Name' },
+            { key: 'status', label: 'Status' },
+            { key: 'replicas', label: 'Replicas' },
+          ]),
+        );
+      }),
+    );
+
+  projects
+    .command('create <name>')
+    .description('Create a new project')
+    .option('--json', 'Output as JSON')
+    .action(
+      withErrorHandler(async (name: unknown, opts: { json?: boolean }) => {
+        const repoUrl = await ask('Repository URL: ');
+        const branch = (await ask('Branch (main): ')) || 'main';
+        const dbAnswer = await ask('Needs database? (y/N): ');
+        const needsDatabase = dbAnswer.toLowerCase() === 'y';
+
+        const spinner = ora('Creating project...').start();
+        const data = await api<{ project: Record<string, unknown> }>('/projects', {
+          method: 'POST',
+          body: {
+            name: String(name),
+            repo_url: repoUrl,
+            branch,
+            needs_database: needsDatabase,
+          },
+        });
+        spinner.succeed(chalk.green(`Project "${name}" created.`));
+
+        handleJson(opts.json, data.project);
+
+        console.log(`  ${chalk.blue('ID:')} ${data.project.id}`);
+      }),
+    );
+
+  projects
+    .command('info <idOrName>')
+    .description('Show project detail')
+    .option('--json', 'Output as JSON')
+    .action(
+      withErrorHandler(async (idOrName: unknown, opts: { json?: boolean }) => {
+        const spinner = ora('Fetching project...').start();
+        const project = await resolveProject(String(idOrName));
+        spinner.stop();
+
+        handleJson(opts.json, project);
+
+        console.log(chalk.bold(`Project: ${project.name}`));
+        const fields = ['id', 'slug', 'status', 'repo_url', 'branch', 'replicas', 'url', 'created_at'];
+        for (const f of fields) {
+          if (project[f] !== undefined) {
+            console.log(`  ${chalk.blue(f + ':')}  ${project[f]}`);
+          }
+        }
+      }),
+    );
+
+  projects
+    .command('delete <idOrName>')
+    .description('Delete a project')
+    .action(
+      withErrorHandler(async (idOrName: unknown) => {
+        const project = await resolveProject(String(idOrName));
+        const confirm = await ask(`Delete project "${project.name}"? This cannot be undone. (yes/no): `);
+        if (confirm !== 'yes') {
+          console.log(chalk.yellow('Cancelled.'));
+          return;
+        }
+
+        const spinner = ora('Deleting project...').start();
+        await api(`/projects/${project.id}`, { method: 'DELETE' });
+        spinner.succeed(chalk.green(`Project "${project.name}" deleted.`));
+      }),
+    );
+}

package/src/commands/scale.ts

@@ -0,0 +1,48 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { api } from '../api.js';
+import { resolveProject, handleJson, withErrorHandler } from '../util.js';
+
+export function registerScaleCommands(program: Command): void {
+  program
+    .command('scale <idOrName> <replicas>')
+    .description('Scale replicas for a project')
+    .action(
+      withErrorHandler(async (idOrName: unknown, replicas: unknown) => {
+        const project = await resolveProject(String(idOrName));
+        const count = parseInt(String(replicas), 10);
+        if (isNaN(count) || count < 0) {
+          console.error(chalk.red('Replicas must be a non-negative integer.'));
+          process.exit(1);
+        }
+
+        const spinner = ora(`Scaling "${project.name}" to ${count} replicas...`).start();
+        await api(`/projects/${project.id}/scale`, {
+          method: 'POST',
+          body: { replicas: count },
+        });
+        spinner.succeed(chalk.green(`Scaled "${project.name}" to ${count} replicas.`));
+      }),
+    );
+
+  program
+    .command('status <idOrName>')
+    .description('Show app status (pods, replicas, health)')
+    .option('--json', 'Output as JSON')
+    .action(
+      withErrorHandler(async (idOrName: unknown, opts: { json?: boolean }) => {
+        const project = await resolveProject(String(idOrName));
+
+        handleJson(opts.json, project);
+
+        console.log(chalk.bold(`Status: ${project.name}`));
+        console.log(`  ${chalk.blue('Status:')}    ${project.status ?? 'unknown'}`);
+        console.log(`  ${chalk.blue('Replicas:')}  ${project.replicas ?? 'N/A'}`);
+        console.log(`  ${chalk.blue('URL:')}       ${project.url ?? 'N/A'}`);
+        if (project.health) {
+          console.log(`  ${chalk.blue('Health:')}    ${project.health}`);
+        }
+      }),
+    );
+}