@robsonai/emilyremote 0.3.0

package/PROVENANCE.json

@@ -0,0 +1,18 @@
+{
+  "schema": "emilyremote.npm-provenance/1",
+  "display_name": "EmilyRemote",
+  "npm_package_name": "@robsonai/emilyremote",
+  "npm_name_status": "requested organization target; robsonai organization ownership and publication are pending verification",
+  "primary_command": "emilyremote",
+  "prior_distribution": {
+    "name": "@martinrobson/dialhome@0.2.0",
+    "status": "published; anonymous version metadata and tarball verified",
+    "tarball_sha256": "dfd56b3bd0f8e57b07559bf43551c05c58957732cd69e70c37a5fbbf86506326"
+  },
+  "sdk_version": "0.3.0",
+  "wheel": "vendor/robsonai_emilyremote-0.3.0-py3-none-any.whl",
+  "wheel_sha256": "e730b011b844dc70442fa793d29c98eb9df8dea5341ebbb49ba38fd73da0269e",
+  "source_changes": "Version 0.3.0 uses the emilyremote Python namespace and robsonai-emilyremote distribution, with release security fixes. Prior release test results do not certify this build.",
+  "scope": "Host Python runtime only; optional dependencies, Android APK, and microcontroller firmware are not installed by this npm wrapper",
+  "sdk_source": "RobsonAI EmilyRemote 0.3.0 release source, rebuilt after namespace and security changes"
+}

package/README.md

