settld 0.1.0

package/conformance/v1/expected/security_bundle_symlink_outside.json

@@ -0,0 +1,9 @@
+{
+  "schemaVersion": "ConformanceExpected.v1",
+  "exitCode": 1,
+  "ok": false,
+  "verificationOk": false,
+  "errorCodes": ["MANIFEST_SYMLINK_FORBIDDEN"],
+  "warningCodes": []
+}
+

package/conformance/v1/expected/security_manifest_case_collision.json

@@ -0,0 +1,8 @@
+{
+  "schemaVersion": "ConformanceExpected.v1",
+  "exitCode": 1,
+  "ok": false,
+  "verificationOk": false,
+  "errorCodes": ["MANIFEST_PATH_CASE_COLLISION"],
+  "warningCodes": []
+}

package/conformance/v1/expected/security_manifest_duplicate_paths.json

@@ -0,0 +1,9 @@
+{
+  "schemaVersion": "ConformanceExpected.v1",
+  "exitCode": 1,
+  "ok": false,
+  "verificationOk": false,
+  "errorCodes": ["MANIFEST_DUPLICATE_PATH"],
+  "warningCodes": []
+}
+

package/conformance/v1/expected/security_manifest_path_traversal.json

@@ -0,0 +1,9 @@
+{
+  "schemaVersion": "ConformanceExpected.v1",
+  "exitCode": 1,
+  "ok": false,
+  "verificationOk": false,
+  "errorCodes": ["MANIFEST_PATH_INVALID"],
+  "warningCodes": []
+}
+

package/conformance/v1/lib/harness.mjs

@@ -0,0 +1,78 @@
+import fs from "node:fs/promises";
+import { spawn } from "node:child_process";
+
+export function stableStringSet(list) {
+  const s = new Set();
+  for (const v of Array.isArray(list) ? list : []) {
+    if (typeof v === "string" && v.trim()) s.add(v);
+  }
+  return [...s].sort();
+}
+
+export function codesFromCliOutput(cliJson, key) {
+  const list = Array.isArray(cliJson?.[key]) ? cliJson[key] : [];
+  const codes = [];
+  for (const item of list) {
+    if (!item || typeof item !== "object") continue;
+    if (typeof item.code === "string" && item.code.trim()) codes.push(item.code.trim());
+  }
+  return stableStringSet(codes);
+}
+
+export async function readJsonFile(fp) {
+  const raw = await fs.readFile(fp, "utf8");
+  return JSON.parse(raw);
+}
+
+export async function writeJsonFile(fp, json) {
+  const text = JSON.stringify(json, null, 0) + "\n";
+  await fs.writeFile(fp, text, "utf8");
+}
+
+export function diffSets({ expected, actual }) {
+  const exp = stableStringSet(expected);
+  const act = stableStringSet(actual);
+  const expSet = new Set(exp);
+  const actSet = new Set(act);
+  const missing = exp.filter((c) => !actSet.has(c));
+  const extra = act.filter((c) => !expSet.has(c));
+  return { expected: exp, actual: act, missing, extra, equal: missing.length === 0 && extra.length === 0 };
+}
+
+export async function spawnCapture({ cmd, args = [], cwd, env, stdinText = null, timeoutMs = 60_000, maxStdoutBytes = 2 * 1024 * 1024, maxStderrBytes = 2 * 1024 * 1024 } = {}) {
+  const child = spawn(cmd, args, { cwd, env, stdio: ["pipe", "pipe", "pipe"] });
+  const stdoutChunks = [];
+  const stderrChunks = [];
+  let stdoutBytes = 0;
+  let stderrBytes = 0;
+
+  child.stdout.on("data", (d) => {
+    stdoutBytes += d.length;
+    if (stdoutBytes <= maxStdoutBytes) stdoutChunks.push(d);
+  });
+  child.stderr.on("data", (d) => {
+    stderrBytes += d.length;
+    if (stderrBytes <= maxStderrBytes) stderrChunks.push(d);
+  });
+
+  const timeout = setTimeout(() => {
+    try {
+      child.kill("SIGKILL");
+    } catch {
+      // ignore
+    }
+  }, timeoutMs);
+
+  if (typeof stdinText === "string") child.stdin.end(stdinText);
+  else child.stdin.end();
+
+  const exitCode = await new Promise((resolve, reject) => {
+    child.on("error", reject);
+    child.on("close", (code) => resolve(code ?? 1));
+  }).finally(() => clearTimeout(timeout));
+
+  const stdout = Buffer.concat(stdoutChunks).toString("utf8");
+  const stderr = Buffer.concat(stderrChunks).toString("utf8");
+  return { exitCode, stdout, stderr };
+}
+

