veryfront 0.1.215 → 0.1.217

package/src/cli/commands/extension/validate-command.ts

@@ -0,0 +1,78 @@
+/**
+ * Extension validate command — check an extension for shape and capability issues.
+ *
+ * @module cli/commands/extension/validate-command
+ */
+import * as dntShim from "../../../_dnt.shims.js";
+
+
+import { validateExtension } from "../../../src/extensions/validation.js";
+
+export interface ValidationReport {
+  valid: boolean;
+  issues: string[];
+}
+
+/**
+ * Validate an extension at the given directory path.
+ */
+export async function validateExtensionAtPath(
+  extensionPath: string,
+): Promise<ValidationReport> {
+  const issues: string[] = [];
+
+  const candidates = [
+    `${extensionPath}/src/index.ts`,
+    `${extensionPath}/index.ts`,
+  ];
+
+  let entryPoint: string | undefined;
+  for (const candidate of candidates) {
+    try {
+      const stat = await dntShim.Deno.stat(candidate);
+      if (stat.isFile) {
+        entryPoint = candidate;
+        break;
+      }
+    } catch { /* next candidate */ }
+  }
+
+  if (!entryPoint) {
+    issues.push(`No entry point found. Expected src/index.ts or index.ts in ${extensionPath}`);
+    return { valid: false, issues };
+  }
+
+  try {
+    const mod = await import(`file://${await dntShim.Deno.realPath(entryPoint)}`);
+    const factory = mod.default;
+
+    if (typeof factory !== "function") {
+      issues.push("Default export must be a function (ExtensionFactory).");
+      return { valid: false, issues };
+    }
+
+    const ext = factory();
+    issues.push(...validateExtension(ext));
+  } catch (err) {
+    issues.push(`Failed to import extension: ${(err as Error).message}`);
+  }
+
+  return { valid: issues.length === 0, issues };
+}
+
+/**
+ * CLI entry point for `veryfront extension validate <path>`.
+ */
+export async function runExtensionValidate(extensionPath: string): Promise<void> {
+  const report = await validateExtensionAtPath(extensionPath);
+
+  if (report.valid) {
+    console.log("Extension is valid.");
+  } else {
+    console.error("Extension validation failed:");
+    for (const issue of report.issues) {
+      console.error(`  - ${issue}`);
+    }
+    dntShim.Deno.exit(1);
+  }
+}

package/src/cli/commands/generate/integration-generator-helpers.ts

