@fmode/studio 0.0.2 → 0.0.5

package/bin/fmode.js

@@ -7,23 +7,28 @@
  * Features:
  *   - Version checking against repos.fmode.cn
  *   - Automatic binary download and caching
- *   - Update command for manual updates
- *   - Fallback to Node.js/Bun execution
+ *   - Process management (start/stop)
+ *   - Cache clearing
+ *   - Smart upgrade with version detection
  *
  * Usage:
  *   npx @fmode/studio
- *   npx @fmode/studio -y
- *   npx @fmode/studio update
- *   fmode
+ *   npx @fmode/studio start
+ *   npx @fmode/studio stop
+ *   npx @fmode/studio clear
+ *   npx @fmode/studio upgrade
  */
 
-import { spawn } from 'child_process';
+import { spawn, exec } from 'child_process';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
-import { existsSync, mkdirSync, chmodSync, renameSync } from 'fs';
+import { existsSync, mkdirSync, chmodSync, renameSync, rmSync } from 'fs';
 import { createReadStream, createWriteStream } from 'fs';
 import { pipeline } from 'stream/promises';
-import { unlink, readFile } from 'fs/promises';
+import { unlink, readFile, writeFile, readdir } from 'fs/promises';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -33,6 +38,10 @@ const rootDir = dirname(__dirname);
 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');
+const PID_DIR = join(rootDir, '.cache', 'pids');
+const PID_FILE = join(PID_DIR, 'fmode.pid');
+const LOG_DIR = join(rootDir, '.cache', 'logs');
+const LOG_FILE = join(LOG_DIR, 'fmode.log');
 
 // Platform detection
 const platform = process.platform;
@@ -145,86 +154,463 @@ async function downloadBinary(version, executableName) {
   }
 }
 
-// Check for updates
-async function checkForUpdates() {
-  const localVersion = await getLocalVersion();
-  const manifest = await fetchRemoteManifest();
+// Get executable path (cached or bundled)
+async function getExecutablePath() {
+  const executableName = getExecutableName();
 
-  if (!manifest || !manifest.version) {
-    console.log('Could not check for updates.');
+  // Priority 1: Try cached binary
+  const cachedPath = join(CACHE_DIR, executableName);
+  if (existsSync(cachedPath)) {
+    return cachedPath;
+  }
+
+  // Priority 2: Try bundled binary
+  const bundledPath = join(rootDir, 'dist', 'bin', executableName);
+  if (existsSync(bundledPath)) {
+    return bundledPath;
+  }
+
+  return null;
+}
+
+// Get current binary version with timeout
+async function getBinaryVersion(executablePath) {
+  return new Promise((resolve) => {
+    let output = '';
+    let timedOut = false;
+
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      child.kill();
+      resolve(null); // Timeout = version unknown
+    }, 3000);
+
+    const child = spawn(executablePath, ['-vvv'], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env }
+    });
+
+    child.stdout.on('data', (data) => {
+      output += data.toString();
+    });
+
+    child.on('exit', (code) => {
+      clearTimeout(timeout);
+      if (timedOut) return;
+
+      // Parse version from output: "@fmode/studio version x.x.x"
+      const match = output.match(/version\s+(\d+\.\d+\.\d+)/);
+      if (match) {
+        resolve(match[1]);
+      } else {
+        resolve(null);
+      }
+    });
+
+    child.on('error', () => {
+      clearTimeout(timeout);
+      resolve(null);
+    });
+  });
+}
+
+// Save PID to file
+function savePid(pid) {
+  if (!existsSync(PID_DIR)) {
+    mkdirSync(PID_DIR, { recursive: true });
+  }
+  writeFile(PID_FILE, String(pid));
+}
+
+// Read PID from file
+async function readPid() {
+  try {
+    const content = await readFile(PID_FILE, 'utf-8');
+    return parseInt(content.trim(), 10);
+  } catch {
     return null;
   }
+}
+
+// Check if process is running
+async function isProcessRunning(pid) {
+  try {
+    if (platform === 'win32') {
+      // Windows: 使用 tasklist 检查进程是否存在
+      const { stdout } = await execAsync(`tasklist /FI "PID eq ${pid}" /FO CSV`);
+      return stdout.includes(String(pid));
+    } else {
+      // Unix: 使用 process.kill(pid, 0) 检查
+      process.kill(pid, 0);
+      return true;
+    }
+  } catch {
+    return false;
+  }
+}
 
