@rivet-dev/agentos-toolchain 0.0.0-nathan-agentos-package-resolution.efc374f

package/dist/chunk-K4RHMOJ7.js

@@ -0,0 +1,282 @@
+// src/bundle.ts
+import { buildSync } from "esbuild";
+import { chmodSync, readFileSync, writeFileSync } from "fs";
+var SHEBANG = "#!/usr/bin/env node\n";
+function bundleEntry(entryFile, outFile) {
+  const source = readFileSync(entryFile, "utf8");
+  const withoutShebang = source.startsWith("#!") ? source.slice(source.indexOf("\n") + 1) : source;
+  const META_SHIM = "const __agentos_import_meta_url = require('url').pathToFileURL(__filename).href;";
+  buildSync({
+    stdin: {
+      contents: withoutShebang,
+      resolveDir: entryFile.slice(0, entryFile.lastIndexOf("/")),
+      sourcefile: entryFile,
+      loader: "js"
+    },
+    bundle: true,
+    platform: "node",
+    format: "cjs",
+    target: "node20",
+    outfile: outFile,
+    banner: { js: `${SHEBANG.trimEnd()}
+${META_SHIM}` },
+    define: { "import.meta.url": "__agentos_import_meta_url" },
+    logLevel: "silent"
+  });
+  chmodSync(outFile, 493);
+  const out = readFileSync(outFile, "utf8");
+  if (!out.startsWith(SHEBANG)) {
+    writeFileSync(outFile, `${SHEBANG}${out.replace(/^#![^\n]*\n?/, "")}`);
+    chmodSync(outFile, 493);
+  }
+}
+
+// src/header.ts
+var WASM_MAGIC = Buffer.from([0, 97, 115, 109]);
+var ELF_MAGIC = Buffer.from([127, 69, 76, 70]);
+var MACHO_MAGICS = [
+  4277009102,
+  3472551422,
+  4277009103,
+  3489328638,
+  3405691582,
+  3199925962
+];
+function detectExecutableKind(head) {
+  if (head.length >= 2 && head[0] === 35 && head[1] === 33) {
+    return "shebang";
+  }
+  if (head.length >= 4 && head.subarray(0, 4).equals(WASM_MAGIC)) {
+    return "wasm";
+  }
+  if (head.length >= 4 && head.subarray(0, 4).equals(ELF_MAGIC)) {
+    return "native-elf";
+  }
+  if (head.length >= 4) {
+    const be = head.readUInt32BE(0);
+    if (be === 3405691582 && head.length >= 8) {
+      const next = head.readUInt32BE(4);
+      if (next >= 45) return "unknown";
+    }
+    if (MACHO_MAGICS.includes(be)) return "native-macho";
+  }
+  if (head.length >= 2 && head[0] === 77 && head[1] === 90) {
+    return "native-pe";
+  }
+  return "unknown";
+}
+function isNativeKind(kind) {
+  return kind === "native-elf" || kind === "native-macho" || kind === "native-pe";
+}
+function parseShebangInterpreter(head) {
+  if (!(head.length >= 2 && head[0] === 35 && head[1] === 33)) return null;
+  const nl = head.indexOf(10);
+  const line = head.subarray(2, nl < 0 ? head.length : nl).toString("utf8");
+  const trimmed = line.replace(/^\s+/, "");
+  const interp = trimmed.split(/\s+/, 1)[0] ?? "";
+  return interp.length > 0 ? interp : null;
+}
+
+// src/manifest.ts
+function makeManifest(name, version, acpEntrypoint) {
+  const manifest = { name, version };
+  if (acpEntrypoint) {
+    manifest.agent = { acpEntrypoint };
+  }
+  return manifest;
+}
+function manifestJson(manifest) {
+  return `${JSON.stringify(manifest, null, 2)}
+`;
+}
+
+// src/pack.ts
+import { execFileSync } from "child_process";
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  openSync,
+  readFileSync as readFileSync2,
+  readSync,
+  closeSync,
+  lstatSync,
+  readdirSync,
+  rmSync,
+  statSync,
+  symlinkSync,
+  unlinkSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { tmpdir } from "os";
+import { join, relative, resolve } from "path";
+var HEAD_BYTES = 256;
+function readHead(file) {
+  const fd = openSync(file, "r");
+  try {
+    const buf = Buffer.alloc(HEAD_BYTES);
+    const n = readSync(fd, buf, 0, HEAD_BYTES, 0);
+    return buf.subarray(0, n);
+  } finally {
+    closeSync(fd);
+  }
+}
+function npmInstallFlat(source, into) {
+  mkdirSync(join(into, "node_modules"), { recursive: true });
+  execFileSync(
+    "npm",
+    [
+      "install",
+      source,
+      "--omit=dev",
+      "--ignore-scripts",
+      "--no-audit",
+      "--no-fund",
+      "--no-package-lock",
+      "--install-strategy=hoisted",
+      "--prefix",
+      into
+    ],
+    { stdio: "pipe" }
+  );
+}
+function installedPackageName(source) {
+  if (existsSync(source) && statSync(source).isDirectory()) {
+    const pkg = JSON.parse(readFileSync2(join(source, "package.json"), "utf8"));
+    return pkg.name;
+  }
+  const at = source.lastIndexOf("@");
+  return at > 0 ? source.slice(0, at) : source;
+}
+function binEntries(pkgDir) {
+  const pkg = JSON.parse(readFileSync2(join(pkgDir, "package.json"), "utf8"));
+  const bin = pkg.bin;
+  if (!bin) return {};
+  if (typeof bin === "string") {
+    return { [pkg.name.replace(/^@[^/]+\//, "")]: bin };
+  }
+  return bin;
+}
+function findNativeAddons(root) {
+  const hits = [];
+  const walk = (dir) => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const p = join(dir, entry.name);
+      if (entry.isDirectory()) walk(p);
+      else if (entry.isFile() && entry.name.endsWith(".node")) hits.push(p);
+    }
+  };
+  if (existsSync(root)) walk(root);
+  return hits;
+}
+function verifyPackageDir(packageDir) {
+  if (!existsSync(join(packageDir, "agentos-package.json"))) {
+    throw new Error(`missing required agentos-package.json in ${packageDir}`);
+  }
+  const binDir = join(packageDir, "bin");
+  if (!existsSync(binDir)) {
+    throw new Error(`package has no bin/ directory: ${packageDir}`);
+  }
+  for (const entry of readdirSync(binDir)) {
+    const target = resolve(binDir, entry);
+    const kind = detectExecutableKind(readHead(target));
+    if (isNativeKind(kind)) {
+      throw new Error(
+        `bin/${entry} is a native ${kind} binary, which cannot run in agentOS`
+      );
+    }
+    if (kind === "unknown") {
+      throw new Error(
+        `bin/${entry} has no recognized header \u2014 JS/script commands need a '#!' shebang`
+      );
+    }
+  }
+  const addons = findNativeAddons(join(packageDir, "node_modules"));
+  if (addons.length > 0) {
+    throw new Error(
+      `package contains native .node addons (won't load in V8): ${addons.map((a) => relative(packageDir, a)).join(", ")}`
+    );
+  }
+}
+function pack(options) {
+  const { source, out, agent, bundle, pruneNative } = options;
+  const tmp = mkdtempSync(join(tmpdir(), "agentos-pack-"));
+  try {
+    const absSource = existsSync(source) && statSync(source).isDirectory() ? resolve(source) : source;
+    npmInstallFlat(absSource, tmp);
+    const name = installedPackageName(source);
+    const installedDir = join(tmp, "node_modules", name);
+    const pkg = JSON.parse(readFileSync2(join(installedDir, "package.json"), "utf8"));
+    const version = pkg.version;
+    const bins = binEntries(installedDir);
+    const commands = Object.keys(bins);
+    if (commands.length === 0) {
+      throw new Error(`package "${name}" declares no bin commands`);
+    }
+    if (agent && !commands.includes(agent)) {
+      throw new Error(
+        `--agent "${agent}" is not one of the package's commands: ${commands.join(", ")}`
+      );
+    }
+    const packageDir = join(out, name, version);
+    rmSync(packageDir, { recursive: true, force: true });
+    mkdirSync(packageDir, { recursive: true });
+    const binDir = join(packageDir, "bin");
+    mkdirSync(binDir, { recursive: true });
+    if (bundle) {
+      for (const [cmd, entryRel] of Object.entries(bins)) {
+        const entryAbs = join(installedDir, entryRel);
+        bundleEntry(entryAbs, join(binDir, cmd));
+      }
+    } else {
+      cpSync(join(tmp, "node_modules"), join(packageDir, "node_modules"), {
+        recursive: true
+      });
+      for (const [cmd, entryRel] of Object.entries(bins)) {
+        const targetAbs = join(packageDir, "node_modules", name, entryRel);
+        symlinkSync(relative(binDir, targetAbs), join(binDir, cmd));
+      }
+      if (pruneNative) {
+        const addons = findNativeAddons(join(packageDir, "node_modules"));
+        for (const addon of addons) {
+          rmSync(addon, { force: true });
+        }
+        if (addons.length > 0) {
+          console.warn(
+            `[agentos-toolchain] pruned ${addons.length} native .node addon(s) from ${name} (--prune-native); they must be unreachable on the V8 code path`
+          );
+        }
+      }
+    }
+    writeFileSync2(
+      join(packageDir, "agentos-package.json"),
+      manifestJson(makeManifest(name, version, agent))
+    );
+    const currentLink = join(out, name, "current");
+    try {
+      if (lstatSync(currentLink).isSymbolicLink()) {
+        unlinkSync(currentLink);
+      } else {
+        rmSync(currentLink, { recursive: true, force: true });
+      }
+    } catch {
+    }
+    symlinkSync(version, currentLink);
+    verifyPackageDir(packageDir);
+    return { name, version, packageDir, commands };
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+export {
+  bundleEntry,
+  detectExecutableKind,
+  isNativeKind,
+  parseShebangInterpreter,
+  makeManifest,
+  manifestJson,
+  verifyPackageDir,
+  pack
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import {
+  pack
+} from "./chunk-CSSRRHDX.js";
+
+// src/cli.ts
+import { existsSync, statSync } from "fs";
+import { basename, resolve } from "path";
+var USAGE = `agentos-toolchain \u2014 build agentOS packages
+
+Usage:
+  agentos-toolchain pack <npm-pkg | ./local-dir> [options]
+
+Options:
+  --agent <command>   mark a bin command as the package's ACP entrypoint
+  --out <dir>         output dir for the package itself (FLAT;
+                      default: ./<input-name>-package)
+  --prune-native      delete unreachable native .node addons from the flat closure
+  -h, --help          show this help
+`;
+function defaultOutName(source) {
+  if (existsSync(source) && statSync(source).isDirectory()) {
+    return `./${basename(resolve(source))}-package`;
+  }
+  const at = source.lastIndexOf("@");
+  const name = at > 0 ? source.slice(0, at) : source;
+  return `./${name.replace(/^@[^/]+\//, "")}-package`;
+}
+function parseArgs(argv) {
+  const [cmd, ...rest] = argv;
+  let source;
+  let agent;
+  let out;
+  let pruneNative = false;
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (a === "--agent") agent = rest[++i];
+    else if (a === "--out") out = rest[++i];
+    else if (a === "--prune-native") pruneNative = true;
+    else if (a === "-h" || a === "--help") {
+      process.stdout.write(USAGE);
+      process.exit(0);
+    } else if (!a.startsWith("-") && source === void 0) source = a;
+    else throw new Error(`unexpected argument: ${a}`);
+  }
+  return { cmd, source, agent, out, pruneNative };
+}
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.cmd === void 0 || args.cmd === "-h" || args.cmd === "--help") {
+    process.stdout.write(USAGE);
+    process.exit(args.cmd === void 0 ? 1 : 0);
+  }
+  if (args.cmd !== "pack") {
+    throw new Error(`unknown command "${args.cmd}" (only "pack" is supported)`);
+  }
+  if (!args.source) throw new Error("pack requires a <npm-pkg | ./local-dir> argument");
+  const result = pack({
+    source: args.source,
+    out: resolve(args.out ?? defaultOutName(args.source)),
+    agent: args.agent,
+    pruneNative: args.pruneNative
+  });
+  process.stdout.write(
+    `packed ${result.name}@${result.version} \u2192 ${result.packageDir}
+  commands: ${result.commands.join(", ")}
+`
+  );
+}
+try {
+  main();
+} catch (error) {
+  process.stderr.write(`error: ${error instanceof Error ? error.message : String(error)}
+`);
+  process.exit(1);
+}

package/dist/index.d.ts

@@ -0,0 +1,50 @@
+interface PackOptions {
+    /** npm package spec (`name`, `name@version`) or a local directory path. */
+    source: string;
+    /**
+     * Output dir for the package itself (FLAT): the package lands directly at
+     * `<out>/{bin/, node_modules/, package.json}`. The versioned
+     * `/opt/agentos/<name>/<version>` + `current` layout is the sidecar
+     * projection's job (name from the descriptor, version from this package.json).
+     */
+    out: string;
+    /** Mark a bin command as the package's ACP entrypoint (validated against bin/). */
+    agent?: string;
+    /**
+     * Delete native `.node` addons from the flat closure instead of failing.
+     * Use when a package's dependency tree contains optional/platform native
+     * addons (e.g. `koffi`, `clipboard-*`) that are never loaded on the code path
+     * that runs in V8. The JS closure (including dynamically-required modules) is
+     * kept; only the V8-incompatible `.node` files are removed. If a pruned addon
+     * IS reached at runtime it fails then — so this is opt-in.
+     */
+    pruneNative?: boolean;
+}
+interface PackResult {
+    name: string;
+    version: string;
+    packageDir: string;
+    commands: string[];
+}
+/**
+ * Verify a finished package directory satisfies the agentOS package format:
+ * every `bin/` entry has a recognized, non-native header, and the tree has no
+ * native `.node` addons. Throws with a clear message on the first violation.
+ */
+declare function verifyPackageDir(packageDir: string): void;
+declare function pack(options: PackOptions): PackResult;
+
+/**
+ * Executable header detection — the same binfmt rules the runtime uses.
+ *
+ * Runtime is decided by the file's leading bytes, never its name or extension:
+ * a `#!` shebang, the `\0asm` WebAssembly magic, or a native object-file magic
+ * (ELF / Mach-O / PE) which agentOS cannot execute (no native-arch handler).
+ */
+type ExecutableKind = "shebang" | "wasm" | "native-elf" | "native-macho" | "native-pe" | "unknown";
+declare function detectExecutableKind(head: Buffer): ExecutableKind;
+declare function isNativeKind(kind: ExecutableKind): boolean;
+/** The interpreter named on a shebang line, taken literally (no PATH search). */
+declare function parseShebangInterpreter(head: Buffer): string | null;
+
+export { type ExecutableKind, type PackOptions, type PackResult, detectExecutableKind, isNativeKind, pack, parseShebangInterpreter, verifyPackageDir };

package/dist/index.js

@@ -0,0 +1,14 @@
+import {
+  detectExecutableKind,
+  isNativeKind,
+  pack,
+  parseShebangInterpreter,
+  verifyPackageDir
+} from "./chunk-CSSRRHDX.js";
+export {
+  detectExecutableKind,
+  isNativeKind,
+  pack,
+  parseShebangInterpreter,
+  verifyPackageDir
+};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@rivet-dev/agentos-toolchain",
+  "version": "0.0.0-nathan-agentos-package-resolution.efc374f",
+  "description": "Build toolchain for agentOS packages (pack npm packages/scripts into self-contained agentOS packages).",
+  "type": "module",
+  "license": "Apache-2.0",
+  "bin": {
+    "agentos-toolchain": "./dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "package.json",
+    "README.md"
+  ],
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.9"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/cli.ts --format esm --dts",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}