vibefast-cli 0.1.1

package/src/commands/list.ts

@@ -0,0 +1,45 @@
+import { Command } from 'commander';
+import { log } from '../core/log.js';
+import { getToken } from '../core/auth.js';
+import { listRecipes } from '../core/http.js';
+
+export const listCommand = new Command('list')
+  .description('List available VibeFast features')
+  .action(async () => {
+    try {
+      const token = await getToken();
+      if (!token) {
+        log.error('Not logged in. Run "vf login --token <TOKEN>" first');
+        process.exit(1);
+      }
+
+      const response = await listRecipes(token);
+      
+      if (!response.recipes || response.recipes.length === 0) {
+        log.info('No recipes available');
+        return;
+      }
+
+      const native = response.recipes.filter((r: any) => r.target === 'native');
+      const web = response.recipes.filter((r: any) => r.target === 'web');
+
+      if (native.length > 0) {
+        log.info('Native (Expo) features:');
+        native.forEach((recipe: any) => {
+          log.plain(`  • ${recipe.name} - ${recipe.description}`);
+        });
+      }
+
+      if (web.length > 0) {
+        log.info('\nWeb (Next.js) features:');
+        web.forEach((recipe: any) => {
+          log.plain(`  • ${recipe.name} - ${recipe.description}`);
+        });
+      }
+
+      log.plain('\nInstall with: vf add <feature-name>');
+    } catch (error: any) {
+      log.error(`Failed to list recipes: ${error.message}`);
+      process.exit(1);
+    }
+  });

package/src/commands/login.ts

@@ -0,0 +1,24 @@
+import { Command } from 'commander';
+import { log } from '../core/log.js';
+import { saveToken } from '../core/auth.js';
+
+export const loginCommand = new Command('login')
+  .description('Authenticate with your VibeFast token')
+  .requiredOption('--token <token>', 'Your VibeFast license token')
+  .action(async (options) => {
+    try {
+      const token = options.token.trim();
+      
+      if (!token || token.length < 10) {
+        log.error('Invalid token format');
+        process.exit(1);
+      }
+      
+      await saveToken(token);
+      log.success('Token saved successfully');
+      log.info('Run "vf doctor" to verify your setup');
+    } catch (error: any) {
+      log.error(`Login failed: ${error.message}`);
+      process.exit(1);
+    }
+  });

package/src/commands/logout.ts

@@ -0,0 +1,15 @@
+import { Command } from 'commander';
+import { log } from '../core/log.js';
+import { clearToken } from '../core/auth.js';
+
+export const logoutCommand = new Command('logout')
+  .description('Clear your stored VibeFast token')
+  .action(async () => {
+    try {
+      await clearToken();
+      log.success('Token cleared');
+    } catch (error: any) {
+      log.error(`Logout failed: ${error.message}`);
+      process.exit(1);
+    }
+  });

package/src/commands/remove.ts

