@oh-my-tool/cli 0.2.0 → 0.3.1

package/src/core/executor.ts

@@ -1,84 +1,84 @@
-import type { Logger, SecretStore, ToolContext, ToolResult } from "@oh-my-tool/sdk";
-import { ToolError } from "@oh-my-tool/sdk";
-import type { Config } from "../config/config";
-import { getConnectionConfig } from "../config/config";
-import { resolveTool, OmtError, type Registry } from "./registry";
-import { validateInput, type Schema } from "./schema";
-import { validateConnectionInput, applyLimits, PolicyError } from "../policy/policy";
-import { loadExtension } from "../extension/loader";
-import type { OmtResult } from "./result";
-
-const noopLogger: Logger = {
-  debug: () => {},
-  info: () => {},
-  warn: () => {},
-  error: () => {},
-};
-
-export interface ExecutorDeps {
-  registry: Registry;
-  config: Config;
-  secrets: SecretStore;
-  logger?: Logger;
-}
-
-function hasConnection(schema: Schema | undefined): boolean {
-  return Boolean(schema?.properties && "connection" in schema.properties);
-}
-
-export async function executeTool(
-  deps: ExecutorDeps,
-  toolName: string,
-  rawInput: Record<string, unknown>,
-): Promise<OmtResult> {
-  const started = Date.now();
-  try {
-    const { extension, tool } = resolveTool(deps.registry, toolName);
-    const schema = tool.inputSchema as Schema | undefined;
-
-    const limits = applyLimits(rawInput);
-    const normalized = { ...rawInput, maxRows: limits.maxRows, timeoutMs: limits.timeoutMs };
-
-    const needsConnection = hasConnection(schema) || "connection" in normalized;
-    if (needsConnection) {
-      validateConnectionInput(normalized, deps.config, extension.id);
-    }
-
-    const input = validateInput(schema, normalized);
-
-    const connectionCfg = needsConnection
-      ? getConnectionConfig(deps.config, extension.id, String(input.connection))
-      : undefined;
-
-    const ctx: ToolContext = {
-      toolName,
-      logger: deps.logger ?? noopLogger,
-      config: (connectionCfg ?? {}) as Record<string, unknown>,
-      secrets: deps.secrets,
-    };
-
-    const def = await loadExtension(extension);
-    const handler = def.handlers[toolName];
-    if (!handler) {
-      throw new OmtError("HANDLER_MISSING", `no handler for ${toolName}`);
-    }
-
-    const result: ToolResult = await handler(ctx, input);
-    const durationMs = Date.now() - started;
-    return {
-      ok: true,
-      tool: toolName,
-      data: result.data,
-      meta: { durationMs, ...(result.meta ?? {}) },
-    };
-  } catch (e) {
-    const durationMs = Date.now() - started;
-    if (e instanceof PolicyError) {
-      return { ok: false, tool: toolName, error: { code: "POLICY_VIOLATION", message: e.message } };
-    }
-    if (e instanceof ToolError) {
-      return { ok: false, tool: toolName, error: { code: e.code, message: e.message } };
-    }
+import type { Logger, SecretStore, ToolContext, ToolResult } from "@oh-my-tool/sdk";
+import { ToolError } from "@oh-my-tool/sdk";
+import type { Config } from "../config/config";
+import { getConnectionConfig, sanitizeExtensionConnections } from "../config/config";
+import { resolveTool, OmtError, type Registry } from "./registry";
+import { validateInput, type Schema } from "./schema";
+import { validateConnectionInput, applyLimits, PolicyError } from "../policy/policy";
+import { loadExtension } from "../extension/loader";
+import type { OmtResult } from "./result";
+
+const noopLogger: Logger = {
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+};
+
+export interface ExecutorDeps {
+  registry: Registry;
+  config: Config;
+  secrets: SecretStore;
+  logger?: Logger;
+}
+
+function hasConnection(schema: Schema | undefined): boolean {
+  return Boolean(schema?.properties && "connection" in schema.properties);
+}
+
+export async function executeTool(
+  deps: ExecutorDeps,
+  toolName: string,
+  rawInput: Record<string, unknown>,
+): Promise<OmtResult> {
+  const started = Date.now();
+  try {
+    const { extension, tool } = resolveTool(deps.registry, toolName);
+    const schema = tool.inputSchema as Schema | undefined;
+
+    const limits = applyLimits(rawInput);
+    const normalized = { ...rawInput, maxRows: limits.maxRows, timeoutMs: limits.timeoutMs };
+
+    const needsConnection = hasConnection(schema) || "connection" in normalized;
+    if (needsConnection) {
+      validateConnectionInput(normalized, deps.config, extension.id);
+    }
+
+    const input = validateInput(schema, normalized);
+
+    const connectionCfg = needsConnection
+      ? getConnectionConfig(deps.config, extension.id, String(input.connection))
+      : undefined;
+
+    const ctx: ToolContext = {
+      toolName,
+      logger: deps.logger ?? noopLogger,
+      config: (connectionCfg ?? { connections: sanitizeExtensionConnections(deps.config)[extension.id] ?? {} }) as Record<string, unknown>,
+      secrets: deps.secrets,
+    };
+
+    const def = await loadExtension(extension);
+    const handler = def.handlers[toolName];
+    if (!handler) {
+      throw new OmtError("HANDLER_MISSING", `no handler for ${toolName}`);
+    }
+
+    const result: ToolResult = await handler(ctx, input);
+    const durationMs = Date.now() - started;
+    return {
+      ok: true,
+      tool: toolName,
+      data: result.data,
+      meta: { durationMs, ...(result.meta ?? {}) },
+    };
+  } catch (e) {
+    const durationMs = Date.now() - started;
+    if (e instanceof PolicyError) {
+      return { ok: false, tool: toolName, error: { code: "POLICY_VIOLATION", message: e.message } };
+    }
+    if (e instanceof ToolError) {
+      return { ok: false, tool: toolName, error: { code: e.code, message: e.message } };
+    }
     if (e instanceof OmtError) {
       return { ok: false, tool: toolName, error: { code: e.code, message: e.message } };
     }
@@ -89,11 +89,11 @@ export async function executeTool(
         error: { code: (e as { code: string }).code, message: e instanceof Error ? e.message : String(e) },
       };
     }
-    return {
-      ok: false,
-      tool: toolName,
-      error: { code: "EXECUTION_FAILED", message: e instanceof Error ? e.message : String(e) },
-    };
-  }
-}
-
+    return {
+      ok: false,
+      tool: toolName,
+      error: { code: "EXECUTION_FAILED", message: e instanceof Error ? e.message : String(e) },
+    };
+  }
+}
+

