libretto 0.5.4 → 0.5.5

package/dist/cli/core/browser.js

@@ -47,19 +47,44 @@ async function pickFreePort() {
     server.on("error", reject);
   });
 }
+function tryParseAbsoluteUrl(url) {
+  try {
+    return new URL(url);
+  } catch {
+    return null;
+  }
+}
+function isLikelyHostWithPort(parsedUrl, rawUrl) {
+  const remainder = rawUrl.slice(parsedUrl.protocol.length);
+  if (remainder.length === 0) return false;
+  let index = 0;
+  while (index < remainder.length) {
+    const charCode = remainder.charCodeAt(index);
+    if (charCode < 48 || charCode > 57) break;
+    index += 1;
+  }
+  if (index === 0) return false;
+  if (index === remainder.length) return true;
+  const nextChar = remainder[index];
+  return nextChar === "/" || nextChar === "?" || nextChar === "#";
+}
 function normalizeUrl(url) {
-  if (!/^https?:\/\//i.test(url)) {
-    return `https://${url}`;
+  const parsedUrl = tryParseAbsoluteUrl(url);
+  if (!parsedUrl) {
+    return new URL(`https://${url}`);
   }
-  return url;
+  if (parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:" || parsedUrl.protocol === "file:") {
+    return parsedUrl;
+  }
+  if (isLikelyHostWithPort(parsedUrl, url)) {
+    return new URL(`https://${url}`);
+  }
+  throw new Error(
+    `Unsupported URL protocol: ${parsedUrl.protocol}. Use http://, https://, or file://.`
+  );
 }
 function normalizeDomain(url) {
-  try {
-    const u = new URL(normalizeUrl(url));
-    return u.hostname.replace(/^www\./, "");
-  } catch {
-    return url.replace(/^www\./, "");
-  }
+  return url.hostname.replace(/^www\./, "");
 }
 function getProfilePath(domain) {
   return join(PROFILES_DIR, `${domain}.json`);
@@ -265,7 +290,8 @@ function resolveWindowPosition(logger) {
   return void 0;
 }
 async function runOpen(rawUrl, headed, session, logger, options) {
-  const url = normalizeUrl(rawUrl);
+  const parsedUrl = normalizeUrl(rawUrl);
+  const url = parsedUrl.href;
   const viewport = resolveViewport(options?.viewport, logger);
   const windowPosition = headed ? resolveWindowPosition(logger) : void 0;
   logger.info("open-start", { url, headed, session, viewport, windowPosition });
@@ -275,9 +301,10 @@ async function runOpen(rawUrl, headed, session, logger, options) {
   const networkLogPath = getSessionNetworkLogPath(session);
   const actionsLogPath = getSessionActionsLogPath(session);
   const browserMode = headed ? "headed" : "headless";
-  const domain = normalizeDomain(url);
-  const profilePath = getProfilePath(domain);
-  const useProfile = hasProfile(domain);
+  const supportsSavedProfile = parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:";
+  const domain = supportsSavedProfile ? normalizeDomain(parsedUrl) : void 0;
+  const profilePath = domain ? getProfilePath(domain) : void 0;
+  const useProfile = domain ? hasProfile(domain) : false;
   logger.info("open-launching", {
     url,
     mode: browserMode,
@@ -291,9 +318,8 @@ async function runOpen(rawUrl, headed, session, logger, options) {
     console.log(`Loading saved profile for ${domain}`);
   }
   console.log(`Launching ${browserMode} browser (session: ${session})...`);
-  const escapedProfilePath = profilePath.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
   const escapedUrl = url.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-  const storageStateCode = useProfile ? `storageState: '${escapedProfilePath}',` : "";
+  const storageStateCode = useProfile ? `storageState: '${profilePath.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}',` : "";
   const escapedLogPath = runLogPath.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
   const escapedNetworkLogPath = networkLogPath.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
   const escapedActionsLogPath = actionsLogPath.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
@@ -528,7 +554,7 @@ async function runSave(urlOrDomain, session, logger) {
   const { browser, context, page } = await connect(session, logger);
   try {
     await new Promise((r) => setTimeout(r, 500));
-    const domain = normalizeDomain(urlOrDomain);
+    const domain = normalizeDomain(normalizeUrl(urlOrDomain));
     const profilePath = getProfilePath(domain);
     const cdpSession = await context.newCDPSession(page);
     const { cookies: rawCookies } = await cdpSession.send(

package/dist/cli/workers/run-integration-runtime.js

@@ -10,7 +10,11 @@ import {
   launchBrowser
 } from "../../index.js";
 import { parseSessionStateContent } from "../../shared/state/index.js";
-import { getProfilePath, normalizeDomain } from "../core/browser.js";
+import {
+  getProfilePath,
+  normalizeDomain,
+  normalizeUrl
+} from "../core/browser.js";
 import {
   getSessionActionsLogPath,
   getSessionNetworkLogPath,
@@ -68,18 +72,14 @@ async function waitForFailureSessionRelease(args) {
     );
   }
 }
-function resolveLocalAuthProfilePath(domain) {
-  return getProfilePath(normalizeDomain(domain));
-}
 function getMissingLocalAuthProfileError(args) {
-  const normalizedDomain = normalizeDomain(args.domain);
   return [
-    `Local auth profile not found for domain "${normalizedDomain}".`,
+    `Local auth profile not found for domain "${args.normalizedDomain}".`,
     `Expected profile file: ${args.profilePath}`,
     "To create it:",
-    `  1. libretto open https://${normalizedDomain} --headed --session ${args.session}`,
+    `  1. libretto open https://${args.normalizedDomain} --headed --session ${args.session}`,
     "  2. Log in manually in the browser window.",
-    `  3. libretto save ${normalizedDomain} --session ${args.session}`
+    `  3. libretto save ${args.normalizedDomain} --session ${args.session}`
   ].join("\n");
 }
 function getAbsoluteIntegrationPath(integrationPath) {
@@ -138,11 +138,12 @@ async function runIntegrationInternal(args, options) {
     session: args.session
   });
   const authProfileDomain = args.authProfileDomain;
-  const storageStatePath = authProfileDomain ? resolveLocalAuthProfilePath(authProfileDomain) : void 0;
-  if (authProfileDomain && storageStatePath && !existsSync(storageStatePath)) {
+  const normalizedAuthProfileDomain = authProfileDomain ? normalizeDomain(normalizeUrl(authProfileDomain)) : void 0;
+  const storageStatePath = normalizedAuthProfileDomain ? getProfilePath(normalizedAuthProfileDomain) : void 0;
+  if (normalizedAuthProfileDomain && storageStatePath && !existsSync(storageStatePath)) {
     throw new Error(
       getMissingLocalAuthProfileError({
-        domain: authProfileDomain,
+        normalizedDomain: normalizedAuthProfileDomain,
         profilePath: storageStatePath,
         session: args.session
       })
@@ -175,7 +176,6 @@ async function runIntegrationInternal(args, options) {
   });
   const workflowContext = {
     session: args.session,
-    logger: integrationLogger,
     page: browserSession.page
   };
   try {

package/dist/shared/workflow/workflow.d.ts

@@ -1,11 +1,9 @@
 import { Page } from 'playwright';
-import { MinimalLogger } from '../logger/logger.js';
 
 declare const LIBRETTO_WORKFLOW_BRAND: unique symbol;
 type LibrettoWorkflowContext = {
     session: string;
     page: Page;
-    logger: MinimalLogger;
 };
 type LibrettoWorkflowHandler<Input = unknown, Output = unknown> = (ctx: LibrettoWorkflowContext, input: Input) => Promise<Output>;
 declare class LibrettoWorkflow<Input = unknown, Output = unknown> {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libretto",
-  "version": "0.5.4",
+  "version": "0.5.5",
   "description": "AI-powered browser automation library and CLI built on Playwright",
   "license": "MIT",
   "repository": {
@@ -8,7 +8,6 @@
     "url": "https://github.com/saffron-health/libretto"
   },
   "type": "module",
-  "packageManager": "pnpm@9.15.4",
   "publishConfig": {
     "access": "public"
   },
@@ -29,20 +28,6 @@
       "default": "./dist/index.js"
     }
   },
-  "scripts": {
-    "postinstall": "node scripts/postinstall.mjs",
-    "sync:mirrors": "node ../dev-tools/scripts/sync-mirrors.mjs",
-    "check:mirrors": "node ../dev-tools/scripts/check-mirrors-sync.mjs",
-    "sync-skills": "pnpm run sync:mirrors",
-    "check:skills": "pnpm run check:mirrors",
-    "build": "tsup --config tsup.config.ts",
-    "type-check": "tsc --noEmit",
-    "test": "pnpm run build && vitest run",
-    "test:watch": "vitest",
-    "cli": "node dist/index.js",
-    "generate-changelog": "tsx scripts/generate-changelog.ts",
-    "prepack": "pnpm run build"
-  },
   "peerDependencies": {
     "@ai-sdk/anthropic": "^3.0.58",
     "@ai-sdk/google": "^3.0.51",
@@ -87,5 +72,18 @@
     "playwright": "^1.58.2",
     "tsx": "^4.21.0",
     "zod": "^4.3.6"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.mjs",
+    "sync:mirrors": "node ../dev-tools/scripts/sync-mirrors.mjs",
+    "check:mirrors": "node ../dev-tools/scripts/check-mirrors-sync.mjs",
+    "sync-skills": "pnpm run sync:mirrors",
+    "check:skills": "pnpm run check:mirrors",
+    "build": "tsup --config tsup.config.ts",
+    "type-check": "tsc --noEmit",
+    "test": "pnpm run build && vitest run",
+    "test:watch": "vitest",
+    "cli": "node dist/index.js",
+    "generate-changelog": "tsx scripts/generate-changelog.ts"
   }
-}
+}

package/skills/libretto/references/code-generation-rules.md

@@ -25,9 +25,9 @@ type Output = {
 export const myWorkflow = workflow<Input, Output>(
   "myWorkflow",
   async (ctx: LibrettoWorkflowContext, input): Promise<Output> => {
-    const { session, page, logger } = ctx;
+    const { session, page } = ctx;
 
-    logger.info("workflow-start", { session, query: input.query });
+    console.log("workflow-start", { session, query: input.query });
     await page.goto("https://example.com");
     await pause(session);
 
@@ -40,7 +40,7 @@ Key points:
 
 - `workflow(name, handler)` takes a unique workflow name and returns the workflow object that Libretto can run.
 - `npx libretto run ./file.ts myWorkflow` resolves `myWorkflow` from the workflows exported by `./file.ts`, so export or re-export the workflow from that file directly or through a `workflows` object, and make sure the run argument matches the name passed to `workflow("myWorkflow", ...)`.
-- `ctx` provides `session`, `page`, and `logger`
+- `ctx` provides `session` and `page`. Use `console.log`/`console.warn`/`console.error` for logging — the runtime wraps these with structured metadata automatically.
 - `input` comes from `--params '{"query":"foo"}'` or `--params-file params.json` on the CLI
 - Use `await pause(ctx.session)` (or `await pause(session)`) to pause the workflow for debugging. It is a no-op in production.
 - After validation is complete and the workflow is confirmed working end to end, remove all `pause()` calls and pause-only workflow params unless the user explicitly says to keep them.

package/src/cli/core/browser.ts

@@ -56,20 +56,61 @@ async function pickFreePort(): Promise<number> {
   });
 }
 
-export function normalizeUrl(url: string): string {
-  if (!/^https?:\/\//i.test(url)) {
-    return `https://${url}`;
+function tryParseAbsoluteUrl(url: string): URL | null {
+  try {
+    return new URL(url);
+  } catch {
+    return null;
   }
-  return url;
 }
 
-export function normalizeDomain(url: string): string {
-  try {
-    const u = new URL(normalizeUrl(url));
-    return u.hostname.replace(/^www\./, "");
-  } catch {
-    return url.replace(/^www\./, "");
+function isLikelyHostWithPort(parsedUrl: URL, rawUrl: string): boolean {
+  // `new URL("localhost:3000")` parses successfully, but treats `localhost:`
+  // as a custom scheme instead of a bare host with port. Detect that shape so
+  // CLI shorthand like `libretto open localhost:3000` still normalizes to
+  // `https://localhost:3000/`.
+  const remainder = rawUrl.slice(parsedUrl.protocol.length);
+  if (remainder.length === 0) return false;
+
+  let index = 0;
+  while (index < remainder.length) {
+    const charCode = remainder.charCodeAt(index);
+    if (charCode < 48 || charCode > 57) break;
+    index += 1;
   }
+
+  if (index === 0) return false;
+  if (index === remainder.length) return true;
+
+  const nextChar = remainder[index];
+  return nextChar === "/" || nextChar === "?" || nextChar === "#";
+}
+
+export function normalizeUrl(url: string): URL {
+  const parsedUrl = tryParseAbsoluteUrl(url);
+  if (!parsedUrl) {
+    return new URL(`https://${url}`);
+  }
+
+  if (
+    parsedUrl.protocol === "http:" ||
+    parsedUrl.protocol === "https:" ||
+    parsedUrl.protocol === "file:"
+  ) {
+    return parsedUrl;
+  }
+
+  if (isLikelyHostWithPort(parsedUrl, url)) {
+    return new URL(`https://${url}`);
+  }
+
+  throw new Error(
+    `Unsupported URL protocol: ${parsedUrl.protocol}. Use http://, https://, or file://.`,
+  );
+}
+
+export function normalizeDomain(url: URL): string {
+  return url.hostname.replace(/^www\./, "");
 }
 
 export function getProfilePath(domain: string): string {
@@ -359,7 +400,8 @@ export async function runOpen(
   logger: LoggerApi,
   options?: { viewport?: { width: number; height: number } },
 ): Promise<void> {
-  const url = normalizeUrl(rawUrl);
+  const parsedUrl = normalizeUrl(rawUrl);
+  const url = parsedUrl.href;
   const viewport = resolveViewport(options?.viewport, logger);
   const windowPosition = headed ? resolveWindowPosition(logger) : undefined;
   logger.info("open-start", { url, headed, session, viewport, windowPosition });
@@ -371,9 +413,11 @@ export async function runOpen(
   const actionsLogPath = getSessionActionsLogPath(session);
 
   const browserMode = headed ? "headed" : "headless";
-  const domain = normalizeDomain(url);
-  const profilePath = getProfilePath(domain);
-  const useProfile = hasProfile(domain);
+  const supportsSavedProfile =
+    parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:";
+  const domain = supportsSavedProfile ? normalizeDomain(parsedUrl) : undefined;
+  const profilePath = domain ? getProfilePath(domain) : undefined;
+  const useProfile = domain ? hasProfile(domain) : false;
 
   logger.info("open-launching", {
     url,
@@ -390,12 +434,11 @@ export async function runOpen(
   }
   console.log(`Launching ${browserMode} browser (session: ${session})...`);
 
-  const escapedProfilePath = profilePath
-    .replace(/\\/g, "\\\\")
-    .replace(/'/g, "\\'");
   const escapedUrl = url.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
   const storageStateCode = useProfile
-    ? `storageState: '${escapedProfilePath}',`
+    ? `storageState: '${profilePath!
+        .replace(/\\/g, "\\\\")
+        .replace(/'/g, "\\'")}',`
     : "";
 
   const escapedLogPath = runLogPath.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
@@ -671,7 +714,7 @@ export async function runSave(
   try {
     await new Promise((r) => setTimeout(r, 500));
 
-    const domain = normalizeDomain(urlOrDomain);
+    const domain = normalizeDomain(normalizeUrl(urlOrDomain));
     const profilePath = getProfilePath(domain);
 
     const cdpSession = await context.newCDPSession(page);

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

@@ -14,7 +14,11 @@ import {
 } from "../../index.js";
 import type { LoggerApi } from "../../shared/logger/index.js";
 import { parseSessionStateContent } from "../../shared/state/index.js";
-import { getProfilePath, normalizeDomain } from "../core/browser.js";
+import {
+  getProfilePath,
+  normalizeDomain,
+  normalizeUrl,
+} from "../core/browser.js";
 import {
   getSessionActionsLogPath,
   getSessionDir,
@@ -109,23 +113,18 @@ async function waitForFailureSessionRelease(args: {
   }
 }
 
-function resolveLocalAuthProfilePath(domain: string): string {
-  return getProfilePath(normalizeDomain(domain));
-}
-
 function getMissingLocalAuthProfileError(args: {
-  domain: string;
+  normalizedDomain: string;
   profilePath: string;
   session: string;
 }): string {
-  const normalizedDomain = normalizeDomain(args.domain);
   return [
-    `Local auth profile not found for domain "${normalizedDomain}".`,
+    `Local auth profile not found for domain "${args.normalizedDomain}".`,
     `Expected profile file: ${args.profilePath}`,
     "To create it:",
-    `  1. libretto open https://${normalizedDomain} --headed --session ${args.session}`,
+    `  1. libretto open https://${args.normalizedDomain} --headed --session ${args.session}`,
     "  2. Log in manually in the browser window.",
-    `  3. libretto save ${normalizedDomain} --session ${args.session}`,
+    `  3. libretto save ${args.normalizedDomain} --session ${args.session}`,
   ].join("\n");
 }
 
@@ -215,13 +214,20 @@ async function runIntegrationInternal(
 
   // Resolve auth profile from CLI flag (--auth-profile <domain>)
   const authProfileDomain = args.authProfileDomain;
-  const storageStatePath = authProfileDomain
-    ? resolveLocalAuthProfilePath(authProfileDomain)
+  const normalizedAuthProfileDomain = authProfileDomain
+    ? normalizeDomain(normalizeUrl(authProfileDomain))
+    : undefined;
+  const storageStatePath = normalizedAuthProfileDomain
+    ? getProfilePath(normalizedAuthProfileDomain)
     : undefined;
-  if (authProfileDomain && storageStatePath && !existsSync(storageStatePath)) {
+  if (
+    normalizedAuthProfileDomain &&
+    storageStatePath &&
+    !existsSync(storageStatePath)
+  ) {
     throw new Error(
       getMissingLocalAuthProfileError({
-        domain: authProfileDomain,
+        normalizedDomain: normalizedAuthProfileDomain,
         profilePath: storageStatePath,
         session: args.session,
       }),
@@ -255,7 +261,6 @@ async function runIntegrationInternal(
 
   const workflowContext: LibrettoWorkflowContext = {
     session: args.session,
-    logger: integrationLogger,
     page: browserSession.page,
   };
 

package/src/shared/workflow/workflow.ts

@@ -1,12 +1,10 @@
 import type { Page } from "playwright";
-import type { MinimalLogger } from "../logger/logger.js";
 
 export const LIBRETTO_WORKFLOW_BRAND = Symbol.for("libretto.workflow");
 
 export type LibrettoWorkflowContext = {
   session: string;
   page: Page;
-  logger: MinimalLogger;
 };
 
 export type LibrettoWorkflowHandler<Input = unknown, Output = unknown> = (