@@ -0,0 +1,78 @@
+import { Command } from 'commander';
+import { log } from '../core/log.js';
+import { getPaths } from '../core/paths.js';
+import { validateSignature, validateTarget } from '../core/validate.js';
+import { getEntry, removeEntry } from '../core/journal.js';
+import { deleteFile } from '../core/fsx.js';
+import { removeNavLinkNative, removeNavLinkWeb } from '../core/codemod.js';
+
+export const removeCommand = new Command('remove')
+  .description('Remove a VibeFast feature from your project')
+  .argument('<feature>', 'Feature name to remove')
+  .option('--target <target>', 'Target platform (native or web)', 'native')
+  .option('--dry-run', 'Preview changes without applying')
+  .action(async (feature: string, options) => {
+    try {
+      const paths = getPaths();
+      const target = options.target as 'native' | 'web';
+
+      // Validate setup
+      const config = await validateSignature(paths.signatureFile);
+      validateTarget(target, config.targets);
+
+      if (options.dryRun) {
+        log.info('[DRY RUN] No changes will be made');
+      }
+
+      // Get journal entry (do not mutate journal yet)
+      const entry = await getEntry(paths.journalFile, feature, target);
+      
+      if (!entry) {
+        log.warn(`${feature} is not installed for ${target}`);
+        log.info('Run "vf list" to see installed features');
+        return;
+      }
+
+      log.info(`Removing ${feature} from ${target}...`);
+
+      // Delete files
+      for (const file of entry.files) {
+        log.info(`Deleting ${file}`);
+        if (!options.dryRun) {
+          await deleteFile(file);
+        }
+      }
+
+      // Remove nav link
+      if (entry.insertedNav) {
+        log.info('Removing navigation link...');
+        const navFile = target === 'native' ? paths.nativeNavFile : paths.webNavFile;
+        const removeFn = target === 'native' ? removeNavLinkNative : removeNavLinkWeb;
+        
+        const href = entry.navHref
+          ? entry.navHref
+          : target === 'native'
+            ? `/(root)/(protected)/${feature}`
+            : `/${feature}`;
+        
+        if (!options.dryRun) {
+          await removeFn(navFile, href);
+        }
+        log.success('Navigation link removed');
+      }
+
+      if (!options.dryRun) {
+        await removeEntry(paths.journalFile, entry.feature, entry.target);
+      }
+
+      log.success(`${feature} removed successfully!`);
+      log.info(`Files deleted: ${entry.files.length}`);
+      
+      if (options.dryRun) {
+        log.warn('This was a dry run. Run without --dry-run to apply changes.');
+      }
+    } catch (error: any) {
+      log.error(`Removal failed: ${error.message}`);
+      process.exit(1);
+    }
+  });

package/src/core/__tests__/journal.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { readJournal, writeJournal, addEntry, removeEntry, getEntry } from '../journal.js';
+import { deleteFile } from '../fsx.js';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { randomUUID } from 'crypto';
+
+describe('journal', () => {
+  let testDir: string;
+  let journalPath: string;
+
+  beforeEach(async () => {
+    testDir = join(tmpdir(), 'vibefast-test', randomUUID());
+    journalPath = join(testDir, '.vibefast', 'journal.json');
+  });
+
+  afterEach(async () => {
+    await deleteFile(testDir);
+  });
+
+  it('should return empty journal if file missing', async () => {
+    const journal = await readJournal(journalPath);
+    expect(journal.entries).toEqual([]);
+  });
+
+  it('should write and read journal', async () => {
+    const journal = {
+      entries: [
+        {
+          feature: 'test',
+          target: 'native' as const,
+          files: ['/test/file.ts'],
+          insertedNav: true,
+          ts: Date.now(),
+        },
+      ],
+    };
+
+    await writeJournal(journalPath, journal);
+    const read = await readJournal(journalPath);
+    expect(read.entries).toHaveLength(1);
+    expect(read.entries[0].feature).toBe('test');
+  });
+
+  it('should add entry', async () => {
+    const entry = {
+      feature: 'mini-native',
+      target: 'native' as const,
+      files: ['/apps/native/src/app/mini/index.tsx'],
+      insertedNav: true,
+      ts: Date.now(),
+    };
+
+    await addEntry(journalPath, entry);
+    const journal = await readJournal(journalPath);
+    expect(journal.entries).toHaveLength(1);
+    expect(journal.entries[0].feature).toBe('mini-native');
+  });
+
+  it('should replace existing entry for same feature+target', async () => {
+    const entry1 = {
+      feature: 'test',
+      target: 'native' as const,
+      files: ['/file1.ts'],
+      insertedNav: true,
+      ts: 1000,
+    };
+
+    const entry2 = {
+      feature: 'test',
+      target: 'native' as const,
+      files: ['/file2.ts'],
+      insertedNav: false,
+      ts: 2000,
+    };
+
+    await addEntry(journalPath, entry1);
+    await addEntry(journalPath, entry2);
+
+    const journal = await readJournal(journalPath);
+    expect(journal.entries).toHaveLength(1);
+    expect(journal.entries[0].ts).toBe(2000);
+  });
+
+  it('should remove entry', async () => {
+    const entry = {
+      feature: 'test',
+      target: 'native' as const,
+      files: ['/file.ts'],
+      insertedNav: true,
+      ts: Date.now(),
+    };
+
+    await addEntry(journalPath, entry);
+    const removed = await removeEntry(journalPath, 'test', 'native');
+    
+    expect(removed).not.toBeNull();
+    expect(removed?.feature).toBe('test');
+
+    const journal = await readJournal(journalPath);
+    expect(journal.entries).toHaveLength(0);
+  });
+
+  it('should get entry', async () => {
+    const entry = {
+      feature: 'test',
+      target: 'native' as const,
+      files: ['/file.ts'],
+      insertedNav: true,
+      ts: Date.now(),
+    };
+
+    await addEntry(journalPath, entry);
+    const found = await getEntry(journalPath, 'test', 'native');
+    
+    expect(found).not.toBeNull();
+    expect(found?.feature).toBe('test');
+  });
+});

