@rivet-dev/agentos-toolchain 0.0.0-nathan-agentos-package-resolution.efc374f → 0.2.5-rc.4

package/dist/chunk-YTYFSDXW.js

@@ -0,0 +1,1135 @@
+// src/aospkg.ts
+import { readFileSync, writeFileSync } from "fs";
+
+// src/generated-package-format.ts
+import * as bare from "@rivetkit/bare-ts";
+var DEFAULT_CONFIG = /* @__PURE__ */ bare.Config({});
+function writeTarEntryKind(bc, x) {
+  switch (x) {
+    case "File" /* File */: {
+      bare.writeU8(bc, 0);
+      break;
+    }
+    case "Directory" /* Directory */: {
+      bare.writeU8(bc, 1);
+      break;
+    }
+    case "Symlink" /* Symlink */: {
+      bare.writeU8(bc, 2);
+      break;
+    }
+  }
+}
+function write0(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    bare.writeString(bc, x);
+  }
+}
+function writeTarEntry(bc, x) {
+  bare.writeString(bc, x.path);
+  writeTarEntryKind(bc, x.kind);
+  bare.writeU64(bc, x.offset);
+  bare.writeU64(bc, x.size);
+  bare.writeU32(bc, x.mode);
+  bare.writeU32(bc, x.uid);
+  bare.writeU32(bc, x.gid);
+  bare.writeI64(bc, x.mtime);
+  write0(bc, x.linkTarget);
+}
+function write1(bc, x) {
+  bare.writeUintSafe(bc, x.size);
+  for (const kv of x) {
+    bare.writeString(bc, kv[0]);
+    bare.writeString(bc, kv[1]);
+  }
+}
+function write2(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    bare.writeString(bc, x[i]);
+  }
+}
+function writeAgentBlock(bc, x) {
+  bare.writeString(bc, x.acpEntrypoint);
+  bare.writeBool(bc, x.snapshot);
+  write1(bc, x.env);
+  write2(bc, x.launchArgs);
+}
+function writeCommandTarget(bc, x) {
+  bare.writeString(bc, x.command);
+  bare.writeString(bc, x.entry);
+}
+function writeManPage(bc, x) {
+  bare.writeString(bc, x.section);
+  bare.writeString(bc, x.page);
+}
+function writeProvidesFile(bc, x) {
+  bare.writeString(bc, x.source);
+  bare.writeString(bc, x.target);
+}
+function write3(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeProvidesFile(bc, x[i]);
+  }
+}
+function writeProvidesBlock(bc, x) {
+  write1(bc, x.env);
+  write3(bc, x.files);
+}
+function write4(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    writeAgentBlock(bc, x);
+  }
+}
+function write5(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    writeProvidesBlock(bc, x);
+  }
+}
+function write6(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeCommandTarget(bc, x[i]);
+  }
+}
+function write7(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeManPage(bc, x[i]);
+  }
+}
+function writePackageManifest(bc, x) {
+  bare.writeString(bc, x.name);
+  bare.writeString(bc, x.version);
+  write4(bc, x.agent);
+  write5(bc, x.provides);
+  write6(bc, x.commands);
+  write7(bc, x.manPages);
+  write0(bc, x.snapshotBundlePath);
+}
+function encodePackageManifest(x, config) {
+  const fullConfig = config != null ? bare.Config(config) : DEFAULT_CONFIG;
+  const bc = new bare.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writePackageManifest(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function write8(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeTarEntry(bc, x[i]);
+  }
+}
+function writeMountIndex(bc, x) {
+  write8(bc, x.tarEntries);
+}
+function encodeMountIndex(x, config) {
+  const fullConfig = config != null ? bare.Config(config) : DEFAULT_CONFIG;
+  const bc = new bare.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeMountIndex(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+
+// src/aospkg.ts
+var AOSPKG_MAGIC = Uint8Array.from([137, 65, 79, 83]);
+var AOSPKG_FORMAT_VERSION = 1;
+var PACKAGE_MANIFEST_VERSION = 1;
+var MANIFEST_JSON_NAME = "agentos-package.json";
+var SNAPSHOT_BUNDLE_PATH = "/dist/sdk-snapshot.js";
+var BLOCK = 512;
+var MAX_PACK_INDEX_ENTRIES = 2e5;
+function byteCompare(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+var S_IFDIR = 16384;
+var S_IFREG = 32768;
+var S_IFLNK = 40960;
+function packAospkgFromTar(sourceTar, dest) {
+  const source = readFileSync(sourceTar);
+  const { bytes, summary } = packAospkgFromTarBytes(source);
+  writeFileSync(dest, bytes);
+  return summary;
+}
+function packAospkgFromTarBytes(source) {
+  const members = parseTarMembers(source);
+  let manifestJson;
+  let packageJson;
+  const keptSlices = [];
+  const entries = /* @__PURE__ */ new Map();
+  let outOffset = 0;
+  for (const member of members) {
+    if (member.path === `/${MANIFEST_JSON_NAME}`) {
+      manifestJson = memberData(source, member);
+      continue;
+    }
+    if (member.path === "/") {
+      continue;
+    }
+    const indexed = indexEntry(member);
+    if (indexed === void 0) {
+      continue;
+    }
+    if (member.path === "/package.json") {
+      packageJson = memberData(source, member);
+    }
+    const record = source.subarray(member.recordStart, member.recordEnd);
+    keptSlices.push(record);
+    synthesizeParentDirs(member.path, entries);
+    entries.set(member.path, {
+      ...indexed,
+      offset: BigInt(outOffset + member.dataOffsetInRecord)
+    });
+    outOffset += record.length;
+  }
+  keptSlices.push(Buffer.alloc(2 * BLOCK));
+  const mountTar = Buffer.concat(keptSlices);
+  if (!entries.has("/")) {
+    entries.set("/", {
+      path: "/",
+      kind: "Directory" /* Directory */,
+      offset: 0n,
+      size: 0n,
+      mode: S_IFDIR | 493,
+      uid: 0,
+      gid: 0,
+      mtime: 0n,
+      linkTarget: null
+    });
+  }
+  if (manifestJson === void 0) {
+    throw new Error(`source tar must contain /${MANIFEST_JSON_NAME}`);
+  }
+  let sourceManifest;
+  try {
+    sourceManifest = JSON.parse(manifestJson.toString("utf8"));
+  } catch (error) {
+    throw new Error(`invalid ${MANIFEST_JSON_NAME}: ${String(error)}`);
+  }
+  const name = sourceManifest.name;
+  if (typeof name !== "string" || name.length === 0) {
+    throw new Error(`${MANIFEST_JSON_NAME} is missing a valid "name"`);
+  }
+  const version = sourceManifest.version;
+  if (typeof version !== "string" || version.length === 0) {
+    throw new Error(`${MANIFEST_JSON_NAME} is missing a valid "version"`);
+  }
+  if (entries.size > MAX_PACK_INDEX_ENTRIES) {
+    throw new Error(
+      `package mount index has ${entries.size} entries > MAX_PACK_INDEX_ENTRIES (${MAX_PACK_INDEX_ENTRIES}); the load-side TarFileSystem cap would reject this package at VM configure \u2014 split the package or raise both limits together`
+    );
+  }
+  const sortedPaths = [...entries.keys()].sort(byteCompare);
+  const tarEntries = sortedPaths.map((path) => entries.get(path));
+  const commands = commandTargets(sortedPaths, packageJson);
+  const manPages = manPagesFromIndex(sortedPaths);
+  const agent = agentBlock(sourceManifest);
+  const snapshotBundlePath = agent?.snapshot && entries.has(SNAPSHOT_BUNDLE_PATH) ? SNAPSHOT_BUNDLE_PATH : null;
+  const manifest = {
+    name,
+    version,
+    agent,
+    provides: providesBlock(sourceManifest),
+    commands,
+    manPages,
+    snapshotBundlePath
+  };
+  const manifestChunk = versionedChunk(encodePackageManifest(manifest));
+  const indexChunk = versionedChunk(encodeMountIndex({ tarEntries }));
+  const header = Buffer.alloc(16);
+  Buffer.from(AOSPKG_MAGIC).copy(header, 0);
+  header.writeUInt16LE(AOSPKG_FORMAT_VERSION, 4);
+  header.writeUInt16LE(0, 6);
+  header.writeUInt32LE(manifestChunk.length, 8);
+  header.writeUInt32LE(indexChunk.length, 12);
+  return {
+    bytes: Buffer.concat([header, manifestChunk, indexChunk, mountTar]),
+    summary: {
+      name,
+      version,
+      commands: commands.map((target) => target.command)
+    }
+  };
+}
+function versionedChunk(payload) {
+  const chunk = Buffer.alloc(2 + payload.length);
+  chunk.writeUInt16LE(PACKAGE_MANIFEST_VERSION, 0);
+  Buffer.from(payload).copy(chunk, 2);
+  return chunk;
+}
+function agentBlock(manifest) {
+  const agent = manifest.agent;
+  if (agent === void 0) return null;
+  return {
+    acpEntrypoint: agent.acpEntrypoint,
+    snapshot: agent.snapshot ?? false,
+    env: new Map(Object.entries(agent.env ?? {})),
+    launchArgs: agent.launchArgs ?? []
+  };
+}
+function providesBlock(manifest) {
+  const provides = manifest.provides;
+  if (provides === void 0) return null;
+  return {
+    env: new Map(Object.entries(provides.env ?? {})),
+    files: (provides.files ?? []).map((file) => ({
+      source: file.source,
+      target: file.target
+    }))
+  };
+}
+function indexEntry(member) {
+  const mode = member.mode & 4095;
+  const base = {
+    path: member.path,
+    offset: 0n,
+    size: 0n,
+    uid: member.uid,
+    gid: member.gid,
+    mtime: BigInt(member.mtime),
+    linkTarget: null
+  };
+  if (member.typeflag === "5") {
+    return { ...base, kind: "Directory" /* Directory */, mode: S_IFDIR | mode };
+  }
+  if (member.typeflag === "2") {
+    if (member.linkTarget === void 0) {
+      throw new Error(`symlink ${member.path} has no target`);
+    }
+    return {
+      ...base,
+      kind: "Symlink" /* Symlink */,
+      mode: S_IFLNK | Math.max(mode, 511),
+      linkTarget: member.linkTarget
+    };
+  }
+  if (member.typeflag === "0" || member.typeflag === "\0" || member.typeflag === "7") {
+    return {
+      ...base,
+      kind: "File" /* File */,
+      mode: S_IFREG | mode,
+      size: BigInt(member.size)
+    };
+  }
+  return void 0;
+}
+function synthesizeParentDirs(path, entries) {
+  const parts = path.split("/").filter((part) => part.length > 0);
+  let current = "";
+  for (const part of parts.slice(0, -1)) {
+    current += `/${part}`;
+    if (!entries.has(current)) {
+      entries.set(current, {
+        path: current,
+        kind: "Directory" /* Directory */,
+        offset: 0n,
+        size: 0n,
+        mode: S_IFDIR | 493,
+        uid: 0,
+        gid: 0,
+        mtime: 0n,
+        linkTarget: null
+      });
+    }
+  }
+}
+function commandTargets(sortedPaths, packageJson) {
+  if (packageJson !== void 0) {
+    try {
+      const fromBin = commandTargetsFromPackageJson(
+        JSON.parse(packageJson.toString("utf8"))
+      );
+      if (fromBin !== void 0) return fromBin;
+    } catch {
+    }
+  }
+  return sortedPaths.filter(
+    (path) => path.startsWith("/bin/") && !path.slice("/bin/".length).includes("/") && isProjectableCommandName(path.slice("/bin/".length))
+  ).map((path) => {
+    const name = path.slice("/bin/".length);
+    return { command: name, entry: `bin/${name}` };
+  });
+}
+function commandTargetsFromPackageJson(value) {
+  if (typeof value.bin === "string") {
+    if (typeof value.name !== "string") return void 0;
+    const unscoped = value.name.split("/").pop() ?? value.name;
+    return isProjectableCommandName(unscoped) ? [{ command: unscoped, entry: normalizeRel(value.bin) }] : [];
+  }
+  if (value.bin !== null && typeof value.bin === "object") {
+    return Object.entries(value.bin).filter(
+      ([name, entry]) => isProjectableCommandName(name) && typeof entry === "string"
+    ).map(([name, entry]) => ({
+      command: name,
+      entry: normalizeRel(entry)
+    })).sort((a, b) => byteCompare(a.command, b.command));
+  }
+  return void 0;
+}
+function manPagesFromIndex(sortedPaths) {
+  return sortedPaths.flatMap((path) => {
+    const suffix = path.startsWith("/share/man/") ? path.slice("/share/man/".length) : void 0;
+    if (suffix === void 0) return [];
+    const parts = suffix.split("/");
+    if (parts.length !== 2) return [];
+    return [{ section: parts[0], page: parts[1] }];
+  }).sort((a, b) => byteCompare(a.section, b.section) || byteCompare(a.page, b.page));
+}
+function isProjectableCommandName(name) {
+  return !name.startsWith("_") && !name.startsWith(".");
+}
+function normalizeRel(path) {
+  return path.startsWith("./") ? path.slice(2) : path;
+}
+function parseTarMembers(source) {
+  const members = [];
+  let offset = 0;
+  let pendingName;
+  let pendingLink;
+  let pendingSize;
+  let recordStart = 0;
+  let sawExtension = false;
+  while (offset + BLOCK <= source.length) {
+    const block = source.subarray(offset, offset + BLOCK);
+    if (isZeroBlock(block)) break;
+    if (!sawExtension) {
+      recordStart = offset;
+    }
+    const typeflag = String.fromCharCode(block[156]);
+    const size = parseOctal(block, 124, 12);
+    const dataBlocks = Math.ceil(size / BLOCK);
+    const dataStart = offset + BLOCK;
+    const next = dataStart + dataBlocks * BLOCK;
+    if (typeflag === "L" || typeflag === "K") {
+      const value = source.subarray(dataStart, dataStart + size).toString("utf8").replace(/\0+$/, "");
+      if (typeflag === "L") pendingName = value;
+      else pendingLink = value;
+      sawExtension = true;
+      offset = next;
+      continue;
+    }
+    if (typeflag === "x" || typeflag === "g") {
+      if (typeflag === "x") {
+        const records = parsePaxRecords(
+          source.subarray(dataStart, dataStart + size)
+        );
+        if (records.path !== void 0) pendingName = records.path;
+        if (records.linkpath !== void 0) pendingLink = records.linkpath;
+        if (records.size !== void 0) pendingSize = records.size;
+        sawExtension = true;
+      } else {
+        recordStart = next;
+      }
+      offset = next;
+      continue;
+    }
+    const memberSize = pendingSize ?? size;
+    const memberDataBlocks = Math.ceil(memberSize / BLOCK);
+    const memberNext = dataStart + memberDataBlocks * BLOCK;
+    const rawName = readCString(block, 0, 100);
+    const prefix = isUstar(block) ? readCString(block, 345, 155) : "";
+    const name = pendingName ?? (prefix.length > 0 ? `${prefix}/${rawName}` : rawName);
+    const linkTarget = pendingLink ?? (typeflag === "2" ? readCString(block, 157, 100) : void 0);
+    members.push({
+      path: canonicalTarPath(name),
+      typeflag,
+      mode: parseOctal(block, 100, 8),
+      uid: parseOctal(block, 108, 8),
+      gid: parseOctal(block, 116, 8),
+      mtime: parseOctal(block, 136, 12),
+      size: memberSize,
+      linkTarget,
+      recordStart,
+      recordEnd: memberNext,
+      dataOffsetInRecord: dataStart - recordStart
+    });
+    pendingName = void 0;
+    pendingLink = void 0;
+    pendingSize = void 0;
+    sawExtension = false;
+    offset = memberNext;
+  }
+  return members;
+}
+function memberData(source, member) {
+  const dataStart = member.recordStart + member.dataOffsetInRecord;
+  return source.subarray(dataStart, dataStart + member.size);
+}
+function parsePaxRecords(data) {
+  const out = {};
+  let offset = 0;
+  while (offset < data.length) {
+    const space = data.indexOf(32, offset);
+    if (space === -1) break;
+    const length = Number.parseInt(
+      data.subarray(offset, space).toString("latin1"),
+      10
+    );
+    if (!Number.isFinite(length) || length <= 0) break;
+    const record = data.subarray(offset, offset + length);
+    const eq = record.indexOf(61);
+    if (eq !== -1) {
+      const key = record.subarray(space - offset + 1, eq).toString("utf8");
+      let value = record.subarray(eq + 1).toString("utf8");
+      value = value.endsWith("\n") ? value.slice(0, -1) : value;
+      if (key === "path") out.path = value;
+      if (key === "linkpath") out.linkpath = value;
+      if (key === "size") {
+        const parsed = Number.parseInt(value, 10);
+        if (Number.isFinite(parsed) && parsed >= 0) out.size = parsed;
+      }
+    }
+    offset += length;
+  }
+  return out;
+}
+function canonicalTarPath(name) {
+  const parts = name.split("/").filter((part) => part.length > 0 && part !== ".");
+  for (const part of parts) {
+    if (part === "..") {
+      throw new Error(`tar member path escapes root: ${name}`);
+    }
+  }
+  return parts.length === 0 ? "/" : `/${parts.join("/")}`;
+}
+function isUstar(block) {
+  return block.subarray(257, 262).toString("latin1") === "ustar";
+}
+function isZeroBlock(block) {
+  return block.every((byte) => byte === 0);
+}
+function readCString(block, start, length) {
+  const slice = block.subarray(start, start + length);
+  const nul = slice.indexOf(0);
+  return slice.subarray(0, nul === -1 ? length : nul).toString("utf8");
+}
+function parseOctal(block, start, length) {
+  const slice = block.subarray(start, start + length);
+  if ((slice[0] & 128) !== 0) {
+    if (slice[0] !== 128) {
+      throw new Error(
+        "unsupported base-256 tar numeric field (negative or oversized value)"
+      );
+    }
+    let value2 = 0;
+    for (let i = 1; i < length; i += 1) {
+      value2 = value2 * 256 + slice[i];
+      if (!Number.isSafeInteger(value2)) {
+        throw new Error("base-256 tar numeric field exceeds 2^53");
+      }
+    }
+    return value2;
+  }
+  const text = slice.toString("latin1").replace(/\0.*$/, "").trim();
+  if (text.length === 0) return 0;
+  const value = Number.parseInt(text, 8);
+  return Number.isFinite(value) ? value : 0;
+}
+
+// src/manifest.ts
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { join } from "path";
+function readManifest(packageDir) {
+  const path = join(packageDir, "agentos-package.json");
+  if (!existsSync(path)) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync2(path, "utf8"));
+  } catch (error) {
+    throw new Error(`${path} is not valid JSON: ${String(error)}`);
+  }
+  return parsed;
+}
+function unscopedName(name) {
+  return name.replace(/^@[^/]+\//, "");
+}
+
+// src/build.ts
+import {
+  execFileSync
+} from "child_process";
+import {
+  cpSync,
+  existsSync as existsSync2,
+  mkdirSync,
+  readFileSync as readFileSync3,
+  readdirSync,
+  rmSync,
+  statSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { join as join2, resolve } from "path";
+function build(packageDirInput) {
+  const packageDir = resolve(packageDirInput ?? process.cwd());
+  const srcPkgPath = join2(packageDir, "package.json");
+  if (!existsSync2(srcPkgPath)) {
+    throw new Error(`no package.json in ${packageDir}`);
+  }
+  let srcPkg;
+  try {
+    srcPkg = JSON.parse(readFileSync3(srcPkgPath, "utf8"));
+  } catch (error) {
+    throw new Error(
+      `package.json in ${packageDir} is not valid JSON: ${String(error)}`
+    );
+  }
+  const name = srcPkg.name;
+  const version = srcPkg.version;
+  if (typeof name !== "string" || name.length === 0) {
+    throw new Error(`package.json in ${packageDir} is missing a valid "name"`);
+  }
+  if (typeof version !== "string" || version.length === 0) {
+    throw new Error(
+      `package.json in ${packageDir} is missing a valid "version"`
+    );
+  }
+  const srcManifest = readManifest(packageDir);
+  const manifest = {
+    name: typeof srcManifest?.name === "string" && srcManifest.name.length > 0 ? srcManifest.name : unscopedName(name),
+    version,
+    ...srcManifest?.agent !== void 0 ? { agent: srcManifest.agent } : {},
+    ...srcManifest?.provides !== void 0 ? { provides: srcManifest.provides } : {}
+  };
+  const srcBinDir = join2(packageDir, "bin");
+  const hasBinDir = existsSync2(srcBinDir) && statSync(srcBinDir).isDirectory();
+  const commands = hasBinDir ? readdirSync(srcBinDir, { withFileTypes: true }).filter((entry) => entry.isFile() || entry.isSymbolicLink()).map((entry) => entry.name).sort() : [];
+  const outDir = join2(packageDir, "dist", "package");
+  rmSync(outDir, { recursive: true, force: true });
+  mkdirSync(outDir, { recursive: true });
+  if (commands.length > 0) {
+    cpSync(srcBinDir, join2(outDir, "bin"), {
+      recursive: true,
+      verbatimSymlinks: true
+    });
+  }
+  const srcShareDir = join2(packageDir, "share");
+  if (existsSync2(srcShareDir) && statSync(srcShareDir).isDirectory()) {
+    cpSync(srcShareDir, join2(outDir, "share"), {
+      recursive: true,
+      verbatimSymlinks: true
+    });
+  }
+  writeFileSync2(
+    join2(outDir, "agentos-package.json"),
+    `${JSON.stringify(manifest, null, 2)}
+`
+  );
+  const outTar = join2(packageDir, "dist", "package.tar");
+  rmSync(outTar, { force: true });
+  execFileSync("tar", ["-cf", outTar, "-C", outDir, "."], { stdio: "pipe" });
+  const outAospkg = join2(packageDir, "dist", "package.aospkg");
+  rmSync(outAospkg, { force: true });
+  packAospkgFromTar(outTar, outAospkg);
+  process.stdout.write(
+    commands.length > 0 ? `assembled ${name}@${version} -> ${outAospkg}
+  commands (${commands.length}): ${commands.join(", ")}
+` : `assembled ${name}@${version} -> ${outAospkg} (PLANNED: empty placeholder, no bin/ yet \u2014 run stage with a commands dir to populate)
+`
+  );
+  return { name, version, commands, outDir, outTar, outAospkg };
+}
+
+// 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/pack.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import {
+  chmodSync,
+  cpSync as cpSync2,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  mkdtempSync,
+  lstatSync,
+  openSync,
+  readFileSync as readFileSync4,
+  readlinkSync,
+  readSync,
+  closeSync,
+  readdirSync as readdirSync2,
+  rmSync as rmSync2,
+  statSync as statSync2,
+  symlinkSync,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { tmpdir } from "os";
+import { dirname, isAbsolute, join as join3, relative, resolve as resolve2 } from "path";
+var HEAD_BYTES = 256;
+function npmBinary() {
+  const candidates = [
+    process.env.AGENTOS_TOOLCHAIN_NPM,
+    join3(dirname(process.execPath), "npm"),
+    "npm"
+  ].filter((value) => typeof value === "string" && value.length > 0);
+  return candidates.find((candidate) => candidate === "npm" || existsSync3(candidate)) ?? "npm";
+}
+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) {
+  mkdirSync2(join3(into, "node_modules"), { recursive: true });
+  execFileSync2(
+    npmBinary(),
+    [
+      "install",
+      source,
+      "--omit=dev",
+      "--ignore-scripts",
+      "--no-audit",
+      "--no-fund",
+      "--no-package-lock",
+      "--install-strategy=hoisted",
+      "--prefix",
+      into
+    ],
+    { stdio: "pipe" }
+  );
+}
+function resolveInstallSpec(source, scratch) {
+  if (!(existsSync3(source) && statSync2(source).isDirectory())) return source;
+  const dest = join3(scratch, "tarball");
+  mkdirSync2(dest, { recursive: true });
+  const out = execFileSync2(
+    npmBinary(),
+    ["pack", resolve2(source), "--pack-destination", dest, "--ignore-scripts", "--silent"],
+    { encoding: "utf8" }
+  );
+  const file = out.trim().split("\n").pop()?.trim();
+  if (!file) throw new Error(`npm pack produced no tarball for ${source}`);
+  return join3(dest, file);
+}
+function installedPackageName(source) {
+  if (existsSync3(source) && statSync2(source).isDirectory()) {
+    const pkg = JSON.parse(readFileSync4(join3(source, "package.json"), "utf8"));
+    return pkg.name;
+  }
+  const at = source.lastIndexOf("@");
+  return at > 0 ? source.slice(0, at) : source;
+}
+function readAgentosPackageManifest(source) {
+  if (!(existsSync3(source) && statSync2(source).isDirectory())) return void 0;
+  const manifestPath = join3(source, "agentos-package.json");
+  if (!existsSync3(manifestPath)) return void 0;
+  return JSON.parse(readFileSync4(manifestPath, "utf8"));
+}
+function unscopedName2(name) {
+  return name.replace(/^@[^/]+\//, "");
+}
+function binEntries(pkgDir) {
+  const pkg = JSON.parse(readFileSync4(join3(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 readdirSync2(dir, { withFileTypes: true })) {
+      const p = join3(dir, entry.name);
+      if (entry.isDirectory()) walk(p);
+      else if (entry.isFile() && entry.name.endsWith(".node")) hits.push(p);
+    }
+  };
+  if (existsSync3(root)) walk(root);
+  return hits;
+}
+function verifyPackageDir(packageDir) {
+  const manifestPath = join3(packageDir, "agentos-package.json");
+  if (!existsSync3(manifestPath)) {
+    throw new Error(`missing required agentos-package.json in ${packageDir}`);
+  }
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync4(manifestPath, "utf8"));
+  } catch (error) {
+    throw new Error(
+      `agentos-package.json in ${packageDir} is not valid JSON: ${String(error)}`
+    );
+  }
+  if (typeof manifest.name !== "string" || manifest.name.length === 0) {
+    throw new Error(
+      `agentos-package.json in ${packageDir} is missing a valid "name"`
+    );
+  }
+  if (typeof manifest.version !== "string" || manifest.version.length === 0) {
+    throw new Error(
+      `agentos-package.json in ${packageDir} is missing a valid "version"`
+    );
+  }
+  const binDir = join3(packageDir, "bin");
+  if (!existsSync3(binDir)) {
+    throw new Error(`package has no bin/ directory: ${packageDir}`);
+  }
+  for (const entry of readdirSync2(binDir)) {
+    const target = resolve2(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(join3(packageDir, "node_modules"));
+  if (addons.length > 0) {
+    throw new Error(
+      `package contains native .node addon(s) that won't load in V8: ${addons.map((a) => relative(packageDir, a)).join(", ")}; re-run with --prune-native to drop them if they are unreachable on the V8 code path`
+    );
+  }
+}
+function isInside(root, target) {
+  const rel = relative(root, target);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+function dereferenceEscapingSymlinks(root) {
+  const walk = (dir) => {
+    for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+      const path = join3(dir, entry.name);
+      const stat = lstatSync(path);
+      if (stat.isSymbolicLink()) {
+        const target = resolve2(dirname(path), readlinkSync(path));
+        if (!isInside(root, target)) {
+          rmSync2(path, { recursive: true, force: true });
+          cpSync2(target, path, {
+            recursive: true,
+            dereference: true,
+            verbatimSymlinks: false
+          });
+        }
+        continue;
+      }
+      if (stat.isDirectory()) walk(path);
+    }
+  };
+  walk(root);
+}
+function createPackageTar(packageDir, packageTar) {
+  rmSync2(packageTar, { recursive: true, force: true });
+  mkdirSync2(dirname(packageTar), { recursive: true });
+  execFileSync2("tar", ["-cf", packageTar, "-C", packageDir, "."], {
+    stdio: "pipe"
+  });
+}
+function resolveBinTarget(closureModules, name, entryRel) {
+  const nested = join3(closureModules, name, entryRel);
+  if (existsSync3(nested)) return nested;
+  const hoistedMatch = entryRel.match(/^\.?\/?node_modules\/(.+)$/);
+  if (hoistedMatch) {
+    const hoisted = join3(closureModules, hoistedMatch[1]);
+    if (existsSync3(hoisted)) return hoisted;
+  }
+  throw new Error(
+    `pack: cannot resolve bin target "${entryRel}" for ${name} \u2014 not found nested (${nested}) or hoisted. The declaring package's bin path does not match the installed (hoisted) layout.`
+  );
+}
+function pack(options) {
+  const { source, out, agent, pruneNative } = options;
+  const tmp = mkdtempSync(join3(tmpdir(), "agentos-pack-"));
+  try {
+    npmInstallFlat(resolveInstallSpec(source, tmp), tmp);
+    const name = installedPackageName(source);
+    const installedDir = join3(tmp, "node_modules", name);
+    const sourceManifest = readAgentosPackageManifest(installedDir);
+    const pkg = JSON.parse(readFileSync4(join3(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 explicitTarOut = out.endsWith(".tar");
+    const packageDir = explicitTarOut ? join3(tmp, "package") : out;
+    rmSync2(packageDir, { recursive: true, force: true });
+    mkdirSync2(packageDir, { recursive: true });
+    const binDir = join3(packageDir, "bin");
+    mkdirSync2(binDir, { recursive: true });
+    cpSync2(join3(tmp, "node_modules"), join3(packageDir, "node_modules"), {
+      recursive: true
+    });
+    const closureModules = join3(packageDir, "node_modules");
+    const binMap = {};
+    for (const [cmd, entryRel] of Object.entries(bins)) {
+      const targetAbs = resolveBinTarget(closureModules, name, entryRel);
+      binMap[cmd] = relative(packageDir, targetAbs).split(/[\\/]/).join("/");
+      chmodSync(targetAbs, 493);
+      symlinkSync(relative(binDir, targetAbs), join3(binDir, cmd));
+    }
+    if (pruneNative) {
+      const addons = findNativeAddons(join3(packageDir, "node_modules"));
+      for (const addon of addons) {
+        rmSync2(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`
+        );
+      }
+    }
+    writeFileSync3(
+      join3(packageDir, "package.json"),
+      `${JSON.stringify({ name, version, bin: binMap }, null, 2)}
+`
+    );
+    const manifest = {
+      name: typeof sourceManifest?.name === "string" && sourceManifest.name.length > 0 ? sourceManifest.name : unscopedName2(name),
+      ...sourceManifest?.agent !== void 0 ? { agent: sourceManifest.agent } : agent ? { agent: { acpEntrypoint: agent } } : {},
+      version,
+      ...sourceManifest?.provides !== void 0 ? { provides: sourceManifest.provides } : {}
+    };
+    writeFileSync3(
+      join3(packageDir, "agentos-package.json"),
+      `${JSON.stringify(manifest, null, 2)}
+`
+    );
+    verifyPackageDir(packageDir);
+    dereferenceEscapingSymlinks(packageDir);
+    const packageTar = out.endsWith(".tar") ? out : `${out}.tar`;
+    createPackageTar(packageDir, packageTar);
+    const packageAospkg = packageTar.replace(/\.tar$/, ".aospkg");
+    packAospkgFromTar(packageTar, packageAospkg);
+    return { name, version, packageTar, packageAospkg, commands };
+  } finally {
+    rmSync2(tmp, { recursive: true, force: true });
+  }
+}
+
+// src/publish.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname2, join as join4, resolve as resolve3 } from "path";
+function resolveTag(options) {
+  if (options.latest) {
+    if (options.tag !== void 0 && options.tag !== "latest") {
+      throw new Error(
+        `--latest conflicts with --tag ${options.tag}: pass one or the other`
+      );
+    }
+    return "latest";
+  }
+  if (options.tag === "latest") {
+    throw new Error(
+      "refusing implicit `--tag latest` \u2014 pass --latest to move the latest pointer"
+    );
+  }
+  return options.tag ?? "dev";
+}
+function findUp(startDir, fileName) {
+  let dir = startDir;
+  for (; ; ) {
+    if (existsSync4(join4(dir, fileName))) return join4(dir, fileName);
+    const parent = dirname2(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function publish(options) {
+  const packageDir = resolve3(options.packageDir);
+  const tag = resolveTag(options);
+  const pkgPath = join4(packageDir, "package.json");
+  if (!existsSync4(pkgPath)) {
+    throw new Error(`no package.json in ${packageDir}`);
+  }
+  const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
+  if (typeof pkg.name !== "string" || pkg.name.length === 0) {
+    throw new Error(`package.json in ${packageDir} is missing a valid "name"`);
+  }
+  if (options.setVersion !== void 0) {
+    const raw = JSON.parse(readFileSync5(pkgPath, "utf8"));
+    raw.version = options.setVersion;
+    writeFileSync4(pkgPath, `${JSON.stringify(raw, null, "	")}
+`);
+    pkg.version = options.setVersion;
+  }
+  if (typeof pkg.version !== "string" || pkg.version.length === 0) {
+    throw new Error(
+      `package.json in ${packageDir} is missing a valid "version"`
+    );
+  }
+  if (!existsSync4(join4(packageDir, "dist", "index.js"))) {
+    throw new Error(
+      `${pkg.name} is not built (no dist/index.js in ${packageDir}) \u2014 build it first`
+    );
+  }
+  const inPnpmWorkspace = findUp(packageDir, "pnpm-workspace.yaml") !== void 0;
+  const pm = inPnpmWorkspace ? "pnpm" : "npm";
+  const args = ["publish", "--access", "public", "--tag", tag];
+  if (pm === "pnpm") args.push("--no-git-checks");
+  if (options.dryRun) args.push("--dry-run");
+  process.stdout.write(
+    `publishing ${pkg.name}@${pkg.version} (dist-tag: ${tag}${options.dryRun ? ", dry-run" : ""}) via ${pm}
+`
+  );
+  const result = spawnSync(pm, args, { cwd: packageDir, stdio: "inherit" });
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    throw new Error(`${pm} publish failed for ${pkg.name} (exit ${result.status})`);
+  }
+  return { name: pkg.name, version: pkg.version, tag };
+}
+
+// src/stage.ts
+import {
+  copyFileSync,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync3,
+  rmSync as rmSync3,
+  statSync as statSync3
+} from "fs";
+import { join as join5, resolve as resolve4 } from "path";
+function stage(options) {
+  const packageDir = resolve4(options.packageDir);
+  const commandsDir = resolve4(options.commandsDir);
+  const ifMissing = options.ifMissing ?? "error";
+  const manifest = readManifest(packageDir);
+  const commands = manifest?.commands ?? [];
+  const aliases = manifest?.aliases ?? {};
+  const stubs = manifest?.stubs ?? [];
+  if (commands.length === 0 && stubs.length === 0 && Object.keys(aliases).length === 0) {
+    process.stdout.write(
+      `stage: no commands declared in ${join5(packageDir, "agentos-package.json")} \u2014 nothing to stage
+`
+    );
+    return { staged: [], missing: [] };
+  }
+  if (!existsSync5(commandsDir)) {
+    if (ifMissing === "skip") {
+      process.stdout.write(
+        `stage: commands dir not found (${commandsDir}) \u2014 leaving bin/ unstaged (placeholder package)
+`
+      );
+      return { staged: [], missing: [...commands, ...stubs, ...Object.keys(aliases)] };
+    }
+    throw new Error(`stage: commands dir not found: ${commandsDir}`);
+  }
+  const binDir = join5(packageDir, "bin");
+  rmSync3(binDir, { recursive: true, force: true });
+  mkdirSync3(binDir, { recursive: true });
+  const staged = [];
+  const missing = [];
+  for (const command of commands) {
+    const source = join5(commandsDir, command);
+    if (!existsSync5(source) || !statSync3(source).isFile()) {
+      missing.push(command);
+      continue;
+    }
+    copyFileSync(source, join5(binDir, command));
+    staged.push(command);
+  }
+  const stubsSource = join5(commandsDir, "_stubs");
+  const hasStubsBinary = existsSync5(stubsSource);
+  for (const stub of stubs) {
+    if (!hasStubsBinary) {
+      missing.push(stub);
+      continue;
+    }
+    copyFileSync(stubsSource, join5(binDir, stub));
+    staged.push(stub);
+  }
+  for (const [alias, target] of Object.entries(aliases)) {
+    const source = join5(binDir, target);
+    if (!existsSync5(source)) {
+      missing.push(alias);
+      continue;
+    }
+    copyFileSync(source, join5(binDir, alias));
+    staged.push(alias);
+  }
+  if (missing.length > 0) {
+    const detail = `missing from ${commandsDir}: ${missing.join(", ")}`;
+    if (ifMissing === "error") {
+      throw new Error(`stage: ${detail}`);
+    }
+    process.stdout.write(`stage: WARN ${detail}
+`);
+  }
+  process.stdout.write(
+    `staged ${staged.length} command(s) into ${binDir}
+`
+  );
+  return { staged, missing };
+}
+
+export {
+  packAospkgFromTar,
+  packAospkgFromTarBytes,
+  readManifest,
+  build,
+  detectExecutableKind,
+  isNativeKind,
+  parseShebangInterpreter,
+  verifyPackageDir,
+  pack,
+  resolveTag,
+  publish,
+  stage
+};