@sirenodeck/sirenodeck 0.1.1-alpha.0

package/src/cli/cwd.ts

@@ -0,0 +1,28 @@
+import { isAbsolute, resolve as resolvePath } from "node:path"
+
+// ponytail: SIRENO_CWD is a privilege escalation surface — it lets any process
+// in the user's shell environment redirect config include resolution to an
+// attacker-controlled cwd. Refuse the override unless we can attribute it to a
+// trusted setter:
+//   - SIRENO_WRAPPER_CHILD=1 — bin/dev.js and bin/sirenodeck.js spawn the CLI
+//     with `cwd` at the package root (tsx needs it) and both set SIRENO_CWD
+//     from their OWN process.cwd() in the same env literal that sets the
+//     sentinel, so an inherited SIRENO_CWD is always overwritten, never
+//     honoured. Without this branch the wrappers' SIRENO_CWD was silently
+//     dropped and every relative config path resolved against packages/cli.
+//   - SIRENO_ALLOW_CWD_OVERRIDE=1 — explicit opt-in for non-wrapper callers.
+export const getOriginalCwd = (): string => {
+  const override = process.env["SIRENO_CWD"]
+  if (override === undefined || override === "") return process.cwd()
+  const trusted =
+    process.env["SIRENO_WRAPPER_CHILD"] === "1" ||
+    process.env["SIRENO_ALLOW_CWD_OVERRIDE"] === "1"
+  return trusted ? override : process.cwd()
+}
+
+// ponytail: the CLI's own cwd is the package root under the dev wrapper, so a
+// relative `--config config.yml` typed at the repo root used to resolve to
+// packages/cli/config.yml and fail with "Config file not found". Anchor every
+// user-supplied path to the cwd the user actually typed it in.
+export const resolveUserPath = (path: string): string =>
+  isAbsolute(path) ? path : resolvePath(getOriginalCwd(), path)

package/src/cli/first-run.ts

