peachsim 0.1.527

package/cli/commands/desktop.ts

@@ -0,0 +1,39 @@
+import { runElectron } from './electron'
+import { runInstallDesktop } from './install-desktop'
+
+interface DesktopOptions {
+  port?: number
+  device?: string
+}
+
+function printHelp(): void {
+  console.log(`
+rnx desktop — launch or install the desktop companion
+
+usage:
+  rnx desktop [options]
+  rnx desktop install [options]
+
+options:
+  --port <number>     connect to a running dev server on this port
+  --profile <id>      launch with an isolated persistent storage profile
+  --ephemeral         launch with a temporary isolated storage profile
+  -y, --yes           install without prompting
+`)
+}
+
+export async function runDesktop(args: string[], opts: DesktopOptions): Promise<void> {
+  if (args.includes('--help') || args.includes('-h')) {
+    printHelp()
+    return
+  }
+
+  const sub = args.find((arg) => !arg.startsWith('-'))
+  if (sub === 'install') {
+    const index = args.indexOf(sub)
+    await runInstallDesktop([...args.slice(0, index), ...args.slice(index + 1)])
+    return
+  }
+
+  await runElectron(args, opts)
+}

package/cli/commands/detect.ts

@@ -0,0 +1,201 @@
+// project detection — finds project root, detects framework, scans monorepo workspaces
+
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs'
+import { basename, dirname, join } from 'path'
+
+export type Framework = 'one' | 'expo' | 'bare' | 'unknown'
+export type PackageManager = 'bun' | 'pnpm' | 'npm' | 'yarn'
+export type MonorepoType = 'turbo' | 'pnpm' | 'nx' | 'npm-workspaces' | 'single'
+
+export interface DetectedProject {
+  dir: string
+  name: string
+  framework: Framework
+  hasViteConfig: boolean
+  hasMetroConfig: boolean
+  devCommand: string | null
+}
+
+export interface DetectedWorkspace {
+  root: string
+  type: MonorepoType
+  packageManager: PackageManager
+  apps: DetectedProject[]
+}
+
+const CONFIG_EXTENSIONS = ['ts', 'js', 'cjs', 'mjs', 'mts', 'cts']
+
+export function findProjectRoot(cwd: string): string {
+  let dir = cwd
+  while (true) {
+    if (
+      existsSync(join(dir, 'turbo.json')) ||
+      existsSync(join(dir, 'nx.json')) ||
+      existsSync(join(dir, 'lerna.json')) ||
+      existsSync(join(dir, 'pnpm-workspace.yaml'))
+    ) {
+      return dir
+    }
+
+    const pkgPath = join(dir, 'package.json')
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'))
+        if (pkg.workspaces) return dir
+      } catch {}
+    }
+
+    const parent = dirname(dir)
+    if (parent === dir) break
+    dir = parent
+  }
+  return cwd
+}
+
+export function detectPackageManager(root: string): PackageManager {
+  if (existsSync(join(root, 'bun.lock')) || existsSync(join(root, 'bun.lockb'))) {
+    return 'bun'
+  }
+  if (existsSync(join(root, 'pnpm-lock.yaml'))) return 'pnpm'
+  if (existsSync(join(root, 'yarn.lock'))) return 'yarn'
+  return 'npm'
+}
+
+export function detectMonorepoType(root: string): MonorepoType {
+  if (existsSync(join(root, 'turbo.json'))) return 'turbo'
+  if (existsSync(join(root, 'nx.json'))) return 'nx'
+  if (existsSync(join(root, 'pnpm-workspace.yaml'))) return 'pnpm'
+
+  const pkgPath = join(root, 'package.json')
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'))
+      if (pkg.workspaces) return 'npm-workspaces'
+    } catch {}
+  }
+  return 'single'
+}
+
+export function detectFramework(deps: Record<string, string>): Framework {
+  if (deps.one) return 'one'
+  if (deps.expo) return 'expo'
+  if (deps['react-native']) return 'bare'
+  return 'unknown'
+}
+
+export function detectProject(dir: string): DetectedProject | null {
+  const pkgPath = join(dir, 'package.json')
+  if (!existsSync(pkgPath)) return null
+
+  let pkg: any
+  try {
+    pkg = JSON.parse(readFileSync(pkgPath, 'utf8'))
+  } catch {
+    return null
+  }
+
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies }
+  const framework = detectFramework(deps)
+
+  if (framework === 'unknown') return null
+
+  return {
+    dir,
+    name: pkg.name || basename(dir),
+    framework,
+    // a config file is a config file whatever module system it declares. real
+    // apps write .cjs as often as .js, and missing one reads as "this project
+    // has no bundler config" and sends the user to create a second one.
+    hasViteConfig: CONFIG_EXTENSIONS.some((ext) =>
+      existsSync(join(dir, `vite.config.${ext}`)),
+    ),
+    hasMetroConfig: CONFIG_EXTENSIONS.some((ext) =>
+      existsSync(join(dir, `metro.config.${ext}`)),
+    ),
+    devCommand: pkg.scripts?.dev || null,
+  }
+}
+
+function getWorkspaceDirs(root: string): string[] {
+  const dirs: string[] = []
+
+  const pnpmWs = join(root, 'pnpm-workspace.yaml')
+  if (existsSync(pnpmWs)) {
+    const content = readFileSync(pnpmWs, 'utf8')
+    const match = content.match(/packages:\s*\n((?:\s+-\s+.+\n?)+)/)
+    if (match) {
+      const lines = match[1].split('\n').filter(Boolean)
+      for (const line of lines) {
+        const glob = line.replace(/^\s*-\s*['"]?/, '').replace(/['"]?\s*$/, '')
+        if (glob) dirs.push(...expandGlob(root, glob))
+      }
+    }
+    return dirs
+  }
+
+  const pkgPath = join(root, 'package.json')
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'))
+      const workspaces = Array.isArray(pkg.workspaces)
+        ? pkg.workspaces
+        : pkg.workspaces?.packages || []
+      for (const glob of workspaces) {
+        dirs.push(...expandGlob(root, glob))
+      }
+    } catch {}
+  }
+
+  return dirs
+}
+
+function expandGlob(root: string, pattern: string): string[] {
+  const clean = pattern.replace(/\/\*\*?$/, '').replace(/\*$/, '')
+  const baseDir = join(root, clean)
+
+  if (!existsSync(baseDir)) return []
+
+  try {
+    const entries = readdirSync(baseDir)
+    return entries
+      .map((entry) => join(baseDir, entry))
+      .filter((path) => {
+        try {
+          return statSync(path).isDirectory() && existsSync(join(path, 'package.json'))
+        } catch {
+          return false
+        }
+      })
+  } catch {
+    return []
+  }
+}
+
+export function scanWorkspace(root: string): DetectedWorkspace {
+  const type = detectMonorepoType(root)
+  const packageManager = detectPackageManager(root)
+
+  if (type === 'single') {
+    const project = detectProject(root)
+    return {
+      root,
+      type,
+      packageManager,
+      apps: project ? [project] : [],
+    }
+  }
+
+  const workspaceDirs = getWorkspaceDirs(root)
+  const apps: DetectedProject[] = []
+
+  const rootProject = detectProject(root)
+  if (rootProject) apps.push(rootProject)
+
+  for (const dir of workspaceDirs) {
+    if (dir === root) continue
+    const project = detectProject(dir)
+    if (project) apps.push(project)
+  }
+
+  return { root, type, packageManager, apps }
+}