@doriandev/devcc 0.1.2

package/src/devcc/processes/graph.ts

@@ -0,0 +1,98 @@
+import type { ProcessDefinition } from "./ManagedProcess.js"
+
+/**
+ * Dependency ordering for `dependsOn`.
+ *
+ * Pure so the ordering rules can be tested without spawning anything: the
+ * manager only has to execute the waves this produces.
+ */
+
+export interface StartPlan {
+  /**
+   * Processes to start, grouped into waves. Everything in a wave can start
+   * concurrently; wave N+1 waits for wave N to become ready.
+   */
+  waves: string[][]
+  /** Edges pointing at ids that were never defined. */
+  missing: { id: string; dependsOn: string }[]
+  /** Ids that form a dependency cycle, if any. Their waves are omitted. */
+  cycle: string[]
+}
+
+/**
+ * Group ids into dependency waves (Kahn's algorithm).
+ *
+ * Unknown dependencies are reported and then ignored, so one typo cannot stop
+ * the rest of the project from starting. A cycle is reported rather than
+ * guessed at - devcc refuses to pick an arbitrary order.
+ */
+export function planStartOrder(
+  definitions: readonly ProcessDefinition[],
+  only?: readonly string[],
+): StartPlan {
+  const byId = new Map(definitions.map((definition) => [definition.id, definition]))
+  const selected = new Set(only ?? definitions.map((definition) => definition.id))
+
+  // Only consider selected ids that actually exist.
+  const ids = [...selected].filter((id) => byId.has(id))
+
+  const missing: { id: string; dependsOn: string }[] = []
+  const dependencies = new Map<string, Set<string>>()
+
+  for (const id of ids) {
+    const declared = byId.get(id)?.dependsOn ?? []
+    const resolved = new Set<string>()
+    for (const dependency of declared) {
+      if (!byId.has(dependency)) {
+        missing.push({ id, dependsOn: dependency })
+        continue
+      }
+      // A dependency outside the selection is still a real edge, but it cannot
+      // gate a start we were not asked to perform.
+      if (ids.includes(dependency)) resolved.add(dependency)
+    }
+    dependencies.set(id, resolved)
+  }
+
+  const waves: string[][] = []
+  const placed = new Set<string>()
+
+  while (placed.size < ids.length) {
+    const wave = ids
+      .filter((id) => !placed.has(id))
+      .filter((id) => [...(dependencies.get(id) ?? [])].every((dependency) => placed.has(dependency)))
+
+    if (wave.length === 0) {
+      // Everything left depends on something unplaced: that is a cycle.
+      return { waves, missing, cycle: ids.filter((id) => !placed.has(id)).sort() }
+    }
+
+    for (const id of wave) placed.add(id)
+    waves.push(wave)
+  }
+
+  return { waves, missing, cycle: [] }
+}
+
+/**
+ * Ids that must be stopped before `id` can be, i.e. everything depending on it,
+ * transitively. Used to stop a stack from the top down.
+ */
+export function dependentsOf(definitions: readonly ProcessDefinition[], id: string): string[] {
+  const direct = new Map<string, string[]>()
+  for (const definition of definitions) {
+    for (const dependency of definition.dependsOn ?? []) {
+      direct.set(dependency, [...(direct.get(dependency) ?? []), definition.id])
+    }
+  }
+
+  const found = new Set<string>()
+  const queue = [...(direct.get(id) ?? [])]
+  while (queue.length > 0) {
+    const next = queue.shift()
+    if (!next || found.has(next)) continue
+    found.add(next)
+    queue.push(...(direct.get(next) ?? []))
+  }
+  return [...found].sort()
+}

package/src/devcc/projects/ProjectRegistry.ts

