rnxsim 0.0.0 → 0.1.312

package/src/auth/shared-session.ts

@@ -0,0 +1,204 @@
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+import { electronUserDataDir } from '../home-paths'
+
+export type SharedDesktopAuthTeamSummary = {
+  id: string
+  name: string
+  role: 'owner' | 'member'
+  githubOrg: string | null
+}
+
+export type SharedDesktopAuthUser = {
+  id: string
+  name?: string
+  email?: string
+  image?: string
+  githubUsername?: string
+  teams?: SharedDesktopAuthTeamSummary[]
+  isAdmin?: boolean
+}
+
+export type SharedDesktopAuthSession = {
+  version: 1
+  token: string
+  user: SharedDesktopAuthUser | null
+  origin: string
+  source: 'cli' | 'electron' | 'browser' | 'unknown'
+  updatedAt: string
+  validatedAt?: string
+}
+
+const SESSION_VERSION = 1 as const
+const SESSION_FILE_ENV = 'SOOTSIM_SHARED_AUTH_FILE'
+const DEFAULT_ORIGIN = 'https://contrast.dev'
+
+function getBaseDir() {
+  const explicit = process.env[SESSION_FILE_ENV]
+  if (explicit?.trim()) {
+    return dirname(resolve(explicit))
+  }
+  return electronUserDataDir()
+}
+
+export function getSharedDesktopAuthFilePath() {
+  const explicit = process.env[SESSION_FILE_ENV]
+  if (explicit?.trim()) return resolve(explicit)
+  return join(getBaseDir(), 'desktop-auth.json')
+}
+
+function normalizeUser(input: unknown): SharedDesktopAuthUser | null {
+  if (!input || typeof input !== 'object') return null
+  const value = input as Record<string, unknown>
+  if (typeof value.id !== 'string' || !value.id.trim()) return null
+  return {
+    id: value.id.trim(),
+    name: typeof value.name === 'string' ? value.name : undefined,
+    email: typeof value.email === 'string' ? value.email : undefined,
+    image: typeof value.image === 'string' ? value.image : undefined,
+    githubUsername:
+      typeof value.githubUsername === 'string' ? value.githubUsername : undefined,
+    isAdmin: value.isAdmin === true,
+    teams: Array.isArray(value.teams)
+      ? value.teams
+          .map((team): SharedDesktopAuthTeamSummary | null => {
+            if (!team || typeof team !== 'object') return null
+            const t = team as Record<string, unknown>
+            if (typeof t.id !== 'string' || typeof t.name !== 'string') return null
+            return {
+              id: t.id,
+              name: t.name,
+              role: t.role === 'owner' ? 'owner' : 'member',
+              githubOrg: typeof t.githubOrg === 'string' ? t.githubOrg : null,
+            }
+          })
+          .filter((team): team is SharedDesktopAuthTeamSummary => !!team)
+      : undefined,
+  }
+}
+
+function normalizeSession(input: unknown): SharedDesktopAuthSession | null {
+  if (!input || typeof input !== 'object') return null
+  const value = input as Record<string, unknown>
+  if (value.version !== SESSION_VERSION) return null
+  if (typeof value.token !== 'string' || !value.token.trim()) return null
+  const origin =
+    typeof value.origin === 'string' && value.origin.trim()
+      ? value.origin.trim()
+      : DEFAULT_ORIGIN
+  const source =
+    value.source === 'cli' ||
+    value.source === 'electron' ||
+    value.source === 'browser' ||
+    value.source === 'unknown'
+      ? value.source
+      : 'unknown'
+  const updatedAt =
+    typeof value.updatedAt === 'string' && value.updatedAt
+      ? value.updatedAt
+      : new Date().toISOString()
+  const validatedAt =
+    typeof value.validatedAt === 'string' && value.validatedAt
+      ? value.validatedAt
+      : undefined
+
+  return {
+    version: SESSION_VERSION,
+    token: value.token.trim(),
+    user: normalizeUser(value.user),
+    origin,
+    source,
+    updatedAt,
+    validatedAt,
+  }
+}
+
+export function readSharedDesktopAuthSession(): SharedDesktopAuthSession | null {
+  const filepath = getSharedDesktopAuthFilePath()
+  if (!existsSync(filepath)) return null
+
+  try {
+    const parsed = JSON.parse(readFileSync(filepath, 'utf8')) as unknown
+    const normalized = normalizeSession(parsed)
+    if (!normalized) {
+      rmSync(filepath, { force: true })
+      return null
+    }
+    return normalized
+  } catch {
+    rmSync(filepath, { force: true })
+    return null
+  }
+}
+
+export function writeSharedDesktopAuthSession(
+  session: Omit<SharedDesktopAuthSession, 'version' | 'updatedAt'> & {
+    updatedAt?: string
+  },
+) {
+  const filepath = getSharedDesktopAuthFilePath()
+  mkdirSync(dirname(filepath), { recursive: true })
+  const normalized: SharedDesktopAuthSession = {
+    version: SESSION_VERSION,
+    token: session.token.trim(),
+    user: session.user ? normalizeUser(session.user) : null,
+    origin: session.origin?.trim() || DEFAULT_ORIGIN,
+    source: session.source,
+    updatedAt: session.updatedAt || new Date().toISOString(),
+    validatedAt: session.validatedAt,
+  }
+  writeFileSync(filepath, JSON.stringify(normalized, null, 2) + '\n')
+  try {
+    chmodSync(filepath, 0o600)
+  } catch {
+    // best-effort only
+  }
+  return normalized
+}
+
+export function clearSharedDesktopAuthSession() {
+  rmSync(getSharedDesktopAuthFilePath(), { force: true })
+}
+
+export async function refreshSharedDesktopAuthSession(
+  originOverride?: string,
+): Promise<SharedDesktopAuthSession | null> {
+  const current = readSharedDesktopAuthSession()
+  if (!current?.token) return null
+
+  const origin = originOverride || current.origin || DEFAULT_ORIGIN
+
+  try {
+    const res = await fetch(`${origin.replace(/\/$/, '')}/api/auth/me`, {
+      headers: { authorization: `Bearer ${current.token}` },
+    })
+    if (res.status === 401) {
+      clearSharedDesktopAuthSession()
+      return null
+    }
+    if (!res.ok) return current
+
+    const data = (await res.json()) as { user?: SharedDesktopAuthUser | null }
+    if (!data.user?.id) {
+      clearSharedDesktopAuthSession()
+      return null
+    }
+
+    return writeSharedDesktopAuthSession({
+      token: current.token,
+      user: data.user,
+      origin,
+      source: current.source,
+      validatedAt: new Date().toISOString(),
+    })
+  } catch {
+    return current
+  }
+}

