@factorim/monotui 0.1.0

package/src/services/runtime/command-runner.ts

@@ -0,0 +1,87 @@
+import { spawn } from "node:child_process"
+
+import type { ProjectGridCell } from "../../types/project-grid"
+
+/**
+ * Extracts the shell command string from a navigation cell.
+ */
+export function getCommandFromCell(cell: ProjectGridCell): string | null {
+  switch (cell.type) {
+    case "makefile":
+      return cell.command.command
+    case "packageJson":
+      return cell.script.command
+    case "composeCommand":
+      return cell.action.command
+    case "composeService":
+      return null
+  }
+}
+
+/**
+ * Extracts the shell command string from a navigation cell.
+ */
+export function getExecFromCell(cell: ProjectGridCell): string | null {
+  switch (cell.type) {
+    case "makefile":
+      return cell.command.exec
+    case "packageJson":
+      return cell.script.exec
+    case "composeCommand":
+      return cell.action.command
+  }
+  return null
+}
+
+export function runCellCommand(
+  command: string,
+  cwd: string,
+  options?: { detached?: boolean },
+): void {
+  if (!command) {
+    return
+  }
+
+  const detached = options?.detached ?? false
+
+  if (detached) {
+    const child = spawn(command, {
+      cwd,
+      shell: true,
+      detached: true,
+      stdio: "ignore",
+    })
+    child.unref()
+    return
+  }
+
+  // Restore terminal to cooked mode so the TTY driver handles Ctrl+C → SIGINT
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(false)
+  }
+
+  spawn(command, {
+    cwd,
+    stdio: "inherit",
+    shell: true,
+  })
+}
+
+/**
+ * Returns true when a command is expected to detach
+ */
+export function shouldKeepTuiOpen(command: string): boolean {
+  const normalized = command.trim().toLowerCase()
+  if (!normalized) {
+    return false
+  }
+
+  const isDockerCompose = /\bdocker(?:\s+compose|\s+-compose)\b/.test(
+    normalized,
+  )
+  const isUpCommand = /\bup\b/.test(normalized)
+  const isDownOrStopCommand = /\b(down|stop)\b/.test(normalized)
+  const isDetached = /(^|\s)(-d|--detach)(\s|$)/.test(normalized)
+
+  return isDockerCompose && ((isUpCommand && isDetached) || isDownOrStopCommand)
+}

package/src/services/runtime/docker-runtime.ts

