@oh-my-tool/cli 0.3.1 → 0.3.3

package/src/extension/manifest.ts

@@ -20,15 +20,26 @@ export function parseManifest(raw: string): ExtensionManifest {
 }
 
 export function validateManifest(manifest: ExtensionManifest): void {
+  if (!/^[a-z0-9][a-z0-9_-]*$/.test(manifest.id)) {
+    throw new ManifestError("manifest 'id' must contain only lowercase letters, numbers, underscores, and hyphens");
+  }
   if (!manifest.name || typeof manifest.name !== "string") {
     throw new ManifestError("manifest must contain a string 'name'");
   }
   if (!manifest.version || typeof manifest.version !== "string") {
     throw new ManifestError("manifest must contain a string 'version'");
   }
+  if (!FULL_VERSION_RE.test(manifest.version)) {
+    throw new ManifestError(`invalid manifest version '${manifest.version}'`);
+  }
   if (!manifest.sdkVersion || typeof manifest.sdkVersion !== "string") {
     throw new ManifestError("manifest must contain a string 'sdkVersion'");
   }
+  if (manifest.connectionSchema !== undefined && (
+    manifest.connectionSchema === null || typeof manifest.connectionSchema !== "object" || Array.isArray(manifest.connectionSchema)
+  )) {
+    throw new ManifestError("manifest 'connectionSchema' must be an object");
+  }
 
   const seen = new Set<string>();
   for (const tool of manifest.tools) {
@@ -47,6 +58,19 @@ export function validateManifest(manifest: ExtensionManifest): void {
       );
     }
   }
+
+  if (manifest.connectionCheckTool !== undefined) {
+    if (typeof manifest.connectionCheckTool !== "string" || manifest.connectionCheckTool.length === 0) {
+      throw new ManifestError("manifest 'connectionCheckTool' must be a non-empty string");
+    }
+    const checkTool = manifest.tools.find((tool) => tool.name === manifest.connectionCheckTool);
+    if (!checkTool || !manifest.connectionCheckTool.startsWith(`${manifest.id}.`)) {
+      throw new ManifestError("manifest 'connectionCheckTool' must name a declared tool prefixed by the extension id");
+    }
+    if ((checkTool.risk ?? "read") !== "read") {
+      throw new ManifestError("manifest 'connectionCheckTool' must be read-only");
+    }
+  }
 }
 
 const FULL_VERSION_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
@@ -112,4 +136,4 @@ export function validateHandlers(
       );
     }
   }
-}
+}

package/src/integration/manager.ts

@@ -274,17 +274,17 @@ export function createIntegrationManager(options: IntegrationManagerOptions) {
       const recorded = records[agent.id];
       if (!recorded) {
         if (!pathPresent(agent.target)) {
-          return result(agent, "not-installed", "not installed; run `omt integrate` to install");
+          return result(agent, "not-installed", "not installed; run `ohmytool integrate` to install");
         }
         return result(agent, "conflict", "target exists but is not managed by OMT");
       }
       try {
         assertSafeManagedState(agent, recorded, options.omtHome, platform);
       } catch {
-        return result(agent, "conflict", "recorded state is unsafe; run `omt integrate repair`");
+        return result(agent, "conflict", "recorded state is unsafe; run `ohmytool integrate repair`");
       }
       if (!pathPresent(agent.target) || !safeRealpath(agent.target)) {
-        return result(agent, "broken", "link is missing; run `omt integrate repair`");
+        return result(agent, "broken", "link is missing; run `ohmytool integrate repair`");
       }
       if (!isManagedLink(agent.target, recorded.canonical)) {
         return result(agent, "conflict", "target was replaced by unmanaged content");
@@ -292,7 +292,7 @@ export function createIntegrationManager(options: IntegrationManagerOptions) {
       if (recorded.version === options.skillVersion) {
         return result(agent, "current");
       }
-      return result(agent, "update-available", `new version ${options.skillVersion} available; run \`omt integrate\``);
+      return result(agent, "update-available", `new version ${options.skillVersion} available; run \`ohmytool integrate\``);
     });
   }
 

package/src/policy/policy.ts