package/src/core/__tests__/validate.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { validateSignature, validateTarget } from '../validate.js';
+import { writeFileContent, deleteFile } from '../fsx.js';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { randomUUID } from 'crypto';
+
+describe('validate', () => {
+  let testDir: string;
+  let signaturePath: string;
+
+  beforeEach(async () => {
+    testDir = join(tmpdir(), 'vibefast-test', randomUUID());
+    signaturePath = join(testDir, '.vibefast', 'starter.json');
+  });
+
+  afterEach(async () => {
+    await deleteFile(testDir);
+  });
+
+  describe('validateSignature', () => {
+    it('should validate correct signature', async () => {
+      const config = {
+        name: 'vibefast',
+        version: '1.0.0',
+        targets: ['native', 'web'],
+      };
+      await writeFileContent(signaturePath, JSON.stringify(config));
+
+      const result = await validateSignature(signaturePath);
+      expect(result.name).toBe('vibefast');
+      expect(result.version).toBe('1.0.0');
+      expect(result.targets).toEqual(['native', 'web']);
+    });
+
+    it('should throw if file missing', async () => {
+      await expect(validateSignature(signaturePath)).rejects.toThrow('Not a VibeFast repo');
+    });
+
+    it('should throw if name is wrong', async () => {
+      const config = { name: 'wrong', version: '1.0.0', targets: ['native'] };
+      await writeFileContent(signaturePath, JSON.stringify(config));
+
+      await expect(validateSignature(signaturePath)).rejects.toThrow('Invalid starter name');
+    });
+
+    it('should throw if targets empty', async () => {
+      const config = { name: 'vibefast', version: '1.0.0', targets: [] };
+      await writeFileContent(signaturePath, JSON.stringify(config));
+
+      await expect(validateSignature(signaturePath)).rejects.toThrow('targets must be a non-empty array');
+    });
+  });
+
+  describe('validateTarget', () => {
+    it('should accept valid target', () => {
+      expect(() => validateTarget('native', ['native', 'web'])).not.toThrow();
+    });
+
+    it('should reject invalid target', () => {
+      expect(() => validateTarget('invalid', ['native', 'web'])).toThrow('Invalid target');
+    });
+  });
+});

package/src/core/archive.ts

@@ -0,0 +1,69 @@
+import yauzl from 'yauzl';
+import { ensureDir, deleteFile } from './fsx.js';
+import { dirname, resolve } from 'path';
+import { pipeline } from 'stream/promises';
+import { createWriteStream } from 'fs';
+import { ensureWithinBase } from './pathGuard.js';
+
+function isSymlink(entry: yauzl.Entry): boolean {
+  // Upper 4 bits of external attributes encode the file type on Unix
+  const fileType = (entry.externalFileAttributes >>> 28) & 0xf;
+  return fileType === 0xa;
+}
+
+export async function extractZipSafe(zipPath: string, destinationDir: string): Promise<void> {
+  const destRoot = resolve(destinationDir);
+  await deleteFile(destRoot);
+  await ensureDir(destRoot);
+
+  await new Promise<void>((resolvePromise, rejectPromise) => {
+    yauzl.open(zipPath, { lazyEntries: true }, (openErr, zipfile) => {
+      if (openErr || !zipfile) {
+        rejectPromise(openErr || new Error('Unable to read zip archive'));
+        return;
+      }
+
+      const bail = (err: Error) => {
+        zipfile.close();
+        rejectPromise(err);
+      };
+
+      zipfile.readEntry();
+
+      zipfile.on('entry', (entry: yauzl.Entry) => {
+        const normalizedName = entry.fileName.replace(/\\/g, '/');
+        const targetPath = ensureWithinBase(destRoot, resolve(destRoot, normalizedName), `Archive entry ${entry.fileName}`);
+
+        if (/\/$/.test(normalizedName)) {
+          ensureDir(targetPath)
+            .then(() => zipfile.readEntry())
+            .catch(bail);
+          return;
+        }
+
+        if (isSymlink(entry)) {
+          bail(new Error(`Archive entry ${entry.fileName} is a symlink, which is not supported`));
+          return;
+        }
+
+        zipfile.openReadStream(entry, (streamErr, readStream) => {
+          if (streamErr || !readStream) {
+            bail(streamErr || new Error(`Failed to read ${entry.fileName}`));
+            return;
+          }
+
+          ensureDir(dirname(targetPath))
+            .then(() => pipeline(readStream, createWriteStream(targetPath)))
+            .then(() => zipfile.readEntry())
+            .catch(bail);
+        });
+      });
+
+      zipfile.on('end', () => {
+        zipfile.close();
+        resolvePromise();
+      });
+      zipfile.on('error', bail);
+    });
+  });
+}

