nolo-cli 0.1.22 → 0.1.26

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,
+  };
+}

package/cliEnvHelpers.ts

@@ -0,0 +1,44 @@
+import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
+import { NOLO_CLUSTER_SERVERS } from "./database/config";
+
+export type EnvLike = Record<string, string | undefined>;
+
+export function resolveServerUrl(env: EnvLike) {
+  return (env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL).replace(/\/+$/, "");
+}
+
+export function resolveServerCandidates(env: EnvLike, preferred?: string | null) {
+  const values = [
+    preferred?.trim(),
+    env.NOLO_SERVER,
+    env.BASE_URL,
+    env.NOLO_SERVER_URL,
+    DEFAULT_NOLO_SERVER_URL,
+    ...NOLO_CLUSTER_SERVERS,
+  ];
+  return [...new Set(
+    values
+      .filter((value): value is string => typeof value === "string" && value.trim().length > 0)
+      .map((value) => value.replace(/\/+$/, ""))
+  )];
+}
+
+export function resolveAuthToken(env: EnvLike) {
+  return env.AUTH_TOKEN || env.AUTH || "";
+}
+
+export function parseUserIdFromAuthToken(token: string) {
+  const payload = token.trim().split(".")[0];
+  if (!payload) return "";
+  try {
+    const parsed = JSON.parse(Buffer.from(payload, "base64").toString("utf8"));
+    return typeof parsed?.userId === "string" ? parsed.userId : "";
+  } catch {
+    return "";
+  }
+}
+
+export function readOption(args: string[], flag: string) {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : undefined;
+}