@@ -81,6 +81,8 @@ export function assertReadOnly(sql: string): void {
 }
 
 const FORBIDDEN_INPUT = new Set([
+  "settings",
+  "secrets",
   "host",
   "username",
   "password",

package/src/runtime/provider.ts

@@ -11,6 +11,22 @@ export interface ToolDescriptor {
   source: { id: string; kind: string; version?: string };
 }
 
+export interface ToolSearchOptions {
+  readonly limit?: number;
+  readonly provider?: string;
+  readonly source?: string;
+  readonly risk?: ToolDescriptor["risk"];
+}
+
+export interface ProviderStatus {
+  readonly id: string;
+  readonly kind: string;
+  readonly status: "available" | "unavailable";
+  readonly code?: string;
+  readonly message?: string;
+  readonly namespace?: string;
+}
+
 export type ToolSearchResult = Omit<ToolDescriptor, "inputSchema">;
 
 export interface ExecutionContext {
@@ -22,6 +38,7 @@ export interface ExecutionContext {
 export interface ToolProvider {
   readonly id: string;
   readonly kind: string;
+  readonly namespace?: string;
   listTools(): Promise<readonly ToolDescriptor[]>;
   execute(toolId: string, input: unknown, context: ExecutionContext): Promise<ToolResult>;
   close?(): Promise<void>;

package/src/runtime/providers/mcp/oauth-provider.ts

@@ -33,11 +33,13 @@ import {
 export interface McpOAuthProviderOptions {
   readonly redirectUrl?: URL;
   readonly interactive?: boolean;
+  readonly forceDynamicRegistration?: boolean;
 }
 
 export interface McpOAuthClientProvider extends OAuthClientProvider {
   readonly redirectUrl: URL;
   readonly secretValues: readonly string[];
+  readonly clientConfigurationFingerprint: string;
   authorizationUrl(): URL | undefined;
   authorizationState(): string | undefined;
   clearVerifier(): Promise<void>;
@@ -65,6 +67,7 @@ function oauthAuthRequired(serverId: string): RuntimeError {
 
 class PersistentMcpOAuthProvider implements McpOAuthClientProvider {
   readonly clientMetadata: OAuthClientMetadata;
+  readonly clientConfigurationFingerprint: string;
   private pendingAuthorizationUrl: URL | undefined;
   private pendingState: string | undefined;
 
@@ -85,6 +88,12 @@ class PersistentMcpOAuthProvider implements McpOAuthClientProvider {
       client_name: "Oh My Tool",
       ...(config.auth.scopes.length === 0 ? {} : { scope: config.auth.scopes.join(" ") }),
     };
+    this.clientConfigurationFingerprint = JSON.stringify({
+      redirectUrl: redirectUrl.toString(),
+      clientId: config.auth.clientId ?? null,
+      clientSecretConfigured: config.auth.clientSecretSecret !== undefined,
+      metadata: this.clientMetadata,
+    });
   }
 
   state(): string {
@@ -172,6 +181,9 @@ export async function createMcpOAuthProvider(
   const interactive = options.interactive ?? false;
   const store = createMcpOAuthStore(serverId, secrets);
   if (!interactive && await store.tokens() === undefined) throw oauthAuthRequired(serverId);
+  if (options.forceDynamicRegistration === true && config.auth.clientId === undefined) {
+    await store.clear("client");
+  }
   let preRegisteredClient: StoredOAuthClientInformation | undefined;
   const secretValues: string[] = [];
   if (config.auth.clientId !== undefined) {
@@ -191,7 +203,7 @@ export async function createMcpOAuthProvider(
       client_secret: clientSecret,
     };
   }
-  return new PersistentMcpOAuthProvider(
+  const provider = new PersistentMcpOAuthProvider(
     serverId,
     config,
     store,
@@ -200,6 +212,14 @@ export async function createMcpOAuthProvider(
     secretValues,
     interactive,
   );
+  const previousFingerprint = await store.clientConfiguration();
+  if (previousFingerprint !== provider.clientConfigurationFingerprint) {
+    if (previousFingerprint !== undefined) {
+      await store.clear("client");
+    }
+  }
+  await store.saveClientConfiguration(provider.clientConfigurationFingerprint);
+  return provider;
 }
 
 function oauthConfig(serverId: string, config: McpHttpServerConfig): OAuthMcpServerConfig {
@@ -287,6 +307,7 @@ export async function authorizeMcpServer(
     const activeProvider = await createMcpOAuthProvider(serverId, validated, secrets, {
       redirectUrl: callback.redirectUrl,
       interactive: true,
+      forceDynamicRegistration: true,
     });
     provider = activeProvider;
     firstClient = createClient({ name: "oh-my-tool", version: VERSION });

package/src/runtime/providers/mcp/oauth-store.ts

@@ -11,6 +11,8 @@ export interface McpOAuthStore {
   saveTokens(tokens: StoredOAuthTokens): Promise<void>;
   clientInformation(): Promise<StoredOAuthClientInformation | undefined>;
   saveClientInformation(info: StoredOAuthClientInformation): Promise<void>;
+  clientConfiguration(): Promise<string | undefined>;
+  saveClientConfiguration(fingerprint: string): Promise<void>;
   codeVerifier(): Promise<string | undefined>;
   saveCodeVerifier(value: string): Promise<void>;
   discoveryState(): Promise<OAuthDiscoveryState | undefined>;
@@ -19,13 +21,14 @@ export interface McpOAuthStore {
   clearAll(): Promise<void>;
 }
 
-type CredentialScope = "tokens" | "client" | "verifier" | "discovery";
+type CredentialScope = "tokens" | "client" | "client-config" | "verifier" | "discovery";
 
 function credentialNames(serverId: string): Record<CredentialScope, string> {
   const prefix = `mcp:${serverId}:oauth`;
   return {
     tokens: `${prefix}:tokens`,
     client: `${prefix}:client`,
+    "client-config": `${prefix}:client-config`,
     verifier: `${prefix}:verifier`,
     discovery: `${prefix}:discovery`,
   };
@@ -72,6 +75,14 @@ export class SecretMcpOAuthStore implements McpOAuthStore {
     return this.secrets.set(this.names.client, JSON.stringify(info));
   }
 
+  clientConfiguration(): Promise<string | undefined> {
+    return this.secrets.get(this.names["client-config"]);
+  }
+
+  saveClientConfiguration(fingerprint: string): Promise<void> {
+    return this.secrets.set(this.names["client-config"], fingerprint);
+  }
+
   codeVerifier(): Promise<string | undefined> {
     return this.secrets.get(this.names.verifier);
   }

package/src/runtime/providers/mcp/provider.ts

@@ -17,6 +17,7 @@ export interface McpProviderOptions {
 export class McpProvider implements ToolProvider {
   readonly id: string;
   readonly kind = "mcp";
+  readonly namespace: string;
   private session?: McpSession;
   private descriptors?: readonly ToolDescriptor[];
   private readonly routes = new Map<string, string>();
@@ -24,6 +25,7 @@ export class McpProvider implements ToolProvider {
 
   constructor(private readonly options: McpProviderOptions) {
     this.id = `mcp:${options.serverId}`;
+    this.namespace = options.config.namespace;
   }
 
   async listTools(): Promise<readonly ToolDescriptor[]> {

package/src/runtime/providers/native/provider.ts

@@ -8,7 +8,15 @@ export class NativeExtensionProvider implements ToolProvider {
   readonly id = "native";
   readonly kind = "native";
 
-  constructor(private readonly homeOrPaths: string | Pick<OhMyToolPaths, "home">) {}
+  private readonly discover: (home: string) => InstalledExtension[];
+  private snapshot?: { extensions: InstalledExtension[]; routes: Map<string, InstalledExtension> };
+
+  constructor(
+    private readonly homeOrPaths: string | Pick<OhMyToolPaths, "home">,
+    discover: (home: string) => InstalledExtension[] = discoverExtensions,
+  ) {
+    this.discover = discover;
+  }
 
   private home(): string {
     return typeof this.homeOrPaths === "string" ? this.homeOrPaths : this.homeOrPaths.home;
@@ -16,7 +24,7 @@ export class NativeExtensionProvider implements ToolProvider {
 
   async listTools(): Promise<readonly ToolDescriptor[]> {
     const descriptors: ToolDescriptor[] = [];
-    for (const extension of discoverExtensions(this.home())) {
+    for (const extension of this.getSnapshot().extensions) {
       for (const tool of extension.manifest.tools) {
         descriptors.push({
           id: tool.name,
@@ -40,18 +48,30 @@ export class NativeExtensionProvider implements ToolProvider {
   }
 
   async execute(toolId: string, input: unknown, context: ExecutionContext): Promise<ToolResult> {
-    const extension = this.findExtension(toolId);
+    const extension = this.getSnapshot().routes.get(toolId);
+    if (!extension) throw new Error(`unknown native tool '${toolId}'`);
     const definition = await loadExtension(extension);
     const handler = definition.handlers[toolId];
     if (!handler) throw new Error(`no handler for ${toolId}`);
     return handler({ toolName: toolId, logger: context.logger, config: context.config, secrets: context.secrets }, input);
   }
 
-  private findExtension(toolId: string): InstalledExtension {
-    const extension = discoverExtensions(this.home()).find((candidate) =>
-      candidate.manifest.tools.some((tool) => tool.name === toolId),
-    );
-    if (!extension) throw new Error(`unknown native tool '${toolId}'`);
-    return extension;
+  async hasTool(toolId: string): Promise<boolean> {
+    return this.getSnapshot().routes.has(toolId);
+  }
+
+  installedExtensions(): readonly InstalledExtension[] {
+    return this.getSnapshot().extensions;
+  }
+
+  private getSnapshot(): { extensions: InstalledExtension[]; routes: Map<string, InstalledExtension> } {
+    if (this.snapshot) return this.snapshot;
+    const extensions = this.discover(this.home());
+    const routes = new Map<string, InstalledExtension>();
+    for (const extension of extensions) {
+      for (const tool of extension.manifest.tools) routes.set(tool.name, extension);
+    }
+    this.snapshot = { extensions, routes };
+    return this.snapshot;
   }
 }

package/src/runtime/result.ts

@@ -3,10 +3,17 @@ export interface ToolResult {
   meta?: Record<string, unknown>;
 }
 
-export interface ExecutionResult {
-  ok: boolean;
+export interface ExecutionOk {
+  ok: true;
   toolId: string;
-  output?: unknown;
-  meta?: Record<string, unknown>;
-  error?: { code: string; message: string; details?: unknown };
+  output: unknown;
+  meta: Record<string, unknown>;
 }
+
+export interface ExecutionError {
+  ok: false;
+  toolId: string;
+  error: { code: string; message: string; details?: unknown };
+}
+
+export type ExecutionResult = ExecutionOk | ExecutionError;

package/src/runtime/runtime.ts

@@ -1,4 +1,4 @@
-import type { ExecutionContext, ToolDescriptor, ToolProvider, ToolSearchResult } from "./provider";
+import type { ExecutionContext, ProviderStatus, ToolDescriptor, ToolProvider, ToolSearchOptions, ToolSearchResult } from "./provider";
 import type { ExecutionResult } from "./result";
 import { executeRuntimeTool, type CreateExecutionContext, type PolicyPreflight } from "./executor";
 import { RuntimeError } from "./errors";
@@ -20,23 +20,30 @@ interface RuntimeState {
 
 export class ToolRuntime {
   private closePromise?: Promise<void>;
+  private readonly discovery = new Map<string, Promise<void>>();
+  private readonly statuses = new Map<string, ProviderStatus>();
+  private readonly closedProviders = new Set<string>();
 
   constructor(private readonly state: RuntimeState, private readonly registeredProviders: readonly ToolProvider[] = []) {}
 
-  search(query: string): Promise<ToolSearchResult[]> {
-    return Promise.resolve(this.state.tools.search(query));
+  async search(query: string, options?: ToolSearchOptions): Promise<ToolSearchResult[]> {
+    await this.discoverAll();
+    return this.state.tools.search(query, options);
   }
 
-  describe(toolId: string): Promise<ToolDescriptor> {
+  async describe(toolId: string): Promise<ToolDescriptor> {
+    await this.discoverForTarget(toolId);
     const descriptor = this.state.tools.get(toolId);
-    if (!descriptor) return Promise.reject(new RuntimeError("TOOL_NOT_FOUND", `unknown tool '${toolId}'`));
-    return Promise.resolve(descriptor);
+    if (!descriptor) throw this.targetError(toolId);
+    return descriptor;
   }
 
   async run(toolId: string, input: unknown): Promise<ExecutionResult> {
+    await this.discoverForTarget(toolId);
     const descriptor = this.state.tools.get(toolId);
     if (!descriptor) {
-      return { ok: false, toolId, error: { code: "TOOL_NOT_FOUND", message: `unknown tool '${toolId}'` } };
+      const error = this.targetError(toolId);
+      return { ok: false, toolId, error: { code: error.code, message: error.message } };
     }
     const provider = this.state.providers.require(descriptor.provider.id);
     return executeRuntimeTool({
@@ -47,32 +54,45 @@ export class ToolRuntime {
     }, (input ?? {}) as Record<string, unknown>);
   }
 
+  providerStatuses(): readonly ProviderStatus[] {
+    return [...this.statuses.values()].sort((a, b) => a.id.localeCompare(b.id));
+  }
+
   close(): Promise<void> {
     if (this.closePromise) return this.closePromise;
     this.closePromise = (async () => {
       const errors: unknown[] = [];
       for (const provider of [...this.registeredProviders].reverse()) {
-        if (!provider.close) continue;
-        try { await provider.close(); } catch (error) { errors.push(error); }
+        try { await this.closeProvider(provider); } catch (error) { errors.push(error); }
       }
       if (errors.length > 0) throw errors[0];
     })();
     return this.closePromise;
   }
-}
 
-async function closeProviders(providers: readonly ToolProvider[]): Promise<void> {
-  await Promise.allSettled([...providers].reverse().map(async (provider) => {
-    if (provider.close) await provider.close();
-  }));
-}
+  private async discoverAll(): Promise<void> {
+    await Promise.all(this.registeredProviders.map((provider) => this.discoverProvider(provider)));
+  }
 
-export async function createToolRuntime(options: ToolRuntimeOptions): Promise<ToolRuntime> {
-  const providers = new ProviderRegistry();
-  const tools = new ToolRegistry();
-  try {
-    for (const provider of options.providers) {
-      providers.register(provider);
+  private async discoverForTarget(toolId: string): Promise<void> {
+    const nativeProviders = this.registeredProviders.filter((provider) => provider.kind === "native");
+    await Promise.all(nativeProviders.map((provider) => this.discoverProvider(provider)));
+    if (this.state.tools.get(toolId)) return;
+    await Promise.all(this.registeredProviders
+      .filter((provider) => provider.kind !== "native")
+      .map((provider) => this.discoverProvider(provider)));
+  }
+
+  private discoverProvider(provider: ToolProvider): Promise<void> {
+    const current = this.discovery.get(provider.id);
+    if (current) return current;
+    const promise = this.discoverProviderOnce(provider);
+    this.discovery.set(provider.id, promise);
+    return promise;
+  }
+
+  private async discoverProviderOnce(provider: ToolProvider): Promise<void> {
+    try {
       const descriptors = await provider.listTools();
       for (const descriptor of descriptors) {
         if (descriptor.provider.id !== provider.id || descriptor.provider.kind !== provider.kind) {
@@ -82,12 +102,46 @@ export async function createToolRuntime(options: ToolRuntimeOptions): Promise<To
           );
         }
       }
-      tools.register(descriptors);
+      this.state.tools.register(descriptors);
+      this.statuses.set(provider.id, {
+        id: provider.id,
+        kind: provider.kind,
+        status: "available",
+        ...("namespace" in provider && typeof provider.namespace === "string" ? { namespace: provider.namespace } : {}),
+      });
+    } catch (error) {
+      if (provider.kind !== "mcp") throw error;
+      const typed = error as { code?: unknown; message?: unknown };
+      this.statuses.set(provider.id, {
+        id: provider.id,
+        kind: provider.kind,
+        status: "unavailable",
+        ...("namespace" in provider && typeof provider.namespace === "string" ? { namespace: provider.namespace } : {}),
+        code: typeof typed.code === "string" ? typed.code : "PROVIDER_UNAVAILABLE",
+        message: typeof typed.message === "string" ? typed.message : "provider discovery failed",
+      });
+      try { await this.closeProvider(provider); } catch { /* preserve discovery status */ }
     }
-  } catch (error) {
-    await closeProviders(options.providers);
-    throw error;
   }
+
+  private targetError(toolId: string): RuntimeError {
+    const unavailable = this.providerStatuses().find((status) =>
+      status.status === "unavailable" && status.namespace !== undefined && toolId.startsWith(`${status.namespace}.`));
+    if (unavailable) return new RuntimeError("PROVIDER_UNAVAILABLE", `provider '${unavailable.id}' is unavailable`);
+    return new RuntimeError("TOOL_NOT_FOUND", `unknown tool '${toolId}'`);
+  }
+
+  private async closeProvider(provider: ToolProvider): Promise<void> {
+    if (!provider.close || this.closedProviders.has(provider.id)) return;
+    this.closedProviders.add(provider.id);
+    await provider.close();
+  }
+}
+
+export async function createToolRuntime(options: ToolRuntimeOptions): Promise<ToolRuntime> {
+  const providers = new ProviderRegistry();
+  const tools = new ToolRegistry();
+  for (const provider of options.providers) providers.register(provider);
   return new ToolRuntime({
     providers,
     tools,

package/src/runtime/tool-registry.ts

@@ -1,9 +1,12 @@
-import type { ToolDescriptor, ToolSearchResult } from "./provider";
+import type { ToolDescriptor, ToolSearchOptions, ToolSearchResult } from "./provider";
 import { RuntimeError } from "./errors";
 
 const NAME_WEIGHT = 3;
 const KEYWORD_WEIGHT = 2;
 const DESCRIPTION_WEIGHT = 1;
+const EXACT_BOOST = 4;
+const PREFIX_BOOST = 2;
+const MAX_SEARCH_RESULTS = 100;
 
 export class ToolRegistry {
   private readonly tools = new Map<string, ToolDescriptor>();
@@ -25,13 +28,17 @@ export class ToolRegistry {
     return this.tools.get(toolId);
   }
 
-  search(query: string): ToolSearchResult[] {
+  search(query: string, options: ToolSearchOptions = {}): ToolSearchResult[] {
     const tokens = query.toLowerCase().split(/\s+/).filter(Boolean);
     if (tokens.length === 0) return [];
     return [...this.tools.values()]
+      .filter((descriptor) => options.provider === undefined || descriptor.provider.id === options.provider)
+      .filter((descriptor) => options.source === undefined || descriptor.source.id === options.source)
+      .filter((descriptor) => options.risk === undefined || descriptor.risk === options.risk)
       .map((descriptor) => ({ descriptor, score: this.score(descriptor, tokens) }))
       .filter((hit) => hit.score > 0)
-      .sort((a, b) => b.score - a.score)
+      .sort((a, b) => b.score - a.score || a.descriptor.id.localeCompare(b.descriptor.id))
+      .slice(0, Math.min(Math.max(Math.trunc(options.limit ?? MAX_SEARCH_RESULTS), 1), MAX_SEARCH_RESULTS))
       .map(({ descriptor }) => {
         const { inputSchema: _inputSchema, ...summary } = descriptor;
         return summary;
@@ -43,12 +50,20 @@ export class ToolRegistry {
     const description = descriptor.description.toLowerCase();
     const keywords = (descriptor.keywords ?? []).map((keyword) => keyword.toLowerCase());
     return tokens.reduce((score, token) => {
-      if (id.includes(token)) return score + NAME_WEIGHT;
-      if (keywords.some((keyword) => keyword.includes(token) || token.includes(keyword))) {
-        return score + KEYWORD_WEIGHT;
-      }
-      if (description.includes(token)) return score + DESCRIPTION_WEIGHT;
+      const idScore = matchWeight(id, token, NAME_WEIGHT);
+      if (idScore > 0) return score + idScore;
+      const keywordScore = Math.max(0, ...keywords.map((keyword) => matchWeight(keyword, token, KEYWORD_WEIGHT)));
+      if (keywordScore > 0) return score + keywordScore;
+      const descriptionScore = matchWeight(description, token, DESCRIPTION_WEIGHT);
+      if (descriptionScore > 0) return score + descriptionScore;
       return score;
     }, 0);
   }
 }
+
+function matchWeight(value: string, token: string, base: number): number {
+  if (value === token) return base + EXACT_BOOST;
+  if (value.startsWith(token)) return base + PREFIX_BOOST;
+  if (value.includes(token) || token.includes(value)) return base;
+  return 0;
+}

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = "0.3.1";
+export const VERSION = "0.3.3";

package/src/core/executor.ts

@@ -1,99 +0,0 @@
-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 } };
-    }
-    if (e && typeof e === "object" && "code" in e && typeof (e as { code?: unknown }).code === "string") {
-      return {
-        ok: false,
-        tool: toolName,
-        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) },
-    };
-  }
-}
-