@hraness/slopcamera 3.2.4

package/src/config.ts

@@ -0,0 +1,180 @@
+import { readFile } from "node:fs/promises"
+import { dirname, extname, isAbsolute, resolve } from "node:path"
+import { pathToFileURL } from "node:url"
+import { pathExists } from "./fs.js"
+import { builtInIcons, sanitizeIcon } from "./icons.js"
+import type {
+  DiagramConfig,
+  FontConfig,
+  IconDefinition,
+  LoadedConfig,
+  PartialTheme,
+} from "./types.js"
+
+const configNames = [
+  { current: "slopcamera.config.ts", retired: "diagram.config.ts" },
+  { current: "slopcamera.config.mjs", retired: "diagram.config.mjs" },
+  { current: "slopcamera.config.js", retired: "diagram.config.js" },
+  { current: "slopcamera.config.json", retired: "diagram.config.json" },
+] as const
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+function parseFont(value: unknown, at: string): FontConfig {
+  if (!isRecord(value) || typeof value.family !== "string" || value.family.trim() === "") {
+    throw new Error(`${at} must have a non-empty family`)
+  }
+  if (value.files !== undefined && !Array.isArray(value.files)) {
+    throw new Error(`${at}.files must be an array`)
+  }
+  if (
+    value.monoFamily !== undefined &&
+    (typeof value.monoFamily !== "string" || value.monoFamily.trim() === "")
+  ) {
+    throw new Error(`${at}.monoFamily must be a non-empty string when present`)
+  }
+  const files = (value.files ?? []).map((file, index) => {
+    if (!isRecord(file) || typeof file.path !== "string" || file.path.trim() === "") {
+      throw new Error(`${at}.files[${index}].path must be a non-empty string`)
+    }
+    if (file.weight !== undefined && (typeof file.weight !== "number" || !Number.isFinite(file.weight))) {
+      throw new Error(`${at}.files[${index}].weight must be a finite number`)
+    }
+    if (file.style !== undefined && file.style !== "normal" && file.style !== "italic") {
+      throw new Error(`${at}.files[${index}].style must be normal or italic`)
+    }
+    if (file.embed !== undefined && typeof file.embed !== "boolean") {
+      throw new Error(`${at}.files[${index}].embed must be a boolean`)
+    }
+    const style = file.style as "normal" | "italic" | undefined
+    return {
+      path: file.path,
+      ...(file.weight === undefined ? {} : { weight: file.weight }),
+      ...(style === undefined ? {} : { style }),
+      ...(file.embed === undefined ? {} : { embed: file.embed }),
+    }
+  })
+  return {
+    family: value.family,
+    ...(value.monoFamily === undefined ? {} : { monoFamily: value.monoFamily }),
+    ...(files.length === 0 ? {} : { files }),
+  }
+}
+
+function parseIcons(value: unknown, at: string): Readonly<Record<string, IconDefinition>> {
+  if (!isRecord(value)) throw new Error(`${at} must be an object`)
+  return Object.fromEntries(
+    Object.entries(value).map(([name, icon]) => {
+      if (!isRecord(icon) || typeof icon.viewBox !== "string" || typeof icon.body !== "string") {
+        throw new Error(`${at}.${name} must have string viewBox and body fields`)
+      }
+      return [name, sanitizeIcon({ viewBox: icon.viewBox, body: icon.body })]
+    }),
+  )
+}
+
+function parseTheme(value: unknown, at: string): PartialTheme {
+  if (!isRecord(value)) throw new Error(`${at} must be an object`)
+  const scalarKeys = ["background", "foreground", "muted", "stroke"] as const
+  for (const key of scalarKeys) {
+    if (value[key] !== undefined && typeof value[key] !== "string") {
+      throw new Error(`${at}.${key} must be a CSS color string`)
+    }
+  }
+  if (value.tones !== undefined && !isRecord(value.tones)) {
+    throw new Error(`${at}.tones must be an object`)
+  }
+  return value as PartialTheme
+}
+
+function parseConfig(value: unknown): DiagramConfig {
+  if (!isRecord(value)) throw new Error("Slopcamera config must export an object")
+  const font = value.font === undefined ? undefined : parseFont(value.font, "font")
+  const icons = value.icons === undefined ? undefined : parseIcons(value.icons, "icons")
+  let theme: DiagramConfig["theme"]
+  if (value.theme !== undefined) {
+    if (!isRecord(value.theme)) throw new Error("theme must be an object")
+    theme = {
+      ...(value.theme.light === undefined ? {} : { light: parseTheme(value.theme.light, "theme.light") }),
+      ...(value.theme.dark === undefined ? {} : { dark: parseTheme(value.theme.dark, "theme.dark") }),
+    }
+  }
+  return {
+    ...(font === undefined ? {} : { font }),
+    ...(icons === undefined ? {} : { icons: { ...builtInIcons, ...icons } }),
+    ...(theme === undefined ? {} : { theme }),
+  }
+}
+
+async function discoverConfig(directory: string): Promise<string | null> {
+  let current: string | null = null
+  for (const names of configNames) {
+    const candidate = resolve(directory, names.current)
+    if (await pathExists(candidate)) {
+      current = candidate
+      break
+    }
+  }
+  if (current !== null) return current
+  for (const names of configNames) {
+    const candidate = resolve(directory, names.retired)
+    if (await pathExists(candidate)) {
+      const replacement = resolve(directory, names.current)
+      throw new Error(
+        `Legacy Slopcamera config found at ${candidate}. Rename it to ${replacement}; Slopcamera does not auto-load diagram.config.*.`,
+      )
+    }
+  }
+  return null
+}
+
+export async function loadDiagramConfig(options: {
+  readonly explicitPath?: string
+  readonly searchDirectory: string
+}): Promise<LoadedConfig> {
+  const filePath =
+    options.explicitPath === undefined
+      ? await discoverConfig(options.searchDirectory)
+      : resolve(options.explicitPath)
+  if (filePath === null) {
+    return {
+      filePath: null,
+      baseDirectory: options.searchDirectory,
+      value: { icons: builtInIcons },
+    }
+  }
+  if (!(await pathExists(filePath))) throw new Error(`Config does not exist: ${filePath}`)
+
+  const raw: unknown =
+    extname(filePath) === ".json"
+      ? JSON.parse(await readFile(filePath, "utf8"))
+      : ((await import(`${pathToFileURL(filePath).href}?v=${Date.now()}`)) as { default?: unknown })
+          .default
+  const value = parseConfig(raw)
+  const baseDirectory = dirname(filePath)
+  const font =
+    value.font === undefined
+      ? undefined
+      : {
+          ...value.font,
+          ...(value.font.files === undefined
+            ? {}
+            : {
+                files: value.font.files.map((file) => ({
+                  ...file,
+                  path: isAbsolute(file.path) ? file.path : resolve(baseDirectory, file.path),
+                })),
+              }),
+        }
+  return {
+    filePath,
+    baseDirectory,
+    value: {
+      ...value,
+      icons: { ...builtInIcons, ...value.icons },
+      ...(font === undefined ? {} : { font }),
+    },
+  }
+}

