@oh-my-tool/cli 0.3.1 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oh-my-tool/cli",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "type": "module",
   "description": "Oh My Tool CLI - local and enterprise tools for agents",
   "keywords": [
@@ -29,7 +29,7 @@
   "dependencies": {
     "@clack/prompts": "^1.7.0",
     "@modelcontextprotocol/client": "2.0.0",
-    "@oh-my-tool/sdk": "0.3.1",
+    "@oh-my-tool/sdk": "0.3.2",
     "open": "11.0.0"
   },
   "engines": {

package/src/cli/commands/connections.ts

@@ -81,16 +81,12 @@ export async function runConnectionCheck(): Promise<ConnectionCheckResult> {
   return withRuntime(async (runtime) => {
     const checks: ConnectionCheck[] = [];
     for (const connection of list.connections) {
-      if (connection.extension !== "redis" && connection.extension !== "mysql") {
-        checks.push({ extension: connection.extension, name: connection.name, status: "unsupported", code: "CHECK_UNSUPPORTED" });
-        continue;
-      }
       const started = Date.now();
       const result = await runtime.run(`${connection.extension}.ping`, { connection: connection.name });
       checks.push(result.ok
         ? { extension: connection.extension, name: connection.name, status: "ok", durationMs: Date.now() - started }
         : result.error?.code === "TOOL_NOT_FOUND"
-          ? { extension: connection.extension, name: connection.name, status: "unsupported", code: "CHECK_UNSUPPORTED", durationMs: Date.now() - started }
+          ? { extension: connection.extension, name: connection.name, status: "unsupported", code: "CHECK_UNSUPPORTED" }
           : { extension: connection.extension, name: connection.name, status: "error", code: result.error?.code ?? "CHECK_FAILED", durationMs: Date.now() - started });
     }
     return { checks, count: checks.length };

package/src/cli/commands/extension.ts

@@ -1,5 +1,5 @@
 import { discoverExtensions } from "../../extension/discovery";
-import { installLocalExtension, type InstalledRef } from "../../extension/install";
+import { installExtension, type InstalledRef } from "../../extension/install";
 import { homeDir } from "../context";
 
 export interface InstalledInfo {
@@ -19,6 +19,6 @@ export async function runExtensionList(): Promise<InstalledInfo[]> {
 }
 
 export async function runExtensionInstall(spec: string): Promise<InstalledRef> {
-  return installLocalExtension(homeDir(), spec);
+  return installExtension(homeDir(), spec);
 }
 

package/src/cli/index.ts

@@ -30,7 +30,7 @@ Usage:
   ohmytool connection check                check MySQL/Redis connectivity
   ohmytool config check                     validate configuration
   ohmytool extension list                  list installed extensions
-  ohmytool extension install <path>        install an extension from a local dir
+  ohmytool extension install <path|package> install a local or npm extension
   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 mcp list                       list configured MCP servers

package/src/extension/install.ts

@@ -1,24 +1,135 @@
-import { cp, mkdir, readFile } from "node:fs/promises";
-import { join } from "node:path";
+import { cp, mkdir, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { execFile as execFileCallback } from "node:child_process";
+import { promisify } from "node:util";
+import { tmpdir } from "node:os";
+import { basename, join, resolve } from "node:path";
 import { parseManifest, validateManifest, checkSdkCompatibility } from "./manifest";
 
+const execFile = promisify(execFileCallback);
+const EXACT_VERSION_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+const OFFICIAL_PACKAGE_RE = /^@oh-my-tool\/[a-z0-9][a-z0-9._-]*$/;
+const EXTENSION_ID_RE = /^[a-z0-9][a-z0-9_-]*$/;
+
 export interface InstalledRef {
   id: string;
   version: string;
   target: string;
 }
 
-export async function installLocalExtension(home: string, srcDir: string): Promise<InstalledRef> {
+export interface NpmExtensionSpec {
+  packageName: string;
+  npmSpec: string;
+  version?: string;
+}
+
+export class ExtensionInstallError extends Error {}
+
+export interface NpmInstallDependencies {
+  install(spec: string, tempDir: string): Promise<void>;
+}
+
+export function normalizeNpmExtensionSpec(spec: string): NpmExtensionSpec {
+  const trimmed = spec.trim();
+  if (!trimmed) throw new ExtensionInstallError("extension package name must not be empty");
+
+  let packageName = trimmed;
+  let version: string | undefined;
+  const separator = trimmed.startsWith("@") ? trimmed.lastIndexOf("@") : trimmed.indexOf("@");
+  if (separator > 0) {
+    packageName = trimmed.slice(0, separator);
+    version = trimmed.slice(separator + 1);
+    if (!EXACT_VERSION_RE.test(version)) {
+      throw new ExtensionInstallError("npm extension versions must be exact semver values, for example 0.3.1");
+    }
+  }
+
+  if (!trimmed.startsWith("@")) packageName = `@oh-my-tool/${packageName}`;
+  if (!OFFICIAL_PACKAGE_RE.test(packageName)) {
+    throw new ExtensionInstallError("only official @oh-my-tool extension packages are supported");
+  }
+  return { packageName, npmSpec: `${packageName}${version === undefined ? "" : `@${version}`}`, ...(version === undefined ? {} : { version }) };
+}
+
+async function installExtensionDirectory(home: string, srcDir: string, expectedPackage?: NpmExtensionSpec): Promise<InstalledRef> {
   const manifest = parseManifest(await readFile(join(srcDir, "omt.manifest.json"), "utf8"));
   validateManifest(manifest);
   checkSdkCompatibility(manifest.sdkVersion);
+  if (!EXTENSION_ID_RE.test(manifest.id)) throw new ExtensionInstallError(`invalid extension id '${manifest.id}'`);
+  if (expectedPackage !== undefined) {
+    const packageJson = JSON.parse(await readFile(join(srcDir, "package.json"), "utf8")) as { name?: unknown; version?: unknown };
+    if (packageJson.name !== expectedPackage.packageName) {
+      throw new ExtensionInstallError(`package manifest mismatch: expected '${expectedPackage.packageName}'`);
+    }
+    if (packageJson.version !== manifest.version) {
+      throw new ExtensionInstallError("package.json and omt.manifest.json versions do not match");
+    }
+    if (expectedPackage.version !== undefined && packageJson.version !== expectedPackage.version) {
+      throw new ExtensionInstallError(`npm package '${expectedPackage.npmSpec}' resolved to an unexpected version`);
+    }
+  }
   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"),
+    filter: (s: string) => basename(s) !== "node_modules",
   });
   return { id: manifest.id, version: manifest.version, target };
-}
+}
+
+export async function installLocalExtension(home: string, srcDir: string): Promise<InstalledRef> {
+  return installExtensionDirectory(home, srcDir);
+}
+
+export async function installNpmExtension(
+  home: string,
+  spec: string,
+  dependencies: Partial<NpmInstallDependencies> = {},
+): Promise<InstalledRef> {
+  const normalized = normalizeNpmExtensionSpec(spec);
+  const temp = await mkdtemp(join(tmpdir(), "oh-my-tool-npm-"));
+  try {
+    await writeFile(join(temp, "package.json"), JSON.stringify({ private: true }), "utf8");
+    try {
+      if (dependencies.install !== undefined) {
+        await dependencies.install(normalized.npmSpec, temp);
+      } else {
+        await execFile("npm", [
+          "install",
+          "--prefix", temp,
+          "--ignore-scripts",
+          "--no-save",
+          "--no-package-lock",
+          "--omit=dev",
+          "--registry=https://registry.npmjs.org",
+          "--", normalized.npmSpec,
+        ], { timeout: 120_000, maxBuffer: 4 * 1024 * 1024 });
+      }
+    } catch {
+      throw new ExtensionInstallError(`failed to download npm extension '${normalized.npmSpec}'`);
+    }
+
+    const packageDir = join(temp, "node_modules", ...normalized.packageName.split("/"));
+    try {
+      await stat(packageDir);
+    } catch {
+      throw new ExtensionInstallError(`npm extension '${normalized.npmSpec}' was not installed`);
+    }
+    return await installExtensionDirectory(home, packageDir, normalized);
+  } finally {
+    await rm(temp, { recursive: true, force: true });
+  }
+}
+
+export async function installExtension(home: string, spec: string): Promise<InstalledRef> {
+  const candidate = resolve(spec);
+  let isLocal = false;
+  try {
+    await stat(join(candidate, "omt.manifest.json"));
+    isLocal = true;
+  } catch {
+    // Not a local extension directory; interpret the argument as an npm spec.
+  }
+  return isLocal ? installLocalExtension(home, candidate) : installNpmExtension(home, spec);
+}

package/src/extension/manifest.ts

@@ -20,12 +20,18 @@ 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'");
   }
@@ -112,4 +118,4 @@ export function validateHandlers(
       );
     }
   }
-}
+}

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/version.ts

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