@donotdev/cli 0.0.14 → 0.0.16

package/dist/bin/commands/setup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.js","sourceRoot":"","sources":["../../../src/bin/commands/setup.ts"],"names":[],"mappings":"AAAA,yCAAyC;AACzC;;;GAGG;AAEH,OAAO,EAAE,KAAK,IAAI,IAAI,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/bin/commands/supabase-setup.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Supabase Setup Command Wrapper
+ * @description Re-exports supabaseSetup from tooling for CLI bundling.
+ */
+export { supabaseSetup as main } from '@donotdev/tooling';
+//# sourceMappingURL=supabase-setup.d.ts.map

package/dist/bin/commands/supabase-setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supabase-setup.d.ts","sourceRoot":"","sources":["../../../src/bin/commands/supabase-setup.ts"],"names":[],"mappings":"AACA;;;GAGG;AAEH,OAAO,EAAE,aAAa,IAAI,IAAI,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/bin/commands/supabase-setup.js

@@ -0,0 +1,7 @@
+// packages/cli/src/bin/commands/supabase-setup.ts
+/**
+ * @fileoverview Supabase Setup Command Wrapper
+ * @description Re-exports supabaseSetup from tooling for CLI bundling.
+ */
+export { supabaseSetup as main } from '@donotdev/tooling';
+//# sourceMappingURL=supabase-setup.js.map

package/dist/bin/commands/supabase-setup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"supabase-setup.js","sourceRoot":"","sources":["../../../src/bin/commands/supabase-setup.ts"],"names":[],"mappings":"AAAA,kDAAkD;AAClD;;;GAGG;AAEH,OAAO,EAAE,aAAa,IAAI,IAAI,EAAE,MAAM,mBAAmB,CAAC"}

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

@@ -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;
       }
     };
   }
@@ -7717,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,
@@ -7746,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(
@@ -7761,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}`);
   }
@@ -7836,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;
       }
@@ -7849,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;
         }
@@ -8065,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
   };
@@ -8082,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;
   }
@@ -8135,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) {
@@ -8195,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"}