@@ -0,0 +1,149 @@
+import { spawn } from "node:child_process"
+import { existsSync, mkdirSync, readdirSync, writeFileSync } from "node:fs"
+import { createRequire } from "node:module"
+import { homedir } from "node:os"
+import { dirname, join } from "node:path"
+
+import type pino from "pino"
+
+import { systemRequirements } from "./commands/system-requirements"
+
+const FLAG_VERSION = 1
+
+export const isInstalledBuild = (): boolean =>
+  process.env["SIRENO_INSTALL_ROOT"] !== undefined &&
+  process.env["SIRENO_INSTALL_ROOT"] !== ""
+
+const configDir = (): string => {
+  const xdg = process.env["XDG_CONFIG_HOME"] ?? join(homedir(), ".config")
+  return join(xdg, "sirenodeck")
+}
+
+const flagPath = (): string => join(configDir(), "first-run.json")
+
+const playrightBrowsersPath = (): string => {
+  const cached =
+    process.env["PLAYWRIGHT_BROWSERS_PATH"] ??
+    join(homedir(), ".cache", "sirenodeck", "playwright")
+  process.env["PLAYWRIGHT_BROWSERS_PATH"] = cached
+  return cached
+}
+
+const chromiumInstalled = (browsersPath: string): boolean => {
+  if (!existsSync(browsersPath)) return false
+  try {
+    return readdirSync(browsersPath).some((entry) =>
+      entry.startsWith("chromium"),
+    )
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Download the headless chromium build without npm by shelling out to the
+ * bundled playwright CLI. Browsers land in ~/.cache/sirenodeck/playwright/
+ * (PLAYWRIGHT_BROWSERS_PATH) and the env var stays set for the child daemon,
+ * so `browser-renderer` finds them at runtime.
+ */
+/**
+ * Locate playwright's CLI entry point. Installed builds keep it under
+ * SIRENO_INSTALL_ROOT; dev checkouts resolve it from whichever node_modules
+ * the running CLI was loaded from (pnpm's layout means it is not necessarily
+ * a sibling of the repo root).
+ */
+const resolvePlaywrightCli = (): string | null => {
+  const root = process.env["SIRENO_INSTALL_ROOT"]
+  if (root !== undefined) {
+    const installed = join(root, "node_modules", "playwright", "cli.js")
+    if (existsSync(installed)) return installed
+  }
+  try {
+    const require_ = createRequire(import.meta.url)
+    // playwright's package.json "bin" points at cli.js; resolve the package
+    // entry then take its directory so we don't depend on the export map.
+    return join(dirname(require_.resolve("playwright")), "cli.js")
+  } catch {
+    return null
+  }
+}
+
+export const ensurePlaywright = async (logger: pino.Logger): Promise<void> => {
+  const browsersPath = playrightBrowsersPath()
+  if (chromiumInstalled(browsersPath)) return
+  const cliPath = resolvePlaywrightCli()
+  if (cliPath === null || !existsSync(cliPath)) {
+    logger.warn(
+      { cliPath },
+      "first-run: playwright cli not found — skipping browser download",
+    )
+    return
+  }
+  logger.info(
+    { browsersPath },
+    "first-run: downloading headless chromium for browser rendering (one-time, ~150MB)",
+  )
+  await new Promise<void>((resolve) => {
+    const child = spawn(process.execPath, [cliPath, "install", "chromium"], {
+      env: { ...process.env, PLAYWRIGHT_BROWSERS_PATH: browsersPath },
+      stdio: "inherit",
+    })
+    child.on("error", (err) => {
+      logger.error({ err }, "first-run: failed to start playwright install")
+      resolve()
+    })
+    child.on("exit", (code) => {
+      if (code !== 0) {
+        logger.warn(
+          { code },
+          "first-run: playwright install exited non-zero — browser output will be unavailable",
+        )
+      }
+      resolve()
+    })
+  })
+}
+
+/**
+ * First-run bootstrap for installed builds: run the setup wizard (which
+ * surfaces the Wayland GNOME extension prerequisite), then download the
+ * Playwright browsers, then stamp the flag file so it happens once.
+ *
+ * Skips for non-installed (dev) builds and for query commands
+ * (--help/--version/system-requirements). Never blocks the requested command:
+ * failures are logged and the run proceeds.
+ */
+export const runFirstRunIfNeeded = async (
+  logger: pino.Logger,
+): Promise<void> => {
+  if (!isInstalledBuild()) return
+  const command = process.argv.slice(2).find((arg) => !arg.startsWith("-"))
+  if (command === undefined || command === "system-requirements") return
+  if (existsSync(flagPath())) return
+
+  const tty = process.stdin.isTTY === true
+  try {
+    await systemRequirements({
+      logger,
+      ...(tty ? {} : { nonInteractive: true }),
+    })
+  } catch (err) {
+    logger.warn({ err }, "first-run: setup wizard failed, continuing")
+  }
+
+  try {
+    await ensurePlaywright(logger)
+  } catch (err) {
+    logger.warn(
+      { err },
+      "first-run: playwright download failed — browser output will be unavailable",
+    )
+  }
+
+  try {
+    mkdirSync(configDir(), { recursive: true })
+    writeFileSync(flagPath(), JSON.stringify({ version: FLAG_VERSION }))
+  } catch (err) {
+    logger.warn({ err }, "first-run: failed to write first-run flag file")
+  }
+}

package/src/cli/http-server.ts

@@ -0,0 +1,244 @@
+import {
+  createServer,
+  type IncomingMessage,
+  type Server,
+  type ServerResponse,
+} from "node:http"
+import { readFile, stat } from "node:fs/promises"
+import { extname, join, normalize, sep } from "node:path"
+
+import type pino from "pino"
+
+export interface StartHttpServerOptions {
+  readonly port: number
+  readonly host?: string
+  readonly distDir: string
+  readonly getToken: () => string | null
+  readonly logger: pino.Logger
+  readonly getConfigContent?: () => string | null
+  readonly getConfigPath?: () => string | null
+  readonly getAddons?: () => Array<{
+    name: string
+    path: string
+    internal: boolean
+    source: string
+    buttonTypes: Array<{ type: string; internal: boolean }>
+    defaultButton: string | null
+    decks: Array<{
+      id: string
+      isOverlay: boolean
+      paginated: boolean
+      buttons: number
+      internal: boolean
+    }>
+  }>
+}
+
+export interface RunningHttpServer {
+  readonly port: number
+  stop(): Promise<void>
+}
+
+const CONTENT_TYPES: Record<string, string> = {
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".html": "text/html; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".map": "application/json; charset=utf-8",
+}
+
+const TOKEN_SENTINEL = '<script type="module"'
+
+const injectToken = (html: string, token: string | null): string => {
+  if (token === null) return html
+  const script = `<script>window.__SIRENO_TOKEN__ = ${JSON.stringify(token)};</script>`
+  const idx = html.indexOf(TOKEN_SENTINEL)
+  if (idx === -1) return `${script}${html}`
+  return `${html.slice(0, idx)}${script}${html.slice(idx)}`
+}
+
+const resolveSafePath = (rootDir: string, requested: string): string | null => {
+  const cleaned = requested.replace(/\?.*$/, "")
+  const decoded = decodeURIComponent(cleaned)
+  const joined = normalize(join(rootDir, decoded))
+  const rootWithSep = rootDir.endsWith(sep) ? rootDir : `${rootDir}${sep}`
+  if (joined !== rootDir && !joined.startsWith(rootWithSep)) return null
+  return joined
+}
+
+const serveFile = async (
+  res: ServerResponse,
+  filePath: string,
+): Promise<void> => {
+  try {
+    const data = await readFile(filePath)
+    const type =
+      CONTENT_TYPES[extname(filePath).toLowerCase()] ??
+      "application/octet-stream"
+    res.writeHead(200, { "content-type": type, "content-length": data.length })
+    res.end(data)
+  } catch {
+    res.writeHead(404, { "content-type": "text/plain; charset=utf-8" })
+    res.end("Not Found")
+  }
+}
+
+export const startHttpServer = async (
+  options: StartHttpServerOptions,
+): Promise<RunningHttpServer> => {
+  const host = options.host ?? "127.0.0.1"
+  const indexPath = join(options.distDir, "index.html")
+
+  let html: string
+  try {
+    html = await readFile(indexPath, "utf8")
+  } catch (err) {
+    throw new Error(
+      `http-server: cannot read ${indexPath}: ${err instanceof Error ? err.message : String(err)}`,
+    )
+  }
+
+  const server: Server = createServer(
+    (req: IncomingMessage, res: ServerResponse) => {
+      void (async () => {
+        const url = req.url ?? "/"
+        if (url === "/health") {
+          const body = JSON.stringify({ status: "ok" })
+          res.writeHead(200, {
+            "content-type": "application/json; charset=utf-8",
+            "content-length": body.length,
+          })
+          res.end(body)
+          return
+        }
+        if (url === "/" || url === "/index.html") {
+          const injected = injectToken(html, options.getToken())
+          res.writeHead(200, {
+            "content-type": "text/html; charset=utf-8",
+            "content-length": Buffer.byteLength(injected),
+          })
+          res.end(injected)
+          return
+        }
+        if (url.startsWith("/api/")) {
+          const expectedToken = options.getToken()
+          if (expectedToken === null) {
+            res.writeHead(503, { "content-type": "text/plain; charset=utf-8" })
+            res.end("Auth unavailable: no token configured")
+            return
+          }
+          const auth = req.headers["authorization"]
+          if (typeof auth !== "string" || !auth.startsWith("Bearer ")) {
+            res.writeHead(401, { "content-type": "text/plain; charset=utf-8" })
+            res.end("Missing bearer token")
+            return
+          }
+          const presented = auth.slice("Bearer ".length)
+          if (presented !== expectedToken) {
+            res.writeHead(403, { "content-type": "text/plain; charset=utf-8" })
+            res.end("Invalid bearer token")
+            return
+          }
+        }
+        if (url === "/api/config" || url === "/api/config/") {
+          const text = options.getConfigContent?.() ?? null
+          if (text === null) {
+            res.writeHead(404, { "content-type": "text/plain; charset=utf-8" })
+            res.end("Config not available")
+            return
+          }
+          res.writeHead(200, {
+            "content-type": "text/plain; charset=utf-8",
+            "content-length": Buffer.byteLength(text),
+          })
+          res.end(text)
+          return
+        }
+        if (url === "/api/config-path") {
+          const path = options.getConfigPath?.() ?? null
+          const body = JSON.stringify({ path })
+          res.writeHead(200, {
+            "content-type": "application/json; charset=utf-8",
+            "content-length": Buffer.byteLength(body),
+          })
+          res.end(body)
+          return
+        }
+        if (url === "/api/addons" || url === "/api/addons/") {
+          const addons = options.getAddons?.() ?? []
+          const body = JSON.stringify({ addons })
+          res.writeHead(200, {
+            "content-type": "application/json; charset=utf-8",
+            "content-length": Buffer.byteLength(body),
+          })
+          res.end(body)
+          return
+        }
+        if (url.startsWith("/assets/")) {
+          const filePath = resolveSafePath(options.distDir, url)
+          if (filePath === null) {
+            res.writeHead(403)
+            res.end("Forbidden")
+            return
+          }
+          try {
+            const st = await stat(filePath)
+            if (!st.isFile()) {
+              res.writeHead(404)
+              res.end("Not Found")
+              return
+            }
+          } catch {
+            res.writeHead(404)
+            res.end("Not Found")
+            return
+          }
+          await serveFile(res, filePath)
+          return
+        }
+        res.writeHead(404, { "content-type": "text/plain; charset=utf-8" })
+        res.end("Not Found")
+      })().catch((err: unknown) => {
+        options.logger.error({ err }, "http-server: request failed")
+        if (!res.headersSent) {
+          res.writeHead(500)
+          res.end("Internal Server Error")
+        }
+      })
+    },
+  )
+
+  await new Promise<void>((resolve, reject) => {
+    server.once("error", reject)
+    server.listen(options.port, host, () => {
+      server.off("error", reject)
+      resolve()
+    })
+  })
+
+  const addr = server.address()
+  if (addr === null || typeof addr === "string") {
+    throw new Error("http-server: failed to bind")
+  }
+  const boundPort = addr.port
+  options.logger.info({ port: boundPort, host }, "http-server started")
+
+  return {
+    port: boundPort,
+    stop: () =>
+      new Promise<void>((resolve) => {
+        server.close(() => resolve())
+        server.closeAllConnections?.()
+      }),
+  }
+}