@scp-dev/broker 0.0.0-stage → 0.1.1

package/src/ndjson.ts

@@ -0,0 +1,95 @@
+/** the longest request line the broker reads, in bytes */
+export const MAX_LINE = 256 * 1024
+
+const NEWLINE = 0x0a
+const decoder = new TextDecoder()
+const encoder = new TextEncoder()
+
+/** splits a byte stream into UTF-8 lines; a multibyte character split across chunks stays whole */
+export class LineReader {
+  private pending: Buffer = Buffer.alloc(0)
+
+  constructor(private readonly maxBytes: number) {}
+
+  /** bytes of a line that has not ended yet */
+  get buffered(): number {
+    return this.pending.length
+  }
+
+  /** the complete lines so far; `tooLong` once a line passes the cap (lines before it still count) */
+  push(chunk: Uint8Array): { lines: string[]; tooLong: boolean } {
+    this.pending = this.pending.length ? Buffer.concat([this.pending, chunk]) : Buffer.from(chunk)
+    const lines: string[] = []
+    for (let newline = this.pending.indexOf(NEWLINE); newline !== -1; newline = this.pending.indexOf(NEWLINE)) {
+      if (newline > this.maxBytes) return { lines, tooLong: true }
+      const line = decoder.decode(this.pending.subarray(0, newline))
+      this.pending = this.pending.subarray(newline + 1)
+      if (line.trim()) lines.push(line)
+    }
+    return { lines, tooLong: this.pending.length > this.maxBytes }
+  }
+}
+
+const BATCH = 64 * 1024
+
+/** queues lines as a list of chunks and writes as much as the socket takes, the rest on drain */
+export class LineWriter {
+  private chunks: Uint8Array[] = []
+  private static readonly EMPTY = new Uint8Array(0)
+  private head = 0
+  private queued = 0
+
+  /** bytes waiting for the socket */
+  get pending(): number {
+    return this.queued
+  }
+
+  push(value: unknown): void {
+    this.pushBytes(encodeLine(value))
+  }
+
+  pushBytes(line: Uint8Array): void {
+    this.chunks.push(line)
+    this.queued += line.length
+  }
+
+  flush(write: (bytes: Uint8Array) => number): void {
+    while (this.queued) {
+      const first = this.chunks[this.head]!
+      let batch: Uint8Array = first
+      if (first.length < BATCH && this.head + 1 < this.chunks.length) {
+        const parts: Uint8Array[] = []
+        let size = 0
+        for (let i = this.head; i < this.chunks.length && size < BATCH; i++) {
+          parts.push(this.chunks[i]!)
+          size += this.chunks[i]!.length
+        }
+        batch = Buffer.concat(parts, size)
+      }
+      const written = write(batch)
+      if (written <= 0) return
+      this.consume(written)
+    }
+  }
+
+  private consume(bytes: number): void {
+    this.queued -= bytes
+    while (bytes > 0) {
+      const first = this.chunks[this.head]!
+      if (bytes < first.length) {
+        this.chunks[this.head] = first.subarray(bytes)
+        break
+      }
+      bytes -= first.length
+      this.chunks[this.head++] = LineWriter.EMPTY
+    }
+    if (this.head > 1024 || this.head === this.chunks.length) {
+      this.chunks = this.chunks.slice(this.head)
+      this.head = 0
+    }
+  }
+}
+
+export function encodeLine(value: unknown): Uint8Array {
+  return encoder.encode(`${JSON.stringify(value)}\n`)
+}

package/src/paths.ts

