fabrica-e-commerce 0.1.5 → 0.1.6

package/README.md

@@ -38,7 +38,7 @@ On Windows CMD, these commands do not require Unix tools such as `find` or `xarg
 
 ## Commands
 
-- `build` — checks dependencies (git, GitHub CLI, Vercel CLI), creates a Fabrica Connect Supabase job, opens the OAuth bridge, asks for required secrets, clones `https://github.com/trucount/fabrica-final-e-c.git`, verifies/logs in to Vercel (`vercel login`), publishes that code to a **new GitHub repository** under your account, connects the Vercel project to that repo for continuous deployment, writes every environment variable to production/preview/development, and deploys with `vercel --prod`.
+- `build` — checks Git, creates a Fabrica Connect Supabase job, opens the OAuth bridge, asks for required secrets, clones `https://github.com/trucount/fabrica-final-e-c.git`, then asks whether to run locally or deploy on Vercel. Local mode writes `.env.local`, installs dependencies, and starts the Next.js dev server. Vercel mode checks GitHub/Vercel dependencies, verifies/logs in to Vercel, creates a user-owned repo from the hardcoded storefront source (fork/template, not `git push`), connects Vercel to that repo, writes every environment variable to production/preview/development, and deploys with `vercel --prod`.
 - `list` — shows locally saved deployments and lets you replace a saved project's Vercel environment variable (across production, preview, and development), then redeploys.
 - `vins` — verifies the CLI's external dependencies (`git`, GitHub CLI `gh`, and the Vercel CLI via `npx`) and automatically installs anything missing using your system's package manager (`apt-get`/`dnf`/`pacman` on Linux, `brew` on macOS, `winget`/`choco` on Windows). Prints manual install links for anything it can't install automatically.
 - `info` / `.info` — prints package, bridge, repository, and local data paths.
@@ -60,12 +60,14 @@ On Windows CMD, these commands do not require Unix tools such as `find` or `xarg
    - `UMAMI_API_CLIENT_ENDPOINT=https://api.umami.is/v1`
    - `SUPABASE_SERVICE_ROLE_KEY=0000`
 5. Adds `SUPABASE_URL` and `SUPABASE_ANON_KEY` from the bridge response.
-6. **Step 3 — deploy:**
-   - Verifies you're logged in to Vercel (`vercel whoami`); if not, runs an interactive `vercel login` and waits for it to finish.
-   - Logs in to the GitHub CLI if needed (`gh auth login`), detaches the cloned code from the template's git history, and publishes it to a **brand new private GitHub repository** under your account using the GitHub API, avoiding separate `git push` credential prompts.
-   - Links a new Vercel project with `vercel link --yes --project <name>` and connects it to the new GitHub repo with `vercel git connect` so future pushes auto-deploy.
-   - Writes every collected environment variable (including the Supabase URL/anon key) to the **production, preview, and development** environments with `vercel env add`, so the values are permanent for the project, not just the first deploy.
-   - Creates the production deployment with `vercel --prod --yes`.
+6. **Step 3 — run target:**
+   - Asks whether to run the storefront **locally** or deploy on **Vercel cloud**.
+   - Local mode writes every collected variable to `.env.local` inside the cloned Next.js app, installs dependencies (`pnpm install` when available, otherwise `npm install`), and starts `pnpm run dev`/`npm run dev` at `http://localhost:3000`.
+   - Vercel mode verifies you're logged in to Vercel (`vercel whoami`); if not, runs an interactive `vercel login` and waits for it to finish.
+   - Vercel mode logs in to the GitHub CLI if needed (`gh auth login`) and creates a user-owned repo from the hardcoded storefront source with a fork/template flow, avoiding local `git push` credentials.
+   - Vercel mode links a new Vercel project with `vercel link --yes --project <name>` and connects it to the new GitHub repo with `vercel git connect` so future pushes auto-deploy.
+   - Vercel mode writes every collected environment variable (including the Supabase URL/anon key) to the **production, preview, and development** environments with `vercel env add`, so the values are permanent for the project, not just the first deploy.
+   - Vercel mode creates the production deployment with `vercel --prod --yes`.
 
 ## Dependency check (`vins`)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fabrica-e-commerce",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Orange themed CMD launcher for deploying Fabrica e-commerce stores with Supabase and Vercel.",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -3,11 +3,12 @@ import { readFile } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
 import { connectSupabase } from './bridge.js';
