@doriandev/devcc 0.2.0 → 0.3.0

package/src/devcc/app/App.ts

@@ -1,7 +1,10 @@
 import { BoxRenderable, createCliRenderer, type CliRenderer, type KeyEvent } from "@opentui/core"
-import { existsSync } from "node:fs"
+import { existsSync, mkdirSync, writeFileSync } from "node:fs"
 import { basename, join, resolve } from "node:path"
 import { AgentManager, createAgentAdapters } from "../agents/agents.js"
+import { configProblems } from "../automation.js"
+import { detectProject, renderStarterConfig } from "../init/detect.js"
+import { buildSetupPrompt, extractConfigFromOutput } from "../init/prompt.js"
 import { ConfirmDialog, PromptDialog } from "../components/ConfirmDialog.js"
 import { Footer, type KeyHint } from "../components/Footer.js"
 import { Header } from "../components/Header.js"
@@ -11,7 +14,7 @@ import { Sidebar } from "../components/Sidebar.js"
 import { CommandPalette } from "../components/CommandPalette.js"
 import { ProjectPicker } from "../components/ProjectPicker.js"
 import { CommandRegistry, type CommandContext } from "../core/commands.js"
-import { loadConfig, type CommandConfigEntry, type ResolvedConfig } from "../core/config.js"
+import { loadConfig, loadConfigFile, type CommandConfigEntry, type ResolvedConfig } from "../core/config.js"
 import { EnvironmentService, type EnvironmentSnapshot } from "../environment/EnvironmentService.js"
 import { Subscriptions } from "../core/events.js"
 import {
@@ -132,6 +135,8 @@ interface ProjectSession {
   /** Config problems that make verification untrustworthy; running is refused while any exist. */
   verifyIssues: string[]
   verifyAbort: AbortController | null
+  /** The agent session proposing a .devcc.ts, if one is running. */
+  setupAgentSessionId: string | null
   scripts: { name: string; command: string }[]
   /** Script runs belong to the project they ran in, not to the store. */
   scriptRuns: Record<string, ScriptRun>
@@ -361,6 +366,7 @@ export class App {
       verify: { configured: resolvedVerify.steps.length, running: false, steps: [] },
       verifyIssues: [...loaded.issues.filter(isVerifyIssue), ...resolvedVerify.issues],
       verifyAbort: null,
+      setupAgentSessionId: null,
       scripts,
       scriptRuns: {},
       wiring: new Subscriptions(),
@@ -388,6 +394,9 @@ export class App {
     for (const issue of this.session.project.configIssues) {
       this.pushNotification("warn", `Config: ${issue}`)
     }
+    if (!this.session.project.configPath) {
+      this.pushNotification("info", "No .devcc.ts yet: press / and run “Project: set up .devcc.ts”")
+    }
   }
 
   // ---------------------------------------------------------------------
@@ -519,6 +528,7 @@ export class App {
     processes.on("process:exit", (process) => {
       this.finishScriptRun(session, process.id, process.exitCode ?? 0)
       syncProcesses()
+      if (process.id === session.setupAgentSessionId) void this.finishConfigSetup(session, process)
     })
     processes.on("process:error", (error) => notify("error", error.message, error.detail))
     processes.on("process:retry", (managed, delayMs) => {
@@ -1148,6 +1158,8 @@ export class App {
       runVerify: () => this.runVerify(),
       remoteMachines: () => this.config.remoteMachines,
       sshTo: (machineId) => this.sshTo(machineId),
+      setUpConfig: (how) => this.setUpConfig(how),
+      reloadConfig: () => this.reloadConfig(),
       quit: () => void this.quit(),
     }
 
@@ -1690,6 +1702,145 @@ export class App {
     }
   }
 
+  // ---------------------------------------------------------------------
+  // Project setup (.devcc.ts)
+  // ---------------------------------------------------------------------
+
+  private async setUpConfig(how: string): Promise<void> {
+    const session = this.session
+    const facts = detectProject(session.rootDir)
+
+    if (how === "starter") {
+      if (facts.configPath) {
+        const replace = await this.askConfirm(
+          "Replace the existing config with a starter?",
+          `${tildify(facts.configPath)} will be overwritten with what devcc detects. Consider setting it up with an agent instead, which keeps what is still right.`,
+        )
+        if (!replace) return
+      }
+      const target = join(session.rootDir, ".devcc.ts")
+      writeFileSync(target, renderStarterConfig(facts), "utf8")
+      this.pushNotification("success", `Created ${tildify(target)}`)
+      await this.reloadConfig()
+      return
+    }
+
+    const adapter = this.agents.get(how)
+    if (!adapter) {
+      this.pushNotification("warn", `Unknown agent "${how}"`)
+      return
+    }
+    if (session.setupAgentSessionId && session.processes.isRunning(session.setupAgentSessionId)) {
+      this.pushNotification("warn", "An agent is already setting up .devcc.ts")
+      return
+    }
+
+    try {
+      const agentSession = await this.agents.launch(how, {
+        cwd: session.rootDir,
+        prompt: buildSetupPrompt(facts, "print"),
+      })
+      session.setupAgentSessionId = agentSession.id
+      updateUi(this.store, { logSource: agentSession.id })
+      this.pushNotification(
+        "info",
+        `${adapter.name} is reading the project; devcc will offer its .devcc.ts when it finishes`,
+      )
+    } catch (error) {
+      const devccError = toDevccError(error, "process")
+      this.pushNotification("error", devccError.message, devccError.detail)
+    }
+  }
+
+  /**
+   * The setup agent exited: take the config it printed, validate it from a
+   * scratch file under .devcc/, and write it only if the user agrees.
+   */
+  private async finishConfigSetup(session: ProjectSession, agent: ManagedProcess): Promise<void> {
+    session.setupAgentSessionId = null
+    const name = session.project.name
+    if (agent.exitCode !== 0) {
+      this.pushNotification(
+        "error",
+        `[${name}] Config setup agent exited with code ${agent.exitCode ?? "?"}; see its logs`,
+      )
+      return
+    }
+
+    const output = (session.logs.get(agent.id)?.toArray() ?? [])
+      .filter((entry) => entry.stream !== "system")
+      .map((entry) => entry.text)
+      .join("\n")
+    const proposal = extractConfigFromOutput(output)
+    if (!proposal) {
+      this.pushNotification("warn", `[${name}] The agent did not print a .devcc.ts; see its logs`)
+      return
+    }
+
+    const scratchDir = join(session.rootDir, ".devcc")
+    const proposedPath = join(scratchDir, "proposed.devcc.ts")
+    mkdirSync(scratchDir, { recursive: true })
+    writeFileSync(proposedPath, proposal, "utf8")
+    const loaded = await loadConfigFile(proposedPath)
+    const problems = configProblems(session.rootDir, loaded)
+    const { config } = loaded
+
+    const current = session.project.configPath
+    const target = current && !current.endsWith(".json") ? current : join(session.rootDir, ".devcc.ts")
+    const summary = [
+      `${config.processes.length} process(es), ${config.commands.length} command(s), verify: ${
+        config.verify.map((entry) => (typeof entry === "string" ? entry : entry.id)).join(", ") || "none"
+      }.`,
+      problems.length > 0 ? `${problems.length} issue(s): ${problems[0] ?? ""}` : "It validates cleanly.",
+      `Review it first in ${tildify(proposedPath)}.`,
+    ].join(" ")
+
+    const write = await this.askConfirm(
+      `Write ${current ? "the updated" : "the proposed"} ${tildify(target)}?`,
+      summary,
+    )
+    if (!write) {
+      this.pushNotification("info", `Kept the proposal at ${tildify(proposedPath)}`)
+      return
+    }
+    writeFileSync(target, proposal, "utf8")
+    this.pushNotification("success", `Wrote ${tildify(target)}`)
+    if (session === this.session) await this.reloadConfig()
+    else this.pushNotification("info", `Switch to ${name} and reload its config to use it`)
+  }
+
+  /** Rebuild the active project's session so a changed config takes effect. */
+  private async reloadConfig(): Promise<void> {
+    const previous = this.session
+    const running = previous.processes.list().filter((entry) => isActive(entry.status))
+    if (running.length > 0) {
+      const confirmed = await this.askConfirm(
+        `Reload the config and stop ${running.length} running process(es)?`,
+        `${running.map((entry) => entry.name).join(", ")} will be stopped; start them again afterwards.`,
+      )
+      if (!confirmed) return
+    }
+
+    this.stopSessionBackground(previous)
+    previous.verifyAbort?.abort()
+    await previous.processes.stopAll()
+    previous.wiring.dispose()
+
+    try {
+      const next = await this.createSession(previous.rootDir)
+      this.sessions.set(next.rootDir, next)
+      this.wireSession(next)
+      this.activateSession(next)
+      this.reportConfigIssues()
+      this.pushNotification(
+        "success",
+        `Reloaded ${next.project.configPath ? basename(next.project.configPath) : "config"}`,
+      )
+    } catch (error) {
+      this.pushNotification("error", `Could not reload the config: ${errorMessage(error)}`)
+    }
+  }
+
   // ---------------------------------------------------------------------
   // Dependencies
   // ---------------------------------------------------------------------

package/src/devcc/app/controlPlaneCommands.ts

@@ -168,6 +168,36 @@ export function createControlPlaneCommands(options: ControlPlaneCommandOptions):
     },
   ]
 
+  // --- Project setup -------------------------------------------------------
+  const hasConfig = (context: CommandContext) => context.store.getState().project.configPath !== null
+  commands.push(
+    {
+      id: "config.starter",
+      title: "Project: set up .devcc.ts from detected scripts",
+      category: "Project",
+      keywords: ["init", "config", "setup", "starter", "generate"],
+      when: (context) => !hasConfig(context),
+      execute: (context) => context.setUpConfig("starter"),
+    },
+    ...options.agents
+      .filter((agent) => agent.separatesPrompt)
+      .map((agent): CommandDefinition => ({
+        id: `config.agent.${agent.id}`,
+        title: `Project: set up .devcc.ts with ${agent.name}`,
+        category: "Project",
+        keywords: ["init", "config", "setup", "improve", "agent", agent.id],
+        execute: (context) => context.setUpConfig(agent.id),
+      })),
+    {
+      id: "config.reload",
+      title: "Project: reload .devcc.ts",
+      category: "Project",
+      keywords: ["config", "refresh", "reread"],
+      when: hasConfig,
+      execute: (context) => context.reloadConfig(),
+    },
+  )
+
   // --- Remote machines -----------------------------------------------------
   for (const machine of options.machines) {
     commands.push({

package/src/devcc/app/keymap.ts

@@ -64,6 +64,7 @@ export const HELP_SECTIONS: HelpSection[] = [
     title: "Getting started",
     entries: [
       { keys: ".devcc.ts", description: "declare processes devcc can control (see Config below)" },
+      { keys: "/ set up", description: "“Project: set up .devcc.ts” writes a starter or asks an agent" },
       { keys: "ctrl+p", description: "open another project; the current one keeps running" },
       { keys: "/", description: "the palette lists everything the app can do" },
       { keys: ".devcc/devcc.log", description: "internal diagnostics, if something looks wrong" },

package/src/devcc/automation.ts

@@ -1,8 +1,15 @@
-import { loadConfig } from "./core/config.js"
+import { spawn } from "node:child_process"
+import { writeFileSync } from "node:fs"
+import { basename, join } from "node:path"
+import { createAgentAdapters } from "./agents/agents.js"
+import { loadConfig, loadConfigFile, type LoadedConfig } from "./core/config.js"
 import { EnvironmentService, type EnvironmentSnapshot } from "./environment/EnvironmentService.js"
 import { GitService } from "./git/GitService.js"
 import { worktreeLabel } from "./git/worktrees.js"
+import { detectProject, renderStarterConfig, starterConfig } from "./init/detect.js"
+import { buildSetupPrompt } from "./init/prompt.js"
 import { errorMessage } from "./utils/errors.js"
+import { pluralise } from "./utils/format.js"
 import { createLogger } from "./utils/logger.js"
 import { detectPackageManager, readPackageJson, readScripts } from "./utils/packageManager.js"
 import { tildify } from "./utils/paths.js"
@@ -240,3 +247,163 @@ export function formatEnvironment(snapshot: EnvironmentSnapshot): string {
   }
   return `${lines.join("\n")}\n`
 }
+
+// ---------------------------------------------------------------------------
+// devcc config check
+// ---------------------------------------------------------------------------
+
+/** Everything wrong with a loaded config, including verify names that resolve to nothing. */
+export function configProblems(rootDir: string, loaded: LoadedConfig): string[] {
+  const packageJson = readPackageJson(rootDir)
+  const { issues } = resolveVerifySteps(loaded.config.verify, {
+    commands: loaded.config.commands,
+    scripts: readScripts(packageJson),
+    packageManager: detectPackageManager({ rootDir, packageJson }).manager,
+  })
+  return [...loaded.issues, ...issues]
+}
+
+function configSummary(loaded: LoadedConfig) {
+  const { config } = loaded
+  return {
+    processes: config.processes.length,
+    commands: config.commands.length,
+    verify: config.verify.length,
+    services: config.services.length,
+    remoteMachines: config.remoteMachines.length,
+  }
+}
+
+export async function configCheckCommand(options: AutomationOptions): Promise<number> {
+  const io = options.io ?? processIo
+  const loaded = await loadConfig(options.rootDir)
+  if (!loaded.filePath) {
+    const issue = "No devcc config found (run `devcc init` to create .devcc.ts)"
+    if (options.json) printJson(io, { ok: false, file: null, issues: [issue] })
+    else io.stderr(`devcc config check: ${issue}\n`)
+    return EXIT_FAILED
+  }
+
+  const problems = configProblems(options.rootDir, loaded)
+  const summary = configSummary(loaded)
+  if (options.json) {
+    printJson(io, { ok: problems.length === 0, file: loaded.filePath, issues: problems, summary })
+  } else if (problems.length > 0) {
+    io.stderr(`✗ ${basename(loaded.filePath)} has ${problems.length} issue(s):\n`)
+    for (const problem of problems) io.stderr(`  - ${problem}\n`)
+  } else {
+    const labels: Record<keyof typeof summary, [string, string]> = {
+      processes: ["process", "processes"],
+      commands: ["command", "commands"],
+      verify: ["verify step", "verify steps"],
+      services: ["service", "services"],
+      remoteMachines: ["remote machine", "remote machines"],
+    }
+    const parts = (Object.entries(summary) as [keyof typeof summary, number][])
+      .filter(([, count]) => count > 0)
+      .map(([field, count]) => pluralise(count, ...labels[field]))
+    io.stdout(`✓ ${basename(loaded.filePath)} is valid${parts.length > 0 ? `: ${parts.join(", ")}` : ""}\n`)
+  }
+  return problems.length === 0 ? EXIT_OK : EXIT_FAILED
+}
+
+// ---------------------------------------------------------------------------
+// devcc init
+// ---------------------------------------------------------------------------
+
+export interface InitOptions extends AutomationOptions {
+  /** Replace an existing .devcc.ts with the starter. */
+  force?: boolean
+  /** Print the agent setup prompt instead of writing anything. */
+  printPrompt?: boolean
+  /** Start this agent interactively with the setup prompt. */
+  agent?: string
+  /** Injected for tests. */
+  isTTY?: boolean
+  runInteractive?: (command: string, args: string[], cwd: string) => Promise<number>
+}
+
+function runInteractive(command: string, args: string[], cwd: string): Promise<number> {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, { cwd, stdio: "inherit" })
+    child.once("error", (error) => {
+      process.stderr.write(`devcc init: could not start ${command}: ${error.message}\n`)
+      resolve(EXIT_FAILED)
+    })
+    child.once("exit", (code) => resolve(code ?? EXIT_FAILED))
+  })
+}
+
+/**
+ * `devcc init`: write a starter .devcc.ts from what can be detected.
+ * `--prompt` prints the agent setup prompt; `--agent <id>` opens that agent
+ * interactively with it, so the user watches and approves its edits.
+ */
+export async function initCommand(options: InitOptions): Promise<number> {
+  const io = options.io ?? processIo
+  const { rootDir } = options
+  const facts = detectProject(rootDir)
+
+  if (options.printPrompt) {
+    io.stdout(buildSetupPrompt(facts, "write"))
+    return EXIT_OK
+  }
+
+  if (options.agent) {
+    const loaded = await loadConfig(rootDir)
+    const adapters = createAgentAdapters(loaded.config.agents)
+    const adapter = adapters.find((candidate) => candidate.id === options.agent)
+    if (!adapter?.interactiveArgs) {
+      const available = adapters
+        .filter((candidate) => candidate.interactiveArgs)
+        .map((candidate) => candidate.id)
+      io.stderr(`devcc init: --agent must be one of: ${available.join(", ")}\n`)
+      return EXIT_USAGE
+    }
+    if (!(options.isTTY ?? process.stdout.isTTY)) {
+      io.stderr(
+        "devcc init --agent needs an interactive terminal. Use `devcc init --prompt` to get the prompt instead.\n",
+      )
+      return EXIT_USAGE
+    }
+    if (!(await adapter.detect())) {
+      io.stderr(`devcc init: ${adapter.name} is not installed (\`${adapter.command}\` was not found)\n`)
+      return EXIT_FAILED
+    }
+    io.stdout(`Starting ${adapter.name} to set up devcc for ${facts.name}…\n`)
+    const run = options.runInteractive ?? runInteractive
+    return run(adapter.command, adapter.interactiveArgs(buildSetupPrompt(facts, "write")), rootDir)
+  }
+
+  if (facts.configPath && !options.force) {
+    io.stderr(
+      `devcc init: ${basename(facts.configPath)} already exists.\n` +
+        "  Improve it with an agent:  devcc init --agent claude   (or codex)\n" +
+        "  Replace it with a starter: devcc init --force\n",
+    )
+    return EXIT_USAGE
+  }
+
+  const target = join(rootDir, ".devcc.ts")
+  writeFileSync(target, renderStarterConfig(facts), "utf8")
+  const loaded = await loadConfigFile(target)
+  const problems = configProblems(rootDir, loaded)
+  const starter = starterConfig(facts)
+
+  io.stdout(`Created ${tildify(target)}\n`)
+  if (facts.configPath && facts.configPath !== target) {
+    io.stdout(`  note: .devcc.ts takes precedence over ${basename(facts.configPath)}, which is now ignored\n`)
+  }
+  io.stdout(
+    `  processes: ${starter.processes.map((entry) => entry.name).join(", ") || "none detected"}\n` +
+      `  verify:    ${starter.verify.map((entry) => (typeof entry === "string" ? entry : entry.id)).join(", ") || "none detected"}\n`,
+  )
+  for (const problem of problems) io.stderr(`  ⚠ ${problem}\n`)
+  io.stdout(
+    "\nNext:\n" +
+      "  devcc init --agent claude   let an agent read the project and refine it (or codex)\n" +
+      "  devcc init --prompt         print that prompt for any other agent\n" +
+      "  devcc config check          validate after editing\n",
+  )
+  return problems.length === 0 ? EXIT_OK : EXIT_FAILED
+}

package/src/devcc/cli.ts

@@ -10,7 +10,14 @@
 import { createRequire } from "node:module"
 import { resolve } from "node:path"
 import { pathToFileURL } from "node:url"
-import { envCommand, EXIT_USAGE, verifyCommand, worktreeListCommand } from "./automation.js"
+import {
+  configCheckCommand,
+  envCommand,
+  EXIT_USAGE,
+  initCommand,
+  verifyCommand,
+  worktreeListCommand,
+} from "./automation.js"
 import { errorMessage } from "./utils/errors.js"
 import { findProjectRoot } from "./utils/paths.js"
 
@@ -19,6 +26,9 @@ interface CliArgs {
   help: boolean
   version: boolean
   json: boolean
+  force: boolean
+  prompt: boolean
+  agent?: string
   /** Subcommand and its arguments, e.g. `["worktree", "list"]`. */
   positionals: string[]
 }
@@ -41,12 +51,25 @@ function readVersion(): string {
 const VERSION = readVersion()
 
 function parseArgs(argv: readonly string[]): CliArgs {
-  const args: CliArgs = { help: false, version: false, json: false, positionals: [] }
+  const args: CliArgs = {
+    help: false,
+    version: false,
+    json: false,
+    force: false,
+    prompt: false,
+    positionals: [],
+  }
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index]
     if (arg === "--help" || arg === "-h") args.help = true
     else if (arg === "--version" || arg === "-v") args.version = true
     else if (arg === "--json") args.json = true
+    else if (arg === "--force") args.force = true
+    else if (arg === "--prompt") args.prompt = true
+    else if (arg === "--agent") {
+      args.agent = argv[index + 1]
+      index += 1
+    } else if (arg?.startsWith("--agent=")) args.agent = arg.slice("--agent=".length)
     else if (arg === "--cwd" || arg === "-C") {
       const value = argv[index + 1]
       if (value) {
@@ -69,10 +92,15 @@ Usage:
   devcc verify [--json]           Run the project's verify steps; exit 0 only if all pass
   devcc worktree list [--json]    List git worktrees
   devcc env [--json]              Report tools, mise runtimes and direnv status
+  devcc init                      Write a starter .devcc.ts from what is detected
+  devcc init --agent <claude|codex>  Let an agent inspect the project and set up .devcc.ts
+  devcc init --prompt             Print that setup prompt for any other agent
+  devcc config check [--json]     Validate the project's devcc config
 
 Options:
   -C, --cwd <dir>   Project directory (default: nearest project root)
-      --json        Machine-readable output (verify, worktree list, env)
+      --json        Machine-readable output (verify, worktree list, env, config check)
+      --force       init: replace an existing .devcc.ts
   -h, --help        Show this help
   -v, --version     Show the version
 
@@ -105,6 +133,10 @@ export async function main(argv: readonly string[] = process.argv.slice(2)): Pro
     if (command === "verify" && rest.length === 0) return runVerifyCli(options)
     if (command === "worktree" && rest.length === 1 && rest[0] === "list") return worktreeListCommand(options)
     if (command === "env" && rest.length === 0) return envCommand(options)
+    if (command === "init" && rest.length === 0) {
+      return initCommand({ ...options, force: args.force, printPrompt: args.prompt, agent: args.agent })
+    }
+    if (command === "config" && rest.length === 1 && rest[0] === "check") return configCheckCommand(options)
     process.stderr.write(`devcc: unknown command "${args.positionals.join(" ")}"\n\n${USAGE}`)
     return EXIT_USAGE
   }

package/src/devcc/core/commands.ts

@@ -69,6 +69,14 @@ export interface CommandContext {
   remoteMachines: () => RemoteMachineConfig[]
   /** Open an interactive SSH session in a terminal. */
   sshTo: (machineId: string) => Promise<void>
+  /**
+   * Set up `.devcc.ts`: `"starter"` writes the detected starter; an agent id
+   * asks that agent to inspect the project and propose one, which devcc
+   * validates and writes only after confirmation.
+   */
+  setUpConfig: (how: "starter" | (string & {})) => Promise<void>
+  /** Re-read the config, rebuilding the project session (confirms if processes run). */
+  reloadConfig: () => Promise<void>
   quit: () => void
 }
 

package/src/devcc/core/config.ts

@@ -411,7 +411,11 @@ export interface LoadedConfig extends ValidationResult {
 export async function loadConfig(rootDir: string): Promise<LoadedConfig> {
   const filePath = findConfigFile(rootDir)
   if (!filePath) return { filePath: null, config: { ...EMPTY_CONFIG }, issues: [] }
+  return loadConfigFile(filePath)
+}
 
+/** Load and validate one specific config file (e.g. a proposed config before it is written). */
+export async function loadConfigFile(filePath: string): Promise<LoadedConfig> {
   try {
     const raw = await importConfigModule(filePath)
     const result = validateConfig(raw)

package/src/devcc/index.ts

@@ -17,7 +17,15 @@ export {
   type AgentLaunchOptions,
   type AgentSession,
 } from "./agents/agents.js"
-export { envCommand, verifyCommand, worktreeListCommand } from "./automation.js"
+export {
+  configCheckCommand,
+  envCommand,
+  initCommand,
+  verifyCommand,
+  worktreeListCommand,
+} from "./automation.js"
+export { detectProject, renderStarterConfig, starterConfig, type ProjectFacts } from "./init/detect.js"
+export { buildSetupPrompt, extractConfigFromOutput, type SetupPromptMode } from "./init/prompt.js"
 export { createBuiltinCommands, createConfigCommands, createScriptCommands } from "./app/builtinCommands.js"
 export { HELP_SECTIONS, VIEW_SHORTCUTS } from "./app/keymap.js"
 export { theme, glyphs, processStatusStyle, serviceStateStyle } from "./app/theme.js"
@@ -28,6 +36,7 @@ export {
   loadConfig,
   validateConfig,
   findConfigFile,
+  loadConfigFile,
   CONFIG_FILENAMES,
   DEFAULT_REFRESH,
   type CommandConfigEntry,