@synopackageland/cli 0.4.0 → 0.5.0

package/dist/standalone/worker-registry.js

@@ -0,0 +1,167 @@
+import { createHash } from "node:crypto";
+import { lstatSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { inertWorkerRegistry } from "./helper-inventory.js";
+import { WORKER_CONTRACT } from "./worker-contract.js";
+import { fail, strictJSON } from "./worker-contract-json.js";
+const actions = ["nas.files.list", "nas.files.stat", "nas.files.read", "nas.files.read-stream"];
+const modes = ["interactive", "background"];
+const checkpoints = ["before-step", "before-chunk", "before-result"];
+const ceilings = {
+    inputBytes: 8192, steps: 16, totalMs: 120000, idleMs: 10000, metadataMs: 5000,
+    boundedMs: 10000, boundedBytes: 1048576, streamBytes: 67108864, chunkBytes: 65536, outstandingLeases: 1,
+};
+const idPattern = /^[a-z][a-z0-9_]{0,31}$/;
+const digestPattern = /^[a-f0-9]{64}$/;
+const asciiCompare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function object(value, required, optional = []) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return fail();
+    const o = value;
+    if (required.some(k => !Object.hasOwn(o, k)) || Object.keys(o).some(k => !required.includes(k) && !optional.includes(k)))
+        fail();
+    return o;
+}
+function bounded(value, max, min = 1) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < min)
+        return fail();
+    if (value > max)
+        fail("limit-exceeded");
+    return value;
+}
+function digest(value) {
+    if (typeof value !== "string" || !digestPattern.test(value))
+        return fail();
+    return value;
+}
+function subset(value, allowed) {
+    if (!Array.isArray(value) || !value.length || new Set(value).size !== value.length || value.some(v => !allowed.includes(v)))
+        return fail();
+    return allowed.filter(v => value.includes(v));
+}
+function limits(value, partial) {
+    const keys = Object.keys(ceilings);
+    const raw = object(value, partial ? [] : keys, partial ? keys : []);
+    const result = { ...ceilings };
+    for (const k of keys)
+        if (Object.hasOwn(raw, k))
+            result[k] = bounded(raw[k], ceilings[k]);
+    if (result.idleMs > result.totalMs || result.metadataMs > result.totalMs || result.boundedMs > result.totalMs || result.chunkBytes > result.streamBytes)
+        fail();
+    return result;
+}
+/** Manifest metadata only; never accepts a source path or a caller-chosen digest. */
+export function parseSDKWorkers(value, inertIDs = []) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return fail();
+    const entries = Object.entries(value);
+    if (!entries.length || entries.length + inertIDs.length > WORKER_CONTRACT.maxWorkers)
+        fail("limit-exceeded");
+    return Object.fromEntries(entries.sort(([a], [b]) => asciiCompare(a, b)).map(([id, value]) => {
+        if (!idPattern.test(id) || inertIDs.includes(id))
+            fail();
+        const o = object(value, ["kind", "workerRevision", "actions", "modes"], ["limits"]);
+        if (o.kind !== "sdk-read-plan")
+            fail("unsupported");
+        return [id, {
+                kind: "sdk-read-plan", workerRevision: bounded(o.workerRevision, Number.MAX_SAFE_INTEGER),
+                actions: subset(o.actions, actions), modes: subset(o.modes, modes),
+                limits: limits(Object.hasOwn(o, "limits") ? o.limits : {}, true),
+            }];
+    }));
+}
+/** Must match jobcontract/bindings.go; filenames and exact source bytes are bound. */
+export function sourceWorkerBindings(backend) {
+    const hash = (kind, names, root = "internal/helper/jobcontract", version = 1) => {
+        const h = createHash("sha256").update(`synopkgland/m3/${kind}/source-v${version}\0`);
+        for (const name of names) {
+            const path = join(backend, root, name);
+            if (!lstatSync(path).isFile() || lstatSync(path).size > 1048576)
+                fail();
+            for (const b of [Buffer.from(name), readFileSync(path)]) {
+                const size = Buffer.alloc(4);
+                size.writeUInt32BE(b.length);
+                h.update(size).update(b);
+            }
+        }
+        return h.digest("hex");
+    };
+    return {
+        handlerBinding: hash("handler", ["jobcontract/stub.go", "sdk_job_child_linux.go", "sdk_job_process_linux.go", "sdk_job.go", "sdk_attach.go", "sdk_rpc.go", "sdk_session.go", "sdk_session_contract.go"], "internal/helper", 2),
+        inputSchemaDigest: hash("input", ["decode.go", "digest.go", "types.go", "validate.go"]),
+        outputSchemaDigest: hash("result", ["decode.go", "result.go", "types.go", "validate.go"]),
+    };
+}
+export function buildWorkerRegistry(inert, sdkWorkers, backend) {
+    // Do not even read new SDK files for legacy projects (including old templates).
+    if (sdkWorkers === undefined)
+        return inertWorkerRegistry(inert);
+    const configs = parseSDKWorkers(sdkWorkers, inert.map(w => w.id));
+    const bindings = sourceWorkerBindings(backend);
+    const registry = {
+        registrySchema: 2, productionAvailability: "unavailable",
+        inert: inert.map(({ id, digest }) => ({ id, digest })).sort((a, b) => asciiCompare(a.id, b.id)),
+        sdk: Object.entries(configs).map(([workerId, c]) => ({
+            registrySchema: 2, workerId, workerRevision: c.workerRevision, kind: c.kind,
+            ...bindings, actions: c.actions, modes: c.modes, checkpoints: [...checkpoints], limits: c.limits,
+        })),
+    };
+    const raw = JSON.stringify(registry);
+    decodeSDKRegistry(raw);
+    return raw;
+}
+/** Structural/artifact inspection only; the compiled Go consumer checks source bindings. */
+export function decodeSDKRegistry(raw) {
+    const r = object(strictJSON(raw, WORKER_CONTRACT.maxArtifactBytes), ["registrySchema", "productionAvailability", "inert", "sdk"]);
+    if (r.registrySchema !== 2 || r.productionAvailability !== "unavailable")
+        fail("incompatible");
+    if (!Array.isArray(r.inert) || !Array.isArray(r.sdk) || !r.sdk.length || r.inert.length + r.sdk.length > WORKER_CONTRACT.maxWorkers)
+        return fail();
+    const ids = new Set();
+    let previous = "";
+    const id = (value) => {
+        if (typeof value !== "string" || !idPattern.test(value) || value <= previous || ids.has(value))
+            return fail();
+        previous = value;
+        ids.add(value);
+        return value;
+    };
+    const inert = r.inert.map(value => {
+        const w = object(value, ["id", "digest"]);
+        return { id: id(w.id), digest: digest(w.digest) };
+    });
+    previous = "";
+    const sdk = r.sdk.map(value => {
+        const w = object(value, ["registrySchema", "workerId", "workerRevision", "kind", "handlerBinding", "inputSchemaDigest", "outputSchemaDigest", "actions", "modes", "checkpoints", "limits"]);
+        if (w.registrySchema !== 2 || w.kind !== "sdk-read-plan")
+            fail("incompatible");
+        if (JSON.stringify(w.checkpoints) !== JSON.stringify(checkpoints))
+            fail();
+        return {
+            registrySchema: 2, workerId: id(w.workerId), workerRevision: bounded(w.workerRevision, Number.MAX_SAFE_INTEGER), kind: "sdk-read-plan",
+            handlerBinding: digest(w.handlerBinding), inputSchemaDigest: digest(w.inputSchemaDigest), outputSchemaDigest: digest(w.outputSchemaDigest),
+            actions: subset(w.actions, actions), modes: subset(w.modes, modes), checkpoints: [...checkpoints], limits: limits(w.limits, false),
+        };
+    });
+    const result = { registrySchema: 2, productionAvailability: "unavailable", inert, sdk };
+    // One byte representation is compiled and approved; no aliases or reordering.
+    if (JSON.stringify(result) !== (typeof raw === "string" ? raw : Buffer.from(raw).toString("utf8")))
+        fail();
+    return result;
+}
+const safeReasons = ["invalid-request", "incompatible", "unsupported", "replay", "stale", "expired", "denied", "unavailable", "suspended", "revoked", "fenced", "busy", "limit-exceeded", "canceled", "timeout", "partial", "commit-uncertain", "cleanup-required", "internal"];
+export function decodeWorkerResult(raw) {
+    const r = object(strictJSON(raw, WORKER_CONTRACT.maxProgressBytes), ["resultSchema", "completedSteps", "entries", "bytesRead"], ["safeReason"]);
+    if (r.resultSchema !== 1)
+        fail("incompatible");
+    const result = {
+        resultSchema: 1, completedSteps: bounded(r.completedSteps, 16, 0),
+        entries: bounded(r.entries, 3200, 0), bytesRead: bounded(r.bytesRead, 67108864, 0),
+    };
+    if (Object.hasOwn(r, "safeReason")) {
+        if (!safeReasons.includes(r.safeReason))
+            fail();
+        result.safeReason = r.safeReason;
+    }
+    return result;
+}

