@titanpl/cli 2.0.0 → 2.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@titanpl/cli",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "The unified CLI for Titan Planet. Use it to create, manage, build, and deploy high-performance backend projects.",
   "keywords": [
     "titanpl",
@@ -21,12 +21,12 @@
     "tit": "./index.js"
   },
   "optionalDependencies": {
-    "@titanpl/engine-win32-x64": "2.0.0",
-    "@titanpl/engine-linux-x64": "2.0.0",
-    "@titanpl/engine-darwin-arm64": "2.0.0"
+    "@titanpl/engine-win32-x64": "2.0.1",
+    "@titanpl/engine-linux-x64": "2.0.1",
+    "@titanpl/engine-darwin-arm64": "2.0.1"
   },
   "dependencies": {
-    "@titanpl/packet": "2.0.0",
+    "@titanpl/packet": "2.0.1",
     "prompts": "^2.4.2",
     "commander": "^11.0.0",
     "chalk": "^4.1.2"

package/src/commands/dev.js

@@ -1,5 +1,12 @@
 import { dev } from "@titanpl/packet";
+import { resolveEngineBinaryPath } from "../engine.js";
 
 export async function devCommand() {
+  // Resolve the engine binary from CLI's context (where optionalDependencies live)
+  // and inject it into the environment so packet can find it without re-resolving.
+  const enginePath = resolveEngineBinaryPath();
+  if (enginePath) {
+    process.env.TITAN_ENGINE_BINARY = enginePath;
+  }
   await dev(process.cwd());
-}
+}

package/src/commands/init.js

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { spawn } from 'child_process';
+import { execSync } from 'child_process';
 import prompts from 'prompts';
 import chalk from 'chalk';
 
@@ -166,15 +166,7 @@ export async function initCommand(projectName, templateName) {
 
     console.log(chalk.gray(`  Installing dependencies...`));
 
-    await new Promise((resolve, reject) => {
-        const npm = spawn('npm', ['install'], {
-            cwd: target,
-            stdio: 'inherit',
-            shell: true
-        });
-        npm.on('error', reject);
-        npm.on('close', resolve);
-    });
+    execSync('npm install', { cwd: target, stdio: 'inherit' });
 
     console.log(chalk.green(`\n✔ Project '${projName}' created successfully!\n`));
     console.log(chalk.yellow(`  cd ${projName}`));

package/src/commands/migrate.js

@@ -1,5 +1,9 @@
 import fs from 'fs';
 import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 
 export async function migrateCommand() {
     const root = process.cwd();
@@ -51,15 +55,29 @@ export async function migrateCommand() {
                 }
             }
 
-            // Add dependencies
+            // Add / fix dependencies — ensure correct @titanpl/ scope
             pkg.dependencies = pkg.dependencies || {};
-            if (!pkg.dependencies['@titan/native']) {
-                pkg.dependencies['@titan/native'] = "latest";
-                modified = true;
+
+            // Remove any stale old-scope packages (@titan/ typo) that may exist
+            const stalePackages = ['@titanp/native', '@titan/route', '@titan/cli', '@titan/packet'];
+            for (const stale of stalePackages) {
+                if (pkg.dependencies[stale]) {
+                    delete pkg.dependencies[stale];
+                    modified = true;
+                }
             }
-            if (!pkg.dependencies['@titan/route']) {
-                pkg.dependencies['@titan/route'] = "latest";
-                modified = true;
+
+            const requiredDeps = {
+                '@titanpl/cli': 'latest',
+                '@titanpl/route': 'latest',
+                '@titanpl/native': 'latest',
+                '@titanpl/packet': 'latest',
+            };
+            for (const [dep, version] of Object.entries(requiredDeps)) {
+                if (!pkg.dependencies[dep]) {
+                    pkg.dependencies[dep] = version;
+                    modified = true;
+                }
             }
 
             if (modified) {

package/src/engine.js

@@ -10,13 +10,17 @@ const __dirname = path.dirname(__filename);
 
 const require = createRequire(import.meta.url);
 
-export function getEngineBinaryPath() {
-  const platform = os.platform(); // 'win32', 'linux', 'darwin'
-  const arch = os.arch();         // 'x64', 'arm64'
+/**
+ * Resolves the engine binary path. Returns null if not found (non-fatal).
+ * Used by the dev command to pre-resolve and inject the path via env.
+ */
+export function resolveEngineBinaryPath() {
+  const platform = os.platform();
+  const arch = os.arch();
   const pkgName = `@titanpl/engine-${platform}-${arch}`;
   const binName = platform === 'win32' ? 'titan-server.exe' : 'titan-server';
 
-  // 1. Robust Binary Discovery (Monorepo, Local, or Global)
+  // 1. Monorepo search (local dev)
   const searchPaths = [
     __dirname,
     process.cwd(),
@@ -29,38 +33,43 @@ export function getEngineBinaryPath() {
     for (let i = 0; i < 8; i++) {
       const potential = path.join(current, 'engine', 'target', 'release', binName);
       if (fs.existsSync(potential)) return potential;
-
       const parent = path.dirname(current);
       if (parent === current) break;
       current = parent;
     }
   }
 
-  // 2. Resolve installed optional dependency
+  // 2. Resolve from CLI's own context (correct require context for optionalDependencies)
   try {
-    // We use a try/catch specifically for the resolve to provide a better diagnostic
-    let pkgPath;
-    try {
-      pkgPath = require.resolve(`${pkgName}/package.json`);
-    } catch (e) {
-      // Fallback: check if the binary exists in a standard location even if require.resolve fails
-      const fallbackBin = path.join(process.cwd(), 'node_modules', pkgName, 'bin', binName);
-      if (fs.existsSync(fallbackBin)) return fallbackBin;
-      throw e;
-    }
-    const pkgDir = path.dirname(pkgPath);
-    const binaryPath = path.join(pkgDir, 'bin', binName);
+    const pkgPath = require.resolve(`${pkgName}/package.json`);
+    const binaryPath = path.join(path.dirname(pkgPath), 'bin', binName);
+    if (fs.existsSync(binaryPath)) return binaryPath;
+  } catch (e) { }
 
-    if (fs.existsSync(binaryPath)) {
-      return binaryPath;
-    }
-    throw new Error(`Corrupted installation: Binary missing at ${binaryPath}.`);
-  } catch (err) {
-    console.error(`\n[TITAN FATAL] Unsupported platform: ${platform} (${arch})`);
-    console.error(`Or the optional dependency '${pkgName}' failed to install.`);
-    console.error(`Error: ${err.message}\n`);
-    process.exit(1);
-  }
+  // 3. Fallback: sibling in node_modules (global install layout)
+  const cliParent = path.dirname(path.dirname(__dirname)); // up from cli/src → cli → parent
+  const siblingBin = path.join(cliParent, pkgName, 'bin', binName);
+  if (fs.existsSync(siblingBin)) return siblingBin;
+
+  return null;
+}
+
+/**
+ * Resolves the engine binary path. Exits with a fatal error if not found.
+ * Used by the start command.
+ */
+export function getEngineBinaryPath() {
+  const platform = os.platform();
+  const arch = os.arch();
+  const pkgName = `@titanpl/engine-${platform}-${arch}`;
+
+  const resolved = resolveEngineBinaryPath();
+  if (resolved) return resolved;
+
+  console.error(`\n[TITAN FATAL] Unsupported platform: ${platform} (${arch})`);
+  console.error(`Or the optional dependency '${pkgName}' failed to install.`);
+  console.error(`Try: npm install -g @titanpl/cli\n`);
+  process.exit(1);
 }
 
 export function startEngine(watchMode = false) {