@oh-my-tool/cli 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 oh-my-tool
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,13 @@
+# @oh-my-tool/cli
+
+The `ohmytool` command-line interface for discovering and running local agent
+tools.
+
+```powershell
+npm install --global @oh-my-tool/cli
+ohmytool --help
+```
+
+Requires Bun 1.4 or newer. Use `ohmytool search`, `ohmytool describe`, then
+`ohmytool run`; see the main [Oh My Tool repository](https://github.com/oh-my-tool/oh-my-tool)
+for configuration and extension installation guidance.

package/assets/skills/oh-my-tool/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: oh-my-tool
+description: Discover and invoke local, development, and enterprise tools through the Oh My Tool Agent Tool Runtime.
+---
+
+# Oh My Tool — The Agent Tool Runtime
+
+Use the canonical `ohmytool` CLI to discover and execute tools exposed by installed native extensions.
+
+## When to use
+
+Use Oh My Tool when the task requires an external capability that may be available in the user's environment, such as:
+
+- querying a database
+- inspecting Redis
+- reading configuration
+- searching internal logs
+- invoking development and operations tools
+
+Do not assume a specific extension or tool is installed.
+
+## Workflow
+
+### 1. Search
+
+When you do not know the exact tool ID:
+
+```bash
+ohmytool search "<what you need to do>"
+```
+
+Search returns lightweight summary metadata and does not load handlers or access secrets.
+
+### 2. Describe
+
+Before using an unfamiliar tool, inspect its complete descriptor and input schema:
+
+```bash
+ohmytool describe <tool-name>
+```
+
+Use the returned schema, constraints, risk level, and configuration requirements to construct the input.
+
+### 3. Run
+
+Execute the selected tool through the runtime:
+
+```bash
+ohmytool run <tool-name> key=value
+```
+
+For structured or complex arguments, prefer JSON through stdin:
+
+```bash
+echo '{"connection":"iot-test","sql":"SELECT 1"}' | ohmytool run mysql.query --stdin
+```
+
+## Rules
+
+- Prefer `ohmytool` over directly invoking an underlying database, cache, CLI, API, or service.
+- Do not guess installed tools; use `ohmytool search`.
+- Do not guess tool arguments; use `ohmytool describe`.
+- Do not guess connection names, endpoints, credentials, tokens, or authentication details.
+- Never request or expose secrets managed by Oh My Tool.
+- Respect tool risk levels, policy restrictions, and environment restrictions.
+- Prefer the smallest and safest tool that can complete the task.
+- Treat runtime results as structured tool output and use them to continue the task.
+
+## Mental model
+
+The CLI is the Agent-facing adapter. ToolRuntime indexes static descriptors and governs execution through ToolProviders; native extension handlers are loaded only when `run` executes a tool.
+
+```text
+search   → lightweight ToolDescriptor summary
+describe → complete ToolDescriptor and inputSchema
+run      → policy → provider → dynamic handler execution
+```

package/bin/ohmytool.cjs

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+
+const { spawnSync } = require("node:child_process");
+const { join } = require("node:path");
+
+const result = spawnSync("bun", [join(__dirname, "ohmytool.ts"), ...process.argv.slice(2)], {
+  stdio: "inherit",
+});
+
+if (result.error) {
+  console.error("ohmytool requires Bun 1.4 or newer. Install it from https://bun.sh.");
+  process.exit(1);
+}
+
+process.exit(result.status ?? 1);

package/bin/ohmytool.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env bun
+import { main } from "../src/cli/index";
+
+const code = await main(process.argv.slice(2));
+process.exit(code);

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@oh-my-tool/cli",
+  "version": "0.2.0",
+  "type": "module",
+  "description": "Oh My Tool CLI - local and enterprise tools for agents",
+  "keywords": ["ai", "agent", "cli", "tools", "extensions", "bun"],
+  "homepage": "https://github.com/oh-my-tool/oh-my-tool#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/oh-my-tool/oh-my-tool.git",
+    "directory": "packages/cli"
+  },
+  "bugs": "https://github.com/oh-my-tool/oh-my-tool/issues",
+  "bin": {
+    "ohmytool": "bin/ohmytool.cjs"
+  },
+  "files": [
+    "assets",
+    "bin",
+    "src"
+  ],
+  "dependencies": {
+    "@clack/prompts": "^1.7.0",
+    "@oh-my-tool/sdk": "0.2.0"
+  },
+  "engines": {
+    "node": ">=20",
+    "bun": ">=1.4.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT"
+}

package/src/cli/commands/describe.ts

@@ -0,0 +1,24 @@
+import { createRuntime } from "../context";
+
+export interface DescribedTool {
+  name: string;
+  description: string;
+  risk: string;
+  inputSchema: Record<string, unknown> | undefined;
+  extension: string;
+  extensionVersion: string;
+}
+
+export async function runDescribe(toolName: string): Promise<DescribedTool> {
+  const runtime = await createRuntime();
+  const descriptor = await runtime.describe(toolName);
+  return {
+    name: descriptor.id,
+    description: descriptor.description,
+    risk: descriptor.risk,
+    inputSchema: descriptor.inputSchema,
+    extension: descriptor.source.id,
+    extensionVersion: "unknown",
+  };
+}
+

