@pushto/cli 0.0.1

package/src/commands/deploy.ts

@@ -0,0 +1,125 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'node:fs';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import archiver from 'archiver';
+import { getToken } from '../lib/config';
+import { api } from '../lib/api';
+import { resolveSlug } from '../lib/resolve-slug';
+
+const IGNORE = [
+  'node_modules',
+  '.git',
+  '.next',
+  '.vercel',
+  '.turbo',
+  'dist',
+  '.pushto',
+  '.env',
+  '.env.local',
+  '.DS_Store',
+];
+
+const getGitInfo = (): { hash: string | null; message: string | null; branch: string } => {
+  try {
+    const hash = execSync('git rev-parse --short HEAD', { stdio: ['pipe', 'pipe', 'ignore'] }).toString().trim();
+    const message = execSync('git log -1 --pretty=%s', { stdio: ['pipe', 'pipe', 'ignore'] }).toString().trim();
+    const branch = execSync('git rev-parse --abbrev-ref HEAD', { stdio: ['pipe', 'pipe', 'ignore'] }).toString().trim();
+    return { hash, message, branch };
+  } catch {
+    return { hash: null, message: null, branch: 'main' };
+  }
+};
+
+const zipDirectory = (dir: string): Promise<Buffer> => {
+  return new Promise((resolve, reject) => {
+    const archive = archiver('zip', { zlib: { level: 9 } });
+    const chunks: Buffer[] = [];
+
+    archive.on('data', (chunk) => chunks.push(chunk));
+    archive.on('end', () => resolve(Buffer.concat(chunks)));
+    archive.on('error', reject);
+
+    // Add files, respecting ignores
+    const addDir = (dirPath: string, prefix: string) => {
+      const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (IGNORE.includes(entry.name)) continue;
+        if (entry.name.startsWith('.') && entry.name !== '.htaccess') continue;
+
+        const fullPath = path.join(dirPath, entry.name);
+        const archivePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+
+        if (entry.isFile()) {
+          archive.file(fullPath, { name: archivePath });
+        } else if (entry.isDirectory()) {
+          addDir(fullPath, archivePath);
+        }
+      }
+    };
+
+    addDir(dir, '');
+    archive.finalize();
+  });
+};
+
+export const deploy = 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(' to get started.'));
+    process.exit(1);
+  }
+
+  const spinner = ora('zipping project...').start();
+
+  try {
+    const git = getGitInfo();
+
+    // Zip the current directory
+    const zipBuffer = await zipDirectory(process.cwd());
+    const sizeMB = (zipBuffer.length / 1024 / 1024).toFixed(1);
+    spinner.text = `uploading ${sizeMB}MB...`;
+
+    // Upload to the deploy endpoint
+    const res = await api(`/cli/projects/${slug}/upload`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/zip',
+      },
+      body: zipBuffer,
+    });
+
+    if (!res.ok) {
+      const data = (await res.json()) as { error?: string };
+      spinner.fail(chalk.red(`> ${data.error ?? 'deploy failed.'}`));
+      process.exit(1);
+    }
+
+    const data = (await res.json()) as {
+      deployment: { version: number; fileCount: number; buildDuration: number };
+      url: string;
+      message: string;
+    };
+
+    spinner.succeed(chalk.green(`> ${data.message}`));
+    if (git.hash) {
+      console.log(chalk.dim(`  commit:  ${git.hash} — ${git.message ?? ''}`));
+    }
+    console.log(chalk.dim('  files:   ') + chalk.cyan(String(data.deployment.fileCount)));
+    console.log(chalk.dim('  time:    ') + chalk.cyan(`${data.deployment.buildDuration}s`));
+    console.log(chalk.dim('  url:     ') + chalk.cyan(data.url));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : 'unknown error';
+    spinner.fail(chalk.red(`> deploy failed: ${msg}`));
+    process.exit(1);
+  }
+};

package/src/commands/doctor.ts

