@doriandev/devcc 0.1.2

package/src/devcc/services/docker.ts

@@ -0,0 +1,220 @@
+import { existsSync } from "node:fs"
+import { join } from "node:path"
+import { DevccError } from "../utils/errors.js"
+import { exec } from "../utils/exec.js"
+import type {
+  ServiceActionContext,
+  ServiceAdapter,
+  ServiceState,
+  ServiceStatus,
+  ServiceStatusItem,
+} from "./types.js"
+
+const COMPOSE_FILES = [
+  "docker-compose.yml",
+  "docker-compose.yaml",
+  "compose.yml",
+  "compose.yaml",
+  "docker/docker-compose.yml",
+]
+
+export function findComposeFile(
+  rootDir: string,
+  exists: (path: string) => boolean = existsSync,
+): string | null {
+  for (const file of COMPOSE_FILES) {
+    if (exists(join(rootDir, file))) return file
+  }
+  return null
+}
+
+interface ComposePsEntry {
+  Name?: string
+  Service?: string
+  State?: string
+  Status?: string
+  Health?: string
+  Publishers?: { PublishedPort?: number; TargetPort?: number }[]
+}
+
+/**
+ * `docker compose ps --format json` emits either a JSON array or one JSON
+ * object per line depending on the CLI version. Handle both.
+ */
+export function parseComposePs(output: string): ServiceStatusItem[] {
+  const trimmed = output.trim()
+  if (trimmed === "") return []
+
+  const entries: ComposePsEntry[] = []
+  if (trimmed.startsWith("[")) {
+    try {
+      const parsed: unknown = JSON.parse(trimmed)
+      if (Array.isArray(parsed)) entries.push(...(parsed as ComposePsEntry[]))
+    } catch {
+      return []
+    }
+  } else {
+    for (const line of trimmed.split("\n")) {
+      if (line.trim() === "") continue
+      try {
+        entries.push(JSON.parse(line) as ComposePsEntry)
+      } catch {
+        // Skip malformed lines rather than losing the whole listing.
+      }
+    }
+  }
+
+  return entries.map((entry) => {
+    const name = entry.Service ?? entry.Name ?? "container"
+    const ports = (entry.Publishers ?? [])
+      .map((publisher) => publisher.PublishedPort)
+      .filter((port): port is number => typeof port === "number" && port > 0)
+    const detail = [entry.Status, ports.length > 0 ? `:${[...new Set(ports)].join(",")}` : null]
+      .filter(Boolean)
+      .join(" ")
+    return { name, state: composeState(entry), detail: detail || undefined }
+  })
+}
+
+function composeState(entry: ComposePsEntry): ServiceState {
+  const health = entry.Health?.toLowerCase()
+  if (health === "unhealthy" || health === "starting") return "degraded"
+  switch (entry.State?.toLowerCase()) {
+    case "running":
+      return "running"
+    case "restarting":
+    case "paused":
+      return "degraded"
+    case "exited":
+    case "dead":
+    case "created":
+      return "stopped"
+    default:
+      return "unknown"
+  }
+}
+
+export interface DockerServiceOptions {
+  rootDir: string
+  timeoutMs?: number
+}
+
+/**
+ * Docker / Docker Compose adapter.
+ *
+ * `stop` runs `docker compose stop` (not `down`): stopping must never remove
+ * containers, networks or volumes without an explicit confirmation.
+ */
+export class DockerService implements ServiceAdapter {
+  readonly id = "docker"
+  readonly name = "Docker Compose"
+  readonly category = "container" as const
+
+  private composeFile: string | null
+  private readonly timeoutMs: number
+
+  constructor(private readonly options: DockerServiceOptions) {
+    this.composeFile = findComposeFile(options.rootDir)
+    this.timeoutMs = options.timeoutMs ?? 6_000
+  }
+
+  get hasCompose(): boolean {
+    return this.composeFile !== null
+  }
+
+  async detect(): Promise<boolean> {
+    this.composeFile = findComposeFile(this.options.rootDir)
+    const result = await exec("docker", ["--version"], { timeoutMs: 3_000 })
+    return result.spawnError === undefined
+  }
+
+  async getStatus(): Promise<ServiceStatus> {
+    const checkedAt = new Date()
+    const info = await exec("docker", ["info", "--format", "{{.ServerVersion}}"], {
+      cwd: this.options.rootDir,
+      timeoutMs: this.timeoutMs,
+    })
+
+    if (!info.ok) {
+      return {
+        state: "unavailable",
+        detail: info.spawnError ? "docker not installed" : "daemon unreachable",
+        checkedAt,
+      }
+    }
+
+    const serverVersion = info.stdout.trim()
+    if (!this.composeFile) {
+      return { state: "running", detail: `daemon ${serverVersion}`, checkedAt }
+    }
+
+    const ps = await exec("docker", ["compose", "ps", "--all", "--format", "json"], {
+      cwd: this.options.rootDir,
+      timeoutMs: this.timeoutMs,
+    })
+
+    if (!ps.ok) {
+      return { state: "degraded", detail: `daemon ${serverVersion}, compose ps failed`, checkedAt }
+    }
+
+    const items = parseComposePs(ps.stdout)
+    const running = items.filter((item) => item.state === "running").length
+    const state: ServiceState =
+      items.length === 0 ? "stopped" : running === items.length ? "running" : "degraded"
+
+    return {
+      state,
+      detail:
+        items.length === 0 ? `no containers (${this.composeFile})` : `${running}/${items.length} running`,
+      items,
+      checkedAt,
+    }
+  }
+
+  async start(): Promise<void> {
+    this.requireCompose()
+    await this.compose(["up", "--detach"], 120_000)
+  }
+
+  async stop(): Promise<void> {
+    this.requireCompose()
+    // `stop`, never `down` - see the class comment.
+    await this.compose(["stop"], 60_000)
+  }
+
+  async restart(): Promise<void> {
+    this.requireCompose()
+    await this.compose(["restart"], 120_000)
+  }
+
+  /** `docker compose down` removes containers and networks, so it must be confirmed. */
+  async down(context: ServiceActionContext, removeVolumes = false): Promise<void> {
+    this.requireCompose()
+    const message = removeVolumes
+      ? "This removes containers, networks AND named volumes. Data will be lost."
+      : "This removes containers and networks created by compose."
+    const confirmed = await context.confirm(
+      removeVolumes ? "docker compose down --volumes" : "docker compose down",
+      message,
+    )
+    if (!confirmed) return
+    await this.compose(removeVolumes ? ["down", "--volumes"] : ["down"], 120_000)
+  }
+
+  private requireCompose(): void {
+    if (!this.composeFile) {
+      throw new DevccError({ scope: "docker", message: "No docker compose file found in this project" })
+    }
+  }
+
+  private async compose(args: string[], timeoutMs: number): Promise<void> {
+    const result = await exec("docker", ["compose", ...args], { cwd: this.options.rootDir, timeoutMs })
+    if (!result.ok) {
+      throw new DevccError({
+        scope: "docker",
+        message: `docker compose ${args.join(" ")} failed`,
+        detail: result.stderr.trim() || result.stdout.trim() || (result.timedOut ? "timed out" : undefined),
+      })
+    }
+  }
+}