@@ -0,0 +1,171 @@
+import { execFile } from "node:child_process"
+import { promisify } from "node:util"
+
+import type { ComposeService } from "../../types/project"
+import type { RunState, RuntimeStatus } from "../../types/workspace-runtime"
+import { logger } from "../../utils/logging/logger.js"
+import { isPortInUse } from "../../utils/runtime/port.js"
+
+const execFileAsync = promisify(execFile)
+
+/**
+ * Shape returned by `docker ps --format '{{json .}}'` (one JSON object per line)
+ */
+interface DockerPsEntry {
+  ID: string
+  Names: string
+  Image: string
+  State: string // "running", "exited", "paused", etc.
+  Status: string // "Up 2 hours", "Exited (0) 3 minutes ago"
+  Ports: string // "0.0.0.0:5432->5432/tcp" or ""
+}
+
+/**
+ * Fetch all Docker containers (running + stopped) as structured JSON.
+ */
+async function getDockerContainers(): Promise<DockerPsEntry[]> {
+  try {
+    const { stdout } = await execFileAsync("docker", [
+      "ps",
+      "-a",
+      "--format",
+      "{{json .}}",
+    ])
+
+    // Each line is a separate JSON object
+    return stdout
+      .trim()
+      .split("\n")
+      .filter(Boolean)
+      .map((line) => JSON.parse(line) as DockerPsEntry)
+  } catch (error) {
+    logger.debug(error, "Failed to get Docker containers")
+    return []
+  }
+}
+
+/**
+ * Extract host ports from Docker's Ports string.
+ * e.g. "0.0.0.0:5432->5432/tcp, :::5432->5432/tcp" → [5432]
+ */
+function parseDockerPorts(portsStr: string): number[] {
+  if (!portsStr) return []
+  const ports = new Set<number>()
+  // Match patterns like "0.0.0.0:5432->5432/tcp" or ":::3000->3000/tcp"
+  const matches = portsStr.matchAll(/:(\d+)->/g)
+  for (const match of matches) {
+    ports.add(Number.parseInt(match[1], 10))
+  }
+  return [...ports]
+}
+
+/**
+ * Build RunState[] for compose services.
+ *
+ * 1. Get all running Docker containers.
+ * 2. For each compose service, check if a running container matches the service name.
+ *    - Name matches → "running"
+ *    - A container is running on the same port but with a different name → "conflict"
+ * 3. No matching container found → check if the port is already in use.
+ *    - Port in use → "conflict"
+ *    - Port free → "stopped"
+ */
+export async function getDockerRunStates(
+  workspacePath: string,
+  services: ComposeService[],
+): Promise<RunState[]> {
+  if (services.length === 0) return []
+
+  // Only get running containers
+  const allContainers = await getDockerContainers()
+  const runningContainers = allContainers.filter(
+    (c) => c.State.toLowerCase() === "running",
+  )
+
+  const results: RunState[] = []
+
+  for (const service of services) {
+    let status: RuntimeStatus = "stopped"
+    let statusMessage: string | undefined
+    const port = service.ports?.[0]
+
+    // 1. Check if a running container matches the service name
+    const nameMatch = runningContainers.find((c) =>
+      c.Names.toLowerCase().includes(service.name.toLowerCase()),
+    )
+
+    if (nameMatch) {
+      // If containerName is set, also verify it matches
+      if (
+        service.containerName &&
+        !nameMatch.Names.toLowerCase().includes(
+          service.containerName.toLowerCase(),
+        )
+      ) {
+        // Service name matches but containerName doesn't → conflict
+        status = "conflict"
+        statusMessage = `Conflict with running container: ${nameMatch.Names}`
+      } else {
+        // Both names match (or no containerName set) → running
+        status = "running"
+        const containerPorts = parseDockerPorts(nameMatch.Ports)
+        const resolvedPort =
+          containerPorts.length > 0 ? containerPorts[0] : port
+
+        results.push({
+          id: `${workspacePath}::compose::${service.name}`,
+          name: service.name,
+          type: "service" as const,
+          status,
+          statusMessage,
+          command: `docker compose up ${service.name}`,
+          port: resolvedPort,
+        })
+        continue
+      }
+    } else if (service.containerName) {
+      // No match on service name — also try matching by containerName
+      const containerName = service.containerName
+      const containerNameMatch = runningContainers.find((c) =>
+        c.Names.toLowerCase().includes(containerName.toLowerCase()),
+      )
+
+      if (containerNameMatch) {
+        // containerName matches but service name didn't → conflict
+        status = "conflict"
+        statusMessage = `Conflict with running container: ${containerNameMatch.Names}`
+      }
+    }
+
+    // 2. No match at all — check if the port is already in use
+    if (status === "stopped" && port != null) {
+      const portConflict = runningContainers.find((c) => {
+        const containerPorts = parseDockerPorts(c.Ports)
+        return containerPorts.includes(port)
+      })
+
+      if (portConflict) {
+        status = "conflict"
+        statusMessage = `Conflict with running container: ${portConflict.Names}`
+      } else {
+        const taken = await isPortInUse(port)
+        if (taken) {
+          status = "conflict"
+          statusMessage = `Port ${port} is already in use`
+        }
+      }
+    }
+
+    results.push({
+      id: `${workspacePath}::compose::${service.name}`,
+      name: service.name,
+      type: "service" as const,
+      status,
+      statusMessage,
+      command: `docker compose up ${service.name}`,
+      port,
+    })
+  }
+
+  return results
+}

package/src/services/runtime/node-runtime.ts

