@rallycry/conveyor-k3 0.1.10 → 0.1.11

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { PersonalClusterEnrollmentBundle, PersonalClusterEnrollmentCompletion, PersonalClusterDesiredState, PersonalClusterHeartbeat, PersonalClusterKubeletState } from '@project/shared';
+import { PersonalClusterEnrollmentBundle, PersonalClusterEnrollmentCompletion, PersonalClusterDesiredState, PersonalClusterHeartbeat, PersonalClusterWorkloads, PersonalClusterKubeletState } from '@project/shared';
 
 interface ClusterConnectionConfig {
     apiUrl: string;
@@ -19,8 +19,8 @@ declare class ClusterConnection {
     enroll(): Promise<PersonalClusterEnrollmentBundle>;
     completeEnrollment(payload: PersonalClusterEnrollmentCompletion): Promise<void>;
     requestDesiredState(): Promise<PersonalClusterDesiredState>;
-    /** Fire-and-forget: a lost heartbeat is covered by the next one. */
-    sendHeartbeat(payload: PersonalClusterHeartbeat): void;
+    /** Old servers still receive liveness even when they do not acknowledge inspection data. */
+    sendHeartbeat(payload: PersonalClusterHeartbeat): Promise<PersonalClusterWorkloads | undefined>;
     /**
      * Tell Conveyor this machine is stopping, so placement skips it at once
      * instead of waiting out the stale window.
@@ -83,6 +83,7 @@ interface DaemonPorts {
     fs: FileSystemPort$1;
     connection: ClusterConnection;
     cliVersion: string;
+    writeWorkloads?: (data: PersonalClusterWorkloads | undefined) => Promise<void>;
     log: (line: string) => void;
 }
 declare class ClusterDaemon {
@@ -150,7 +151,11 @@ declare class ClusterDaemon {
     private strandedBytesExceedLimit;
     prune(): Promise<void>;
     private buildHeartbeat;
+    private persistWorkloads;
+    private beating?;
+    private stopped;
     beat(): Promise<void>;
+    private runBeat;
 }
 
 /**
@@ -710,6 +715,7 @@ interface GuestSrvRecord {
     weight: number;
 }
 interface ResolvedNetwork {
+    publicWeb?: boolean;
     hosts: ResolvedNetworkHost[];
     /** Static SRV answers needed by cloudflared's documented edge discovery. */
     srv: GuestSrvRecord[];

package/dist/index.js

@@ -4109,12 +4109,12 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// ../shared/dist/chunk-3D2OVVIS.js
-var DEFAULT_SONNET_MODEL = "claude-sonnet-5";
+// ../shared/dist/chunk-PVMC53P5.js
+var DEFAULT_SONNET_MODEL = "claude-sonnet-5-5";
 var DEFAULT_OPUS_MODEL = "claude-opus-5-5";
 var DEFAULT_HAIKU_MODEL = "claude-haiku-4-5-20251001";
 var FABLE_MODEL = "claude-fable-5-1";
-var PREVIOUS_SONNET_MODEL = "claude-sonnet-4-6";
+var PREVIOUS_SONNET_MODEL = "claude-sonnet-5";
 var PREVIOUS_OPUS_MODEL = "claude-opus-5";
 function formatModelId(provider, model) {
   return `${provider}/${model}`;
@@ -6175,8 +6175,8 @@ function anthropicEntry(model, label, inputPerMillion, outputPerMillion, opts =
 var ANTHROPIC_CATALOG = [
   anthropicEntry(DEFAULT_OPUS_MODEL, "Opus 5.5 Latest", 4, 20),
   anthropicEntry(PREVIOUS_OPUS_MODEL, "Opus 5", 5, 25),
-  anthropicEntry(DEFAULT_SONNET_MODEL, "Sonnet 5 Latest", 3, 15),
-  anthropicEntry(PREVIOUS_SONNET_MODEL, "Sonnet 4.6", 3, 15),
+  anthropicEntry(DEFAULT_SONNET_MODEL, "Sonnet 5.5 Latest", 2, 10),
+  anthropicEntry(PREVIOUS_SONNET_MODEL, "Sonnet 5", 2, 10),
   // The Haiku line (4.5 and older) predates the tuning surface and 400s on it.
   anthropicEntry(DEFAULT_HAIKU_MODEL, "Haiku 4.5", 1, 5, { supportsEffort: false }),
   anthropicEntry(FABLE_MODEL, "Fable 5.1", 10, 50)
@@ -6611,9 +6611,16 @@ var ClusterConnection = class {
     const ack = await this.require().timeout(3e4).emitWithAck(PERSONAL_CLUSTER_EVENTS.requestDesiredState, {});
     return unwrap(ack, "Fetching settings");
   }
-  /** Fire-and-forget: a lost heartbeat is covered by the next one. */
-  sendHeartbeat(payload) {
-    this.socket?.emit(PERSONAL_CLUSTER_EVENTS.heartbeat, payload);
+  /** Old servers still receive liveness even when they do not acknowledge inspection data. */
+  async sendHeartbeat(payload) {
+    if (!this.socket?.connected) return void 0;
+    try {
+      const ack = await this.socket.timeout(8e3).emitWithAck(PERSONAL_CLUSTER_EVENTS.heartbeat, payload);
+      if (!this.socket?.connected) return void 0;
+      return unwrap(ack, "Reading pod assignments");
+    } catch {
+      return void 0;
+    }
   }
   /**
    * Tell Conveyor this machine is stopping, so placement skips it at once
@@ -7398,6 +7405,7 @@ async function collectHeartbeat(ports, state, inventory) {
   const runnerUsers = await detectRunnerUsers(ports.exec);
   const ungranted = ungrantedRunnerUsers(runnerUsers, await ports.readFile(RUNNERS_SUDOERS_FILE));
   return {
+    publicWebProxy: (await ports.readFile("/etc/conveyor-vm/public-web"))?.trim() === "enabled",
     cliVersion: state.cliVersion,
     k3sVersion: await versionOf(ports.exec, "k3s", ["--version"]),
     cloudflaredVersion: await versionOf(ports.exec, "cloudflared", ["--version"]),
@@ -7420,6 +7428,31 @@ async function collectHeartbeat(ports, state, inventory) {
     ]
   };
 }
+async function readPodIdentities(exec) {
+  const result = await exec(
+    "k3s",
+    [
+      "kubectl",
+      "get",
+      "pods",
+      "-A",
+      "-l",
+      CONVEYOR_POD_SELECTOR,
+      "--request-timeout=5s",
+      "--no-headers",
+      "-o",
+      "custom-columns=NS:.metadata.namespace,NAME:.metadata.name,UID:.metadata.uid"
+    ],
+    { timeoutMs: 7e3, maxOutputBytes: 65536 }
+  );
+  if (result.exitCode !== 0) return [];
+  const rows = result.stdout.trim().split("\n").filter(Boolean);
+  if (rows.length > 100) return [];
+  return rows.flatMap((row) => {
+    const [namespace, name, uid, extra] = row.trim().split(/\s+/);
+    return !extra && [namespace, name, uid].every((s) => s && /^[a-zA-Z0-9][a-zA-Z0-9.-]{0,252}$/.test(s)) ? [{ namespace, name, uid }] : [];
+  });
+}
 
 // src/daemon/runner.ts
 var HOUR_MS = 60 * 6e4;
@@ -7489,10 +7522,13 @@ var ClusterDaemon = class {
     await this.beat();
   }
   async stop() {
+    this.stopped = true;
     for (const timer of this.timers) clearInterval(timer);
     this.timers = [];
     await this.ports.connection.sayGoodbye();
     this.ports.connection.disconnect();
+    await this.beating;
+    await this.persistWorkloads(void 0);
   }
   /** Fetch the desired state and converge to it. Queued, never concurrent. */
   syncAndReconcile() {
@@ -7654,10 +7690,33 @@ var ClusterDaemon = class {
       inventory
     );
   }
-  async beat() {
+  async persistWorkloads(data) {
     try {
-      this.ports.connection.sendHeartbeat(await this.buildHeartbeat());
+      await this.ports.writeWorkloads?.(data);
     } catch (error) {
+      this.ports.log(
+        `Pod context cache unavailable: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  beating;
+  stopped = false;
+  beat() {
+    if (this.stopped) return Promise.resolve();
+    this.beating ??= this.runBeat().finally(() => {
+      this.beating = void 0;
+    });
+    return this.beating;
+  }
+  async runBeat() {
+    try {
+      const workloads = await this.ports.connection.sendHeartbeat({
+        ...await this.buildHeartbeat(),
+        observedPods: await readPodIdentities(this.ports.exec).catch(() => [])
+      });
+      if (!this.stopped) await this.persistWorkloads(workloads);
+    } catch (error) {
+      await this.persistWorkloads(void 0);
       this.ports.log(`Heartbeat failed: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
@@ -8449,6 +8508,13 @@ while True:
                 udp.sendto(response, peer)
 `;
 
+// src/vm/public-web.ts
+import { resolve4 } from "dns/promises";
+import { networkInterfaces as networkInterfaces2 } from "os";
+var PUBLIC_WEB_IP = "192.168.5.250";
+var PUBLIC_WEB_PORT = 3128;
+var PUBLIC_WEB_URL = `http://${PUBLIC_WEB_IP}:${PUBLIC_WEB_PORT}`;
+
 // src/vm/qemu-policy.ts
 var ALLOWED_PROBES = new Set(
   [
@@ -8685,7 +8751,10 @@ function restrictedUsernet(network, forwards, ncPath) {
     "restrict=on",
     "ipv6=off",
     `hostfwd=tcp:127.0.0.1:${network.sshPort}-:22`,
-    ...guestForwards
+    ...guestForwards,
+    ...network.publicWeb === true ? [
+      `guestfwd=tcp:${PUBLIC_WEB_IP}:${PUBLIC_WEB_PORT}-cmd:${ncPath} -4 -n -w 60 public-web ${PUBLIC_WEB_PORT}`
+    ] : []
   ].join(",");
 }
 function validateForwards(forwards) {

package/dist/vm-qemu.js

@@ -7,6 +7,10 @@ import { dirname, join as join5 } from "path";
 import { fileURLToPath } from "url";
 import { createHash } from "crypto";
 
+// src/vm/public-web.ts
+import { resolve4 } from "dns/promises";
+import { networkInterfaces as networkInterfaces2 } from "os";
+
 // src/vm/network.ts
 import { networkInterfaces } from "os";
 import { resolve4 as systemResolve4, resolveSrv as systemResolveSrv } from "dns/promises";
@@ -50,6 +54,98 @@ function isGloballyRoutableIPv4(address) {
   ].some(([base, mask]) => inCidr(value, parseIPv4(base), mask));
 }
 
+// src/vm/public-web.ts
+var PUBLIC_WEB_IP = "192.168.5.250";
+var PUBLIC_WEB_PORT = 3128;
+var PUBLIC_WEB_URL = `http://${PUBLIC_WEB_IP}:${PUBLIC_WEB_PORT}`;
+async function publicWebAddress(host, lookup = resolve4, interfaces = networkInterfaces2) {
+  if (!/^[a-z0-9.-]+$/i.test(host) || host.length > 253)
+    throw new Error("Invalid public destination");
+  const own = new Set(
+    Object.values(interfaces()).flatMap((items) => items?.map((i) => i.address) ?? [])
+  );
+  const answers = /^\d+\.\d+\.\d+\.\d+$/.test(host) ? [host] : await lookup(host);
+  if (!answers.length || answers.some((ip) => !isGloballyRoutableIPv4(ip) || own.has(ip)))
+    throw new Error("Host, LAN and reserved destinations are blocked");
+  const address = answers[0];
+  if (!address) throw new Error("No public DNS answer");
+  return address;
+}
+function publicWebRequest(header) {
+  const lines = header.split("\r\n");
+  const match = /^(CONNECT|GET|HEAD|POST|PUT|PATCH|DELETE|OPTIONS) ([^\s]+) HTTP\/1\.[01]$/.exec(
+    lines.shift() ?? ""
+  );
+  if (!match) throw new Error("Unsupported proxy request");
+  const connect = match[1] === "CONNECT";
+  const target = match[2] ?? "";
+  if (connect && !/^[a-z0-9.-]+:(80|443)$/i.test(target))
+    throw new Error("Invalid CONNECT destination");
+  const { url, port } = proxyUrl(target, connect);
+  for (const line of lines.filter(Boolean)) {
+    if (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+:[\t\x20-\x7e]*$/.test(line))
+      throw new Error("Invalid proxy header");
+  }
+  const headers = lines.filter(
+    (line) => line && !/^(host|connection|proxy-connection|proxy-authorization):/i.test(line)
+  );
+  return {
+    host: url.hostname,
+    port,
+    connect,
+    forward: connect ? "" : `${match[1]} ${url.pathname}${url.search} HTTP/1.1\r
+Host: ${url.host}\r
+Connection: close\r
+${headers.length ? headers.join("\r\n") + "\r\n" : ""}\r
+`
+  };
+}
+function readPublicWebRequest(input) {
+  return new Promise((resolve, reject) => {
+    let data = Buffer.alloc(0);
+    const cleanup = () => {
+      clearTimeout(timer);
+      input.pause();
+      input.removeListener("data", receive);
+      input.removeListener("end", closed);
+      input.removeListener("error", failed);
+    };
+    const failed = (error) => {
+      cleanup();
+      reject(error);
+    };
+    const closed = () => failed(new Error("Incomplete proxy request"));
+    const timer = setTimeout(() => failed(new Error("Proxy handshake timed out")), 1e4);
+    const receive = (chunk) => {
+      data = Buffer.concat([data, chunk]);
+      const end = data.indexOf("\r\n\r\n");
+      if (end < 0 && data.length > 16384 || end > 16384)
+        return failed(new Error("Proxy header too large"));
+      if (end < 0) return;
+      cleanup();
+      try {
+        const request = publicWebRequest(data.subarray(0, end).toString("latin1"));
+        const remaining = Buffer.concat([Buffer.from(request.forward), data.subarray(end + 4)]);
+        if (remaining.length) input.unshift(remaining);
+        resolve(request);
+      } catch (error) {
+        reject(error);
+      }
+    };
+    input.on("data", receive);
+    input.once("end", closed);
+    input.once("error", failed);
+  });
+}
+function proxyUrl(target, connect) {
+  const url = new URL(connect ? `https://${target}` : target);
+  if (url.username || url.password || url.hash || !connect && url.protocol !== "http:")
+    throw new Error("Invalid proxy URL");
+  const port = Number(url.port || (connect ? 443 : 80));
+  if (port !== 80 && port !== 443) throw new Error("Only public web ports 80 and 443 are allowed");
+  return { url, port };
+}
+
 // src/vm/qemu-policy.ts
 var ALLOWED_PROBES = new Set(
   [
@@ -286,7 +382,10 @@ function restrictedUsernet(network, forwards, ncPath) {
     "restrict=on",
     "ipv6=off",
     `hostfwd=tcp:127.0.0.1:${network.sshPort}-:22`,
-    ...guestForwards
+    ...guestForwards,
+    ...network.publicWeb === true ? [
+      `guestfwd=tcp:${PUBLIC_WEB_IP}:${PUBLIC_WEB_PORT}-cmd:${ncPath} -4 -n -w 60 public-web ${PUBLIC_WEB_PORT}`
+    ] : []
   ].join(",");
 }
 function validateForwards(forwards) {
@@ -473,7 +572,7 @@ import { Socket } from "net";
 var MAX_RELAYS = 16;
 var MAX_RELAY_BYTES = 1024 * 1024 * 1024;
 var RELAY_CONNECT_MS = 6e4;
-var RELAY_IDLE_MS = 3e4;
+var RELAY_IDLE_MS = 15 * 6e4;
 var GUARD_FRESH_MS = 6e3;
 var RELAY_PREFIX = "--conveyor-vm-relay";
 function validPid(value) {
@@ -589,7 +688,7 @@ function parseRelayInvocation(args) {
   }
   const address = args[5] ?? "";
   const port = Number(args[6]);
-  if (!isGloballyRoutableIPv4(address) || !Number.isInteger(port) || port < 1 || port > 65535) {
+  if (!(isGloballyRoutableIPv4(address) || address === "public-web" && port === PUBLIC_WEB_PORT) || !Number.isInteger(port) || port < 1 || port > 65535) {
     throw new Error("Invalid VM relay destination");
   }
   return { address, port };
@@ -668,21 +767,53 @@ function currentGuardStillValid(root, runId) {
 function runRelay(root, invocation, io) {
   return Promise.resolve().then(() => runRelayNow(root, invocation, io));
 }
-function runRelayNow(root, invocation, io) {
+async function runRelayNow(root, invocation, io) {
   const guard = readLiveGuard(root);
-  assertApprovedDestination(root, invocation);
+  const publicWeb = invocation.address === "public-web" && invocation.port === PUBLIC_WEB_PORT;
+  if (publicWeb) {
+    if (readNetwork(root).publicWeb !== true) throw new Error("Public web access is not enabled");
+  } else assertApprovedDestination(root, invocation);
   const record = registerRelay(root, guard.runId);
+  const streams = io ?? { socket: new Socket(), input: process.stdin, output: process.stdout };
+  let connectedResponse = false;
+  if (publicWeb) {
+    const releaseHandshake = handshakeExitCleanup(root, record);
+    let timeout;
+    try {
+      const request = await readPublicWebRequest(streams.input);
+      const address = await Promise.race([
+        publicWebAddress(request.host),
+        new Promise((_, reject) => {
+          timeout = setTimeout(() => reject(new Error("DNS lookup timed out")), 5e3);
+        })
+      ]);
+      if (!currentGuardStillValid(root, record.runId))
+        throw new Error("Resource guard is no longer healthy");
+      invocation = { address, port: request.port };
+      connectedResponse = request.connect;
+    } catch {
+      unregisterRelay(root, record);
+      streams.output.write(
+        "HTTP/1.1 403 Forbidden\r\nConnection: close\r\nContent-Length: 0\r\n\r\n"
+      );
+      streams.input.destroy();
+      streams.socket.destroy();
+      return;
+    } finally {
+      if (timeout) clearTimeout(timeout);
+      releaseHandshake();
+    }
+  }
+  return transportRelay(root, invocation, streams, record, connectedResponse);
+}
+function transportRelay(root, invocation, streams, record, connectedResponse) {
   return new Promise((resolve) => {
     let finished = false;
     let sent = 0;
     let received = 0;
     let guardTimer;
     let connectTimer;
-    const { socket, input, output } = io ?? {
-      socket: new Socket(),
-      input: process.stdin,
-      output: process.stdout
-    };
+    const { socket, input, output } = streams;
     const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
     const cleanup = () => {
       try {
@@ -714,6 +845,7 @@ function runRelayNow(root, invocation, io) {
     socket.once("connect", () => {
       if (connectTimer) clearTimeout(connectTimer);
       connectTimer = void 0;
+      if (connectedResponse) output.write("HTTP/1.1 200 Connection Established\r\n\r\n");
     });
     socket.on("error", () => finish(new Error("VM relay connection failed")));
     socket.on("close", () => finish());
@@ -741,8 +873,30 @@ function runRelayNow(root, invocation, io) {
       RELAY_CONNECT_MS
     );
     socket.connect(invocation.port, invocation.address);
+    input.resume();
   });
 }
+function handshakeExitCleanup(root, record) {
+  const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
+  const cleanup = () => {
+    try {
+      unregisterRelay(root, record);
+    } catch {
+    }
+  };
+  const release = () => {
+    process.removeListener("exit", cleanup);
+    for (const signal of signals) process.removeListener(signal, terminated);
+  };
+  const terminated = (signal) => {
+    cleanup();
+    release();
+    process.kill(process.pid, signal);
+  };
+  process.once("exit", cleanup);
+  for (const signal of signals) process.once(signal, terminated);
+  return release;
+}
 
 // src/vm/memory-budget.ts
 function vmHostMemoryGiB(guestGiB) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rallycry/conveyor-k3",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "Managed personal compute for Conveyor. Installs and maintains a k3s cluster that runs your own card builds, kept converged on Conveyor's desired state.",
   "keywords": [
     "cloudflared",