package/src/cli/commands/extension.ts

@@ -0,0 +1,24 @@
+import { discoverExtensions } from "../../extension/discovery";
+import { installLocalExtension, type InstalledRef } from "../../extension/install";
+import { homeDir } from "../context";
+
+export interface InstalledInfo {
+  id: string;
+  version: string;
+  entry: string;
+  toolCount: number;
+}
+
+export async function runExtensionList(): Promise<InstalledInfo[]> {
+  return discoverExtensions(homeDir()).map((e) => ({
+    id: e.id,
+    version: e.version,
+    entry: e.entry,
+    toolCount: e.manifest.tools.length,
+  }));
+}
+
+export async function runExtensionInstall(spec: string): Promise<InstalledRef> {
+  return installLocalExtension(homeDir(), spec);
+}
+

package/src/cli/commands/index.ts

@@ -0,0 +1,7 @@
+export * from "./search";
+export * from "./describe";
+export * from "./run";
+export * from "./extension";
+export * from "./secret";
+export * from "./integrate";
+

package/src/cli/commands/integrate.ts

@@ -0,0 +1,64 @@
+import type { AgentDetection, AgentId, IntegrationResult } from "../../integration";
+import { AGENT_IDS, createIntegrationManager } from "../../integration";
+import { homeDir } from "../context";
+import { VERSION } from "../../version";
+
+export type IntegrateAction = "install" | "status" | "repair" | "uninstall";
+
+export interface IntegrateInput {
+  action: IntegrateAction;
+  agents?: AgentId[];
+  force?: boolean;
+  dryRun?: boolean;
+}
+
+export interface IntegrateOutput {
+  action: IntegrateAction;
+  dryRun: boolean;
+  detected: AgentDetection[];
+  selected: AgentId[];
+  results: IntegrationResult[];
+}
+
+type IntegrationManager = ReturnType<typeof createIntegrationManager>;
+
+export function defaultIntegrationManager(): IntegrationManager {
+  return createIntegrationManager({ omtHome: homeDir(), skillVersion: VERSION });
+}
+
+export async function runIntegrate(
+  input: IntegrateInput,
+  manager: IntegrationManager = defaultIntegrationManager(),
+): Promise<IntegrateOutput> {
+  const detected = await manager.detect();
+  const known = new Set<AgentId>(AGENT_IDS);
+  for (const id of input.agents ?? []) {
+    if (!known.has(id)) throw new Error(`Unknown agent: ${id}`);
+  }
+  const selected = input.agents?.length ? input.agents : detected.map((agent) => agent.id);
+  const detectedIds = new Set(detected.map((agent) => agent.id));
+  for (const id of selected) {
+    if (!detectedIds.has(id)) throw new Error(`Agent is not detected: ${id}`);
+  }
+
+  if (input.dryRun) {
+    return { action: input.action, dryRun: true, detected, selected, results: [] };
+  }
+
+  let results: IntegrationResult[];
+  switch (input.action) {
+    case "install":
+      results = await manager.install(selected, { force: input.force });
+      break;
+    case "status":
+      results = (await manager.status()).filter((item) => selected.includes(item.agent));
+      break;
+    case "repair":
+      results = await manager.repair(selected);
+      break;
+    case "uninstall":
+      results = await manager.uninstall(selected);
+      break;
+  }
+  return { action: input.action, dryRun: false, detected, selected, results };
+}

package/src/cli/commands/run.ts

@@ -0,0 +1,39 @@
+import { coerceInput } from "../parseArgs";
+import { createRuntime } from "../context";
+import type { OmtResult } from "../../core/result";
+
+export async function runTool(
+  toolName: string,
+  keyValues: Record<string, string>,
+  useStdin: boolean,
+): Promise<OmtResult> {
+  let input: Record<string, unknown>;
+  if (useStdin) {
+    input = await readStdinJson();
+  } else {
+    input = coerceInput(keyValues);
+  }
+  const runtime = await createRuntime();
+  const result = await runtime.run(toolName, input);
+  if (result.ok) {
+    return { ok: true, tool: toolName, data: result.output, meta: result.meta ?? {} };
+  }
+  return { ok: false, tool: toolName, error: result.error ?? { code: "EXECUTION_FAILED", message: "execution failed" } };
+}
+
+function readStdinJson(): Promise<Record<string, unknown>> {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    const stdin = process.stdin;
+    stdin.setEncoding("utf8");
+    stdin.on("data", (chunk: string) => (data += chunk));
+    stdin.on("end", () => {
+      try {
+        resolve(JSON.parse(data));
+      } catch (e) {
+        reject(e);
+      }
+    });
+    stdin.on("error", reject);
+  });
+}

package/src/cli/commands/search.ts