@@ -0,0 +1,160 @@
+import chalk from 'chalk';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getToken } from '../lib/config';
+import { resolveSlug } from '../lib/resolve-slug';
+import { api } from '../lib/api';
+
+interface Check {
+  name: string;
+  status: 'pass' | 'warn' | 'fail';
+  message: string;
+}
+
+export const doctor = async (): Promise<void> => {
+  console.log(chalk.green('> pushto doctor\n'));
+
+  const checks: Check[] = [];
+  const cwd = process.cwd();
+
+  // 1. Auth check
+  const token = getToken();
+  checks.push(token
+    ? { name: 'auth', status: 'pass', message: 'logged in' }
+    : { name: 'auth', status: 'fail', message: 'not logged in. run pushto login' },
+  );
+
+  // 2. Project linked
+  const slug = resolveSlug();
+  checks.push(slug
+    ? { name: 'project', status: 'pass', message: `linked to ${slug}` }
+    : { name: 'project', status: 'fail', message: 'no .pushto file. run pushto init <name>' },
+  );
+
+  // 3. Package.json exists
+  const pkgPath = path.join(cwd, 'package.json');
+  const hasPkg = fs.existsSync(pkgPath);
+  checks.push(hasPkg
+    ? { name: 'package.json', status: 'pass', message: 'found' }
+    : { name: 'package.json', status: 'warn', message: 'not found. static site? that works too.' },
+  );
+
+  // 4. Framework detection
+  if (hasPkg) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      const framework =
+        deps['next'] ? 'Next.js' :
+        deps['react'] ? 'React' :
+        deps['vue'] ? 'Vue' :
+        deps['svelte'] ? 'Svelte' :
+        deps['@sveltejs/kit'] ? 'SvelteKit' :
+        deps['astro'] ? 'Astro' :
+        deps['nuxt'] ? 'Nuxt' :
+        deps['express'] ? 'Express' :
+        deps['fastify'] ? 'Fastify' :
+        deps['hono'] ? 'Hono' :
+        null;
+
+      checks.push(framework
+        ? { name: 'framework', status: 'pass', message: `detected ${framework}` }
+        : { name: 'framework', status: 'warn', message: 'no known framework detected. nixpacks will figure it out.' },
+      );
+
+      // 5. Build script
+      const hasBuild = pkg.scripts?.build;
+      checks.push(hasBuild
+        ? { name: 'build script', status: 'pass', message: `"${hasBuild}"` }
+        : { name: 'build script', status: 'warn', message: 'no build script. might be fine for static sites.' },
+      );
+
+      // 6. Node version
+      const nodeVersion = pkg.engines?.node;
+      if (nodeVersion) {
+        checks.push({ name: 'node version', status: 'pass', message: nodeVersion });
+      }
+    } catch {
+      checks.push({ name: 'package.json', status: 'warn', message: 'could not parse package.json' });
+    }
+  }
+
+  // 7. .gitignore check
+  const gitignorePath = path.join(cwd, '.gitignore');
+  if (fs.existsSync(gitignorePath)) {
+    const gitignore = fs.readFileSync(gitignorePath, 'utf-8');
+    if (!gitignore.includes('node_modules')) {
+      checks.push({ name: '.gitignore', status: 'warn', message: 'node_modules not in .gitignore. deploy will be slow.' });
+    }
+    if (!gitignore.includes('.env')) {
+      checks.push({ name: '.gitignore', status: 'warn', message: '.env not in .gitignore. secrets might leak.' });
+    }
+    if (!gitignore.includes('.pushto')) {
+      checks.push({ name: '.gitignore', status: 'warn', message: '.pushto not in .gitignore. add it.' });
+    }
+  }
+
+  // 8. Env vars check (if project linked and authed)
+  if (token && slug) {
+    try {
+      const res = await api(`/cli/projects/${slug}`);
+      if (res.ok) {
+        checks.push({ name: 'api', status: 'pass', message: 'pushto.host reachable' });
+      } else {
+        checks.push({ name: 'api', status: 'fail', message: 'project not found on pushto.host' });
+      }
+    } catch {
+      checks.push({ name: 'api', status: 'fail', message: 'cannot reach pushto.host' });
+    }
+  }
+
+  // 9. Large files check
+  const largeFiles: string[] = [];
+  const checkDir = (dir: string, depth = 0) => {
+    if (depth > 3) return;
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === '.next') continue;
+        const full = path.join(dir, entry.name);
+        if (entry.isFile()) {
+          const stat = fs.statSync(full);
+          if (stat.size > 10 * 1024 * 1024) {
+            largeFiles.push(`${entry.name} (${Math.round(stat.size / 1024 / 1024)}MB)`);
+          }
+        } else if (entry.isDirectory()) {
+          checkDir(full, depth + 1);
+        }
+      }
+    } catch { /* permission error, skip */ }
+  };
+  checkDir(cwd);
+
+  if (largeFiles.length > 0) {
+    checks.push({ name: 'large files', status: 'warn', message: `found: ${largeFiles.join(', ')}. will slow deploy.` });
+  }
+
+  // Print results
+  console.log();
+  for (const check of checks) {
+    const icon = check.status === 'pass' ? chalk.green('✓')
+      : check.status === 'warn' ? chalk.yellow('⚠')
+      : chalk.red('✗');
+    const color = check.status === 'pass' ? chalk.dim
+      : check.status === 'warn' ? chalk.yellow
+      : chalk.red;
+    console.log(`  ${icon} ${chalk.dim(check.name.padEnd(16))} ${color(check.message)}`);
+  }
+
+  const fails = checks.filter((c) => c.status === 'fail');
+  const warns = checks.filter((c) => c.status === 'warn');
+
+  console.log();
+  if (fails.length > 0) {
+    console.log(chalk.red(`  ${fails.length} issue${fails.length > 1 ? 's' : ''} to fix before deploying.`));
+  } else if (warns.length > 0) {
+    console.log(chalk.yellow(`  ${warns.length} warning${warns.length > 1 ? 's' : ''}. probably fine. deploy when ready.`));
+  } else {
+    console.log(chalk.green('  all good. run pushto to deploy.'));
+  }
+};

