@pushto/cli 0.0.1

package/src/commands/rollback.ts

@@ -0,0 +1,43 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { getToken } from '../lib/config';
+import { resolveSlug } from '../lib/resolve-slug';
+import { api } from '../lib/api';
+
+export const rollback = async (version?: string): Promise<void> => {
+  const token = getToken();
+  if (!token) {
+    console.log(chalk.red('> not logged in.'));
+    process.exit(1);
+  }
+
+  const slug = resolveSlug();
+  if (!slug) {
+    console.log(chalk.red('> no project here. run pushto init first.'));
+    process.exit(1);
+  }
+
+  const spinner = ora('rolling back...').start();
+
+  try {
+    // TODO: when build engine is live, this will call the rollback API
+    // which restores the previous Fly Machine image
+    spinner.info(chalk.yellow('> rollback is ready to wire up.'));
+    console.log();
+    console.log(chalk.dim('  when the build engine is live, this command will:'));
+    console.log(chalk.dim('  1. find the last working deployment'));
+    console.log(chalk.dim('  2. restore that container image'));
+    console.log(chalk.dim('  3. update DNS to point to it'));
+    console.log(chalk.dim('  4. mark the current deploy as rolled back'));
+    console.log();
+    if (version) {
+      console.log(chalk.dim(`  target version: v${version}`));
+    } else {
+      console.log(chalk.dim('  target: previous working deploy'));
+    }
+    console.log(chalk.dim("  you're early. this will work soon."));
+  } catch {
+    spinner.fail(chalk.red('> rollback failed.'));
+    process.exit(1);
+  }
+};

package/src/commands/status.ts

@@ -0,0 +1,58 @@
+import chalk from 'chalk';
+import { getToken } from '../lib/config';
+import { api } from '../lib/api';
+import { resolveSlug } from '../lib/resolve-slug';
+
+const STATUS_COLORS: Record<string, (s: string) => string> = {
+  CREATED: chalk.dim,
+  BUILDING: chalk.yellow,
+  DEPLOYING: chalk.yellow,
+  LIVE: chalk.green,
+  SLEEPING: chalk.cyan,
+  FAILED: chalk.red,
+  SUSPENDED: chalk.red,
+};
+
+export const status = async (): Promise<void> => {
+  const token = getToken();
+  if (!token) {
+    console.log(chalk.red('> not logged in.'));
+    console.log(chalk.dim('  run ') + chalk.cyan('pushto login') + chalk.dim(' first.'));
+    process.exit(1);
+  }
+
+  const slug = resolveSlug();
+  if (!slug) {
+    console.log(chalk.red('> no project here.'));
+    console.log(chalk.dim('  run ') + chalk.cyan('pushto init <name>') + chalk.dim(' first.'));
+    process.exit(1);
+  }
+
+  try {
+    const res = await api(`/cli/projects/${slug}`);
+
+    if (!res.ok) {
+      const data = (await res.json()) as { error?: string };
+      console.log(chalk.red(`> ${data.error ?? 'something went wrong.'}`));
+      process.exit(1);
+    }
+
+    const project = (await res.json()) as {
+      name: string;
+      status: string;
+      subdomain: string;
+      customDomain?: string | null;
+    };
+    const colorFn = STATUS_COLORS[project.status] ?? chalk.dim;
+
+    console.log(chalk.green(`> ${project.name}`));
+    console.log(chalk.dim('  status:  ') + colorFn(project.status.toLowerCase()));
+    console.log(chalk.dim('  url:     ') + chalk.cyan(`${project.subdomain}.pushto.host`));
+    if (project.customDomain) {
+      console.log(chalk.dim('  domain:  ') + chalk.cyan(project.customDomain));
+    }
+  } catch {
+    console.log(chalk.red('> could not reach pushto.host. check your internet.'));
+    process.exit(1);
+  }
+};

