sootsim 0.1.83 → 0.1.85

package/src/profiles.ts

@@ -0,0 +1,179 @@
+import fs from 'fs'
+import path from 'path'
+import { electronUserDataDir, ensureSootsimHome, profilesDir } from './home-paths'
+
+export const DEFAULT_PROFILE_ID = 'default'
+const PROFILE_INDEX_FILE = 'profiles.json'
+const PROFILE_INDEX_VERSION = 1 as const
+
+export interface StorageProfile {
+  id: string
+  createdAt: string
+  updatedAt: string
+}
+
+interface ProfileIndex {
+  version: 1
+  profiles: StorageProfile[]
+}
+
+export function normalizeProfileId(input: string): string {
+  const id = input.trim()
+  if (!id) throw new Error('profile id is required')
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(id)) {
+    throw new Error(
+      'profile ids must start with a letter or number and contain only letters, numbers, dot, dash, or underscore',
+    )
+  }
+  if (id === '.' || id === '..') throw new Error(`invalid profile id: ${id}`)
+  return id
+}
+
+export function profileIndexPath(): string {
+  return path.join(profilesDir(), PROFILE_INDEX_FILE)
+}
+
+export function electronProfilePartitionName(profileId: string): string {
+  return `sootsim-profile-${normalizeProfileId(profileId)}`
+}
+
+export function electronProfilePartition(profileId: string): string {
+  return `persist:${electronProfilePartitionName(profileId)}`
+}
+
+export function electronProfilePartitionDir(profileId: string): string {
+  return path.join(
+    electronUserDataDir(),
+    'Partitions',
+    electronProfilePartitionName(profileId),
+  )
+}
+
+export function playwrightProfileUserDataDir(profileId: string): string {
+  return path.join(profilesDir(), 'playwright', normalizeProfileId(profileId))
+}
+
+function readIndexRaw(): ProfileIndex {
+  try {
+    const parsed = JSON.parse(
+      fs.readFileSync(profileIndexPath(), 'utf8'),
+    ) as Partial<ProfileIndex> | null
+    if (!parsed || parsed.version !== PROFILE_INDEX_VERSION) {
+      return { version: PROFILE_INDEX_VERSION, profiles: [] }
+    }
+    const profiles = Array.isArray(parsed.profiles)
+      ? parsed.profiles
+          .filter(
+            (profile): profile is StorageProfile =>
+              !!profile &&
+              typeof profile.id === 'string' &&
+              typeof profile.createdAt === 'string' &&
+              typeof profile.updatedAt === 'string',
+          )
+          .map((profile) => ({
+            id: normalizeProfileId(profile.id),
+            createdAt: profile.createdAt,
+            updatedAt: profile.updatedAt,
+          }))
+      : []
+    return { version: PROFILE_INDEX_VERSION, profiles }
+  } catch {
+    return { version: PROFILE_INDEX_VERSION, profiles: [] }
+  }
+}
+
+function sortProfiles(profiles: StorageProfile[]): StorageProfile[] {
+  return [...profiles].sort((a, b) => {
+    if (a.id === DEFAULT_PROFILE_ID) return -1
+    if (b.id === DEFAULT_PROFILE_ID) return 1
+    return a.id.localeCompare(b.id)
+  })
+}
+
+function withDefault(index: ProfileIndex): ProfileIndex {
+  if (index.profiles.some((profile) => profile.id === DEFAULT_PROFILE_ID)) {
+    return { ...index, profiles: sortProfiles(index.profiles) }
+  }
+  const now = new Date().toISOString()
+  return {
+    version: PROFILE_INDEX_VERSION,
+    profiles: sortProfiles([
+      { id: DEFAULT_PROFILE_ID, createdAt: now, updatedAt: now },
+      ...index.profiles,
+    ]),
+  }
+}
+
+function writeIndex(index: ProfileIndex): ProfileIndex {
+  ensureSootsimHome()
+  const next = withDefault(index)
+  const tmp = `${profileIndexPath()}.tmp`
+  fs.writeFileSync(tmp, `${JSON.stringify(next, null, 2)}\n`, 'utf8')
+  fs.renameSync(tmp, profileIndexPath())
+  return next
+}
+
+export function listProfiles(): StorageProfile[] {
+  return writeIndex(readIndexRaw()).profiles
+}
+
+export function getProfile(id: string): StorageProfile | null {
+  const normalized = normalizeProfileId(id)
+  return listProfiles().find((profile) => profile.id === normalized) ?? null
+}
+
+export function ensureProfile(id = DEFAULT_PROFILE_ID): StorageProfile {
+  const normalized = normalizeProfileId(id)
+  const existing = getProfile(normalized)
+  if (existing) return existing
+  return createProfile(normalized)
+}
+
+export function createProfile(id: string): StorageProfile {
+  const normalized = normalizeProfileId(id)
+  const index = withDefault(readIndexRaw())
+  if (index.profiles.some((profile) => profile.id === normalized)) {
+    throw new Error(`profile already exists: ${normalized}`)
+  }
+  const now = new Date().toISOString()
+  const profile = { id: normalized, createdAt: now, updatedAt: now }
+  writeIndex({ version: PROFILE_INDEX_VERSION, profiles: [...index.profiles, profile] })
+  return profile
+}
+
+export function nextGeneratedProfileId(): string {
+  const existing = new Set(listProfiles().map((profile) => profile.id))
+  for (let i = 1; i < 10_000; i++) {
+    const id = `profile-${i}`
+    if (!existing.has(id)) return id
+  }
+  throw new Error('could not allocate a new profile id')
+}
+
+export function deleteProfile(id: string): StorageProfile {
+  const normalized = normalizeProfileId(id)
+  if (normalized === DEFAULT_PROFILE_ID) {
+    throw new Error('the default profile cannot be deleted; clear it instead')
+  }
+  const index = withDefault(readIndexRaw())
+  const profile = index.profiles.find((entry) => entry.id === normalized)
+  if (!profile) throw new Error(`profile not found: ${normalized}`)
+  writeIndex({
+    version: PROFILE_INDEX_VERSION,
+    profiles: index.profiles.filter((entry) => entry.id !== normalized),
+  })
+  clearProfileStorage(normalized)
+  return profile
+}
+
+export function clearProfileStorage(id: string): void {
+  const normalized = normalizeProfileId(id)
+  for (const dir of [
+    electronProfilePartitionDir(normalized),
+    playwrightProfileUserDataDir(normalized),
+  ]) {
+    try {
+      fs.rmSync(dir, { recursive: true, force: true })
+    } catch {}
+  }
+}

