@datalabrotterdam/nova-ai-cli 1.1.0 → 1.2.0-alpha.2

package/dist/chunk-NHGIUEIR.js

@@ -0,0 +1,754 @@
+// src/tui/settings/workspace-mcp.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+import { isWorkspaceTrusted } from "@datalabrotterdam/nova-ai-agent/core/nova-home.js";
+import { readSettings } from "@datalabrotterdam/nova-ai-agent/core/policy/settings.js";
+
+// src/tui/settings/workspace-settings.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+function settingsPath(cwd) {
+  return join(cwd, ".nova-ai", "settings.json");
+}
+function readWorkspaceSettings(cwd) {
+  try {
+    const raw = readFileSync(settingsPath(cwd), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+// src/tui/settings/workspace-mcp.ts
+var UNTRUSTED_MCP_MESSAGE = "Not started: MCP servers declared by this workspace only run once you trust it (/trust in the TUI, --trust-workspace headless).";
+function readWorkspaceMcpConfiguration(cwd, options = {}) {
+  const configured = readWorkspaceSettings(cwd).mcpServers ?? [];
+  const project = readProjectMcpConfiguration(cwd);
+  const servers = new Map(configured.map((server) => [server.name, server]));
+  for (const server of project.servers) servers.set(server.name, server);
+  const declared = [...servers.values()];
+  if (declared.length && !(options.trusted ?? isWorkspaceTrusted(cwd))) {
+    return {
+      servers: [],
+      failures: [
+        ...project.failures,
+        ...declared.map((server) => ({ serverName: server.name, message: UNTRUSTED_MCP_MESSAGE }))
+      ],
+      untrusted: declared.map((server) => server.name)
+    };
+  }
+  return { servers: declared, failures: project.failures };
+}
+function workspaceNeedsTrust(cwd) {
+  if (isWorkspaceTrusted(cwd)) return false;
+  if (readWorkspaceMcpConfiguration(cwd, { trusted: true }).servers.length) return true;
+  return loadWorkspaceAllowRules(cwd).length > 0;
+}
+function loadWorkspaceAllowRules(cwd) {
+  return ["settings.json", "settings.local.json"].flatMap((name) => {
+    const allow = readSettings(join2(cwd, ".nova-ai", name))?.permissions?.allow;
+    return Array.isArray(allow) ? allow : [];
+  });
+}
+function readProjectMcpConfiguration(cwd) {
+  const path = join2(cwd, ".mcp.json");
+  let raw;
+  try {
+    raw = readFileSync2(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return { servers: [], failures: [] };
+    return { servers: [], failures: [{ serverName: ".mcp.json", message: errorMessage(error, "Could not read file") }] };
+  }
+  let document;
+  try {
+    document = JSON.parse(raw);
+  } catch (error) {
+    return { servers: [], failures: [{ serverName: ".mcp.json", message: errorMessage(error, "Invalid JSON") }] };
+  }
+  const root = asRecord(document);
+  const definitions = root ? asRecord(root.mcpServers) : null;
+  if (!definitions) {
+    return {
+      servers: [],
+      failures: [{ serverName: ".mcp.json", message: 'Expected an "mcpServers" object.' }]
+    };
+  }
+  const servers = [];
+  const failures = [];
+  for (const [name, value] of Object.entries(definitions)) {
+    const config = asRecord(value);
+    if (config?.disabled === true || config?.enabled === false) continue;
+    try {
+      servers.push(normalizeProjectServer(name, config));
+    } catch (error) {
+      failures.push({ serverName: `.mcp.json:${name}`, message: errorMessage(error, "Invalid server configuration") });
+    }
+  }
+  return { servers, failures };
+}
+function normalizeProjectServer(name, config) {
+  if (!config) throw new Error("Server definition must be an object.");
+  const type = typeof config.type === "string" ? config.type : config.url ? "http" : "stdio";
+  if (type === "http" || type === "sse") {
+    if (typeof config.url !== "string" || !config.url) throw new Error(`${type} server requires a URL.`);
+    try {
+      new URL(config.url);
+    } catch {
+      throw new Error(`${type} server requires a valid URL.`);
+    }
+    return {
+      name,
+      type,
+      url: config.url,
+      headers: normalizePairs(config.headers, "headers")
+    };
+  }
+  if (type !== "stdio") throw new Error(`Unsupported transport type: ${type}.`);
+  if (typeof config.command !== "string" || !config.command) throw new Error("stdio server requires a command.");
+  if (config.args !== void 0 && (!Array.isArray(config.args) || !config.args.every((arg) => typeof arg === "string"))) {
+    throw new Error("args must be an array of strings.");
+  }
+  return {
+    name,
+    command: config.command,
+    args: config.args ?? [],
+    env: normalizePairs(config.env, "env")
+  };
+}
+function normalizePairs(value, label) {
+  if (value === void 0) return [];
+  if (Array.isArray(value)) {
+    if (!value.every((entry) => {
+      const pair = asRecord(entry);
+      return typeof pair?.name === "string" && typeof pair.value === "string";
+    })) {
+      throw new Error(`${label} must contain name/value strings.`);
+    }
+    return value.map((entry) => {
+      const pair = entry;
+      return { name: pair.name, value: pair.value };
+    });
+  }
+  const record = asRecord(value);
+  if (!record || !Object.values(record).every((entry) => typeof entry === "string")) {
+    throw new Error(`${label} must be an object of string values.`);
+  }
+  return Object.entries(record).map(([name, entry]) => ({ name, value: entry }));
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function errorMessage(error, fallback) {
+  return error instanceof Error && error.message ? `${fallback}: ${error.message}` : fallback;
+}
+
+// src/tui/session/tui-acp-client.ts
+import { NOVA_NOTIFICATIONS } from "@datalabrotterdam/nova-ai-agent/acp/extensions.js";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { dirname } from "path";
+import {
+  spawnCommand,
+  terminateProcessTree
+} from "@datalabrotterdam/nova-ai-agent/core/process-tree.js";
+import { resolveWorkspaceFile } from "@datalabrotterdam/nova-ai-agent/core/tools/workspace-paths.js";
+import {
+  isInteractionMode
+} from "@datalabrotterdam/nova-ai-agent/core/interaction-modes.js";
+import {
+  fromElicitationRequest,
+  toElicitationResponse
+} from "@datalabrotterdam/nova-ai-agent/acp/user-questions.js";
+var DEFAULT_OUTPUT_LIMIT = 1e5;
+var nextMessageId = 0;
+function uid() {
+  nextMessageId += 1;
+  return `m${nextMessageId}`;
+}
+var TuiAcpClient = class {
+  constructor(store, cwd, onBackgroundLifecycle, onInteractionModeChange) {
+    this.store = store;
+    this.cwd = cwd;
+    this.onBackgroundLifecycle = onBackgroundLifecycle;
+    this.onInteractionModeChange = onInteractionModeChange;
+  }
+  store;
+  cwd;
+  onBackgroundLifecycle;
+  onInteractionModeChange;
+  capabilities = {
+    fs: { readTextFile: true, writeTextFile: true },
+    terminal: true,
+    elicitation: { form: {} }
+  };
+  terminals = /* @__PURE__ */ new Map();
+  streamingMessageId = null;
+  nextTerminalId = 0;
+  /**
+   * Set while the runner loads a session whose transcript it restored itself;
+   * the agent's replay would show everything twice.
+   */
+  muteSessionUpdates = false;
+  /** The agent's latest prompt queue (from _nova/queue/changed or a response). */
+  queueSnapshot = [];
+  /** This client as the SDK's ACP Client, for a real (in-process) connection. */
+  asAcpClient() {
+    return {
+      sessionUpdate: (params) => this.muteSessionUpdates ? Promise.resolve() : this.sessionUpdate(params),
+      requestPermission: (params) => this.requestPermission(params),
+      readTextFile: (params) => this.readTextFile(params),
+      writeTextFile: async (params) => {
+        await this.writeTextFile(params);
+        return {};
+      },
+      createTerminal: (params) => this.createTerminal(params),
+      terminalOutput: (params) => this.terminalOutput(params),
+      waitForTerminalExit: (params) => this.waitForTerminalExit(params),
+      killTerminal: async (params) => {
+        await this.killTerminal(params);
+        return {};
+      },
+      releaseTerminal: async (params) => {
+        await this.releaseTerminal(params);
+        return {};
+      },
+      unstable_createElicitation: (params) => this.createElicitation(params),
+      extNotification: (method, params) => this.handleNotification(method, params)
+    };
+  }
+  context() {
+    return {
+      request: (method, params, options) => this.handleRequest(method, params, options),
+      notify: (method, params) => this.handleNotification(method, params)
+    };
+  }
+  resetStreaming() {
+    if (this.streamingMessageId) {
+      const id = this.streamingMessageId;
+      this.store.setState((state) => ({
+        messages: state.messages.map(
+          (message) => message.id === id && message.role === "assistant" ? { ...message, streaming: false } : message
+        )
+      }));
+    }
+    this.streamingMessageId = null;
+  }
+  appendUserMessage(text) {
+    this.appendMessage({ id: uid(), role: "user", text });
+  }
+  appendError(text) {
+    this.appendMessage({ id: uid(), role: "error", text });
+  }
+  failPendingTools(reason) {
+    let count = 0;
+    this.store.setState((state) => ({
+      messages: state.messages.map((message) => {
+        if (message.role !== "tool" || message.call.status !== "pending")
+          return message;
+        count++;
+        const output = message.call.output ? `${message.call.output.replace(/\s+$/, "")}
+${reason}` : reason;
+        return {
+          ...message,
+          call: { ...message.call, status: "failed", output }
+        };
+      })
+    }));
+    return count;
+  }
+  async releaseAllTerminals() {
+    await Promise.all(
+      [...this.terminals.keys()].map(
+        (terminalId) => this.releaseTerminal({
+          sessionId: this.store.getState().sessionId,
+          terminalId
+        })
+      )
+    );
+  }
+  async readTextFile(params) {
+    let content = await readFile(await this.confine(params.path), "utf8");
+    if (params.line || params.limit) {
+      const start = Math.max((params.line ?? 1) - 1, 0);
+      const end = params.limit ? start + params.limit : void 0;
+      content = content.split(/\r?\n/).slice(start, end).join("\n");
+    }
+    return { content };
+  }
+  async writeTextFile(params) {
+    const path = await this.confine(params.path);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, params.content, "utf8");
+  }
+  /**
+   * Second line of defence behind the agent's own path checks: this client
+   * only touches files inside its workspace, whatever the agent asks for.
+   */
+  async confine(path) {
+    const resolved = await resolveWorkspaceFile(this.cwd, path);
+    if ("error" in resolved) throw new Error(resolved.error);
+    return resolved.path;
+  }
+  async createTerminal(params) {
+    const terminalId = `tui-${++this.nextTerminalId}`;
+    const outputByteLimit = params.outputByteLimit ?? DEFAULT_OUTPUT_LIMIT;
+    const env = { ...process.env };
+    for (const variable of params.env ?? [])
+      env[variable.name] = variable.value;
+    const child = spawnCommand(params.command, {
+      cwd: params.cwd ?? this.cwd,
+      env,
+      args: params.args
+    });
+    const record = {
+      child,
+      command: params.command,
+      toolCallId: this.findPendingTerminalTool(params.command),
+      output: "",
+      truncated: false,
+      outputByteLimit,
+      previewTimer: null,
+      exitStatus: null,
+      exitPromise: Promise.resolve({})
+    };
+    const append = (chunk) => {
+      record.output += chunk.toString("utf8");
+      if (record.output.length > record.outputByteLimit) {
+        record.output = record.output.slice(
+          record.output.length - record.outputByteLimit
+        );
+        record.truncated = true;
+      }
+      this.scheduleTerminalPreview(record);
+    };
+    child.stdout?.on("data", append);
+    child.stderr?.on("data", append);
+    record.exitPromise = new Promise((resolve) => {
+      child.on("error", (err) => {
+        record.output += `
+${err.message}`;
+        this.flushTerminalPreview(record);
+        record.exitStatus = { exitCode: null, signal: "error" };
+        resolve(record.exitStatus);
+      });
+      child.on("close", (exitCode, signal) => {
+        this.flushTerminalPreview(record);
+        record.exitStatus = { exitCode, signal };
+        resolve(record.exitStatus);
+      });
+    });
+    this.terminals.set(terminalId, record);
+    return { terminalId };
+  }
+  async terminalOutput(params) {
+    const record = this.requireTerminal(params.terminalId);
+    return {
+      output: record.output,
+      truncated: record.truncated,
+      exitStatus: record.exitStatus
+    };
+  }
+  async waitForTerminalExit(params) {
+    return this.requireTerminal(params.terminalId).exitPromise;
+  }
+  async killTerminal(params) {
+    const record = this.requireTerminal(params.terminalId);
+    if (!record.exitStatus) await terminateProcessTree(record.child);
+  }
+  async releaseTerminal(params) {
+    const record = this.terminals.get(params.terminalId);
+    if (!record) return;
+    if (record.previewTimer) clearTimeout(record.previewTimer);
+    this.terminals.delete(params.terminalId);
+    if (!record.exitStatus) await terminateProcessTree(record.child);
+  }
+  /**
+   * Only shows the agent's question: rules, modes and remembered approvals
+   * are the agent's permission policy, so every ACP client behaves the same.
+   */
+  async requestPermission(params) {
+    const toolName = toolNameOf(params.toolCall) ?? "tool";
+    const kind = params.toolCall.kind ?? "other";
+    const args = toRecord(params.toolCall.rawInput);
+    return new Promise((resolve) => {
+      this.store.setState({
+        pendingPermission: {
+          toolCallId: params.toolCall.toolCallId,
+          toolName,
+          title: params.toolCall.title ?? toolName,
+          kind,
+          args,
+          resolve: (allow, scope) => {
+            this.store.setState({ pendingPermission: null });
+            const optionId = choosePermissionOption(params.options, allow, scope);
+            resolve(
+              optionId ? selected(optionId) : { outcome: { outcome: "cancelled" } }
+            );
+          }
+        }
+      });
+    });
+  }
+  async createElicitation(params, signal) {
+    const request = fromElicitationRequest(params);
+    if (!request) return { action: "decline" };
+    const id = `question-${uid()}`;
+    return new Promise((resolve) => {
+      let settled = false;
+      const finish = (response) => {
+        if (settled) return;
+        settled = true;
+        signal?.removeEventListener("abort", abort);
+        if (this.store.getState().pendingQuestion?.id === id) {
+          this.store.setState({ pendingQuestion: null });
+        }
+        resolve(toElicitationResponse(request, response));
+      };
+      const abort = () => finish({ action: "cancel", answers: [] });
+      signal?.addEventListener("abort", abort, { once: true });
+      if (signal?.aborted) {
+        abort();
+        return;
+      }
+      this.store.setState({
+        pendingQuestion: { id, request, resolve: finish }
+      });
+    });
+  }
+  async sessionUpdate(params) {
+    const update = params.update;
+    switch (update.sessionUpdate) {
+      case "user_message_chunk":
+        if (update.content.type === "text") {
+          this.resetStreaming();
+          this.appendUserMessage(update.content.text);
+        }
+        return;
+      case "agent_message_chunk":
+        if (update.content.type === "text")
+          this.appendStreamingText(update.content.text);
+        return;
+      case "agent_thought_chunk":
+        if (update.content.type === "text" && update.content.text.trim()) {
+          this.resetStreaming();
+          this.appendMessage({
+            id: uid(),
+            role: "assistant",
+            text: update.content.text,
+            streaming: false
+          });
+        }
+        return;
+      case "current_mode_update":
+        if (isInteractionMode(update.currentModeId)) {
+          this.onInteractionModeChange?.(update.currentModeId);
+        }
+        return;
+      case "plan":
+        this.store.setState({
+          plan: update.entries.map(
+            ({ content, priority, status }) => ({
+              content,
+              priority,
+              status
+            })
+          )
+        });
+        return;
+      case "tool_call":
+        this.resetStreaming();
+        if (toolNameOf(update) === "update_plan") return;
+        this.appendMessage({
+          id: uid(),
+          role: "tool",
+          call: {
+            toolCallId: update.toolCallId,
+            name: toolNameOf(update) ?? update.title,
+            mutating: typeof update._meta?.["nova-ai-cli/mutating"] === "boolean" ? update._meta["nova-ai-cli/mutating"] : update.kind !== "read" && update.kind !== "search",
+            kind: update.kind ?? "other",
+            args: toRecord(update.rawInput),
+            status: normalizeToolStatus(update.status),
+            output: null,
+            diff: null
+          }
+        });
+        return;
+      case "tool_call_update":
+        this.patchToolCall(update.toolCallId, {
+          status: normalizeToolStatus(update.status),
+          output: extractToolOutput(update),
+          diff: extractToolDiff(update)
+        });
+        return;
+      default:
+        return;
+    }
+  }
+  async backgroundUpdate(params) {
+    if (!params || typeof params !== "object") return;
+    const event = "event" in params ? String(params.event) : "background";
+    const job = parseBackgroundJob("job" in params ? params.job : null);
+    if (!job) return;
+    const preview = job.outputPath && event !== "started" ? await readPreview(job.outputPath) : "";
+    this.upsertBackgroundMessage({ ...job, preview });
+    this.store.setState({ statusLine: `Background ${event}: ${job.title}` });
+    await this.onBackgroundLifecycle?.(event, job);
+  }
+  queueChanged(params) {
+    if (!params || typeof params !== "object") return;
+    const rawEntries = "entries" in params && Array.isArray(params.entries) ? params.entries : [];
+    const entries = rawEntries.flatMap((value) => {
+      if (!value || typeof value !== "object") return [];
+      const entry = value;
+      if (typeof entry.id !== "string" || typeof entry.text !== "string" || entry.kind !== "steer" && entry.kind !== "followup") {
+        return [];
+      }
+      return [{ id: entry.id, text: entry.text, kind: entry.kind }];
+    });
+    this.queueSnapshot = rawEntries.filter(
+      (value) => !!value && typeof value === "object" && typeof value.id === "string" && typeof value.text === "string"
+    );
+    this.store.setState((state) => {
+      const transcript = state.messages.filter(
+        (message) => !(message.role === "user" && message.queued)
+      );
+      const queued = entries.map((entry) => ({
+        id: entry.id,
+        role: "user",
+        text: entry.text,
+        queued: entry.kind
+      }));
+      return {
+        messages: [...transcript, ...queued],
+        queuedCount: queued.length
+      };
+    });
+  }
+  async handleRequest(method, params, options) {
+    options?.cancellationSignal?.throwIfAborted();
+    switch (method) {
+      case "fs/read_text_file":
+        return this.readTextFile(params);
+      case "fs/write_text_file":
+        return this.writeTextFile(params);
+      case "terminal/create":
+        return this.createTerminal(params);
+      case "terminal/output":
+        return this.terminalOutput(params);
+      case "terminal/wait_for_exit":
+        return this.waitForTerminalExit(params);
+      case "terminal/kill":
+        return this.killTerminal(params);
+      case "terminal/release":
+        return this.releaseTerminal(params);
+      case "session/request_permission":
+        return this.requestPermission(params);
+      case "elicitation/create":
+        return this.createElicitation(
+          params,
+          options?.cancellationSignal
+        );
+      default:
+        throw new Error(`Unsupported ACP client request: ${method}`);
+    }
+  }
+  async handleNotification(method, params) {
+    switch (method) {
+      case "session/update":
+        return this.sessionUpdate(params);
+      case NOVA_NOTIFICATIONS.backgroundUpdate:
+        return this.backgroundUpdate(params);
+      case NOVA_NOTIFICATIONS.queueChanged:
+        return this.queueChanged(params);
+      default:
+        return;
+    }
+  }
+  requireTerminal(terminalId) {
+    const record = this.terminals.get(terminalId);
+    if (!record) throw new Error(`Terminal ${terminalId} not found`);
+    return record;
+  }
+  findPendingTerminalTool(command) {
+    const messages = this.store.getState().messages;
+    for (let index = messages.length - 1; index >= 0; index--) {
+      const message = messages[index];
+      if (!message || message.role !== "tool" || message.call.status !== "pending")
+        continue;
+      if (message.call.name === "run_package_script")
+        return message.call.toolCallId;
+      if (message.call.name === "run_command" && message.call.args.command === command)
+        return message.call.toolCallId;
+    }
+    return null;
+  }
+  scheduleTerminalPreview(record) {
+    if (!record.toolCallId || record.previewTimer) return;
+    record.previewTimer = setTimeout(() => {
+      record.previewTimer = null;
+      this.patchToolCall(record.toolCallId, { output: record.output });
+    }, 50);
+    record.previewTimer.unref?.();
+  }
+  flushTerminalPreview(record) {
+    if (record.previewTimer) {
+      clearTimeout(record.previewTimer);
+      record.previewTimer = null;
+    }
+    if (record.toolCallId && record.output)
+      this.patchToolCall(record.toolCallId, { output: record.output });
+  }
+  appendStreamingText(text) {
+    if (!this.streamingMessageId) {
+      const id = uid();
+      this.streamingMessageId = id;
+      this.appendMessage({ id, role: "assistant", text, streaming: true });
+      return;
+    }
+    this.store.setState((state) => ({
+      messages: state.messages.map(
+        (message) => message.id === this.streamingMessageId && message.role === "assistant" ? { ...message, text: message.text + text } : message
+      )
+    }));
+  }
+  patchToolCall(toolCallId, patch) {
+    this.store.setState((state) => ({
+      messages: state.messages.map(
+        (message) => message.role === "tool" && message.call.toolCallId === toolCallId ? { ...message, call: { ...message.call, ...patch } } : message
+      )
+    }));
+  }
+  appendMessage(message) {
+    this.store.setState((state) => ({
+      messages: insertBeforeQueuedMessages(state.messages, message)
+    }));
+  }
+  upsertBackgroundMessage(job) {
+    this.store.setState((state) => {
+      const existing = state.messages.find(
+        (message) => message.role === "background" && message.job.jobId === job.jobId
+      );
+      if (!existing)
+        return {
+          messages: insertBeforeQueuedMessages(state.messages, {
+            id: uid(),
+            role: "background",
+            job
+          })
+        };
+      return {
+        messages: state.messages.map(
+          (message) => message.role === "background" && message.job.jobId === job.jobId ? { ...message, job } : message
+        )
+      };
+    });
+  }
+};
+function insertBeforeQueuedMessages(messages, message) {
+  const queuedIndex = messages.findIndex(
+    (item) => item.role === "user" && item.queued !== void 0
+  );
+  if (queuedIndex < 0) return [...messages, message];
+  return [
+    ...messages.slice(0, queuedIndex),
+    message,
+    ...messages.slice(queuedIndex)
+  ];
+}
+function choosePermissionOption(options, allow, scope) {
+  const preferred = !allow ? ["reject_once"] : scope === "always" ? ["allow_always", "allow_session", "allow_once"] : scope === "session" ? ["allow_session", "allow_once"] : ["allow_once"];
+  for (const id of preferred) {
+    const byId = options.find((option) => option.optionId === id);
+    if (byId) return byId.optionId;
+  }
+  const kinds = !allow ? ["reject_once", "reject_always"] : scope === "once" ? ["allow_once"] : ["allow_always", "allow_once"];
+  for (const kind of kinds) {
+    const byKind = options.find((option) => option.kind === kind);
+    if (byKind) return byKind.optionId;
+  }
+  return null;
+}
+function toolNameOf(call) {
+  const fromMeta = call._meta?.["nova-ai-cli/tool"];
+  return typeof fromMeta === "string" ? fromMeta : call.title ?? void 0;
+}
+function selected(optionId) {
+  return { outcome: { outcome: "selected", optionId } };
+}
+function toRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function normalizeToolStatus(status) {
+  if (status === "completed" || status === "failed") return status;
+  return "pending";
+}
+function extractToolOutput(update) {
+  if (typeof update.rawOutput === "object" && update.rawOutput && "output" in update.rawOutput) {
+    return String(update.rawOutput.output ?? "");
+  }
+  const content = update.content?.find(
+    (item) => item.type === "content" && item.content.type === "text"
+  );
+  return content && content.type === "content" && content.content.type === "text" ? content.content.text : null;
+}
+function extractToolDiff(update) {
+  const diff = update.content?.find((item) => item.type === "diff");
+  if (!diff || diff.type !== "diff") return null;
+  return {
+    path: diff.path,
+    oldText: diff.oldText ?? null,
+    newText: diff.newText
+  };
+}
+function parseBackgroundJob(value) {
+  if (!value || typeof value !== "object") return null;
+  const job = value;
+  const jobId = typeof job.jobId === "string" ? job.jobId : null;
+  const kind = job.kind === "terminal" || job.kind === "prompt" ? job.kind : null;
+  const title = typeof job.title === "string" ? job.title : "background job";
+  const status = job.status === "running" || job.status === "completed" || job.status === "failed" || job.status === "killed" || job.status === "released" ? job.status : null;
+  if (!jobId || !kind || !status) return null;
+  return {
+    jobId,
+    kind,
+    title,
+    status,
+    outputPath: typeof job.outputPath === "string" ? job.outputPath : void 0,
+    preview: ""
+  };
+}
+async function readPreview(path) {
+  try {
+    const raw = await readFile(path, "utf8");
+    return raw.split(/\r?\n/).slice(0, 12).join("\n");
+  } catch {
+    return "";
+  }
+}
+
+// src/tui/state/store.ts
+function createStore(initial) {
+  let state = initial;
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    getState() {
+      return state;
+    },
+    setState(update) {
+      const partial = typeof update === "function" ? update(state) : update;
+      state = { ...state, ...partial };
+      for (const listener of listeners) listener();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+
+export {
+  readWorkspaceMcpConfiguration,
+  workspaceNeedsTrust,
+  TuiAcpClient,
+  choosePermissionOption,
+  createStore
+};