libretto 0.5.1 → 0.5.3-experimental.0

package/src/cli/workers/run-integration-runtime.ts

@@ -5,8 +5,11 @@ import { cwd } from "node:process";
 import { isAbsolute, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import {
+  getWorkflowFromModuleExports,
+  getWorkflowsFromModuleExports,
   instrumentContext,
   launchBrowser,
+  type ExportedLibrettoWorkflow,
   type LibrettoWorkflowContext,
 } from "../../index.js";
 import type { LoggerApi } from "../../shared/logger/index.js";
@@ -25,9 +28,7 @@ import {
 import { installSessionTelemetry } from "../core/session-telemetry.js";
 import type { RunIntegrationWorkerRequest } from "./run-integration-worker-protocol.js";
 
-const LIBRETTO_WORKFLOW_BRAND = Symbol.for("libretto.workflow");
-
-type LoadedLibrettoWorkflow = {
+type LoadedLibrettoWorkflow = ExportedLibrettoWorkflow & {
   run: (ctx: LibrettoWorkflowContext, input: unknown) => Promise<unknown>;
 };
 
@@ -108,17 +109,6 @@ async function waitForFailureSessionRelease(args: {
   }
 }
 
-function isLoadedLibrettoWorkflow(
-  value: unknown,
-): value is LoadedLibrettoWorkflow {
-  if (!value || typeof value !== "object") return false;
-  const candidate = value as Record<PropertyKey, unknown>;
-  return (
-    candidate[LIBRETTO_WORKFLOW_BRAND] === true &&
-    typeof candidate.run === "function"
-  );
-}
-
 function resolveLocalAuthProfilePath(domain: string): string {
   return getProfilePath(normalizeDomain(domain));
 }
@@ -149,9 +139,9 @@ function getAbsoluteIntegrationPath(integrationPath: string): string {
   return absolutePath;
 }
 
-async function loadWorkflowExport(
+async function loadWorkflowByName(
   absolutePath: string,
-  exportName: string,
+  workflowName: string,
 ): Promise<LoadedLibrettoWorkflow> {
   let loadedModule: Record<string, unknown>;
   try {
@@ -167,42 +157,23 @@ async function loadWorkflowExport(
     );
   }
 
-  const targetExport = loadedModule[exportName];
-  if (!targetExport) {
-    const availableExports = Object.keys(loadedModule);
-    const detail =
-      availableExports.length > 0
-        ? ` Available exports: ${availableExports.join(", ")}`
-        : " The module has no exports.";
-    throw new Error(
-      `Export "${exportName}" was not found in ${absolutePath}.${detail}`,
-    );
+  const workflow = getWorkflowFromModuleExports(loadedModule, workflowName);
+  if (workflow) {
+    return workflow as LoadedLibrettoWorkflow;
   }
 
-  if (!isLoadedLibrettoWorkflow(targetExport)) {
-    throw new Error(
-      [
-        `Export "${exportName}" in ${absolutePath} is not a valid Libretto workflow.`,
-        "",
-        'A workflow must be created using the workflow() function from "libretto":',
-        "",
-        '  import { workflow } from "libretto";',
-        "",
-        `  export const ${exportName} = workflow<InputType, OutputType>(`,
-        "    async (ctx, input) => {",
-        "      // ctx.session  — libretto session name",
-        "      // ctx.page     — Playwright Page instance",
-        "      // ctx.logger   — MinimalLogger",
-        "      // ctx.services — injected dependencies (generic, default {})",
-        "      // input        — JSON-serializable input matching InputType",
-        "      return output; // must match OutputType",
-        "    },",
-        "  );",
-      ].join("\n"),
-    );
-  }
+  const availableWorkflows = getWorkflowsFromModuleExports(loadedModule).map(
+    (candidate) => candidate.name,
+  );
+
+  const detail =
+    availableWorkflows.length > 0
+      ? ` Available workflows: ${availableWorkflows.join(", ")}`
+      : ' No workflows found in this file. Export a workflow() instance from "libretto" directly or via `export const workflows = { ... }`.';
 
-  return targetExport;
+  throw new Error(
+    `Workflow "${workflowName}" not found in ${absolutePath}.${detail}`,
+  );
 }
 
 export async function installHeadedWorkflowVisualization(args: {
@@ -224,7 +195,7 @@ async function runIntegrationInternal(
 ): Promise<RunIntegrationOutcome> {
   const { logger } = options;
   const absolutePath = getAbsoluteIntegrationPath(args.integrationPath);
-  const workflow = await loadWorkflowExport(absolutePath, args.exportName);
+  const workflow = await loadWorkflowByName(absolutePath, args.workflowName);
   const signalPaths = getPauseSignalPaths(args.session);
   await removeSignalIfExists(signalPaths.pausedSignalPath);
   await removeSignalIfExists(signalPaths.resumeSignalPath);
@@ -233,12 +204,12 @@ async function runIntegrationInternal(
   const restoreStdout = mirrorStdoutToFile(signalPaths.outputSignalPath);
 
   console.log(
-    `Running integration "${args.exportName}" from ${absolutePath} (${args.headless ? "headless" : "headed"})...`,
+    `Running workflow "${args.workflowName}" from ${absolutePath} (${args.headless ? "headless" : "headed"})...`,
   );
 
   const integrationLogger = logger.withScope("integration-run", {
     integrationPath: absolutePath,
-    integrationExport: args.exportName,
+    workflowName: args.workflowName,
     session: args.session,
   });
 
@@ -287,6 +258,7 @@ async function runIntegrationInternal(
     logger: integrationLogger,
     page: browserSession.page,
     services: {},
+    credentials: args.credentials,
   };
 
   try {

package/src/cli/workers/run-integration-worker-protocol.ts

@@ -2,9 +2,10 @@ import { z } from "zod";
 
 export const RunIntegrationWorkerRequestSchema = z.object({
   integrationPath: z.string().min(1),
-  exportName: z.string().min(1),
+  workflowName: z.string().min(1),
   session: z.string().min(1),
   params: z.unknown(),
+  credentials: z.record(z.string(), z.unknown()).optional(),
   headless: z.boolean(),
   visualize: z.boolean().default(true),
   authProfileDomain: z.string().optional(),

package/src/index.ts

@@ -102,9 +102,13 @@ export {
 
 // Workflow helpers
 export {
+  getWorkflowFromModuleExports,
+  getWorkflowsFromModuleExports,
+  isLibrettoWorkflow,
   LibrettoWorkflow,
   LIBRETTO_WORKFLOW_BRAND,
   workflow,
+  type ExportedLibrettoWorkflow,
   type LibrettoWorkflowContext,
   type LibrettoWorkflowHandler,
 } from "./shared/workflow/workflow.js";

package/src/shared/condense-dom/condense-dom.ts

@@ -20,6 +20,14 @@
  *  12.  Whitespace — collapse (preserve <pre> content)
  */
 
+import {
+  filterSemanticClasses,
+  INTERACTIVE_ROLE_NAMES,
+  INTERACTIVE_TAG_NAMES,
+  TEST_ATTRIBUTE_NAMES,
+  TRUSTED_ATTRIBUTE_NAMES,
+} from "../dom-semantics.js";
+
 export type CondenseDomResult = {
   /** The condensed HTML string. Valid, parseable HTML. */
   html: string;
@@ -37,25 +45,8 @@ type ParsedAttribute = {
   value: string | null;
 };
 
-const TEST_ATTRS = new Set(["data-testid", "data-test", "data-qa", "data-cy"]);
-const TRUSTED_ATTRS = new Set([
-  "id",
-  "name",
-  "for",
-  "tabindex",
-  "contenteditable",
-  "role",
-  "title",
-  "alt",
-  "type",
-  "value",
-  "placeholder",
-  "autocomplete",
-  "href",
-  "action",
-  "method",
-  "src",
-]);
+const TEST_ATTRS: Set<string> = new Set(TEST_ATTRIBUTE_NAMES);
+const TRUSTED_ATTRS: Set<string> = new Set(TRUSTED_ATTRIBUTE_NAMES);
 const STATE_ATTRS = new Set([
   "disabled",
   "hidden",
@@ -94,28 +85,8 @@ const SCRIPT_ATTRS = new Set([
   "referrerpolicy",
 ]);
 const STYLE_TAG_ATTRS = new Set(["media", "type", "nonce", "title"]);
-const INTERACTIVE_TAGS = new Set([
-  "a",
-  "button",
-  "input",
-  "select",
-  "textarea",
-  "form",
-  "details",
-  "dialog",
-  "label",
-]);
-const INTERACTIVE_ROLES = new Set([
-  "button",
-  "link",
-  "tab",
-  "menuitem",
-  "checkbox",
-  "radio",
-  "switch",
-  "slider",
-  "combobox",
-]);
+const INTERACTIVE_TAGS: Set<string> = new Set(INTERACTIVE_TAG_NAMES);
+const INTERACTIVE_ROLES: Set<string> = new Set(INTERACTIVE_ROLE_NAMES);
 const OPEN_TAG_PATTERN =
   /<([a-zA-Z][\w:-]*)(\s(?:[^"'<>/]|"[^"]*"|'[^']*')*)?\s*(\/?)>/g;
 
@@ -458,29 +429,6 @@ function normalizeUrlValue(value: string): string {
   }
 }
 
-function filterSemanticClasses(value: string): string {
-  const classes = value.split(/\s+/).filter(Boolean);
-  const kept = classes.filter((cls) => !isObfuscatedClass(cls));
-  return kept.join(" ");
-}
-
-/**
- * Heuristic: a class name is "obfuscated" if it looks like a hash or random ID
- * rather than a human-readable semantic name.
- */
-function isObfuscatedClass(cls: string): boolean {
-  if (cls.length > 80) return true;
-  if (/^_?[0-9a-f]{6,}$/i.test(cls)) return true;
-  if (/^[a-z]+_[0-9a-f]{4,}$/i.test(cls)) return true;
-  if (/^[a-z]{1,2}[0-9]{2,}$/i.test(cls)) return true;
-
-  const digits = (cls.match(/[0-9]/g) || []).length;
-  const letters = (cls.match(/[a-zA-Z]/g) || []).length;
-  if (cls.length >= 6 && digits >= letters * 0.5 && digits >= 2) return true;
-
-  return false;
-}
-
 function parseAttributes(rawAttrs: string): ParsedAttribute[] {
   const attrs: ParsedAttribute[] = [];
   const attrPattern =

package/src/shared/dom-semantics.ts

@@ -0,0 +1,68 @@
+export const TEST_ATTRIBUTE_NAMES = [
+  "data-testid",
+  "data-test",
+  "data-qa",
+  "data-cy",
+] as const;
+
+export const TRUSTED_ATTRIBUTE_NAMES = [
+  "id",
+  "name",
+  "for",
+  "tabindex",
+  "contenteditable",
+  "role",
+  "title",
+  "alt",
+  "type",
+  "value",
+  "placeholder",
+  "autocomplete",
+  "href",
+  "action",
+  "method",
+  "src",
+] as const;
+
+export const INTERACTIVE_TAG_NAMES = [
+  "a",
+  "button",
+  "input",
+  "select",
+  "textarea",
+  "form",
+  "details",
+  "dialog",
+  "label",
+] as const;
+
+export const INTERACTIVE_ROLE_NAMES = [
+  "button",
+  "link",
+  "tab",
+  "menuitem",
+  "checkbox",
+  "radio",
+  "switch",
+  "slider",
+  "combobox",
+] as const;
+
+export function filterSemanticClasses(value: string): string {
+  const classes = value.split(/\s+/).filter(Boolean);
+  const kept = classes.filter((cls) => !isObfuscatedClass(cls));
+  return kept.join(" ");
+}
+
+export function isObfuscatedClass(cls: string): boolean {
+  if (cls.length > 80) return true;
+  if (/^_?[0-9a-f]{6,}$/i.test(cls)) return true;
+  if (/^[a-z]+_[0-9a-f]{4,}$/i.test(cls)) return true;
+  if (/^[a-z]{1,2}[0-9]{2,}$/i.test(cls)) return true;
+
+  const digits = (cls.match(/[0-9]/g) || []).length;
+  const letters = (cls.match(/[a-zA-Z]/g) || []).length;
+  if (cls.length >= 6 && digits >= letters * 0.5 && digits >= 2) return true;
+
+  return false;
+}

package/src/shared/run/browser.ts

@@ -11,6 +11,7 @@ import {
   SESSION_STATE_VERSION,
   SessionStateFileSchema,
 } from "../state/session-state.js";
+import { readLibrettoConfig } from "../../cli/core/ai-config.js";
 
 async function pickFreePort(): Promise<number> {
   return await new Promise((resolve, reject) => {
@@ -44,6 +45,53 @@ export type BrowserSession = {
   close: () => Promise<void>;
 };
 
+function resolveWindowPosition(): { x: number; y: number } | undefined {
+  return readLibrettoConfig().windowPosition;
+}
+
+async function applyWindowPosition(
+  browser: Browser,
+  context: BrowserContext,
+  page: Page,
+  windowPosition: { x: number; y: number } | undefined,
+): Promise<void> {
+  if (!windowPosition) {
+    return;
+  }
+
+  const requestedBounds = {
+    left: windowPosition.x,
+    top: windowPosition.y,
+    windowState: "normal" as const,
+  };
+
+  const pageCdp = await context.newCDPSession(page);
+  let browserCdp:
+    | Awaited<ReturnType<Browser["newBrowserCDPSession"]>>
+    | undefined;
+  try {
+    const targetInfo = await pageCdp.send("Target.getTargetInfo");
+    const targetId = (
+      targetInfo as { targetInfo?: { targetId?: string } }
+    ).targetInfo?.targetId;
+    browserCdp = await browser.newBrowserCDPSession();
+    const windowResult = await browserCdp.send(
+      "Browser.getWindowForTarget",
+      targetId ? { targetId } : {},
+    );
+    await browserCdp.send("Browser.setWindowBounds", {
+      windowId: windowResult.windowId,
+      bounds: requestedBounds,
+    });
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  } catch {
+    // Best-effort: window positioning should not prevent browser launch.
+  } finally {
+    await pageCdp.detach().catch(() => {});
+    await browserCdp?.detach().catch(() => {});
+  }
+}
+
 export async function launchBrowser({
   sessionName,
   headless = false,
@@ -51,12 +99,16 @@ export async function launchBrowser({
   storageStatePath,
 }: LaunchBrowserArgs): Promise<BrowserSession> {
   const debugPort = await pickFreePort();
+  const windowPosition = headless ? undefined : resolveWindowPosition();
   const browser = await chromium.launch({
     headless,
     args: [
       "--disable-blink-features=AutomationControlled",
       `--remote-debugging-port=${debugPort}`,
       "--no-focus-on-check",
+      ...(windowPosition
+        ? [`--window-position=${windowPosition.x},${windowPosition.y}`]
+        : []),
     ],
   });
 
@@ -65,6 +117,7 @@ export async function launchBrowser({
     ...(storageStatePath ? { storageState: storageStatePath } : {}),
   });
   const page = await context.newPage();
+  await applyWindowPosition(browser, context, page, windowPosition);
   page.setDefaultTimeout(30_000);
   page.setDefaultNavigationTimeout(45_000);
 

package/src/shared/visualization/ghost-cursor.ts

@@ -16,7 +16,7 @@ export type GhostCursorOptions = {
 const DEFAULTS: Required<GhostCursorOptions> = {
   style: "minimal",
   color: "rgba(255, 70, 70, 0.9)",
-  size: 20,
+  size: 23,
   zIndex: 2147483646,
   easing: "cubic-bezier(0.16, 1, 0.3, 1)",
   minDurationMs: 100,
@@ -38,20 +38,38 @@ function buildCursorSvg(
     return `<div style="width:${size * 1.4}px;height:${size * 1.4}px;border-radius:50%;background:${color};box-shadow:0 0 ${size * 0.6}px ${color};opacity:0.7;"></div>`;
   }
   // minimal: default arrow-like SVG cursor
-  return `<svg width="${size}" height="${size}" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+  return `<svg width="${size}" height="${size}" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg" style="display:block;filter:drop-shadow(0 2px 6px rgba(15,23,42,0.22));">
 		<path d="M5 3L19 12L12 13L9 20L5 3Z" fill="${color}" stroke="rgba(0,0,0,0.3)" stroke-width="1"/>
 	</svg>`;
 }
 
+function buildCursorMarkup(
+  style: GhostCursorStyle,
+  color: string,
+  size: number,
+): string {
+  const cursor = buildCursorSvg(style, color, size);
+  const badgeHeight = Math.max(12, Math.round(size * 0.54));
+  const fontSize = Math.max(8, Math.round(size * 0.28));
+  const minWidth = Math.max(28, Math.round(size * 1.28));
+  const paddingX = Math.max(5, Math.round(size * 0.2));
+  const left = Math.round(size * 0.84);
+  const top = Math.round(size * 0.74);
+  const width = Math.round(size * 2.4);
+  const height = Math.round(size * 1.95);
+  const badge = `<div aria-hidden="true" style="position:absolute;left:${left}px;top:${top}px;display:flex;align-items:center;justify-content:center;min-width:${minWidth}px;height:${badgeHeight}px;padding:0 ${paddingX}px;border-radius:${badgeHeight}px;background:${color};color:rgba(255,255,255,0.96);font:700 ${fontSize}px/1 ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif;letter-spacing:0.02em;white-space:nowrap;border:1px solid rgba(0,0,0,0.16);box-shadow:0 4px 12px rgba(0,0,0,0.14);transform-origin:left center;">Agent</div>`;
+  return `<div style="position:relative;width:${width}px;height:${height}px;overflow:visible;">${cursor}${badge}</div>`;
+}
+
 function buildInitScript(opts: Required<GhostCursorOptions>): string {
-  const svg = buildCursorSvg(opts.style, opts.color, opts.size);
+  const markup = buildCursorMarkup(opts.style, opts.color, opts.size);
   return `
 (function() {
 	if (document.getElementById("${CURSOR_ID}")) return;
 	var el = document.createElement("div");
 	el.id = "${CURSOR_ID}";
 	el.style.cssText = "position:fixed;top:0;left:0;z-index:${opts.zIndex};pointer-events:none;transform:translate3d(-100px,-100px,0);transition:none;will-change:transform,opacity;opacity:0;";
-	el.innerHTML = ${JSON.stringify(svg)};
+	el.innerHTML = ${JSON.stringify(markup)};
 	document.documentElement.appendChild(el);
 })();
 `;

package/src/shared/workflow/workflow.ts

@@ -8,6 +8,7 @@ export type LibrettoWorkflowContext<S = {}> = {
   page: Page;
   logger: MinimalLogger;
   services: S;
+  credentials?: Record<string, unknown>;
 };
 
 export type LibrettoWorkflowHandler<
@@ -18,9 +19,14 @@ export type LibrettoWorkflowHandler<
 
 export class LibrettoWorkflow<Input = unknown, Output = unknown, S = {}> {
   public readonly [LIBRETTO_WORKFLOW_BRAND] = true;
+  public readonly name: string;
   private readonly handler: LibrettoWorkflowHandler<Input, Output, S>;
 
-  constructor(handler: LibrettoWorkflowHandler<Input, Output, S>) {
+  constructor(
+    name: string,
+    handler: LibrettoWorkflowHandler<Input, Output, S>,
+  ) {
+    this.name = name;
     this.handler = handler;
   }
 
@@ -29,8 +35,88 @@ export class LibrettoWorkflow<Input = unknown, Output = unknown, S = {}> {
   }
 }
 
+export type ExportedLibrettoWorkflow = {
+  readonly [LIBRETTO_WORKFLOW_BRAND]: true;
+  readonly name: string;
+  run: (ctx: LibrettoWorkflowContext, input: unknown) => Promise<unknown>;
+};
+
+type WorkflowModuleExports = Record<string, unknown>;
+
+// Use the workflow brand instead of `instanceof` so imported workflows are
+// still recognized after loading the integration module dynamically.
+export function isLibrettoWorkflow(
+  value: unknown,
+): value is ExportedLibrettoWorkflow {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value as Record<PropertyKey, unknown>;
+  return (
+    candidate[LIBRETTO_WORKFLOW_BRAND] === true &&
+    typeof candidate.name === "string" &&
+    typeof candidate.run === "function"
+  );
+}
+
+function addWorkflowOrThrow(
+  workflowsByName: Map<string, ExportedLibrettoWorkflow>,
+  value: unknown,
+): void {
+  if (!isLibrettoWorkflow(value)) return;
+
+  // Re-exporting the same workflow object is fine, but two distinct workflow
+  // instances cannot claim the same runtime name.
+  const existing = workflowsByName.get(value.name);
+  if (existing && existing !== value) {
+    throw new Error(
+      `Duplicate workflow name: "${value.name}". Each workflow() call must use a unique name.`,
+    );
+  }
+
+  workflowsByName.set(value.name, value);
+}
+
+export function getWorkflowsFromModuleExports(
+  moduleExports: WorkflowModuleExports,
+): ExportedLibrettoWorkflow[] {
+  const workflowsByName = new Map<string, ExportedLibrettoWorkflow>();
+
+  for (const [exportName, value] of Object.entries(moduleExports)) {
+    if (exportName === "workflows" && value && typeof value === "object") {
+      // Support both `export const workflows = workflow(...)` and
+      // `export const workflows = { myWorkflow }`.
+      if (isLibrettoWorkflow(value)) {
+        addWorkflowOrThrow(workflowsByName, value);
+      } else {
+        for (const nestedValue of Object.values(
+          value as Record<string, unknown>,
+        )) {
+          addWorkflowOrThrow(workflowsByName, nestedValue);
+        }
+      }
+      continue;
+    }
+
+    addWorkflowOrThrow(workflowsByName, value);
+  }
+
+  return [...workflowsByName.values()];
+}
+
+export function getWorkflowFromModuleExports(
+  moduleExports: WorkflowModuleExports,
+  workflowName: string,
+): ExportedLibrettoWorkflow | null {
+  for (const workflow of getWorkflowsFromModuleExports(moduleExports)) {
+    if (workflow.name === workflowName) {
+      return workflow;
+    }
+  }
+  return null;
+}
+
 export function workflow<Input = unknown, Output = unknown, S = {}>(
+  name: string,
   handler: LibrettoWorkflowHandler<Input, Output, S>,
 ): LibrettoWorkflow<Input, Output, S> {
-  return new LibrettoWorkflow(handler);
+  return new LibrettoWorkflow(name, handler);
 }

package/scripts/prepare-release.sh

@@ -1,97 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-usage() {
-  cat <<'EOF'
-Usage: scripts/prepare-release.sh [patch|minor|major]
-
-Creates a release PR branch from main, bumps package.json, pushes the branch,
-and opens a pull request targeting main.
-EOF
-}
-
-bump="${1:-patch}"
-
-case "$bump" in
-  patch|minor|major)
-    ;;
-  -h|--help|help)
-    usage
-    exit 0
-    ;;
-  *)
-    echo "Invalid bump type: $bump" >&2
-    usage >&2
-    exit 1
-    ;;
-esac
-
-if ! command -v gh >/dev/null 2>&1; then
-  echo "gh CLI is required." >&2
-  exit 1
-fi
-
-if [ -n "$(git status --porcelain)" ]; then
-  echo "Working tree must be clean before preparing a release." >&2
-  exit 1
-fi
-
-current_branch="$(git branch --show-current)"
-if [ "$current_branch" != "main" ]; then
-  echo "Switching from $current_branch to main."
-fi
-
-git fetch origin
-git checkout main
-git pull --ff-only origin main
-
-pnpm install --frozen-lockfile
-pnpm type-check
-pnpm test
-
-current_version="$(node -p "require('./package.json').version")"
-next_version="$(node -e '
-const [major, minor, patch] = process.argv[1].split(".").map(Number)
-const bump = process.argv[2]
-
-let next
-if (bump === "major") next = [major + 1, 0, 0]
-else if (bump === "minor") next = [major, minor + 1, 0]
-else next = [major, minor, patch + 1]
-
-process.stdout.write(next.join("."))
-' "$current_version" "$bump")"
-branch_name="tk-release-v${next_version}"
-
-if git show-ref --verify --quiet "refs/heads/${branch_name}"; then
-  echo "Local branch ${branch_name} already exists." >&2
-  exit 1
-fi
-
-if git ls-remote --exit-code --heads origin "${branch_name}" >/dev/null 2>&1; then
-  echo "Remote branch ${branch_name} already exists." >&2
-  exit 1
-fi
-
-npm version "$next_version" --no-git-tag-version >/dev/null
-
-git checkout -b "$branch_name"
-git add package.json
-git commit -m "release: v${next_version}"
-git push -u origin "$branch_name"
-
-gh pr create \
-  --base main \
-  --head "$branch_name" \
-  --title "release: v${next_version}" \
-  --body "$(cat <<EOF
-## Summary
-
-- release libretto v${next_version}
-
-## Verification
-
-- pnpm type-check
-- pnpm test
-EOF
-)"