@daileyos/cli 0.1.0

package/src/commands/storage.ts

@@ -0,0 +1,214 @@
+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 StorageInfoResponse {
+  project: {
+    id: string;
+    name: string;
+    slug: string;
+  };
+  binding: {
+    bucket: string;
+    provider: string;
+    endpoint: string;
+    region: string;
+    cdn_base_url: string;
+    binding_model: string;
+    upload_strategy: string;
+    download_strategy: string;
+    usage: {
+      total_objects: number;
+      total_size_mb: number;
+      storage_limit_mb: number;
+    };
+    limits: {
+      max_single_upload_mb: number;
+      signed_url_ttl_seconds: number;
+    };
+  };
+  next_step?: string;
+}
+
+interface StorageListResponse {
+  bucket: string;
+  prefix: string;
+  continuation_token: string | null;
+  objects: Array<{
+    key: string;
+    size_mb: number;
+    last_modified: string | null;
+  }>;
+}
+
+interface PresignedUploadResponse {
+  bucket: string;
+  key: string;
+  method: string;
+  upload_url: string;
+  expires_at: string;
+  headers: Record<string, string>;
+}
+
+interface PresignedDownloadResponse {
+  bucket: string;
+  key: string;
+  download_url: string;
+  expires_at: string;
+  content_type: string | null;
+  size_bytes: number | null;
+}
+
+export function registerStorageCommands(program: Command): void {
+  const storage = program.command('storage').description('Project-scoped object storage');
+
+  storage
+    .command('info <idOrName>')
+    .description('Show the storage binding for 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 storage binding...').start();
+        const data = await api<StorageInfoResponse>(`/projects/${project.id}/storage`);
+        spinner?.stop();
+
+        handleJson(opts.json, data);
+
+        console.log(chalk.bold(`Storage: ${data.project.name}`));
+        console.log(chalk.gray(`${data.project.slug} • ${data.binding.bucket}\n`));
+        console.log(`  ${chalk.blue('Provider:')}  ${data.binding.provider}`);
+        console.log(`  ${chalk.blue('Endpoint:')}  ${data.binding.endpoint}`);
+        console.log(`  ${chalk.blue('Region:')}    ${data.binding.region}`);
+        console.log(`  ${chalk.blue('Mode:')}      ${data.binding.binding_model}`);
+        console.log(`  ${chalk.blue('Upload:')}    ${data.binding.upload_strategy}`);
+        console.log(`  ${chalk.blue('Download:')}  ${data.binding.download_strategy}`);
+        console.log(`  ${chalk.blue('Objects:')}   ${data.binding.usage.total_objects}`);
+        console.log(`  ${chalk.blue('Usage:')}     ${data.binding.usage.total_size_mb} MB / ${data.binding.usage.storage_limit_mb} MB`);
+        console.log(`  ${chalk.blue('Max File:')}  ${data.binding.limits.max_single_upload_mb} MB`);
+        console.log(`  ${chalk.blue('TTL:')}       ${data.binding.limits.signed_url_ttl_seconds}s`);
+
+        if (data.next_step) {
+          console.log(`\n${chalk.gray(data.next_step)}`);
+        }
+      }),
+    );
+
+  storage
+    .command('ls <idOrName> [prefix]')
+    .description('List objects in a project bucket')
+    .option('--limit <n>', 'Maximum number of objects to return', '100')
+    .option('--json', 'Output as JSON')
+    .action(
+      withErrorHandler(async (idOrName: unknown, prefix: unknown, opts: { limit?: string; json?: boolean }) => {
+        const project = await resolveProject(String(idOrName));
+        const spinner = opts.json ? null : ora('Listing storage objects...').start();
+        const params: Record<string, string> = {
+          limit: String(opts.limit || '100'),
+        };
+        if (prefix) params.prefix = String(prefix);
+        const data = await api<StorageListResponse>(`/projects/${project.id}/storage/objects`, { params });
+        spinner?.stop();
+
+        handleJson(opts.json, data);
+
+        console.log(chalk.bold(`Objects: ${project.name}`));
+        console.log(chalk.gray(`${data.bucket}${data.prefix ? ` • prefix ${data.prefix}` : ''}\n`));
+
+        console.log(formatTable(
+          data.objects.map((object) => ({
+            key: object.key,
+            size: `${object.size_mb} MB`,
+            updated: object.last_modified ? new Date(object.last_modified).toLocaleString() : '-',
+          })),
+          [
+            { key: 'key', label: 'Key' },
+            { key: 'size', label: 'Size' },
+            { key: 'updated', label: 'Updated' },
+          ],
+        ));
+
+        if (data.continuation_token) {
+          console.log(chalk.gray(`\nContinuation token available. Re-run with --json to fetch the next page.`));
+        }
+      }),
+    );
+
+  storage
+    .command('presign-upload <idOrName> <key>')
+    .description('Create a presigned upload URL for a project object')
+    .option('--content-type <type>', 'Content-Type to bind into the signed request')
+    .option('--size <bytes>', 'Expected content length in bytes')
+    .option('--ttl <seconds>', 'Signed URL TTL in seconds')
+    .option('--json', 'Output as JSON')
+    .action(
+      withErrorHandler(async (
+        idOrName: unknown,
+        key: unknown,
+        opts: { contentType?: string; size?: string; ttl?: string; json?: boolean },
+      ) => {
+        const project = await resolveProject(String(idOrName));
+        const spinner = opts.json ? null : ora('Creating upload URL...').start();
+        const body: Record<string, unknown> = { key: String(key) };
+        if (opts.contentType) body.content_type = opts.contentType;
+        if (opts.size) body.content_length_bytes = Number(opts.size);
+        if (opts.ttl) body.expires_in_seconds = Number(opts.ttl);
+        const data = await api<PresignedUploadResponse>(`/projects/${project.id}/storage/presign-upload`, {
+          method: 'POST',
+          body,
+        });
+        spinner?.stop();
+
+        handleJson(opts.json, data);
+
+        console.log(chalk.bold('Presigned Upload URL'));
+        console.log(chalk.gray(`${data.bucket}/${data.key}\n`));
+        console.log(`  ${chalk.blue('Method:')}   ${data.method}`);
+        console.log(`  ${chalk.blue('Expires:')}  ${new Date(data.expires_at).toLocaleString()}`);
+        for (const [header, value] of Object.entries(data.headers || {})) {
+          console.log(`  ${chalk.blue(header + ':')} ${value}`);
+        }
+        console.log(`\n${data.upload_url}`);
+      }),
+    );
+
+  storage
+    .command('presign-download <idOrName> <key>')
+    .description('Create a presigned download URL for a project object')
+    .option('--download-name <name>', 'Suggested filename for the download')
+    .option('--ttl <seconds>', 'Signed URL TTL in seconds')
+    .option('--json', 'Output as JSON')
+    .action(
+      withErrorHandler(async (
+        idOrName: unknown,
+        key: unknown,
+        opts: { downloadName?: string; ttl?: string; json?: boolean },
+      ) => {
+        const project = await resolveProject(String(idOrName));
+        const spinner = opts.json ? null : ora('Creating download URL...').start();
+        const body: Record<string, unknown> = { key: String(key) };
+        if (opts.downloadName) body.download_name = opts.downloadName;
+        if (opts.ttl) body.expires_in_seconds = Number(opts.ttl);
+        const data = await api<PresignedDownloadResponse>(`/projects/${project.id}/storage/presign-download`, {
+          method: 'POST',
+          body,
+        });
+        spinner?.stop();
+
+        handleJson(opts.json, data);
+
+        console.log(chalk.bold('Presigned Download URL'));
+        console.log(chalk.gray(`${data.bucket}/${data.key}\n`));
+        console.log(`  ${chalk.blue('Expires:')}  ${new Date(data.expires_at).toLocaleString()}`);
+        if (data.content_type) {
+          console.log(`  ${chalk.blue('Type:')}     ${data.content_type}`);
+        }
+        if (data.size_bytes !== null) {
+          console.log(`  ${chalk.blue('Size:')}     ${data.size_bytes} bytes`);
+        }
+        console.log(`\n${data.download_url}`);
+      }),
+    );
+}

