@doriandev/devcc 0.1.2 → 0.2.0

package/src/devcc/core/commands.ts

@@ -1,5 +1,9 @@
+import type { AgentManager } from "../agents/agents.js"
+import type { RemoteMachineConfig } from "./config.js"
 import type { DependencyService } from "../deps/DependencyService.js"
+import type { EnvironmentService } from "../environment/EnvironmentService.js"
 import type { GitService } from "../git/GitService.js"
+import type { GitWorktree } from "../git/worktrees.js"
 import type { LogStore } from "../logs/LogBuffer.js"
 import type { ProcessManager } from "../processes/ProcessManager.js"
 import type { ServiceManager } from "../services/ServiceManager.js"
@@ -23,6 +27,8 @@ export interface CommandContext {
   logs: LogStore
   system: SystemMonitor
   deps: DependencyService
+  agents: AgentManager
+  environment: EnvironmentService
 
   navigate: (view: ViewId) => void
   notify: (level: NotificationLevel, message: string, detail?: string) => void
@@ -43,6 +49,26 @@ export interface CommandContext {
   switchProject: (path: string) => Promise<void>
   /** Close an open project, stopping what devcc started there. Defaults to the current one. */
   closeProject: (path?: string) => Promise<void>
+
+  /**
+   * The worktree commands act on: the one selected in the Worktrees view, or
+   * the worktree devcc is running in. Undefined outside a git repository.
+   */
+  selectedWorktree: () => GitWorktree | undefined
+  /** Prompt for branch, base and path, then `git worktree add`. */
+  createWorktree: () => Promise<void>
+  /** Confirmed, never forced `git worktree remove`. */
+  removeWorktree: (worktree: GitWorktree) => Promise<void>
+  /** Prompt for a task and start the agent in the worktree (default: the selected one). */
+  launchAgent: (agentId: string, worktree?: GitWorktree) => Promise<void>
+  openInEditor: (path: string) => Promise<void>
+  openInTerminal: (path: string) => Promise<void>
+  /** Run the project's verification steps; output lands in Logs. */
+  runVerify: () => Promise<void>
+  /** Remote machines declared in config. */
+  remoteMachines: () => RemoteMachineConfig[]
+  /** Open an interactive SSH session in a terminal. */
+  sshTo: (machineId: string) => Promise<void>
   quit: () => void
 }
 

package/src/devcc/core/config.ts

@@ -1,9 +1,12 @@
 import { existsSync } from "node:fs"
 import { join } from "node:path"
+import type { AgentConfig } from "../agents/agents.js"
 import type { ProcessDefinition, ProcessKind, ReadinessCheck } from "../processes/ManagedProcess.js"
+import type { ServiceCategory } from "../services/types.js"
 import { errorMessage } from "../utils/errors.js"
 import type { LogLevel } from "../utils/logger.js"
 import { isLogLevel } from "../utils/logger.js"
+import type { VerifyEntry } from "../verify/verify.js"
 
 /** A command declared in project config: runs an executable and streams its logs. */
 export interface CommandConfigEntry {
@@ -18,14 +21,70 @@ export interface CommandConfigEntry {
   confirm?: { title: string; message: string } | boolean
 }
 
-/** An extra port/HTTP endpoint to watch in the Services view. */
+/**
+ * An extra endpoint to watch in the Services view.
+ *
+ * The default `type: "port"` is a TCP (or HTTP, with `healthPath`) probe.
+ * `type: "ollama"` watches an Ollama server at `baseUrl` - localhost, a LAN
+ * hostname or a Tailscale name - including its models.
+ */
 export interface ServiceConfigEntry {
   id: string
   name: string
+  /** Required for port services; derived from `baseUrl` for Ollama. */
   port: number
   host?: string
   healthPath?: string
-  category?: "container" | "database" | "runtime" | "ai" | "web"
+  category?: ServiceCategory
+  type?: "port" | "ollama"
+  /** Ollama only, e.g. `http://gpu-server:11434`. */
+  baseUrl?: string
+}
+
+/** How to open a directory in an editor. `command` wins over `application`. */
+export interface EditorConfig {
+  /** CLI launcher on PATH: `code`, `zed`, `cursor`, `webstorm`. */
+  command?: string
+  /** Extra arguments placed before the path. */
+  args?: string[]
+  /** macOS application name for `open -a`, e.g. `WebStorm`. */
+  application?: string
+}
+
+/**
+ * How to open a terminal. By default devcc uses Terminal on macOS.
+ * `application` names another macOS app; `command` + `args` launches anything
+ * else, with `{path}` in an argument replaced by the directory.
+ */
+export interface TerminalConfig {
+  application?: string
+  command?: string
+  /** Arguments to open a directory (default `["{path}"]`). */
+  args?: string[]
+  /** Arguments that make `command` run a program, e.g. `["start", "--"]` for WezTerm; used for SSH. */
+  execArgs?: string[]
+}
+
+export interface WorktreesConfig {
+  /** Where new worktrees go, relative to the main worktree (default `..`). */
+  directory?: string
+}
+
+/**
+ * A development machine reached over SSH. `host` may be an alias from
+ * `~/.ssh/config`; devcc resolves it with `ssh -G` and never stores credentials.
+ */
+export interface RemoteMachineConfig {
+  id: string
+  name: string
+  host: string
+  transport: "ssh"
+  /** Overrides the port from SSH config. */
+  port?: number
+  /** Overrides the user from SSH config. */
+  user?: string
+  /** Ids of `services` entries that run on this machine. */
+  services?: string[]
 }
 
 export interface RefreshIntervals {
@@ -52,12 +111,29 @@ export interface DevccConfig {
   /** Cap for each log source's ring buffer. */
   maxLogLines?: number
   logLevel?: LogLevel
+  /** Editor for "open in editor" (default: `$VISUAL`/`$EDITOR` is not used; see README). */
+  editor?: EditorConfig
+  terminal?: TerminalConfig
+  /** Override or add AI agents, keyed by id (`claude`, `codex`, or your own). */
+  agents?: Record<string, AgentConfig>
+  worktrees?: WorktreesConfig
+  /** Steps for `devcc verify`: command ids, package.json scripts, or inline steps. */
+  verify?: VerifyEntry[]
+  remoteMachines?: RemoteMachineConfig[]
 }
 
-export type ResolvedConfig = Required<
-  Pick<DevccConfig, "processes" | "commands" | "services" | "projects" | "projectSearchDirs">
-> &
-  Omit<DevccConfig, "processes" | "commands" | "services" | "projects" | "projectSearchDirs"> & {
+type ListFields =
+  | "processes"
+  | "commands"
+  | "services"
+  | "projects"
+  | "projectSearchDirs"
+  | "verify"
+  | "remoteMachines"
+  | "agents"
+
+export type ResolvedConfig = Required<Pick<DevccConfig, ListFields>> &
+  Omit<DevccConfig, ListFields> & {
     refresh: Required<RefreshIntervals>
   }
 
@@ -74,6 +150,9 @@ export const EMPTY_CONFIG: ResolvedConfig = {
   services: [],
   projects: [],
   projectSearchDirs: [],
+  verify: [],
+  remoteMachines: [],
+  agents: {},
   refresh: DEFAULT_REFRESH,
 }
 
@@ -231,15 +310,41 @@ export function validateConfig(raw: unknown): ValidationResult {
       continue
     }
     const id = asString(record.id)
-    const port = asPositiveInt(record.port)
-    if (!id || port === undefined) {
-      issues.push(`services[${index}] needs "id" and a numeric "port"`)
+    const type = asString(record.type) ?? "port"
+    if (type !== "port" && type !== "ollama") {
+      issues.push(`services[${index}] has unknown type "${type}" (expected "port" or "ollama")`)
       continue
     }
-    if (seenServiceIds.has(id)) {
+    if (id && seenServiceIds.has(id)) {
       issues.push(`services[${index}] duplicates id "${id}"`)
       continue
     }
+
+    if (type === "ollama") {
+      const baseUrl = asString(record.baseUrl)
+      const endpoint = baseUrl ? parseHttpUrl(baseUrl) : null
+      if (!id || !endpoint) {
+        issues.push(`services[${index}] (ollama) needs "id" and an http(s) "baseUrl"`)
+        continue
+      }
+      seenServiceIds.add(id)
+      services.push({
+        id,
+        name: asString(record.name) ?? `Ollama (${endpoint.host})`,
+        type: "ollama",
+        baseUrl: endpoint.baseUrl,
+        host: endpoint.host,
+        port: endpoint.port,
+        category: "ai",
+      })
+      continue
+    }
+
+    const port = asPositiveInt(record.port)
+    if (!id || port === undefined) {
+      issues.push(`services[${index}] needs "id" and a numeric "port"`)
+      continue
+    }
     seenServiceIds.add(id)
     services.push({
       id,
@@ -251,6 +356,15 @@ export function validateConfig(raw: unknown): ValidationResult {
     })
   }
 
+  const remoteMachines = asRemoteMachines(input.remoteMachines, seenServiceIds, issues)
+  const verify = asVerify(input.verify, issues)
+  const agents = asAgents(input.agents, issues)
+  const editor = asEditor(input.editor, issues)
+  const terminal = asTerminal(input.terminal, issues)
+  const worktreesRecord = asRecord(input.worktrees)
+  if (input.worktrees !== undefined && !worktreesRecord) issues.push(`"worktrees" must be an object`)
+  const worktrees = worktreesRecord ? { directory: asString(worktreesRecord.directory) } : undefined
+
   const refreshInput = asRecord(input.refresh) ?? {}
   const refresh: Required<RefreshIntervals> = {
     system: asPositiveInt(refreshInput.system) ?? DEFAULT_REFRESH.system,
@@ -273,6 +387,12 @@ export function validateConfig(raw: unknown): ValidationResult {
       refresh,
       maxLogLines: asPositiveInt(input.maxLogLines),
       logLevel: logLevel && isLogLevel(logLevel) ? logLevel : undefined,
+      editor,
+      terminal,
+      agents,
+      worktrees,
+      verify,
+      remoteMachines,
     },
     issues,
   }
@@ -397,9 +517,149 @@ function asReadiness(value: unknown, processId: string, issues: string[]): Readi
 }
 
 function asServiceCategory(value: unknown): ServiceConfigEntry["category"] {
-  const categories = ["container", "database", "runtime", "ai", "web"] as const
+  const categories = ["container", "database", "runtime", "ai", "web", "remote"] as const
   const name = asString(value)
   return name && (categories as readonly string[]).includes(name)
     ? (name as ServiceConfigEntry["category"])
     : "web"
 }
+
+function parseHttpUrl(value: string): { baseUrl: string; host: string; port: number } | null {
+  try {
+    const url = new URL(value)
+    if (url.protocol !== "http:" && url.protocol !== "https:") return null
+    const port = url.port ? Number(url.port) : url.protocol === "https:" ? 443 : 80
+    return { baseUrl: `${url.protocol}//${url.host}`, host: url.hostname, port }
+  } catch {
+    return null
+  }
+}
+
+/**
+ * A value handed to `ssh` as an argument must never be readable as an option
+ * (`-oProxyCommand=...`), so hosts and users are held to a conservative charset.
+ */
+const SSH_TOKEN = /^[A-Za-z0-9_][A-Za-z0-9._%+:[\]-]*$/u
+
+function asRemoteMachines(value: unknown, serviceIds: Set<string>, issues: string[]): RemoteMachineConfig[] {
+  const machines: RemoteMachineConfig[] = []
+  const seen = new Set<string>()
+  for (const [index, entry] of asArray(value, "remoteMachines", issues).entries()) {
+    const record = asRecord(entry)
+    const id = asString(record?.id)
+    const host = asString(record?.host)
+    if (!record || !id || !host) {
+      issues.push(`remoteMachines[${index}] needs "id" and "host"`)
+      continue
+    }
+    if (seen.has(id)) {
+      issues.push(`remoteMachines[${index}] duplicates id "${id}"`)
+      continue
+    }
+    const transport = asString(record.transport) ?? "ssh"
+    if (transport !== "ssh") {
+      issues.push(`remoteMachines "${id}": transport "${transport}" is not supported (only "ssh")`)
+      continue
+    }
+    if (!SSH_TOKEN.test(host)) {
+      issues.push(`remoteMachines "${id}": host "${host}" is not a valid hostname or SSH alias`)
+      continue
+    }
+    const user = asString(record.user)
+    if (user !== undefined && !SSH_TOKEN.test(user)) {
+      issues.push(`remoteMachines "${id}": user "${user}" is not valid`)
+      continue
+    }
+    const services = asStringArray(record.services)
+    for (const serviceId of services ?? []) {
+      if (!serviceIds.has(serviceId)) {
+        issues.push(`remoteMachines "${id}": service "${serviceId}" is not a declared service`)
+      }
+    }
+    seen.add(id)
+    machines.push({
+      id,
+      name: asString(record.name) ?? id,
+      host,
+      transport: "ssh",
+      port: asPositiveInt(record.port),
+      user,
+      services,
+    })
+  }
+  return machines
+}
+
+function asVerify(value: unknown, issues: string[]): VerifyEntry[] {
+  const entries: VerifyEntry[] = []
+  for (const [index, entry] of asArray(value, "verify", issues).entries()) {
+    const name = asString(entry)
+    if (name) {
+      entries.push(name)
+      continue
+    }
+    const record = asRecord(entry)
+    const id = asString(record?.id)
+    const command = asString(record?.command)
+    if (!record || !id || !command) {
+      issues.push(`verify[${index}] must be a command id, a script name, or { id, command }`)
+      continue
+    }
+    entries.push({
+      id,
+      name: asString(record.name),
+      command,
+      args: asStringArray(record.args),
+      cwd: asString(record.cwd),
+    })
+  }
+  return entries
+}
+
+function asAgents(value: unknown, issues: string[]): Record<string, AgentConfig> {
+  if (value === undefined) return {}
+  const record = asRecord(value)
+  if (!record) {
+    issues.push(`"agents" must be an object keyed by agent id`)
+    return {}
+  }
+  const agents: Record<string, AgentConfig> = {}
+  for (const [id, entry] of Object.entries(record)) {
+    const agent = asRecord(entry)
+    if (!agent) {
+      issues.push(`agents.${id} must be an object`)
+      continue
+    }
+    agents[id] = {
+      name: asString(agent.name),
+      command: asString(agent.command),
+      args: asStringArray(agent.args),
+      enabled: agent.enabled === false ? false : undefined,
+    }
+  }
+  return agents
+}
+
+function asEditor(value: unknown, issues: string[]): EditorConfig | undefined {
+  if (value === undefined) return undefined
+  const record = asRecord(value)
+  const command = asString(record?.command)
+  const application = asString(record?.application)
+  if (!record || (!command && !application)) {
+    issues.push(`"editor" needs a "command" (e.g. "zed") or an "application" (e.g. "WebStorm")`)
+    return undefined
+  }
+  return { command, application, args: asStringArray(record.args) }
+}
+
+function asTerminal(value: unknown, issues: string[]): TerminalConfig | undefined {
+  if (value === undefined) return undefined
+  const record = asRecord(value)
+  const command = asString(record?.command)
+  const application = asString(record?.application)
+  if (!record || (!command && !application)) {
+    issues.push(`"terminal" needs a "command" or an "application"`)
+    return undefined
+  }
+  return { command, application, args: asStringArray(record.args), execArgs: asStringArray(record.execArgs) }
+}

package/src/devcc/core/state.ts

@@ -1,3 +1,6 @@
+import type { AgentSession } from "../agents/agents.js"
+import type { EnvironmentSnapshot } from "../environment/EnvironmentService.js"
+import { EMPTY_ENVIRONMENT } from "../environment/EnvironmentService.js"
 import type { GitSnapshot } from "../git/GitService.js"
 import { EMPTY_GIT_SNAPSHOT } from "../git/GitService.js"
 import type { LogSource } from "../logs/LogBuffer.js"
@@ -8,6 +11,7 @@ import type { ProjectEntry } from "../projects/ProjectRegistry.js"
 import type { ServiceSnapshot } from "../services/types.js"
 import type { HostInfo, SystemMetrics, ToolVersions } from "../system/SystemMonitor.js"
 import type { PackageManagerDetection } from "../utils/packageManager.js"
+import type { VerifyStepResult } from "../verify/verify.js"
 
 export const VIEW_IDS = [
   "overview",
@@ -15,6 +19,7 @@ export const VIEW_IDS = [
   "services",
   "scripts",
   "git",
+  "worktrees",
   "logs",
   "dependencies",
   "system",
@@ -60,6 +65,19 @@ export interface ScriptsState {
   runs: Record<string, ScriptRun>
 }
 
+export interface VerifyState {
+  /** Steps resolved from config; empty when verification is not configured. */
+  configured: number
+  running: boolean
+  /** Progress of the current or most recent run. */
+  steps: VerifyStepResult[]
+  startedAt?: Date
+  finishedAt?: Date
+  ok?: boolean
+}
+
+export const EMPTY_VERIFY: VerifyState = { configured: 0, running: false, steps: [] }
+
 export interface UiState {
   view: ViewId
   overlay: OverlayKind
@@ -83,6 +101,10 @@ export interface AppState {
   scripts: ScriptsState
   git: GitSnapshot
   dependencies: DependencySnapshot
+  /** AI agent sessions started in this project, newest first. */
+  agents: AgentSession[]
+  environment: EnvironmentSnapshot
+  verify: VerifyState
   system: SystemMetrics | null
   logSources: LogSource[]
   notifications: Notification[]
@@ -119,6 +141,9 @@ export function createInitialState(project: ProjectState, width: number, height:
     scripts: { available: [], runs: {} },
     git: EMPTY_GIT_SNAPSHOT,
     dependencies: EMPTY_DEPENDENCY_SNAPSHOT,
+    agents: [],
+    environment: EMPTY_ENVIRONMENT,
+    verify: EMPTY_VERIFY,
     system: null,
     logSources: [],
     notifications: [],

package/src/devcc/environment/EnvironmentService.ts

@@ -0,0 +1,215 @@
+import { existsSync } from "node:fs"
+import { join } from "node:path"
+import { TypedEmitter } from "../core/events.js"
+import { DevccError } from "../utils/errors.js"
+import { exec } from "../utils/exec.js"
+import type { ScopedLogger } from "../utils/logger.js"
+import {
+  isDirenvLoaded,
+  MISE_ARGS,
+  miseErrorMessage,
+  parseDirenvStatus,
+  parseMiseLs,
+  type DirenvStatus,
+  type MiseStatus,
+} from "./integrations.js"
+import {
+  DEFAULT_TOOLS,
+  detectTool,
+  findExecutable,
+  firstLine,
+  type Exec,
+  type ToolDefinition,
+  type ToolStatus,
+  type Which,
+} from "./tools.js"
+
+export interface EnvironmentSnapshot {
+  tools: ToolStatus[]
+  mise: MiseStatus
+  direnv: DirenvStatus
+  /** Null until the first detection finishes. */
+  checkedAt: Date | null
+  checking: boolean
+}
+
+export const EMPTY_ENVIRONMENT: EnvironmentSnapshot = {
+  tools: [],
+  mise: { installed: false, runtimes: [] },
+  direnv: { installed: false, approval: "unknown", loaded: null },
+  checkedAt: null,
+  checking: false,
+}
+
+export type EnvironmentServiceEvents = {
+  "environment:changed": [EnvironmentSnapshot]
+}
+
+export interface EnvironmentServiceOptions {
+  rootDir: string
+  logger?: ScopedLogger
+  tools?: readonly ToolDefinition[]
+  /** Injected for tests. */
+  run?: Exec
+  which?: Which
+  env?: NodeJS.ProcessEnv
+  exists?: (path: string) => boolean
+  timeoutMs?: number
+}
+
+/**
+ * Machine and project environment health.
+ *
+ * Detection runs asynchronously, every external call has a timeout, and the
+ * result is cached until someone asks for a refresh: tool versions change
+ * rarely, so there is nothing to poll.
+ */
+export class EnvironmentService extends TypedEmitter<EnvironmentServiceEvents> {
+  private snapshot: EnvironmentSnapshot = EMPTY_ENVIRONMENT
+  private pending: Promise<EnvironmentSnapshot> | null = null
+  private readonly run: Exec
+  private readonly which: Which
+  private readonly env: NodeJS.ProcessEnv
+
+  constructor(private readonly options: EnvironmentServiceOptions) {
+    super()
+    this.env = options.env ?? process.env
+    this.run = options.run ?? exec
+    this.which = options.which ?? ((command) => findExecutable(command, this.env.PATH ?? ""))
+  }
+
+  getSnapshot(): EnvironmentSnapshot {
+    return this.snapshot
+  }
+
+  /** Detect everything. Concurrent calls share one run. */
+  refresh(): Promise<EnvironmentSnapshot> {
+    if (this.pending) return this.pending
+    this.publish({ ...this.snapshot, checking: true })
+    this.pending = this.detect().finally(() => {
+      this.pending = null
+    })
+    return this.pending
+  }
+
+  /** The cached snapshot, detecting first if nothing has been checked yet. */
+  async ensure(): Promise<EnvironmentSnapshot> {
+    return this.snapshot.checkedAt ? this.snapshot : this.refresh()
+  }
+
+  /**
+   * `direnv allow` for this project's `.envrc`. Only ever called from an
+   * explicit, confirmed user action - devcc never approves an `.envrc` itself.
+   */
+  async allowDirenv(): Promise<void> {
+    const { rcPath, installed } = this.snapshot.direnv
+    if (!installed || !rcPath) {
+      throw new DevccError({ scope: "system", message: "No .envrc for direnv to allow" })
+    }
+    const result = await this.run("direnv", ["allow", rcPath], {
+      cwd: this.options.rootDir,
+      timeoutMs: 10_000,
+      logger: this.options.logger,
+    })
+    if (!result.ok) {
+      throw new DevccError({
+        scope: "system",
+        message: "direnv allow failed",
+        detail: result.stderr.trim() || undefined,
+      })
+    }
+    await this.refresh()
+  }
+
+  private async detect(): Promise<EnvironmentSnapshot> {
+    const startedAt = Date.now()
+    const definitions = this.options.tools ?? DEFAULT_TOOLS
+    const tools = await Promise.all(
+      definitions.map((definition) =>
+        detectTool(definition, {
+          run: (command, args, options) =>
+            this.run(command, args, { ...options, logger: this.options.logger }),
+          which: this.which,
+          timeoutMs: this.options.timeoutMs,
+        }),
+      ),
+    )
+
+    const installed = (id: string) => tools.find((tool) => tool.id === id)?.installed === true
+    const [mise, direnv] = await Promise.all([
+      this.detectMise(installed("mise")),
+      this.detectDirenv(installed("direnv")),
+    ])
+
+    this.options.logger?.debug("environment detected", {
+      durationMs: Date.now() - startedAt,
+      installed: tools.filter((tool) => tool.installed).map((tool) => tool.id),
+    })
+    return this.publish({ tools, mise, direnv, checkedAt: new Date(), checking: false })
+  }
+
+  private async detectMise(installed: boolean): Promise<MiseStatus> {
+    if (!installed) return { installed: false, runtimes: [] }
+    const result = await this.run("mise", MISE_ARGS, {
+      cwd: this.options.rootDir,
+      timeoutMs: this.options.timeoutMs ?? 5_000,
+      // stdin is closed by exec, so mise cannot stop to prompt (e.g. to trust a config).
+      logger: this.options.logger,
+    })
+    if (result.timedOut) return { installed: true, runtimes: [], error: "mise did not answer in time" }
+    if (!result.ok) return { installed: true, runtimes: [], error: miseErrorMessage(result.stderr) }
+    return { installed: true, runtimes: parseMiseLs(result.stdout) }
+  }
+
+  private async detectDirenv(installed: boolean): Promise<DirenvStatus> {
+    const exists = this.options.exists ?? existsSync
+    const localRc = [".envrc", ".env"]
+      .map((name) => join(this.options.rootDir, name))
+      .find((path) => exists(path))
+
+    if (!installed) {
+      return {
+        installed: false,
+        rcPath: localRc,
+        approval: "unknown",
+        loaded: localRc ? false : null,
+        error: localRc?.endsWith(".envrc")
+          ? "direnv is not installed; .envrc is not being loaded"
+          : undefined,
+      }
+    }
+
+    const options = {
+      cwd: this.options.rootDir,
+      timeoutMs: this.options.timeoutMs ?? 5_000,
+      logger: this.options.logger,
+    }
+    let result = await this.run("direnv", ["status", "--json"], options)
+    if (!result.ok && !result.timedOut) result = await this.run("direnv", ["status"], options)
+    if (!result.ok) {
+      return {
+        installed: true,
+        rcPath: localRc,
+        approval: "unknown",
+        loaded: null,
+        error: result.timedOut
+          ? "direnv did not answer in time"
+          : (firstLine(result.stderr) ?? "direnv status failed"),
+      }
+    }
+
+    const parsed = parseDirenvStatus(result.stdout)
+    return {
+      installed: true,
+      rcPath: parsed.rcPath,
+      approval: parsed.rcPath ? parsed.approval : "unknown",
+      loaded: parsed.rcPath ? isDirenvLoaded(parsed.rcPath, this.env) : null,
+    }
+  }
+
+  private publish(snapshot: EnvironmentSnapshot): EnvironmentSnapshot {
+    this.snapshot = snapshot
+    this.emit("environment:changed", snapshot)
+    return snapshot
+  }
+}