package/src/devcc/services/node.ts

@@ -0,0 +1,137 @@
+import { probeTcpPort } from "../utils/exec.js"
+import type { ServiceAdapter, ServiceStatus } from "./types.js"
+
+export interface PortServiceOptions {
+  id: string
+  name: string
+  port: number
+  host?: string
+  category?: ServiceAdapter["category"]
+  /** When set, a successful HTTP request to this path upgrades the detail line. */
+  healthPath?: string
+  /** Auto-detected services hide themselves when nothing is listening. */
+  onlyWhenListening?: boolean
+  timeoutMs?: number
+}
+
+/**
+ * A generic "is something serving on this port?" adapter.
+ *
+ * This is how Next.js, Vite, Payload, Typesense and any user-declared HTTP
+ * service are represented - devcc observes them, it does not own them, so it
+ * deliberately exposes no start/stop actions here. Use a managed process for
+ * something devcc should control.
+ */
+export class PortService implements ServiceAdapter {
+  readonly id: string
+  readonly name: string
+  readonly category: ServiceAdapter["category"]
+
+  private readonly host: string
+  private readonly port: number
+  private readonly healthPath: string | undefined
+  private readonly onlyWhenListening: boolean
+  private readonly timeoutMs: number
+
+  constructor(options: PortServiceOptions) {
+    this.id = options.id
+    this.name = options.name
+    this.category = options.category ?? "web"
+    this.host = options.host ?? "127.0.0.1"
+    this.port = options.port
+    this.healthPath = options.healthPath
+    this.onlyWhenListening = options.onlyWhenListening ?? false
+    this.timeoutMs = options.timeoutMs ?? 1_000
+  }
+
+  async detect(): Promise<boolean> {
+    if (!this.onlyWhenListening) return true
+    return probeTcpPort(this.port, this.host, this.timeoutMs)
+  }
+
+  async getStatus(): Promise<ServiceStatus> {
+    const checkedAt = new Date()
+    const endpoint = `${this.host}:${this.port}`
+    const listening = await probeTcpPort(this.port, this.host, this.timeoutMs)
+    if (!listening) return { state: "stopped", endpoint, detail: "not listening", checkedAt }
+
+    if (!this.healthPath) return { state: "running", endpoint, detail: "listening", checkedAt }
+
+    try {
+      const response = await fetch(`http://${endpoint}${this.healthPath}`, {
+        signal: AbortSignal.timeout(this.timeoutMs),
+      })
+      return {
+        state: response.ok ? "running" : "degraded",
+        endpoint,
+        detail: `HTTP ${response.status}`,
+        checkedAt,
+      }
+    } catch {
+      return { state: "degraded", endpoint, detail: "listening, health check failed", checkedAt }
+    }
+  }
+}
+
+interface FrameworkHint {
+  /** Dependency name to look for in package.json. */
+  dependency: string
+  id: string
+  name: string
+  port: number
+  category?: ServiceAdapter["category"]
+  healthPath?: string
+}
+
+/** Well-known local dev servers and their conventional ports. */
+const FRAMEWORK_HINTS: readonly FrameworkHint[] = [
+  { dependency: "next", id: "next", name: "Next.js", port: 3000 },
+  { dependency: "vite", id: "vite", name: "Vite", port: 5173 },
+  { dependency: "@remix-run/dev", id: "remix", name: "Remix", port: 3000 },
+  { dependency: "nuxt", id: "nuxt", name: "Nuxt", port: 3000 },
+  { dependency: "astro", id: "astro", name: "Astro", port: 4321 },
+  { dependency: "payload", id: "payload", name: "Payload CMS", port: 3000, healthPath: "/admin" },
+  { dependency: "typesense", id: "typesense", name: "Typesense", port: 8108, category: "database" },
+  { dependency: "express", id: "express", name: "Express API", port: 3001, category: "runtime" },
+  { dependency: "fastify", id: "fastify", name: "Fastify API", port: 3001, category: "runtime" },
+  { dependency: "@nestjs/core", id: "nest", name: "NestJS API", port: 3000, category: "runtime" },
+]
+
+function dependencyNames(packageJson: Record<string, unknown> | null): Set<string> {
+  const names = new Set<string>()
+  for (const field of ["dependencies", "devDependencies", "peerDependencies"]) {
+    const value = packageJson?.[field]
+    if (typeof value === "object" && value !== null) {
+      for (const name of Object.keys(value)) names.add(name)
+    }
+  }
+  return names
+}
+
+/**
+ * Build port adapters for frameworks this project actually depends on.
+ * Nothing is assumed: a project with none of these gets no adapters.
+ */
+export function detectNodeServices(packageJson: Record<string, unknown> | null): PortService[] {
+  const dependencies = dependencyNames(packageJson)
+  const seenPorts = new Set<number>()
+  const adapters: PortService[] = []
+
+  for (const hint of FRAMEWORK_HINTS) {
+    if (!dependencies.has(hint.dependency)) continue
+    if (seenPorts.has(hint.port)) continue
+    seenPorts.add(hint.port)
+    adapters.push(
+      new PortService({
+        id: hint.id,
+        name: hint.name,
+        port: hint.port,
+        category: hint.category ?? "web",
+        healthPath: hint.healthPath,
+        onlyWhenListening: true,
+      }),
+    )
+  }
+
+  return adapters
+}

