@owdproject/core 3.3.1 → 3.4.0

package/types/index.d.ts

@@ -1,16 +1,14 @@
 import type { Nuxt } from '@nuxt/schema'
 import type { ShallowRef } from 'vue'
-import { useApplicationManager } from '../runtime/composables/useApplicationManager'
 
 declare module 'nuxt/schema' {
   interface PublicRuntimeConfig {
-    owd: {
-      tailwindPaths: []
-    }
+    desktop: DesktopConfig
   }
 }
 
-interface IApplicationManager {
+declare global {
+  interface IApplicationManager {
   apps: Map<string, IApplicationController>
 
   get appsEntries(): Reactive<ApplicationEntry[]>
@@ -61,6 +59,7 @@ interface ApplicationConfig {
   windows?: { [key: string]: WindowConfig }
   entries: { [key: string]: ApplicationEntry }
   commands?: { [key: string]: ApplicationCommand }
+  terminal?: { [commandName: string]: Omit<TerminalCommand, 'name' | 'applicationId'> }
 
   onReady?(app: IApplicationController): void | Promise<void>
 
@@ -73,7 +72,8 @@ interface ApplicationConfig {
 
 interface ApplicationConfigProvide {
   name: string
-  command: string
+  entry: string
+  command?: string
 }
 
 type IApplicationMeta = { [key: string]: any }
@@ -131,6 +131,8 @@ export interface IWindowController {
   // common
   get title(): string
 
+  get windowTitle(): string
+
   get icon(): string | undefined
 
   // sizes
@@ -173,6 +175,11 @@ export interface IWindowController {
     maximize(): boolean
     unmaximize(): boolean
 
+    // layout (snap / tiled zones)
+    setLayout(layout: WindowLayout): boolean
+    clearLayout(): boolean
+    saveBoundsBeforeLayout(): void
+
     // destroy
     destroy(): boolean
 
@@ -182,13 +189,15 @@ export interface IWindowController {
     // override
     setTitleOverride(title: string | undefined): void
     resetTitleOverride(): void
+    setWindowTitleOverride(title: string | undefined): void
+    resetWindowTitleOverride(): void
   }
 
   /** Payload restored with window state (e.g. explorer cwd in `path`). */
   get meta(): { path?: string } & Record<string, unknown>
 
-  /** Chrome menu model (e.g. PrimeVue Menubar). */
-  menu: unknown[]
+  /** Chrome menu model ({@link DesktopMenuItem}[]; Menubar-compatible). */
+  menu: import('../runtime/types/desktopMenu').DesktopMenuItem[]
 
   setMenu(menu: unknown[]): void
 
@@ -254,6 +263,7 @@ interface WindowStoredState {
 
 interface WindowOverride {
   title?: undefined | string
+  windowTitle?: undefined | string
   icon?: undefined | string
 }
 
@@ -289,6 +299,37 @@ interface WindowState {
 
   // draggable
   resizable?: boolean
+
+  /** Snap zone layout; `normal` is unset or explicit restore. */
+  layout?: WindowLayout
+
+  /** Bounds saved before first snap so restore can revert geometry. */
+  boundsBeforeLayout?: WindowBounds
+}
+
+export type WindowLayout =
+  | 'normal'
+  | 'maximize'
+  | 'bottom-half'
+  | 'left-half'
+  | 'right-half'
+  | 'top-left'
+  | 'top-right'
+  | 'bottom-left'
+  | 'bottom-right'
+
+export interface WindowBounds {
+  x: number
+  y: number
+  width: number
+  height: number
+}
+
+export interface DesktopWorkAreaRect {
+  x: number
+  y: number
+  width: number
+  height: number
 }
 
 interface WindowSize {
@@ -351,6 +392,7 @@ interface DocsModuleConfig {
 }
 
 interface DesktopConfig {
+  coreVersion?: string
   theme?: string
   modules?: string[]
   apps?: string[]
@@ -364,6 +406,7 @@ interface DesktopConfig {
   systemBar?: DesktopSystemBarConfig
   dockBar?: DesktopDockBarConfig
   workspaces?: DesktopWorkspacesConfig
+  windows?: DesktopWindowsConfig
 }
 
 interface DesktopWindowsConfig {
@@ -387,13 +430,36 @@ interface DesktopWorkspacesConfig {
 
 // TERMINAL
 
+type TerminalCommandArg = {
+  name: string
+  description?: string
+  required?: boolean
+}
+
+type TerminalCommandOption = {
+  flag: string
+  description?: string
+}
+
 type TerminalCommand = {
   name: string
   applicationId: string
+  description?: string
+  usage?: string
+  args?: TerminalCommandArg[]
+  options?: TerminalCommandOption[]
+}
+
+interface ITerminalManager {
+  addCommand(command: TerminalCommand): void
+  listCommands(): string[]
+  getCommand(name: string): TerminalCommand | undefined
+  getAllCommands(): TerminalCommand[]
+  execCommand(input: string): Promise<CommandOutput | void>
 }
 
 interface CommandOutput {
-  text: string
+  message: string
   isError?: boolean
 }
 
@@ -407,14 +473,59 @@ interface DefaultAppsConfig {
   [key: string]: DefaultAppConfig
 }
 
-/** Stored default for a feature: which app and which entry key to use. */
-interface DefaultAppConfig {
-  applicationId: string
-  entry: string
+  /** Stored default for a feature: which app and which entry key to use. */
+  interface DefaultAppConfig {
+    applicationId: string
+    entry: string
+  }
+
+  module '*.vue' {
+    import type { DefineComponent } from 'vue'
+    const component: DefineComponent<{}, {}, any>
+    export default component
+  }
 }
 
 export function defineDesktopApp(config: ApplicationConfig)
 export function defineDesktopConfig(config: DesktopConfig)
-export function registerTailwindPath(nuxt: Nuxt, path: string): void
+export function defineDesktopModule(
+  definition: import('@nuxt/kit').NuxtModule<
+    Record<string, unknown>,
+    Record<string, unknown>,
+    false
+  > & { meta: { name: string; configKey: string } },
+): ReturnType<typeof import('@nuxt/kit').defineNuxtModule>
+
+export function defineDesktopTheme(
+  definition: import('@nuxt/kit').NuxtModule<
+    Record<string, unknown>,
+    Record<string, unknown>,
+    false
+  >,
+): ReturnType<typeof import('@nuxt/kit').defineNuxtModule>
+
+export function setDesktopExtensionConfig(
+  nuxt: Nuxt,
+  configKey: string,
+  resolved: Record<string, unknown>,
+): void
+
+export function mergeDesktopExtensionConfig(
+  nuxt: Nuxt,
+  configKey: string,
+  partial: Record<string, unknown>,
+): void
+
+export function useDesktopConfig(): import('vue').ComputedRef<DesktopConfig>
+export function useDesktopExtension<K extends string>(
+  key: K,
+): import('vue').ComputedRef<unknown>
+export function hasDesktopModule(
+  pkg: string,
+): import('vue').ComputedRef<boolean>
+export function hasDesktopApp(pkg: string): import('vue').ComputedRef<boolean>
+export function hasDesktopExtension(
+  key: string,
+): import('vue').ComputedRef<boolean>
 
 export {}

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))