@owdproject/cli 0.0.3 → 0.2.0

package/bin/lib/workspace.js

@@ -0,0 +1,289 @@
+import { existsSync, readFileSync, mkdirSync, writeFileSync, readdirSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { execSync } from 'node:child_process'
+import {
+  resolveDesktopConfigPath,
+  desktopConfigWritePath,
+} from './desktopConfig.js'
+
+export const SCOPE = '@owdproject/'
+
+/** Not loadable via desktop.config `modules` (core is the shell). */
+export const DESKTOP_NON_INSTALLABLE = new Set([
+  '@owdproject/core',
+  '@owdproject/cli',
+  '@owdproject/nx',
+])
+
+/** Installed documentation modules (current + deprecated package name). */
+export const DOCS_MODULE_PACKAGES = [
+  '@owdproject/module-docs',
+  '@owdproject/docs',
+]
+
+export function hasDocsModuleInstalled(config, deps = {}) {
+  return DOCS_MODULE_PACKAGES.some(
+    (name) => config?.modules?.includes(name) || deps[name],
+  )
+}
+
+export function docsBasePathFromConfig(config) {
+  const base = config?.docs?.basePath
+  if (typeof base === 'string' && base.startsWith('/')) return base
+  return '/docs'
+}
+
+/** Theme-internal UI kits — pulled in by themes, not listed as desktop modules. */
+export function isDesktopKitPackage(pkgName) {
+  const isScoped = pkgName.startsWith(SCOPE)
+  const short = isScoped ? pkgName.slice(SCOPE.length) : pkgName
+  if (!isScoped && !pkgName.startsWith('kit-')) return false
+  return short.startsWith('kit-')
+}
+
+/** Scaffold / blueprint packages — not loadable desktop modules. */
+export function isDesktopTemplatePackage(pkgName) {
+  const isScoped = pkgName.startsWith(SCOPE)
+  const short = isScoped ? pkgName.slice(SCOPE.length) : pkgName
+  if (!isScoped && !pkgName.endsWith('-template')) return false
+  return short.endsWith('-template')
+}
+
+export function isInstallableDesktopModule(pkgName) {
+  const isScoped = pkgName.startsWith(SCOPE)
+  if (!isScoped && !pkgName.startsWith('module-')) return false
+  return (
+    !DESKTOP_NON_INSTALLABLE.has(pkgName) &&
+    !isDesktopKitPackage(pkgName) &&
+    !isDesktopTemplatePackage(pkgName)
+  )
+}
+
+export const KINDS = {
+  app: {
+    label: 'Apps',
+    topic: 'owd-apps',
+    workspaceDir: 'apps',
+    configKey: 'apps',
+    nx: 'desktop:install-app',
+  },
+  module: {
+    label: 'Modules',
+    topic: 'owd-modules',
+    workspaceDir: 'packages',
+    configKey: 'modules',
+    nx: 'desktop:install-module',
+  },
+  theme: {
+    label: 'Themes',
+    topic: 'owd-themes',
+    workspaceDir: 'themes',
+    configKey: 'theme',
+    nx: 'desktop:install-theme',
+  },
+}
+
+export function findWorkspaceRoot(startDir = process.cwd()) {
+  let dir = startDir
+  for (;;) {
+    if (
+      existsSync(join(dir, 'pnpm-workspace.yaml')) &&
+      existsSync(join(dir, 'nx.json'))
+    ) {
+      return dir
+    }
+    const parent = dirname(dir)
+    if (parent === dir) return null
+    dir = parent
+  }
+}
+
+export function desktopMetaDir(workspaceRoot) {
+  return join(workspaceRoot, '.desktop')
+}
+
+export function settingsPath(workspaceRoot) {
+  return join(desktopMetaDir(workspaceRoot), 'settings.json')
+}
+
+/** @typedef {'npm' | 'workspace'} InstallMode */
+
+export function normalizeInstallMode(value) {
+  if (value === 'workspace' || value === 'dev') return 'workspace'
+  return 'npm'
+}
+
+export function isWorkspaceInstallMode(settings) {
+  return normalizeInstallMode(settings?.installMode) === 'workspace'
+}
+
+/** @typedef {'updated' | 'name' | 'stars' | 'installed'} CatalogSortMode */
+
+export function normalizeCatalogSort(value) {
+  const modes = ['updated', 'name', 'stars', 'installed']
+  return modes.includes(value) ? /** @type {CatalogSortMode} */ (value) : 'updated'
+}
+
+export function loadSettings(workspaceRoot, metaDir = null) {
+  const defaults = {
+    devPort: 3000,
+    githubUser: null,
+    githubOrgs: ['owdproject'],
+    installMode: /** @type {InstallMode} */ ('npm'),
+    catalogSort: /** @type {CatalogSortMode} */ ('updated'),
+    catalogNewDays: 14,
+  }
+
+  try {
+    const path = metaDir ? join(metaDir, 'settings.json') : settingsPath(workspaceRoot)
+    if (!existsSync(path)) {
+      return { ...defaults, ...detectGithubUser(), installMode: 'npm' }
+    }
+    const merged = { ...defaults, ...detectGithubUser(), ...JSON.parse(readFileSync(path, 'utf8')) }
+    merged.installMode = normalizeInstallMode(merged.installMode)
+    merged.catalogSort = normalizeCatalogSort(merged.catalogSort)
+    merged.catalogNewDays =
+      typeof merged.catalogNewDays === 'number' && merged.catalogNewDays > 0
+        ? merged.catalogNewDays
+        : 14
+    return merged
+  } catch {
+    return { ...defaults, ...detectGithubUser(), installMode: 'npm' }
+  }
+}
+
+function detectGithubUser() {
+  const fromEnv = process.env.OWD_GITHUB_USER?.trim()
+  if (fromEnv) return { githubUser: fromEnv }
+
+  try {
+    const user = execSync('git config --get github.user || git config --get user.username', {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim()
+    if (user) return { githubUser: user }
+  } catch {
+    /* ignore */
+  }
+
+  return {}
+}
+
+export function saveSettings(workspaceRoot, settings, metaDir = null) {
+  const dir = metaDir || desktopMetaDir(workspaceRoot)
+  mkdirSync(dir, { recursive: true })
+  const path = metaDir ? join(metaDir, 'settings.json') : settingsPath(workspaceRoot)
+  writeFileSync(path, JSON.stringify(settings, null, 2) + '\n')
+}
+
+export function desktopPaths(workspaceRoot) {
+  const desktop = join(workspaceRoot, 'desktop')
+  const resolved = resolveDesktopConfigPath(desktop)
+  const configWrite = desktopConfigWritePath(desktop)
+
+  return {
+    desktop,
+    config: resolved?.path ?? configWrite,
+    configWrite,
+    configLegacy: resolved?.legacy ?? false,
+    packageJson: join(desktop, 'package.json'),
+  }
+}
+
+export function shortName(pkgName) {
+  return pkgName.startsWith(SCOPE) ? pkgName.slice(SCOPE.length) : pkgName
+}
+
+export function fullName(short) {
+  return short.startsWith(SCOPE) ? short : `${SCOPE}${short}`
+}
+
+export function inferKind(shortName) {
+  if (shortName.startsWith('app-')) return 'app'
+  if (shortName.startsWith('theme-')) return 'theme'
+  return 'module'
+}
+
+export function getPackagesRequiredByTheme(workspaceRoot, themeName) {
+  if (!themeName) return []
+  const themeShort = shortName(themeName)
+  const pkgJsonPath = join(workspaceRoot, 'themes', themeShort, 'package.json')
+  if (!existsSync(pkgJsonPath)) return []
+  try {
+    const pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf8'))
+    const themeDeps = { ...pkgJson.dependencies, ...pkgJson.devDependencies }
+    return Object.keys(themeDeps).filter(
+      (dep) => isDesktopKitPackage(dep) || isInstallableDesktopModule(dep)
+    )
+  } catch {
+    return []
+  }
+}
+
+/**
+ * Scans all package.json files in the workspace (including desktop/)
+ * and returns any @owdproject/ dependencies that use the 'workspace:' protocol
+ * but are not present locally on disk.
+ * @param {string} workspaceRoot
+ * @returns {string[]}
+ */
+export function findMissingWorkspaceDependencies(workspaceRoot) {
+  const missing = new Set()
+  const localPackages = new Set()
+  const pkgPaths = []
+
+  // 1. Scan KINDS subdirectories for local packages
+  for (const kind of Object.values(KINDS)) {
+    const dir = join(workspaceRoot, kind.workspaceDir)
+    if (!existsSync(dir)) continue
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true })
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const pkgJsonPath = join(dir, entry.name, 'package.json')
+          if (existsSync(pkgJsonPath)) {
+            const pkgPath = join(dir, entry.name)
+            pkgPaths.push(pkgPath)
+            try {
+              const pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf8'))
+              if (pkgJson.name) {
+                localPackages.add(pkgJson.name)
+              }
+            } catch {}
+          }
+        }
+      }
+    } catch {}
+  }
+
+  // 2. Include the desktop app itself
+  const desktopDir = join(workspaceRoot, 'desktop')
+  if (existsSync(join(desktopDir, 'package.json'))) {
+    pkgPaths.push(desktopDir)
+    try {
+      const pkgJson = JSON.parse(readFileSync(join(desktopDir, 'package.json'), 'utf8'))
+      if (pkgJson.name) {
+        localPackages.add(pkgJson.name)
+      }
+    } catch {}
+  }
+
+  // 3. Find missing workspace:* dependencies
+  for (const pkgPath of pkgPaths) {
+    try {
+      const pkgJson = JSON.parse(readFileSync(join(pkgPath, 'package.json'), 'utf8'))
+      const deps = { ...pkgJson.dependencies, ...pkgJson.devDependencies }
+      for (const [depName, version] of Object.entries(deps)) {
+        if (depName.startsWith(SCOPE) && typeof version === 'string' && version.startsWith('workspace:')) {
+          if (!localPackages.has(depName)) {
+            missing.add(depName)
+          }
+        }
+      }
+    } catch {}
+  }
+
+  return Array.from(missing)
+}
+
+

