sandboxedjs 0.1.94 → 0.1.97

package/dist/index.cjs

@@ -7003,8 +7003,8 @@ var WasiHost = class {
       view.setUint16(at + 8, WASI_ESUCCESS, true);
       view.setUint8(at + 10, subscription.type);
       if (subscription.type === EVENTTYPE_FD_READ) {
-        const available = subscription.fd === 0 ? this.opts.stdin.available : this.bytesLeft(subscription.fd);
-        view.setBigUint64(at + 16, BigInt(available), true);
+        const available2 = subscription.fd === 0 ? this.opts.stdin.available : this.bytesLeft(subscription.fd);
+        view.setBigUint64(at + 16, BigInt(available2), true);
       } else if (subscription.type === EVENTTYPE_FD_WRITE) {
         view.setBigUint64(at + 16, BigInt(64 * 1024), true);
       }
@@ -7241,13 +7241,13 @@ var BinaryExecutionRegistry = class {
   }
   async run(ctx, path) {
     const bytes2 = ctx.vfs.readFile(path, ctx.cred);
-    let info;
+    let info2;
     try {
-      info = inspectElf(bytes2);
+      info2 = inspectElf(bytes2);
     } catch (error) {
       return ctx.fail(String(error), 126);
     }
-    const request = { path, bytes: bytes2, info, sha256: binaryDigest(bytes2) };
+    const request = { path, bytes: bytes2, info: info2, sha256: binaryDigest(bytes2) };
     const reasons = [];
     const backends = [...this.backends];
     for (const tier of ["compatibility", "translation", "emulation"]) {
@@ -7266,7 +7266,7 @@ var BinaryExecutionRegistry = class {
         reasons.push(`${backend.id}: ${result.reason}`);
       }
     }
-    return ctx.fail(`cannot execute ${info.architecture} ELF: ${reasons.join("; ") || "no binary backends registered"}`, 126);
+    return ctx.fail(`cannot execute ${info2.architecture} ELF: ${reasons.join("; ") || "no binary backends registered"}`, 126);
   }
 };
 function checkedWasm(artifact) {
@@ -8530,8 +8530,8 @@ var NetworkStack = class {
     return this.ifaces.some((i) => i.ipv4 === addr);
   }
   // ── listening ports ──────────────────────────────────────────────────────
-  registerListener(port, info) {
-    this.listeners.set(port, { port, since: Date.now(), ...info });
+  registerListener(port, info2) {
+    this.listeners.set(port, { port, since: Date.now(), ...info2 });
   }
   unregisterListener(port) {
     this.listeners.delete(port);
@@ -12124,21 +12124,21 @@ var uname = defineCommand({
       { short: "i", long: "hardware-platform" },
       { short: "o", long: "operating-system" }
     ]);
-    const info = unameInfo(ctx.kernel.hostname);
+    const info2 = unameInfo(ctx.kernel.hostname);
     if (args.has("all")) {
-      ctx.line(`${info.sysname} ${info.nodename} ${info.release} ${info.version} ${info.machine} ${info.operatingSystem}`);
+      ctx.line(`${info2.sysname} ${info2.nodename} ${info2.release} ${info2.version} ${info2.machine} ${info2.operatingSystem}`);
       return 0;
     }
     const parts = [];
-    if (args.has("kernel-name")) parts.push(info.sysname);
-    if (args.has("nodename")) parts.push(info.nodename);
-    if (args.has("kernel-release")) parts.push(info.release);
-    if (args.has("kernel-version")) parts.push(info.version);
-    if (args.has("machine")) parts.push(info.machine);
-    if (args.has("processor")) parts.push(info.processor);
-    if (args.has("hardware-platform")) parts.push(info.hardwarePlatform);
-    if (args.has("operating-system")) parts.push(info.operatingSystem);
-    ctx.line(parts.length ? parts.join(" ") : info.sysname);
+    if (args.has("kernel-name")) parts.push(info2.sysname);
+    if (args.has("nodename")) parts.push(info2.nodename);
+    if (args.has("kernel-release")) parts.push(info2.release);
+    if (args.has("kernel-version")) parts.push(info2.version);
+    if (args.has("machine")) parts.push(info2.machine);
+    if (args.has("processor")) parts.push(info2.processor);
+    if (args.has("hardware-platform")) parts.push(info2.hardwarePlatform);
+    if (args.has("operating-system")) parts.push(info2.operatingSystem);
+    ctx.line(parts.length ? parts.join(" ") : info2.sysname);
     return 0;
   }
 });
@@ -15122,15 +15122,15 @@ var Interpreter = class {
     return this.exitCode;
   }
 };