package/conformance/v1/lib/mutations.mjs

@@ -0,0 +1,61 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import { readJsonFile, writeJsonFile } from "./harness.mjs";
+
+export async function applyMutations({ bundleDir, tmpRoot, mutations, allowSkip }) {
+  for (const m of Array.isArray(mutations) ? mutations : []) {
+    if (!m || typeof m !== "object") throw new Error("mutation must be an object");
+    if (m.type === "manifest_add_entry") {
+      const manifestPath = path.join(bundleDir, "manifest.json");
+      const manifest = await readJsonFile(manifestPath);
+      if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) throw new Error("manifest.json must be an object");
+      if (!Array.isArray(manifest.files)) throw new Error("manifest.json missing files[]");
+      if (!m.entry || typeof m.entry !== "object" || Array.isArray(m.entry)) throw new Error("manifest_add_entry requires entry object");
+      manifest.files.push(m.entry);
+      await writeJsonFile(manifestPath, manifest);
+      continue;
+    }
+    if (m.type === "manifest_duplicate_entry") {
+      const name = String(m.name ?? "");
+      if (!name) throw new Error("manifest_duplicate_entry requires name");
+      const manifestPath = path.join(bundleDir, "manifest.json");
+      const manifest = await readJsonFile(manifestPath);
+      if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) throw new Error("manifest.json must be an object");
+      if (!Array.isArray(manifest.files)) throw new Error("manifest.json missing files[]");
+      const found = manifest.files.find((f) => f && typeof f === "object" && !Array.isArray(f) && f.name === name);
+      if (!found) throw new Error(`manifest_duplicate_entry: no existing entry named ${name}`);
+      manifest.files.push({ ...found });
+      await writeJsonFile(manifestPath, manifest);
+      continue;
+    }
+    if (m.type === "write_outside_file") {
+      const rel = String(m.relativeOutsidePath ?? "");
+      if (!rel || rel.includes(path.sep) || rel.includes("/")) throw new Error("write_outside_file.relativeOutsidePath must be a single filename");
+      const outsidePath = path.join(tmpRoot, rel);
+      await fs.writeFile(outsidePath, String(m.contents ?? ""), "utf8");
+      continue;
+    }
+    if (m.type === "replace_with_symlink") {
+      const name = String(m.name ?? "");
+      const targetRelative = String(m.targetRelative ?? "");
+      if (!name || !targetRelative) throw new Error("replace_with_symlink requires name and targetRelative");
+      const filePath = path.join(bundleDir, ...name.split("/"));
+      await fs.rm(filePath, { force: true });
+      await fs.mkdir(path.dirname(filePath), { recursive: true });
+      try {
+        await fs.symlink(targetRelative, filePath);
+      } catch (err) {
+        const code = err?.code ?? null;
+        if (allowSkip && (code === "EPERM" || code === "EACCES")) {
+          return { skipped: true, reason: `symlink not permitted (${code})` };
+        }
+        throw err;
+      }
+      continue;
+    }
+    throw new Error(`unknown mutation type: ${m.type}`);
+  }
+  return { skipped: false };
+}
+

package/conformance/v1/produce-cases.json