package/bin/owd.js

@@ -1,121 +1,5 @@
 #!/usr/bin/env node
 
-import { Command } from 'commander'
-import chalk from 'chalk'
-import gradient from 'gradient-string'
-import inquirer from 'inquirer'
-import { execSync } from 'child_process'
-import fs from 'fs'
-import path from 'path'
+import { runCli } from './cli.js'
 
-import {cloneRepo} from '../src/utils/cloneRepo.js'
-
-const program = new Command()
-const owdGradient = gradient('#0080ff', '#53bdf3', '#0080ff')
-
-const logTitle = () => {
-    console.log(owdGradient(`\n
-   ___                    __    __     _          ___          _    _              
-  /___\\_ __   ___ _ __   / / /\\ \\ \\___| |__      /   \\___  ___| | _| |_ ___  _ __  
- //  // '_ \\ / _ \\ '_ \\  \\ \\/  \\/ / _ \\ '_ \\    / /\\ / _ \\/ __| |/ / __/ _ \\| '_ \\ 
-/ \\_//| |_) |  __/ | | |  \\  /\\  /  __/ |_) |  / /_//  __/\\__ \\   <| || (_) | |_) |
-\\___/ | .__/ \\___|_| |_|   \\/  \\/ \\___|_.__/  /___,' \\___||___/_|\\_\\\\__\\___/| .__/ 
-      |_|                                                                   |_|    
-\n`))
-    console.log(chalk.white(summonInspiration()))
-    console.log(chalk.white('\n──────────────────────────────────────────────────────────────────────────────\n'))
-    console.log(chalk.white('  ➜ ') + chalk.whiteBright('npx @owdproject/cli create') + chalk.gray('          Create a new project from the template'))
-    console.log(chalk.white('  ➜ ') + chalk.whiteBright('npx @owdproject/cli start') + chalk.gray('           Start the dev server for local development'))
-    console.log(chalk.white('  ➜ ') + chalk.whiteBright('npx @owdproject/cli generate') + chalk.gray('        Generate project for static deployment'))
-    console.log(chalk.white('\n──────────────────────────────────────────────────────────────────────────────\n'))
-}
-
-const logServerInfo = () => {
-    console.log(`\n  ${chalk.red.bold('➜  Local:')}    ${chalk.white('http://localhost:3000/')}`)
-    console.log(`  ${chalk.red.bold('➜  Network:')}  ${chalk.white('http://localhost:3000/')} \n`)
-}
-
-program.command('create')
-    .description('Create a new project')
-    .action(async () => {
-        logTitle()
-        console.log(chalk.green('✨ Creating new project\n'))
-
-        const { projectDir } = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'projectDir',
-                message: 'Enter the directory name for your new project:',
-                default: 'owd-client'
-            }
-        ])
-
-        const targetDir = path.join(process.cwd(), projectDir)
-
-        if (fs.existsSync(targetDir)) {
-            console.log(chalk.red(`Directory ${projectDir} already exists!`))
-            return
-        }
-
-        fs.mkdirSync(targetDir, { recursive: true })
-
-        try {
-            await cloneRepo(targetDir)
-
-            process.chdir(targetDir)
-
-            console.log(chalk.green('Installing dependencies...'))
-            execSync('npm install', { stdio: 'inherit' })
-
-            console.log(chalk.blue('Starting development server...'))
-            execSync('npm run dev', { stdio: 'inherit' })
-        } catch (error) {
-            console.error(error)
-            console.log(chalk.red('✖ Error during project setup'))
-        }
-    })
-
-program.command('start')
-    .description('Start the project in development mode')
-    .action(() => {
-        logTitle()
-
-        try {
-            execSync('npx nuxi dev --host --qr=false', { stdio: 'inherit' })
-            console.log(chalk.blue('🚀 Starting development server'))
-            logServerInfo()
-        } catch (error) {
-            console.log(chalk.red('✖ Error starting Nuxt server'))
-            console.log(chalk.yellow(error.message))
-        } finally {
-            console.log(chalk.white('👨‍💻 If you need help, check the logs or visit our docs'))
-        }
-    })
-
-program.command('generate')
-    .description('Generate deployment files')
-    .action(() => {
-        logTitle()
-
-        try {
-            execSync('npx nuxi generate', { stdio: 'inherit' })
-            console.log(chalk.green('✅ Static site generated successfully!'))
-        } catch (error) {
-            console.log(chalk.red('✖ Error generating static site'))
-        }
-    })
-
-function summonInspiration() {
-    const phrases = [
-        "Launching your digital workspace with Open Web Desktop",
-        "Unleashing the potential of your browser with Open Web Desktop",
-        "Crafting a better web experience with Open Web Desktop",
-        "Transforming how you showcase your portfolio on a browser",
-        "Bringing your digital garden to life, right in the browser",
-        "Opening up new possibilities with Open Web Desktop",
-    ];
-    const randomIndex = Math.floor(Math.random() * phrases.length);
-    return phrases[randomIndex];
-}
-
-program.parse()
+await runCli('owd', process.argv.slice(2), { deprecated: true })

