@owdproject/core 3.3.1 → 4.0.0-alpha.3

package/bin/lib/migrateModulePlayground.mjs

@@ -1,313 +0,0 @@
-#!/usr/bin/env node
-import {
-  copyFileSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  writeFileSync,
-} from 'node:fs'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { configs } from './migrateModulePlayground.config.mjs'
-
-const ROOT = join(dirname(fileURLToPath(import.meta.url)), '../../../../')
-
-function fixAppPlugin(pluginPath, registerName) {
-  const raw = readFileSync(pluginPath, 'utf8')
-  const configVar = raw.match(/import (config\w+) from/)?.[1] || 'configApp'
-  writeFileSync(
-    pluginPath,
-    `import { defineNuxtPlugin } from 'nuxt/app'
-import { defineDesktopApp } from '@owdproject/core/runtime/utils/utilDesktop'
-import ${configVar} from './app.config'
-
-export default defineNuxtPlugin({
-  name: '${registerName}',
-  async setup() {
-    if (import.meta.server) return
-    await defineDesktopApp(${configVar})
-  },
-})
-`,
-  )
-}
-
-function buildLaunchPlugin(cfg) {
-  const l = cfg.launch
-  if (l.fsDemo) {
-    return `import { nextTick } from 'vue'
-import { defineNuxtPlugin } from 'nuxt/app'
-import { useApplicationManager } from '@owdproject/core/runtime/composables/useApplicationManager'
-import { openVfsFile } from '@owdproject/module-fs/runtime/utils/utilFsOpenFile'
-
-const APP_ID = '${l.appId}'
-
-export default defineNuxtPlugin({
-  name: '${l.pluginName}',
-  dependsOn: ['${l.dependsOn}'],
-  async setup(nuxtApp) {
-    if (!import.meta.dev) return
-
-    const applicationManager = useApplicationManager()
-
-    async function runDemo() {
-      if (!applicationManager.isAppDefined('org.owdproject.explorer')) return false
-      await applicationManager.execAppCommand('org.owdproject.explorer', 'explorer /mnt/test')
-      const opened = await openVfsFile('/mnt/test/demo.mp3')
-      if (!opened && applicationManager.isAppDefined(APP_ID)) {
-        await applicationManager.execAppCommand(APP_ID, ${JSON.stringify(l.command)})
-      }
-      return true
-    }
-
-    nuxtApp.hook('app:mounted', async () => {
-      await nextTick()
-      for (let i = 0; i < 80; i++) {
-        if (await runDemo()) return
-        await new Promise((r) => setTimeout(r, 50))
-      }
-    })
-  },
-})
-`
-  }
-
-  return `import { nextTick } from 'vue'
-import { defineNuxtPlugin } from 'nuxt/app'
-import { useApplicationManager } from '@owdproject/core/runtime/composables/useApplicationManager'
-
-const APP_ID = '${l.appId}'
-const WINDOW_MODEL = 'main'
-
-export default defineNuxtPlugin({
-  name: '${l.pluginName}',
-  dependsOn: ['${l.dependsOn}'],
-  async setup(nuxtApp) {
-    if (!import.meta.dev) return
-
-    const applicationManager = useApplicationManager()
-
-    async function surfaceWindow() {
-      if (!applicationManager.isAppDefined(APP_ID)) return false
-      const app = applicationManager.getAppById(APP_ID)!
-      if (app.storeWindows.$persistedState) {
-        await app.storeWindows.$persistedState.isReady()
-      }
-      app.closeAllWindows()
-      app.storeWindows.windows = {}
-      await applicationManager.execAppCommand(APP_ID, ${JSON.stringify(l.command)})
-      const window = app.getFirstWindowByModel(WINDOW_MODEL)
-      if (window) {
-        window.actions.setActive(true)
-        window.actions.bringToFront()
-      }
-      return Boolean(window)
-    }
-
-    nuxtApp.hook('app:mounted', async () => {
-      await nextTick()
-      await surfaceWindow()
-    })
-
-    for (let attempt = 0; attempt < 80; attempt++) {
-      if (await surfaceWindow()) return
-      await new Promise((resolve) => setTimeout(resolve, 50))
-    }
-  },
-})
-`
-}
-
-function buildPackageJson(cfg, old) {
-  const slug = cfg.slug
-  const deps = { '@nuxt/kit': '^4.3.0', ...(cfg.dependencies || {}) }
-  const devDeps = {
-    '@nuxt/module-builder': '^1.0.2',
-    '@nuxt/schema': '^4.3.0',
-    '@owdproject/core': 'workspace:*',
-    '@owdproject/theme-nova': '0.0.1',
-    nuxt: '^4.3.0',
-    typescript: '~5.9.3',
-    ...(cfg.devDependencies || {}),
-    ...(cfg.playgroundExtraDevDeps || {}),
-  }
-
-  const pkg = {
-    name: cfg.name,
-    version: old.version || cfg.version,
-    description: old.description,
-    keywords: old.keywords || cfg.keywords,
-    license: old.license || 'MIT',
-    homepage: old.homepage || `https://github.com/owdproject/${slug}`,
-    author: old.author,
-    type: 'module',
-    exports: { '.': { types: './dist/types.d.mts', import: './dist/module.mjs' } },
-    main: './dist/module.mjs',
-    typesVersions: { '*': { '.': ['./dist/types.d.mts'] } },
-    files: ['dist'],
-    nx: { name: slug },
-    scripts: {
-      prepack: 'nuxt-module-build build',
-      dev: 'pnpm run dev:prepare && cd playground && pnpm exec nuxt dev',
-      'dev:build': 'nuxt build playground',
-      'dev:generate': `NUXT_APP_BASE_URL=\${NUXT_APP_BASE_URL:-/${slug}/} nuxt generate playground`,
-      'dev:prepare':
-        'nuxt-module-build build --stub && nuxt-module-build prepare && cd playground && pnpm exec nuxt prepare',
-      validate: 'desktop validate .',
-    },
-    dependencies: deps,
-    devDependencies: devDeps,
-    peerDependencies: old.peerDependencies || { '@owdproject/core': '^3.2.0' },
-  }
-  if (cfg.private || old.private) pkg.private = true
-  if (old.peerDependenciesMeta) pkg.peerDependenciesMeta = old.peerDependenciesMeta
-  return pkg
-}
-
-function buildPlaygroundPkg(cfg) {
-  const deps = {
-    '@owdproject/core': 'workspace:*',
-    [cfg.name]: 'workspace:*',
-    nuxt: '^4.4.4',
-    ...(cfg.playgroundExtraDevDeps || {}),
-  }
-  if (!cfg.playgroundTheme) deps['@owdproject/theme-nova'] = '0.0.1'
-  if (cfg.playgroundTheme) deps[cfg.playgroundTheme] = 'workspace:*'
-  return {
-    name: `${cfg.name}-playground`,
-    private: true,
-    type: 'module',
-    scripts: { dev: 'nuxt dev', build: 'nuxt build', generate: 'nuxt generate' },
-    dependencies: deps,
-  }
-}
-
-function buildDesktopConfig(cfg) {
-  const theme = cfg.playgroundTheme || '@owdproject/theme-nova'
-  const apps = cfg.playgroundApps || [cfg.name]
-  const modules = cfg.playgroundModules || []
-  let s = `import { defineDesktopConfig } from '@owdproject/core'\n\nexport default defineDesktopConfig({\n  theme: '${theme}',\n`
-  if (apps.length) s += `  apps: [${apps.map((a) => `'${a}'`).join(', ')}],\n`
-  if (modules.length) s += `  modules: [${modules.map((m) => `'${m}'`).join(', ')}],\n`
-  s += '  systemBar: { enabled: true, startButton: true },\n'
-  if (cfg.fsMounts) {
-    s += '  fs: {\n    mounts: {\n'
-    for (const [k, v] of Object.entries(cfg.fsMounts)) s += `      '${k}': '${v}',\n`
-    s += '    },\n  },\n'
-  }
-  s += '})\n'
-  return s
-}
-
-const NUXT = `export default defineNuxtConfig({
-  modules: ['@owdproject/core'],
-  app: { baseURL: process.env.NUXT_APP_BASE_URL || '/' },
-  i18n: { strategy: 'no_prefix' },
-  devtools: { enabled: true },
-  compatibilityDate: 'latest',
-  ssr: false,
-})
-`
-
-function pagesYml(slug) {
-  return `name: Deploy playground to GitHub Pages
-on:
-  push:
-    branches: [main]
-  workflow_dispatch:
-permissions:
-  contents: read
-  pages: write
-  id-token: write
-concurrency:
-  group: pages
-  cancel-in-progress: true
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-node@v6
-        with:
-          node-version: 22
-      - run: npm i -g --force corepack@latest && corepack enable
-      - run: npx nypm@latest i
-      - run: npm run dev:prepare
-      - run: npm run dev:generate
-        env:
-          NUXT_APP_BASE_URL: /${slug}/
-      - uses: actions/upload-pages-artifact@v3
-        with:
-          path: playground/.output/public
-  deploy:
-    needs: build
-    runs-on: ubuntu-latest
-    environment:
-      name: github-pages
-      url: \${{ steps.deployment.outputs.page_url }}
-    steps:
-      - uses: actions/deploy-pages@v4
-`
-}
-
-function migrate(cfg) {
-  const dir = join(ROOT, cfg.path)
-  const src = join(dir, 'src')
-  mkdirSync(src, { recursive: true })
-  if (existsSync(join(dir, 'module.ts'))) renameSync(join(dir, 'module.ts'), join(src, 'module.ts'))
-  if (existsSync(join(dir, 'runtime'))) renameSync(join(dir, 'runtime'), join(src, 'runtime'))
-
-  const registerName = `${cfg.moduleName}-register`
-  const pluginPath = join(src, 'runtime/plugin.ts')
-  if (existsSync(pluginPath)) fixAppPlugin(pluginPath, registerName)
-
-  const old = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'))
-  writeFileSync(join(dir, 'package.json'), JSON.stringify(buildPackageJson(cfg, old), null, 2) + '\n')
-
-  writeFileSync(
-    join(dir, 'tsconfig.json'),
-    JSON.stringify(
-      {
-        extends: '../../tsconfig.base.json',
-        include: ['src/runtime', 'src/module.ts', '../../packages/core/types/index.d.ts'],
-        exclude: ['dist', 'node_modules', 'playground'],
-        compilerOptions: { outDir: 'dist' },
-      },
-      null,
-      2,
-    ) + '\n',
-  )
-
-  writeFileSync(
-    join(dir, '.gitignore'),
-    'node_modules\n.nuxt\ndist\n.output\nplayground/.nuxt\nplayground/node_modules\n._*\n',
-  )
-
-  const pg = join(dir, 'playground')
-  mkdirSync(join(pg, 'app/plugins'), { recursive: true })
-  writeFileSync(join(pg, 'nuxt.config.ts'), NUXT)
-  writeFileSync(join(pg, 'tsconfig.json'), '{ "extends": "./.nuxt/tsconfig.json" }\n')
-  writeFileSync(join(pg, 'package.json'), JSON.stringify(buildPlaygroundPkg(cfg), null, 2) + '\n')
-  writeFileSync(join(pg, 'desktop.config.ts'), buildDesktopConfig(cfg))
-  writeFileSync(join(pg, 'app/app.vue'), '<template>\n  <Desktop />\n</template>\n')
-  if (cfg.launch) {
-    writeFileSync(join(pg, 'app/plugins', cfg.launch.file), buildLaunchPlugin(cfg))
-  }
-
-  if (cfg.copyTestZip) {
-    mkdirSync(join(pg, 'public'), { recursive: true })
-    const srcZip = join(ROOT, 'desktop/public/test.zip')
-    if (existsSync(srcZip)) copyFileSync(srcZip, join(pg, 'public/test.zip'))
-  }
-
-  if (cfg.pagesYml) {
-    const wf = join(dir, '.github/workflows')
-    mkdirSync(wf, { recursive: true })
-    writeFileSync(join(wf, 'pages.yml'), pagesYml(cfg.slug))
-  }
-
-  console.log('OK', cfg.name)
-}
-
-for (const cfg of configs) migrate(cfg)