@@ -0,0 +1,75 @@
+{
+  "schemaVersion": "ProduceConformanceCases.v1",
+  "cases": [
+    {
+      "id": "produce_jobproof_remote_auth_missing",
+      "description": "Producer fail: remote signer auth missing (no token)",
+      "scenario": "remote_auth_missing",
+      "expected": { "exitCode": 1, "errors": ["SIGNER_AUTH_MISSING"], "warnings": [], "verifyOk": false },
+      "invariantIds": ["PROD-001", "PROD-002"]
+    },
+    {
+      "id": "produce_jobproof_remote_command_bad_json",
+      "description": "Producer fail: remote signer command returns invalid JSON",
+      "scenario": "remote_command_bad_json",
+      "expected": { "exitCode": 1, "errors": ["SIGNER_BAD_RESPONSE"], "warnings": [], "verifyOk": false },
+      "invariantIds": ["PROD-001", "PROD-003"]
+    },
+    {
+      "id": "produce_jobproof_remote_command_stderr_only_exit1",
+      "description": "Producer fail: remote signer command writes to stderr only and exits nonzero",
+      "scenario": "remote_command_stderr_only_exit1",
+      "expected": { "exitCode": 1, "errors": ["SIGNER_BAD_RESPONSE"], "warnings": [], "verifyOk": false },
+      "invariantIds": ["PROD-001", "PROD-003"]
+    },
+    {
+      "id": "produce_jobproof_remote_command_partial_stdout_exit1",
+      "description": "Producer fail: remote signer command writes partial stdout and exits nonzero",
+      "scenario": "remote_command_partial_stdout_exit1",
+      "expected": { "exitCode": 1, "errors": ["SIGNER_BAD_RESPONSE"], "warnings": [], "verifyOk": false },
+      "invariantIds": ["PROD-001", "PROD-003"]
+    },
+    {
+      "id": "produce_jobproof_plugin_load_failed",
+      "description": "Producer fail: plugin module cannot be loaded",
+      "scenario": "plugin_load_failed",
+      "expected": { "exitCode": 1, "errors": ["SIGNER_PLUGIN_LOAD_FAILED"], "warnings": [], "verifyOk": false },
+      "invariantIds": ["PROD-001", "PROD-004"]
+    },
+    {
+      "id": "produce_jobproof_plugin_missing_export",
+      "description": "Producer fail: plugin missing expected export",
+      "scenario": "plugin_missing_export",
+      "expected": { "exitCode": 1, "errors": ["SIGNER_PLUGIN_MISSING_EXPORT"], "warnings": [], "verifyOk": false },
+      "invariantIds": ["PROD-001", "PROD-004"]
+    },
+    {
+      "id": "produce_jobproof_plugin_invalid_provider",
+      "description": "Producer fail: plugin export returns an invalid provider",
+      "scenario": "plugin_invalid_provider",
+      "expected": { "exitCode": 1, "errors": ["SIGNER_PLUGIN_INVALID_PROVIDER"], "warnings": [], "verifyOk": false },
+      "invariantIds": ["PROD-001", "PROD-004"]
+    },
+    {
+      "id": "produce_jobproof_plugin_success_strict_verify",
+      "description": "Producer pass: plugin signer produces JobProof that strict-verify passes",
+      "scenario": "plugin_success",
+      "expected": { "exitCode": 0, "errors": [], "warnings": [], "verifyOk": true },
+      "invariantIds": ["PROD-001", "PROD-005"]
+    },
+    {
+      "id": "produce_jobproof_remote_process_success_strict_verify",
+      "description": "Producer pass: remote signer (process/stdio) produces JobProof that strict-verify passes",
+      "scenario": "remote_process_success",
+      "expected": { "exitCode": 0, "errors": [], "warnings": [], "verifyOk": true },
+      "invariantIds": ["PROD-001", "PROD-006"]
+    },
+    {
+      "id": "produce_trust_remote_only_init_then_remote_sign_strict_verify",
+      "description": "Producer pass: settld-trust init --mode remote-only produces a trust.json that strict-verifies a remote-signed JobProof",
+      "scenario": "trust_remote_only_init_remote_sign",
+      "expected": { "exitCode": 0, "errors": [], "warnings": [], "verifyOk": true },
+      "invariantIds": ["PROD-001", "PROD-008"]
+    }
+  ]
+}

package/conformance/v1/producer/bad-plugin-invalid-provider.mjs

@@ -0,0 +1,4 @@
+export async function createSignerProvider() {
+  return { notASigner: true };
+}
+

package/conformance/v1/producer/bad-plugin-no-export.mjs

@@ -0,0 +1,3 @@
+// Intentionally does not export createSignerProvider.
+export const noop = 1;
+

package/conformance/v1/producer/fixture_keypairs.json