package/src/core/auth.ts

@@ -0,0 +1,103 @@
+import { readFileContent, writeFileContent, ensureDir, exists } from './fsx.js';
+import { getConfigPath } from './paths.js';
+import { randomUUID } from 'crypto';
+import { hostname, userInfo, platform, arch } from 'os';
+import { dirname } from 'path';
+
+export interface AuthConfig {
+  token?: string;
+  deviceId?: string;
+}
+
+export interface DeviceInfo {
+  id: string;
+  os: string;
+  arch: string;
+  version: string;
+}
+
+export async function saveToken(token: string): Promise<void> {
+  const configPath = getConfigPath();
+  await ensureDir(dirname(configPath));
+  
+  let config: AuthConfig = {};
+  if (await exists(configPath)) {
+    const content = await readFileContent(configPath);
+    config = JSON.parse(content);
+  }
+  
+  config.token = token;
+  
+  // Generate device ID if not exists
+  if (!config.deviceId) {
+    config.deviceId = generateDeviceId();
+  }
+  
+  await writeFileContent(configPath, JSON.stringify(config, null, 2), { force: true });
+}
+
+export async function getToken(): Promise<string | null> {
+  const configPath = getConfigPath();
+  if (!(await exists(configPath))) {
+    return null;
+  }
+  
+  const content = await readFileContent(configPath);
+  const config: AuthConfig = JSON.parse(content);
+  return config.token || null;
+}
+
+export async function clearToken(): Promise<void> {
+  const configPath = getConfigPath();
+  if (await exists(configPath)) {
+    const content = await readFileContent(configPath);
+    const config: AuthConfig = JSON.parse(content);
+    delete config.token;
+    await writeFileContent(configPath, JSON.stringify(config, null, 2), { force: true });
+  }
+}
+
+export async function getDeviceInfo(): Promise<DeviceInfo> {
+  const configPath = getConfigPath();
+  let deviceId: string;
+  
+  if (await exists(configPath)) {
+    const content = await readFileContent(configPath);
+    const config: AuthConfig = JSON.parse(content);
+    deviceId = config.deviceId || generateDeviceId();
+    
+    if (!config.deviceId) {
+      config.deviceId = deviceId;
+      await writeFileContent(configPath, JSON.stringify(config, null, 2), { force: true });
+    }
+  } else {
+    deviceId = generateDeviceId();
+    await ensureDir(dirname(configPath));
+    await writeFileContent(
+      configPath,
+      JSON.stringify({ deviceId }, null, 2),
+      { force: true }
+    );
+  }
+  
+  return {
+    id: deviceId,
+    os: platform(),
+    arch: arch(),
+    version: '0.1.0',
+  };
+}
+
+function generateDeviceId(): string {
+  try {
+    const user = userInfo().username;
+    const host = hostname();
+    const os = platform();
+    const uuid = randomUUID();
+    
+    // Create a stable but unique device ID
+    return `${user}-${host}-${os}-${uuid}`.slice(0, 64);
+  } catch {
+    return randomUUID();
+  }
+}