@oh-my-tool/cli 0.2.0 → 0.3.1

package/src/integration/skill.ts

@@ -1,84 +1,84 @@
-import {
-  cpSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  readdirSync,
-  renameSync,
-  statSync,
-} from "node:fs";
-import { createHash } from "node:crypto";
-import { dirname, join, relative, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-
-export interface SkillMetadata {
-  name: string;
-  description: string;
-}
-
-export function bundledSkillPath(): string {
-  return fileURLToPath(new URL("../../assets/skills/oh-my-tool", import.meta.url));
-}
-
-export function validateSkill(directory: string): SkillMetadata {
-  const skillFile = join(directory, "SKILL.md");
-  if (!existsSync(skillFile)) throw new Error(`Skill is missing SKILL.md: ${directory}`);
-  const content = readFileSync(skillFile, "utf8");
-  const frontmatter = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
-  if (!frontmatter) throw new Error("Skill SKILL.md is missing YAML frontmatter");
-  const name = frontmatter[1].match(/^name:\s*(.+?)\s*$/m)?.[1];
-  const description = frontmatter[1].match(/^description:\s*(.+?)\s*$/m)?.[1];
-  if (!name || !description) throw new Error("Skill frontmatter requires name and description");
-  if (name !== "oh-my-tool") throw new Error(`Unexpected bundled skill name: ${name}`);
-  return { name, description };
-}
-
-function filesUnder(directory: string): string[] {
-  const files: string[] = [];
-  for (const entry of readdirSync(directory, { withFileTypes: true })) {
-    const path = join(directory, entry.name);
-    if (entry.isDirectory()) files.push(...filesUnder(path));
-    else if (entry.isFile()) files.push(path);
-  }
-  return files.sort((a, b) => a.localeCompare(b));
-}
-
-export function skillDigest(directory: string): string {
-  const hash = createHash("sha256");
-  for (const file of filesUnder(directory)) {
-    hash.update(relative(directory, file).replaceAll("\\", "/"));
-    hash.update("\0");
-    hash.update(readFileSync(file));
-    hash.update("\0");
-  }
-  return `sha256:${hash.digest("hex")}`;
-}
-
-export function stageCanonicalSkill(
-  omtHome: string,
-  source: string,
-  version: string,
-): { path: string; digest: string } {
-  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(version)) {
-    throw new Error(`Invalid skill version: ${version}`);
-  }
-  validateSkill(source);
-  const digest = skillDigest(source);
-  const canonicalRoot = resolve(omtHome, "integrations", "skills", "oh-my-tool");
-  const target = resolve(canonicalRoot, version);
-  if (dirname(target) !== canonicalRoot) throw new Error(`Invalid skill version path: ${version}`);
-  if (existsSync(target)) {
-    validateSkill(target);
-    if (skillDigest(target) !== digest) {
-      throw new Error(`Immutable skill version ${version} already exists with different content`);
-    }
-    return { path: target, digest };
-  }
-  mkdirSync(dirname(target), { recursive: true });
-  const staging = `${target}.tmp-${process.pid}-${Date.now()}`;
-  if (existsSync(staging)) throw new Error(`Skill staging path already exists: ${staging}`);
-  cpSync(source, staging, { recursive: true, errorOnExist: true });
-  validateSkill(staging);
-  if (statSync(staging).isDirectory()) renameSync(staging, target);
-  return { path: target, digest };
-}
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  statSync,
+} from "node:fs";
+import { createHash } from "node:crypto";
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export interface SkillMetadata {
+  name: string;
+  description: string;
+}
+
+export function bundledSkillPath(): string {
+  return fileURLToPath(new URL("../../assets/skills/oh-my-tool", import.meta.url));
+}
+
+export function validateSkill(directory: string): SkillMetadata {
+  const skillFile = join(directory, "SKILL.md");
+  if (!existsSync(skillFile)) throw new Error(`Skill is missing SKILL.md: ${directory}`);
+  const content = readFileSync(skillFile, "utf8");
+  const frontmatter = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+  if (!frontmatter) throw new Error("Skill SKILL.md is missing YAML frontmatter");
+  const name = frontmatter[1].match(/^name:\s*(.+?)\s*$/m)?.[1];
+  const description = frontmatter[1].match(/^description:\s*(.+?)\s*$/m)?.[1];
+  if (!name || !description) throw new Error("Skill frontmatter requires name and description");
+  if (name !== "oh-my-tool") throw new Error(`Unexpected bundled skill name: ${name}`);
+  return { name, description };
+}
+
+function filesUnder(directory: string): string[] {
+  const files: string[] = [];
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    const path = join(directory, entry.name);
+    if (entry.isDirectory()) files.push(...filesUnder(path));
+    else if (entry.isFile()) files.push(path);
+  }
+  return files.sort((a, b) => a.localeCompare(b));
+}
+
+export function skillDigest(directory: string): string {
+  const hash = createHash("sha256");
+  for (const file of filesUnder(directory)) {
+    hash.update(relative(directory, file).replaceAll("\\", "/"));
+    hash.update("\0");
+    hash.update(readFileSync(file));
+    hash.update("\0");
+  }
+  return `sha256:${hash.digest("hex")}`;
+}
+
+export function stageCanonicalSkill(
+  omtHome: string,
+  source: string,
+  version: string,
+): { path: string; digest: string } {
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(version)) {
+    throw new Error(`Invalid skill version: ${version}`);
+  }
+  validateSkill(source);
+  const digest = skillDigest(source);
+  const canonicalRoot = resolve(omtHome, "integrations", "skills", "oh-my-tool");
+  const target = resolve(canonicalRoot, version);
+  if (dirname(target) !== canonicalRoot) throw new Error(`Invalid skill version path: ${version}`);
+  if (existsSync(target)) {
+    validateSkill(target);
+    if (skillDigest(target) !== digest) {
+      throw new Error(`Immutable skill version ${version} already exists with different content`);
+    }
+    return { path: target, digest };
+  }
+  mkdirSync(dirname(target), { recursive: true });
+  const staging = `${target}.tmp-${process.pid}-${Date.now()}`;
+  if (existsSync(staging)) throw new Error(`Skill staging path already exists: ${staging}`);
+  cpSync(source, staging, { recursive: true, errorOnExist: true });
+  validateSkill(staging);
+  if (statSync(staging).isDirectory()) renameSync(staging, target);
+  return { path: target, digest };
+}

