@joytreesite/joytree 1.0.0

package/commands/deploy.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const readline = require('readline');
+const { api }  = require('../lib/api');
+const config   = require('../lib/config');
+const ui       = require('../lib/ui');
+
+async function prompt(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => rl.question(question, ans => { rl.close(); resolve(ans.trim()); }));
+}
+
+async function deployGit(opts) {
+  const apiKey = config.getApiKey();
+  if (!apiKey) { ui.error('Not logged in. Run: joytree login'); process.exit(1); }
+
+  let { repo, branch, name, build, start, static: isStatic, message } = opts;
+
+  if (!repo) {
+    repo = await prompt(`${ui.c.bold}GitHub repo URL:${ui.c.reset} `);
+    if (!repo) { ui.error('Repository URL is required.'); process.exit(1); }
+  }
+
+  if (!name) {
+    const guessed = repo.split('/').pop().replace(/\.git$/, '').toLowerCase().replace(/[^a-z0-9-]/g, '-');
+    const ans = await prompt(`${ui.c.bold}Project name/subdomain${ui.c.reset} [${guessed}]: `);
+    name = ans || guessed;
+  }
+
+  const body = {
+    repoUrl:      repo,
+    branch:       branch || 'main',
+    subdomain:    name,
+    name,
+    buildCommand: build  || '',
+    startCommand: start  || '',
+    isStatic:     !!isStatic,
+    message:      message || `Deployed via joytree CLI`,
+  };
+
+  const spin = ui.spinner(`Deploying ${ui.c.bold}${name}${ui.c.reset}`);
+  try {
+    const data = await api.post('/api/deploy', body);
+    spin.stop(`Deploy started!`);
+    ui.header('Deployment');
+    ui.label('Project',  name);
+    ui.label('Repo',     repo);
+    ui.label('Branch',   branch || 'main');
+    ui.label('Deploy ID', data.deployId || data.id || '—');
+    if (data.subdomain || name) {
+      const baseUrl = config.getBaseUrl().replace(/^https?:\/\//, '');
+      ui.label('URL',     `https://${data.subdomain || name}.${baseUrl}`);
+    }
+    console.log(`\n${ui.c.dim}Watch logs: ${ui.c.cyan}joytree logs ${name} --follow${ui.c.reset}\n`);
+  } catch (err) {
+    spin.stop();
+    ui.error(`Deploy failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+async function redeploy(projectId) {
+  const spin = ui.spinner(`Redeploying ${projectId}`);
+  try {
+    const data = await api.post(`/api/projects/${projectId}/autodeploy/check`, {});
+    spin.stop(`Redeploy triggered for ${ui.c.bold}${projectId}${ui.c.reset}`);
+    if (data.deployId) ui.label('Deploy ID', data.deployId);
+  } catch (err) {
+    // Fallback: try the redeploy-upload endpoint if the check one doesn't apply
+    try {
+      await api.post(`/api/projects/${projectId}/redeploy-upload`, {});
+      spin.stop(`Redeploy triggered for ${ui.c.bold}${projectId}${ui.c.reset}`);
+    } catch (e2) {
+      spin.stop();
+      ui.error(`Redeploy failed: ${err.message}`);
+      process.exit(1);
+    }
+  }
+}
+
+async function open(projectId) {
+  let url;
+  if (projectId) {
+    const baseUrl = config.getBaseUrl().replace(/^https?:\/\//, '');
+    url = `https://${projectId}.${baseUrl}`;
+  } else {
+    ui.error('Provide a project ID/subdomain. Example: joytree open my-site');
+    process.exit(1);
+  }
+  ui.info(`Opening ${url}`);
+  const { exec } = require('child_process');
+  const cmd = process.platform === 'darwin' ? `open "${url}"`
+            : process.platform === 'win32'  ? `start "${url}"`
+            : `xdg-open "${url}"`;
+  exec(cmd);
+}
+
+async function listDeployments(projectId, opts) {
+  const limit = parseInt(opts.limit, 10) || 10;
+  const spin = ui.spinner('Fetching deployments');
+  try {
+    const query = projectId ? `?projectId=${encodeURIComponent(projectId)}&limit=${limit}` : `?limit=${limit}`;
+    const data  = await api.get(`/api/deployments${query}`);
+    spin.stop();
+    const items = Array.isArray(data) ? data : (data.deployments || data.items || []);
+    if (!items.length) { ui.info('No deployments found.'); return; }
+
+    ui.header(`Recent Deployments${projectId ? ' — ' + projectId : ''}`);
+    ui.divider();
+    items.slice(0, limit).forEach(d => {
+      const ts = d.createdAt ? new Date(d.createdAt).toLocaleString() : '—';
+      console.log(`  ${ui.statusBadge(d.status || d.deployStatus)}  ${ui.c.bold}${d.projectName || d.subdomain || d.projectId || '—'}${ui.c.reset}  ${ui.c.dim}${ts}${ui.c.reset}`);
+      if (d.branch) console.log(`     ${ui.c.dim}branch: ${d.branch}  sha: ${String(d.sha||'').slice(0,7)}${ui.c.reset}`);
+    });
+    console.log();
+  } catch (err) {
+    spin.stop();
+    ui.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = { deployGit, redeploy, open, listDeployments };

package/commands/domains.js

@@ -0,0 +1,91 @@
+'use strict';
+
+const { api } = require('../lib/api');
+const ui      = require('../lib/ui');
+
+async function list() {
+  const spin = ui.spinner('Fetching domains');
+  try {
+    const data = await api.get('/api/domains/mine');
+    spin.stop();
+    const items = Array.isArray(data) ? data : (data.domains || []);
+    if (!items.length) { ui.info('No custom domains configured.'); return; }
+    ui.header(`Custom Domains (${items.length})`);
+    ui.divider();
+    items.forEach(d => {
+      const status = d.verified ? `${ui.c.green}✓ verified${ui.c.reset}` : `${ui.c.yellow}⚠ unverified${ui.c.reset}`;
+      console.log(`  ${ui.c.bold}${d.domain}${ui.c.reset}  ${status}`);
+      if (d.projectId || d.subdomain) console.log(`     ${ui.c.dim}→ project: ${d.projectId || d.subdomain}${ui.c.reset}`);
+    });
+    console.log();
+  } catch (err) {
+    spin.stop();
+    ui.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+async function attach(domain, projectId) {
+  const spin = ui.spinner(`Attaching ${domain} to ${projectId}`);
+  try {
+    await api.post('/api/domains/attach', { domain, projectId });
+    spin.stop(`Domain ${ui.c.bold}${domain}${ui.c.reset} attached to ${projectId}`);
+    ui.info('DNS propagation may take a few minutes.');
+    console.log();
+  } catch (err) {
+    spin.stop();
+    ui.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+async function verify(domain) {
+  const spin = ui.spinner(`Verifying ${domain}`);
+  try {
+    const data = await api.post(`/api/domains/${encodeURIComponent(domain)}/verify`, {});
+    spin.stop();
+    if (data.verified) {
+      ui.success(`${domain} is verified!`);
+    } else {
+      ui.warn(`Verification pending. ${data.message || 'Check your DNS records.'}`);
+    }
+    console.log();
+  } catch (err) {
+    spin.stop();
+    ui.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+async function remove(domain) {
+  const spin = ui.spinner(`Removing ${domain}`);
+  try {
+    await api.delete(`/api/domains/${encodeURIComponent(domain)}`);
+    spin.stop(`Domain ${ui.c.bold}${domain}${ui.c.reset} removed.`);
+  } catch (err) {
+    spin.stop();
+    ui.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+async function check(domain) {
+  const spin = ui.spinner(`Checking availability of ${domain}`);
+  try {
+    const data = await api.get(`/api/domains/check?domain=${encodeURIComponent(domain)}`);
+    spin.stop();
+    if (data.available) {
+      ui.success(`${ui.c.bold}${domain}${ui.c.reset} is ${ui.c.green}available${ui.c.reset}!`);
+      if (data.price) ui.label('Price', data.price);
+    } else {
+      ui.warn(`${domain} is ${ui.c.red}not available${ui.c.reset}.`);
+    }
+    console.log();
+  } catch (err) {
+    spin.stop();
+    ui.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = { list, attach, verify, remove, check };

package/commands/env.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const fs   = require('fs');
+const { api } = require('../lib/api');
+const ui   = require('../lib/ui');
+
+async function list(projectId) {
+  const spin = ui.spinner(`Fetching env vars for ${projectId}`);
+  try {
+    const data = await api.get(`/api/projects/${encodeURIComponent(projectId)}/env`);
+    spin.stop();
+    const env = data.env || data.envVars || data || {};
+    const keys = Object.keys(env);
+    if (!keys.length) { ui.info('No env vars set.'); return; }
+    ui.header(`Env vars — ${projectId}`);
+    ui.divider();
+    keys.forEach(k => {
+      const v = String(env[k]);
+      const masked = v.length > 4 ? v.slice(0,2) + '*'.repeat(Math.min(v.length-2, 10)) : '****';
+      console.log(`  ${ui.c.bold}${k}${ui.c.reset}=${ui.c.dim}${masked}${ui.c.reset}`);
+    });
+    console.log(`\n  ${ui.c.dim}${keys.length} variable(s)${ui.c.reset}\n`);
+  } catch (err) {
+    spin.stop();
+    ui.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+async function set(projectId, pairs) {
+  // pairs is an array like ["KEY=VALUE", "FOO=bar"]
+  const env = {};
+  for (const pair of pairs) {
+    const idx = pair.indexOf('=');
+    if (idx < 1) { ui.error(`Invalid format: "${pair}". Use KEY=VALUE`); process.exit(1); }
+    env[pair.slice(0, idx)] = pair.slice(idx + 1);
+  }
+
+  const spin = ui.spinner(`Setting ${Object.keys(env).length} env var(s)`);
+  try {
+    await api.post(`/api/projects/${encodeURIComponent(projectId)}/env`, { env });
+    spin.stop(`Env var(s) updated on ${ui.c.bold}${projectId}${ui.c.reset}`);
+    Object.keys(env).forEach(k => ui.label(k, '(set)'));
+    console.log();
+  } catch (err) {
+    spin.stop();
+    ui.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+async function del(projectId, key) {
+  const spin = ui.spinner(`Deleting ${key}`);
+  try {
+    await api.delete(`/api/projects/${encodeURIComponent(projectId)}/env/${encodeURIComponent(key)}`);
+    spin.stop(`Deleted env var ${ui.c.bold}${key}${ui.c.reset} from ${projectId}`);
+  } catch (err) {
+    spin.stop();
+    ui.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+async function push(projectId, opts) {
+  const filePath = opts.file || '.env';
+  if (!fs.existsSync(filePath)) {
+    ui.error(`File not found: ${filePath}`);
+    process.exit(1);
+  }
+
+  const raw  = fs.readFileSync(filePath, 'utf8');
+  const env  = {};
+  let count  = 0;
+  for (const line of raw.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const idx = trimmed.indexOf('=');
+    if (idx < 1) continue;
+    env[trimmed.slice(0, idx).trim()] = trimmed.slice(idx + 1).trim().replace(/^["']|["']$/g, '');
+    count++;
+  }
+
+  if (!count) { ui.warn(`No variables found in ${filePath}`); return; }
+
+  const spin = ui.spinner(`Pushing ${count} env var(s) from ${filePath}`);
+  try {
+    if (opts.force) {
+      await api.put(`/api/projects/${encodeURIComponent(projectId)}/env`, { env });
+    } else {
+      await api.post(`/api/projects/${encodeURIComponent(projectId)}/env`, { env });
+    }
+    spin.stop(`Pushed ${count} env var(s) to ${ui.c.bold}${projectId}${ui.c.reset}`);
+    console.log();
+  } catch (err) {
+    spin.stop();
+    ui.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = { list, set, del, push };

package/commands/extras.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const { api } = require('../lib/api');
+const ui      = require('../lib/ui');
+
+// ── Activity feed ─────────────────────────────────────────────────────
+async function activity(opts) {
+  const limit = parseInt(opts.limit, 10) || 20;
+  const spin = ui.spinner('Fetching activity');
+  try {
+    const data = await api.get(`/api/activity?limit=${limit}`);
+    spin.stop();
+    const items = Array.isArray(data) ? data : (data.activity || data.events || data.items || []);
+    if (!items.length) { ui.info('No recent activity.'); return; }
+    ui.header('Recent Activity');
+    ui.divider();
+    items.slice(0, limit).forEach(a => {
+      const ts  = a.createdAt || a.timestamp ? `${ui.c.dim}${new Date(a.createdAt || a.timestamp).toLocaleString()}${ui.c.reset}` : '';
+      const type = a.type || a.event || '';
+      const project = a.projectName || a.subdomain || a.projectId || '';
+      console.log(`  ${ui.c.bold}${type}${ui.c.reset}${project ? '  ' + project : ''}  ${ts}`);
+      if (a.message || a.description) console.log(`     ${ui.c.dim}${a.message || a.description}${ui.c.reset}`);
+    });
+    console.log();
+  } catch (err) {
+    spin.stop();
+    ui.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// ── Stop a running deployment ─────────────────────────────────────────
+async function stopDeploy(deployId) {
+  const spin = ui.spinner(`Stopping deployment ${deployId}`);
+  try {
+    await api.post(`/api/deploy/${encodeURIComponent(deployId)}/stop`, {});
+    spin.stop(`Deployment ${ui.c.bold}${deployId}${ui.c.reset} stopped.`);
+  } catch (err) {
+    spin.stop();
+    ui.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// ── Autodeploy toggle ─────────────────────────────────────────────────
+async function autodeploy(projectId, opts) {
+  const enable = opts.enable !== undefined ? true : opts.disable !== undefined ? false : null;
+  if (enable === null) {
+    ui.error('Specify --enable or --disable. Example: joytree autodeploy my-site --enable');
+    process.exit(1);
+  }
+  const spin = ui.spinner(`${enable ? 'Enabling' : 'Disabling'} auto-deploy for ${projectId}`);
+  try {
+    await api.post(`/api/projects/${encodeURIComponent(projectId)}/autodeploy`, { enabled: enable });
+    spin.stop(`Auto-deploy ${enable ? ui.c.green + 'enabled' : ui.c.yellow + 'disabled'}${ui.c.reset} for ${ui.c.bold}${projectId}${ui.c.reset}`);
+    console.log();
+  } catch (err) {
+    spin.stop();
+    ui.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// ── API key management ────────────────────────────────────────────────
+async function apiKey() {
+  const spin = ui.spinner('Fetching API key');
+  try {
+    const data = await api.get('/api/account/api-key');
+    spin.stop();
+    ui.header('API Key');
+    ui.divider();
+    ui.label('Key',        data.key || '—');
+    ui.label('Created',    data.createdAt ? new Date(data.createdAt).toLocaleString() : '—');
+    ui.label('Last Used',  data.lastUsed  ? new Date(data.lastUsed).toLocaleString()  : 'never');
+    ui.label('Status',     data.disabled ? `${ui.c.red}disabled${ui.c.reset}` : `${ui.c.green}active${ui.c.reset}`);
+    ui.label('Projects',   String(data.projectCount || 0));
+    if (data.transferUrl)  ui.label('Transfer URL', data.transferUrl);
+    console.log(`\n  ${ui.c.dim}To rotate your key run: joytree apikey rotate${ui.c.reset}\n`);
+  } catch (err) {
+    spin.stop();
+    ui.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+async function rotateApiKey() {
+  const spin = ui.spinner('Rotating API key');
+  try {
+    const data = await api.post('/api/account/api-key/rotate', {});
+    spin.stop(`API key rotated!`);
+    ui.label('New Key', data.key || '—');
+    ui.warn('Your old key is now revoked. Update your CLI: joytree login --api-key <new-key>');
+    console.log();
+  } catch (err) {
+    spin.stop();
+    ui.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = { activity, stopDeploy, autodeploy, apiKey, rotateApiKey };

package/commands/github.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const { api } = require('../lib/api');
+const ui      = require('../lib/ui');
+
+async function repos(opts) {
+  const spin = ui.spinner('Fetching your GitHub repositories');
+  try {
+    const data = await api.get('/api/github/repos');
+    spin.stop();
+    const items = Array.isArray(data) ? data : (data.repos || data.repositories || []);
+    if (!items.length) {
+      ui.warn('No GitHub repos found. Make sure your GitHub account is linked on the dashboard.');
+      return;
+    }
+    ui.header(`GitHub Repositories (${items.length})`);
+    ui.divider();
+    items.forEach(r => {
+      const visibility = r.private ? `${ui.c.dim}private${ui.c.reset}` : `${ui.c.green}public${ui.c.reset}`;
+      console.log(`  ${ui.c.bold}${r.full_name || r.name}${ui.c.reset}  [${visibility}]`);
+      if (r.description) console.log(`     ${ui.c.dim}${r.description}${ui.c.reset}`);
+      if (r.default_branch) console.log(`     ${ui.c.dim}default branch: ${r.default_branch}${ui.c.reset}`);
+    });
+    console.log(`\n  ${ui.c.dim}Run: joytree deploy --repo <url> to deploy any repo above.${ui.c.reset}\n`);
+  } catch (err) {
+    spin.stop();
+    ui.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+async function branches(repoUrl) {
+  if (!repoUrl) { ui.error('Provide a repo URL. Example: joytree pull branches https://github.com/you/repo'); process.exit(1); }
+  const spin = ui.spinner(`Fetching branches for ${repoUrl}`);
+  try {
+    const data = await api.get(`/api/github/branches?repoUrl=${encodeURIComponent(repoUrl)}`);
+    spin.stop();
+    const items = Array.isArray(data) ? data : (data.branches || []);
+    if (!items.length) { ui.info('No branches found.'); return; }
+    ui.header(`Branches — ${repoUrl}`);
+    ui.divider();
+    items.forEach(b => {
+      const name = b.name || b;
+      const isDefault = b.default ? ` ${ui.c.green}(default)${ui.c.reset}` : '';
+      console.log(`  ${ui.c.bold}${name}${ui.c.reset}${isDefault}`);
+    });
+    console.log();
+  } catch (err) {
+    spin.stop();
+    ui.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = { repos, branches };

package/commands/logs.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const { api } = require('../lib/api');
+const ui      = require('../lib/ui');
+
+function printLogLines(lines) {
+  if (!Array.isArray(lines)) return;
+  lines.forEach(entry => {
+    const ts  = entry.timestamp ? `${ui.c.dim}[${new Date(entry.timestamp).toLocaleTimeString()}]${ui.c.reset} ` : '';
+    const lvl = (entry.level || '').toLowerCase();
+    const msg = entry.message || entry.text || String(entry);
+    const colored = lvl === 'error' || lvl === 'stderr'
+      ? `${ui.c.red}${msg}${ui.c.reset}`
+      : lvl === 'warn'
+      ? `${ui.c.yellow}${msg}${ui.c.reset}`
+      : msg;
+    console.log(`${ts}${colored}`);
+  });
+}
+
+async function fetchLogs(projectId, opts) {
+  const lines = parseInt(opts.lines, 10) || 50;
+
+  if (opts.follow) {
+    ui.info(`Streaming logs for ${ui.c.bold}${projectId}${ui.c.reset} (Ctrl+C to stop)`);
+    ui.divider();
+    let seen = new Set();
+    const poll = async () => {
+      try {
+        const data = await api.get(`/api/projects/${encodeURIComponent(projectId)}/runtime-logs?lines=${lines}`);
+        const entries = Array.isArray(data) ? data : (data.logs || data.lines || []);
+        const fresh = entries.filter(e => {
+          const key = e.timestamp + (e.message || '');
+          if (seen.has(key)) return false;
+          seen.add(key);
+          return true;
+        });
+        if (fresh.length) printLogLines(fresh);
+      } catch (err) {
+        ui.warn(`Log fetch error: ${err.message}`);
+      }
+    };
+    await poll();
+    const iv = setInterval(poll, 3000);
+    process.on('SIGINT', () => { clearInterval(iv); console.log('\n'); process.exit(0); });
+    // Keep alive
+    await new Promise(() => {});
+    return;
+  }
+
+  const spin = ui.spinner(`Fetching logs for ${projectId}`);
+  try {
+    const data = await api.get(`/api/projects/${encodeURIComponent(projectId)}/runtime-logs?lines=${lines}`);
+    spin.stop();
+    const entries = Array.isArray(data) ? data : (data.logs || data.lines || []);
+    if (!entries.length) { ui.info('No log entries found.'); return; }
+    ui.header(`Logs — ${projectId} (last ${entries.length})`);
+    ui.divider();
+    printLogLines(entries);
+    console.log();
+  } catch (err) {
+    spin.stop();
+    ui.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = { fetchLogs };

package/commands/projects.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const readline = require('readline');
+const { api }  = require('../lib/api');
+const ui       = require('../lib/ui');
+const config   = require('../lib/config');
+
+async function prompt(q) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(r => rl.question(q, a => { rl.close(); r(a.trim()); }));
+}
+
+async function list(opts) {
+  const spin = ui.spinner('Fetching projects');
+  try {
+    // Use the transfer endpoint — it returns the full workspace with all projects
+    const apiKey = config.getApiKey();
+    const baseUrl = config.getBaseUrl();
+    const { validateApiKey } = require('../lib/api');
+    const data = await validateApiKey(apiKey, baseUrl);
+    spin.stop();
+
+    const projects = Array.isArray(data.projects) ? data.projects : [];
+    if (!projects.length) {
+      ui.info('No projects yet. Deploy one: joytree deploy');
+      return;
+    }
+
+    if (opts && opts.json) {
+      console.log(JSON.stringify(projects, null, 2));
+      return;
+    }
+
+    ui.header(`Projects (${projects.length})`);
+    ui.divider();
+    const base = config.getBaseUrl().replace(/^https?:\/\//, '');
+    projects.forEach(p => {
+      const subdomain = p.subdomain || p.name || p.id;
+      console.log(`  ${ui.c.bold}${subdomain}${ui.c.reset}  ${ui.c.dim}→  https://${subdomain}.${base}${ui.c.reset}`);
+      if (p.repoUrl) console.log(`     ${ui.c.dim}repo: ${p.repoUrl}  branch: ${p.branch||'main'}${ui.c.reset}`);
+      if (p.buildCommand) console.log(`     ${ui.c.dim}build: ${p.buildCommand}${ui.c.reset}`);
+    });
+    console.log();
+  } catch (err) {
+    spin.stop();
+    ui.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+async function inspect(projectId) {
+  const spin = ui.spinner(`Loading ${projectId}`);
+  try {
+    const data = await api.get(`/api/projects/${encodeURIComponent(projectId)}`);
+    spin.stop();
+    const p = data.project || data;
+    const base = config.getBaseUrl().replace(/^https?:\/\//, '');
+
+    ui.header(`Project: ${p.name || p.subdomain || projectId}`);
+    ui.divider();
+    ui.label('ID',           p.id || p._id || projectId);
+    ui.label('Subdomain',    p.subdomain || '—');
+    ui.label('Live URL',     `https://${p.subdomain||projectId}.${base}`);
+    ui.label('Repo',         p.repoUrl || '—');
+    ui.label('Branch',       p.branch || 'main');
+    ui.label('Build Cmd',    p.buildCommand || '—');
+    ui.label('Start Cmd',    p.startCommand || '—');
+    ui.label('Static',       p.isStatic ? 'yes' : 'no');
+    ui.label('Auto-deploy',  p.autoDeploy ? 'enabled' : 'disabled');
+    ui.label('Node Version', p.nodeVersion || '20');
+    if (p.createdAt) ui.label('Created', new Date(p.createdAt).toLocaleString());
+    console.log();
+  } catch (err) {
+    spin.stop();
+    ui.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+async function deleteProject(projectId, opts) {
+  if (!opts.yes) {
+    const ans = await prompt(`${ui.c.yellow}Delete project "${projectId}"? This is irreversible. Type yes to confirm: ${ui.c.reset}`);
+    if (ans.toLowerCase() !== 'yes') { ui.info('Cancelled.'); return; }
+  }
+  const spin = ui.spinner(`Deleting ${projectId}`);
+  try {
+    await api.delete(`/api/projects/${encodeURIComponent(projectId)}`);
+    spin.stop(`Project ${ui.c.bold}${projectId}${ui.c.reset} deleted.`);
+  } catch (err) {
+    spin.stop();
+    ui.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = { list, inspect, deleteProject };