@ai-ecoverse/slicc-jsh 0.1.0-8 → 0.2.1

package/dist/host/main.mjs

@@ -0,0 +1,893 @@
+// src/host/main.mjs
+import { spawn as spawnChild } from "node:child_process";
+import { accessSync, constants as fsConstants, readFileSync, writeSync } from "node:fs";
+import { createRequire } from "node:module";
+import { constants as osConstants } from "node:os";
+import { delimiter, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import vm from "node:vm";
+
+// package.json
+var package_default = {
+  name: "@ai-ecoverse/slicc-jsh",
+  version: "0.2.1",
+  description: "Node.js-compatible runtime for slicc-kernel: the node and jsh commands (abi: js)",
+  type: "module",
+  license: "Apache-2.0",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/ai-ecoverse/slicc-jsh.git"
+  },
+  homepage: "https://github.com/ai-ecoverse/slicc-jsh",
+  bugs: {
+    url: "https://github.com/ai-ecoverse/slicc-jsh/issues"
+  },
+  bin: {
+    jsh: "dist/host/jsh.mjs"
+  },
+  engines: {
+    node: ">=22",
+    "slicc-kernel": ">=1.53.2"
+  },
+  publishConfig: {
+    access: "public",
+    provenance: true
+  },
+  fledgling: {
+    provider: "github",
+    workflow: "release.yml",
+    repo: "ai-ecoverse/slicc-jsh",
+    publish: true
+  },
+  files: [
+    "LICENSE",
+    "NOTICE",
+    "README.md",
+    "dist"
+  ],
+  slicc: {
+    commands: {
+      node: {
+        abi: "js",
+        module: "dist/node.mjs",
+        argv0: "node"
+      },
+      jsh: {
+        abi: "js",
+        module: "dist/jsh.mjs",
+        argv0: "jsh"
+      }
+    },
+    binfmt: {
+      ".jsh": "jsh"
+    }
+  },
+  scripts: {
+    build: "node scripts/build.mjs && node scripts/build-host.mjs",
+    prepack: "npm run build",
+    prepare: "npm run build",
+    lint: "node scripts/lint.mjs",
+    test: "npm run test:golden && npm run test:jsh && npm run test:integration",
+    "test:golden": "node --max-old-space-size=512 scripts/golden.mjs check",
+    "test:integration": "node --max-old-space-size=512 --test --test-timeout=120000 test/integration/*.test.mjs",
+    "test:cert": "node --max-old-space-size=512 test/integration/cert/run.mjs",
+    "test:node-parallel": "node --max-old-space-size=512 test/node-parallel/run.mjs",
+    "golden:record": "node --max-old-space-size=512 scripts/golden.mjs record",
+    "test:jsh": "node --max-old-space-size=512 scripts/jsh-golden.mjs check",
+    "jsh:record": "node --max-old-space-size=512 scripts/jsh-golden.mjs record",
+    release: "semantic-release",
+    trust: "npx fledgling sync -y --skip-publish",
+    "trust:dry": "npx fledgling sync --dry-run -y --skip-publish"
+  },
+  devDependencies: {
+    "@ai-ecoverse/slicc-kernel": "1.59.0",
+    "@ai-ecoverse/wasi-pnpm": "12.9.1-8",
+    "abort-controller": "3.0.0",
+    acorn: "8.19.0",
+    esbuild: "0.28.2",
+    "node-inspect-extracted": "3.3.4",
+    process: "0.11.10",
+    "readable-stream": "4.8.0",
+    "semantic-release": "25.0.9",
+    string_decoder: "1.3.0",
+    ws: "8.22.0"
+  }
+};
+
+// src/jsh/parse-flags.mjs
+function parseFlags(argv) {
+  const positional = [];
+  const flags = {};
+  const passthrough = [];
+  const set = (key, value) => {
+    if (key in flags) {
+      const prev = flags[key];
+      if (Array.isArray(prev)) prev.push(String(value));
+      else flags[key] = [String(prev), String(value)];
+    } else {
+      flags[key] = value;
+    }
+  };
+  let i = 2;
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (arg === "--") {
+      passthrough.push(...argv.slice(i + 1));
+      break;
+    }
+    if (arg.startsWith("--")) {
+      const body = arg.slice(2);
+      const eq = body.indexOf("=");
+      if (eq !== -1) {
+        set(body.slice(0, eq), body.slice(eq + 1));
+        i++;
+        continue;
+      }
+      const next = argv[i + 1];
+      if (next !== void 0 && !next.startsWith("-")) {
+        set(body, next);
+        i += 2;
+        continue;
+      }
+      set(body, true);
+      i++;
+      continue;
+    }
+    if (arg.startsWith("-") && arg.length > 1) {
+      for (const ch of arg.slice(1)) set(ch, true);
+      i++;
+      continue;
+    }
+    positional.push(arg);
+    i++;
+  }
+  const subcommand = positional.length > 0 && /^[a-z][\w-]*$/i.test(positional[0]) ? positional[0] : null;
+  return { positional, flags, subcommand, passthrough };
+}
+function attachParseFlags(argv) {
+  if (Object.prototype.hasOwnProperty.call(argv, "parseFlags")) return argv;
+  Object.defineProperty(argv, "parseFlags", {
+    value: () => parseFlags(argv),
+    enumerable: false,
+    writable: false,
+    configurable: true
+  });
+  return argv;
+}
+
+// src/jsh/sliccy/exec.mjs
+var SIGNALS = { SIGHUP: 1, SIGINT: 2, SIGQUIT: 3, SIGKILL: 9, SIGTERM: 15 };
+function killExitCode(sig = "SIGTERM") {
+  const n = typeof sig === "number" ? sig : SIGNALS[sig] ?? 15;
+  return 128 + n;
+}
+function createExec(engine2) {
+  const shellArgv = (command, args = []) => [...engine2.shell, command, "jsh", ...args];
+  const run = (argv, stdin) => engine2.spawn(argv, { stdin }).done;
+  const exec = (command) => {
+    if (typeof command !== "string") throw new TypeError("exec(command): command must be a string");
+    return run(shellArgv(command));
+  };
+  exec.spawn = (argv) => {
+    if (!Array.isArray(argv) || argv.length === 0) {
+      throw new TypeError("exec.spawn(argv): argv must be a non-empty array");
+    }
+    return run(argv.map(String));
+  };
+  exec.start = (commandOrArgv, opts = {}) => {
+    const argv = Array.isArray(commandOrArgv) ? [...commandOrArgv.map(String), ...(opts.args ?? []).map(String)] : shellArgv(String(commandOrArgv), (opts.args ?? []).map(String));
+    const chunks = [];
+    let child = null;
+    let killed = false;
+    let resolveDone;
+    let rejectDone;
+    const done = new Promise((resolve2, reject) => {
+      resolveDone = resolve2;
+      rejectDone = reject;
+    });
+    const fire = () => {
+      if (child || killed) return;
+      const stdin = chunks.length > 0 ? chunks.join("") : opts.stdin;
+      child = engine2.spawn(argv, { stdin });
+      child.done.then(resolveDone, rejectDone);
+    };
+    return {
+      kill(sig) {
+        if (child) return Promise.resolve(child.kill(sig ?? "SIGTERM")).then(() => true);
+        killed = true;
+        resolveDone({ stdout: "", stderr: "", exitCode: killExitCode(sig) });
+        return Promise.resolve(true);
+      },
+      stdin: {
+        write(chunk) {
+          if (!child && !killed) chunks.push(String(chunk));
+        },
+        end: () => fire()
+      },
+      done
+    };
+  };
+  exec.exec = exec;
+  return exec;
+}
+function dirnameOf(path) {
+  if (!path) return "";
+  const idx = path.lastIndexOf("/");
+  if (idx < 0) return "";
+  if (idx === 0) return "/";
+  return path.slice(0, idx);
+}
+function joinChild(dir, name) {
+  if (dir === "") return name;
+  if (dir === "/") return `/${name}`;
+  return `${dir}/${name}`;
+}
+function createSkill({ argv, fs, exec }) {
+  const dir = dirnameOf(argv[1] ?? "");
+  const refs = joinChild(dir, "references");
+  const assets = joinChild(dir, "assets");
+  const configPath = joinChild(dir, ".config");
+  async function readConfig() {
+    let text;
+    try {
+      if (!fs.existsSync(configPath)) return null;
+      text = await fs.promises.readFile(configPath, "utf8");
+    } catch {
+      return null;
+    }
+    if (!String(text).trim()) return null;
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch (err) {
+      throw new Error(`skill.config(): failed to parse ${configPath}: ${err?.message ?? err}`);
+    }
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+    throw new Error(`skill.config(): ${configPath} must contain a JSON object`);
+  }
+  async function config(updates) {
+    const existing = await readConfig();
+    if (updates === void 0) return existing;
+    if (updates === null || typeof updates !== "object" || Array.isArray(updates)) {
+      throw new TypeError("skill.config(updates): updates must be a plain object");
+    }
+    const merged = { ...existing ?? {}, ...updates };
+    await fs.promises.writeFile(configPath, `${JSON.stringify(merged, null, 2)}
+`);
+    return merged;
+  }
+  async function token(providerId) {
+    if (typeof providerId !== "string" || !providerId.trim()) {
+      throw new TypeError("skill.token(providerId): providerId must be a non-empty string");
+    }
+    const { stdout, stderr, exitCode } = await exec.spawn(["oauth-token", providerId]);
+    if (exitCode !== 0) {
+      const msg = stderr.trim() || `oauth-token exited with code ${exitCode}`;
+      throw new Error(`skill.token('${providerId}'): ${msg}`);
+    }
+    return stdout.replace(/\r?\n+$/, "");
+  }
+  return Object.freeze({ dir, refs, assets, config, token });
+}
+
+// src/jsh/sliccy/http.mjs
+var HttpError = class extends Error {
+  constructor(status, statusText, url, body) {
+    const detail = typeof body === "string" && body ? `: ${body.slice(0, 200)}` : body && typeof body === "object" ? `: ${safeJson(body).slice(0, 200)}` : "";
+    super(`HTTP ${status} ${statusText} ${url}${detail}`);
+    this.name = "HttpError";
+    this.status = status;
+    this.statusText = statusText;
+    this.url = url;
+    this.body = body;
+  }
+};
+function safeJson(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+var DEFAULT_BACKOFF_BASE_MS = 500;
+function buildUrl(baseUrl, path, params) {
+  let url;
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(path)) url = path;
+  else if (baseUrl) {
+    const base = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+    url = `${base}${path.startsWith("/") ? path : `/${path}`}`;
+  } else url = path;
+  if (!params) return url;
+  const qs = [];
+  const push = (k, v) => qs.push(`${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`);
+  for (const [k, v] of Object.entries(params)) {
+    if (v === void 0 || v === null) continue;
+    if (Array.isArray(v)) {
+      for (const item of v) if (item !== void 0 && item !== null) push(k, item);
+    } else push(k, v);
+  }
+  if (qs.length === 0) return url;
+  return url + (url.includes("?") ? "&" : "?") + qs.join("&");
+}
+function isJsonContentType(ct) {
+  if (!ct) return false;
+  const lower = ct.toLowerCase();
+  return lower.startsWith("application/json") || /[+/]json(;|$|\s)/.test(lower);
+}
+function parseRetryAfter(value) {
+  const trimmed = value?.trim();
+  if (!trimmed) return null;
+  if (/^\d+(\.\d+)?$/.test(trimmed)) {
+    const seconds = Number(trimmed);
+    if (Number.isFinite(seconds) && seconds >= 0) return Math.round(seconds * 1e3);
+  }
+  const date = Date.parse(trimmed);
+  if (Number.isFinite(date)) return Math.max(0, date - Date.now());
+  return null;
+}
+async function readBody(resp) {
+  if (isJsonContentType(resp.headers.get("content-type"))) {
+    const text = await resp.text();
+    if (!text) return null;
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+  return resp.text();
+}
+function serializeBody(body, headers) {
+  if (body === void 0 || body === null) return void 0;
+  if (typeof body === "string") return body;
+  if (body instanceof ArrayBuffer || ArrayBuffer.isView(body) || typeof Blob !== "undefined" && body instanceof Blob || typeof FormData !== "undefined" && body instanceof FormData || typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams || typeof ReadableStream !== "undefined" && body instanceof ReadableStream) {
+    return body;
+  }
+  if (typeof body === "object") {
+    if (!Object.keys(headers).some((k) => k.toLowerCase() === "content-type")) {
+      headers["Content-Type"] = "application/json";
+    }
+    return JSON.stringify(body);
+  }
+  return String(body);
+}
+function createHttp({ fetch, sleep = (ms) => new Promise((r) => setTimeout(r, ms)) }) {
+  function makeClient(config = {}) {
+    const retryOn = new Set(config.retry?.on ?? []);
+    const maxAttempts = Math.max(1, Math.trunc(config.retry?.maxAttempts ?? 1));
+    async function request(method, path, opts = {}) {
+      if (typeof fetch !== "function") throw new Error("sliccy:http: fetch is not available");
+      const url = buildUrl(config.baseUrl, path, opts.params);
+      const headers = { ...config.headers ?? {}, ...opts.headers ?? {} };
+      if (config.token) {
+        const tok = await config.token({ method, path, url });
+        if (tok && !Object.keys(headers).some((k) => k.toLowerCase() === "authorization")) {
+          headers.Authorization = `Bearer ${tok}`;
+        }
+      }
+      const body = serializeBody(opts.body, headers);
+      const init = { method, headers };
+      if (body !== void 0) init.body = body;
+      for (let attempt = 0; ; attempt++) {
+        const timeoutCtl = config.timeoutMs ? new AbortController() : null;
+        const timeoutId = timeoutCtl ? setTimeout(() => timeoutCtl.abort(new Error("timeout")), config.timeoutMs) : null;
+        const signal = opts.signal && timeoutCtl ? AbortSignal.any([opts.signal, timeoutCtl.signal]) : opts.signal ?? timeoutCtl?.signal;
+        let resp;
+        try {
+          resp = await fetch(url, signal ? { ...init, signal } : init);
+        } finally {
+          if (timeoutId !== null) clearTimeout(timeoutId);
+        }
+        if (resp.ok) {
+          const respBody = await readBody(resp);
+          if (opts.raw) {
+            return {
+              body: respBody,
+              headers: Object.fromEntries(resp.headers.entries()),
+              status: resp.status
+            };
+          }
+          return respBody;
+        }
+        if (attempt + 1 >= maxAttempts || !retryOn.has(resp.status)) {
+          const errBody = await readBody(resp).catch(() => null);
+          throw new HttpError(resp.status, resp.statusText, url, errBody);
+        }
+        const retryAfter = parseRetryAfter(resp.headers.get("retry-after"));
+        await sleep(retryAfter ?? DEFAULT_BACKOFF_BASE_MS * 2 ** attempt);
+      }
+    }
+    return Object.freeze({
+      get: (path, opts) => request("GET", path, opts),
+      post: (path, opts) => request("POST", path, opts),
+      put: (path, opts) => request("PUT", path, opts),
+      patch: (path, opts) => request("PATCH", path, opts),
+      delete: (path, opts) => request("DELETE", path, opts)
+    });
+  }
+  return Object.freeze({ client: makeClient, HttpError });
+}
+
+// src/jsh/sliccy/pure.mjs
+var ANSI = {
+  reset: "\x1B[0m",
+  green: "\x1B[32m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m",
+  gray: "\x1B[90m",
+  bold: "\x1B[1m",
+  cyan: "\x1B[36m",
+  dim: "\x1B[2m"
+};
+function colorEnabled(env, stdoutIsTTY) {
+  const force = env?.FORCE_COLOR;
+  if (force !== void 0) return force !== "" && force !== "0" && force !== "false";
+  if (env?.NO_COLOR) return false;
+  return !!stdoutIsTTY;
+}
+function createColor(enabled) {
+  const wrap = (code) => (s) => enabled ? `${code}${s}${ANSI.reset}` : String(s);
+  return Object.freeze({
+    enabled,
+    green: wrap(ANSI.green),
+    red: wrap(ANSI.red),
+    yellow: wrap(ANSI.yellow),
+    gray: wrap(ANSI.gray),
+    bold: wrap(ANSI.bold),
+    cyan: wrap(ANSI.cyan),
+    dim: wrap(ANSI.dim)
+  });
+}
+function createCli({ writeStdout, writeStderr, exit, color }) {
+  const toLine = (v) => {
+    if (typeof v === "string") return v;
+    if (v instanceof Error) return v.message;
+    if (v === null || v === void 0) return String(v);
+    try {
+      return JSON.stringify(v);
+    } catch {
+      return String(v);
+    }
+  };
+  const prefixed = (paint, prefix, text, fallback) => {
+    if (prefix === void 0) return `${paint(`${fallback}:`)} ${text}
+`;
+    if (prefix === "") return `${paint(text)}
+`;
+    return `${paint(`${prefix}:`)} ${text}
+`;
+  };
+  const prefixOf = (opts) => typeof opts === "object" && opts !== null && "prefix" in opts ? opts.prefix : void 0;
+  return Object.freeze({
+    die(msg, opts) {
+      const code = typeof opts === "number" ? opts : opts?.exitCode ?? 1;
+      writeStderr(prefixed(color.red, prefixOf(opts), toLine(msg), "Error"));
+      exit(code);
+      throw new Error("unreachable");
+    },
+    out(value) {
+      if (typeof value === "string") {
+        writeStdout(value.endsWith("\n") ? value : `${value}
+`);
+        return;
+      }
+      try {
+        writeStdout(`${JSON.stringify(value, null, 2)}
+`);
+      } catch {
+        writeStdout(`${String(value)}
+`);
+      }
+    },
+    warn(msg, opts) {
+      writeStderr(prefixed(color.yellow, prefixOf(opts), toLine(msg), "Warning"));
+    },
+    help(text) {
+      writeStdout(text.endsWith("\n") ? text : `${text}
+`);
+      exit(0);
+      throw new Error("unreachable");
+    }
+  });
+}
+var ANSI_RE = /\u001b\[[0-9;]*m/g;
+var stripAnsi = (s) => s.replace(ANSI_RE, "");
+var visibleLength = (s) => stripAnsi(s).length;
+var pad2 = (n) => n < 10 ? `0${n}` : String(n);
+function trunc(s, n) {
+  const text = String(s ?? "");
+  if (n <= 0) return "";
+  if (visibleLength(text) <= n) return text;
+  if (n <= 1) return text.slice(0, n);
+  return `${stripAnsi(text).slice(0, n - 1)}\u2026`;
+}
+function col(s, width) {
+  const text = String(s ?? "");
+  const vis = visibleLength(text);
+  if (vis === width) return text;
+  if (vis > width) return trunc(text, width);
+  return text + " ".repeat(width - vis);
+}
+function table(rows, widths) {
+  if (!rows.length) return "";
+  const colCount = Math.max(...rows.map((r) => r.length));
+  const computed = [];
+  for (let i = 0; i < colCount; i++) {
+    if (widths && widths[i] !== void 0) {
+      computed[i] = widths[i];
+    } else {
+      let max = 0;
+      for (const r of rows) max = Math.max(max, visibleLength(i < r.length ? String(r[i] ?? "") : ""));
+      computed[i] = max;
+    }
+  }
+  return rows.map(
+    (r) => computed.map((w, i) => col(i < r.length ? String(r[i] ?? "") : "", w)).join("  ").replace(/\s+$/, "")
+  ).join("\n");
+}
+function fmtDate(value, style = "short") {
+  const d = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(d.getTime())) return String(value);
+  if (style === "iso") return d.toISOString();
+  if (style === "locale") return new Intl.DateTimeFormat(void 0, { dateStyle: "medium" }).format(d);
+  if (style === "human") {
+    const diff = Date.now() - d.getTime();
+    const abs = Math.abs(diff);
+    if (abs < 6e4) return diff >= 0 ? "just now" : "in a moment";
+    const tense = (n, u) => diff >= 0 ? `${n} ${u}${n === 1 ? "" : "s"} ago` : `in ${n} ${u}${n === 1 ? "" : "s"}`;
+    if (abs < 36e5) return tense(Math.round(abs / 6e4), "minute");
+    if (abs < 864e5) return tense(Math.round(abs / 36e5), "hour");
+    if (abs < 26298e5) return tense(Math.round(abs / 864e5), "day");
+    if (abs < 315576e5) return tense(Math.round(abs / 26298e5), "month");
+    return tense(Math.round(abs / 315576e5), "year");
+  }
+  return `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())}`;
+}
+var fmt = Object.freeze({ trunc, col, table, date: fmtDate });
+var DURATION_UNITS_MS = {
+  ms: 1,
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5,
+  w: 6048e5,
+  M: 26298e5,
+  y: 315576e5
+};
+function parseDuration(spec) {
+  if (typeof spec === "number" && Number.isFinite(spec)) return Math.trunc(spec);
+  if (typeof spec !== "string") throw new TypeError("time.parseDuration: spec must be string or number");
+  const m = /^([0-9]+(?:\.[0-9]+)?)\s*(ms|s|m|h|d|w|M|y)?$/.exec(spec.trim());
+  if (!m) throw new RangeError(`time.parseDuration: unrecognized spec "${spec}"`);
+  return Math.trunc(Number(m[1]) * DURATION_UNITS_MS[m[2] ?? "ms"]);
+}
+var time = Object.freeze({
+  parseDuration,
+  ago(spec, from = /* @__PURE__ */ new Date()) {
+    return new Date(from.getTime() - parseDuration(spec));
+  },
+  range(spec, from = /* @__PURE__ */ new Date()) {
+    const end = new Date(from.getTime());
+    return { start: new Date(end.getTime() - parseDuration(spec)), end };
+  },
+  future(spec, from = /* @__PURE__ */ new Date()) {
+    const start = new Date(from.getTime());
+    return { start, end: new Date(start.getTime() + parseDuration(spec)) };
+  },
+  gmailDate(spec, from = /* @__PURE__ */ new Date()) {
+    const d = new Date(from.getTime() - parseDuration(spec));
+    return `${d.getFullYear()}/${pad2(d.getMonth() + 1)}/${pad2(d.getDate())}`;
+  }
+});
+async function pool(concurrency, items, fn) {
+  const n = Math.max(1, Math.trunc(concurrency) || 1);
+  const results = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    for (; ; ) {
+      const i = next++;
+      if (i >= items.length) return;
+      results[i] = await fn(items[i], i);
+    }
+  };
+  const workers = [];
+  for (let w = 0; w < Math.min(n, items.length); w++) workers.push(worker());
+  await Promise.all(workers);
+  return results;
+}
+
+// src/jsh/sliccy/index.mjs
+var SLICC_ONLY = /* @__PURE__ */ new Set(["agent", "usb", "serial", "hid", "computer"]);
+function isNotFound(err, request) {
+  return err?.code === "MODULE_NOT_FOUND" && String(err.message).includes(`'${request}'`);
+}
+function createSliccyResolver({ engine: engine2, process: process2, require: require2 }) {
+  let color;
+  let exec;
+  const getColor = () => {
+    color ??= createColor(colorEnabled(process2.env, engine2.stdoutIsTTY));
+    return color;
+  };
+  const getExec = () => {
+    exec ??= createExec(engine2);
+    return exec;
+  };
+  const factories = {
+    cli: () => createCli({
+      writeStdout: engine2.writeStdout,
+      writeStderr: engine2.writeStderr,
+      exit: (code) => process2.exit(code),
+      color: getColor()
+    }),
+    color: getColor,
+    exec: getExec,
+    fmt: () => fmt,
+    http: () => createHttp({ fetch: engine2.fetch }),
+    pool: () => pool,
+    skill: () => createSkill({ argv: process2.argv, fs: require2("fs"), exec: getExec() }),
+    time: () => time
+  };
+  const cache = /* @__PURE__ */ new Map();
+  const lookups = [require2, engine2.selfRequire].filter(Boolean);
+  return function requireSliccy(id) {
+    const name = id.slice("sliccy:".length);
+    if (name === "") throw new Error("require('sliccy:'): empty sliccy: module name");
+    if (cache.has(name)) return cache.get(name);
+    let value;
+    if (Object.prototype.hasOwnProperty.call(factories, name)) {
+      value = factories[name]();
+    } else {
+      value = findPackage(name, lookups);
+    }
+    if (value === void 0) {
+      if (SLICC_ONLY.has(name)) {
+        throw new Error(`require('${id}'): sliccy:${name} is only available inside SLICC`);
+      }
+      const known = Object.keys(factories).sort().join(", ");
+      throw new Error(
+        `require('${id}'): unknown sliccy: module '${name}'. Known names: ${known}. Install @ai-ecoverse/sliccy-${name} to provide it.`
+      );
+    }
+    cache.set(name, value);
+    return value;
+  };
+}
+function findPackage(name, lookups) {
+  for (const pkg of [`@ai-ecoverse/sliccy-${name}`, `sliccy-${name}`]) {
+    for (const req of lookups) {
+      try {
+        return req(pkg);
+      } catch (err) {
+        if (!isNotFound(err, pkg)) throw err;
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/jsh/run.mjs
+var JSH_VERSION = package_default.version;
+var JSH_PARAMS = Object.freeze([
+  "process",
+  "console",
+  "require",
+  "module",
+  "exports",
+  "fetch",
+  "__dirname",
+  "__filename"
+]);
+var JSH_USAGE = `Usage: jsh [--version | --help] <script.jsh> [args...]
+
+Runs a .jsh script: the body of an async function with process, console,
+require, module, exports, fetch, __dirname and __filename in scope.
+`;
+function parseJshArgv(args) {
+  let i = 0;
+  const first = args[0];
+  if (first === "--version" || first === "-v") return { action: "version" };
+  if (first === "--help" || first === "-h") return { action: "help" };
+  if (first === "--") i = 1;
+  else if (first?.startsWith("-") && first !== "-") {
+    return { action: "error", message: `jsh: bad option: ${first}`, status: 9 };
+  }
+  if (i >= args.length) return { action: "usage" };
+  return { action: "run", script: args[i], args: args.slice(i + 1) };
+}
+function prepareSource(source) {
+  let text = source.charCodeAt(0) === 65279 ? source.slice(1) : source;
+  if (text.startsWith("#!")) {
+    const nl = text.indexOf("\n");
+    text = nl === -1 ? "" : text.slice(nl);
+  }
+  return text;
+}
+function wrapSource(body) {
+  return `(async function (${JSH_PARAMS.join(", ")}) {${body}
+})`;
+}
+function dirnameOf2(path) {
+  const idx = path.lastIndexOf("/");
+  if (idx <= 0) return "/";
+  return path.slice(0, idx);
+}
+function wrapRequire(baseRequire, requireSliccy, module) {
+  const require2 = (id) => typeof id === "string" && id.startsWith("sliccy:") ? requireSliccy(id) : baseRequire(id);
+  const resolve2 = (id, options) => typeof id === "string" && id.startsWith("sliccy:") ? id : baseRequire.resolve(id, options);
+  resolve2.paths = (id) => baseRequire.resolve.paths?.(id) ?? null;
+  require2.resolve = resolve2;
+  require2.cache = baseRequire.cache;
+  require2.main = module;
+  return require2;
+}
+async function runJsh({ filename, engine: engine2, process: process2, console: console2 }) {
+  let source;
+  try {
+    source = engine2.readSource(filename);
+  } catch (err) {
+    engine2.writeStderr(`jsh: cannot open ${filename}: ${err?.code ?? err?.message ?? err}
+`);
+    return engine2.exit(1);
+  }
+  attachParseFlags(process2.argv);
+  try {
+    process2.versions.jsh = JSH_VERSION;
+  } catch {
+  }
+  const dirname = dirnameOf2(filename);
+  const module = {
+    id: ".",
+    filename,
+    path: dirname,
+    exports: {},
+    loaded: false,
+    children: [],
+    paths: []
+  };
+  const baseRequire = engine2.createRequire(filename);
+  const requireSliccy = createSliccyResolver({ engine: engine2, process: process2, require: baseRequire });
+  const require2 = wrapRequire(baseRequire, requireSliccy, module);
+  try {
+    const fn = engine2.compile(prepareSource(source), filename);
+    await fn(process2, console2, require2, module, module.exports, engine2.fetch, dirname, filename);
+    module.loaded = true;
+  } catch (err) {
+    if (engine2.isExit(err)) return engine2.exit(err.code);
+    engine2.writeStderr(`${err?.stack ?? err}
+`);
+    return engine2.exit(1);
+  }
+  return void 0;
+}
+
+// src/host/main.mjs
+var writeFd = (fd, text) => {
+  const bytes = Buffer.from(String(text));
+  let off = 0;
+  while (off < bytes.length) {
+    try {
+      off += writeSync(fd, bytes, off);
+    } catch (err) {
+      if (err?.code === "EAGAIN") continue;
+      throw err;
+    }
+  }
+};
+function findOnPath(name) {
+  for (const dir of (process.env.PATH ?? "").split(delimiter)) {
+    if (!dir) continue;
+    const candidate = join(dir, name);
+    try {
+      accessSync(candidate, fsConstants.X_OK);
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function silenceLoaderWarning() {
+  const emitWarning = process.emitWarning;
+  process.emitWarning = function filtered(warning, ...rest) {
+    const text = typeof warning === "string" ? warning : warning?.message;
+    if (typeof text === "string" && text.includes("USE_MAIN_CONTEXT_DEFAULT_LOADER")) return;
+    return emitWarning.call(this, warning, ...rest);
+  };
+}
+function spawn(argv, { stdin } = {}) {
+  let child;
+  const done = new Promise((resolveDone) => {
+    let settled = false;
+    const finish = (result) => {
+      if (!settled) {
+        settled = true;
+        resolveDone(result);
+      }
+    };
+    const out = [];
+    const err = [];
+    child = spawnChild(argv[0], argv.slice(1), {
+      cwd: process.cwd(),
+      env: process.env,
+      stdio: [stdin === void 0 ? "ignore" : "pipe", "pipe", "pipe"]
+    });
+    child.stdout.on("data", (c) => out.push(c));
+    child.stderr.on("data", (c) => err.push(c));
+    child.on("error", (e) => {
+      if (e?.code === "ENOENT") {
+        finish({ stdout: "", stderr: `${argv[0]}: command not found
+`, exitCode: 127 });
+      } else {
+        finish({ stdout: "", stderr: `${argv[0]}: ${e?.message ?? e}
+`, exitCode: 126 });
+      }
+    });
+    child.on("close", (code, signal) => {
+      finish({
+        stdout: Buffer.concat(out).toString("utf8"),
+        stderr: Buffer.concat(err).toString("utf8"),
+        exitCode: code ?? 128 + (osConstants.signals[signal] ?? 0)
+      });
+    });
+    if (stdin !== void 0) {
+      child.stdin.on("error", () => {
+      });
+      child.stdin.end(stdin);
+    }
+  });
+  return { kill: (sig = "SIGTERM") => child.kill(sig), done };
+}
+var selfRequire = null;
+try {
+  selfRequire = createRequire(fileURLToPath(import.meta.url));
+} catch {
+  selfRequire = null;
+}
+var engine = {
+  readSource: (filename) => readFileSync(filename, "utf8"),
+  compile: (body, filename) => vm.runInThisContext(wrapSource(body), {
+    filename,
+    importModuleDynamically: vm.constants.USE_MAIN_CONTEXT_DEFAULT_LOADER
+  }),
+  createRequire: (filename) => createRequire(filename),
+  selfRequire,
+  writeStdout: (s) => writeFd(1, s),
+  writeStderr: (s) => writeFd(2, s),
+  get stdoutIsTTY() {
+    return !!process.stdout.isTTY;
+  },
+  spawn,
+  shell: [findOnPath("bash") ?? "sh", "-c"],
+  fetch: globalThis.fetch,
+  isExit: () => false,
+  exit: (code) => process.exit(code)
+};
+async function main() {
+  const parsed = parseJshArgv(process.argv.slice(2));
+  if (parsed.action === "version") {
+    writeFd(1, `${JSH_VERSION}
+`);
+    return;
+  }
+  if (parsed.action === "help") {
+    writeFd(1, JSH_USAGE);
+    return;
+  }
+  if (parsed.action === "usage") {
+    writeFd(2, JSH_USAGE);
+    process.exit(2);
+  }
+  if (parsed.action === "error") {
+    writeFd(2, `${parsed.message}
+${JSH_USAGE}`);
+    process.exit(parsed.status);
+  }
+  const filename = resolve(parsed.script);
+  process.argv = [process.execPath, filename, ...parsed.args];
+  silenceLoaderWarning();
+  await runJsh({ filename, engine, process, console });
+}
+main().catch((err) => {
+  writeFd(2, `${err?.stack ?? err}
+`);
+  process.exit(1);
+});