@owdproject/core 3.3.1 → 4.0.0-alpha.3

package/bin/lib/scaffold.js

@@ -1,197 +0,0 @@
-import { execSync, spawnSync } from 'node:child_process'
-import {
-  cpSync,
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from 'node:fs'
-import { tmpdir } from 'node:os'
-import { basename, dirname, join, resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-const CLIENT_TEMPLATE = resolve(__dirname, '../../../../template')
-const DEFAULT_CLIENT_REPO = 'https://github.com/owdproject/client.git'
-
-/**
- * @param {string} [startDir]
- */
-export function resolveLocalTemplatePath(startDir = process.cwd()) {
-  const fromEnv = process.env.OWD_TEMPLATE_PATH?.trim()
-  if (fromEnv && existsSync(join(fromEnv, 'package.json'))) {
-    return resolve(fromEnv)
-  }
-
-  if (existsSync(join(CLIENT_TEMPLATE, 'package.json'))) {
-    return CLIENT_TEMPLATE
-  }
-
-  let dir = startDir
-  for (;;) {
-    const candidate = join(dir, 'template')
-    if (
-      existsSync(join(candidate, 'package.json')) &&
-      existsSync(join(dir, 'pnpm-workspace.yaml'))
-    ) {
-      return candidate
-    }
-    const parent = dirname(dir)
-    if (parent === dir) break
-    dir = parent
-  }
-
-  return null
-}
-
-/**
- * @param {string} templatePath
- * @param {string} targetDir
- */
-export function copyTemplate(templatePath, targetDir) {
-  cpSync(templatePath, targetDir, { recursive: true, filter: (src) => !src.includes('node_modules') })
-}
-
-/**
- * @param {string} targetDir
- * @param {{ repo?: string, templatePath?: string | null, cwd?: string }} [options]
- */
-export async function cloneTemplate(targetDir, options = {}) {
-  const localTemplate = options.templatePath ?? resolveLocalTemplatePath(options.cwd)
-
-  if (localTemplate) {
-    copyTemplate(localTemplate, targetDir)
-    return { source: 'local', path: localTemplate }
-  }
-
-  const repo = options.repo ?? DEFAULT_CLIENT_REPO
-  const tempParent = mkdtempSync(join(tmpdir(), 'owd-scaffold-'))
-  const tempClone = join(tempParent, 'client')
-
-  try {
-    execSync(`git clone --depth 1 ${JSON.stringify(repo)} ${JSON.stringify(tempClone)}`, {
-      stdio: 'inherit',
-    })
-
-    const templatePath = join(tempClone, 'template')
-    if (!existsSync(templatePath)) {
-      throw new Error('Template directory does not exist in the cloned repository.')
-    }
-
-    copyTemplate(templatePath, targetDir)
-    return { source: 'git', path: repo }
-  } finally {
-    try {
-      rmSync(tempParent, { recursive: true, force: true })
-    } catch {
-      /* ignore */
-    }
-  }
-}
-
-/**
- * @param {string} targetDir
- */
-export function runPostScaffold(targetDir) {
-  execSync('pnpm install', { cwd: targetDir, stdio: 'inherit' })
-}
-
-export function canLaunchUi() {
-  return Boolean(process.stdout.isTTY) && !process.env.CI
-}
-
-/**
- * @param {string} targetDir
- * @param {string} [commandName]
- */
-export function launchControlPanel(targetDir, commandName = 'desktop') {
-  const relDir = basename(targetDir)
-
-  if (!canLaunchUi()) {
-    console.log(`\nNext: cd ${relDir} && pnpm desktop\n`)
-    return false
-  }
-
-  console.log('\nOpening control panel…\n')
-  const result = spawnSync('pnpm', ['exec', commandName], {
-    cwd: targetDir,
-    stdio: 'inherit',
-    shell: false,
-  })
-
-  if (result.status !== 0 && result.status !== null) {
-    console.log(`\nControl panel exited. Run again with: cd ${relDir} && pnpm desktop\n`)
-  }
-
-  return true
-}
-
-/**
- * @param {{ dir?: string, cwd?: string, commandName?: string, skipInstall?: boolean, skipUi?: boolean, repo?: string }} [options]
- */
-export async function scaffoldProject(options = {}) {
-  const cwd = options.cwd ?? process.cwd()
-  const dir = (options.dir ?? 'owd-client').trim()
-  const commandName = options.commandName ?? 'desktop'
-
-  if (!dir) {
-    throw new Error('Project directory name is required.')
-  }
-
-  const targetDir = resolve(cwd, dir)
-
-  if (existsSync(targetDir)) {
-    if (existsSync(join(targetDir, 'package.json'))) {
-      throw new Error(`Directory "${dir}" already exists and contains a package.json.`)
-    }
-    throw new Error(`Directory "${dir}" already exists.`)
-  }
-
-  mkdirSync(targetDir, { recursive: true })
-
-  console.log(`\nScaffolding Open Web Desktop project in ${dir}/…\n`)
-  const cloneResult = await cloneTemplate(targetDir, {
-    repo: options.repo,
-    cwd,
-  })
-
-  if (cloneResult.source === 'local') {
-    console.log(`Using local template: ${cloneResult.path}\n`)
-  }
-
-  if (!options.skipInstall) {
-    console.log('Installing dependencies (pnpm install)…\n')
-    runPostScaffold(targetDir)
-  }
-
-  console.log('\n✓ Project ready\n')
-
-  if (!options.skipUi) {
-    const launched = launchControlPanel(targetDir, commandName)
-    if (launched) {
-      console.log(`\nLater: cd ${dir} && pnpm run dev · pnpm desktop\n`)
-    } else {
-      console.log(`  cd ${dir}`)
-      console.log('  pnpm desktop       # control panel ([m] menu, [s] start, [x] stop, [R] reboot)')
-      console.log('  pnpm run dev       # Nuxt dev server\n')
-    }
-  } else {
-    console.log(`  cd ${dir}`)
-    console.log('  pnpm desktop')
-    console.log('  pnpm run dev\n')
-  }
-
-  return { targetDir, dir }
-}
-
-/** Copy scaffold.js into create-owd for npm publish (run from repo root). */
-export function vendorScaffoldForCreateOwd(createOwdRoot) {
-  const src = join(__dirname, 'scaffold.js')
-  const destDir = join(createOwdRoot, 'src/lib')
-  const dest = join(destDir, 'scaffold.js')
-  mkdirSync(destDir, { recursive: true })
-  writeFileSync(dest, readFileSync(src, 'utf8'))
-  return dest
-}

package/bin/lib/status.js

@@ -1,289 +0,0 @@
-import { execSync, spawn } from 'node:child_process'
-import {
-  existsSync,
-  readFileSync,
-  mkdirSync,
-  writeFileSync,
-  unlinkSync,
-  appendFileSync,
-} from 'node:fs'
-import { join } from 'node:path'
-import { desktopMetaDir } from './workspace.js'
-import {
-  devSpawnCwd,
-  devTargetLogLabel,
-  normalizeDevTarget,
-} from './playgroundContext.js'
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms))
-}
-
-export function devPidPath(workspaceRoot) {
-  return join(desktopMetaDir(workspaceRoot), 'dev.pid')
-}
-
-export function devLogPath(workspaceRoot) {
-  return join(desktopMetaDir(workspaceRoot), 'dev.log')
-}
-
-function readPidFile(workspaceRoot) {
-  const path = devPidPath(workspaceRoot)
-  if (!existsSync(path)) return null
-  const pid = Number.parseInt(readFileSync(path, 'utf8').trim(), 10)
-  if (!Number.isFinite(pid)) return null
-  try {
-    process.kill(pid, 0)
-    return pid
-  } catch {
-    try {
-      unlinkSync(path)
-    } catch {
-      /* ignore */
-    }
-    return null
-  }
-}
-
-export function findDevProcess() {
-  const patterns = [
-    'nuxt dev',
-    'nuxi dev',
-    'nx run desktop:serve',
-    'node.*\\.nuxt',
-    'desktop.*nuxt',
-  ]
-
-  for (const pattern of patterns) {
-    try {
-      const out = execSync(`pgrep -af ${JSON.stringify(pattern)}`, {
-        encoding: 'utf8',
-        stdio: ['ignore', 'pipe', 'ignore'],
-      })
-      for (const line of out.split('\n').filter(Boolean)) {
-        if (line.includes('pgrep')) continue
-        const pid = Number.parseInt(line.trim().split(/\s+/)[0], 10)
-        if (Number.isFinite(pid)) return { pid, cmdline: line.trim() }
-      }
-    } catch {
-      /* try next pattern */
-    }
-  }
-
-  return null
-}
-
-export function findProcessOnPort(port) {
-  try {
-    const out = execSync(`ss -tlnp 2>/dev/null | grep :${port} || lsof -i :${port} -t 2>/dev/null | head -1`, {
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'ignore'],
-    })
-    const pidMatch = out.match(/pid=(\d+)/) ?? out.match(/^(\d+)/m)
-    if (pidMatch) {
-      const pid = Number.parseInt(pidMatch[1], 10)
-      if (Number.isFinite(pid)) return pid
-    }
-  } catch {
-    /* ignore */
-  }
-  return null
-}
-
-export function readProcessStats(pid) {
-  if (!pid || !existsSync(`/proc/${pid}/status`)) {
-    return { memMb: 0, threads: 0, rssKb: 0 }
-  }
-
-  try {
-    const status = readFileSync(`/proc/${pid}/status`, 'utf8')
-    const vmRss = status.match(/^VmRSS:\s+(\d+)/m)?.[1]
-    const threads = status.match(/^Threads:\s+(\d+)/m)?.[1]
-    const rssKb = vmRss ? Number(vmRss) : 0
-    return {
-      memMb: rssKb ? Math.round(rssKb / 1024) : 0,
-      rssKb,
-      threads: threads ? Number(threads) : 0,
-    }
-  } catch {
-    return { memMb: 0, threads: 0, rssKb: 0 }
-  }
-}
-
-const SPARK_CHARS = '▁▂▃▄▅▆▇█'
-
-/** @param {number[]} samples RSS in MiB */
-export function formatSparkline(samples) {
-  if (!samples.length) return '—'
-  const min = Math.min(...samples)
-  const max = Math.max(...samples)
-  const span = max - min || 1
-  return samples
-    .map((v) => {
-      const idx = Math.min(
-        SPARK_CHARS.length - 1,
-        Math.floor(((v - min) / span) * (SPARK_CHARS.length - 1)),
-      )
-      return SPARK_CHARS[idx]
-    })
-    .join('')
-}
-
-/** @param {number} value @param {number} max @param {number} [width] */
-export function formatBar(value, max, width = 12) {
-  if (max <= 0) return '░'.repeat(width)
-  const filled = Math.round((value / max) * width)
-  return '█'.repeat(Math.min(width, filled)) + '░'.repeat(Math.max(0, width - filled))
-}
-
-export async function probeDevServer(port) {
-  const url = `http://127.0.0.1:${port}/`
-  try {
-    const controller = new AbortController()
-    const timer = setTimeout(() => controller.abort(), 1200)
-    const res = await fetch(url, { signal: controller.signal, redirect: 'manual' })
-    clearTimeout(timer)
-    return { up: true, status: res.status, url }
-  } catch {
-    return { up: false, status: 0, url }
-  }
-}
-
-export async function getClientStatus(workspaceRoot, port) {
-  const http = await probeDevServer(port)
-  const fromFile = readPidFile(workspaceRoot)
-  const fromPg = findDevProcess()
-  const portPid = findProcessOnPort(port)
-
-  const pid = fromPg?.pid ?? portPid ?? fromFile ?? null
-  const stats = pid ? readProcessStats(pid) : { memMb: 0, threads: 0 }
-  const running = http.up || Boolean(fromPg) || Boolean(portPid) || Boolean(fromFile)
-
-  return {
-    running,
-    pid,
-    http,
-    stats,
-    port,
-    cmdline: fromPg?.cmdline ?? null,
-  }
-}
-
-let devChild = null
-
-/**
- * @param {import('./playgroundContext.js').DevTarget | string} target
- */
-export function startDev(target) {
-  const resolved = normalizeDevTarget(target)
-  if (!resolved) {
-    throw new Error('startDev: missing workspace root')
-  }
-
-  const { workspaceRoot } = resolved
-  const spawnCwd = devSpawnCwd(resolved)
-
-  if (devChild?.pid) {
-    try {
-      process.kill(devChild.pid, 0)
-      return devChild
-    } catch {
-      devChild = null
-    }
-  }
-
-  mkdirSync(desktopMetaDir(workspaceRoot), { recursive: true })
-  const logPath = devLogPath(workspaceRoot)
-
-  devChild = spawn('pnpm', ['run', 'dev'], {
-    cwd: spawnCwd,
-    detached: true,
-    stdio: ['ignore', 'pipe', 'pipe'],
-  })
-
-  const appendLog = (chunk) => {
-    try {
-      appendFileSync(logPath, chunk)
-    } catch {
-      /* ignore */
-    }
-  }
-  try {
-    appendFileSync(
-      logPath,
-      `[owd] dev target: ${devTargetLogLabel(resolved)} (cwd ${spawnCwd})\n`,
-    )
-  } catch {
-    /* ignore */
-  }
-  devChild.stdout?.on('data', appendLog)
-  devChild.stderr?.on('data', appendLog)
-
-  devChild.unref()
-  writeFileSync(devPidPath(workspaceRoot), String(devChild.pid))
-  return devChild
-}
-
-export function stopDev(workspaceRoot, pid) {
-  const targets = new Set([pid, readPidFile(workspaceRoot)].filter(Boolean))
-
-  for (const p of targets) {
-    try {
-      process.kill(-p, 'SIGTERM')
-    } catch {
-      try {
-        process.kill(p, 'SIGTERM')
-      } catch {
-        /* ignore */
-      }
-    }
-  }
-
-  try {
-    unlinkSync(devPidPath(workspaceRoot))
-  } catch {
-    /* ignore */
-  }
-
-  devChild = null
-  return targets.size > 0
-}
-
-export async function waitForDev(workspaceRoot, port, timeoutMs = 90_000) {
-  const started = Date.now()
-  while (Date.now() - started < timeoutMs) {
-    const status = await getClientStatus(workspaceRoot, port)
-    if (status.http.up) return status
-    await sleep(1500)
-  }
-  return getClientStatus(workspaceRoot, port)
-}
-
-export function runScript(workspaceRoot, script) {
-  return spawn('pnpm', ['run', script], {
-    cwd: workspaceRoot,
-    stdio: 'inherit',
-    shell: false,
-  })
-}
-
-/** Run dev in the foreground (`desktop dev`). */
-export function runDevForeground(target) {
-  const resolved = normalizeDevTarget(target)
-  if (!resolved) {
-    console.error('Not inside an OWD workspace.')
-    process.exit(1)
-  }
-
-  const spawnCwd = devSpawnCwd(resolved)
-  if (resolved.mode === 'playground' && resolved.packageName) {
-    console.log(`Starting playground: ${resolved.packageName}`)
-  }
-
-  const child = spawn('pnpm', ['run', 'dev'], {
-    cwd: spawnCwd,
-    stdio: 'inherit',
-    shell: false,
-  })
-  child.on('exit', (code) => process.exit(code ?? 0))
-}