package/src/backend-origin.ts

@@ -0,0 +1,49 @@
+const DEFAULT_CONTRAST_BACKEND_ORIGIN = 'https://contrast.dev'
+
+function normalizeHostname(hostname: string): string {
+  return hostname.replace(/^\[|\]$/g, '').toLowerCase()
+}
+
+export function isLoopbackHost(hostname: string): boolean {
+  const normalized = normalizeHostname(hostname)
+  return (
+    normalized === 'localhost' ||
+    normalized.endsWith('.localhost') ||
+    normalized === '0.0.0.0' ||
+    normalized === '::1' ||
+    /^127(?:\.\d{1,3}){3}$/.test(normalized)
+  )
+}
+
+export function isContrastBackendHost(hostname: string): boolean {
+  const normalized = normalizeHostname(hostname)
+  return (
+    isLoopbackHost(normalized) ||
+    normalized === 'contrast.dev' ||
+    normalized.endsWith('.contrast.dev')
+  )
+}
+
+export function isContrastBackendOrigin(origin: string): boolean {
+  try {
+    return isContrastBackendHost(new URL(origin).hostname)
+  } catch {
+    return false
+  }
+}
+
+export function resolveContrastBackendOrigin(currentOrigin?: string | null): string {
+  const origin = currentOrigin?.trim()
+  if (!origin) return DEFAULT_CONTRAST_BACKEND_ORIGIN
+
+  try {
+    const parsed = new URL(origin)
+    if (isLoopbackHost(parsed.hostname) || isContrastBackendHost(parsed.hostname)) {
+      return parsed.origin
+    }
+  } catch {}
+
+  return DEFAULT_CONTRAST_BACKEND_ORIGIN
+}
+
+export { DEFAULT_CONTRAST_BACKEND_ORIGIN }

package/src/beta.ts

@@ -0,0 +1,19 @@
+// public beta flag + copy. single source of truth for the badge that
+// appears on the CLI banner, electron title, shell rail pill, and the
+// download page. flip IS_BETA to false when 1.0 ships and the badge
+// disappears everywhere automatically.
+//
+// see plans/sootsim-public-beta.md for the rollout plan.
+
+export const IS_BETA = true
+
+// short label — used on the rail pill, electron title, etc.
+export const BETA_LABEL = 'public beta'
+
+// one-line tagline — used in the CLI banner.
+export const BETA_TAGLINE = BETA_LABEL
+
+// what we ask for in return — kept here so the onboarding flow, the
+// privacy page, and any future surface render the same words.
+export const BETA_ASK_HEADLINE =
+  'we send anonymous error and dependency data while you use it'

package/src/bridge-constants.ts

