@gojsop/cli 0.0.0-stage → 0.2.0

package/README.md

@@ -1,3 +1,18 @@
-# Temporary Holding Version
+# @gojsop/cli
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The [gojsop](https://github.com/efuturetoday/gojsop) CLI. It runs hooks and
+policies on your machine, in the engine the operator uses, against a cluster
+held in memory.
+
+```bash
+npm install --save-dev @gojsop/cli
+npx gojsop run policy.yaml --request request.yaml --trace
+```
+
+npm installs the binary for your platform as an optional dependency
+(`@gojsop/cli-<os>-<arch>`): macOS and Linux on x64 and arm64, Windows on
+x64. Set `GOJSOP_BIN` to use another binary.
+
+To test hooks and policies with vitest, use
+[`@gojsop/testing`](https://www.npmjs.com/package/@gojsop/testing); it
+depends on this package.

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { parseArgs } from "node:util";
+import { build } from "./build.js";
+import { bundle, isModule, scriptBeside } from "./bundle.js";
+import { binaryPath, notFoundHint } from "./index.js";
+import { create, remove, rename } from "./scaffold.js";
+const usage = `usage:
+  gojsop new <policy|hook> <name>     add a policy or hook with a passing test
+  gojsop rn <name> <new-name>         rename one
+  gojsop rm <name> [--yes]            remove one
+  gojsop build                        write dist/ for kubectl apply -f dist/
+  gojsop run <manifest> (--request <file> | --event <file>) [--cluster <file>] [--trace]
+  gojsop serve --stdio
+`;
+const args = process.argv.slice(2);
+// These commands run here, in Node: they edit the workspace or bundle with
+// the project's Vite. run and serve are the gojsop binary's.
+const OWN = new Set([undefined, "help", "-h", "--help", "new", "rm", "remove", "rn", "rename", "build"]);
+async function workspaceCommand() {
+    const [cmd, ...rest] = args;
+    if (!OWN.has(cmd))
+        return false;
+    const { values, positionals } = parseArgs({
+        args: rest,
+        allowPositionals: true,
+        options: { yes: { type: "boolean", short: "y" } },
+    });
+    const want = (n) => {
+        if (positionals.length !== n)
+            throw new Error(usage);
+    };
+    switch (cmd) {
+        case undefined:
+        case "help":
+        case "-h":
+        case "--help":
+            console.log(usage);
+            return true;
+        case "new":
+            want(2);
+            create(positionals[0], positionals[1]);
+            return true;
+        case "rm":
+        case "remove":
+            want(1);
+            await remove(positionals[0], values.yes ?? false);
+            return true;
+        case "rn":
+        case "rename":
+            want(2);
+            rename(positionals[0], positionals[1]);
+            return true;
+        case "build":
+            want(0);
+            await build();
+            return true;
+    }
+    return false;
+}
+try {
+    if (await workspaceCommand())
+        process.exit(0);
+    // gojsop run on a TypeScript script: bundle it here and hand the result
+    // to the binary with --source, as @gojsop/testing does for every call.
+    if (args[0] === "run" && args[1] && !args.includes("--source")) {
+        const st = fs.statSync(args[1], { throwIfNoEntry: false });
+        const entry = st && scriptBeside(st.isDirectory() ? args[1] : path.dirname(args[1]));
+        if (entry && isModule(entry)) {
+            const file = path.join(fs.mkdtempSync(path.join(os.tmpdir(), "gojsop-")), "script.js");
+            fs.writeFileSync(file, (await bundle(entry)).code);
+            args.push("--source", file);
+        }
+    }
+}
+catch (e) {
+    console.error(e instanceof Error ? e.message : e);
+    process.exit(1);
+}
+const bin = binaryPath();
+const r = spawnSync(bin, args, { stdio: "inherit" });
+if (r.error) {
+    const code = r.error.code;
+    console.error(code === "ENOENT" ? notFoundHint(bin) : `cannot start "${bin}": ${r.error.message}`);
+    process.exit(1);
+}
+process.exit(r.status ?? 1);

package/dist/build.d.ts

@@ -0,0 +1,7 @@
+/**
+ * gojsop build: writes every hook and policy of the workspace to
+ * dist/<policy|hook>-<name>.yaml, with its script bundled into
+ * spec.source.inline, ready for kubectl apply -f dist/. Files it wrote
+ * before for hooks and policies that are gone are removed.
+ */
+export declare function build(out?: string): Promise<number>;

package/dist/build.js

@@ -0,0 +1,46 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parseDocument, Scalar } from "yaml";
+import { bundle, isModule, scriptBeside } from "./bundle.js";
+import { entries } from "./workspace.js";
+/** The most spec.source.inline may hold. */
+const INLINE_LIMIT = 512 * 1024;
+const OWN = /^(policy|hook)-.+\.yaml$/;
+/**
+ * gojsop build: writes every hook and policy of the workspace to
+ * dist/<policy|hook>-<name>.yaml, with its script bundled into
+ * spec.source.inline, ready for kubectl apply -f dist/. Files it wrote
+ * before for hooks and policies that are gone are removed.
+ */
+export async function build(out = "dist") {
+    const all = entries();
+    fs.mkdirSync(out, { recursive: true });
+    for (const f of fs.readdirSync(out))
+        if (OWN.test(f))
+            fs.rmSync(path.join(out, f));
+    const seen = new Set();
+    for (const e of all) {
+        const file = `${e.kind}-${e.name}.yaml`;
+        if (seen.has(file))
+            throw new Error(`two ${e.kind === "hook" ? "hooks" : "policies"} are named ${e.name}`);
+        seen.add(file);
+        const doc = parseDocument(fs.readFileSync(e.manifest, "utf8"));
+        if (!doc.hasIn(["spec", "source", "inline"]) && !doc.hasIn(["spec", "source", "configMapRef"])) {
+            const entry = scriptBeside(e.dir);
+            if (!entry)
+                throw new Error(`${e.dir}: no script next to ${path.basename(e.manifest)}`);
+            const code = isModule(entry) ? (await bundle(entry)).code : fs.readFileSync(entry, "utf8");
+            if (Buffer.byteLength(code) > INLINE_LIMIT) {
+                throw new Error(`${entry}: the bundled script has ${Buffer.byteLength(code)} bytes, more than 512 KiB`);
+            }
+            const inline = new Scalar(code);
+            inline.type = Scalar.BLOCK_LITERAL;
+            doc.setIn(["spec", "source"], doc.createNode({ inline }));
+        }
+        fs.writeFileSync(path.join(out, file), doc.toString({ lineWidth: 0, flowCollectionPadding: false }));
+        console.log(`built ${path.join(out, file)}`);
+    }
+    if (all.length === 0)
+        console.log("no hooks or policies found");
+    return all.length;
+}

package/dist/bundle.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The script next to a manifest: policy.ts or hook.ts (or .mts, .mjs, .js)
+ * named like the manifest, else the one script file of the directory that
+ * is not a test. Other files are modules the script may import.
+ * Undefined when there is none.
+ */
+export declare function scriptBeside(manifestDir: string): string | undefined;
+/** Whether a script is a module that bundle() must turn into a plain script. */
+export declare function isModule(file: string): boolean;
+/** A bundled script, the files it was built from, and its source map. */
+export interface Bundle {
+    code: string;
+    files: string[];
+    /** Source map (v3) with absolute paths in sources. */
+    map?: {
+        version: number;
+        sources: string[];
+        mappings: string;
+        names: string[];
+    };
+}
+/**
+ * Bundles a TypeScript or ES-module script, with its imports, into the one
+ * plain script gojsop runs: ES2023, no modules, the exports as globals.
+ * Uses the project's Vite.
+ */
+export declare function bundle(file: string): Promise<Bundle>;

package/dist/bundle.js

@@ -0,0 +1,94 @@
+import fs from "node:fs";
+import path from "node:path";
+// Names the IIFE that holds the module's exports while it runs.
+const EXPORTS = "__gojsop_exports";
+/** Script files gojsop bundles; a .js file is a plain script and runs as it is. */
+const MODULE = /\.(ts|mts|mjs)$/;
+const NOT_A_SCRIPT = /\.(test|spec)\.[cm]?[jt]s$|\.d\.ts$/;
+/**
+ * The script next to a manifest: policy.ts or hook.ts (or .mts, .mjs, .js)
+ * named like the manifest, else the one script file of the directory that
+ * is not a test. Other files are modules the script may import.
+ * Undefined when there is none.
+ */
+export function scriptBeside(manifestDir) {
+    for (const base of ["policy", "hook"]) {
+        if (!fs.existsSync(path.join(manifestDir, `${base}.yaml`)))
+            continue;
+        for (const ext of [".ts", ".mts", ".mjs", ".js"]) {
+            const f = path.join(manifestDir, base + ext);
+            if (fs.existsSync(f))
+                return f;
+        }
+    }
+    const found = fs
+        .readdirSync(manifestDir)
+        .filter((f) => /\.([cm]?[jt]s)$/.test(f) && !NOT_A_SCRIPT.test(f))
+        .sort();
+    if (found.length > 1) {
+        throw new Error(`${manifestDir}: several scripts (${found.join(", ")}); name the entry policy.ts or hook.ts`);
+    }
+    return found[0] && path.join(manifestDir, found[0]);
+}
+/** Whether a script is a module that bundle() must turn into a plain script. */
+export function isModule(file) {
+    return MODULE.test(file);
+}
+// After the bundle runs, its exports become globals: gojsop calls
+// validate, mutate and handle as properties of globalThis.
+function exportsToGlobals() {
+    return {
+        name: "gojsop:exports-to-globals",
+        generateBundle(_options, bundle) {
+            for (const chunk of Object.values(bundle)) {
+                if (chunk.type !== "chunk" || !chunk.isEntry)
+                    continue;
+                // Region markers name local paths, and the script ends up in the
+                // cluster. Blank them but keep the lines, so the source map holds.
+                chunk.code = chunk.code.replace(/^[ \t]*\/\/#(end)?region.*$/gm, "");
+                chunk.code += `\n${chunk.exports.map((n) => `globalThis.${n} = ${EXPORTS}.${n};\n`).join("")}`;
+            }
+        },
+    };
+}
+// Vite writes sources relative to its output directory, dist/ of root.
+function absoluteSources(map, root) {
+    return { ...map, sources: map.sources.map((s) => path.resolve(root, "dist", s)) };
+}
+/**
+ * Bundles a TypeScript or ES-module script, with its imports, into the one
+ * plain script gojsop runs: ES2023, no modules, the exports as globals.
+ * Uses the project's Vite.
+ */
+export async function bundle(file) {
+    const { build } = await import("vite");
+    const entry = path.resolve(file); // vite resolves a relative entry against root
+    const out = await build({
+        configFile: false,
+        logLevel: "silent",
+        root: path.dirname(entry),
+        plugins: [exportsToGlobals()],
+        build: {
+            write: false,
+            target: "es2023",
+            minify: false,
+            sourcemap: "hidden",
+            emptyOutDir: false,
+            lib: { entry, formats: ["iife"], name: EXPORTS, fileName: "script" },
+        },
+    });
+    const outputs = Array.isArray(out) ? out : [out];
+    for (const o of outputs) {
+        if ("output" in o) {
+            const chunk = o.output.find((c) => c.type === "chunk" && c.isEntry);
+            if (chunk && chunk.type === "chunk") {
+                return {
+                    code: chunk.code,
+                    files: chunk.moduleIds.filter((id) => path.isAbsolute(id)),
+                    map: chunk.map ? absoluteSources(JSON.parse(chunk.map.toString()), path.dirname(entry)) : undefined,
+                };
+            }
+        }
+    }
+    throw new Error(`${entry}: vite produced no script`);
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The path of the gojsop binary: GOJSOP_BIN if set, else the binary of the
+ * platform package npm installed, else "gojsop" from PATH.
+ */
+export declare function binaryPath(): string;
+/** Explains how to get the binary when binaryPath() points nowhere. */
+export declare function notFoundHint(bin: string): string;
+export { type Bundle, bundle, isModule, scriptBeside } from "./bundle.js";

package/dist/index.js

@@ -0,0 +1,28 @@
+import { createRequire } from "node:module";
+import { platforms } from "./platforms.js";
+const require = createRequire(import.meta.url);
+/**
+ * The path of the gojsop binary: GOJSOP_BIN if set, else the binary of the
+ * platform package npm installed, else "gojsop" from PATH.
+ */
+export function binaryPath() {
+    if (process.env.GOJSOP_BIN)
+        return process.env.GOJSOP_BIN;
+    const p = platforms[`${process.platform}-${process.arch}`];
+    if (p) {
+        const exe = process.platform === "win32" ? "gojsop.exe" : "gojsop";
+        try {
+            return require.resolve(`${p.pkg}/bin/${exe}`);
+        }
+        catch {
+            // not installed (unsupported platform, --omit=optional); fall back to PATH
+        }
+    }
+    return "gojsop";
+}
+/** Explains how to get the binary when binaryPath() points nowhere. */
+export function notFoundHint(bin) {
+    return (`cannot start the gojsop binary "${bin}": not found. ` +
+        `Reinstall @gojsop/cli without --omit=optional, put gojsop on PATH, or set GOJSOP_BIN to its path.`);
+}
+export { bundle, isModule, scriptBeside } from "./bundle.js";

package/dist/platforms.d.ts

@@ -0,0 +1,7 @@
+export interface Platform {
+    /** npm package that holds the binary */
+    pkg: string;
+    goos: string;
+    goarch: string;
+}
+export declare const platforms: Record<string, Platform>;

package/dist/platforms.js

@@ -0,0 +1,7 @@
+export const platforms = {
+    "darwin-arm64": { pkg: "@gojsop/cli-darwin-arm64", goos: "darwin", goarch: "arm64" },
+    "darwin-x64": { pkg: "@gojsop/cli-darwin-x64", goos: "darwin", goarch: "amd64" },
+    "linux-arm64": { pkg: "@gojsop/cli-linux-arm64", goos: "linux", goarch: "arm64" },
+    "linux-x64": { pkg: "@gojsop/cli-linux-x64", goos: "linux", goarch: "amd64" },
+    "win32-x64": { pkg: "@gojsop/cli-win32-x64", goos: "windows", goarch: "amd64" },
+};

package/dist/scaffold.d.ts

@@ -0,0 +1,6 @@
+/** gojsop new <policy|hook> <name>: a new directory with a passing test. */
+export declare function create(kind: string, name: string): void;
+/** gojsop rm <name>: removes the directory of a hook or policy. */
+export declare function remove(nameOrDir: string, yes: boolean): Promise<void>;
+/** gojsop rn <name> <new-name>: renames a hook or policy and its directory. */
+export declare function rename(nameOrDir: string, to: string): void;

package/dist/scaffold.js

@@ -0,0 +1,127 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createInterface } from "node:readline/promises";
+import { parseDocument } from "yaml";
+import { checkName, find, KINDS } from "./workspace.js";
+// What gojsop new writes: a manifest, a script and a test that passes.
+const FILES = {
+    policy: (name) => ({
+        "policy.yaml": `apiVersion: core.gojsop.io/v1alpha1
+kind: JSAdmission
+metadata:
+  name: ${name}
+spec:
+  type: validating
+  rules:
+    - apiGroups: [""]
+      apiVersions: ["v1"]
+      resources: ["pods"]
+      operations: ["CREATE", "UPDATE"]
+  # Audit records what the policy would deny and blocks nothing; switch to
+  # Deny once kubectl describe jsadmission ${name} shows no surprises.
+  enforcement: Audit
+`,
+        "policy.ts": `import type { Request, Response } from "@gojsop/types";
+
+export function validate(req: Request): Response {
+  return { allowed: true };
+}
+`,
+        "policy.test.ts": `import { expect, test } from "vitest";
+import { pod, policy } from "@gojsop/testing";
+
+const ${camel(name)} = policy("./policy.yaml");
+
+test("allows a pod", async () => {
+  const result = await ${camel(name)}.review({ object: pod() });
+  expect(result.allowed).toBe(true);
+});
+`,
+    }),
+    hook: (name) => ({
+        "hook.yaml": `apiVersion: core.gojsop.io/v1alpha1
+kind: JSHook
+metadata:
+  name: ${name}
+spec:
+  bindings:
+    - name: pods
+      apiGroups: [""]
+      apiVersions: ["v1"]
+      resources: ["pods"]
+  # What kube.* may do besides reading the bindings, for example:
+  # permissions:
+  #   - apiGroups: [""]
+  #     resources: ["configmaps"]
+  #     verbs: ["get", "create", "patch"]
+`,
+        "hook.ts": `import type { Event } from "@gojsop/types";
+
+export function handle(event: Event) {
+  console.log(event.type, event.object.metadata?.name);
+}
+`,
+        "hook.test.ts": `import { expect, test } from "vitest";
+import { hook, pod } from "@gojsop/testing";
+
+const ${camel(name)} = hook("./hook.yaml");
+
+test("logs the pod", async () => {
+  const result = await ${camel(name)}.handle({ object: pod({ name: "web" }) });
+  expect(result.console.map((l) => l.text)).toEqual(["Added web"]);
+});
+`,
+    }),
+};
+function camel(name) {
+    return name.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+/** gojsop new <policy|hook> <name>: a new directory with a passing test. */
+export function create(kind, name) {
+    if (kind !== "policy" && kind !== "hook")
+        throw new Error(`gojsop new: give policy or hook, not "${kind}"`);
+    checkName(name);
+    const dir = path.join(KINDS[kind].dir, name);
+    if (fs.existsSync(dir))
+        throw new Error(`${dir} exists already`);
+    fs.mkdirSync(dir, { recursive: true });
+    for (const [file, text] of Object.entries(FILES[kind](name)))
+        fs.writeFileSync(path.join(dir, file), text);
+    console.log(`created ${dir}: ${Object.keys(FILES[kind](name)).join(", ")}`);
+}
+async function confirm(question) {
+    if (!process.stdin.isTTY)
+        return false;
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await rl.question(`${question} [y/N] `);
+    rl.close();
+    return /^y(es)?$/i.test(answer.trim());
+}
+function stillDeployed(kind, name) {
+    return `If it is deployed, it stays in the cluster until: kubectl delete ${KINDS[kind].resource} ${name}`;
+}
+/** gojsop rm <name>: removes the directory of a hook or policy. */
+export async function remove(nameOrDir, yes) {
+    const e = find(nameOrDir);
+    if (!yes && !(await confirm(`Remove ${e.dir}?`))) {
+        throw new Error(`not removed; confirm, or pass --yes`);
+    }
+    fs.rmSync(e.dir, { recursive: true });
+    console.log(`removed ${e.dir}\n${stillDeployed(e.kind, e.name)}`);
+}
+/** gojsop rn <name> <new-name>: renames a hook or policy and its directory. */
+export function rename(nameOrDir, to) {
+    checkName(to);
+    const e = find(nameOrDir);
+    const doc = parseDocument(fs.readFileSync(e.manifest, "utf8"));
+    doc.setIn(["metadata", "name"], to);
+    fs.writeFileSync(e.manifest, doc.toString({ lineWidth: 0, flowCollectionPadding: false }));
+    let dir = e.dir;
+    if (path.basename(e.dir) === e.name) {
+        dir = path.join(path.dirname(e.dir), to);
+        if (fs.existsSync(dir))
+            throw new Error(`${dir} exists already`);
+        fs.renameSync(e.dir, dir);
+    }
+    console.log(`renamed ${e.name} to ${to} (${dir})\n${stillDeployed(e.kind, e.name)}`);
+}

package/dist/workspace.d.ts

@@ -0,0 +1,30 @@
+export declare const KINDS: {
+    readonly policy: {
+        readonly file: "policy.yaml";
+        readonly kind: "JSAdmission";
+        readonly dir: "policies";
+        readonly resource: "jsadmission";
+    };
+    readonly hook: {
+        readonly file: "hook.yaml";
+        readonly kind: "JSHook";
+        readonly dir: "hooks";
+        readonly resource: "jshook";
+    };
+};
+export type Kind = keyof typeof KINDS;
+/** A hook or policy of the workspace. */
+export interface Entry {
+    kind: Kind;
+    /** metadata.name */
+    name: string;
+    dir: string;
+    manifest: string;
+}
+/** Reads the hook or policy of a directory; undefined when it has none. */
+export declare function entryIn(dir: string): Entry | undefined;
+/** Every hook and policy below root, in a stable order. */
+export declare function entries(root?: string): Entry[];
+/** The one hook or policy a name or directory names; throws otherwise. */
+export declare function find(nameOrDir: string): Entry;
+export declare function checkName(name: string): void;

package/dist/workspace.js

@@ -0,0 +1,59 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parseDocument } from "yaml";
+// The layout of a workspace: one directory per hook or policy, holding
+// hook.yaml or policy.yaml, the script and its tests.
+export const KINDS = {
+    policy: { file: "policy.yaml", kind: "JSAdmission", dir: "policies", resource: "jsadmission" },
+    hook: { file: "hook.yaml", kind: "JSHook", dir: "hooks", resource: "jshook" },
+};
+const SKIP = new Set(["node_modules", "dist"]);
+/** Reads the hook or policy of a directory; undefined when it has none. */
+export function entryIn(dir) {
+    for (const kind of Object.keys(KINDS)) {
+        const manifest = path.join(dir, KINDS[kind].file);
+        if (!fs.existsSync(manifest))
+            continue;
+        const doc = parseDocument(fs.readFileSync(manifest, "utf8"));
+        const name = doc.getIn(["metadata", "name"]);
+        return { kind, name: typeof name === "string" && name ? name : path.basename(dir), dir, manifest };
+    }
+    return undefined;
+}
+/** Every hook and policy below root, in a stable order. */
+export function entries(root = ".") {
+    const found = [];
+    const walk = (dir) => {
+        const e = entryIn(dir);
+        if (e)
+            found.push(e);
+        for (const d of fs.readdirSync(dir, { withFileTypes: true })) {
+            if (d.isDirectory() && !SKIP.has(d.name) && !d.name.startsWith("."))
+                walk(path.join(dir, d.name));
+        }
+    };
+    walk(root);
+    return found.sort((a, b) => a.dir.localeCompare(b.dir));
+}
+/** The one hook or policy a name or directory names; throws otherwise. */
+export function find(nameOrDir) {
+    if (fs.existsSync(nameOrDir) && fs.statSync(nameOrDir).isDirectory()) {
+        const e = entryIn(nameOrDir);
+        if (e)
+            return e;
+    }
+    const hits = entries().filter((e) => e.name === nameOrDir || path.basename(e.dir) === nameOrDir);
+    if (hits.length === 1)
+        return hits[0];
+    if (hits.length === 0)
+        throw new Error(`no hook or policy named ${nameOrDir}`);
+    throw new Error(`${nameOrDir} names ${hits.map((h) => h.dir).join(" and ")}; give the directory instead`);
+}
+// metadata.name becomes part of ServiceAccount and webhook names, so a
+// DNS label keeps every one of them valid.
+const NAME = /^[a-z0-9]([-a-z0-9]{0,61}[a-z0-9])?$/;
+export function checkName(name) {
+    if (!NAME.test(name)) {
+        throw new Error(`"${name}" is not a valid name: use lowercase letters, digits and "-", at most 63 characters`);
+    }
+}

package/package.json

@@ -1,6 +1,52 @@
 {
   "name": "@gojsop/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "The gojsop CLI: run and serve gojsop hooks and policies locally, in the engine the operator uses.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/efuturetoday/gojsop.git",
+    "directory": "sdk/cli"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "gojsop": "dist/bin.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=22.12"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^7.0.2",
+    "vite": "^8.0.0"
+  },
+  "peerDependencies": {
+    "vite": ">=7"
+  },
+  "dependencies": {
+    "yaml": "^2.9.1"
+  },
+  "optionalDependencies": {
+    "@gojsop/cli-darwin-arm64": "0.2.0",
+    "@gojsop/cli-darwin-x64": "0.2.0",
+    "@gojsop/cli-linux-arm64": "0.2.0",
+    "@gojsop/cli-linux-x64": "0.2.0",
+    "@gojsop/cli-win32-x64": "0.2.0"
+  }
+}