@@ -0,0 +1,219 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs"
+import { homedir } from "node:os"
+import { basename, dirname, join, resolve } from "node:path"
+import { errorMessage } from "../utils/errors.js"
+
+export interface ProjectEntry {
+  /** Absolute path; the identity of a project. */
+  path: string
+  name: string
+  /** How devcc knows about it. */
+  source: "current" | "recent" | "configured" | "discovered"
+  /** Last time it was opened in devcc, for recents. */
+  lastOpenedAt?: Date
+  hasGit: boolean
+  hasPackageJson: boolean
+}
+
+/** Directories that are never worth scanning into. */
+const IGNORED_DIRECTORIES = new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  "dist",
+  "build",
+  "target",
+  "vendor",
+  "coverage",
+  ".turbo",
+  ".cache",
+])
+
+export function isProjectDirectory(path: string, exists: (p: string) => boolean = existsSync): boolean {
+  return exists(join(path, "package.json")) || exists(join(path, ".git"))
+}
+
+/** Read `name` from a package.json, falling back to the directory name. */
+export function projectNameFor(path: string): string {
+  try {
+    const raw: unknown = JSON.parse(readFileSync(join(path, "package.json"), "utf8"))
+    const name = typeof raw === "object" && raw !== null ? (raw as { name?: unknown }).name : undefined
+    if (typeof name === "string" && name.length > 0) return name
+  } catch {
+    // Fall through to the directory name.
+  }
+  return basename(path)
+}
+
+export interface DiscoverOptions {
+  /** Directories whose immediate children are candidate projects. */
+  searchDirs: readonly string[]
+  /** Maximum entries to return per search directory. */
+  limit?: number
+  readdir?: (dir: string) => string[]
+  exists?: (path: string) => boolean
+  isDirectory?: (path: string) => boolean
+}
+
+/**
+ * Find sibling projects one level below each search directory.
+ *
+ * Deliberately shallow: a recursive walk of a developer's home directory is slow
+ * and finds far more than anyone wants in a picker.
+ */
+export function discoverProjects(options: DiscoverOptions): ProjectEntry[] {
+  const readdir = options.readdir ?? ((dir: string) => readdirSync(dir))
+  const exists = options.exists ?? existsSync
+  const isDirectory = options.isDirectory ?? ((path: string) => statSync(path).isDirectory())
+  const limit = options.limit ?? 200
+
+  const found = new Map<string, ProjectEntry>()
+
+  for (const searchDir of options.searchDirs) {
+    let entries: string[]
+    try {
+      entries = readdir(searchDir)
+    } catch {
+      continue
+    }
+
+    for (const entry of entries) {
+      if (found.size >= limit) break
+      if (entry.startsWith(".") || IGNORED_DIRECTORIES.has(entry)) continue
+
+      const path = join(searchDir, entry)
+      try {
+        if (!isDirectory(path)) continue
+      } catch {
+        continue
+      }
+      if (!isProjectDirectory(path, exists)) continue
+      if (found.has(path)) continue
+
+      found.set(path, {
+        path,
+        name: entry,
+        source: "discovered",
+        hasGit: exists(join(path, ".git")),
+        hasPackageJson: exists(join(path, "package.json")),
+      })
+    }
+  }
+
+  return [...found.values()]
+}
+
+interface RecentsFile {
+  projects?: { path?: unknown; lastOpenedAt?: unknown }[]
+}
+
+/** Where the cross-project recents list lives. */
+export function recentsPath(home: string = homedir()): string {
+  return join(home, ".devcc", "recent-projects.json")
+}
+
+export function readRecents(path: string = recentsPath(), limit = 20): ProjectEntry[] {
+  try {
+    if (!existsSync(path)) return []
+    const parsed = JSON.parse(readFileSync(path, "utf8")) as RecentsFile
+    const entries = Array.isArray(parsed.projects) ? parsed.projects : []
+
+    return entries
+      .map((entry): ProjectEntry | null => {
+        const projectPath = typeof entry.path === "string" ? entry.path : null
+        if (!projectPath) return null
+        const openedAt = typeof entry.lastOpenedAt === "string" ? new Date(entry.lastOpenedAt) : undefined
+        return {
+          path: projectPath,
+          name: basename(projectPath),
+          source: "recent" as const,
+          lastOpenedAt: openedAt && !Number.isNaN(openedAt.getTime()) ? openedAt : undefined,
+          hasGit: existsSync(join(projectPath, ".git")),
+          hasPackageJson: existsSync(join(projectPath, "package.json")),
+        }
+      })
+      .filter((entry): entry is ProjectEntry => entry !== null && existsSync(entry.path))
+      .slice(0, limit)
+  } catch {
+    return []
+  }
+}
+
+/** Record a project as most-recently opened. Failure is never fatal. */
+export function recordRecent(projectPath: string, path: string = recentsPath(), limit = 20): string | null {
+  try {
+    const existing = readRecents(path, limit).filter((entry) => entry.path !== projectPath)
+    const next = [{ path: projectPath, lastOpenedAt: new Date().toISOString() }].concat(
+      existing.map((entry) => ({
+        path: entry.path,
+        lastOpenedAt: (entry.lastOpenedAt ?? new Date()).toISOString(),
+      })),
+    )
+    mkdirSync(dirname(path), { recursive: true })
+    writeFileSync(path, `${JSON.stringify({ projects: next.slice(0, limit) }, null, 2)}\n`, "utf8")
+    return null
+  } catch (error) {
+    return errorMessage(error)
+  }
+}
+
+export interface BuildProjectListOptions {
+  currentPath: string
+  /** Explicit paths from project config. */
+  configured?: readonly string[]
+  /** Extra directories to scan for siblings. Defaults to the parent directory. */
+  searchDirs?: readonly string[]
+  recents?: readonly ProjectEntry[]
+  discovered?: readonly ProjectEntry[]
+}
+
+/**
+ * Merge the sources into one de-duplicated, ranked list:
+ * current project first, then recents, then configured, then discovered.
+ */
+export function buildProjectList(options: BuildProjectListOptions): ProjectEntry[] {
+  const current = resolve(options.currentPath)
+  const byPath = new Map<string, ProjectEntry>()
+
+  const add = (entry: ProjectEntry) => {
+    const path = resolve(entry.path)
+    const existing = byPath.get(path)
+    if (existing) {
+      // Keep the highest-priority source but carry over a known open time.
+      if (entry.lastOpenedAt && !existing.lastOpenedAt) existing.lastOpenedAt = entry.lastOpenedAt
+      return
+    }
+    byPath.set(path, { ...entry, path })
+  }
+
+  add({
+    path: current,
+    name: projectNameFor(current),
+    source: "current",
+    hasGit: existsSync(join(current, ".git")),
+    hasPackageJson: existsSync(join(current, "package.json")),
+  })
+
+  for (const entry of options.recents ?? []) add(entry)
+
+  for (const configured of options.configured ?? []) {
+    const path = resolve(current, configured)
+    if (!existsSync(path)) continue
+    add({
+      path,
+      name: basename(path),
+      source: "configured",
+      hasGit: existsSync(join(path, ".git")),
+      hasPackageJson: existsSync(join(path, "package.json")),
+    })
+  }
+
+  for (const entry of options.discovered ?? []) add(entry)
+
+  return [...byPath.values()]
+}
+
+/** Default search directories: the parent of the current project. */
+export function defaultSearchDirs(currentPath: string): string[] {
+  return [dirname(resolve(currentPath))]
+}