@@ -0,0 +1,18 @@
+{
+  "govRoot": {
+    "keyId": "key_4bd1ee0813b265cb6670a1cc",
+    "publicKeyPem": "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAFzw7qxt31VJOSAJCw7zy267twYhbJzf9H0dwm3ZmCDM=\n-----END PUBLIC KEY-----\n",
+    "privateKeyPem": "-----BEGIN PRIVATE KEY-----\nMC4CAQAwBQYDK2VwBCIEIATJ5cPIVnqSgMVEsfkFlEoaLyRTG4PM5HWUeeyaJ4pJ\n-----END PRIVATE KEY-----\n"
+  },
+  "timeAuthority": {
+    "keyId": "key_0c6b00150d3433d8d612eef2",
+    "publicKeyPem": "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEA9CRBU82m4eS1uHNL6PtKBKPLN0YdtubYFP/f9flGVd0=\n-----END PUBLIC KEY-----\n",
+    "privateKeyPem": "-----BEGIN PRIVATE KEY-----\nMC4CAQAwBQYDK2VwBCIEIIP7NPqYQlQBA9+NK9h/MlzDY6BjU8NgZ42tJpUguxR3\n-----END PRIVATE KEY-----\n"
+  },
+  "serverA": {
+    "keyId": "key_9ed38005b42d9364601ffab3",
+    "publicKeyPem": "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAQ70D1FtwopWnvJeFsiKdThSP/9QADgSeaZYKip79KQI=\n-----END PUBLIC KEY-----\n",
+    "privateKeyPem": "-----BEGIN PRIVATE KEY-----\nMC4CAQAwBQYDK2VwBCIEILP0SvKxPshPvhk7qDsIZPZTTQiy3RG+aX9dOG9+VL3F\n-----END PRIVATE KEY-----\n"
+  }
+}
+

package/conformance/v1/producer/inmemory-signer-plugin.mjs

@@ -0,0 +1,47 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { sign as nodeSign } from "node:crypto";
+
+function assertNonEmptyString(v, name) {
+  if (typeof v !== "string" || v.trim() === "") throw new TypeError(`${name} must be a non-empty string`);
+}
+
+async function readJson(fp) {
+  const raw = await fs.readFile(fp, "utf8");
+  return JSON.parse(raw);
+}
+
+export async function createSignerProvider({ config } = {}) {
+  if (!config || typeof config !== "object") throw new TypeError("config is required");
+  assertNonEmptyString(config.keypairsPath, "config.keypairsPath");
+  const abs = path.resolve(process.cwd(), config.keypairsPath);
+  const keypairs = await readJson(abs);
+  const byKeyId = new Map();
+  for (const v of Object.values(keypairs ?? {})) {
+    const keyId = typeof v?.keyId === "string" ? v.keyId : null;
+    const publicKeyPem = typeof v?.publicKeyPem === "string" ? v.publicKeyPem : null;
+    const privateKeyPem = typeof v?.privateKeyPem === "string" ? v.privateKeyPem : null;
+    if (!keyId || !publicKeyPem || !privateKeyPem) continue;
+    byKeyId.set(keyId, { keyId, publicKeyPem, privateKeyPem });
+  }
+
+  return {
+    async getPublicKeyPem({ keyId }) {
+      assertNonEmptyString(keyId, "keyId");
+      const kp = byKeyId.get(keyId) ?? null;
+      if (!kp) throw new Error("unknown keyId");
+      return kp.publicKeyPem;
+    },
+    async sign({ keyId, algorithm, messageBytes }) {
+      assertNonEmptyString(keyId, "keyId");
+      assertNonEmptyString(algorithm, "algorithm");
+      if (!(messageBytes instanceof Uint8Array)) throw new TypeError("messageBytes must be a Uint8Array");
+      if (algorithm !== "ed25519") throw new Error("unsupported algorithm");
+      const kp = byKeyId.get(keyId) ?? null;
+      if (!kp) throw new Error("unknown keyId");
+      const sig = nodeSign(null, Buffer.from(messageBytes), kp.privateKeyPem).toString("base64");
+      return { signatureBase64: sig };
+    }
+  };
+}
+

package/conformance/v1/producer/signer-stdio-bad-json.mjs