-function splitRecord(record, fs) {
-  if (record === "") return [];
+function splitRecord(record2, fs) {
+  if (record2 === "") return [];
   if (fs === " ") {
-    const trimmed = record.replace(/^[ \t\n]+|[ \t\n]+$/g, "");
+    const trimmed = record2.replace(/^[ \t\n]+|[ \t\n]+$/g, "");
     return trimmed === "" ? [] : trimmed.split(/[ \t\n]+/);
   }
-  if (fs === "") return [...record];
-  if (fs.length === 1 && !"\\^$.[]|()*+?{}".includes(fs)) return record.split(fs);
-  return record.split(new RegExp(translateEre(fs)));
+  if (fs === "") return [...record2];
+  if (fs.length === 1 && !"\\^$.[]|()*+?{}".includes(fs)) return record2.split(fs);
+  return record2.split(new RegExp(translateEre(fs)));
 }
 var ERE_CLASSES = {
   alpha: "A-Za-z",
@@ -20958,7 +20958,7 @@ var wheels_default = {
 
 // package.json
 var package_default = {
-  version: "0.1.94"};
+  version: "0.1.97"};
 
 // src/python/extension-abi.ts
 var EXTENSION_ABI = {
@@ -23686,7 +23686,7 @@ async function resolve2(options) {
     const clauses = (state.constraints.get(name) ?? []).flatMap((entry) => entry.spec.map((s) => `${s.op}${s.version}`)).sort();
     return `${name}|${[...new Set(clauses)].join(",")}`;
   };
-  const search = async (queue, state) => {
+  const search2 = async (queue, state) => {
     checkBudget();
     if (queue.length === 0) return state;
     const [edge, ...rest] = queue;
@@ -23694,7 +23694,7 @@ async function resolve2(options) {
     const name = requirement.name;
     if (!markerApplies(requirement.marker, environment, extras)) {
       if (requirement.marker) skipped.push({ name, marker: requirement.marker });
-      return search(rest, state);
+      return search2(rest, state);
     }
     const previous = state.constraints.get(name) ?? [];
     const constraints = new Map(state.constraints);
@@ -23711,7 +23711,7 @@ async function resolve2(options) {
           explain(name, next.constraints, already.version)
         );
       }
-      return search(rest, next);
+      return search2(rest, next);
     }
     const signature = signatureOf(name, next);
     const learned = nogoods.get(signature);
@@ -23774,7 +23774,7 @@ async function resolve2(options) {
       const chosen = new Map(next.chosen);
       chosen.set(name, { ...candidate, requires });
       try {
-        return await search([...edges, ...rest], { chosen, constraints: next.constraints });
+        return await search2([...edges, ...rest], { chosen, constraints: next.constraints });
       } catch (error) {
         if (!(error instanceof ResolutionError)) throw error;
         if (/cancelled|budget/.test(error.message)) throw error;
@@ -23789,12 +23789,12 @@ async function resolve2(options) {
     if (specifiers.length === 0 || !markerApplies(marker, environment, root.extras)) continue;
     seeded.set(name, [...seeded.get(name) ?? [], { spec: specifiers, origin: root.origin }]);
   }
-  const solved = await search(roots, { chosen: /* @__PURE__ */ new Map(), constraints: seeded });
+  const solved = await search2(roots, { chosen: /* @__PURE__ */ new Map(), constraints: seeded });
   const distributions = [...solved.chosen.values()].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
   const reported = new Map(skipped.map((s) => [`${s.name}\0${s.marker}`, s]));
   return { distributions, skipped: [...reported.values()] };
 }
-function explain(name, constraints, chosenVersion, available = []) {
+function explain(name, constraints, chosenVersion, available2 = []) {
   const lines = [];
   for (const entry of constraints.get(name) ?? []) {
     if (entry.spec.length === 0) continue;
@@ -23802,9 +23802,9 @@ function explain(name, constraints, chosenVersion, available = []) {
     lines.push(`${entry.origin} requires ${name} ${text2}`);
   }
   if (chosenVersion) lines.push(`but ${name} ${chosenVersion} is already selected`);
-  if (available.length > 0) {
-    const versions = [...new Set(available.map((c) => c.version))].slice(0, 8);
-    lines.push(`usable versions: ${versions.join(", ")}${available.length > 8 ? ", ..." : ""}`);
+  if (available2.length > 0) {
+    const versions = [...new Set(available2.map((c) => c.version))].slice(0, 8);
+    lines.push(`usable versions: ${versions.join(", ")}${available2.length > 8 ? ", ..." : ""}`);
   }
   return lines;
 }
@@ -23933,9 +23933,7 @@ async function installRequirements(options) {
       continue;
     }
     options.progress.downloading(distribution.name, distribution.version);
-    const bytes2 = await options.client.bytes(distribution.url, { timeoutMs: 12e4 });
-    requireArchive(distribution, bytes2);
-    verifyDigest(distribution, bytes2);
+    const bytes2 = await download(options.client, distribution);
     const files = stageWheel(readZip(bytes2));
     staged.push(...distribution.kind === "substituted" ? substituteFiles(distribution.name, files, SITE_PACKAGES) : files);
     installed3.push({ name: distribution.name, version: distribution.version });
@@ -23951,18 +23949,41 @@ function requireArchive(distribution, bytes2) {
     `${distribution.filename} did not arrive as a wheel from ${distribution.url}: ` + (looksLikeMarkup ? "the server answered with an HTML page, which usually means the wheel is not published at that address and the server returned its index page instead" : `expected a zip archive, got ${bytes2.length} bytes beginning ${JSON.stringify(opening)}`)
   );
 }
-function verifyDigest(distribution, bytes2) {
+async function download(client, distribution) {
+  const bytes2 = await client.bytes(distribution.url, { timeoutMs: 12e4 });
+  requireArchive(distribution, bytes2);
+  const mismatch = digestMismatch(distribution, bytes2);
+  if (!mismatch) return bytes2;
+  const fresh = await refetch(client, distribution);
+  if (fresh && !digestMismatch(distribution, fresh)) {
+    requireArchive(distribution, fresh);
+    return fresh;
+  }
+  throw new Error(
+    `${mismatch} ${fresh ? "A retry past any cache returned the same bytes, so the index and the file it names disagree." : "A retry past any cache could not be made, so this may be a cached copy of an older build; clearing the cache, or asking the index's host to purge it, is worth trying before the index is blamed."}`
+  );
+}
+async function refetch(client, distribution) {
+  const separator = distribution.url.includes("?") ? "&" : "?";
+  try {
+    const bytes2 = await client.bytes(
+      `${distribution.url}${separator}sha256=${distribution.sha256}`,
+      { timeoutMs: 6e4 }
+    );
+    return bytes2.length > 1 && bytes2[0] === 80 && bytes2[1] === 75 ? bytes2 : null;
+  } catch {
+    return null;
+  }
+}
+function digestMismatch(distribution, bytes2) {
   if (!distribution.sha256) {
     throw new Error(
       `${distribution.filename} was published without a sha256 digest, so it cannot be verified`
     );
   }
   const actual = [...sha256.sha256(bytes2)].map((b) => b.toString(16).padStart(2, "0")).join("");
-  if (actual !== distribution.sha256) {
-    throw new Error(
-      `${distribution.filename} failed verification: the index published sha256 ${distribution.sha256} but the download hashes to ${actual}`
-    );
-  }
+  if (actual === distribution.sha256) return null;
+  return `${distribution.filename} failed verification: the index published sha256 ${distribution.sha256} but the download hashes to ${actual}.`;
 }
 function stageWheel(entries, resolved) {
   const staged = [];
@@ -26401,9 +26422,9 @@ function parsePax(data) {
     if (space < 0) break;
     const length = Number(value.slice(offset, space));
     if (!Number.isFinite(length) || length <= 0) break;
-    const record = value.slice(space + 1, offset + length - 1);
-    const equal2 = record.indexOf("=");
-    if (equal2 > 0) result[record.slice(0, equal2)] = record.slice(equal2 + 1);
+    const record2 = value.slice(space + 1, offset + length - 1);
+    const equal2 = record2.indexOf("=");
+    if (equal2 > 0) result[record2.slice(0, equal2)] = record2.slice(equal2 + 1);
     offset += length;
   }
   return result;
@@ -27183,27 +27204,27 @@ var apt = defineCommand({
     switch (subcommand) {
       case "list": {
         const installedOnly = rest.includes("--installed");
-        for (const [name, info] of Object.entries(provided)) {
-          const available = ctx.kernel.which(name === "python3-pip" ? "pip" : name === "gawk" ? "awk" : name, ctx.cwd, ctx.env, ctx.cred) !== null;
-          if (installedOnly && !available) continue;
-          ctx.line(`${name}/stable ${info.version} amd64${available ? " [installed]" : ""}`);
+        for (const [name, info2] of Object.entries(provided)) {
+          const available2 = ctx.kernel.which(name === "python3-pip" ? "pip" : name === "gawk" ? "awk" : name, ctx.cwd, ctx.env, ctx.cred) !== null;
+          if (installedOnly && !available2) continue;
+          ctx.line(`${name}/stable ${info2.version} amd64${available2 ? " [installed]" : ""}`);
         }
         return 0;
       }
       case "show": {
         let status = 0;
         for (const name of rest) {
-          const info = provided[name];
-          if (!info) {
+          const info2 = provided[name];
+          if (!info2) {
             ctx.warn(`E: No packages found matching ${name}`);
             status = 1;
             continue;
           }
           ctx.line(`Package: ${name}`);
-          ctx.line(`Version: ${info.version}`);
+          ctx.line(`Version: ${info2.version}`);
           ctx.line(`Priority: optional`);
           ctx.line(`Architecture: amd64`);
-          ctx.line(`Description: ${info.description}`);
+          ctx.line(`Description: ${info2.description}`);
           ctx.line("");
         }
         return status;
@@ -27234,10 +27255,10 @@ var apt = defineCommand({
         return 100;
       case "search": {
         const pattern = new RegExp(rest[0] ?? "", "i");
-        for (const [name, info] of Object.entries(provided)) {
-          if (pattern.test(name) || pattern.test(info.description)) {
-            ctx.line(`${name}/stable ${info.version} amd64`);
-            ctx.line(`  ${info.description}`);
+        for (const [name, info2] of Object.entries(provided)) {
+          if (pattern.test(name) || pattern.test(info2.description)) {
+            ctx.line(`${name}/stable ${info2.version} amd64`);
+            ctx.line(`  ${info2.description}`);
             ctx.line("");
           }
         }
@@ -27702,6 +27723,708 @@ function browserCommands() {
   ];
 }
 
+// src/apps/pm.ts
+init_binary();
+init_zip();
+
+// src/apps/registry.ts
+var APPS_ROOT = "/opt";
+var APP_BIN_DIR = "/usr/local/bin";
+var APP_STATE = "/var/lib/pm/installed.json";
+var DEFAULT_REGISTRY = "https://sandboxedjswheels.pages.dev/apps";
+var BUILT_IN_PUBLISHERS = [
+  {
+    publisher: "SandboxedJs",
+    publicKey: "MCowBQYDK2VwAyEAuyxKMeyeO/05mr5Qu8vc+Dd9yMG2/oKDwt7KA+C9Mj4="
+  }
+];
+var AppRegistryError = class extends Error {
+};
+function parseIndex(text2, source) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text2);
+  } catch (error) {
+    throw new AppRegistryError(`${source} is not JSON: ${error.message}`);
+  }
+  const index = parsed;
+  if (index?.format !== "sandboxedjs-app-index") {
+    throw new AppRegistryError(
+      `${source} is not an application index (its format is ${JSON.stringify(index?.format ?? null)})`
+    );
+  }
+  if (!Array.isArray(index.apps)) {
+    throw new AppRegistryError(`${source} has no apps`);
+  }
+  for (const app of index.apps) {
+    for (const field of ["name", "version", "filename", "sha256"]) {
+      if (typeof app[field] !== "string" || !app[field]) {
+        throw new AppRegistryError(`${source}: an entry is missing ${field}`);
+      }
+    }
+  }
+  return index;
+}
+function selectRelease(index, name, version) {
+  const matches3 = index.apps.filter((app) => app.name === name);
+  if (matches3.length === 0) {
+    const names = index.apps.map((app) => app.name).sort();
+    throw new AppRegistryError(
+      `no application named ${name}. The registry has: ${names.join(", ") || "nothing"}`
+    );
+  }
+  if (version) {
+    const exact = matches3.find((app) => app.version === version);
+    if (!exact) {
+      const versions = matches3.map((app) => app.version).join(", ");
+      throw new AppRegistryError(`${name} has no version ${version}; it has ${versions}`);
+    }
+    return exact;
+  }
+  return matches3.slice().sort((a, b) => compareVersions2(b.version, a.version))[0];
+}
+function compareVersions2(a, b) {
+  const left = a.split(/[.-]/);
+  const right = b.split(/[.-]/);
+  for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+    const x = left[index] ?? "";
+    const y = right[index] ?? "";
+    const nx = Number(x);
+    const ny = Number(y);
+    if (Number.isFinite(nx) && Number.isFinite(ny) && x !== "" && y !== "") {
+      if (nx !== ny) return nx - ny;
+      continue;
+    }
+    if (x !== y) return x < y ? -1 : 1;
+  }
+  return 0;
+}
+function parseSpecifier(specifier) {
+  const at = specifier.lastIndexOf("@");
+  if (at <= 0) return { name: specifier };
+  return { name: specifier.slice(0, at), version: specifier.slice(at + 1) };
+}
+function validateManifest2(manifest, source) {
+  const app = manifest;
+  if (typeof app?.name !== "string" || typeof app?.version !== "string") {
+    throw new AppRegistryError(`${source} is not an application manifest`);
+  }
+  for (const binary of app.bins ?? []) {
+    if (typeof binary?.name !== "string" || typeof binary?.path !== "string") {
+      throw new AppRegistryError(`${source}: a bins entry needs a name and a path`);
+    }
+    if (binary.name.includes("/")) {
+      throw new AppRegistryError(`${source}: a command name cannot contain a slash`);
+    }
+  }
+  for (const service of app.services ?? []) {
+    if (typeof service?.port !== "number" || !Number.isInteger(service.port)) {
+      throw new AppRegistryError(`${source}: a service needs an integer port`);
+    }
+  }
+  return app;
+}
+
+// src/apps/sbjs.ts
+init_binary();
+init_zip();
+var MANIFEST_PATH = "META/manifest.json";
+var SIGNATURE_PATH = "META/signature.json";
+var TRUSTED_KEYS_PATH = "/etc/pm/trusted-keys.json";
+var PackageError = class extends Error {
+};
+async function openPackage(bytes2, trusted) {
+  const entries = readZip(bytes2);
+  const byName = new Map(entries.map((entry) => [entry.name, entry]));
+  const manifestEntry = byName.get(MANIFEST_PATH);
+  if (!manifestEntry) {
+    throw new PackageError(
+      `not a SandboxedJs package: it has no ${MANIFEST_PATH}. A plain zip can be installed with --allow-unsigned, but it carries no publisher.`
+    );
+  }
+  const manifestBytes = manifestEntry.data();
+  const manifest = parseManifest(manifestBytes);
+  validateManifest2(manifest.app, `${MANIFEST_PATH}'s app`);
+  for (const entry of entries) {
+    if (entry.isDirectory || entry.name.startsWith("META/")) continue;
+    const expected = manifest.files[entry.name];
+    if (!expected) {
+      throw new PackageError(`${entry.name} is in the package but not in its manifest`);
+    }
+    const actual = await digestHex("sha256", entry.data());
+    if (actual !== expected) {
+      throw new PackageError(
+        `${entry.name} does not match the manifest (expected ${expected}, found ${actual})`
+      );
+    }
+  }
+  for (const name of Object.keys(manifest.files)) {
+    if (!byName.has(name)) {
+      throw new PackageError(`${name} is in the manifest but missing from the package`);
+    }
+  }
+  const signatureEntry = byName.get(SIGNATURE_PATH);
+  if (!signatureEntry) {
+    return { manifest, signature: null, entries, trustedBy: null };
+  }
+  const signature = parseSignature(signatureEntry.data());
+  const valid = await verifySignature(manifestBytes, signature);
+  if (!valid) {
+    throw new PackageError(
+      `the signature on ${manifest.app.name} does not match its manifest; the package has been altered since it was signed`
+    );
+  }
+  const trustedBy = trusted.find((key) => key.publicKey === signature.publicKey) ?? null;
+  return { manifest, signature, entries, trustedBy };
+}
+function parseManifest(bytes2) {
+  let parsed;
+  try {
+    parsed = JSON.parse(new TextDecoder().decode(bytes2));
+  } catch (error) {
+    throw new PackageError(`${MANIFEST_PATH} is not JSON: ${error.message}`);
+  }
+  const manifest = parsed;
+  if (manifest?.format !== "sandboxedjs-package") {
+    throw new PackageError(`${MANIFEST_PATH} is not a package manifest`);
+  }
+  if (!manifest.files || typeof manifest.files !== "object") {
+    throw new PackageError(`${MANIFEST_PATH} lists no files`);
+  }
+  if (!manifest.app) {
+    throw new PackageError(`${MANIFEST_PATH} carries no application manifest`);
+  }
+  return manifest;
+}
+function parseSignature(bytes2) {
+  let parsed;
+  try {
+    parsed = JSON.parse(new TextDecoder().decode(bytes2));
+  } catch (error) {
+    throw new PackageError(`${SIGNATURE_PATH} is not JSON: ${error.message}`);
+  }
+  const signature = parsed;
+  if (signature?.format !== "sandboxedjs-signature") {
+    throw new PackageError(`${SIGNATURE_PATH} is not a signature`);
+  }
+  if (signature.algorithm !== "ed25519") {
+    throw new PackageError(
+      `${signature.algorithm} signatures are not supported by this runtime; only ed25519 is`
+    );
+  }
+  for (const field of ["publicKey", "signature"]) {
+    if (typeof signature[field] !== "string" || !signature[field]) {
+      throw new PackageError(`${SIGNATURE_PATH} has no ${field}`);
+    }
+  }
+  return signature;
+}
+async function verifySignature(manifestBytes, signature) {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) {
+    throw new PackageError(
+      "this runtime has no WebCrypto, so a package signature cannot be checked"
+    );
+  }
+  let key;
+  try {
+    key = await subtle.importKey(
+      "spki",
+      intoBuffer(base64ToBytes(signature.publicKey)),
+      { name: "Ed25519" },
+      false,
+      ["verify"]
+    );
+  } catch (error) {
+    throw new PackageError(
+      `cannot use the package's public key: ${error.message}. Ed25519 needs Node 20 or a browser that implements it.`
+    );
+  }
+  return subtle.verify(
+    { name: "Ed25519" },
+    key,
+    intoBuffer(base64ToBytes(signature.signature)),
+    intoBuffer(manifestBytes)
+  );
+}
+function intoBuffer(bytes2) {
+  return bytes2.slice().buffer;
+}
+function base64ToBytes(text2) {
+  const binary = atob(text2);
+  const bytes2 = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes2[index] = binary.charCodeAt(index);
+  }
+  return bytes2;
+}
+async function fingerprint(publicKey) {
+  const digest2 = await digestHex("sha256", base64ToBytes(publicKey));
+  return digest2.slice(0, 32).replace(/(.{4})(?=.)/g, "$1-");
+}
+function asRegistryError(error) {
+  return new AppRegistryError(error.message);
+}
+
+// src/apps/pm.ts
+function registryBase(ctx) {
+  const configured = ctx.env.SBX_PM_REGISTRY ?? ctx.env.PM_REGISTRY;
+  return configured && configured.trim() || DEFAULT_REGISTRY;
+}
+var pm = defineCommand({
+  name: "pm",
+  path: "/usr/bin/pm",
+  summary: "install and manage applications",
+  usage: "pm <install|remove|list|info|search|available> [name[@version]]",
+  manual: `Applications are programs the container runs, packaged with what
+they need. They are not Python or Node packages: use pip or npm for those.
+
+  pm install NAME[@VERSION]   download, verify and install
+  pm remove NAME              remove it and the commands it installed
+  pm list                     what is installed here
+  pm info NAME                what a package provides
+  pm search TEXT              search the registry
+  pm available                everything the registry offers
+  pm trust list|add|remove    publisher keys this container trusts
+
+Packages come from ${DEFAULT_REGISTRY} unless SBX_PM_REGISTRY names another.
+
+A package is a .sbjs file: a zip carrying META/manifest.json, which lists a
+sha256 for every file in it, and META/signature.json, an Ed25519 signature
+over that manifest. Installing checks both, and refuses a package signed by a
+key this container does not trust. --allow-untrusted and --allow-unsigned
+override that, one install at a time.
+
+A signature says who published a package and that nothing in it has changed
+since. It does not say the program is safe to run.`,
+  async run(ctx) {
+    const [subcommand, ...rest] = ctx.args;
+    try {
+      switch (subcommand) {
+        case "install":
+          return await install2(ctx, rest);
+        case "remove":
+        case "uninstall":
+          return await remove(ctx, rest);
+        case "list":
+          return listInstalled2(ctx);
+        case "info":
+          return await info(ctx, rest);
+        case "search":
+          return await search(ctx, rest);
+        case "available":
+          return await available(ctx);
+        case "trust":
+          return await trust(ctx, rest);
+        case void 0:
+        case "--help":
+        case "-h":
+          ctx.line(pm.usage);
+          return 0;
+        default:
+          ctx.warn(`pm: unknown command ${subcommand}`);
+          return 2;
+      }
+    } catch (error) {
+      ctx.warn(`pm: ${error.message}`);
+      return error instanceof AppRegistryError ? 2 : 1;
+    }
+  }
+});
+async function install2(ctx, args) {
+  if (args.length === 0) {
+    ctx.warn("pm install: name it, as `pm install officesuite`");
+    return 2;
+  }
+  const options = {
+    allowUnsigned: args.includes("--allow-unsigned"),
+    allowUntrusted: args.includes("--allow-untrusted") || args.includes("--allow-unsigned")
+  };
+  const names = args.filter((argument) => !argument.startsWith("--"));
+  if (names.length === 0) {
+    ctx.warn("pm install: name it, as `pm install officesuite`");
+    return 2;
+  }
+  const index = await fetchIndex(ctx);
+  for (const specifier of names) {
+    const { name, version } = parseSpecifier(specifier);
+    const release = selectRelease(index, name, version);
+    await installRelease(ctx, index, release, /* @__PURE__ */ new Set(), options);
+  }
+  return 0;
+}
+async function installRelease(ctx, index, release, seen, options) {
+  if (seen.has(release.name)) return;
+  seen.add(release.name);
+  for (const required of release.requires ?? []) {
+    const { name, version } = parseSpecifier(required);
+    if (installedApps(ctx).some((app) => app.name === name)) continue;
+    await installRelease(ctx, index, selectRelease(index, name, version), seen, options);
+  }
+  const base2 = registryBase(ctx).replace(/\/$/, "");
+  const url = `${base2}/${release.filename}`;
+  ctx.line(`Fetching ${release.name} ${release.version}`);
+  let archive = await download2(url);
+  let digest2 = await digestHex("sha256", archive);
+  if (digest2 !== release.sha256) {
+    const retried = await download2(`${url}${url.includes("?") ? "&" : "?"}sha256=${release.sha256}`).catch(() => null);
+    const retriedDigest = retried && await digestHex("sha256", retried);
+    if (retried && retriedDigest === release.sha256) {
+      archive = retried;
+      digest2 = retriedDigest;
+    } else {
+      throw new AppRegistryError(
+        `${release.filename} failed verification: the registry publishes sha256 ${release.sha256} but the download hashes to ${digest2}. ` + (retried ? "A retry past any cache returned the same bytes, so the registry and the file it names disagree." : "A retry past any cache could not be made; a cached copy of an older build would look like this, so clearing the cache is worth trying before the registry is blamed.")
+      );
+    }
+  }
+  const verified = await verify(ctx, archive, release, options);
+  const root = `${APPS_ROOT}/${release.name}`;
+  removeInstalled(ctx, release.name, { quiet: true });
+  const manifest = unpack(ctx, archive, root, release, verified);
+  const bins = linkBinaries(ctx, manifest, root);
+  record(ctx, {
+    ...manifest,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    root,
+    installedBins: bins,
+    sha256: release.sha256,
+    ...verified?.signature ? {
+      publisher: verified.signature.publisher ?? verified.trustedBy?.publisher ?? "unknown",
+      publicKey: verified.signature.publicKey
+    } : {}
+  });
+  ctx.line(`Installed ${manifest.name} ${manifest.version} in ${root}`);
+  if (bins.length > 0) ctx.line(`  commands: ${bins.join(", ")}`);
+  for (const service of manifest.services ?? []) {
+    ctx.line(
+      `  service: ${service.name} on port ${service.port}` + (service.path ? ` at ${service.path}` : "") + ` (start it with \`${service.command}\`)`
+    );
+  }
+  if (manifest.docs) ctx.line(`  docs: ${root}/${manifest.docs}`);
+}
+async function download2(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new AppRegistryError(`${url} answered ${response.status} ${response.statusText}`);
+  }
+  return new Uint8Array(await response.arrayBuffer());
+}
+async function verify(ctx, archive, release, options) {
+  let opened;
+  try {
+    opened = await openPackage(archive, trustedKeys(ctx));
+  } catch (error) {
+    if (options.allowUnsigned && /has no META\/manifest\.json/.test(error.message)) {
+      ctx.warn(`pm: ${release.name} is unsigned and its publisher is unknown`);
+      return null;
+    }
+    throw asRegistryError(error);
+  }
+  if (!opened.signature) {
+    if (!options.allowUnsigned) {
+      throw new AppRegistryError(
+        `${release.name} carries no signature, so its publisher cannot be established. Install it with --allow-unsigned if you got it from somewhere you trust.`
+      );
+    }
+    ctx.warn(`pm: ${release.name} is unsigned and its publisher is unknown`);
+    return opened;
+  }
+  const print = await fingerprint(opened.signature.publicKey);
+  if (!opened.trustedBy && !options.allowUntrusted) {
+    throw new AppRegistryError(
+      `${release.name} is signed by a key this container does not trust (${opened.signature.publisher ?? "unnamed"}, ${print}). Add it with \`pm trust add ${print}\` after checking it, or install with --allow-untrusted.`
+    );
+  }
+  ctx.line(
+    opened.trustedBy ? `  signed by ${opened.trustedBy.publisher} (${print})` : `  signed by an untrusted key (${opened.signature.publisher ?? "unnamed"}, ${print})`
+  );
+  return opened;
+}
+function trustedKeys(ctx) {
+  let stored = [];
+  try {
+    const parsed = JSON.parse(ctx.vfs.readText(TRUSTED_KEYS_PATH, ctx.cred));
+    stored = Array.isArray(parsed.keys) ? parsed.keys : [];
+  } catch {
+  }
+  const known = new Set(stored.map((key) => key.publicKey));
+  return [...stored, ...BUILT_IN_PUBLISHERS.filter((key) => !known.has(key.publicKey))];
+}
+function writeTrustedKeys(ctx, keys) {
+  ctx.vfs.mkdir("/etc/pm", { cred: ctx.cred, recursive: true });
+  ctx.vfs.writeFile(
+    TRUSTED_KEYS_PATH,
+    `${JSON.stringify({ format: "sandboxedjs-trusted-keys", keys }, null, 2)}
+`,
+    { cred: ctx.cred, mode: 420 }
+  );
+}
+async function trust(ctx, args) {
+  const [action, ...rest] = args;
+  const keys = trustedKeys(ctx);
+  switch (action) {
+    case "list":
+    case void 0: {
+      if (keys.length === 0) {
+        ctx.line("No publisher keys are trusted; only unsigned installs are possible.");
+        return 0;
+      }
+      for (const key of keys) {
+        ctx.line(`${key.publisher}  ${await fingerprint(key.publicKey)}`);
+      }
+      return 0;
+    }
+    case "add": {
+      const [publisher, publicKey] = rest;
+      if (!publisher || !publicKey) {
+        ctx.warn("pm trust add: give a publisher name and its base64 public key");
+        return 2;
+      }
+      const next = keys.filter((key) => key.publicKey !== publicKey);
+      next.push({ publisher, publicKey, addedAt: (/* @__PURE__ */ new Date()).toISOString() });
+      writeTrustedKeys(ctx, next);
+      ctx.line(`Trusting ${publisher} (${await fingerprint(publicKey)})`);
+      return 0;
+    }
+    case "remove": {
+      const [publisher] = rest;
+      const next = keys.filter((key) => key.publisher !== publisher);
+      if (next.length === keys.length) {
+        ctx.warn(`pm: no trusted key named ${publisher}`);
+        return 1;
+      }
+      writeTrustedKeys(ctx, next);
+      ctx.line(`Removed ${publisher}`);
+      return 0;
+    }
+    default:
+      ctx.warn(`pm trust: unknown action ${action}`);
+      return 2;
+  }
+}
+function unpack(ctx, archive, root, release, verified) {
+  const entries = verified?.entries ?? readZip(archive);
+  const manifest = verified?.manifest.app ?? readAppManifest(entries, release);
+  if (manifest.name !== release.name || manifest.version !== release.version) {
+    throw new AppRegistryError(
+      `${release.filename} contains ${manifest.name} ${manifest.version}, but the registry lists it as ${release.name} ${release.version}`
+    );
+  }
+  ctx.vfs.mkdir(root, { cred: ctx.cred, recursive: true });
+  for (const entry of entries) {
+    if (entry.name.startsWith("META/")) continue;
+    const target = resolveInside(root, entry.name);
+    if (entry.isDirectory) {
+      ctx.vfs.mkdir(target, { cred: ctx.cred, recursive: true });
+      continue;
+    }
+    const parent = target.slice(0, target.lastIndexOf("/"));
+    if (parent) ctx.vfs.mkdir(parent, { cred: ctx.cred, recursive: true });
+    const executable = (entry.mode & 73) !== 0 || (manifest.bins ?? []).some((binary) => binary.path === entry.name);
+    ctx.vfs.writeFile(target, entry.data(), {
+      cred: ctx.cred,
+      mode: executable ? 493 : 420
+    });
+  }
+  return manifest;
+}
+function readAppManifest(entries, release) {
+  const entry = entries.find((candidate) => candidate.name === "app.json");
+  if (!entry) throw new AppRegistryError(`${release.filename} has no app.json`);
+  return validateManifest2(
+    JSON.parse(new TextDecoder().decode(entry.data())),
+    `${release.name}'s app.json`
+  );
+}
+function resolveInside(root, name) {
+  const clean2 = name.replace(/\\/g, "/");
+  if (clean2.startsWith("/")) {
+    throw new AppRegistryError(`archive entry ${name} is an absolute path`);
+  }
+  const parts = [];
+  for (const part of clean2.split("/")) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") {
+      throw new AppRegistryError(`archive entry ${name} escapes the package directory`);
+    }
+    parts.push(part);
+  }
+  return `${root}/${parts.join("/")}`;
+}
+function linkBinaries(ctx, manifest, root) {
+  const installed3 = [];
+  if ((manifest.bins ?? []).length === 0) return installed3;
+  ctx.vfs.mkdir(APP_BIN_DIR, { cred: ctx.cred, recursive: true });
+  for (const binary of manifest.bins ?? []) {
+    const target = resolveInside(root, binary.path);
+    const wrapper = `${APP_BIN_DIR}/${binary.name}`;
+    ctx.vfs.writeFile(
+      wrapper,
+      `#!/bin/sh
+# installed by pm for ${manifest.name} ${manifest.version}
+exec ${target} "$@"
+`,
+      { cred: ctx.cred, mode: 493 }
+    );
+    installed3.push(binary.name);
+  }
+  return installed3;
+}
+async function remove(ctx, args) {
+  if (args.length === 0) {
+    ctx.warn("pm remove: name it");
+    return 2;
+  }
+  let code = 0;
+  for (const specifier of args) {
+    const { name } = parseSpecifier(specifier);
+    if (!removeInstalled(ctx, name, { quiet: false })) {
+      ctx.warn(`pm: ${name} is not installed`);
+      code = 1;
+    } else {
+      ctx.line(`Removed ${name}`);
+    }
+  }
+  return code;
+}
+function removeInstalled(ctx, name, options) {
+  const apps = installedApps(ctx);
+  const app = apps.find((entry) => entry.name === name);
+  if (!app) return false;
+  for (const binary of app.installedBins) {
+    try {
+      ctx.vfs.unlink(`${APP_BIN_DIR}/${binary}`, ctx.cred);
+    } catch {
+    }
+  }
+  try {
+    removeTree(ctx, app.root);
+  } catch (error) {
+    if (!options.quiet) ctx.warn(`pm: could not remove ${app.root}: ${error.message}`);
+  }
+  writeState(ctx, apps.filter((entry) => entry.name !== name));
+  return true;
+}
+function removeTree(ctx, path) {
+  let stats;
+  try {
+    stats = ctx.vfs.stat(path, { cred: ctx.cred });
+  } catch {
+    return;
+  }
+  if (stats.isDirectory()) {
+    for (const entry of ctx.vfs.readdir(path, ctx.cred)) {
+      removeTree(ctx, `${path}/${entry}`);
+    }
+    ctx.vfs.rmdir(path, ctx.cred);
+    return;
+  }
+  ctx.vfs.unlink(path, ctx.cred);
+}
+function listInstalled2(ctx) {
+  const apps = installedApps(ctx);
+  if (apps.length === 0) {
+    ctx.line("No applications installed. `pm available` lists what there is.");
+    return 0;
+  }
+  for (const app of apps.slice().sort((a, b) => a.name.localeCompare(b.name))) {
+    const commands12 = app.installedBins.length > 0 ? `  (${app.installedBins.join(", ")})` : "";
+    ctx.line(`${app.name} ${app.version}${commands12}`);
+  }
+  return 0;
+}
+async function info(ctx, args) {
+  const name = args[0];
+  if (!name) {
+    ctx.warn("pm info: name it");
+    return 2;
+  }
+  const local = installedApps(ctx).find((app) => app.name === name);
+  if (local) {
+    ctx.line(`${local.name} ${local.version} (installed ${local.installedAt})`);
+    if (local.summary) ctx.line(`  ${local.summary}`);
+    ctx.line(`  root: ${local.root}`);
+    if (local.installedBins.length > 0) ctx.line(`  commands: ${local.installedBins.join(", ")}`);
+    for (const service of local.services ?? []) {
+      ctx.line(`  service: ${service.name} on port ${service.port}${service.path ?? ""}`);
+    }
+    if (local.docs) ctx.line(`  docs: ${local.root}/${local.docs}`);
+    return 0;
+  }
+  const release = selectRelease(await fetchIndex(ctx), name);
+  ctx.line(`${release.name} ${release.version} (not installed)`);
+  if (release.summary) ctx.line(`  ${release.summary}`);
+  ctx.line(`  size: ${Math.round(release.size / 1024)} kB`);
+  if ((release.bins ?? []).length > 0) {
+    ctx.line(`  commands: ${(release.bins ?? []).map((b) => b.name).join(", ")}`);
+  }
+  return 0;
+}
+async function search(ctx, args) {
+  const term = (args[0] ?? "").toLowerCase();
+  const index = await fetchIndex(ctx);
+  const matches3 = index.apps.filter(
+    (app) => app.name.toLowerCase().includes(term) || (app.summary ?? "").toLowerCase().includes(term)
+  );
+  if (matches3.length === 0) {
+    ctx.line(`nothing matches ${JSON.stringify(args[0] ?? "")}`);
+    return 1;
+  }
+  for (const app of matches3) ctx.line(`${app.name} ${app.version}  ${app.summary ?? ""}`);
+  return 0;
+}
+async function available(ctx) {
+  const index = await fetchIndex(ctx);
+  for (const app of index.apps.slice().sort((a, b) => a.name.localeCompare(b.name))) {
+    ctx.line(`${app.name} ${app.version}  ${app.summary ?? ""}`);
+  }
+  return 0;
+}
+async function fetchIndex(ctx) {
+  const base2 = registryBase(ctx).replace(/\/$/, "");
+  const url = `${base2}/index.json`;
+  let response;
+  try {
+    response = await fetch(url);
+  } catch (error) {
+    throw new AppRegistryError(
+      `cannot reach the application registry at ${url}: ${error.message}`
+    );
+  }
+  if (!response.ok) {
+    throw new AppRegistryError(`${url} answered ${response.status} ${response.statusText}`);
+  }
+  return parseIndex(await response.text(), url);
+}
+function installedApps(ctx) {
+  try {
+    const text2 = ctx.vfs.readText(APP_STATE, ctx.cred);
+    const parsed = JSON.parse(text2);
+    return Array.isArray(parsed.apps) ? parsed.apps : [];
+  } catch {
+    return [];
+  }
+}
+function record(ctx, app) {
+  const apps = installedApps(ctx).filter((entry) => entry.name !== app.name);
+  apps.push(app);
+  writeState(ctx, apps);
+}
+function writeState(ctx, apps) {
+  const directory2 = APP_STATE.slice(0, APP_STATE.lastIndexOf("/"));
+  ctx.vfs.mkdir(directory2, { cred: ctx.cred, recursive: true });
+  ctx.vfs.writeFile(
+    APP_STATE,
+    `${JSON.stringify({ format: "sandboxedjs-installed-apps", apps }, null, 2)}
+`,
+    { cred: ctx.cred, mode: 420 }
+  );
+}
+function appCommands() {
+  return [pm];
+}
+
 // src/bin/index.ts
 function allCommands() {
   return [
@@ -27721,7 +28444,8 @@ function allCommands() {
     ...ffmpegCommands(),
     ...wasiCommands(),
     ...packageCommands(),
-    ...browserCommands()
+    ...browserCommands(),
+    ...appCommands()
   ];
 }
 function installUserland(kernel) {
@@ -31440,7 +32164,7 @@ ${indent(detail, 4)}
     if (detail) host2.write(`${indent(detail, depth * 2 + 2)}
 `);
   };
-  const record = (outcome, name, error) => {
+  const record2 = (outcome, name, error) => {
     counts.tests += 1;
     if (outcome === "pass") counts.pass += 1;
     else if (outcome === "fail") {
@@ -31462,13 +32186,13 @@ ${indent(detail, 4)}
     if (!matchesPattern2(display)) return true;
     if (runOnly && !options.only) return true;
     if (options.skip) {
-      record("skip", display);
+      record2("skip", display);
       report(depth, "skip", name, started);
       return true;
     }
     if (!fn) {
       const outcome = options.todo ? "todo" : "skip";
-      record(outcome, display);
+      record2(outcome, display);
       report(depth, outcome, name, started);
       return true;
     }
@@ -31532,21 +32256,21 @@ ${indent(detail, 4)}
       controller.abort();
     }
     if (skipped) {
-      record("skip", display);
+      record2("skip", display);
       report(depth, "skip", name, started);
       return true;
     }
     if (error !== void 0) {
       if (todo) {
-        record("todo", display);
+        record2("todo", display);
         report(depth, "todo", name, started);
         return true;
       }
-      record("fail", display, error);
+      record2("fail", display, error);
       report(depth, "fail", name, started, errorText(error));
       return false;
     }
-    record(todo ? "todo" : "pass", display);
+    record2(todo ? "todo" : "pass", display);
     report(depth, todo ? "todo" : "pass", name, started);
     return true;
   };
@@ -31561,7 +32285,7 @@ ${indent(detail, 4)}
       else host2.write(`${"  ".repeat(depth)}\u25B6 ${suite.name}
 `);
       if (suite.options.skip) {
-        for (const child of suite.children) if (child.kind === "test") record("skip", fullName(child));
+        for (const child of suite.children) if (child.kind === "test") record2("skip", fullName(child));
         report(depth, "skip", suite.name, started);
         return true;
       }
@@ -31573,7 +32297,7 @@ ${indent(detail, 4)}
     } catch (error) {
       for (const child of suite.children) {
         if (child.kind === "test") {
-          record("cancelled", fullName(child), error);
+          record2("cancelled", fullName(child), error);
           report(depth + (isRoot ? 0 : 1), "cancelled", child.name, started, errorText(error));
         }
       }
@@ -37031,6 +37755,14 @@ var Container = class _Container {
     installUserland(kernel);
     const container = new _Container(kernel, pod, opts);
     if (opts.files) container.mountSync(opts.files, { cwd: opts.cwd ?? "/" });
+    if (opts.modules && opts.modules.length > 0) {
+      const result = await container.exec(`pm install ${opts.modules.join(" ")}`);
+      if (result.exitCode !== 0) {
+        throw new Error(
+          `could not install ${opts.modules.join(", ")}: ${(result.stderr || result.stdout).trim() || `pm exited ${result.exitCode}`}`
+        );
+      }
+    }
     return container;
   }
   // ── file seeding ──────────────────────────────────────────────────────────