package/src/commands/usage.ts

@@ -0,0 +1,30 @@
+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 registerUsageCommands(program: Command): void {
+  program
+    .command('usage <idOrName>')
+    .description('Show resource usage')
+    .option('--period <period>', 'Time period (e.g., 7d, 30d)', '7d')
+    .option('--json', 'Output as JSON')
+    .action(
+      withErrorHandler(async (idOrName: unknown, opts: { period: string; json?: boolean }) => {
+        const project = await resolveProject(String(idOrName));
+        const spinner = ora('Fetching usage...').start();
+        const data = await api<Record<string, unknown>>(`/projects/${project.id}/usage`, {
+          params: { period: opts.period },
+        });
+        spinner.stop();
+
+        handleJson(opts.json, data);
+
+        console.log(chalk.bold(`Usage for ${project.name} (${opts.period}):`));
+        for (const [key, value] of Object.entries(data)) {
+          console.log(`  ${chalk.blue(key + ':')}  ${value}`);
+        }
+      }),
+    );
+}

package/src/index.ts

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { registerAuthCommands } from './commands/auth.js';
+import { registerProjectCommands } from './commands/projects.js';
+import { registerDeployCommands } from './commands/deploy.js';
+import { registerScaleCommands } from './commands/scale.js';
+import { registerEnvCommands } from './commands/env.js';
+import { registerDomainCommands } from './commands/domains.js';
+import { registerDbCommands } from './commands/db.js';
+import { registerUsageCommands } from './commands/usage.js';
+import { registerBillingCommands } from './commands/billing.js';
+import { registerOpenCommand } from './commands/open.js';
+import { registerPlatformCommands } from './commands/platform.js';
+import { registerStorageCommands } from './commands/storage.js';
+import { registerJobCommands } from './commands/jobs.js';
+
+const program = new Command();
+
+program
+  .name('dailey')
+  .description('Dailey OS CLI — manage your projects, deployments, and billing')
+  .version('0.1.0');
+
+registerAuthCommands(program);
+registerProjectCommands(program);
+registerDeployCommands(program);
+registerScaleCommands(program);
+registerEnvCommands(program);
+registerDomainCommands(program);
+registerDbCommands(program);
+registerUsageCommands(program);
+registerBillingCommands(program);
+registerOpenCommand(program);
+registerPlatformCommands(program);
+registerStorageCommands(program);
+registerJobCommands(program);
+
+program.parse();

