@moondeck/station 0.0.0-stage → 1.0.0

package/images/standard/container/uai-task-forwarder.mjs

@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+
+/**
+ * Task-local authenticated stream forwarder (ADR-153).
+ *
+ * The generation secret is read as exactly 32 raw bytes from stdin, converted
+ * to a KeyObject, and never placed in argv, the environment, a file or a
+ * network frame. The runner proves each connection with a fresh nonce/HMAC.
+ */
+
+import { createHmac, createSecretKey } from "node:crypto";
+import { createConnection, createServer } from "node:net";
+import { pathToFileURL } from "node:url";
+
+const PREAMBLE_MAGIC = Buffer.from([
+  0x00, 0x55, 0x41, 0x49, 0x46, 0x57, 0x44, 0x01,
+]);
+const CHALLENGE_MAGIC = Buffer.from("UAICHL01", "ascii");
+const RESPONSE_MAGIC = Buffer.from("UAIRES01", "ascii");
+const ACCEPT_MAGIC = Buffer.from("UAIOK001", "ascii");
+const HMAC_DOMAIN = Buffer.from("uai-task-forwarder-v1\0", "ascii");
+const FIELD_SEPARATOR = Buffer.from([0]);
+
+const SECRET_BYTES = 32;
+const NONCE_BYTES = 32;
+const FORWARDER_UID = 65_532;
+const PREAUTH_TIMEOUT_MS = 3_000;
+const SECRET_INPUT_TIMEOUT_MS = 5_000;
+const MAX_PENDING_PREAUTH = 64;
+const MAX_TASK_ID_BYTES = 128;
+const MAX_GENERATION_BYTES = 64;
+
+function fail(message) {
+  throw new Error(message);
+}
+
+function parsePort(value, name) {
+  if (!/^\d+$/.test(value ?? "")) fail(`invalid ${name}`);
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed < 1 || parsed > 65_535) {
+    fail(`invalid ${name}`);
+  }
+  return parsed;
+}
+
+export function parseForwarderArgs(argv) {
+  const values = new Map();
+  for (let index = 0; index < argv.length; index += 2) {
+    const flag = argv[index];
+    const value = argv[index + 1];
+    if (!flag?.startsWith("--") || value === undefined || values.has(flag)) {
+      fail("invalid forwarder arguments");
+    }
+    values.set(flag, value);
+  }
+  const taskId = values.get("--task-id") ?? "";
+  const generation = values.get("--generation") ?? "";
+  const gatewayHost = values.get("--gateway-host") ?? "";
+  const allowed = new Set([
+    "--task-id",
+    "--generation",
+    "--gateway-host",
+    "--gateway-port",
+    "--listen-port",
+  ]);
+  if ([...values.keys()].some((key) => !allowed.has(key))) {
+    fail("invalid forwarder arguments");
+  }
+  if (
+    !/^[a-z0-9][a-z0-9_-]*$/.test(taskId) ||
+    Buffer.byteLength(taskId) > MAX_TASK_ID_BYTES ||
+    !/^[A-Za-z0-9_-]{16,64}$/.test(generation) ||
+    Buffer.byteLength(generation) > MAX_GENERATION_BYTES ||
+    gatewayHost.length < 1 ||
+    gatewayHost.length > 255 ||
+    /[\0\s]/.test(gatewayHost)
+  ) {
+    fail("invalid forwarder arguments");
+  }
+  return {
+    taskId,
+    generation,
+    gatewayHost,
+    gatewayPort: parsePort(values.get("--gateway-port") ?? "5877", "gateway port"),
+    listenPort: parsePort(values.get("--listen-port") ?? "5877", "listen port"),
+  };
+}
+
+function encodePreamble(taskId, generation) {
+  const task = Buffer.from(taskId, "utf8");
+  const generationBytes = Buffer.from(generation, "ascii");
+  return Buffer.concat([
+    PREAMBLE_MAGIC,
+    Buffer.from([task.length, generationBytes.length]),
+    task,
+    generationBytes,
+  ]);
+}
+
+function responseMac(secret, taskId, generation, nonce) {
+  return createHmac("sha256", secret)
+    .update(HMAC_DOMAIN)
+    .update(taskId, "utf8")
+    .update(FIELD_SEPARATOR)
+    .update(generation, "ascii")
+    .update(FIELD_SEPARATOR)
+    .update(nonce)
+    .digest();
+}
+
+async function readExact(socket, length, timeoutMs) {
+  return await new Promise((resolve, reject) => {
+    const chunks = [];
+    let received = 0;
+    let done = false;
+    const finish = (error, value) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      socket.pause();
+      socket.off("data", onData);
+      socket.off("error", onError);
+      socket.off("end", onEnd);
+      socket.off("close", onClose);
+      if (error) reject(error);
+      else resolve(value);
+    };
+    const onData = (chunk) => {
+      received += chunk.length;
+      if (received > length) {
+        finish(new Error("oversized forwarder handshake frame"));
+        return;
+      }
+      chunks.push(chunk);
+      if (received === length) finish(null, Buffer.concat(chunks, length));
+    };
+    const onError = () => finish(new Error("forwarder handshake socket error"));
+    const onEnd = () => finish(new Error("truncated forwarder handshake frame"));
+    const onClose = () => finish(new Error("forwarder handshake socket closed"));
+    const timer = setTimeout(
+      () => finish(new Error("forwarder handshake timed out")),
+      timeoutMs,
+    );
+    timer.unref();
+    socket.on("data", onData);
+    socket.once("error", onError);
+    socket.once("end", onEnd);
+    socket.once("close", onClose);
+    socket.resume();
+  });
+}
+
+async function readSecret(input) {
+  const chunks = [];
+  let size = 0;
+  const timeout = setTimeout(() => input.destroy(), SECRET_INPUT_TIMEOUT_MS);
+  timeout.unref();
+  try {
+    for await (const chunk of input) {
+      const bytes = Buffer.from(chunk);
+      size += bytes.length;
+      if (size > SECRET_BYTES) fail("invalid forwarder secret input");
+      chunks.push(bytes);
+    }
+  } finally {
+    clearTimeout(timeout);
+  }
+  if (size !== SECRET_BYTES) fail("invalid forwarder secret input");
+  return Buffer.concat(chunks, SECRET_BYTES);
+}
+
+export function createTaskForwarder(options, secret, dependencies = {}) {
+  const identityPreamble = encodePreamble(options.taskId, options.generation);
+  const connectUpstream = dependencies.createConnection ?? createConnection;
+  const activeSockets = new Set();
+  let pendingPreauth = 0;
+
+  const server = createServer({ pauseOnConnect: true }, (local) => {
+    activeSockets.add(local);
+    local.once("close", () => activeSockets.delete(local));
+    if (pendingPreauth >= MAX_PENDING_PREAUTH) {
+      local.destroy();
+      return;
+    }
+    pendingPreauth += 1;
+    const upstream = connectUpstream({
+      host: options.gatewayHost,
+      port: options.gatewayPort,
+    });
+    const preauthTimer = setTimeout(() => {
+      local.destroy();
+      upstream.destroy();
+    }, PREAUTH_TIMEOUT_MS);
+    preauthTimer.unref();
+    activeSockets.add(upstream);
+    upstream.setNoDelay(true);
+    upstream.once("close", () => activeSockets.delete(upstream));
+    local.once("error", () => upstream.destroy());
+    local.once("close", () => upstream.destroy());
+    upstream.once("error", () => local.destroy());
+
+    void (async () => {
+      try {
+        await new Promise((resolve, reject) => {
+          let settled = false;
+          const finish = (error) => {
+            if (settled) return;
+            settled = true;
+            upstream.off("connect", onConnect);
+            upstream.off("error", onError);
+            upstream.off("close", onClose);
+            if (error) reject(error);
+            else resolve();
+          };
+          const onConnect = () => finish(null);
+          const onError = () => finish(new Error("forwarder upstream failed"));
+          const onClose = () => finish(new Error("forwarder upstream closed"));
+          upstream.once("connect", onConnect);
+          upstream.once("error", onError);
+          upstream.once("close", onClose);
+          if (upstream.readyState === "open") finish(null);
+          else if (upstream.destroyed) onClose();
+        });
+        upstream.write(identityPreamble);
+        const challenge = await readExact(
+          upstream,
+          CHALLENGE_MAGIC.length + NONCE_BYTES,
+          PREAUTH_TIMEOUT_MS,
+        );
+        if (!challenge.subarray(0, CHALLENGE_MAGIC.length).equals(CHALLENGE_MAGIC)) {
+          fail("invalid forwarder challenge");
+        }
+        const nonce = challenge.subarray(CHALLENGE_MAGIC.length);
+        const mac = responseMac(
+          secret,
+          options.taskId,
+          options.generation,
+          nonce,
+        );
+        upstream.write(Buffer.concat([RESPONSE_MAGIC, mac]));
+        const accepted = await readExact(
+          upstream,
+          ACCEPT_MAGIC.length,
+          PREAUTH_TIMEOUT_MS,
+        );
+        if (!accepted.equals(ACCEPT_MAGIC)) fail("forwarder authentication refused");
+        local.pipe(upstream);
+        upstream.pipe(local);
+        local.resume();
+        upstream.resume();
+      } catch {
+        local.destroy();
+        upstream.destroy();
+      } finally {
+        clearTimeout(preauthTimer);
+        pendingPreauth -= 1;
+      }
+    })();
+  });
+
+  server.shutdown = () => {
+    for (const socket of activeSockets) socket.destroy();
+    activeSockets.clear();
+    server.close();
+  };
+  return server;
+}
+
+async function main() {
+  // The launcher additionally applies no_new_privs and clears capabilities.
+  // Refuse a wiring regression that runs this secret holder as root or node.
+  if (
+    process.getuid?.() !== FORWARDER_UID ||
+    process.getgid?.() !== FORWARDER_UID
+  ) {
+    fail(`task forwarder must run as uid/gid ${FORWARDER_UID}`);
+  }
+  const options = parseForwarderArgs(process.argv.slice(2));
+  const rawSecret = await readSecret(process.stdin);
+  const secret = createSecretKey(rawSecret);
+  rawSecret.fill(0);
+  const server = createTaskForwarder(options, secret);
+  server.once("error", () => {
+    process.stderr.write("uai task forwarder could not start\n");
+    process.exitCode = 1;
+  });
+  server.listen(options.listenPort, "127.0.0.1", () => {
+    process.stdout.write("READY\n");
+  });
+  const stop = () => server.shutdown();
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+}
+
+if (
+  process.argv[1] &&
+  import.meta.url === pathToFileURL(process.argv[1]).href
+) {
+  main().catch(() => {
+    process.stderr.write("uai task forwarder failed\n");
+    process.exitCode = 1;
+  });
+}

