@aptove/bridge 0.1.11 → 0.1.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aptove/bridge",
-  "version": "0.1.11",
+  "version": "0.1.14",
   "description": "ACP bridge — connects ACP agents to mobile and desktop clients over WebSocket",
   "license": "MIT",
   "repository": {
@@ -33,10 +33,10 @@
     "node": ">=16"
   },
   "optionalDependencies": {
-    "@aptove/bridge-darwin-arm64": "0.1.11",
-    "@aptove/bridge-darwin-x64": "0.1.11",
-    "@aptove/bridge-linux-arm64": "0.1.11",
-    "@aptove/bridge-linux-x64": "0.1.11",
-    "@aptove/bridge-win32-x64": "0.1.11"
+    "@aptove/bridge-darwin-arm64": "0.1.14",
+    "@aptove/bridge-darwin-x64": "0.1.14",
+    "@aptove/bridge-linux-arm64": "0.1.14",
+    "@aptove/bridge-linux-x64": "0.1.14",
+    "@aptove/bridge-win32-x64": "0.1.14"
   }
 }

package/postinstall.js

@@ -1,11 +1,13 @@
 /**
  * bridge postinstall script
  *
- * Checks whether the platform-specific binary package was installed.
- * npm sometimes skips optional dependencies during global installs.
- * If so, prints the exact command to complete installation.
+ * Ensures the platform-specific binary package is installed at the correct version.
+ * npm sometimes skips optional dependencies during global installs, so we detect
+ * this and install the platform package explicitly if needed.
+ * Validates the final binary by running it with --version.
  */
 