package/src/commands/domain.ts

@@ -0,0 +1,54 @@
+import chalk from 'chalk';
+import { getToken } from '../lib/config';
+import { resolveSlug } from '../lib/resolve-slug';
+
+export const domain = async (action: string, domainName?: 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);
+  }
+
+  if (action === 'add') {
+    if (!domainName) {
+      console.log(chalk.red('> usage: pushto domain add yourdomain.com'));
+      process.exit(1);
+    }
+
+    console.log(chalk.green(`> setting up ${domainName} for ${slug}\n`));
+    console.log(chalk.dim('  add this DNS record at your domain provider:\n'));
+    console.log(`  ${chalk.cyan('Type')}   ${chalk.cyan('Name')}   ${chalk.cyan('Value')}`);
+    console.log(`  CNAME  @      ${slug}.pushto.host`);
+    console.log();
+    console.log(chalk.dim('  or if your provider doesn\'t support CNAME on root:\n'));
+    console.log(`  A      @      76.76.21.21`);
+    console.log();
+
+    // TODO: when Cloudflare DNS API is wired, this will:
+    // 1. Register the domain in our system
+    // 2. Provision SSL via Let's Encrypt
+    // 3. Poll DNS until verified
+    // 4. Update the project's customDomain field
+
+    console.log(chalk.yellow('  auto-verification coming soon.'));
+    console.log(chalk.dim('  for now, add the domain in your dashboard too:'));
+    console.log(chalk.cyan(`  https://pushto.host/dashboard/projects/${slug}/settings`));
+
+  } else if (action === 'remove' || action === 'rm') {
+    console.log(chalk.green(`> removing custom domain from ${slug}`));
+    console.log(chalk.yellow('  domain management coming soon via CLI.'));
+    console.log(chalk.dim('  use the dashboard for now:'));
+    console.log(chalk.cyan(`  https://pushto.host/dashboard/projects/${slug}/settings`));
+
+  } else {
+    console.log(chalk.dim('  usage:'));
+    console.log(chalk.cyan('  pushto domain add yourdomain.com'));
+    console.log(chalk.cyan('  pushto domain remove'));
+  }
+};

package/src/commands/env.ts

