@micropage-sh/cli 2.0.0

package/src/commands/submissions.js

@@ -0,0 +1,194 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const { db, handleAuthError } = require('../supabase');
+const { getProjectConfig } = require('../auth');
+const { formatTable, formatDate } = require('../utils');
+
+function formatCliFieldValue(value) {
+  if (value === null || value === undefined || value === '') return '—';
+  if (Array.isArray(value)) return value.join(', ');
+  return String(value);
+}
+
+async function list(options = {}) {
+  const cwd = process.cwd();
+  const config = getProjectConfig(cwd);
+  if (!config?.projectId) {
+    console.error('Not in a project folder. Run from a folder with .micropage/project.json');
+    process.exit(1);
+  }
+
+  let submissions;
+  try {
+    submissions = await db
+      .from('form_submissions')
+      .select('id,form_id,form_name,page_url,created_at,form_index')
+      .eq('project_id', config.projectId)
+      .order('created_at', 'desc')
+      .get();
+  } catch (err) {
+    handleAuthError(err);
+    console.error('Failed to list form submissions:', err.message);
+    process.exit(1);
+  }
+
+  if (!Array.isArray(submissions) || submissions.length === 0) {
+    console.log('No form submissions.');
+    return;
+  }
+
+  if (options.json) {
+    console.log(JSON.stringify(submissions, null, 2));
+    return;
+  }
+
+  const rows = submissions.map((s) => [
+    s.id.slice(0, 8) + '…',
+    s.form_id ? s.form_id.slice(0, 8) + '…' : '-',
+    s.form_name || '-',
+    s.page_url || '-',
+    formatDate(s.created_at),
+  ]);
+  formatTable(rows, ['ID (short)', 'Form ID', 'Form', 'Page URL', 'Submitted']);
+}
+
+async function show(id, options = {}) {
+  if (!id) {
+    console.error('Usage: micropage submissions show <submission-id>');
+    process.exit(1);
+  }
+
+  let submission;
+  try {
+    submission = await db
+      .from('form_submissions')
+      .select('*')
+      .eq('id', id)
+      .single();
+  } catch (err) {
+    handleAuthError(err);
+    console.error('Failed to fetch submission:', err.message);
+    process.exit(1);
+  }
+
+  if (!submission) {
+    console.error('Submission not found:', id);
+    process.exit(1);
+  }
+
+  if (options.json) {
+    console.log(JSON.stringify(submission, null, 2));
+    return;
+  }
+
+  console.log('ID:         ', submission.id);
+  console.log('Form ID:    ', submission.form_id || '-');
+  console.log('Form:       ', submission.form_name || '-');
+  console.log('Page URL:   ', submission.page_url || '-');
+  console.log('Form index: ', submission.form_index ?? '-');
+  console.log('Submitted:  ', formatDate(submission.created_at));
+  console.log('Build ID:   ', submission.build_id || '-');
+  const fields = submission.payload?.fields;
+  if (Array.isArray(fields) && fields.length > 0) {
+    console.log('');
+    console.log('Fields:');
+    for (const row of fields) {
+      console.log(`  ${row.label}: ${formatCliFieldValue(row.value)}`);
+    }
+  }
+  console.log('');
+  console.log('Payload:');
+  console.log(JSON.stringify(submission.payload || {}, null, 2));
+}
+
+async function exportSubmissions(options = {}) {
+  const cwd = process.cwd();
+  const config = getProjectConfig(cwd);
+  if (!config?.projectId) {
+    console.error('Not in a project folder. Run from a folder with .micropage/project.json');
+    process.exit(1);
+  }
+
+  let submissions;
+  try {
+    submissions = await db
+      .from('form_submissions')
+      .select('*')
+      .eq('project_id', config.projectId)
+      .order('created_at', 'desc')
+      .get();
+  } catch (err) {
+    handleAuthError(err);
+    console.error('Failed to export form submissions:', err.message);
+    process.exit(1);
+  }
+
+  if (!Array.isArray(submissions) || submissions.length === 0) {
+    console.log('No form submissions to export.');
+    return;
+  }
+
+  const format = (options.format || 'csv').toLowerCase();
+  if (format !== 'csv' && format !== 'json') {
+    console.error('Invalid format. Use "csv" or "json".');
+    process.exit(1);
+  }
+
+  const defaultName = `submissions.${format}`;
+  const outFile = options.output
+    ? path.isAbsolute(options.output)
+      ? options.output
+      : path.join(cwd, options.output)
+    : path.join(cwd, defaultName);
+
+  try {
+    if (format === 'json') {
+      fs.writeFileSync(outFile, JSON.stringify(submissions, null, 2), 'utf8');
+    } else {
+      const header = [
+        'id',
+        'created_at',
+        'page_url',
+        'form_name',
+        'form_id',
+        'form_index',
+        'build_id',
+        'payload_json',
+      ];
+      const escapeCell = (value) => {
+        if (value === null || value === undefined) return '';
+        const str = String(value);
+        if (str.includes('"') || str.includes(',') || str.includes('\n')) {
+          return `"${str.replace(/"/g, '""')}"`;
+        }
+        return str;
+      };
+      const lines = [
+        header.join(','),
+        ...submissions.map((s) =>
+          [
+            s.id,
+            s.created_at,
+            s.page_url || '',
+            s.form_name || '',
+            s.form_id || '',
+            s.form_index ?? '',
+            s.build_id || '',
+            JSON.stringify(s.payload || {}),
+          ].map(escapeCell).join(','),
+        ),
+      ];
+      fs.writeFileSync(outFile, lines.join('\n'), 'utf8');
+    }
+  } catch (err) {
+    console.error('Failed to write export file:', err.message);
+    process.exit(1);
+  }
+
+  console.log(`Exported ${submissions.length} submission(s) → ${outFile}`);
+}
+
+module.exports = { list, show, exportSubmissions };