@@ -0,0 +1,253 @@
+import { execFile } from "node:child_process"
+import { promisify } from "node:util"
+
+import type { PackageJsonScript } from "../../types/project"
+import type { RunState } from "../../types/workspace-runtime"
+
+const execFileAsync = promisify(execFile)
+
+async function sh(cmd: string, args: string[], opts?: { cwd?: string }) {
+  const { stdout } = await execFileAsync(cmd, args, {
+    cwd: opts?.cwd,
+    maxBuffer: 10 * 1024 * 1024,
+  })
+  return String(stdout ?? "")
+}
+
+async function getPsOutput(): Promise<string> {
+  // Try GNU procps first
+  try {
+    // Include both command and working directory
+    return await sh("ps", ["-eo", "pid=,args=,cwd="])
+  } catch {
+    // Fallback: BSD / busybox style
+    // BSD ps doesn't have cwd, so we'll need to read it from /proc later
+    return await sh("ps", ["ax", "-o", "pid=", "-o", "command="])
+  }
+}
+
+async function getPidCwd(pid: number): Promise<string | null> {
+  try {
+    // On Linux, read the cwd symlink
+    const cwd = await sh("readlink", ["-f", `/proc/${pid}/cwd`])
+    return cwd.trim()
+  } catch {
+    return null
+  }
+}
+
+function extractCoreCommand(command: string): string {
+  // Remove common package managers and extract the actual command
+  const trimmed = command.trim()
+
+  // Strip npm/yarn/pnpm run prefix
+  const withoutPkgManager = trimmed
+    .replace(/^(npm|yarn|pnpm|bun)\s+run\s+/, "")
+    .replace(/^(npx|bunx)\s+/, "")
+
+  // Get the first significant part (the actual executable/script)
+  // e.g., "next dev --turbo -p 3001" -> "next dev"
+  // e.g., "vite --port 5173" -> "vite"
+  const parts = withoutPkgManager.split(/\s+/)
+
+  // Take first 1-2 parts depending on common patterns
+  if (
+    parts.length >= 2 &&
+    (parts[1] === "dev" ||
+      parts[1] === "start" ||
+      parts[1] === "serve" ||
+      parts[1] === "preview")
+  ) {
+    return `${parts[0]} ${parts[1]}`
+  }
+
+  return parts[0] || withoutPkgManager
+}
+
+async function getPidsMatchingCommandInWorkspace(params: {
+  command: string
+  absolutePath: string
+}): Promise<number[]> {
+  const out = await getPsOutput()
+
+  // Extract core command for more flexible matching
+  const coreCommand = extractCoreCommand(params.command)
+  const wsNeedle = params.absolutePath.trim()
+  const pids: number[] = []
+
+  for (const line of out.split("\n")) {
+    const trimmed = line.trim()
+    if (!trimmed) continue
+
+    // Parse pid and command
+    const firstSpace = trimmed.indexOf(" ")
+    if (firstSpace <= 0) continue
+
+    const pidStr = trimmed.slice(0, firstSpace).trim()
+    const rest = trimmed.slice(firstSpace + 1)
+
+    const pid = Number(pidStr)
+    if (!Number.isFinite(pid)) continue
+
+    // Check if command matches the core command
+    // This allows "next dev --turbo" to match "next dev --turbopack -p 3001"
+    if (!rest.includes(coreCommand)) continue
+
+    // Check if the command line includes the workspace path OR
+    // check if the process cwd is within the workspace
+    if (rest.includes(wsNeedle)) {
+      pids.push(pid)
+    } else {
+      // Fallback: check the process working directory
+      const cwd = await getPidCwd(pid)
+      if (cwd?.startsWith(wsNeedle)) {
+        pids.push(pid)
+      }
+    }
+  }
+
+  return Array.from(new Set(pids))
+}
+
+type PidToPorts = Map<number, Set<number>>
+
+function parseSsListeningTcp(out: string): PidToPorts {
+  const pidToPorts: PidToPorts = new Map()
+
+  for (const rawLine of out.split("\n")) {
+    const line = rawLine.trim()
+    if (!line) continue
+
+    // Grab a port from "*:3000", "127.0.0.1:5173", "[::]:3000", etc.
+    // This is a heuristic that works for typical `ss -lptnH` output.
+    const portMatch = line.match(/:(\d+)\s+/)
+    if (!portMatch) continue
+    const port = Number(portMatch[1])
+    if (!Number.isFinite(port)) continue
+
+    // Extract pids from users:(("...",pid=123,...),(...pid=456...))
+    const pidMatches = line.matchAll(/pid=(\d+)/g)
+    for (const m of pidMatches) {
+      const pid = Number(m[1])
+      if (!Number.isFinite(pid)) continue
+
+      if (!pidToPorts.has(pid)) pidToPorts.set(pid, new Set())
+      pidToPorts.get(pid)?.add(port)
+    }
+  }
+
+  return pidToPorts
+}
+
+async function getListeningPortsForPids(
+  pids: number[],
+): Promise<Map<number, number[]>> {
+  if (pids.length === 0) return new Map()
+
+  const ssOut = await sh("ss", ["-lptnH"])
+  const pidToPortsSet = parseSsListeningTcp(ssOut)
+
+  const pidToPorts = new Map<number, number[]>()
+  for (const pid of pids) {
+    const ports = pidToPortsSet.get(pid)
+    pidToPorts.set(pid, ports ? Array.from(ports).sort((a, b) => a - b) : [])
+  }
+  return pidToPorts
+}
+
+async function getChildPids(parentPid: number): Promise<number[]> {
+  try {
+    const out = await sh("pgrep", ["-P", String(parentPid)])
+    return out
+      .trim()
+      .split("\n")
+      .filter(Boolean)
+      .map(Number)
+      .filter(Number.isFinite)
+  } catch {
+    return []
+  }
+}
+
+async function getAllDescendantPids(pid: number): Promise<number[]> {
+  const descendants: number[] = [pid]
+  const children = await getChildPids(pid)
+
+  for (const child of children) {
+    const childDescendants = await getAllDescendantPids(child)
+    descendants.push(...childDescendants)
+  }
+
+  return descendants
+}
+
+export async function getNodeRunStates(
+  absolutePath: string,
+  workspacePath: string,
+  scripts: PackageJsonScript[],
+): Promise<RunState[]> {
+  const results: RunState[] = []
+
+  for (const script of scripts) {
+    const name = script.name as string
+    const command = script.command as string
+
+    const pids = await getPidsMatchingCommandInWorkspace({
+      command,
+      absolutePath,
+    })
+
+    // Get all descendant processes
+    const allPids = new Set<number>()
+    for (const pid of pids) {
+      const descendants = await getAllDescendantPids(pid)
+      descendants.forEach((p) => {
+        allPids.add(p)
+      })
+    }
+
+    const allPidsArray = Array.from(allPids)
+    const pidToPorts = await getListeningPortsForPids(allPidsArray)
+
+    const allPorts = new Set<number>()
+    for (const ports of pidToPorts.values()) {
+      for (const p of ports) allPorts.add(p)
+    }
+
+    const portsSorted = Array.from(allPorts).sort((a, b) => a - b)
+
+    let status: RunState["status"] = "stopped"
+    let port: number | undefined
+    let statusMessage: string | undefined
+
+    if (pids.length === 0) {
+      status = "stopped"
+    } else {
+      status = "running"
+      if (portsSorted.length === 1) {
+        port = portsSorted[0]
+      } else if (portsSorted.length > 1) {
+        status = "conflict"
+        statusMessage = `Multiple listening ports detected: ${portsSorted.join(
+          ", ",
+        )} (pids: ${allPidsArray.join(", ")})`
+      } else {
+        statusMessage = `Process running (pids: ${allPidsArray.join(
+          ", ",
+        )}) but no LISTEN TCP port detected`
+      }
+    }
+
+    results.push({
+      id: `${workspacePath}::packageJson::${name}`,
+      name,
+      type: "script",
+      status,
+      statusMessage,
+      command,
+      port,
+    })
+  }
+
+  return results
+}