package/src/devcc/services/ServiceManager.ts

@@ -0,0 +1,180 @@
+import { TypedEmitter } from "../core/events.js"
+import { DevccError, errorMessage, toDevccError } from "../utils/errors.js"
+import { withTimeout } from "../utils/exec.js"
+import type { ScopedLogger } from "../utils/logger.js"
+import type { ServiceActionContext, ServiceAdapter, ServiceSnapshot, ServiceStatus } from "./types.js"
+
+export type ServiceManagerEvents = {
+  "service:list": [ServiceSnapshot[]]
+  "service:changed": [ServiceSnapshot]
+  "service:error": [DevccError]
+}
+
+export interface ServiceManagerOptions {
+  logger: ScopedLogger
+  /** Poll interval for status refreshes. */
+  intervalMs?: number
+  /** Per-adapter budget; a slow adapter must not stall the others. */
+  statusTimeoutMs?: number
+}
+
+const STALLED_STATUS: ServiceStatus = {
+  state: "unknown",
+  detail: "status check timed out",
+  checkedAt: new Date(0),
+}
+
+/**
+ * Runs detection once at startup (off the critical path) and then polls the
+ * adapters that reported themselves relevant.
+ *
+ * All adapters are queried concurrently with an individual timeout, so one
+ * unresponsive daemon cannot freeze the panel.
+ */
+export class ServiceManager extends TypedEmitter<ServiceManagerEvents> {
+  private readonly adapters = new Map<string, ServiceAdapter>()
+  private readonly detected = new Set<string>()
+  private readonly snapshots = new Map<string, ServiceSnapshot>()
+  private timer: NodeJS.Timeout | null = null
+  private refreshing = false
+  private readonly intervalMs: number
+  private readonly statusTimeoutMs: number
+
+  constructor(private readonly options: ServiceManagerOptions) {
+    super()
+    this.intervalMs = options.intervalMs ?? 5_000
+    this.statusTimeoutMs = options.statusTimeoutMs ?? 4_000
+  }
+
+  register(adapter: ServiceAdapter): void {
+    this.adapters.set(adapter.id, adapter)
+  }
+
+  registerAll(adapters: readonly ServiceAdapter[]): void {
+    for (const adapter of adapters) this.register(adapter)
+  }
+
+  list(): ServiceSnapshot[] {
+    return [...this.snapshots.values()]
+  }
+
+  get(id: string): ServiceSnapshot | undefined {
+    return this.snapshots.get(id)
+  }
+
+  getAdapter(id: string): ServiceAdapter | undefined {
+    return this.adapters.get(id)
+  }
+
+  /** Ask every adapter whether it is relevant here. Failures mean "not relevant". */
+  async detectAll(): Promise<ServiceSnapshot[]> {
+    const results = await Promise.all(
+      [...this.adapters.values()].map(async (adapter) => {
+        try {
+          const relevant = await withTimeout(adapter.detect(), this.statusTimeoutMs, false)
+          return { adapter, relevant }
+        } catch (error) {
+          this.options.logger.debug("service detect failed", { id: adapter.id, error: errorMessage(error) })
+          return { adapter, relevant: false }
+        }
+      }),
+    )
+
+    this.detected.clear()
+    for (const { adapter, relevant } of results) {
+      if (relevant) this.detected.add(adapter.id)
+      else this.snapshots.delete(adapter.id)
+    }
+
+    await this.refresh()
+    return this.list()
+  }
+
+  start(): void {
+    if (this.timer) return
+    this.timer = setInterval(() => void this.refresh(), this.intervalMs)
+    this.timer.unref?.()
+  }
+
+  stop(): void {
+    if (!this.timer) return
+    clearInterval(this.timer)
+    this.timer = null
+  }
+
+  /** Refresh all detected adapters concurrently. Overlapping calls are skipped. */
+  async refresh(): Promise<ServiceSnapshot[]> {
+    if (this.refreshing) return this.list()
+    this.refreshing = true
+    try {
+      const targets = [...this.detected]
+        .map((id) => this.adapters.get(id))
+        .filter((a): a is ServiceAdapter => !!a)
+
+      await Promise.all(
+        targets.map(async (adapter) => {
+          const status = await withTimeout(
+            adapter.getStatus().catch((error: unknown) => {
+              this.options.logger.debug("service status failed", {
+                id: adapter.id,
+                error: errorMessage(error),
+              })
+              return {
+                state: "unknown",
+                detail: errorMessage(error),
+                checkedAt: new Date(),
+              } satisfies ServiceStatus
+            }),
+            this.statusTimeoutMs,
+            { ...STALLED_STATUS, checkedAt: new Date() },
+          )
+          this.setSnapshot(adapter, status)
+        }),
+      )
+
+      this.emit("service:list", this.list())
+      return this.list()
+    } finally {
+      this.refreshing = false
+    }
+  }
+
+  async runAction(
+    id: string,
+    action: "start" | "stop" | "restart",
+    context: ServiceActionContext,
+  ): Promise<void> {
+    const adapter = this.adapters.get(id)
+    if (!adapter) throw new DevccError({ scope: "service", message: `Unknown service "${id}"` })
+
+    const handler = adapter[action]
+    if (!handler) {
+      throw new DevccError({ scope: "service", message: `${adapter.name} does not support ${action}` })
+    }
+
+    try {
+      await handler.call(adapter, context)
+      this.options.logger.info("service action ok", { id, action })
+    } catch (error) {
+      const devccError = toDevccError(error, "service", `${adapter.name} ${action} failed`)
+      this.emit("service:error", devccError)
+      throw devccError
+    } finally {
+      await this.refresh()
+    }
+  }
+
+  private setSnapshot(adapter: ServiceAdapter, status: ServiceStatus): void {
+    const snapshot: ServiceSnapshot = {
+      id: adapter.id,
+      name: adapter.name,
+      category: adapter.category,
+      status,
+      canStart: typeof adapter.start === "function",
+      canStop: typeof adapter.stop === "function",
+      canRestart: typeof adapter.restart === "function",
+    }
+    this.snapshots.set(adapter.id, snapshot)
+    this.emit("service:changed", snapshot)
+  }
+}