@@ -0,0 +1,128 @@
+import chalk from 'chalk';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getToken } from '../lib/config';
+import { resolveSlug } from '../lib/resolve-slug';
+import { api } from '../lib/api';
+
+export const env = async (action: string, args: string[]): 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. run pushto init first.'));
+    process.exit(1);
+  }
+
+  if (action === 'set') {
+    // pushto env set KEY=value
+    const pair = args[0];
+    if (!pair || !pair.includes('=')) {
+      console.log(chalk.red('> usage: pushto env set KEY=value'));
+      process.exit(1);
+    }
+
+    const eqIdx = pair.indexOf('=');
+    const key = pair.slice(0, eqIdx);
+    const value = pair.slice(eqIdx + 1);
+
+    if (!key) {
+      console.log(chalk.red('> key is empty.'));
+      process.exit(1);
+    }
+
+    // Call the tRPC mutation via REST-like endpoint
+    // We'll use a simple CLI API endpoint for this
+    const res = await api(`/cli/projects/${slug}/env`, {
+      method: 'POST',
+      body: JSON.stringify({ key, value }),
+    });
+
+    if (!res.ok) {
+      const data = (await res.json()) as { error?: string };
+      console.log(chalk.red(`> ${data.error ?? 'failed to set env var.'}`));
+      process.exit(1);
+    }
+
+    console.log(chalk.green(`> ${key} set.`));
+
+  } else if (action === 'list' || action === 'ls') {
+    // pushto env list
+    const res = await api(`/cli/projects/${slug}/env`);
+
+    if (!res.ok) {
+      const data = (await res.json()) as { error?: string };
+      console.log(chalk.red(`> ${data.error ?? 'failed to list env vars.'}`));
+      process.exit(1);
+    }
+
+    const vars = (await res.json()) as { key: string; value: string }[];
+
+    if (vars.length === 0) {
+      console.log(chalk.dim('> no env vars set.'));
+      return;
+    }
+
+    console.log(chalk.green(`> ${slug} env vars\n`));
+    for (const v of vars) {
+      console.log(`  ${chalk.cyan(v.key)}=${chalk.dim('••••••••')}`);
+    }
+    console.log(chalk.dim(`\n  ${vars.length} variable${vars.length > 1 ? 's' : ''}`));
+
+  } else if (action === 'pull') {
+    // pushto env pull — download to .env
+    const res = await api(`/cli/projects/${slug}/env`);
+
+    if (!res.ok) {
+      const data = (await res.json()) as { error?: string };
+      console.log(chalk.red(`> ${data.error ?? 'failed to pull env vars.'}`));
+      process.exit(1);
+    }
+
+    const vars = (await res.json()) as { key: string; value: string }[];
+
+    if (vars.length === 0) {
+      console.log(chalk.dim('> no env vars to pull.'));
+      return;
+    }
+
+    const envContent = vars.map((v) => `${v.key}=${v.value}`).join('\n') + '\n';
+    const envPath = path.join(process.cwd(), '.env');
+
+    fs.writeFileSync(envPath, envContent);
+    console.log(chalk.green(`> pulled ${vars.length} var${vars.length > 1 ? 's' : ''} to .env`));
+    console.log(chalk.dim('  make sure .env is in your .gitignore.'));
+
+  } else if (action === 'rm' || action === 'remove' || action === 'delete') {
+    const key = args[0];
+    if (!key) {
+      console.log(chalk.red('> usage: pushto env rm KEY'));
+      process.exit(1);
+    }
+
+    const res = await api(`/cli/projects/${slug}/env`, {
+      method: 'DELETE',
+      body: JSON.stringify({ key }),
+    });
+
+    if (!res.ok) {
+      const data = (await res.json()) as { error?: string };
+      console.log(chalk.red(`> ${data.error ?? 'failed to delete env var.'}`));
+      process.exit(1);
+    }
+
+    console.log(chalk.green(`> ${key} removed.`));
+
+  } else {
+    console.log(chalk.dim('  usage:'));
+    console.log(chalk.cyan('  pushto env set KEY=value'));
+    console.log(chalk.cyan('  pushto env list'));
+    console.log(chalk.cyan('  pushto env pull'));
+    console.log(chalk.cyan('  pushto env rm KEY'));
+  }
+};

package/src/commands/init.ts

@@ -0,0 +1,65 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getToken, setProjectSlug } from '../lib/config';
+import { api } from '../lib/api';
+
+export const init = async (name: string): 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 = name
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '');
+
+  if (slug.length < 3) {
+    console.log(chalk.red('> name too short. needs at least 3 characters.'));
+    process.exit(1);
+  }
+
+  const spinner = ora('creating project...').start();
+
+  try {
+    const res = await api('/cli/projects', {
+      method: 'POST',
+      body: JSON.stringify({ name, slug }),
+    });
+
+    const data = (await res.json()) as {
+      error?: string;
+      project?: { id: string };
+      message?: string;
+    };
+
+    if (!res.ok) {
+      spinner.fail(chalk.red(`> ${data.error ?? 'something went wrong.'}`));
+      process.exit(1);
+    }
+
+    // Write .pushto file in current directory
+    const pushtoConfig = { slug, projectId: data.project?.id };
+    fs.writeFileSync(
+      path.join(process.cwd(), '.pushto'),
+      JSON.stringify(pushtoConfig, null, 2) + '\n',
+    );
+
+    // Also store globally so bare `pushto` works from this dir
+    setProjectSlug(slug);
+
+    spinner.succeed(chalk.green(`> ${slug} is ready.`));
+    console.log(chalk.dim(`  ${data.message ?? 'project created.'}`));
+    console.log();
+    console.log(chalk.dim('  deploy anytime with just: ') + chalk.cyan('pushto'));
+    console.log(chalk.dim('  your url will be: ') + chalk.cyan(`${slug}.pushto.host`));
+  } catch (err) {
+    spinner.fail(chalk.red('> could not reach pushto.host. check your internet.'));
+    process.exit(1);
+  }
+};