package/src/services/runtime/resolve-runtime.ts

@@ -0,0 +1,45 @@
+import type { RunState } from "../../types/workspace-runtime"
+
+/**
+ * Resolves conflicts between Node and Docker run states.
+ * If a service is "conflict" in one runtime but "running" in the other,
+ * change the "conflict" status to "stopped" (or another status if needed).
+ *
+ * @param nodeStates RunState[] from Node runtime
+ * @param dockerStates RunState[] from Docker runtime
+ * @returns { node: RunState[], docker: RunState[] }
+ */
+export function resolveRuntimeConflicts(
+  nodeStates: RunState[],
+  dockerStates: RunState[],
+): { node: RunState[]; docker: RunState[] } {
+  // Helper to find a running service in the other runtime by port or name
+  function findRunningOther(states: RunState[], name: string, port?: number) {
+    return states.find(
+      (s) =>
+        s.status === "running" &&
+        ((port != null && s.port === port) || s.name === name),
+    )
+  }
+
+  function resolve(states: RunState[], otherStates: RunState[]): RunState[] {
+    return states.map((state) => {
+      if (state.status === "conflict") {
+        const other = findRunningOther(otherStates, state.name, state.port)
+        if (other) {
+          return {
+            ...state,
+            status: "stopped",
+            statusMessage: "Stopped due to other runtime running",
+          }
+        }
+      }
+      return state
+    })
+  }
+
+  return {
+    node: resolve(nodeStates, dockerStates),
+    docker: resolve(dockerStates, nodeStates),
+  }
+}