package/src/integration/types.ts

@@ -1,55 +1,55 @@
-export type AgentId = "codex" | "omp" | "qoder" | "pi" | "cursor" | "claude";
-
-export const AGENT_IDS: readonly AgentId[] = [
-  "codex",
-  "omp",
-  "qoder",
-  "pi",
-  "cursor",
-  "claude",
-];
-export type IntegrationStatus =
-  | "not-installed"
-  | "installed"
-  | "current"
-  | "update-available"
-  | "broken"
-  | "conflict"
-  | "repaired"
-  | "uninstalled";
-
-export interface AgentDetection {
-  id: AgentId;
-  displayName: string;
-  command: string;
-  target: string;
-  variant?: string;
-}
-
-export interface IntegrationResult {
-  agent: AgentId;
-  displayName: string;
-  target: string;
-  status: IntegrationStatus;
-  detail?: string;
-}
-
-export interface ManagedAgentState {
-  target: string;
-  canonical: string;
-  version: string;
-  digest: string;
-  mode: "junction" | "symlink";
-  backup?: string;
-}
-
-export interface IntegrationState {
-  schemaVersion: 1;
-  skills: {
-    "oh-my-tool"?: {
-      version: string;
-      digest: string;
-      agents: Partial<Record<AgentId, ManagedAgentState>>;
-    };
-  };
-}
+export type AgentId = "codex" | "omp" | "qoder" | "pi" | "cursor" | "claude";
+
+export const AGENT_IDS: readonly AgentId[] = [
+  "codex",
+  "omp",
+  "qoder",
+  "pi",
+  "cursor",
+  "claude",
+];
+export type IntegrationStatus =
+  | "not-installed"
+  | "installed"
+  | "current"
+  | "update-available"
+  | "broken"
+  | "conflict"
+  | "repaired"
+  | "uninstalled";
+
+export interface AgentDetection {
+  id: AgentId;
+  displayName: string;
+  command: string;
+  target: string;
+  variant?: string;
+}
+
+export interface IntegrationResult {
+  agent: AgentId;
+  displayName: string;
+  target: string;
+  status: IntegrationStatus;
+  detail?: string;
+}
+
+export interface ManagedAgentState {
+  target: string;
+  canonical: string;
+  version: string;
+  digest: string;
+  mode: "junction" | "symlink";
+  backup?: string;
+}
+
+export interface IntegrationState {
+  schemaVersion: 1;
+  skills: {
+    "oh-my-tool"?: {
+      version: string;
+      digest: string;
+      agents: Partial<Record<AgentId, ManagedAgentState>>;
+    };
+  };
+}

