libretto 0.5.3-experimental.1 → 0.5.3-experimental.2

package/dist/cli/commands/deploy.js

@@ -1,12 +1,5 @@
-import { execSync } from "node:child_process";
-import {
-  cpSync,
-  mkdirSync,
-  readFileSync
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
 import { z } from "zod";
+import { buildHostedDeployTarball } from "../core/deploy-artifact.js";
 import { SimpleCLI } from "../framework/simple-cli.js";
 function getConfig() {
   const apiUrl = process.env.LIBRETTO_API_URL;
@@ -33,25 +26,6 @@ async function postJson(apiUrl, apiKey, path, input = {}) {
     body: JSON.stringify({ json: input })
   });
 }
-function buildSourceTarball(sourceDir) {
-  const absSourceDir = resolve(sourceDir);
-  const pkgJsonPath = join(absSourceDir, "package.json");
-  try {
-    readFileSync(pkgJsonPath, "utf8");
-  } catch {
-    throw new Error(
-      `No package.json found in ${absSourceDir}. Deploy source must contain a package.json.`
-    );
-  }
-  const dir = join(tmpdir(), `libretto-deploy-${Date.now()}`);
-  mkdirSync(dir, { recursive: true });
-  cpSync(absSourceDir, dir, { recursive: true });
-  const tarPath = join(dir, "source.tar.gz");
-  execSync(
-    `tar czf "${tarPath}" --exclude=source.tar.gz --exclude=node_modules --exclude=.git -C "${dir}" .`
-  );
-  return readFileSync(tarPath).toString("base64");
-}
 async function pollDeployment(apiUrl, apiKey, deploymentId, pollIntervalMs, maxWaitMs) {
   const start = Date.now();
   let status = "building";
@@ -93,7 +67,15 @@ const deployInput = SimpleCLI.input({
     entryPoint: SimpleCLI.option(z.string().optional(), {
       name: "entry-point",
       help: "Entry point file (default: index.ts)"
-    })
+    }),
+    external: SimpleCLI.option(
+      z.string().optional().transform(
+        (value) => value?.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0) ?? []
+      ),
+      {
+        help: "Comma-separated packages to externalize and install at runtime"
+      }
+    )
   }
 });
 const deployCommand = SimpleCLI.command({
@@ -101,14 +83,19 @@ const deployCommand = SimpleCLI.command({
   experimental: true
 }).input(deployInput).handle(async ({ input }) => {
   const { apiUrl, apiKey } = getConfig();
-  console.log(`Packaging source from ${resolve(input.sourceDir)}...`);
-  const source = buildSourceTarball(input.sourceDir);
+  console.log("Bundling hosted deployment artifact...");
+  const { entryPoint, source } = await buildHostedDeployTarball({
+    additionalExternals: input.external,
+    deploymentName: input.name,
+    entryPoint: input.entryPoint,
+    sourceDir: input.sourceDir
+  });
   const createPayload = {
     name: input.name,
-    source
+    source,
+    entry_point: entryPoint
   };
   if (input.description) createPayload.description = input.description;
-  if (input.entryPoint) createPayload.entry_point = input.entryPoint;
   console.log("Uploading deployment...");
   const res = await postJson(
     apiUrl,

package/dist/cli/core/deploy-artifact.js

@@ -0,0 +1,608 @@
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { gzipSync } from "node:zlib";
+import { build } from "esbuild";
+const DEFAULT_RUNTIME_EXTERNALS = [
+  "libretto",
+  "playwright",
+  "playwright-core",
+  "chromium-bidi"
+];
+const BUILT_IN_MANIFEST_DEPENDENCIES = ["libretto"];
+const SOURCE_FILE_EXTENSIONS = [
+  "",
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".mjs",
+  ".cjs",
+  "/index.ts",
+  "/index.tsx",
+  "/index.mts",
+  "/index.cts",
+  "/index.js",
+  "/index.mjs",
+  "/index.cjs"
+];
+const CURRENT_LIBRETTO_VERSION = readCurrentLibrettoVersion();
+function readCurrentLibrettoVersion() {
+  const packageJsonPath = fileURLToPath(
+    new URL("../../../package.json", import.meta.url)
+  );
+  const manifest = readJsonFile(packageJsonPath);
+  if (!manifest.version) {
+    throw new Error(
+      `Unable to determine current libretto version from ${packageJsonPath}.`
+    );
+  }
+  return manifest.version;
+}
+function readJsonFile(path) {
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+function readPackageManifest(path) {
+  return readJsonFile(path);
+}
+function ensureSourcePackageManifest(sourceDir) {
+  const pkgJsonPath = join(sourceDir, "package.json");
+  if (!existsSync(pkgJsonPath)) {
+    throw new Error(
+      `No package.json found in ${sourceDir}. Deploy source must contain a package.json.`
+    );
+  }
+  return readPackageManifest(pkgJsonPath);
+}
+function resolveEntryPointPath(sourceDir, entryPoint) {
+  const candidate = entryPoint ?? "index.ts";
+  const absEntryPoint = isAbsolute(candidate) ? resolve(candidate) : resolve(sourceDir, candidate);
+  if (!existsSync(absEntryPoint)) {
+    throw new Error(
+      `Deploy entry point not found: ${absEntryPoint}. Pass --entry-point to choose a workflow file.`
+    );
+  }
+  return absEntryPoint;
+}
+function isRootPath(path) {
+  return dirname(path) === path;
+}
+function findWorkspaceRoot(startDir) {
+  let currentDir = resolve(startDir);
+  while (true) {
+    if (existsSync(join(currentDir, "pnpm-workspace.yaml"))) {
+      return currentDir;
+    }
+    const pkgJsonPath = join(currentDir, "package.json");
+    if (existsSync(pkgJsonPath)) {
+      const manifest = readPackageManifest(pkgJsonPath);
+      if (manifest.workspaces) {
+        return currentDir;
+      }
+    }
+    if (isRootPath(currentDir)) {
+      return null;
+    }
+    currentDir = dirname(currentDir);
+  }
+}
+function readWorkspacePatterns(rootDir) {
+  const pnpmWorkspacePath = join(rootDir, "pnpm-workspace.yaml");
+  if (existsSync(pnpmWorkspacePath)) {
+    const patterns = [];
+    let inPackagesBlock = false;
+    for (const rawLine of readFileSync(pnpmWorkspacePath, "utf8").split(/\r?\n/)) {
+      const trimmed = rawLine.trim();
+      if (!inPackagesBlock) {
+        if (trimmed === "packages:") {
+          inPackagesBlock = true;
+        }
+        continue;
+      }
+      if (trimmed.length > 0 && !trimmed.startsWith("-") && !rawLine.startsWith(" ") && !rawLine.startsWith("	")) {
+        break;
+      }
+      const match = trimmed.match(/^-\s*["']?(.+?)["']?$/);
+      if (match?.[1]) {
+        patterns.push(match[1]);
+      }
+    }
+    if (patterns.length > 0) {
+      return patterns;
+    }
+  }
+  const pkgJsonPath = join(rootDir, "package.json");
+  if (!existsSync(pkgJsonPath)) {
+    return [];
+  }
+  const manifest = readPackageManifest(pkgJsonPath);
+  if (Array.isArray(manifest.workspaces)) {
+    return manifest.workspaces;
+  }
+  if (manifest.workspaces && Array.isArray(manifest.workspaces.packages)) {
+    return manifest.workspaces.packages;
+  }
+  return [];
+}
+function expandWorkspacePattern(rootDir, pattern) {
+  if (!pattern.includes("*")) {
+    const absDir = resolve(rootDir, pattern);
+    return existsSync(absDir) ? [absDir] : [];
+  }
+  if (!pattern.endsWith("/*")) {
+    return [];
+  }
+  const baseDir = resolve(rootDir, pattern.slice(0, -2));
+  if (!existsSync(baseDir)) {
+    return [];
+  }
+  return readdirSync(baseDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join(baseDir, entry.name));
+}
+function discoverWorkspacePackages(startDir) {
+  const workspaceRoot = findWorkspaceRoot(startDir);
+  if (!workspaceRoot) {
+    return /* @__PURE__ */ new Map();
+  }
+  const packages = /* @__PURE__ */ new Map();
+  for (const pattern of readWorkspacePatterns(workspaceRoot)) {
+    for (const dir of expandWorkspacePattern(workspaceRoot, pattern)) {
+      const pkgJsonPath = join(dir, "package.json");
+      if (!existsSync(pkgJsonPath)) {
+        continue;
+      }
+      const manifest = readPackageManifest(pkgJsonPath);
+      if (!manifest.name) {
+        continue;
+      }
+      packages.set(manifest.name, { dir, manifest, name: manifest.name });
+    }
+  }
+  return packages;
+}
+function findMatchingWorkspacePackage(importPath, workspacePackages) {
+  const names = [...workspacePackages.keys()].sort(
+    (left, right) => right.length - left.length
+  );
+  for (const name of names) {
+    if (importPath === name) {
+      return {
+        info: workspacePackages.get(name),
+        subpath: "."
+      };
+    }
+    if (importPath.startsWith(`${name}/`)) {
+      return {
+        info: workspacePackages.get(name),
+        subpath: `.${importPath.slice(name.length)}`
+      };
+    }
+  }
+  return null;
+}
+function resolvePathCandidates(packageDir, target, replacement) {
+  const value = replacement ? target.replace(/\*/g, replacement) : target;
+  const absCandidate = resolve(packageDir, value);
+  if (existsSync(absCandidate)) {
+    return absCandidate;
+  }
+  for (const suffix of SOURCE_FILE_EXTENSIONS) {
+    const fileCandidate = resolve(packageDir, `${value}${suffix}`);
+    if (existsSync(fileCandidate)) {
+      return fileCandidate;
+    }
+  }
+  return null;
+}
+function resolveExportTarget(exportValue, packageDir, replacement) {
+  if (typeof exportValue === "string") {
+    return resolvePathCandidates(packageDir, exportValue, replacement);
+  }
+  if (Array.isArray(exportValue)) {
+    for (const entry of exportValue) {
+      const resolved = resolveExportTarget(entry, packageDir, replacement);
+      if (resolved) {
+        return resolved;
+      }
+    }
+    return null;
+  }
+  if (!exportValue || typeof exportValue !== "object") {
+    return null;
+  }
+  const record = exportValue;
+  for (const condition of [
+    "types",
+    "source",
+    "import",
+    "default",
+    "module",
+    "require"
+  ]) {
+    if (!(condition in record)) {
+      continue;
+    }
+    const resolved = resolveExportTarget(record[condition], packageDir, replacement);
+    if (resolved) {
+      return resolved;
+    }
+  }
+  for (const value of Object.values(record)) {
+    const resolved = resolveExportTarget(value, packageDir, replacement);
+    if (resolved) {
+      return resolved;
+    }
+  }
+  return null;
+}
+function resolveExportsSubpath(exportsField, packageDir, subpath) {
+  if (!exportsField) {
+    return null;
+  }
+  if (subpath === ".") {
+    const rootExport = resolveExportTarget(exportsField, packageDir);
+    if (rootExport) {
+      return rootExport;
+    }
+  }
+  if (typeof exportsField !== "object" || Array.isArray(exportsField)) {
+    return null;
+  }
+  const record = exportsField;
+  const hasExplicitSubpathKeys = Object.keys(record).some((key) => key.startsWith("."));
+  if (!hasExplicitSubpathKeys) {
+    return subpath === "." ? resolveExportTarget(record, packageDir) : null;
+  }
+  const exactMatch = record[subpath];
+  if (exactMatch !== void 0) {
+    return resolveExportTarget(exactMatch, packageDir);
+  }
+  for (const [key, value] of Object.entries(record)) {
+    const starIndex = key.indexOf("*");
+    if (starIndex < 0) {
+      continue;
+    }
+    const prefix = key.slice(0, starIndex);
+    const suffix = key.slice(starIndex + 1);
+    if (!subpath.startsWith(prefix) || !subpath.endsWith(suffix)) {
+      continue;
+    }
+    const replacement = subpath.slice(prefix.length, subpath.length - suffix.length);
+    const resolved = resolveExportTarget(value, packageDir, replacement);
+    if (resolved) {
+      return resolved;
+    }
+  }
+  return null;
+}
+function resolveWorkspaceSourcePath(info, subpath) {
+  const viaExports = resolveExportsSubpath(info.manifest.exports, info.dir, subpath);
+  if (viaExports) {
+    return viaExports;
+  }
+  if (subpath === ".") {
+    for (const field of [
+      info.manifest.types,
+      info.manifest.source,
+      info.manifest.module,
+      info.manifest.main
+    ]) {
+      if (!field) {
+        continue;
+      }
+      const resolved = resolvePathCandidates(info.dir, field);
+      if (resolved) {
+        return resolved;
+      }
+    }
+  }
+  const directSubpath = subpath === "." ? "index" : subpath.slice(2);
+  return resolvePathCandidates(info.dir, directSubpath);
+}
+function workspaceSourcePlugin(workspacePackages, externalPackages) {
+  return {
+    name: "workspace-source-resolver",
+    setup(buildApi) {
+      buildApi.onResolve({ filter: /^[^./].*/ }, (args) => {
+        if (externalPackages.has(args.path)) {
+          return null;
+        }
+        const match = findMatchingWorkspacePackage(args.path, workspacePackages);
+        if (!match) {
+          return null;
+        }
+        const resolvedPath = resolveWorkspaceSourcePath(match.info, match.subpath);
+        if (!resolvedPath) {
+          throw new Error(
+            `Unable to resolve workspace import "${args.path}" from ${match.info.dir}.`
+          );
+        }
+        return { path: resolvedPath };
+      });
+    }
+  };
+}
+function normalizePackageName(name) {
+  const normalized = name.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return normalized || "libretto-deployment";
+}
+function readDependencyVersionFromManifest(manifest, packageName) {
+  for (const dependencyGroup of [
+    manifest.dependencies,
+    manifest.devDependencies,
+    manifest.peerDependencies,
+    manifest.optionalDependencies
+  ]) {
+    const version = dependencyGroup?.[packageName];
+    if (version) {
+      return version;
+    }
+  }
+  return null;
+}
+function resolveDependencyVersion(sourceDir, packageName, fallbackVersion) {
+  let currentDir = resolve(sourceDir);
+  while (true) {
+    const pkgJsonPath = join(currentDir, "package.json");
+    if (existsSync(pkgJsonPath)) {
+      const version = readDependencyVersionFromManifest(
+        readPackageManifest(pkgJsonPath),
+        packageName
+      );
+      if (version) {
+        return version;
+      }
+    }
+    if (isRootPath(currentDir)) {
+      break;
+    }
+    currentDir = dirname(currentDir);
+  }
+  if (fallbackVersion) {
+    return fallbackVersion;
+  }
+  throw new Error(
+    `Unable to determine a version for external package "${packageName}". Add it to your package.json or remove it from --external.`
+  );
+}
+function writeDeployManifest(args) {
+  const dependencies = Object.fromEntries(
+    [
+      ...BUILT_IN_MANIFEST_DEPENDENCIES,
+      ...args.additionalExternals
+    ].map((packageName) => [
+      packageName,
+      resolveDependencyVersion(
+        args.sourceDir,
+        packageName,
+        packageName === "libretto" ? CURRENT_LIBRETTO_VERSION : void 0
+      )
+    ])
+  );
+  writeFileSync(
+    join(args.outputDir, "package.json"),
+    JSON.stringify(
+      {
+        name: normalizePackageName(args.deploymentName),
+        private: true,
+        type: "module",
+        dependencies
+      },
+      null,
+      2
+    ) + "\n"
+  );
+}
+function formatBuildError(error) {
+  if (!(error instanceof Error)) {
+    return String(error);
+  }
+  const candidate = error;
+  if (!Array.isArray(candidate.errors) || candidate.errors.length === 0) {
+    return error.message;
+  }
+  return candidate.errors.map((entry) => {
+    const location = entry.location?.file ? `${entry.location.file}:${entry.location.line ?? 0}:${entry.location.column ?? 0}` : "unknown";
+    return `${location} ${entry.text ?? error.message}`;
+  }).join("\n");
+}
+function extractExportNamesFromEsmBundle(bundleSource) {
+  const exportNames = /* @__PURE__ */ new Set();
+  for (const entry of bundleSource.matchAll(
+    /export\s+(?:const|let|var|function|class)\s+([A-Za-z_$][\w$]*)/g
+  )) {
+    exportNames.add(entry[1]);
+  }
+  for (const entry of bundleSource.matchAll(/export\s+\{([^}]+)\};/g)) {
+    const specifiers = entry[1]?.split(",") ?? [];
+    for (const specifier of specifiers) {
+      const trimmed = specifier.trim();
+      if (!trimmed) {
+        continue;
+      }
+      const aliasMatch = trimmed.match(
+        /^([A-Za-z_$][\w$]*)\s+as\s+([A-Za-z_$][\w$]*|default)$/
+      );
+      if (aliasMatch?.[2]) {
+        exportNames.add(aliasMatch[2]);
+        continue;
+      }
+      if (/^[A-Za-z_$][\w$]*$/.test(trimmed)) {
+        exportNames.add(trimmed);
+      }
+    }
+  }
+  if (/\bexport\s+default\b/m.test(bundleSource)) {
+    exportNames.add("default");
+  }
+  return [...exportNames];
+}
+function createBootstrapSource(args) {
+  const bundleHash = createHash("sha256").update(args.bundleBuffer).digest("hex").slice(0, 16);
+  const bundleBase64 = gzipSync(args.bundleBuffer, { level: 9 }).toString("base64");
+  const outputPrefix = `${normalizePackageName(args.deploymentName)}-`;
+  const hasDefaultExport = args.exportNames.includes("default");
+  const exportLines = args.exportNames.filter((name) => name !== "default").map(
+    (name) => `export const ${name} = createWorkflowProxy(${JSON.stringify(name)});`
+  ).join("\n");
+  const defaultExportLine = hasDefaultExport ? 'export default createWorkflowProxy("default");' : "";
+  return `import { createRequire } from "node:module";
+import { existsSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { gunzipSync } from "node:zlib";
+import { workflow } from "libretto";
+
+const BUNDLE_HASH = ${JSON.stringify(bundleHash)};
+const BUNDLE_GZIP_BASE64 = ${JSON.stringify(bundleBase64)};
+const BUNDLE_FILENAME = join(
+  tmpdir(),
+  ${JSON.stringify(outputPrefix)} + BUNDLE_HASH + ".cjs",
+);
+const require = createRequire(import.meta.url);
+
+function ensureBundleFile() {
+  if (!existsSync(BUNDLE_FILENAME)) {
+    writeFileSync(
+      BUNDLE_FILENAME,
+      gunzipSync(Buffer.from(BUNDLE_GZIP_BASE64, "base64")),
+    );
+  }
+
+  return BUNDLE_FILENAME;
+}
+
+function createWorkflowProxy(exportName) {
+  return workflow(exportName, async (ctx, input) => {
+    const impl = require(ensureBundleFile());
+    const target = impl[exportName];
+    if (!target || typeof target.run !== "function") {
+      throw new Error(
+        \`Expected workflow export "\${exportName}" to be available in the bundled deployment implementation.\`,
+      );
+    }
+    return await target.run(ctx, input);
+  });
+}
+
+${exportLines}
+${defaultExportLine}
+`;
+}
+async function createHostedDeployPackage(args) {
+  const absSourceDir = resolve(args.sourceDir);
+  ensureSourcePackageManifest(absSourceDir);
+  const absEntryPoint = resolveEntryPointPath(absSourceDir, args.entryPoint);
+  const tempRoot = mkdtempSync(join(tmpdir(), "libretto-deploy-"));
+  const outputDir = join(tempRoot, "deploy");
+  mkdirSync(outputDir, { recursive: true });
+  const additionalExternals = [...new Set(args.additionalExternals ?? [])];
+  const externalPackages = /* @__PURE__ */ new Set([
+    ...DEFAULT_RUNTIME_EXTERNALS,
+    ...additionalExternals
+  ]);
+  const workspacePackages = discoverWorkspacePackages(absSourceDir);
+  try {
+    const implementationBuild = await build({
+      absWorkingDir: absSourceDir,
+      bundle: true,
+      entryPoints: [absEntryPoint],
+      external: [...externalPackages],
+      format: "cjs",
+      outfile: "prebundled.cjs",
+      platform: "node",
+      plugins: [workspaceSourcePlugin(workspacePackages, externalPackages)],
+      splitting: false,
+      target: "node20",
+      write: false
+    });
+    const bundledImplementation = implementationBuild.outputFiles?.find(
+      (file) => file.path.endsWith("prebundled.cjs")
+    );
+    if (!bundledImplementation) {
+      throw new Error("Bundler did not produce a deployment implementation file.");
+    }
+    const exportBuild = await build({
+      absWorkingDir: absSourceDir,
+      bundle: true,
+      entryPoints: [absEntryPoint],
+      external: [...externalPackages],
+      format: "esm",
+      outfile: "entry-exports.js",
+      platform: "node",
+      plugins: [workspaceSourcePlugin(workspacePackages, externalPackages)],
+      splitting: false,
+      target: "node20",
+      write: false
+    });
+    const bundledExports = exportBuild.outputFiles?.find(
+      (file) => file.path.endsWith("entry-exports.js")
+    );
+    if (!bundledExports) {
+      throw new Error("Bundler did not produce an export analysis file.");
+    }
+    const exportNames = extractExportNamesFromEsmBundle(bundledExports.text);
+    if (exportNames.length === 0) {
+      throw new Error(
+        `No named exports were found in ${absEntryPoint}. Hosted deploy expects the entry point to export one or more workflows.`
+      );
+    }
+    writeFileSync(
+      join(outputDir, "index.js"),
+      createBootstrapSource({
+        bundleBuffer: Buffer.from(bundledImplementation.contents),
+        deploymentName: args.deploymentName,
+        exportNames
+      })
+    );
+  } catch (error) {
+    rmSync(tempRoot, { force: true, recursive: true });
+    throw new Error(
+      `Failed to bundle deploy entry point ${absEntryPoint}.
+${formatBuildError(error)}`
+    );
+  }
+  writeDeployManifest({
+    additionalExternals,
+    deploymentName: args.deploymentName,
+    outputDir,
+    sourceDir: absSourceDir
+  });
+  return {
+    cleanup: () => {
+      rmSync(tempRoot, { force: true, recursive: true });
+    },
+    entryPoint: "index.js",
+    outputDir
+  };
+}
+async function buildHostedDeployTarball(args) {
+  const deployPackage = await createHostedDeployPackage(args);
+  try {
+    const tarPath = join(dirname(deployPackage.outputDir), "source.tar.gz");
+    execFileSync("tar", ["czf", tarPath, "-C", deployPackage.outputDir, "."], {
+      stdio: "pipe"
+    });
+    return {
+      entryPoint: deployPackage.entryPoint,
+      source: readFileSync(tarPath).toString("base64")
+    };
+  } finally {
+    deployPackage.cleanup();
+  }
+}
+export {
+  buildHostedDeployTarball,
+  createHostedDeployPackage
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libretto",
-  "version": "0.5.3-experimental.1",
+  "version": "0.5.3-experimental.2",
   "description": "AI-powered browser automation library and CLI built on Playwright",
   "license": "MIT",
   "repository": {
@@ -81,6 +81,7 @@
   },
   "dependencies": {
     "ai": "^6.0.116",
+    "esbuild": "^0.27.0",
     "playwright": "^1.58.2",
     "tsx": "^4.21.0",
     "zod": "^4.3.6"