@lazyingart/agintiflow 0.1.0 → 0.2.0

package/src/artifact-tunnel.js

@@ -0,0 +1,401 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { redactSensitiveText } from "./redaction.js";
+import { checkWorkspaceToolUse, resolveWorkspacePath } from "./workspace-tools.js";
+
+const MAX_INLINE_TEXT_BYTES = 120_000;
+const MAX_ARTIFACT_TEXT_BYTES = 520_000;
+const MAX_ARTIFACT_IMAGE_BYTES = 4_000_000;
+const IMAGE_MIME_BY_EXT = new Map([
+  [".png", "image/png"],
+  [".jpg", "image/jpeg"],
+  [".jpeg", "image/jpeg"],
+  [".gif", "image/gif"],
+  [".webp", "image/webp"],
+  [".svg", "image/svg+xml"],
+]);
+const BINARY_RENDER_MIME_BY_EXT = new Map([[".pdf", "application/pdf"]]);
+
+function normalizeDisplayPath(value) {
+  return String(value || "")
+    .split(path.sep)
+    .join("/");
+}
+
+function isInside(root, target) {
+  const relative = path.relative(root, target);
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+function stableId(...parts) {
+  return crypto.createHash("sha256").update(parts.map((part) => String(part ?? "")).join("\0")).digest("base64url");
+}
+
+function previewText(value, limit = 220) {
+  const text = redactSensitiveText(String(value || "")).replace(/\s+/g, " ").trim();
+  return text.length > limit ? `${text.slice(0, limit).trim()}...` : text;
+}
+
+function normalizeKind(kind, filePath = "") {
+  const candidate = String(kind || "").toLowerCase();
+  if (candidate === "file") {
+    if (IMAGE_MIME_BY_EXT.has(path.extname(String(filePath || "")).toLowerCase())) return "image";
+    if (BINARY_RENDER_MIME_BY_EXT.has(path.extname(String(filePath || "")).toLowerCase())) return "pdf";
+    if (String(filePath || "").toLowerCase().endsWith(".json")) return "json";
+    if (String(filePath || "").toLowerCase().endsWith(".md")) return "markdown";
+    return "file";
+  }
+  if (["image", "markdown", "text", "json", "diff", "pdf"].includes(candidate)) return candidate;
+  if (IMAGE_MIME_BY_EXT.has(path.extname(String(filePath || "")).toLowerCase())) return "image";
+  if (BINARY_RENDER_MIME_BY_EXT.has(path.extname(String(filePath || "")).toLowerCase())) return "pdf";
+  if (String(filePath || "").toLowerCase().endsWith(".json")) return "json";
+  if (String(filePath || "").toLowerCase().endsWith(".md")) return "markdown";
+  return "text";
+}
+
+function mimeForPath(filePath) {
+  const ext = path.extname(String(filePath || "")).toLowerCase();
+  return IMAGE_MIME_BY_EXT.get(ext) || BINARY_RENDER_MIME_BY_EXT.get(ext) || "text/plain; charset=utf-8";
+}
+
+function publicArtifact(item) {
+  return {
+    id: item.id,
+    sessionId: item.sessionId,
+    kind: item.kind,
+    title: item.title,
+    path: item.path || "",
+    preview: item.preview || "",
+    source: item.source,
+    tab: item.tab,
+    createdAt: item.createdAt,
+    selected: Boolean(item.selected),
+    mime: item.mime || "",
+  };
+}
+
+function sessionRelativePath(store, filePath) {
+  const absolutePath = path.resolve(String(filePath || ""));
+  if (!isInside(store.sessionDir, absolutePath)) return "";
+  return normalizeDisplayPath(path.relative(store.sessionDir, absolutePath));
+}
+
+function addSnapshotArtifacts(items, event, store, sessionId) {
+  const data = event.data || {};
+  if (data.screenshotPath) {
+    const displayPath = sessionRelativePath(store, data.screenshotPath);
+    if (displayPath) {
+      items.push({
+        id: stableId(sessionId, event.timestamp, "snapshot-image", displayPath),
+        sessionId,
+        kind: "image",
+        title: `Browser screenshot step ${data.step || "?"}`,
+        path: displayPath,
+        preview: data.title || data.url || "Captured browser screenshot.",
+        source: "snapshot",
+        tab: "canvas",
+        createdAt: event.timestamp,
+        mime: "image/png",
+        ref: {
+          type: "session-file",
+          path: path.resolve(data.screenshotPath),
+        },
+      });
+    }
+  }
+
+  if (data.snapshotPath) {
+    const displayPath = sessionRelativePath(store, data.snapshotPath);
+    if (displayPath) {
+      items.push({
+        id: stableId(sessionId, event.timestamp, "snapshot-json", displayPath),
+        sessionId,
+        kind: "json",
+        title: `Runtime snapshot step ${data.step || "?"}`,
+        path: displayPath,
+        preview: data.title || data.url || "Browser/runtime snapshot JSON.",
+        source: "snapshot",
+        tab: "explorer",
+        createdAt: event.timestamp,
+        mime: "application/json",
+        ref: {
+          type: "session-file",
+          path: path.resolve(data.snapshotPath),
+        },
+      });
+    }
+  }
+}
+
+function addWorkspaceArtifacts(items, event, sessionId) {
+  const data = event.data || {};
+  const filePath = normalizeDisplayPath(data.path || "");
+  if (!filePath) return;
+
+  const diff = redactSensitiveText(String(data.diff || ""));
+  items.push({
+    id: stableId(sessionId, event.timestamp, "file-diff", filePath, diff),
+    sessionId,
+    kind: "diff",
+    title: `Change: ${filePath}`,
+    path: filePath,
+    preview: previewText(diff || `${data.toolName || "file tool"} changed ${filePath}`),
+    source: "file-change",
+    tab: "notifications",
+    createdAt: event.timestamp,
+    mime: "text/x-diff",
+    ref: {
+      type: "inline",
+      text: diff || JSON.stringify(data, null, 2),
+    },
+  });
+
+  items.push({
+    id: stableId(sessionId, event.timestamp, "workspace-file", filePath),
+    sessionId,
+    kind: normalizeKind("file", filePath),
+    title: `Workspace file: ${filePath}`,
+    path: filePath,
+    preview: "Open the current workspace file through guarded read policy.",
+    source: "workspace-file",
+    tab: "explorer",
+    createdAt: event.timestamp,
+    mime: mimeForPath(filePath),
+    ref: {
+      type: "workspace-file",
+      path: filePath,
+      commandCwd: data.commandCwd || "",
+    },
+  });
+}
+
+function addCanvasArtifact(items, event, sessionId) {
+  const data = event.data || {};
+  const artifactId = data.artifactId || stableId(sessionId, event.timestamp, "canvas", data.title, data.path);
+  const artifactPath = normalizeDisplayPath(data.path || "");
+  const text = typeof data.content === "string" ? redactSensitiveText(data.content) : "";
+  items.push({
+    id: artifactId,
+    sessionId,
+    kind: normalizeKind(data.kind, artifactPath),
+    title: String(data.title || "Agent canvas item").slice(0, 120),
+    path: artifactPath,
+    preview: previewText(data.note || text || artifactPath || "Agent selected this item for canvas display."),
+    source: "agent-canvas",
+    tab: "canvas",
+    createdAt: event.timestamp,
+    mime: mimeForPath(artifactPath),
+    ref: text
+      ? {
+          type: "inline",
+          text,
+        }
+      : artifactPath
+        ? {
+            type: "workspace-file",
+            path: artifactPath,
+            commandCwd: data.commandCwd || "",
+          }
+        : {
+            type: "inline",
+            text: redactSensitiveText(String(data.note || "")),
+          },
+  });
+}
+
+function addFinalAnswerArtifact(items, event, sessionId) {
+  const result = String(event.data?.result || "");
+  if (!result.trim()) return;
+  items.push({
+    id: stableId(sessionId, event.timestamp, "final-answer", result),
+    sessionId,
+    kind: "markdown",
+    title: "Final answer",
+    path: "",
+    preview: previewText(result),
+    source: "session",
+    tab: "notifications",
+    createdAt: event.timestamp,
+    mime: "text/markdown; charset=utf-8",
+    ref: {
+      type: "inline",
+      text: redactSensitiveText(result),
+    },
+  });
+}
+
+function selectedArtifactId(events) {
+  return [...events].reverse().find((event) => event.type === "canvas.selected")?.data?.artifactId || "";
+}
+
+export function buildArtifacts({ sessionId, events, store }) {
+  const items = [];
+  const selectedId = selectedArtifactId(events);
+
+  for (const event of events) {
+    if (event.type === "canvas.item") addCanvasArtifact(items, event, sessionId);
+    if (event.type === "snapshot.captured") addSnapshotArtifacts(items, event, store, sessionId);
+    if (event.type === "file.changed") addWorkspaceArtifacts(items, event, sessionId);
+    if (event.type === "session.finished") addFinalAnswerArtifact(items, event, sessionId);
+  }
+
+  items.sort((a, b) => String(b.createdAt).localeCompare(String(a.createdAt)));
+  const fallbackSelected = selectedId || items.find((item) => item.tab === "canvas")?.id || items[0]?.id || "";
+  for (const item of items) item.selected = item.id === fallbackSelected;
+
+  return {
+    items,
+    selectedItemId: fallbackSelected,
+  };
+}
+
+export function serializeArtifacts(items) {
+  return items.map(publicArtifact);
+}
+
+export function countUnreadArtifacts(items, seenAfter = "") {
+  const seenAt = Date.parse(String(seenAfter || ""));
+  if (!Number.isFinite(seenAt)) return items.length;
+  return items.filter((item) => Date.parse(item.createdAt) > seenAt).length;
+}
+
+export function findArtifact(items, artifactId) {
+  return items.find((item) => item.id === artifactId) || null;
+}
+
+export async function readArtifactContent(item, { store, config }) {
+  if (!item) {
+    return { ok: false, error: "Artifact not found." };
+  }
+
+  if (item.ref?.type === "inline") {
+    return {
+      ok: true,
+      id: item.id,
+      kind: item.kind,
+      title: item.title,
+      path: item.path || "",
+      mime: item.mime || "text/plain; charset=utf-8",
+      text: redactSensitiveText(String(item.ref.text || "")),
+    };
+  }
+
+  if (item.ref?.type === "session-file") {
+    const absolutePath = path.resolve(item.ref.path);
+    if (!isInside(store.sessionDir, absolutePath)) {
+      return { ok: false, error: "Artifact path is outside this session." };
+    }
+
+    const stat = await fs.stat(absolutePath).catch(() => null);
+    if (!stat?.isFile()) return { ok: false, error: "Artifact file is missing." };
+    const mime = mimeForPath(absolutePath);
+    const isBinaryRenderable = mime.startsWith("image/") || mime === "application/pdf";
+    const maxBytes = isBinaryRenderable ? MAX_ARTIFACT_IMAGE_BYTES : MAX_ARTIFACT_TEXT_BYTES;
+    if (stat.size > maxBytes) return { ok: false, error: "Artifact is too large to preview safely." };
+
+    const buffer = await fs.readFile(absolutePath);
+    if (isBinaryRenderable) {
+      return {
+        ok: true,
+        id: item.id,
+        kind: mime === "application/pdf" ? "pdf" : "image",
+        title: item.title,
+        path: item.path || "",
+        mime,
+        dataUrl: `data:${mime};base64,${buffer.toString("base64")}`,
+      };
+    }
+
+    if (buffer.includes(0)) return { ok: false, error: "Binary artifact cannot be rendered as text." };
+    return {
+      ok: true,
+      id: item.id,
+      kind: item.kind,
+      title: item.title,
+      path: item.path || "",
+      mime,
+      text: redactSensitiveText(buffer.toString("utf8")),
+    };
+  }
+
+  if (item.ref?.type === "workspace-file") {
+    const itemConfig = item.ref.commandCwd ? { ...config, commandCwd: item.ref.commandCwd } : config;
+    const guard = checkWorkspaceToolUse("read_file", { path: item.ref.path }, itemConfig);
+    if (!guard.allowed) {
+      return { ok: false, error: guard.reason || "Workspace read blocked." };
+    }
+
+    const target = resolveWorkspacePath(itemConfig, item.ref.path);
+    const stat = await fs.stat(target.absolutePath).catch(() => null);
+    if (!stat?.isFile()) return { ok: false, error: "Workspace file is missing." };
+
+    const mime = mimeForPath(target.absolutePath);
+    const isBinaryRenderable = mime.startsWith("image/") || mime === "application/pdf";
+    const maxBytes = isBinaryRenderable ? MAX_ARTIFACT_IMAGE_BYTES : MAX_ARTIFACT_TEXT_BYTES;
+    if (stat.size > maxBytes) return { ok: false, error: "Workspace file is too large to preview safely." };
+
+    const buffer = await fs.readFile(target.absolutePath);
+    if (isBinaryRenderable) {
+      return {
+        ok: true,
+        id: item.id,
+        kind: mime === "application/pdf" ? "pdf" : "image",
+        title: item.title,
+        path: item.path || "",
+        mime,
+        dataUrl: `data:${mime};base64,${buffer.toString("base64")}`,
+      };
+    }
+
+    if (buffer.includes(0)) return { ok: false, error: "Binary workspace file cannot be rendered as text." };
+    return {
+      ok: true,
+      id: item.id,
+      kind: item.kind,
+      title: item.title,
+      path: item.path || "",
+      mime,
+      text: redactSensitiveText(buffer.toString("utf8")),
+    };
+  }
+
+  return { ok: false, error: "Artifact has no readable content." };
+}
+
+export function normalizeCanvasPayload(args, config) {
+  const artifactId = `canvas-${crypto.randomUUID()}`;
+  const title = String(args.title || "Agent canvas item").replace(/\s+/g, " ").trim().slice(0, 120);
+  const pathInput = String(args.path || "").trim();
+  const content = typeof args.content === "string" ? args.content : "";
+  const note = typeof args.note === "string" ? args.note : "";
+
+  if (!title) {
+    return { ok: false, reason: "Canvas title is required." };
+  }
+
+  if (Buffer.byteLength(content, "utf8") > MAX_INLINE_TEXT_BYTES) {
+    return { ok: false, reason: "Canvas content is too large. Write it to a workspace file and send the path instead." };
+  }
+
+  let relativePath = "";
+  if (pathInput) {
+    const guard = checkWorkspaceToolUse("read_file", { path: pathInput }, config);
+    if (!guard.allowed) return { ok: false, reason: guard.reason || "Canvas path is blocked." };
+    relativePath = resolveWorkspacePath(config, pathInput).relativePath;
+  }
+
+  return {
+    ok: true,
+    payload: {
+      artifactId,
+      title,
+      kind: normalizeKind(args.kind, relativePath),
+      path: relativePath,
+      content: content ? redactSensitiveText(content) : "",
+      contentBytes: content ? Buffer.byteLength(content, "utf8") : 0,
+      note: note ? previewText(note, 500) : "",
+      selected: args.selected !== false,
+    },
+  };
+}

package/src/cli.js

@@ -3,6 +3,10 @@ import { loadConfig } from "./config.js";
 import { listAgentWrappers } from "./tool-wrappers.js";
 import { getModelPresets } from "./model-routing.js";
 import { getDockerSandboxStatus, runDockerPreflight } from "./docker-sandbox.js";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const packageDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 
 function readOption(argv, index) {
   const value = argv[index + 1];
@@ -23,7 +27,9 @@ export function parseArgs(argv) {
     sandboxMode: "",
     packageInstallPolicy: "",
     allowShellTool: undefined,
+    allowFileTools: undefined,
     allowWrapperTools: undefined,
+    preferredWrapper: "",
     useDockerSandbox: undefined,
     headless: undefined,
     maxSteps: undefined,
@@ -31,11 +37,28 @@ export function parseArgs(argv) {
     listWrappers: false,
     sandboxStatus: false,
     sandboxPreflight: false,
+    web: false,
+    port: "",
+    host: "",
   };
 
   const parts = [];
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
+    if (arg === "web" || arg === "--web") {
+      result.web = true;
+      continue;
+    }
+    if (arg === "--port") {
+      result.port = readOption(argv, i);
+      i += 1;
+      continue;
+    }
+    if (arg === "--host") {
+      result.host = readOption(argv, i);
+      i += 1;
+      continue;
+    }
     if (arg === "--start-url") {
       result.startUrl = readOption(argv, i);
       i += 1;
@@ -95,10 +118,23 @@ export function parseArgs(argv) {
       result.allowShellTool = true;
       continue;
     }
+    if (arg === "--allow-file-tools") {
+      result.allowFileTools = true;
+      continue;
+    }
+    if (arg === "--no-file-tools") {
+      result.allowFileTools = false;
+      continue;
+    }
     if (arg === "--allow-wrappers") {
       result.allowWrapperTools = true;
       continue;
     }
+    if (arg === "--wrapper" || arg === "--preferred-wrapper") {
+      result.preferredWrapper = readOption(argv, i);
+      i += 1;
+      continue;
+    }
     if (arg === "--docker-sandbox") {
       result.useDockerSandbox = true;
       result.sandboxMode = result.sandboxMode || "docker-readonly";
@@ -150,6 +186,14 @@ function printWrappers() {
 export async function main(argv = process.argv.slice(2)) {
   const args = parseArgs(argv);
 
+  if (args.web) {
+    if (args.port) process.env.PORT = String(args.port);
+    if (args.host) process.env.HOST = String(args.host);
+    process.env.AGINTIFLOW_PACKAGE_DIR = packageDir;
+    await import("../web.js");
+    return;
+  }
+
   if (args.listRoutes) {
     printRoutes();
     return;
@@ -161,7 +205,7 @@ export async function main(argv = process.argv.slice(2)) {
   }
 
   if (args.sandboxStatus || args.sandboxPreflight) {
-    const config = loadConfig({ ...args, goal: args.goal || "sandbox preflight" });
+    const config = loadConfig({ ...args, goal: args.goal || "sandbox preflight" }, { packageDir });
     const result = args.sandboxPreflight
       ? await runDockerPreflight(config, { buildImage: true })
       : { ok: true, status: await getDockerSandboxStatus(config) };
@@ -171,11 +215,11 @@ export async function main(argv = process.argv.slice(2)) {
 
   if (!args.goal && !args.resume) {
     console.error(
-      'Usage: aginti-cli [--routing smart|fast|complex|manual] [--sandbox-mode host|docker-readonly|docker-workspace] [--package-install-policy block|prompt|allow] [--allow-shell] [--allow-wrappers] [--sandbox-status|--sandbox-preflight] "your task"'
+      'Usage: aginti-cli web [--port 3210] OR aginti-cli [--routing smart|fast|complex|manual] [--provider deepseek|openai|mock] [--sandbox-mode host|docker-readonly|docker-workspace] [--package-install-policy block|prompt|allow] [--allow-shell] [--allow-file-tools|--no-file-tools] [--allow-wrappers --wrapper codex] [--sandbox-status|--sandbox-preflight] "your task"'
     );
     process.exit(1);
   }
 
-  const config = loadConfig(args);
+  const config = loadConfig(args, { packageDir });
   await runAgent(config);
 }

package/src/command-policy.js

@@ -5,6 +5,8 @@ const READ_ONLY_PATTERNS = [
   /^pwd$/,
   /^date$/,
   /^whoami$/,
+  /^which\s+[-\w.]+(?:\s+[-\w.]+)*$/,
+  /^command\s+-v\s+[-\w.]+$/,
   /^uname(?:\s+-a)?$/,
   /^ls(?:\s+[-\w./~*]+)*$/,
   /^find(?:\s+[./~\w-]+)*(?:\s+-maxdepth\s+\d+)?(?:\s+-type\s+[fd])?$/,
@@ -31,6 +33,12 @@ const TEST_PATTERNS = [
   /^pytest(?:\s+[-\w./:=]+)*$/,
 ];
 
+const TOOLCHAIN_PATTERNS = [
+  /^python(?:3)?\s+[-\w./]+\.py(?:\s+[-\w./:=]+)*$/,
+  /^latexmk\s+(?=[-\w./=\s]*-pdf\b)(?:(?:-cd|-pdf|-interaction=nonstopmode|-halt-on-error|-output-directory=[-\w./]+)\s+)+[-\w./]+\.tex$/,
+  /^pdflatex\s+(?:(?:-interaction=nonstopmode|-halt-on-error|-output-directory=[-\w./]+|-jobname\s+[-\w./]+)\s+)*[-\w./]+\.tex$/,
+];
+
 const PACKAGE_INSTALL_PATTERNS = [
   /^npm\s+ci$/,
   /^npm\s+install$/,
@@ -121,6 +129,9 @@ export function classifyCommand(command) {
   if (matchAny(TEST_PATTERNS, normalized)) {
     return { category: "test", needsNetwork: false, writesWorkspace: false };
   }
+  if (matchAny(TOOLCHAIN_PATTERNS, normalized)) {
+    return { category: "toolchain", needsNetwork: false, writesWorkspace: true };
+  }
   if (matchAny(PACKAGE_INSTALL_PATTERNS, normalized)) {
     return { category: "package-install", needsNetwork: true, writesWorkspace: true };
   }
@@ -176,6 +187,16 @@ export function evaluateCommandPolicy(command, config) {
     }
   }
 
+  if (classification.writesWorkspace && config.useDockerSandbox && sandboxMode !== "docker-workspace") {
+    return {
+      allowed: false,
+      category: classification.category,
+      reason: "Workspace-writing toolchain commands must run in Docker workspace-write sandbox mode.",
+      sandboxMode,
+      packageInstallPolicy,
+    };
+  }
+
   return {
     allowed: true,
     ...classification,

package/src/config.js

@@ -2,6 +2,7 @@ import path from "node:path";
 import crypto from "node:crypto";
 import { getProviderDefaults, normalizeRoutingMode, selectModelRoute } from "./model-routing.js";
 import { normalizePackageInstallPolicy, normalizeSandboxMode } from "./command-policy.js";
+import { normalizeWrapperName } from "./tool-wrappers.js";
 
 function parseBoolean(value, fallback) {
   if (value === undefined) return fallback;
@@ -37,6 +38,7 @@ export function resolveRuntimeConfig(args, overrides = {}) {
 
   const defaults = getProviderDefaults(route.provider);
   const baseDir = path.resolve(overrides.baseDir || process.cwd());
+  const packageDir = path.resolve(overrides.packageDir || process.env.AGINTIFLOW_PACKAGE_DIR || baseDir);
   const dockerRequested = parseBoolean(overrides.useDockerSandbox ?? args.useDockerSandbox ?? process.env.USE_DOCKER_SANDBOX, false);
   const requestedSandboxMode =
     overrides.sandboxMode || args.sandboxMode || process.env.SANDBOX_MODE || (dockerRequested ? "docker-readonly" : "host");
@@ -45,6 +47,7 @@ export function resolveRuntimeConfig(args, overrides = {}) {
   return {
     ...defaults,
     baseDir,
+    packageDir,
     goal: args.goal || "",
     startUrl: args.startUrl || "",
     resume: args.resume || "",
@@ -66,10 +69,14 @@ export function resolveRuntimeConfig(args, overrides = {}) {
     allowPasswords: parseBoolean(overrides.allowPasswords ?? process.env.ALLOW_PASSWORDS, false),
     allowDestructive: parseBoolean(overrides.allowDestructive ?? process.env.ALLOW_DESTRUCTIVE, false),
     allowShellTool: parseBoolean(overrides.allowShellTool ?? args.allowShellTool ?? process.env.ALLOW_SHELL_TOOL, false),
+    allowFileTools: parseBoolean(overrides.allowFileTools ?? args.allowFileTools ?? process.env.ALLOW_FILE_TOOLS, true),
     allowWrapperTools: parseBoolean(
       overrides.allowWrapperTools ?? args.allowWrapperTools ?? process.env.ALLOW_WRAPPER_TOOLS,
       false
     ),
+    preferredWrapper: normalizeWrapperName(
+      overrides.preferredWrapper ?? args.preferredWrapper ?? process.env.PREFERRED_WRAPPER ?? process.env.AGENT_WRAPPER
+    ),
     wrapperTimeoutMs: parseNumber(overrides.wrapperTimeoutMs ?? process.env.WRAPPER_TIMEOUT_MS, 120000),
     sandboxMode,
     packageInstallPolicy: normalizePackageInstallPolicy(
@@ -84,6 +91,6 @@ export function resolveRuntimeConfig(args, overrides = {}) {
   };
 }
 
-export function loadConfig(args) {
-  return resolveRuntimeConfig(args);
+export function loadConfig(args, overrides = {}) {
+  return resolveRuntimeConfig(args, overrides);
 }