package/src/commands/login.ts

@@ -0,0 +1,97 @@
+import chalk from 'chalk';
+import http from 'node:http';
+import { setToken, config } from '../lib/config';
+import { api } from '../lib/api';
+
+export const login = async (): Promise<void> => {
+  const baseUrl = config.get('apiUrl');
+
+  // Start a local server to receive the callback
+  const server = http.createServer((req, res) => {
+    // Handle CORS preflight
+    if (req.method === 'OPTIONS') {
+      res.writeHead(200, {
+        'Access-Control-Allow-Origin': baseUrl,
+        'Access-Control-Allow-Methods': 'POST, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type',
+      });
+      res.end();
+      return;
+    }
+
+    if (req.method === 'POST' && req.url === '/callback') {
+      let body = '';
+      req.on('data', (chunk) => (body += chunk));
+      req.on('end', async () => {
+        res.writeHead(200, {
+          'Content-Type': 'application/json',
+          'Access-Control-Allow-Origin': baseUrl,
+        });
+        res.end(JSON.stringify({ ok: true }));
+
+        try {
+          const { access_token } = JSON.parse(body);
+          if (!access_token) {
+            console.log(chalk.red('\n> auth failed. no token received.'));
+            process.exit(1);
+          }
+
+          setToken(access_token);
+
+          // Verify the token
+          const meRes = await api('/cli/me');
+          if (meRes.ok) {
+            const me = (await meRes.json()) as { email: string; tier: string };
+            console.log(chalk.green(`\n> logged in as ${me.email}`));
+            console.log(chalk.dim(`  tier: ${me.tier.toLowerCase()}`));
+          } else {
+            console.log(chalk.green('\n> logged in.'));
+          }
+        } catch {
+          console.log(chalk.green('\n> logged in.'));
+        }
+
+        server.close();
+        process.exit(0);
+      });
+      return;
+    }
+
+    res.writeHead(404);
+    res.end();
+  });
+
+  // Listen on a random available port
+  server.listen(0, () => {
+    const port = (server.address() as { port: number }).port;
+    const authUrl = `${baseUrl}/cli/auth?port=${port}`;
+
+    console.log(chalk.dim('> opening browser to log you in...'));
+    console.log(chalk.dim(`  if it doesn't open, go to: `) + chalk.cyan(authUrl));
+
+    // Open browser
+    const open = (url: string) => {
+      const { execSync } = require('node:child_process');
+      const cmd =
+        process.platform === 'darwin'
+          ? `open "${url}"`
+          : process.platform === 'win32'
+            ? `start "${url}"`
+            : `xdg-open "${url}"`;
+      try {
+        execSync(cmd, { stdio: 'ignore' });
+      } catch {
+        // User will see the URL in the console
+      }
+    };
+
+    open(authUrl);
+
+    // Timeout after 2 minutes
+    setTimeout(() => {
+      console.log(chalk.red('\n> login timed out. try again.'));
+      server.close();
+      process.exit(1);
+    }, 120_000);
+  });
+};

package/src/commands/logs.ts

@@ -0,0 +1,24 @@
+import chalk from 'chalk';
+import { getToken } from '../lib/config';
+import { resolveSlug } from '../lib/resolve-slug';
+
+export const logs = 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. run pushto init first.'));
+    process.exit(1);
+  }
+
+  console.log(chalk.dim(`> streaming logs for ${slug}...`));
+  console.log(chalk.dim('  (ctrl+c to stop)\n'));
+
+  // TODO: Phase 3 — SSE connection to log stream API
+  console.log(chalk.yellow('> log streaming coming soon. deploy first, then we\'ll show you everything.'));
+};

package/src/commands/open.ts

@@ -0,0 +1,27 @@
+import chalk from 'chalk';
+import { execSync } from 'node:child_process';
+import { resolveSlug } from '../lib/resolve-slug';
+
+export const open = async (): Promise<void> => {
+  const slug = resolveSlug();
+  if (!slug) {
+    console.log(chalk.red('> no project here. run pushto init first.'));
+    process.exit(1);
+  }
+
+  const url = `https://${slug}.pushto.host`;
+  console.log(chalk.green(`> opening ${url}`));
+
+  const cmd =
+    process.platform === 'darwin'
+      ? `open "${url}"`
+      : process.platform === 'win32'
+        ? `start "${url}"`
+        : `xdg-open "${url}"`;
+
+  try {
+    execSync(cmd, { stdio: 'ignore' });
+  } catch {
+    console.log(chalk.dim(`  couldn't open browser. go to: `) + chalk.cyan(url));
+  }
+};