vibefast-cli 0.1.1

package/src/core/codemod.ts

@@ -0,0 +1,211 @@
+import { readFileContent, writeFileContent } from './fsx.js';
+
+const NATIVE_START = '// --- @vibefast:features:start ---';
+const NATIVE_END = '// --- @vibefast:features:end ---';
+const WEB_START = '{/* @vibefast:nav:start */}';
+const WEB_END = '{/* @vibefast:nav:end */}';
+
+function escapeTsLiteral(value: string): string {
+  return value
+    .replace(/\\/g, '\\\\')
+    .replace(/'/g, "\\'")
+    .replace(/\r/g, '\\r')
+    .replace(/\n/g, '\\n')
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029');
+}
+
+function escapeHtmlAttribute(value: string): string {
+  return value
+    .replace(/&/g, '&')
+    .replace(/"/g, '"')
+    .replace(/'/g, ''')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+}
+
+function escapeForRegex(value: string): string {
+  return value.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
+}
+
+function safeNavId(value: string): string {
+  const sanitized = value.replace(/[^a-zA-Z0-9_-]/g, '');
+  return sanitized || 'feature';
+}
+
+export interface NavLink {
+  href: string;
+  label: string;
+}
+
+export async function insertNavLinkNative(
+  filePath: string,
+  link: NavLink & { icon?: string; color?: string },
+  options?: { dryRun?: boolean }
+): Promise<boolean> {
+  const content = await readFileContent(filePath);
+  
+  if (!content.includes(NATIVE_START) || !content.includes(NATIVE_END)) {
+    throw new Error(`Missing navigation markers in ${filePath}`);
+  }
+
+  // Check if link already exists by route
+  const routeCheck = link.href.replace('/(root)/(protected)/', '/');
+  const safeRoute = escapeTsLiteral(routeCheck);
+  if (content.includes(`route: '${safeRoute}'`)) {
+    return false; // Already exists, idempotent
+  }
+
+  // Create feature object for the vibefast-features.ts file
+  const featureId = safeNavId(link.href.split('/').pop() || 'feature');
+  const navItem = `  {
+    id: '${featureId}',
+    title: '${escapeTsLiteral(link.label)}',
+    icon: '${escapeTsLiteral(link.icon || '📦')}',
+    color: '${escapeTsLiteral(link.color || '#6366F1')}',
+    description: '${escapeTsLiteral(`${link.label} feature`)}',
+    route: '${safeRoute}',
+    testID: '${featureId}-button',
+  }`;
+
+  const startIdx = content.indexOf(NATIVE_START) + NATIVE_START.length;
+  const endIdx = content.indexOf(NATIVE_END);
+  
+  const before = content.slice(0, startIdx);
+  const after = content.slice(endIdx);
+  const between = content.slice(startIdx, endIdx);
+  
+  // Check if there are existing features (look for opening brace)
+  const hasExistingFeatures = between.includes('{');
+  
+  let newContent;
+  if (hasExistingFeatures) {
+    // Add comma after new item since there are more items
+    newContent = `${before}\n${navItem},${between}${after}`;
+  } else {
+    // First item, no comma needed
+    newContent = `${before}\n${navItem}\n  ${after}`;
+  }
+
+  if (!options?.dryRun) {
+    await writeFileContent(filePath, newContent, { force: true });
+  }
+  
+  return true;
+}
+
+export async function removeNavLinkNative(
+  filePath: string,
+  href: string,
+  options?: { dryRun?: boolean }
+): Promise<boolean> {
+  const content = await readFileContent(filePath);
+  
+  const routeCheck = href.replace('/(root)/(protected)/', '/');
+  const safeRoute = escapeTsLiteral(routeCheck);
+  if (!content.includes(`route: '${safeRoute}'`)) {
+    return false; // Not found
+  }
+
+  // Use regex to remove the entire feature object including trailing comma
+  // Match: { ... route: '/charts' ... }, or { ... route: '/charts' ... }
+  const featureObjectRegex = new RegExp(
+    `\\s*\\{[^}]*route:\\s*'${escapeForRegex(safeRoute)}'[^}]*\\},?\\s*`,
+    'gs'
+  );
+  
+  const newContent = content.replace(featureObjectRegex, '');
+
+  if (!options?.dryRun) {
+    await writeFileContent(filePath, newContent, { force: true });
+  }
+  
+  return true;
+}
+
+export async function insertNavLinkWeb(
+  filePath: string,
+  link: NavLink,
+  options?: { dryRun?: boolean }
+): Promise<boolean> {
+  const content = await readFileContent(filePath);
+  
+  if (!content.includes(WEB_START) || !content.includes(WEB_END)) {
+    throw new Error(`Missing navigation markers in ${filePath}`);
+  }
+
+  // Check if link already exists
+  const safeHref = escapeHtmlAttribute(link.href);
+  if (content.includes(`href="${safeHref}"`)) {
+    return false; // Already exists
+  }
+
+  const navCard = `        <Link href="${safeHref}" className="card">
+          <h3>{${JSON.stringify(link.label)}}</h3>
+        </Link>`;
+
+  const startIdx = content.indexOf(WEB_START) + WEB_START.length;
+  const endIdx = content.indexOf(WEB_END);
+  
+  const before = content.slice(0, startIdx);
+  const after = content.slice(endIdx);
+  const existing = content.slice(startIdx, endIdx).trim();
+  
+  const newContent = existing
+    ? `${before}\n${existing}\n${navCard}\n${after}`
+    : `${before}\n${navCard}\n${after}`;
+
+  if (!options?.dryRun) {
+    await writeFileContent(filePath, newContent, { force: true });
+  }
+  
+  return true;
+}
+
+export async function removeNavLinkWeb(
+  filePath: string,
+  href: string,
+  options?: { dryRun?: boolean }
+): Promise<boolean> {
+  const content = await readFileContent(filePath);
+  const safeHref = escapeHtmlAttribute(href);
+  
+  if (!content.includes(`href="${safeHref}"`)) {
+    return false;
+  }
+
+  const lines = content.split('\n');
+  const filtered: string[] = [];
+  let skipCount = 0;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    
+      if (line.includes(`href="${safeHref}"`)) {
+      let start = i;
+      while (start > 0 && !lines[start].trim().startsWith('<Link')) {
+        start--;
+      }
+      let end = i;
+      while (end < lines.length && !lines[end].trim().startsWith('</Link>')) {
+        end++;
+      }
+      skipCount = end - start + 1;
+      i = end;
+      continue;
+    }
+    
+    if (skipCount > 0) {
+      skipCount--;
+      continue;
+    }
+    
+    filtered.push(line);
+  }
+
+  if (!options?.dryRun) {
+    await writeFileContent(filePath, filtered.join('\n'), { force: true });
+  }
+  
+  return true;
+}

package/src/core/fsx.ts

@@ -0,0 +1,80 @@
+import { mkdir, writeFile, readFile, rm, access, readdir, stat, copyFile } from 'fs/promises';
+import { dirname, join } from 'path';
+import { constants } from 'fs';
+
+export async function ensureDir(path: string): Promise<void> {
+  try {
+    await mkdir(path, { recursive: true });
+  } catch (err: any) {
+    if (err.code !== 'EEXIST') throw err;
+  }
+}
+
+export async function exists(path: string): Promise<boolean> {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function readFileContent(path: string): Promise<string> {
+  return readFile(path, 'utf-8');
+}
+
+export async function writeFileContent(
+  path: string,
+  content: string,
+  options?: { force?: boolean }
+): Promise<void> {
+  const fileExists = await exists(path);
+  if (fileExists && !options?.force) {
+    throw new Error(`File already exists: ${path}. Use --force to overwrite.`);
+  }
+  await ensureDir(dirname(path));
+  await writeFile(path, content, 'utf-8');
+}
+
+export async function deleteFile(path: string): Promise<void> {
+  try {
+    await rm(path, { recursive: true, force: true });
+  } catch (err: any) {
+    if (err.code !== 'ENOENT') throw err;
+  }
+}
+
+export async function copyTree(
+  src: string,
+  dest: string,
+  options?: { dryRun?: boolean; force?: boolean }
+): Promise<string[]> {
+  const copied: string[] = [];
+  
+  async function copyRecursive(srcPath: string, destPath: string) {
+    const stats = await stat(srcPath);
+    
+    if (stats.isDirectory()) {
+      if (!options?.dryRun) {
+        await ensureDir(destPath);
+      }
+      const entries = await readdir(srcPath);
+      for (const entry of entries) {
+        await copyRecursive(join(srcPath, entry), join(destPath, entry));
+      }
+    } else {
+      const destExists = await exists(destPath);
+      if (destExists && !options?.force) {
+        throw new Error(`File exists: ${destPath}. Use --force to overwrite.`);
+      }
+      if (!options?.dryRun) {
+        await ensureDir(dirname(destPath));
+        await copyFile(srcPath, destPath);
+      }
+      copied.push(destPath);
+    }
+  }
+  
+  await copyRecursive(src, dest);
+  return copied;
+}

package/src/core/http.ts

@@ -0,0 +1,136 @@
+import { writeFile, mkdir } from 'fs/promises';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { randomUUID } from 'crypto';
+
+export interface RecipeFetchRequest {
+  token: string;
+  device: {
+    id: string;
+    os: string;
+    arch: string;
+    version: string;
+  };
+  feature: string;
+  target: string;
+  starter: {
+    name: string;
+    version: string;
+  };
+}
+
+export interface RecipeFetchResponse {
+  ok: boolean;
+  signedUrl?: string;
+  zipData?: string;
+  expiresIn?: number;
+  watermark?: string;
+  error?: string;
+  message?: string;
+}
+
+const WORKER_URL = process.env.VIBEFAST_WORKER_URL || 'https://vibefast-cli-worker.mzafar611.workers.dev';
+
+export async function fetchRecipe(request: RecipeFetchRequest): Promise<RecipeFetchResponse> {
+  try {
+    const response = await fetch(`${WORKER_URL}/api/recipe/fetch`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(request),
+    });
+
+    if (!response.ok) {
+      const error: any = await response.json().catch(() => ({ message: response.statusText }));
+      return {
+        ok: false,
+        error: error.message || `HTTP ${response.status}`,
+      };
+    }
+
+    return response.json() as Promise<RecipeFetchResponse>;
+  } catch (err: any) {
+    return {
+      ok: false,
+      error: 'Network error',
+      message: `Failed to connect to ${WORKER_URL}: ${err.message}`,
+    };
+  }
+}
+
+export async function downloadZip(signedUrlOrBase64: string, isBase64 = false): Promise<string> {
+  let buffer: Buffer;
+  
+  if (isBase64) {
+    // Decode base64 data
+    buffer = Buffer.from(signedUrlOrBase64, 'base64');
+  } else {
+    // Download from URL
+    const response = await fetch(signedUrlOrBase64);
+    
+    if (!response.ok) {
+      throw new Error(`Failed to download recipe: ${response.statusText}`);
+    }
+    
+    const arrayBuffer = await response.arrayBuffer();
+    buffer = Buffer.from(arrayBuffer);
+  }
+
+  const tempDir = join(tmpdir(), 'vibefast', randomUUID());
+  await mkdir(tempDir, { recursive: true });
+  
+  const zipPath = join(tempDir, 'recipe.zip');
+  await writeFile(zipPath, buffer);
+  
+  return zipPath;
+}
+
+export async function listRecipes(token: string): Promise<any> {
+  try {
+    const response = await fetch(`${WORKER_URL}/api/recipes/list`, {
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${token}`,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to fetch recipes: ${response.statusText}`);
+    }
+
+    return response.json();
+  } catch (err: any) {
+    throw new Error(`Failed to connect to ${WORKER_URL}: ${err.message}`);
+  }
+}
+
+export async function listDevices(token: string): Promise<any> {
+  const response = await fetch(`${WORKER_URL}/api/devices/list`, {
+    method: 'GET',
+    headers: {
+      'Authorization': `Bearer ${token}`,
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch devices: ${response.statusText}`);
+  }
+
+  return response.json();
+}
+
+export async function deactivateDevice(token: string, deviceId: string): Promise<void> {
+  const response = await fetch(`${WORKER_URL}/api/devices/deactivate`, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${token}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ deviceId }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to deactivate device: ${response.statusText}`);
+  }
+}

package/src/core/journal.ts

@@ -0,0 +1,64 @@
+import { readFileContent, writeFileContent, exists, ensureDir } from './fsx.js';
+import { dirname } from 'path';
+
+export interface JournalEntry {
+  feature: string;
+  target: 'native' | 'web';
+  files: string[];
+  insertedNav: boolean;
+  ts: number;
+  navHref?: string;
+  navLabel?: string;
+}
+
+export interface Journal {
+  entries: JournalEntry[];
+}
+
+export async function readJournal(journalPath: string): Promise<Journal> {
+  if (!(await exists(journalPath))) {
+    return { entries: [] };
+  }
+  const content = await readFileContent(journalPath);
+  return JSON.parse(content);
+}
+
+export async function writeJournal(journalPath: string, journal: Journal): Promise<void> {
+  await ensureDir(dirname(journalPath));
+  await writeFileContent(journalPath, JSON.stringify(journal, null, 2), { force: true });
+}
+
+export async function addEntry(journalPath: string, entry: JournalEntry): Promise<void> {
+  const journal = await readJournal(journalPath);
+  // Remove existing entry for same feature+target
+  journal.entries = journal.entries.filter(
+    e => !(e.feature === entry.feature && e.target === entry.target)
+  );
+  journal.entries.push(entry);
+  await writeJournal(journalPath, journal);
+}
+
+export async function removeEntry(
+  journalPath: string,
+  feature: string,
+  target: 'native' | 'web'
+): Promise<JournalEntry | null> {
+  const journal = await readJournal(journalPath);
+  const entry = journal.entries.find(e => e.feature === feature && e.target === target);
+  if (!entry) return null;
+  
+  journal.entries = journal.entries.filter(
+    e => !(e.feature === feature && e.target === target)
+  );
+  await writeJournal(journalPath, journal);
+  return entry;
+}
+
+export async function getEntry(
+  journalPath: string,
+  feature: string,
+  target: 'native' | 'web'
+): Promise<JournalEntry | null> {
+  const journal = await readJournal(journalPath);
+  return journal.entries.find(e => e.feature === feature && e.target === target) || null;
+}

package/src/core/log.ts

@@ -0,0 +1,9 @@
+import pc from 'picocolors';
+
+export const log = {
+  success: (msg: string) => console.log(pc.green('✓'), msg),
+  info: (msg: string) => console.log(pc.blue('ℹ'), msg),
+  warn: (msg: string) => console.log(pc.yellow('⚠'), msg),
+  error: (msg: string) => console.error(pc.red('✗'), msg),
+  plain: (msg: string) => console.log(msg),
+};

package/src/core/pathGuard.ts

@@ -0,0 +1,22 @@
+import { resolve, sep } from 'path';
+
+function withTrailingSep(path: string): string {
+  return path.endsWith(sep) ? path : `${path}${sep}`;
+}
+
+export function isSubPath(basePath: string, targetPath: string): boolean {
+  const base = withTrailingSep(resolve(basePath));
+  const target = resolve(targetPath);
+  return target === base.slice(0, -1) || target.startsWith(base);
+}
+
+export function ensureWithinBase(basePath: string, targetPath: string, label: string): string {
+  const base = resolve(basePath);
+  const target = resolve(targetPath);
+  
+  if (!isSubPath(base, target)) {
+    throw new Error(`${label} must stay within ${base}`);
+  }
+  
+  return target;
+}

package/src/core/paths.ts

@@ -0,0 +1,33 @@
+import { join, resolve } from 'path';
+import { homedir } from 'os';
+
+export interface PathsConfig {
+  cwd: string;
+  signatureFile: string;
+  journalFile: string;
+  configDir: string;
+  nativeNavFile: string;
+  webNavFile: string;
+}
+
+export function getPaths(cwd: string = process.cwd()): PathsConfig {
+  return {
+    cwd,
+    signatureFile: join(cwd, '.vibefast', 'starter.json'),
+    journalFile: join(cwd, '.vibefast', 'journal.json'),
+    configDir: join(homedir(), '.vibefast'),
+    nativeNavFile: join(cwd, 'apps', 'native', 'src', 'features', 'vibefast-features.ts'),
+    webNavFile: join(cwd, 'apps', 'web', 'app', 'page.tsx'),
+  };
+}
+
+export function getConfigPath(): string {
+  const directPath = process.env.VIBEFAST_CONFIG_PATH;
+  if (directPath) {
+    return resolve(directPath);
+  }
+
+  const customDir = process.env.VIBEFAST_CONFIG_DIR;
+  const baseDir = customDir ? resolve(customDir) : join(homedir(), '.vibefast');
+  return join(baseDir, 'config.json');
+}

package/src/core/validate.ts

@@ -0,0 +1,44 @@
+import { readFileContent, exists } from './fsx.js';
+
+export interface StarterConfig {
+  name: string;
+  version: string;
+  targets: string[];
+}
+
+export async function validateSignature(signaturePath: string): Promise<StarterConfig> {
+  if (!(await exists(signaturePath))) {
+    throw new Error(
+      'Not a VibeFast repo. Missing .vibefast/starter.json. Run this command from your VibeFast monorepo root.'
+    );
+  }
+
+  const content = await readFileContent(signaturePath);
+  let config: StarterConfig;
+  
+  try {
+    config = JSON.parse(content);
+  } catch {
+    throw new Error('Invalid .vibefast/starter.json: not valid JSON');
+  }
+
+  if (config.name !== 'vibefast') {
+    throw new Error(
+      `Invalid starter name: expected "vibefast", got "${config.name}"`
+    );
+  }
+
+  if (!Array.isArray(config.targets) || config.targets.length === 0) {
+    throw new Error('Invalid .vibefast/starter.json: targets must be a non-empty array');
+  }
+
+  return config;
+}
+
+export function validateTarget(target: string, availableTargets: string[]): void {
+  if (!availableTargets.includes(target)) {
+    throw new Error(
+      `Invalid target "${target}". Available: ${availableTargets.join(', ')}`
+    );
+  }
+}

package/src/index.ts

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { addCommand } from './commands/add.js';
+import { removeCommand } from './commands/remove.js';
+import { listCommand } from './commands/list.js';
+import { doctorCommand } from './commands/doctor.js';
+import { loginCommand } from './commands/login.js';
+import { devicesCommand } from './commands/devices.js';
+import { logoutCommand } from './commands/logout.js';
+
+const program = new Command();
+
+program
+  .name('vf')
+  .description('VibeFast CLI - Install features into your monorepo')
+  .version('0.1.0');
+
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(devicesCommand);
+program.addCommand(doctorCommand);
+program.addCommand(listCommand);
+program.addCommand(addCommand);
+program.addCommand(removeCommand);
+
+program.parse();