pubz 0.2.12 → 0.4.0

package/README.md

@@ -1,5 +1,9 @@
 # `pubz`
 
+<img width="1024" height="1024" alt="image" src="https://github.com/user-attachments/assets/11ffa33c-e895-4a7d-b2c3-dfadde8dd124" />
+
+---
+
 ```bash
 bunx pubz
 ```
@@ -14,8 +18,9 @@ bunx pubz
 6. Commits version changes
 7. Prompts you for where you want to publish (e.g. `npm` or private registry)
 8. Builds packages
-9. Publishes to npm
-10. Prompts you to create a `git tag` and push it
+9. Transforms `workspace:` definitions to hard version numbers (so `npm` can be used for publishing with OIDC support).
+10. Publishes to npm
+11. Prompts you to create a `git tag` and push it
 
 ## Options
 

package/dist/cli.js

@@ -195,6 +195,9 @@ function prompt(question) {
 function closePrompt() {
   rl.close();
 }
+function pausePrompt() {
+  rl.close();
+}
 function resetPrompt() {
   rl.close();
   rl = readline.createInterface({
@@ -317,10 +320,25 @@ async function multiSelect(message, options, allSelectedByDefault = true) {
 
 // src/auth.ts
 import { spawn } from "node:child_process";
+import { homedir } from "node:os";
+
+// src/log.ts
+var verboseEnabled = false;
+function setVerbose(enabled) {
+  verboseEnabled = enabled;
+}
+function debug(...args) {
+  if (verboseEnabled) {
+    console.error("[debug]", ...args);
+  }
+}
+
+// src/auth.ts
 async function checkNpmAuth(registry) {
   return new Promise((resolve2) => {
     const proc = spawn("npm", ["whoami", "--registry", registry], {
-      stdio: ["inherit", "pipe", "pipe"]
+      stdio: ["ignore", "pipe", "pipe"],
+      cwd: homedir()
     });
     let stdout = "";
     let stderr = "";
@@ -334,6 +352,7 @@ async function checkNpmAuth(registry) {
       if (code === 0 && stdout.trim()) {
         resolve2({ authenticated: true, username: stdout.trim() });
       } else {
+        debug(`npm whoami failed: code=${code}, stdout=${JSON.stringify(stdout)}, stderr=${JSON.stringify(stderr)}`);
         resolve2({ authenticated: false });
       }
     });
@@ -341,10 +360,13 @@ async function checkNpmAuth(registry) {
 }
 async function npmLogin(registry) {
   return new Promise((resolve2) => {
+    debug(`spawning: npm login --registry ${registry}`);
     const proc = spawn("npm", ["login", "--registry", registry], {
-      stdio: "inherit"
+      stdio: "inherit",
+      cwd: homedir()
     });
     proc.on("close", (code) => {
+      debug(`npm login exited: code=${code}`);
       if (code === 0) {
         resolve2({ success: true });
       } else {
@@ -357,6 +379,7 @@ async function npmLogin(registry) {
 // src/publish.ts
 import { spawn as spawn2 } from "node:child_process";
 import { readFile as readFile2, stat as stat3 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
 import { join as join3 } from "node:path";
 function run(command, args, cwd) {
   return new Promise((resolve2) => {
@@ -441,6 +464,7 @@ async function verifyBuild(pkg) {
 function isOtpError(output) {
   return output.includes("EOTP") || output.includes("one-time password");
 }
+var NPM_COMMAND = process.env.PUBZ_NPM_COMMAND ?? "npm";
 async function publishPackage(pkg, registry, context, dryRun) {
   if (dryRun) {
     console.log(`  [DRY RUN] Would publish ${pkg.name}@${pkg.version} to ${registry}`);
@@ -454,11 +478,13 @@ async function publishPackage(pkg, registry, context, dryRun) {
   let result;
   if (context.useBrowserAuth) {
     args.push("--auth-type", "web");
-    const interactiveResult = await runInteractive("npm", args, pkg.path);
+    args.push(pkg.path);
+    context.onInteractiveStart?.();
+    const interactiveResult = await runInteractive(NPM_COMMAND, args, homedir2());
     result = { code: interactiveResult.code, output: "" };
     context.onInteractiveComplete?.();
   } else {
-    result = await run("npm", args, pkg.path);
+    result = await run(NPM_COMMAND, args, pkg.path);
   }
   if (result.code !== 0) {
     if (isOtpError(result.output)) {
@@ -534,8 +560,184 @@ async function pushGitTag(version, cwd, dryRun) {
   return { success: true };
 }
 
+// src/changelog.ts
+import { spawn as spawn3 } from "node:child_process";
+function parseGitRemoteUrl(remoteUrl) {
+  const sshMatch = remoteUrl.match(/^git@([^:]+):(.+?)(?:\.git)?$/);
+  if (sshMatch) {
+    return `https://${sshMatch[1]}/${sshMatch[2]}`;
+  }
+  const httpsMatch = remoteUrl.match(/^https?:\/\/([^/]+)\/(.+?)(?:\.git)?$/);
+  if (httpsMatch) {
+    return `https://${httpsMatch[1]}/${httpsMatch[2]}`;
+  }
+  return null;
+}
+function runSilent(command, args, cwd) {
+  return new Promise((resolve2) => {
+    const proc = spawn3(command, args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let output = "";
+    proc.stdout?.on("data", (data) => {
+      output += data.toString();
+    });
+    proc.stderr?.on("data", (data) => {
+      output += data.toString();
+    });
+    proc.on("close", (code) => {
+      resolve2({ code: code ?? 1, output });
+    });
+  });
+}
+async function getPreviousTag(cwd) {
+  const result = await runSilent("git", ["tag", "--sort=-version:refname"], cwd);
+  if (result.code !== 0)
+    return null;
+  const tags = result.output.trim().split(`
+`).filter((t) => t.length > 0);
+  return tags[0] ?? null;
+}
+async function getRepoUrl(cwd) {
+  const result = await runSilent("git", ["remote", "get-url", "origin"], cwd);
+  if (result.code !== 0)
+    return null;
+  return parseGitRemoteUrl(result.output.trim());
+}
+async function getCommitsSince(ref, cwd) {
+  const result = await runSilent("git", ["log", `${ref}..HEAD`, "--oneline", "--no-decorate"], cwd);
+  if (result.code !== 0)
+    return [];
+  return result.output.trim().split(`
+`).filter((line) => line.length > 0).map((line) => {
+    const spaceIdx = line.indexOf(" ");
+    return {
+      sha: line.slice(0, spaceIdx),
+      message: line.slice(spaceIdx + 1)
+    };
+  });
+}
+function isReleaseCommit(message) {
+  return /^chore: release v/.test(message);
+}
+function formatChangelogTerminal(commits) {
+  const filtered = commits.filter((c) => !isReleaseCommit(c.message));
+  if (filtered.length === 0)
+    return "";
+  return filtered.map((c) => `  ${dim(c.sha)} ${c.message}`).join(`
+`);
+}
+function formatChangelogMarkdown(commits, repoUrl) {
+  const filtered = commits.filter((c) => !isReleaseCommit(c.message));
+  if (filtered.length === 0)
+    return "";
+  return filtered.map((c) => {
+    const shaRef = repoUrl ? `[\`${c.sha}\`](${repoUrl}/commit/${c.sha})` : `\`${c.sha}\``;
+    return `- ${shaRef} ${c.message}`;
+  }).join(`
+`);
+}
+async function generateChangelog(cwd) {
+  const [previousTag, repoUrl] = await Promise.all([
+    getPreviousTag(cwd),
+    getRepoUrl(cwd)
+  ]);
+  if (!previousTag) {
+    return { commits: [], terminal: "", markdown: "", previousTag: null, repoUrl };
+  }
+  const commits = await getCommitsSince(previousTag, cwd);
+  const terminal = formatChangelogTerminal(commits);
+  const markdown = formatChangelogMarkdown(commits, repoUrl);
+  return { commits, terminal, markdown, previousTag, repoUrl };
+}
+async function createGitHubRelease(version, body, cwd, dryRun) {
+  const tagName = `v${version}`;
+  if (dryRun) {
+    console.log(`[DRY RUN] Would create GitHub release for ${tagName}`);
+    return { success: true };
+  }
+  const result = await runSilent("gh", ["release", "create", tagName, "--title", tagName, "--notes", body], cwd);
+  if (result.code !== 0) {
+    return {
+      success: false,
+      error: result.output.trim() || `Failed to create GitHub release for ${tagName}`
+    };
+  }
+  const url = result.output.trim();
+  return { success: true, url };
+}
+
 // src/version.ts
 import { readFile as readFile3, writeFile } from "node:fs/promises";
+async function transformWorkspaceProtocolForPublish(packages, newVersion, dryRun) {
+  const packageNames = new Set(packages.map((p) => p.name));
+  const transforms = [];
+  for (const pkg of packages) {
+    const content = await readFile3(pkg.packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(content);
+    let modified = false;
+    for (const depType of [
+      "dependencies",
+      "devDependencies",
+      "peerDependencies"
+    ]) {
+      const deps = packageJson[depType];
+      if (!deps)
+        continue;
+      for (const depName of Object.keys(deps)) {
+        if (packageNames.has(depName)) {
+          const oldVersion = deps[depName];
+          if (oldVersion.startsWith("workspace:")) {
+            const modifier = oldVersion.replace("workspace:", "");
+            const newVersionSpec = modifier === "*" || modifier === "" ? newVersion : `${modifier}${newVersion}`;
+            if (dryRun) {
+              console.log(`  [DRY RUN] Would temporarily transform ${pkg.name} ${depType}.${depName}: ${oldVersion} -> ${newVersionSpec}`);
+            } else {
+              transforms.push({
+                packageJsonPath: pkg.packageJsonPath,
+                depType,
+                depName,
+                originalValue: oldVersion
+              });
+              deps[depName] = newVersionSpec;
+              modified = true;
+            }
+          }
+        }
+      }
+    }
+    if (modified && !dryRun) {
+      await writeFile(pkg.packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+`);
+      console.log(`  Transformed workspace references in ${pkg.name}`);
+    }
+  }
+  return transforms;
+}
+async function restoreWorkspaceProtocol(transforms) {
+  const byPath = new Map;
+  for (const transform of transforms) {
+    const existing = byPath.get(transform.packageJsonPath) ?? [];
+    existing.push(transform);
+    byPath.set(transform.packageJsonPath, existing);
+  }
+  for (const [packageJsonPath, pathTransforms] of byPath) {
+    const content = await readFile3(packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(content);
+    for (const transform of pathTransforms) {
+      const deps = packageJson[transform.depType];
+      if (deps) {
+        deps[transform.depName] = transform.originalValue;
+      }
+    }
+    await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+`);
+  }
+  if (transforms.length > 0) {
+    console.log(`  Restored workspace references in ${byPath.size} package(s)`);
+  }
+}
 function bumpVersion(version, type) {
   if (type === "none")
     return version;
@@ -633,6 +835,7 @@ Options:
   --yes, -y              Skip yes/no confirmation prompts (still asks for choices)
   --ci                   CI mode: skip all prompts, auto-accept everything
   --version <value>      Version bump type (patch|minor|major) or explicit version (required with --ci)
+  --verbose              Show debug logging
   -h, --help             Show this help message
 
 Examples:
@@ -652,6 +855,7 @@ function parseArgs(args) {
     skipConfirms: false,
     ci: false,
     version: "",
+    verbose: false,
     help: false
   };
   for (let i = 0;i < args.length; i++) {
@@ -679,6 +883,9 @@ function parseArgs(args) {
       case "--version":
         options.version = args[++i] || "";
         break;
+      case "--verbose":
+        options.verbose = true;
+        break;
       case "-h":
       case "--help":
         options.help = true;
@@ -693,6 +900,7 @@ async function main() {
     process.exit(0);
   }
   const options = parseArgs(process.argv.slice(2));
+  setVerbose(options.verbose);
   if (options.help) {
     printUsage();
     process.exit(0);
@@ -861,7 +1069,9 @@ async function main() {
       console.log("");
       console.log(yellow("Not logged in to npm.") + " Starting login...");
       console.log("");
+      pausePrompt();
       const loginResult = await npmLogin(registry);
+      resetPrompt();
       if (!loginResult.success) {
         console.error(red(bold("Login failed:")) + ` ${loginResult.error}`);
         closePrompt();
@@ -915,47 +1125,68 @@ async function main() {
   console.log("");
   if (options.dryRun) {
     console.log(yellow("[DRY RUN]") + ` Would publish the following packages to ${cyan(registry)}:`);
-    console.log("");
-    for (const pkg of packages) {
-      console.log(`  ${dim("•")} ${cyan(pkg.name)}${dim("@")}${yellow(newVersion)}`);
-    }
-    console.log("");
-    console.log(muted("Run without --dry-run to actually publish."));
   } else {
     console.log("About to publish the following packages:");
-    console.log("");
-    for (const pkg of packages) {
-      console.log(`  ${dim("•")} ${cyan(pkg.name)}${dim("@")}${yellow(newVersion)}`);
-    }
-    console.log("");
-    console.log(`Registry: ${cyan(registry)}`);
-    console.log("");
-    if (!skipConfirms) {
-      const shouldContinue = await confirm("Continue?");
-      if (!shouldContinue) {
-        console.log(yellow("Publish cancelled."));
-        closePrompt();
-        process.exit(0);
-      }
+  }
+  console.log("");
+  for (const pkg of packages) {
+    console.log(`  ${dim("•")} ${cyan(pkg.name)}${dim("@")}${yellow(newVersion)}`);
+  }
+  console.log("");
+  console.log(`Registry: ${cyan(registry)}`);
+  console.log("");
+  if (!options.dryRun && !skipConfirms) {
+    const shouldContinue = await confirm("Continue?");
+    if (!shouldContinue) {
+      console.log(yellow("Publish cancelled."));
+      closePrompt();
+      process.exit(0);
     }
     console.log("");
-    console.log(cyan("Publishing packages..."));
+  }
+  console.log(cyan("Preparing packages for publish..."));
+  console.log("");
+  const workspaceTransforms = await transformWorkspaceProtocolForPublish(packages, newVersion, options.dryRun);
+  if (workspaceTransforms.length > 0 || options.dryRun) {
     console.log("");
-    const publishContext = {
-      otp: options.otp,
-      useBrowserAuth: !options.ci,
-      onInteractiveComplete: resetPrompt
-    };
+  }
+  console.log(cyan("Publishing packages..."));
+  console.log("");
+  const publishContext = {
+    otp: options.otp,
+    useBrowserAuth: !options.ci,
+    onInteractiveStart: pausePrompt,
+    onInteractiveComplete: resetPrompt
+  };
+  let publishFailed = false;
+  let failedPackageName = "";
+  let failedError = "";
+  try {
     for (const pkg of packages) {
       const result = await publishPackage(pkg, registry, publishContext, options.dryRun);
       if (!result.success) {
-        console.error(red(bold("Failed to publish")) + ` ${cyan(pkg.name)}: ${result.error}`);
-        console.log("");
-        console.log(red("Stopping publish process."));
-        closePrompt();
-        process.exit(1);
+        publishFailed = true;
+        failedPackageName = pkg.name;
+        failedError = result.error ?? "Unknown error";
+        break;
       }
     }
+  } finally {
+    if (workspaceTransforms.length > 0) {
+      console.log("");
+      await restoreWorkspaceProtocol(workspaceTransforms);
+    }
+  }
+  if (publishFailed) {
+    console.error(red(bold("Failed to publish")) + ` ${cyan(failedPackageName)}: ${failedError}`);
+    console.log("");
+    console.log(red("Stopping publish process."));
+    closePrompt();
+    process.exit(1);
+  }
+  if (options.dryRun) {
+    console.log("");
+    console.log(muted("Run without --dry-run to actually publish."));
   }
   console.log("");
   console.log(dim("═".repeat(30)));
@@ -963,27 +1194,52 @@ async function main() {
   console.log("");
   console.log(`Published version: ${green(bold(newVersion))}`);
   console.log("");
+  const changelog = await generateChangelog(cwd);
+  if (changelog.terminal) {
+    console.log(bold("Changes since ") + cyan(changelog.previousTag ?? "initial") + bold(":"));
+    console.log(changelog.terminal);
+    console.log("");
+  }
   if (!options.dryRun) {
     if (options.ci) {
-      console.log("");
       console.log(cyan("Creating git tag..."));
       const tagResult = await createGitTag(newVersion, cwd, options.dryRun);
       if (tagResult.success) {
         console.log(cyan("Pushing tag to origin..."));
         await pushGitTag(newVersion, cwd, options.dryRun);
+        if (changelog.markdown) {
+          console.log(cyan("Creating GitHub release..."));
+          const releaseResult = await createGitHubRelease(newVersion, changelog.markdown, cwd, options.dryRun);
+          if (releaseResult.success && releaseResult.url) {
+            console.log(`  Release created: ${cyan(releaseResult.url)}`);
+          } else if (!releaseResult.success) {
+            console.error(yellow(releaseResult.error ?? "Failed to create GitHub release"));
+          }
+        }
       } else {
         console.error(red(tagResult.error ?? "Failed to create git tag"));
       }
       console.log("");
-    } else if (!skipConfirms) {
-      const shouldTag = await confirm(`Create a git tag for ${cyan(`v${newVersion}`)}?`);
+    } else {
+      const shouldTag = skipConfirms || await confirm(`Create a git tag for ${cyan(`v${newVersion}`)}?`);
       if (shouldTag) {
         console.log("");
         const tagResult = await createGitTag(newVersion, cwd, options.dryRun);
         if (tagResult.success) {
-          const shouldPush = await confirm("Push tag to origin?");
+          const shouldPush = skipConfirms || await confirm("Push tag to origin?");
           if (shouldPush) {
             await pushGitTag(newVersion, cwd, options.dryRun);
+            if (changelog.markdown) {
+              const shouldRelease = skipConfirms || await confirm("Create a GitHub release?");
+              if (shouldRelease) {
+                const releaseResult = await createGitHubRelease(newVersion, changelog.markdown, cwd, options.dryRun);
+                if (releaseResult.success && releaseResult.url) {
+                  console.log(`  Release created: ${cyan(releaseResult.url)}`);
+                } else if (!releaseResult.success) {
+                  console.error(yellow(releaseResult.error ?? "Failed to create GitHub release"));
+                }
+              }
+            }
           } else {
             console.log(`Tag created locally. Push manually with: ${dim(`git push origin v${newVersion}`)}`);
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pubz",
-  "version": "0.2.12",
+  "version": "0.4.0",
   "description": "Interactive CLI for publishing npm packages (single or monorepo)",
   "type": "module",
   "bin": {