oneworks 0.0.0 → 0.1.0-alpha.0

package/__tests__/runtime-package.spec.ts

@@ -0,0 +1,211 @@
+import { chmod, mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import process from 'node:process'
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { checkRuntimePackage, installRuntimePackage } from '../src/runtime-package'
+
+describe('bootstrap runtime package commands', () => {
+  const originalPath = process.env.PATH
+  let tempDir: string
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(path.join(os.tmpdir(), 'ow-bootstrap-runtime-'))
+    vi.restoreAllMocks()
+    vi.stubEnv('__ONEWORKS_PROJECT_REAL_HOME__', tempDir)
+    vi.stubEnv('ONEWORKS_BOOTSTRAP_DISABLE_BACKGROUND_REFRESH', '1')
+    vi.stubEnv('ONEWORKS_BOOTSTRAP_PACKAGE_CACHE_FIRST', '0')
+    await installFakeNpm()
+  })
+
+  afterEach(async () => {
+    vi.restoreAllMocks()
+    vi.unstubAllEnvs()
+    await rm(tempDir, { force: true, recursive: true })
+  })
+
+  const writeCachedPackage = async (packageName: string, version: string) => {
+    const sanitizedName = packageName.replace(/^@/, '').replace(/[\\/]/g, '__')
+    const packageDir = path.join(
+      tempDir,
+      '.oneworks/bootstrap/npm',
+      sanitizedName,
+      version,
+      'node_modules',
+      ...packageName.split('/')
+    )
+    await mkdir(packageDir, { recursive: true })
+    await writeFile(
+      path.join(packageDir, 'package.json'),
+      JSON.stringify({ name: packageName, version }),
+      'utf8'
+    )
+  }
+
+  const installFakeNpm = async () => {
+    const binDir = path.join(tempDir, 'bin')
+    const npmBin = path.join(binDir, 'npm')
+    await mkdir(binDir, { recursive: true })
+    await writeFile(
+      npmBin,
+      `#!/usr/bin/env node
+const fs = require('node:fs')
+const path = require('node:path')
+const version = process.env.ONEWORKS_TEST_NPM_VERSION || '2.0.0'
+const parsePackageSpec = (spec) => {
+  const lastAt = spec.lastIndexOf('@')
+  return {
+    packageName: spec.slice(0, lastAt),
+    version: spec.slice(lastAt + 1)
+  }
+}
+if (process.argv[2] === 'view') {
+  process.stdout.write(JSON.stringify(version) + '\\n')
+  process.exit(0)
+}
+if (process.argv[2] === 'install') {
+  const prefix = process.argv[process.argv.indexOf('--prefix') + 1]
+  const spec = process.argv[process.argv.length - 1]
+  const parsed = parsePackageSpec(spec)
+  const packageDir = path.join(prefix, 'node_modules', ...parsed.packageName.split('/'))
+  fs.mkdirSync(packageDir, { recursive: true })
+  fs.writeFileSync(path.join(packageDir, 'package.json'), JSON.stringify({
+    name: parsed.packageName,
+    version: parsed.version
+  }))
+  process.exit(0)
+}
+process.exit(1)
+`,
+      'utf8'
+    )
+    await chmod(npmBin, 0o755)
+    vi.stubEnv('PATH', [binDir, originalPath].filter(Boolean).join(path.delimiter))
+  }
+
+  it('checks the published CLI version against the bootstrap cache', async () => {
+    await writeCachedPackage('@oneworks/cli', '1.0.0')
+    vi.stubEnv('ONEWORKS_TEST_NPM_VERSION', '2.0.0')
+
+    await expect(checkRuntimePackage('cli')).resolves.toMatchObject({
+      installedVersion: '1.0.0',
+      latestVersion: '2.0.0',
+      packageName: '@oneworks/cli',
+      updateAvailable: true
+    })
+  })
+
+  it('checks the server runtime package target', async () => {
+    await writeCachedPackage('@oneworks/server', '1.0.0')
+    vi.stubEnv('ONEWORKS_TEST_NPM_VERSION', '2.0.0')
+
+    await expect(checkRuntimePackage('server')).resolves.toMatchObject({
+      installedVersion: '1.0.0',
+      latestVersion: '2.0.0',
+      packageName: '@oneworks/server',
+      target: 'server',
+      updateAvailable: true
+    })
+  })
+
+  it('reports an empty runtime package cache without installing anything on check', async () => {
+    vi.stubEnv('ONEWORKS_TEST_NPM_VERSION', '2.0.0')
+
+    await expect(checkRuntimePackage('server')).resolves.toMatchObject({
+      installed: false,
+      latestInstalled: false,
+      latestVersion: '2.0.0',
+      packageName: '@oneworks/server',
+      target: 'server',
+      updateAvailable: true
+    })
+  })
+
+  it('checks an explicit runtime package version without resolving latest', async () => {
+    await writeCachedPackage('@oneworks/server', '1.0.0')
+    vi.stubEnv('ONEWORKS_TEST_NPM_VERSION', '2.0.0')
+
+    await expect(checkRuntimePackage('server', { version: '1.0.0' })).resolves.toMatchObject({
+      installedVersion: '1.0.0',
+      latestInstalled: true,
+      latestVersion: '1.0.0',
+      packageName: '@oneworks/server',
+      requestedVersion: '1.0.0',
+      target: 'server',
+      updateAvailable: false
+    })
+  })
+
+  it('installs the latest CLI version into the bootstrap cache', async () => {
+    vi.stubEnv('ONEWORKS_TEST_NPM_VERSION', '2.1.0')
+
+    await expect(installRuntimePackage('cli')).resolves.toMatchObject({
+      installedVersion: '2.1.0',
+      latestInstalled: true,
+      latestVersion: '2.1.0',
+      updateAvailable: false
+    })
+  })
+
+  it('installs an explicit runtime package version into the bootstrap cache', async () => {
+    vi.stubEnv('ONEWORKS_TEST_NPM_VERSION', '9.9.9')
+
+    await expect(installRuntimePackage('client', { version: '2.2.0' })).resolves.toMatchObject({
+      installedVersion: '2.2.0',
+      latestInstalled: true,
+      latestVersion: '2.2.0',
+      packageName: '@oneworks/client',
+      requestedVersion: '2.2.0',
+      target: 'client',
+      updateAvailable: false
+    })
+  })
+
+  it('honors the configured package cache root for runtime packages', async () => {
+    const packageCacheRoot = path.join(tempDir, 'package-cache')
+    vi.stubEnv('__ONEWORKS_PROJECT_PACKAGE_CACHE_DIR__', packageCacheRoot)
+    vi.stubEnv('ONEWORKS_TEST_NPM_VERSION', '8.8.8')
+
+    await expect(installRuntimePackage('server', { version: '2.2.0' })).resolves.toMatchObject({
+      installedVersion: '2.2.0',
+      latestInstalled: true,
+      packageName: '@oneworks/server'
+    })
+    await expect(
+      writeFile(
+        path.join(
+          packageCacheRoot,
+          'npm',
+          'oneworks__server',
+          '2.2.0',
+          'node_modules',
+          '@oneworks',
+          'server',
+          'probe'
+        ),
+        'ok'
+      )
+    ).resolves.toBeUndefined()
+  })
+
+  it('installs the latest client runtime package target', async () => {
+    vi.stubEnv('ONEWORKS_TEST_NPM_VERSION', '2.2.0')
+
+    await expect(installRuntimePackage('client')).resolves.toMatchObject({
+      installedVersion: '2.2.0',
+      latestInstalled: true,
+      latestVersion: '2.2.0',
+      packageName: '@oneworks/client',
+      target: 'client',
+      updateAvailable: false
+    })
+  })
+
+  it('rejects non-exact runtime package versions', async () => {
+    await expect(checkRuntimePackage('cli', { version: 'latest' })).rejects.toThrow(
+      'Runtime package version must be an exact semver version'
+    )
+  })
+})

