@doriandev/devcc 0.1.2 → 0.2.0

package/src/devcc/services/ollama.ts

@@ -1,73 +1,216 @@
+import { formatBytes } from "../utils/format.js"
 import { probeTcpPort } from "../utils/exec.js"
-import type { ServiceAdapter, ServiceStatus } from "./types.js"
+import type { ServiceAdapter, ServiceStatus, ServiceStatusItem } from "./types.js"
 
 const DEFAULT_HOST = "127.0.0.1"
 const DEFAULT_PORT = 11434
+/** Remote endpoints are checked at most this often while polling. */
+const REMOTE_REFRESH_MS = 60_000
+const MAX_ITEMS = 12
+
+interface OllamaModelDetails {
+  parameter_size?: string
+  quantization_level?: string
+  family?: string
+}
 
 interface OllamaTagsResponse {
-  models?: { name?: string }[]
+  models?: { name?: string; size?: number; details?: OllamaModelDetails }[]
+}
+
+interface OllamaPsResponse {
+  models?: {
+    name?: string
+    size?: number
+    size_vram?: number
+    expires_at?: string
+    details?: OllamaModelDetails
+  }[]
+}
+
+export interface OllamaModel {
+  name: string
+  /** Bytes on disk. */
+  size?: number
+  parameterSize?: string
+  quantization?: string
+  family?: string
+  /** Loaded into memory right now. */
+  loaded: boolean
+  /** Bytes of VRAM in use, when loaded. */
+  vram?: number
+  /** When Ollama will unload it. */
+  expiresAt?: Date
 }
 
 export interface OllamaServiceOptions {
+  /** Defaults to `ollama`; set for extra endpoints. */
+  id?: string
+  name?: string
+  /** `http://gpu-server:11434`. Takes precedence over host/port and `OLLAMA_HOST`. */
+  baseUrl?: string
   host?: string
   port?: number
   timeoutMs?: number
+  /** Minimum time between polled checks (default: none locally, 60s for a baseUrl). */
+  refreshIntervalMs?: 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.
+ * Ollama adapter, local or remote.
+ *
+ * Reachability is a TCP probe; when the port answers, `/api/tags` lists the
+ * models and `/api/ps` says which are loaded. Model names are never assumed.
  */
 export class OllamaService implements ServiceAdapter {
-  readonly id = "ollama"
-  readonly name = "Ollama"
+  readonly id: string
+  readonly name: string
   readonly category = "ai" as const
+  readonly refreshIntervalMs: number | undefined
 
+  private readonly baseUrl: string
   private readonly host: string
   private readonly port: number
   private readonly timeoutMs: number
+  private readonly remote: boolean
 
   constructor(options: OllamaServiceOptions = {}) {
+    const fromUrl = options.baseUrl ? parseBaseUrl(options.baseUrl) : null
     const fromEnv = parseHostPort(process.env.OLLAMA_HOST)
-    this.host = options.host ?? fromEnv?.host ?? DEFAULT_HOST
-    this.port = options.port ?? fromEnv?.port ?? DEFAULT_PORT
+    this.remote = options.baseUrl !== undefined
+    this.id = options.id ?? "ollama"
+    this.host = fromUrl?.host ?? options.host ?? fromEnv?.host ?? DEFAULT_HOST
+    this.port = fromUrl?.port ?? options.port ?? fromEnv?.port ?? DEFAULT_PORT
+    this.baseUrl = options.baseUrl?.replace(/\/+$/u, "") ?? `http://${this.host}:${this.port}`
+    this.name = options.name ?? (this.remote ? `Ollama (${this.host})` : "Ollama")
     this.timeoutMs = options.timeoutMs ?? 1_500
+    this.refreshIntervalMs = options.refreshIntervalMs ?? (this.remote ? REMOTE_REFRESH_MS : undefined)
   }
 
+  /** A configured endpoint is always shown, so "unreachable" is visible; the local one only when running. */
   async detect(): Promise<boolean> {
+    if (this.remote) return true
     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 listening = await probeTcpPort(this.port, this.host, this.remote ? 2_000 : 700)
+    if (!listening) {
+      return { state: "stopped", endpoint, detail: this.remote ? "unreachable" : "not listening", checkedAt }
+    }
+
+    const [tags, ps] = await Promise.all([
+      this.getJson<OllamaTagsResponse>("/api/tags"),
+      this.getJson<OllamaPsResponse>("/api/ps"),
+    ])
+    if (!tags) return { state: "degraded", endpoint, detail: "listening, API not responding", checkedAt }
+
+    const models = mergeOllamaModels(tags, ps)
+    const loaded = models.filter((model) => model.loaded).length
+    const detail = [
+      `${models.length} model${models.length === 1 ? "" : "s"}`,
+      ps ? `${loaded} loaded` : undefined,
+    ]
+      .filter(Boolean)
+      .join(" · ")
 
-    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 })),
+      detail,
+      items: models.slice(0, MAX_ITEMS).map(modelItem),
       checkedAt,
     }
   }
 
