nolo-cli 0.1.32 → 0.1.34

package/tui/session.ts

@@ -1,50 +1,379 @@
-import {
-  type TuiInterpreterAction,
-  type TuiInterpreterResult,
-  type TuiCommandInterpreterDeps,
-  handleTuiInput as handleTuiInputWithDeps,
-} from "./tuiCommandInterpreter";
-import {
-  DEFAULT_TUI_SERVER_URL,
-  type EnvLike,
-  type TuiState,
-  createInitialTuiState,
-  renderContextPanel,
-  renderKnownAgents,
-  renderPrompt,
-  renderStatusLine,
-  renderTuiHelp,
-  renderWelcome,
-  resolveDialogLabel,
-} from "./tuiPresentation";
-import { DEFAULT_TUI_AGENT_KEY, KNOWN_AGENTS, KNOWN_AGENT_ALIASES } from "./tuiCatalog";
-
-export { DEFAULT_TUI_AGENT_KEY, DEFAULT_TUI_SERVER_URL, KNOWN_AGENTS, KNOWN_AGENT_ALIASES };
-export type { EnvLike, TuiState } from "./tuiPresentation";
-
-export type TuiAction = TuiInterpreterAction;
-export type TuiInputResult = TuiInterpreterResult;
-
-function createInterpreterDeps(): TuiCommandInterpreterDeps {
+import { DEFAULT_NOLO_SERVER_URL } from "../defaultServer";
+import type { AgentRuntimeRequestedMode } from "../agentRuntimeLocal";
+
+export const DEFAULT_TUI_AGENT_KEY = "agent-pub-01NOLOAPPBLD000000019KCKT0";
+export const DEFAULT_TUI_SERVER_URL = DEFAULT_NOLO_SERVER_URL;
+
+const KNOWN_AGENTS: Array<{
+  name: string;
+  key: string;
+  description: string;
+}> = [
+  {
+    name: "nolo",
+    key: "agent-pub-01NOLOAPPBLD000000019KCKT0",
+    description: "one assistant that routes work across your agents and data",
+  },
+  {
+    name: "app-builder",
+    key: "agent-pub-01APPBUILDER00000001YAII3I",
+    description: "builds web apps, tools, charts, and product prototypes",
+  },
+];
+
+const KNOWN_AGENT_ALIASES: Record<string, { name: string; key: string }> =
+  Object.fromEntries(KNOWN_AGENTS.map((agent) => [agent.name, agent]));
+
+function shortenDialogId(dialogId: string) {
+  return dialogId.length > 12
+    ? `${dialogId.slice(0, 6)}...${dialogId.slice(-4)}`
+    : dialogId;
+}
+
+export function resolveDialogLabel(
+  state: Pick<TuiState, "dialogId" | "dialogLabel">
+) {
+  return state.dialogId ? shortenDialogId(state.dialogId) : state.dialogLabel;
+}
+
+export type TuiState = {
+  agentKey: string;
+  agentName: string;
+  dialogId?: string;
+  dialogLabel: string;
+  profileName: string;
+  serverUrl: string;
+  cliVersion?: string;
+  attachedDocs: string[];
+  runtimeMode: AgentRuntimeRequestedMode;
+};
+
+export type TuiAction =
+  | {
+      type: "chat";
+      message: string;
+      agentKey: string;
+      runtimeMode: AgentRuntimeRequestedMode;
+      continueDialogId?: string;
+    }
+  | {
+      type: "compact";
+      dialogId: string;
+    }
+  | {
+      type: "self-update";
+    }
+  | {
+      type: "exit";
+    };
+
+export type TuiInputResult = {
+  nextState: TuiState;
+  output: string;
+  action?: TuiAction;
+};
+
+type EnvLike = Record<string, string | undefined>;
+
+export function createInitialTuiState(env: EnvLike = process.env): TuiState {
+  const agentKey = env.NOLO_AGENT?.trim() || DEFAULT_TUI_AGENT_KEY;
+  const agentName = env.NOLO_AGENT_NAME?.trim() || "nolo";
+
   return {
-    knownAgents: KNOWN_AGENTS,
-    renderHelp: renderTuiHelp,
-    renderContextPanel,
-    renderKnownAgents,
+    agentKey,
+    agentName,
+    dialogId: env.NOLO_DIALOG_ID?.trim() || undefined,
+    dialogLabel: env.NOLO_DIALOG?.trim() || "new",
+    profileName: env.NOLO_PROFILE?.trim() || "local",
+    serverUrl: (env.NOLO_SERVER || env.BASE_URL || DEFAULT_TUI_SERVER_URL).replace(
+      /\/+$/,
+      ""
+    ),
+    cliVersion: env.NOLO_CLI_VERSION?.trim() || undefined,
+    attachedDocs: [],
+    runtimeMode: env.NOLO_RUNTIME_MODE === "local" || env.NOLO_RUNTIME_MODE === "server"
+      ? env.NOLO_RUNTIME_MODE
+      : "auto",
   };
 }
 
-export {
-  createInitialTuiState,
-  renderContextPanel,
-  renderKnownAgents,
-  renderPrompt,
-  renderStatusLine,
-  renderTuiHelp,
-  renderWelcome,
-  resolveDialogLabel,
-};
+export function renderStatusLine(state: TuiState) {
+  const docs =
+    state.attachedDocs.length > 0
+      ? String(state.attachedDocs.length)
+      : "0";
+
+  return [
+    `agent ${state.agentName}`,
+    `dialog ${resolveDialogLabel(state)}`,
+    `docs ${docs}`,
+    `runtime ${state.runtimeMode}`,
+    `profile ${state.profileName}`,
+  ].join(" | ");
+}
+
+export function renderWelcome(state: TuiState) {
+  const docs = state.attachedDocs.length > 0
+    ? `${state.attachedDocs.length} attached`
+    : "none";
+  return [
+    "",
+    `Nolo workspace${state.cliVersion ? `  nolo ${state.cliVersion}` : ""}`,
+    `agent ${state.agentName} | dialog ${resolveDialogLabel(state)} | docs ${docs} | profile ${state.profileName}`,
+    `server ${state.serverUrl}`,
+    "",
+    "Tell nolo what you want. Use /help for commands. Use /version if this install feels stale.",
+    "",
+  ].join("\n");
+}
+
+export function renderPrompt(_state: TuiState) {
+  return "you > ";
+}
+
+export function renderTuiHelp() {
+  return [
+    "Commands:",
+    "  /help                 Show this help",
+    "  /new                  Start a fresh dialog",
+    "  /compact              Compact current dialog and fork a new one",
+    "  /context              Show workspace context and next actions",
+    "  /runtime <mode>       Use auto, local, or server runtime",
+    "  /agent                Show the current agent",
+    "  /agents               List built-in agent shortcuts",
+    "  /switch <agent>       Switch the current agent",
+    "  /dialog               Show the current dialog",
+    "  /doc                  List attached docs",
+    "  /doc attach <doc>     Attach a doc to this workspace",
+    "  /customize            Describe how you want to tune nolo",
+    "  /login                Show login/profile hint",
+    "  /profile              Show active profile",
+    "  /update               Update the global nolo install",
+    "  /version              Show version/update hint",
+    "  /exit                 Leave the workspace",
+    "",
+    "You can also type normally. nolo will send it to the current agent.",
+  ].join("\n");
+}
+
+export function renderContextPanel(state: TuiState) {
+  const docs = state.attachedDocs.length
+    ? state.attachedDocs.join(", ")
+    : "none";
+  return [
+    "Workspace context",
+    "-----------------",
+    `agent   ${state.agentName}`,
+    `dialog  ${resolveDialogLabel(state)}`,
+    `docs    ${docs}`,
+    `profile ${state.profileName}`,
+    `runtime ${state.runtimeMode}`,
+    `server  ${state.serverUrl}`,
+    "",
+    "Next:",
+    "  /agents              see specialist shortcuts",
+    "  /doc attach <doc>    add working context",
+    "  /new                 start a clean dialog",
+  ].join("\n");
+}
+
+export function renderKnownAgents() {
+  return [
+    "Agents:",
+    ...KNOWN_AGENTS.map(
+      (agent, index) =>
+        `  ${index + 1}  ${agent.name.padEnd(11)} ${agent.description}`
+    ),
+    "",
+    "Tip: stay on nolo for the one-assistant feel; switch only when you want a specialist directly.",
+  ].join("\n");
+}
+
+function resolveSwitchTarget(rawTarget: string) {
+  const target = rawTarget.trim();
+  if (/^\d+$/.test(target)) {
+    const agent = KNOWN_AGENTS[Number(target) - 1];
+    return agent ? { name: agent.name, key: agent.key } : null;
+  }
+  const alias = KNOWN_AGENT_ALIASES[target.toLowerCase()];
+  if (alias) return alias;
+  if (target.startsWith("agent-") || target.startsWith("agent-pub-")) {
+    return { name: target, key: target };
+  }
+  return null;
+}
 
 export function handleTuiInput(input: string, state: TuiState): TuiInputResult {
-  return handleTuiInputWithDeps(input, state, createInterpreterDeps());
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return { nextState: state, output: "" };
+  }
+
+  if (!trimmed.startsWith("/")) {
+    return {
+      nextState: state,
+      output: "",
+      action: {
+        type: "chat",
+        message: trimmed,
+        agentKey: state.agentKey,
+        runtimeMode: state.runtimeMode,
+        ...(state.dialogId ? { continueDialogId: state.dialogId } : {}),
+      },
+    };
+  }
+
+  const [command = "", ...rest] = trimmed.split(/\s+/);
+  const argText = rest.join(" ").trim();
+
+  switch (command) {
+    case "/help":
+      return { nextState: state, output: renderTuiHelp() };
+    case "/context":
+    case "/ctx":
+      return { nextState: state, output: renderContextPanel(state) };
+    case "/runtime": {
+      if (argText !== "auto" && argText !== "local" && argText !== "server") {
+        return {
+          nextState: state,
+          output: "Usage: /runtime <auto|local|server>",
+        };
+      }
+      return {
+        nextState: { ...state, runtimeMode: argText },
+        output: `Runtime: ${argText}`,
+      };
+    }
+    case "/exit":
+    case "/quit":
+      return { nextState: state, output: "Bye.", action: { type: "exit" } };
+    case "/new":
+      return {
+        nextState: {
+          ...state,
+          dialogId: undefined,
+          dialogLabel: "new",
+          attachedDocs: [],
+        },
+        output: "Started a fresh dialog.",
+      };
+    case "/compact":
+      if (argText) {
+        return {
+          nextState: state,
+          output: `Unknown command: ${trimmed}\n\n${renderTuiHelp()}`,
+        };
+      }
+      if (!state.dialogId) {
+        return {
+          nextState: state,
+          output: "Current dialog: new (nothing to compact yet)",
+        };
+      }
+      return {
+        nextState: state,
+        output: "Compacting current dialog...",
+        action: { type: "compact", dialogId: state.dialogId },
+      };
+    case "/agent":
+      return {
+        nextState: state,
+        output: `Current agent: ${state.agentName} (${state.agentKey})`,
+      };
+    case "/agents":
+      return {
+        nextState: state,
+        output: renderKnownAgents(),
+      };
+    case "/switch": {
+      if (!argText) {
+        return {
+          nextState: state,
+          output: "Usage: /switch <agent-key|alias>",
+        };
+      }
+      const resolvedTarget = resolveSwitchTarget(argText);
+      if (!resolvedTarget) {
+        return {
+          nextState: state,
+          output:
+            `I don't know agent shortcut "${argText}" yet.\n` +
+            "Use /switch nolo, /switch app-builder, or a full agent key like agent-pub-...",
+        };
+      }
+      return {
+        nextState: {
+          ...state,
+          agentName: resolvedTarget.name,
+          agentKey: resolvedTarget.key,
+        },
+        output: `Switched to ${resolvedTarget.name}.`,
+      };
+    }
+    case "/dialog":
+      return {
+        nextState: state,
+        output: state.dialogId
+          ? `Current dialog: ${state.dialogId}`
+          : "Current dialog: new",
+      };
+    case "/doc": {
+      if (rest[0] === "attach") {
+        const docName = rest.slice(1).join(" ").trim();
+        if (!docName) {
+          return { nextState: state, output: "Usage: /doc attach <doc>" };
+        }
+        const attachedDocs = state.attachedDocs.includes(docName)
+          ? state.attachedDocs
+          : [...state.attachedDocs, docName];
+        return {
+          nextState: { ...state, attachedDocs },
+          output: `Attached doc: ${docName}`,
+        };
+      }
+      return {
+        nextState: state,
+        output:
+          state.attachedDocs.length > 0
+            ? `Attached docs: ${state.attachedDocs.join(", ")}`
+            : "No docs attached. Use /doc attach <doc>.",
+      };
+    }
+    case "/customize":
+      return {
+        nextState: state,
+        output:
+          "Tell nolo what to change, for example: /customize make my default agent more concise.",
+      };
+    case "/login":
+      return {
+        nextState: state,
+        output:
+          "MVP login uses profile/env auth. Set AUTH_TOKEN, NOLO_SERVER, or NOLO_PROFILE before starting nolo.",
+      };
+    case "/profile":
+      return {
+        nextState: state,
+        output: `Profile: ${state.profileName}`,
+      };
+    case "/update":
+      return {
+        nextState: state,
+        output: "Starting self-update...",
+        action: { type: "self-update" },
+      };
+    case "/version":
+      return {
+        nextState: state,
+        output:
+          `nolo ${state.cliVersion || "unknown version"}\n` +
+          "Update this install with: nolo update\n" +
+          "If repo-local output differs, publish/install the latest npm package first.",
+      };
+    default:
+      return {
+        nextState: state,
+        output: `Unknown command: ${command}\n\n${renderTuiHelp()}`,
+      };
+  }
 }