@@ -0,0 +1,132 @@
+import { spawnSync } from "node:child_process"
+import { createHash } from "node:crypto"
+import { chmodSync, lstatSync, mkdirSync, readFileSync } from "node:fs"
+import { homedir, hostname, userInfo } from "node:os"
+import { join } from "node:path"
+
+type Run = (cmd: string[]) => { exitCode: number | null; stdout: string | Buffer }
+
+const runQuiet: Run = (cmd) => {
+  const result = spawnSync(cmd[0]!, cmd.slice(1), { stdio: ["ignore", "pipe", "ignore"], timeout: 2000 })
+  return { exitCode: result.status, stdout: result.stdout ?? "" }
+}
+
+/** macOS's LocalHostName (read only), or undefined when it is unset */
+export function localHostName(run: Run = runQuiet): string | undefined {
+  try {
+    const result = run(["scutil", "--get", "LocalHostName"])
+    return (result.exitCode === 0 && result.stdout.toString().trim()) || undefined
+  } catch {
+    return undefined
+  }
+}
+
+/** this machine's name: on macOS its LocalHostName, which a network change does not rename as it can the hostname; else the hostname */
+export function systemHostname(
+  platform: string = process.platform,
+  local: () => string | undefined = localHostName,
+  fallback: () => string = hostname,
+): string {
+  return (platform === "darwin" && local()) || fallback()
+}
+
+let host: string | undefined
+
+/** systemHostname, read once per process */
+export function thisHostname(): string {
+  host ??= systemHostname()
+  return host
+}
+
+/** the lowercased first label of `name` (default this machine's): agents' machine label, and what `machine:` matches */
+export function shortHostname(name: string = thisHostname()): string {
+  return (name.split(".")[0] ?? "").toLowerCase().replace(/[^a-z0-9._-]+/g, "-") || "unknown"
+}
+
+/** `$SCP_DIR`, else `$XDG_STATE_HOME/scp`, else ~/.local/state/scp */
+export function relayDir(env: NodeJS.ProcessEnv = process.env): string {
+  if (env.SCP_DIR) return env.SCP_DIR
+  return join(env.XDG_STATE_HOME || join(env.HOME || homedir(), ".local", "state"), "scp")
+}
+
+/**
+ * `~/.config/scp/policy.json` of the account the broker runs as, from the user database rather
+ * than HOME or XDG_CONFIG_HOME, so the process that happens to start the broker cannot pick its policy
+ */
+export function policyPath(): string {
+  return join(accountHome(), ".config", "scp", "policy.json")
+}
+
+let home: string | undefined
+let verified = false
+
+/** whether accountHome came from the user database rather than HOME */
+export function accountHomeVerified(): boolean {
+  accountHome()
+  return verified
+}
+
+/**
+ * the home directory the user database holds for `uid`. Node's userInfo reads it with getpwuid; Bun's answers from HOME,
+ * so under Bun it comes from the system's directory tools instead: dscacheutil on macOS, getent or /etc/passwd elsewhere
+ */
+export function userDatabaseHome(uid: number, options: { platform?: string; bun?: boolean; run?: Run; passwd?: () => string } = {}): string | undefined {
+  const platform = options.platform ?? process.platform
+  if (!(options.bun ?? typeof process.versions.bun === "string")) return userInfo().homedir || undefined
+  const run = options.run ?? runQuiet
+  if (platform === "darwin") {
+    const result = run(["dscacheutil", "-q", "user", "-a", "uid", String(uid)])
+    return (result.exitCode === 0 && /^dir: (.+)$/m.exec(result.stdout.toString())?.[1]?.trim()) || undefined
+  }
+  const entry = (text: string) => text.split("\n").find((line) => line.split(":")[2] === String(uid))
+  const result = run(["getent", "passwd", String(uid)])
+  let line = result.exitCode === 0 ? entry(result.stdout.toString()) : undefined
+  if (!line) {
+    try {
+      line = entry((options.passwd ?? (() => readFileSync("/etc/passwd", "utf8")))())
+    } catch {}
+  }
+  return line?.split(":")[5] || undefined
+}
+
+/** the account's home directory from the user database, falling back to HOME where that is unavailable */
+export function accountHome(): string {
+  if (home) return home
+  try {
+    if (typeof process.getuid === "function") home = userDatabaseHome(process.getuid())
+    verified = Boolean(home)
+  } catch {}
+  home ||= homedir()
+  return home
+}
+
+const SUN_PATH_MAX = 100
+
+/** a private directory: created 0700, and refused when it is a link or someone else's */
+export function privateDir(path: string): string {
+  mkdirSync(path, { recursive: true, mode: 0o700 })
+  const stat = lstatSync(path)
+  if (!stat.isDirectory() || (typeof process.getuid === "function" && stat.uid !== process.getuid())) {
+    throw new Error(`${path} is not a directory this user owns`)
+  }
+  chmodSync(path, 0o700)
+  return path
+}
+
+/** whether `path` is a directory of this user's, not a link, that nobody else may write: where a socket can be trusted */
+export function ownPrivateDir(path: string): boolean {
+  const stat = lstatSync(path, { throwIfNoEntry: false })
+  return !!stat && stat.isDirectory() && (typeof process.getuid !== "function" || stat.uid === process.getuid()) && (stat.mode & 0o022) === 0
+}
+
+/**
+ * The broker's socket: inside the relay dir, unless that path is too long for a unix socket
+ * (deep temp HOMEs), then a per-user, per-dir private directory under /tmp.
+ */
+export function socketPath(dir: string): string {
+  const inside = join(dir, "relay.sock")
+  if (Buffer.byteLength(inside) <= SUN_PATH_MAX) return inside
+  const uid = typeof process.getuid === "function" ? process.getuid() : 0
+  const key = createHash("sha256").update(dir).digest("hex").slice(0, 12)
+  return join("/tmp", `scp-${uid}-${key}`, "relay.sock")
+}