@owdproject/core 3.3.1 → 4.0.0-alpha.3

package/bin/cli.js

@@ -1,395 +0,0 @@
-import { spawn } from 'node:child_process'
-import { runDevForeground } from './lib/status.js'
-import { existsSync } from 'node:fs'
-import { join } from 'node:path'
-import getopts from 'getopts'
-import {
-  resolveSource,
-  printPlan,
-  printNextSteps,
-  runWorkspaceInstall,
-  runNpmInstall,
-} from './lib/install.js'
-import { findWorkspaceRoot, inferKind } from './lib/workspace.js'
-import { resolveDevTarget } from './lib/playgroundContext.js'
-import { scaffoldProject } from './lib/scaffold.js'
-
-const SCOPE = '@owdproject/'
-
-/** @type {Record<string, { configKey: string, workspaceDir: string, nx: string, label: string }>} */
-const KINDS = {
-  app: {
-    label: 'app',
-    configKey: 'apps',
-    workspaceDir: 'apps',
-    nx: 'desktop:install-app',
-  },
-  module: {
-    label: 'module',
-    configKey: 'modules',
-    workspaceDir: 'packages',
-    nx: 'desktop:install-module',
-  },
-  theme: {
-    label: 'theme',
-    configKey: 'theme',
-    workspaceDir: 'themes',
-    nx: 'desktop:install-theme',
-  },
-}
-
-const LEGACY_COMMANDS = {
-  'install-app': 'app',
-  'install-module': 'module',
-  'install-theme': 'theme',
-}
-
-/** @type {string} */
-let commandName = 'desktop'
-
-function buildHelp(name) {
-  return `
-${name} — add apps, modules, and themes to your Open Web Desktop
-
-USAGE
-  ${name}                 Open the control panel (interactive TUI)
-  ${name} dev [--playground]  Start dev server (auto-detects module playground)
-
-CONTROL PANEL (TUI)
-  m                       Open command menu (all actions)
-  s                       Start the Nuxt dev server
-  x                       Stop the Nuxt dev server
-  R                       Reboot the Nuxt dev server (stop + start)
-  w                       Save catalog/theme changes to desktop.config.ts
-  i                       Open in-app docs (when module-docs is installed)
-  d                       Toggle User (npm) / Dev (git clone) install mode
-  g                       Settings (GitHub username for fork clones)
-  r                       Refresh package list from GitHub
-  b                       Run pnpm run generate
-  q / Esc                 Quit
-  ${name} init [dir]      Create a new OWD project (then opens the control panel)
-  ${name} add <package> [options]
-  ${name} add <kind> <name> [options]
-  ${name} validate [path...]  Check Nuxt module + playground layout
-  ${name} template [--dry-run] [--check]  Regenerate client/template/ (maintainers)
-
-TEMPLATE (monorepo maintainers)
-  ${name} template              Write template/ from blueprint + desktop/ + latest npm versions
-  ${name} template --dry-run    Show planned @owdproject/* and starter versions
-  ${name} template --check      Fail if committed template/ differs (CI)
-
-VALIDATE
-  ${name} validate            Validate cwd package, or all apps/themes/modules at repo root
-  ${name} validate .          Validate explicit package directory
-  ${name} validate apps       Validate every @owdproject/* module under apps/
-  --json                      Machine-readable output
-  --strict                    Treat warnings as failures
-  --smoke                     Run dev:prepare + nuxt build playground (slow, CI)
-
-INSTALL MODES
-  User (default)        npm registry — for end users and generated projects
-  Dev                   clone into apps/, packages/, or themes/ in the monorepo
-
-EXAMPLES
-  pnpm ${name}            # control panel
-  pnpm ${name} dev        # monorepo desktop (from repo root)
-  cd apps/app-about && pnpm ${name} dev   # app-about playground
-  pnpm ${name} dev --playground           # force playground when cwd is in a module
-  ${name} init my-desktop # scaffold + pnpm install + control panel
-  ${name} add app-todo --npm
-  ${name} add app-todo --dev
-  ${name} add module-persistence --from dxlliv
-
-KINDS (optional — inferred from the package name)
-  app       app-*     → apps/
-  module    module-*  → packages/  (kit-* and *-template are not listed in the control panel)
-  theme     theme-*   → themes/
-
-OPTIONS
-  --playground      Start the module playground dev server (when cwd is inside an @owdproject/* package with playground/)
-  --from <source>   Git source (user, user/repo, or URL)
-  --branch <name>   Git branch to clone
-  --npm             Install from npm (default when --from is omitted)
-  --dev, --workspace  Clone from github.com/owdproject/<package>
-  --dry-run         Print the plan without changing anything
-  -h, --help        Show this help
-
---from <source>
-  (omit)          npm registry (default)
-  npm             npm registry
-  owdproject      Clone official repo (monorepo only)
-  <github-user>   Clone github.com/<user>/<package> (your fork)
-  <user>/<repo>   Explicit GitHub repo
-  <git-url>       Full clone URL
-
-LEGACY (still supported)
-  ${name} install-app @owdproject/app-todo
-  → prefer: ${name} add app-todo
-`
-}
-
-async function openControlPanel(name) {
-  const { runTui } = await import('./tui.js')
-  await runTui(name)
-}
-
-function fail(message, hint) {
-  console.error(`\n✗ ${message}`)
-  if (hint) console.error(`  ${hint}`)
-  console.error(`\nRun \`${commandName} --help\` for usage.\n`)
-  process.exit(1)
-}
-
-function warn(message) {
-  console.warn(`\n⚠ ${message}\n`)
-}
-
-/**
- * @param {string} input
- * @param {string | undefined} explicitKind
- */
-function normalizePackage(input, explicitKind) {
-  let raw = input.trim()
-  if (raw.startsWith(SCOPE)) raw = raw.slice(SCOPE.length)
-
-  if (!raw) {
-    fail('Package name is required.', `Example: ${commandName} add app-todo`)
-  }
-
-  const kind = explicitKind ?? inferKind(raw)
-
-  if (explicitKind) {
-    const prefixes = {
-      app: 'app-',
-      theme: 'theme-',
-      module: ['module-', 'kit-'],
-    }
-    const expected = prefixes[explicitKind]
-    const list = Array.isArray(expected) ? expected : [expected]
-    if (!list.some((p) => raw.startsWith(p))) {
-      raw = `${list[0]}${raw}`
-    }
-  }
-
-  return { pkgName: `${SCOPE}${raw}`, shortName: raw, kind }
-}
-
-function mapLegacyFlags(parsed) {
-  const { dev, workspace, fork, repo, branch, from, npm } = parsed
-  let mappedFrom = from
-  let mappedNpm = npm
-  const forceDev = dev || workspace
-
-  if (fork || repo) {
-    warn('`--fork` and `--repo` are deprecated — use `--from` instead.')
-    mappedFrom = repo || fork
-  }
-  if (forceDev && !mappedFrom && !mappedNpm) {
-    mappedFrom = 'owdproject'
-  }
-  if (mappedNpm) mappedFrom = 'npm'
-
-  return { from: mappedFrom, branch, npm: mappedNpm, dev: forceDev }
-}
-
-function parseAddArgs(positionals) {
-  const kindNames = Object.keys(KINDS)
-  if (positionals.length === 0) {
-    fail('Missing package name.', `Example: ${commandName} add app-todo`)
-  }
-
-  if (kindNames.includes(positionals[0])) {
-    const kind = positionals[0]
-    const name = positionals[1]
-    if (!name) {
-      fail(`Missing name for kind "${kind}".`, `Example: ${commandName} add ${kind} todo`)
-    }
-    return normalizePackage(name, kind)
-  }
-
-  return normalizePackage(positionals[0])
-}
-
-function parseLegacyInstall(cmd, positionals) {
-  const kind = LEGACY_COMMANDS[cmd]
-  const raw = positionals[0]
-  if (!raw) {
-    fail('Missing package name.', `Example: ${commandName} ${cmd} ${SCOPE}app-todo`)
-  }
-  warn(`\`${cmd}\` is deprecated — use \`${commandName} add …\` instead.`)
-  return normalizePackage(raw, kind)
-}
-
-/**
- * @param {string} name CLI binary name (`desktop` or deprecated `owd`)
- * @param {string[]} argv Arguments (without node and script path)
- * @param {{ deprecated?: boolean }} [options]
- */
-export async function runCli(name, argv, options = {}) {
-  commandName = name
-
-  if (options.deprecated) {
-    warn('The `owd` command is deprecated. Use `desktop` instead.')
-  }
-
-  const parsed = getopts(argv, {
-    alias: { h: 'help', b: 'branch' },
-    boolean: ['help', 'npm', 'dry-run', 'dev', 'workspace', 'playground', 'json', 'strict', 'smoke', 'check'],
-    string: ['from', 'branch', 'fork', 'repo'],
-  })
-
-  const { _, help, npm: npmFlag } = parsed
-  const dryRun = parsed['dry-run'] === true
-  const { from, branch, npm: npmFromLegacy, dev: devFlag } = mapLegacyFlags(parsed)
-  const useNpm = npmFlag || npmFromLegacy || (!from && !devFlag)
-
-  if (help || _[0] === 'help') {
-    console.log(buildHelp(name))
-    process.exit(0)
-  }
-
-  const cmd = _[0]
-
-  if (cmd === 'init') {
-    const projectDir = (_[1] || 'owd-client').trim()
-    const cwd = process.cwd()
-
-    if (findWorkspaceRoot(cwd)) {
-      fail(
-        'Already inside an OWD workspace.',
-        `Use \`${name}\` to manage this project, or run init from a parent directory.`,
-      )
-    }
-
-    try {
-      await scaffoldProject({ dir: projectDir, cwd, commandName: name })
-    } catch (error) {
-      fail(error.message ?? String(error))
-    }
-    return
-  }
-
-  const workspaceRoot = findWorkspaceRoot()
-
-  if (cmd === 'dev') {
-    if (!workspaceRoot) {
-      fail(
-        'Not inside an OWD workspace.',
-        'Run from the client repo, or try: desktop · desktop add <package>',
-      )
-    }
-    const forcePlayground = parsed.playground === true
-    const devTarget = resolveDevTarget(process.cwd(), workspaceRoot, { forcePlayground })
-    if (forcePlayground && !devTarget) {
-      fail(
-        'No @owdproject module with playground/desktop.config.ts found from this directory.',
-        'Run from an app/theme/module package (e.g. apps/app-about), or omit --playground for the monorepo desktop.',
-      )
-    }
-    runDevForeground(devTarget)
-    return
-  }
-
-  if (cmd === 'validate') {
-    const { runValidateCli, formatValidationReport } = await import('./lib/validateModule.js')
-    const strict = parsed.strict === true
-    const json = parsed.json === true
-    const smoke = parsed.smoke === true
-    const paths = _.slice(1).map(String)
-    const { exitCode, results } = runValidateCli(paths, {
-      workspaceRoot,
-      json,
-      strict,
-      smoke,
-    })
-    for (const result of results) {
-      console.log(formatValidationReport(result, { json }))
-      if (!json) console.log('')
-    }
-    process.exit(exitCode)
-  }
-
-  if (cmd === 'template') {
-    if (!workspaceRoot) {
-      fail(
-        'Not inside an OWD workspace.',
-        `Run from the client monorepo root to regenerate template/.`,
-      )
-    }
-    const { runGenerateTemplateCli } = await import('./lib/generateTemplate.js')
-    await runGenerateTemplateCli({
-      workspaceRoot,
-      dryRun: parsed['dry-run'] === true,
-      check: parsed.check === true,
-    })
-    return
-  }
-
-  if (!cmd) {
-    if (!workspaceRoot) {
-      fail(
-        'Not inside an OWD workspace.',
-        'Run from the client repo, or try: desktop · desktop add <package>',
-      )
-    }
-    await openControlPanel(name)
-    return
-  }
-
-  if (cmd === 'ui') {
-    fail('The `ui` subcommand was removed.', `Use \`${name}\` to open the control panel.`)
-  }
-
-  if (!workspaceRoot) {
-    fail(
-      'Not inside an OWD workspace.',
-      'Run from the client repo (needs pnpm-workspace.yaml + nx.json), or use a generated project with the same layout.',
-    )
-  }
-
-  let pkgInfo
-
-  if (cmd === 'add') {
-    pkgInfo = parseAddArgs(_.slice(1))
-  } else if (LEGACY_COMMANDS[cmd]) {
-    pkgInfo = parseLegacyInstall(cmd, _.slice(1))
-  } else {
-    fail(`Unknown command: ${cmd}`, `Use \`${name}\`, \`${name} dev\`, or \`${name} add <package>\`.`)
-  }
-
-  const { pkgName, shortName, kind } = pkgInfo
-  const inMonorepo = Boolean(workspaceRoot)
-  const source = resolveSource(useNpm ? 'npm' : from, shortName, inMonorepo, {
-    npm: useNpm,
-    dev: devFlag,
-  })
-
-  if (source.mode === 'npm') {
-    if (dryRun) {
-      printPlan({
-        pkgName,
-        kind,
-        targetDir: '(npm → node_modules)',
-        source,
-        branch: null,
-        dryRun: true,
-      })
-      process.exit(0)
-    }
-    runNpmInstall(kind, pkgName, workspaceRoot)
-  } else {
-    try {
-      await runWorkspaceInstall({
-        pkgName,
-        shortName,
-        kind,
-        workspaceRoot,
-        source,
-        branch,
-        dryRun,
-      })
-    } catch (error) {
-      fail(error.message ?? String(error))
-    }
-  }
-}