package/workflowInternalCommandEntries.ts

@@ -1,31 +1,11 @@
 import { createEnvCommand } from "./cliCommandFactories";
 import type { CommandEntry } from "./cliCommandTypes";
-import { runTableMetaCommand } from "./tableMetaCommands";
-import {
-  runTableAddColumnCommand,
-  runTableAddRowCommand,
-  runTableAddRowsCommand,
-  runTableDataCommand,
-  runTableDeleteRowCommand,
-  runTableDeleteRowsCommand,
-  runTableUpdateRowCommand,
-  runTableUpdateRowsCommand,
-} from "./tableMutationCommands";
 import { runTableQueryCommand } from "./tableCommands";
 import { runTaskRunCommand } from "./taskRunCommand";
 
 export function getWorkflowInternalCommandEntries(): CommandEntry[] {
   return [
     createEnvCommand(["table", "query"], "Query table rows", runTableQueryCommand),
-    createEnvCommand(["table", "meta"], "Create or update table metadata", runTableMetaCommand),
-    createEnvCommand(["table", "add-column"], "Add one table column", runTableAddColumnCommand),
-    createEnvCommand(["table", "add-row"], "Add one table row", runTableAddRowCommand),
-    createEnvCommand(["table", "add-rows"], "Add table rows", runTableAddRowsCommand),
-    createEnvCommand(["table", "update-row"], "Update one table row", runTableUpdateRowCommand),
-    createEnvCommand(["table", "update-rows"], "Update table rows", runTableUpdateRowsCommand),
-    createEnvCommand(["table", "delete-row"], "Delete one table row", runTableDeleteRowCommand),
-    createEnvCommand(["table", "delete-rows"], "Delete table rows", runTableDeleteRowsCommand),
-    createEnvCommand(["table", "data"], "Low-level table row command", runTableDataCommand),
     createEnvCommand(["task-run"], "Update durable task-run state through the runner bridge", runTaskRunCommand),
   ];
 }

