kasy-cli 1.2.1

package/lib/scaffold/patch.js

@@ -0,0 +1,395 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const YAML = require('yaml');
+const {
+  pathExists,
+  ensureDir,
+  mergeDirNoConflicts
+} = require('../utils/fs');
+
+const PATCH_MANIFEST = 'patch.manifest.json';
+
+function normalizePath(value) {
+  return String(value || '').replace(/\\/g, '/').replace(/^\/+/, '');
+}
+
+function normalizeScalar(value) {
+  return JSON.stringify(value);
+}
+
+function mergeYamlNode(baseNode, patchNode) {
+  if (Array.isArray(baseNode) && Array.isArray(patchNode)) {
+    const merged = [...baseNode];
+    const seen = new Set(baseNode.map((item) => normalizeScalar(item)));
+    for (const item of patchNode) {
+      const key = normalizeScalar(item);
+      if (!seen.has(key)) {
+        merged.push(item);
+        seen.add(key);
+      }
+    }
+    return merged;
+  }
+
+  const baseIsObject =
+    baseNode !== null && typeof baseNode === 'object' && !Array.isArray(baseNode);
+  const patchIsObject =
+    patchNode !== null && typeof patchNode === 'object' && !Array.isArray(patchNode);
+
+  if (baseIsObject && patchIsObject) {
+    const merged = { ...baseNode };
+    for (const [key, value] of Object.entries(patchNode)) {
+      if (Object.prototype.hasOwnProperty.call(merged, key)) {
+        merged[key] = mergeYamlNode(merged[key], value);
+      } else {
+        merged[key] = value;
+      }
+    }
+    return merged;
+  }
+
+  return patchNode;
+}
+
+function parsePlistEntries(xml) {
+  const dictMatch = xml.match(/<dict>([\s\S]*?)<\/dict>/);
+  if (!dictMatch) {
+    return [];
+  }
+
+  const body = dictMatch[1];
+  const entries = [];
+  const regex = /<key>([^<]+)<\/key>\s*([\s\S]*?)(?=<key>|$)/g;
+  let match = regex.exec(body);
+
+  while (match) {
+    entries.push({
+      key: match[1].trim(),
+      valueXml: match[2].trim()
+    });
+    match = regex.exec(body);
+  }
+
+  return entries;
+}
+
+function mergeInfoPlist(targetXml, patchXml) {
+  const targetEntries = parsePlistEntries(targetXml);
+  const patchEntries = parsePlistEntries(patchXml);
+
+  if (targetEntries.length === 0 || patchEntries.length === 0) {
+    return targetXml;
+  }
+
+  const targetHeaderMatch = targetXml.match(/^([\s\S]*?<dict>)/);
+  const targetFooterMatch = targetXml.match(/(<\/dict>[\s\S]*)$/);
+  if (!targetHeaderMatch || !targetFooterMatch) {
+    return targetXml;
+  }
+
+  const orderedKeys = targetEntries.map((entry) => entry.key);
+  const mergedByKey = new Map(targetEntries.map((entry) => [entry.key, entry.valueXml]));
+
+  for (const entry of patchEntries) {
+    if (!mergedByKey.has(entry.key)) {
+      orderedKeys.push(entry.key);
+    }
+    mergedByKey.set(entry.key, entry.valueXml);
+  }
+
+  const mergedBody = orderedKeys
+    .map((key) => {
+      const valueXml = String(mergedByKey.get(key) || '')
+        .split('\n')
+        .map((line) => line.trim())
+        .join('\n    ');
+      return `    <key>${key}</key>\n    ${valueXml}`;
+    })
+    .join('\n');
+
+  return `${targetHeaderMatch[1]}\n${mergedBody}\n${targetFooterMatch[1]}`;
+}
+
+function mapGradleBlocks(lines) {
+  const stack = [];
+  const blocks = new Map();
+
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    const openMatch = trimmed.match(/^([A-Za-z_][A-Za-z0-9_.-]*)\s*(?:\([^)]*\))?\s*\{$/);
+    if (openMatch) {
+      const name = openMatch[1];
+      stack.push({ name, start: i, depth: stack.length + 1 });
+      continue;
+    }
+
+    if (trimmed.startsWith('}')) {
+      const current = stack.pop();
+      if (current) {
+        const pathKey = [...stack.map((item) => item.name), current.name].join('.');
+        blocks.set(pathKey, {
+          start: current.start,
+          end: i,
+          depth: current.depth
+        });
+      }
+    }
+  }
+
+  return blocks;
+}
+
+function detectGradlePath(lines, lineIndex) {
+  const stack = [];
+
+  for (let i = 0; i <= lineIndex; i += 1) {
+    const trimmed = lines[i].trim();
+    const openMatch = trimmed.match(/^([A-Za-z_][A-Za-z0-9_.-]*)\s*(?:\([^)]*\))?\s*\{$/);
+    if (openMatch) {
+      stack.push(openMatch[1]);
+      continue;
+    }
+
+    if (trimmed.startsWith('}')) {
+      stack.pop();
+    }
+  }
+
+  return stack.join('.');
+}
+
+function normalizeLine(line) {
+  return line.trim().replace(/\s+/g, ' ');
+}
+
+function mergeGradleText(targetText, patchText) {
+  const targetLines = targetText.split('\n');
+  const patchLines = patchText.split('\n');
+  const existing = new Set(targetLines.map((line) => normalizeLine(line)).filter(Boolean));
+
+  const groupedByPath = new Map();
+  for (let i = 0; i < patchLines.length; i += 1) {
+    const line = patchLines[i];
+    const trimmed = line.trim();
+    if (!trimmed || trimmed === '{' || trimmed === '}' || trimmed.startsWith('//')) {
+      continue;
+    }
+
+    const normalized = normalizeLine(line);
+    if (existing.has(normalized)) {
+      continue;
+    }
+
+    const pathKey = detectGradlePath(patchLines, i);
+    if (!groupedByPath.has(pathKey)) {
+      groupedByPath.set(pathKey, []);
+    }
+    groupedByPath.get(pathKey).push(trimmed);
+  }
+
+  if (groupedByPath.size === 0) {
+    return targetText;
+  }
+
+  let output = [...targetLines];
+  for (const [pathKey, linesToInsert] of groupedByPath.entries()) {
+    const blocks = mapGradleBlocks(output);
+    const block = blocks.get(pathKey);
+    const uniqueLines = [];
+
+    for (const line of linesToInsert) {
+      if (!existing.has(normalizeLine(line))) {
+        uniqueLines.push(line);
+        existing.add(normalizeLine(line));
+      }
+    }
+
+    if (uniqueLines.length === 0) {
+      continue;
+    }
+
+    if (block) {
+      const indent = '  '.repeat(block.depth);
+      const insertion = uniqueLines.map((line) => `${indent}${line}`);
+      output.splice(block.end, 0, ...insertion);
+      continue;
+    }
+
+    if (!pathKey) {
+      output.push('', ...uniqueLines);
+      continue;
+    }
+
+    const names = pathKey.split('.');
+    const snippet = [];
+    let indentLevel = 0;
+    for (const name of names) {
+      const indent = '  '.repeat(indentLevel);
+      snippet.push(`${indent}${name} {`);
+      indentLevel += 1;
+    }
+    for (const line of uniqueLines) {
+      snippet.push(`${'  '.repeat(indentLevel)}${line}`);
+    }
+    while (indentLevel > 0) {
+      indentLevel -= 1;
+      snippet.push(`${'  '.repeat(indentLevel)}}`);
+    }
+    output.push('', ...snippet);
+  }
+
+  return output.join('\n');
+}
+
+async function applyCopyOperation(filePath, patchDir, targetDir) {
+  const normalized = normalizePath(filePath);
+  const source = path.join(patchDir, 'files', normalized);
+  const destination = path.join(targetDir, normalized);
+  await ensureDir(path.dirname(destination));
+
+  const sourceExists = await pathExists(source);
+  if (!sourceExists) {
+    throw new Error(`Patch file not found: ${source}`);
+  }
+
+  const destinationExists = await pathExists(destination);
+  if (!destinationExists) {
+    await fs.copy(source, destination);
+    return;
+  }
+
+  const [sourceContent, targetContent] = await Promise.all([
+    fs.readFile(source),
+    fs.readFile(destination)
+  ]);
+
+  if (!sourceContent.equals(targetContent)) {
+    throw new Error(`Patch conflict on file: ${destination}`);
+  }
+}
+
+async function applyReplaceOperation(filePath, patchDir, targetDir) {
+  const normalized = normalizePath(filePath);
+  const source = path.join(patchDir, 'files', normalized);
+  const destination = path.join(targetDir, normalized);
+  await ensureDir(path.dirname(destination));
+
+  const sourceExists = await pathExists(source);
+  if (!sourceExists) {
+    throw new Error(`Patch file not found: ${source}`);
+  }
+
+  await fs.copy(source, destination);
+}
+
+async function applyRemoveOperation(filePath, targetDir) {
+  const normalized = normalizePath(filePath);
+  const destination = path.join(targetDir, normalized);
+  if (await pathExists(destination)) {
+    await fs.remove(destination);
+  }
+}
+
+async function applyMergeOperation(operation, patchDir, targetDir) {
+  const normalized = normalizePath(operation.path);
+  const sourceRelative = operation.source
+    ? normalizePath(operation.source)
+    : path.join('merge', normalized);
+
+  const source = path.join(patchDir, sourceRelative);
+  const destination = path.join(targetDir, normalized);
+  const destinationExists = await pathExists(destination);
+
+  if (!(await pathExists(source))) {
+    throw new Error(`Merge source not found: ${source}`);
+  }
+
+  if (!destinationExists) {
+    await ensureDir(path.dirname(destination));
+    await fs.copy(source, destination);
+    return;
+  }
+
+  const [targetRaw, patchRaw] = await Promise.all([
+    fs.readFile(destination, 'utf8'),
+    fs.readFile(source, 'utf8')
+  ]);
+
+  let mergedRaw = targetRaw;
+  switch (operation.strategy) {
+    case 'yaml_deep_merge': {
+      const targetDoc = YAML.parse(targetRaw) || {};
+      const patchDoc = YAML.parse(patchRaw) || {};
+      const mergedDoc = mergeYamlNode(targetDoc, patchDoc);
+      mergedRaw = YAML.stringify(mergedDoc);
+      break;
+    }
+    case 'plist_key_merge': {
+      mergedRaw = mergeInfoPlist(targetRaw, patchRaw);
+      break;
+    }
+    case 'gradle_line_merge': {
+      mergedRaw = mergeGradleText(targetRaw, patchRaw);
+      break;
+    }
+    default:
+      throw new Error(`Unsupported merge strategy: ${operation.strategy}`);
+  }
+
+  if (mergedRaw !== targetRaw) {
+    await fs.writeFile(destination, mergedRaw, 'utf8');
+  }
+}
+
+async function applyManifestPatch(patchDir, targetDir, manifest) {
+  const copy = Array.isArray(manifest.copy) ? manifest.copy : [];
+  const replace = Array.isArray(manifest.replace) ? manifest.replace : [];
+  const remove = Array.isArray(manifest.remove) ? manifest.remove : [];
+  const merge = Array.isArray(manifest.merge) ? manifest.merge : [];
+
+  for (const filePath of copy) {
+    await applyCopyOperation(filePath, patchDir, targetDir);
+  }
+
+  for (const filePath of replace) {
+    await applyReplaceOperation(filePath, patchDir, targetDir);
+  }
+
+  for (const operation of merge) {
+    await applyMergeOperation(operation, patchDir, targetDir);
+  }
+
+  for (const filePath of remove) {
+    await applyRemoveOperation(filePath, targetDir);
+  }
+}
+
+async function applyPatchDirectory(patchDir, targetDir) {
+  if (!(await pathExists(patchDir))) {
+    return;
+  }
+
+  const manifestPath = path.join(patchDir, PATCH_MANIFEST);
+  if (!(await pathExists(manifestPath))) {
+    const isBackend = path.basename(path.dirname(patchDir)) === 'backends';
+    const options = {
+      exclude: ['pubspec.yaml', 'pubspec.lock', 'lib/app.dart', 'lib/backend_config.dart', 'patch.yaml', 'README.md'],
+      overwrite: isBackend ? ['lib/main.dart'] : []
+    };
+    await mergeDirNoConflicts(patchDir, targetDir, options);
+    return;
+  }
+
+  const manifest = await fs.readJson(manifestPath);
+  await applyManifestPatch(patchDir, targetDir, manifest);
+}
+
+module.exports = {
+  PATCH_MANIFEST,
+  applyPatchDirectory,
+  mergeYamlNode,
+  mergeInfoPlist,
+  mergeGradleText
+};