@@ -0,0 +1,16 @@
+import { createRuntime } from "../context";
+
+export async function runSearch(query: string): Promise<{ tools: Array<Record<string, unknown>> }> {
+  const runtime = await createRuntime();
+  const descriptors = await runtime.search(query);
+  return {
+    tools: descriptors.map((descriptor) => ({
+      name: descriptor.id,
+      description: descriptor.description,
+      extension: descriptor.source.id,
+      risk: descriptor.risk,
+      provider: descriptor.provider,
+    })),
+  };
+}
+

package/src/cli/commands/secret.ts

@@ -0,0 +1,72 @@
+import { SecretsManager } from "../../secrets/secrets";
+import type { SecretStore } from "@oh-my-tool/sdk";
+
+export interface SecretSetResult {
+  ok: true;
+  name: string;
+}
+
+export async function runSecretSet(
+  name: string,
+  value: string,
+  store?: SecretStore,
+): Promise<SecretSetResult> {
+  const mgr = new SecretsManager(store);
+  await mgr.set(name, value);
+  return { ok: true, name };
+}
+
+export interface SecretListResult {
+  names: string[];
+  supported: boolean;
+  hint?: string;
+}
+
+/** 从 cmdkey /list 输出解析 oh-my-tool 命名空间下的 secret 名（不返回值）。 */
+export function parseSecretNamesFromCmdkey(output: string): string[] {
+  const names = new Set<string>();
+  const re = /oh-my-tool\/([A-Za-z0-9:._@-]+)/g;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(output)) !== null) {
+    names.add(m[1]);
+  }
+  return [...names].sort();
+}
+
+type CmdkeyExec = (args: string[]) => Promise<string>;
+
+async function defaultCmdkeyList(): Promise<string> {
+  const proc = Bun.spawn(["cmdkey", "/list"], { stdout: "pipe", stderr: "pipe" });
+  const output = await Bun.readableStreamToArrayBuffer(proc.stdout);
+  const out = new TextDecoder().decode(output);
+  const code = await proc.exited;
+  if (code !== 0) throw new Error(`cmdkey /list exited ${code}`);
+  return out;
+}
+
+/**
+ * 列出已设置的 secret 名（只列名、不显值）。
+ * Bun.secrets 无枚举 API，Windows 下通过 cmdkey 解析 oh-my-tool/ 前缀；
+ * 非 Windows 不支持枚举，返回 supported=false。
+ */
+export async function runSecretList(
+  exec: CmdkeyExec = defaultCmdkeyList,
+): Promise<SecretListResult> {
+  if (process.platform !== "win32") {
+    return {
+      names: [],
+      supported: false,
+      hint: "Bun.secrets 无枚举 API；secret list 仅在 Windows（通过 cmdkey）支持",
+    };
+  }
+  try {
+    const out = await exec(["cmdkey", "/list"]);
+    return { names: parseSecretNamesFromCmdkey(out), supported: true };
+  } catch (e) {
+    return {
+      names: [],
+      supported: false,
+      hint: `cmdkey 调用失败: ${e instanceof Error ? e.message : String(e)}`,
+    };
+  }
+}

package/src/cli/context.ts

@@ -0,0 +1,44 @@
+import { createPaths } from "../paths";
+import { prepareHome } from "../migration";
+import { loadConfig, getConnectionConfig } from "../config/config";
+import { SecretsManager } from "../secrets/secrets";
+import { applyLimits, validateConnectionInput } from "../policy/policy";
+import { NativeExtensionProvider } from "../runtime/providers/native/provider";
+import { createToolRuntime } from "../runtime/runtime";
+import type { ToolDescriptor } from "../runtime/provider";
+
+export function homeDir(): string {
+  return createPaths().home;
+}
+
+export async function createRuntime() {
+  const paths = createPaths();
+  await prepareHome(paths);
+  const config = loadConfig(paths.home);
+  const secrets = new SecretsManager();
+  return createToolRuntime({
+    providers: [new NativeExtensionProvider(paths)],
+    policy: {
+      preflight(descriptor, input) {
+        const limits = applyLimits(input);
+        input.maxRows = limits.maxRows;
+        input.timeoutMs = limits.timeoutMs;
+        const extensionId = descriptor.source.id;
+        const schema = descriptor.inputSchema as { properties?: Record<string, unknown> } | undefined;
+        const needsConnection = Boolean(schema?.properties && "connection" in schema.properties) || "connection" in input;
+        if (needsConnection) validateConnectionInput(input, config, extensionId);
+      },
+    },
+    createExecutionContext(descriptor: ToolDescriptor, input: Record<string, unknown>) {
+      const extensionId = descriptor.source.id;
+      const connection = typeof input.connection === "string"
+        ? getConnectionConfig(config, extensionId, input.connection)
+        : undefined;
+      return {
+        logger: { debug() {}, info() {}, warn() {}, error() {} },
+        config: (connection ?? {}) as Record<string, unknown>,
+        secrets,
+      };
+    },
+  });
+}