ppcos 0.3.0

package/lib/commands/update.js

@@ -0,0 +1,480 @@
+/**
+ * update command - Update base skills in all clients
+ *
+ * Usage: ppcos update [--client <name>] [--dry-run]
+ */
+
+import { readFileSync, existsSync, readdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createInterface } from 'node:readline';
+import {
+  readManifest,
+  writeManifest,
+  detectModifications,
+  addConflict,
+  manifestExists,
+  getManagedType,
+  isConfigFile
+} from '../utils/manifest.js';
+import { calculateChecksum } from '../utils/checksum.js';
+import {
+  getAllFiles,
+  copyFileWithDirs,
+  ensureDir,
+  createBackupTimestamp
+} from '../utils/fs-helpers.js';
+import { fetchSkills } from '../utils/skills-fetcher.js';
+import { requireAuth } from '../utils/auth.js';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import logger from '../utils/logger.js';
+import ora from 'ora';
+
+// Get package root directory
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PACKAGE_ROOT = join(__dirname, '..', '..');
+
+/**
+ * Get package version from package.json
+ * @returns {string}
+ */
+function getPackageVersion() {
+  const pkgPath = join(PACKAGE_ROOT, 'package.json');
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+  return pkg.version;
+}
+
+/**
+ * Get path to .claude-base template directory
+ * @returns {string}
+ */
+function getBaseTemplatePath() {
+  return join(PACKAGE_ROOT, '.claude-base');
+}
+
+/**
+ * Get clients directory path
+ * @returns {string}
+ */
+function getClientsDir() {
+  return join(process.cwd(), 'clients');
+}
+
+/**
+ * Ensure memory folder exists in client workspace
+ * Creates context/memory/ if it doesn't exist (for existing clients)
+ * @param {string} clientDir - Path to client directory
+ */
+async function ensureMemoryFolder(clientDir) {
+  const memoryDir = join(clientDir, 'context', 'memory');
+  if (!existsSync(memoryDir)) {
+    await ensureDir(memoryDir);
+    logger.info('  Created context/memory/ folder');
+  }
+}
+
+/**
+ * Find all client directories with .managed.json
+ * @returns {string[]} Array of client names
+ */
+function discoverClients() {
+  const clientsDir = getClientsDir();
+
+  if (!existsSync(clientsDir)) {
+    return [];
+  }
+
+  const entries = readdirSync(clientsDir, { withFileTypes: true });
+  const clients = [];
+
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const clientDir = join(clientsDir, entry.name);
+      if (manifestExists(clientDir)) {
+        clients.push(entry.name);
+      }
+    }
+  }
+
+  return clients;
+}
+
+/**
+ * Prompt user for conflict resolution
+ * @param {string[]} modifiedFiles - List of modified file paths
+ * @returns {Promise<'backup'|'skip'|'cancel'>}
+ */
+async function promptConflictResolution(modifiedFiles) {
+  console.log('');
+  logger.warn('Modified files detected:');
+  for (const file of modifiedFiles) {
+    console.log(`  - ${file}`);
+  }
+
+  console.log('');
+  console.log('Options:');
+  console.log('  [1] Backup and overwrite (files saved to .backup/)');
+  console.log('  [2] Skip modified files (keep your changes)');
+  console.log('  [3] Cancel update');
+  console.log('');
+
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    const ask = () => {
+      rl.question('Choice [1/2/3]: ', (answer) => {
+        const choice = answer.trim();
+        if (choice === '1') {
+          rl.close();
+          resolve('backup');
+        } else if (choice === '2') {
+          rl.close();
+          resolve('skip');
+        } else if (choice === '3') {
+          rl.close();
+          resolve('cancel');
+        } else {
+          console.log('Invalid choice. Please enter 1, 2, or 3.');
+          ask();
+        }
+      });
+    };
+    ask();
+  });
+}
+
+/**
+ * Backup modified files to .backup/<timestamp>/
+ * @param {string} clientDir - Path to client directory
+ * @param {string[]} files - Relative paths of files to backup
+ * @returns {Promise<string>} Backup folder path
+ */
+async function backupFiles(clientDir, files) {
+  const timestamp = createBackupTimestamp();
+  const backupDir = join(clientDir, '.backup', timestamp);
+
+  for (const relativePath of files) {
+    const srcPath = join(clientDir, relativePath);
+    const destPath = join(backupDir, relativePath);
+    await copyFileWithDirs(srcPath, destPath);
+  }
+
+  // Write backup manifest
+  const manifestContent = [
+    `# Backup created during update`,
+    `# ${new Date().toISOString()}`,
+    '',
+    ...files
+  ].join('\n');
+  await ensureDir(backupDir);
+  const { writeFile } = await import('node:fs/promises');
+  await writeFile(join(backupDir, 'manifest.txt'), manifestContent);
+
+  return backupDir;
+}
+
+/**
+ * Update a single client
+ * @param {string} clientName - Client name
+ * @param {string|object} basePathOrOptions - Path to template files (temp dir or local), or options object for backward compat
+ * @param {object} options - Command options
+ * @param {boolean} options.dryRun - Dry run mode
+ * @returns {Promise<{status: 'updated'|'up-to-date'|'skipped'|'cancelled', details?: object}>}
+ */
+async function updateClient(clientName, basePathOrOptions = {}, options = {}) {
+  // Backward compatibility: if second arg is object, it's options (old signature)
+  let basePath;
+  if (typeof basePathOrOptions === 'string') {
+    basePath = basePathOrOptions;
+  } else {
+    options = basePathOrOptions;
+    basePath = getBaseTemplatePath();
+  }
+
+  const clientsDir = getClientsDir();
+  const clientDir = join(clientsDir, clientName);
+  const packageVersion = getPackageVersion();
+
+  // Read manifest
+  const manifest = await readManifest(clientDir);
+  const currentVersion = manifest.baseVersion;
+
+  // Auto-create memory folder for existing clients (migration)
+  await ensureMemoryFolder(clientDir);
+
+  // Check if already up to date
+  if (currentVersion === packageVersion) {
+    return { status: 'up-to-date' };
+  }
+
+  // Get base template files
+  const baseFiles = await getAllFiles(basePath);
+
+  // Detect modifications
+  const mods = await detectModifications(clientDir, manifest, baseFiles);
+
+  // Dry run output
+  if (options.dryRun) {
+    return {
+      status: 'skipped',
+      details: {
+        fromVersion: currentVersion,
+        toVersion: packageVersion,
+        unchanged: mods.unchanged.length,
+        modified: mods.modified,
+        missing: mods.missing,
+        newInBase: mods.newInBase
+      }
+    };
+  }
+
+  // Handle modified files
+  let resolution = null;
+  let backedUpFiles = [];
+
+  if (mods.modified.length > 0) {
+    console.log(`Updating ${clientName} (v${currentVersion} → v${packageVersion})`);
+    resolution = await promptConflictResolution(mods.modified);
+
+    if (resolution === 'cancel') {
+      return { status: 'cancelled' };
+    }
+
+    if (resolution === 'backup') {
+      const backupDir = await backupFiles(clientDir, mods.modified);
+      backedUpFiles = mods.modified;
+      console.log(`  Backed up ${mods.modified.length} modified files to ${backupDir.replace(clientDir + '/', '')}`);
+    }
+  }
+
+  // Determine which files to update
+  const filesToUpdate = [];
+  const filesToSkip = [];
+
+  for (const file of baseFiles) {
+    // Skip config files entirely (they're never updated)
+    if (isConfigFile(file)) {
+      continue;
+    }
+
+    if (mods.modified.includes(file) && resolution === 'skip') {
+      filesToSkip.push(file);
+    } else {
+      filesToUpdate.push(file);
+    }
+  }
+
+  // Apply updates
+  const updatedFiles = {};
+
+  for (const relativePath of filesToUpdate) {
+    const srcPath = join(basePath, relativePath);
+    const destPath = join(clientDir, relativePath);
+
+    await copyFileWithDirs(srcPath, destPath);
+
+    const checksum = await calculateChecksum(destPath);
+
+    // Preserve managedType from existing manifest or determine new
+    const existingEntry = manifest.managedFiles[relativePath];
+    const managedType = existingEntry?.managedType || getManagedType(relativePath);
+
+    updatedFiles[relativePath] = {
+      checksum,
+      version: packageVersion,
+      managedType
+    };
+  }
+
+  // Update manifest
+  manifest.baseVersion = packageVersion;
+  manifest.lastUpdated = new Date().toISOString();
+
+  // Update file entries
+  for (const [path, info] of Object.entries(updatedFiles)) {
+    manifest.managedFiles[path] = info;
+  }
+
+  // Record skipped files as conflicts
+  for (const file of filesToSkip) {
+    addConflict(manifest, file, 'User modified - skipped during update', packageVersion);
+  }
+
+  await writeManifest(clientDir, manifest);
+
+  return {
+    status: 'updated',
+    details: {
+      fromVersion: currentVersion,
+      toVersion: packageVersion,
+      updatedCount: filesToUpdate.length,
+      skippedCount: filesToSkip.length,
+      backedUpCount: backedUpFiles.length
+    }
+  };
+}
+
+/**
+ * Main update command handler
+ * @param {object} options - Command options
+ * @param {string} [options.client] - Update only this client
+ * @param {boolean} [options.dryRun] - Show changes without applying
+ */
+export default async function update(options = {}) {
+  const packageVersion = getPackageVersion();
+
+  // Download latest skills from API to temp directory
+  const spinner = ora('Downloading latest skills from API...').start();
+  const tempDir = mkdtempSync(join(tmpdir(), 'ppcos-update-'));
+
+  let basePath;
+  try {
+    await fetchSkills(tempDir);
+    basePath = tempDir;
+    spinner.succeed('Skills downloaded');
+  } catch (error) {
+    spinner.fail('Failed to download skills');
+    logger.error(error.message);
+    logger.info('Falling back to local template if available...');
+
+    // Fallback to local template during migration period
+    basePath = getBaseTemplatePath();
+    if (!existsSync(basePath)) {
+      logger.error('No local template available. Cannot update.');
+      process.exitCode = 1;
+      rmSync(tempDir, { recursive: true, force: true });
+      return;
+    }
+  }
+
+  // Discover clients
+  let clients = discoverClients();
+
+  if (clients.length === 0) {
+    logger.info('No clients found.');
+    console.log('');
+    console.log('To create a client:');
+    console.log('  ppcos init <client-name>');
+    console.log('');
+    console.log('Or create main-config.json and run:');
+    console.log('  ppcos init-all');
+    return;
+  }
+
+  // Filter to specific client if requested
+  if (options.client) {
+    if (!clients.includes(options.client)) {
+      logger.error(`Client "${options.client}" not found.`);
+      process.exitCode = 1;
+      return;
+    }
+    clients = [options.client];
+  }
+
+  // Dry run header
+  if (options.dryRun) {
+    console.log('Dry run - no changes will be made');
+    console.log('');
+  }
+
+  // Process each client
+  const results = {
+    updated: 0,
+    upToDate: 0,
+    skipped: 0,
+    cancelled: 0
+  };
+
+  for (const clientName of clients) {
+    try {
+      const result = await updateClient(clientName, basePath, options);
+
+      if (options.dryRun && result.details) {
+        // Dry run output
+        const d = result.details;
+        console.log(`${clientName} (v${d.fromVersion} → v${d.toVersion}):`);
+
+        const updateCount = d.unchanged + d.missing.length + d.newInBase.length;
+        console.log(`  Update: ${updateCount} files`);
+
+        if (d.modified.length > 0) {
+          console.log(`  Modified (would prompt): ${d.modified.length} files`);
+          for (const file of d.modified) {
+            console.log(`    - ${file}`);
+          }
+        }
+
+        if (d.newInBase.length > 0) {
+          console.log(`  New: ${d.newInBase.length} files`);
+          for (const file of d.newInBase) {
+            console.log(`    - ${file}`);
+          }
+        }
+
+        console.log('');
+        results.skipped++;
+      } else if (result.status === 'up-to-date') {
+        if (!options.dryRun) {
+          console.log(`Updating ${clientName}...`);
+          console.log('  Already up to date');
+          console.log('');
+        } else {
+          console.log(`${clientName} (v${packageVersion}):`);
+          console.log('  Already up to date');
+          console.log('');
+        }
+        results.upToDate++;
+      } else if (result.status === 'updated') {
+        const d = result.details;
+        console.log(`  Updated ${d.updatedCount} files`);
+        if (d.skippedCount > 0) {
+          console.log(`  Skipped ${d.skippedCount} modified files`);
+        }
+        logger.success('Complete');
+        console.log('');
+        results.updated++;
+      } else if (result.status === 'cancelled') {
+        console.log('  Update cancelled');
+        console.log('');
+        results.cancelled++;
+      }
+    } catch (err) {
+      logger.error(`Failed to update ${clientName}: ${err.message}`);
+      results.skipped++;
+    }
+  }
+
+  // Summary (only for non-dry-run with multiple clients)
+  if (!options.dryRun && clients.length > 1) {
+    console.log('Summary:');
+    if (results.updated > 0) {
+      console.log(`  Updated: ${results.updated} client${results.updated !== 1 ? 's' : ''}`);
+    }
+    if (results.upToDate > 0) {
+      console.log(`  Up to date: ${results.upToDate} client${results.upToDate !== 1 ? 's' : ''}`);
+    }
+    if (results.cancelled > 0) {
+      console.log(`  Cancelled: ${results.cancelled} client${results.cancelled !== 1 ? 's' : ''}`);
+    }
+  }
+
+  // Clean up temp directory
+  if (tempDir && tempDir.includes('ppcos-update-')) {
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+// Export helpers for testing
+export {
+  getPackageVersion,
+  getBaseTemplatePath,
+  getClientsDir,
+  discoverClients,
+  backupFiles,
+  updateClient
+};

package/lib/commands/whoami.js

@@ -0,0 +1,42 @@
+import logger from '../utils/logger.js';
+import { readAuth } from '../utils/auth.js';
+import chalk from 'chalk';
+
+/**
+ * Show current authentication status
+ */
+export async function whoami() {
+  const auth = readAuth();
+
+  if (!auth?.sessionToken) {
+    logger.info('Not logged in');
+    logger.info('Run: ppcos login');
+    return;
+  }
+
+  const expiresAt = new Date(auth.expiresAt);
+  const now = new Date();
+  const isExpired = expiresAt < now;
+
+  console.log();
+  console.log(chalk.bold('Authentication Status'));
+  console.log(chalk.gray('─'.repeat(50)));
+  console.log(`${chalk.bold('Email:')} ${auth.email}`);
+  console.log(`${chalk.bold('Status:')} ${isExpired ? chalk.red('Expired') : chalk.green('Active')}`);
+  console.log(`${chalk.bold('Expires:')} ${expiresAt.toLocaleString()}`);
+
+  if (isExpired) {
+    console.log();
+    console.log(chalk.yellow('Session expired. Run: ppcos login'));
+  } else {
+    const hoursLeft = Math.floor((expiresAt - now) / (1000 * 60 * 60));
+    const minutesLeft = Math.floor(((expiresAt - now) % (1000 * 60 * 60)) / (1000 * 60));
+
+    if (hoursLeft < 2) {
+      console.log();
+      console.log(chalk.yellow(`⚠ Session expires in ${hoursLeft}h ${minutesLeft}m`));
+    }
+  }
+
+  console.log();
+}

package/lib/utils/api-client.js

@@ -0,0 +1,119 @@
+import logger from './logger.js';
+
+// API base URL - can be overridden with PPCOS_API_URL env var
+const API_BASE_URL = process.env.PPCOS_API_URL || 'https://ppcos.vercel.app';
+
+/**
+ * Send verification code to email
+ */
+export async function sendVerificationCode(email) {
+  try {
+    const response = await fetch(`${API_BASE_URL}/api/auth/send-code`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ email })
+    });
+
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.error || 'Failed to send code');
+    }
+
+    return await response.json();
+  } catch (error) {
+    logger.error(`API error: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * Verify OTP code and get session token
+ */
+export async function verifyCode(email, code, token) {
+  try {
+    const response = await fetch(`${API_BASE_URL}/api/auth/verify-code`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ email, code, token })
+    });
+
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.error || 'Verification failed');
+    }
+
+    return await response.json();
+  } catch (error) {
+    logger.error(`API error: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * Validate current session
+ */
+export async function validateSession(sessionToken) {
+  try {
+    const response = await fetch(`${API_BASE_URL}/api/auth/validate`, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${sessionToken}`
+      }
+    });
+
+    if (!response.ok) {
+      return false;
+    }
+
+    const data = await response.json();
+    return data.valid;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Get skills version info
+ */
+export async function getSkillsVersion(sessionToken) {
+  try {
+    const response = await fetch(`${API_BASE_URL}/api/skills/version`, {
+      headers: {
+        'Authorization': `Bearer ${sessionToken}`
+      }
+    });
+
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.error || 'Failed to get version');
+    }
+
+    return await response.json();
+  } catch (error) {
+    logger.error(`API error: ${error.message}`);
+    throw error;
+  }
+}
+
+/**
+ * Download skills as stream
+ */
+export async function downloadSkills(sessionToken) {
+  try {
+    const response = await fetch(`${API_BASE_URL}/api/skills`, {
+      headers: {
+        'Authorization': `Bearer ${sessionToken}`
+      }
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: 'Download failed' }));
+      throw new Error(error.error || 'Failed to download skills');
+    }
+
+    return response.body;
+  } catch (error) {
+    logger.error(`API error: ${error.message}`);
+    throw error;
+  }
+}