package/go/bridge/bridge.go

@@ -0,0 +1,220 @@
+package bridge
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+)
+
+type Config struct {
+	Theme   *string  `json:"theme"`
+	Apps    []string `json:"apps"`
+	Modules []string `json:"modules"`
+}
+
+type Settings struct {
+	DevPort            int                    `json:"devPort"`
+	GithubUser         *string                `json:"githubUser"`
+	GithubOrgs         []string               `json:"githubOrgs"`
+	InstallMode        string                 `json:"installMode"`
+	CatalogSort        string                 `json:"catalogSort"`
+	CatalogNewDays     int                    `json:"catalogNewDays"`
+	LastInstallChoices map[string]interface{} `json:"lastInstallChoices"`
+}
+
+type WorkspacePaths struct {
+	Desktop      string `json:"desktop"`
+	Config       string `json:"config"`
+	ConfigWrite  string `json:"configWrite"`
+	ConfigLegacy bool   `json:"configLegacy"`
+	PackageJson  string `json:"packageJson"`
+	IsPlayground bool   `json:"isPlayground"`
+	PackageName  string `json:"packageName,omitempty"`
+	PackageDir   string `json:"packageDir,omitempty"`
+	MetaDir      string `json:"metaDir"`
+}
+
+type WorkspaceContext struct {
+	WorkspaceRoot string         `json:"workspaceRoot"`
+	Settings      Settings       `json:"settings"`
+	Config        Config         `json:"config"`
+	Deps          []string       `json:"deps"`
+	Paths         WorkspacePaths `json:"paths"`
+}
+
+type GithubForkInfo struct {
+	Owner  string `json:"owner"`
+	Exists bool   `json:"exists"`
+	IsFork bool   `json:"isFork"`
+}
+
+type GithubSources struct {
+	Official struct {
+		Owner   string `json:"owner"`
+		HtmlUrl string `json:"htmlUrl"`
+	} `json:"official"`
+	Fork *GithubForkInfo `json:"fork"`
+}
+
+type NpmSourceInfo struct {
+	Version string `json:"version"`
+}
+
+type SourcesMetadata struct {
+	Npm    *NpmSourceInfo `json:"npm"`
+	Github GithubSources  `json:"github"`
+}
+
+type CatalogEntry struct {
+	ShortName      string           `json:"shortName"`
+	Description    string           `json:"description"`
+	Stars          int              `json:"stars"`
+	HtmlUrl        *string          `json:"htmlUrl"`
+	Org            string           `json:"org"`
+	Kind           string           `json:"kind"`
+	LocalPath      *string          `json:"localPath"`
+	Remote         *string          `json:"remote"`
+	Version        *string          `json:"version"`
+	Name           string           `json:"name"`
+	Trusted        bool             `json:"trusted"`
+	Installed      bool             `json:"installed"`
+	LocalSource    bool             `json:"localSource"`
+	InPackageJson  bool             `json:"inPackageJson"`
+	ActiveTheme    bool             `json:"activeTheme"`
+	SourcesMeta    *SourcesMetadata `json:"sourcesMeta"`
+	UpdatedAt      *string          `json:"updatedAt"`
+	PushedAt       *string          `json:"pushedAt"`
+}
+
+type CatalogResponse struct {
+	Entries  []CatalogEntry `json:"entries"`
+	CacheAge string         `json:"cacheAge"`
+}
+
+type WritePayload struct {
+	Config       *Config           `json:"config,omitempty"`
+	DepsToAdd    map[string]string `json:"depsToAdd,omitempty"`
+	DepsToRemove []string          `json:"depsToRemove,omitempty"`
+	Settings     *Settings         `json:"settings,omitempty"`
+}
+
+// FindWorkspaceRoot searches upwards from the current directory for pnpm-workspace.yaml
+func FindWorkspaceRoot() (string, error) {
+	dir, err := os.Getwd()
+	if err != nil {
+		return "", err
+	}
+	for {
+		if _, err := os.Stat(filepath.Join(dir, "pnpm-workspace.yaml")); err == nil {
+			return dir, nil
+		}
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			break
+		}
+		dir = parent
+	}
+	return "", fmt.Errorf("not inside an OWD workspace")
+}
+
+func getBridgePath(root string) string {
+	return filepath.Join(root, "packages", "cli", "bin", "bridge.js")
+}
+
+// ReadWorkspaceContext runs the node bridge with --read
+func ReadWorkspaceContext(root string) (*WorkspaceContext, error) {
+	cmd := exec.Command("node", getBridgePath(root), "--read")
+	cmd.Dir = root
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+
+	if err := cmd.Run(); err != nil {
+		return nil, fmt.Errorf("bridge --read failed: %w (stderr: %s)", err, stderr.String())
+	}
+
+	var ctx WorkspaceContext
+	if err := json.Unmarshal(stdout.Bytes(), &ctx); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal context JSON: %w", err)
+	}
+
+	return &ctx, nil
+}
+
+// ReadCatalog runs the node bridge with --catalog
+func ReadCatalog(root string, force bool) (*CatalogResponse, error) {
+	args := []string{getBridgePath(root), "--catalog"}
+	if force {
+		args = append(args, "--force")
+	}
+	cmd := exec.Command("node", args...)
+	cmd.Dir = root
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+
+	if err := cmd.Run(); err != nil {
+		return nil, fmt.Errorf("bridge --catalog failed: %w (stderr: %s)", err, stderr.String())
+	}
+
+	var cat CatalogResponse
+	if err := json.Unmarshal(stdout.Bytes(), &cat); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal catalog JSON: %w", err)
+	}
+
+	return &cat, nil
+}
+
+// WriteConfigOnly writes desktop.config.ts (theme/apps/modules only).
+func WriteConfigOnly(root string, config *Config) error {
+	return writeBridge(root, &WritePayload{Config: config})
+}
+
+// WritePackageJsonDeps updates desktop/package.json dependencies.
+func WritePackageJsonDeps(root string, toAdd map[string]string, toRemove []string) error {
+	return writeBridge(root, &WritePayload{
+		DepsToAdd:    toAdd,
+		DepsToRemove: toRemove,
+	})
+}
+
+// WriteChanges feeds the write payload to the node bridge via stdin
+func WriteChanges(root string, payload *WritePayload) error {
+	return writeBridge(root, payload)
+}
+
+func writeBridge(root string, payload *WritePayload) error {
+	cmd := exec.Command("node", getBridgePath(root), "--write")
+	cmd.Dir = root
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+
+	stdinPipe, err := cmd.StdinPipe()
+	if err != nil {
+		return err
+	}
+
+	if err := cmd.Start(); err != nil {
+		return err
+	}
+
+	payloadBytes, err := json.Marshal(payload)
+	if err != nil {
+		return err
+	}
+
+	if _, err := stdinPipe.Write(payloadBytes); err != nil {
+		return err
+	}
+	stdinPipe.Close()
+
+	if err := cmd.Wait(); err != nil {
+		return fmt.Errorf("bridge --write failed: %w (stderr: %s)", err, stderr.String())
+	}
+
+	return nil
+}

