swallowkit 2.0.0-alpha.1 → 2.0.0-alpha.10

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

@@ -428,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!");
@@ -458,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")) {
@@ -510,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());
@@ -689,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(
@@ -742,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.");
@@ -786,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"}',
     },
   },
 `;
@@ -821,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.");
+  });

package/src/cli/commands/dev.ts

@@ -19,15 +19,15 @@ import {
 import { BackendLanguage } from '../../types';
 import { detectFromProject, getCommands } from '../../utils/package-manager';
 import {
-  buildProjectLocalUvEnv,
   buildProjectLocalUvInstallerEnv,
   buildUvPipInstallArgs,
-  buildUvVenvArgs,
+  ensureUvVirtualEnvironment,
   getProjectLocalUvInstallerCommand,
   getProjectLocalUvPaths,
   getPythonProjectRoot,
 } from '../../utils/python-uv';
 import { ConnectorMockServer } from '../../core/mock/connector-mock-server';
+import { buildReactDevConfigSource } from '../../utils/react-dev';
 
 export interface DevOptions {
   port?: string;
@@ -65,8 +65,8 @@ function normalizeParsedDevOptions(options: ParsedDevActionOptions): DevOptions
   };
 }
 
-export function buildFunctionsStartArgs(functionsPort: string): string[] {
-  return ['start', '--port', functionsPort];
+export function buildFunctionsStartArgs(functionsPort: string, backendLanguage: BackendLanguage = 'typescript'): string[] {
+  return [...(backendLanguage === 'csharp' ? [] : ['start']), '--port', functionsPort];
 }
 
 export function parseCoreToolsVersion(output: string): string | null {
@@ -105,15 +105,15 @@ export function buildFunctionsCoreToolsCommand(
 
     return {
       command: 'npm',
-      argsPrefix: ['exec', '--yes', NPM_CORE_TOOLS_PACKAGE, '--'],
-      label: `npm exec ${NPM_CORE_TOOLS_PACKAGE} (${reason})`,
+      argsPrefix: ['exec', '--yes', '--package', NPM_CORE_TOOLS_PACKAGE, '--', 'dotnet', 'run', '--no-launch-profile', '--'],
+      label: `dotnet run with npm ${NPM_CORE_TOOLS_PACKAGE} (${reason})`,
     };
   }
 
   return {
-    command: 'func',
-    argsPrefix: [],
-    label: installedVersion ? `func ${installedVersion}` : 'func',
+    command: backendLanguage === 'csharp' ? 'dotnet' : 'func',
+    argsPrefix: backendLanguage === 'csharp' ? ['run', '--no-launch-profile', '--'] : [],
+    label: backendLanguage === 'csharp' ? 'dotnet run' : installedVersion ? `func ${installedVersion}` : 'func',
   };
 }
 
@@ -138,8 +138,8 @@ export function buildSwaStartArgs(host: string | undefined, nextPort: string, sw
   ];
 }
 
-export function buildReactDevArgs(pm: string, port: string, host = 'localhost'): string[] {
-  const args = ['vite', '--port', port, '--host', host, '--strictPort'];
+export function buildReactDevArgs(pm: string, port: string, host = 'localhost', configPath?: string): string[] {
+  const args = ['vite', '--port', port, '--host', host, '--strictPort', ...(configPath ? ['--config', configPath] : [])];
   return pm === 'pnpm' ? ['exec', ...args] : args;
 }
 
@@ -270,7 +270,7 @@ async function checkCommand(
 }
 
 async function resolveProjectLocalUvCommand(projectRoot: string): Promise<{ command: string; env: NodeJS.ProcessEnv }> {
-  const uvEnv = buildProjectLocalUvEnv(process.env, projectRoot);
+  const uvEnv = { ...process.env };
   const { localUvExecutable } = getProjectLocalUvPaths(projectRoot);
 
   if (await checkCommand('uv', ['--version'], { shell: false })) {
@@ -471,22 +471,8 @@ async function bridgePythonCoreToolsForWindowsArm64(
 async function preparePythonFunctionsEnvironment(functionsDir: string): Promise<NodeJS.ProcessEnv> {
   const projectRoot = getPythonProjectRoot(functionsDir);
   const { command: uvCommand, env: uvEnv } = await resolveProjectLocalUvCommand(projectRoot);
-  const { venvDir, pythonExecutable } = getPythonVirtualEnvPaths(functionsDir);
-  const hasUsableVirtualEnv = fs.existsSync(pythonExecutable) && await checkCommand(pythonExecutable, ['--version'], {
-    cwd: functionsDir,
-    env: uvEnv,
-    shell: false,
-  });
-
-  if (!hasUsableVirtualEnv) {
-    const venvArgs = buildUvVenvArgs('.venv');
-    if (fs.existsSync(venvDir)) {
-      venvArgs.push('--clear');
-    }
-
-    console.log('📦 Creating Python virtual environment with uv...');
-    await runCommand(uvCommand, venvArgs, functionsDir, 'python virtual environment setup', uvEnv, false);
-  }
+  const { venvDir } = getPythonVirtualEnvPaths(functionsDir);
+  const pythonExecutable = await ensureUvVirtualEnvironment(uvCommand, venvDir, functionsDir, uvEnv);
 
   console.log('📦 Installing Python Azure Functions dependencies with uv...');
   await runCommand(
@@ -538,7 +524,7 @@ export async function assertDevPortAvailable(port: number, host: string): Promis
 }
 
 function stopDevProcesses(processes: ChildProcess[]): void {
-  const active = processes.filter(child => child.pid && !child.killed);
+  const active = processes.filter(child => child.pid && !child.killed && child.exitCode === null && child.signalCode === null);
   if (process.platform === 'win32' && active.length) {
     // Windows shell termination alone leaves Vite, Core Tools, and SWA running.
     const ids = active.map(child => child.pid).join(',');
@@ -721,6 +707,14 @@ async function startDevEnvironment(options: DevOptions) {
   const functionsBaseUrl = buildFunctionsBaseUrl(options.host, functionsPort);
   let functionsReadinessPromise: Promise<boolean> | null = null;
   let functionsReady = !!options.noFunctions;
+  let reactDevConfigDir: string | undefined;
+  const cleanupReactDevConfig = () => {
+    if (reactDevConfigDir) {
+      fs.rmSync(reactDevConfigDir, { recursive: true, force: true });
+      reactDevConfigDir = undefined;
+    }
+  };
+  process.once('exit', cleanupReactDevConfig);
 
   // Cleanup processes on Ctrl+C
   process.on('SIGINT', async () => {
@@ -939,7 +933,7 @@ async function startDevEnvironment(options: DevOptions) {
 
       // Azure Functions を起動
       const functionsCommand = functionsCoreToolsCommand ?? buildFunctionsCoreToolsCommand(backendLanguage, installedCoreToolsVersion);
-      const funcProcess = spawn(functionsCommand.command, [...functionsCommand.argsPrefix, ...buildFunctionsStartArgs(functionsPort)], {
+      const funcProcess = spawn(functionsCommand.command, [...functionsCommand.argsPrefix, ...buildFunctionsStartArgs(functionsPort, backendLanguage)], {
         cwd: functionsDir,
         shell: true,
         stdio: 'pipe', // Always pipe to capture output
@@ -987,6 +981,8 @@ async function startDevEnvironment(options: DevOptions) {
         console.error('⚠️  Azure Functions startup error:', error.message);
         console.log('💡 Please ensure Azure Functions Core Tools is installed');
         console.log(`   ${pmCmd.addGlobal} azure-functions-core-tools@4`);
+        stopDevProcesses(processes);
+        process.exit(1);
       });
 
       funcProcess.on('close', (code) => {
@@ -997,6 +993,8 @@ async function startDevEnvironment(options: DevOptions) {
             console.log('   Reinstall a matching Core Tools v4 package (Windows users should prefer the official x64/x86 MSI for their machine).');
             console.log('   SwallowKit local Python dev uses functions/.venv and requirements.txt, but Core Tools still needs its own bundled Python worker.');
           }
+          stopDevProcesses(processes);
+          process.exit(code || 1);
         }
       });
 
@@ -1083,7 +1081,17 @@ async function startDevEnvironment(options: DevOptions) {
     }
 
     // 5. Start Next.js development server
-    const nextArgs = react ? buildReactDevArgs(pm, port, options.host) : buildNextDevArgs(pm, port);
+    let reactDevConfigPath: string | undefined;
+    if (react) {
+      const stateDir = path.join(process.cwd(), '.swallowkit');
+      fs.mkdirSync(stateDir, { recursive: true });
+      reactDevConfigDir = fs.mkdtempSync(path.join(stateDir, 'vite-dev-'));
+      reactDevConfigPath = path.join(reactDevConfigDir, 'config.mjs');
+      fs.writeFileSync(reactDevConfigPath, buildReactDevConfigSource());
+    }
+    const nextArgs = react
+      ? buildReactDevArgs(pm, port, options.host, reactDevConfigPath && path.relative(process.cwd(), reactDevConfigPath))
+      : buildNextDevArgs(pm, port);
     
     // Ensure .env.local points to bffTargetPort so Next.js reads the correct backend URL.
     // When --mock-connectors is active, bffTargetPort = mock port (7072); otherwise = Functions port (7071).
@@ -1141,6 +1149,7 @@ async function startDevEnvironment(options: DevOptions) {
 
     nextProcess.on('error', (error) => {
       console.error(`❌ ${frontendLabel} startup error:`, error.message);
+      stopDevProcesses(processes);
       process.exit(1);
     });