package/lib/scaffold/shared/backend-config.js

@@ -0,0 +1,74 @@
+/**
+ * Centralized backend configuration: files/dirs to remove, post-copy behavior.
+ * Single source of truth — add new backends here.
+ *
+ * @module scaffold/shared/backend-config
+ */
+
+const path = require('node:path');
+const fs = require('fs-extra');
+
+const FIREBASE_SOURCE_DIR = path.resolve(__dirname, '../../../templates/firebase');
+
+/** Firebase-specific files not used by Supabase/API */
+const FIREBASE_ONLY_FILES = [
+  'lib/core/data/api/firestore_retry.dart',
+  'lib/core/data/entities/json_converters.dart',
+  // iOS native home-widget extension config (not needed without widget module)
+  'ios/HomeWidgetExtension.entitlements',
+  'home_widget_config.json',
+];
+
+/** iOS native home-widget extension — not needed for Supabase/API */
+const HOME_WIDGET_IOS_EXTENSION_DIR = 'ios/HomeWidgetExtension';
+
+/**
+ * Get files to remove for a given backend.
+ *
+ * @param {'firebase'|'supabase'|'api'} backend
+ * @returns {string[]}
+ */
+function getFilesToRemove(backend) {
+  if (backend === 'firebase') return [];
+  return [...FIREBASE_ONLY_FILES];
+}
+
+/**
+ * Get directories to remove for a given backend.
+ *
+ * @param {'firebase'|'supabase'|'api'} backend
+ * @param {string[]} [modules=[]] - Selected modules
+ * @returns {string[]}
+ */
+function getDirsToRemove(backend, modules = []) {
+  if (backend === 'firebase') return [];
+  // home_widget works on all backends — only remove the iOS native extension
+  return [HOME_WIDGET_IOS_EXTENSION_DIR];
+}
+
+/**
+ * Remove files and directories from target project.
+ *
+ * @param {string} targetDir - Project root
+ * @param {'firebase'|'supabase'|'api'} backend
+ * @param {string[]} [modules=[]] - Selected modules
+ */
+async function removeBackendSpecificArtifacts(targetDir, backend, modules = []) {
+  const { removeFiles } = require('../engine');
+
+  await removeFiles(targetDir, getFilesToRemove(backend));
+
+  for (const relDir of getDirsToRemove(backend, modules)) {
+    const dirPath = path.join(targetDir, relDir);
+    if (await fs.pathExists(dirPath)) {
+      await fs.remove(dirPath);
+    }
+  }
+}
+
+module.exports = {
+  FIREBASE_SOURCE_DIR,
+  getFilesToRemove,
+  getDirsToRemove,
+  removeBackendSpecificArtifacts,
+};

