swallowkit 1.1.2 → 2.0.0-alpha.10

package/src/cli/commands/add-auth.ts

@@ -5,8 +5,10 @@
 
 import * as fs from "fs";
 import * as path from "path";
-import { ensureSwallowKitProject, getBackendLanguage, getConnectorDefinition, getValidatedFullConfig } from "../../core/config";
-import { AuthProvider, BackendLanguage, CustomJwtConfig, RdbConnectorConfig } from "../../types";
+import { ensureSwallowKitProject, getBackendLanguage, getFrontendFramework, getConnectorDefinition, getValidatedFullConfig } from "../../core/config";
+import { generateManagedFunctionConfig, generateReactAuthBff, generateReactBffHelper } from "../../core/scaffold/react-bff-generator";
+import { adaptReactPage } from "../../core/scaffold/react-ui-generator";
+import { AuthConfig, AuthProvider, BackendLanguage, CustomJwtConfig, RdbConnectorConfig } from "../../types";
 import {
   generateAuthModels,
   generateAuthFunctionsTS,
@@ -98,6 +100,32 @@ function defaultCustomJwtConfig(): CustomJwtConfig {
   };
 }
 
+function writeCallFunction(cwd: string, session: FileOperationSession, nextSource: string, auth: AuthConfig): void {
+  if (getFrontendFramework() === "react") {
+    const name = JSON.parse(session.readFile(path.join(cwd, "package.json"))).name;
+    session.writeFile(path.join(cwd, "bff", "src", "lib", "call-function.ts"), generateReactBffHelper(name, auth), managedMeta);
+  } else {
+    session.writeFile(path.join(cwd, "lib", "api", "call-function.ts"), nextSource, managedMeta);
+  }
+}
+
+function writeLoginPage(cwd: string, session: FileOperationSession, source: string): void {
+  const react = getFrontendFramework() === "react";
+  const destination = react ? path.join(cwd, "src", "pages", "login.tsx") : path.join(cwd, "app", "login", "page.tsx");
+  session.writeFile(destination, react ? adaptReactPage(source) : source, managedMeta);
+}
+
+function writeAuthContext(cwd: string, session: FileOperationSession, source: string): void {
+  session.writeFile(path.join(cwd, "lib", "auth", "auth-context.tsx"), getFrontendFramework() === "react" ? adaptReactPage(source) : source, managedMeta);
+}
+
+function writeManagedAuthRoute(cwd: string, session: FileOperationSession, customJwt: boolean): void {
+  const name = JSON.parse(session.readFile(path.join(cwd, "package.json"))).name;
+  const sharedName = JSON.parse(session.readFile(path.join(cwd, "shared", "package.json"))).name;
+  session.writeFile(path.join(cwd, "bff", "src", "auth", "index.ts"), generateReactAuthBff(name, sharedName, customJwt), managedMeta);
+  session.writeFile(path.join(cwd, "bff", "auth", "function.json"), generateManagedFunctionConfig("auth/{action}", ["GET", "POST"], "auth"), managedMeta);
+}
+
 function setupSwaAuth(cwd: string, backendLanguage: BackendLanguage, session: FileOperationSession, allowedProviders?: string[]): void {
   const providers = normalizeSwaProviders(allowedProviders);
   const helperPath = backendLanguage === "typescript"
@@ -112,14 +140,12 @@ function setupSwaAuth(cwd: string, backendLanguage: BackendLanguage, session: Fi
       : generateSwaAuthHelperPython();
   session.writeFile(helperPath, helper, managedMeta);
 
-  const callFnPath = path.join(cwd, "lib", "api", "call-function.ts");
-  session.writeFile(callFnPath, generateBFFCallFunctionWithSwaAuth(), managedMeta);
+  writeCallFunction(cwd, session, generateBFFCallFunctionWithSwaAuth(), { provider: "swa" });
 
   const authDir = path.join(cwd, "lib", "auth");
   session.writeFile(path.join(authDir, "auth-context.tsx"), generateSwaAuthContext(providers), managedMeta);
   updateRootLayoutWithAuthProvider(cwd, session);
-  const loginDir = path.join(cwd, "app", "login");
-  session.writeFile(path.join(loginDir, "page.tsx"), generateSwaLoginPage(providers), managedMeta);
+  writeLoginPage(cwd, session, generateSwaLoginPage(providers));
   updateSwaRouteConfig(cwd, session, providers);
 }
 
@@ -127,10 +153,10 @@ function setupExternalTokenAuth(cwd: string, backendLanguage: BackendLanguage, s
   const authDir = path.join(cwd, "lib", "auth");
   writeIfMissing(session, path.join(authDir, "external-token-adapter.ts"), generateExternalTokenAdapter());
   session.writeFile(path.join(authDir, "authenticated-fetch.ts"), generateAuthenticatedFetch(), managedMeta);
-  session.writeFile(path.join(authDir, "auth-context.tsx"), generateExternalTokenAuthContext(), managedMeta);
-  session.writeFile(path.join(cwd, "lib", "api", "call-function.ts"), generateBFFCallFunctionWithAuth(), managedMeta);
-  const meDir = path.join(cwd, "app", "api", "auth", "me");
-  session.writeFile(path.join(meDir, "route.ts"), generateExternalTokenBFFMeRoute(), managedMeta);
+  writeAuthContext(cwd, session, generateExternalTokenAuthContext());
+  writeCallFunction(cwd, session, generateBFFCallFunctionWithAuth(), { provider: "external-token" });
+  if (getFrontendFramework() === "react") writeManagedAuthRoute(cwd, session, false);
+  else session.writeFile(path.join(cwd, "app", "api", "auth", "me", "route.ts"), generateExternalTokenBFFMeRoute(), managedMeta);
   updateRootLayoutWithAuthProvider(cwd, session);
 
   if (backendLanguage === "typescript") {
@@ -240,6 +266,14 @@ export function addAuthProviderToRootLayout(layout: string): string {
 }
 
 function updateRootLayoutWithAuthProvider(cwd: string, session: FileOperationSession): void {
+  if (getFrontendFramework() === "react") {
+    const mainPath = path.join(cwd, "src", "main.tsx");
+    const main = session.readFile(mainPath);
+    if (main.includes("<AuthProvider>")) return;
+    if (!main.includes("<App />")) throw new Error("Could not find <App /> in src/main.tsx; cannot install AuthProvider");
+    session.writeFile(mainPath, `import { AuthProvider } from '@/lib/auth/auth-context';\n${main.replace("<App />", "<AuthProvider><App /></AuthProvider>")}`, extensionMeta);
+    return;
+  }
   const layoutPath = path.join(cwd, "app", "layout.tsx");
   if (!session.fileExists(layoutPath)) {
     throw new Error("app/layout.tsx was not found; cannot install AuthProvider");
@@ -364,27 +398,25 @@ export async function addAuthCommand(options: AddAuthOptions) {
 
   // 4. Generate proxy
   console.log("\n  Generating proxy...");
-  const proxyPath = path.join(cwd, "proxy.ts");
-  session.writeFile(proxyPath, generateProxy(projectName), managedMeta);
-  console.log(` Created: proxy.ts`);
+  if (getFrontendFramework() === "nextjs") {
+    const proxyPath = path.join(cwd, "proxy.ts");
+    session.writeFile(proxyPath, generateProxy(projectName), managedMeta);
+    console.log(` Created: proxy.ts`);
+  }
 
   // 5. Generate login page
   console.log("\n Generating login page...");
-  const loginDir = path.join(cwd, "app", "login");
-  session.writeFile(path.join(loginDir, "page.tsx"), generateLoginPage(), managedMeta);
-  console.log(` Created: app/login/page.tsx`);
+  writeLoginPage(cwd, session, generateLoginPage());
 
   // 6. Generate auth context
   console.log("\n Generating auth context...");
-  const authLibDir = path.join(cwd, "lib", "auth");
-  session.writeFile(path.join(authLibDir, "auth-context.tsx"), generateAuthContext(), managedMeta);
+  writeAuthContext(cwd, session, generateAuthContext());
   console.log(`✅ Created: lib/auth/auth-context.tsx`);
 
   // 7. Update callFunction with auth support
   console.log("\n Updating callFunction with auth support...");
-  const callFnPath = path.join(cwd, "lib", "api", "call-function.ts");
-  session.writeFile(callFnPath, generateBFFCallFunctionWithAuth(), managedMeta);
-  console.log(` Updated: lib/api/call-function.ts`);
+  writeCallFunction(cwd, session, generateBFFCallFunctionWithAuth(), { provider: "custom-jwt" });
+  console.log(` Updated: ${getFrontendFramework() === "react" ? "bff/src/lib" : "lib/api"}/call-function.ts`);
 
   // 8. Update swallowkit.config.js
   console.log("\n Updating configuration...");
@@ -396,7 +428,7 @@ export async function addAuthCommand(options: AddAuthOptions) {
 
   // 10. Install dependencies
   console.log("\n Installing auth dependencies...");
-  await installAuthDependencies(cwd, backendLanguage, rdbProvider, session);
+  installAuthDependenciesSync(cwd, backendLanguage, rdbProvider, session);
   await finalize();
 
   console.log("\n Authentication setup complete!");
@@ -426,7 +458,8 @@ function findObjectEnd(content: string, open: number): number {
 function updateConfigWithNamedScheme(cwd: string, scheme: string, provider: AuthProvider, session: FileOperationSession, allowedProviders?: string[]): void {
   const jsPath = path.join(cwd, "swallowkit.config.js");
   const jsonPath = path.join(cwd, "swallowkit.config.json");
-  const configPath = session.fileExists(jsPath) ? jsPath : jsonPath;
+  // Match loadConfig precedence: swallowkit.config.json wins when both files exist.
+  const configPath = session.fileExists(jsonPath) ? jsonPath : jsPath;
   if (!session.fileExists(configPath)) throw new Error("swallowkit.config.js or swallowkit.config.json is required");
   const swaProviders = provider === "swa" ? normalizeSwaProviders(allowedProviders) : undefined;
   if (configPath.endsWith(".json")) {
@@ -478,6 +511,11 @@ function addNamedScheme(cwd: string, scheme: string, provider: AuthProvider, lan
   // Validate/update config before creating files, so duplicate names stop safely.
   updateConfigWithNamedScheme(cwd, scheme, provider, session, allowedProviders);
   const slug = scheme.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/_/g, "-").toLowerCase();
+  if (provider === "custom-jwt") {
+    // The scheme's JWT helper needs the same token/password/driver packages as single-provider custom-jwt.
+    const connector = getConnectorDefinition(defaultCustomJwtConfig().userConnector) as RdbConnectorConfig | undefined;
+    installAuthDependenciesSync(cwd, language, connector?.provider ?? "mysql", session);
+  }
   if (language === "typescript") {
     const dir = path.join(cwd, "functions", "src", "auth", "schemes", slug);
     if (provider === "external-token") writeIfMissing(session, path.join(dir, "verifier.ts"), generateExternalTokenVerifierTS());
@@ -498,11 +536,19 @@ function addNamedScheme(cwd: string, scheme: string, provider: AuthProvider, lan
   if (provider === "external-token") {
     writeIfMissing(session, path.join(clientDir, "token-adapter.ts"), generateExternalTokenAdapter());
     writeIfMissing(session, path.join(clientDir, "authenticated-fetch.ts"), generateAuthenticatedFetch().replace("'./external-token-adapter'", "'./token-adapter'"));
-    writeIfMissing(session, path.join(clientDir, "auth-context.tsx"), generateExternalTokenAuthContext().replace(/external-token-adapter/g, "token-adapter"));
+    const source = generateExternalTokenAuthContext().replace(/external-token-adapter/g, "token-adapter");
+    writeIfMissing(session, path.join(clientDir, "auth-context.tsx"), getFrontendFramework() === "react" ? adaptReactPage(source) : source);
   } else if (provider === "swa") {
     writeIfMissing(session, path.join(clientDir, "auth-context.tsx"), generateSwaAuthContext(allowedProviders));
   } else if (provider === "custom-jwt") {
-    writeIfMissing(session, path.join(clientDir, "auth-context.tsx"), generateAuthContext());
+    writeIfMissing(session, path.join(clientDir, "auth-context.tsx"), getFrontendFramework() === "react" ? adaptReactPage(generateAuthContext()) : generateAuthContext());
+  }
+  if (getFrontendFramework() === "react") {
+    const existing = getValidatedFullConfig().auth;
+    writeCallFunction(cwd, session, "", {
+      ...existing, schemes: { ...existing?.schemes, [scheme]: { provider } },
+    });
+    return;
   }
   const callFunctionPath = path.join(cwd, "lib", "api", "call-function.ts");
   if (!session.fileExists(callFunctionPath)) writeIfMissing(session, callFunctionPath, generateBFFCallFunctionWithMultipleAuth());
@@ -649,9 +695,14 @@ function generateFunctionsAuth(
     const functionAppPath = path.join(functionsDir, "function_app.py");
     if (session.fileExists(functionAppPath)) {
       const content = session.readFile(functionAppPath);
-      const authImport = "from blueprints.auth import bp as auth_bp";
+      const authImport = "from blueprints.auth import auth_bp";
       const authRegister = "app.register_blueprint(auth_bp)";
-      if (!content.includes(authImport)) {
+      // Earlier releases imported a non-existent `bp`; repair it in place when re-running.
+      const legacyImport = "from blueprints.auth import bp as auth_bp";
+      if (content.includes(legacyImport)) {
+        session.writeFile(functionAppPath, content.replace(legacyImport, authImport), extensionMeta);
+        console.log(` Updated: functions/function_app.py (fixed auth blueprint import)`);
+      } else if (!content.includes(authImport)) {
         const marker = "# SwallowKit scaffold registrations";
         if (content.includes(marker)) {
           const updated = content.replace(
@@ -667,6 +718,10 @@ function generateFunctionsAuth(
 }
 
 function generateBFFAuth(cwd: string, projectName: string, sharedPackageName: string, session: FileOperationSession): void {
+  if (getFrontendFramework() === "react") {
+    writeManagedAuthRoute(cwd, session, true);
+    return;
+  }
   const authApiDir = path.join(cwd, "app", "api", "auth");
 
   // Login route
@@ -698,6 +753,24 @@ function generateBFFAuth(cwd: string, projectName: string, sharedPackageName: st
 }
 
 function updateConfigWithAuth(cwd: string, provider: AuthProvider, config: CustomJwtConfig, session: FileOperationSession, allowedProviders?: string[]): void {
+  const jsonPath = path.join(cwd, "swallowkit.config.json");
+  if (session.fileExists(jsonPath)) {
+    // loadConfig reads swallowkit.config.json first, so it is the effective configuration.
+    const value = JSON.parse(session.readFile(jsonPath));
+    if (value.auth) {
+      console.log("  'auth' section already exists in swallowkit.config.json");
+      return;
+    }
+    value.auth = {
+      provider,
+      ...(provider === "custom-jwt" ? { customJwt: { ...config, jwtSecretEnv: config.jwtSecretEnv || "JWT_SECRET", tokenExpiry: config.tokenExpiry || "24h" } } : {}),
+      ...(provider === "swa" ? { swa: { allowedProviders: normalizeSwaProviders(allowedProviders), roleSource: "swa-roles" } } : {}),
+      authorization: { defaultPolicy: provider === "none" ? "anonymous" : "authenticated" },
+    };
+    session.writeFile(jsonPath, JSON.stringify(value, null, 2) + "\n", extensionMeta);
+    console.log(` Updated: swallowkit.config.json`);
+    return;
+  }
   const configPath = path.join(cwd, "swallowkit.config.js");
   if (!session.fileExists(configPath)) {
     console.warn("  swallowkit.config.js not found. Please add auth config manually.");
@@ -742,7 +815,8 @@ function updateConfigWithAuth(cwd: string, provider: AuthProvider, config: Custo
     provider: '${provider}',
 ${providerSettings}
     authorization: {
-      defaultPolicy: 'authenticated',
+      // Disabled auth has no scheme to authenticate against; 'authenticated' would fail validateConfig.
+      defaultPolicy: '${provider === "none" ? "anonymous" : "authenticated"}',
     },
   },
 `;
@@ -777,7 +851,7 @@ function updateEnvironmentFiles(cwd: string, session: FileOperationSession): voi
   }
 }
 
-async function installAuthDependencies(cwd: string, backendLanguage: BackendLanguage, provider: "mysql" | "postgres" | "sqlserver" = "mysql", session: FileOperationSession): Promise<void> {
+function installAuthDependenciesSync(cwd: string, backendLanguage: BackendLanguage, provider: "mysql" | "postgres" | "sqlserver" = "mysql", session: FileOperationSession): void {
   if (backendLanguage === "typescript") {
     const funcPkgPath = path.join(cwd, "functions", "package.json");
     if (session.fileExists(funcPkgPath)) {

package/src/cli/commands/configure-mcp.ts

@@ -0,0 +1,54 @@
+import { Command } from "commander";
+import { ensureSwallowKitProject } from "../../core/config";
+import {
+  MCP_CONFIG_PATH,
+  MCP_LATEST,
+  lookupPublishedLatestVersion,
+  readMcpConfigVersion,
+  resolveMcpPinVersion,
+  writeMcpConfigVersion,
+} from "../../core/project/mcp-config";
+import { resolveProjectSwallowKit } from "../../mcp/version-selection";
+import { parseSemver } from "../../utils/semver";
+import { getSwallowKitVersion } from "../../version";
+
+export interface ConfigureMcpResult {
+  previousVersion: string | null;
+  version: string;
+  reason: string;
+}
+
+export function configureMcp(
+  options: { version?: string; cwd?: string },
+  lookupLatest: (packageName: string) => string | null = lookupPublishedLatestVersion
+): ConfigureMcpResult {
+  const cwd = options.cwd ?? process.cwd();
+  const requested = (options.version ?? "auto").trim();
+  const previousVersion = readMcpConfigVersion(cwd);
+
+  let decision: { version: string; reason: string };
+  if (requested === "auto") {
+    const projectVersion = resolveProjectSwallowKit(cwd)?.version ?? getSwallowKitVersion();
+    decision = resolveMcpPinVersion(projectVersion, lookupLatest("swallowkit"));
+  } else if (requested === MCP_LATEST) {
+    decision = { version: MCP_LATEST, reason: "Explicitly requested latest." };
+  } else if (parseSemver(requested)) {
+    decision = { version: requested, reason: "Explicitly pinned version." };
+  } else {
+    throw new Error(`--version must be "auto", "latest", or a semantic version (got "${requested}").`);
+  }
+
+  writeMcpConfigVersion(cwd, decision.version);
+  return { previousVersion, ...decision };
+}
+
+export const configureMcpCommand = new Command("configure-mcp")
+  .description(`Select the SwallowKit MCP version used by ${MCP_CONFIG_PATH} (auto: latest unless the project is newer)`)
+  .option("--version <version>", "auto | latest | <semver>", "auto")
+  .action((options: { version?: string }) => {
+    ensureSwallowKitProject("configure-mcp");
+    const result = configureMcp({ version: options.version });
+    console.log(`${MCP_CONFIG_PATH}: SWALLOWKIT_MCP_VERSION ${result.previousVersion ?? "(unset)"} -> ${result.version}`);
+    console.log(`Reason: ${result.reason}`);
+    console.log("Restart the MCP server (or reload your agent) to apply the change.");
+  });