@oh-my-tool/cli 0.2.0

package/src/cli/index.ts

@@ -0,0 +1,296 @@
+import { parseArgs } from "./parseArgs";
+import { runSearch } from "./commands/search";
+import { runDescribe } from "./commands/describe";
+import { runTool } from "./commands/run";
+import { runExtensionList, runExtensionInstall } from "./commands/extension";
+import { runSecretList, runSecretSet } from "./commands/secret";
+import {
+  defaultIntegrationManager,
+  runIntegrate,
+  type IntegrateAction,
+} from "./commands/integrate";
+import type { AgentDetection, AgentId, IntegrationResult, IntegrationStatus } from "../integration";
+import { AGENT_IDS } from "../integration";
+import { multiselect, isCancel } from "@clack/prompts";
+import { VERSION } from "../version";
+
+const HELP = `Oh My Tool - local and enterprise tools for agents
+
+Usage:
+  ohmytool search "<task>"                 search tools by intent
+  ohmytool describe <tool>                 inspect a tool and its input schema
+  ohmytool run <tool> [key=value ...]      execute a tool
+  ohmytool run <tool> --stdin              execute with JSON from stdin
+  ohmytool extension list                  list installed extensions
+  ohmytool extension install <path>        install an extension from a local dir
+  ohmytool secret set <name>               set a secret (interactive hidden prompt or stdin pipe)
+  ohmytool secret list                     list secret names (Windows only, values never shown)
+  ohmytool setup                           detect agents and install the OMT skill
+  ohmytool integrate [status|repair|uninstall]
+                                      manage agent skill integrations
+  ohmytool --version                   print version
+
+Examples:
+  ohmytool search "查询 mysql 设备数据"
+  ohmytool describe mysql.query
+  ohmytool run mysql.query connection=iot-test sql="SELECT id FROM device"
+  echo '{"connection":"iot-test","sql":"SELECT 1"}' | ohmytool run mysql.query --stdin
+`;
+
+const AGENT_IDS_SET = new Set<AgentId>(AGENT_IDS);
+
+function readStdin(): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk: string) => (data += chunk));
+    process.stdin.on("end", () => resolve(data.trim()));
+    process.stdin.on("error", reject);
+  });
+}
+
+/** 交互式隐藏输入（不回显、不进历史、不落盘），仅 TTY 下调用。 */
+function readSecretHidden(prompt: string): Promise<string> {
+  const { promise, resolve, reject } = Promise.withResolvers<string>();
+  process.stdout.write(prompt);
+  const stdin = process.stdin;
+  const prevRaw = stdin.isRaw;
+  stdin.setRawMode(true);
+  stdin.resume();
+  stdin.setEncoding("utf8");
+  let value = "";
+  const finish = () => {
+    stdin.removeListener("data", onData);
+    stdin.setRawMode(prevRaw);
+    stdin.pause();
+  };
+  const onData = (chunk: string) => {
+    for (const ch of chunk) {
+      if (ch === "\r" || ch === "\n") {
+        finish();
+        process.stdout.write("\n");
+        resolve(value);
+        return;
+      }
+      if (ch === "\x03") {
+        finish();
+        process.stdout.write("\n");
+        reject(new Error("aborted"));
+        return;
+      }
+      if (ch === "\x7f" || ch === "\b") {
+        value = value.slice(0, -1);
+        continue;
+      }
+      value += ch;
+    }
+  };
+  stdin.on("data", onData);
+  return promise;
+}
+
+function print(v: unknown): void {
+  console.log(JSON.stringify(v, null, 2));
+}
+
+function parseAgentIds(raw?: string): AgentId[] | undefined {
+  if (!raw) return undefined;
+  const values = raw.split(",").map((value) => value.trim()).filter(Boolean);
+  for (const value of values) {
+    if (!AGENT_IDS_SET.has(value as AgentId)) throw new Error(`Unknown agent: ${value}`);
+  }
+  return [...new Set(values as AgentId[])];
+}
+
+function printDetected(agents: AgentDetection[]): void {
+  console.log("Detected agents:\n");
+  for (const agent of agents) console.log(`✓ ${agent.variant ?? agent.displayName}`);
+}
+
+const STATUS_ICON: Record<IntegrationStatus, string> = {
+  current: "✓",
+  installed: "✓",
+  repaired: "✓",
+  uninstalled: "✓",
+  "update-available": "↻",
+  "not-installed": "○",
+  broken: "⚠",
+  conflict: "✗",
+};
+
+const STATUS_SEVERITY: Record<IntegrationStatus, number> = {
+  conflict: 0,
+  broken: 1,
+  "update-available": 2,
+  "not-installed": 3,
+  current: 4,
+  installed: 4,
+  repaired: 4,
+  uninstalled: 4,
+};
+
+function printIntegrationResults(results: IntegrationResult[]): void {
+  console.log("");
+  for (const item of results) {
+    const suffix = item.detail ? ` — ${item.detail}` : "";
+    console.log(`${STATUS_ICON[item.status]} ${item.displayName.padEnd(14)} ${item.status}${suffix}`);
+  }
+}
+
+function printStatus(results: IntegrationResult[]): void {
+  console.log("");
+  const ordered = [...results].sort((a, b) => STATUS_SEVERITY[a.status] - STATUS_SEVERITY[b.status]);
+  for (const item of ordered) {
+    console.log(
+      `${STATUS_ICON[item.status]} ${item.displayName.padEnd(14)} ${item.status.padEnd(19)} ${item.detail ?? item.target}`,
+    );
+  }
+  const counts: Record<string, number> = {};
+  for (const item of results) counts[item.status] = (counts[item.status] ?? 0) + 1;
+  const summary = Object.entries(counts).map(([status, n]) => `${n} ${status}`).join("  ·  ");
+  console.log(`\nSummary: ${summary}`);
+  if (results.some((item) => item.status === "broken")) {
+    console.log("Tip:   run `omt integrate repair` to recreate broken links");
+  }
+  if (results.some((item) => item.status === "conflict")) {
+    console.log("Tip:   conflict means OMT refuses to touch an unmanaged path; run `omt integrate --force` only if you accept replacing it");
+  }
+}
+
+async function promptForAgents(agents: AgentDetection[]): Promise<AgentId[]> {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error("Interactive confirmation requires a TTY; pass --yes for unattended setup");
+  }
+  const selected = await multiselect({
+    message: "选择要集成的 Agent（空格切换，回车确认）",
+    options: agents.map((agent) => ({
+      value: agent.id,
+      label: agent.variant ?? agent.displayName,
+      hint: agent.target,
+    })),
+    initialValues: agents.map((agent) => agent.id),
+    required: false,
+  });
+  if (isCancel(selected) || !selected?.length) return [];
+  return selected as AgentId[];
+}
+
+export async function main(argv: string[]): Promise<number> {
+  const parsed = parseArgs(argv);
+  const cmd = parsed.positional[0];
+  try {
+    switch (cmd) {
+      case "search": {
+        const q = parsed.positional.slice(1).join(" ");
+        print(await runSearch(q));
+        return 0;
+      }
+      case "describe": {
+        print(await runDescribe(parsed.positional[1]));
+        return 0;
+      }
+      case "run": {
+        const tool = parsed.positional[1];
+        const res = await runTool(tool, parsed.keyValues, parsed.flags.includes("stdin"));
+        print(res);
+        return res.ok ? 0 : 1;
+      }
+      case "secret": {
+        const sub = parsed.positional[1];
+        if (sub === "set") {
+          const name = parsed.positional[2];
+          if (!name) {
+            console.error("usage: ohmytool secret set <name>  (交互输入或 stdin 管道)");
+            return 1;
+          }
+          // TTY 下交互隐藏输入（不回显/不进历史），非 TTY 保持管道 stdin
+          const value = process.stdin.isTTY ? await readSecretHidden("password: ") : await readStdin();
+          print(await runSecretSet(name, value));
+          return 0;
+        }
+        if (sub === "list") {
+          print(await runSecretList());
+          return 0;
+        }
+        console.error("usage: ohmytool secret set <name> | secret list");
+        return 1;
+      }
+      case "extension": {
+        const sub = parsed.positional[1];
+        if (sub === "list") {
+          print(await runExtensionList());
+          return 0;
+        }
+        if (sub === "install") {
+          print(await runExtensionInstall(parsed.positional[2]));
+          return 0;
+        }
+        console.error("usage: ohmytool extension list|install <path>");
+        return 1;
+      }
+      case "setup":
+      case "integrate": {
+        const action = (cmd === "setup" ? "install" : parsed.positional[1] ?? "install") as IntegrateAction;
+        if (!["install", "status", "repair", "uninstall"].includes(action)) {
+          throw new Error(`Unknown integrate action: ${action}`);
+        }
+        const manager = defaultIntegrationManager();
+        const detected = await manager.detect();
+        if (!detected.length) throw new Error("No supported agents detected");
+        printDetected(detected);
+        let agents = parseAgentIds(parsed.options.agents);
+        const mutating = action !== "status" && !parsed.flags.includes("dry-run");
+        if (mutating && !parsed.flags.includes("yes") && !agents) {
+          agents = await promptForAgents(detected);
+          if (!agents.length) {
+            console.log("\nCancelled.");
+            return 0;
+          }
+        } else if (mutating && !parsed.flags.includes("yes")) {
+          if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            throw new Error("Confirmation required; pass --yes for unattended setup");
+          }
+          const selectedDetections = detected.filter((agent) => agents!.includes(agent.id));
+          agents = await promptForAgents(selectedDetections);
+          if (!agents.length) {
+            console.log("\nCancelled.");
+            return 0;
+          }
+        }
+        const integration = await runIntegrate(
+          {
+            action,
+            agents,
+            force: parsed.flags.includes("force"),
+            dryRun: parsed.flags.includes("dry-run"),
+          },
+          manager,
+        );
+        if (integration.dryRun) {
+          console.log(`\nDry run: would ${action} ${integration.selected.join(", ")}`);
+        } else if (action === "status") {
+          printStatus(integration.results);
+        } else {
+          printIntegrationResults(integration.results);
+        }
+        return 0;
+      }
+      case "-v": {
+        print({ name: "ohmytool", version: VERSION });
+        return 0;
+      }
+      default:
+        if (parsed.flags.includes("version")) {
+          print({ name: "ohmytool", version: VERSION });
+          return 0;
+        }
+        console.log(HELP);
+        return cmd ? 1 : 0;
+    }
+  } catch (e) {
+    console.error(e instanceof Error ? e.message : String(e));
+    return 1;
+  }
+}
+
+

