nolo-cli 0.1.23 → 0.1.26

package/ai/tools/index.ts

@@ -22,6 +22,7 @@ import {
   createWorkflowFunc,
 } from "./createWorkflowTool";
 import { delayFunctionSchema, delayFunc } from "./delayTool";
+import { canonicalizeToolName } from "./toolNameAliases";
 import {
   completeDialogGoalFunc,
   completeDialogGoalFunctionSchema,
@@ -160,6 +161,10 @@ import {
   fetchWebpageFunctionSchema,
   fetchWebpageFunc,
 } from "./fetchWebpageTool";
+import {
+  convertMarxistsBookToOfflineHtmlFunctionSchema,
+  convertMarxistsBookToOfflineHtmlFunc,
+} from "./convertMarxistsBookTool";
 import {
   readXPostFunctionSchema,
   readXPostFunc,
@@ -281,7 +286,7 @@ import {
   rememberMemoryFunc,
   rememberMemoryFunctionSchema,
 } from "./rememberMemoryTool";
-import { execBashFunctionSchema, execBashFunc, execShellFunctionSchema, execShellFunc } from "./execBashTool";
+import { execShellFunctionSchema, execShellFunc } from "./execShellTool";
 import { checkEnvFunctionSchema, checkEnvFunc } from "./checkEnvTool";
 
 import { agentToolDefinitions } from "./agent/agentTools";
@@ -1464,6 +1469,23 @@ const baseToolDefinitions: ToolDefinition[] = [
     },
     behavior: "data",
   },
+  {
+    id: "convertMarxistsBookToOfflineHtml",
+    schema: convertMarxistsBookToOfflineHtmlFunctionSchema,
+    executor: convertMarxistsBookToOfflineHtmlFunc,
+    description: {
+      name: "convertMarxistsBookToOfflineHtml",
+      description:
+        "将 Marxists.org 中文旧式书籍页面转换成保留原 CSS、背景和排版的离线单 HTML。",
+      category: "网络与智能",
+    },
+    behavior: "data",
+    capability: "web_access",
+    riskLevel: "low",
+    costLevel: "medium",
+    defaultConsent: "auto",
+    cancelable: true,
+  },
   {
     id: "readXPost",
     schema: readXPostFunctionSchema,
@@ -1837,18 +1859,6 @@ const baseToolDefinitions: ToolDefinition[] = [
     behavior: "data",
     uiGroup: "general",
   },
-  {
-    id: "execBash",
-    schema: execBashFunctionSchema,
-    executor: execBashFunc,
-    description: {
-      name: "exec_bash",
-      description:
-        "通过后端 diff-server 的 /api/exec-bash 接口执行一条 bash 命令，仅用于本地开发调试。",
-      category: "网络与智能",
-    },
-    behavior: "action",
-  },
   {
     id: "execShell",
     schema: execShellFunctionSchema,
@@ -2070,7 +2080,7 @@ export const findToolExecutor = (
   executor: ToolDefinition["executor"];
   canonicalName: string;
 } => {
-  const normalizedRawName = normalizeToolName(rawName);
+  const normalizedRawName = normalizeToolName(canonicalizeToolName(rawName));
   const canonicalName = Object.keys(toolExecutors).find(
     (key) => normalizeToolName(key) === normalizedRawName
   );

package/ai/tools/marxistsOfflineBook.ts

@@ -0,0 +1,253 @@
+export type MarxistsOfflineBookPage = {
+  name: string;
+  url: string;
+  title: string;
+};
+
+export type MarxistsOfflineBookResult = {
+  title: string;
+  startUrl: string;
+  indexUrl: string;
+  stylesheetUrl: string | null;
+  pages: MarxistsOfflineBookPage[];
+  html: string;
+  validation: {
+    pageCount: number;
+    hasEmbeddedAssets: boolean;
+    hasNetworkUrls: boolean;
+    hasUtf8Meta: boolean;
+    byteLength: number;
+  };
+};
+
+export type ConvertMarxistsBookArgs = {
+  startUrl: string;
+  encoding?: string;
+  fetchImpl?: typeof fetch;
+  maxPages?: number;
+};
+
+const DEFAULT_ENCODING = "gb2312";
+const USER_AGENT =
+  "Mozilla/5.0 (compatible; NoloMarxistsOfflineBook/1.0; +https://nolo.chat)";
+
+const normalizeBookBaseUrl = (startUrl: string): URL => {
+  const parsed = new URL(startUrl);
+  if (!/^https?:$/i.test(parsed.protocol)) {
+    throw new Error("startUrl must be an http or https URL.");
+  }
+  return new URL("./", parsed);
+};
+
+const decodeBytes = (bytes: ArrayBuffer, encoding: string): string => {
+  try {
+    return new TextDecoder(encoding).decode(bytes);
+  } catch {
+    return new TextDecoder(DEFAULT_ENCODING).decode(bytes);
+  }
+};
+
+const fetchBytes = async (
+  url: string,
+  fetchImpl: typeof fetch,
+): Promise<ArrayBuffer> => {
+  const response = await fetchImpl(url, {
+    headers: {
+      "user-agent": USER_AGENT,
+      accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+    },
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url}: HTTP ${response.status}`);
+  }
+  return response.arrayBuffer();
+};
+
+const extractTitle = (html: string): string => {
+  return (
+    html.match(/<title>([\s\S]*?)<\/title>/i)?.[1]
+      ?.replace(/<[^>]+>/g, " ")
+      .replace(/\s+/g, " ")
+      .trim() || ""
+  );
+};
+
+const extractBody = (html: string): string => {
+  return html.match(/<body[^>]*>([\s\S]*?)<\/body>/i)?.[1] ?? html;
+};
+
+export const discoverMarxistsBookPageNames = (
+  indexHtml: string,
+  maxPages = 80,
+): string[] => {
+  const pageNames = [...indexHtml.matchAll(/href=["']?([^"' >#]+\.htm)(#[^"' >]*)?["']?/gi)]
+    .map((match) => match[1])
+    .filter((href) => !href.includes("/") && !href.startsWith(".."))
+    .map((href) => href.trim())
+    .filter(Boolean)
+    .sort();
+
+  const uniqueNames = Array.from(new Set(["index.htm", ...pageNames]));
+  if (uniqueNames.length <= 1) {
+    throw new Error("No same-directory .htm chapter links were found in index.htm.");
+  }
+  if (uniqueNames.length > maxPages) {
+    throw new Error(
+      `Refusing to download ${uniqueNames.length} pages; maxPages is ${maxPages}.`,
+    );
+  }
+  return uniqueNames;
+};
+
+const extractStylesheetHref = (html: string): string | null => {
+  return (
+    html.match(/<link[^>]+href=["']([^"']+\.css)["'][^>]*>/i)?.[1] ?? null
+  );
+};
+
+const guessMimeType = (url: string): string => {
+  const pathname = new URL(url).pathname.toLowerCase();
+  if (pathname.endsWith(".gif")) return "image/gif";
+  if (pathname.endsWith(".png")) return "image/png";
+  if (pathname.endsWith(".jpg") || pathname.endsWith(".jpeg")) return "image/jpeg";
+  if (pathname.endsWith(".webp")) return "image/webp";
+  if (pathname.endsWith(".css")) return "text/css";
+  return "application/octet-stream";
+};
+
+export const inlineCssUrlAssets = async (args: {
+  css: string;
+  cssUrl: string;
+  fetchImpl: typeof fetch;
+}): Promise<string> => {
+  const replacements = new Map<string, string>();
+  const matches = [...args.css.matchAll(/url\((['"]?)([^)'"]+)\1\)/gi)];
+
+  for (const match of matches) {
+    const rawRef = match[2].trim();
+    if (!rawRef || /^(data:|https?:)/i.test(rawRef)) continue;
+    const assetUrl = new URL(rawRef, args.cssUrl).toString();
+    if (!replacements.has(rawRef)) {
+      const bytes = await fetchBytes(assetUrl, args.fetchImpl);
+      const base64 = Buffer.from(bytes).toString("base64");
+      replacements.set(
+        rawRef,
+        `data:${guessMimeType(assetUrl)};base64,${base64}`,
+      );
+    }
+  }
+
+  return args.css.replace(/url\((['"]?)([^)'"]+)\1\)/gi, (full, quote, rawRef) => {
+    const replacement = replacements.get(String(rawRef).trim());
+    return replacement ? `url('${replacement}')` : full;
+  });
+};
+
+const rewriteLocalChapterLinks = (body: string): string => {
+  return body.replace(
+    /href=["']([^"']+\.htm)(#[^"']*)?["']/gi,
+    (_full, href: string, hash: string | undefined) => {
+      const anchor = href.replace(/\.htm$/i, "");
+      return `href="#${anchor}${hash ? `-${hash.replace(/^#/, "")}` : ""}"`;
+    },
+  );
+};
+
+const buildSingleHtml = (args: {
+  title: string;
+  css: string;
+  pages: Array<MarxistsOfflineBookPage & { body: string }>;
+}): string => {
+  const sections = args.pages.map((page) => {
+    const anchor = page.name.replace(/\.htm$/i, "");
+    return `<section class="chapter" id="${anchor}"><div class="chapter-source">${page.title}</div>${rewriteLocalChapterLinks(page.body)}</section>`;
+  });
+
+  return `<!doctype html>
+<html lang="zh-CN">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${args.title}</title>
+<style>
+${args.css}
+body { margin: 0 10px; }
+.table1 { max-width: 960px; width: min(960px, calc(100vw - 20px)); }
+.chapter { page-break-after: always; break-after: page; }
+.chapter-source { display: none; }
+@media screen and (max-width: 700px) {
+  html { margin-left: 8px !important; margin-right: 8px !important; }
+  body { margin-left: 8px !important; margin-right: 8px !important; }
+  .table1 { width: 100% !important; max-width: 100% !important; }
+  table { max-width: 100% !important; }
+}
+@media print {
+  .chapter { page-break-after: always; }
+}
+</style>
+</head>
+<body id="top">
+${sections.join("\n")}
+</body>
+</html>`;
+};
+
+export async function convertMarxistsBookToOfflineHtml(
+  args: ConvertMarxistsBookArgs,
+): Promise<MarxistsOfflineBookResult> {
+  const startUrl = args.startUrl?.trim();
+  if (!startUrl) throw new Error("startUrl is required.");
+
+  const fetchImpl = args.fetchImpl ?? fetch;
+  const encoding = args.encoding || DEFAULT_ENCODING;
+  const bookBaseUrl = normalizeBookBaseUrl(startUrl);
+  const indexUrl = new URL("index.htm", bookBaseUrl).toString();
+  const indexHtml = decodeBytes(await fetchBytes(indexUrl, fetchImpl), encoding);
+  const pageNames = discoverMarxistsBookPageNames(indexHtml, args.maxPages);
+
+  const pages: Array<MarxistsOfflineBookPage & { body: string }> = [];
+  for (const name of pageNames) {
+    const pageUrl = new URL(name, bookBaseUrl).toString();
+    const html = decodeBytes(await fetchBytes(pageUrl, fetchImpl), encoding);
+    pages.push({
+      name,
+      url: pageUrl,
+      title: extractTitle(html),
+      body: extractBody(html),
+    });
+  }
+
+  const stylesheetHref =
+    extractStylesheetHref(indexHtml) ||
+    pages.map((page) => extractStylesheetHref(page.body)).find(Boolean) ||
+    "../../MIA01.css";
+  const stylesheetUrl = stylesheetHref
+    ? new URL(stylesheetHref, indexUrl).toString()
+    : null;
+  const rawCss = stylesheetUrl
+    ? decodeBytes(await fetchBytes(stylesheetUrl, fetchImpl), encoding)
+    : "";
+  const css = stylesheetUrl
+    ? await inlineCssUrlAssets({ css: rawCss, cssUrl: stylesheetUrl, fetchImpl })
+    : rawCss;
+
+  const title = extractTitle(indexHtml) || pages[0]?.title || "Offline Book";
+  const html = buildSingleHtml({ title, css, pages });
+  const byteLength = new TextEncoder().encode(html).byteLength;
+
+  return {
+    title,
+    startUrl,
+    indexUrl,
+    stylesheetUrl,
+    pages: pages.map(({ body: _body, ...page }) => page),
+    html,
+    validation: {
+      pageCount: pages.length,
+      hasEmbeddedAssets: html.includes("data:image/"),
+      hasNetworkUrls: /https?:\/\//i.test(html),
+      hasUtf8Meta: html.includes('<meta charset="utf-8">'),
+      byteLength,
+    },
+  };
+}

package/ai/tools/modelUsageTools.ts

@@ -52,11 +52,13 @@ export const queryModelUsageFunctionSchema = {
       },
       thresholdCredits: {
         type: "number",
-        description: "可选阈值，单位 credits；返回 threshold.exceeded。",
+        description:
+          "可选阈值，单位 credits；返回 threshold.exceeded 与 0-100 的 threshold.usedPercent。",
       },
       thresholdUsd: {
         type: "number",
-        description: "可选阈值，单位 USD；会按 creditsPerUsd 换算。",
+        description:
+          "可选阈值，单位 USD；会按 creditsPerUsd 换算，并返回 0-100 的 threshold.usedPercent。",
       },
     },
   },

package/ai/tools/readTool.ts

@@ -9,6 +9,7 @@ import { isTableMetaKey, rowKey, isAgentKey } from "database/keys";
 import { DataType } from "create/types";
 import { TableMeta } from "render/table/types";
 import { fetchAndSerializeTable } from "render/table/utils/tableSerialization";
+import { readFileFunc } from "./readFileTool";
 
 // ---- Types ----
 
@@ -24,6 +25,13 @@ export type ReadArgs = {
    * - true：使用 readAndWaitAction，等待远程与本地决策后返回“权威”结果
    */
   waitRemote?: boolean;
+
+  /**
+   * Backward-compatible escape hatch for models that call read with a local
+   * file path even when the readFile tool is available.
+   */
+  filePath?: string;
+  path?: string;
 };
 
 // ---- 工具 Schema，供 LLM 调用 ----
@@ -68,6 +76,29 @@ export async function readFunc(
   context?: { parentMessageId?: string; signal?: AbortSignal }
 ): Promise<{ rawData: any; displayData?: string }> {
   const { dbKey, waitRemote = false } = args || {};
+  const localFilePath =
+    typeof args?.filePath === "string"
+      ? args.filePath
+      : typeof args?.path === "string"
+        ? args.path
+        : "";
+
+  if (!dbKey && localFilePath) {
+    const result = await readFileFunc(
+      {
+        filePath: localFilePath,
+        startLine: (args as any).startLine,
+        endLine: (args as any).endLine,
+      },
+      thunkApi,
+      context
+    );
+    return {
+      rawData: result,
+      displayData:
+        typeof result === "string" ? result : JSON.stringify(result, null, 2),
+    };
+  }
 
   if (!dbKey || typeof dbKey !== "string") {
     throw new Error("read 工具需要提供字符串类型的 id（dbKey）。");

package/ai/tools/toolApiClient.ts

@@ -14,6 +14,7 @@
 
 import type { RootState } from "app/store";
 import { selectCurrentServer } from "app/settings/settingSlice";
+import { getIsDesktopApp } from "app/utils/env";
 import { selectCurrentToken } from "auth/authSlice";
 import { selectCurrentDialogKey } from "chat/dialog/dialogSlice";
 import { extractCustomId } from "core/prefix";
@@ -39,6 +40,34 @@ export const resolveToolBaseUrl = (currentServer?: string | null): string => {
     return currentServer.replace(/\/+$/, "");
 };
 
+const DESKTOP_LOCAL_TOOL_PATHS = new Set([
+    "/api/exec-shell",
+    "/api/check-env",
+    "/api/read-file",
+    "/api/write-file",
+    "/api/apply-edit",
+    "/api/apply-line-edits",
+    "/api/code-search",
+    "/api/search-repo",
+]);
+
+const getWindowOrigin = (): string | null => {
+    const _window = (globalThis as any).window;
+    const origin = _window?.location?.origin;
+    return typeof origin === "string" && origin ? origin.replace(/\/+$/, "") : null;
+};
+
+export const resolveToolApiBaseUrl = (
+    currentServer?: string | null,
+    path?: string
+): string => {
+    if (path && DESKTOP_LOCAL_TOOL_PATHS.has(path) && getIsDesktopApp()) {
+        const localOrigin = getWindowOrigin();
+        if (localOrigin) return localOrigin;
+    }
+    return resolveToolBaseUrl(currentServer);
+};
+
 export const getRequestConfig = (thunkApi: any): RequestConfig => {
     const state = thunkApi.getState() as RootState;
     const currentServer = selectCurrentServer(state);
@@ -118,6 +147,9 @@ export const buildToolRequestHeaders = (
     if (agentKey && typeof agentKey === "string" && agentKey.trim()) {
         headers["X-Nolo-Agent-Key"] = agentKey.trim();
     }
+    if (typeof window !== "undefined" && (window as any).__NOLO_DESKTOP__) {
+        headers["X-Nolo-Desktop-Tool"] = "1";
+    }
     return headers;
 };
 
@@ -152,7 +184,9 @@ export async function callToolApi<T = any>(
 ): Promise<T> {
     const { currentServer } = getRequestConfig(thunkApi);
 
-    const url = `${currentServer}${path}`;
+    const baseUrl = resolveToolApiBaseUrl(currentServer, path);
+    if (!baseUrl) throw new Error("无法获取工具服务器地址。");
+    const url = `${baseUrl}${path}`;
     const headers = buildToolRequestHeaders(thunkApi, options);
 
     const response = await fetch(url, {

package/ai/tools/toolNameAliases.ts

@@ -15,6 +15,19 @@ const LEGACY_TOOL_NAME_ALIASES: Record<string, string> = {
   read_doc: "readDoc",
   createdoc: "createDoc",
   updateDocTool: "updateDoc",
+  readLocal: "readLocalFile",
+  read_local: "readLocalFile",
+  readLocalTool: "readLocalFile",
+  listLocal: "listLocalFiles",
+  list_local: "listLocalFiles",
+  terminalCommand: "execShell",
+  terminal_command: "execShell",
+  runCommand: "execShell",
+  run_command: "execShell",
+  runInBash: "execShell",
+  run_in_bash: "execShell",
+  executeCommand: "execShell",
+  execute_command: "execShell",
 };
 
 const normalizeToolName = (name: string): string =>

package/cliCommandAdapters.ts

@@ -0,0 +1,28 @@
+import type { CliCommandHandler, CliRuntimeContext } from "./cliCommandTypes";
+
+export function withCliEnv<TDeps extends { env: NodeJS.ProcessEnv }>(
+  command: (args: string[], deps: TDeps) => Promise<number>
+): CliCommandHandler {
+  return (args: string[], ctx: CliRuntimeContext) =>
+    command(args, { env: ctx.env } as TDeps);
+}
+
+export function withCliEnvAndScriptDir<TDeps extends { env: NodeJS.ProcessEnv; scriptDir: string }>(
+  command: (args: string[], deps: TDeps) => Promise<number>
+): CliCommandHandler {
+  return (args: string[], ctx: CliRuntimeContext) =>
+    command(args, {
+      env: ctx.env,
+      scriptDir: ctx.scriptDir,
+    } as TDeps);
+}
+
+export function withCliEntrypointEnv<TDeps extends { env: NodeJS.ProcessEnv; cliEntrypointPath: string }>(
+  command: (args: string[], deps: TDeps) => Promise<number>
+): CliCommandHandler {
+  return (args: string[], ctx: CliRuntimeContext) =>
+    command(args, {
+      env: ctx.env,
+      cliEntrypointPath: ctx.entrypointPath,
+    } as TDeps);
+}

package/cliCommandDispatch.ts

@@ -0,0 +1,66 @@
+import { fileURLToPath } from "node:url";
+import type { CliPackageInfo, CliRuntimeContext, CommandEntry } from "./cliCommandTypes";
+
+export async function runResolvedCommand(
+  command: CommandEntry,
+  originalArgs: string[],
+  ctx: CliRuntimeContext,
+  deps: {
+    runScript: (script: string, forwardedArgs: string[], env: NodeJS.ProcessEnv) => Promise<number>;
+  }
+) {
+  if (command.kind === "internal") {
+    if (!command.handler) {
+      throw new Error(`Internal command ${command.path.join(" ")} is missing a handler.`);
+    }
+    return command.handler(originalArgs.slice(command.path.length), ctx);
+  }
+
+  if (!command.script) {
+    throw new Error(`Script command ${command.path.join(" ")} is missing a script.`);
+  }
+
+  const forwardedArgs = [...(command.fixedArgs ?? []), ...originalArgs.slice(command.path.length)];
+  return deps.runScript(command.script, forwardedArgs, ctx.env);
+}
+
+function readOption(args: string[], flag: string) {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : undefined;
+}
+
+function buildDaemonEnv(args: string[], runtimeEnv: NodeJS.ProcessEnv) {
+  const serverUrl = readOption(args, "--server-url") || readOption(args, "--server");
+  const apiKey = readOption(args, "--api-key") || readOption(args, "--token");
+  return {
+    ...runtimeEnv,
+    ...(serverUrl ? { NOLO_SERVER: serverUrl } : {}),
+    ...(apiKey ? { AUTH_TOKEN: apiKey } : {}),
+  };
+}
+
+export function looksLikeDaemonShortcut(args: string[]) {
+  return args.includes("--server-url") || args.includes("--api-key");
+}
+
+export function createCliRuntimeContext(args: {
+  env: NodeJS.ProcessEnv;
+  scriptDir: string;
+  entrypointPath?: string;
+  packageInfo: CliPackageInfo;
+}): CliRuntimeContext {
+  return {
+    env: args.env,
+    scriptDir: args.scriptDir,
+    entrypointPath: args.entrypointPath ?? fileURLToPath(import.meta.url),
+    packageInfo: args.packageInfo,
+  };
+}
+
+export function withDaemonShortcutArgs(args: string[], runtimeEnv: NodeJS.ProcessEnv) {
+  if (!looksLikeDaemonShortcut(args)) return { commandArgs: args, envOverride: null as NodeJS.ProcessEnv | null };
+  return {
+    commandArgs: ["daemon", ...args],
+    envOverride: buildDaemonEnv(args, runtimeEnv),
+  };
+}

package/cliCommandFactories.ts

@@ -0,0 +1,34 @@
+import {
+  withCliEntrypointEnv,
+  withCliEnv,
+  withCliEnvAndScriptDir,
+} from "./cliCommandAdapters";
+import {
+  createInternalCommand,
+  type CliCommandHandler,
+  type CommandEntry,
+} from "./cliCommandTypes";
+
+export function createEnvCommand<TDeps extends { env: NodeJS.ProcessEnv }>(
+  path: string[],
+  description: string,
+  command: (args: string[], deps: TDeps) => Promise<number>
+): CommandEntry {
+  return createInternalCommand(path, description, withCliEnv(command) as CliCommandHandler);
+}
+
+export function createEnvScriptDirCommand<TDeps extends { env: NodeJS.ProcessEnv; scriptDir: string }>(
+  path: string[],
+  description: string,
+  command: (args: string[], deps: TDeps) => Promise<number>
+): CommandEntry {
+  return createInternalCommand(path, description, withCliEnvAndScriptDir(command) as CliCommandHandler);
+}
+
+export function createEntrypointEnvCommand<TDeps extends { env: NodeJS.ProcessEnv; cliEntrypointPath: string }>(
+  path: string[],
+  description: string,
+  command: (args: string[], deps: TDeps) => Promise<number>
+): CommandEntry {
+  return createInternalCommand(path, description, withCliEntrypointEnv(command) as CliCommandHandler);
+}

package/cliCommandTypes.ts

@@ -0,0 +1,49 @@
+import type { readPackageInfo } from "./updateCommands";
+
+export type CliPackageInfo = ReturnType<typeof readPackageInfo>;
+
+export type CliRuntimeContext = {
+  env: NodeJS.ProcessEnv;
+  scriptDir: string;
+  entrypointPath: string;
+  packageInfo: CliPackageInfo;
+};
+
+export type CliCommandHandler = (args: string[], ctx: CliRuntimeContext) => Promise<number>;
+
+export type CommandEntry = {
+  path: string[];
+  description: string;
+  kind: "internal" | "script";
+  script?: string;
+  fixedArgs?: string[];
+  handler?: CliCommandHandler;
+};
+
+export function createScriptCommand(
+  path: string[],
+  script: string,
+  description: string,
+  fixedArgs?: string[]
+): CommandEntry {
+  return {
+    path,
+    kind: "script",
+    script,
+    description,
+    ...(fixedArgs ? { fixedArgs } : {}),
+  };
+}
+
+export function createInternalCommand(
+  path: string[],
+  description: string,
+  handler: CliCommandHandler
+): CommandEntry {
+  return {
+    path,
+    kind: "internal",
+    description,
+    handler,
+  };
+}