package/lib/scaffold/shared/fcm-service-account.js

@@ -0,0 +1,126 @@
+/**
+ * FCM Service Account key generation via gcloud CLI.
+ *
+ * Finds the Firebase Admin SDK service account (firebase-adminsdk-*@project.iam.gserviceaccount.com)
+ * and generates a new private key JSON. This is equivalent to:
+ *   Firebase Console → Project Settings → Service Accounts → "Generate new private key"
+ *
+ * Used by Supabase and API backends only.
+ * Firebase backend uses Application Default Credentials (ADC) automatically — no key needed.
+ */
+
+const { exec } = require('node:child_process');
+const { promisify } = require('node:util');
+const fs = require('fs-extra');
+const path = require('node:path');
+const os = require('node:os');
+
+const execAsync = promisify(exec);
+
+async function run(cmd) {
+  try {
+    const { stdout, stderr } = await execAsync(cmd, { maxBuffer: 5 * 1024 * 1024 });
+    return { ok: true, stdout: stdout.trim(), stderr: stderr.trim() };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err.message,
+      stdout: (err.stdout || '').trim(),
+      stderr: (err.stderr || '').trim(),
+    };
+  }
+}
+
+/**
+ * Find the Firebase Admin SDK service account email for a GCP project.
+ * Firebase creates this account automatically when Firebase is added to a project.
+ * Email pattern: firebase-adminsdk-XXXXX@{projectId}.iam.gserviceaccount.com
+ *
+ * @param {string} projectId
+ * @returns {{ ok: boolean, email?: string, error?: string }}
+ */
+async function findFirebaseAdminSdkSA(projectId) {
+  const result = await run(
+    `gcloud iam service-accounts list --project=${projectId}` +
+    ` --filter="email~firebase-adminsdk"` +
+    ` --format="value(email)" --limit=1`
+  );
+  if (!result.ok) return { ok: false, error: result.error };
+  const email = result.stdout.split('\n')[0].trim();
+  if (!email) return { ok: false, error: 'Firebase Admin SDK service account not found' };
+  return { ok: true, email };
+}
+
+/**
+ * Grants the roles/firebasecloudmessaging.admin IAM role to the Firebase Admin SDK
+ * service account. Required for the FCM HTTP v1 API to accept messages.send requests.
+ * Safe to call multiple times (gcloud is idempotent for IAM bindings).
+ *
+ * @param {string} projectId
+ * @param {string} saEmail
+ * @returns {{ ok: boolean, error?: string }}
+ */
+async function grantFcmAdminRole(projectId, saEmail) {
+  const result = await run(
+    `gcloud projects add-iam-policy-binding ${projectId}` +
+    ` --member="serviceAccount:${saEmail}"` +
+    ` --role="roles/firebasecloudmessaging.admin"` +
+    ` --condition=None`
+  );
+  if (!result.ok) {
+    return { ok: false, error: `Failed to grant FCM admin role: ${result.error}` };
+  }
+  return { ok: true };
+}
+
+/**
+ * Generates a new private key for the Firebase Admin SDK service account and returns
+ * the JSON content as a string. The temporary key file is deleted immediately after reading.
+ * Also ensures the service account has the roles/firebasecloudmessaging.admin IAM role.
+ *
+ * @param {string} projectId - Firebase/GCP project ID
+ * @returns {{ ok: boolean, json?: string, saEmail?: string, error?: string }}
+ */
+async function createFcmServiceAccountKey(projectId) {
+  if (!projectId || !projectId.trim()) {
+    return { ok: false, error: 'projectId is required' };
+  }
+
+  const saResult = await findFirebaseAdminSdkSA(projectId.trim());
+  if (!saResult.ok) {
+    return { ok: false, error: saResult.error };
+  }
+
+  const saEmail = saResult.email;
+
+  // Ensure the service account can send FCM messages (idempotent)
+  const roleResult = await grantFcmAdminRole(projectId.trim(), saEmail);
+  if (!roleResult.ok) {
+    return { ok: false, error: roleResult.error };
+  }
+
+  const tmpPath = path.join(os.tmpdir(), `kasy-fcm-${Date.now()}.json`);
+
+  const keyResult = await run(
+    `gcloud iam service-accounts keys create "${tmpPath}"` +
+    ` --iam-account="${saEmail}"` +
+    ` --project=${projectId.trim()}`
+  );
+
+  if (!keyResult.ok) {
+    await fs.remove(tmpPath).catch(() => {});
+    return { ok: false, error: `Failed to generate key: ${keyResult.error}` };
+  }
+
+  try {
+    const jsonContent = await fs.readFile(tmpPath, 'utf8');
+    await fs.remove(tmpPath).catch(() => {});
+    JSON.parse(jsonContent); // validate
+    return { ok: true, json: jsonContent.trim(), saEmail };
+  } catch (err) {
+    await fs.remove(tmpPath).catch(() => {});
+    return { ok: false, error: `Failed to read generated key: ${err.message}` };
+  }
+}
+
+module.exports = { createFcmServiceAccountKey };