package/src/services/runtime/stop-runtime.ts

@@ -0,0 +1,52 @@
+import { exec } from "node:child_process"
+
+import { logger } from "../../utils/logging/logger.js"
+
+/**
+ * Stop a running script process by port (using fuser)
+ */
+export function stopScriptProcess(runState: { port?: number }) {
+  if (runState.port) {
+    exec(`fuser -k ${runState.port}/tcp`, (err) => {
+      if (err) {
+        // eslint-disable-next-line no-console
+        console.error(`Failed to kill process on port ${runState.port}: ${err}`)
+      } else {
+        // eslint-disable-next-line no-console
+        logger.debug(`Stopped process on port ${runState.port}`)
+      }
+    })
+  } else {
+    // eslint-disable-next-line no-console
+    console.warn("No port found for running script, cannot stop.")
+  }
+}
+
+/**
+ * Stop a running Docker Compose service
+ */
+export function stopComposeService(runState: { id: string; name: string }) {
+  // Try to extract workspace path from runState.id (format: workspacePath::compose::<service>)
+  const match = runState.id.match(/^(.*)::compose::/)
+  const workspacePath = match ? match[1] : undefined
+  if (workspacePath) {
+    exec(
+      `docker compose stop ${runState.name}`,
+      { cwd: workspacePath },
+      (err) => {
+        if (err) {
+          // eslint-disable-next-line no-console
+          console.error(
+            `Failed to stop docker service ${runState.name}: ${err}`,
+          )
+        } else {
+          // eslint-disable-next-line no-console
+          logger.debug(`Stopped docker service ${runState.name}`)
+        }
+      },
+    )
+  } else {
+    // eslint-disable-next-line no-console
+    console.warn("Could not determine workspace path for docker compose stop.")
+  }
+}

package/src/theme/theme.ts

@@ -0,0 +1,72 @@
+import { type ComponentTheme, defaultTheme, extendTheme } from "@inkjs/ui"
+import type { BoxProps, TextProps } from "ink"
+import type { ThemeName } from "../types/config.js"
+
+const appLayoutTheme = {
+  styles: {
+    container: (): BoxProps => ({
+      borderColor: "cyan",
+    }),
+  },
+} satisfies ComponentTheme
+
+const gridTheme = {
+  styles: {
+    title: (): TextProps => ({
+      color: "cyan",
+    }),
+    headerText: (): TextProps => ({
+      color: "white",
+    }),
+    text: (): TextProps => ({
+      color: "white",
+    }),
+    info: (): TextProps => ({
+      color: "cyan",
+    }),
+    workspaceName: (): TextProps => ({
+      color: "white",
+    }),
+    action: (): TextProps => ({
+      color: "cyan",
+    }),
+    error: (): TextProps => ({
+      color: "red",
+    }),
+    border: (): BoxProps => ({
+      borderColor: "cyan",
+    }),
+    runtime: ({ status }: { status?: string }): TextProps => ({
+      color:
+        status === "failed" || status === "conflict"
+          ? "red"
+          : status === "starting" || status === "stopping"
+            ? "yellow"
+            : status === "running"
+              ? "green"
+              : "white",
+    }),
+  },
+} satisfies ComponentTheme
+
+export type AppLayoutTheme = typeof appLayoutTheme
+export type GridTheme = typeof gridTheme
+
+export const darkTheme = extendTheme(defaultTheme, {
+  components: {
+    AppLayout: appLayoutTheme,
+    GridTheme: gridTheme,
+  },
+})
+
+const themes: Record<ThemeName, typeof darkTheme> = {
+  dark: darkTheme,
+}
+
+export function getAppTheme(themeName?: ThemeName) {
+  if (!themeName) {
+    return darkTheme
+  }
+
+  return themes[themeName] ?? darkTheme
+}