@owdproject/cli 0.0.3 → 0.1.0

package/bin/lib/packageSources.js

@@ -0,0 +1,365 @@
+import { execSync } from 'node:child_process'
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { fetchLatestVersion } from './npmVersions.js'
+import { desktopMetaDir, fullName, SCOPE, KINDS, inferKind } from './workspace.js'
+
+/**
+ * @param {string} githubUser
+ * @param {string} pkgShortName
+ */
+export async function resolveForkUser(githubUser, pkgShortName) {
+  if (!githubUser || githubUser === 'owdproject') return { exists: false, isFork: false }
+
+  try {
+    const res = await fetch(`https://api.github.com/repos/${githubUser}/${pkgShortName}`, {
+      headers: { Accept: 'application/vnd.github+json', 'User-Agent': 'owd-desktop-cli' },
+    })
+    if (res.ok) {
+      const data = await res.json()
+      // data.fork === true only if this repo was forked FROM another repo
+      return { exists: true, isFork: data.fork === true }
+    }
+  } catch {
+    /* ignore */
+  }
+
+  return { exists: false, isFork: false }
+}
+
+/**
+ * @param {string} workspaceRoot
+ * @param {string} pkgName
+ */
+function hasLocalWorkspaceSource(workspaceRoot, pkgName) {
+  const pkgShort = pkgName.startsWith(SCOPE) ? pkgName.slice(SCOPE.length) : pkgName
+  const kind = inferKind(pkgShort)
+  return existsSync(join(workspaceRoot, KINDS[kind].workspaceDir, pkgShort, 'package.json'))
+}
+
+const CACHE_TTL_MS = 60 * 60 * 1000
+const SSH_CACHE_TTL_MS = 15 * 60 * 1000
+
+/**
+ * @typedef {{ type: 'npm' } | { type: 'git', protocol: 'https' | 'ssh', owner: string }} InstallSourceChoice
+ */
+
+/**
+ * @typedef {{
+ *   id: string
+ *   kind: 'npm' | 'git'
+ *   protocol?: 'https' | 'ssh'
+ *   owner?: string
+ *   label: string
+ *   url: string
+ *   choice: InstallSourceChoice
+ * }} SourceOption
+ */
+
+function cachePath(workspaceRoot) {
+  return join(desktopMetaDir(workspaceRoot), 'package-sources.json')
+}
+
+function readCacheFile(workspaceRoot) {
+  const path = cachePath(workspaceRoot)
+  if (!existsSync(path)) return null
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+function writeCacheFile(workspaceRoot, data) {
+  mkdirSync(desktopMetaDir(workspaceRoot), { recursive: true })
+  writeFileSync(cachePath(workspaceRoot), JSON.stringify(data, null, 2) + '\n')
+}
+
+/**
+ * @param {string[] | undefined} githubOrgs
+ * @param {string | null | undefined} githubUser
+ */
+export function trustedPublishers(githubOrgs, githubUser) {
+  return [...new Set([...(githubOrgs ?? ['owdproject']), githubUser].filter(Boolean))]
+}
+
+/**
+ * @param {{ org?: string }} entry
+ * @param {{ githubOrgs?: string[], githubUser?: string | null }} settings
+ */
+export function isTrustedPublisher(entry, settings) {
+  if (!entry.org || entry.org === 'workspace') return true
+  return trustedPublishers(settings.githubOrgs, settings.githubUser).includes(entry.org)
+}
+
+/**
+ * @param {string} owner
+ * @param {string} shortName
+ * @param {'https' | 'ssh'} protocol
+ */
+export function githubCloneUrl(owner, shortName, protocol) {
+  return protocol === 'ssh'
+    ? `git@github.com:${owner}/${shortName}.git`
+    : `https://github.com/${owner}/${shortName}.git`
+}
+
+export function githubHtmlUrl(owner, shortName) {
+  return `https://github.com/${owner}/${shortName}`
+}
+
+export function npmPackageUrl(pkgName) {
+  const short = pkgName.startsWith(SCOPE) ? pkgName.slice(SCOPE.length) : pkgName
+  return `https://www.npmjs.com/package/${SCOPE}${short}`
+}
+
+/**
+ * @param {string} workspaceRoot
+ * @param {{ force?: boolean }} [options]
+ */
+export async function detectGithubSshAuth(workspaceRoot, options = {}) {
+  const cache = readCacheFile(workspaceRoot)
+  const cached = cache?.sshAuth
+  if (!options.force && cached?.checkedAt && Date.now() - cached.checkedAt < SSH_CACHE_TTL_MS) {
+    return cached
+  }
+
+  /** @type {{ checkedAt: number, available: boolean, githubLogin: string | null, message: string }} */
+  let result = {
+    checkedAt: Date.now(),
+    available: false,
+    githubLogin: null,
+    message: 'SSH not configured',
+  }
+
+  try {
+    const out = execSync(
+      'ssh -T -o BatchMode=yes -o StrictHostKeyChecking=accept-new git@github.com 2>&1',
+      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: 8000 },
+    )
+    const text = out || ''
+    const login = text.match(/Hi ([^!]+)!/)?.[1]?.trim() ?? null
+    if (login) {
+      result = {
+        checkedAt: Date.now(),
+        available: true,
+        githubLogin: login,
+        message: `authenticated as ${login}`,
+      }
+    }
+  } catch (error) {
+    const text = `${error.stdout ?? ''}${error.stderr ?? ''}${error.message ?? ''}`
+    const login = text.match(/Hi ([^!]+)!/)?.[1]?.trim() ?? null
+    if (login) {
+      result = {
+        checkedAt: Date.now(),
+        available: true,
+        githubLogin: login,
+        message: `authenticated as ${login}`,
+      }
+    } else if (/Permission denied|publickey/i.test(text)) {
+      result = {
+        checkedAt: Date.now(),
+        available: false,
+        githubLogin: null,
+        message: 'SSH keys not accepted by GitHub',
+      }
+    } else {
+      result = {
+        checkedAt: Date.now(),
+        available: false,
+        githubLogin: null,
+        message: 'SSH probe failed',
+      }
+    }
+  }
+
+  const next = { ...(cache ?? { fetchedAt: 0, packages: {} }), sshAuth: result }
+  writeCacheFile(workspaceRoot, next)
+  return result
+}
+
+/**
+ * @param {string} workspaceRoot
+ */
+export function getCachedSshAuth(workspaceRoot) {
+  const cache = readCacheFile(workspaceRoot)
+  return cache?.sshAuth ?? null
+}
+
+/**
+ * @param {string} shortName
+ * @param {{ htmlUrl?: string | null, org?: string }} [catalogEntry]
+ * @param {{ githubUser?: string | null }} settings
+ */
+export async function resolvePackageSources(shortName, settings, workspaceRoot, catalogEntry = {}) {
+  const pkgName = fullName(shortName)
+  const officialOwner = catalogEntry.org && catalogEntry.org !== 'workspace' ? catalogEntry.org : 'owdproject'
+  const officialHtml =
+    catalogEntry.htmlUrl ?? githubHtmlUrl(officialOwner, shortName)
+
+  const cache = readCacheFile(workspaceRoot)
+  const cachedPkg = cache?.packages?.[shortName]
+  const cacheFresh = cachedPkg && cache?.fetchedAt && Date.now() - cache.fetchedAt < CACHE_TTL_MS
+
+  let npm = cachedPkg?.npm ?? null
+  if (!cacheFresh || npm === undefined) {
+    const version = fetchLatestVersion(pkgName, { optional: true })
+    npm = version ? { version } : null
+  }
+
+  let forkOwner = settings.githubUser && settings.githubUser !== 'owdproject' ? settings.githubUser : null
+  let forkExists = false
+  let forkIsActualFork = false
+  if (forkOwner) {
+    const result = await resolveForkUser(forkOwner, shortName)
+    forkExists = result.exists
+    forkIsActualFork = result.isFork
+  }
+
+  const local = workspaceRoot && hasLocalWorkspaceSource(workspaceRoot, pkgName)
+
+  const metadata = {
+    shortName,
+    pkgName,
+    npm,
+    github: {
+      official: {
+        owner: officialOwner,
+        htmlUrl: officialHtml,
+        exists: Boolean(catalogEntry.htmlUrl || officialOwner),
+      },
+      fork: forkOwner && forkExists
+        ? { owner: forkOwner, exists: forkExists, isFork: forkIsActualFork, htmlUrl: githubHtmlUrl(forkOwner, shortName) }
+        : null,
+    },
+    local: local ? true : false,
+  }
+
+  const packages = { ...(cache?.packages ?? {}), [shortName]: { npm, github: metadata.github } }
+  writeCacheFile(workspaceRoot, {
+    fetchedAt: Date.now(),
+    sshAuth: cache?.sshAuth ?? null,
+    packages,
+  })
+
+  return metadata
+}
+
+/**
+ * @param {Awaited<ReturnType<typeof resolvePackageSources>>} metadata
+ * @param {{ githubUser?: string | null }} settings
+ * @param {{ available?: boolean }} sshAuth
+ * @returns {SourceOption[]}
+ */
+export function buildSourceOptions(metadata, settings, sshAuth = {}) {
+  /** @type {SourceOption[]} */
+  const options = []
+
+  const official = metadata.github.official
+  if (official?.owner) {
+    options.push({
+      id: 'git-https-official',
+      kind: 'git',
+      protocol: 'https',
+      owner: official.owner,
+      label: `GitHub HTTPS — ${official.owner}/${metadata.shortName}`,
+      url: githubCloneUrl(official.owner, metadata.shortName, 'https'),
+      choice: { type: 'git', protocol: 'https', owner: official.owner },
+    })
+    if (sshAuth.available) {
+      options.push({
+        id: 'git-ssh-official',
+        kind: 'git',
+        protocol: 'ssh',
+        owner: official.owner,
+        label: `GitHub SSH — ${official.owner}/${metadata.shortName}`,
+        url: githubCloneUrl(official.owner, metadata.shortName, 'ssh'),
+        choice: { type: 'git', protocol: 'ssh', owner: official.owner },
+      })
+    }
+  }
+
+  const fork = metadata.github.fork
+  const officialOwnerLower = official?.owner?.toLowerCase()
+  const forkOwnerLower = fork?.owner?.toLowerCase()
+  const userLower = settings.githubUser?.toLowerCase()
+  // Skip fork options when fork owner is the same as the official repo owner
+  // (the official options already cover that user)
+  const forkIsSameAsOfficial = forkOwnerLower && forkOwnerLower === officialOwnerLower
+  const forkMissingIsSameAsOfficial = userLower && userLower === officialOwnerLower
+
+  if (fork?.exists && fork.owner && !forkIsSameAsOfficial) {
+    options.push({
+      id: 'git-https-fork',
+      kind: 'git',
+      protocol: 'https',
+      owner: fork.owner,
+      label: `GitHub HTTPS — ${fork.owner}/${metadata.shortName} (your fork)`,
+      url: githubCloneUrl(fork.owner, metadata.shortName, 'https'),
+      choice: { type: 'git', protocol: 'https', owner: fork.owner },
+    })
+    if (sshAuth.available) {
+      options.push({
+        id: 'git-ssh-fork',
+        kind: 'git',
+        protocol: 'ssh',
+        owner: fork.owner,
+        label: `GitHub SSH — ${fork.owner}/${metadata.shortName} (your fork)`,
+        url: githubCloneUrl(fork.owner, metadata.shortName, 'ssh'),
+        choice: { type: 'git', protocol: 'ssh', owner: fork.owner },
+      })
+    }
+  }
+
+  if (metadata.npm?.version) {
+    options.push({
+      id: 'npm',
+      kind: 'npm',
+      label: `npm — ${metadata.pkgName}@${metadata.npm.version}`,
+      url: npmPackageUrl(metadata.pkgName),
+      choice: { type: 'npm' },
+    })
+  }
+
+  return options
+}
+
+/**
+ * @param {object[]} entries
+ * @param {string} workspaceRoot
+ * @param {{ githubOrgs?: string[], githubUser?: string | null }} settings
+ */
+export async function enrichCatalogEntries(entries, workspaceRoot, settings) {
+  const cache = readCacheFile(workspaceRoot)
+  const sshAuth = getCachedSshAuth(workspaceRoot) ?? { available: false }
+
+  return entries.map((entry) => {
+    const pkgMeta = cache?.packages?.[entry.shortName]
+    return {
+      ...entry,
+      trusted: isTrustedPublisher(entry, settings),
+      sourcesMeta: {
+        npm: pkgMeta?.npm ?? null,
+        github: {
+          official: {
+            owner: entry.org && entry.org !== 'workspace' ? entry.org : 'owdproject',
+            htmlUrl: entry.htmlUrl ?? githubHtmlUrl(entry.org ?? 'owdproject', entry.shortName),
+          },
+          fork: pkgMeta?.github?.fork ?? null,
+        },
+      },
+    }
+  })
+}
+
+/**
+ * @param {{ sourcesMeta?: { npm?: { version?: string } | null }, localSource?: boolean, htmlUrl?: string, trusted?: boolean }} item
+ */
+export function formatSourceBadges(item) {
+  const parts = []
+  if (item.localSource) parts.push(`{cyan-fg}l{/}`)
+  if (item.sourcesMeta?.npm?.version) parts.push(`{green-fg}n{/}`)
+  if (item.htmlUrl || item.sourcesMeta?.github) parts.push(`{blue-fg}g{/}`)
+  if (item.trusted === false) parts.push(`{yellow-fg}!{/}`)
+  return parts.length ? ` ${parts.join('')}` : ''
+}