package/src/index.ts

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { init } from './commands/init';
+import { deploy } from './commands/deploy';
+import { login } from './commands/login';
+import { logs } from './commands/logs';
+import { status } from './commands/status';
+import { doctor } from './commands/doctor';
+import { env } from './commands/env';
+import { open } from './commands/open';
+import { rollback } from './commands/rollback';
+import { domain } from './commands/domain';
+
+const program = new Command();
+
+program
+  .name('pushto')
+  .description(chalk.green('pushto') + chalk.dim(' — deploy from your terminal. no yaml. no drama.'))
+  .version('0.0.1')
+  .action(async () => {
+    await deploy();
+  });
+
+program
+  .command('init <name>')
+  .description('create a new project')
+  .action(async (name: string) => {
+    await init(name);
+  });
+
+program
+  .command('login')
+  .description('authenticate with pushto.host')
+  .action(async () => {
+    await login();
+  });
+
+program
+  .command('logs')
+  .description('stream logs from your project')
+  .action(async () => {
+    await logs();
+  });
+
+program
+  .command('status')
+  .description('check your project status')
+  .action(async () => {
+    await status();
+  });
+
+program
+  .command('doctor')
+  .description('check if your project is ready to deploy')
+  .action(async () => {
+    await doctor();
+  });
+
+program
+  .command('env <action> [args...]')
+  .description('manage environment variables (set, list, pull, rm)')
+  .action(async (action: string, args: string[]) => {
+    await env(action, args);
+  });
+
+program
+  .command('open')
+  .description('open your live site in the browser')
+  .action(async () => {
+    await open();
+  });
+
+program
+  .command('rollback [version]')
+  .description('rollback to a previous deployment')
+  .action(async (version?: string) => {
+    await rollback(version);
+  });
+
+program
+  .command('domain <action> [domain]')
+  .description('manage custom domains (add, remove)')
+  .action(async (action: string, domainName?: string) => {
+    await domain(action, domainName);
+  });
+
+program.parse();

package/src/lib/api.ts

@@ -0,0 +1,20 @@
+import { config, getToken } from './config';
+
+export const api = async (path: string, options: RequestInit = {}): Promise<Response> => {
+  const baseUrl = config.get('apiUrl');
+  const token = getToken();
+
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+    ...((options.headers as Record<string, string>) ?? {}),
+  };
+
+  if (token) {
+    headers['Authorization'] = `Bearer ${token}`;
+  }
+
+  return fetch(`${baseUrl}/api${path}`, {
+    ...options,
+    headers,
+  });
+};

package/src/lib/config.ts

@@ -0,0 +1,30 @@
+import Conf from 'conf';
+
+interface PushtoConfig {
+  token?: string;
+  apiUrl: string;
+  projectSlug?: string;
+}
+
+export const config = new Conf<PushtoConfig>({
+  projectName: 'pushto',
+  defaults: {
+    apiUrl: 'https://pushto.host',
+  },
+});
+
+export const getToken = (): string | undefined => config.get('token');
+
+export const setToken = (token: string): void => {
+  config.set('token', token);
+};
+
+export const clearToken = (): void => {
+  config.delete('token');
+};
+
+export const getProjectSlug = (): string | undefined => config.get('projectSlug');
+
+export const setProjectSlug = (slug: string): void => {
+  config.set('projectSlug', slug);
+};

package/src/lib/resolve-slug.ts

@@ -0,0 +1,23 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getProjectSlug } from './config';
+
+/**
+ * Resolve the project slug from:
+ * 1. .pushto file in the current directory
+ * 2. Global config (last `pushto init`)
+ */
+export const resolveSlug = (): string | undefined => {
+  // Check for .pushto file in cwd
+  const pushtoFile = path.join(process.cwd(), '.pushto');
+  try {
+    const content = fs.readFileSync(pushtoFile, 'utf-8');
+    const parsed = JSON.parse(content);
+    if (parsed.slug) return parsed.slug;
+  } catch {
+    // No .pushto file or invalid JSON — fall through
+  }
+
+  // Fall back to global config
+  return getProjectSlug();
+};

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src"]
+}