@skaft/octet 0.8.1 → 0.10.4

package/README.md

@@ -1,20 +1,19 @@
 # octet npm launcher
 
-`@skaft/octet` is a small, shell-only launcher for the native octet
-runtime. npm selects one exact-version platform package through
-`optionalDependencies`; the normal `octet` and `octet-host` paths immediately `exec`
-the selected native binary.
+`@skaft/octet` is a small Node.js launcher for the native octet runtime. npm
+selects one exact-version platform package through `optionalDependencies`; the
+`octet` and `octet-host` commands start the selected native binary directly.
 
 These scoped names are source packaging identities, not proof of registry rights
 or availability. Use the installation command only after an authorized release
 has published the packages.
 
-The launcher does not run Node, access the network, download an archive, or
-execute an install lifecycle hook. Install it with scripts, audit, and funding
-requests disabled:
+The launcher requires Node.js but does not access the network, download an
+archive, or execute an install lifecycle hook. Install it with scripts, audit,
+and funding requests disabled:
 
 ```sh
-npm install --global --ignore-scripts --no-audit --no-fund @skaft/octet@0.8.1
+npm install --global --ignore-scripts --no-audit --no-fund @skaft/octet@0.10.4
 ```
 
 GNU/Linux uses the glibc x64 package. macOS uses the arm64 or x64 package that

package/bin/octet

@@ -1,26 +1,5 @@
-#!/bin/sh
-set -eu
+#!/usr/bin/env node
+'use strict';
 