package/src/commands/whoami.js

@@ -0,0 +1,87 @@
+'use strict';
+
+const { getSession } = require('../auth');
+const { db, getUserInfo, getValidAccessToken, handleAuthError } = require('../supabase');
+
+async function run() {
+  const session = getSession();
+  if (!session) {
+    console.error('Not logged in. Run: micropage login');
+    process.exit(1);
+  }
+
+  let user;
+  try {
+    const accessToken = await getValidAccessToken();
+    user = await getUserInfo(accessToken);
+  } catch (err) {
+    handleAuthError(err);
+    console.error('Failed to get user info:', err.message);
+    process.exit(1);
+  }
+
+  if (!user) {
+    console.error('Session expired. Run: micropage login');
+    process.exit(1);
+  }
+
+  console.log('User ID:   ', user.id);
+  console.log('Email:     ', user.email || '-');
+  const name =
+    user.user_metadata?.full_name ||
+    user.user_metadata?.user_name ||
+    user.user_metadata?.name ||
+    '-';
+  console.log('Name:      ', name);
+  if (user.app_metadata?.provider) {
+    console.log('Auth via:  ', user.app_metadata.provider);
+  }
+
+  // Billing / subscription overview (best-effort; do not fail whoami if this breaks).
+  let planTier = 'free';
+  let subscription = null;
+  try {
+    const customer = await db
+      .from('customers')
+      .select('plan_tier')
+      .eq('user_id', user.id)
+      .single();
+    if (customer?.plan_tier) {
+      planTier = customer.plan_tier;
+    }
+  } catch (err) {
+    handleAuthError(err);
+    console.error('Warning: failed to load plan info:', err.message);
+  }
+
+  try {
+    const subs = await db
+      .from('subscriptions')
+      .select('status,plan_tier,provider,product_name,current_period_end')
+      .eq('user_id', user.id)
+      .in('status', ['active', 'trialing', 'paused'])
+      .order('updated_at', 'desc')
+      .limit(1)
+      .get();
+    subscription = Array.isArray(subs) ? subs[0] || null : subs || null;
+  } catch (err) {
+    handleAuthError(err);
+    console.error('Warning: failed to load subscription details:', err.message);
+  }
+
+  console.log('Plan tier: ', planTier);
+  if (subscription) {
+    console.log('Subscription status: ', subscription.status || '-');
+    if (subscription.provider) {
+      console.log('Billing provider:   ', subscription.provider);
+    }
+    if (subscription.product_name) {
+      console.log('Product:           ', subscription.product_name);
+    }
+    if (subscription.current_period_end) {
+      console.log('Current period end:', subscription.current_period_end);
+    }
+  }
+}
+
+module.exports = { run };

package/src/config.js