-  if (!localVersion) {
-    console.log(`Remote version: ${manifest.version}`);
-    console.log('Local version: unknown');
-    return manifest.version;
+// Kill process by PID
+async function killProcess(pid) {
+  try {
+    if (platform === 'win32') {
+      // Windows: 使用 taskkill 强制终止进程
+      await execAsync(`taskkill /F /PID ${pid}`);
+      return true;
+    } else {
+      // Unix: 使用 process.kill
+      process.kill(pid);
+      return true;
+    }
+  } catch {
+    return false;
   }
+}
 
-  const comparison = compareVersions(manifest.version, localVersion);
+// Find fmode processes
+async function findFmodeProcesses() {
+  try {
+    const command = platform === 'win32'
+      ? 'tasklist /FI "IMAGENAME eq fmode*" /FO CSV'
+      : 'ps aux | grep -E "fmode|fmode-win|fmode-linux|fmode-macos" | grep -v grep';
 
-  if (comparison > 0) {
-    console.log(`Update available: ${localVersion} -> ${manifest.version}`);
-    return manifest.version;
-  } else if (comparison === 0) {
-    console.log(`Already up to date: ${localVersion}`);
+    const { stdout } = await execAsync(command);
+    return stdout;
+  } catch {
+    return '';
+  }
+}
+
+// Find process by port and return PID
+async function findProcessByPort(port) {
+  try {
+    let command;
+    if (platform === 'win32') {
+      // Windows: use netstat to find PID listening on port
+      command = `netstat -ano | findstr :${port} | findstr LISTENING`;
+    } else {
+      // Unix-like: use lsof
+      command = `lsof -ti:${port}`;
+    }
+
+    const { stdout } = await execAsync(command);
+
+    if (platform === 'win32') {
+      // Parse Windows netstat output: format is "protocol local_address foreign_address state pid"
+      // Example: TCP    0.0.0.0:16666    0.0.0.0:0    LISTENING    12345
+      const lines = stdout.trim().split('\n');
+      for (const line of lines) {
+        const parts = line.trim().split(/\s+/);
+        const pid = parseInt(parts[parts.length - 1], 10);
+        if (!isNaN(pid)) {
+          return pid;
+        }
+      }
+    } else {
+      // lsof -ti returns just the PID
+      const pid = parseInt(stdout.trim(), 10);
+      if (!isNaN(pid)) {
+        return pid;
+      }
+    }
     return null;
-  } else {
-    console.log(`Local version is newer: ${localVersion} > ${manifest.version}`);
+  } catch {
     return null;
   }
 }
 
-// Run the executable
-async function runExecutable(executablePath, args) {
-  const child = spawn(executablePath, args, {
+// Get port from args (default 16666)
+function getPortFromArgs(args) {
+  const portIndex = args.indexOf('-p');
+  if (portIndex !== -1 && args[portIndex + 1]) {
+    return parseInt(args[portIndex + 1], 10);
+  }
+  const portIndex2 = args.indexOf('--port');
+  if (portIndex2 !== -1 && args[portIndex2 + 1]) {
+    return parseInt(args[portIndex2 + 1], 10);
+  }
+  return 16666; // default port
+}
+
+// Save PID with port info
+function savePidWithPort(pid, port) {
+  if (!existsSync(PID_DIR)) {
+    mkdirSync(PID_DIR, { recursive: true });
+  }
+  // Save as "pid:port" format
+  writeFile(PID_FILE, `${pid}:${port}`);
+}
+
+// Read PID and port from file
+async function readPidWithPort() {
+  try {
+    const content = await readFile(PID_FILE, 'utf-8');
+    const parts = content.trim().split(':');
+    if (parts.length === 2) {
+      return { pid: parseInt(parts[0], 10), port: parseInt(parts[1], 10) };
+    }
+    return { pid: parseInt(content.trim(), 10), port: null };
+  } catch {
+    return { pid: null, port: null };
+  }
+}
+
+// ============================================================
+// COMMAND: START
+// ============================================================
+/**
+ * 启动 Fmode Studio 服务
+ * 直接启动二进制文件，输出直接显示在终端
+ */
+async function cmdStart(args) {
+  const executablePath = await getExecutablePath();
+
+  // If no executable, download first
+  let finalExecutablePath = executablePath;
+  if (!finalExecutablePath) {
+    console.log('No local binary found. Downloading...');
+    const manifest = await fetchRemoteManifest();
+    if (manifest && manifest.version) {
+      finalExecutablePath = await downloadBinary(manifest.version, getExecutableName());
+    }
+  }
+
+  // 如果仍然没有可执行文件，退出
+  if (!finalExecutablePath) {
+    console.error('No executable found and could not download. Please run "fmode upgrade" first.');
+    process.exit(1);
+  }
+
+  // 直接启动二进制文件，不使用 detached，让输出直接显示在终端
+  spawn(finalExecutablePath, args, {
     stdio: 'inherit',
-    env: { ...process.env }
+    env: {
+      ...process.env,
+      FORCE_COLOR: process.env.FORCE_COLOR || '1',
+      TERM: process.env.TERM || 'xterm-256color'
+    }
+  }).on('exit', (code) => {
+    process.exit(code ?? 0);
   });
+}
 
-  return new Promise((resolve, reject) => {
-    child.on('exit', (code) => {
-      resolve(code ?? 0);
-      process.exit(code ?? 0);
+// ============================================================
+// COMMAND: STOP
+// ============================================================
+async function cmdStop(args) {
+  const port = getPortFromArgs(args);
+  const { pid: savedPid, port: savedPort } = await readPidWithPort();
+
+  // First try to find process by port
+  const portPid = await findProcessByPort(port);
+
+  if (portPid && await isProcessRunning(portPid)) {
+    console.log(`Stopping Fmode Studio on port ${port} (PID: ${portPid})...`);
+    if (await killProcess(portPid)) {
+      console.log('Fmode Studio stopped.');
+      await unlink(PID_FILE).catch(() => {});
+      return;
+    } else {
+      console.error('Failed to stop Fmode Studio.');
+      process.exit(1);
+    }
+  }
+
+  // If no process found on port, check saved PID
+  if (savedPid && await isProcessRunning(savedPid)) {
+    console.log(`Stopping Fmode Studio (PID: ${savedPid})...`);
+    if (await killProcess(savedPid)) {
+      console.log('Fmode Studio stopped.');
+      await unlink(PID_FILE).catch(() => {});
+      return;
+    } else {
+      console.error('Failed to stop Fmode Studio.');
+      process.exit(1);
+    }
+  }
+
+  // Clean up stale PID file
+  if (savedPid || portPid) {
+    console.log('Process not running. Cleaning up PID file...');
+    await unlink(PID_FILE).catch(() => {});
+  }
+
+  // Try to find any fmode processes
+  console.log(`No process found on port ${port}. Searching for Fmode processes...`);
+  const processes = await findFmodeProcesses();
+
+  if (processes.trim()) {
+    console.log('\nFound Fmode processes:');
+    console.log(processes);
+    console.log('\nPlease manually kill the process or use:');
+    console.log(platform === 'win32' ? '  taskkill /F /PID <pid>' : '  kill -9 <pid>');
+  } else {
+    console.log('No Fmode Studio process found running.');
+  }
+}
+
+// ============================================================
+// COMMAND: CLEAR
+// ============================================================
+async function cmdClear() {
+  console.log('Clearing cached binaries...');
+
+  if (!existsSync(CACHE_DIR)) {
+    console.log('No cache directory found.');
+    return;
+  }
+
+  try {
+    const files = await readdir(CACHE_DIR);
+    let removedCount = 0;
+
+    for (const file of files) {
+      const filePath = join(CACHE_DIR, file);
+      try {
+        await unlink(filePath);
+        console.log(`  Removed: ${file}`);
+        removedCount++;
+      } catch (err) {
+        console.warn(`  Skipped: ${file} (${err.message})`);
+      }
+    }
+
+    console.log(`\nCleared ${removedCount} file(s).`);
+  } catch (error) {
+    console.error(`Failed to clear cache: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+// ============================================================
+// COMMAND: LOG
+// ============================================================
+async function cmdLog(args) {
+  // Check for -f or --follow flag
+  const followMode = args.includes('-f') || args.includes('--follow');
+  const linesIndex = args.indexOf('-n') !== -1 ? args.indexOf('-n') : args.indexOf('--lines');
+  const numLines = linesIndex !== -1 ? parseInt(args[linesIndex + 1] || '50', 10) : 50;
+
+  if (!existsSync(LOG_FILE)) {
+    console.log('No log file found. Has the server been started?');
+    console.log(`Expected log file: ${LOG_FILE}`);
+    return;
+  }
+
+  if (followMode) {
+    // Follow mode (tail -f)
+    console.log(`Following log file: ${LOG_FILE} (Ctrl+C to exit)`);
+    console.log(`${'='.repeat(60)}\n`);
+
+    let tailCmd;
+    if (platform === 'win32') {
+      // Windows: use Get-Content with -Wait
+      tailCmd = spawn('powershell', ['-Command', `Get-Content -Path "${LOG_FILE}" -Wait -Tail 50`], {
+        stdio: 'inherit',
+        windowsHide: false // 需要窗口显示输出
+      });
+    } else {
+      // Unix: use tail -f
+      tailCmd = spawn('tail', ['-n', String(numLines), '-f', LOG_FILE], {
+        stdio: 'inherit'
+      });
+    }
+
+    tailCmd.on('error', (err) => {
+      console.log(`Follow mode not available: ${err.message}`);
+      console.log('Showing current log content:');
+      showLogContent(numLines);
     });
 
-    child.on('error', (err) => {
-      reject(err);
+    // 等待 tail 进程结束（用户按 Ctrl+C）
+    await new Promise((resolve) => {
+      tailCmd.on('exit', resolve);
     });
-  });
+  } else {
+    showLogContent(numLines);
+  }
+}
+
+async function showLogContent(numLines) {
+  const content = await readFile(LOG_FILE, 'utf-8');
+  const lines = content.split('\n');
+
+  if (lines.length <= numLines) {
+    console.log(content);
+  } else {
+    console.log(lines.slice(-numLines).join('\n'));
+  }
+}
+
+// ============================================================
+// COMMAND: UPGRADE
+// ============================================================
+async function cmdUpgrade() {
+  console.log('Checking for updates...\n');
+
+  const manifest = await fetchRemoteManifest();
+
+  if (!manifest || !manifest.version) {
+    console.log('Could not fetch remote version.');
+    return;
+  }
+
+  const remoteVersion = manifest.version;
+  console.log(`Remote version: ${remoteVersion}`);
+
+  const executablePath = await getExecutablePath();
+
+  // Case 1: No binary found
+  if (!executablePath) {
+    console.log('No binary found. Downloading latest version...');
+    await downloadBinary(remoteVersion, getExecutableName());
+    console.log('\nUpgrade complete!');
+    return;
+  }
+
+  console.log(`Local binary: ${executablePath}`);
+
+  // Case 2: Check current binary version
+  console.log('Checking local binary version...');
+  const localVersion = await getBinaryVersion(executablePath);
+
+  if (localVersion) {
+    console.log(`Local version: ${localVersion}`);
+
+    const comparison = compareVersions(remoteVersion, localVersion);
+
+    if (comparison > 0) {
+      console.log(`Update available: ${localVersion} -> ${remoteVersion}`);
+      console.log('Downloading...');
+      await downloadBinary(remoteVersion, getExecutableName());
+      console.log('\nUpgrade complete!');
+    } else if (comparison === 0) {
+      console.log('Already up to date.');
+    } else {
+      console.log('Local version is newer.');
+    }
+  } else {
+    // Timeout or error getting version - download latest
+    console.log('Could not determine local version (timeout or error)');
+    console.log('Downloading latest version to ensure compatibility...');
+    await downloadBinary(remoteVersion, getExecutableName());
+    console.log('\nUpgrade complete!');
+  }
 }
 
-// Main execution
+// ============================================================
+// MAIN ENTRY POINT
+// ============================================================
 async function main() {
   const args = process.argv.slice(2);
 
-  // Handle -y flag (auto-confirm, no-op in our case)
+  // Handle -y flag (auto-confirm)
   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')) {
+  // Handle --version flag FIRST (before switch)
+  if (args.includes('--version') || (args.includes('-v') && !args.includes('-vvv'))) {
     const localVersion = await getLocalVersion();
     if (localVersion) {
       console.log(`@fmode/studio v${localVersion}`);
@@ -232,114 +618,94 @@ async function main() {
       console.log('@fmode/studio (version unknown)');
     }
     process.exit(0);
+    return;
   }
 
-  // Handle --help flag
+  // Handle --help flag FIRST (before switch)
   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
+  fmode <COMMAND> [OPTIONS]
+  npx @fmode/studio <COMMAND> [OPTIONS]
+
+COMMANDS:
+  start                    Start the Fmode Studio server (default)
+  stop                     Stop the running Fmode Studio server
+  log                      View server logs
+  clear                    Clear cached binary files
+  upgrade / update         Upgrade to the latest version
 
 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
+  -p, --port <PORT>        Set the server port (default: 16666)
+  -h, --host <HOST>        Set the server host (default: 0.0.0.0)
+      --help               Show this help message
+      --version, -v        Show version information
+
+LOG OPTIONS:
+  -f, --follow             Follow log output (like tail -f)
+  -n, --lines <NUM>        Number of lines to show (default: 50)
 
 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.
+  fmode                       # Start with default settings
+  fmode start                 # Explicitly start the server
+  fmode start --port 8080     # Start on port 8080
+  fmode --port 8080           # Start on port 8080 (same as above)
+  fmode stop                  # Stop the server
+  fmode stop --port 8080      # Stop server on port 8080
+  fmode log                   # Show recent logs
+  fmode log -f                # Follow logs in real-time
+  fmode log -n 100            # Show last 100 log lines
+  fmode clear                 # Clear cached binaries
+  fmode upgrade               # Upgrade to latest version
+
+UPGRADE MECHANISM:
+  The CLI automatically downloads the latest binary from repos.fmode.cn.
+  Use 'fmode upgrade' to manually upgrade.
 `);
     process.exit(0);
+    return;
   }
 
-  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;
-    }
-  }
+  const command = args[0];
 
-  // 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}`);
-    }
-  }
+  // Handle commands
+  switch (command) {
+    case 'start':
+      await cmdStart(args.slice(1));
+      return;
 
-  // If we have an executable, run it
-  if (executablePath) {
-    try {
-      await runExecutable(executablePath, args);
+    case 'stop':
+      await cmdStop(args.slice(1));
+      process.exit(0);
       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);
-}
+    case 'log':
+      await cmdLog(args.slice(1));
+      process.exit(0);
+      return;
 
-function fallbackToNode(args) {
-  const cliPath = join(rootDir, 'cli.ts');
+    case 'clear':
+      await cmdClear();
+      process.exit(0);
+      return;
 
-  if (existsSync(cliPath)) {
-    console.log('Running with bun...');
-    const child = spawn('bun', [cliPath, ...args], {
-      stdio: 'inherit',
-      env: { ...process.env }
-    });
+    case 'upgrade':
+      await cmdUpgrade();
+      process.exit(0);
+      return;
 
-    child.on('exit', (code) => {
-      process.exit(code ?? 0);
-    });
+    case 'update':
+      // Legacy command - same as upgrade
+      await cmdUpgrade();
+      process.exit(0);
+      return;
 
-    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);
+    default:
+      // Default: start the server with all args (no command specified)
+      await cmdStart(args);
+      return;
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fmode/studio",
-  "version": "0.0.2",
+  "version": "0.0.5",
   "description": "AI PaaS IDE for Vibe Coding - Cross-platform CLI tool",
   "license": "ISC",
   "author": "Fmode Studio Team",
@@ -28,9 +28,5 @@
     "x64",
     "arm64"
   ],
-  "dependencies": {
-    "@aws-sdk/client-s3": "^3.965.0",
-    "@siteboon/claude-code-ui": "^1.13.6",
-    "bun-pty": "^0.4.6"
-  }
+  "dependencies": {}
 }