-  private async listModels(): Promise<string[] | null> {
+  /** Models with metadata, for the CLI and tests. Null when unreachable. */
+  async listModels(): Promise<OllamaModel[] | null> {
+    const [tags, ps] = await Promise.all([
+      this.getJson<OllamaTagsResponse>("/api/tags"),
+      this.getJson<OllamaPsResponse>("/api/ps"),
+    ])
+    return tags ? mergeOllamaModels(tags, ps) : null
+  }
+
+  private async getJson<T>(path: string): Promise<T | null> {
     try {
-      const response = await fetch(`http://${this.host}:${this.port}/api/tags`, {
-        signal: AbortSignal.timeout(this.timeoutMs),
-      })
+      const response = await fetch(`${this.baseUrl}${path}`, { 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")
+      return (await response.json()) as T
     } catch {
       return null
     }
   }
 }
 
+/** Combine `/api/tags` with `/api/ps`: loaded models first, then by name. */
+export function mergeOllamaModels(tags: OllamaTagsResponse, ps: OllamaPsResponse | null): OllamaModel[] {
+  const running = new Map(
+    (ps?.models ?? []).filter((model) => model.name).map((model) => [model.name as string, model]),
+  )
+  const models: OllamaModel[] = (tags.models ?? [])
+    .filter((model) => typeof model.name === "string")
+    .map((model) => {
+      const name = model.name as string
+      const live = running.get(name)
+      running.delete(name)
+      return {
+        name,
+        size: model.size,
+        parameterSize: model.details?.parameter_size,
+        quantization: model.details?.quantization_level,
+        family: model.details?.family,
+        loaded: live !== undefined,
+        vram: live?.size_vram,
+        expiresAt: parseDate(live?.expires_at),
+      }
+    })
+  // A model can be loaded but missing from tags (e.g. pulled mid-refresh).
+  for (const [name, live] of running) {
+    models.push({
+      name,
+      size: live.size,
+      parameterSize: live.details?.parameter_size,
+      quantization: live.details?.quantization_level,
+      family: live.details?.family,
+      loaded: true,
+      vram: live.size_vram,
+      expiresAt: parseDate(live.expires_at),
+    })
+  }
+  return models.sort((a, b) => Number(b.loaded) - Number(a.loaded) || a.name.localeCompare(b.name))
+}
+
+function modelItem(model: OllamaModel): ServiceStatusItem {
+  const meta = [model.parameterSize, model.quantization, model.size ? formatBytes(model.size) : undefined]
+  if (model.loaded && model.vram) meta.push(`${formatBytes(model.vram)} VRAM`)
+  return {
+    name: model.name,
+    state: model.loaded ? "running" : "stopped",
+    detail: [model.loaded ? "loaded" : undefined, ...meta].filter(Boolean).join(" · "),
+  }
+}
+
+function parseDate(value: string | undefined): Date | undefined {
+  if (!value) return undefined
+  const date = new Date(value)
+  return Number.isNaN(date.getTime()) ? undefined : date
+}
+
+/** A full base URL: a missing port means the scheme's default, exactly as `fetch` will treat it. */
+export function parseBaseUrl(value: string): { host: string; port: number } | null {
+  try {
+    const parsed = new URL(value)
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null
+    return { host: parsed.hostname, port: Number(parsed.port || (parsed.protocol === "https:" ? 443 : 80)) }
+  } catch {
+    return null
+  }
+}
+
+/** `OLLAMA_HOST`-style `host[:port]`, where a missing port means Ollama's 11434. */
 export function parseHostPort(value: string | undefined): { host: string; port: number } | null {
   if (!value) return null
   const withScheme = value.includes("://") ? value : `http://${value}`

package/src/devcc/services/remote.ts

@@ -0,0 +1,306 @@
+import type { RemoteMachineConfig } from "../core/config.js"
+import { findExecutable, firstLine, type Exec, type Which } from "../environment/tools.js"
+import { exec, probeTcpPort } from "../utils/exec.js"
+import type { ScopedLogger } from "../utils/logger.js"
+import type { ServiceAdapter, ServiceSnapshot, ServiceStatus, ServiceStatusItem } from "./types.js"
+
+/**
+ * Remote development machines and Tailscale.
+ *
+ * Both are observed, never managed: devcc resolves hosts through the user's own
+ * SSH configuration, checks reachability, and reads Tailscale's structured
+ * status. Opening a session is a separate, explicit action (see `platform/`).
+ */
+
+const REMOTE_REFRESH_MS = 60_000
+const TAILSCALE_REFRESH_MS = 30_000
+
+// ---------------------------------------------------------------------------
+// SSH configuration
+// ---------------------------------------------------------------------------
+
+export interface SshTarget {
+  hostname: string
+  port: number
+  user?: string
+}
+
+/** Arguments for `ssh -G`, which prints the effective config without connecting. */
+export function sshConfigArgs(machine: Pick<RemoteMachineConfig, "host" | "port" | "user">): string[] {
+  const args = ["-G"]
+  if (machine.port) args.push("-p", String(machine.port))
+  if (machine.user) args.push("-l", machine.user)
+  args.push(machine.host)
+  return args
+}
+
+/** Parse the `key value` lines of `ssh -G`. */
+export function parseSshConfig(output: string): Partial<SshTarget> {
+  const target: Partial<SshTarget> = {}
+  for (const line of output.split("\n")) {
+    const [key, ...rest] = line.trim().split(/\s+/u)
+    const value = rest.join(" ")
+    if (!value) continue
+    if (key === "hostname") target.hostname = value
+    else if (key === "port" && Number.isInteger(Number(value))) target.port = Number(value)
+    else if (key === "user") target.user = value
+  }
+  return target
+}
+
+/** The destination `ssh` should connect to: the alias, so the user's config applies in full. */
+export function sshDestination(machine: Pick<RemoteMachineConfig, "host" | "user">): string {
+  return machine.user ? `${machine.user}@${machine.host}` : machine.host
+}
+
+// ---------------------------------------------------------------------------
+// Tailscale
+// ---------------------------------------------------------------------------
+
+export interface TailscaleNode {
+  hostName: string
+  /** MagicDNS name without the trailing dot. */
+  dnsName: string
+  ips: string[]
+  online: boolean
+  os?: string
+}
+
+export interface TailscaleStatus {
+  backendState: string
+  connected: boolean
+  self?: TailscaleNode
+  peers: TailscaleNode[]
+  tailnet?: string
+}
+
+function asNode(value: unknown): TailscaleNode | undefined {
+  if (typeof value !== "object" || value === null) return undefined
+  const node = value as Record<string, unknown>
+  return {
+    hostName: typeof node.HostName === "string" ? node.HostName : "",
+    dnsName: typeof node.DNSName === "string" ? node.DNSName.replace(/\.$/u, "") : "",
+    ips: Array.isArray(node.TailscaleIPs)
+      ? node.TailscaleIPs.filter((ip): ip is string => typeof ip === "string")
+      : [],
+    online: node.Online === true,
+    os: typeof node.OS === "string" ? node.OS : undefined,
+  }
+}
+
+/** Parse `tailscale status --json`. Returns null for output that is not a status object. */
+export function parseTailscaleStatus(output: string): TailscaleStatus | null {
+  let data: unknown
+  try {
+    data = JSON.parse(output)
+  } catch {
+    return null
+  }
+  if (typeof data !== "object" || data === null) return null
+  const status = data as Record<string, unknown>
+  const backendState = typeof status.BackendState === "string" ? status.BackendState : "Unknown"
+  const peerRecord = typeof status.Peer === "object" && status.Peer !== null ? status.Peer : {}
+  const tailnet = (status.CurrentTailnet as { Name?: unknown } | undefined)?.Name
+  return {
+    backendState,
+    connected: backendState === "Running",
+    self: asNode(status.Self),
+    peers: Object.values(peerRecord)
+      .map(asNode)
+      .filter((node): node is TailscaleNode => node !== undefined),
+    tailnet: typeof tailnet === "string" ? tailnet : undefined,
+  }
+}
+
+/** Find the tailnet peer a configured host refers to: MagicDNS name, short name, host name or IP. */
+export function findTailscalePeer(status: TailscaleStatus, host: string): TailscaleNode | undefined {
+  const wanted = host.toLowerCase().replace(/\.$/u, "")
+  return status.peers.find((peer) => {
+    const dns = peer.dnsName.toLowerCase()
+    return (
+      dns === wanted ||
+      dns.split(".")[0] === wanted ||
+      peer.hostName.toLowerCase() === wanted ||
+      peer.ips.includes(host)
+    )
+  })
+}
+
+export interface TailscaleServiceOptions {
+  /** Hosts of configured remote machines, shown when they are tailnet peers. */
+  machines?: readonly RemoteMachineConfig[]
+  run?: Exec
+  which?: Which
+  logger?: ScopedLogger
+}
+
+const TAILSCALE_APP_CLI = "/Applications/Tailscale.app/Contents/MacOS/Tailscale"
+
+export class TailscaleService implements ServiceAdapter {
+  readonly id = "tailscale"
+  readonly name = "Tailscale"
+  readonly category = "remote" as const
+  readonly refreshIntervalMs = TAILSCALE_REFRESH_MS
+
+  private readonly run: Exec
+  private readonly which: Which
+  private last: TailscaleStatus | null = null
+
+  constructor(private readonly options: TailscaleServiceOptions = {}) {
+    this.run = options.run ?? exec
+    this.which = options.which ?? ((command) => findExecutable(command))
+  }
+
+  /** The most recent parsed status, for remote machines to look up peers. */
+  getLastStatus(): TailscaleStatus | null {
+    return this.last
+  }
+
+  private command(): string | undefined {
+    return this.which("tailscale") ?? this.which(TAILSCALE_APP_CLI)
+  }
+
+  async detect(): Promise<boolean> {
+    return this.command() !== undefined
+  }
+
+  async getStatus(): Promise<ServiceStatus> {
+    const checkedAt = new Date()
+    const command = this.command()
+    if (!command) return { state: "unavailable", detail: "not installed", checkedAt }
+
+    const result = await this.run(command, ["status", "--json"], {
+      timeoutMs: 4_000,
+      logger: this.options.logger,
+    })
+    const status = parseTailscaleStatus(result.stdout)
+    this.last = status
+    if (!status) {
+      const reason = result.timedOut ? "no answer" : (firstLine(result.stderr) ?? "status unavailable")
+      return { state: "unknown", detail: reason, checkedAt }
+    }
+
+    const items: ServiceStatusItem[] = []
+    for (const machine of this.options.machines ?? []) {
+      const peer = findTailscalePeer(status, machine.host)
+      if (!peer) continue
+      items.push({
+        name: machine.name,
+        state: peer.online ? "running" : "stopped",
+        detail: `${peer.dnsName || peer.hostName} · ${peer.online ? "online" : "offline"}`,
+      })
+    }
+
+    if (!status.connected) {
+      return { state: "stopped", detail: `disconnected (${status.backendState})`, items, checkedAt }
+    }
+    const online = status.peers.filter((peer) => peer.online).length
+    return {
+      state: "running",
+      endpoint: status.self?.dnsName || status.self?.ips[0],
+      detail: `connected · ${online}/${status.peers.length} peers online`,
+      items,
+      checkedAt,
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Remote machines
+// ---------------------------------------------------------------------------
+
+export interface RemoteMachineServiceOptions {
+  machine: RemoteMachineConfig
+  run?: Exec
+  probe?: (port: number, host: string, timeoutMs: number) => Promise<boolean>
+  /** Current Tailscale status, when the Tailscale adapter has one. */
+  tailscale?: () => TailscaleStatus | null
+  /** Status of an associated service by id. */
+  service?: (id: string) => ServiceSnapshot | undefined
+  logger?: ScopedLogger
+}
+
+export function remoteServiceId(machineId: string): string {
+  return `remote:${machineId}`
+}
+
+/**
+ * A configured remote machine as a service: reachability of its SSH port, the
+ * effective target from `ssh -G`, Tailscale presence and associated services.
+ * It connects to nothing but the TCP port, and only once a minute while polling.
+ */
+export class RemoteMachineService implements ServiceAdapter {
+  readonly id: string
+  readonly name: string
+  readonly category = "remote" as const
+  readonly refreshIntervalMs = REMOTE_REFRESH_MS
+
+  private readonly run: Exec
+  private readonly probe: (port: number, host: string, timeoutMs: number) => Promise<boolean>
+  private target: SshTarget | null = null
+
+  constructor(private readonly options: RemoteMachineServiceOptions) {
+    this.id = remoteServiceId(options.machine.id)
+    this.name = options.machine.name
+    this.run = options.run ?? exec
+    this.probe = options.probe ?? probeTcpPort
+  }
+
+  get machine(): RemoteMachineConfig {
+    return this.options.machine
+  }
+
+  async detect(): Promise<boolean> {
+    return true
+  }
+
+  /** Effective host/port/user, resolved once through `ssh -G` and cached. */
+  async resolveTarget(): Promise<SshTarget> {
+    if (this.target) return this.target
+    const { machine } = this.options
+    const result = await this.run("ssh", sshConfigArgs(machine), {
+      timeoutMs: 3_000,
+      logger: this.options.logger,
+    })
+    const parsed = result.ok ? parseSshConfig(result.stdout) : {}
+    const target: SshTarget = {
+      hostname: parsed.hostname ?? machine.host,
+      port: machine.port ?? parsed.port ?? 22,
+      user: machine.user ?? parsed.user,
+    }
+    if (result.ok) this.target = target
+    return target
+  }
+
+  async getStatus(): Promise<ServiceStatus> {
+    const checkedAt = new Date()
+    const { machine } = this.options
+    const target = await this.resolveTarget()
+    const endpoint = `${target.user ? `${target.user}@` : ""}${target.hostname}:${target.port}`
+
+    const startedAt = Date.now()
+    const reachable = await this.probe(target.port, target.hostname, 2_000)
+    const latencyMs = Date.now() - startedAt
+
+    const tailscale = this.options.tailscale?.()
+    const peer = tailscale
+      ? (findTailscalePeer(tailscale, machine.host) ?? findTailscalePeer(tailscale, target.hostname))
+      : undefined
+
+    const items: ServiceStatusItem[] = (machine.services ?? []).map((serviceId) => {
+      const snapshot = this.options.service?.(serviceId)
+      return snapshot
+        ? { name: snapshot.name, state: snapshot.status.state, detail: snapshot.status.detail }
+        : { name: serviceId, state: "unknown" as const, detail: "not checked yet" }
+    })
+
+    const detail = [
+      reachable ? `ssh reachable · ${latencyMs}ms` : "ssh unreachable",
+      peer ? `tailscale ${peer.online ? "online" : "offline"}` : undefined,
+    ]
+      .filter(Boolean)
+      .join(" · ")
+
+    return { state: reachable ? "running" : "stopped", endpoint, detail, items, checkedAt }
+  }
+}

package/src/devcc/services/types.ts

@@ -31,11 +31,19 @@ export interface ServiceActionContext {
   confirm: (title: string, message: string) => Promise<boolean>
 }
 
+export type ServiceCategory = "container" | "database" | "runtime" | "ai" | "web" | "remote"
+
 export interface ServiceAdapter {
   id: string
   name: string
   /** Grouping label shown in the Services view. */
-  category: "container" | "database" | "runtime" | "ai" | "web"
+  category: ServiceCategory
+  /**
+   * Minimum time between polled status checks. Remote and slow adapters set
+   * this so an open dashboard does not generate constant network traffic; an
+   * explicit refresh always checks immediately.
+   */
+  refreshIntervalMs?: number
 
   /** Cheap check: is this service relevant to this project/host at all? */
   detect: () => Promise<boolean>

package/src/devcc/utils/exec.ts

@@ -1,5 +1,6 @@
 import { spawn, type SpawnOptions } from "node:child_process"
 import { connect } from "node:net"
+import type { ScopedLogger } from "./logger.js"
 
 /**
  * Small, safe process helpers.
@@ -17,6 +18,11 @@ export interface ExecOptions {
   maxBuffer?: number
   input?: string
   signal?: AbortSignal
+  /**
+   * When given, each run is logged at debug level: executable, arguments, cwd,
+   * duration, exit code and failure reason. The environment is never logged.
+   */
+  logger?: ScopedLogger
 }
 
 export interface ExecResult {
@@ -41,7 +47,15 @@ export function exec(
   args: readonly string[] = [],
   options: ExecOptions = {},
 ): Promise<ExecResult> {
-  const { cwd, env, timeoutMs = DEFAULT_EXEC_TIMEOUT_MS, maxBuffer = 1024 * 1024, input, signal } = options
+  const {
+    cwd,
+    env,
+    timeoutMs = DEFAULT_EXEC_TIMEOUT_MS,
+    maxBuffer = 1024 * 1024,
+    input,
+    signal,
+    logger,
+  } = options
 
   return new Promise<ExecResult>((resolve) => {
     const startedAt = Date.now()
@@ -64,7 +78,17 @@ export function exec(
       settled = true
       clearTimeout(timer)
       signal?.removeEventListener("abort", onAbort)
-      resolve({ ...result, durationMs: Date.now() - startedAt })
+      const durationMs = Date.now() - startedAt
+      logger?.debug("exec", {
+        command,
+        args,
+        cwd,
+        durationMs,
+        code: result.code,
+        ...(result.timedOut ? { timedOut: true } : {}),
+        ...(result.spawnError ? { error: result.spawnError.message } : {}),
+      })
+      resolve({ ...result, durationMs })
     }
 
     const timer = setTimeout(() => {