package/src/devcc/services/ollama.ts

@@ -0,0 +1,80 @@
+import { probeTcpPort } from "../utils/exec.js"
+import type { ServiceAdapter, ServiceStatus } from "./types.js"
+
+const DEFAULT_HOST = "127.0.0.1"
+const DEFAULT_PORT = 11434
+
+interface OllamaTagsResponse {
+  models?: { name?: string }[]
+}
+
+export interface OllamaServiceOptions {
+  host?: string
+  port?: number
+  timeoutMs?: number
+}
+
+/**
+ * Ollama adapter. Uses the HTTP API for a model count when the port is open;
+ * falls back to a plain port probe if the API call fails.
+ */
+export class OllamaService implements ServiceAdapter {
+  readonly id = "ollama"
+  readonly name = "Ollama"
+  readonly category = "ai" as const
+
+  private readonly host: string
+  private readonly port: number
+  private readonly timeoutMs: number
+
+  constructor(options: OllamaServiceOptions = {}) {
+    const fromEnv = parseHostPort(process.env.OLLAMA_HOST)
+    this.host = options.host ?? fromEnv?.host ?? DEFAULT_HOST
+    this.port = options.port ?? fromEnv?.port ?? DEFAULT_PORT
+    this.timeoutMs = options.timeoutMs ?? 1_500
+  }
+
+  async detect(): Promise<boolean> {
+    return probeTcpPort(this.port, this.host)
+  }
+
+  async getStatus(): Promise<ServiceStatus> {
+    const checkedAt = new Date()
+    const endpoint = `${this.host}:${this.port}`
+    const listening = await probeTcpPort(this.port, this.host)
+    if (!listening) return { state: "stopped", endpoint, detail: "not listening", checkedAt }
+
+    const models = await this.listModels()
+    return {
+      state: "running",
+      endpoint,
+      detail: models === null ? "listening" : `${models.length} model${models.length === 1 ? "" : "s"}`,
+      items: models?.slice(0, 6).map((name) => ({ name, state: "running" as const })),
+      checkedAt,
+    }
+  }
+
+  private async listModels(): Promise<string[] | null> {
+    try {
+      const response = await fetch(`http://${this.host}:${this.port}/api/tags`, {
+        signal: AbortSignal.timeout(this.timeoutMs),
+      })
+      if (!response.ok) return null
+      const body = (await response.json()) as OllamaTagsResponse
+      return (body.models ?? []).map((model) => model.name ?? "unnamed")
+    } catch {
+      return null
+    }
+  }
+}
+
+export function parseHostPort(value: string | undefined): { host: string; port: number } | null {
+  if (!value) return null
+  const withScheme = value.includes("://") ? value : `http://${value}`
+  try {
+    const parsed = new URL(withScheme)
+    return { host: parsed.hostname || DEFAULT_HOST, port: Number(parsed.port || DEFAULT_PORT) }
+  } catch {
+    return null
+  }
+}

