onework 0.1.0-alpha.0 → 0.1.0-alpha.2

package/src/desktop-mode.ts

@@ -0,0 +1,92 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import process from 'node:process'
+
+import { isCancel, select } from '@clack/prompts'
+
+import { resolveBootstrapDataDir } from './paths'
+
+export type DesktopInstallMode = 'cache' | 'user'
+
+interface DesktopPreferenceState {
+  installMode?: DesktopInstallMode
+}
+
+const DEFAULT_INSTALL_MODE: DesktopInstallMode = 'user'
+
+const ensureDirectory = async (targetPath: string) => {
+  await mkdir(targetPath, { recursive: true })
+}
+
+const resolveDesktopPreferencePath = () => path.join(resolveBootstrapDataDir(), 'desktop', 'preferences.json')
+
+const readJsonFile = async <T>(filePath: string) => {
+  try {
+    const content = await readFile(filePath, 'utf8')
+    return JSON.parse(content) as T
+  } catch {
+    return undefined
+  }
+}
+
+const writeJsonFile = async (filePath: string, value: unknown) => {
+  await ensureDirectory(path.dirname(filePath))
+  await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`)
+}
+
+export const readDesktopPreference = async () => (
+  await readJsonFile<DesktopPreferenceState>(resolveDesktopPreferencePath())
+)
+
+const writeDesktopPreference = async (installMode: DesktopInstallMode) => {
+  await writeJsonFile(resolveDesktopPreferencePath(), { installMode })
+}
+
+const promptDesktopInstallMode = async () => {
+  const selectedMode = await select<DesktopInstallMode>({
+    message: 'Choose how to launch the desktop app',
+    options: [
+      {
+        value: 'user',
+        label: 'User directory',
+        hint: 'Install into the user application directory'
+      },
+      {
+        value: 'cache',
+        label: 'Bootstrap cache',
+        hint: 'Keep the app inside the bootstrap cache'
+      }
+    ]
+  })
+
+  if (isCancel(selectedMode)) {
+    throw new Error('Desktop launch was cancelled.')
+  }
+
+  return selectedMode
+}
+
+export const resolveInstallMode = async (input: {
+  explicitInstallMode?: DesktopInstallMode
+  persistInstallMode?: boolean
+}) => {
+  if (input.explicitInstallMode != null) {
+    if (input.persistInstallMode === true) {
+      await writeDesktopPreference(input.explicitInstallMode)
+    }
+    return input.explicitInstallMode
+  }
+
+  const preference = await readDesktopPreference()
+  if (preference?.installMode != null) {
+    return preference.installMode
+  }
+
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return DEFAULT_INSTALL_MODE
+  }
+
+  const selectedMode = await promptDesktopInstallMode()
+  await writeDesktopPreference(selectedMode)
+  return selectedMode
+}

package/src/desktop-release.ts

@@ -0,0 +1,198 @@
+import type { Buffer } from 'node:buffer'
+import { createHash } from 'node:crypto'
+import { createWriteStream } from 'node:fs'
+import { mkdir, unlink } from 'node:fs/promises'
+import https from 'node:https'
+import path from 'node:path'
+import process from 'node:process'
+
+import { createBootstrapProgress } from './progress'
+
+interface GitHubReleaseAsset {
+  browser_download_url?: string
+  digest?: string
+  name: string
+  url: string
+}
+
+interface GitHubReleaseResponse {
+  assets?: GitHubReleaseAsset[]
+  draft?: boolean
+  tag_name?: string
+  tagName?: string
+}
+
+export interface DesktopRelease {
+  assets: GitHubReleaseAsset[]
+  tagName: string
+}
+
+const GITHUB_RELEASES_API = 'https://api.github.com/repos/oneworks-ai/app/releases'
+const DESKTOP_RELEASE_TAG_PREFIX = 'pkg/oneworks-desktop/v'
+const RELEASE_TAG_OVERRIDE = process.env.ONEWORKS_BOOTSTRAP_DESKTOP_RELEASE_TAG?.trim()
+
+const ensureDirectory = async (targetPath: string) => {
+  await mkdir(targetPath, { recursive: true })
+}
+
+const parseContentLength = (value: string | string[] | undefined) => {
+  const rawValue = Array.isArray(value) ? value[0] : value
+  if (rawValue == null) return undefined
+
+  const parsed = Number.parseInt(rawValue, 10)
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined
+}
+
+const requestJson = async <T>(url: string) => (
+  await new Promise<T>((resolve, reject) => {
+    https.get(url, {
+      headers: {
+        Accept: 'application/vnd.github+json',
+        'User-Agent': 'oneworks'
+      }
+    }, (response) => {
+      const statusCode = response.statusCode ?? 0
+      if (statusCode < 200 || statusCode >= 300) {
+        response.resume()
+        reject(new Error(`GitHub API request failed: HTTP ${statusCode}`))
+        return
+      }
+
+      let content = ''
+      response.setEncoding('utf8')
+      response.on('data', (chunk: string) => {
+        content += chunk
+      })
+      response.on('end', () => {
+        try {
+          resolve(JSON.parse(content) as T)
+        } catch (error) {
+          reject(error)
+        }
+      })
+    }).on('error', reject)
+  })
+)
+
+export const fetchDesktopRelease = async (): Promise<DesktopRelease> => {
+  const release = RELEASE_TAG_OVERRIDE
+    ? await requestJson<GitHubReleaseResponse>(
+      `${GITHUB_RELEASES_API}/tags/${encodeURIComponent(RELEASE_TAG_OVERRIDE)}`
+    )
+    : (await requestJson<GitHubReleaseResponse[]>(`${GITHUB_RELEASES_API}?per_page=50`))
+      .find(item => (
+        item.draft !== true &&
+        typeof item.tag_name === 'string' &&
+        item.tag_name.startsWith(DESKTOP_RELEASE_TAG_PREFIX) &&
+        /^\d+\.\d+\.\d+$/u.test(item.tag_name.slice(DESKTOP_RELEASE_TAG_PREFIX.length))
+      ))
+  const tagName = release?.tag_name ?? release?.tagName
+  if (!tagName || !Array.isArray(release?.assets)) {
+    throw new Error('Invalid desktop release metadata returned by GitHub.')
+  }
+  return {
+    assets: release.assets.map(asset => ({
+      ...asset,
+      url: asset.browser_download_url ?? asset.url
+    })),
+    tagName
+  }
+}
+
+export const selectDesktopAsset = (release: DesktopRelease, runtime: {
+  arch: string
+  platform: NodeJS.Platform
+}) => {
+  if (runtime.platform === 'darwin') {
+    return release.assets.find(asset => asset.name.endsWith(`-mac-${runtime.arch}.zip`))
+  }
+
+  if (runtime.platform === 'linux') {
+    const appImageArch = runtime.arch === 'x64' ? 'x86_64' : runtime.arch
+    return release.assets.find(asset => asset.name.endsWith(`-linux-${appImageArch}.AppImage`))
+  }
+
+  if (runtime.platform === 'win32') {
+    return release.assets.find(asset => asset.name.endsWith(`-win-${runtime.arch}.exe`))
+  }
+
+  return undefined
+}
+
+export const downloadReleaseAsset = async (asset: GitHubReleaseAsset, destinationPath: string) => {
+  await ensureDirectory(path.dirname(destinationPath))
+
+  return await new Promise<void>((resolve, reject) => {
+    const hash = createHash('sha256')
+    const file = createWriteStream(destinationPath)
+    let downloadedBytes = 0
+    let progress: ReturnType<typeof createBootstrapProgress> | undefined
+
+    file.on('error', (error) => {
+      progress?.fail(`failed to download ${asset.name}`)
+      reject(error)
+    })
+
+    const request = https.get(asset.url, {
+      headers: {
+        'User-Agent': 'oneworks'
+      }
+    }, (response) => {
+      const statusCode = response.statusCode ?? 0
+      const redirectLocation = response.headers.location
+
+      if (statusCode >= 300 && statusCode < 400 && redirectLocation != null) {
+        file.close()
+        void unlink(destinationPath).catch(() => {})
+        downloadReleaseAsset({
+          ...asset,
+          url: new URL(redirectLocation, asset.url).toString()
+        }, destinationPath).then(resolve, reject)
+        return
+      }
+
+      if (statusCode < 200 || statusCode >= 300) {
+        response.resume()
+        file.close()
+        reject(new Error(`Failed to download ${asset.name}: HTTP ${statusCode}`))
+        return
+      }
+
+      progress = createBootstrapProgress({
+        label: `downloading ${asset.name}`,
+        total: parseContentLength(response.headers['content-length'])
+      })
+
+      response.on('data', (chunk: Buffer) => {
+        downloadedBytes += chunk.length
+        hash.update(chunk)
+        progress?.update(downloadedBytes)
+      })
+      response.on('error', (error) => {
+        progress?.fail(`failed to download ${asset.name}`)
+        file.close()
+        reject(error)
+      })
+      response.pipe(file)
+      file.on('finish', () => {
+        file.close(() => {
+          const expectedDigest = asset.digest?.replace(/^sha256:/, '')
+          if (expectedDigest && hash.digest('hex') !== expectedDigest) {
+            progress?.fail(`failed to verify ${asset.name}`)
+            reject(new Error(`Downloaded desktop asset digest mismatch for ${asset.name}.`))
+            return
+          }
+
+          progress?.finish(`downloaded ${asset.name}`)
+          resolve()
+        })
+      })
+    })
+
+    request.on('error', (error) => {
+      progress?.fail(`failed to download ${asset.name}`)
+      file.close()
+      reject(error)
+    })
+  })
+}

package/src/npm-package-cache.ts

@@ -0,0 +1,185 @@
+import { createHash } from 'node:crypto'
+import { existsSync } from 'node:fs'
+import { access, mkdir, readFile, rename, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import process from 'node:process'
+
+import { resolveBootstrapPackageCacheDir, resolveRealHomeDir } from './paths'
+
+const DEFAULT_PACKAGE_TAG = 'latest'
+const DEFAULT_PACKAGE_LOOKUP_TIMEOUT_MS = 1_000
+const DEFAULT_CACHE_FIRST = true
+
+interface PublishedPackageVersionMetadata {
+  lookupKey: string
+  packageName: string
+  packageTag: string
+  resolvedAt: string
+  version: string
+}
+
+export const ensureDirectory = async (targetPath: string) => {
+  await mkdir(targetPath, { recursive: true })
+}
+
+export const sanitizePackageName = (packageName: string) => packageName.replace(/^@/, '').replace(/[\\/]/g, '__')
+
+export const splitPackageName = (packageName: string) => packageName.split('/')
+
+export const compareVersionLike = (left: string, right: string) => (
+  left.localeCompare(right, 'en', {
+    numeric: true,
+    sensitivity: 'base'
+  })
+)
+
+const hashValue = (value: string) => createHash('sha1').update(value).digest('hex')
+
+export const resolvePackageTag = () => process.env.ONEWORKS_BOOTSTRAP_PACKAGE_TAG?.trim() || DEFAULT_PACKAGE_TAG
+
+export const resolvePackageLookupTimeoutMs = () => {
+  const rawValue = process.env.ONEWORKS_BOOTSTRAP_PACKAGE_LOOKUP_TIMEOUT_MS?.trim()
+  if (!rawValue) {
+    return DEFAULT_PACKAGE_LOOKUP_TIMEOUT_MS
+  }
+
+  const parsedValue = Number.parseInt(rawValue, 10)
+  return Number.isFinite(parsedValue) && parsedValue > 0
+    ? parsedValue
+    : DEFAULT_PACKAGE_LOOKUP_TIMEOUT_MS
+}
+
+export const shouldUseCachedPackageVersionFirst = () => {
+  const rawValue = process.env.ONEWORKS_BOOTSTRAP_PACKAGE_CACHE_FIRST?.trim().toLowerCase()
+  if (rawValue == null || rawValue === '') {
+    return DEFAULT_CACHE_FIRST
+  }
+
+  return !['0', 'false', 'no', 'off'].includes(rawValue)
+}
+
+export const resolvePackageCacheDir = (packageName: string, version: string) => (
+  path.join(resolveBootstrapPackageCacheDir(), 'npm', sanitizePackageName(packageName), version)
+)
+
+export const resolvePackageCacheRootDir = (packageName: string) => (
+  path.join(resolveBootstrapPackageCacheDir(), 'npm', sanitizePackageName(packageName))
+)
+
+export const resolvePackageInstallDir = (cacheDir: string, packageName: string) => (
+  path.join(cacheDir, 'node_modules', ...splitPackageName(packageName))
+)
+
+const resolvePackageVersionMetadataDir = () => path.join(resolveBootstrapPackageCacheDir(), 'npm-version-cache')
+
+const resolveProjectNpmrc = () => {
+  const projectNpmrc = path.resolve(process.cwd(), '.npmrc')
+  return existsSync(projectNpmrc) ? projectNpmrc : undefined
+}
+
+export 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: string | undefined) => {
+  if (filePath == null || filePath === '') {
+    return undefined
+  }
+
+  try {
+    return await readFile(filePath, 'utf8')
+  } catch {
+    return undefined
+  }
+}
+
+const resolvePackageLookupKey = async (packageName: string) => {
+  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: string) => {
+  const lookupKey = await resolvePackageLookupKey(packageName)
+  return {
+    lookupKey,
+    metadataPath: path.join(
+      resolvePackageVersionMetadataDir(),
+      `${sanitizePackageName(packageName)}-${hashValue(lookupKey)}.json`
+    )
+  }
+}
+
+export const readPublishedPackageVersionMetadata = async (packageName: string) => {
+  const { lookupKey, metadataPath } = await resolvePackageVersionMetadataPath(packageName)
+
+  try {
+    const content = await readFile(metadataPath, 'utf8')
+    const parsed = JSON.parse(content) as Partial<PublishedPackageVersionMetadata>
+    if (
+      parsed.lookupKey === lookupKey &&
+      parsed.packageName === packageName &&
+      parsed.packageTag === resolvePackageTag() &&
+      typeof parsed.version === 'string' &&
+      parsed.version.trim()
+    ) {
+      return {
+        metadataPath,
+        version: parsed.version.trim()
+      }
+    }
+  } catch {
+    // Ignore missing or invalid metadata and use the registry path.
+  }
+
+  return undefined
+}
+
+export const writePublishedPackageVersionMetadata = async (packageName: string, version: string) => {
+  const { lookupKey, metadataPath } = await resolvePackageVersionMetadataPath(packageName)
+  await ensureDirectory(path.dirname(metadataPath))
+
+  const tempPath = `${metadataPath}.${process.pid}.${Date.now()}.tmp`
+  const metadata: PublishedPackageVersionMetadata = {
+    lookupKey,
+    packageName,
+    packageTag: resolvePackageTag(),
+    resolvedAt: new Date().toISOString(),
+    version
+  }
+  await writeFile(tempPath, `${JSON.stringify(metadata, null, 2)}\n`, 'utf8')
+  await rename(tempPath, metadataPath)
+}
+
+export const isExistingPath = async (targetPath: string) => {
+  try {
+    await access(targetPath)
+    return true
+  } catch {
+    return false
+  }
+}

package/src/npm-package-install.ts

@@ -0,0 +1,139 @@
+import { readFile, readdir, rename, rm } from 'node:fs/promises'
+import path from 'node:path'
+import process from 'node:process'
+
+import {
+  compareVersionLike,
+  ensureDirectory,
+  isExistingPath,
+  resolvePackageCacheDir,
+  resolvePackageCacheRootDir,
+  resolvePackageInstallDir,
+  resolvePackageManagerEnv
+} from './npm-package-cache'
+import { runBufferedCommand } from './process-utils'
+import { createBootstrapProgress } from './progress'
+
+const NPM_BIN = process.platform === 'win32' ? 'npm.cmd' : 'npm'
+
+interface InstalledPackageInfo {
+  packageDir: string
+  version: string
+}
+
+export const readInstalledPackageVersion = async (packageDir: string) => {
+  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) as { version?: unknown }
+    return typeof packageJson.version === 'string' ? packageJson.version : undefined
+  } catch {
+    return undefined
+  }
+}
+
+export const findInstalledPublishedPackageVersion = async (packageName: string) => {
+  let versions: string[]
+  try {
+    versions = (await readdir(resolvePackageCacheRootDir(packageName), { withFileTypes: true }))
+      .filter(entry => entry.isDirectory())
+      .map(entry => entry.name)
+  } catch {
+    return undefined
+  }
+
+  const installedVersions: string[] = []
+  for (const version of versions) {
+    const packageDir = resolvePackageInstallDir(resolvePackageCacheDir(packageName, version), packageName)
+    const installedVersion = await readInstalledPackageVersion(packageDir)
+    if (installedVersion === version) {
+      installedVersions.push(version)
+    }
+  }
+
+  return installedVersions.sort(compareVersionLike).at(-1)
+}
+
+const formatInstallError = (message: string, stderr: string) => {
+  const detail = stderr.trim()
+  return detail ? `${message}\n${detail}` : message
+}
+
+export const installPublishedPackage = async (packageName: string, version: string): Promise<InstalledPackageInfo> => {
+  const cacheDir = resolvePackageCacheDir(packageName, version)
+  const packageDir = resolvePackageInstallDir(cacheDir, packageName)
+  const installedVersion = await readInstalledPackageVersion(packageDir)
+  if (installedVersion === version) {
+    return { packageDir, version }
+  }
+
+  const stagingDir = `${cacheDir}.tmp-${process.pid}-${Date.now()}`
+  await rm(stagingDir, { recursive: true, force: true })
+  await ensureDirectory(stagingDir)
+
+  const progress = createBootstrapProgress({
+    label: `installing ${packageName}@${version} into bootstrap cache`
+  })
+  try {
+    const result = await runBufferedCommand({
+      command: NPM_BIN,
+      args: [
+        'install',
+        '--prefix',
+        stagingDir,
+        '--no-audit',
+        '--no-fund',
+        '--loglevel=error',
+        `${packageName}@${version}`
+      ],
+      env: resolvePackageManagerEnv()
+    })
+
+    if (result.code !== 0) {
+      throw new Error(formatInstallError(`Failed to install ${packageName}@${version}.`, result.stderr))
+    }
+
+    await ensureDirectory(path.dirname(cacheDir))
+    await rm(cacheDir, { recursive: true, force: true })
+    await rename(stagingDir, cacheDir)
+    progress.finish(`cached ${packageName}@${version}`)
+  } catch (error) {
+    progress.fail(`failed to cache ${packageName}@${version}`)
+    await rm(stagingDir, { recursive: true, force: true }).catch(() => {})
+    throw error
+  }
+
+  return {
+    packageDir: resolvePackageInstallDir(cacheDir, packageName),
+    version
+  }
+}
+
+export const resolvePackageBinEntrypoint = async (packageDir: string, commandName?: string) => {
+  const packageJsonContent = await readFile(path.join(packageDir, 'package.json'), 'utf8')
+  const packageJson = JSON.parse(packageJsonContent) as { bin?: unknown }
+  const { bin } = packageJson
+
+  if (typeof bin === 'string') {
+    return path.resolve(packageDir, bin)
+  }
+
+  if (bin == null || typeof bin !== 'object') {
+    throw new Error(`Package ${packageDir} does not expose a CLI bin.`)
+  }
+
+  const binEntries = Object.entries(bin).filter((entry): entry is [string, string] => typeof entry[1] === 'string')
+  if (binEntries.length === 0) {
+    throw new Error(`Package ${packageDir} does not expose a CLI bin.`)
+  }
+
+  const matchedEntry = commandName != null
+    ? binEntries.find(([binName]) => binName === commandName)
+    : undefined
+
+  return path.resolve(packageDir, (matchedEntry ?? binEntries[0])[1])
+}