package/go/go.mod

@@ -0,0 +1,33 @@
+module owd-cli
+
+go 1.24.2
+
+require (
+	github.com/charmbracelet/bubbles v1.0.0
+	github.com/charmbracelet/bubbletea v1.3.10
+	github.com/charmbracelet/lipgloss v1.1.0
+)
+
+require (
+	github.com/atotto/clipboard v0.1.4 // indirect
+	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
+	github.com/charmbracelet/colorprofile v0.4.1 // indirect
+	github.com/charmbracelet/x/ansi v0.11.6 // indirect
+	github.com/charmbracelet/x/cellbuf v0.0.15 // indirect
+	github.com/charmbracelet/x/term v0.2.2 // indirect
+	github.com/clipperhouse/displaywidth v0.9.0 // indirect
+	github.com/clipperhouse/stringish v0.1.1 // indirect
+	github.com/clipperhouse/uax29/v2 v2.5.0 // indirect
+	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
+	github.com/lucasb-eyer/go-colorful v1.3.0 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mattn/go-localereader v0.0.1 // indirect
+	github.com/mattn/go-runewidth v0.0.19 // indirect
+	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
+	github.com/muesli/cancelreader v0.2.2 // indirect
+	github.com/muesli/termenv v0.16.0 // indirect
+	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
+	golang.org/x/sys v0.38.0 // indirect
+	golang.org/x/text v0.3.8 // indirect
+)