@donotdev/cli 0.0.13 → 0.0.15

package/dist/bin/commands/sync-secrets.js

@@ -1915,7 +1915,7 @@ var require_parse = __commonJS({
       CHAR_NO_BREAK_SPACE,
       CHAR_ZERO_WIDTH_NOBREAK_SPACE
     } = require_constants();
-    var parse = (input, options = {}) => {
+    var parse2 = (input, options = {}) => {
       if (typeof input !== "string") {
         throw new TypeError("Expected a string");
       }
@@ -2115,7 +2115,7 @@ var require_parse = __commonJS({
       push({ type: "eos" });
       return ast;
     };
-    module.exports = parse;
+    module.exports = parse2;
   }
 });
 
@@ -2127,7 +2127,7 @@ var require_braces = __commonJS({
     var stringify2 = require_stringify();
     var compile = require_compile();
     var expand = require_expand();
-    var parse = require_parse();
+    var parse2 = require_parse();
     var braces = (input, options = {}) => {
       let output = [];
       if (Array.isArray(input)) {
@@ -2147,7 +2147,7 @@ var require_braces = __commonJS({
       }
       return output;
     };
-    braces.parse = (input, options = {}) => parse(input, options);
+    braces.parse = (input, options = {}) => parse2(input, options);
     braces.stringify = (input, options = {}) => {
       if (typeof input === "string") {
         return stringify2(braces.parse(input, options), options);
@@ -2804,7 +2804,7 @@ var require_parse2 = __commonJS({
     var syntaxError = (type, char) => {
       return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
     };
-    var parse = (input, options) => {
+    var parse2 = (input, options) => {
       if (typeof input !== "string") {
         throw new TypeError("Expected a string");
       }
@@ -2953,7 +2953,7 @@ var require_parse2 = __commonJS({
             output = token.close = `)$))${extglobStar}`;
           }
           if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
-            const expression = parse(rest, { ...options, fastpaths: false }).output;
+            const expression = parse2(rest, { ...options, fastpaths: false }).output;
             output = token.close = `)${expression})${extglobStar})`;
           }
           if (token.prev.type === "bos") {
@@ -3478,7 +3478,7 @@ var require_parse2 = __commonJS({
       }
       return state;
     };
-    parse.fastpaths = (input, options) => {
+    parse2.fastpaths = (input, options) => {
       const opts = { ...options };
       const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
       const len = input.length;
@@ -3544,7 +3544,7 @@ var require_parse2 = __commonJS({
       }
       return source;
     };
-    module.exports = parse;
+    module.exports = parse2;
   }
 });
 
@@ -3555,7 +3555,7 @@ var require_picomatch = __commonJS({
     init_utils();
     var path = __require("path");
     var scan = require_scan();
-    var parse = require_parse2();
+    var parse2 = require_parse2();
     var utils = require_utils2();
     var constants2 = require_constants2();
     var isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
@@ -3643,7 +3643,7 @@ var require_picomatch = __commonJS({
     picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
     picomatch.parse = (pattern, options) => {
       if (Array.isArray(pattern)) return pattern.map((p2) => picomatch.parse(p2, options));
-      return parse(pattern, { ...options, fastpaths: false });
+      return parse2(pattern, { ...options, fastpaths: false });
     };
     picomatch.scan = (input, options) => scan(input, options);
     picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
@@ -3669,10 +3669,10 @@ var require_picomatch = __commonJS({
       }
       let parsed = { negated: false, fastpaths: true };
       if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) {
-        parsed.output = parse.fastpaths(input, options);
+        parsed.output = parse2.fastpaths(input, options);
       }
       if (!parsed.output) {
-        parsed = parse(input, options);
+        parsed = parse2(input, options);
       }
       return picomatch.compileRe(parsed, options, returnOutput, returnState);
     };
@@ -7534,11 +7534,39 @@ var init_PathResolver = __esm({
 });
 
 // packages/tooling/src/utils/errors.ts
-var DoNotDevError;
+var DO_NOT_DEV_ERROR_CODES, DoNotDevError;
 var init_errors = __esm({
   "packages/tooling/src/utils/errors.ts"() {
     "use strict";
     init_utils();
+    DO_NOT_DEV_ERROR_CODES = {
+      CONFIGURATION_ERROR: "configuration-error",
+      CONFIG_NOT_FOUND: "config-not-found",
+      CONFIG_INVALID: "config-invalid",
+      PATH_RESOLUTION_ERROR: "path-resolution-error",
+      FILE_OPERATION_ERROR: "file-operation-error",
+      FILE_NOT_FOUND: "file-not-found",
+      PERMISSION_DENIED: "permission-denied",
+      GENERATION_ERROR: "generation-error",
+      TEMPLATE_ERROR: "template-error",
+      TEMPLATE_NOT_FOUND: "template-not-found",
+      CLI_EXECUTION_ERROR: "cli-execution-error",
+      COMMAND_NOT_FOUND: "command-not-found",
+      COMMAND_FAILED: "command-failed",
+      VALIDATION_ERROR: "validation-error",
+      SCHEMA_ERROR: "schema-error",
+      DEPENDENCY_ERROR: "dependency-error",
+      DEPENDENCY_NOT_FOUND: "dependency-not-found",
+      DEPENDENCY_VERSION_ERROR: "dependency-version-error",
+      INVALID_ARGUMENT: "invalid-argument",
+      MISSING_ARGUMENT: "missing-argument",
+      MISSING_PROJECT_ID: "missing-project-id",
+      FIREBASE_CLI_ERROR: "firebase-cli-error",
+      DEPLOYMENT_FAILED: "deployment-failed",
+      OPERATION_CANCELLED: "operation-cancelled",
+      TIMEOUT_ERROR: "timeout-error",
+      UNKNOWN_ERROR: "unknown-error"
+    };
     DoNotDevError = class _DoNotDevError extends Error {
       /** The error code categorizing this error */
       code;
@@ -7558,7 +7586,7 @@ var init_errors = __esm({
        * @param {Record<string, any>} [options.context] - Additional context data
        * @param {boolean} [options.displayable=true] - Whether this error should be displayed to the user
        */
-      constructor(message, code = "unknown-error", options) {
+      constructor(message, code = DO_NOT_DEV_ERROR_CODES.UNKNOWN_ERROR, options) {
         super(message);
         this.name = "DoNotDevError";
         this.code = code;
@@ -7589,7 +7617,7 @@ var init_errors = __esm({
        * @param {boolean} [options.displayable=true] - Whether this error should be displayed to the user
        * @returns {DoNotDevError} New DoNotDev error wrapping the original
        */
-      static from(error2, context, code = "unknown-error", options) {
+      static from(error2, context, code = DO_NOT_DEV_ERROR_CODES.UNKNOWN_ERROR, options) {
         if (!(error2 instanceof Error)) {
           return new _DoNotDevError(
             `Unknown error: ${String(error2)}`,
@@ -7626,21 +7654,21 @@ var init_errors = __esm({
         }
         const message = error2.message.toLowerCase();
         if (error2.name === "ValidationError" || message.includes("validation")) {
-          return "validation-error";
+          return DO_NOT_DEV_ERROR_CODES.VALIDATION_ERROR;
         }
         if (message.includes("not found") || message.includes("no such file")) {
-          return "file-not-found";
+          return DO_NOT_DEV_ERROR_CODES.FILE_NOT_FOUND;
         }
         if (message.includes("permission") || message.includes("access denied")) {
-          return "permission-denied";
+          return DO_NOT_DEV_ERROR_CODES.PERMISSION_DENIED;
         }
         if (message.includes("timeout") || message.includes("timed out")) {
-          return "timeout-error";
+          return DO_NOT_DEV_ERROR_CODES.TIMEOUT_ERROR;
         }
         if (message.includes("dependency") || message.includes("module not found")) {
-          return "dependency-error";
+          return DO_NOT_DEV_ERROR_CODES.DEPENDENCY_ERROR;
         }
-        return "unknown-error";
+        return DO_NOT_DEV_ERROR_CODES.UNKNOWN_ERROR;
       }
     };
   }
@@ -7655,6 +7683,7 @@ import {
   extname as extname2,
   relative as relative2,
   resolve as resolve2,
+  parse,
   isAbsolute as pathIsAbsolute
 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
@@ -7716,18 +7745,7 @@ var init_utils = __esm({
   }
 });
 
-// packages/cli/src/bin/commands/sync-secrets.ts
-init_utils();
-
-// packages/tooling/src/index.ts
-init_utils();
-
-// packages/tooling/src/cli/index.ts
-init_utils();
-
 // packages/tooling/src/utils/cli-input.ts
-init_utils();
-init_dist2();
 async function askForSelection(message, choices, defaultValue = 0) {
   const options = choices.map((choice) => ({
     value: choice.value,
@@ -7745,13 +7763,16 @@ async function askForSelection(message, choices, defaultValue = 0) {
   }
   return result;
 }
+var init_cli_input = __esm({
+  "packages/tooling/src/utils/cli-input.ts"() {
+    "use strict";
+    init_utils();
+    init_dist2();
+  }
+});
 
 // packages/tooling/src/apps/sync-secrets.ts
-init_utils();
 import { spawnSync } from "node:child_process";
-init_cli_output();
-init_errors();
-init_pathResolver();
 function parseEnvFile(filePath) {
   if (!pathExists(filePath)) {
     throw new DoNotDevError(
@@ -7760,7 +7781,8 @@ function parseEnvFile(filePath) {
       { context: { filePath } }
     );
   }
-  const content = readSync(filePath, { format: "text" });
+  const contentRaw = readSync(filePath, { format: "text" });
+  const content = typeof contentRaw === "string" ? contentRaw : null;
   if (!content) {
     throw new Error(`Failed to read secrets file: ${filePath}`);
   }
@@ -7835,7 +7857,8 @@ function detectFirebaseProjectId(cwd) {
   const firebasercPath = joinPath(searchDir, ".firebaserc");
   if (pathExists(firebasercPath)) {
     try {
-      const firebaserc = readSync(firebasercPath, { format: "json" });
+      const firebasercRaw = readSync(firebasercPath, { format: "json" });
+      const firebaserc = firebasercRaw && typeof firebasercRaw === "object" ? firebasercRaw : null;
       if (firebaserc && firebaserc.projects?.default) {
         return firebaserc.projects.default;
       }
@@ -7848,7 +7871,8 @@ function detectFirebaseProjectId(cwd) {
     const firebasercPath2 = joinPath(current, ".firebaserc");
     if (pathExists(firebasercPath2)) {
       try {
-        const firebaserc = readSync(firebasercPath2, { format: "json" });
+        const firebasercRaw = readSync(firebasercPath2, { format: "json" });
+        const firebaserc = firebasercRaw && typeof firebasercRaw === "object" ? firebasercRaw : null;
         if (firebaserc && firebaserc.projects?.default) {
           return firebaserc.projects.default;
         }
@@ -8064,12 +8088,99 @@ function setVercelSecret(key, value, projectId, dryRun = false) {
     );
   }
 }
+function detectGitHubRepo() {
+  try {
+    const result = spawnSync("git", ["remote", "get-url", "origin"], {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (result.status !== 0 || !result.stdout) return void 0;
+    const url = result.stdout.trim();
+    const sshMatch = url.match(/github\.com[:/]([^/]+\/[^/.]+)/);
+    if (sshMatch) return sshMatch[1];
+    const httpsMatch = url.match(/github\.com\/([^/]+\/[^/.]+)/);
+    if (httpsMatch) return httpsMatch[1];
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function setGitHubSecret(key, value, repo, dryRun = false) {
+  if (dryRun) {
+    log.info(
+      `[DRY RUN] Would set GitHub secret: ${key}${repo ? ` (repo: ${repo})` : ""}`
+    );
+    return;
+  }
+  try {
+    log.info(`Setting GitHub secret: ${key}${repo ? ` (repo: ${repo})` : ""}`);
+    const args = ["secret", "set", key];
+    if (repo) {
+      args.push("--repo", repo);
+    }
+    const result = spawnSync("gh", args, {
+      input: value,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (result.error) {
+      throw result.error;
+    }
+    if (result.status !== 0) {
+      const stderr = result.stderr?.toString() || "";
+      const stdout = result.stdout?.toString() || "";
+      const errorOutput = stderr || stdout;
+      if (errorOutput.includes("not logged in") || errorOutput.includes("authentication")) {
+        throw new DoNotDevError(
+          `GitHub CLI authentication required. Run 'gh auth login' to authenticate.`,
+          "permission-denied",
+          { context: { key, error: errorOutput } }
+        );
+      }
+      throw new Error(
+        `gh CLI exited with code ${result.status}
+${errorOutput}`
+      );
+    }
+    log.success(`GitHub secret ${key} set successfully`);
+  } catch (err) {
+    if (err instanceof DoNotDevError) throw err;
+    log.error(`Failed to set GitHub secret ${key}:`, err);
+    throw new DoNotDevError(
+      `Failed to set GitHub secret ${key}`,
+      "command-failed",
+      {
+        context: {
+          target: "github",
+          key,
+          error: err instanceof Error ? err.message : String(err)
+        }
+      }
+    );
+  }
+}
+function uploadServiceAccountToGitHub(appDir, repo, dryRun = false, staging = false) {
+  const fileName = staging ? "service-account-key.staging.json" : "service-account-key.json";
+  const secretName = staging ? "FIREBASE_SERVICE_ACCOUNT_STAGING" : "FIREBASE_SERVICE_ACCOUNT";
+  const filePath = joinPath(appDir, fileName);
+  if (!pathExists(filePath)) {
+    log.debug(`No ${fileName} found in ${appDir}, skipping GitHub upload`);
+    return;
+  }
+  const contentRaw = readSync(filePath, { format: "text" });
+  const content = typeof contentRaw === "string" ? contentRaw : null;
+  if (!content) return;
+  const encoded = Buffer2.from(content).toString("base64");
+  setGitHubSecret(secretName, encoded, repo, dryRun);
+}
 async function main(options = {}) {
   const config = {
     envFile: options.envFile || ".env",
     platform: options.platform,
     projectId: options.projectId,
     vercelProjectId: options.vercelProjectId,
+    target: options.target || "runtime",
+    repo: options.repo,
     dryRun: options.dryRun ?? false,
     verbose: options.verbose ?? false
   };
@@ -8081,20 +8192,22 @@ Usage: bun run sync-secrets [options]
 
 Options:
   --env-file <path>       Path to .env file (default: .env)
-  --platform <platform>   Platform to sync to: 'firebase' or 'vercel' (auto-detected if not specified)
+  --target <target>       Sync target: 'runtime' (default) or 'github'
+  --platform <platform>   Platform to sync to: 'firebase' or 'vercel' (runtime target only, auto-detected)
   --project <id>          Firebase project ID (for Firebase platform)
   --vercel-project <id>   Vercel project ID (for Vercel platform)
+  --repo <owner/repo>     GitHub repository (github target only, auto-detected from git remote)
   --dry-run, --dry        Show what would be done without actually setting secrets
   --verbose               Show detailed output
   --help                  Show this help message
 
 Examples:
-  bun run sync-secrets
-  bun run sync-secrets --platform=firebase
-  bun run sync-secrets --platform=vercel
-  bun run sync-secrets --dry-run
-  bun run sync-secrets --env-file .env.production --project my-project
-  bun run sync-secrets --platform=vercel --vercel-project my-vercel-project
+  dndev sync-secrets                                      # sync to Firebase/Vercel runtime
+  dndev sync-secrets --target github                      # sync to GitHub Secrets
+  dndev sync-secrets --target github --repo owner/repo    # sync to specific repo
+  dndev sync-secrets --platform=firebase
+  dndev sync-secrets --dry-run
+  dndev sync-secrets --env-file .env.production --project my-project
         `);
     return 0;
   }
@@ -8134,6 +8247,51 @@ Examples:
       }
     }
     const envFilePath = joinPath(currentDir, config.envFile);
+    const syncTarget = config.target || "runtime";
+    if (syncTarget === "github") {
+      const repo = config.repo || detectGitHubRepo();
+      if (!repo) {
+        log.error(
+          "Could not detect GitHub repository. Use --repo owner/repo or ensure a GitHub remote is configured."
+        );
+        return 1;
+      }
+      log.info(`Syncing secrets to GitHub repository: ${repo}`);
+      const secrets2 = parseEnvFile(envFilePath);
+      const secretKeys2 = Object.keys(secrets2);
+      if (secretKeys2.length === 0) {
+        log.info("No secrets found in .env file");
+      } else {
+        log.info(`Found ${secretKeys2.length} secrets to sync to GitHub:`);
+        secretKeys2.forEach((key) => log.info(`  ${key}`));
+        for (const [key, value] of Object.entries(secrets2)) {
+          setGitHubSecret(key, value, repo, config.dryRun);
+        }
+      }
+      if (firebaseProjectDir) {
+        uploadServiceAccountToGitHub(
+          firebaseProjectDir,
+          repo,
+          config.dryRun,
+          false
+        );
+        uploadServiceAccountToGitHub(
+          firebaseProjectDir,
+          repo,
+          config.dryRun,
+          true
+        );
+      } else {
+        uploadServiceAccountToGitHub(currentDir, repo, config.dryRun, false);
+        uploadServiceAccountToGitHub(currentDir, repo, config.dryRun, true);
+      }
+      if (config.dryRun) {
+        log.success("\nDry run completed. No GitHub secrets were set.");
+      } else {
+        log.success("\nAll secrets synced to GitHub successfully!");
+      }
+      return 0;
+    }
     const platform = config.platform || detectPlatform();
     log.info(`Reading secrets from: ${envFilePath}`);
     if (config.verbose) {
@@ -8194,6 +8352,26 @@ All secrets synced successfully to ${platform}!`);
     return 1;
   }
 }
+var init_sync_secrets = __esm({
+  "packages/tooling/src/apps/sync-secrets.ts"() {
+    "use strict";
+    init_utils();
+    init_cli_input();
+    init_cli_output();
+    init_errors();
+    init_pathResolver();
+  }
+});
+
+// packages/cli/src/bin/commands/sync-secrets.ts
+init_utils();
+
+// packages/tooling/src/index.ts
+init_utils();
+
+// packages/tooling/src/cli/index.ts
+init_utils();
+init_sync_secrets();
 export {
   main
 };

package/dist/bin/commands/type-check.d.ts

@@ -0,0 +1,14 @@
+export interface TypeCheckOptions {
+    /** Optional: scope to one app subdirectory */
+    app?: string;
+    verbose?: boolean;
+    quiet?: boolean;
+}
+/**
+ * Type-check all packages with a `type-check` script in the consumer project.
+ *
+ * @param options - Command options
+ * @returns Exit code: 0 = all pass, 1 = any failure
+ */
+export declare function main(options?: TypeCheckOptions): Promise<number>;
+//# sourceMappingURL=type-check.d.ts.map

package/dist/bin/commands/type-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-check.d.ts","sourceRoot":"","sources":["../../../src/bin/commands/type-check.ts"],"names":[],"mappings":"AAgBA,MAAM,WAAW,gBAAgB;IAC/B,8CAA8C;IAC9C,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAoQD;;;;;GAKG;AACH,wBAAsB,IAAI,CAAC,OAAO,GAAE,gBAAqB,GAAG,OAAO,CAAC,MAAM,CAAC,CAkF1E"}