package/src/util.ts

@@ -0,0 +1,92 @@
+import chalk from 'chalk';
+import { api } from './api.js';
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+interface Project {
+  id: string;
+  name: string;
+  slug?: string;
+  [key: string]: unknown;
+}
+
+/**
+ * Resolve a project identifier (UUID or name/slug) to a project object.
+ */
+export async function resolveProject(idOrName: string): Promise<Project> {
+  if (UUID_RE.test(idOrName)) {
+    return api<Project>(`/projects/${idOrName}`);
+  }
+
+  const { projects } = await api<{ projects: Project[] }>('/projects');
+  const lower = idOrName.toLowerCase();
+  const match = projects.find(
+    (p) =>
+      p.name.toLowerCase() === lower ||
+      (p.slug && p.slug.toLowerCase() === lower),
+  );
+
+  if (!match) {
+    console.error(chalk.red(`Project "${idOrName}" not found.`));
+    process.exit(1);
+  }
+
+  return match;
+}
+
+/**
+ * Format an array of objects as an aligned table.
+ */
+export function formatTable(rows: Record<string, string>[], columns: { key: string; label: string }[]): string {
+  if (rows.length === 0) return chalk.gray('  No results.');
+
+  // Calculate column widths
+  const widths: Record<string, number> = {};
+  for (const col of columns) {
+    widths[col.key] = col.label.length;
+  }
+  for (const row of rows) {
+    for (const col of columns) {
+      const val = String(row[col.key] ?? '');
+      if (val.length > widths[col.key]) {
+        widths[col.key] = val.length;
+      }
+    }
+  }
+
+  const header = columns.map((c) => c.label.padEnd(widths[c.key])).join('  ');
+  const sep = columns.map((c) => '-'.repeat(widths[c.key])).join('  ');
+  const body = rows.map((row) =>
+    columns.map((c) => String(row[c.key] ?? '').padEnd(widths[c.key])).join('  '),
+  );
+
+  return [chalk.bold(header), chalk.gray(sep), ...body].join('\n');
+}
+
+/**
+ * Handle --json flag: if set, print raw JSON and exit.
+ */
+export function handleJson(flag: boolean | undefined, data: unknown): void {
+  if (flag) {
+    console.log(JSON.stringify(data, null, 2));
+    process.exit(0);
+  }
+}
+
+/**
+ * Wrap an async command handler with standard error handling.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function withErrorHandler<T extends (...args: any[]) => Promise<void>>(fn: T): T {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const wrapped = async (...args: any[]) => {
+    try {
+      await fn(...args);
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(chalk.red(`Error: ${message}`));
+      process.exit(1);
+    }
+  };
+  return wrapped as unknown as T;
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}