@bulletproof-sh/ctrl-daemon 0.2.0-beta.5 → 0.2.0

package/bin/ctrl-daemon.cjs

@@ -53,7 +53,7 @@ if (!binaryPath) {
 	console.error(
 		`ctrl-daemon: no binary available for ${key}.\n\n` +
 			`Supported platforms: ${supported}\n` +
-			'If you installed with --no-optional, reinstall without that flag.',
+			'Try reinstalling, or set CTRL_DAEMON_BINARY_PATH to a compiled binary.',
 	);
 	process.exit(1);
 }

package/bin/install.js

@@ -0,0 +1,266 @@
+#!/usr/bin/env node
+/* eslint-disable */
+// @ts-nocheck
+
+/**
+ * ctrl-daemon postinstall — fallback binary downloader.
+ *
+ * Runs automatically after `npm install @bulletproof-sh/ctrl-daemon`.
+ * npm has a known bug where `npx` sometimes skips optionalDependencies,
+ * leaving the platform binary missing. This script detects that case and
+ * downloads the tarball directly from the npm registry.
+ *
+ * Resolution order:
+ *   1. Binary already installed via optionalDependencies → exit 0 silently
+ *   2. Download tarball from npm registry, extract binary, write to node_modules
+ *   3. Any failure → log warning + exit 0 (never break npm install)
+ */
+
+import fs from 'node:fs';
+import https from 'node:https';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import zlib from 'node:zlib';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const platformPackages = {
+	'darwin-arm64': '@bulletproof-sh/ctrl-daemon-darwin-arm64',
+	'darwin-x64': '@bulletproof-sh/ctrl-daemon-darwin-x64',
+	'linux-arm64': '@bulletproof-sh/ctrl-daemon-linux-arm64',
+	'linux-x64': '@bulletproof-sh/ctrl-daemon-linux-x64',
+	'win32-x64': '@bulletproof-sh/ctrl-daemon-windows-x64',
+};
+
+function getPlatformKey() {
+	return `${process.platform}-${process.arch}`;
+}
+
+function getBinName() {
+	return process.platform === 'win32' ? 'ctrl-daemon.exe' : 'ctrl-daemon';
+}
+
+/**
+ * __dirname is .../node_modules/@bulletproof-sh/ctrl-daemon/bin/
+ * Go up: bin/ -> ctrl-daemon/ -> @bulletproof-sh/ -> node_modules/
+ */
+function getNodeModulesDir() {
+	return path.resolve(__dirname, '..', '..', '..');
+}
+
+function getInstalledBinaryPath(platformPkg) {
+	const nodeModules = getNodeModulesDir();
+	const binName = getBinName();
+	return path.join(nodeModules, platformPkg, 'bin', binName);
+}
+
+function binaryAlreadyInstalled(platformPkg) {
+	const binPath = getInstalledBinaryPath(platformPkg);
+	try {
+		fs.accessSync(binPath, fs.constants.X_OK);
+		return true;
+	} catch {
+		return fs.existsSync(binPath);
+	}
+}
+
+function getOwnVersion() {
+	const pkgPath = path.resolve(__dirname, '..', 'package.json');
+	const raw = fs.readFileSync(pkgPath, 'utf8');
+	const pkg = JSON.parse(raw);
+	return pkg.version;
+}
+
+function getRegistryBase() {
+	const configured = process.env.npm_config_registry;
+	if (configured) {
+		return configured.replace(/\/$/, '');
+	}
+	return 'https://registry.npmjs.org';
+}
+
+function buildTarballUrl(platformPkg, version) {
+	const registry = getRegistryBase();
+	const shortName = platformPkg.split('/')[1];
+	return `${registry}/${platformPkg}/-/${shortName}-${version}.tgz`;
+}
+
+/**
+ * Fetch a URL, following up to `maxRedirects` 3xx redirects.
+ * Resolves with the IncomingMessage of the final response.
+ */
+function fetchWithRedirects(url, maxRedirects) {
+	return new Promise((resolve, reject) => {
+		function doFetch(currentUrl, remaining) {
+			https
+				.get(currentUrl, (res) => {
+					if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+						if (remaining === 0) {
+							reject(new Error(`Too many redirects fetching ${url}`));
+							return;
+						}
+						res.resume();
+						doFetch(res.headers.location, remaining - 1);
+						return;
+					}
+					resolve(res);
+				})
+				.on('error', reject);
+		}
+		doFetch(url, maxRedirects);
+	});
+}
+
+/**
+ * Parse the NUL-terminated filename from a tar header block (bytes 0-99).
+ */
+function parseTarFilename(header) {
+	let nameEnd = 0;
+	while (nameEnd < 100 && header[nameEnd] !== 0) {
+		nameEnd++;
+	}
+	return header.slice(0, nameEnd).toString('utf8');
+}
+
+/**
+ * Parse the file size from a tar header block (bytes 124-135, octal ASCII).
+ */
+function parseTarFileSize(header) {
+	let sizeStr = '';
+	for (let i = 124; i < 136; i++) {
+		const c = header[i];
+		if (c === 0 || c === 0x20) {
+			break;
+		}
+		sizeStr += String.fromCharCode(c);
+	}
+	return Number.parseInt(sizeStr, 8) || 0;
+}
+
+/**
+ * Scan the inflated tar buffer for a file matching targetRelativePath.
+ * Returns the file's raw bytes, or null if not found.
+ *
+ * npm tarballs are gzipped POSIX ustar archives. Each entry consists of:
+ *   - A 512-byte header block
+ *   - ceil(fileSize / 512) * 512 bytes of data (padded with NUL bytes)
+ *
+ * Header layout (bytes):
+ *   0-99:   filename (NUL-terminated)
+ *   124-135: file size in octal ASCII (NUL/space-terminated)
+ *   156:    type flag ('0' or NUL = regular file)
+ *
+ * Files inside npm tarballs are prefixed with `package/`.
+ */
+function scanTarBuffer(buf, targetRelativePath) {
+	let offset = 0;
+	while (offset + 512 <= buf.length) {
+		const header = buf.slice(offset, offset + 512);
+
+		// Two consecutive zero blocks = end of archive
+		if (isZeroBlock(header)) {
+			break;
+		}
+
+		const name = parseTarFilename(header);
+		const fileSize = parseTarFileSize(header);
+		// Type flag byte 156: '0' (0x30) or NUL = regular file
+		const typeFlag = header[156];
+		const isRegularFile = typeFlag === 0x30 || typeFlag === 0;
+
+		offset += 512;
+
+		if (isRegularFile && name === targetRelativePath) {
+			return buf.slice(offset, offset + fileSize);
+		}
+
+		offset += Math.ceil(fileSize / 512) * 512;
+	}
+	return null;
+}
+
+function isZeroBlock(header) {
+	for (let i = 0; i < 512; i++) {
+		if (header[i] !== 0) {
+			return false;
+		}
+	}
+	return true;
+}
+
+/**
+ * Parse a gzipped POSIX tar stream and extract a single file by name.
+ */
+function extractBinaryFromTarball(tarballStream, targetRelativePath) {
+	return new Promise((resolve, reject) => {
+		const gunzip = zlib.createGunzip();
+		tarballStream.pipe(gunzip);
+
+		const chunks = [];
+		gunzip.on('data', (chunk) => chunks.push(chunk));
+		gunzip.on('error', reject);
+		gunzip.on('end', () => {
+			const buf = Buffer.concat(chunks);
+			const data = scanTarBuffer(buf, targetRelativePath);
+			if (data !== null) {
+				resolve(data);
+			} else {
+				reject(new Error(`Binary '${targetRelativePath}' not found in tarball`));
+			}
+		});
+	});
+}
+
+async function downloadAndInstall(platformPkg, version) {
+	const nodeModules = getNodeModulesDir();
+	const binName = getBinName();
+	const tarballUrl = buildTarballUrl(platformPkg, version);
+
+	console.log(`ctrl-daemon: downloading ${platformPkg}@${version} from npm...`);
+
+	const res = await fetchWithRedirects(tarballUrl, 5);
+
+	if (res.statusCode !== 200) {
+		throw new Error(`HTTP ${res.statusCode} fetching ${tarballUrl}`);
+	}
+
+	const targetRelativePath = `package/bin/${binName}`;
+	const binaryData = await extractBinaryFromTarball(res, targetRelativePath);
+
+	const pkgDir = path.join(nodeModules, platformPkg);
+	const binDir = path.join(pkgDir, 'bin');
+	fs.mkdirSync(binDir, { recursive: true });
+
+	const binPath = path.join(binDir, binName);
+	fs.writeFileSync(binPath, binaryData);
+	fs.chmodSync(binPath, 0o755);
+
+	const pkgJson = { name: platformPkg, version: version };
+	fs.writeFileSync(path.join(pkgDir, 'package.json'), `${JSON.stringify(pkgJson, null, 2)}\n`);
+
+	console.log(`ctrl-daemon: installed binary to ${binPath}`);
+}
+
+async function main() {
+	const key = getPlatformKey();
+	const platformPkg = platformPackages[key];
+
+	if (!platformPkg) {
+		return;
+	}
+
+	if (binaryAlreadyInstalled(platformPkg)) {
+		return;
+	}
+
+	const version = getOwnVersion();
+
+	try {
+		await downloadAndInstall(platformPkg, version);
+	} catch (err) {
+		console.warn(`ctrl-daemon: postinstall fallback download failed: ${err.message}`);
+		console.warn('ctrl-daemon: if this persists, set CTRL_DAEMON_BINARY_PATH to a compiled binary.');
+	}
+}
+
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@bulletproof-sh/ctrl-daemon",
-	"version": "0.2.0-beta.5",
+	"version": "0.2.0",
 	"description": "WebSocket daemon for ctrl — watches Claude Code sessions and broadcasts agent state",
 	"type": "module",
 	"license": "BUSL-1.1",