@@ -0,0 +1,185 @@
+export type TokenAuthMethod =
+  | "basic"
+  | "body"
+  | "client_secret_basic"
+  | "client_secret_post"
+  | "request_body";
+
+export interface IntegrationGeneratorOptionsLike {
+  name?: string;
+  displayName?: string;
+  authType?: "oauth2" | "api-key";
+  apiBaseUrl?: string;
+  authorizationUrl?: string;
+  tokenUrl?: string;
+  scopes?: string;
+  tokenAuthMethod?: TokenAuthMethod;
+  additionalAuthParams?: string;
+  usePKCE?: boolean;
+}
+
+export interface IntegrationConfig {
+  name: string;
+  displayName: string;
+  authType: "oauth2" | "api-key";
+  apiBaseUrl: string;
+  authorizationUrl?: string;
+  tokenUrl?: string;
+  scopes: string[];
+  tokenAuthMethod: TokenAuthMethod;
+  additionalAuthParams: Record<string, string>;
+  usePKCE: boolean;
+  envVarPrefix: string;
+}
+
+export function parseScopes(scopes?: string): string[] {
+  return scopes?.split(",").map((scope) => scope.trim()) || [];
+}
+
+export function parseAdditionalAuthParams(params?: string): Record<string, string> {
+  if (!params?.trim()) return {};
+
+  return Object.fromEntries(
+    params.split(",")
+      .map((entry) => entry.trim())
+      .filter(Boolean)
+      .map((entry) => {
+        const separatorIndex = entry.indexOf("=");
+        if (separatorIndex === -1) {
+          throw new Error(
+            "Additional auth params must use key=value pairs separated by commas",
+          );
+        }
+
+        const key = entry.slice(0, separatorIndex).trim();
+        const value = entry.slice(separatorIndex + 1).trim();
+
+        if (!key || !value) {
+          throw new Error(
+            "Additional auth params must use non-empty key=value pairs",
+          );
+        }
+
+        return [key, value];
+      }),
+  );
+}
+
+export function normalizeTokenAuthMethod(method?: string): TokenAuthMethod {
+  switch (method?.trim().toLowerCase()) {
+    case "basic":
+      return "basic";
+    case "body":
+      return "body";
+    case "client_secret_basic":
+      return "client_secret_basic";
+    case "client_secret_post":
+      return "client_secret_post";
+    case "request_body":
+    case undefined:
+    case "":
+      return "request_body";
+    default:
+      throw new Error(
+        "OAuth token auth method must be one of: request_body, body, basic, client_secret_basic, client_secret_post",
+      );
+  }
+}
+
+export function parseBooleanOption(
+  value: string | boolean | undefined,
+  defaultValue = false,
+): boolean {
+  if (typeof value === "boolean") return value;
+  if (!value?.trim()) return defaultValue;
+
+  switch (value.trim().toLowerCase()) {
+    case "y":
+    case "yes":
+    case "true":
+    case "1":
+      return true;
+    case "n":
+    case "no":
+    case "false":
+    case "0":
+      return false;
+    default:
+      throw new Error("Boolean option must be yes/no, true/false, or 1/0");
+  }
+}
+
+export function validateIntegrationName(name: string): void {
+  if (!name || !/^[a-z][a-z0-9-]*$/.test(name)) {
+    throw new Error("Integration name must be lowercase letters, numbers, and hyphens");
+  }
+}
+
+export function getNonInteractiveConfig(
+  options: IntegrationGeneratorOptionsLike,
+): IntegrationConfig {
+  const { name, displayName, authType } = options;
+
+  if (!name || !displayName || !authType) {
+    throw new Error(
+      "Non-interactive mode requires --name, --display-name, and --auth-type options",
+    );
+  }
+
+  const normalizedName = name.toLowerCase();
+
+  return {
+    name: normalizedName,
+    displayName,
+    authType,
+    apiBaseUrl: options.apiBaseUrl ?? `https://api.${name}.com`,
+    authorizationUrl: options.authorizationUrl,
+    tokenUrl: options.tokenUrl,
+    scopes: parseScopes(options.scopes),
+    tokenAuthMethod: normalizeTokenAuthMethod(options.tokenAuthMethod),
+    additionalAuthParams: parseAdditionalAuthParams(options.additionalAuthParams),
+    usePKCE: parseBooleanOption(options.usePKCE, false),
+    envVarPrefix: name.toUpperCase().replace(/-/g, "_"),
+  };
+}
+
+const TOOL_FILE_CONTENTS: Record<string, { inputSchema: string; executeBody: string }> = {
+  "list-items.ts": {
+    inputSchema: `limit: z.number().optional().describe("Maximum number of items to return"),
+    offset: z.number().optional().describe("Number of items to skip"),`,
+    executeBody: `const items = await listItems({
+        limit: input.limit,
+        offset: input.offset,
+      });
+      return {
+        success: true,
+        items,
+        count: items.length,
+      };`,
+  },
+  "get-item.ts": {
+    inputSchema: `id: z.string().describe("The ID of the item to retrieve"),`,
+    executeBody: `const item = await getItem(input.id);
+      return {
+        success: true,
+        item,
+      };`,
+  },
+  "search.ts": {
+    inputSchema: `query: z.string().describe("Search query"),`,
+    executeBody: `const results = await searchItems(input.query);
+      return {
+        success: true,
+        results,
+        count: results.length,
+      };`,
+  },
+};
+
+export function getToolInputSchema(toolFile: string): string {
+  return TOOL_FILE_CONTENTS[toolFile]?.inputSchema ?? "";
+}
+
+export function getToolExecuteBody(toolFile: string): string {
+  return TOOL_FILE_CONTENTS[toolFile]?.executeBody ?? "";
+}

package/src/cli/commands/generate/integration-generator.ts

@@ -12,6 +12,18 @@ import { createFileSystem, type FileSystem } from "../../../src/platform/index.j
 import { ensureDir } from "../../utils/fs.js";
 import { isInteractive as checkIsInteractive, promptSync } from "../../../src/platform/index.js";
 import { isCiEnv, isDenoTestingEnv } from "../../../src/config/index.js";
+import {
+  getNonInteractiveConfig,
+  getToolExecuteBody,
+  getToolInputSchema,
+  type IntegrationConfig,
+  normalizeTokenAuthMethod,
+  parseAdditionalAuthParams,
+  parseBooleanOption,
+  parseScopes,
+  type TokenAuthMethod,
+  validateIntegrationName,
+} from "./integration-generator-helpers.js";
 import { select } from "../../utils/terminal-select.js";
 
 let fs: FileSystem;
@@ -41,27 +53,6 @@ export interface IntegrationGeneratorOptions {
   skipPrompts?: boolean;
 }
 
-type TokenAuthMethod =
-  | "basic"
-  | "body"
-  | "client_secret_basic"
-  | "client_secret_post"
-  | "request_body";
-
-interface IntegrationConfig {
-  name: string;
-  displayName: string;
-  authType: "oauth2" | "api-key";
-  apiBaseUrl: string;
-  authorizationUrl?: string;
-  tokenUrl?: string;
-  scopes: string[];
-  tokenAuthMethod: TokenAuthMethod;
-  additionalAuthParams: Record<string, string>;
-  usePKCE: boolean;
-  envVarPrefix: string;
-}
-
 function canRunPrompts(): boolean {
   return !(isCiEnv() || isDenoTestingEnv()) && checkIsInteractive();
 }
@@ -73,86 +64,6 @@ function promptText(question: string, defaultValue?: string): Promise<string> {
   return Promise.resolve(input?.trim() || defaultValue || "");
 }
 
