@geohar/pi-svg-mcp 0.0.0

package/src/sharedserver-resolve.ts

@@ -0,0 +1,221 @@
+// Resolve the `sharedserver` binary, fetching it when none is usable.
+//
+// VENDORED FILE. This is copied byte-identical into the consuming OpenCode plugins
+// (cribsheet, svg-mcp) by their scripts/sync-vendored.sh, so the drift check is a plain
+// diff. There is no way to share it as a dependency without coupling their versions to
+// sharedserver's — see plugins/claude/bin/sharedserver for the same reasoning on the
+// shell side. Edit it HERE; consumers re-sync.
+//
+// Everything repo-specific arrives through ResolveConfig rather than being hardcoded,
+// mirroring bin/sharedserver.conf.
+
+import { spawnSync } from "node:child_process"
+import { existsSync, mkdirSync, rmSync, statSync, writeFileSync } from "node:fs"
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+export type LogFn = (level: "info" | "warn" | "error", message: string) => void
+export type ToastFn = (variant: "success" | "warning" | "error", message: string) => void
+
+export type ResolveConfig = {
+    /** Prefix for user-facing messages. Default "sharedserver". */
+    label?: string
+    /** Minimum acceptable version. Defaults to pkgVersion (lockstep). */
+    minVersion?: string
+    /** Installer to fetch. Defaults to the release pinned to pkgVersion. */
+    installerUrl?: string
+    /** The host package's own version — only meaningful in lockstep mode. */
+    pkgVersion?: string
+}
+
+/** Oldest release these plugins are correct against: 0.5.0 added the PID-reuse guard,
+ *  without which a recycled client PID can hold a server open indefinitely. */
+const HARDCODED_FLOOR = "0.5.0"
+
+const CANDIDATE_BINARIES = [
+    "sharedserver",
+    join(homedir(), ".cargo", "bin", "sharedserver"),
+    join(homedir(), ".local", "bin", "sharedserver"),
+    "/usr/local/bin/sharedserver",
+    "/opt/homebrew/bin/sharedserver",
+]
+
+function parseVersion(text: string): [number, number, number] | undefined {
+    const m = text.match(/(\d+)\.(\d+)\.(\d+)/)
+    return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : undefined
+}
+
+function gte(a: [number, number, number], b: [number, number, number]): boolean {
+    for (let i = 0; i < 3; i++) if (a[i] !== b[i]) return a[i] > b[i]
+    return true
+}
+
+function versionOf(candidate: string, env: NodeJS.ProcessEnv): [number, number, number] | undefined {
+    const r = spawnSync(candidate, ["--version"], { env })
+    if (r.error) return undefined
+    return parseVersion(`${r.stdout?.toString() ?? ""}${r.stderr?.toString() ?? ""}`)
+}
+
+/** Synchronous sleep — this path runs before anything can be awaited, so the lock wait
+ *  cannot use timers. Atomics.wait blocks without spinning. */
+function sleepSync(ms: number): void {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms)
+}
+
+/** First sharedserver found at ANY version, or undefined. */
+function probeAny(override: string | undefined, env: NodeJS.ProcessEnv): string | undefined {
+    const candidates = [override, env.SHAREDSERVER_BIN, ...CANDIDATE_BINARIES].filter(
+        (v): v is string => typeof v === "string" && v.length > 0,
+    )
+    for (const candidate of candidates) {
+        if (candidate.includes("/")) {
+            if (existsSync(candidate)) return candidate
+            continue
+        }
+        // Presence is "spawn did not fail", NOT "exited 0" — a build that rejects some
+        // flag is still present.
+        if (!spawnSync(candidate, ["--version"], { stdio: "ignore", env }).error) return candidate
+    }
+    return undefined
+}
+
+/** Download and run the cargo-dist installer, then re-probe. */
+function installPinned(
+    cfg: Required<Pick<ResolveConfig, "label">> & ResolveConfig,
+    url: string,
+    what: string,
+    env: NodeJS.ProcessEnv,
+    log?: LogFn,
+    toast?: ToastFn,
+): string | undefined {
+    // The SAME lock directory as the shell shim — cross-client coordination, so a
+    // Claude session and an OpenCode session starting together do not race.
+    const lockdir = join(env.TMPDIR || "/tmp", ".sharedserver-install.lock")
+    let haveLock = false
+    try {
+        mkdirSync(lockdir)
+        haveLock = true
+    } catch {
+        const deadline = Date.now() + 20_000
+        while (existsSync(lockdir) && Date.now() < deadline) sleepSync(250)
+        const after = probeAny(undefined, env)
+        if (after) return after
+        try {
+            mkdirSync(lockdir)
+            haveLock = true
+        } catch {
+            log?.("warn", `${cfg.label}: another process is installing sharedserver and did not finish; remove the stale lock if this persists: ${lockdir}`)
+            return undefined
+        }
+    }
+
+    try {
+        // Re-probe under the lock: the winner may have finished while we waited.
+        const already = probeAny(undefined, env)
+        const floor = parseVersion(cfg.minVersion ?? HARDCODED_FLOOR)
+        if (already) {
+            const v = versionOf(already, env)
+            if (v && floor && gte(v, floor)) return already
+        }
+
+        // Download to a file, then run it. `curl … | sh` would report success on a 404,
+        // since a pipeline's status is sh's; spawnSync uses no shell, so this is exact.
+        const script = join(lockdir, "installer.sh")
+        const dl = spawnSync("curl", ["--proto", "=https", "--tlsv1.2", "-LsSf", url, "-o", script], { env })
+        if (dl.error || dl.status !== 0) {
+            const msg = `${cfg.label}: could not download the sharedserver installer (${what})`
+            log?.("warn", msg)
+            toast?.("warning", msg)
+            return undefined
+        }
+        if (!existsSync(script) || statSync(script).size === 0) {
+            log?.("warn", `${cfg.label}: the downloaded sharedserver installer was empty`)
+            return undefined
+        }
+
+        // cargo-dist embeds the expected sha256 but looks up only `sha256sum` and SKIPS
+        // verification when missing — i.e. always, on macOS. Give it one (identical
+        // output) rather than execute an unverified binary.
+        let runEnv = env
+        if (spawnSync("sh", ["-c", "command -v sha256sum"], { stdio: "ignore" }).status !== 0) {
+            if (spawnSync("sh", ["-c", "command -v shasum"], { stdio: "ignore" }).status !== 0) {
+                log?.("warn", `${cfg.label}: refusing to install sharedserver — no sha256sum or shasum to verify the download`)
+                return undefined
+            }
+            writeFileSync(join(lockdir, "sha256sum"), '#!/bin/sh\nexec shasum -a 256 "$@"\n', { mode: 0o755 })
+            runEnv = { ...env, PATH: `${lockdir}:${env.PATH ?? ""}` }
+        }
+
+        const run = spawnSync("sh", [script], { env: runEnv, stdio: "ignore" })
+        if (run.error || run.status !== 0) {
+            log?.("warn", `${cfg.label}: the sharedserver installer ran but failed`)
+            return undefined
+        }
+        return probeAny(undefined, env)
+    } finally {
+        if (haveLock) {
+            try {
+                rmSync(lockdir, { recursive: true, force: true })
+            } catch {
+                /* best effort — a leaked lock costs the next run its bounded wait */
+            }
+        }
+    }
+}
+
+/** Resolve the sharedserver binary, fetching a release when nothing usable is present.
+ *
+ *  Behaviourally identical to plugins/claude/bin/sharedserver — same ladder, floor,
+ *  lock and degrade-rather-than-die fallback, so a user running both clients gets the
+ *  same answer to "which sharedserver am I on, and why". */
+export function resolveSharedserver(
+    cfg: ResolveConfig,
+    override: string | undefined,
+    env: NodeJS.ProcessEnv,
+    log?: LogFn,
+    toast?: ToastFn,
+): string | undefined {
+    const label = cfg.label ?? "sharedserver"
+    const minVersion = cfg.minVersion ?? cfg.pkgVersion ?? HARDCODED_FLOOR
+    const url =
+        cfg.installerUrl ??
+        (cfg.pkgVersion
+            ? `https://github.com/georgeharker/sharedserver/releases/download/v${cfg.pkgVersion}/sharedserver-installer.sh`
+            : "https://github.com/georgeharker/sharedserver/releases/latest/download/sharedserver-installer.sh")
+    const what = cfg.installerUrl || !cfg.pkgVersion ? "the latest release" : `v${cfg.pkgVersion}`
+    const resolved = { ...cfg, label, minVersion }
+    const floor = parseVersion(minVersion)
+
+    // An explicit binary / SHAREDSERVER_BIN is never second-guessed: the user named a
+    // specific one, so quietly downloading a different one is the wrong answer.
+    const explicit = override ?? env.SHAREDSERVER_BIN
+    if (explicit) {
+        const present = explicit.includes("/")
+            ? existsSync(explicit)
+            : !spawnSync(explicit, ["--version"], { stdio: "ignore", env }).error
+        if (present) {
+            const v = versionOf(explicit, env)
+            if (v && floor && !gte(v, floor)) {
+                const msg = `${label}: sharedserver at ${explicit} is ${v.join(".")}; this plugin expects >= ${minVersion}. Using it anyway because you set it explicitly.`
+                log?.("warn", msg)
+                toast?.("warning", msg)
+            }
+            return explicit
+        }
+    }
+
+    const found = probeAny(override, env)
+    if (found) {
+        const v = versionOf(found, env)
+        if (v && floor && gte(v, floor)) return found
+        // Too old: fetch, but remember this one — if the download fails we would rather
+        // run the old binary than nothing.
+        const msg = `${label}: sharedserver at ${found} is ${v?.join(".") ?? "an unknown version"}; this plugin expects >= ${minVersion}. Fetching ${what}. To keep your own build, set SHAREDSERVER_BIN=${found}`
+        log?.("warn", msg)
+        toast?.("warning", msg)
+        return installPinned(resolved, url, what, env, log, toast) ?? found
+    }
+
+    log?.("info", `${label}: no usable sharedserver found; fetching ${what} (one time). This needs no Rust toolchain.`)
+    return installPinned(resolved, url, what, env, log, toast)
+}