@@ -0,0 +1,54 @@
+import fsSync from "node:fs";
+
+function writeStdout(text) {
+  fsSync.writeFileSync(1, Buffer.from(String(text ?? ""), "utf8"));
+}
+
+function writeStderr(text) {
+  fsSync.writeFileSync(2, Buffer.from(String(text ?? ""), "utf8"));
+}
+
+function usage() {
+  writeStderr("usage: signer-stdio-bad-json.mjs --stdio [--request-json-base64 <b64>]\n");
+  process.exit(2);
+}
+
+function parse(argv) {
+  let stdio = false;
+  let requestJsonBase64 = null;
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i];
+    if (a === "--stdio") {
+      stdio = true;
+      continue;
+    }
+    if (a === "--request-json-base64") {
+      requestJsonBase64 = argv[i + 1] ?? null;
+      if (!requestJsonBase64) usage();
+      i += 1;
+      continue;
+    }
+    if (a === "--help" || a === "-h") usage();
+    usage();
+  }
+  if (!stdio) usage();
+  return { requestJsonBase64 };
+}
+
+async function main() {
+  const { requestJsonBase64 } = parse(process.argv.slice(2));
+
+  // This stub is specifically designed to exercise argv/base64 fallback paths.
+  // If no argv request is provided, fail with "unknown op" so the caller can fall back.
+  if (!requestJsonBase64) {
+    process.exitCode = 1;
+    writeStderr("unknown op\n");
+    return;
+  }
+
+  // Ignore request contents and emit invalid JSON with exit 0.
+  writeStdout("not json\n");
+}
+
+await main();
+

package/conformance/v1/producer/signer-stdio-partial-stdout-exit1.mjs

@@ -0,0 +1,51 @@
+import fsSync from "node:fs";
+
+function writeStdout(text) {
+  fsSync.writeFileSync(1, Buffer.from(String(text ?? ""), "utf8"));
+}
+
+function writeStderr(text) {
+  fsSync.writeFileSync(2, Buffer.from(String(text ?? ""), "utf8"));
+}
+
+function usage() {
+  writeStderr("usage: signer-stdio-partial-stdout-exit1.mjs --stdio [--request-json-base64 <b64>]\n");
+  process.exit(2);
+}
+
+function parse(argv) {
+  let stdio = false;
+  let requestJsonBase64 = null;
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i];
+    if (a === "--stdio") {
+      stdio = true;
+      continue;
+    }
+    if (a === "--request-json-base64") {
+      requestJsonBase64 = argv[i + 1] ?? null;
+      if (!requestJsonBase64) usage();
+      i += 1;
+      continue;
+    }
+    if (a === "--help" || a === "-h") usage();
+    usage();
+  }
+  if (!stdio) usage();
+  return { requestJsonBase64 };
+}
+
+async function main() {
+  const { requestJsonBase64 } = parse(process.argv.slice(2));
+  if (!requestJsonBase64) {
+    process.exitCode = 1;
+    writeStderr("unknown op\n");
+    return;
+  }
+  writeStdout("{\"schemaVersion\":");
+  process.exitCode = 1;
+  writeStderr("simulated failure\n");
+}
+
+await main();
+

package/conformance/v1/producer/signer-stdio-stderr-only-exit1.mjs

@@ -0,0 +1,46 @@
+import fsSync from "node:fs";
+
+function writeStderr(text) {
+  fsSync.writeFileSync(2, Buffer.from(String(text ?? ""), "utf8"));
+}
+
+function usage() {
+  writeStderr("usage: signer-stdio-stderr-only-exit1.mjs --stdio [--request-json-base64 <b64>]\n");
+  process.exit(2);
+}
+
+function parse(argv) {
+  let stdio = false;
+  let requestJsonBase64 = null;
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i];
+    if (a === "--stdio") {
+      stdio = true;
+      continue;
+    }
+    if (a === "--request-json-base64") {
+      requestJsonBase64 = argv[i + 1] ?? null;
+      if (!requestJsonBase64) usage();
+      i += 1;
+      continue;
+    }
+    if (a === "--help" || a === "-h") usage();
+    usage();
+  }
+  if (!stdio) usage();
+  return { requestJsonBase64 };
+}
+
+async function main() {
+  const { requestJsonBase64 } = parse(process.argv.slice(2));
+  if (!requestJsonBase64) {
+    process.exitCode = 1;
+    writeStderr("unknown op\n");
+    return;
+  }
+  process.exitCode = 1;
+  writeStderr("simulated failure\n");
+}
+
+await main();
+

package/conformance/v1/producer/signer-stdio-stub.mjs