@@ -11,6 +11,7 @@
 		"bin/"
 	],
 	"scripts": {
+		"postinstall": "node bin/install.js",
 		"dev": "bun --watch src/index.ts",
 		"start": "bun src/index.ts",
 		"build": "bun build src/index.ts --outdir dist --target bun --minify",
@@ -27,11 +28,11 @@
 		"vitest": "^4.0.18"
 	},
 	"optionalDependencies": {
-		"@bulletproof-sh/ctrl-daemon-darwin-arm64": "0.2.0-beta.5",
-		"@bulletproof-sh/ctrl-daemon-darwin-x64": "0.2.0-beta.5",
-		"@bulletproof-sh/ctrl-daemon-linux-arm64": "0.2.0-beta.5",
-		"@bulletproof-sh/ctrl-daemon-linux-x64": "0.2.0-beta.5",
-		"@bulletproof-sh/ctrl-daemon-windows-x64": "0.2.0-beta.5"
+		"@bulletproof-sh/ctrl-daemon-darwin-arm64": "0.2.0",
+		"@bulletproof-sh/ctrl-daemon-darwin-x64": "0.2.0",
+		"@bulletproof-sh/ctrl-daemon-linux-arm64": "0.2.0",
+		"@bulletproof-sh/ctrl-daemon-linux-x64": "0.2.0",
+		"@bulletproof-sh/ctrl-daemon-windows-x64": "0.2.0"
 	},
 	"dependencies": {
 		"posthog-node": "^5.26.0"