@intentius/chant-lexicon-e2b 0.0.0-stage → 0.124.32

package/dist/config.js

@@ -0,0 +1,82 @@
+/**
+ * The `e2b` namespace in `chant.config.ts`.
+ *
+ * ```ts
+ * import type { ChantConfig } from "@intentius/chant/config";
+ * import "@intentius/chant-lexicon-e2b";   // brings the `e2b` key into ChantConfig
+ *
+ * export default {
+ *   lexicons: ["e2b"],
+ *   e2b: {
+ *     profiles: {
+ *       prod: {
+ *         apiKey: { env: "E2B_API_KEY" },
+ *         domain: "e2b.loam.example.com",     // omit for hosted E2B
+ *         steward: "prod-steward",
+ *         gitToken: { env: "GITHUB_TOKEN" },
+ *       },
+ *     },
+ *     defaultProfile: "prod",
+ *   },
+ * } satisfies ChantConfig;
+ * ```
+ *
+ * One schema, three consumers, as for fountain's namespace: core validates the
+ * namespace against it at load, the type below is derived from it, and that
+ * type augments `ChantConfig`. A project with no `e2b.profiles` keeps working:
+ * the runtime falls back to `E2B_API_KEY`, `E2B_DOMAIN` and `CHANT_GIT_TOKEN`.
+ */
+import { z } from "zod";
+/** A secret named by its environment variable, never a literal value. */
+const envRef = z.strictObject({ env: z.string() });
+export const e2bProfileSchema = z.strictObject({
+    /** The E2B API key, by environment variable. Default `E2B_API_KEY`. */
+    apiKey: envRef.optional(),
+    /**
+     * The E2B domain the SDK talks to: `api.<domain>` and `<port>-<id>.<domain>`.
+     * Omitted, the SDK's own default (hosted E2B, or `E2B_DOMAIN`).
+     */
+    domain: z.string().optional(),
+    /** The template a steward's sandbox is made from. Default `base`. It needs git and Node. */
+    template: z.string().optional(),
+    /**
+     * The steward's name: the one sandbox every run of this profile lands on,
+     * found again by its `chant/steward` metadata. Default: the repository's name.
+     */
+    steward: z.string().optional(),
+    /**
+     * The repository the sandbox clones, as an https URL. Default: `origin`'s
+     * URL, with an ssh URL rewritten to https.
+     */
+    repo: z.string().optional(),
+    /**
+     * A token for that repository, by environment variable, so the sandbox can
+     * fetch a private repo and push chant's ledger branch. It is handed to each
+     * command in the sandbox and never written to its disk.
+     */
+    gitToken: envRef.optional(),
+});
+export const e2bConfigSchema = z.strictObject({
+    profiles: z.record(z.string(), e2bProfileSchema).optional(),
+    /** Profile used when a run names none. */
+    defaultProfile: z.string().optional(),
+});
+/**
+ * The named profile, else `defaultProfile`, else `undefined`. A name that is
+ * not declared is an error rather than a fall back to the default: running
+ * against the wrong steward because a profile name was misspelt is the one
+ * mistake a runtime must not make.
+ */
+export function resolveProfile(config, name) {
+    const profiles = config?.e2b?.profiles;
+    if (name !== undefined) {
+        const named = profiles?.[name];
+        if (!named) {
+            throw new Error(`e2b runtime: no profile "${name}" under e2b.profiles in chant.config.ts. ` +
+                `Declare it, or drop --profile to use e2b.defaultProfile.`);
+        }
+        return named;
+    }
+    const fallback = config?.e2b?.defaultProfile;
+    return fallback !== undefined ? profiles?.[fallback] : undefined;
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { e2bPlugin } from "./plugin.js";
+export { e2bSerializer } from "./serializer.js";
+export { Template, type TemplateProps } from "./resources.js";
+export { e2bConfigSchema, e2bProfileSchema, resolveProfile, type E2bConfig, type E2bProfile } from "./config.js";
+export { createE2bOpRuntime, type E2bOpRuntimeOptions } from "./op/runtime.js";
+export { e2bSandboxes, STEWARD_METADATA_KEY, type StewardSandbox, type StewardSandboxes } from "./op/sandbox.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,cAAc,EAAE,KAAK,SAAS,EAAE,KAAK,UAAU,EAAE,MAAM,UAAU,CAAC;AAC9G,OAAO,EAAE,kBAAkB,EAAE,KAAK,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAC5E,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,KAAK,cAAc,EAAE,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+export { e2bPlugin } from "./plugin.js";
+export { e2bSerializer } from "./serializer.js";
+export { Template } from "./resources.js";
+export { e2bConfigSchema, e2bProfileSchema, resolveProfile } from "./config.js";
+export { createE2bOpRuntime } from "./op/runtime.js";
+export { e2bSandboxes, STEWARD_METADATA_KEY } from "./op/sandbox.js";

package/dist/integrity.json

@@ -0,0 +1,15 @@
+{
+  "algorithm": "sha256",
+  "artifacts": {
+    "manifest.json": "fd36bde57f75482471fbc6444daf3b190f9b7ffcadba72e5fad1a419328aac9c",
+    "meta.json": "324b605d8aa8c5fae317aad1f0fa1afb3704e2586ffb8bb958dd868d8cf5b6ae",
+    "types/index.d.ts": "1a79ae1697e6c89fa1d79443c17791366bac50baf7dff00d3c6fbb2260800798",
+    "rules/pinned-image.ts": "a93030b2694e552c2f7565edef9117216067e3b68138ed95aad46e1e06c0bdd8",
+    "rules/template-literal.ts": "4da6b9e62e92f0db34410f9a806a6c2e1894bab37618988b1a7d7a127958f1d6",
+    "rules/template-size.ts": "035c28ce063c447dee2e2dc46f2426ab542998257eb08c15d6c69d5c5512af7b",
+    "rules/e2b011-template-name.ts": "3b9af285d5d658538f948a9bf9d74eea149c6933861b38c008d9a887f68711d4",
+    "rules/e2b012-steward-tools.ts": "1e4e1a93b80b939c3a2135ba43493e4d9b8552f71e5fe9c0ca71dae7fa49842e",
+    "skills/chant-e2b-ops.md": "8e6ae4c8af6a724501c5363d7fa3a4adf85537788529a6039d6857b2865889e7"
+  },
+  "composite": "2b10b0b5337aa1febb3718cdd2e8dc8d155afae40a415ff9d6a9a1cc01efb092"
+}

package/dist/lint/audit-catalog.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The e2b lexicon's chant audit catalog: metadata for the E2B post-synth
+ * checks, contributed via `e2bPlugin.auditCatalog()`.
+ *
+ * Every check reads the chant model (`ctx.entities`), not the emitted files,
+ * so they fire on `chant build` and not on an audit of a hand-written
+ * `e2b.Dockerfile`.
+ */
+import type { RuleMeta } from "@intentius/chant/audit/catalog";
+export declare const e2bAuditCatalog: Record<string, RuleMeta>;
+//# sourceMappingURL=audit-catalog.d.ts.map

package/dist/lint/audit-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-catalog.d.ts","sourceRoot":"","sources":["../../src/lint/audit-catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AAM/D,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAapD,CAAC"}

package/dist/lint/audit-catalog.js

@@ -0,0 +1,15 @@
+/**
+ * The e2b lexicon's chant audit catalog: metadata for the E2B post-synth
+ * checks, contributed via `e2bPlugin.auditCatalog()`.
+ *
+ * Every check reads the chant model (`ctx.entities`), not the emitted files,
+ * so they fire on `chant build` and not on an audit of a hand-written
+ * `e2b.Dockerfile`.
+ */
+function rule(id, tier, title, remediation) {
+    return { id, tier, fixKind: "guidance", category: "correctness", title, remediation, yamlBased: false };
+}
+export const e2bAuditCatalog = {
+    E2B011: rule("E2B011", "merge-worthy", "Template name is not one E2B accepts, or two templates share it", "Name the template with lowercase letters, digits, dashes and underscores, and give each template its own name."),
+    E2B012: rule("E2B012", "report-only", "Template shows no sign of git or Node", "Start from a `node` image, or add a `run` step that installs git and Node."),
+};

package/dist/lint/post-synth/e2b011-template-name.d.ts

@@ -0,0 +1,12 @@
+/**
+ * E2B011: a template's name is one E2B accepts, and only one template has it.
+ *
+ * E2B names templates with lowercase letters, digits, dashes and underscores;
+ * `e2b template create` refuses anything else. The name is also the profile's
+ * `template` and the stem of the Dockerfile the serializer writes, so two
+ * templates with one name would overwrite each other's file.
+ */
+import type { PostSynthCheck } from "@intentius/chant/lint/post-synth";
+export declare const TEMPLATE_NAME: RegExp;
+export declare const e2b011: PostSynthCheck;
+//# sourceMappingURL=e2b011-template-name.d.ts.map

package/dist/lint/post-synth/e2b011-template-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"e2b011-template-name.d.ts","sourceRoot":"","sources":["../../../src/lint/post-synth/e2b011-template-name.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAyC,MAAM,kCAAkC,CAAC;AAG9G,eAAO,MAAM,aAAa,QAAkB,CAAC;AAE7C,eAAO,MAAM,MAAM,EAAE,cAoCpB,CAAC"}

package/dist/lint/post-synth/e2b011-template-name.js

@@ -0,0 +1,48 @@
+/**
+ * E2B011: a template's name is one E2B accepts, and only one template has it.
+ *
+ * E2B names templates with lowercase letters, digits, dashes and underscores;
+ * `e2b template create` refuses anything else. The name is also the profile's
+ * `template` and the stem of the Dockerfile the serializer writes, so two
+ * templates with one name would overwrite each other's file.
+ */
+import { templateProps } from "../../resources.js";
+export const TEMPLATE_NAME = /^[a-z0-9_-]+$/;
+export const e2b011 = {
+    id: "E2B011",
+    description: "A Template's name must be lowercase letters, digits, dashes and underscores, and unique",
+    check(ctx) {
+        const diagnostics = [];
+        const seen = new Map();
+        for (const [entityName, entity] of ctx.entities) {
+            const props = templateProps(entity);
+            if (!props)
+                continue;
+            const name = props.name;
+            if (typeof name !== "string" || !TEMPLATE_NAME.test(name)) {
+                diagnostics.push({
+                    checkId: "E2B011",
+                    severity: "error",
+                    message: `Template "${entityName}" has name ${JSON.stringify(name)}. E2B template names are lowercase letters, digits, dashes and underscores.`,
+                    entity: entityName,
+                    lexicon: "e2b",
+                });
+                continue;
+            }
+            const first = seen.get(name);
+            if (first !== undefined) {
+                diagnostics.push({
+                    checkId: "E2B011",
+                    severity: "error",
+                    message: `Templates "${first}" and "${entityName}" are both named "${name}"; their e2b.${name}.Dockerfile files would overwrite each other.`,
+                    entity: entityName,
+                    lexicon: "e2b",
+                });
+            }
+            else {
+                seen.set(name, entityName);
+            }
+        }
+        return diagnostics;
+    },
+};

package/dist/lint/post-synth/e2b012-steward-tools.d.ts

@@ -0,0 +1,20 @@
+/**
+ * E2B012: a template has the git and Node a steward needs.
+ *
+ * The runtime clones the repository with git and runs the project's own chant
+ * with Node, and it stops a run at once on a sandbox that lacks either. This
+ * check looks for both in the declaration: Node from a `node` image or a
+ * step that installs it, git from a full (not `-slim` or `-alpine`) `node` image, which
+ * ships it, or a step that installs it. It cannot see inside other images, so
+ * it warns rather than fails: a template from an image that already has both
+ * can say so with a `run` step such as `git --version && node --version`.
+ */
+import type { PostSynthCheck } from "@intentius/chant/lint/post-synth";
+import { type TemplateProps } from "../../resources.js";
+/** Which of git and Node the declaration visibly provides. */
+export declare function stewardTools(props: TemplateProps): {
+    git: boolean;
+    node: boolean;
+};
+export declare const e2b012: PostSynthCheck;
+//# sourceMappingURL=e2b012-steward-tools.d.ts.map

package/dist/lint/post-synth/e2b012-steward-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"e2b012-steward-tools.d.ts","sourceRoot":"","sources":["../../../src/lint/post-synth/e2b012-steward-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAyC,MAAM,kCAAkC,CAAC;AAC9G,OAAO,EAAiB,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AASpE,8DAA8D;AAC9D,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa,GAAG;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAQlF;AAED,eAAO,MAAM,MAAM,EAAE,cAwBpB,CAAC"}

package/dist/lint/post-synth/e2b012-steward-tools.js

@@ -0,0 +1,53 @@
+/**
+ * E2B012: a template has the git and Node a steward needs.
+ *
+ * The runtime clones the repository with git and runs the project's own chant
+ * with Node, and it stops a run at once on a sandbox that lacks either. This
+ * check looks for both in the declaration: Node from a `node` image or a
+ * step that installs it, git from a full (not `-slim` or `-alpine`) `node` image, which
+ * ships it, or a step that installs it. It cannot see inside other images, so
+ * it warns rather than fails: a template from an image that already has both
+ * can say so with a `run` step such as `git --version && node --version`.
+ */
+import { templateProps } from "../../resources.js";
+function imageRepoAndTag(image) {
+    const ref = image.toLowerCase().split("@")[0];
+    const segment = ref.slice(ref.lastIndexOf("/") + 1);
+    const [repo, tag = ""] = segment.split(":");
+    return { repo, tag };
+}
+/** Which of git and Node the declaration visibly provides. */
+export function stewardTools(props) {
+    const { repo, tag } = imageRepoAndTag(props.fromImage ?? "");
+    const steps = (props.run ?? []).join("\n");
+    const nodeImage = repo === "node";
+    return {
+        node: nodeImage || /\b(nodejs|node|nvm|fnm|volta)\b/.test(steps),
+        git: (nodeImage && !/slim|alpine/.test(tag)) || /\bgit\b/.test(steps),
+    };
+}
+export const e2b012 = {
+    id: "E2B012",
+    description: "A Template a steward runs on needs git and Node",
+    check(ctx) {
+        const diagnostics = [];
+        for (const [name, entity] of ctx.entities) {
+            const props = templateProps(entity);
+            if (!props)
+                continue;
+            const tools = stewardTools(props);
+            const missing = [tools.git ? undefined : "git", tools.node ? undefined : "Node"].filter((t) => t !== undefined);
+            if (missing.length === 0)
+                continue;
+            diagnostics.push({
+                checkId: "E2B012",
+                severity: "warning",
+                message: `Template "${name}" shows no sign of ${missing.join(" or ")}. A steward needs both; ` +
+                    `start from a node image or add a run step that installs ${missing.length === 2 ? "them" : "it"}.`,
+                entity: name,
+                lexicon: "e2b",
+            });
+        }
+        return diagnostics;
+    },
+};

package/dist/lint/post-synth/index.d.ts

@@ -0,0 +1,3 @@
+import type { PostSynthCheck } from "@intentius/chant/lint/post-synth";
+export declare const postSynthChecks: PostSynthCheck[];
+//# sourceMappingURL=index.d.ts.map

package/dist/lint/post-synth/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lint/post-synth/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAIvE,eAAO,MAAM,eAAe,EAAE,cAAc,EAG3C,CAAC"}

package/dist/lint/post-synth/index.js

@@ -0,0 +1,6 @@
+import { e2b011 } from "./e2b011-template-name.js";
+import { e2b012 } from "./e2b012-steward-tools.js";
+export const postSynthChecks = [
+    e2b011,
+    e2b012,
+];

package/dist/lint/rules/index.d.ts

@@ -0,0 +1,6 @@
+import type { LintRule } from "@intentius/chant/lint/rule";
+export { templateSizeRule } from "./template-size.js";
+export { pinnedImageRule, isFloatingImage } from "./pinned-image.js";
+/** All lint rules the e2b lexicon provides. */
+export declare const rules: LintRule[];
+//# sourceMappingURL=index.d.ts.map

package/dist/lint/rules/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lint/rules/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAI3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAElE,+CAA+C;AAC/C,eAAO,MAAM,KAAK,EAAE,QAAQ,EAAwC,CAAC"}

package/dist/lint/rules/index.js

@@ -0,0 +1,6 @@
+import { templateSizeRule } from "./template-size.js";
+import { pinnedImageRule } from "./pinned-image.js";
+export { templateSizeRule } from "./template-size.js";
+export { pinnedImageRule, isFloatingImage } from "./pinned-image.js";
+/** All lint rules the e2b lexicon provides. */
+export const rules = [templateSizeRule, pinnedImageRule];

package/dist/lint/rules/pinned-image.d.ts

@@ -0,0 +1,14 @@
+import type { LintRule } from "@intentius/chant/lint/rule";
+/** An image reference with no tag or digest, or the `latest` tag. */
+export declare function isFloatingImage(image: string): boolean;
+/**
+ * E2B002: A template's base image is pinned.
+ *
+ * A steward keeps one sandbox for months, but a template is rebuilt whenever
+ * someone runs `e2b template create`. With `fromImage` untagged or on `latest`,
+ * two builds of the same declaration can carry different Node or git
+ * versions, and a steward made from the second behaves differently with no
+ * change in the repository.
+ */
+export declare const pinnedImageRule: LintRule;
+//# sourceMappingURL=pinned-image.d.ts.map

package/dist/lint/rules/pinned-image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pinned-image.d.ts","sourceRoot":"","sources":["../../../src/lint/rules/pinned-image.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAA+B,MAAM,4BAA4B,CAAC;AAIxF,qEAAqE;AACrE,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAKtD;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,EAAE,QAmB7B,CAAC"}

package/dist/lint/rules/pinned-image.js

@@ -0,0 +1,36 @@
+import { ts } from "@intentius/chant/lint/typescript";
+import { at, property, templateLiterals } from "./template-literal.js";
+/** An image reference with no tag or digest, or the `latest` tag. */
+export function isFloatingImage(image) {
+    if (image.includes("@"))
+        return false;
+    const lastSegment = image.slice(image.lastIndexOf("/") + 1);
+    const colon = lastSegment.indexOf(":");
+    return colon === -1 || lastSegment.slice(colon + 1) === "latest";
+}
+/**
+ * E2B002: A template's base image is pinned.
+ *
+ * A steward keeps one sandbox for months, but a template is rebuilt whenever
+ * someone runs `e2b template create`. With `fromImage` untagged or on `latest`,
+ * two builds of the same declaration can carry different Node or git
+ * versions, and a steward made from the second behaves differently with no
+ * change in the repository.
+ */
+export const pinnedImageRule = {
+    id: "E2B002",
+    severity: "warning",
+    category: "correctness",
+    description: "A Template's fromImage should name a tag other than latest, or a digest",
+    check(context) {
+        const { sourceFile } = context;
+        const diagnostics = [];
+        for (const obj of templateLiterals(sourceFile)) {
+            const image = property(obj, "fromImage", sourceFile);
+            if (image && ts.isStringLiteralLike(image) && image.text.length > 0 && isFloatingImage(image.text)) {
+                diagnostics.push(at(sourceFile, image, "E2B002", "warning", `fromImage "${image.text}" is not pinned; name a version tag such as node:22-bookworm, or a digest.`));
+            }
+        }
+        return diagnostics;
+    },
+};

package/dist/lint/rules/template-literal.d.ts

@@ -0,0 +1,11 @@
+/** Helpers the e2b lint rules share: finding `new Template({...})` literals and reporting on them. */
+import type { LintDiagnostic } from "@intentius/chant/lint/rule";
+import { ts } from "@intentius/chant/lint/typescript";
+/** The object literal passed to each `new Template({...})` in the file. */
+export declare function templateLiterals(sourceFile: ts.SourceFile): ts.ObjectLiteralExpression[];
+/** The initializer of `key` in an object literal, when it is written there. */
+export declare function property(obj: ts.ObjectLiteralExpression, key: string, sourceFile: ts.SourceFile): ts.Expression | undefined;
+/** A numeric literal's value, a negated one included; `undefined` for anything computed. */
+export declare function numberLiteral(expr: ts.Expression): number | undefined;
+export declare function at(sourceFile: ts.SourceFile, node: ts.Node, ruleId: string, severity: LintDiagnostic["severity"], message: string): LintDiagnostic;
+//# sourceMappingURL=template-literal.d.ts.map

package/dist/lint/rules/template-literal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-literal.d.ts","sourceRoot":"","sources":["../../../src/lint/rules/template-literal.ts"],"names":[],"mappings":"AAAA,sGAAsG;AAEtG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,EAAE,EAAE,MAAM,kCAAkC,CAAC;AAEtD,2EAA2E;AAC3E,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,GAAG,EAAE,CAAC,uBAAuB,EAAE,CAaxF;AAED,+EAA+E;AAC/E,wBAAgB,QAAQ,CAAC,GAAG,EAAE,EAAE,CAAC,uBAAuB,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,EAAE,CAAC,UAAU,GAAG,EAAE,CAAC,UAAU,GAAG,SAAS,CAK3H;AAED,4FAA4F;AAC5F,wBAAgB,aAAa,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,GAAG,MAAM,GAAG,SAAS,CAMrE;AAED,wBAAgB,EAAE,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,CAAC,UAAU,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,cAAc,CAGlJ"}

package/dist/lint/rules/template-literal.js

@@ -0,0 +1,39 @@
+/** Helpers the e2b lint rules share: finding `new Template({...})` literals and reporting on them. */
+import { ts } from "@intentius/chant/lint/typescript";
+/** The object literal passed to each `new Template({...})` in the file. */
+export function templateLiterals(sourceFile) {
+    const found = [];
+    function visit(node) {
+        if (ts.isNewExpression(node)) {
+            const callee = node.expression;
+            const name = ts.isIdentifier(callee) ? callee.text : ts.isPropertyAccessExpression(callee) ? callee.name.text : "";
+            const arg = node.arguments?.[0];
+            if (name === "Template" && arg && ts.isObjectLiteralExpression(arg))
+                found.push(arg);
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return found;
+}
+/** The initializer of `key` in an object literal, when it is written there. */
+export function property(obj, key, sourceFile) {
+    for (const p of obj.properties) {
+        if (ts.isPropertyAssignment(p) && p.name.getText(sourceFile) === key)
+            return p.initializer;
+    }
+    return undefined;
+}
+/** A numeric literal's value, a negated one included; `undefined` for anything computed. */
+export function numberLiteral(expr) {
+    if (ts.isNumericLiteral(expr))
+        return Number(expr.text);
+    if (ts.isPrefixUnaryExpression(expr) && expr.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(expr.operand)) {
+        return -Number(expr.operand.text);
+    }
+    return undefined;
+}
+export function at(sourceFile, node, ruleId, severity, message) {
+    const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+    return { file: sourceFile.fileName, line: line + 1, column: character + 1, ruleId, severity, message };
+}

package/dist/lint/rules/template-size.d.ts

@@ -0,0 +1,10 @@
+import type { LintRule } from "@intentius/chant/lint/rule";
+/**
+ * E2B001: A template's CPU and memory are sizes E2B accepts.
+ *
+ * `cpuCount` is a whole number of vCPUs, at least one. `memoryMB` is a whole
+ * number of MiB, at least one and even: `e2b template create` refuses an odd
+ * one. Both are only checked when written as literals.
+ */
+export declare const templateSizeRule: LintRule;
+//# sourceMappingURL=template-size.d.ts.map

package/dist/lint/rules/template-size.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-size.d.ts","sourceRoot":"","sources":["../../../src/lint/rules/template-size.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAA+B,MAAM,4BAA4B,CAAC;AAGxF;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,EAAE,QAyB9B,CAAC"}

package/dist/lint/rules/template-size.js

@@ -0,0 +1,31 @@
+import { at, numberLiteral, property, templateLiterals } from "./template-literal.js";
+/**
+ * E2B001: A template's CPU and memory are sizes E2B accepts.
+ *
+ * `cpuCount` is a whole number of vCPUs, at least one. `memoryMB` is a whole
+ * number of MiB, at least one and even: `e2b template create` refuses an odd
+ * one. Both are only checked when written as literals.
+ */
+export const templateSizeRule = {
+    id: "E2B001",
+    severity: "error",
+    category: "correctness",
+    description: "A Template's cpuCount must be a positive integer and its memoryMB a positive even integer",
+    check(context) {
+        const { sourceFile } = context;
+        const diagnostics = [];
+        for (const obj of templateLiterals(sourceFile)) {
+            const cpu = property(obj, "cpuCount", sourceFile);
+            const cpuValue = cpu ? numberLiteral(cpu) : undefined;
+            if (cpu && cpuValue !== undefined && !(Number.isInteger(cpuValue) && cpuValue >= 1)) {
+                diagnostics.push(at(sourceFile, cpu, "E2B001", "error", `cpuCount ${cpuValue} is not a whole number of vCPUs; use 1 or more.`));
+            }
+            const mem = property(obj, "memoryMB", sourceFile);
+            const memValue = mem ? numberLiteral(mem) : undefined;
+            if (mem && memValue !== undefined && !(Number.isInteger(memValue) && memValue >= 2 && memValue % 2 === 0)) {
+                diagnostics.push(at(sourceFile, mem, "E2B001", "error", `memoryMB ${memValue} is not a positive even number of MiB, which E2B requires.`));
+            }
+        }
+        return diagnostics;
+    },
+};

package/dist/lsp/completions.d.ts

@@ -0,0 +1,7 @@
+import type { CompletionContext, CompletionItem } from "@intentius/chant/lsp/types";
+/**
+ * e2b completions: `Template` after `new`, and its properties inside the
+ * object passed to it.
+ */
+export declare function completions(ctx: CompletionContext): CompletionItem[];
+//# sourceMappingURL=completions.d.ts.map

package/dist/lsp/completions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completions.d.ts","sourceRoot":"","sources":["../../src/lsp/completions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAMpF;;;GAGG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,iBAAiB,GAAG,cAAc,EAAE,CAEpE"}

package/dist/lsp/completions.js

@@ -0,0 +1,10 @@
+import { LexiconIndex, lexiconCompletions } from "@intentius/chant/lsp/lexicon-providers";
+import { LEXICON_ENTRIES } from "../catalog.js";
+const index = new LexiconIndex(LEXICON_ENTRIES);
+/**
+ * e2b completions: `Template` after `new`, and its properties inside the
+ * object passed to it.
+ */
+export function completions(ctx) {
+    return lexiconCompletions(ctx, index, "E2B sandbox template");
+}

package/dist/lsp/hover.d.ts

@@ -0,0 +1,7 @@
+import type { HoverContext, HoverInfo } from "@intentius/chant/lsp/types";
+/**
+ * e2b hover: the `Template` class, with its properties and what it builds
+ * into, and each of its properties by name.
+ */
+export declare function hover(ctx: HoverContext): HoverInfo | undefined;
+//# sourceMappingURL=hover.d.ts.map

package/dist/lsp/hover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hover.d.ts","sourceRoot":"","sources":["../../src/lsp/hover.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAG1E;;;GAGG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,SAAS,GAAG,SAAS,CA2B9D"}

package/dist/lsp/hover.js

@@ -0,0 +1,30 @@
+import { LEXICON_ENTRIES, TEMPLATE_PROPERTIES } from "../catalog.js";
+/**
+ * e2b hover: the `Template` class, with its properties and what it builds
+ * into, and each of its properties by name.
+ */
+export function hover(ctx) {
+    const { word } = ctx;
+    if (!word)
+        return undefined;
+    const entry = LEXICON_ENTRIES[word];
+    if (entry) {
+        const lines = [
+            `**${word}**`,
+            "",
+            `E2B type: \`${entry.resourceType}\``,
+            "",
+            "*A sandbox template, written out as `e2b.<name>.Dockerfile` and built with `e2b template create`.*",
+            "",
+            ...Object.entries(TEMPLATE_PROPERTIES).map(([name, p]) => `- \`${name}${p.required ? "" : "?"}: ${p.type}\`: ${p.description}`),
+        ];
+        return { contents: lines.join("\n") };
+    }
+    // A property name only means a Template property on a line that builds one
+    // or inside its object, so the hover stays quiet on an unrelated `name`.
+    const prop = TEMPLATE_PROPERTIES[word];
+    if (prop && /\bTemplate\b|^\s*\w+\??\s*:/.test(ctx.lineText ?? "") && ctx.content.includes("Template")) {
+        return { contents: `**${word}**${prop.required ? "" : " (optional)"}: \`${prop.type}\`\n\n${prop.description}` };
+    }
+    return undefined;
+}

package/dist/manifest.json

@@ -0,0 +1,6 @@
+{
+  "name": "e2b",
+  "version": "0.124.32",
+  "chantVersion": ">=0.1.0",
+  "namespace": "E2B"
+}

package/dist/meta.json

@@ -0,0 +1,45 @@
+{
+  "Template": {
+    "resourceType": "E2B::Template",
+    "kind": "resource",
+    "lexicon": "e2b",
+    "propertyConstraints": {
+      "name": {
+        "type": "string",
+        "required": true
+      },
+      "fromImage": {
+        "type": "string",
+        "required": true
+      },
+      "run": {
+        "type": "string[]",
+        "required": false
+      },
+      "env": {
+        "type": "Record<string, string>",
+        "required": false
+      },
+      "workdir": {
+        "type": "string",
+        "required": false
+      },
+      "startCmd": {
+        "type": "string",
+        "required": false
+      },
+      "readyCmd": {
+        "type": "string",
+        "required": false
+      },
+      "cpuCount": {
+        "type": "number",
+        "required": false
+      },
+      "memoryMB": {
+        "type": "number",
+        "required": false
+      }
+    }
+  }
+}

package/dist/okf/index.md

@@ -0,0 +1,14 @@
+---
+okf_version: '0.2'
+---
+
+# Resource types
+
+* [Template](/types/Template.md) - E2B::Template
+
+# Rules
+
+* [E2B001](/rules/E2B001.md) - A template's CPU and memory are sizes E2B accepts.
+* [E2B002](/rules/E2B002.md) - A template's base image is pinned.
+* [E2B011](/rules/E2B011.md) - A Template's name must be lowercase letters, digits, dashes and underscores, and unique
+* [E2B012](/rules/E2B012.md) - A Template a steward runs on needs git and Node