-import { collectEnv, cloneRepo, deployToVercel, editProjectEnv, ensureVercelLogin } from './deploy.js';
+import { collectEnv, cloneRepo, deployToVercel, editProjectEnv, ensureVercelLogin, runLocally } from './deploy.js';
 import { createGithubRepoFromClone } from './github.js';
 import { ensureDependencies, vinsCommand } from './deps.js';
 import { BRIDGE_ORIGIN, STORE_REPO } from './config.js';
 import { dataDir, readProjects } from './store.js';
+import { choose } from './prompt.js';
 import { banner, help, kv, section } from './ui.js';
 
 async function packageVersion() {
@@ -20,7 +21,7 @@ async function build() {
   banner();
 
   section('Dependency check');
-  await ensureDependencies({ names: ['git', 'gh', 'vercel'] });
+  await ensureDependencies({ names: ['git'] });
 
   section('Supabase Connect');
   kv('BRIDGE', 'ONLINE');
@@ -29,9 +30,18 @@ async function build() {
   const env = await collectEnv(supabase);
   const project = await cloneRepo();
 
-  // Step 3: log in to Vercel first, push the cloned code into a brand new
-  // GitHub repo owned by the user, then deploy that repo to a new Vercel
-  // project with every env variable (including Supabase) set permanently.
+  section('Step 3: Run target');
+  const target = await choose('Where should Fabrica run this storefront?', [
+    { name: 'Deploy on Vercel cloud', value: 'vercel' },
+    { name: 'Run locally on this computer', value: 'local' }
+  ]);
+
+  if (target === 'local') {
+    await runLocally(project, env);
+    return;
+  }
+
+  await ensureDependencies({ names: ['gh', 'vercel'] });
   await ensureVercelLogin();
   const githubRepo = await createGithubRepoFromClone(project);
   const record = await deployToVercel(project, env, githubRepo);

package/src/deploy.js

@@ -1,3 +1,4 @@
+import fs from 'node:fs/promises';
 import path from 'node:path';
 import crypto from 'node:crypto';
 import { HARDCODED_ENV, REQUIRED_ENV_KEYS, STORE_REPO } from './config.js';
@@ -103,3 +104,24 @@ export async function editProjectEnv(projects) {
   await runCommand('npx', ['vercel@latest', '--prod', '--yes'], { cwd: project.target });
   kv('Redeployed', project.projectName);
 }
+
+
+export async function runLocally(project, env) {
+  section('Local Next.js setup');
+  const envPath = path.join(project.target, '.env.local');
+  const contents = Object.entries(env).map(([key, value]) => `${key}=${String(value).replace(/\n/g, '\\n')}`).join('\n') + '\n';
+  await fs.writeFile(envPath, contents, 'utf8');
+  kv('Env file', envPath);
+
+  const hasPnpmLock = await fs.access(path.join(project.target, 'pnpm-lock.yaml')).then(() => true, () => false);
+  const pnpmAvailable = (await runCommandCapture('pnpm', ['--version'])).code === 0;
+  const installCommand = hasPnpmLock && pnpmAvailable ? ['pnpm', ['install']] : ['npm', ['install']];
+  const devCommand = hasPnpmLock && pnpmAvailable ? ['pnpm', ['run', 'dev']] : ['npm', ['run', 'dev']];
+
+  await runCommand(installCommand[0], installCommand[1], { cwd: project.target });
+  section('Local app');
+  kv('Path', project.target);
+  kv('URL', 'http://localhost:3000');
+  console.log('Starting the Next.js dev server. Press Ctrl+C to stop it.');
+  await runCommand(devCommand[0], devCommand[1], { cwd: project.target });
+}

package/src/github.js

@@ -1,7 +1,5 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import process from 'node:process';
 import { commandExists, runCommand, runCommandCapture } from './system.js';
+import { STORE_REPO } from './config.js';
 import { choose } from './prompt.js';
 import { kv, section, spinner } from './ui.js';
 
@@ -57,26 +55,6 @@ async function githubRepoExists(owner, repoName) {
   return result.code === 0;
 }
 
-async function ensureGithubRepo(owner, repoName) {
-  const fullName = `${owner}/${repoName}`;
-  if (await githubRepoExists(owner, repoName)) {
-    const action = await choose(`GitHub repo ${fullName} already exists. What should Fabrica do?`, [
-      { name: 'Use the existing repo and publish this storefront to it', value: 'use' },
-      { name: 'Stop so I can choose a different Vercel project/repo name', value: 'stop' }
-    ]);
-    if (action === 'stop') throw new Error(`GitHub repo ${fullName} already exists. Re-run build with a different project name.`);
-    return;
-  }
-
-  const spin = spinner(`Creating GitHub repo ${fullName}`);
-  const create = await runCommandCapture('gh', ['repo', 'create', fullName, '--private']);
-  if (create.code !== 0) {
-    spin.fail('Could not create GitHub repository');
-    throw new Error(create.stderr || 'gh repo create failed');
-  }
-  spin.succeed(`Created GitHub repo ${fullName}`);
-}
-
 async function setOrigin(project, repoUrl) {
   const existing = await runCommandCapture('git', ['remote', 'get-url', 'origin'], { cwd: project.target });
   if (existing.code === 0) {
@@ -86,89 +64,62 @@ async function setOrigin(project, repoUrl) {
   }
 }
 
-
-async function ghApiJson(args, body) {
-  const result = await runCommandCapture('gh', ['api', ...args, '--input', '-'], { input: JSON.stringify(body) });
-  if (result.code !== 0) throw new Error(result.stderr || result.stdout || `gh api ${args.join(' ')} failed`);
-  return result.stdout ? JSON.parse(result.stdout) : {};
-}
-
-async function ghApiGet(args) {
-  const result = await runCommandCapture('gh', ['api', ...args]);
-  if (result.code !== 0) return null;
-  return result.stdout ? JSON.parse(result.stdout) : {};
+// Creates or reuses a GitHub repository from the hardcoded storefront source
+// repository, so Vercel connects to user-owned code without requiring a local
+// git push from this machine.
+function sourceRepoFullName() {
+  return STORE_REPO.replace(/^https:\/\/github\.com\//, '').replace(/\.git$/, '');
 }
 
-async function listTrackedFiles(project) {
-  const result = await runCommandCapture('git', ['ls-files', '-z'], { cwd: project.target });
-  if (result.code !== 0) throw new Error(result.stderr || 'Could not list storefront files for GitHub upload.');
-  return result.stdout.split('\0').filter(Boolean);
-}
-
-async function createGithubBlob(project, owner, repoName, filePath) {
-  const absolute = path.join(project.target, filePath);
-  const content = await fs.readFile(absolute);
-  const blob = await ghApiJson([`repos/${owner}/${repoName}/git/blobs`], {
-    content: content.toString('base64'),
-    encoding: 'base64'
-  });
-  return { path: filePath.replace(/\\/g, '/'), mode: '100644', type: 'blob', sha: blob.sha };
+async function waitForGithubRepo(owner, repoName) {
+  for (let attempt = 0; attempt < 20; attempt += 1) {
+    if (await githubRepoExists(owner, repoName)) return;
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+  }
 }
 
-async function publishWithGithubApi(project, owner, repoName) {
-  const spin = spinner('Publishing storefront through GitHub API');
-  const files = await listTrackedFiles(project);
-  const treeItems = [];
-  for (const filePath of files) {
-    treeItems.push(await createGithubBlob(project, owner, repoName, filePath));
+async function forkSourceRepo(owner, repoName) {
+  const source = sourceRepoFullName();
+  const existing = await githubRepoExists(owner, repoName);
+  if (existing) {
+    const action = await choose(`GitHub repo ${owner}/${repoName} already exists. What should Fabrica do?`, [
+      { name: 'Use the existing repo for Vercel', value: 'use' },
+      { name: 'Stop so I can choose a different Vercel project/repo name', value: 'stop' }
+    ]);
+    if (action === 'stop') throw new Error(`GitHub repo ${owner}/${repoName} already exists. Re-run build with a different project name.`);
+    return;
   }
 
-  const tree = await ghApiJson([`repos/${owner}/${repoName}/git/trees`], { tree: treeItems });
-
-  const existingRef = await ghApiGet([`repos/${owner}/${repoName}/git/ref/heads/main`]);
-  const parents = existingRef?.object?.sha ? [existingRef.object.sha] : [];
-  const commit = await ghApiJson([`repos/${owner}/${repoName}/git/commits`], {
-    message: 'Initial commit from Fabrica storefront',
-    tree: tree.sha,
-    parents
+  const spin = spinner(`Creating GitHub repo ${owner}/${repoName} from ${source}`);
+  const fork = await runCommandCapture('gh', ['api', `repos/${source}/forks`, '--method', 'POST', '--input', '-'], {
+    input: JSON.stringify({ name: repoName, default_branch_only: false })
   });
+  if (fork.code === 0) {
+    await waitForGithubRepo(owner, repoName);
+    spin.succeed(`Forked ${source} to ${owner}/${repoName}`);
+    return;
+  }
 
-  if (existingRef?.ref) {
-    await ghApiJson([`repos/${owner}/${repoName}/git/refs/heads/main`, '--method', 'PATCH'], { sha: commit.sha, force: true });
-  } else {
-    await ghApiJson([`repos/${owner}/${repoName}/git/refs`], { ref: 'refs/heads/main', sha: commit.sha });
+  const template = await runCommandCapture('gh', ['repo', 'create', `${owner}/${repoName}`, '--private', '--template', source, '--include-all-branches']);
+  if (template.code === 0) {
+    spin.succeed(`Created ${owner}/${repoName} from ${source}`);
+    return;
   }
-  spin.succeed('Published storefront to GitHub without git push');
-}
 
+  spin.fail('Could not create GitHub repo from source repo');
+  throw new Error(fork.stderr || template.stderr || 'GitHub repo creation from source failed');
+}
 
-// Re-homes the cloned storefront code into a brand new GitHub repository
-// owned by the logged-in user, so the deployed Vercel project can stay
-// connected to that repo (future changes can auto deploy) instead of the original
-// template repository.
 export async function createGithubRepoFromClone(project) {
   section('GitHub repository');
   await ensureGithubLogin();
   const owner = await getGithubLogin();
   const repoName = project.projectName;
-  const repoUrl = `https://github.com/${owner}/${repoName}.git`;
-
-  // Detach from the template's git history and start a clean repo so we
-  // don't try to push into someone else's repository history.
-  if (process.platform === 'win32') {
-    await runCommand('cmd', ['/c', 'rmdir', '/s', '/q', '.git'], { cwd: project.target, allowFailure: true });
-  } else {
-    await runCommand('rm', ['-rf', '.git'], { cwd: project.target, allowFailure: true });
-  }
-  await runCommand('git', ['init', '-b', 'main'], { cwd: project.target });
-  await runCommand('git', ['add', '-A'], { cwd: project.target });
-  await runCommand('git', ['-c', 'user.email=fabrica-cli@local', '-c', 'user.name=Fabrica CLI', 'commit', '-m', 'Initial commit from Fabrica storefront'], { cwd: project.target });
-
-  await ensureGithubRepo(owner, repoName);
-  await setOrigin(project, repoUrl);
-  await publishWithGithubApi(project, owner, repoName);
+  await forkSourceRepo(owner, repoName);
 
   const browserUrl = `https://github.com/${owner}/${repoName}`;
+  const cloneUrl = `${browserUrl}.git`;
+  await setOrigin(project, cloneUrl);
   kv('GitHub repo', browserUrl);
   return { owner, repoName, repoUrl: browserUrl };
 }

package/src/ui.js

@@ -21,7 +21,7 @@ export function help() {
   banner();
   console.log(`
 ${orange('Commands')}
-  ${bold('build')}      Connect Supabase, collect secrets, clone the store, publish to a new GitHub repo, deploy to Vercel
+  ${bold('build')}      Connect Supabase, collect secrets, then run locally or deploy to Vercel
   ${bold('list')}       Show deployed Fabrica projects and edit env variables
   ${bold('vins')}       Verify CLI dependencies (git, gh, vercel) and auto-install anything missing
   ${bold('info')}       Show package, bridge, repo, and local storage information