@@ -0,0 +1,171 @@
+// canonical bridge port for sootsim's WebSocket connection between the CLI
+// and the running engine. matches main — kept in a single module so CLI,
+// dev plugin, and runtime agree on the same value.
+export const DEFAULT_SOOTSIM_BRIDGE_PORT = 7668
+export const DEFAULT_SOOTSIM_BRIDGE_URL = `http://localhost:${DEFAULT_SOOTSIM_BRIDGE_PORT}/`
+
+function parsePort(value: unknown): number | null {
+  if (typeof value === 'number') {
+    return Number.isInteger(value) && value > 0 ? value : null
+  }
+  if (typeof value !== 'string') return null
+  const trimmed = value.trim()
+  if (!trimmed) return null
+  const parsed = Number(trimmed)
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : null
+}
+
+function parsePortOffset(value: unknown): number {
+  const parsed = parsePort(value)
+  return parsed === null ? 0 : parsed
+}
+
+export function resolveSootsimBridgePort(
+  input: {
+    explicitPort?: unknown
+    portOffset?: unknown
+  } = {},
+): number {
+  const explicitPort = parsePort(input.explicitPort)
+  if (explicitPort !== null) return explicitPort
+  return DEFAULT_SOOTSIM_BRIDGE_PORT + parsePortOffset(input.portOffset)
+}
+
+export function resolveSootsimBridgePortForHttpPort(input: {
+  explicitPort?: unknown
+  httpPort?: unknown
+  baseHttpPort: number
+}): number {
+  const explicitPort = parsePort(input.explicitPort)
+  if (explicitPort !== null) return explicitPort
+  const httpPort = parsePort(input.httpPort)
+  const portOffset = httpPort === null ? 0 : Math.max(0, httpPort - input.baseHttpPort)
+  return resolveSootsimBridgePort({ portOffset })
+}
+
+const CONTRAST_DEV_HTTP_BASE_PORT = 3000
+const SOOTSIM_SITE_DEV_HTTP_BASE_PORT = 3001
+const SOOTSIM_SHELL_DEV_HTTP_BASE_PORT = 5173
+const LOCAL_DEV_HTTP_BASE_PORTS = [
+  CONTRAST_DEV_HTTP_BASE_PORT,
+  SOOTSIM_SHELL_DEV_HTTP_BASE_PORT,
+]
+const MAX_LOCAL_DEV_PORT_OFFSET = 2000
+
+function parseHrefUrl(value: unknown): URL | null {
+  if (typeof value !== 'string' || !value.trim()) return null
+  try {
+    return new URL(value)
+  } catch {
+    return null
+  }
+}
+
+function closestLocalDevBaseHttpPort(httpPort: number): number | null {
+  let closest: { basePort: number; offset: number } | null = null
+  for (const basePort of LOCAL_DEV_HTTP_BASE_PORTS) {
+    const offset = httpPort - basePort
+    if (offset < 0 || offset > MAX_LOCAL_DEV_PORT_OFFSET) continue
+    if (!closest || offset < closest.offset) closest = { basePort, offset }
+  }
+  return closest?.basePort ?? null
+}
+
+/** the vite dev shell that shares a world with a bridge port. the two are one
+ *  offset apart by construction (bridge 7668 + N, shell 5173 + N), so a caller
+ *  that pinned an explicit bridge port can name its own shell directly. that
+ *  matters because the dev-bridge lockfile records only the stack that
+ *  heartbeated last: on a machine running several worktree stacks it routinely
+ *  names someone else's shell, and a page opened there while we poll our own
+ *  bridge never connects. null when the port is not a local dev bridge port. */
+export function resolveSootsimShellBaseUrlForBridgePort(
+  bridgePort: number,
+): string | null {
+  const offset = bridgePort - DEFAULT_SOOTSIM_BRIDGE_PORT
+  if (offset < 0 || offset > MAX_LOCAL_DEV_PORT_OFFSET) return null
+  return `http://localhost:${SOOTSIM_SHELL_DEV_HTTP_BASE_PORT + offset}/`
+}
+
+export function resolveSootsimBridgePortForRuntimeLocation(
+  input: {
+    explicitPort?: unknown
+    href?: unknown
+    httpPort?: unknown
+  } = {},
+): number {
+  const explicitPort = parsePort(input.explicitPort)
+  if (explicitPort !== null) return explicitPort
+  const hrefUrl = parseHrefUrl(input.href)
+  const httpPort = parsePort(input.httpPort) ?? parsePort(hrefUrl?.port)
+  if (httpPort === null) return DEFAULT_SOOTSIM_BRIDGE_PORT
+  if (
+    hrefUrl?.pathname.startsWith('/sootsim') &&
+    (hrefUrl.searchParams.has('embed') || hrefUrl.searchParams.has('nativePreview'))
+  ) {
+    return resolveSootsimBridgePortForHttpPort({
+      httpPort,
+      baseHttpPort: CONTRAST_DEV_HTTP_BASE_PORT,
+    })
+  }
+  if (
+    hrefUrl?.pathname.startsWith('/sootsim') &&
+    httpPort >= SOOTSIM_SITE_DEV_HTTP_BASE_PORT &&
+    httpPort <= SOOTSIM_SITE_DEV_HTTP_BASE_PORT + MAX_LOCAL_DEV_PORT_OFFSET
+  ) {
+    return resolveSootsimBridgePortForHttpPort({
+      httpPort,
+      baseHttpPort: SOOTSIM_SITE_DEV_HTTP_BASE_PORT,
+    })
+  }
+  const baseHttpPort = closestLocalDevBaseHttpPort(httpPort)
+  if (baseHttpPort === null) return DEFAULT_SOOTSIM_BRIDGE_PORT
+  return resolveSootsimBridgePortForHttpPort({ httpPort, baseHttpPort })
+}
+
+export function resolveSootsimWebSocketProxyUrl(input: {
+  targetUrl: string
+  href: string
+}): string {
+  const pageUrl = parseHrefUrl(input.href)
+  if (!pageUrl || (pageUrl.protocol !== 'http:' && pageUrl.protocol !== 'https:')) {
+    throw new Error(`invalid rnx websocket proxy page URL: ${input.href}`)
+  }
+  let targetUrl: URL
+  try {
+    targetUrl = new URL(input.targetUrl)
+  } catch {
+    throw new Error(`invalid rnx websocket proxy target URL: ${input.targetUrl}`)
+  }
+  if (targetUrl.protocol !== 'ws:' && targetUrl.protocol !== 'wss:') {
+    throw new Error(`invalid rnx websocket proxy target URL: ${input.targetUrl}`)
+  }
+  const proxyUrl = new URL('/__websocket-proxy', pageUrl)
+  proxyUrl.protocol = pageUrl.protocol === 'https:' ? 'wss:' : 'ws:'
+  proxyUrl.searchParams.set('url', input.targetUrl)
+  return proxyUrl.href
+}
+
+export function resolveSootsimBridgeWebSocketUrl(input: {
+  bridgePort: number
+  href: string
+}): string {
+  return resolveSootsimWebSocketProxyUrl({
+    targetUrl: `ws://localhost:${input.bridgePort}`,
+    href: input.href,
+  })
+}
+
+export function isSootsimBridgeHealth(value: unknown, expectedPort: number): boolean {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    Reflect.get(value, 'ok') === true &&
+    Reflect.get(value, 'bridgePort') === expectedPort
+  )
+}
+
+// private websocket close code used when the daemon intentionally closes a
+// sim. browser clients treat it as terminal and skip their normal reconnect
+// loop; playwright-owned sims use it to close their hosting context.
+export const SOOTSIM_BRIDGE_SIM_CLOSE_CODE = 4001
+export const SOOTSIM_BRIDGE_SIM_CLOSE_REASON = 'sootsim close'

