@fmode/studio 0.0.2

package/README.md

@@ -0,0 +1,208 @@
+# @fmode/studio
+
+**AI PaaS IDE for Vibe Coding** - A cross-platform CLI tool that provides a powerful development environment powered by AI.
+
+## Quick Start
+
+The fastest way to get started is using npx (no installation required):
+
+```bash
+npx -y @fmode/studio
+```
+
+This will:
+1. Download and run the latest version automatically
+2. Start the development server on port 16666
+3. Open your browser to the IDE
+
+## Installation
+
+### Global Installation (Recommended for frequent use)
+
+```bash
+npm install -g @fmode/studio
+```
+
+Once installed, you can run:
+
+```bash
+fmode
+```
+
+### Using npx (Run without installing)
+
+```bash
+npx @fmode/studio
+```
+
+## Usage
+
+### Basic Usage
+
+Start the server with default settings (port 16666, host 0.0.0.0):
+
+```bash
+fmode
+# or
+npx @fmode/studio
+```
+
+### Custom Port
+
+Start on a specific port:
+
+```bash
+fmode --port 16666
+# or
+npx @fmode/studio --port 16666
+```
+
+### Custom Host
+
+Start on a specific host:
+
+```bash
+fmode --host localhost --port 16666
+# or
+npx @fmode/studio --host localhost --port 16666
+```
+
+### Environment Variables
+
+You can also configure the server using environment variables:
+
+```bash
+PORT=16666 HOST=localhost fmode
+```
+
+Available environment variables:
+- `PORT` - Server port (default: 16666)
+- `HOST` - Server host (default: 0.0.0.0)
+- `VITE_IS_PLATFORM` - Set to 'true' for platform mode
+
+## Command Line Options
+
+| Option | Alias | Description |
+|--------|-------|-------------|
+| `--port <PORT>` | `-p` | Set the server port (default: 16666) |
+| `--host <HOST>` | `-h` | Set the server host (default: 0.0.0.0) |
+| `--help` | | Show help message |
+| `--version` | `-v` | Show version information |
+| `-y` | | Auto-confirm (used with npx) |
+
+## Examples
+
+### Development Workflow
+
+```bash
+# Start the development server
+fmode
+
+# Start on port 16666 for local development
+fmode --port 16666
+
+# Start on localhost only
+fmode --host localhost --port 16666
+```
+
+### With npx (No Installation)
+
+```bash
+# Quick start with auto-confirm
+npx -y @fmode/studio
+
+# Specify custom port
+npx @fmode/studio --port 16666
+
+# Full options
+npx @fmode/studio --host localhost --port 16666
+```
+
+## Platform Support
+
+@fmode/studio provides native executables for the following platforms:
+
+| Platform | Architecture | Executable |
+|----------|--------------|------------|
+| Windows | x64 | fmode-win-x64.exe |
+| Windows | ARM64 | fmode-win-arm64.exe |
+| Linux | x64 | fmode-linux-x64 |
+| Linux | ARM64 | fmode-linux-arm64 |
+| macOS | x64 (Intel) | fmode-macos-x64 |
+| macOS | ARM64 (Apple Silicon) | fmode-macos-arm64 |
+
+The CLI automatically detects your platform and uses the appropriate executable.
+
+## Requirements
+
+- **Node.js**: >= 18.0.0
+- **Bun**: >= 1.0.0 (optional, for development)
+- **OS**: Windows, macOS, or Linux
+- **CPU**: x64 or ARM64
+
+## Data Storage
+
+Application data is stored in your user data directory:
+
+- **Windows**: `%APPDATA%\fmode-studio`
+- **macOS**: `~/Library/Application Support/fmode-studio`
+- **Linux**: `~/.config/fmode-studio`
+
+## Troubleshooting
+
+### Port Already in Use
+
+If you see an error that the port is already in use:
+
+```bash
+fmode --port 16666
+```
+
+### Permission Issues
+
+On Linux/macOS, if you get permission errors, make sure the executable has execute permissions:
+
+```bash
+chmod +x node_modules/@fmode/studio/dist/bin/fmode-*
+```
+
+### Fallback to Node.js
+
+If the native executable is not available for your platform, the CLI will automatically fall back to running with Bun (if installed).
+
+## Version Check
+
+Check your installed version:
+
+```bash
+fmode --version
+# or
+npx @fmode/studio --version
+```
+
+## Help
+
+Display help information:
+
+```bash
+fmode --help
+# or
+npx @fmode/studio --help
+```
+
+## License
+
+© 2026 未来飞马® All rights reserved.
+
+## Author
+
+Fmode Studio
+
+- [Fmode Inc](https://www.npmjs.com/~fmode)
+- [RyaneMax](https://github.com/ryanemax)
+
+## Links
+
+- Repository: https://www.npmjs.com/package/@fmode/studio
+- Issues: https://app.fmode.cn/dev/studio
+

package/bin/fmode.js

@@ -0,0 +1,350 @@
+#!/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
+ *
+ * Usage:
+ *   npx @fmode/studio
+ *   npx @fmode/studio -y
+ *   npx @fmode/studio update
+ *   fmode
+ */
+
+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';
+
+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) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@fmode/studio",
+  "version": "0.0.2",
+  "description": "AI PaaS IDE for Vibe Coding - Cross-platform CLI tool",
+  "license": "ISC",
+  "author": "Fmode Studio Team",
+  "type": "module",
+  "bin": {
+    "fmode": "./bin/fmode.js",
+    "@fmode/studio": "./bin/fmode.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "*.js",
+    "api"
+  ],
+  "engines": {
+    "node": ">=18.0.0",
+    "bun": ">=1.0.0"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.965.0",
+    "@siteboon/claude-code-ui": "^1.13.6",
+    "bun-pty": "^0.4.6"
+  }
+}