package/src/devcc/services/postgres.ts

@@ -0,0 +1,57 @@
+import { probeTcpPort } from "../utils/exec.js"
+import type { ServiceAdapter, ServiceStatus } from "./types.js"
+
+export interface PostgresServiceOptions {
+  host?: string
+  port?: number
+  /** Only report the service when one of these is true. */
+  hints?: boolean
+}
+
+/** Parse `postgres://user:pass@host:5432/db` style URLs for host/port. */
+export function parsePostgresUrl(url: string | undefined): { host: string; port: number } | null {
+  if (!url) return null
+  try {
+    const parsed = new URL(url)
+    if (!parsed.protocol.startsWith("postgres")) return null
+    return { host: parsed.hostname || "127.0.0.1", port: Number(parsed.port || 5432) }
+  } catch {
+    return null
+  }
+}
+
+/**
+ * PostgreSQL adapter.
+ *
+ * Detection is intentionally conservative: we only claim Postgres is relevant
+ * when the project mentions it (DATABASE_URL / a pg dependency) or something is
+ * actually listening on the port.
+ */
+export class PostgresService implements ServiceAdapter {
+  readonly id = "postgres"
+  readonly name = "PostgreSQL"
+  readonly category = "database" as const
+
+  private readonly host: string
+  private readonly port: number
+
+  constructor(options: PostgresServiceOptions = {}) {
+    const fromEnv = parsePostgresUrl(process.env.DATABASE_URL ?? process.env.POSTGRES_URL)
+    this.host = options.host ?? fromEnv?.host ?? "127.0.0.1"
+    this.port = options.port ?? fromEnv?.port ?? 5432
+  }
+
+  async detect(): Promise<boolean> {
+    return probeTcpPort(this.port, this.host)
+  }
+
+  async getStatus(): Promise<ServiceStatus> {
+    const listening = await probeTcpPort(this.port, this.host)
+    return {
+      state: listening ? "running" : "stopped",
+      endpoint: `${this.host}:${this.port}`,
+      detail: listening ? "accepting connections" : "not listening",
+      checkedAt: new Date(),
+    }
+  }
+}