@@ -0,0 +1,125 @@
+# EmilyRemote by RobsonAI
+
+EmilyRemote installs the RobsonAI EmilyRemote 0.3.0 host SDK from a bundled,
+verified Python wheel. The Python namespace is `emilyremote`, the Python
+distribution is `robsonai-emilyremote`, and the command is `emilyremote`.
+The requested npm publication target is **`@robsonai/emilyremote`**. The display
+name is **EmilyRemote**; npm package names use lowercase. Organization ownership
+and publication are pending verification. The examples below become public
+installation commands after publication.
+
+## Install and initialize
+
+Requires Node.js 18 or newer and Python 3.11 or newer with `venv` and `ensurepip`.
+The wrapper has no external Node dependencies. The SDK core has no external
+Python dependencies.
+
+```bash
+npm install -g @robsonai/emilyremote@0.3.0
+emilyremote setup --python python3
+emilyremote self-check
+```
+
+Or use npx:
+
+```bash
+npx --yes --package=@robsonai/emilyremote@0.3.0 emilyremote setup --python python3
+npx --yes --package=@robsonai/emilyremote@0.3.0 emilyremote self-check
+```
+
+Installing the npm package runs no lifecycle hook. `setup` is an explicit action:
+it creates a private, versioned virtualenv and installs the bundled wheel using
+`pip --isolated --no-index --no-deps`. It checks the wheel SHA-256, installed
+metadata, every installed SDK Python file, and the SDK self-check before writing
+an atomic READY receipt. A failed attempt is retained for diagnosis and never
+published as a ready installation. A setup lock prevents simultaneous installers.
+If a process dies during setup, inspect the reported lock before removing it.
+
+Setup does not install system Python, Node, optional dependencies, operating
+system services, enroll a node, configure credentials, or start a worker.
+On Debian/Ubuntu, Python may require its matching `python3-venv` system package.
+The wrapper reports missing prerequisites and does not install them implicitly.
+
+## Isolated installation or local tarball
+
+```bash
+npm install --prefix ./npm-runtime --ignore-scripts --no-audit --no-fund ./robsonai-emilyremote-0.3.0.tgz
+./npm-runtime/node_modules/.bin/emilyremote setup --home ./emilyremote-state --python /usr/bin/python3
+./npm-runtime/node_modules/.bin/emilyremote --home ./emilyremote-state self-check
+./npm-runtime/node_modules/.bin/emilyremote --home ./emilyremote-state status
+```
+
+`--home` or `EMILYREMOTE_HOME` selects the installation directory. Otherwise the
+defaults are:
+
+| Platform | Default |
+| --- | --- |
+| Linux | `$XDG_DATA_HOME/robsonai/emilyremote`, otherwise `~/.local/share/robsonai/emilyremote` |
+| macOS | `~/Library/Application Support/RobsonAI/EmilyRemote` |
+| Windows | `%LOCALAPPDATA%\RobsonAI\EmilyRemote` |
+
+Choose a directory owned by your account with trusted parent directories.
+POSIX setup rejects writable shared ancestors, except root-owned sticky temporary
+directories, and rejects symlinked ancestors. Windows ACL behavior still needs
+native qualification; use the default per-user location.
+
+Use the same home for setup and subsequent commands. A new npm invocation can
+reuse the same verified runtime. `setup --python` accepts an executable path,
+including spaces, rather than a shell command. Windows setup also probes the
+`py -3` launcher when no executable is selected. PowerShell can invoke the npm
+generated `emilyremote.cmd` shim; use a Python executable path for `--python`.
+Only the `emilyremote` command is installed. The explicit npx `--package` form
+selects that command directly. For an unpublished local tarball, use
+`npx --offline --yes --package=./robsonai-emilyremote-0.3.0.tgz emilyremote --help`.
+
+## Upgrading from the earlier package
+
+The historical `@martinrobson/dialhome@0.2.0` distribution remains separate.
+Version 0.3.0 installs the fully renamed EmilyRemote package and command without
+adding a `dialhome` alias. Use `EMILYREMOTE_HOME` or the new default directory;
+`DIALHOME_HOME` is not read. Keep old installation files and operational state
+for reference until migration is verified. Create fresh runtime/node state and
+explicitly re-enroll as needed; do not assume old identity databases, receipt
+schemas, or running services migrate automatically. Installing this version
+does not remove the prior package or change its services.
+
+## SDK commands
+
+```bash
+emilyremote --home ./emilyremote-state node --config /absolute/path/node.json
+```
+
+Arguments are passed directly without a shell, using isolated Python mode.
+The caller's ordinary OS environment remains available to the SDK; Python path
+injection and pip index environment variables are removed. `--` stops wrapper
+option parsing. Node shutdown signals are forwarded to the Python process.
+
+Only commands explicitly requested by the caller run. The SDK's shell capability
+uses that process owner's OS permissions; this wrapper is not a sandbox. The
+wrapper's `status` reports package readiness, not a running service or enrollment.
+
+## Supported scope and validation
+
+This package installs the Python host runtime on systems that can provide the
+prerequisites. Linux package installation and self-check are verified for this
+release. macOS and Windows paths and launcher handling are implemented but still
+require native qualification. Core installation
+does not include the optional `cryptography`, `pyserial`, or `pymavlink` packages,
+local model weights, Android APK, Arduino/ESP32 firmware, or a controller service.
+It makes no claim that Emily can dispatch a task until that integration is tested.
+
+## Draft publication procedure
+
+1. Verify the authenticated account has publish rights for the `robsonai`
+   organization and target `@robsonai/emilyremote@0.3.0`. Review licensing before
+   publishing; the package currently declares `UNLICENSED`.
+2. Run `npm test`, `npm pack --json`, and test installation of the resulting
+   tarball into a fresh prefix and fresh EmilyRemote home.
+3. Review the packed file list and provenance. It contains the SDK wheel and
+   wrapper, with no node credentials or private keys.
+4. From the verified package directory, use `npm publish --access public` only
+   after publication is authorized and the registry authentication is ready.
+5. Verify the registry tarball integrity and repeat installation using the public
+   package name. Do not describe the npm URL as live before that check succeeds.
+
+`PROVENANCE.json` records the release wheel identity and historical distribution.

package/bin/emilyremote.cjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+'use strict';
+require('../lib/cli.cjs').main().then((code) => { process.exitCode = code; }).catch((error) => {
+  console.error(`EmilyRemote: ${error.message}`);
+  process.exitCode = 1;
+});

package/lib/cli.cjs