@@ -0,0 +1,22 @@
+'use strict';
+
+/**
+ * Central configuration constants for the CLI.
+ * All values can be overridden with environment variables for local development.
+ */
+const SUPABASE_URL =
+  process.env.MICROPAGE_SUPABASE_URL || 'https://vhlifcdslnmnvnvorluu.supabase.co';
+
+// This is the public anon key – safe to embed in the CLI (same as the web app).
+const SUPABASE_ANON_KEY =
+  process.env.MICROPAGE_SUPABASE_ANON_KEY ||
+  'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InZobGlmY2RzbG5tbnZudm9ybHV1Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3MjUxMTUzMTMsImV4cCI6MjA0MDY5MTMxM30.IprHOpa397Wcv5iFwa_e9hkXhhmXYZFXC4BF_qGYkkk';
+
+const APP_URL = process.env.MICROPAGE_APP_URL || 'https://app.micropage.sh';
+
+const BUILD_COMPILER_URL =
+  process.env.MICROPAGE_BUILD_COMPILER_URL ||
+  process.env.MICROPAGE_PARSER_URL ||
+  'https://build-compiler.micropage.sh';
+
+module.exports = { SUPABASE_URL, SUPABASE_ANON_KEY, APP_URL, BUILD_COMPILER_URL };

package/src/index.js