package/src/browser-cache.ts

@@ -0,0 +1,16 @@
+export const DISPOSABLE_BROWSER_CACHE_DIR_NAMES = [
+  'Cache',
+  'Code Cache',
+  'DawnCache',
+  'DawnGraphiteCache',
+  'DawnWebGPUCache',
+  'GPUCache',
+  'GrShaderCache',
+  'ShaderCache',
+] as const
+
+const disposableBrowserCacheDirs = new Set<string>(DISPOSABLE_BROWSER_CACHE_DIR_NAMES)
+
+export function isDisposableBrowserCacheDir(name: string): boolean {
+  return disposableBrowserCacheDirs.has(name)
+}

package/src/cli-constants.ts

@@ -0,0 +1 @@
+export const DEFAULT_SOOTSIM_SHELL_URL = 'http://localhost:5173/'

package/src/cli-version.ts

@@ -0,0 +1,32 @@
+// sootsim CLI version — the `sootsim` npm package version. resolved once
+// and cached. shared by `--version`, `--help`, the `upgrade` command, the
+// startup flow, and the bridge-host (which injects it into the served
+// runtime html as window.__sootsimCliVersion).
+
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { rnxPublicBrand } from './public-brand.ts'
+
+let cached: string | null = null
+
+export function getCliVersion(): string {
+  if (cached != null) return cached
+  // prefer package resolution (works for npm/global installs); fall back to
+  // the package.json next to this module's source for repo / bundled runs.
+  const candidates: Array<() => string> = [
+    () =>
+      fileURLToPath(import.meta.resolve(`${rnxPublicBrand.packageName}/package.json`)),
+    () => fileURLToPath(new URL('../package.json', import.meta.url)),
+  ]
+  for (const resolve of candidates) {
+    try {
+      const version = JSON.parse(readFileSync(resolve(), 'utf8')).version
+      if (typeof version === 'string' && version) {
+        cached = version
+        return cached
+      }
+    } catch {}
+  }
+  cached = '0.0.0'
+  return cached
+}