wizards 0.6.1 → 0.7.0

package/bin/wizards.mjs

@@ -24,7 +24,8 @@ const home = join(
 );
 const runtime = join(home, "runtime");
 const wrapper = join(home, "bin", "wizards");
-const RUN_HERE = ["help", "validate", "mcp"];
+// uninstall: never installs or hands over first; the install it takes away may no longer run.
+const RUN_HERE = ["help", "validate", "mcp", "uninstall"];
 const tilde = (path) =>
   path.startsWith(homedir() + sep) ? `~${path.slice(homedir().length)}` : path;
 
@@ -164,7 +165,7 @@ if (process.platform === "win32" && !checkout && !RUN_HERE.includes(command)) {
   process.exit(1);
 }
 const fromNpm = process.platform !== "win32" && !checkout && !isInstall();
-if (fromNpm && (!currentNode || !RUN_HERE.includes(command))) {
+if (fromNpm && command !== "uninstall" && (!currentNode || !RUN_HERE.includes(command))) {
   const own = versionOf(root) || "0.0.0";
   const installed = existsSync(wrapper)
     ? versionOf(join(runtime, "node_modules", "wizards"))
@@ -194,6 +195,14 @@ if (fromNpm && (!currentNode || !RUN_HERE.includes(command))) {
     process.exit(await handOver());
   }
 }
+if (!currentNode && command === "uninstall") {
+  // The install's own Node, if it is still there, runs this copy's uninstall.
+  const node = join(home, "tools", "node", "bin", "node");
+  const result = existsSync(node)
+    ? spawnSync(node, [fileURLToPath(import.meta.url), ...args], { stdio: "inherit" })
+    : null;
+  process.exit(result?.status ?? 1);
+}
 if (!currentNode) {
   console.error(
     `engenty wizards needs Node.js 24.11 or newer. This is ${process.version}.\n` +
@@ -202,4 +211,9 @@ if (!currentNode) {
   );
   process.exit(1);
 }
-await import("../apps/runtime/dist/cli/main.js");
+// The uninstall has an entry of its own: main.js makes the install and data folders as it loads.
+await import(
+  command === "uninstall"
+    ? "../apps/runtime/dist/cli/uninstall-main.js"
+    : "../apps/runtime/dist/cli/main.js"
+);

package/node_modules/@engenty-wizards/shared/dist/definition.d.ts

@@ -20,6 +20,11 @@ export declare const SPEECH_LOCALES: Record<Lang, string>;
 export declare function isLang(value: unknown): value is Lang;
 /** The language of a tag such as "de-AT", "fr" or "pt_BR", where engenty speaks it. */
 export declare function langOf(tag: string | null | undefined): Lang | null;
+/**
+ * The languages a wizard is offered in when its author picks one: English, German and the main
+ * languages of Europe. A wizard may name any other real language by its code as well.
+ */
+export declare const WIZARD_LANGS: readonly string[];
 /**
  * The person's own language beside English: the first of their languages (the browser's, in
  * its order) that engenty speaks, else the main language of the country their time zone lies
@@ -33,6 +38,13 @@ export declare function localLang(languages: readonly string[], timeZone?: strin
 export declare const LANG_CODE: RegExp;
 /** The code of a tag such as "fr-CA" or "pt_BR"; null where it names no language. */
 export declare function langCodeOf(tag: string | null | undefined): string | null;
+/**
+ * A real language, as the platform's own language data knows it: "it" and "nb" are, "xx" is
+ * not. The schema only checks the shape of a code; this checks that it names a language.
+ */
+export declare function isRealLanguage(code: string): boolean;
+/** The language engenty's own strings are read in for any language: itself where they are written, else English. */
+export declare function textLang(code: string): Lang;
 /**
  * The language the person reads, for a wizard translated on request: the first of their
  * languages (the browser's, in its order), else the main language of the country their time
@@ -45,6 +57,8 @@ export declare function langName(code: string): string;
 export declare function langNameEn(code: string): string;
 /** The locale amounts, dates and plural forms are written in for any language. */
 export declare function localeOf(code: string): string;
+/** The locale speech is recognised and read aloud in for any language. */
+export declare function speechLocaleOf(code: string): string;
 export declare const FIELD_KINDS: readonly ["text", "textarea", "number", "select", "multiselect", "date", "email", "url", "toggle", "color", "image", "file", "items", "connection", "list", "location", "audio", "signature", "slot"];
 export type FieldKind = (typeof FIELD_KINDS)[number];
 /**
@@ -1937,10 +1951,7 @@ export declare const wizardSchema: z.ZodObject<{
         wedge: "wedge";
     }>>;
     intro: z.ZodOptional<z.ZodString>;
-    lang: z.ZodOptional<z.ZodEnum<{
-        de: "de";
-        en: "en";
-    }>>;
+    lang: z.ZodOptional<z.ZodString>;
     lists: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         title: z.ZodString;
@@ -2884,9 +2895,9 @@ export interface SlotTime {
  */
 export declare function slotTime(iso: string): SlotTime | null;
 /** The weekday and date of a slot's day: "Montag, 12. Oktober" / "Monday, 12 October". */
-export declare function slotDayText(iso: string, lang?: Lang): string;
+export declare function slotDayText(iso: string, lang?: string): string;
 /** A chosen slot as a person reads it back: "Di 13.10.2026, 10:30" / "Tue 13/10/2026, 10:30". */
-export declare function slotText(iso: string, lang?: Lang): string;
+export declare function slotText(iso: string, lang?: string): string;
 /**
  * The slot among `options` that is the same moment as `value`, written as offered — so an answer
  * in another offset ("…T07:00:00Z" for "…T09:00:00+02:00") picks the offered time.
@@ -2906,6 +2917,6 @@ export declare function allFields(def: WizardDefinition): Field[];
  * The language a wizard speaks to people: the one it names, else read from its own words
  * (titles, labels, intro) — English where they are not clearly German.
  */
-export declare function wizardLang(def: WizardDefinition): Lang;
+export declare function wizardLang(def: WizardDefinition): string;
 /** True when this app's schema reads the definition without losing anything of it. */
 export declare function readable(definition: unknown): boolean;

package/node_modules/@engenty-wizards/shared/dist/definition.js

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: FSL-1.1-MIT OR MIT
 import { z } from "zod";
 import { tableColumnsSchema } from "./engenty/data-tables/index.js";
+import { readNumber } from "./numbers.js";
 import { outputShapeSchema, shapeOfFields } from "./shape.js";
 import { CONNECTION_KINDS } from "./store.js";
 import { surfaceComponentsSchema, validateSurface } from "./surface.js";
@@ -81,6 +82,13 @@ const COUNTRY_LANGUAGE = {
     UA: "uk",
     VA: "it",
 };
+/**
+ * The languages a wizard is offered in when its author picks one: English, German and the main
+ * languages of Europe. A wizard may name any other real language by its code as well.
+ */
+export const WIZARD_LANGS = [
+    ...new Set(["en", "de", ...Object.values(COUNTRY_LANGUAGE)]),
+];
 /** The country of each European time zone (IANA names, as `Intl` gives them). */
 const ZONE_COUNTRY = {
     "Europe/Amsterdam": "NL",
@@ -151,6 +159,25 @@ export function langCodeOf(tag) {
     const code = tag?.trim().toLowerCase().split(/[-_]/)[0] ?? "";
     return LANG_CODE.test(code) ? code : null;
 }
+/**
+ * A real language, as the platform's own language data knows it: "it" and "nb" are, "xx" is
+ * not. The schema only checks the shape of a code; this checks that it names a language.
+ */
+export function isRealLanguage(code) {
+    if (!LANG_CODE.test(code)) {
+        return false;
+    }
+    try {
+        return Boolean(new Intl.DisplayNames(["en"], { type: "language", fallback: "none" }).of(code));
+    }
+    catch {
+        return false;
+    }
+}
+/** The language engenty's own strings are read in for any language: itself where they are written, else English. */
+export function textLang(code) {
+    return isLang(code) ? code : "en";
+}
 /**
  * The language the person reads, for a wizard translated on request: the first of their
  * languages (the browser's, in its order), else the main language of the country their time
@@ -192,6 +219,10 @@ export function langNameEn(code) {
 export function localeOf(code) {
     return isLang(code) ? LOCALES[code] : code;
 }
+/** The locale speech is recognised and read aloud in for any language. */
+export function speechLocaleOf(code) {
+    return isLang(code) ? SPEECH_LOCALES[code] : code;
+}
 export const FIELD_KINDS = [
     "text",
     "textarea",
@@ -793,9 +824,14 @@ export const wizardSchema = z.object({
     intro: z.string().optional(),
     /**
      * The language the wizard speaks to people: its texts, the runner's words, its numbers and
-     * dates. Without one it is read from the wizard's own words (`wizardLang`).
+     * dates, by its two-letter code ("en", "de", "it"). Any language, not only those engenty's own
+     * strings are written in; `validateWizard` checks it names a real one. Without one it is read
+     * from the wizard's own words (`wizardLang`).
      */
-    lang: z.enum(LANGS).optional(),
+    lang: z
+        .string()
+        .regex(/^[a-z]{2}$/)
+        .optional(),
     /** Tabular data the wizard keeps between runs, per person — or for all runs (`shared`). */
     lists: z.array(listSchema).max(12).optional(),
     /** Accounts the person connects; kept between runs, per person. */
@@ -875,6 +911,11 @@ export function validateWizard(def, files) {
     const sharedLists = new Set();
     const connectionIds = new Set();
     const notShown = (id) => `List "${id}" is shared: every run writes it, so the person running the wizard never sees it.`;
+    if (def.lang && !isRealLanguage(def.lang)) {
+        issues.push({
+            message: `"${def.lang}" isn't a language code. Use a two-letter code such as "en", "de" or "it".`,
+        });
+    }
     for (const list of def.lists ?? []) {
         if (listIds.has(list.id)) {
             issues.push({ message: `Duplicate list id "${list.id}".` });
@@ -1566,17 +1607,6 @@ function isEmptyValue(v) {
 export function conditionsOf(when) {
     return when === undefined ? [] : Array.isArray(when) ? when : [when];
 }
-/** A typed number as a number: "89,90" from a German number pad counts as 89.9. */
-function numberOf(v) {
-    if (typeof v === "number") {
-        return Number.isFinite(v) ? v : null;
-    }
-    if (typeof v !== "string" || !v.trim()) {
-        return null;
-    }
-    const n = Number(v.replace(/\s/g, "").replace(",", "."));
-    return Number.isFinite(n) ? n : null;
-}
 export function conditionMatches(c, values) {
     const v = values[c.field];
     switch (c.op) {
@@ -1592,8 +1622,8 @@ export function conditionMatches(c, values) {
             return Array.isArray(c.value) && c.value.map(String).includes(String(v));
         case "gt":
         case "lt": {
-            const a = numberOf(v);
-            const b = numberOf(c.value);
+            const a = readNumber(v);
+            const b = readNumber(c.value);
             return a !== null && b !== null && (c.op === "gt" ? a > b : a < b);
         }
         case "contains":
@@ -1769,7 +1799,7 @@ export function slotDayText(iso, lang = "en") {
     if (!slot) {
         return iso;
     }
-    const locale = LOCALES[lang];
+    const locale = localeOf(lang);
     const weekday = slot.wall.toLocaleDateString(locale, { weekday: "long", timeZone: "UTC" });
     const date = slot.wall.toLocaleDateString(locale, {
         day: "numeric",
@@ -1784,7 +1814,7 @@ export function slotText(iso, lang = "en") {
     if (!slot) {
         return iso;
     }
-    const locale = LOCALES[lang];
+    const locale = localeOf(lang);
     const weekday = slot.wall
         .toLocaleDateString(locale, { weekday: "short", timeZone: "UTC" })
         .replace(/\.$/, "");
@@ -1818,8 +1848,8 @@ export function itemsTotals(field, value, values) {
     let vatRate = field.vat?.rate ?? 0;
     if (field.vat?.field) {
         const raw = values[field.vat.field];
-        const parsed = Number.parseFloat(String(raw ?? "").replace(",", "."));
-        if (Number.isFinite(parsed)) {
+        const parsed = readNumber(raw, { units: true });
+        if (parsed !== null) {
             vatRate = parsed;
         }
     }
@@ -1835,8 +1865,7 @@ export function itemsTotals(field, value, values) {
 }
 /** A typed amount as a number: a phone's number pad in German gives "89,90". */
 function amountOf(v) {
-    const n = typeof v === "string" ? Number(v.replace(/\s/g, "").replace(",", ".")) : Number(v);
-    return Number.isFinite(n) ? n : 0;
+    return readNumber(v) ?? 0;
 }
 function round2(n) {
     return Math.round(n * 100) / 100;

package/node_modules/@engenty-wizards/shared/dist/features.d.ts

@@ -20,6 +20,12 @@ export interface FeatureDeclarationInput {
 }
 /** A plugin's declarations under its id: `contacts` + `leadScoring` → `contacts.leadScoring`. */
 export declare function declaredByPlugin(pluginId: string, features: Record<string, FeatureDeclarationInput | boolean> | undefined): Record<string, FeatureDeclaration>;
+/**
+ * Whether a switch is on in resolved values: a switch they do not carry counts as declared – a
+ * core flag with its default (`ownKeys` on, `teamPlans` off), anything else off. Every read of a
+ * flag goes through this (`useFeature` in the studio), so a missing value means one thing.
+ */
+export declare function featureOn(features: Features | null | undefined, name: string): boolean;
 /** The defaults of these declarations; without any, the core's. */
 export declare function defaultFeatures(declared?: Record<string, FeatureDeclaration>): Features;
 /**

package/node_modules/@engenty-wizards/shared/dist/features.js

@@ -25,6 +25,18 @@ export function declaredByPlugin(pluginId, features) {
     }
     return out;
 }
+/**
+ * Whether a switch is on in resolved values: a switch they do not carry counts as declared – a
+ * core flag with its default (`ownKeys` on, `teamPlans` off), anything else off. Every read of a
+ * flag goes through this (`useFeature` in the studio), so a missing value means one thing.
+ */
+export function featureOn(features, name) {
+    const value = features?.[name];
+    if (typeof value === "boolean") {
+        return value;
+    }
+    return Object.hasOwn(FEATURES, name) ? FEATURES[name].default : false;
+}
 /** The defaults of these declarations; without any, the core's. */
 export function defaultFeatures(declared = FEATURES) {
     const out = {};

package/node_modules/@engenty-wizards/shared/dist/numbers.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Numbers as people write and read them: what a phone's number pad, a table cell or a document
+ * gives, and an amount or a file's size as a page shows it. The server, the studio and the runner read and
+ * show them the same way.
+ */
+/**
+ * A number as a person types it: digits with at most one decimal mark, a point or a comma
+ * alike, as a phone's number pad gives it in either language (`1.5`, `1,5`, `89,90`). There are
+ * no thousands separators: `1.234` and `1,234` are 1.234, and anything with two marks
+ * (`1.234,50`, `1.234.567`) is no number, since only the writer's language could say which mark
+ * is which. Text that is not typed (a document, a website) is read by a model into numbers
+ * before it gets here. With `units`, what stands around the number is dropped (`38 h`,
+ * `19 %`); without, anything but the number makes it none. Null where there is no number.
+ */
+export declare function readNumber(value: unknown, opts?: {
+    units?: boolean;
+}): number | null;
+/**
+ * A file's size for a list, in decimal units as the operating systems show them: `1 KB` for
+ * anything below a kilobyte but nothing (`0 KB`), `340 KB`, `2.4 MB`, `1.2 GB`.
+ */
+export declare function formatBytes(bytes: number): string;
+/** An amount in a currency, as the language writes it (`1.234,50 €`); an unknown currency code as `1234.50 XYZ`. */
+export declare function formatMoney(amount: number, currency: string, locale: string): string;

package/node_modules/@engenty-wizards/shared/dist/numbers.js

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: FSL-1.1-MIT OR MIT
+/**
+ * Numbers as people write and read them: what a phone's number pad, a table cell or a document
+ * gives, and an amount or a file's size as a page shows it. The server, the studio and the runner read and
+ * show them the same way.
+ */
+/**
+ * A number as a person types it: digits with at most one decimal mark, a point or a comma
+ * alike, as a phone's number pad gives it in either language (`1.5`, `1,5`, `89,90`). There are
+ * no thousands separators: `1.234` and `1,234` are 1.234, and anything with two marks
+ * (`1.234,50`, `1.234.567`) is no number, since only the writer's language could say which mark
+ * is which. Text that is not typed (a document, a website) is read by a model into numbers
+ * before it gets here. With `units`, what stands around the number is dropped (`38 h`,
+ * `19 %`); without, anything but the number makes it none. Null where there is no number.
+ */
+export function readNumber(value, opts = {}) {
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? value : null;
+    }
+    if (typeof value !== "string") {
+        return null;
+    }
+    const s = opts.units ? value.replace(/[^\d,.-]/g, "") : value.trim();
+    if (!/^-?(\d+([.,]\d*)?|[.,]\d+)$/.test(s)) {
+        return null;
+    }
+    const n = Number(s.replace(",", "."));
+    return Number.isFinite(n) ? n : null;
+}
+/**
+ * A file's size for a list, in decimal units as the operating systems show them: `1 KB` for
+ * anything below a kilobyte but nothing (`0 KB`), `340 KB`, `2.4 MB`, `1.2 GB`.
+ */
+export function formatBytes(bytes) {
+    if (!(bytes > 0)) {
+        return "0 KB";
+    }
+    if (bytes < 999_500) {
+        return `${Math.max(1, Math.round(bytes / 1000))} KB`;
+    }
+    if (bytes < 999_950_000) {
+        return `${(bytes / 1_000_000).toFixed(1)} MB`;
+    }
+    return `${(bytes / 1_000_000_000).toFixed(1)} GB`;
+}
+/** An amount in a currency, as the language writes it (`1.234,50 €`); an unknown currency code as `1234.50 XYZ`. */
+export function formatMoney(amount, currency, locale) {
+    try {
+        return new Intl.NumberFormat(locale, { style: "currency", currency }).format(amount);
+    }
+    catch {
+        return `${amount.toFixed(2)} ${currency}`;
+    }
+}

package/node_modules/@engenty-wizards/shared/dist/run.d.ts

@@ -501,8 +501,8 @@ export interface RunView {
     status: RunStatus;
     mode: "test" | "live";
     wizard: Pick<WizardDefinition, "title" | "description" | "avatar" | "intro">;
-    /** The language the wizard speaks: what is read aloud, and in which voice. */
-    lang: Lang;
+    /** The language the wizard speaks, by its code: what is read aloud, and in which voice. */
+    lang: string;
     /**
      * The run in the viewer's language (a wizard translated on request): every text of the view
      * is written in it, the choices keep their values and show `labels[value]`. Null: the
@@ -627,8 +627,8 @@ export interface PublicWizard {
         kind: "page" | "channel";
         url: string | null;
     }[];
-    /** The language the wizard is written in: the page opens in it. */
-    lang: Lang;
+    /** The language the wizard is written in, by its code: the page opens in it. */
+    lang: string;
     /** The author offers the wizard in the viewer's language, translated on request. */
     translatable: boolean;
     /** The page in the viewer's language, where it was asked for (`?lang=`); null: the original. */

package/node_modules/@engenty-wizards/shared/dist/store.d.ts

@@ -108,3 +108,10 @@ export declare function rowKey(def: ListDef, cells: Record<string, unknown>): st
 export declare function newCells(def: ListDef, input: Record<string, unknown>): Record<string, unknown>;
 /** An existing row's cells with some columns changed; cells of columns the list no longer has are dropped. */
 export declare function patchCells(def: ListDef, current: Record<string, unknown>, patch: Record<string, unknown>): Record<string, unknown>;
+/**
+ * What a person typed into a cell, as the value sent for its column; the runtime still checks it
+ * against the column. Blank is null; a number or a duration (in the column's input unit) is read
+ * as people write it ("12,5"); a date and time from the browser's picker, in local time, becomes
+ * ISO. What cannot be read goes as typed, for the runtime to refuse and name.
+ */
+export declare function cellValue(column: TableColumn, text: string): unknown;

package/node_modules/@engenty-wizards/shared/dist/store.js

@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: FSL-1.1-MIT OR MIT
 import { coerceRowValues, mergeRowValues } from "./engenty/data-tables/index.js";
+import { readNumber } from "./numbers.js";
 export const STORE_LIMITS = {
     fileBytes: 15_000_000,
     totalBytes: 200_000_000,
@@ -51,3 +52,30 @@ export function patchCells(def, current, patch) {
     const kept = Object.fromEntries(Object.entries(current).filter(([id]) => known.has(id)));
     return mergeRowValues(def.columns, kept, patch);
 }
+/**
+ * What a person typed into a cell, as the value sent for its column; the runtime still checks it
+ * against the column. Blank is null; a number or a duration (in the column's input unit) is read
+ * as people write it ("12,5"); a date and time from the browser's picker, in local time, becomes
+ * ISO. What cannot be read goes as typed, for the runtime to refuse and name.
+ */
+export function cellValue(column, text) {
+    if (text.trim() === "") {
+        return null;
+    }
+    switch (column.type) {
+        case "number":
+        case "duration":
+            return readNumber(text) ?? text;
+        case "boolean":
+            return text === "true";
+        case "date": {
+            if (column.format.kind !== "datetime") {
+                return text;
+            }
+            const at = new Date(text);
+            return Number.isNaN(at.getTime()) ? text : at.toISOString();
+        }
+        default:
+            return text;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wizards",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "Make a wish. Get your wizard. It guides you step by step. Let AI do the work. Runs on your machine, on the AI subscription you already have.",
   "license": "FSL-1.1-MIT",
   "homepage": "https://engenty.ai",

package/apps/runtime/dist/sandbox/agentos.js

@@ -1,191 +0,0 @@
-import { posix } from "node:path";
-const WORKDIR = "/workspace";
-const EXEC_TIMEOUT_MS = 120_000;
-const INSTALL_TIMEOUT_MS = 300_000;
-/** The only hosts the VM reaches: where npm and Python packages come from. */
-const REGISTRIES = ["registry.npmjs.org", "pypi.org", "files.pythonhosted.org"];
-/** python at the start of a command, after an operator, or behind VAR=value assignments. */
-const PYTHON_IN_SHELL = /(?:^|[;&|(\n`]|\$\()\s*(?:\w+=\S*\s+)*python3?(?:\.\d+)?(?=\s|$)/;
-/**
- * What an agentOS VM runs: a WASM userland (a POSIX shell and coreutils, no native binaries),
- * Node in a V8 isolate and Python as Pyodide. Python started from the shell never returns, so
- * it is offered as its own tool; of the compiled wheels only numpy loads reliably.
- */
-export const AGENTOS_CAPABILITIES = {
-    commands: [
-        "sh",
-        "ls",
-        "cat",
-        "head",
-        "tail",
-        "sort",
-        "wc",
-        "grep",
-        "sed",
-        "awk",
-        "find",
-        "diff",
-        "tar",
-        "gzip",
-        "base64",
-        "node",
-        "npm",
-    ],
-    python: "tool",
-    pythonPackages: "Python 3.13 standard library; `packages` installs numpy and pure-Python packages from PyPI such as openpyxl or pypdf — no pandas, pillow or matplotlib",
-    network: "none, except the npm and PyPI registries",
-    uses: "calculations or file conversion",
-    workdir: WORKDIR,
-};
-let runtime = null;
-/** One native sidecar process hosts the VM of every run; the first sandbox starts it. */
-function agentOsRuntime() {
-    runtime ??= (async () => {
-        const [core, runtimeCore] = await Promise.all([
-            import("@rivet-dev/agentos-core"),
-            import("@rivet-dev/agentos-runtime-core"),
-        ]).catch((err) => {
-            throw new Error(`SANDBOX=agentos needs @rivet-dev/agentos-core in this build: ${err.message}`);
-        });
-        keepRuntimeCommands(runtimeCore.SidecarProcess);
-        return { AgentOs: core.AgentOs, sidecar: await core.AgentOs.createSidecar() };
-    })().catch((err) => {
-        runtime = null;
-        throw err;
-    });
-    return runtime;
-}
-const patched = new WeakSet();
-/**
- * agentOS registers `python` as a kernel command when it creates a VM and leaves it out when
- * it configures that VM; naming the runtime commands there again is what makes Python start.
- */
-function keepRuntimeCommands(SidecarProcess) {
-    const proto = SidecarProcess.prototype;
-    if (patched.has(proto)) {
-        return;
-    }
-    patched.add(proto);
-    const configureVm = proto.configureVm;
-    proto.configureVm = function (session, vm, options) {
-        const commands = [
-            "node",
-            "npm",
-            "npx",
-            "python",
-            "python3",
-            ...(options?.bootstrapCommands ?? []),
-        ];
-        return configureVm.call(this, session, vm, {
-            ...options,
-            bootstrapCommands: [...new Set(commands)],
-        });
-    };
-}
-/** Stops the sidecar process. The next sandbox starts a new one. */
-export async function stopAgentOs() {
-    const current = runtime;
-    runtime = null;
-    await (await current?.catch(() => null))?.sidecar.dispose();
-}
-function toResult(result, python = false) {
-    const stdout = result.stdout ?? "";
-    let stderr = result.stderr ?? "";
-    if (python) {
-        // A Python traceback arrives with the interpreter's own JavaScript stack behind it.
-        stderr = stderr.replace(/\n\s+at [\s\S]*$/, "\n");
-    }
-    if (result.outcome === "timed_out") {
-        stderr = `${stderr}\ntimed out`.trim();
-    }
-    else if (result.outcome !== "succeeded" && !stdout && !stderr) {
-        stderr = result.error.message;
-    }
-    return { exitCode: result.exitCode ?? (result.outcome === "succeeded" ? 0 : 1), stdout, stderr };
-}
-/** One agentOS VM per run, inside the server process's sidecar: no Docker, no container. */
-export class AgentOsSandbox {
-    capabilities = AGENTOS_CAPABILITIES;
-    machine = null;
-    installed = new Set();
-    vm() {
-        this.machine ??= (async () => {
-            const { AgentOs, sidecar } = await agentOsRuntime();
-            return AgentOs.create({
-                sidecar: { kind: "explicit", handle: sidecar },
-                // Anything not listed is refused, the host's own loopback included.
-                permissions: {
-                    fs: "allow",
-                    childProcess: "allow",
-                    process: "allow",
-                    env: "allow",
-                    network: {
-                        default: "deny",
-                        rules: [
-                            {
-                                mode: "allow",
-                                operations: ["*"],
-                                patterns: REGISTRIES.flatMap((host) => [`dns://${host}`, `tcp://${host}:443`]),
-                            },
-                        ],
-                    },
-                },
-            });
-        })();
-        return this.machine;
-    }
-    async exec(command, options = {}) {
-        if (PYTHON_IN_SHELL.test(command)) {
-            return {
-                exitCode: 127,
-                stdout: "",
-                stderr: "python is not a shell command in this sandbox; run Python with run_python.",
-            };
-        }
-        const vm = await this.vm();
-        return toResult(await vm.process.exec(command, {
-            cwd: options.cwd ?? WORKDIR,
-            env: options.env,
-            timeoutMs: options.timeoutMs ?? EXEC_TIMEOUT_MS,
-            output: { capture: "all" },
-        }));
-    }
-    async runPython(source, options = {}) {
-        const vm = await this.vm();
-        const missing = (options.packages ?? []).filter((name) => !this.installed.has(name));
-        if (missing.length) {
-            const install = toResult(await vm.python.install(missing, {
-                timeoutMs: INSTALL_TIMEOUT_MS,
-                output: { capture: "all" },
-            }));
-            // A wheel that is listed but not shipped "installs" and then fails to load.
-            if (install.exitCode !== 0 || /Failed to load/.test(install.stdout)) {
-                return { ...install, exitCode: install.exitCode || 1 };
-            }
-            for (const name of missing) {
-                this.installed.add(name);
-            }
-        }
-        return toResult(await vm.python.execute(source, {
-            // Python starts in its HOME whatever cwd says, and only /workspace is shared with the shell.
-            env: { ...options.env, HOME: WORKDIR },
-            timeoutMs: options.timeoutMs ?? EXEC_TIMEOUT_MS,
-            output: { capture: "all" },
-        }), true);
-    }
-    async writeFile(path, data) {
-        const vm = await this.vm();
-        const target = posix.resolve(WORKDIR, path);
-        await vm.filesystem.mkdir(posix.dirname(target), { recursive: true });
-        await vm.filesystem.writeFile(target, data);
-    }
-    async readFile(path) {
-        const vm = await this.vm();
-        return vm.filesystem.readFile(posix.resolve(WORKDIR, path));
-    }
-    async destroy() {
-        const machine = this.machine;
-        this.machine = null;
-        await (await machine?.catch(() => null))?.dispose();
-    }
-}