@@ -0,0 +1,282 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { spawn, spawnSync } = require('node:child_process');
+
+const VERSION = '0.3.0';
+const WHEEL_SHA = 'e730b011b844dc70442fa793d29c98eb9df8dea5341ebbb49ba38fd73da0269e';
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+const WHEEL = path.join(PACKAGE_ROOT, 'vendor', 'robsonai_emilyremote-0.3.0-py3-none-any.whl');
+const VERIFY = path.join(PACKAGE_ROOT, 'scripts', 'verify_install.py');
+
+const HELP = `EmilyRemote by RobsonAI ${VERSION}
+
+  emilyremote setup [--python PATH] [--home DIRECTORY]
+  emilyremote [--home DIRECTORY] <SDK command> [arguments...]
+  emilyremote status [--home DIRECTORY]
+
+Setup explicitly installs the bundled core SDK into your own versioned Python
+virtualenv. Python 3.11+ with venv/ensurepip is required. Installation is offline.
+Installing this npm package does not start setup, services, or enrollment.
+
+Examples:
+  emilyremote setup --python python3
+  emilyremote self-check
+  emilyremote node --config /path/to/node.json
+
+--home overrides EMILYREMOTE_HOME and the platform's per-user data directory.
+--python selects a Python executable only for setup. Use -- to stop wrapper
+option parsing. Other arguments pass directly to the SDK without a shell.
+Optional update/serial/vehicle dependencies are not bundled.
+`;
+
+function parseArgs(argv) {
+  let home, python;
+  const rest = [];
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--') { rest.push(...argv.slice(i + 1)); break; }
+    if (argv[i] === '--home' || argv[i] === '--python') {
+      const flag = argv[i];
+      if (!argv[i + 1] || argv[i + 1].startsWith('--')) throw new Error(`${flag} requires a value`);
+      if (flag === '--home') { if (home !== undefined) throw new Error('Duplicate --home'); home = argv[++i]; }
+      else { if (python !== undefined) throw new Error('Duplicate --python'); python = argv[++i]; }
+    } else rest.push(argv[i]);
+  }
+  if (python !== undefined && rest[0] !== 'setup') throw new Error('--python is supported only for setup');
+  return { home, python, command: rest[0], args: rest.slice(1) };
+}
+
+function defaultHome(env = process.env, platform = process.platform, userHome = os.homedir()) {
+  if (env.EMILYREMOTE_HOME) return path.resolve(env.EMILYREMOTE_HOME);
+  if (platform === 'win32') return path.join(env.LOCALAPPDATA || path.join(userHome, 'AppData', 'Local'), 'RobsonAI', 'EmilyRemote');
+  if (platform === 'darwin') return path.join(userHome, 'Library', 'Application Support', 'RobsonAI', 'EmilyRemote');
+  return path.join(env.XDG_DATA_HOME || path.join(userHome, '.local', 'share'), 'robsonai', 'emilyremote');
+}
+
+function sha(file) { return crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex'); }
+function checkWheel() { if (sha(WHEEL) !== WHEEL_SHA) throw new Error('Bundled SDK wheel failed its SHA-256 check; reinstall this npm package'); }
+function pythonPath(runtime, platform = process.platform) { return path.join(runtime, platform === 'win32' ? 'Scripts' : 'bin', platform === 'win32' ? 'python.exe' : 'python'); }
+function cleanEnv(env = process.env) {
+  const copy = { ...env };
+  // SDK children retain normal OS environment, but never inherit Python path
+  // injection or pip index settings from the calling npm process.
+  for (const key of Object.keys(copy)) if (/^(PYTHON|PIP_)/i.test(key)) delete copy[key];
+  copy.PYTHONDONTWRITEBYTECODE = '1';
+  return copy;
+}
+function privateDir(directory) { fs.mkdirSync(directory, { recursive: true, mode: 0o700 }); }
+function checkHomeAncestors(home) {
+  // A private leaf is insufficient if another account can replace a parent.
+  // Root-owned sticky temporary directories protect an owned child from rename.
+  let current = path.dirname(path.resolve(home));
+  while (true) {
+    try {
+      const stat = fs.lstatSync(current);
+      if (stat.isSymbolicLink()) throw new Error(`EmilyRemote home requires real directory ancestors; resolve this symlink first: ${current}`);
+      if (!stat.isDirectory()) throw new Error(`EmilyRemote home ancestor is not a directory: ${current}`);
+      if (process.platform !== 'win32') {
+        if (![0, process.getuid()].includes(stat.uid)) throw new Error(`EmilyRemote home ancestor is not owned by this user or root: ${current}`);
+        const protectedTemporary = stat.uid === 0 && (stat.mode & 0o1000);
+        if ((stat.mode & 0o022) && !protectedTemporary) throw new Error(`EmilyRemote home ancestor is writable by other users: ${current}`);
+      }
+    } catch (error) { if (error.code !== 'ENOENT') throw error; }
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+}
+function checkHomePath(home, target) {
+  checkHomeAncestors(home);
+  const relative = path.relative(home, target);
+  if (relative.startsWith('..' + path.sep) || relative === '..' || path.isAbsolute(relative)) throw new Error('Path escapes EmilyRemote home');
+  let current = home;
+  for (const segment of ['', ...relative.split(path.sep).filter(Boolean)]) {
+    if (segment) current = path.join(current, segment);
+    try {
+      const stat = fs.lstatSync(current);
+      if (stat.isSymbolicLink()) throw new Error(`Symlink refused inside EmilyRemote home: ${current}`);
+      if (process.platform !== 'win32' && stat.uid !== process.getuid()) throw new Error(`EmilyRemote state must belong to the current user: ${current}`);
+      if (process.platform !== 'win32' && (stat.mode & 0o022)) throw new Error(`EmilyRemote state must not be writable by other users: ${current}`);
+    }
+    catch (error) { if (error.code !== 'ENOENT') throw error; }
+  }
+}
+function homeDir(home, target) { checkHomePath(home, target); privateDir(target); }
+function writeJsonAtomic(destination, value) {
+  privateDir(path.dirname(destination));
+  const temp = `${destination}.${crypto.randomBytes(8).toString('hex')}.tmp`;
+  let fd;
+  try {
+    fd = fs.openSync(temp, 'wx', 0o600);
+    fs.writeFileSync(fd, JSON.stringify(value, null, 2) + '\n');
+    fs.fsyncSync(fd); fs.closeSync(fd); fd = undefined;
+    fs.renameSync(temp, destination);
+    if (process.platform !== 'win32') { const parent = fs.openSync(path.dirname(destination), 'r'); try { fs.fsyncSync(parent); } finally { fs.closeSync(parent); } }
+  } finally {
+    if (fd !== undefined) fs.closeSync(fd);
+    if (fs.existsSync(temp)) fs.unlinkSync(temp);
+  }
+}
+
+function runChecked(executable, args, options = {}, runner = spawnSync) {
+  const result = runner(executable, args, { shell: false, encoding: 'utf8', maxBuffer: 8 * 1024 * 1024,
+    timeout: 120000, windowsHide: true, env: cleanEnv(), ...options });
+  if (result.error) throw new Error(`Could not run ${path.basename(executable)}: ${result.error.code || result.error.message}`);
+  if (result.status !== 0) throw new Error(`Command failed (${result.status === null ? result.signal : result.status}): ${(result.stderr || result.stdout || '').trim().slice(-3000)}`);
+  return result.stdout || '';
+}
+function discoverPython(selected, runner = spawnSync) {
+  const candidates = selected ? [{ executable: selected, prefix: [] }] : process.platform === 'win32'
+    ? [{ executable: 'py', prefix: ['-3'] }, { executable: 'python', prefix: [] }]
+    : [{ executable: 'python3', prefix: [] }, { executable: 'python', prefix: [] }];
+  const problems = [];
+  for (const candidate of candidates) {
+    try {
+      const output = runChecked(candidate.executable, [...candidate.prefix, '-I', '-B', '-c',
+        'import json,sys; print(json.dumps({"version":list(sys.version_info[:3]),"executable":sys.executable}))'], { timeout: 15000 }, runner);
+      const info = JSON.parse(output);
+      if (info.version[0] !== 3 || info.version[1] < 11) throw new Error(`Python ${info.version.join('.')} is too old`);
+      if (!path.isAbsolute(info.executable)) throw new Error('Python did not report an absolute executable path');
+      return info;
+    } catch (error) { problems.push(`${candidate.executable}: ${error.message}`); }
+  }
+  throw new Error(`Python 3.11+ is required. Install it with venv/ensurepip support, then run emilyremote setup --python /absolute/path/to/python. ${problems.join('; ')}`);
+}
+
+function receiptPath(home) { return path.join(home, 'receipts', `${VERSION}.json`); }
+function readReceipt(home) {
+  const file = receiptPath(home);
+  checkHomePath(home, file);
+  if (!fs.existsSync(file)) throw new Error('SDK is not installed here. Run emilyremote setup first');
+  const receipt = JSON.parse(fs.readFileSync(file, 'utf8'));
+  if (receipt.state !== 'READY' || receipt.version !== VERSION || receipt.wheel_sha256 !== WHEEL_SHA) throw new Error('Installation receipt is not READY for this SDK version; run emilyremote setup');
+  if (typeof receipt.runtime_relative !== 'string' || path.isAbsolute(receipt.runtime_relative)) throw new Error('Invalid runtime path in installation receipt');
+  const root = path.resolve(home, 'runtimes', VERSION);
+  const runtime = path.resolve(home, receipt.runtime_relative);
+  if (!runtime.startsWith(root + path.sep) || runtime === root) throw new Error('Runtime path escapes the versioned installation directory');
+  checkHomePath(home, runtime);
+  if (!fs.existsSync(runtime) || !fs.realpathSync(runtime).startsWith(fs.realpathSync(root) + path.sep)) throw new Error('Runtime directory is missing or escapes its installation');
+  return { receipt, runtime };
+}
+function verifyInstalled(runtime, runner = spawnSync) {
+  checkWheel();
+  return JSON.parse(runChecked(pythonPath(runtime), ['-I', '-B', VERIFY, '--wheel', WHEEL, '--runtime', runtime], { timeout: 30000 }, runner));
+}
+
+async function setup(home, selectedPython, { runner = spawnSync, log = console.log } = {}) {
+  checkWheel();
+  homeDir(home, home);
+  const lock = path.join(home, '.setup-lock');
+  checkHomePath(home, lock);
+  try { fs.mkdirSync(lock, { mode: 0o700 }); } catch (error) {
+    if (error.code === 'EEXIST') throw new Error(`Setup is already running or was interrupted. Inspect ${lock} before removing that lock and trying again`);
+    throw error;
+  }
+  let runtime;
+  try {
+    writeJsonAtomic(path.join(lock, 'owner.json'), { pid: process.pid, started_at: new Date().toISOString() });
+    try {
+      const existing = readReceipt(home);
+      verifyInstalled(existing.runtime, runner);
+      log(JSON.stringify({ state: 'READY', already_installed: true, version: VERSION, runtime: existing.runtime, receipt: receiptPath(home) }));
+      return 0;
+    } catch (error) {
+      if (fs.existsSync(receiptPath(home))) {
+        checkHomePath(home, receiptPath(home));
+        log(`Existing installation needs repair: ${error.message}`);
+        // A failed replacement must never leave an invalid READY receipt.
+        fs.renameSync(receiptPath(home), path.join(home, 'receipts', `${VERSION}-invalidated-${Date.now()}-${crypto.randomBytes(4).toString('hex')}.json`));
+      }
+    }
+    const python = discoverPython(selectedPython, runner);
+    const attempt = `${Date.now()}-${crypto.randomBytes(6).toString('hex')}`;
+    runtime = path.join(home, 'runtimes', VERSION, attempt);
+    homeDir(home, path.dirname(runtime));
+    checkHomePath(home, runtime);
+    const temporary = path.join(home, 'tmp', attempt);
+    homeDir(home, temporary);
+    const environment = { ...cleanEnv(), TMPDIR: temporary, TMP: temporary, TEMP: temporary,
+      // pip compares against Python's os.devnull exactly; Node's Windows
+      // spelling (\\\\.\\nul) differs from Python's "nul".
+      PIP_CONFIG_FILE: process.platform === 'win32' ? 'nul' : '/dev/null' };
+    log(`Installing EmilyRemote ${VERSION} offline into ${runtime}`);
+    try {
+      runChecked(python.executable, ['-I', '-B', '-m', 'venv', runtime], { env: environment }, runner);
+    } catch (error) {
+      throw new Error(`Unable to create the private virtualenv. Python must include venv and ensurepip (on Debian/Ubuntu the matching python3-venv package). No system packages were installed. ${error.message}`);
+    }
+    const executable = pythonPath(runtime);
+    const pipReport = path.join(home, 'receipts', `${attempt}-pip.json`);
+    homeDir(home, path.dirname(pipReport));
+    checkHomePath(home, pipReport);
+    const pipOutput = runChecked(executable, ['-I', '-B', '-m', 'pip', '--isolated', 'install',
+      '--no-index', '--no-deps', '--no-compile', '--no-cache-dir', '--disable-pip-version-check',
+      '--report', pipReport, WHEEL], { env: environment }, runner);
+    fs.writeFileSync(path.join(home, 'receipts', `${attempt}-install.log`), pipOutput, { mode: 0o600 });
+    const verification = verifyInstalled(runtime, runner);
+    const selfCheck = JSON.parse(runChecked(executable, ['-I', '-B', '-m', 'emilyremote', 'self-check'], { env: environment }, runner));
+    if (selfCheck.ok !== true || selfCheck.version !== VERSION) throw new Error('Installed SDK self-check did not pass');
+    const receipt = { schema: 'emilyremote.npm-installation/1', state: 'READY', version: VERSION,
+      installed_at: new Date().toISOString(), wheel_sha256: WHEEL_SHA,
+      runtime_relative: path.relative(home, runtime), python: python.version, verification, self_check: selfCheck,
+      pip_report_relative: path.relative(home, pipReport),
+      scope: 'Core package installed only; no service, enrollment, task dispatch, or optional dependencies' };
+    writeJsonAtomic(receiptPath(home), receipt);
+    log(JSON.stringify({ state: 'READY', version: VERSION, runtime, receipt: receiptPath(home) }));
+    return 0;
+  } catch (error) {
+    if (runtime) {
+      const failure = path.join(home, 'receipts', `${path.basename(runtime)}-failed.json`);
+      try {
+        checkHomePath(home, failure);
+        writeJsonAtomic(failure, { state: 'FAILED', version: VERSION, runtime_relative: path.relative(home, runtime),
+          failed_at: new Date().toISOString(), error: error.message,
+          note: 'This attempt was not published as a READY installation. Partial files retained for diagnosis.' });
+      } catch (_) { /* Preserve the original error; never write through an unsafe path. */ }
+    }
+    throw error;
+  } finally {
+    fs.rmSync(lock, { recursive: true, force: true });
+  }
+}
+
+function delegate(runtime, args, spawner = spawn) {
+  return new Promise((resolve, reject) => {
+    const child = spawner(pythonPath(runtime), ['-I', '-B', '-m', 'emilyremote', ...args],
+      { shell: false, stdio: 'inherit', env: cleanEnv(), windowsHide: true });
+    const forward = (signal) => { try { child.kill(signal); } catch (_) {} };
+    const onInt = () => forward('SIGINT');
+    const onTerm = () => forward('SIGTERM');
+    process.on('SIGINT', onInt); process.on('SIGTERM', onTerm);
+    const cleanup = () => { process.off('SIGINT', onInt); process.off('SIGTERM', onTerm); };
+    child.once('error', (error) => { cleanup(); reject(new Error(`Unable to launch installed SDK: ${error.message}`)); });
+    child.once('exit', (code, signal) => { cleanup(); resolve(code === null ? signal === 'SIGINT' ? 130 : 143 : code); });
+  });
+}
+
+async function main(argv = process.argv.slice(2)) {
+  const parsed = parseArgs(argv);
+  if (!parsed.command || ['--help', '-h', 'help'].includes(parsed.command)) { console.log(HELP); return 0; }
+  if (parsed.command === '--version') { console.log(VERSION); return 0; }
+  const home = path.resolve(parsed.home || defaultHome());
+  if (parsed.command === 'setup') {
+    if (parsed.args.includes('--help') || parsed.args.includes('-h')) { console.log(HELP); return 0; }
+    if (parsed.args.length) throw new Error('Unknown setup arguments; use emilyremote setup --help');
+    return setup(home, parsed.python);
+  }
+  const installed = readReceipt(home);
+  const verification = verifyInstalled(installed.runtime);
+  if (parsed.command === 'status') {
+    if (parsed.args.length) throw new Error('status does not accept SDK arguments');
+    console.log(JSON.stringify({ state: 'READY', version: VERSION, runtime: installed.runtime,
+      receipt: receiptPath(home), verification, service_started_by_wrapper: false }, null, 2));
+    return 0;
+  }
+  return delegate(installed.runtime, [parsed.command, ...parsed.args]);
+}
+
+module.exports = { main, parseArgs, defaultHome, cleanEnv, checkHomeAncestors, checkHomePath, runChecked, discoverPython, readReceipt,
+  verifyInstalled, setup, delegate, pythonPath, VERSION, WHEEL_SHA, WHEEL, receiptPath };

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@robsonai/emilyremote",
+  "version": "0.3.0",
+  "description": "EmilyRemote by RobsonAI: explicit offline installer and command wrapper for the EmilyRemote host SDK",
+  "license": "UNLICENSED",
+  "engines": {"node": ">=18"},
+  "bin": {"emilyremote": "bin/emilyremote.cjs"},
+  "files": ["bin/", "lib/", "scripts/", "vendor/", "README.md", "PROVENANCE.json"],
+  "scripts": {"test": "node --test test/*.test.cjs"},
+  "publishConfig": {"access": "public"},
+  "keywords": ["emilyremote", "robsonai", "edge", "sdk"],
+  "author": "RobsonAI"
+}

package/scripts/verify_install.py

@@ -0,0 +1,48 @@
+"""Read-only installed-wheel verification. Invoked with isolated Python -I -B."""
+import argparse
+import hashlib
+import importlib.metadata
+import importlib.util
+import json
+import os
+from pathlib import Path
+import sys
+import zipfile
+
+EXPECTED_SHA = "e730b011b844dc70442fa793d29c98eb9df8dea5341ebbb49ba38fd73da0269e"
+parser = argparse.ArgumentParser()
+parser.add_argument("--wheel", required=True)
+parser.add_argument("--runtime", required=True)
+args = parser.parse_args()
+assert sys.version_info >= (3, 11), "Python 3.11+ is required"
+wheel = Path(args.wheel)
+assert hashlib.sha256(wheel.read_bytes()).hexdigest() == EXPECTED_SHA, "Bundled wheel mismatch"
+runtime = Path(args.runtime).resolve()
+assert Path(sys.prefix).resolve() == runtime, "Python is not running in the selected virtualenv"
+assert sys.prefix != sys.base_prefix, "Global Python is not an isolated runtime"
+assert importlib.metadata.version("robsonai-emilyremote") == "0.3.0", "Installed metadata version mismatch"
+spec = importlib.util.find_spec("emilyremote")
+assert spec and spec.origin and spec.origin.endswith("__init__.py"), "SDK did not resolve to Python source"
+package = Path(spec.origin).resolve().parent
+assert runtime in package.parents, "SDK import came from outside its virtualenv"
+hashes = {}
+with zipfile.ZipFile(wheel) as archive:
+    for name in archive.namelist():
+        if not name.startswith("emilyremote/") or not name.endswith(".py"):
+            continue
+        relative = name[len("emilyremote/"):]
+        actual = package / relative
+        assert package in actual.resolve().parents, "Source path escapes installed SDK"
+        expected = hashlib.sha256(archive.read(name)).hexdigest()
+        assert hashlib.sha256(actual.read_bytes()).hexdigest() == expected, "Installed source mismatch: " + name
+        hashes[name] = expected
+actual_names = {"emilyremote/" + p.relative_to(package).as_posix() for p in package.rglob("*.py")}
+assert actual_names == set(hashes), "Installed SDK source set differs from the wheel"
+all_files = {"emilyremote/" + p.relative_to(package).as_posix() for p in package.rglob("*") if p.is_file()}
+assert all_files == set(hashes), "Unexpected installed SDK files (including bytecode or native modules)"
+import emilyremote
+assert emilyremote.__version__ == "0.3.0", "Runtime version mismatch"
+print(json.dumps({"ok": True, "version": emilyremote.__version__, "python": sys.version.split()[0],
+                  "executable": sys.executable, "runtime": str(runtime), "package": str(package),
+                  "wheel_sha256": EXPECTED_SHA, "source_hashes": hashes,
+                  "uid": os.getuid() if hasattr(os, "getuid") else None}, sort_keys=True))