oneworks 0.0.0 → 0.1.0-alpha.0

package/src/progress.ts

@@ -0,0 +1,174 @@
+import process from 'node:process'
+
+const BAR_WIDTH = 24
+const PULSE_WIDTH = 7
+const TICK_MS = 120
+const SPINNER_FRAMES = ['-', '\\', '|', '/']
+
+export interface BootstrapProgress {
+  fail: (summary?: string) => void
+  finish: (summary?: string) => void
+  setTotal: (total: number | undefined) => void
+  update: (completed: number, total?: number) => void
+}
+
+const isTestRun = () => process.env.VITEST != null || process.env.VITEST_WORKER_ID != null
+
+const formatElapsed = (startedAt: number) => {
+  const totalSeconds = Math.max(0, Math.floor((Date.now() - startedAt) / 1000))
+  const minutes = Math.floor(totalSeconds / 60)
+  const seconds = totalSeconds % 60
+  return `${minutes}:${seconds.toString().padStart(2, '0')}`
+}
+
+const formatBytes = (bytes: number) => {
+  const normalized = Math.max(0, bytes)
+  if (normalized < 1024) return `${normalized} B`
+
+  const units = ['KB', 'MB', 'GB', 'TB']
+  let value = normalized / 1024
+  let unitIndex = 0
+  while (value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024
+    unitIndex += 1
+  }
+
+  return `${value >= 10 ? value.toFixed(1) : value.toFixed(2)} ${units[unitIndex]}`
+}
+
+const normalizeTotal = (total: number | undefined) => (
+  total != null && Number.isFinite(total) && total > 0 ? total : undefined
+)
+
+const trimToWidth = (value: string, width: number) => (
+  value.length <= width ? value : `${value.slice(0, Math.max(0, width - 3))}...`
+)
+
+const buildDeterminateBar = (completed: number, total: number) => {
+  const ratio = Math.max(0, Math.min(1, completed / total))
+  const filled = Math.max(0, Math.min(BAR_WIDTH, Math.round(ratio * BAR_WIDTH)))
+  return `${'#'.repeat(filled)}${'.'.repeat(BAR_WIDTH - filled)}`
+}
+
+const buildIndeterminateBar = (frame: number) => {
+  const position = frame % (BAR_WIDTH + PULSE_WIDTH)
+  const start = position - PULSE_WIDTH
+  return Array.from({ length: BAR_WIDTH }, (_, index) => (
+    index >= start && index < position ? '#' : '.'
+  )).join('')
+}
+
+export const createBootstrapProgress = (params: {
+  enabled?: boolean
+  label: string
+  total?: number
+}): BootstrapProgress => {
+  const enabled = params.enabled !== false && !isTestRun()
+  const startedAt = Date.now()
+  const tty = Boolean(process.stderr.isTTY)
+  let completed = 0
+  let failed = false
+  let frame = 0
+  let interval: NodeJS.Timeout | undefined
+  let stopped = false
+  let total = normalizeTotal(params.total)
+  let wrote = false
+
+  const buildLine = (summary?: string) => {
+    const hasTotal = total != null
+    const progressText = hasTotal
+      ? `${Math.round(Math.max(0, Math.min(1, completed / total)) * 100)}% ${formatBytes(completed)}/${
+        formatBytes(total)
+      }`
+      : stopped && !failed
+      ? 'done'
+      : 'working'
+    const bar = failed
+      ? `${'#'.repeat(Math.max(1, Math.round(BAR_WIDTH / 3)))}${
+        '.'.repeat(
+          BAR_WIDTH - Math.max(1, Math.round(BAR_WIDTH / 3))
+        )
+      }`
+      : hasTotal
+      ? buildDeterminateBar(completed, total)
+      : stopped
+      ? '#'.repeat(BAR_WIDTH)
+      : buildIndeterminateBar(frame)
+    const marker = failed ? '!' : stopped ? ' ' : SPINNER_FRAMES[frame % SPINNER_FRAMES.length]
+    return `[bootstrap] ${marker} [${bar}] ${progressText} ${trimToWidth(summary ?? params.label, 72)} ${
+      formatElapsed(startedAt)
+    }`
+  }
+
+  const stopTicker = () => {
+    if (interval == null) return
+    clearInterval(interval)
+    interval = undefined
+  }
+
+  const render = (summary?: string) => {
+    if (!enabled) return
+    wrote = true
+
+    if (tty) {
+      process.stderr.write(`\r${buildLine(summary)}\x1B[K`)
+      frame += 1
+      return
+    }
+
+    if (!stopped && frame > 0) return
+    process.stderr.write(`${buildLine(summary)}\n`)
+    frame += 1
+  }
+
+  const finishLine = (summary?: string) => {
+    if (!enabled || !wrote) return
+    if (tty) {
+      process.stderr.write(`\r${buildLine(summary)}\x1B[K\n`)
+      return
+    }
+    process.stderr.write(`${buildLine(summary)}\n`)
+  }
+
+  if (enabled) {
+    render()
+    if (tty) {
+      interval = setInterval(() => render(), TICK_MS)
+      interval.unref()
+    }
+  }
+
+  return {
+    setTotal(nextTotal) {
+      total = normalizeTotal(nextTotal)
+      render()
+    },
+    update(nextCompleted, nextTotal) {
+      const normalizedTotal = normalizeTotal(nextTotal)
+      if (normalizedTotal != null) {
+        total = normalizedTotal
+      }
+      completed = Math.max(0, nextCompleted)
+      if (total != null) {
+        completed = Math.min(completed, total)
+      }
+      render()
+    },
+    finish(summary) {
+      if (stopped) return
+      stopped = true
+      if (total != null) {
+        completed = total
+      }
+      stopTicker()
+      finishLine(summary)
+    },
+    fail(summary) {
+      if (stopped) return
+      stopped = true
+      failed = true
+      stopTicker()
+      finishLine(summary)
+    }
+  }
+}

