@owdproject/core 3.3.1 → 4.0.0-alpha.3

package/bin/lib/install.js

@@ -1,408 +0,0 @@
-import { execSync, spawn } from 'node:child_process'
-import { existsSync } from 'node:fs'
-import { createRequire } from 'node:module'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import {
-  KINDS,
-  shortName as toShortName,
-  isWorkspaceInstallMode,
-  inferKind,
-} from './workspace.js'
-import {
-  resolveDesktopConfigPath,
-  desktopConfigWritePath,
-} from './desktopConfig.js'
-
-const require = createRequire(import.meta.url)
-const __dirname = dirname(fileURLToPath(import.meta.url))
-const desktopBin = join(__dirname, '..', 'desktop.js')
-
-const SCOPE = '@owdproject/'
-
-/**
- * @param {string | undefined} from
- * @param {string} pkgShortName
- * @param {boolean} inMonorepo
- * @param {{ npm?: boolean, dev?: boolean }} [options]
- */
-export function resolveSource(from, pkgShortName, inMonorepo, options = {}) {
-  const { npm = false, dev = false } = options
-
-  if (npm || from === 'npm' || from === 'registry') {
-    return { mode: 'npm', label: 'npm registry' }
-  }
-
-  if (dev && inMonorepo) {
-    return {
-      mode: 'workspace',
-      gitUrl: `https://github.com/owdproject/${pkgShortName}.git`,
-      label: `github.com/owdproject/${pkgShortName}`,
-    }
-  }
-
-  if (!from) {
-    return { mode: 'npm', label: 'npm registry' }
-  }
-
-  if (from === 'owdproject' || from === 'official') {
-    if (!inMonorepo) {
-      return { mode: 'npm', label: 'npm registry' }
-    }
-    return {
-      mode: 'workspace',
-      gitUrl: `https://github.com/owdproject/${pkgShortName}.git`,
-      label: `github.com/owdproject/${pkgShortName}`,
-    }
-  }
-
-  const trimmed = from.trim()
-
-  if (
-    trimmed.startsWith('https://') ||
-    trimmed.startsWith('http://') ||
-    trimmed.startsWith('git@') ||
-    trimmed.startsWith('ssh://')
-  ) {
-    return {
-      mode: 'workspace',
-      gitUrl: normalizeGitUrl(trimmed),
-      label: trimmed,
-    }
-  }
-
-  const slug = trimmed
-    .replace(/^github:/, '')
-    .replace(/^fork:/, '')
-    .replace(/^https?:\/\/github\.com\//, '')
-    .replace(/\.git$/, '')
-    .replace(/\/$/, '')
-
-  if (slug.includes('/')) {
-    const gitUrl = normalizeGitUrl(`https://github.com/${slug}`)
-    return { mode: 'workspace', gitUrl, label: slug }
-  }
-
-  if (!inMonorepo) {
-    return { mode: 'npm', label: 'npm registry' }
-  }
-
-  return {
-    mode: 'workspace',
-    gitUrl: `https://github.com/${slug}/${pkgShortName}.git`,
-    label: `github.com/${slug}/${pkgShortName}`,
-  }
-}
-
-export function normalizeGitUrl(input) {
-  const trimmed = input.trim().replace(/\/$/, '')
-  if (trimmed.startsWith('git@') || trimmed.startsWith('ssh://')) return trimmed
-  if (/^https?:\/\//.test(trimmed)) {
-    return trimmed.endsWith('.git') ? trimmed : `${trimmed}.git`
-  }
-  const path = trimmed
-    .replace(/^github\.com\//, '')
-    .replace(/^https?:\/\/github\.com\//, '')
-  if (/^[\w.-]+\/[\w.-]+/.test(path)) {
-    return `https://github.com/${path.split('/').slice(0, 2).join('/')}.git`
-  }
-  throw new Error(`Could not parse git source: "${input}"`)
-}
-
-/**
- * @param {string} workspaceRoot
- * @param {string} pkgName full @owdproject/name
- */
-export function hasLocalWorkspaceSource(workspaceRoot, pkgName) {
-  const pkgShort = toShortName(pkgName)
-  const kind = inferKind(pkgShort)
-  return existsSync(join(workspaceRoot, KINDS[kind].workspaceDir, pkgShort, 'package.json'))
-}
-
-export async function resolveForkUser(githubUser, pkgShortName) {
-  if (!githubUser || githubUser === 'owdproject') return 'owdproject'
-
-  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) return githubUser
-  } catch {
-    /* ignore */
-  }
-
-  return 'owdproject'
-}
-
-/**
- * @param {string} pkgName full @owdproject/name
- * @param {import('./workspace.js').InstallMode extends infer M ? { installMode?: M, githubUser?: string | null } : never} settings
- * @param {string | null} workspaceRoot
- */
-export async function resolveInstallPlan(pkgName, settings, workspaceRoot) {
-  const pkgShort = toShortName(pkgName)
-  const kind = inferKind(pkgShort)
-  const inMonorepo = Boolean(workspaceRoot)
-
-  if (!isWorkspaceInstallMode(settings)) {
-    return {
-      mode: 'npm',
-      pkgName,
-      shortName: pkgShort,
-      kind,
-      label: 'npm registry',
-    }
-  }
-
-  if (!inMonorepo) {
-    return {
-      error:
-        'Dev install mode requires an OWD monorepo (apps/, packages/, themes/). Switch to User mode or use --npm.',
-    }
-  }
-
-  const fromUser = settings.githubUser
-    ? await resolveForkUser(settings.githubUser, pkgShort)
-    : 'owdproject'
-
-  const source = resolveSource(fromUser, pkgShort, true)
-  return {
-    mode: 'workspace',
-    pkgName,
-    shortName: pkgShort,
-    kind,
-    from: fromUser,
-    source,
-    targetDir: join(KINDS[kind].workspaceDir, pkgShort),
-    label: source.label,
-  }
-}
-
-/**
- * @param {string} pkgName
- * @param {{ installMode?: string, githubUser?: string | null }} settings
- * @param {string} workspaceRoot
- * @param {{ stdio?: 'inherit' | 'pipe' }} [options]
- */
-export async function installPackage(pkgName, settings, workspaceRoot, options = {}) {
-  const plan = await resolveInstallPlan(pkgName, settings, workspaceRoot)
-  if (plan.error) throw new Error(plan.error)
-
-  const stdio = options.stdio ?? 'inherit'
-  const args = ['add', plan.shortName]
-
-  if (plan.mode === 'npm') {
-    args.push('--npm')
-  } else if (plan.from && plan.from !== 'owdproject') {
-    args.push('--from', plan.from)
-  } else {
-    args.push('--dev')
-  }
-
-  execSync(
-    `node ${JSON.stringify(desktopBin)} ${args.map((a) => JSON.stringify(a)).join(' ')}`,
-    { cwd: workspaceRoot, stdio },
-  )
-
-  return plan
-}
-
-export function runPrepareModules(workspaceRoot, stdio = 'inherit') {
-  try {
-    execSync('pnpm run prepare:modules', { cwd: workspaceRoot, stdio })
-  } catch {
-    /* optional in minimal workspaces */
-  }
-}
-
-function loadConfigUtil(workspaceRoot) {
-  const utilPath = join(
-    workspaceRoot,
-    'node_modules/@owdproject/nx/dist/utils/utilConfig.js',
-  )
-  if (!existsSync(utilPath)) {
-    throw new Error('Workspace install needs @owdproject/nx. Run `pnpm install` at the repo root.')
-  }
-  return require(utilPath)
-}
-
-export function printPlan({ pkgName, kind, targetDir, source, branch, dryRun }) {
-  const kindMeta = KINDS[kind]
-  console.log(`
-${dryRun ? 'Plan (dry run)' : 'Adding to desktop'}
-────────────────────────────────────────
-  Package   ${pkgName}
-  Type      ${kindMeta.label}
-  Folder    ${targetDir}/
-  Source    ${source.label}${branch ? ` (branch: ${branch})` : ''}
-  Config    desktop/desktop.config.ts → ${kindMeta.configKey}
-────────────────────────────────────────
-`)
-}
-
-export function printNextSteps({ targetDir, dryRun }) {
-  if (dryRun) {
-    console.log('Dry run complete. Re-run without --dry-run to apply.\n')
-    return
-  }
-  console.log(`Next steps:
-  pnpm run dev               Start the desktop
-  pnpm run prepare:modules   Rebuild module stubs if needed
-
-  Package lives in ${targetDir}/
-`)
-}
-
-/**
- * @param {string} targetDir
- * @param {string} gitUrl
- * @param {string | undefined} branch
- * @param {string} workspaceRoot
- * @param {{ stdio?: 'inherit' | 'pipe' | 'ignore', quiet?: boolean }} [options]
- */
-export function cloneRepo(targetDir, gitUrl, branch, workspaceRoot, options = {}) {
-  const stdio = options.stdio ?? 'inherit'
-  const quiet = options.quiet ?? stdio !== 'inherit'
-  const absoluteTarget = join(workspaceRoot, targetDir)
-
-  if (existsSync(join(absoluteTarget, 'package.json'))) {
-    if (!quiet) console.log(`Folder ${targetDir}/ already exists — skipping clone.\n`)
-    return
-  }
-
-  if (existsSync(absoluteTarget)) {
-    throw new Error(
-      `${targetDir}/ exists but has no package.json. Remove the folder or clone your fork there manually.`,
-    )
-  }
-
-  const branchArg = branch ? `-b ${JSON.stringify(branch)} ` : ''
-  if (!quiet) console.log(`Cloning into ${targetDir}/ …\n`)
-  execSync(
-    `git clone ${branchArg}${JSON.stringify(gitUrl)} ${JSON.stringify(absoluteTarget)}`,
-    { stdio, cwd: workspaceRoot },
-  )
-}
-
-function linkWorkspacePackage(desktopPath, pkgName, stdio = 'inherit') {
-  execSync(`pnpm add ${pkgName}@workspace:*`, {
-    stdio,
-    cwd: desktopPath,
-  })
-}
-
-function runDevPrepare(workspaceRoot, pkgName, options = {}) {
-  const stdio = options.stdio ?? 'inherit'
-  const quiet = options.quiet ?? stdio !== 'inherit'
-  try {
-    execSync(`pnpm --filter "${pkgName}" run dev:prepare`, {
-      stdio,
-      cwd: workspaceRoot,
-    })
-  } catch {
-    if (!quiet) console.log('(no dev:prepare script — ok for some packages)\n')
-  }
-}
-
-export async function runWorkspaceInstall({
-  pkgName,
-  shortName: pkgShort,
-  kind,
-  workspaceRoot,
-  source,
-  branch,
-  dryRun,
-}) {
-  const { workspaceDir } = KINDS[kind]
-  const targetDir = join(workspaceDir, pkgShort)
-  const desktopPath = join(workspaceRoot, 'desktop')
-  const resolved = resolveDesktopConfigPath(desktopPath)
-  const configPath = resolved?.path ?? desktopConfigWritePath(desktopPath)
-
-  printPlan({
-    pkgName,
-    kind,
-    targetDir,
-    source,
-    branch,
-    dryRun,
-  })
-
-  if (dryRun) {
-    printNextSteps({ targetDir, dryRun: true })
-    return
-  }
-
-  cloneRepo(targetDir, source.gitUrl, branch, workspaceRoot)
-  linkWorkspacePackage(desktopPath, pkgName)
-
-  const { addToDesktopConfig } = loadConfigUtil(workspaceRoot)
-  addToDesktopConfig(configPath, KINDS[kind].configKey, pkgName)
-
-  runDevPrepare(workspaceRoot, pkgName)
-
-  console.log(`✓ ${pkgName} is ready.\n`)
-  printNextSteps({ targetDir, dryRun: false })
-}
-
-export function runNpmInstall(kind, pkgName, workspaceRoot, stdio = 'inherit') {
-  const nxTarget = KINDS[kind].nx
-  const child = spawn('pnpm', ['nx', 'run', nxTarget, `--name=${pkgName}`], {
-    stdio,
-    shell: true,
-    cwd: workspaceRoot,
-  })
-  child.on('exit', (code) => {
-    if (stdio === 'inherit') process.exit(code ?? 1)
-  })
-  return child
-}
-
-/** Preview label for TUI list rows */
-/**
- * @param {string} pkgName
- * @param {{ installMode?: string, githubUser?: string | null }} settings
- * @param {string} workspaceRoot
- * @param {{ stdio?: 'inherit' | 'pipe' }} [options]
- */
-export async function materializeToWorkspace(pkgName, settings, workspaceRoot, options = {}) {
-  const plan = await resolveInstallPlan(pkgName, settings, workspaceRoot)
-  if (plan.error) throw new Error(plan.error)
-  if (plan.mode !== 'workspace') {
-    throw new Error(`Cannot materialize ${pkgName}: install mode is not DEV (workspace).`)
-  }
-
-  if (hasLocalWorkspaceSource(workspaceRoot, pkgName)) {
-    return { skipped: true, plan }
-  }
-
-  const stdio = options.stdio ?? 'inherit'
-  const quiet = stdio !== 'inherit'
-  const desktopPath = join(workspaceRoot, 'desktop')
-
-  cloneRepo(plan.targetDir, plan.source.gitUrl, undefined, workspaceRoot, { stdio, quiet })
-  linkWorkspacePackage(desktopPath, pkgName, stdio)
-  runDevPrepare(workspaceRoot, pkgName, { stdio, quiet })
-
-  return { skipped: false, plan }
-}
-
-/** @param {import('./catalog.js').CatalogEntry} item */
-export function catalogListTag(item) {
-  if (item.localSource) return 'local'
-  if (item.installed && !item.localSource) return 'npm'
-  if (item.org === 'workspace') return 'local'
-  return 'catalog'
-}
-
-export function installTag(settings, item) {
-  const tag = catalogListTag(item)
-  if (tag === 'catalog') {
-    if (isWorkspaceInstallMode(settings)) {
-      const user = settings.githubUser
-      return user && user !== 'owdproject' ? 'git fork' : 'git'
-    }
-    return 'npm'
-  }
-  return tag
-}

package/bin/lib/migrateModulePlayground.config.mjs

@@ -1,164 +0,0 @@
-/** @typedef {import('./migrateModulePlayground.mjs').MigrateConfig} MigrateConfig */
-
-/** @type {MigrateConfig[]} */
-export const configs = [
-  {
-    path: 'apps/app-todo',
-    slug: 'app-todo',
-    name: '@owdproject/app-todo',
-    moduleName: 'owd-app-todo',
-    version: '0.1.3',
-    keywords: ['owd-client', 'owd-apps', 'owd-modules'],
-    launch: {
-      file: 'launch-todo.client.ts',
-      pluginName: 'app-todo-playground-launch',
-      dependsOn: 'owd-app-todo-register',
-      appId: 'org.owdproject.todo',
-      command: 'todo',
-    },
-    pagesYml: true,
-  },
-  {
-    path: 'apps/app-terminal',
-    slug: 'app-terminal',
-    name: '@owdproject/app-terminal',
-    moduleName: 'owd-app-terminal',
-    version: '0.1.3',
-    launch: {
-      file: 'launch-terminal.client.ts',
-      pluginName: 'app-terminal-playground-launch',
-      dependsOn: 'owd-app-terminal-register',
-      appId: 'org.owdproject.terminal',
-      command: 'terminal',
-    },
-    pagesYml: true,
-  },
-  {
-    path: 'apps/app-debug',
-    slug: 'app-debug',
-    name: '@owdproject/app-debug',
-    moduleName: 'owd-app-debug',
-    version: '0.1.0',
-    launch: {
-      file: 'launch-debug.client.ts',
-      pluginName: 'app-debug-playground-launch',
-      dependsOn: 'owd-app-debug-register',
-      appId: 'org.owdproject.debug',
-      command: 'debug',
-    },
-    pagesYml: true,
-  },
-  {
-    path: 'apps/app-dino',
-    slug: 'app-dino',
-    name: '@owdproject/app-dino',
-    moduleName: 'owd-app-dino',
-    version: '0.0.1',
-    private: true,
-    launch: {
-      file: 'launch-dino.client.ts',
-      pluginName: 'app-dino-playground-launch',
-      dependsOn: 'owd-app-dino-register',
-      appId: 'org.owdproject.dino',
-      command: 'dino',
-    },
-  },
-  {
-    path: 'apps/app-soundcloud',
-    slug: 'app-soundcloud',
-    name: '@owdproject/app-soundcloud',
-    moduleName: 'owd-app-soundcloud',
-    version: '0.1.0',
-    launch: {
-      file: 'launch-soundcloud.client.ts',
-      pluginName: 'app-soundcloud-playground-launch',
-      dependsOn: 'owd-app-soundcloud-register',
-      appId: 'org.owdproject.soundcloud',
-      command: 'soundcloud --new --no-check',
-    },
-    pagesYml: true,
-  },
-  {
-    path: 'apps/app-youtube',
-    slug: 'app-youtube',
-    name: '@owdproject/app-youtube',
-    moduleName: 'owd-app-youtube',
-    version: '0.1.0',
-    launch: {
-      file: 'launch-youtube.client.ts',
-      pluginName: 'app-youtube-playground-launch',
-      dependsOn: 'owd-app-youtube-register',
-      appId: 'org.owdproject.youtube',
-      command: 'youtube --new --no-check',
-    },
-    pagesYml: true,
-  },
-  {
-    path: 'apps/app-classic-audioplayer',
-    slug: 'app-classic-audioplayer',
-    name: '@owdproject/app-classic-audioplayer',
-    moduleName: 'owd-app-classic-audioplayer',
-    version: '0.0.4',
-    playgroundModules: ['@owdproject/module-fs', '@owdproject/module-persistence'],
-    playgroundApps: ['@owdproject/app-classic-audioplayer'],
-    fsMounts: { '/mnt/test': '/test.zip' },
-    copyTestZip: true,
-    playgroundExtraDevDeps: {
-      '@owdproject/module-fs': '^0.0.4',
-      '@owdproject/module-persistence': '^0.0.2',
-    },
-    launch: {
-      file: 'launch-audioplayer.client.ts',
-      pluginName: 'app-classic-audioplayer-playground-launch',
-      dependsOn: 'owd-app-classic-audioplayer-register',
-      appId: 'org.owdproject.classic-audioplayer',
-      command: 'classic-audioplayer',
-      fsDemo: true,
-    },
-    pagesYml: true,
-  },
-  {
-    path: 'apps/app-classic-videoplayer',
-    slug: 'app-classic-videoplayer',
-    name: '@owdproject/app-classic-videoplayer',
-    moduleName: 'owd-app-classic-videoplayer',
-    version: '0.0.4',
-    launch: {
-      file: 'launch-videoplayer.client.ts',
-      pluginName: 'app-classic-videoplayer-playground-launch',
-      dependsOn: 'owd-app-classic-videoplayer-register',
-      appId: 'org.owdproject.classic-videoplayer',
-      command: 'classic-videoplayer',
-    },
-    pagesYml: true,
-  },
-  {
-    path: 'apps/app-explorer',
-    slug: 'app-explorer',
-    name: '@owdproject/app-explorer',
-    moduleName: 'owd-app-explorer',
-    version: '0.0.4',
-    playgroundModules: ['@owdproject/module-fs', '@owdproject/module-persistence'],
-    playgroundApps: ['@owdproject/app-explorer'],
-    fsMounts: { '/mnt/test': '/test.zip' },
-    copyTestZip: true,
-    playgroundExtraDevDeps: {
-      '@owdproject/module-fs': '^0.0.4',
-      '@owdproject/module-persistence': '^0.0.2',
-      '@owdproject/kit-fs': 'workspace:*',
-      '@owdproject/kit-explorer': 'workspace:*',
-    },
-    dependencies: {
-      '@owdproject/kit-explorer': 'workspace:*',
-      '@owdproject/kit-fs': 'workspace:*',
-    },
-    launch: {
-      file: 'launch-explorer.client.ts',
-      pluginName: 'app-explorer-playground-launch',
-      dependsOn: 'owd-app-explorer-register',
-      appId: 'org.owdproject.explorer',
-      command: 'explorer /mnt/test',
-    },
-    pagesYml: true,
-  },
-]