package/src/devcc/services/redis.ts

@@ -0,0 +1,47 @@
+import { probeTcpPort } from "../utils/exec.js"
+import type { ServiceAdapter, ServiceStatus } from "./types.js"
+
+export interface RedisServiceOptions {
+  host?: string
+  port?: number
+}
+
+export function parseRedisUrl(url: string | undefined): { host: string; port: number } | null {
+  if (!url) return null
+  try {
+    const parsed = new URL(url)
+    if (!parsed.protocol.startsWith("redis")) return null
+    return { host: parsed.hostname || "127.0.0.1", port: Number(parsed.port || 6379) }
+  } catch {
+    return null
+  }
+}
+
+export class RedisService implements ServiceAdapter {
+  readonly id = "redis"
+  readonly name = "Redis"
+  readonly category = "database" as const
+
+  private readonly host: string
+  private readonly port: number
+
+  constructor(options: RedisServiceOptions = {}) {
+    const fromEnv = parseRedisUrl(process.env.REDIS_URL)
+    this.host = options.host ?? fromEnv?.host ?? "127.0.0.1"
+    this.port = options.port ?? fromEnv?.port ?? 6379
+  }
+
+  async detect(): Promise<boolean> {
+    return probeTcpPort(this.port, this.host)
+  }
+
+  async getStatus(): Promise<ServiceStatus> {
+    const listening = await probeTcpPort(this.port, this.host)
+    return {
+      state: listening ? "running" : "stopped",
+      endpoint: `${this.host}:${this.port}`,
+      detail: listening ? "accepting connections" : "not listening",
+      checkedAt: new Date(),
+    }
+  }
+}

package/src/devcc/services/types.ts

@@ -0,0 +1,59 @@
+/**
+ * Service adapters describe things the project depends on but that devcc does
+ * not necessarily own: Docker, a database, a local model server, a dev server
+ * someone started in another terminal.
+ *
+ * Adapters are detected at runtime. Nothing here assumes a given project has
+ * any particular service.
+ */
+
+export type ServiceState = "running" | "stopped" | "degraded" | "unknown" | "unavailable"
+
+export interface ServiceStatusItem {
+  name: string
+  state: ServiceState
+  detail?: string
+}
+
+export interface ServiceStatus {
+  state: ServiceState
+  /** One-line summary shown next to the service name. */
+  detail?: string
+  /** Where to reach it, e.g. `localhost:5432`. */
+  endpoint?: string
+  /** Sub-entries, e.g. individual compose containers. */
+  items?: ServiceStatusItem[]
+  checkedAt: Date
+}
+
+export interface ServiceActionContext {
+  /** Ask the user before doing something destructive. Resolves to the answer. */
+  confirm: (title: string, message: string) => Promise<boolean>
+}
+
+export interface ServiceAdapter {
+  id: string
+  name: string
+  /** Grouping label shown in the Services view. */
+  category: "container" | "database" | "runtime" | "ai" | "web"
+
+  /** Cheap check: is this service relevant to this project/host at all? */
+  detect: () => Promise<boolean>
+  getStatus: () => Promise<ServiceStatus>
+
+  start?: (context: ServiceActionContext) => Promise<void>
+  stop?: (context: ServiceActionContext) => Promise<void>
+  restart?: (context: ServiceActionContext) => Promise<void>
+}
+
+export interface ServiceSnapshot {
+  id: string
+  name: string
+  category: ServiceAdapter["category"]
+  status: ServiceStatus
+  canStart: boolean
+  canStop: boolean
+  canRestart: boolean
+}
+
+export const UNKNOWN_STATUS: ServiceStatus = { state: "unknown", checkedAt: new Date(0) }