package/agent-runtime/dialogStatus.ts

@@ -1,139 +0,0 @@
-export type DialogStatusSnapshot = {
-  dialogId: string;
-  dialogKey?: string;
-  base?: string;
-  title?: string | null;
-  status?: string | null;
-  parentDialogId?: string | null;
-  rootDialogId?: string | null;
-  subjectRefs?: Array<{ kind?: string; id?: string; role?: string }>;
-  runtimeCheckpoint?: Record<string, any> | null;
-  artifacts?: any;
-  writtenFiles?: string[];
-  toolsUsed?: string[];
-  toolErrors?: string[];
-  durationMs?: number | null;
-  updatedAt?: string | number | null;
-  finishedAt?: string | number | null;
-};
-
-const ACTIVE_STALE_AFTER_MS = 5 * 60_000;
-
-function compact(value: unknown, max = 180) {
-  const text = typeof value === "string" ? value.trim() : "";
-  if (!text) return "";
-  return text.length > max ? `${text.slice(0, max - 3)}...` : text;
-}
-
-function list(values: unknown, max = 8) {
-  if (!Array.isArray(values)) return [];
-  return values
-    .map((value) => (typeof value === "string" ? value.trim() : ""))
-    .filter(Boolean)
-    .slice(0, max);
-}
-
-function artifactFiles(artifacts: any) {
-  if (!artifacts || typeof artifacts !== "object") return [];
-  return list(artifacts.changedFiles ?? artifacts.writtenFiles ?? artifacts.files);
-}
-
-function formatSubjectRefs(refs: DialogStatusSnapshot["subjectRefs"], max = 8) {
-  if (!Array.isArray(refs)) return [];
-  return refs
-    .map((ref) => {
-      const kind = typeof ref?.kind === "string" ? ref.kind.trim() : "";
-      const id = typeof ref?.id === "string" ? ref.id.trim() : "";
-      if (!kind || !id) return "";
-      const role = typeof ref?.role === "string" && ref.role.trim() ? `#${ref.role.trim()}` : "";
-      return `${kind}:${id}${role}`;
-    })
-    .filter(Boolean)
-    .slice(0, max);
-}
-
-export function resolveDialogTerminalState(snapshot: DialogStatusSnapshot) {
-  const checkpointStatus =
-    typeof snapshot.runtimeCheckpoint?.status === "string"
-      ? snapshot.runtimeCheckpoint.status
-      : null;
-  if (checkpointStatus === "done" || checkpointStatus === "completed") return "done";
-  if (checkpointStatus === "failed" || checkpointStatus === "error") return "failed";
-
-  const status = snapshot.status ?? checkpointStatus ?? "unknown";
-  if (status === "done" || status === "completed") return "done";
-  if (status === "failed" || status === "error") return "failed";
-  if (status === "running" || status === "pending" || status === "queued") return "active";
-  return "unknown";
-}
-
-function parseTimeMs(value: unknown): number | null {
-  if (typeof value === "number" && Number.isFinite(value)) return value;
-  if (typeof value === "string" && value.trim()) {
-    const parsed = Date.parse(value);
-    return Number.isFinite(parsed) ? parsed : null;
-  }
-  return null;
-}
-
-export function resolveDialogActiveHealth(snapshot: DialogStatusSnapshot, nowMs = Date.now()) {
-  if (resolveDialogTerminalState(snapshot) !== "active") return null;
-  const checkpointUpdatedAt = parseTimeMs(snapshot.runtimeCheckpoint?.updatedAt);
-  const dialogUpdatedAt = parseTimeMs(snapshot.updatedAt);
-  const latest = checkpointUpdatedAt ?? dialogUpdatedAt;
-  if (!snapshot.runtimeCheckpoint) return "no-checkpoint";
-  if (!checkpointUpdatedAt) return "checkpoint-without-updatedAt";
-  if (latest && nowMs - latest > ACTIVE_STALE_AFTER_MS) return "stale-running";
-  return "running";
-}
-
-export function renderDialogStatus(snapshot: DialogStatusSnapshot) {
-  const checkpoint = snapshot.runtimeCheckpoint ?? {};
-  const files = list(snapshot.writtenFiles).length
-    ? list(snapshot.writtenFiles)
-    : artifactFiles(snapshot.artifacts);
-  const tools = list(snapshot.toolsUsed).length
-    ? list(snapshot.toolsUsed)
-    : list(checkpoint.lastToolNames);
-  const errors = list(snapshot.toolErrors);
-  const errorMessage = compact(checkpoint.errorMessage ?? (snapshot as any).errorMessage);
-  const subjectRefs = formatSubjectRefs(snapshot.subjectRefs);
-  const terminal = resolveDialogTerminalState(snapshot);
-  const activeHealth = resolveDialogActiveHealth(snapshot);
-  const lines = [
-    `dialog: ${snapshot.dialogId}`,
-    ...(snapshot.base ? [`base: ${snapshot.base}`] : []),
-    ...(snapshot.title ? [`title: ${snapshot.title}`] : []),
-    ...(snapshot.parentDialogId ? [`parentDialogId: ${snapshot.parentDialogId}`] : []),
-    ...(snapshot.rootDialogId ? [`rootDialogId: ${snapshot.rootDialogId}`] : []),
-    `status: ${snapshot.status ?? "unknown"}`,
-    ...(typeof checkpoint.status === "string" ? [`checkpoint: ${checkpoint.status}`] : []),
-    `state: ${terminal}`,
-    ...(activeHealth ? [`activeHealth: ${activeHealth}`] : []),
-    ...(typeof snapshot.durationMs === "number" ? [`durationMs: ${snapshot.durationMs}`] : []),
-    ...(snapshot.updatedAt ? [`updatedAt: ${snapshot.updatedAt}`] : []),
-    ...(snapshot.finishedAt ? [`finishedAt: ${snapshot.finishedAt}`] : []),
-    ...(compact(checkpoint.lastUserInput) ? [`lastUserInput: ${compact(checkpoint.lastUserInput)}`] : []),
-    ...(compact(checkpoint.lastAssistantText) ? [`lastAssistantText: ${compact(checkpoint.lastAssistantText)}`] : []),
-    ...(errorMessage ? [`error: ${errorMessage}`] : []),
-    ...(tools.length ? [`tools: ${tools.join(", ")}`] : []),
-    ...(files.length ? [`files: ${files.join(", ")}`] : []),
-    ...(subjectRefs.length ? [`subjects: ${subjectRefs.join(", ")}`] : []),
-    ...(errors.length ? [`toolErrors: ${errors.join(", ")}`] : []),
-    "",
-    "next:",
-    `- read full dialog: nolo dialog read ${snapshot.dialogId} 120`,
-  ];
-
-  if (terminal === "active") {
-    lines.push(`- poll again: nolo dialog status ${snapshot.dialogId}`);
-  } else if (terminal === "failed") {
-    lines.push(`- inspect failure and rerun/continue with: nolo agent run <agent> --continue ${snapshot.dialogId} --msg "..."`);
-  } else if (terminal === "done") {
-    lines.push("- use artifacts/files above for review, handoff, or alpha integration.");
-  } else {
-    lines.push("- inspect meta/messages before deciding whether to continue or rerun.");
-  }
-
-  return `${lines.join("\n")}\n`;
-}