package/src/core/registry.ts

@@ -1,33 +1,33 @@
-import type { ExtensionManifest } from "@oh-my-tool/sdk";
-import type { InstalledExtension } from "../extension/discovery";
-
+import type { ExtensionManifest } from "@oh-my-tool/sdk";
+import type { InstalledExtension } from "../extension/discovery";
+
 import { RuntimeError as OmtError } from "../runtime/errors";
 export { OmtError };
-
-export interface Registry {
-  byTool: Map<string, { extension: InstalledExtension; tool: ExtensionManifest["tools"][number] }>;
-  byId: Map<string, InstalledExtension>;
-}
-
-export function createRegistry(installed: InstalledExtension[]): Registry {
-  const byTool = new Map();
-  const byId = new Map();
-  for (const ext of installed) {
-    byId.set(ext.id, ext);
-    for (const tool of ext.manifest.tools) {
-      byTool.set(tool.name, { extension: ext, tool });
-    }
-  }
-  return { byTool, byId };
-}
-
-export function resolveTool(
-  reg: Registry,
-  toolName: string,
-): { extension: InstalledExtension; tool: ExtensionManifest["tools"][number] } {
-  const hit = reg.byTool.get(toolName);
-  if (!hit) {
-    throw new OmtError("UNKNOWN_TOOL", `unknown tool '${toolName}'`);
-  }
-  return hit;
-}
+
+export interface Registry {
+  byTool: Map<string, { extension: InstalledExtension; tool: ExtensionManifest["tools"][number] }>;
+  byId: Map<string, InstalledExtension>;
+}
+
+export function createRegistry(installed: InstalledExtension[]): Registry {
+  const byTool = new Map();
+  const byId = new Map();
+  for (const ext of installed) {
+    byId.set(ext.id, ext);
+    for (const tool of ext.manifest.tools) {
+      byTool.set(tool.name, { extension: ext, tool });
+    }
+  }
+  return { byTool, byId };
+}
+
+export function resolveTool(
+  reg: Registry,
+  toolName: string,
+): { extension: InstalledExtension; tool: ExtensionManifest["tools"][number] } {
+  const hit = reg.byTool.get(toolName);
+  if (!hit) {
+    throw new OmtError("UNKNOWN_TOOL", `unknown tool '${toolName}'`);
+  }
+  return hit;
+}

