@fmode/studio 0.0.7 → 0.0.8

package/bin/fmode.js

@@ -1,22 +1,1078 @@
-#!/usr/bin/env node
-
-/**
- * Fmode Studio CLI Entry Point
- * npm/npx compatible entry point
- *
- * 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 start
- *   npx @fmode/studio server start
- */
-
-import { runCli } from '../cli/index.ts';
-
-// Run the CLI
-runCli().catch((error) => {
-  console.error('Fatal error:', error);
-  process.exit(1);
-});
+#!/usr/bin/env node
+
+// ============================================================
+// ROOTDIR FIX FOR NPM PACKAGE
+// ============================================================
+// In the npm package, the bin file is at: node_modules/@fmode/studio/bin/fmode.js
+// The package.json is at: node_modules/@fmode/studio/package.json
+// So we need to calculate rootDir relative to the bin file
+import { fileURLToPath as _fileURLToPath } from 'url';
+import { dirname as _dirname, join as _join } from 'path';
+const _pkgRoot = _dirname(_dirname(_fileURLToPath(import.meta.url)));
+// Override the rootDir variable used in the bundled code
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// cli/shared/utils.ts
+import { spawn, exec } from "child_process";
+import { join } from "path";
+import { existsSync, mkdirSync, chmodSync, renameSync } from "fs";
+import { createWriteStream } from "fs";
+import { pipeline } from "stream/promises";
+import { unlink } from "fs/promises";
+import { promisify } from "util";
+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}`);
+  }
+}
+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;
+}
+async function downloadBinary(url, executableName, cacheDir) {
+  const tempPath = join(cacheDir, `${executableName}.tmp`);
+  const finalPath = join(cacheDir, executableName);
+  console.log(`Downloading ${url}...`);
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    if (!existsSync(cacheDir)) {
+      mkdirSync(cacheDir, { recursive: true });
+    }
+    const fileStream = createWriteStream(tempPath);
+    await pipeline(response.body, fileStream);
+    if (platform !== "win32") {
+      chmodSync(tempPath, 493);
+    }
+    if (existsSync(finalPath)) {
+      await unlink(finalPath);
+    }
+    renameSync(tempPath, finalPath);
+    console.log(`Downloaded to ${finalPath}`);
+    return finalPath;
+  } catch (error) {
+    if (existsSync(tempPath)) {
+      await unlink(tempPath).catch(() => {});
+    }
+    throw error;
+  }
+}
+async function getBinaryVersion(executablePath) {
+  return new Promise((resolve) => {
+    let output = "";
+    let timedOut = false;
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      child.kill();
+      resolve(null);
+    }, 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;
+      const match = output.match(/version\s+(\d+\.\d+\.\d+)/);
+      if (match) {
+        resolve(match[1]);
+      } else {
+        resolve(null);
+      }
+    });
+    child.on("error", () => {
+      clearTimeout(timeout);
+      resolve(null);
+    });
+  });
+}
+async function isProcessRunning(pid) {
+  try {
+    if (platform === "win32") {
+      const { stdout } = await execAsync(`tasklist /FI "PID eq ${pid}" /FO CSV`);
+      return stdout.includes(String(pid));
+    } else {
+      process.kill(pid, 0);
+      return true;
+    }
+  } catch {
+    return false;
+  }
+}
+async function killProcess(pid) {
+  try {
+    if (platform === "win32") {
+      await execAsync(`taskkill /F /PID ${pid}`);
+      return true;
+    } else {
+      process.kill(pid);
+      return true;
+    }
+  } catch {
+    return false;
+  }
+}
+async function findProcessByPort(port) {
+  try {
+    let command;
+    if (platform === "win32") {
+      command = `netstat -ano | findstr :${port} | findstr LISTENING`;
+    } else {
+      command = `lsof -ti:${port}`;
+    }
+    const { stdout } = await execAsync(command);
+    if (platform === "win32") {
+      const lines = stdout.trim().split(`
+`);
+      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 {
+      const pid = parseInt(stdout.trim(), 10);
+      if (!isNaN(pid)) {
+        return pid;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+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';
+    const { stdout } = await execAsync(command);
+    return stdout;
+  } catch {
+    return "";
+  }
+}
+var execAsync, platform, arch;
+var init_utils = __esm(() => {
+  execAsync = promisify(exec);
+  platform = process.platform;
+  arch = process.arch;
+});
+
+// cli/shared/repos.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
+function getReposConfig(packageName) {
+  const baseUrl = `https://repos.fmode.cn/x/${packageName}`;
+  return {
+    baseUrl,
+    manifestUrl: `${baseUrl}/manifest.json`
+  };
+}
+async function fetchRemoteManifest(packageName) {
+  const config = getReposConfig(packageName);
+  try {
+    const response = await fetch(config.manifestUrl);
+    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;
+  }
+}
+async function getLocalVersion(rootDir) {
+  const packageJson = join2(rootDir, "package.json");
+  try {
+    const content = await readFile2(packageJson, "utf-8");
+    const pkg = JSON.parse(content);
+    return pkg.version || null;
+  } catch {
+    return null;
+  }
+}
+var init_repos = () => {};
+
+// cli/server/start.ts
+var exports_start = {};
+__export(exports_start, {
+  run: () => run6
+});
+import { spawn as spawn4 } from "child_process";
+import { join as join8, resolve } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, chmodSync as chmodSync2, renameSync as renameSync2 } from "fs";
+import { createWriteStream as createWriteStream2 } from "fs";
+import { pipeline as pipeline2 } from "stream/promises";
+import { unlink as unlink4 } from "fs/promises";
+function getServerExecutableName() {
+  const ext = platform === "win32" ? ".exe" : "";
+  if (platform === "win32") {
+    return arch2 === "arm64" ? `fmode-server-win-arm64${ext}` : `fmode-server-win-x64${ext}`;
+  } else if (platform === "linux") {
+    return arch2 === "arm64" ? "fmode-server-linux-arm64" : "fmode-server-linux-x64";
+  } else if (platform === "darwin") {
+    return arch2 === "arm64" ? "fmode-server-macos-arm64" : "fmode-server-macos-x64";
+  }
+  throw new Error(`Unsupported platform: ${platform}`);
+}
+function getCachedServerPath() {
+  const executableName = getServerExecutableName();
+  const cachedPath = join8(SERVER_CACHE_DIR, executableName);
+  return existsSync6(cachedPath) ? cachedPath : null;
+}
+async function downloadServerBinary(version) {
+  const executableName = getServerExecutableName();
+  const url = `${REPOS_BASE_URL3}/${version}/${executableName}`;
+  const tempPath = join8(SERVER_CACHE_DIR, `${executableName}.tmp`);
+  const finalPath = join8(SERVER_CACHE_DIR, executableName);
+  console.log(`Downloading fmode-server ${version}...`);
+  console.log(`URL: ${url}`);
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    if (!existsSync6(SERVER_CACHE_DIR)) {
+      mkdirSync3(SERVER_CACHE_DIR, { recursive: true });
+    }
+    const fileStream = createWriteStream2(tempPath);
+    await pipeline2(response.body, fileStream);
+    if (platform !== "win32") {
+      chmodSync2(tempPath, 493);
+    }
+    if (existsSync6(finalPath)) {
+      await unlink4(finalPath);
+    }
+    renameSync2(tempPath, finalPath);
+    console.log(`Downloaded to ${finalPath}`);
+    return finalPath;
+  } catch (error) {
+    if (existsSync6(tempPath)) {
+      await unlink4(tempPath).catch(() => {});
+    }
+    throw error;
+  }
+}
+function getConfigPath(args) {
+  const configIndex = args.indexOf("--config");
+  if (configIndex !== -1 && args[configIndex + 1]) {
+    const configPath = args[configIndex + 1];
+    return resolve(process.cwd(), configPath);
+  }
+  return resolve(process.cwd(), "config.json");
+}
+async function run6(args) {
+  const configPath = getConfigPath(args);
+  if (!existsSync6(configPath)) {
+    console.error(`Config file not found: ${configPath}`);
+    console.error("Please create a config.json file or specify --config <path>");
+    console.error("");
+    console.error("Example config.json:");
+    console.error(JSON.stringify({
+      parse: {
+        appId: "your-app-id",
+        masterKey: "your-master-key",
+        databaseURI: "postgresql://localhost/dev",
+        serverURL: "http://localhost:3000/parse",
+        port: 3000,
+        allowClientClassCreation: true,
+        enableAnonymousUsers: true,
+        allowExpiredAuthDataToken: false,
+        revokeSessionOnPasswordReset: false,
+        cloud: "./cloud/main.js"
+      }
+    }, null, 2));
+    process.exit(1);
+    return;
+  }
+  console.log(`Using config: ${configPath}`);
+  let serverPath = getCachedServerPath();
+  if (!serverPath) {
+    console.log("fmode-server not found. Downloading...");
+    const manifest = await fetchRemoteManifest("fmode-server");
+    if (!manifest || !manifest.version) {
+      console.error("Could not fetch fmode-server version information.");
+      console.error("Please check your internet connection.");
+      process.exit(1);
+      return;
+    }
+    serverPath = await downloadServerBinary(manifest.version);
+  }
+  console.log(`Starting fmode-server...`);
+  const serverArgs = ["--config", configPath, ...args.filter((a) => a !== "--config" && !args[args.indexOf("--config") + 1]?.startsWith("./"))];
+  spawn4(serverPath, serverArgs, {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      FORCE_COLOR: process.env.FORCE_COLOR || "1",
+      TERM: process.env.TERM || "xterm-256color"
+    }
+  }).on("exit", (code) => {
+    process.exit(code ?? 0);
+  });
+}
+var REPOS_BASE_URL3 = "https://repos.fmode.cn/x/fmode-server", arch2;
+var init_start = __esm(() => {
+  init_utils();
+  init_repos();
+  init_server();
+  arch2 = process.arch;
+});
+
+// cli/server/update.ts
+var exports_update = {};
+__export(exports_update, {
+  run: () => run7
+});
+import { join as join9 } from "path";
+import { existsSync as existsSync7, renameSync as renameSync3, unlinkSync, mkdirSync as mkdirSync4 } from "fs";
+import { exec as exec3 } from "child_process";
+import { promisify as promisify2 } from "util";
+import { createWriteStream as createWriteStream3 } from "fs";
+import { pipeline as pipeline3 } from "stream/promises";
+function getServerExecutableName2() {
+  const ext = platform === "win32" ? ".exe" : "";
+  if (platform === "win32") {
+    return process.arch === "arm64" ? `fmode-server-win-arm64${ext}` : `fmode-server-win-x64${ext}`;
+  } else if (platform === "linux") {
+    return process.arch === "arm64" ? "fmode-server-linux-arm64" : "fmode-server-linux-x64";
+  } else if (platform === "darwin") {
+    return process.arch === "arm64" ? "fmode-server-macos-arm64" : "fmode-server-macos-x64";
+  }
+  throw new Error(`Unsupported platform: ${platform}`);
+}
+function getCachedServerPath2() {
+  const executableName = getServerExecutableName2();
+  const cachedPath = join9(SERVER_CACHE_DIR, executableName);
+  return existsSync7(cachedPath) ? cachedPath : null;
+}
+async function getLocalServerVersion(executablePath) {
+  return new Promise((resolve2) => {
+    let output = "";
+    let timedOut = false;
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      child.kill();
+      resolve2(null);
+    }, 5000);
+    const child = exec3(`"${executablePath}" --version`, {
+      env: { ...process.env }
+    });
+    child.stdout?.on("data", (data) => {
+      output += data.toString();
+    });
+    child.on("exit", (code) => {
+      clearTimeout(timeout);
+      if (timedOut)
+        return;
+      const match = output.match(/(\d+\.\d+\.\d+)/);
+      if (match) {
+        resolve2(match[1]);
+      } else {
+        resolve2(null);
+      }
+    });
+    child.on("error", () => {
+      clearTimeout(timeout);
+      resolve2(null);
+    });
+  });
+}
+async function downloadServerBinary2(version) {
+  const executableName = getServerExecutableName2();
+  const url = `${REPOS_BASE_URL4}/${version}/${executableName}`;
+  const tempPath = join9(SERVER_CACHE_DIR, `${executableName}.tmp`);
+  const finalPath = join9(SERVER_CACHE_DIR, executableName);
+  console.log(`Downloading fmode-server ${version}...`);
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    if (!existsSync7(SERVER_CACHE_DIR)) {
+      mkdirSync4(SERVER_CACHE_DIR, { recursive: true });
+    }
+    const fileStream = createWriteStream3(tempPath);
+    await pipeline3(response.body, fileStream);
+    if (existsSync7(finalPath)) {
+      unlinkSync(finalPath);
+    }
+    renameSync3(tempPath, finalPath);
+    console.log(`Downloaded to ${finalPath}`);
+  } catch (error) {
+    if (existsSync7(tempPath)) {
+      unlinkSync(tempPath);
+    }
+    throw error;
+  }
+}
+async function run7(args) {
+  console.log(`Checking for fmode-server updates...
+`);
+  const manifest = await fetchRemoteManifest("fmode-server");
+  if (!manifest || !manifest.version) {
+    console.log("Could not fetch remote version.");
+    return;
+  }
+  const remoteVersion = manifest.version;
+  console.log(`Remote version: ${remoteVersion}`);
+  const serverPath = getCachedServerPath2();
+  if (!serverPath) {
+    console.log("No fmode-server binary found. Downloading...");
+    await downloadServerBinary2(remoteVersion);
+    console.log(`
+Update complete!`);
+    return;
+  }
+  console.log(`Local binary: ${serverPath}`);
+  console.log("Checking local binary version...");
+  const localVersion = await getLocalServerVersion(serverPath);
+  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 downloadServerBinary2(remoteVersion);
+      console.log(`
+Update complete!`);
+    } else if (comparison === 0) {
+      console.log("Already up to date.");
+    } else {
+      console.log("Local version is newer.");
+    }
+  } else {
+    console.log("Could not determine local version");
+    console.log("Downloading latest version...");
+    await downloadServerBinary2(remoteVersion);
+    console.log(`
+Update complete!`);
+  }
+}
+var execAsync2, REPOS_BASE_URL4 = "https://repos.fmode.cn/x/fmode-server";
+var init_update = __esm(() => {
+  init_utils();
+  init_repos();
+  init_server();
+  execAsync2 = promisify2(exec3);
+});
+
+// cli/server/version.ts
+var exports_version = {};
+__export(exports_version, {
+  run: () => run8
+});
+import { join as join10 } from "path";
+import { existsSync as existsSync8 } from "fs";
+function getServerExecutableName3() {
+  const ext = platform === "win32" ? ".exe" : "";
+  if (platform === "win32") {
+    return process.arch === "arm64" ? `fmode-server-win-arm64${ext}` : `fmode-server-win-x64${ext}`;
+  } else if (platform === "linux") {
+    return process.arch === "arm64" ? "fmode-server-linux-arm64" : "fmode-server-linux-x64";
+  } else if (platform === "darwin") {
+    return process.arch === "arm64" ? "fmode-server-macos-arm64" : "fmode-server-macos-x64";
+  }
+  throw new Error(`Unsupported platform: ${platform}`);
+}
+function getCachedServerPath3() {
+  const executableName = getServerExecutableName3();
+  const cachedPath = join10(SERVER_CACHE_DIR, executableName);
+  return existsSync8(cachedPath) ? cachedPath : null;
+}
+async function getLocalServerVersion2(executablePath) {
+  return new Promise((resolve2) => {
+    let output = "";
+    let timedOut = false;
+    const { exec: exec4 } = __require("child_process");
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      child.kill();
+      resolve2(null);
+    }, 5000);
+    const child = exec4(`"${executablePath}" --version`, {
+      env: { ...process.env }
+    });
+    child.stdout?.on("data", (data) => {
+      output += data.toString();
+    });
+    child.on("exit", (code) => {
+      clearTimeout(timeout);
+      if (timedOut)
+        return;
+      const match = output.match(/(\d+\.\d+\.\d+)/);
+      if (match) {
+        resolve2(match[1]);
+      } else {
+        resolve2(null);
+      }
+    });
+    child.on("error", () => {
+      clearTimeout(timeout);
+      resolve2(null);
+    });
+  });
+}
+async function run8(args) {
+  const rootDir6 = join10(import.meta.dir, "..", "..");
+  const cliVersion = await getLocalVersion(rootDir6);
+  console.log("Fmode CLI Version Information:");
+  console.log("==============================");
+  console.log(`CLI Version: ${cliVersion || "unknown"}`);
+  const serverPath = getCachedServerPath3();
+  if (serverPath) {
+    console.log(`Server Binary: ${serverPath}`);
+    const serverVersion = await getLocalServerVersion2(serverPath);
+    console.log(`Server Version: ${serverVersion || "unknown"}`);
+  } else {
+    console.log('Server Binary: Not installed (run "fmode server update" to install)');
+  }
+}
+var init_version = __esm(() => {
+  init_utils();
+  init_repos();
+  init_server();
+});
+
+// cli/server/index.ts
+import { join as join11, dirname as dirname6 } from "path";
+import { homedir as homedir3 } from "os";
+import { fileURLToPath as fileURLToPath6 } from "url";
+function showHelp() {
+  console.log(`
+Fmode-Server Management Commands
+
+USAGE:
+  fmode server <COMMAND> [OPTIONS]
+
+COMMANDS:
+  start           Start fmode-server with config.json
+  update          Update fmode-server binary
+  version         Show CLI and fmode-server version information
+
+OPTIONS:
+  --config <path> Path to config.json (default: ./config.json)
+
+EXAMPLES:
+  fmode server start                 # Start with ./config.json
+  fmode server start --config ./server-config.json
+  fmode server update                # Check and update fmode-server
+  fmode server version               # Show version information
+`);
+}
+async function run9(args) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "start": {
+      const { run: run10 } = await Promise.resolve().then(() => (init_start(), exports_start));
+      await run10(args.slice(1));
+      break;
+    }
+    case "update": {
+      const { run: run10 } = await Promise.resolve().then(() => (init_update(), exports_update));
+      await run10(args.slice(1));
+      process.exit(0);
+      break;
+    }
+    case "-v":
+    case "-vvv":
+    case "-version":
+    case "--version":
+    case "version": {
+      const { run: run10 } = await Promise.resolve().then(() => (init_version(), exports_version));
+      await run10(args.slice(1));
+      process.exit(0);
+      break;
+    }
+    case "--help":
+    case "-h":
+    case undefined:
+      showHelp();
+      break;
+    default:
+      console.error(`Unknown server command: ${subcommand}`);
+      console.log('Run "fmode server --help" for usage.');
+      process.exit(1);
+      break;
+  }
+}
+var __filename7, __dirname7, SERVER_CACHE_DIR;
+var init_server = __esm(() => {
+  __filename7 = fileURLToPath6(import.meta.url);
+  __dirname7 = dirname6(__filename7);
+  SERVER_CACHE_DIR = join11(homedir3(), ".fmode", "server", "bin");
+});
+
+// cli/index.ts
+import { fileURLToPath as fileURLToPath7 } from "url";
+import { dirname as dirname7 } from "path";
+
+// cli/start/index.ts
+init_utils();
+init_repos();
+import { spawn as spawn2 } from "child_process";
+import { join as join3, dirname } from "path";
+import { homedir } from "os";
+import { existsSync as existsSync2 } from "fs";
+import { fileURLToPath } from "url";
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+var rootDir = dirname(dirname(__dirname2));
+var REPOS_BASE_URL = "https://repos.fmode.cn/x/fmode-studio";
+var CACHE_DIR = join3(homedir(), ".fmode", "studio", "bin");
+async function getExecutablePath() {
+  const executableName = getExecutableName();
+  const cachedPath = join3(CACHE_DIR, executableName);
+  if (existsSync2(cachedPath)) {
+    return cachedPath;
+  }
+  const bundledPath = join3(rootDir, "dist", "bin", executableName);
+  if (existsSync2(bundledPath)) {
+    return bundledPath;
+  }
+  return null;
+}
+async function downloadBinary2(version, executableName) {
+  const url = `${REPOS_BASE_URL}/${version}/${executableName}`;
+  return downloadBinary(url, executableName, CACHE_DIR);
+}
+async function run(args) {
+  const executablePath = await getExecutablePath();
+  let finalExecutablePath = executablePath;
+  if (!finalExecutablePath) {
+    console.log("No local binary found. Downloading...");
+    const manifest = await fetchRemoteManifest("fmode-studio");
+    if (manifest && manifest.version) {
+      finalExecutablePath = await downloadBinary2(manifest.version, getExecutableName());
+    }
+  }
+  if (!finalExecutablePath) {
+    console.error('No executable found and could not download. Please run "fmode upgrade" first.');
+    process.exit(1);
+    return;
+  }
+  spawn2(finalExecutablePath, args, {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      FORCE_COLOR: process.env.FORCE_COLOR || "1",
+      TERM: process.env.TERM || "xterm-256color"
+    }
+  }).on("exit", (code) => {
+    process.exit(code ?? 0);
+  });
+}
+
+// cli/stop/index.ts
+init_utils();
+import { unlink as unlink2, readFile as readFile3 } from "fs/promises";
+import { join as join4, dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __filename3 = fileURLToPath2(import.meta.url);
+var __dirname3 = dirname2(__filename3);
+var rootDir2 = dirname2(dirname2(__dirname3));
+var PID_DIR = join4(rootDir2, ".cache", "pids");
+var PID_FILE = join4(PID_DIR, "fmode.pid");
+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;
+}
+async function readPidWithPort() {
+  try {
+    const content = await readFile3(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 };
+  }
+}
+async function run2(args) {
+  const port = getPortFromArgs(args);
+  const { pid: savedPid, port: savedPort } = await readPidWithPort();
+  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 unlink2(PID_FILE).catch(() => {});
+      return;
+    } else {
+      console.error("Failed to stop Fmode Studio.");
+      process.exit(1);
+      return;
+    }
+  }
+  if (savedPid && await isProcessRunning(savedPid)) {
+    console.log(`Stopping Fmode Studio (PID: ${savedPid})...`);
+    if (await killProcess(savedPid)) {
+      console.log("Fmode Studio stopped.");
+      await unlink2(PID_FILE).catch(() => {});
+      return;
+    } else {
+      console.error("Failed to stop Fmode Studio.");
+      process.exit(1);
+      return;
+    }
+  }
+  if (savedPid || portPid) {
+    console.log("Process not running. Cleaning up PID file...");
+    await unlink2(PID_FILE).catch(() => {});
+  }
+  console.log(`No process found on port ${port}. Searching for Fmode processes...`);
+  const processes = await findFmodeProcesses();
+  if (processes.trim()) {
+    console.log(`
+Found Fmode processes:`);
+    console.log(processes);
+    console.log(`
+Please 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.");
+  }
+}
+
+// cli/log/index.ts
+init_utils();
+import { readFile as readFile4 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { spawn as spawn3 } from "child_process";
+import { join as join5, dirname as dirname3 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var __filename4 = fileURLToPath3(import.meta.url);
+var __dirname4 = dirname3(__filename4);
+var rootDir3 = dirname3(dirname3(__dirname4));
+var LOG_DIR = join5(rootDir3, ".cache", "logs");
+var LOG_FILE = join5(LOG_DIR, "fmode.log");
+async function showLogContent(numLines) {
+  const content = await readFile4(LOG_FILE, "utf-8");
+  const lines = content.split(`
+`);
+  if (lines.length <= numLines) {
+    console.log(content);
+  } else {
+    console.log(lines.slice(-numLines).join(`
+`));
+  }
+}
+async function run3(args) {
+  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 (!existsSync3(LOG_FILE)) {
+    console.log("No log file found. Has the server been started?");
+    console.log(`Expected log file: ${LOG_FILE}`);
+    return;
+  }
+  if (followMode) {
+    console.log(`Following log file: ${LOG_FILE} (Ctrl+C to exit)`);
+    console.log(`${"=".repeat(60)}
+`);
+    let tailCmd;
+    if (platform === "win32") {
+      tailCmd = spawn3("powershell", ["-Command", `Get-Content -Path "${LOG_FILE}" -Wait -Tail 50`], {
+        stdio: "inherit",
+        windowsHide: false
+      });
+    } else {
+      tailCmd = spawn3("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);
+    });
+    await new Promise((resolve) => {
+      tailCmd.on("exit", resolve);
+    });
+  } else {
+    await showLogContent(numLines);
+  }
+}
+
+// cli/clear/index.ts
+import { readdir, unlink as unlink3 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { join as join6, dirname as dirname4 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+var __filename5 = fileURLToPath4(import.meta.url);
+var __dirname5 = dirname4(__filename5);
+var rootDir4 = dirname4(dirname4(__dirname5));
+var CACHE_DIR2 = join6(rootDir4, ".cache", "binaries");
+async function run4(args) {
+  console.log("Clearing cached binaries...");
+  if (!existsSync4(CACHE_DIR2)) {
+    console.log("No cache directory found.");
+    return;
+  }
+  try {
+    const files = await readdir(CACHE_DIR2);
+    let removedCount = 0;
+    for (const file of files) {
+      const filePath = join6(CACHE_DIR2, file);
+      try {
+        await unlink3(filePath);
+        console.log(`  Removed: ${file}`);
+        removedCount++;
+      } catch (err) {
+        console.warn(`  Skipped: ${file} (${err.message})`);
+      }
+    }
+    console.log(`
+Cleared ${removedCount} file(s).`);
+  } catch (error) {
+    console.error(`Failed to clear cache: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+// cli/upgrade/index.ts
+init_utils();
+init_repos();
+import { join as join7, dirname as dirname5 } from "path";
+import { homedir as homedir2 } from "os";
+import { existsSync as existsSync5 } from "fs";
+import { fileURLToPath as fileURLToPath5 } from "url";
+var __filename6 = fileURLToPath5(import.meta.url);
+var __dirname6 = dirname5(__filename6);
+var rootDir5 = dirname5(dirname5(__dirname6));
+var REPOS_BASE_URL2 = "https://repos.fmode.cn/x/fmode-studio";
+var CACHE_DIR3 = join7(homedir2(), ".fmode", "studio", "bin");
+async function getExecutablePath2() {
+  const executableName = getExecutableName();
+  const cachedPath = join7(CACHE_DIR3, executableName);
+  if (existsSync5(cachedPath)) {
+    return cachedPath;
+  }
+  const bundledPath = join7(rootDir5, "dist", "bin", executableName);
+  if (existsSync5(bundledPath)) {
+    return bundledPath;
+  }
+  return null;
+}
+async function downloadBinary3(version, executableName) {
+  const url = `${REPOS_BASE_URL2}/${version}/${executableName}`;
+  return downloadBinary(url, executableName, CACHE_DIR3);
+}
+async function run5(args) {
+  console.log(`Checking for updates...
+`);
+  const manifest = await fetchRemoteManifest("fmode-studio");
+  if (!manifest || !manifest.version) {
+    console.log("Could not fetch remote version.");
+    return;
+  }
+  const remoteVersion = manifest.version;
+  console.log(`Remote version: ${remoteVersion}`);
+  const executablePath = await getExecutablePath2();
+  if (!executablePath) {
+    console.log("No binary found. Downloading latest version...");
+    await downloadBinary3(remoteVersion, getExecutableName());
+    console.log(`
+Upgrade complete!`);
+    return;
+  }
+  console.log(`Local binary: ${executablePath}`);
+  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 downloadBinary3(remoteVersion, getExecutableName());
+      console.log(`
+Upgrade complete!`);
+    } else if (comparison === 0) {
+      console.log("Already up to date.");
+    } else {
+      console.log("Local version is newer.");
+    }
+  } else {
+    console.log("Could not determine local version (timeout or error)");
+    console.log("Downloading latest version to ensure compatibility...");
+    await downloadBinary3(remoteVersion, getExecutableName());
+    console.log(`
+Upgrade complete!`);
+  }
+}
+
+// cli/index.ts
+init_server();
+init_repos();
+var __filename8 = fileURLToPath7(import.meta.url);
+var __dirname8 = dirname7(__filename8);
+var rootDir6 = _pkgRoot;
+async function showHelp2() {
+  const localVersion = await getLocalVersion(rootDir6);
+  console.log(`
+Fmode Code UI Server${localVersion ? ` v${localVersion}` : ""}
+
+USAGE:
+  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
+
+  server                   Manage fmode-server
+    server start           Start fmode-server with config.json
+    server update          Update fmode-server binary
+    server version         Show CLI and fmode-server version information
+
+OPTIONS:
+  -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 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
+  fmode server start          # Start fmode-server
+  fmode server update         # Update fmode-server
+  fmode server version        # Show version information
+
+UPGRADE MECHANISM:
+  The CLI automatically downloads the latest binary from repos.fmode.cn.
+  Use 'fmode upgrade' to manually upgrade.
+`);
+}
+async function showVersion() {
+  const localVersion = await getLocalVersion(rootDir6);
+  if (localVersion) {
+    console.log(`@fmode/studio v${localVersion}`);
+  } else {
+    console.log("@fmode/studio (version unknown)");
+  }
+}
+async function runCli() {
+  const args = process.argv.slice(2);
+  const yesIndex = args.indexOf("-y");
+  if (yesIndex !== -1) {
+    args.splice(yesIndex, 1);
+  }
+  const command = args[0];
+  const commandArgs = args.slice(1);
+  if (args.includes("version") || args.includes("--version") || args.includes("-version") || args.includes("-v") || args.includes("-vvv")) {
+    if (command !== "server") {
+      await showVersion();
+      return;
+    }
+  }
+  if (args.includes("--help") || args.includes("-h") && !args.includes("--host")) {
+    if (!command || command !== "server") {
+      await showHelp2();
+      return;
+    }
+  }
+  switch (command) {
+    case "start":
+      await run(commandArgs);
+      break;
+    case "stop":
+      await run2(commandArgs);
+      process.exit(0);
+      break;
+    case "log":
+      await run3(commandArgs);
+      process.exit(0);
+      break;
+    case "clear":
+      await run4(commandArgs);
+      process.exit(0);
+      break;
+    case "upgrade":
+    case "update":
+      await run5(commandArgs);
+      process.exit(0);
+      break;
+    case "server":
+      await run9(commandArgs);
+      break;
+    default:
+      await run(args);
+      break;
+  }
+}
+var isMainModule = process.argv[1] && import.meta.url === `file:///${process.argv[1].replace(/\\/g, "/")}`;
+if (isMainModule) {
+  runCli().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+  });
+}
+export {
+  showVersion,
+  showHelp2 as showHelp,
+  runCli
+};