@speedscale/proxymock 2.3.661 → 2.3.677

package/bin/proxymock.js

@@ -1,15 +1,19 @@
 #!/usr/bin/env node
 
 import { spawn } from "child_process";
-import { join, dirname } from "path";
 import { existsSync } from "fs";
-import { homedir } from "os";
-import { fileURLToPath } from "url";
-
-// Determine the binary path
-const INSTALLROOT = process.env.INSTALLROOT || join(homedir(), ".speedscale");
-const binaryPath = join(INSTALLROOT, "proxymock");
+import {
+  getPackageVersion,
+  getInstalledVersion,
+} from "../lib/version.js";
+import { binaryPath } from "../lib/constants.js";
+import logger from "../lib/log.js";
+import install from "../lib/install.js";
 
+/**
+ * Spawns the proxymock binary with the provided command line arguments
+ * Exits the process with the same code as proxymock
+ */
 function runProxyMock() {
   const child = spawn(binaryPath, process.argv.slice(2), {
     stdio: "inherit",
@@ -17,7 +21,7 @@ function runProxyMock() {
   });
 
   child.on("error", (err) => {
-    console.error("Failed to start proxymock:", err);
+    logger.error(`Failed to start proxymock: ${err.message}`);
     process.exit(1);
   });
 
@@ -26,23 +30,45 @@ function runProxyMock() {
   });
 }
 