package/src/core/result.ts

@@ -1,14 +1,14 @@
-export interface OmtOk {
-  ok: true;
-  tool: string;
-  data: unknown;
-  meta: Record<string, unknown>;
-}
-
-export interface OmtErr {
-  ok: false;
-  tool: string;
-  error: { code: string; message: string };
-}
-
-export type OmtResult = OmtOk | OmtErr;
+export interface OmtOk {
+  ok: true;
+  tool: string;
+  data: unknown;
+  meta: Record<string, unknown>;
+}
+
+export interface OmtErr {
+  ok: false;
+  tool: string;
+  error: { code: string; message: string; details?: unknown };
+}
+
+export type OmtResult = OmtOk | OmtErr;

package/src/extension/discovery.ts

@@ -1,62 +1,62 @@
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-import { join } from "node:path";
-import type { ExtensionManifest } from "@oh-my-tool/sdk";
-import { parseManifest, validateManifest, checkSdkCompatibility } from "./manifest";
-
-export interface InstalledExtension {
-  id: string;
-  version: string;
-  dir: string;
-  manifest: ExtensionManifest;
-  entry: string;
-}
-
-const EXTENSIONS_DIR = "extensions";
-
-function readEntry(dir: string): string {
-  const pkgPath = join(dir, "package.json");
-  if (existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as Record<string, any>;
-      const entry = pkg.omt?.entry;
-      if (typeof entry === "string") {
-        return join(dir, entry.replace(/^\.\//, ""));
-      }
-    } catch {
-      // ignore malformed package.json, fall through
-    }
-  }
-  return join(dir, "src", "index.ts");
-}
-
-export function discoverExtensions(home: string): InstalledExtension[] {
-  const root = join(home, EXTENSIONS_DIR);
-  if (!existsSync(root)) return [];
-
-  const out: InstalledExtension[] = [];
-  for (const id of readdirSync(root)) {
-    const idDir = join(root, id);
-    if (!statSync(idDir).isDirectory()) continue;
-    for (const version of readdirSync(idDir)) {
-      const versionDir = join(idDir, version);
-      if (!statSync(versionDir).isDirectory()) continue;
-      const manifestPath = join(versionDir, "omt.manifest.json");
-      if (!existsSync(manifestPath)) continue;
-      try {
-        const manifest = parseManifest(readFileSync(manifestPath, "utf8"));
-        validateManifest(manifest);
-        checkSdkCompatibility(manifest.sdkVersion);
-        out.push({
-          id,
-          version,
-          dir: versionDir,
-          manifest,
-          entry: readEntry(versionDir),
-        });
-      } catch {
-        // skip invalid or incompatible manifests
-      }
-    }
-  }
-  return out;
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import type { ExtensionManifest } from "@oh-my-tool/sdk";
+import { parseManifest, validateManifest, checkSdkCompatibility } from "./manifest";
+
+export interface InstalledExtension {
+  id: string;
+  version: string;
+  dir: string;
+  manifest: ExtensionManifest;
+  entry: string;
+}
+
+const EXTENSIONS_DIR = "extensions";
+
+function readEntry(dir: string): string {
+  const pkgPath = join(dir, "package.json");
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as Record<string, any>;
+      const entry = pkg.omt?.entry;
+      if (typeof entry === "string") {
+        return join(dir, entry.replace(/^\.\//, ""));
+      }
+    } catch {
+      // ignore malformed package.json, fall through
+    }
+  }
+  return join(dir, "src", "index.ts");
+}
+
+export function discoverExtensions(home: string): InstalledExtension[] {
+  const root = join(home, EXTENSIONS_DIR);
+  if (!existsSync(root)) return [];
+
+  const out: InstalledExtension[] = [];
+  for (const id of readdirSync(root)) {
+    const idDir = join(root, id);
+    if (!statSync(idDir).isDirectory()) continue;
+    for (const version of readdirSync(idDir)) {
+      const versionDir = join(idDir, version);
+      if (!statSync(versionDir).isDirectory()) continue;
+      const manifestPath = join(versionDir, "omt.manifest.json");
+      if (!existsSync(manifestPath)) continue;
+      try {
+        const manifest = parseManifest(readFileSync(manifestPath, "utf8"));
+        validateManifest(manifest);
+        checkSdkCompatibility(manifest.sdkVersion);
+        out.push({
+          id,
+          version,
+          dir: versionDir,
+          manifest,
+          entry: readEntry(versionDir),
+        });
+      } catch {
+        // skip invalid or incompatible manifests
+      }
+    }
+  }
+  return out;
 }

package/src/extension/install.ts

@@ -1,24 +1,24 @@
-import { cp, mkdir, readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { parseManifest, validateManifest, checkSdkCompatibility } from "./manifest";
-
-export interface InstalledRef {
-  id: string;
-  version: string;
-  target: string;
-}
-
-export async function installLocalExtension(home: string, srcDir: string): Promise<InstalledRef> {
-  const manifest = parseManifest(await readFile(join(srcDir, "omt.manifest.json"), "utf8"));
-  validateManifest(manifest);
-  checkSdkCompatibility(manifest.sdkVersion);
-  const target = join(home, "extensions", manifest.id, manifest.version);
-  await mkdir(target, { recursive: true });
-  // 显式 force:true：Bun 的 fs.cp 在带 filter 时默认覆盖失效（重装不更新旧文件）
-  await cp(srcDir, target, {
-    recursive: true,
-    force: true,
-    filter: (s: string) => !s.includes("node_modules"),
-  });
-  return { id: manifest.id, version: manifest.version, target };
+import { cp, mkdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parseManifest, validateManifest, checkSdkCompatibility } from "./manifest";
+
+export interface InstalledRef {
+  id: string;
+  version: string;
+  target: string;
+}
+
+export async function installLocalExtension(home: string, srcDir: string): Promise<InstalledRef> {
+  const manifest = parseManifest(await readFile(join(srcDir, "omt.manifest.json"), "utf8"));
+  validateManifest(manifest);
+  checkSdkCompatibility(manifest.sdkVersion);
+  const target = join(home, "extensions", manifest.id, manifest.version);
+  await mkdir(target, { recursive: true });
+  // 显式 force:true：Bun 的 fs.cp 在带 filter 时默认覆盖失效（重装不更新旧文件）
+  await cp(srcDir, target, {
+    recursive: true,
+    force: true,
+    filter: (s: string) => !s.includes("node_modules"),
+  });
+  return { id: manifest.id, version: manifest.version, target };
 }

package/src/extension/loader.ts

@@ -1,32 +1,32 @@
-import { pathToFileURL } from "node:url";
-import type { ExtensionDefinition } from "@oh-my-tool/sdk";
-import { OmtError } from "../core/registry";
-import type { InstalledExtension } from "./discovery";
-import { validateHandlers } from "./manifest";
-
-export async function loadExtension(
-  installed: InstalledExtension,
-): Promise<ExtensionDefinition> {
-  let mod: unknown;
-  try {
-    mod = await import(pathToFileURL(installed.entry).href);
-  } catch (e) {
-    throw new OmtError(
-      "LOAD_FAILED",
-      `failed to load extension '${installed.id}': ${e instanceof Error ? e.message : String(e)}`,
-    );
-  }
-
-  const def = (mod as any)?.default ?? mod;
-  if (!def || typeof def.handlers !== "object" || def.handlers === null) {
-    throw new OmtError("LOAD_FAILED", `extension '${installed.id}' has no handlers`);
-  }
-
-  const handlerNames = Object.keys(def.handlers);
-  try {
-    validateHandlers(installed.manifest, handlerNames);
-  } catch (e) {
-    throw new OmtError("LOAD_FAILED", (e as Error).message);
-  }
-  return def as ExtensionDefinition;
-}
+import { pathToFileURL } from "node:url";
+import type { ExtensionDefinition } from "@oh-my-tool/sdk";
+import { OmtError } from "../core/registry";
+import type { InstalledExtension } from "./discovery";
+import { validateHandlers } from "./manifest";
+
+export async function loadExtension(
+  installed: InstalledExtension,
+): Promise<ExtensionDefinition> {
+  let mod: unknown;
+  try {
+    mod = await import(pathToFileURL(installed.entry).href);
+  } catch (e) {
+    throw new OmtError(
+      "LOAD_FAILED",
+      `failed to load extension '${installed.id}': ${e instanceof Error ? e.message : String(e)}`,
+    );
+  }
+
+  const def = (mod as any)?.default ?? mod;
+  if (!def || typeof def.handlers !== "object" || def.handlers === null) {
+    throw new OmtError("LOAD_FAILED", `extension '${installed.id}' has no handlers`);
+  }
+
+  const handlerNames = Object.keys(def.handlers);
+  try {
+    validateHandlers(installed.manifest, handlerNames);
+  } catch (e) {
+    throw new OmtError("LOAD_FAILED", (e as Error).message);
+  }
+  return def as ExtensionDefinition;
+}