@golem-fail/golem 0.8.0

package/README.md

@@ -0,0 +1,47 @@
+# @golem-fail/golem
+
+Prebuilt-binary wrapper for [golem](https://github.com/golem-fail/golem), a
+mobile UI testing framework. Install it as a **per-project dev dependency** so
+the version is pinned in your lockfile — which dovetails with golem's
+host↔companion version lock for reproducible local + CI runs.
+
+```sh
+npm install -D @golem-fail/golem
+# or
+pnpm add -D @golem-fail/golem
+bun add -d @golem-fail/golem
+yarn add -D @golem-fail/golem
+```
+
+Then run it via `npx golem` (or a `package.json` script):
+
+```sh
+npx golem doctor
+npx golem run e2e/flow.test.toml
+```
+
+`postinstall` downloads a self-contained `golem` binary (iOS/Android companions
+baked in) matched to your platform and verifies its sha256. Driving devices
+still needs host tooling (`adb`, Xcode/simulators) — `golem doctor` checks it.
+
+macOS arm64 only for now (Linux is planned). The pinned version is downloaded by
+default; set `GOLEM_VERSION` to override.
+
+## pnpm / bun
+
+pnpm (v10+) and bun don't run dependency install scripts by default, so the
+`postinstall` download won't fire until you allow this package:
+
+- **pnpm** — add to your root `package.json`:
+  ```json
+  { "pnpm": { "onlyBuiltDependencies": ["@golem-fail/golem"] } }
+  ```
+  (or run `pnpm approve-builds`).
+- **bun** — add to your root `package.json`:
+  ```json
+  { "trustedDependencies": ["@golem-fail/golem"] }
+  ```
+
+npm and Yarn run it by default. If a download was skipped, `npx golem` prints a
+clear "native binary missing — reinstall" error rather than failing obscurely.
+

package/bin/cli.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+// Thin launcher: spawn the vendored native `golem` binary, forwarding argv,
+// stdio, and the exit code. The native binary is fetched by install.js
+// (postinstall). Kept as a JS shim so the published package always has a valid
+// `bin` target regardless of postinstall ordering.
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const { spawnSync } = require('child_process');
+
+const bin = path.join(__dirname, '..', 'vendor', 'golem');
+
+if (!fs.existsSync(bin)) {
+  console.error(
+    '@golem-fail/golem: native binary missing — reinstall the package ' +
+      '(the postinstall download may have been skipped or blocked).'
+  );
+  process.exit(1);
+}
+
+const result = spawnSync(bin, process.argv.slice(2), { stdio: 'inherit' });
+if (result.error) {
+  console.error(`@golem-fail/golem: failed to run golem: ${result.error.message}`);
+  process.exit(1);
+}
+process.exit(result.status === null ? 1 : result.status);

package/install.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+// postinstall: download the arch-matched prebuilt `golem` binary, verify its
+// sha256, and extract it into vendor/. The binary is self-contained (companions
+// baked in). The version is pinned to this package's version (so the lockfile
+// dovetails with the host↔companion lock); GOLEM_VERSION overrides it.
+//
+// Dependency-free by design: Node built-ins + the system `tar` (present on the
+// macOS/Linux targets we ship). GOLEM_BASE_URL points the download at a mirror
+// or a local dir laid out as <tag>/<asset> (used for offline tests).
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const { execFileSync } = require('child_process');
+
+const pkg = require('./package.json');
+
+const VERSION = process.env.GOLEM_VERSION || pkg.version;
+const BASE_URL =
+  process.env.GOLEM_BASE_URL ||
+  'https://github.com/golem-fail/golem/releases/download';
+const VENDOR = path.join(__dirname, 'vendor');
+const BIN = path.join(VENDOR, 'golem');
+
+function fail(msg) {
+  console.error(`@golem-fail/golem: ${msg}`);
+  process.exit(1);
+}
+
+function target() {
+  const p = process.platform;
+  const a = process.arch;
+  if (p === 'darwin' && a === 'arm64') return 'aarch64-apple-darwin';
+  // Linux triples are ready but no artifacts are published yet (deferred).
+  fail(
+    `unsupported platform ${p}/${a} — golem ships a prebuilt binary for macOS ` +
+      `arm64 only for now (build from source: cargo install --path golem-cli)`
+  );
+}
+
+// GET with redirect following, over http or https (local test servers use http).
+function get(url, redirectsLeft = 5) {
+  return new Promise((resolve, reject) => {
+    const lib = url.startsWith('https:') ? require('https') : require('http');
+    lib
+      .get(url, (res) => {
+        const { statusCode, headers } = res;
+        if (statusCode >= 300 && statusCode < 400 && headers.location) {
+          if (redirectsLeft === 0) return reject(new Error('too many redirects'));
+          res.resume();
+          const next = new URL(headers.location, url).toString();
+          return resolve(get(next, redirectsLeft - 1));
+        }
+        if (statusCode !== 200) {
+          res.resume();
+          return reject(new Error(`HTTP ${statusCode} for ${url}`));
+        }
+        const chunks = [];
+        res.on('data', (c) => chunks.push(c));
+        res.on('end', () => resolve(Buffer.concat(chunks)));
+      })
+      .on('error', reject);
+  });
+}
+
+async function main() {
+  if (process.env.GOLEM_SKIP_DOWNLOAD) {
+    console.error('@golem-fail/golem: GOLEM_SKIP_DOWNLOAD set — skipping binary download.');
+    return;
+  }
+
+  const triple = target();
+  const asset = `golem-${VERSION}-${triple}.tar.gz`;
+  const url = `${BASE_URL}/v${VERSION}/${asset}`;
+
+  console.error(`@golem-fail/golem: downloading ${asset}…`);
+  const [tarball, shaFile] = await Promise.all([get(url), get(`${url}.sha256`)]);
+
+  // Verify: the .sha256 payload is "<hex>  <filename>".
+  const expected = shaFile.toString('utf8').trim().split(/\s+/)[0];
+  const actual = crypto.createHash('sha256').update(tarball).digest('hex');
+  if (!expected || expected !== actual) {
+    fail(`checksum mismatch for ${asset} (expected ${expected || '<none>'}, got ${actual})`);
+  }
+
+  // Extract via system tar (no npm tar dependency).
+  fs.mkdirSync(VENDOR, { recursive: true });
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'golem-'));
+  const tarPath = path.join(tmp, asset);
+  fs.writeFileSync(tarPath, tarball);
+  try {
+    execFileSync('tar', ['xzf', tarPath, '-C', tmp]);
+  } catch (e) {
+    fail(`failed to extract ${asset}: ${e.message}`);
+  }
+  const extracted = path.join(tmp, 'golem');
+  if (!fs.existsSync(extracted)) fail(`archive did not contain a 'golem' binary`);
+  fs.copyFileSync(extracted, BIN);
+  fs.chmodSync(BIN, 0o755);
+  fs.rmSync(tmp, { recursive: true, force: true });
+
+  console.error(`@golem-fail/golem: installed golem ${VERSION} → ${BIN}`);
+  console.error('Next: run `npx golem doctor` to check your device toolchain.');
+}
+
+main().catch((e) => fail(e.message));

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@golem-fail/golem",
+  "version": "0.8.0",
+  "description": "Mobile UI testing framework — prebuilt binary wrapper for npm/bun/yarn",
+  "homepage": "https://golem.fail",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/golem-fail/golem.git",
+    "directory": "npm"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "bin": {
+    "golem": "bin/cli.js"
+  },
+  "files": [
+    "bin/cli.js",
+    "install.js"
+  ],
+  "scripts": {
+    "postinstall": "node install.js"
+  },
+  "os": [
+    "darwin"
+  ],
+  "cpu": [
+    "arm64"
+  ],
+  "engines": {
+    "node": ">=16"
+  }
+}