@@ -0,0 +1,243 @@
+#!/usr/bin/env node
+'use strict';
+
+const { Command } = require('commander');
+
+const login = require('./commands/login');
+const logout = require('./commands/logout');
+const whoami = require('./commands/whoami');
+const projects = require('./commands/projects');
+const builds = require('./commands/builds');
+const submissions = require('./commands/submissions');
+const forms = require('./commands/forms');
+const files = require('./commands/files');
+const links = require('./commands/links');
+
+const program = new Command();
+
+program
+  .name('micropage')
+  .description('CLI for micropage.sh – create, sync, and publish microsites')
+  .version('2.0.0');
+
+// ---------------------------------------------------------------------------
+// Authentication
+// ---------------------------------------------------------------------------
+
+program
+  .command('login')
+  .description('Authenticate via the browser')
+  .option('-f, --force', 'Re-authenticate even if already logged in')
+  .action((opts) => login.run(opts));
+
+program
+  .command('logout')
+  .description('Clear the stored session')
+  .action(() => logout.run());
+
+program
+  .command('whoami')
+  .description('Show the currently logged-in user and subscription')
+  .action(() => whoami.run());
+
+// ---------------------------------------------------------------------------
+// Projects  (micropage projects <subcommand>)
+// ---------------------------------------------------------------------------
+
+const projectCmd = program.command('projects').description('Manage projects');
+
+projectCmd
+  .command('list')
+  .description('List your projects')
+  .option('--json', 'Output as JSON')
+  .action((opts) => projects.list(opts));
+
+projectCmd
+  .command('show [uuidOrDomain]')
+  .description('Show project details including latest build info (UUID or domain; omit from a project folder)')
+  .option('--json', 'Output as JSON')
+  .action((uuidOrDomain, opts) => projects.show(uuidOrDomain, opts));
+
+projectCmd
+  .command('create <name>')
+  .description('Create a new project and init local folder')
+  .option(
+    '-d, --domain <domain>',
+    'Override Cloudflare Pages project name / slug (default: server generates name-slug + 6 hex, max 58 chars)',
+  )
+  .action((name, opts) => projects.create(name, opts));
+
+projectCmd
+  .command('fetch <uuidOrDomain>')
+  .description('Fetch an existing project by UUID or domain, init local folder')
+  .action((ref) => projects.fetch(ref));
+
+projectCmd
+  .command('pull')
+  .description('Pull latest build raw content → local landing.page')
+  .action(() => projects.pull());
+
+projectCmd
+  .command('delete')
+  .description('Delete project (remote + local .micropage/)')
+  .option('-y, --yes', 'Skip confirmation prompt')
+  .action((opts) => projects.deleteProject(opts));
+
+projectCmd
+  .command('publish')
+  .description('Push local content and publish (deploy to Cloudflare Pages) — alias for `micropage publish`')
+  .option('-w, --watch', 'Stream build/deploy events after triggering publish')
+  .action((opts) => builds.publish(opts));
+
+projectCmd
+  .command('deploy [projectUuid] [token]')
+  .description(
+    'CI publish using a deploy token (Pro+). No login required. ' +
+    'projectUuid is optional when run from a project directory (reads from .micropage/project.json). ' +
+    'Without --build: reads .page files in the current directory, creates a build, and publishes. ' +
+    'With --build <id>: publishes an existing build by id.',
+  )
+  .option('-b, --build <id>', 'Publish a specific existing build id instead of creating one from .page files')
+  .option('-w, --watch', 'Stream build/deploy events until finished or failed')
+  .option(
+    '--exchange-ttl <seconds>',
+    'Exchanged access JWT lifetime in seconds (60–3600; omit for server default)',
+    (v) => parseInt(String(v), 10),
+  )
+  .option(
+    '--watch-with-deploy-token',
+    'Use the deploy token for the event stream instead of the exchanged JWT',
+  )
+  .action((projectUuid, token, opts) => {
+    // If only one positional arg was given, it is the token; read UUID from project config.
+    if (token === undefined) {
+      return projects.deploy(null, projectUuid, opts);
+    }
+    return projects.deploy(projectUuid, token, opts);
+  });
+
+// ---------------------------------------------------------------------------
+// Builds  (micropage builds <subcommand>)
+// ---------------------------------------------------------------------------
+
+const buildCmd = program.command('builds').description('Manage builds');
+
+buildCmd
+  .command('list')
+  .description('List builds for the current project')
+  .option('--json', 'Output as JSON')
+  .action((opts) => builds.list(opts));
+
+buildCmd
+  .command('redeploy [version]')
+  .description('Set active build to a version and republish (no new build row)')
+  .action((version) => builds.redeploy(version));
+
+buildCmd
+  .command('download [version]')
+  .description('Download a build archive (zip) locally')
+  .option('-o, --output <file>', 'Output file path')
+  .action((version, opts) => builds.download(version, opts));
+
+// ---------------------------------------------------------------------------
+// Top-level push / publish (most common workflow commands)
+// ---------------------------------------------------------------------------
+
+program
+  .command('push')
+  .description('Merge local .page files and save as a draft build')
+  .action(() => builds.push());
+
+program
+  .command('publish')
+  .description('Push local content and publish (deploy to Cloudflare Pages)')
+  .option('-w, --watch', 'Stream build/deploy events after triggering publish')
+  .action((opts) => builds.publish(opts));
+
+// ---------------------------------------------------------------------------
+// Links
+// ---------------------------------------------------------------------------
+
+program
+  .command('preview')
+  .description('Open the project live URL in the browser')
+  .action(() => links.preview());
+
+program
+  .command('copy-link')
+  .description('Copy the project live URL to the clipboard')
+  .action(() => links.copyLink());
+
+program
+  .command('open-pricing')
+  .description('Open the pricing page in the browser')
+  .action(() => links.openPricing());
+
+// ---------------------------------------------------------------------------
+// Files  (micropage files <subcommand>)
+// ---------------------------------------------------------------------------
+
+const filesCmd = program.command('files').description('Manage project files');
+
+filesCmd
+  .command('list')
+  .description('List uploaded project files')
+  .option('--json', 'Output as JSON')
+  .action((opts) => files.list(opts));
+
+filesCmd
+  .command('url <filename>')
+  .description('Get the URL for an uploaded file')
+  .option('--copy', 'Copy the URL to clipboard')
+  .action((filename, opts) => files.url(filename, opts));
+
+filesCmd
+  .command('sync')
+  .description('Download all project files from storage into ./assets (mirrors remote list)')
+  .option('-q, --quiet', 'No per-file output or summary (errors still print)')
+  .action((opts) => files.sync(opts));
+
+// ---------------------------------------------------------------------------
+// Forms  (micropage forms <subcommand>)
+// ---------------------------------------------------------------------------
+
+const formCmd = program.command('forms').description('View forms for the current project');
+
+formCmd
+  .command('list')
+  .description('List forms and their submission counts for the current project')
+  .option('--json', 'Output as JSON')
+  .action((opts) => forms.list(opts));
+
+// ---------------------------------------------------------------------------
+// Form submissions  (micropage submissions <subcommand>)
+// ---------------------------------------------------------------------------
+
+const subCmd = program.command('submissions').description('View form submissions');
+
+subCmd
+  .command('list')
+  .description('List form submissions for the current project')
+  .option('--json', 'Output as JSON')
+  .action((opts) => submissions.list(opts));
+
+subCmd
+  .command('show <id>')
+  .description('Show a single form submission in detail')
+  .option('--json', 'Output as JSON')
+  .action((id, opts) => submissions.show(id, opts));
+
+subCmd
+  .command('export')
+  .description('Export form submissions for the current project to a file')
+  .option(
+    '-f, --format <format>',
+    'Output format: csv or json (default: csv)',
+  )
+  .option(
+    '-o, --output <file>',
+    'Output file path (default: submissions.<format>)',
+  )
+  .action((opts) => submissions.exportSubmissions(opts));
+
+program.parse();