package/bin/desktop.js

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-
-import { runCli } from './cli.js'
-
-await runCli('desktop', process.argv.slice(2))

package/bin/lib/catalog.js

@@ -1,293 +0,0 @@
-import {
-  existsSync,
-  readFileSync,
-  readdirSync,
-  mkdirSync,
-  writeFileSync,
-  statSync,
-} from 'node:fs'
-import { join } from 'node:path'
-import { execSync } from 'node:child_process'
-import {
-  KINDS,
-  SCOPE,
-  fullName,
-  shortName,
-  inferKind,
-  isInstallableDesktopModule,
-  desktopMetaDir,
-} from './workspace.js'
-import { hasLocalWorkspaceSource } from './install.js'
-
-const CACHE_TTL_MS = 60 * 60 * 1000
-
-function cachePath(workspaceRoot) {
-  return join(desktopMetaDir(workspaceRoot), 'catalog-cache.json')
-}
-
-function readCache(workspaceRoot) {
-  const path = cachePath(workspaceRoot)
-  if (!existsSync(path)) return null
-  try {
-    const data = JSON.parse(readFileSync(path, 'utf8'))
-    if (Date.now() - data.fetchedAt > CACHE_TTL_MS) return null
-    const ageMin = Math.round((Date.now() - data.fetchedAt) / 60_000)
-    return { entries: data.entries, cacheAge: `${ageMin}m` }
-  } catch {
-    return null
-  }
-}
-
-function formatCacheAge(fetchedAt) {
-  const ageMin = Math.round((Date.now() - fetchedAt) / 60_000)
-  if (ageMin < 1) return '<1m'
-  if (ageMin < 60) return `${ageMin}m`
-  return `${Math.round(ageMin / 60)}h`
-}
-
-function writeCache(workspaceRoot, entries) {
-  mkdirSync(desktopMetaDir(workspaceRoot), { recursive: true })
-  writeFileSync(
-    cachePath(workspaceRoot),
-    JSON.stringify({ fetchedAt: Date.now(), entries }, null, 2),
-  )
-}
-
-async function fetchTopic(topic, org) {
-  const q = encodeURIComponent(`topic:${topic} org:${org}`)
-  const url = `https://api.github.com/search/repositories?q=${q}&sort=stars&per_page=100`
-  const headers = {
-    Accept: 'application/vnd.github+json',
-    'User-Agent': 'owd-desktop-cli',
-  }
-  if (process.env.GITHUB_TOKEN) {
-    headers.Authorization = `Bearer ${process.env.GITHUB_TOKEN}`
-  }
-
-  const res = await fetch(url, { headers })
-  if (!res.ok) throw new Error(`GitHub API ${res.status} for ${org}/${topic}`)
-  const json = await res.json()
-  return (json.items ?? []).map((repo) => ({
-    shortName: repo.name,
-    description: repo.description ?? '',
-    stars: repo.stargazers_count ?? 0,
-    htmlUrl: repo.html_url,
-    org: repo.owner?.login ?? org,
-    kind: inferKind(repo.name),
-  }))
-}
-
-async function fetchUserRepos(user) {
-  const url = `https://api.github.com/users/${encodeURIComponent(user)}/repos?per_page=100&sort=updated`
-  const headers = {
-    Accept: 'application/vnd.github+json',
-    'User-Agent': 'owd-desktop-cli',
-  }
-  if (process.env.GITHUB_TOKEN) {
-    headers.Authorization = `Bearer ${process.env.GITHUB_TOKEN}`
-  }
-
-  const res = await fetch(url, { headers })
-  if (!res.ok) return []
-  const repos = await res.json()
-  return repos
-    .filter((repo) => /^(app|theme|module|kit)-/.test(repo.name))
-    .map((repo) => ({
-      shortName: repo.name,
-      description: repo.description ?? '',
-      stars: repo.stargazers_count ?? 0,
-      htmlUrl: repo.html_url,
-      org: repo.owner?.login ?? user,
-      kind: inferKind(repo.name),
-    }))
-}
-
-function scanLocal(workspaceRoot, kind) {
-  const dir = join(workspaceRoot, KINDS[kind].workspaceDir)
-  if (!existsSync(dir)) return []
-
-  return readdirSync(dir, { withFileTypes: true })
-    .filter((d) => d.isDirectory())
-    .map((d) => {
-      const pkgPath = join(dir, d.name, 'package.json')
-      if (!existsSync(pkgPath)) return null
-      try {
-        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'))
-        if (!pkg.name?.startsWith(SCOPE)) return null
-        let remote = null
-        try {
-          remote = execSync(`git -C ${join(dir, d.name)} remote get-url origin`, {
-            encoding: 'utf8',
-            stdio: ['ignore', 'pipe', 'ignore'],
-          }).trim()
-        } catch {
-          /* no git */
-        }
-        return {
-          shortName: shortName(pkg.name),
-          description: pkg.description ?? '',
-          stars: 0,
-          htmlUrl: pkg.homepage ?? pkg.repository?.url ?? null,
-          org: 'workspace',
-          kind,
-          localPath: join(KINDS[kind].workspaceDir, d.name),
-          remote,
-          version: pkg.version,
-        }
-      } catch {
-        return null
-      }
-    })
-    .filter(Boolean)
-}
-
-export async function loadCatalog(workspaceRoot, settings) {
-  const cached = readCache(workspaceRoot)
-  let remote = cached?.entries ?? null
-  let cacheAge = cached?.cacheAge ?? null
-
-  if (!remote) {
-    remote = []
-    const orgs = [...new Set([...(settings.githubOrgs ?? ['owdproject']), settings.githubUser].filter(Boolean))]
-
-    for (const org of orgs) {
-      for (const kind of Object.keys(KINDS)) {
-        try {
-          const items = await fetchTopic(KINDS[kind].topic, org)
-          remote.push(...items)
-        } catch {
-          /* offline — use local only */
-        }
-      }
-    }
-
-    if (settings.githubUser && !orgs.includes(settings.githubUser)) {
-      try {
-        remote.push(...(await fetchUserRepos(settings.githubUser)))
-      } catch {
-        /* ignore */
-      }
-    }
-
-    if (remote.length) {
-      const at = Date.now()
-      writeCache(workspaceRoot, remote)
-      cacheAge = formatCacheAge(at)
-    }
-  }
-
-  const byName = new Map()
-
-  for (const item of remote) {
-    byName.set(item.shortName, { ...item, sources: [item.org] })
-  }
-
-  for (const kind of Object.keys(KINDS)) {
-    for (const item of scanLocal(workspaceRoot, kind)) {
-      const prev = byName.get(item.shortName)
-      if (prev) {
-        byName.set(item.shortName, {
-          ...prev,
-          ...item,
-          localPath: item.localPath,
-          remote: item.remote ?? prev.htmlUrl,
-          sources: [...new Set([...(prev.sources ?? []), 'workspace'])],
-        })
-      } else {
-        byName.set(item.shortName, { ...item, sources: ['workspace'] })
-      }
-    }
-  }
-
-  const entries = [...byName.values()].map((entry) => ({
-    ...entry,
-    name: fullName(entry.shortName),
-    kind: entry.kind ?? inferKind(entry.shortName),
-  }))
-
-  return {
-    entries,
-    cacheAge: cacheAge ?? 'live',
-  }
-}
-
-export function filterCatalog(catalog, kind) {
-  return catalog
-    .filter((e) => e.kind === kind)
-    .filter((e) => kind !== 'module' || isInstallableDesktopModule(e.name))
-    .sort((a, b) => {
-      if (a.org === 'workspace' && b.org !== 'workspace') return -1
-      if (b.org === 'workspace' && a.org !== 'workspace') return 1
-      return (b.stars ?? 0) - (a.stars ?? 0) || a.shortName.localeCompare(b.shortName)
-    })
-}
-
-export function mergeInstalled(catalog, config, deps, workspaceRoot) {
-  const installedApps = new Set(config.apps ?? [])
-  const installedModules = new Set(config.modules ?? [])
-  const activeTheme = config.theme
-
-  return catalog.map((entry) => {
-    let installed = false
-    if (entry.kind === 'app') installed = installedApps.has(entry.name)
-    else if (entry.kind === 'module') installed = installedModules.has(entry.name)
-    else if (entry.kind === 'theme') installed = activeTheme === entry.name
-
-    const localSource = workspaceRoot
-      ? hasLocalWorkspaceSource(workspaceRoot, entry.name)
-      : entry.org === 'workspace'
-
-    return {
-      ...entry,
-      installed,
-      localSource,
-      inPackageJson: deps.includes(entry.name),
-      activeTheme: entry.kind === 'theme' && activeTheme === entry.name,
-    }
-  })
-}
-
-export function readThemeMeta(workspaceRoot, themePkgName) {
-  const short = shortName(themePkgName)
-  const localDir = join(workspaceRoot, 'themes', short)
-  const pkgPath = join(localDir, 'package.json')
-
-  if (!existsSync(pkgPath)) {
-    return {
-      name: themePkgName,
-      description: 'Theme package not in workspace',
-      version: '—',
-      author: '—',
-      remote: null,
-      license: '—',
-    }
-  }
-
-  const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'))
-  let remote = null
-  try {
-    remote = execSync(`git -C ${localDir} remote get-url origin`, {
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'ignore'],
-    }).trim()
-  } catch {
-    remote = pkg.repository?.url ?? pkg.homepage ?? null
-  }
-
-  const author =
-    typeof pkg.author === 'string'
-      ? pkg.author
-      : pkg.author?.name
-        ? `${pkg.author.name}${pkg.author.url ? ` · ${pkg.author.url}` : ''}`
-        : '—'
-
-  return {
-    name: pkg.name,
-    description: pkg.description ?? '',
-    version: pkg.version ?? '—',
-    author,
-    license: pkg.license ?? 'MIT',
-    remote,
-    homepage: pkg.homepage ?? null,
-  }
-}