package/src/desktop.ts

@@ -0,0 +1,253 @@
+import { createHash } from "node:crypto"
+import { createReadStream, createWriteStream } from "node:fs"
+import { chmod, mkdir, readFile, rename, rm } from "node:fs/promises"
+import { homedir, platform as hostPlatform, arch as hostArch } from "node:os"
+import { dirname, join, resolve } from "node:path"
+import { Readable } from "node:stream"
+import { pipeline } from "node:stream/promises"
+import { pathExists } from "./fs.js"
+import { nonGatewayChildEnvironment } from "./process-environment.js"
+
+const releaseApi = "https://api.github.com/repos/tldraw/tldraw-offline/releases/latest"
+export const desktopDownloadPage = "https://offline.tldraw.com"
+
+export interface ReleaseAsset {
+  readonly name: string
+  readonly browser_download_url: string
+  readonly size: number
+  readonly digest: string | null
+}
+
+interface Release {
+  readonly tag_name: string
+  readonly html_url: string
+  readonly assets: readonly ReleaseAsset[]
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+function parseRelease(value: unknown): Release {
+  if (
+    !isRecord(value) ||
+    typeof value.tag_name !== "string" ||
+    typeof value.html_url !== "string" ||
+    !Array.isArray(value.assets)
+  ) {
+    throw new Error("GitHub returned an invalid tldraw Offline release")
+  }
+  const assets = value.assets.map((asset, index) => {
+    if (
+      !isRecord(asset) ||
+      typeof asset.name !== "string" ||
+      typeof asset.browser_download_url !== "string" ||
+      typeof asset.size !== "number" ||
+      (asset.digest !== null && asset.digest !== undefined && typeof asset.digest !== "string")
+    ) {
+      throw new Error(`GitHub returned an invalid release asset at index ${index}`)
+    }
+    return {
+      name: asset.name,
+      browser_download_url: asset.browser_download_url,
+      size: asset.size,
+      digest: asset.digest ?? null,
+    }
+  })
+  return { tag_name: value.tag_name, html_url: value.html_url, assets }
+}
+
+export function selectDesktopAsset(
+  release: Release,
+  platform: NodeJS.Platform = hostPlatform(),
+  architecture: string = hostArch(),
+): ReleaseAsset {
+  const expectedName =
+    platform === "darwin"
+      ? "tldraw-offline-mac-universal.dmg"
+      : platform === "win32"
+        ? architecture === "arm64"
+          ? "tldraw-offline-win-arm64.exe"
+          : "tldraw-offline-win-x64.exe"
+        : platform === "linux"
+          ? architecture === "arm64"
+            ? "tldraw-offline-linux-arm64.AppImage"
+            : "tldraw-offline-linux-x86_64.AppImage"
+          : null
+  if (expectedName === null) {
+    throw new Error(`tldraw Offline has no automated installer for ${platform}/${architecture}`)
+  }
+  const asset = release.assets.find((candidate) => candidate.name === expectedName)
+  if (asset === undefined) {
+    throw new Error(`The latest tldraw Offline release does not contain ${expectedName}`)
+  }
+  return asset
+}
+
+export async function getLatestDesktopRelease(): Promise<Release> {
+  const response = await fetch(releaseApi, {
+    headers: {
+      Accept: "application/vnd.github+json",
+      "User-Agent": "hraness-slopcamera",
+      "X-GitHub-Api-Version": "2022-11-28",
+    },
+  })
+  if (!response.ok) throw new Error(`GitHub release lookup failed with HTTP ${response.status}`)
+  return parseRelease((await response.json()) as unknown)
+}
+
+async function sha256(filePath: string): Promise<string> {
+  const hash = createHash("sha256")
+  for await (const chunk of createReadStream(filePath)) hash.update(chunk)
+  return hash.digest("hex")
+}
+
+async function download(asset: ReleaseAsset, filePath: string): Promise<void> {
+  const response = await fetch(asset.browser_download_url, {
+    headers: { "User-Agent": "hraness-slopcamera" },
+    redirect: "follow",
+  })
+  if (!response.ok || response.body === null) {
+    throw new Error(`Installer download failed with HTTP ${response.status}`)
+  }
+  const temporary = `${filePath}.part-${process.pid}`
+  await mkdir(dirname(filePath), { recursive: true })
+  try {
+    await pipeline(
+      Readable.fromWeb(
+        response.body as unknown as import("node:stream/web").ReadableStream,
+      ),
+      createWriteStream(temporary, { mode: 0o600 }),
+    )
+    const expected = asset.digest?.startsWith("sha256:") ? asset.digest.slice(7) : null
+    if (expected === null) {
+      throw new Error("GitHub did not publish a SHA-256 digest for this installer")
+    }
+    const actual = await sha256(temporary)
+    if (actual !== expected) {
+      throw new Error(`Installer checksum mismatch: expected ${expected}, received ${actual}`)
+    }
+    await rename(temporary, filePath)
+  } catch (error) {
+    await rm(temporary, { force: true })
+    throw error
+  }
+}
+
+function spawnDetached(command: readonly string[]): void {
+  const child = Bun.spawn([...command], {
+    env: nonGatewayChildEnvironment(),
+    stdin: "ignore",
+    stdout: "ignore",
+    stderr: "ignore",
+  })
+  child.unref()
+}
+
+export async function installDesktop(options: {
+  readonly downloadOnly?: boolean
+}): Promise<{ readonly filePath: string; readonly release: string }> {
+  const release = await getLatestDesktopRelease()
+  const asset = selectDesktopAsset(release)
+  const cacheDirectory = join(homedir(), ".cache", "slopcamera", "installers", release.tag_name)
+  const installerPath = join(cacheDirectory, asset.name)
+  let reusable = false
+  if (await pathExists(installerPath)) {
+    const expected = asset.digest?.startsWith("sha256:") ? asset.digest.slice(7) : null
+    reusable = expected !== null && (await sha256(installerPath)) === expected
+  }
+  if (!reusable) await download(asset, installerPath)
+
+  if (hostPlatform() === "linux") {
+    const installedPath = join(homedir(), ".local", "bin", "tldraw-offline")
+    await mkdir(dirname(installedPath), { recursive: true })
+    const temporary = `${installedPath}.tmp-${process.pid}`
+    await Bun.write(temporary, Bun.file(installerPath))
+    await chmod(temporary, 0o755)
+    await rename(temporary, installedPath)
+    if (!options.downloadOnly) spawnDetached([installedPath])
+    return { filePath: installedPath, release: release.tag_name }
+  }
+
+  if (!options.downloadOnly) {
+    if (hostPlatform() === "darwin") {
+      spawnDetached(["open", installerPath])
+    } else {
+      spawnDetached(["cmd.exe", "/d", "/s", "/c", "start", "", installerPath])
+    }
+  }
+  return { filePath: installerPath, release: release.tag_name }
+}
+
+export async function findDesktopApplication(): Promise<string | null> {
+  const candidates =
+    hostPlatform() === "darwin"
+      ? [
+          "/Applications/tldraw offline.app",
+          join(homedir(), "Applications", "tldraw offline.app"),
+        ]
+      : hostPlatform() === "linux"
+        ? [join(homedir(), ".local", "bin", "tldraw-offline")]
+        : [
+            join(
+              process.env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local"),
+              "Programs",
+              "tldraw offline",
+              "tldraw offline.exe",
+            ),
+          ]
+  for (const candidate of candidates) if (await pathExists(candidate)) return candidate
+  return null
+}
+
+function serverFilePath(): string {
+  if (hostPlatform() === "darwin") {
+    return join(homedir(), "Library", "Application Support", "tldraw", "server.json")
+  }
+  if (hostPlatform() === "win32") {
+    return join(process.env.APPDATA ?? join(homedir(), "AppData", "Roaming"), "tldraw", "server.json")
+  }
+  return join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "tldraw", "server.json")
+}
+
+export async function desktopStatus(): Promise<{
+  readonly installedPath: string | null
+  readonly server: { readonly port: number; readonly pid: number | null } | null
+}> {
+  const installedPath = await findDesktopApplication()
+  const filePath = serverFilePath()
+  if (!(await pathExists(filePath))) return { installedPath, server: null }
+  try {
+    const parsed = JSON.parse(await readFile(filePath, "utf8")) as unknown
+    if (!isRecord(parsed) || typeof parsed.port !== "number") {
+      return { installedPath, server: null }
+    }
+    return {
+      installedPath,
+      server: {
+        port: parsed.port,
+        pid: typeof parsed.pid === "number" ? parsed.pid : null,
+      },
+    }
+  } catch {
+    return { installedPath, server: null }
+  }
+}
+
+export async function openInDesktop(filePath: string): Promise<void> {
+  const absolutePath = resolve(filePath)
+  if (!(await pathExists(absolutePath))) throw new Error(`File does not exist: ${absolutePath}`)
+  const application = await findDesktopApplication()
+  if (application === null) {
+    throw new Error(
+      `tldraw Offline is not installed. Run "slopcamera canvas install" or visit ${desktopDownloadPage}`,
+    )
+  }
+  if (hostPlatform() === "darwin") {
+    spawnDetached(["open", "-a", application, absolutePath])
+  } else if (hostPlatform() === "win32") {
+    spawnDetached(["cmd.exe", "/d", "/s", "/c", "start", "", absolutePath])
+  } else {
+    spawnDetached([application, absolutePath])
+  }
+}

package/src/fs.ts

@@ -0,0 +1,10 @@
+import { access } from "node:fs/promises"
+
+export async function pathExists(filePath: string): Promise<boolean> {
+  try {
+    await access(filePath)
+    return true
+  } catch {
+    return false
+  }
+}