package/agent-runtime/hostRuntimeConfig.ts

@@ -1,86 +0,0 @@
-type EnvLike = Record<string, string | undefined>;
-
-export type HostRuntimeSurface =
-  | "cli-local"
-  | "desktop"
-  | "connector-local"
-  | "connector-cli";
-
-export type HostRuntimeWorkspaceBinding =
-  | "explicit-cwd"
-  | "default-cwd";
-
-export type HostRuntimeCapabilities = {
-  allowShell: boolean;
-};
-
-export type HostRuntimeConfig = {
-  surface: HostRuntimeSurface;
-  workspaceBinding: HostRuntimeWorkspaceBinding;
-  capabilities: HostRuntimeCapabilities;
-};
-
-const SHELL_ENABLED_BY_DEFAULT_SURFACES = new Set<HostRuntimeSurface>([
-  "cli-local",
-  "desktop",
-]);
-
-function defaultAllowShellForSurface(surface: HostRuntimeSurface) {
-  return SHELL_ENABLED_BY_DEFAULT_SURFACES.has(surface);
-}
-
-function readAllowShellOverrideFromEnv(env: EnvLike) {
-  const rawMode = (env.NOLO_LOCAL_SHELL_MODE || "").trim().toLowerCase();
-  if (!rawMode) return undefined;
-  if (["worktree", "dangerous", "1", "true"].includes(rawMode)) return true;
-  if (["0", "false", "off", "none", "disabled"].includes(rawMode)) return false;
-  return undefined;
-}
-
-export function createHostRuntimeCapabilities(args: {
-  allowShell?: boolean;
-} = {}): HostRuntimeCapabilities {
-  return {
-    allowShell: args.allowShell === true,
-  };
-}
-
-export function createHostRuntimeConfig(args: {
-  surface: HostRuntimeSurface;
-  workspaceBinding: HostRuntimeWorkspaceBinding;
-  allowShell?: boolean;
-}): HostRuntimeConfig {
-  return {
-    surface: args.surface,
-    workspaceBinding: args.workspaceBinding,
-    capabilities: createHostRuntimeCapabilities({
-      allowShell: args.allowShell,
-    }),
-  };
-}
-
-export function resolveHostRuntimeCapabilitiesFromEnv(
-  env: EnvLike,
-  args: { surface?: HostRuntimeSurface } = {},
-): HostRuntimeCapabilities {
-  const allowShellOverride = readAllowShellOverrideFromEnv(env);
-  return createHostRuntimeCapabilities({
-    allowShell:
-      allowShellOverride ??
-      (args.surface ? defaultAllowShellForSurface(args.surface) : false),
-  });
-}
-
-export function resolveHostRuntimeConfigFromEnv(args: {
-  env: EnvLike;
-  surface: HostRuntimeSurface;
-  workspaceBinding: HostRuntimeWorkspaceBinding;
-}): HostRuntimeConfig {
-  return {
-    surface: args.surface,
-    workspaceBinding: args.workspaceBinding,
-    capabilities: resolveHostRuntimeCapabilitiesFromEnv(args.env, {
-      surface: args.surface,
-    }),
-  };
-}