agent-takkub 1.0.84 → 1.0.86

package/npm/bin/agent-takkub.js

@@ -2,12 +2,25 @@
 'use strict';
 // Launches the cockpit GUI from the provisioned (isolated) venv.
 const { spawnSync } = require('child_process');
-const { venvPythonIfExists } = require('../scripts/lib');
+const {
+  venvPythonIfExists,
+  pythonLooksExecutable,
+  brokenInterpreterMessage,
+  agentTakkubHome,
+} = require('../scripts/lib');
 
 const py = venvPythonIfExists();
 if (!py) {
   console.error('agent-takkub is not provisioned. Run: npm install -g agent-takkub');
   process.exit(1);
 }
+if (!pythonLooksExecutable(py)) {
+  console.error(brokenInterpreterMessage(py, agentTakkubHome()));
+  process.exit(1);
+}
 const r = spawnSync(py, ['-m', 'agent_takkub', ...process.argv.slice(2)], { stdio: 'inherit' });
+if (r.error) {
+  console.error(`[agent-takkub] failed to launch the cockpit interpreter: ${r.error.message}`);
+  process.exit(1);
+}
 process.exit(r.status == null ? 1 : r.status);

package/npm/bin/takkub.js

@@ -2,12 +2,28 @@
 'use strict';
 // The `takkub` CLI, run from the provisioned (isolated) venv.
 const { spawnSync } = require('child_process');
-const { venvPythonIfExists } = require('../scripts/lib');
+const {
+  venvPythonIfExists,
+  pythonLooksExecutable,
+  brokenInterpreterMessage,
+  agentTakkubHome,
+} = require('../scripts/lib');
 
 const py = venvPythonIfExists();
 if (!py) {
   console.error('takkub is not provisioned. Run: npm install -g agent-takkub');
   process.exit(1);
 }
+if (!pythonLooksExecutable(py)) {
+  console.error(brokenInterpreterMessage(py, agentTakkubHome()));
+  process.exit(1);
+}
 const r = spawnSync(py, ['-m', 'agent_takkub.cli', ...process.argv.slice(2)], { stdio: 'inherit' });
+if (r.error) {
+  // spawnSync itself failed (e.g. the interpreter passed validation above
+  // but the OS still refused to launch it) — never let this read as a
+  // quiet success (#341).
+  console.error(`[takkub] failed to launch the cockpit interpreter: ${r.error.message}`);
+  process.exit(1);
+}
 process.exit(r.status == null ? 1 : r.status);

package/npm/scripts/lib.js

@@ -31,6 +31,71 @@ function venvPythonIfExists() {
   return fs.existsSync(p) ? p : null;
 }
 