package/src/render-mode.ts

@@ -0,0 +1,27 @@
+export type RenderMode = 'worker'
+
+// worker rendering is now the only supported mode.
+export function getRenderMode(_searchParams: URLSearchParams): RenderMode {
+  return 'worker'
+}
+
+export function isRenderWorkerMode(_searchParams: URLSearchParams): boolean {
+  return true
+}
+
+export function isRenderMainMode(_searchParams: URLSearchParams): boolean {
+  return false
+}
+
+export function hasRenderWorkerBootstrap(
+  workerModuleBaseUrl: string | null | undefined,
+): boolean {
+  return typeof workerModuleBaseUrl === 'string' && workerModuleBaseUrl.length > 0
+}
+
+export function shouldEnableRenderWorker(
+  _searchParams: URLSearchParams,
+  workerModuleBaseUrl: string | null | undefined,
+): boolean {
+  return hasRenderWorkerBootstrap(workerModuleBaseUrl)
+}

package/src/runtime-assets.ts

@@ -0,0 +1,84 @@
+// helpers for serving the installed sootsim engine runtime from framework
+// dev servers. the runtime is managed by `sootsim runtime install` and lives
+// under ~/.sootsim/runtimes/<version>.
+
+import fs from 'fs'
+import path from 'path'
+import { readActiveRuntime, runtimeDir } from './home-paths'
+
+export const SOOTSIM_RUNTIME_MISSING_MESSAGE =
+  '[sootsim] no engine runtime installed — run `sootsim setup-repo` in your project, or `sootsim runtime install`'
+
+const MIME_TYPES: Record<string, string> = {
+  '.js': 'application/javascript',
+  '.mjs': 'application/javascript',
+  '.css': 'text/css',
+  '.html': 'text/html',
+  '.wasm': 'application/wasm',
+  '.json': 'application/json',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.png': 'image/png',
+  '.svg': 'image/svg+xml',
+  '.webp': 'image/webp',
+  '.glb': 'model/gltf-binary',
+  '.ttf': 'font/ttf',
+  '.otf': 'font/otf',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+  '.mp3': 'audio/mpeg',
+  '.wav': 'audio/wav',
+}
+
+const ROOT_RUNTIME_PATHS = [
+  '/assets/',
+  '/engine/',
+  '/engine-tenant/',
+  '/photos/',
+  '/three-mode/',
+  '/canvaskit.wasm',
+  '/fonts/',
+  '/icons/',
+  '/sounds/',
+  '/spike/',
+  '/test-wallpaper.jpg',
+  '/preview-sw.js',
+]
+
+export function resolveActiveRuntimeRoot(): string | null {
+  const active = readActiveRuntime()
+  if (!active) return null
+  const dir = runtimeDir(active)
+  if (!fs.existsSync(path.join(dir, 'index.html'))) return null
+  return dir
+}
+
+export function isRootRuntimeAssetPath(pathname: string): boolean {
+  return ROOT_RUNTIME_PATHS.some((p) => pathname === p || pathname.startsWith(p))
+}
+
+export function resolveRuntimeFilePath(
+  runtimeRoot: string,
+  pathname: string,
+): string | null {
+  if (!pathname.startsWith('/')) return null
+  if (pathname.includes('\0') || pathname.includes('\\')) return null
+  for (const segment of pathname.split('/')) {
+    if (segment === '..') return null
+  }
+
+  const fullPath = path.resolve(runtimeRoot, pathname.replace(/^\/+/, ''))
+  const rootWithSep = runtimeRoot.endsWith(path.sep)
+    ? runtimeRoot
+    : runtimeRoot + path.sep
+  if (!fullPath.startsWith(rootWithSep) && fullPath !== runtimeRoot) return null
+  if (!fs.existsSync(fullPath) || !fs.statSync(fullPath).isFile()) return null
+  return fullPath
+}
+
+export function serveRuntimeFile(res: any, fullPath: string) {
+  const ext = path.extname(fullPath)
+  res.setHeader('content-type', MIME_TYPES[ext] || 'application/octet-stream')
+  res.setHeader('cache-control', 'max-age=31536000,immutable')
+  fs.createReadStream(fullPath).pipe(res)
+}