-function parseScopes(scopes?: string): string[] {
-  return scopes?.split(",").map((s) => s.trim()) || [];
-}
-
-function parseAdditionalAuthParams(params?: string): Record<string, string> {
-  if (!params?.trim()) return {};
-
-  return Object.fromEntries(
-    params.split(",")
-      .map((entry) => entry.trim())
-      .filter(Boolean)
-      .map((entry) => {
-        const separatorIndex = entry.indexOf("=");
-        if (separatorIndex === -1) {
-          throw new Error(
-            "Additional auth params must use key=value pairs separated by commas",
-          );
-        }
-
-        const key = entry.slice(0, separatorIndex).trim();
-        const value = entry.slice(separatorIndex + 1).trim();
-
-        if (!key || !value) {
-          throw new Error(
-            "Additional auth params must use non-empty key=value pairs",
-          );
-        }
-
-        return [key, value];
-      }),
-  );
-}
-
-function normalizeTokenAuthMethod(method?: string): TokenAuthMethod {
-  switch (method?.trim().toLowerCase()) {
-    case "basic":
-      return "basic";
-    case "body":
-      return "body";
-    case "client_secret_basic":
-      return "client_secret_basic";
-    case "client_secret_post":
-      return "client_secret_post";
-    case "request_body":
-    case undefined:
-    case "":
-      return "request_body";
-    default:
-      throw new Error(
-        "OAuth token auth method must be one of: request_body, body, basic, client_secret_basic, client_secret_post",
-      );
-  }
-}
-
-function parseBooleanOption(value: string | boolean | undefined, defaultValue = false): boolean {
-  if (typeof value === "boolean") return value;
-  if (!value?.trim()) return defaultValue;
-
-  switch (value.trim().toLowerCase()) {
-    case "y":
-    case "yes":
-    case "true":
-    case "1":
-      return true;
-    case "n":
-    case "no":
-    case "false":
-    case "0":
-      return false;
-    default:
-      throw new Error("Boolean option must be yes/no, true/false, or 1/0");
-  }
-}
-
-function validateIntegrationName(name: string): void {
-  if (!name || !/^[a-z][a-z0-9-]*$/.test(name)) {
-    throw new Error("Integration name must be lowercase letters, numbers, and hyphens");
-  }
-}
-
 export async function generateIntegration(
   projectDir: string,
   options: IntegrationGeneratorOptions = {},
@@ -182,32 +93,6 @@ export async function generateIntegration(
   console.log("");
 }
 
-function getNonInteractiveConfig(options: IntegrationGeneratorOptions): IntegrationConfig {
-  const { name, displayName, authType } = options;
-
-  if (!name || !displayName || !authType) {
-    throw new Error(
-      "Non-interactive mode requires --name, --display-name, and --auth-type options",
-    );
-  }
-
-  const normalizedName = name.toLowerCase();
-
-  return {
-    name: normalizedName,
-    displayName,
-    authType,
-    apiBaseUrl: options.apiBaseUrl ?? `https://api.${name}.com`,
-    authorizationUrl: options.authorizationUrl,
-    tokenUrl: options.tokenUrl,
-    scopes: parseScopes(options.scopes),
-    tokenAuthMethod: normalizeTokenAuthMethod(options.tokenAuthMethod),
-    additionalAuthParams: parseAdditionalAuthParams(options.additionalAuthParams),
-    usePKCE: parseBooleanOption(options.usePKCE, false),
-    envVarPrefix: name.toUpperCase().replace(/-/g, "_"),
-  };
-}
-
 async function getInteractiveConfig(
   options: IntegrationGeneratorOptions,
 ): Promise<IntegrationConfig> {
@@ -809,47 +694,6 @@ export async function searchItems(query: string): Promise<unknown[]> {
   cliLogger.debug("Created API client");
 }
 
-function getToolInputSchema(toolFile: string): string {
-  return TOOL_FILE_CONTENTS[toolFile]?.inputSchema ?? "";
-}
-
-function getToolExecuteBody(toolFile: string): string {
-  return TOOL_FILE_CONTENTS[toolFile]?.executeBody ?? "";
-}
-
-const TOOL_FILE_CONTENTS: Record<string, { inputSchema: string; executeBody: string }> = {
-  "list-items.ts": {
-    inputSchema: `limit: z.number().optional().describe("Maximum number of items to return"),
-    offset: z.number().optional().describe("Number of items to skip"),`,
-    executeBody: `const items = await listItems({
-        limit: input.limit,
-        offset: input.offset,
-      });
-      return {
-        success: true,
-        items,
-        count: items.length,
-      };`,
-  },
-  "get-item.ts": {
-    inputSchema: `id: z.string().describe("The ID of the item to retrieve"),`,
-    executeBody: `const item = await getItem(input.id);
-      return {
-        success: true,
-        item,
-      };`,
-  },
-  "search.ts": {
-    inputSchema: `query: z.string().describe("Search query"),`,
-    executeBody: `const results = await searchItems(input.query);
-      return {
-        success: true,
-        results,
-        count: results.length,
-      };`,
-  },
-};
-
 async function createToolSkeletons(baseDir: string, config: IntegrationConfig): Promise<void> {
   const tools = [
     {