-// Check if proxymock is installed
-if (!existsSync(binaryPath)) {
-  // Run the installation
-  const __filename = fileURLToPath(import.meta.url);
-  const __dirname = dirname(__filename);
-  const installScript = join(__dirname, "..", "lib", "install.js");
-  const installProcess = spawn("node", [installScript], { stdio: "inherit" });
-
-  installProcess.on("exit", (code) => {
-    if (code !== 0) {
-      console.error("Installation failed");
-      process.exit(1);
-    }
-    // Run proxymock after successful installation
-    runProxyMock();
-  });
-} else {
-  // Binary exists, run it directly
+/**
+ * Installs proxymock and runs it, exiting on failure
+ */
+async function installAndRun() {
+  try {
+    await install();
+  } catch (error) {
+    logger.error(`Installation failed: ${error.message}`);
+    process.exit(1);
+  }
   runProxyMock();
 }
+
+/**
+ * Main entry point - ensures the correct version of proxymock is installed
+ * before executing it. Performs version checking and automatic reinstallation
+ * if the installed version doesn't match the npm package version.
+ */
+async function main() {
+  const npmVersion = getPackageVersion();
+  const expectedVersion = `v${npmVersion}`;
+
+  // Check if proxymock is installed
+  if (!existsSync(binaryPath)) {
+    await installAndRun();
+    return;
+  }
+
+  // Binary exists, check if version matches
+  const installedVersion = await getInstalledVersion();
+
+  if (installedVersion === null || installedVersion !== expectedVersion) {
+    // Version unknown or mismatch, reinstall version from package
+    await installAndRun();
+    return;
+  }
+
+  // Version matches, run directly
+  runProxyMock();
+}
+
+main();

package/lib/constants.js

@@ -0,0 +1,7 @@
+import { join } from "path";
+import { homedir } from "os";
+
+// Determine the binary path
+export const INSTALLROOT =
+  process.env.INSTALLROOT || join(homedir(), ".speedscale");
+export const binaryPath = join(INSTALLROOT, "proxymock");

package/lib/install.js

@@ -8,10 +8,12 @@ import {
   mkdirSync,
   chmodSync,
 } from "fs";
-import { join, dirname } from "path";
-import { tmpdir, platform, arch, homedir } from "os";
+import { join } from "path";
+import { tmpdir, platform, arch } from "os";
 import { createHash } from "crypto";
-import { fileURLToPath } from "url";
+import logger from "./log.js";
+import { getPackageVersion } from "./version.js";
+import { INSTALLROOT } from "./constants.js";
 
 async function downloadFile(url, destPath) {
   return new Promise((resolve, reject) => {
@@ -85,15 +87,7 @@ async function validateChecksum(filePath, expectedChecksum) {
   });
 }
 
-function getPackageVersion() {
-  const __dirname = dirname(fileURLToPath(import.meta.url));
-  const packageJson = JSON.parse(
-    readFileSync(join(__dirname, "..", "package.json"), "utf8"),
-  );
-  return packageJson.version;
-}
-
-async function install() {
+export default async function install() {
   try {
     // Read version from package.json
     const npmVersion = getPackageVersion();
@@ -109,11 +103,14 @@ async function install() {
     const srcUrl = `${baseUrl}/${srcfile}`;
     const shaUrl = `${baseUrl}/${srcfile}.sha256`;
 
-    const INSTALLROOT =
-      process.env.INSTALLROOT || join(homedir(), ".speedscale");
-
     // Ensure install directory exists
-    mkdirSync(INSTALLROOT, { recursive: true });
+    try {
+      mkdirSync(INSTALLROOT, { recursive: true });
+    } catch (error) {
+      throw new Error(
+        `Failed to create install directory ${INSTALLROOT}: ${error.message}`,
+      );
+    }
 
     // Download checksum first
     const tempShaPath = join(tmpdir(), `${srcfile}.sha256`);
@@ -135,23 +132,50 @@ async function install() {
 
     // Install - always as "proxymock" since npm version provides isolation
     const dstPath = join(INSTALLROOT, "proxymock");
-    copyFileSync(tempBinPath, dstPath);
+    try {
+      copyFileSync(tempBinPath, dstPath);
+    } catch (error) {
+      throw new Error(
+        `Failed to install binary to ${dstPath}: ${error.message}`,
+      );
+    }
 
     // Make executable on Unix-like systems
     if (platform() !== "win32") {
-      chmodSync(dstPath, "755");
+      try {
+        chmodSync(dstPath, "755");
+      } catch (error) {
+        throw new Error(`Failed to make binary executable: ${error.message}`);
+      }
     }
 
-    // Cleanup
-    unlinkSync(tempShaPath);
-    unlinkSync(tempBinPath);
+    // Cleanup temp files (non-fatal if it fails)
+    try {
+      unlinkSync(tempShaPath);
+    } catch (error) {
+      logger.error(
+        `Failed to cleanup temp file ${tempShaPath}: ${error.message}`,
+      );
+    }
+    try {
+      unlinkSync(tempBinPath);
+    } catch (error) {
+      logger.error(
+        `Failed to cleanup temp file ${tempBinPath}: ${error.message}`,
+      );
+    }
+
+    logger.info(`installed proxymock ${proxymockVersion}`);
   } catch (error) {
-    console.error("Installation failed:", error.message);
-    process.exit(1);
+    logger.error(`Installation failed: ${error.message}`);
+    throw error; // Let the caller handle the error
   }
 }
 
 // Run installation if this script is executed directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-  install();
+  install().catch((error) => {
+    logger.error(`Installation failed: ${error.message}`);
+    process.exit(1);
+  });
 }

package/lib/log.js

@@ -0,0 +1,35 @@
+import winston from "winston";
+import { join } from "path";
+import { INSTALLROOT } from "./constants.js";
+
+const LOG_FILE = join(INSTALLROOT, "npm.log");
+
+// Create winston logger instance
+const logger = winston.createLogger({
+  level: "info",
+  format: winston.format.combine(
+    winston.format.timestamp({
+      format: "YYYY-MM-DDTHH:mm:ss.SSSZ",
+    }),
+    winston.format.printf(
+      ({ timestamp, level, message }) =>
+        `[${timestamp}] [${level.toUpperCase()}] ${message}`,
+    ),
+  ),
+  transports: [
+    new winston.transports.File({
+      filename: LOG_FILE,
+      handleExceptions: false,
+      handleRejections: false,
+    }),
+  ],
+  exitOnError: false,
+});
+
+// Prevent winston from crashing on errors
+logger.on("error", () => {
+  // Silently ignore errors from the winston logger itself
+});
+
+export default logger;
+

package/lib/version.js

@@ -0,0 +1,64 @@
+import { spawn } from "child_process";
+import { join, dirname } from "path";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import logger from "../lib/log.js";
+import { INSTALLROOT, binaryPath } from "./constants.js";
+
+/**
+ * Reads the npm package version from package.json
+ * @returns {string} The version string (e.g., "2.3.660")
+ */
+export function getPackageVersion() {
+  try {
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const packageJson = JSON.parse(
+      readFileSync(join(__dirname, "..", "package.json"), "utf8"),
+    );
+    if (!packageJson.version) {
+      throw new Error("No version found in package.json");
+    }
+    return packageJson.version;
+  } catch (error) {
+    throw new Error(`Failed to read package version: ${error.message}`);
+  }
+}
+
+/**
+ * Retrieves the version of the installed proxymock binary
+ * @returns {Promise<string|null>} The installed version (e.g., "v2.3.660") or null if unable to determine
+ */
+export async function getInstalledVersion() {
+  return new Promise((resolve) => {
+    const child = spawn(binaryPath, [
+      "version",
+      "--client",
+      "--output",
+      "pretty",
+    ]);
+
+    let stdout = "";
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+
+    child.on("exit", (code) => {
+      if (code !== 0) {
+        logger.error(`Failed to get proxymock version - exit code: ${code}`);
+        resolve(null);
+        return;
+      }
+
+      // With --output pretty, it just prints the version string directly
+      const version = stdout.trim();
+      resolve(version);
+    });
+
+    child.on("error", (err) => {
+      logger.error(
+        `Error spawning proxymock for version check: ${err.message}`,
+      );
+      resolve(null);
+    });
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@speedscale/proxymock",
-  "version": "2.3.661",
+  "version": "2.3.677",
   "description": "A free desktop CLI that automatically creates mocks and tests from watching your app run.",
   "keywords": [
     "api",
@@ -34,5 +34,8 @@
   "scripts": {
     "test": "node --test || echo 'No tests defined'",
     "validate": "npm pack && echo 'Package validation complete'"
+  },
+  "dependencies": {
+    "winston": "^3.11.0"
   }
 }