package/src/runtime-package.ts

@@ -0,0 +1,126 @@
+import { resolvePublishedPackageVersion } from './npm-package'
+import { resolvePackageCacheDir, resolvePackageInstallDir } from './npm-package-cache'
+import {
+  findInstalledPublishedPackageVersion,
+  installPublishedPackage,
+  readInstalledPackageVersion
+} from './npm-package-install'
+
+export type RuntimePackageAction = 'check' | 'install'
+export type RuntimePackageTarget = 'cli' | 'client' | 'server' | 'web'
+
+export interface RuntimePackageOptions {
+  version?: string
+}
+
+export interface RuntimePackageStatus {
+  installed: boolean
+  installedVersion?: string
+  latestInstalled: boolean
+  latestVersion: string
+  packageName: string
+  requestedVersion?: string
+  target: RuntimePackageTarget
+  updateAvailable: boolean
+}
+
+const RUNTIME_PACKAGE_NAMES: Record<RuntimePackageTarget, string> = {
+  cli: '@oneworks/cli',
+  client: '@oneworks/client',
+  server: '@oneworks/server',
+  web: '@oneworks/web'
+}
+
+const RUNTIME_PACKAGE_TARGETS = Object.keys(RUNTIME_PACKAGE_NAMES) as RuntimePackageTarget[]
+
+const isRuntimePackageTarget = (value: string): value is RuntimePackageTarget => (
+  RUNTIME_PACKAGE_TARGETS.includes(value as RuntimePackageTarget)
+)
+
+const EXACT_VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[\da-z.-]+)?(?:\+[\da-z.-]+)?$/i
+
+const normalizeRequestedVersion = (value: string | undefined) => {
+  const normalized = value?.trim()
+  if (normalized == null || normalized === '') return undefined
+  if (!EXACT_VERSION_PATTERN.test(normalized)) {
+    throw new Error(`Runtime package version must be an exact semver version: ${normalized}.`)
+  }
+  return normalized
+}
+
+export const resolveRuntimePackageTarget = (value: string | undefined): RuntimePackageTarget => {
+  const normalized = value?.trim().toLowerCase() || 'cli'
+  if (isRuntimePackageTarget(normalized)) return normalized
+  throw new Error(
+    `Unsupported runtime package target: ${value ?? ''}. Supported targets: ${RUNTIME_PACKAGE_TARGETS.join(', ')}.`
+  )
+}
+
+const readVersionInstalledAt = async (packageName: string, version: string) => {
+  const packageDir = resolvePackageInstallDir(resolvePackageCacheDir(packageName, version), packageName)
+  return await readInstalledPackageVersion(packageDir)
+}
+
+const resolveRuntimePackageVersion = async (packageName: string, options: RuntimePackageOptions) => (
+  normalizeRequestedVersion(options.version) ??
+    await resolvePublishedPackageVersion(packageName, { cacheFirst: false })
+)
+
+const createRuntimePackageStatus = async (
+  target: RuntimePackageTarget,
+  packageName: string,
+  targetVersion: string,
+  requestedVersion: string | undefined
+): Promise<RuntimePackageStatus> => {
+  const installedVersion = await findInstalledPublishedPackageVersion(packageName)
+  const targetInstalled = await readVersionInstalledAt(packageName, targetVersion) === targetVersion
+
+  return {
+    installed: installedVersion != null,
+    ...(installedVersion != null ? { installedVersion } : {}),
+    latestInstalled: targetInstalled,
+    latestVersion: targetVersion,
+    packageName,
+    ...(requestedVersion != null ? { requestedVersion } : {}),
+    target,
+    updateAvailable: requestedVersion != null ? !targetInstalled : installedVersion !== targetVersion
+  }
+}
+
+export const checkRuntimePackage = async (
+  targetValue: string | undefined,
+  options: RuntimePackageOptions = {}
+): Promise<RuntimePackageStatus> => {
+  const target = resolveRuntimePackageTarget(targetValue)
+  const packageName = RUNTIME_PACKAGE_NAMES[target]
+  const requestedVersion = normalizeRequestedVersion(options.version)
+  const targetVersion = requestedVersion ?? await resolveRuntimePackageVersion(packageName, options)
+  return await createRuntimePackageStatus(target, packageName, targetVersion, requestedVersion)
+}
+
+export const installRuntimePackage = async (
+  targetValue: string | undefined,
+  options: RuntimePackageOptions = {}
+): Promise<RuntimePackageStatus> => {
+  const target = resolveRuntimePackageTarget(targetValue)
+  const packageName = RUNTIME_PACKAGE_NAMES[target]
+  const requestedVersion = normalizeRequestedVersion(options.version)
+  const targetVersion = requestedVersion ?? await resolveRuntimePackageVersion(packageName, options)
+  await installPublishedPackage(packageName, targetVersion)
+  return await createRuntimePackageStatus(target, packageName, targetVersion, requestedVersion)
+}
+
+export const formatRuntimePackageStatus = (status: RuntimePackageStatus) => {
+  const current = status.installedVersion ?? 'not installed'
+  if (status.requestedVersion != null) {
+    return status.latestInstalled
+      ? `${status.packageName}@${status.requestedVersion} cached`
+      : `${status.packageName}@${status.requestedVersion} not cached (${current})`
+  }
+
+  const suffix = status.updateAvailable
+    ? `update available: ${current} -> ${status.latestVersion}`
+    : `up to date: ${status.latestVersion}`
+
+  return `${status.packageName} ${suffix}`
+}

package/README.md

@@ -1,3 +0,0 @@
-# oneworks
-
-Reserved placeholder package for OneWorks.

package/index.js

@@ -1,3 +0,0 @@
-"use strict";
-
-module.exports = {};