-# npm may expose bin/octet through a symlink in its global bin directory. Resolve
-# that link without changing the caller's cwd before handing off to the common
-# shell-only launcher.
-script=$0
-case "$script" in
-    /*) ;;
-    *) script=$(pwd -P)/$script ;;
-esac
-while [ -L "$script" ]; do
-    link=$(readlink "$script") || {
-        printf '%s\n' 'octet npm launcher could not resolve its executable path' >&2
-        exit 1
-    }
-    case "$link" in
-        /*) script=$link ;;
-        *) script=$(dirname "$script")/$link ;;
-    esac
-done
-script_directory=$(CDPATH= cd -P -- "$(dirname "$script")" 2>/dev/null && pwd -P) || {
-    printf '%s\n' 'octet npm launcher could not resolve its package directory' >&2
-    exit 1
-}
-exec "$script_directory/../lib/launch.sh" octet "$@"
+const { launch } = require('../lib/launch.js');
+launch('octet');

package/bin/octet-host

@@ -1,25 +1,5 @@
-#!/bin/sh
-set -eu
+#!/usr/bin/env node
+'use strict';
 
-# npm may expose bin/octet-host through a symlink in its global bin directory.
-# Resolve it before exec so package lookup remains independent of PATH.
-script=$0
-case "$script" in
-    /*) ;;
-    *) script=$(pwd -P)/$script ;;
-esac
-while [ -L "$script" ]; do
-    link=$(readlink "$script") || {
-        printf '%s\n' 'octet npm launcher could not resolve its executable path' >&2
-        exit 1
-    }
-    case "$link" in
-        /*) script=$link ;;
-        *) script=$(dirname "$script")/$link ;;
-    esac
-done
-script_directory=$(CDPATH= cd -P -- "$(dirname "$script")" 2>/dev/null && pwd -P) || {
-    printf '%s\n' 'octet npm launcher could not resolve its package directory' >&2
-    exit 1
-}
-exec "$script_directory/../lib/launch.sh" octet-host "$@"
+const { launch } = require('../lib/launch.js');
+launch('octet-host');

package/lib/launch.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const PLATFORMS = Object.freeze({
+  'darwin-arm64': '@skaft/octet-darwin-arm64',
+  'darwin-x64': '@skaft/octet-darwin-x64',
+  'linux-x64': '@skaft/octet-linux-x64-gnu',
+  'win32-x64': '@skaft/octet-win32-x64',
+});
+
+function selectedPackage(platform = process.platform, architecture = process.arch) {
+  if (platform === 'linux' && architecture === 'x64') {
+    const libc = process.report?.getReport?.().header?.glibcVersionRuntime;
+    if (!libc) throw new Error('octet npm package requires GNU libc on Linux; musl is not supported');
+  }
+  const key = `${platform}-${architecture}`;
+  const selected = PLATFORMS[key];
+  if (!selected) throw new Error(`octet npm package does not support this platform: ${key}`);
+  return selected;
+}
+
+function findPlatformRoot(launcherRoot, packageName) {
+  const packageLeaf = packageName.slice(packageName.indexOf('/') + 1);
+  const candidates = [
+    path.join(launcherRoot, 'node_modules', ...packageName.split('/')),
+    path.join(launcherRoot, '..', packageLeaf),
+  ];
+  for (const candidate of candidates) {
+    try {
+      if (fs.lstatSync(candidate).isDirectory() && !fs.lstatSync(candidate).isSymbolicLink()) return candidate;
+    } catch (error) {
+      if (error.code !== 'ENOENT') throw error;
+    }
+  }
+  throw new Error(`octet npm package is missing the selected platform runtime: ${packageName}`);
+}
+
+function launch(commandName, args = process.argv.slice(2)) {
+  if (commandName !== 'octet' && commandName !== 'octet-host') throw new Error('invalid native command');
+  const launcherRoot = path.resolve(__dirname, '..');
+  const packageName = selectedPackage();
+  const platformRoot = findPlatformRoot(launcherRoot, packageName);
+  const executableName = process.platform === 'win32' ? `${commandName}.exe` : commandName;
+  const executable = path.join(platformRoot, 'bin', executableName);
+  const versionPath = path.join(platformRoot, 'share', 'octet', '.octet-version');
+  const required = [
+    ...['package.json', 'README.md', 'LICENSE'].map((name) => path.join(platformRoot, name)), executable,
+    path.join(platformRoot, 'share', 'octet', 'README.md'),
+    path.join(platformRoot, 'share', 'octet', 'docs'),
+    path.join(platformRoot, 'share', 'octet', 'examples'),
+    path.join(platformRoot, 'share', 'octet', 'sdk'),
+  ];
+  for (const file of required) {
+    try {
+      const stat = fs.lstatSync(file);
+      if (stat.isSymbolicLink() || (file === executable ? !stat.isFile() : !stat.isFile() && !stat.isDirectory())) {
+        throw new Error(`octet npm platform package is incomplete: ${platformRoot}`);
+      }
+    } catch (error) {
+      if (error.code === 'ENOENT') throw new Error(`octet npm platform package is incomplete: ${platformRoot}`);
+      throw error;
+    }
+  }
+  if (process.platform !== 'win32' && (fs.statSync(executable).mode & 0o111) === 0) {
+    throw new Error(`octet npm platform executable is not executable: ${executable}`);
+  }
+  const version = fs.readFileSync(path.join(launcherRoot, 'package.json'), 'utf8').match(/"version"\s*:\s*"([^"]+)"/);
+  if (!version || fs.readFileSync(versionPath, 'utf8').trim() !== version[1]) {
+    throw new Error('octet npm platform version does not match launcher version');
+  }
+  const result = spawnSync(executable, args, { cwd: process.cwd(), env: process.env, stdio: 'inherit' });
+  if (result.error) throw result.error;
+  if (result.signal) {
+    process.kill(process.pid, result.signal);
+    return;
+  }
+  process.exitCode = result.status === null ? 1 : result.status;
+}
+
+module.exports = { PLATFORMS, selectedPackage, findPlatformRoot, launch };

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@skaft/octet",
-  "version": "0.8.1",
+  "version": "0.10.4",
   "description": "Native octet coding agent launcher",
   "license": "MIT",
   "repository": "https://github.com/skaft-software/octet",
+  "homepage": "https://octet.skaft.org",
   "files": [
     "README.md",
     "LICENSE",
@@ -15,8 +16,9 @@
     "octet-host": "bin/octet-host"
   },
   "optionalDependencies": {
-    "@skaft/octet-darwin-arm64": "0.8.1",
-    "@skaft/octet-darwin-x64": "0.8.1",
-    "@skaft/octet-linux-x64-gnu": "0.8.1"
+    "@skaft/octet-darwin-arm64": "0.10.4",
+    "@skaft/octet-darwin-x64": "0.10.4",
+    "@skaft/octet-linux-x64-gnu": "0.10.4",
+    "@skaft/octet-win32-x64": "0.10.4"
   }
 }

package/lib/launch.sh

@@ -1,117 +0,0 @@
-#!/bin/sh
-set -eu
-
-package_version="0.8.1"
-
-fail() {
-    printf '%s\n' "$1" >&2
-    exit 1
-}
-
-command_name=${1-}
-case "$command_name" in
-    octet|octet-host) ;;
-    *) fail 'octet npm launcher received an invalid native command' ;;
-esac
-shift
-
-# npm exposes each bin entry through a symlink in its global bin directory.
-# Resolve it without changing the caller's working directory before locating
-# the package-local launcher.
-script=$0
-case "$script" in
-    /*) ;;
-    *) script=$(pwd -P)/$script ;;
-esac
-while [ -L "$script" ]; do
-    link=$(readlink "$script") || fail 'octet npm launcher could not resolve its executable path'
-    case "$link" in
-        /*) script=$link ;;
-        *) script=$(dirname "$script")/$link ;;
-    esac
-done
-launch_directory=$(CDPATH= cd -P -- "$(dirname "$script")" 2>/dev/null && pwd -P) || \
-    fail 'octet npm launcher could not resolve its package directory'
-launcher_root=$(CDPATH= cd -P -- "$launch_directory/.." 2>/dev/null && pwd -P) || \
-    fail 'octet npm launcher could not resolve its package root'
-[ -d "$launcher_root" ] && [ ! -L "$launcher_root" ] || \
-    fail 'octet npm launcher package root is not a real directory'
-
-operating_system=$(uname -s 2>/dev/null) || fail 'octet npm launcher requires uname'
-machine=$(uname -m 2>/dev/null) || fail 'octet npm launcher could not determine the CPU architecture'
-platform_package=
-case "$operating_system:$machine" in
-    Darwin:arm64|Darwin:aarch64)
-        platform_package='@skaft/octet-darwin-arm64'
-        ;;
-    Darwin:x86_64|Darwin:amd64)
-        # Select the package matching the executable ABI. An x86_64 octet under
-        # Rosetta is still an x86_64 binary and must not exec arm64 code.
-        platform_package='@skaft/octet-darwin-x64'
-        ;;
-    Linux:x86_64|Linux:amd64)
-        glibc_available=false
-        if command -v getconf >/dev/null 2>&1; then
-            glibc_version=$(getconf GNU_LIBC_VERSION 2>/dev/null || true)
-            case "$glibc_version" in
-                glibc\ *|GNU\ libc\ *) glibc_available=true ;;
-            esac
-        fi
-        if [ "$glibc_available" != true ] && command -v ldd >/dev/null 2>&1; then
-            ldd_version=$(ldd --version 2>&1 || true)
-            case "$ldd_version" in
-                *glibc*|*GLIBC*|*'GNU libc'*|*'GNU C Library'*) glibc_available=true ;;
-            esac
-        fi
-        [ "$glibc_available" = true ] || \
-            fail 'octet npm package requires GNU libc on Linux; musl is not supported'
-        platform_package='@skaft/octet-linux-x64-gnu'
-        ;;
-    Darwin:*) fail "octet npm package does not support macOS architecture: $machine" ;;
-    Linux:*) fail "octet npm package does not support Linux architecture: $machine" ;;
-    *) fail "octet npm package does not support operating system: $operating_system" ;;
-esac
-
-platform_name=${platform_package#*/}
-platform_root=
-# npm may nest optional dependencies below the public package or hoist them to
-# the sibling scope directory. Both layouts are explicit; there is no network
-# resolver or fallback package.
-for candidate in \
-    "$launcher_root/node_modules/$platform_package" \
-    "$launcher_root/../$platform_name"; do
-    if [ -d "$candidate" ] && [ ! -L "$candidate" ]; then
-        platform_root=$candidate
-        break
-    fi
-done
-[ -n "$platform_root" ] || \
-    fail "octet npm package is missing the selected platform runtime: $platform_package"
-
-for required in \
-    "$platform_root/package.json" \
-    "$platform_root/README.md" \
-    "$platform_root/LICENSE" \
-    "$platform_root/bin/$command_name" \
-    "$platform_root/share/octet/.octet-version" \
-    "$platform_root/share/octet/README.md"; do
-    [ -f "$required" ] && [ ! -L "$required" ] || \
-        fail "octet npm platform package is incomplete: $platform_root"
-done
-for required_directory in \
-    "$platform_root/bin" \
-    "$platform_root/share/octet" \
-    "$platform_root/share/octet/docs" \
-    "$platform_root/share/octet/examples" \
-    "$platform_root/share/octet/sdk"; do
-    [ -d "$required_directory" ] && [ ! -L "$required_directory" ] || \
-        fail "octet npm platform package is incomplete: $platform_root"
-done
-[ -x "$platform_root/bin/$command_name" ] || \
-    fail "octet npm platform executable is not executable: $platform_root/bin/$command_name"
-[ "$(cat "$platform_root/share/octet/.octet-version")" = "$package_version" ] || \
-    fail "octet npm platform version does not match launcher version $package_version"
-
-# Do not print on the successful path: octet-host stdout is a protocol stream.
-# exec preserves cwd, argv, environment, stdio, signal delivery, and status.
-exec "$platform_root/bin/$command_name" "$@"