package/src/runtime-delivery.ts

@@ -0,0 +1,334 @@
+import { spawn } from 'child_process'
+import crypto from 'crypto'
+import fs from 'fs'
+import path from 'path'
+import { Readable } from 'stream'
+import { pipeline } from 'stream/promises'
+import {
+  cacheDir,
+  compareSemver,
+  configFilePath,
+  ensureSootsimHome,
+  readActiveRuntime,
+  runtimeDir,
+  writeActiveRuntime,
+} from './home-paths'
+
+export const DEFAULT_RUNTIME_CDN_ORIGIN = 'https://sootbean.com'
+export const RUNTIME_CDN_ORIGIN_ENV = 'SOOTSIM_CDN_ORIGIN'
+export const RUNTIME_CHANNEL_ENV = 'SOOTSIM_RUNTIME_CHANNEL'
+
+export interface RuntimeManifestChannel {
+  latest: string
+}
+
+export interface RuntimeManifestVersion {
+  tarball?: string
+  sha256: string
+  size?: number
+  published?: string
+}
+
+export interface RuntimeManifest {
+  channels: Record<string, RuntimeManifestChannel>
+  versions: Record<string, RuntimeManifestVersion>
+}
+
+export interface RuntimeInstallOptions {
+  version?: string | null
+  channel?: string
+  cdnOrigin?: string
+  force?: boolean
+  setActive?: boolean
+}
+
+export interface RuntimeInstallResult {
+  version: string
+  channel: string
+  cdnOrigin: string
+  runtimeDir: string
+  installed: boolean
+  activated: boolean
+  manifest: RuntimeManifest
+}
+
+export interface RuntimeUpdateResult {
+  checked: boolean
+  updated: boolean
+  reason?: string
+  activeVersion: string | null
+  latestVersion?: string
+  install?: RuntimeInstallResult
+}
+
+interface SootsimConfig {
+  runtimeChannel?: string
+  cdnOrigin?: string
+}
+
+function readConfig(): SootsimConfig {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(configFilePath(), 'utf8')) as SootsimConfig
+    return parsed && typeof parsed === 'object' ? parsed : {}
+  } catch {
+    return {}
+  }
+}
+
+export function resolveRuntimeCdnOrigin(input?: string): string {
+  const config = readConfig()
+  const value =
+    input ||
+    process.env[RUNTIME_CDN_ORIGIN_ENV] ||
+    config.cdnOrigin ||
+    DEFAULT_RUNTIME_CDN_ORIGIN
+  return value.replace(/\/+$/, '')
+}
+
+export function resolveRuntimeChannel(input?: string): string {
+  const config = readConfig()
+  return input || process.env[RUNTIME_CHANNEL_ENV] || config.runtimeChannel || 'stable'
+}
+
+export function runtimeManifestUrl(cdnOrigin?: string): string {
+  const url = new URL(`${resolveRuntimeCdnOrigin(cdnOrigin)}/runtimes/manifest.json`)
+  // cdn edges can keep the no-query manifest around longer than its
+  // max-age. runtime checks need the latest manifest every time.
+  url.searchParams.set('t', String(Date.now()))
+  return url.toString()
+}
+
+export function runtimeTarballUrl(version: string, cdnOrigin?: string): string {
+  return `${resolveRuntimeCdnOrigin(cdnOrigin)}/runtimes/sootsim-runtime-${version}.tar.gz`
+}
+
+export async function fetchRuntimeManifest(cdnOrigin?: string): Promise<RuntimeManifest> {
+  const url = runtimeManifestUrl(cdnOrigin)
+  const res = await fetch(url, { headers: { Accept: 'application/json' } })
+  if (!res.ok) {
+    throw new Error(`manifest fetch failed: ${res.status} ${res.statusText} (${url})`)
+  }
+  return (await res.json()) as RuntimeManifest
+}
+
+export function resolveRuntimeVersion(
+  manifest: RuntimeManifest,
+  opts: Pick<RuntimeInstallOptions, 'version' | 'channel'> = {},
+): { version: string; channel: string; entry: RuntimeManifestVersion } {
+  const channel = resolveRuntimeChannel(opts.channel)
+  const version = opts.version || manifest.channels[channel]?.latest
+  if (!version) {
+    throw new Error(
+      `no version specified and channel '${channel}' has no latest entry in the manifest`,
+    )
+  }
+  const entry = manifest.versions[version]
+  if (!entry) {
+    throw new Error(
+      `version ${version} not found in manifest; available: ${
+        Object.keys(manifest.versions).slice(-10).join(', ') || '(none)'
+      }`,
+    )
+  }
+  return { version, channel, entry }
+}
+
+export async function installRuntime(
+  opts: RuntimeInstallOptions = {},
+): Promise<RuntimeInstallResult> {
+  ensureSootsimHome()
+
+  const cdnOrigin = resolveRuntimeCdnOrigin(opts.cdnOrigin)
+  const manifest = await fetchRuntimeManifest(cdnOrigin)
+  const { version, channel, entry } = resolveRuntimeVersion(manifest, opts)
+  const destDir = runtimeDir(version)
+  const setActive = opts.setActive !== false
+
+  if (!opts.force && fs.existsSync(path.join(destDir, 'index.html'))) {
+    if (setActive) writeActiveRuntime(version)
+    return {
+      version,
+      channel,
+      cdnOrigin,
+      runtimeDir: destDir,
+      installed: false,
+      activated: setActive,
+      manifest,
+    }
+  }
+
+  const tarUrl = entry.tarball || runtimeTarballUrl(version, cdnOrigin)
+  const tarCachePath = path.join(cacheDir(), `sootsim-runtime-${version}.tar.gz`)
+  process.stderr.write(`sootsim: downloading runtime ${version}…\n`)
+  await downloadToFile(tarUrl, tarCachePath)
+  process.stderr.write(`sootsim: extracting runtime ${version}…\n`)
+
+  const actualSha = await sha256File(tarCachePath)
+  if (actualSha !== entry.sha256) {
+    fs.rmSync(tarCachePath, { force: true })
+    throw new Error(
+      `sha256 mismatch for runtime ${version}: expected ${entry.sha256}, actual ${actualSha}`,
+    )
+  }
+
+  const tmpDir = path.join(path.dirname(destDir), `.installing-${version}-${process.pid}`)
+  fs.rmSync(tmpDir, { recursive: true, force: true })
+  fs.mkdirSync(tmpDir, { recursive: true })
+  try {
+    await extractTarball(tarCachePath, tmpDir)
+    if (!fs.existsSync(path.join(tmpDir, 'index.html'))) {
+      throw new Error(`extracted tarball for runtime ${version} is missing index.html`)
+    }
+    fs.rmSync(destDir, { recursive: true, force: true })
+    fs.renameSync(tmpDir, destDir)
+  } catch (err) {
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+    throw err
+  }
+
+  if (setActive) writeActiveRuntime(version)
+  return {
+    version,
+    channel,
+    cdnOrigin,
+    runtimeDir: destDir,
+    installed: true,
+    activated: setActive,
+    manifest,
+  }
+}
+
+export async function updateRuntimeToLatest(
+  opts: Pick<RuntimeInstallOptions, 'channel' | 'cdnOrigin'> = {},
+): Promise<RuntimeUpdateResult> {
+  ensureSootsimHome()
+  const cdnOrigin = resolveRuntimeCdnOrigin(opts.cdnOrigin)
+  const channel = resolveRuntimeChannel(opts.channel)
+  const manifest = await fetchRuntimeManifest(cdnOrigin)
+  const latestVersion = manifest.channels[channel]?.latest
+  if (!latestVersion) {
+    return {
+      checked: true,
+      updated: false,
+      reason: `channel '${channel}' has no latest runtime`,
+      activeVersion: readActiveRuntime(),
+    }
+  }
+  const entry = manifest.versions[latestVersion]
+  if (!entry) {
+    return {
+      checked: true,
+      updated: false,
+      reason: `manifest is missing version ${latestVersion}`,
+      activeVersion: readActiveRuntime(),
+      latestVersion,
+    }
+  }
+
+  const activeVersion = readActiveRuntime()
+  const activeDir = activeVersion ? runtimeDir(activeVersion) : null
+  const activeInstalled = activeDir
+    ? fs.existsSync(path.join(activeDir, 'index.html'))
+    : false
+  const shouldInstall =
+    !activeVersion || !activeInstalled || compareSemver(latestVersion, activeVersion) > 0
+
+  if (!shouldInstall) {
+    return {
+      checked: true,
+      updated: false,
+      reason: 'active runtime is current',
+      activeVersion,
+      latestVersion,
+    }
+  }
+
+  // setActive=false: callers like the daemon flip the active runtime
+  // themselves so they can broadcast runtime:changed to connected
+  // browsers. CLI install uses installRuntime() directly with
+  // setActive=true and is unaffected.
+  const install = await installRuntime({
+    version: latestVersion,
+    channel,
+    cdnOrigin,
+    setActive: false,
+  })
+  return {
+    checked: true,
+    updated: true,
+    activeVersion: latestVersion,
+    latestVersion,
+    install,
+  }
+}
+
+export interface RuntimeUpToDateCheck {
+  active: string | null
+  latest: string | null
+  // true only when a latest version is known and it is newer than the
+  // active one (or nothing is active yet). network failures resolve to
+  // false so callers can treat this as a best-effort hint.
+  outdated: boolean
+}
+
+/** read-only check: is the active runtime the latest on its channel?
+ *  unlike updateRuntimeToLatest this never downloads or activates — it's
+ *  for surfacing a "newer runtime available" hint at startup / in help. */
+export async function checkRuntimeUpToDate(
+  opts: Pick<RuntimeInstallOptions, 'channel' | 'cdnOrigin'> = {},
+): Promise<RuntimeUpToDateCheck> {
+  const active = readActiveRuntime()
+  try {
+    const manifest = await fetchRuntimeManifest(resolveRuntimeCdnOrigin(opts.cdnOrigin))
+    const channel = resolveRuntimeChannel(opts.channel)
+    const latest = manifest.channels[channel]?.latest ?? null
+    const outdated = !!(latest && (!active || compareSemver(latest, active) > 0))
+    return { active, latest, outdated }
+  } catch {
+    return { active, latest: null, outdated: false }
+  }
+}
+
+async function downloadToFile(url: string, destPath: string): Promise<void> {
+  const res = await fetch(url)
+  if (!res.ok || !res.body) {
+    throw new Error(`download failed: ${res.status} ${res.statusText} (${url})`)
+  }
+  fs.mkdirSync(path.dirname(destPath), { recursive: true })
+  const tmp = `${destPath}.partial`
+  try {
+    await pipeline(
+      Readable.fromWeb(res.body as unknown as Parameters<typeof Readable.fromWeb>[0]),
+      fs.createWriteStream(tmp),
+    )
+    fs.renameSync(tmp, destPath)
+  } catch (err) {
+    try {
+      fs.unlinkSync(tmp)
+    } catch {}
+    throw err
+  }
+}
+
+function sha256File(filePath: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash('sha256')
+    const stream = fs.createReadStream(filePath)
+    stream.on('data', (chunk) => hash.update(chunk))
+    stream.on('error', reject)
+    stream.on('end', () => resolve(hash.digest('hex')))
+  })
+}
+
+function extractTarball(tarPath: string, destDir: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = spawn('tar', ['-xzf', tarPath, '-C', destDir], {
+      stdio: ['ignore', 'inherit', 'inherit'],
+    })
+    child.on('error', reject)
+    child.on('exit', (code) => {
+      if (code === 0) resolve()
+      else reject(new Error(`tar exited with code ${code}`))
+    })
+  })
+}