package/src/mime.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const MAP = {
+  '.png':  'image/png',
+  '.jpg':  'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif':  'image/gif',
+  '.webp': 'image/webp',
+  '.ico':  'image/x-icon',
+  '.svg':  'image/svg+xml',
+};
+
+function fromFilename(filename) {
+  const ext = require('path').extname(filename).toLowerCase();
+  return MAP[ext] || 'application/octet-stream';
+}
+
+module.exports = { fromFilename };

package/src/parser.js

@@ -0,0 +1,72 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Read and merge .page files from a directory.
+ *
+ * Merge order:
+ *   1. landing.page  (canonical primary file, if present)
+ *   2. All other *.page files sorted lexicographically
+ *
+ * Files are joined with a single blank line separator.
+ */
+function readPageFilesFromDir(dir) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  const primary = path.join(dir, 'landing.page');
+  const others = [];
+
+  for (const e of entries) {
+    if (!e.isFile() || !e.name.endsWith('.page')) continue;
+    if (e.name === 'landing.page') continue; // handled separately
+    others.push(path.join(dir, e.name));
+  }
+  others.sort();
+
+  const parts = [];
+  if (fs.existsSync(primary)) {
+    parts.push(fs.readFileSync(primary, 'utf8').trim());
+  }
+  for (const f of others) {
+    const content = fs.readFileSync(f, 'utf8').trim();
+    if (content) parts.push(content);
+  }
+
+  if (parts.length === 0) {
+    throw new Error('No .page files found');
+  }
+
+  return parts.join('\n\n');
+}
+
+/**
+ * Write raw content to landing.page in the given directory.
+ * Used by `micropage pull` to save the latest build content locally.
+ */
+function writePageFile(dir, content) {
+  const dest = path.join(dir, 'landing.page');
+  fs.writeFileSync(dest, content, 'utf8');
+  return dest;
+}
+
+const ASSET_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.ico', '.svg'];
+
+function listAssetsFromDir(dir) {
+  const assetsDir = path.join(dir, 'assets');
+  if (!fs.existsSync(assetsDir)) return [];
+  const entries = fs.readdirSync(assetsDir, { withFileTypes: true });
+  const files = [];
+  for (const e of entries) {
+    if (e.isFile()) {
+      const ext = path.extname(e.name).toLowerCase();
+      if (ASSET_EXTENSIONS.includes(ext)) files.push(e.name);
+    }
+  }
+  return files.sort();
+}
+
+module.exports = {
+  readPageFilesFromDir,
+  writePageFile,
+  listAssetsFromDir,
+  ASSET_EXTENSIONS,
+};

package/src/project-ref.js

@@ -0,0 +1,54 @@
+'use strict';
+
+/** Match standard UUID strings (accepts any version nibble). */
+const PROJECT_UUID_RE =
+  /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+function isProjectUuid(s) {
+  return typeof s === 'string' && PROJECT_UUID_RE.test(s.trim());
+}
+
+function isLegacyNumericProjectId(s) {
+  return typeof s === 'string' && /^\d+$/.test(String(s).trim());
+}
+
+/**
+ * Load a project row from a CLI argument: UUID, legacy numeric id, or domain.
+ */
+async function fetchProjectByUserRef(db, ref) {
+  const r = String(ref).trim();
+  if (!r) return null;
+  if (isProjectUuid(r)) {
+    return db.from('projects').select('*').eq('uuid', r).single();
+  }
+  if (isLegacyNumericProjectId(r)) {
+    return db.from('projects').select('*').eq('id', r).single();
+  }
+  return db.from('projects').select('*').eq('domain', r).single();
+}
+
+/**
+ * Load project from `.micropage/project.json` fields (prefers uuid when set).
+ */
+async function fetchProjectFromConfig(db, config) {
+  if (!config) return null;
+  if (config.projectUuid) {
+    const row = await db
+      .from('projects')
+      .select('*')
+      .eq('uuid', String(config.projectUuid).trim())
+      .single();
+    if (row) return row;
+  }
+  if (config.projectId != null) {
+    return db.from('projects').select('*').eq('id', config.projectId).single();
+  }
+  return null;
+}
+
+module.exports = {
+  isProjectUuid,
+  isLegacyNumericProjectId,
+  fetchProjectByUserRef,
+  fetchProjectFromConfig,
+};