@@ -0,0 +1,134 @@
+import fs from "node:fs/promises";
+import fsSync from "node:fs";
+import path from "node:path";
+import { sign as nodeSign } from "node:crypto";
+
+function writeStdout(text) {
+  fsSync.writeFileSync(1, Buffer.from(String(text ?? ""), "utf8"));
+}
+
+function writeStderr(text) {
+  fsSync.writeFileSync(2, Buffer.from(String(text ?? ""), "utf8"));
+}
+
+function usage() {
+  writeStderr("usage: signer-stdio-stub.mjs --stdio --keys <keypairs.json> [--request-json-base64 <b64>]\n");
+  process.exit(2);
+}
+
+function parse(argv) {
+  let keysPath = null;
+  let stdio = false;
+  let requestJsonBase64 = null;
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i];
+    if (a === "--keys") {
+      keysPath = argv[i + 1] ?? null;
+      if (!keysPath) usage();
+      i += 1;
+      continue;
+    }
+    if (a === "--stdio") {
+      stdio = true;
+      continue;
+    }
+    if (a === "--request-json-base64") {
+      requestJsonBase64 = argv[i + 1] ?? null;
+      if (!requestJsonBase64) usage();
+      i += 1;
+      continue;
+    }
+    if (a === "--help" || a === "-h") usage();
+    usage();
+  }
+  if (!keysPath || !stdio) usage();
+  return { keysPath, requestJsonBase64 };
+}
+
+async function readAllStdin() {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    process.stdin.on("data", (c) => chunks.push(c));
+    process.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    process.stdin.on("error", reject);
+  });
+}
+
+async function loadKeypairs(keysPath) {
+  const abs = path.resolve(process.cwd(), keysPath);
+  const json = JSON.parse(await fs.readFile(abs, "utf8"));
+  const byKeyId = new Map();
+  for (const v of Object.values(json ?? {})) {
+    if (!v?.keyId || !v?.publicKeyPem || !v?.privateKeyPem) continue;
+    byKeyId.set(v.keyId, v);
+  }
+  return byKeyId;
+}
+
+function isBase64(s) {
+  return typeof s === "string" && /^[A-Za-z0-9+/=]+$/.test(s);
+}
+
+async function main() {
+  const { keysPath, requestJsonBase64 } = parse(process.argv.slice(2));
+  const byKeyId = await loadKeypairs(keysPath);
+
+  const raw = requestJsonBase64 ? Buffer.from(String(requestJsonBase64), "base64").toString("utf8") : await readAllStdin();
+  const req = JSON.parse(raw || "null");
+  const op = typeof req?.op === "string" ? req.op : null;
+
+  if (op === "publicKey") {
+    const keyId = typeof req?.keyId === "string" ? req.keyId : null;
+    if (!keyId) {
+      process.exitCode = 1;
+      writeStderr("missing keyId\n");
+      return;
+    }
+    const kp = byKeyId.get(keyId) ?? null;
+    if (!kp) {
+      process.exitCode = 1;
+      writeStderr("unknown keyId\n");
+      return;
+    }
+    writeStdout(JSON.stringify({ schemaVersion: "RemoteSignerPublicKeyResponse.v1", keyId, algorithm: "ed25519", publicKeyPem: kp.publicKeyPem }) + "\n");
+    return;
+  }
+
+  if (op === "sign") {
+    const body = req?.body ?? null;
+    const keyId = typeof body?.keyId === "string" ? body.keyId : null;
+    const algorithm = typeof body?.algorithm === "string" ? body.algorithm : null;
+    const messageBase64 = typeof body?.messageBase64 === "string" ? body.messageBase64 : null;
+    const requestId = typeof body?.requestId === "string" ? body.requestId : null;
+    if (!keyId || !algorithm || !messageBase64) {
+      process.exitCode = 1;
+      writeStderr("missing required fields\n");
+      return;
+    }
+    if (algorithm !== "ed25519") {
+      process.exitCode = 1;
+      writeStderr("unsupported algorithm\n");
+      return;
+    }
+    if (!isBase64(messageBase64)) {
+      process.exitCode = 1;
+      writeStderr("invalid messageBase64\n");
+      return;
+    }
+    const kp = byKeyId.get(keyId) ?? null;
+    if (!kp) {
+      process.exitCode = 1;
+      writeStderr("unknown keyId\n");
+      return;
+    }
+    const msg = Buffer.from(messageBase64, "base64");
+    const sig = nodeSign(null, msg, kp.privateKeyPem).toString("base64");
+    writeStdout(JSON.stringify({ schemaVersion: "RemoteSignerSignResponse.v1", requestId, keyId, algorithm, signatureBase64: sig }) + "\n");
+    return;
+  }
+
+  process.exitCode = 1;
+  writeStderr("unknown op\n");
+}
+
+await main();