package/images/standard/tool-versions

@@ -0,0 +1,2 @@
+nodejs 22.11.0
+python 3.12.4

package/lib/__fixtures__/skill-index/SKILL.md

@@ -0,0 +1,10 @@
+# Dana (designer) — skills
+
+An index of the reference material prepared for you. Each document is its own
+file in `skills/` beside this one. Before work a skill covers, read its
+file in full, for example with `cat`.
+
+- **Brand voice** — covers: How we sound in product copy and marketing. → `skills/brand-voice.md`
+- **Design tokens** — covers: The colour, type and spacing scales every screen uses. → `skills/design-tokens.md`
+- **Accessibility checklist** — covers: Check every screen against these before calling it done. → `skills/accessibility-checklist.md`
+- **Figma library**: Link: https://figma.example.test/library

package/lib/__fixtures__/skill-index/skills/accessibility-checklist.md

@@ -0,0 +1,7 @@
+# Accessibility checklist
+
+**Check every screen** against these before calling it done.
+
+1. Every control is reachable by keyboard, in a sensible order.
+2. Text contrast is at least 4.5:1.
+3. Focus is visible.

package/lib/__fixtures__/skill-index/skills/brand-voice.md

@@ -0,0 +1,9 @@
+# Brand voice
+
+How we sound in product copy and marketing. Plain, warm and specific.
+
+## Rules of thumb
+
+- Say what the person gets, then how.
+- One idea per sentence. Cut adverbs.
+- Never blame the person in an error message.

package/lib/__fixtures__/skill-index/skills/design-tokens.md

@@ -0,0 +1,9 @@
+# Design tokens
+
+The colour, type and spacing scales every screen uses. Read them before choosing a value by eye.
+
+| Token | Value |
+| --- | --- |
+| `space-2` | 8px |
+| `space-4` | 16px |
+| `radius-md` | 8px |