libretto 0.6.10 → 0.6.12

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

@@ -1,235 +0,0 @@
-import { appendFileSync, existsSync, readFileSync } from "node:fs";
-import { writeFile } from "node:fs/promises";
-import { cwd } from "node:process";
-import { isAbsolute, resolve } from "node:path";
-import { pathToFileURL } from "node:url";
-import {
-  getDefaultWorkflowFromModuleExports,
-  getWorkflowsFromModuleExports,
-  instrumentContext,
-  launchBrowser
-} from "../../index.js";
-import { parseSessionStateContent } from "../../shared/state/index.js";
-import {
-  getProfilePath,
-  normalizeDomain,
-  normalizeUrl
-} from "../core/browser.js";
-import {
-  getSessionActionsLogPath,
-  getSessionNetworkLogPath,
-  getSessionStatePath
-} from "../core/context.js";
-import {
-  getPauseSignalPaths,
-  removeSignalIfExists
-} from "../core/pause-signals.js";
-import { installSessionTelemetry } from "../core/session-telemetry.js";
-const FAILURE_HOLD_POLL_INTERVAL_MS = 250;
-const TSCONFIG_HINT = "TypeScript compilation failed. Pass --tsconfig <path> to run against a specific tsconfig.";
-function isTsxCompileError(error) {
-  return error instanceof Error && (error.name === "TransformError" || error.message.startsWith("Cannot resolve tsconfig at path:"));
-}
-function mirrorStdoutToFile(filePath) {
-  const stdout = process.stdout;
-  const originalWrite = stdout.write.bind(stdout);
-  stdout.write = ((chunk, ...args) => {
-    try {
-      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk), "utf8");
-      appendFileSync(filePath, buffer);
-    } catch {
-    }
-    return originalWrite(chunk, ...args);
-  });
-  return () => {
-    stdout.write = originalWrite;
-  };
-}
-function readSessionStatePid(session) {
-  const statePath = getSessionStatePath(session);
-  if (!existsSync(statePath)) return null;
-  try {
-    return parseSessionStateContent(readFileSync(statePath, "utf8"), statePath).pid ?? null;
-  } catch {
-    return null;
-  }
-}
-async function waitForFailureSessionRelease(args) {
-  const { session, expectedPid, logger } = args;
-  logger.info("run-failure-session-hold", { session, expectedPid });
-  while (true) {
-    const currentPid = readSessionStatePid(session);
-    if (currentPid !== expectedPid) {
-      logger.info("run-failure-session-released", {
-        session,
-        expectedPid,
-        currentPid
-      });
-      return;
-    }
-    await new Promise(
-      (resolveWait) => setTimeout(resolveWait, FAILURE_HOLD_POLL_INTERVAL_MS)
-    );
-  }
-}
-function getMissingLocalAuthProfileError(args) {
-  return [
-    `Local auth profile not found for domain "${args.normalizedDomain}".`,
-    `Expected profile file: ${args.profilePath}`,
-    "To create it:",
-    `  1. libretto open https://${args.normalizedDomain} --headed --session ${args.session}`,
-    "  2. Log in manually in the browser window.",
-    `  3. libretto save ${args.normalizedDomain} --session ${args.session}`
-  ].join("\n");
-}
-function getAbsoluteIntegrationPath(integrationPath) {
-  const absolutePath = isAbsolute(integrationPath) ? integrationPath : resolve(cwd(), integrationPath);
-  if (!existsSync(absolutePath)) {
-    throw new Error(`Integration file does not exist: ${absolutePath}`);
-  }
-  return absolutePath;
-}
-async function loadDefaultWorkflow(absolutePath) {
-  let loadedModule;
-  try {
-    loadedModule = await import(pathToFileURL(absolutePath).href);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    const compileHint = isTsxCompileError(error) ? `
-${TSCONFIG_HINT}` : "";
-    throw new Error(
-      `Failed to import integration module at ${absolutePath}: ${message}${compileHint}`
-    );
-  }
-  const defaultWorkflow = getDefaultWorkflowFromModuleExports(loadedModule);
-  if (defaultWorkflow) {
-    return defaultWorkflow;
-  }
-  const availableWorkflowNames = getWorkflowsFromModuleExports(loadedModule).map(
-    (candidate) => candidate.name
-  );
-  if (availableWorkflowNames.length === 0) {
-    throw new Error(
-      `No default-exported workflow found in ${absolutePath}. Export the workflow with \`export default workflow("name", handler)\`.`
-    );
-  }
-  throw new Error(
-    `No default-exported workflow found in ${absolutePath}. libretto run only uses the file's default export. Available named workflows: ${availableWorkflowNames.join(", ")}`
-  );
-}
-async function installHeadedWorkflowVisualization(args) {
-  await (args.instrument ?? instrumentContext)(args.context, {
-    visualize: true,
-    logger: args.logger
-  });
-}
-async function runIntegrationInternal(args, options) {
-  const { logger } = options;
-  const absolutePath = getAbsoluteIntegrationPath(args.integrationPath);
-  const workflow = await loadDefaultWorkflow(absolutePath);
-  const signalPaths = getPauseSignalPaths(args.session);
-  await removeSignalIfExists(signalPaths.pausedSignalPath);
-  await removeSignalIfExists(signalPaths.resumeSignalPath);
-  await removeSignalIfExists(signalPaths.completedSignalPath);
-  await removeSignalIfExists(signalPaths.failedSignalPath);
-  const restoreStdout = mirrorStdoutToFile(signalPaths.outputSignalPath);
-  console.log(
-    `Running workflow "${workflow.name}" from ${absolutePath} (${args.headless ? "headless" : "headed"})...`
-  );
-  const integrationLogger = logger.withScope("integration-run", {
-    integrationPath: absolutePath,
-    workflowName: workflow.name,
-    session: args.session
-  });
-  const authProfileDomain = args.authProfileDomain;
-  const normalizedAuthProfileDomain = authProfileDomain ? normalizeDomain(normalizeUrl(authProfileDomain)) : void 0;
-  const storageStatePath = normalizedAuthProfileDomain ? getProfilePath(normalizedAuthProfileDomain) : void 0;
-  if (normalizedAuthProfileDomain && storageStatePath && !existsSync(storageStatePath)) {
-    throw new Error(
-      getMissingLocalAuthProfileError({
-        normalizedDomain: normalizedAuthProfileDomain,
-        profilePath: storageStatePath,
-        session: args.session
-      })
-    );
-  }
-  const browserSession = await launchBrowser({
-    sessionName: args.session,
-    headless: args.headless,
-    storageStatePath,
-    viewport: args.viewport,
-    accessMode: args.accessMode,
-    cdpEndpoint: args.cdpEndpoint,
-    provider: args.provider
-  });
-  if (!args.headless && args.visualize !== false) {
-    await installHeadedWorkflowVisualization({
-      context: browserSession.context,
-      logger: integrationLogger
-    });
-  }
-  const actionsLogPath = getSessionActionsLogPath(args.session);
-  const networkLogPath = getSessionNetworkLogPath(args.session);
-  await installSessionTelemetry({
-    context: browserSession.context,
-    initialPage: browserSession.page,
-    includeUserDomActions: true,
-    logAction: (entry) => {
-      appendFileSync(actionsLogPath, JSON.stringify(entry) + "\n");
-    },
-    logNetwork: (entry) => {
-      appendFileSync(networkLogPath, JSON.stringify(entry) + "\n");
-    }
-  });
-  await browserSession.context.addInitScript(() => {
-    globalThis.__name = (target, value) => Object.defineProperty(target, "name", { value, configurable: true });
-  });
-  const workflowContext = {
-    session: args.session,
-    page: browserSession.page
-  };
-  try {
-    try {
-      await workflow.run(workflowContext, args.params ?? {});
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      await writeFile(
-        signalPaths.failedSignalPath,
-        JSON.stringify(
-          {
-            failedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            message: errorMessage,
-            phase: "workflow"
-          },
-          null,
-          2
-        ),
-        "utf8"
-      );
-      await waitForFailureSessionRelease({
-        session: args.session,
-        expectedPid: process.pid,
-        logger
-      });
-      return { status: "failed-held" };
-    }
-    await writeFile(
-      signalPaths.completedSignalPath,
-      JSON.stringify({ completedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2),
-      "utf8"
-    );
-    return { status: "completed" };
-  } finally {
-    restoreStdout();
-    await browserSession.close();
-  }
-}
-async function runIntegrationFromFileInWorker(args, logger) {
-  return await runIntegrationInternal(args, {
-    logger
-  });
-}
-export {
-  installHeadedWorkflowVisualization,
-  runIntegrationFromFileInWorker
-};

package/dist/cli/workers/run-integration-worker-protocol.js

@@ -1,17 +0,0 @@
-import { z } from "zod";
-import { SessionAccessModeSchema } from "../../shared/state/index.js";
-const RunIntegrationWorkerRequestSchema = z.object({
-  integrationPath: z.string().min(1),
-  session: z.string().min(1),
-  params: z.unknown(),
-  headless: z.boolean(),
-  visualize: z.boolean().default(true),
-  authProfileDomain: z.string().optional(),
-  viewport: z.object({ width: z.number(), height: z.number() }).optional(),
-  accessMode: SessionAccessModeSchema.default("write-access"),
-  cdpEndpoint: z.string().optional(),
-  provider: z.object({ name: z.string(), sessionId: z.string() }).optional()
-});
-export {
-  RunIntegrationWorkerRequestSchema
-};

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

@@ -1,64 +0,0 @@
-import { writeFile } from "node:fs/promises";
-import { ZodError } from "zod";
-import {
-  RunIntegrationWorkerRequestSchema
-} from "./run-integration-worker-protocol.js";
-import { runIntegrationFromFileInWorker } from "./run-integration-runtime.js";
-import { ensureLibrettoSetup, withSessionLogger } from "../core/context.js";
-import { getPauseSignalPaths } from "../core/pause-signals.js";
-function parseWorkerRequest(argv) {
-  const rawPayload = argv[2];
-  if (!rawPayload) {
-    throw new Error("Missing worker payload argument.");
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(rawPayload);
-  } catch (error) {
-    throw new Error(
-      `Invalid worker payload JSON: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-  try {
-    return RunIntegrationWorkerRequestSchema.parse(parsed);
-  } catch (error) {
-    if (error instanceof ZodError) {
-      const details = error.issues.map((issue) => `${issue.path.join(".") || "root"}: ${issue.message}`).join("; ");
-      throw new Error(`Worker payload is invalid: ${details}`);
-    }
-    throw error;
-  }
-}
-async function main() {
-  let request = null;
-  let exitCode = 0;
-  try {
-    request = parseWorkerRequest(process.argv);
-    const workerRequest = request;
-    ensureLibrettoSetup();
-    await withSessionLogger(workerRequest.session, async (logger) => {
-      await runIntegrationFromFileInWorker(workerRequest, logger);
-    });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (request) {
-      const { failedSignalPath } = getPauseSignalPaths(request.session);
-      await writeFile(
-        failedSignalPath,
-        JSON.stringify(
-          {
-            failedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            message,
-            phase: "setup"
-          },
-          null,
-          2
-        ),
-        "utf8"
-      );
-    }
-    exitCode = 1;
-  }
-  process.exit(exitCode);
-}
-void main();

package/src/cli/core/daemon/index.ts

@@ -1,24 +0,0 @@
-export {
-  DaemonServer,
-  DaemonClient,
-  DaemonClientError,
-  getDaemonSocketPath,
-  type DaemonCommandResult,
-  type DaemonExecOutput,
-  type DaemonRequest,
-  type DaemonResponse,
-  type DaemonResultMap,
-  type RequestHandler,
-} from "./ipc.js";
-
-export {
-  type DaemonLaunchConfig,
-  type DaemonConnectConfig,
-  type DaemonConfig,
-} from "./config.js";
-
-export {
-  spawnSessionDaemon,
-  type SpawnSessionDaemonOptions,
-  type SpawnSessionDaemonResult,
-} from "./spawn.js";

package/src/cli/core/daemon/spawn.ts

@@ -1,171 +0,0 @@
-/**
- * Spawn and wait for a browser daemon process.
- *
- * Shared by `runOpen`, `runConnect`, and `runOpenWithProvider` in
- * `browser.ts`. Encapsulates the child-process lifecycle and IPC
- * readiness polling so callers only need to provide config and
- * handle session-state persistence.
- */
-
-import { openSync, closeSync } from "node:fs";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { createRequire } from "node:module";
-import { spawn } from "node:child_process";
-import type { LoggerApi } from "../../../shared/logger/index.js";
-import { getDaemonSocketPath } from "./ipc.js";
-import { DaemonClient } from "./ipc.js";
-import type { DaemonConfig } from "./config.js";
-
-// ── Public types ─────────────────────────────────────────────────────
-
-export type SpawnSessionDaemonOptions = {
-  /** Daemon config — serialized as JSON and passed to the child process. */
-  config: DaemonConfig;
-  session: string;
-  logger: LoggerApi;
-  /** Path for the child's stderr log file. */
-  logPath: string;
-  /** How long to wait for the daemon's IPC server (default: 10 000 ms). */
-  ipcTimeoutMs?: number;
-  /**
-   * Called before throwing when the daemon fails to start (spawn error,
-   * early exit, or IPC timeout). Use for cleanup — e.g. closing a cloud
-   * provider session. Return value is ignored.
-   */
-  onFailure?: () => Promise<unknown>;
-};
-
-export type SpawnSessionDaemonResult = {
-  /** PID of the detached daemon child process. */
-  pid: number;
-  /** Unix domain socket path for daemon IPC. */
-  socketPath: string;
-  /** Ready-to-use IPC client (already confirmed reachable via ping). */
-  client: DaemonClient;
-};
-
-// ── Implementation ───────────────────────────────────────────────────
-
-const DEFAULT_IPC_TIMEOUT_MS = 10_000;
-const IPC_POLL_INTERVAL_MS = 250;
-
-/**
- * Spawn a daemon child process with the given config and wait for its
- * IPC server to become reachable.
- *
- * The daemon entry point is resolved relative to this module so the
- * caller doesn't need to know where the daemon script lives.
- */
-export async function spawnSessionDaemon(
-  options: SpawnSessionDaemonOptions,
-): Promise<SpawnSessionDaemonResult> {
-  const {
-    config,
-    session,
-    logger,
-    logPath,
-    ipcTimeoutMs = DEFAULT_IPC_TIMEOUT_MS,
-    onFailure,
-  } = options;
-
-  // Resolve paths for the daemon entry point and tsx loader.
-  const daemonEntryPath = fileURLToPath(
-    new URL("./daemon.js", import.meta.url),
-  );
-  const require = createRequire(import.meta.url);
-  const tsxImportPath = pathToFileURL(require.resolve("tsx/esm")).href;
-
-  // Spawn detached child process with stderr going to the log file.
-  const childStderrFd = openSync(logPath, "a");
-  const child = spawn(
-    process.execPath,
-    ["--import", tsxImportPath, daemonEntryPath, JSON.stringify(config)],
-    {
-      detached: true,
-      stdio: ["ignore", "ignore", childStderrFd],
-    },
-  );
-  child.unref();
-  closeSync(childStderrFd);
-
-  const pid = child.pid!;
-  logger.info("daemon-spawned", { pid, session });
-
-  // Track spawn errors and early exits so the polling loop can fail fast.
-  let childSpawnError: Error | null = null;
-  let childEarlyExit: {
-    code: number | null;
-    signal: NodeJS.Signals | null;
-  } | null = null;
-
-  child.on("error", (err) => {
-    childSpawnError = err;
-    logger.error("daemon-spawn-error", { error: err, session });
-  });
-
-  child.on("exit", (code, signal) => {
-    childEarlyExit = { code, signal };
-    logger.warn("daemon-early-exit", { code, signal, session, pid });
-  });
-
-  // Poll the daemon's IPC server until it responds to a ping.
-  const socketPath = getDaemonSocketPath(session);
-  const client = new DaemonClient(socketPath);
-  const maxAttempts = Math.ceil(ipcTimeoutMs / IPC_POLL_INTERVAL_MS);
-  let ipcReady = false;
-
-  for (let i = 0; i < maxAttempts; i++) {
-    // Fail fast on spawn errors. The cast is needed because TypeScript
-    // doesn't track that the variable is mutated asynchronously by the
-    // child's "error" event handler.
-    const spawnError = childSpawnError as Error | null;
-    if (spawnError !== null) {
-      await onFailure?.();
-      const errWithCode = spawnError as Error & { code?: string };
-      const hint =
-        errWithCode.code === "ENOENT"
-          ? " Ensure Node.js is available in PATH for child processes."
-          : "";
-      throw new Error(
-        `Failed to spawn daemon: ${spawnError.message}.${hint} Check logs: ${logPath}`,
-      );
-    }
-
-    // Fail fast on early exit.
-    const earlyExit = childEarlyExit as {
-      code: number | null;
-      signal: NodeJS.Signals | null;
-    } | null;
-    if (earlyExit !== null) {
-      await onFailure?.();
-      const status = earlyExit.code ?? earlyExit.signal ?? "unknown";
-      throw new Error(
-        `Daemon exited before startup (status: ${status}). Check logs: ${logPath}`,
-      );
-    }
-
-    await new Promise((r) => setTimeout(r, IPC_POLL_INTERVAL_MS));
-    ipcReady = await client.ping();
-    if (ipcReady) break;
-
-    if (i > 0 && i % 10 === 0) {
-      logger.info("daemon-waiting-for-ipc", { attempt: i, session });
-    }
-  }
-
-  if (!ipcReady) {
-    // Kill the orphaned daemon process before reporting failure.
-    try {
-      process.kill(pid, "SIGTERM");
-    } catch {
-      // Process may have already exited.
-    }
-    await onFailure?.();
-    throw new Error(
-      `Daemon failed to start within ${Math.ceil(ipcTimeoutMs / 1000)}s. Check logs: ${logPath}`,
-    );
-  }
-
-  logger.info("daemon-ipc-ready", { session, socketPath });
-  return { pid, socketPath, client };
-}

package/src/cli/core/pause-signals.ts

@@ -1,35 +0,0 @@
-import { existsSync } from "node:fs";
-import { unlink } from "node:fs/promises";
-import { join } from "node:path";
-import { getSessionDir } from "./context.js";
-
-export type PauseSignalPaths = {
-  pausedSignalPath: string;
-  resumeSignalPath: string;
-  completedSignalPath: string;
-  failedSignalPath: string;
-  outputSignalPath: string;
-};
-
-export function getPauseSignalPaths(session: string): PauseSignalPaths {
-  const sessionDir = getSessionDir(session);
-  return {
-    pausedSignalPath: join(sessionDir, `${session}.paused`),
-    resumeSignalPath: join(sessionDir, `${session}.resume`),
-    completedSignalPath: join(sessionDir, `${session}.completed`),
-    failedSignalPath: join(sessionDir, `${session}.failed`),
-    outputSignalPath: join(sessionDir, `${session}.output`),
-  };
-}
-
-export async function removeSignalIfExists(path: string): Promise<void> {
-  if (!existsSync(path)) return;
-  try {
-    await unlink(path);
-  } catch (error) {
-    const code = (error as NodeJS.ErrnoException).code;
-    if (code !== "ENOENT") {
-      throw error;
-    }
-  }
-}