package/src/cli/parseArgs.ts

@@ -0,0 +1,44 @@
+export interface ParsedArgs {
+  positional: string[];
+  keyValues: Record<string, string>;
+  flags: string[];
+  options: Record<string, string>;
+}
+
+export function parseArgs(argv: string[]): ParsedArgs {
+  const positional: string[] = [];
+  const keyValues: Record<string, string> = {};
+  const flags: string[] = [];
+  const options: Record<string, string> = {};
+  for (const arg of argv) {
+    if (arg.startsWith("--")) {
+      const option = arg.slice(2);
+      const eq = option.indexOf("=");
+      if (eq > 0) {
+        options[option.slice(0, eq)] = option.slice(eq + 1);
+      } else {
+        flags.push(option);
+      }
+    } else {
+      const eq = arg.indexOf("=");
+      if (eq > 0) {
+        keyValues[arg.slice(0, eq)] = arg.slice(eq + 1);
+      } else {
+        positional.push(arg);
+      }
+    }
+  }
+  return { positional, keyValues, flags, options };
+}
+
+export function coerceInput(input: Record<string, unknown>): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(input)) {
+    if (typeof v === "string" && /^-?\d+$/.test(v)) {
+      out[k] = Number(v);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}

package/src/config/config.ts

@@ -0,0 +1,63 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+export interface ConnectionConfig {
+  environment: string;
+  host: string;
+  port: number;
+  database: string;
+  username: string;
+  secret: string;
+  tls: boolean;
+}
+
+export interface Config {
+  extensions: Record<string, { connections: Record<string, ConnectionConfig> }>;
+}
+
+export function loadConfig(homeDir: string): Config {
+  const path = join(homeDir, "config.toml");
+  if (!existsSync(path)) {
+    return { extensions: {} };
+  }
+  const raw = readFileSync(path, "utf8");
+  const parsed = Bun.TOML.parse(raw) as Record<string, unknown>;
+
+  const extensions: Config["extensions"] = {};
+  const extSection = (parsed as Record<string, any>)["extensions"];
+  if (extSection && typeof extSection === "object") {
+    for (const [extId, extVal] of Object.entries(extSection)) {
+      const connections: Record<string, ConnectionConfig> = {};
+      const connSection = (extVal as any)?.["connections"];
+      if (connSection && typeof connSection === "object") {
+        for (const [name, rawConn] of Object.entries(connSection)) {
+          const rc = rawConn as Record<string, any>;
+          connections[name] = {
+            environment: String(rc.environment ?? ""),
+            host: String(rc.host ?? ""),
+            port: Number(rc.port ?? 3306),
+            database: String(rc.database ?? ""),
+            username: String(rc.username ?? ""),
+            secret: String(rc.secret ?? ""),
+            tls: Boolean(rc.tls ?? false),
+          };
+        }
+      }
+      extensions[extId] = { connections };
+    }
+  }
+  return { extensions };
+}
+
+export function getConnectionConfig(
+  cfg: Config,
+  extensionId: string,
+  connection: string,
+): ConnectionConfig | undefined {
+  return cfg.extensions[extensionId]?.connections[connection];
+}
+
+export function listConnections(cfg: Config, extensionId: string): string[] {
+  const conns = cfg.extensions[extensionId]?.connections ?? {};
+  return Object.keys(conns);
+}

package/src/core/executor.ts

@@ -0,0 +1,99 @@
+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 } };
+    }
+    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) },
+    };
+  }
+}
+

package/src/core/registry.ts

@@ -0,0 +1,33 @@
+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;
+}

package/src/core/result.ts

@@ -0,0 +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;

package/src/core/schema.ts

@@ -0,0 +1,2 @@
+export { validateInput } from "../runtime/schema";
+export type { Schema } from "../runtime/schema";

package/src/extension/discovery.ts

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

package/src/extension/install.ts

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

package/src/extension/loader.ts

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