@owdproject/core 3.1.4-beta.0 → 3.2.0

package/bin/lib/install.js

@@ -0,0 +1,408 @@
+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

@@ -0,0 +1,164 @@
+/** @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': 'workspace:*',
+      '@owdproject/module-persistence': 'workspace:*',
+    },
+    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': 'workspace:*',
+      '@owdproject/module-persistence': 'workspace:*',
+      '@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,
+  },
+]