package/bin/lib/npmVersions.js

@@ -1,124 +0,0 @@
-import { execSync } from 'node:child_process'
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
-import { join } from 'node:path'
-import { desktopMetaDir } from './workspace.js'
-
-const CACHE_TTL_MS = 60 * 60 * 1000
-const SCOPE = '@owdproject/'
-
-/**
- * @param {string} version
- */
-export function formatCaretVersion(version) {
-  const trimmed = String(version).trim()
-  if (!trimmed) throw new Error('Invalid npm version (empty)')
-  if (trimmed.startsWith('^') || trimmed.startsWith('~') || trimmed.startsWith('>=')) {
-    return trimmed
-  }
-  return `^${trimmed}`
-}
-
-/**
- * @param {unknown} error
- */
-function isNpmLookupSkippableError(error) {
-  const msg = error?.stderr?.toString?.() || error?.message || String(error)
-  return (
-    /E404|404 Not Found/.test(msg) ||
-    /EAI_AGAIN|ENOTFOUND|ETIMEDOUT|ECONNREFUSED|network/i.test(msg)
-  )
-}
-
-/**
- * @param {string} pkgName
- * @param {{ optional?: boolean }} [options]
- * @returns {string | null}
- */
-export function fetchLatestVersion(pkgName, options = {}) {
-  let out
-  try {
-    out = execSync(`npm view ${JSON.stringify(pkgName)} version`, {
-      encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'pipe'],
-    }).trim()
-  } catch (error) {
-    if (options.optional || isNpmLookupSkippableError(error)) return null
-    const msg = error.stderr?.toString?.() || error.message || String(error)
-    throw new Error(`npm view failed for ${pkgName}: ${msg}`)
-  }
-  return formatCaretVersion(out)
-}
-
-/**
- * @param {string[]} pkgNames
- * @returns {Record<string, string>}
- */
-export function fetchLatestVersions(pkgNames, options = {}) {
-  const unique = [...new Set(pkgNames.filter(Boolean))]
-  if (unique.length === 0) return {}
-
-  /** @type {Record<string, string>} */
-  const result = {}
-  for (const name of unique) {
-    const version = fetchLatestVersion(name, options)
-    if (version) result[name] = version
-  }
-  return result
-}
-
-function cachePath(workspaceRoot) {
-  return join(desktopMetaDir(workspaceRoot), 'template-versions.json')
-}
-
-/**
- * @param {string} workspaceRoot
- * @param {string[]} pkgNames
- * @param {{ useCache?: boolean }} [options]
- */
-export function resolveLatestVersions(workspaceRoot, pkgNames, options = {}) {
-  const useCache = options.useCache !== false
-  const unique = [...new Set(pkgNames.filter(Boolean))]
-  const path = cachePath(workspaceRoot)
-
-  if (useCache && existsSync(path)) {
-    try {
-      const data = JSON.parse(readFileSync(path, 'utf8'))
-      if (Date.now() - data.fetchedAt < CACHE_TTL_MS && data.versions) {
-        const cached = data.versions
-        const missing = unique.filter((name) => !cached[name])
-        if (missing.length === 0) {
-          return Object.fromEntries(unique.map((name) => [name, cached[name]]))
-        }
-        const fresh = fetchLatestVersions(missing)
-        const merged = { ...cached, ...fresh }
-        writeVersionCache(workspaceRoot, merged)
-        return Object.fromEntries(unique.map((name) => [name, merged[name]]))
-      }
-    } catch {
-      /* ignore corrupt cache */
-    }
-  }
-
-  const versions = fetchLatestVersions(unique)
-  if (useCache) writeVersionCache(workspaceRoot, versions)
-  return versions
-}
-
-/**
- * @param {string} workspaceRoot
- * @param {Record<string, string>} versions
- */
-export function writeVersionCache(workspaceRoot, versions) {
-  mkdirSync(desktopMetaDir(workspaceRoot), { recursive: true })
-  writeFileSync(
-    cachePath(workspaceRoot),
-    JSON.stringify({ fetchedAt: Date.now(), versions }, null, 2) + '\n',
-  )
-}
-
-/**
- * @param {string} pkgName
- */
-export function isOwdScopedPackage(pkgName) {
-  return pkgName.startsWith(SCOPE)
-}

package/bin/lib/playgroundContext.js

@@ -1,188 +0,0 @@
-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'
-}