package/bin/lib/playgroundContext.js

@@ -0,0 +1,188 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { dirname, join, resolve, sep } from 'node:path'
+import { SCOPE } from './workspace.js'
+
+const PLAYGROUND_CONFIG = join('playground', 'desktop.config.ts')
+
+/**
+ * @param {string} dir
+ * @returns {boolean}
+ */
+export function hasPlaygroundDesktopConfig(dir) {
+  return (
+    existsSync(join(dir, 'playground')) &&
+    existsSync(join(dir, PLAYGROUND_CONFIG))
+  )
+}
+
+/**
+ * @param {string} pkgPath
+ * @returns {{ name: string } | null}
+ */
+function readOwdPackageJson(pkgPath) {
+  if (!existsSync(pkgPath)) return null
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'))
+    if (typeof pkg.name === 'string' && pkg.name.startsWith(SCOPE)) {
+      return { name: pkg.name }
+    }
+  } catch {
+    /* ignore */
+  }
+  return null
+}
+
+/**
+ * Walk up from cwd until a package.json with @owdproject/* name and a playground
+ * with desktop.config.ts is found.
+ *
+ * @param {string} [startDir]
+ * @returns {string | null} Absolute package directory
+ */
+export function findOwdModulePackageRoot(startDir = process.cwd()) {
+  let dir = resolve(startDir)
+  for (;;) {
+    const meta = readOwdPackageJson(join(dir, 'package.json'))
+    if (meta && hasPlaygroundDesktopConfig(dir)) {
+      return dir
+    }
+    const parent = dirname(dir)
+    if (parent === dir) return null
+    dir = parent
+  }
+}
+
+/**
+ * @param {string} path
+ * @param {string} root
+ */
+function isPathInside(path, root) {
+  const normalized = resolve(path)
+  const base = resolve(root)
+  return normalized === base || normalized.startsWith(base + sep)
+}
+
+/**
+ * @typedef {'workspace' | 'playground'} DevTargetMode
+ */
+
+/**
+ * @typedef {object} DevTarget
+ * @property {DevTargetMode} mode
+ * @property {string} workspaceRoot
+ * @property {string} packageDir Directory where `pnpm run dev` runs
+ * @property {string | null} packageName Set when mode is playground
+ * @property {string | null} playgroundDir Absolute path to playground/
+ */
+
+/**
+ * @param {string} packageDir
+ * @param {string} workspaceRoot
+ * @param {string} packageName
+ * @returns {DevTarget}
+ */
+function playgroundTarget(packageDir, workspaceRoot, packageName) {
+  return {
+    mode: 'playground',
+    workspaceRoot,
+    packageDir: resolve(packageDir),
+    packageName,
+    playgroundDir: join(resolve(packageDir), 'playground'),
+  }
+}
+
+/**
+ * @param {string} workspaceRoot
+ * @returns {DevTarget}
+ */
+function workspaceTarget(workspaceRoot) {
+  return {
+    mode: 'workspace',
+    workspaceRoot: resolve(workspaceRoot),
+    packageDir: resolve(workspaceRoot),
+    packageName: null,
+    playgroundDir: null,
+  }
+}
+
+/**
+ * Resolve whether the CLI/TUI should start the monorepo desktop shell or a
+ * module package playground dev server.
+ *
+ * @param {string} [cwd]
+ * @param {string | null} workspaceRoot
+ * @param {{ forcePlayground?: boolean }} [options]
+ * @returns {DevTarget | null} null when workspaceRoot is missing
+ */
+export function resolveDevTarget(cwd, workspaceRoot, options = {}) {
+  if (!workspaceRoot) return null
+
+  const normalizedCwd = resolve(cwd ?? process.cwd())
+  const root = resolve(workspaceRoot)
+  const desktopDir = join(root, 'desktop')
+  const packageRoot = findOwdModulePackageRoot(normalizedCwd)
+  const forcePlayground = options.forcePlayground === true
+
+  if (packageRoot) {
+    const meta = readOwdPackageJson(join(packageRoot, 'package.json'))
+    const packageName = meta?.name ?? null
+
+    if (forcePlayground) {
+      return playgroundTarget(packageRoot, root, packageName)
+    }
+
+    const atWorkspaceRoot = normalizedCwd === root
+    const underDesktopOnly =
+      isPathInside(normalizedCwd, desktopDir) && !isPathInside(normalizedCwd, packageRoot)
+
+    if (!atWorkspaceRoot && !underDesktopOnly && isPathInside(normalizedCwd, packageRoot)) {
+      return playgroundTarget(packageRoot, root, packageName)
+    }
+  }
+
+  if (forcePlayground) {
+    return null
+  }
+
+  return workspaceTarget(root)
+}
+
+/**
+ * @param {DevTarget | string | null | undefined} target
+ * @param {string} [workspaceRoot]
+ * @returns {DevTarget | null}
+ */
+export function normalizeDevTarget(target, workspaceRoot) {
+  if (!target) return workspaceRoot ? workspaceTarget(workspaceRoot) : null
+  if (typeof target === 'string') return workspaceTarget(target)
+  if (target.mode && target.workspaceRoot) return target
+  if (workspaceRoot) {
+    return {
+      ...workspaceTarget(workspaceRoot),
+      ...target,
+      workspaceRoot: resolve(workspaceRoot),
+    }
+  }
+  return null
+}
+
+/**
+ * @param {DevTarget | string} target
+ * @returns {string}
+ */
+export function devSpawnCwd(target) {
+  const resolved = typeof target === 'string' ? workspaceTarget(target) : target
+  return resolved.packageDir
+}
+
+/**
+ * @param {DevTarget | string} target
+ * @returns {string}
+ */
+export function devTargetLogLabel(target) {
+  const resolved = typeof target === 'string' ? workspaceTarget(target) : target
+  if (resolved.mode === 'playground' && resolved.packageName) {
+    return `playground ${resolved.packageName}`
+  }
+  return 'workspace desktop'
+}