package/src/policy/policy.ts

@@ -1,139 +1,139 @@
-import type { Config } from "../config/config";
-import { getConnectionConfig } from "../config/config";
-
+import type { Config } from "../config/config";
+import { getConnectionConfig } from "../config/config";
+
 export class PolicyError extends Error {
   readonly code = "POLICY_VIOLATION";
 }
-
-const FORBIDDEN = /(?:^|[^a-z_])(insert|update|delete|drop|alter|create|truncate|rename|grant|revoke|replace|call|set|commit|rollback|load\s+data|lock\s+tables|unlock\s+tables|create\s+database|drop\s+database)(?:[^a-z_]|$)/i;
-
-function stripLiteralsAndComments(sql: string): string {
-  let out = "";
-  let i = 0;
-  const n = sql.length;
-  while (i < n) {
-    const ch = sql[i];
-    const next = sql[i + 1];
-    // line comments
-    if (ch === "-" && next === "-") {
-      while (i < n && sql[i] !== "\n") i++;
-      continue;
-    }
-    if (ch === "#") {
-      while (i < n && sql[i] !== "\n") i++;
-      continue;
-    }
-    // block comments
-    if (ch === "/" && next === "*") {
-      i += 2;
-      while (i < n && !(sql[i] === "*" && sql[i + 1] === "/")) i++;
-      i += 2;
-      continue;
-    }
-    // string literals
-    if (ch === "'" || ch === '"') {
-      const quote = ch;
-      i++;
-      while (i < n) {
-        if (sql[i] === "\\") {
-          i += 2;
-          continue;
-        }
-        if (sql[i] === quote) {
-          if (sql[i + 1] === quote) {
-            i += 2;
-            continue;
-          }
-          i++;
-          break;
-        }
-        i++;
-      }
-      out += " ";
-      continue;
-    }
-    out += ch;
-    i++;
-  }
-  return out;
-}
-
-function countStatements(sql: string): number {
-  const cleaned = stripLiteralsAndComments(sql);
-  const parts = cleaned
-    .split(";")
-    .map((p) => p.trim())
-    .filter((p) => p.length > 0);
-  return parts.length;
-}
-
-export function assertReadOnly(sql: string): void {
-  if (typeof sql !== "string" || sql.trim().length === 0) {
-    throw new PolicyError("sql must be a non-empty string");
-  }
-  if (countStatements(sql) > 1) {
-    throw new PolicyError("only a single read-only statement is allowed");
-  }
-  const cleaned = stripLiteralsAndComments(sql);
-  if (FORBIDDEN.test(cleaned)) {
-    throw new PolicyError("sql contains a non read-only statement");
-  }
-}
-
-const FORBIDDEN_INPUT = new Set([
-  "host",
-  "username",
-  "password",
-  "port",
-  "database",
-  "secret",
-  "tls",
-]);
-
-export function validateConnectionInput(
-  input: Record<string, unknown>,
-  config: Config,
-  extensionId: string,
-): void {
-  for (const key of FORBIDDEN_INPUT) {
-    if (key in input && input[key] !== undefined && input[key] !== null) {
-      throw new PolicyError(`agent input must not contain '${key}'`);
-    }
-  }
-  const connection = input["connection"];
-  if (typeof connection !== "string" || connection.length === 0) {
-    throw new PolicyError("input must specify a configured 'connection' name");
-  }
-  if (!getConnectionConfig(config, extensionId, connection)) {
-    throw new PolicyError(`unknown connection '${connection}' for extension '${extensionId}'`);
-  }
-}
-
-export interface Limits {
-  maxRows: number;
-  timeoutMs: number;
-}
-
-export const DEFAULT_MAX_ROWS = 100;
-export const MAX_MAX_ROWS = 1000;
-export const DEFAULT_TIMEOUT_MS = 5000;
-export const MAX_TIMEOUT_MS = 30000;
-
-export function applyLimits(input: Record<string, unknown>): Limits {
-  const maxRows = clamp(
-    typeof input.maxRows === "number" ? input.maxRows : DEFAULT_MAX_ROWS,
-    1,
-    MAX_MAX_ROWS,
-  );
-  const timeoutMs = clamp(
-    typeof input.timeoutMs === "number" ? input.timeoutMs : DEFAULT_TIMEOUT_MS,
-    1,
-    MAX_TIMEOUT_MS,
-  );
-  return { maxRows, timeoutMs };
-}
-
-function clamp(value: number, min: number, max: number): number {
-  return Math.min(Math.max(value, min), max);
-}
-
+
+const FORBIDDEN = /(?:^|[^a-z_])(insert|update|delete|drop|alter|create|truncate|rename|grant|revoke|replace|call|set|commit|rollback|load\s+data|lock\s+tables|unlock\s+tables|create\s+database|drop\s+database)(?:[^a-z_]|$)/i;
+
+function stripLiteralsAndComments(sql: string): string {
+  let out = "";
+  let i = 0;
+  const n = sql.length;
+  while (i < n) {
+    const ch = sql[i];
+    const next = sql[i + 1];
+    // line comments
+    if (ch === "-" && next === "-") {
+      while (i < n && sql[i] !== "\n") i++;
+      continue;
+    }
+    if (ch === "#") {
+      while (i < n && sql[i] !== "\n") i++;
+      continue;
+    }
+    // block comments
+    if (ch === "/" && next === "*") {
+      i += 2;
+      while (i < n && !(sql[i] === "*" && sql[i + 1] === "/")) i++;
+      i += 2;
+      continue;
+    }
+    // string literals
+    if (ch === "'" || ch === '"') {
+      const quote = ch;
+      i++;
+      while (i < n) {
+        if (sql[i] === "\\") {
+          i += 2;
+          continue;
+        }
+        if (sql[i] === quote) {
+          if (sql[i + 1] === quote) {
+            i += 2;
+            continue;
+          }
+          i++;
+          break;
+        }
+        i++;
+      }
+      out += " ";
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  return out;
+}
+
+function countStatements(sql: string): number {
+  const cleaned = stripLiteralsAndComments(sql);
+  const parts = cleaned
+    .split(";")
+    .map((p) => p.trim())
+    .filter((p) => p.length > 0);
+  return parts.length;
+}
+
+export function assertReadOnly(sql: string): void {
+  if (typeof sql !== "string" || sql.trim().length === 0) {
+    throw new PolicyError("sql must be a non-empty string");
+  }
+  if (countStatements(sql) > 1) {
+    throw new PolicyError("only a single read-only statement is allowed");
+  }
+  const cleaned = stripLiteralsAndComments(sql);
+  if (!/^(select|with|show|explain|describe|desc)\b/i.test(cleaned.trim()) || FORBIDDEN.test(cleaned) || /\bfor\s+update\b|\block\s+in\s+share\s+mode\b|\binto\s+(out|dump)file\b|\bload_file\s*\(/i.test(cleaned)) {
+    throw new PolicyError("sql contains a non read-only statement");
+  }
+}
+
+const FORBIDDEN_INPUT = new Set([
+  "host",
+  "username",
+  "password",
+  "port",
+  "database",
+  "secret",
+  "tls",
+]);
+
+export function validateConnectionInput(
+  input: Record<string, unknown>,
+  config: Config,
+  extensionId: string,
+): void {
+  for (const key of FORBIDDEN_INPUT) {
+    if (key in input && input[key] !== undefined && input[key] !== null) {
+      throw new PolicyError(`agent input must not contain '${key}'`);
+    }
+  }
+  const connection = input["connection"];
+  if (typeof connection !== "string" || connection.length === 0) {
+    throw new PolicyError("input must specify a configured 'connection' name");
+  }
+  if (!getConnectionConfig(config, extensionId, connection)) {
+    throw new PolicyError(`unknown connection '${connection}' for extension '${extensionId}'`);
+  }
+}
+
+export interface Limits {
+  maxRows: number;
+  timeoutMs: number;
+}
+
+export const DEFAULT_MAX_ROWS = 100;
+export const MAX_MAX_ROWS = 1000;
+export const DEFAULT_TIMEOUT_MS = 5000;
+export const MAX_TIMEOUT_MS = 30000;
+
+export function applyLimits(input: Record<string, unknown>): Limits {
+  const maxRows = clamp(
+    typeof input.maxRows === "number" ? input.maxRows : DEFAULT_MAX_ROWS,
+    1,
+    MAX_MAX_ROWS,
+  );
+  const timeoutMs = clamp(
+    typeof input.timeoutMs === "number" ? input.timeoutMs : DEFAULT_TIMEOUT_MS,
+    1,
+    MAX_TIMEOUT_MS,
+  );
+  return { maxRows, timeoutMs };
+}
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.min(Math.max(value, min), max);
+}
+

package/src/runtime/errors.ts

@@ -1,6 +1,11 @@
 export class RuntimeError extends Error {
-  constructor(public readonly code: string, message: string) {
-    super(message);
+  constructor(
+    public readonly code: string,
+    message: string,
+    public readonly details?: unknown,
+    options?: ErrorOptions,
+  ) {
+    super(message, options);
     this.name = "RuntimeError";
   }
 }

package/src/runtime/executor.ts

@@ -38,7 +38,9 @@ export async function executeRuntimeTool(
   rawInput: Record<string, unknown>,
 ): Promise<ExecutionResult> {
   try {
-    const input = validateInput(deps.descriptor.inputSchema as any, rawInput);
+    const input = validateInput(deps.descriptor.inputSchema as any, rawInput, {
+      applyDefaults: deps.descriptor.provider.kind !== "mcp",
+    });
     await deps.policy.preflight(deps.descriptor, input);
     const context = await deps.createExecutionContext(deps.descriptor, input);
     const result = await deps.provider.execute(deps.descriptor.id, input, context);
@@ -56,6 +58,9 @@ export async function executeRuntimeTool(
       error: {
         code: typed.code ?? "EXECUTION_FAILED",
         message: typed.message ?? String(error),
+        ...("details" in (typed as object) && (typed as { details?: unknown }).details !== undefined
+          ? { details: (typed as { details: unknown }).details }
+          : {}),
       },
     };
   }

package/src/runtime/provider.ts

@@ -8,7 +8,7 @@ export interface ToolDescriptor {
   risk: "read" | "write" | "admin";
   inputSchema?: Record<string, unknown>;
   provider: { id: string; kind: string };
-  source: { id: string; kind: string };
+  source: { id: string; kind: string; version?: string };
 }
 
 export type ToolSearchResult = Omit<ToolDescriptor, "inputSchema">;
@@ -24,6 +24,7 @@ export interface ToolProvider {
   readonly kind: string;
   listTools(): Promise<readonly ToolDescriptor[]>;
   execute(toolId: string, input: unknown, context: ExecutionContext): Promise<ToolResult>;
+  close?(): Promise<void>;
 }
 
 export type { ToolResult } from "./result";

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

@@ -0,0 +1,36 @@
+import type { Tool } from "@modelcontextprotocol/client";
+import type { ToolDescriptor } from "../../provider";
+
+export interface NormalizedMcpTool {
+  readonly descriptor: ToolDescriptor;
+  readonly remoteName: string;
+}
+
+function riskFor(tool: Tool): ToolDescriptor["risk"] {
+  if (tool.annotations?.destructiveHint === true) return "admin";
+  if (tool.annotations?.readOnlyHint === true) return "read";
+  return "write";
+}
+
+export function normalizeMcpTool(
+  serverId: string,
+  namespace: string,
+  providerId: string,
+  tool: Tool,
+): NormalizedMcpTool {
+  const description = tool.description ?? tool.title ?? `MCP tool ${tool.name}`;
+  const keywords = [...new Set([serverId, namespace, tool.name, tool.title].filter((value): value is string => value !== undefined))];
+
+  return {
+    descriptor: {
+      id: `${namespace}.${tool.name}`,
+      description,
+      keywords,
+      risk: riskFor(tool),
+      inputSchema: (tool.inputSchema ?? { type: "object", properties: {} }) as Record<string, unknown>,
+      provider: { id: providerId, kind: "mcp" },
+      source: { id: serverId, kind: "mcp-server" },
+    },
+    remoteName: tool.name,
+  };
+}