+// Pick the wheel matching an exact version out of a dist/ dir — never the
+// lexically-last filename. A string sort puts "1.0.9" after "1.0.10" (#340),
+// and dist/ is gitignored so a stale wheel from a previous release can sit
+// there unnoticed. `version` is the SemVer string as read from package.json;
+// the filename convention (setuptools normalizes the project name's `-` to
+// `_`) is `agent_takkub-{version}-py3-none-any.whl`.
+function findWheelForVersion(distDir, version) {
+  if (!fs.existsSync(distDir)) return null;
+  const prefix = `agent_takkub-${version}-`;
+  const match = fs.readdirSync(distDir).find((f) => f.endsWith('.whl') && f.startsWith(prefix));
+  return match ? path.join(distDir, match) : null;
+}
+
+// A venv python that EXISTS but was overwritten/truncated by something
+// outside agent-takkub (#341 — a stray tool once clobbered a live
+// ~/.agent-takkub/venv/Scripts/python.exe with a 29-byte text file) must
+// never be handed to spawnSync: every command built on top of it then fails
+// to even start, with EMPTY stdout/stderr and no diagnostic — the cockpit
+// "dies silently". This check is deliberately static (stat + a couple of
+// header bytes, no attempt to execute the file) so a broken interpreter is
+// never spawned at all — spawning it is exactly the risky step that can
+// leave the file locked/hard to overwrite during recovery.
+const MIN_PYTHON_EXE_BYTES = 40 * 1024; // a real venv python.exe/python is comfortably >90KB
+
+function pythonLooksExecutable(py) {
+  let stat;
+  try {
+    stat = fs.statSync(py);
+  } catch (_e) {
+    return false;
+  }
+  if (!stat.isFile() || stat.size < MIN_PYTHON_EXE_BYTES) return false;
+  if (process.platform === 'win32') {
+    // Windows PE executables always start with the 'MZ' DOS-header magic.
+    let fd;
+    try {
+      fd = fs.openSync(py, 'r');
+      const buf = Buffer.alloc(2);
+      fs.readSync(fd, buf, 0, 2, 0);
+      return buf[0] === 0x4d && buf[1] === 0x5a; // 'M', 'Z'
+    } catch (_e) {
+      return false;
+    } finally {
+      if (fd !== undefined) fs.closeSync(fd);
+    }
+  }
+  return true;
+}
+
+function brokenInterpreterMessage(py, home) {
+  const venvDirPath = path.join(home, 'venv');
+  return (
+    `[agent-takkub] the cockpit interpreter looks broken (exists but is not a real executable):\n` +
+    `    ${py}\n` +
+    '    Something outside agent-takkub overwrote or truncated this file — the cockpit\n' +
+    '    did not do this to itself. Fix:\n' +
+    '      1) close every running cockpit/takkub window and process for this install\n' +
+    '      2) run: npm install -g agent-takkub --force   (reprovisions the venv in place)\n' +
+    `      3) if step 2 still can't overwrite it, delete this folder by hand:\n` +
+    `             ${venvDirPath}\n` +
+    '         then re-run npm install -g agent-takkub\n' +
+    '    `takkub doctor` (once the interpreter itself works again) also checks this.'
+  );
+}
+
 // Windowless python for GUI launchers (Windows: pythonw.exe = no console
 // window pops up behind the cockpit). macOS has no separate pythonw.
 function venvPythonw() {
@@ -40,4 +105,13 @@ function venvPythonw() {
     : path.join(dir, 'bin', 'python');
 }
 
-module.exports = { agentTakkubHome, venvDir, venvPython, venvPythonIfExists, venvPythonw };
+module.exports = {
+  agentTakkubHome,
+  venvDir,
+  venvPython,
+  venvPythonIfExists,
+  venvPythonw,
+  findWheelForVersion,
+  pythonLooksExecutable,
+  brokenInterpreterMessage,
+};

package/npm/scripts/postinstall.js

@@ -15,15 +15,18 @@
 const { spawnSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
-const { agentTakkubHome, venvDir, venvPython } = require('./lib');
+const { agentTakkubHome, venvDir, venvPython, findWheelForVersion } = require('./lib');
 const preflight = require('./preflight');
 
+// The wheel matching THIS install's declared version (#340) — not the
+// lexically-last filename in dist/. A string sort put "1.0.9" after
+// "1.0.10", and a stale wheel from a previous release (dist/ is gitignored,
+// so nothing flags it) got installed silently under a newer version number.
 function findWheel() {
   // Shipped alongside this package under dist/ (see package.json `files`).
   const dist = path.join(__dirname, '..', '..', 'dist');
-  if (!fs.existsSync(dist)) return null;
-  const whl = fs.readdirSync(dist).filter((f) => f.endsWith('.whl')).sort();
-  return whl.length ? path.join(dist, whl[whl.length - 1]) : null;
+  const version = require('../../package.json').version;
+  return findWheelForVersion(dist, version);
 }
 
 function run(cmd, args) {

package/npm/scripts/preflight-publish.js

@@ -0,0 +1,62 @@
+'use strict';
+// `npm publish` preflight guard (#340) — wired as `prepublishOnly` so it runs
+// automatically. dist/ is gitignored, so a wheel left over from a previous
+// `takkub release` sits there unnoticed; without this check `npm publish`
+// happily tars up that stale wheel under the NEW version number (v1.0.84
+// shipped v1.0.82's code, see issue #340). Dies loudly instead of warning —
+// a silent old-code publish is worse than a blocked one.
+
+const fs = require('fs');
+const path = require('path');
+const { findWheelForVersion } = require('./lib');
+
+function checkDistWheelMatchesVersion(distDir, version) {
+  if (!fs.existsSync(distDir)) {
+    return {
+      ok: false,
+      reason: `dist/ not found — build first: python -m build --wheel`,
+    };
+  }
+  const whls = fs.readdirSync(distDir).filter((f) => f.endsWith('.whl'));
+  if (whls.length === 0) {
+    return {
+      ok: false,
+      reason: `dist/ has no wheel — build first: python -m build --wheel`,
+    };
+  }
+  if (whls.length > 1) {
+    return {
+      ok: false,
+      reason:
+        `dist/ has ${whls.length} wheels (expected exactly one): ${whls.join(', ')} — ` +
+        `rebuild clean: rm -f dist/*.whl && python -m build --wheel`,
+    };
+  }
+  const wheel = findWheelForVersion(distDir, version);
+  if (!wheel) {
+    return {
+      ok: false,
+      reason:
+        `dist/${whls[0]} does not match package.json version ${version} — ` +
+        `rebuild: rm -f dist/*.whl && python -m build --wheel`,
+    };
+  }
+  return { ok: true, wheel: path.basename(wheel) };
+}
+
+function main() {
+  const pkg = require('../../package.json');
+  const dist = path.join(__dirname, '..', '..', 'dist');
+  const result = checkDistWheelMatchesVersion(dist, pkg.version);
+  if (!result.ok) {
+    console.error(`[agent-takkub] publish preflight FAILED: ${result.reason}`);
+    process.exit(1);
+  }
+  console.log(`[agent-takkub] publish preflight OK — dist/${result.wheel} matches package.json ${pkg.version}`);
+}
+
+module.exports = { checkDistWheelMatchesVersion };
+
+if (require.main === module) {
+  main();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-takkub",
-  "version": "1.0.84",
+  "version": "1.0.86",
   "description": "Desktop cockpit for orchestrating a team of Claude Code agents (Windows + macOS). Install globally: npm i -g agent-takkub",
   "keywords": [
     "claude",
@@ -26,10 +26,13 @@
     "takkub": "npm/bin/takkub.js"
   },
   "scripts": {
-    "postinstall": "node npm/scripts/postinstall.js"
+    "postinstall": "node npm/scripts/postinstall.js",
+    "prepublishOnly": "node npm/scripts/preflight-publish.js",
+    "test": "node --test npm/scripts/*.test.js"
   },
   "files": [
     "npm/",
+    "!npm/scripts/*.test.js",
     "dist/*.whl",
     "assets/icon.ico",
     "assets/icon.png",