@fmode/studio 0.0.3 → 0.0.6

package/bin/fmode.js

@@ -1,350 +1,22 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 /**
  * Fmode Studio CLI Entry Point
  * npm/npx compatible entry point
  *
- * Features:
- *   - Version checking against repos.fmode.cn
- *   - Automatic binary download and caching
- *   - Update command for manual updates
- *   - Fallback to Node.js/Bun execution
+ * This is a thin router that delegates to the modular CLI structure.
+ * All command logic is now in cli/ subdirectories.
  *
  * Usage:
  *   npx @fmode/studio
- *   npx @fmode/studio -y
- *   npx @fmode/studio update
- *   fmode
+ *   npx @fmode/studio start
+ *   npx @fmode/studio server start
  */
 
-import { spawn } from 'child_process';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-import { existsSync, mkdirSync, chmodSync, renameSync } from 'fs';
-import { createReadStream, createWriteStream } from 'fs';
-import { pipeline } from 'stream/promises';
-import { unlink, readFile } from 'fs/promises';
+import { runCli } from '../cli/index.ts';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const rootDir = dirname(__dirname);
-
-// Configuration
-const REPOS_BASE_URL = 'https://repos.fmode.cn/x/fmode-studio';
-const MANIFEST_URL = `${REPOS_BASE_URL}/manifest.json`;
-const CACHE_DIR = join(rootDir, '.cache', 'binaries');
-
-// Platform detection
-const platform = process.platform;
-const arch = process.arch;
-
-// Map platform/arch to executable name
-function getExecutableName() {
-  const ext = platform === 'win32' ? '.exe' : '';
-
-  if (platform === 'win32' && arch === 'x64') {
-    return `fmode-win-x64${ext}`;
-  } else if (platform === 'win32' && arch === 'arm64') {
-    return `fmode-win-arm64${ext}`;
-  } else if (platform === 'linux' && arch === 'x64') {
-    return 'fmode-linux-x64';
-  } else if (platform === 'linux' && arch === 'arm64') {
-    return 'fmode-linux-arm64';
-  } else if (platform === 'darwin' && arch === 'x64') {
-    return 'fmode-macos-x64';
-  } else if (platform === 'darwin' && arch === 'arm64') {
-    return 'fmode-macos-arm64';
-  } else {
-    throw new Error(`Unsupported platform: ${platform} ${arch}`);
-  }
-}
-
-// Get local package version
-async function getLocalVersion() {
-  const packageJson = join(rootDir, 'package.json');
-  try {
-    const content = await readFile(packageJson, 'utf-8');
-    const pkg = JSON.parse(content);
-    return pkg.version;
-  } catch {
-    return null;
-  }
-}
-
-// Fetch remote manifest from repos.fmode.cn
-async function fetchRemoteManifest() {
-  try {
-    const response = await fetch(MANIFEST_URL);
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}`);
-    }
-    return await response.json();
-  } catch (error) {
-    console.warn(`Warning: Could not fetch remote manifest: ${error.message}`);
-    return null;
-  }
-}
-
-// Compare versions (returns positive if a > b, negative if a < b, 0 if equal)
-function compareVersions(a, b) {
-  const partsA = a.split('.').map(Number);
-  const partsB = b.split('.').map(Number);
-
-  for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
-    const partA = partsA[i] || 0;
-    const partB = partsB[i] || 0;
-    if (partA !== partB) {
-      return partA - partB;
-    }
-  }
-  return 0;
-}
-
-// Download binary from repos.fmode.cn
-async function downloadBinary(version, executableName) {
-  const url = `${REPOS_BASE_URL}/${version}/${executableName}`;
-  const tempPath = join(CACHE_DIR, `${executableName}.tmp`);
-  const finalPath = join(CACHE_DIR, executableName);
-
-  console.log(`Downloading ${url}...`);
-
-  try {
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}`);
-    }
-
-    // Ensure cache directory exists
-    if (!existsSync(CACHE_DIR)) {
-      mkdirSync(CACHE_DIR, { recursive: true });
-    }
-
-    // Download to temp file
-    const fileStream = createWriteStream(tempPath);
-    await pipeline(response.body, fileStream);
-
-    // Make executable (Unix-like systems)
-    if (platform !== 'win32') {
-      chmodSync(tempPath, 0o755);
-    }
-
-    // Move to final path
-    if (existsSync(finalPath)) {
-      await unlink(finalPath);
-    }
-    renameSync(tempPath, finalPath);
-
-    console.log(`Downloaded to ${finalPath}`);
-    return finalPath;
-  } catch (error) {
-    // Clean up temp file on error
-    if (existsSync(tempPath)) {
-      await unlink(tempPath).catch(() => {});
-    }
-    throw error;
-  }
-}
-
-// Check for updates
-async function checkForUpdates() {
-  const localVersion = await getLocalVersion();
-  const manifest = await fetchRemoteManifest();
-
-  if (!manifest || !manifest.version) {
-    console.log('Could not check for updates.');
-    return null;
-  }
-
-  if (!localVersion) {
-    console.log(`Remote version: ${manifest.version}`);
-    console.log('Local version: unknown');
-    return manifest.version;
-  }
-
-  const comparison = compareVersions(manifest.version, localVersion);
-
-  if (comparison > 0) {
-    console.log(`Update available: ${localVersion} -> ${manifest.version}`);
-    return manifest.version;
-  } else if (comparison === 0) {
-    console.log(`Already up to date: ${localVersion}`);
-    return null;
-  } else {
-    console.log(`Local version is newer: ${localVersion} > ${manifest.version}`);
-    return null;
-  }
-}
-
-// Run the executable
-async function runExecutable(executablePath, args) {
-  const child = spawn(executablePath, args, {
-    stdio: 'inherit',
-    env: { ...process.env }
-  });
-
-  return new Promise((resolve, reject) => {
-    child.on('exit', (code) => {
-      resolve(code ?? 0);
-      process.exit(code ?? 0);
-    });
-
-    child.on('error', (err) => {
-      reject(err);
-    });
-  });
-}
-
-// Main execution
-async function main() {
-  const args = process.argv.slice(2);
-
-  // Handle -y flag (auto-confirm, no-op in our case)
-  const yesIndex = args.indexOf('-y');
-  if (yesIndex !== -1) {
-    args.splice(yesIndex, 1);
-  }
-
-  // Handle update command
-  if (args[0] === 'update') {
-    console.log('Checking for updates...');
-    const newVersion = await checkForUpdates();
-
-    if (newVersion) {
-      const executableName = getExecutableName();
-      console.log(`\nDownloading version ${newVersion}...`);
-      try {
-        await downloadBinary(newVersion, executableName);
-        console.log('\n✓ Update complete!');
-      } catch (error) {
-        console.error(`\n✗ Download failed: ${error.message}`);
-        process.exit(1);
-      }
-    }
-    process.exit(0);
-  }
-
-  // Handle --version flag
-  if (args.includes('--version') || args.includes('-v')) {
-    const localVersion = await getLocalVersion();
-    if (localVersion) {
-      console.log(`@fmode/studio v${localVersion}`);
-    } else {
-      console.log('@fmode/studio (version unknown)');
-    }
-    process.exit(0);
-  }
-
-  // Handle --help flag
-  if (args.includes('--help') || (args.includes('-h') && !args.includes('--host'))) {
-    console.log(`
-Fmode Code UI Server
-
-USAGE:
-  fmode [OPTIONS]
-  npx @fmode/studio [OPTIONS]
-  fmode update              Check and install updates
-
-OPTIONS:
-  -p, --port <PORT>         Set the server port (default: 6666)
-  -h, --host <HOST>         Set the server host (default: 0.0.0.0)
-      --help                Show this help message
-      --version, -v         Show version information
-  -y                        Auto-confirm (no-op, for compatibility)
-  update                    Check and install updates
-
-ENVIRONMENT VARIABLES:
-  PORT                      Server port (default: 6666)
-  HOST                      Server host (default: 0.0.0.0)
-  VITE_IS_PLATFORM          Set to 'true' for platform mode
-
-EXAMPLES:
-  fmode                           # Start with default settings
-  fmode --port 8080               # Start on port 8080
-  npx @fmode/studio -y            # Start with npx (auto-confirm)
-  npx @fmode/studio --port 3000   # Start on port 3000
-  fmode update                    # Check for updates
-
-UPDATE MECHANISM:
-  The CLI automatically downloads the latest binary from repos.fmode.cn
-  and caches it locally. Use 'fmode update' to manually check for updates.
-`);
-    process.exit(0);
-  }
-
-  const executableName = getExecutableName();
-  let executablePath = null;
-
-  // Priority 1: Try cached binary (most recent download)
-  const cachedPath = join(CACHE_DIR, executableName);
-  if (existsSync(cachedPath)) {
-    executablePath = cachedPath;
-    console.log(`Using cached binary: ${cachedPath}`);
-  }
-
-  // Priority 2: Try bundled binary (shipped with npm package)
-  if (!executablePath) {
-    const bundledPath = join(rootDir, 'dist', 'bin', executableName);
-    if (existsSync(bundledPath)) {
-      executablePath = bundledPath;
-    }
-  }
-
-  // Priority 3: Download from repos.fmode.cn
-  if (!executablePath) {
-    console.log('No local binary found. Downloading...');
-    try {
-      const manifest = await fetchRemoteManifest();
-      if (manifest && manifest.version) {
-        executablePath = await downloadBinary(manifest.version, executableName);
-      }
-    } catch (error) {
-      console.warn(`Could not download binary: ${error.message}`);
-    }
-  }
-
-  // If we have an executable, run it
-  if (executablePath) {
-    try {
-      await runExecutable(executablePath, args);
-      return;
-    } catch (err) {
-      console.error('Failed to start native executable:', err.message);
-      // Fall through to Node.js/Bun fallback
-    }
-  }
-
-  // Priority 4: Fallback to Node.js/Bun
-  fallbackToNode(args);
-}
-
-function fallbackToNode(args) {
-  const cliPath = join(rootDir, 'cli.ts');
-
-  if (existsSync(cliPath)) {
-    console.log('Running with bun...');
-    const child = spawn('bun', [cliPath, ...args], {
-      stdio: 'inherit',
-      env: { ...process.env }
-    });
-
-    child.on('exit', (code) => {
-      process.exit(code ?? 0);
-    });
-
-    child.on('error', (err) => {
-      console.error('Failed to start with bun:', err.message);
-      console.error('Please install bun: https://bun.sh');
-      process.exit(1);
-    });
-  } else {
-    console.error(`Error: Fmode Studio not found for platform ${platform} ${arch}`);
-    console.error('Please reinstall the package or report this issue.');
-    process.exit(1);
-  }
-}
-
-// Run main function
-main().catch((error) => {
+// Run the CLI
+runCli().catch((error) => {
   console.error('Fatal error:', error);
   process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fmode/studio",
-  "version": "0.0.3",
+  "version": "0.0.6",
   "description": "AI PaaS IDE for Vibe Coding - Cross-platform CLI tool",
   "license": "ISC",
   "author": "Fmode Studio Team",