package/cli.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+require('@oneworks/cli-helper/entry').runCliPackageEntrypoint({
+  packageDir: __dirname
+})

package/package-version-refresh-worker.cjs

@@ -0,0 +1,324 @@
+/* eslint-disable max-lines -- Standalone background worker avoids booting the TS loader on the startup path. */
+const { Buffer } = require('node:buffer')
+const { spawn } = require('node:child_process')
+const { createHash } = require('node:crypto')
+const { existsSync } = require('node:fs')
+const { access, mkdir, readFile, rename, rm, stat, writeFile } = require('node:fs/promises')
+const os = require('node:os')
+const path = require('node:path')
+const process = require('node:process')
+
+const DEFAULT_PACKAGE_TAG = 'latest'
+const NPM_BIN = process.platform === 'win32' ? 'npm.cmd' : 'npm'
+const STALE_LOCK_MS = 5 * 60 * 1000
+
+const resolveRealHomeDir = () => {
+  const realHome = process.env.__ONEWORKS_PROJECT_REAL_HOME__?.trim() || process.env.HOME?.trim()
+  return realHome || os.homedir()
+}
+
+const resolveBootstrapDataDir = () => path.join(resolveRealHomeDir(), '.oneworks', 'bootstrap')
+
+const resolveBootstrapPackageCacheDir = () => (
+  process.env.__ONEWORKS_PROJECT_PACKAGE_CACHE_DIR__?.trim() || resolveBootstrapDataDir()
+)
+
+const sanitizePackageName = packageName => packageName.replace(/^@/, '').replace(/[\\/]/g, '__')
+
+const splitPackageName = packageName => packageName.split('/')
+
+const hashValue = value => createHash('sha1').update(value).digest('hex')
+
+const resolvePackageTag = () => process.env.ONEWORKS_BOOTSTRAP_PACKAGE_TAG?.trim() || DEFAULT_PACKAGE_TAG
+
+const resolvePackageCacheDir = (packageName, version) => (
+  path.join(resolveBootstrapPackageCacheDir(), 'npm', sanitizePackageName(packageName), version)
+)
+
+const resolvePackageInstallDir = (cacheDir, packageName) => (
+  path.join(cacheDir, 'node_modules', ...splitPackageName(packageName))
+)
+
+const resolveProjectNpmrc = () => {
+  const projectNpmrc = path.resolve(process.cwd(), '.npmrc')
+  return existsSync(projectNpmrc) ? projectNpmrc : undefined
+}
+
+const resolvePackageManagerEnv = () => {
+  const userConfig = process.env.npm_config_userconfig ?? process.env.NPM_CONFIG_USERCONFIG ?? resolveProjectNpmrc()
+
+  return {
+    ...process.env,
+    HOME: resolveRealHomeDir(),
+    USERPROFILE: resolveRealHomeDir(),
+    npm_config_cache: path.join(resolveBootstrapPackageCacheDir(), 'npm-cache'),
+    npm_config_replace_registry_host: 'never',
+    npm_config_update_notifier: 'false',
+    NPM_CONFIG_REPLACE_REGISTRY_HOST: 'never',
+    ...(userConfig != null
+      ? {
+        NPM_CONFIG_USERCONFIG: userConfig,
+        npm_config_userconfig: userConfig
+      }
+      : {})
+  }
+}
+
+const readOptionalFile = async filePath => {
+  if (filePath == null || filePath === '') {
+    return undefined
+  }
+
+  try {
+    return await readFile(filePath, 'utf8')
+  } catch {
+    return undefined
+  }
+}
+
+const resolvePackageLookupKey = async packageName => {
+  const env = resolvePackageManagerEnv()
+  const userConfig = env.npm_config_userconfig ?? env.NPM_CONFIG_USERCONFIG
+  const userConfigContent = await readOptionalFile(userConfig)
+
+  return JSON.stringify({
+    packageName,
+    packageTag: resolvePackageTag(),
+    registry: env.npm_config_registry ?? env.NPM_CONFIG_REGISTRY ?? '',
+    userConfig: userConfig ?? '',
+    userConfigContentHash: userConfigContent == null ? '' : hashValue(userConfigContent)
+  })
+}
+
+const resolvePackageVersionMetadataPath = async packageName => {
+  const lookupKey = await resolvePackageLookupKey(packageName)
+  return {
+    lookupKey,
+    metadataPath: path.join(
+      resolveBootstrapPackageCacheDir(),
+      'npm-version-cache',
+      `${sanitizePackageName(packageName)}-${hashValue(lookupKey)}.json`
+    )
+  }
+}
+
+const ensureDirectory = async targetPath => {
+  await mkdir(targetPath, { recursive: true })
+}
+
+const isExistingPath = async targetPath => {
+  try {
+    await access(targetPath)
+    return true
+  } catch {
+    return false
+  }
+}
+
+const runBufferedCommand = async input => {
+  const child = spawn(input.command, input.args, {
+    cwd: input.cwd,
+    env: input.env,
+    stdio: input.stdio ?? 'pipe'
+  })
+
+  let stdout = ''
+  let stderr = ''
+
+  if (input.stdio !== 'inherit') {
+    child.stdout?.on('data', chunk => {
+      stdout += String(chunk)
+    })
+    child.stderr?.on('data', chunk => {
+      stderr += String(chunk)
+    })
+  }
+
+  return await new Promise((resolve, reject) => {
+    child.once('error', reject)
+    child.once('exit', code => {
+      resolve({
+        code: code ?? 0,
+        stderr,
+        stdout
+      })
+    })
+  })
+}
+
+const parseVersionOutput = (spec, stdout) => {
+  const normalizedOutput = stdout.trim()
+  if (!normalizedOutput) {
+    throw new Error(`No version was returned for ${spec}.`)
+  }
+
+  try {
+    const parsed = JSON.parse(normalizedOutput)
+    if (typeof parsed === 'string' && parsed.trim()) {
+      return parsed.trim()
+    }
+  } catch {
+    // fall through
+  }
+
+  const unquotedOutput = normalizedOutput.replace(/^"|"$/g, '').trim()
+  if (!unquotedOutput) {
+    throw new Error(`Invalid published version for ${spec}: ${normalizedOutput}`)
+  }
+
+  return unquotedOutput
+}
+
+const resolvePublishedPackageVersion = async packageName => {
+  const spec = `${packageName}@${resolvePackageTag()}`
+  const result = await runBufferedCommand({
+    command: NPM_BIN,
+    args: ['view', spec, 'version', '--json'],
+    env: resolvePackageManagerEnv()
+  })
+
+  if (result.code !== 0) {
+    throw new Error(`Failed to resolve published version for ${spec}:\n${result.stderr.trim()}`)
+  }
+
+  return parseVersionOutput(spec, result.stdout)
+}
+
+const writePublishedPackageVersionMetadata = async (packageName, version) => {
+  const { lookupKey, metadataPath } = await resolvePackageVersionMetadataPath(packageName)
+  await ensureDirectory(path.dirname(metadataPath))
+
+  const tempPath = `${metadataPath}.${process.pid}.${Date.now()}.tmp`
+  await writeFile(
+    tempPath,
+    `${
+      JSON.stringify(
+        {
+          lookupKey,
+          packageName,
+          packageTag: resolvePackageTag(),
+          resolvedAt: new Date().toISOString(),
+          version
+        },
+        null,
+        2
+      )
+    }\n`,
+    'utf8'
+  )
+  await rename(tempPath, metadataPath)
+}
+
+const readInstalledPackageVersion = async packageDir => {
+  const packageJsonPath = path.join(packageDir, 'package.json')
+  if (!(await isExistingPath(packageJsonPath))) {
+    return undefined
+  }
+
+  try {
+    const content = await readFile(packageJsonPath, 'utf8')
+    const packageJson = JSON.parse(content)
+    return typeof packageJson.version === 'string' ? packageJson.version : undefined
+  } catch {
+    return undefined
+  }
+}
+
+const installPublishedPackage = async (packageName, version) => {
+  const cacheDir = resolvePackageCacheDir(packageName, version)
+  const packageDir = resolvePackageInstallDir(cacheDir, packageName)
+  const installedVersion = await readInstalledPackageVersion(packageDir)
+  if (installedVersion === version) {
+    return
+  }
+
+  const stagingDir = `${cacheDir}.tmp-${process.pid}-${Date.now()}`
+  await rm(stagingDir, { recursive: true, force: true })
+  await ensureDirectory(stagingDir)
+
+  const result = await runBufferedCommand({
+    command: NPM_BIN,
+    args: [
+      'install',
+      '--prefix',
+      stagingDir,
+      '--no-audit',
+      '--no-fund',
+      '--loglevel=error',
+      `${packageName}@${version}`
+    ],
+    env: resolvePackageManagerEnv(),
+    stdio: 'ignore'
+  })
+
+  if (result.code !== 0) {
+    await rm(stagingDir, { recursive: true, force: true })
+    throw new Error(`Failed to install ${packageName}@${version}.`)
+  }
+
+  await ensureDirectory(path.dirname(cacheDir))
+  await rm(cacheDir, { recursive: true, force: true })
+  try {
+    await rename(stagingDir, cacheDir)
+  } catch (error) {
+    await rm(stagingDir, { recursive: true, force: true })
+    throw error
+  }
+}
+
+const acquireLock = async lockPath => {
+  try {
+    await mkdir(lockPath)
+    return true
+  } catch {
+    try {
+      const lockStat = await stat(lockPath)
+      if (Date.now() - lockStat.mtimeMs > STALE_LOCK_MS) {
+        await rm(lockPath, { force: true, recursive: true })
+        await mkdir(lockPath)
+        return true
+      }
+    } catch {
+      return false
+    }
+  }
+
+  return false
+}
+
+const decodePayload = () => {
+  const rawPayload = process.argv[2]
+  if (!rawPayload) {
+    throw new Error('Missing refresh payload.')
+  }
+
+  const parsed = JSON.parse(Buffer.from(rawPayload, 'base64url').toString('utf8'))
+  if (typeof parsed.packageName !== 'string' || parsed.packageName.trim() === '') {
+    throw new Error('Invalid refresh payload.')
+  }
+
+  return {
+    packageName: parsed.packageName
+  }
+}
+
+const main = async () => {
+  const { packageName } = decodePayload()
+  const { metadataPath } = await resolvePackageVersionMetadataPath(packageName)
+  const lockPath = `${metadataPath}.lock`
+  if (!(await acquireLock(lockPath))) {
+    return
+  }
+
+  try {
+    const version = await resolvePublishedPackageVersion(packageName)
+    await writePublishedPackageVersionMetadata(packageName, version)
+    await installPublishedPackage(packageName, version)
+  } finally {
+    await rm(lockPath, { force: true, recursive: true })
+  }
+}
+
+main().catch(() => {
+  process.exitCode = 0
+})

package/package.json

@@ -1,16 +1,29 @@
 {
   "name": "oneworks",
-  "version": "0.0.0",
-  "description": "Reserved placeholder package for OneWorks.",
-  "private": false,
-  "license": "UNLICENSED",
-  "main": "index.js",
-  "files": [
-    "index.js",
-    "README.md"
-  ],
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
+  "version": "0.1.0-alpha.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/oneworks-ai/app.git",
+    "directory": "apps/bootstrap"
+  },
+  "description": "One Works bootstrap launcher",
+  "oneworks": {
+    "runtimeTranspile": true
+  },
+  "exports": {
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "oneworks": "./cli.js",
+    "ow": "./cli.js",
+    "owo": "./cli.js"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.11.0",
+    "commander": "^12.1.0",
+    "@oneworks/cli-helper": "0.1.0-alpha.0"
+  },
+  "scripts": {
+    "test": "pnpm -C ../.. exec vitest run --workspace vitest.workspace.ts --project node apps/bootstrap/__tests__"
   }
-}
+}