+const { execSync, spawnSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
 
@@ -17,31 +19,150 @@ const PLATFORM_PACKAGES = {
   'win32-x64':    '@aptove/bridge-win32-x64',
 };
 
-const platformKey = `${process.platform}-${process.arch}`;
-const packageName = PLATFORM_PACKAGES[platformKey];
+function isBinaryPresent(binaryPath) {
+  return fs.existsSync(binaryPath);
+}
+
+// Ensures the binary has executable permissions (no-op on Windows).
+function ensureExecutable(binaryPath) {
+  if (process.platform === 'win32') return;
+  try {
+    fs.chmodSync(binaryPath, 0o755);
+  } catch (e) {
+    // best-effort
+  }
+}
+
+// Returns the version string from `bridge --version` (e.g. "0.1.12"), or null on failure.
+function getBinaryVersion(binaryPath) {
+  const result = spawnSync(binaryPath, ['--version'], { stdio: 'pipe' });
+  if (result.error || result.status !== 0) return null;
+  const output = (result.stdout || '').toString().trim(); // e.g. "bridge 0.1.12"
+  const parts = output.split(' ');
+  return parts.length >= 2 ? parts[1] : output;
+}
 
-if (!packageName) {
-  console.warn(`⚠️  bridge: unsupported platform ${platformKey}`);
-  process.exit(0);
+// Reads the expected platform package version from the main package's optionalDependencies.
+function getExpectedVersion(packageJsonPath) {
+  try {
+    delete require.cache[require.resolve(packageJsonPath)];
+    const pkg = require(packageJsonPath);
+    // optionalDependencies values are updated by the release workflow to match the published version
+    const deps = pkg.optionalDependencies || {};
+    const versions = Object.values(deps).filter(v => v !== '*');
+    return versions[0] || pkg.version;
+  } catch (e) {
+    return null;
+  }
 }
 
-const binaryName = process.platform === 'win32' ? 'bridge.exe' : 'bridge';
-let installed = false;
+/**
+ * Main postinstall logic.
+ *
+ * All I/O is injectable for testing:
+ *   baseDir        — replaces __dirname for computing the sibling binary path
+ *   packageJsonPath— path to the main package's package.json
+ *   platformKey    — override platform detection (default: process.platform-process.arch)
+ *   npmPrefix      — override npm_config_prefix
+ *   installFn      — (packageName, version) => void; throws on failure
+ *                    defaults to running `npm install` via execSync
+ *   log / warn     — console.log / console.warn replacements
+ *   exitFn         — process.exit replacement
+ */
+function main({
+  baseDir = __dirname,
+  packageJsonPath = path.join(__dirname, 'package.json'),
+  platformKey = `${process.platform}-${process.arch}`,
+  npmPrefix = process.env.npm_config_prefix,
+  installFn = null,
+  log = (...a) => console.log(...a),
+  warn = (...a) => console.warn(...a),
+  exitFn = process.exit,
+} = {}) {
+  const packageName = PLATFORM_PACKAGES[platformKey];
+
+  if (!packageName) {
+    warn(`⚠️  bridge: unsupported platform ${platformKey}`);
+    exitFn(0); return;
+  }
+
+  const binaryName = process.platform === 'win32' ? 'bridge.exe' : 'bridge';
+  const shortName = packageName.split('/')[1]; // e.g. "bridge-darwin-arm64"
+
+  // postinstall.js lives at @aptove/bridge/postinstall.js
+  // platform binary lives at @aptove/bridge-darwin-arm64/bin/bridge (sibling package)
+  const siblingBinaryPath = path.join(baseDir, '..', shortName, 'bin', binaryName);
+
+  function tryInstall(version) {
+    const fn = installFn || ((pkg, ver) => {
+      const prefixFlag = npmPrefix ? `--prefix "${npmPrefix}"` : '';
+      execSync(
+        `npm install ${prefixFlag} --no-save --no-audit --no-fund "${pkg}@${ver}"`,
+        { stdio: 'inherit' }
+      );
+    });
+    try {
+      log(`  Installing ${packageName}@${version}...`);
+      fn(packageName, version);
+      // GitHub artifact uploads strip execute permissions; restore them.
+      if (isBinaryPresent(siblingBinaryPath)) ensureExecutable(siblingBinaryPath);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
 
-try {
-  const packageJsonPath = require.resolve(`${packageName}/package.json`);
-  const binaryPath = path.join(path.dirname(packageJsonPath), 'bin', binaryName);
-  installed = fs.existsSync(binaryPath);
-} catch (e) {
-  // package not installed
+  const expectedVersion = getExpectedVersion(packageJsonPath);
+
+  if (isBinaryPresent(siblingBinaryPath)) {
+    // Fix permissions in case the binary was published without the execute bit
+    // (GitHub Actions artifacts do not preserve file permissions).
+    ensureExecutable(siblingBinaryPath);
+    const installedVersion = getBinaryVersion(siblingBinaryPath);
+    if (installedVersion && expectedVersion && installedVersion !== expectedVersion) {
+      log(`⬆  bridge: updating platform binary ${installedVersion} → ${expectedVersion}...`);
+      if (!tryInstall(expectedVersion)) {
+        warn(`⚠️  bridge: update failed — run: npm install -g ${packageName}@${expectedVersion}`);
+        exitFn(0); return;
+      }
+    } else {
+      log(`✓ bridge ${installedVersion || '(unknown)'} installed successfully for ${platformKey}`);
+      exitFn(0); return;
+    }
+  } else {
+    log(`\n⬇  bridge: platform binary not found, installing ${packageName}...`);
+    if (!tryInstall(expectedVersion || 'latest')) {
+      warn(`\n⚠️  bridge: failed to install ${packageName}`);
+      warn(`   Run manually: npm install -g ${packageName}${expectedVersion ? '@' + expectedVersion : ''}`);
+      exitFn(0); return;
+    }
+  }
+
+  // Validate after install using sibling path directly.
+  // (require.resolve cannot be used here — Node.js caches negative module
+  // resolution results within the same process.)
+  if (isBinaryPresent(siblingBinaryPath)) {
+    ensureExecutable(siblingBinaryPath);
+    const installedVersion = getBinaryVersion(siblingBinaryPath);
+    if (installedVersion) {
+      if (expectedVersion && installedVersion !== expectedVersion) {
+        warn(`⚠️  bridge: installed ${installedVersion} but expected ${expectedVersion} (may not be published yet)`);
+      } else {
+        log(`✓ bridge ${installedVersion} installed successfully for ${platformKey}`);
+      }
+    } else {
+      warn(`⚠️  bridge: binary present but failed to run — try: ${siblingBinaryPath} --version`);
+    }
+  } else {
+    warn(`\n⚠️  bridge: binary not found after installation`);
+    warn(`   Run manually: npm install -g ${packageName}${expectedVersion ? '@' + expectedVersion : ''}`);
+  }
+
+  exitFn(0);
 }
 
-if (installed) {
-  console.log(`✓ bridge installed successfully for ${platformKey}`);
-} else {
-  console.log('');
-  console.log(`⚠️  bridge: platform binary not found (npm skipped optional dependency)`);
-  console.log(`   To complete installation, run:`);
-  console.log(`     npm install -g ${packageName}`);
-  console.log('');
+module.exports = { main, PLATFORM_PACKAGES, isBinaryPresent, ensureExecutable, getBinaryVersion, getExpectedVersion };
+
+if (require.main === module) {
+  main();
 }