@dylanrussell/agent-router 1.0.0

package/dist/tui.js

@@ -0,0 +1,1048 @@
+// src/core/config.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import path2 from "path";
+
+// src/core/errors.ts
+var RouterError = class extends Error {
+  /** CLI exit code for this error class. Subclasses override. */
+  static exitCode = 1;
+  name = "RouterError";
+};
+var StackNotFoundError = class extends RouterError {
+  constructor(stackName, available) {
+    super(
+      `Stack "${stackName}" not found. Available: ${available.length ? available.join(", ") : "(none)"}.`
+    );
+    this.stackName = stackName;
+    this.available = available;
+  }
+  stackName;
+  available;
+  static exitCode = 2;
+  name = "StackNotFoundError";
+};
+var AgentFileError = class extends RouterError {
+  constructor(agentName, filePath, reason) {
+    super(`Agent "${agentName}" (${filePath}): ${reason}`);
+    this.agentName = agentName;
+    this.filePath = filePath;
+  }
+  agentName;
+  filePath;
+  static exitCode = 2;
+  name = "AgentFileError";
+};
+var ValidationError = class extends RouterError {
+  constructor(message, path8, issues) {
+    super(message);
+    this.path = path8;
+    this.issues = issues;
+  }
+  path;
+  issues;
+  static exitCode = 4;
+  name = "ValidationError";
+};
+var ModelValidationError = class extends RouterError {
+  constructor(stackName, missing) {
+    super(
+      `Stack "${stackName}" references ${missing.length} unreachable model ID${missing.length === 1 ? "" : "s"}.`
+    );
+    this.stackName = stackName;
+    this.missing = missing;
+  }
+  stackName;
+  missing;
+  static exitCode = 4;
+  name = "ModelValidationError";
+};
+var IOError = class extends RouterError {
+  static exitCode = 3;
+  name = "IOError";
+  causedBy;
+  constructor(message, causedBy) {
+    super(message);
+    this.causedBy = causedBy;
+  }
+};
+var UserError = class extends RouterError {
+  static exitCode = 1;
+  name = "UserError";
+};
+
+// src/core/paths.ts
+import { homedir } from "os";
+import path from "path";
+function resolvePaths(options = {}) {
+  const env = options.env ?? process.env;
+  const opencodeConfigDir = options.opencodeConfigDir ?? path.join(env.XDG_CONFIG_HOME ?? path.join(homedir(), ".config"), "opencode");
+  const routerHome = options.routerHome ?? env.AGENT_ROUTER_HOME ?? env.OMO_ROUTER_HOME ?? path.join(opencodeConfigDir, "agent-router");
+  const agentsDir = options.agentsDir ?? env.AGENT_ROUTER_AGENTS_DIR ?? path.join(opencodeConfigDir, "agents");
+  const stacksDir = options.stacksDir ?? env.AGENT_ROUTER_STACKS_DIR ?? path.join(routerHome, "stacks");
+  return {
+    opencodeConfigDir,
+    opencodeJsonPath: path.join(opencodeConfigDir, "opencode.json"),
+    tuiJsonPath: path.join(opencodeConfigDir, "tui.json"),
+    agentsDir,
+    opencodeBackupsDir: path.join(opencodeConfigDir, ".backups"),
+    routerHome,
+    statePath: path.join(routerHome, "state.json"),
+    stacksDir,
+    historyDir: path.join(routerHome, "history")
+  };
+}
+
+// src/core/schema.ts
+import { z } from "zod";
+var StateFileSchema = z.object({
+  version: z.literal(1),
+  active: z.string().min(1),
+  previousActive: z.string().min(1).nullable(),
+  lastSwitchedAt: z.string().min(1)
+}).strict();
+var AgentEntrySchema = z.object({
+  model: z.string().min(1)
+}).passthrough();
+var StackFileSchema = z.object({
+  agents: z.record(z.string(), AgentEntrySchema)
+}).passthrough().refine((s) => Object.keys(s.agents).length > 0, {
+  message: "Stack file must map at least one agent in `agents`."
+});
+var ConfigFileSchema = z.object({
+  /** Where the agent .md files live. Default: `${opencodeConfigDir}/agents`. */
+  agentsDir: z.string().min(1).optional(),
+  /** Where named stacks live. Default: `${routerHome}/stacks`. */
+  stacksDir: z.string().min(1).optional()
+}).strict();
+var OpencodeJsonSchema = z.object({
+  plugin: z.array(z.string()).optional()
+}).passthrough();
+
+// src/core/config.ts
+var CONFIG_FILE_NAME = "config.json";
+function expandHome(p) {
+  if (p === "~") return homedir2();
+  if (p.startsWith("~/")) return path2.join(homedir2(), p.slice(2));
+  return p;
+}
+async function readConfigFile(routerHome) {
+  const configPath = path2.join(routerHome, CONFIG_FILE_NAME);
+  if (!existsSync(configPath)) return null;
+  let raw;
+  try {
+    raw = await readFile(configPath, "utf8");
+  } catch (cause) {
+    throw new IOError(`Failed to read ${configPath}: ${cause.message}`, cause);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (cause) {
+    throw new ValidationError(
+      `agent-router config.json is not valid JSON: ${cause.message}`,
+      configPath
+    );
+  }
+  const result = ConfigFileSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new ValidationError(
+      `agent-router config.json failed validation: ${result.error.issues.map((i) => i.message).join("; ")}`,
+      configPath,
+      result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`)
+    );
+  }
+  return result.data;
+}
+function normalizeConfigPath(routerHome, p) {
+  const expanded = expandHome(p);
+  return path2.isAbsolute(expanded) ? expanded : path2.resolve(routerHome, expanded);
+}
+async function resolvePathsWithConfig(options = {}) {
+  const base = resolvePaths(options);
+  const config = await readConfigFile(base.routerHome);
+  if (!config) return base;
+  const next = { ...options };
+  if (options.agentsDir === void 0 && config.agentsDir) {
+    next.agentsDir = normalizeConfigPath(
+      base.routerHome,
+      config.agentsDir
+    );
+  }
+  if (options.stacksDir === void 0 && config.stacksDir) {
+    next.stacksDir = normalizeConfigPath(
+      base.routerHome,
+      config.stacksDir
+    );
+  }
+  return resolvePaths(next);
+}
+
+// src/core/atomic-write.ts
+import { randomBytes } from "crypto";
+import { mkdir, realpath, rename, unlink, writeFile } from "fs/promises";
+import path3 from "path";
+async function resolveDestination(destPath) {
+  try {
+    return await realpath(destPath);
+  } catch {
+    try {
+      const dir = await realpath(path3.dirname(destPath));
+      return path3.join(dir, path3.basename(destPath));
+    } catch {
+      return destPath;
+    }
+  }
+}
+async function atomicWriteFile(destPath, contents) {
+  await mkdir(path3.dirname(destPath), { recursive: true });
+  const dest = await resolveDestination(destPath);
+  const dir = path3.dirname(dest);
+  const tmp = path3.join(
+    dir,
+    `.${path3.basename(dest)}.artmp-${process.pid}-${randomBytes(4).toString("hex")}`
+  );
+  try {
+    await writeFile(tmp, contents, { encoding: "utf8", mode: 420 });
+    await rename(tmp, dest);
+  } catch (cause) {
+    await unlink(tmp).catch(() => {
+    });
+    throw new IOError(`Atomic write failed for ${destPath}: ${cause.message}`, cause);
+  }
+}
+async function atomicWriteJson(destPath, value) {
+  const text2 = `${JSON.stringify(value, null, 2)}
+`;
+  await atomicWriteFile(destPath, text2);
+}
+
+// src/core/stack-manager.ts
+import { existsSync as existsSync5 } from "fs";
+import { copyFile as copyFile2, mkdir as mkdir4, readFile as readFile4, readdir as readdir3, unlink as unlink3 } from "fs/promises";
+import path7 from "path";
+
+// src/core/frontmatter.ts
+import { existsSync as existsSync2 } from "fs";
+import { readFile as readFile2, readdir } from "fs/promises";
+import path4 from "path";
+var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
+var MODEL_LINE_RE = /^model:[ \t]*(.*)$/m;
+function cleanModelValue(raw) {
+  let v = raw;
+  const hash = v.search(/[ \t]#/);
+  if (hash >= 0) v = v.slice(0, hash);
+  v = v.trim();
+  if (v.startsWith('"') && v.endsWith('"') && v.length >= 2 || v.startsWith("'") && v.endsWith("'") && v.length >= 2) {
+    v = v.slice(1, -1);
+  }
+  return v;
+}
+function getFrontmatterModel(content) {
+  const fm = FRONTMATTER_RE.exec(content);
+  if (!fm?.[1]) return null;
+  const line = MODEL_LINE_RE.exec(fm[1]);
+  if (!line) return null;
+  const value = cleanModelValue(line[1] ?? "");
+  return value.length > 0 ? value : null;
+}
+function setFrontmatterModel(content, model) {
+  const fm = FRONTMATTER_RE.exec(content);
+  if (!fm?.[1]) throw new Error("no frontmatter block");
+  const block = fm[1];
+  if (!MODEL_LINE_RE.test(block)) throw new Error("no `model:` line in frontmatter");
+  const nextBlock = block.replace(MODEL_LINE_RE, () => `model: ${model}`);
+  const blockStart = fm[0].indexOf(block);
+  const nextFm = fm[0].slice(0, blockStart) + nextBlock + fm[0].slice(blockStart + block.length);
+  return nextFm + content.slice(fm[0].length);
+}
+function agentFilePath(agentsDir, name) {
+  return path4.join(agentsDir, `${name}.md`);
+}
+async function listAgentFiles(agentsDir) {
+  if (!existsSync2(agentsDir)) return [];
+  let names;
+  try {
+    names = await readdir(agentsDir);
+  } catch (cause) {
+    throw new IOError(`Failed to read agents dir: ${cause.message}`, cause);
+  }
+  return names.filter((n) => n.endsWith(".md")).map((n) => n.slice(0, -".md".length)).sort();
+}
+async function readAgentModels(agentsDir) {
+  const out = {};
+  for (const name of await listAgentFiles(agentsDir)) {
+    const filePath = agentFilePath(agentsDir, name);
+    let content;
+    try {
+      content = await readFile2(filePath, "utf8");
+    } catch (cause) {
+      throw new IOError(`Failed to read ${filePath}: ${cause.message}`, cause);
+    }
+    const model = getFrontmatterModel(content);
+    if (model !== null) out[name] = model;
+  }
+  return out;
+}
+async function readAgentFileStrict(agentsDir, name) {
+  const filePath = agentFilePath(agentsDir, name);
+  if (!existsSync2(filePath)) {
+    throw new AgentFileError(name, filePath, "file does not exist");
+  }
+  let content;
+  try {
+    content = await readFile2(filePath, "utf8");
+  } catch (cause) {
+    throw new IOError(`Failed to read ${filePath}: ${cause.message}`, cause);
+  }
+  const model = getFrontmatterModel(content);
+  if (model === null) {
+    throw new AgentFileError(name, filePath, "no frontmatter `model:` line to rewrite");
+  }
+  return { filePath, content, model };
+}
+
+// src/core/history.ts
+import { mkdir as mkdir3, readdir as readdir2, unlink as unlink2 } from "fs/promises";
+import path6 from "path";
+
+// src/core/backups.ts
+import { existsSync as existsSync3 } from "fs";
+import { copyFile, mkdir as mkdir2 } from "fs/promises";
+import path5 from "path";
+function timestampStamp(date = /* @__PURE__ */ new Date()) {
+  return date.toISOString().replace(/[:.]/g, "-");
+}
+
+// src/core/history.ts
+function filename(fromStack, toStack, when = /* @__PURE__ */ new Date()) {
+  const stamp = timestampStamp(when);
+  const safe = (s) => s.replace(/[^A-Za-z0-9._()-]/g, "_");
+  return `${stamp}__${safe(fromStack)}-to-${safe(toStack)}.json`;
+}
+function parseHistoryFilename(name) {
+  if (!name.endsWith(".json")) return null;
+  const stem = name.slice(0, -".json".length);
+  const sep = stem.indexOf("__");
+  if (sep < 0) return null;
+  const stamp = stem.slice(0, sep);
+  const rest = stem.slice(sep + 2);
+  const toIdx = rest.lastIndexOf("-to-");
+  if (toIdx < 0) return null;
+  return {
+    id: stem,
+    timestamp: stamp,
+    fromStack: rest.slice(0, toIdx),
+    toStack: rest.slice(toIdx + "-to-".length)
+  };
+}
+async function appendHistory(historyDir, fromStack, toStack, displacedContent) {
+  await mkdir3(historyDir, { recursive: true });
+  const name = filename(fromStack, toStack);
+  await atomicWriteFile(path6.join(historyDir, name), displacedContent);
+  return name.slice(0, -".json".length);
+}
+async function listHistory(historyDir) {
+  let names;
+  try {
+    names = await readdir2(historyDir);
+  } catch (cause) {
+    if (cause.code === "ENOENT") return [];
+    throw new IOError(`Failed to read history dir: ${cause.message}`, cause);
+  }
+  const entries = [];
+  for (const n of names) {
+    const parsed = parseHistoryFilename(n);
+    if (parsed) entries.push({ ...parsed, path: path6.join(historyDir, n) });
+  }
+  entries.sort((a, b) => a.timestamp < b.timestamp ? 1 : a.timestamp > b.timestamp ? -1 : 0);
+  return entries;
+}
+async function trimHistory(historyDir, keep = 20) {
+  const all = await listHistory(historyDir);
+  if (all.length <= keep) return [];
+  const toDelete = all.slice(keep);
+  const deleted = [];
+  for (const e of toDelete) {
+    try {
+      await unlink2(e.path);
+      deleted.push(e.id);
+    } catch (cause) {
+      void cause;
+    }
+  }
+  return deleted;
+}
+
+// src/core/state.ts
+import { existsSync as existsSync4 } from "fs";
+import { readFile as readFile3 } from "fs/promises";
+async function readState(statePath) {
+  if (!existsSync4(statePath)) return null;
+  let raw;
+  try {
+    raw = await readFile3(statePath, "utf8");
+  } catch (cause) {
+    throw new IOError(`Failed to read ${statePath}: ${cause.message}`, cause);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (cause) {
+    throw new ValidationError(
+      `state.json is not valid JSON: ${cause.message}`,
+      statePath
+    );
+  }
+  const result = StateFileSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new ValidationError(
+      `state.json failed validation: ${result.error.issues.map((i) => i.message).join("; ")}`,
+      statePath,
+      result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`)
+    );
+  }
+  return result.data;
+}
+async function writeState(statePath, state) {
+  const result = StateFileSchema.safeParse(state);
+  if (!result.success) {
+    throw new ValidationError(
+      `Refusing to write invalid state.json: ${result.error.issues.map((i) => i.message).join("; ")}`,
+      statePath
+    );
+  }
+  await atomicWriteJson(statePath, result.data);
+}
+
+// src/core/validator.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var DEFAULT_RUNNER = async () => {
+  const { stdout } = await execFileAsync("opencode", ["models"], {
+    encoding: "utf8",
+    timeout: 3e4,
+    maxBuffer: 4 * 1024 * 1024
+  });
+  return stdout;
+};
+function parseModelList(stdout) {
+  const out = /* @__PURE__ */ new Set();
+  for (const raw of stdout.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line) continue;
+    if (line.startsWith("#")) continue;
+    out.add(line);
+  }
+  return out;
+}
+function collectModelRefs(stack) {
+  const refs = [];
+  for (const [k, v] of Object.entries(stack.agents)) {
+    refs.push({ path: `agents.${k}.model`, modelId: v.model });
+  }
+  return refs;
+}
+async function validateStack(stack, options = {}) {
+  const runner = options.runOpencodeModels ?? DEFAULT_RUNNER;
+  const stdout = await runner();
+  const available = parseModelList(stdout);
+  const refs = collectModelRefs(stack);
+  const missing = refs.filter((r) => !available.has(r.modelId));
+  return { ok: missing.length === 0, checked: refs.length, missing, available };
+}
+async function validateStackOrThrow(stackName, stack, options = {}) {
+  const result = await validateStack(stack, options);
+  if (!result.ok) throw new ModelValidationError(stackName, result.missing);
+  return result;
+}
+
+// src/core/stack-manager.ts
+async function listStacks(paths) {
+  if (!existsSync5(paths.stacksDir)) return [];
+  let names;
+  try {
+    names = await readdir3(paths.stacksDir);
+  } catch (cause) {
+    throw new IOError(`Failed to read stacks dir: ${cause.message}`, cause);
+  }
+  return names.filter((n) => n.endsWith(".json")).map((n) => n.slice(0, -".json".length)).sort();
+}
+function stackPath(paths, name) {
+  return path7.join(paths.stacksDir, `${name}.json`);
+}
+async function readStack(paths, name) {
+  const filePath = stackPath(paths, name);
+  if (!existsSync5(filePath)) {
+    throw new StackNotFoundError(name, await listStacks(paths));
+  }
+  const raw = await readFile4(filePath, "utf8").catch((cause) => {
+    throw new IOError(`Failed to read ${filePath}: ${cause.message}`, cause);
+  });
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (cause) {
+    throw new ValidationError(
+      `Stack "${name}" is not valid JSON: ${cause.message}`,
+      filePath
+    );
+  }
+  const result = StackFileSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new ValidationError(
+      `Stack "${name}" failed validation: ${result.error.issues.map((i) => i.message).join("; ")}`,
+      filePath,
+      result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`)
+    );
+  }
+  return result.data;
+}
+async function getActiveStackName(paths) {
+  const state = await readState(paths.statePath);
+  return state?.active ?? null;
+}
+async function applyStack(paths, name, options = {}) {
+  const validate = options.validate ?? true;
+  const forceInvalid = options.forceInvalid ?? false;
+  const target = await readStack(paths, name);
+  if (validate && !forceInvalid) {
+    await validateStackOrThrow(name, target, options.validateOptions);
+  }
+  const pending = [];
+  for (const [agent, entry] of Object.entries(target.agents)) {
+    const { filePath, content, model } = await readAgentFileStrict(paths.agentsDir, agent);
+    pending.push({
+      agent,
+      filePath,
+      next: model === entry.model ? null : setFrontmatterModel(content, entry.model)
+    });
+  }
+  const prevState = await readState(paths.statePath);
+  const prevActive = prevState?.active ?? null;
+  const displaced = { agents: modelsToStackAgents(await readAgentModels(paths.agentsDir)) };
+  const historyId = await appendHistory(
+    paths.historyDir,
+    prevActive ?? "(none)",
+    name,
+    `${JSON.stringify(displaced, null, 2)}
+`
+  );
+  const changed = [];
+  for (const p of pending) {
+    if (p.next === null) continue;
+    await atomicWriteFile(p.filePath, p.next);
+    changed.push(p.agent);
+  }
+  await writeState(paths.statePath, {
+    version: 1,
+    active: name,
+    previousActive: prevActive,
+    lastSwitchedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  await trimHistory(paths.historyDir).catch(() => {
+  });
+  return {
+    previous: prevActive,
+    current: name,
+    changed,
+    historyId,
+    restartRequired: true
+  };
+}
+function modelsToStackAgents(models) {
+  const out = {};
+  for (const k of Object.keys(models).sort()) {
+    const model = models[k];
+    if (model !== void 0) out[k] = { model };
+  }
+  return out;
+}
+async function back(paths, n = 1, options = {}) {
+  if (n < 1) throw new UserError("`back -n` must be at least 1.");
+  const state = await readState(paths.statePath);
+  if (!state || !state.previousActive) {
+    throw new UserError("No previous stack to revert to.");
+  }
+  if (n === 1) return applyStack(paths, state.previousActive, options);
+  const entries = await listHistory(paths.historyDir);
+  if (entries.length < n) {
+    throw new UserError(
+      `Cannot go back ${n} steps; only ${entries.length} switch${entries.length === 1 ? "" : "es"} in history.`
+    );
+  }
+  const target = entries[n - 1]?.fromStack;
+  if (!target || target === "(none)") {
+    throw new UserError(`Cannot go back ${n} steps to a non-stack target ("${target}").`);
+  }
+  return applyStack(paths, target, options);
+}
+
+// src/tui/actions.ts
+function targetLabel(target) {
+  return target.agent;
+}
+function listModelTargets(stack) {
+  return Object.entries(stack.agents).map(([agent, entry]) => ({
+    agent,
+    model: entry.model
+  }));
+}
+function applyModelEdit(stack, agent, model) {
+  const entry = stack.agents[agent];
+  if (!entry) {
+    throw new Error(`No entry "${agent}" in stack`);
+  }
+  return {
+    ...stack,
+    agents: {
+      ...stack.agents,
+      [agent]: { ...entry, model }
+    }
+  };
+}
+function collectHostModels(providers) {
+  if (!Array.isArray(providers)) return [];
+  const out = /* @__PURE__ */ new Set();
+  for (const provider of providers) {
+    if (typeof provider !== "object" || provider === null) continue;
+    const record = provider;
+    const id = typeof record.id === "string" ? record.id : void 0;
+    if (!id) continue;
+    const models = record.models;
+    if (Array.isArray(models)) {
+      for (const m of models) {
+        if (typeof m === "string") out.add(`${id}/${m}`);
+        else if (typeof m === "object" && m !== null) {
+          const mid = m.id;
+          if (typeof mid === "string") out.add(`${id}/${mid}`);
+        }
+      }
+    } else if (typeof models === "object" && models !== null) {
+      for (const key of Object.keys(models)) out.add(`${id}/${key}`);
+    }
+  }
+  return [...out].sort();
+}
+
+// src/tui/dialogs.ts
+function canOpenDialogs(api) {
+  return Boolean(api.ui.DialogSelect && api.ui.dialog);
+}
+function toastError(api, e) {
+  api.ui.toast({
+    title: "agent-router",
+    message: e.message ?? String(e),
+    variant: "error"
+  });
+}
+function openSelect(api, props) {
+  const { DialogSelect, dialog } = api.ui;
+  if (!DialogSelect || !dialog) return;
+  dialog.replace(() => DialogSelect(props));
+}
+async function pickStack(deps, title, onPick) {
+  const [stacks, active] = await Promise.all([
+    listStacks(deps.paths),
+    getActiveStackName(deps.paths)
+  ]);
+  if (stacks.length === 0) {
+    deps.api.ui.toast({
+      title: "agent-router",
+      message: "No stacks found \u2014 run `agent-router init` first.",
+      variant: "warning"
+    });
+    return;
+  }
+  const options = stacks.map((name) => ({
+    title: name,
+    value: name,
+    description: name === active ? "\u25CF active" : void 0,
+    onSelect: () => onPick(name, active)
+  }));
+  openSelect(deps.api, { title, options, current: active ?? void 0 });
+}
+function openStackSwitcher(deps) {
+  void pickStack(deps, "Switch stack", (name, active) => {
+    deps.api.ui.dialog?.clear();
+    if (name === active) {
+      deps.api.ui.toast({ title: "agent-router", message: `"${name}" is already active` });
+      return;
+    }
+    deps.api.ui.toast({ title: "agent-router", message: `validating & switching to "${name}"\u2026` });
+    applyStack(deps.paths, name, { validate: true }).then((r) => {
+      deps.refresh();
+      deps.api.ui.toast({
+        title: "agent-router",
+        message: `switched to "${r.current}" \u2014 restart opencode to apply`,
+        variant: "success"
+      });
+    }).catch((e) => toastError(deps.api, e));
+  }).catch((e) => toastError(deps.api, e));
+}
+function openStackViewer(deps) {
+  void pickStack(deps, "View stack", (name) => {
+    readStack(deps.paths, name).then((stack) => {
+      const rows = listModelTargets(stack);
+      const options = rows.map((row) => ({
+        title: targetLabel(row),
+        value: targetLabel(row),
+        description: row.model,
+        onSelect: () => deps.api.ui.dialog?.clear()
+      }));
+      openSelect(deps.api, { title: `stack: ${name}`, options });
+    }).catch((e) => toastError(deps.api, e));
+  }).catch((e) => toastError(deps.api, e));
+}
+function openStackEditor(deps) {
+  void pickStack(deps, "Edit stack", (name) => {
+    readStack(deps.paths, name).then((stack) => {
+      const rows = listModelTargets(stack);
+      const options = rows.map((row) => ({
+        title: targetLabel(row),
+        value: targetLabel(row),
+        description: row.model,
+        onSelect: () => openModelPicker(deps, name, row)
+      }));
+      openSelect(deps.api, { title: `edit ${name}: pick agent`, options });
+    }).catch((e) => toastError(deps.api, e));
+  }).catch((e) => toastError(deps.api, e));
+}
+function openModelPicker(deps, stackName, row) {
+  const models = collectHostModels(deps.api.state?.provider);
+  if (models.length === 0) {
+    deps.api.ui.dialog?.clear();
+    deps.api.ui.toast({
+      title: "agent-router",
+      message: "Model catalog unavailable \u2014 edit the stack file via `agent-router edit` instead.",
+      variant: "warning"
+    });
+    return;
+  }
+  const options = models.map((id) => ({
+    title: id,
+    value: id,
+    onSelect: () => {
+      deps.api.ui.dialog?.clear();
+      saveModelEdit(deps, stackName, row, id).catch((e) => toastError(deps.api, e));
+    }
+  }));
+  openSelect(deps.api, {
+    title: `edit ${stackName}: ${targetLabel(row)}`,
+    options,
+    current: row.model
+  });
+}
+async function saveModelEdit(deps, stackName, row, model) {
+  const stack = await readStack(deps.paths, stackName);
+  const edited = StackFileSchema.parse(applyModelEdit(stack, row.agent, model));
+  await atomicWriteJson(stackPath(deps.paths, stackName), edited);
+  deps.refresh();
+  const active = await getActiveStackName(deps.paths);
+  const hint = active === stackName ? ` \u2014 run \`agent-router use ${stackName}\` + restart to apply to the agent files` : "";
+  deps.api.ui.toast({
+    title: "agent-router",
+    message: `${stackName}: ${targetLabel(row)} \u2192 ${model}${hint}`,
+    variant: "success"
+  });
+}
+function openBackConfirm(deps) {
+  readState(deps.paths.statePath).then((state) => {
+    if (!state?.previousActive) {
+      deps.api.ui.toast({ title: "agent-router", message: "No previous stack to revert to." });
+      return;
+    }
+    const { DialogConfirm, dialog } = deps.api.ui;
+    const revert = () => {
+      dialog?.clear();
+      back(deps.paths, 1).then((r) => {
+        deps.refresh();
+        deps.api.ui.toast({
+          title: "agent-router",
+          message: `reverted to "${r.current}" \u2014 restart opencode to apply`,
+          variant: "success"
+        });
+      }).catch((e) => toastError(deps.api, e));
+    };
+    if (!DialogConfirm || !dialog) {
+      revert();
+      return;
+    }
+    dialog.replace(
+      () => DialogConfirm({
+        title: "agent-router",
+        message: `Revert to "${state.previousActive}"?`,
+        onConfirm: revert,
+        onCancel: () => dialog.clear()
+      })
+    );
+  }).catch((e) => toastError(deps.api, e));
+}
+function openValidator(deps) {
+  void pickStack(deps, "Validate stack", (name) => {
+    deps.api.ui.dialog?.clear();
+    deps.api.ui.toast({ title: "agent-router", message: `validating "${name}"\u2026` });
+    readStack(deps.paths, name).then((stack) => validateStack(stack)).then((result) => {
+      if (result.ok) {
+        deps.api.ui.toast({
+          title: "agent-router",
+          message: `"${name}" ok \u2014 ${result.checked} model refs reachable`,
+          variant: "success"
+        });
+        return;
+      }
+      const sample = result.missing.slice(0, 3).map((m) => m.modelId).join(", ");
+      const extra = result.missing.length > 3 ? ` (+${result.missing.length - 3} more)` : "";
+      deps.api.ui.toast({
+        title: "agent-router",
+        message: `"${name}": ${result.missing.length} unreachable \u2014 ${sample}${extra}`,
+        variant: "warning"
+      });
+    }).catch((e) => toastError(deps.api, e));
+  }).catch((e) => toastError(deps.api, e));
+}
+
+// src/tui/render.ts
+function materialize(nodes, solid) {
+  const root = solid.createElement("box");
+  solid.setProp(root, "flexDirection", "column");
+  for (const node of nodes) {
+    solid.insert(root, materializeNode(node, solid));
+  }
+  return root;
+}
+function materializeNode(node, solid) {
+  const element = solid.createElement(node.kind);
+  for (const [name, value] of Object.entries(node.props)) {
+    if (value !== void 0) solid.setProp(element, name, value);
+  }
+  if (node.kind === "text") {
+    solid.insert(element, node.text ?? "");
+  }
+  for (const child of node.children ?? []) {
+    solid.insert(element, materializeNode(child, solid));
+  }
+  return element;
+}
+
+// src/tui/store.ts
+function snapshotKey(active, stacks) {
+  return `${active ?? "\0"}|${stacks.join(",")}`;
+}
+async function readStackSnapshot(paths) {
+  const [active, stacks] = await Promise.all([
+    getActiveStackName(paths).catch(() => null),
+    listStacks(paths).catch(() => [])
+  ]);
+  return { active, stacks, key: snapshotKey(active, stacks) };
+}
+function createSidebarPoller(options) {
+  const schedule = options.schedule ?? ((fn, ms) => setTimeout(fn, ms));
+  const cancel = options.cancel ?? ((handle) => clearTimeout(handle));
+  let current = options.initial;
+  let disposed = false;
+  let inFlight = false;
+  let timer;
+  const tick = async () => {
+    if (disposed) return;
+    if (inFlight) {
+      timer = schedule(tick, options.intervalMs);
+      return;
+    }
+    inFlight = true;
+    try {
+      const next = await options.read();
+      if (!disposed && next.key !== current.key) {
+        const prev = current;
+        current = next;
+        options.onChange(next, prev);
+      }
+    } catch {
+    } finally {
+      inFlight = false;
+      if (!disposed) timer = schedule(tick, options.intervalMs);
+    }
+  };
+  timer = schedule(tick, options.intervalMs);
+  return () => {
+    disposed = true;
+    if (timer !== void 0) cancel(timer);
+  };
+}
+
+// src/tui/view.ts
+function text(content, props = {}) {
+  return { kind: "text", props, text: content };
+}
+function restartRequired(snapshot, ctx) {
+  return snapshot.active !== ctx.bootActive;
+}
+function buildSidebarNodes(snapshot, ctx) {
+  const theme = ctx.theme ?? {};
+  const nodes = [
+    text("agent-router", { fg: theme.textMuted }),
+    text(` \u25A3 ${snapshot.active ?? "(none)"}`, { fg: theme.success })
+  ];
+  if (restartRequired(snapshot, ctx)) {
+    nodes.push(text(" \u27F3 restart required", { fg: theme.warning }));
+  }
+  nodes.push(
+    text(` ${snapshot.stacks.length} stack${snapshot.stacks.length === 1 ? "" : "s"}`, {
+      fg: theme.textMuted
+    })
+  );
+  return nodes;
+}
+
+// src/tui/index.ts
+var POLL_INTERVAL_MS = 1500;
+var SIDEBAR_ORDER = 850;
+function debugLog(message) {
+  const target = process.env.AGENT_ROUTER_TUI_DEBUG ?? process.env.OMO_TUI_DEBUG;
+  if (!target) return;
+  import("fs").then((fs) => fs.appendFileSync(target, `${(/* @__PURE__ */ new Date()).toISOString()} ${message}
+`)).catch(() => {
+  });
+}
+async function importHostSolid() {
+  try {
+    const mod = await import("@opentui/solid");
+    if (typeof mod.createElement !== "function") {
+      debugLog("solid module lacks createElement \u2014 treating as unavailable");
+      return null;
+    }
+    return mod;
+  } catch (e) {
+    debugLog(`solid import FAILED: ${e.message}`);
+    return null;
+  }
+}
+function buildCommands(api, deps, status) {
+  const commands = [
+    {
+      title: "agent-router: status",
+      value: "agent-router.status",
+      description: "Show the active agent-router stack",
+      category: "agent-router",
+      slash: { name: "agent-status" },
+      onSelect: status
+    }
+  ];
+  if (!canOpenDialogs(api)) return commands;
+  commands.push(
+    {
+      title: "agent-router: switch stack",
+      value: "agent-router.switch",
+      description: "Apply a different model stack to your agents",
+      category: "agent-router",
+      slash: { name: "agent-switch", aliases: ["ar"] },
+      onSelect: () => openStackSwitcher(deps)
+    },
+    {
+      title: "agent-router: view stack",
+      value: "agent-router.view",
+      description: "Inspect a stack's agent \u2192 model assignments",
+      category: "agent-router",
+      slash: { name: "agent-view" },
+      onSelect: () => openStackViewer(deps)
+    },
+    {
+      title: "agent-router: edit stack",
+      value: "agent-router.edit",
+      description: "Reassign a model inside a stack",
+      category: "agent-router",
+      slash: { name: "agent-edit" },
+      onSelect: () => openStackEditor(deps)
+    },
+    {
+      title: "agent-router: undo last switch",
+      value: "agent-router.back",
+      description: "Revert to the previously active stack",
+      category: "agent-router",
+      slash: { name: "agent-back" },
+      onSelect: () => openBackConfirm(deps)
+    },
+    {
+      title: "agent-router: validate stack",
+      value: "agent-router.validate",
+      description: "Check a stack's model IDs against reachable models",
+      category: "agent-router",
+      slash: { name: "agent-validate" },
+      onSelect: () => openValidator(deps)
+    }
+  );
+  return commands;
+}
+var tui = async (api) => {
+  debugLog("tui() entered");
+  const solid = await importHostSolid();
+  if (!solid) return;
+  const paths = await resolvePathsWithConfig().catch(() => null);
+  if (!paths) return;
+  let snapshot = await readStackSnapshot(paths);
+  const bootActive = snapshot.active;
+  const viewContext = () => ({ bootActive, theme: api.theme?.current });
+  try {
+    api.slots.register({
+      order: SIDEBAR_ORDER,
+      slots: {
+        sidebar_content: () => materialize(buildSidebarNodes(snapshot, viewContext()), solid)
+      }
+    });
+    debugLog("slots.register ok");
+  } catch (e) {
+    debugLog(`slots.register FAILED: ${e.message}`);
+    return;
+  }
+  api.renderer.requestRender();
+  const applySnapshot = (next) => {
+    snapshot = next;
+    api.renderer.requestRender();
+  };
+  const refresh = () => {
+    readStackSnapshot(paths).then(applySnapshot).catch(() => {
+    });
+  };
+  const stopPolling = createSidebarPoller({
+    read: () => readStackSnapshot(paths),
+    intervalMs: POLL_INTERVAL_MS,
+    initial: snapshot,
+    onChange: (next, prev) => {
+      applySnapshot(next);
+      if (next.active !== prev.active) {
+        const suffix = next.active === bootActive ? "" : " \u2014 restart opencode to apply";
+        api.ui.toast({
+          title: "agent-router",
+          message: `stack \u2192 ${next.active ?? "(none)"}${suffix}`,
+          variant: "info"
+        });
+      }
+    }
+  });
+  const deps = { api, paths, refresh };
+  const status = () => api.ui.toast({
+    title: "agent-router",
+    message: `active: ${snapshot.active ?? "(none)"} \xB7 stacks: ${snapshot.stacks.join(", ") || "(none)"}`,
+    variant: "info"
+  });
+  try {
+    api.command?.register(() => buildCommands(api, deps, status));
+    debugLog(`commands registered (dialogs=${canOpenDialogs(api)})`);
+  } catch (e) {
+    debugLog(`command.register FAILED: ${e.message}`);
+  }
+  api.lifecycle.onDispose(stopPolling);
+  debugLog(`tui() init complete \u2014 active=${snapshot.active ?? "(none)"}`);
+};
+var agentRouterTui = {
+  id: "agent-router:tui",
+  tui
+};
+var tui_default = agentRouterTui;
+export {
+  tui_default as default,
+  tui
+};
+//# sourceMappingURL=tui.js.map