package/dist/template-paths.d.ts

@@ -0,0 +1,2 @@
+/** Both source execution and the published CLI resolve the same bundled templates. */
+export declare function templatesRoot(): string;

package/dist/template-paths.js

@@ -0,0 +1,9 @@
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+/** Both source execution and the published CLI resolve the same bundled templates. */
+export function templatesRoot() {
+    const moduleDir = dirname(fileURLToPath(import.meta.url));
+    const distTemplates = join(moduleDir, "templates");
+    return existsSync(distTemplates) ? distTemplates : join(moduleDir, "..", "templates");
+}

package/dist/templates/_daemon/fixture_linux_test.go

@@ -0,0 +1,15 @@
+//go:build linux
+
+package main
+
+import (
+	"os"
+	"os/exec"
+	"syscall"
+)
+
+func dropFixtureUser(cmd *exec.Cmd) {
+	if os.Geteuid() == 0 {
+		cmd.SysProcAttr = &syscall.SysProcAttr{Credential: &syscall.Credential{Uid: 65534, Gid: 65534, Groups: []uint32{65534}}}
+	}
+}

package/dist/templates/_daemon/fixture_other_test.go

@@ -0,0 +1,7 @@
+//go:build !linux
+
+package main
+
+import "os/exec"
+
+func dropFixtureUser(cmd *exec.Cmd) {}

package/dist/templates/_daemon/go.mod

@@ -0,0 +1,5 @@
+module synopkgland-daemon
+
+go 1.24
+
+toolchain go1.26.8