libretto 0.6.9 → 0.6.11

package/dist/cli/core/daemon/spawn.js

@@ -0,0 +1,90 @@
+import { openSync, closeSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createRequire } from "node:module";
+import { spawn } from "node:child_process";
+import { getDaemonSocketPath } from "./ipc.js";
+import { DaemonClient } from "./ipc.js";
+const DEFAULT_IPC_TIMEOUT_MS = 1e4;
+const IPC_POLL_INTERVAL_MS = 250;
+async function spawnSessionDaemon(options) {
+  const {
+    config,
+    session,
+    logger,
+    logPath,
+    ipcTimeoutMs = DEFAULT_IPC_TIMEOUT_MS,
+    onFailure
+  } = options;
+  const daemonEntryPath = fileURLToPath(
+    new URL("./daemon.js", import.meta.url)
+  );
+  const require2 = createRequire(import.meta.url);
+  const tsxImportPath = pathToFileURL(require2.resolve("tsx/esm")).href;
+  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 });
+  let childSpawnError = null;
+  let childEarlyExit = 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 });
+  });
+  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++) {
+    const spawnError = childSpawnError;
+    if (spawnError !== null) {
+      await onFailure?.();
+      const errWithCode = spawnError;
+      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}`
+      );
+    }
+    const earlyExit = childEarlyExit;
+    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) {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+    }
+    await onFailure?.();
+    throw new Error(
+      `Daemon failed to start within ${Math.ceil(ipcTimeoutMs / 1e3)}s. Check logs: ${logPath}`
+    );
+  }
+  logger.info("daemon-ipc-ready", { session, socketPath });
+  return { pid, socketPath, client };
+}
+export {
+  spawnSessionDaemon
+};

package/dist/cli/core/exec-compiler.js

@@ -0,0 +1,111 @@
+import * as moduleBuiltin from "node:module";
+const stripTypeScriptTypes = moduleBuiltin.stripTypeScriptTypes;
+function withSuppressedStripTypeScriptWarning(action) {
+  const mutableProcess = process;
+  const originalEmitWarning = mutableProcess.emitWarning;
+  mutableProcess.emitWarning = (...args) => {
+    const warning = args[0];
+    const typeOrOptions = args[1];
+    const warningMessage = typeof warning === "string" ? warning : warning instanceof Error ? warning.message : "";
+    const warningType = typeof typeOrOptions === "string" ? typeOrOptions : typeof typeOrOptions === "object" && typeOrOptions !== null && "type" in typeOrOptions && typeof typeOrOptions.type === "string" ? typeOrOptions.type ?? "" : "";
+    if (warningType === "ExperimentalWarning" && warningMessage.includes("stripTypeScriptTypes")) {
+      return;
+    }
+    originalEmitWarning(...args);
+  };
+  try {
+    return action();
+  } finally {
+    mutableProcess.emitWarning = originalEmitWarning;
+  }
+}
+function compileTypeScriptExecFunction(code, helperNames) {
+  if (!stripTypeScriptTypes) return null;
+  const wrappedSource = `(async function __librettoExec(${helperNames.join(", ")}) {
+${code}
+})`;
+  const jsSource = withSuppressedStripTypeScriptWarning(
+    () => stripTypeScriptTypes(wrappedSource, { mode: "strip" })
+  );
+  const createFunction = new Function(
+    `return ${jsSource}`
+  );
+  return createFunction();
+}
+function compileExecFunction(code, helperNames) {
+  const typeStripped = compileTypeScriptExecFunction(code, helperNames);
+  if (typeStripped) return typeStripped;
+  const AsyncFunction = Object.getPrototypeOf(async function() {
+  }).constructor;
+  return new AsyncFunction(...helperNames, code);
+}
+function stripEmptyCatchHandlers(code) {
+  const catchRe = /\??\s*\.catch\(\s*\(\)\s*=>\s*\{\s*\}\s*\)/g;
+  let strippedCount = 0;
+  let result = "";
+  let i = 0;
+  while (i < code.length) {
+    if (code[i] === "/" && code[i + 1] === "/") {
+      const end = code.indexOf("\n", i);
+      const slice = end === -1 ? code.slice(i) : code.slice(i, end + 1);
+      result += slice;
+      i += slice.length;
+      continue;
+    }
+    if (code[i] === "/" && code[i + 1] === "*") {
+      const end = code.indexOf("*/", i + 2);
+      const slice = end === -1 ? code.slice(i) : code.slice(i, end + 2);
+      result += slice;
+      i += slice.length;
+      continue;
+    }
+    if (code[i] === '"' || code[i] === "'" || code[i] === "`") {
+      const quote = code[i];
+      let j = i + 1;
+      while (j < code.length) {
+        if (code[j] === "\\" && quote !== "`") {
+          j += 2;
+          continue;
+        }
+        if (code[j] === "\\" && quote === "`") {
+          j += 2;
+          continue;
+        }
+        if (code[j] === quote) {
+          j++;
+          break;
+        }
+        if (quote === "`" && code[j] === "$" && code[j + 1] === "{") {
+          let depth = 1;
+          j += 2;
+          while (j < code.length && depth > 0) {
+            if (code[j] === "{") depth++;
+            else if (code[j] === "}") depth--;
+            j++;
+          }
+          continue;
+        }
+        j++;
+      }
+      result += code.slice(i, j);
+      i = j;
+      continue;
+    }
+    catchRe.lastIndex = i;
+    const match = catchRe.exec(code);
+    if (match && match.index === i) {
+      strippedCount++;
+      i += match[0].length;
+      continue;
+    }
+    result += code[i];
+    i++;
+  }
+  return { cleaned: result, strippedCount };
+}
+export {
+  compileExecFunction,
+  compileTypeScriptExecFunction,
+  stripEmptyCatchHandlers,
+  withSuppressedStripTypeScriptWarning
+};

package/dist/cli/core/prompt.js

@@ -0,0 +1,72 @@
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+async function prompt(question, opts = {}) {
+  const rl = createInterface({ input: stdin, output: stdout });
+  try {
+    const display = opts.defaultValue ? `${question} (${opts.defaultValue}) ` : `${question} `;
+    const answer = (await rl.question(display)).trim();
+    if (answer.length === 0 && opts.defaultValue !== void 0) {
+      return opts.defaultValue;
+    }
+    return answer;
+  } finally {
+    rl.close();
+  }
+}
+const CTRL_C = "";
+const CR = "\r";
+const LF = "\n";
+const BACKSPACE = "\b";
+const DELETE = "\x7F";
+async function promptPassword(question) {
+  if (!stdin.isTTY) {
+    return prompt(question);
+  }
+  process.stdout.write(`${question} `);
+  return new Promise((resolve, reject) => {
+    let buffer = "";
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const cleanup = () => {
+      stdin.setRawMode(wasRaw);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+      process.stdout.write("\n");
+    };
+    const onData = (chunk) => {
+      for (const ch of chunk) {
+        if (ch === LF || ch === CR) {
+          cleanup();
+          resolve(buffer);
+          return;
+        }
+        if (ch === CTRL_C) {
+          cleanup();
+          reject(new Error("Aborted."));
+          return;
+        }
+        if (ch === BACKSPACE || ch === DELETE) {
+          if (buffer.length > 0) {
+            buffer = buffer.slice(0, -1);
+            process.stdout.write("\b \b");
+          }
+          continue;
+        }
+        if (ch.charCodeAt(0) < 32) continue;
+        buffer += ch;
+        process.stdout.write("*");
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+function slugify(name) {
+  return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+export {
+  prompt,
+  promptPassword,
+  slugify
+};

package/dist/cli/core/providers/libretto-cloud.js

@@ -1,15 +1,11 @@
+import { HOSTED_API_URL } from "../auth-fetch.js";
 function createLibrettoCloudProvider() {
   const apiKey = process.env.LIBRETTO_API_KEY;
   if (!apiKey)
     throw new Error(
       "LIBRETTO_API_KEY is required for the Libretto Cloud provider."
     );
-  const apiUrl = process.env.LIBRETTO_API_URL;
-  if (!apiUrl)
-    throw new Error(
-      "LIBRETTO_API_URL is required for the Libretto Cloud provider."
-    );
-  const endpoint = apiUrl.replace(/\/$/, "");
+  const endpoint = HOSTED_API_URL;
   return {
     async createSession() {
       const timeoutSeconds = Number(

package/dist/cli/core/readonly-exec.js

@@ -214,7 +214,7 @@ function createReadonlyExecHelpers(page, options = {}) {
         "fetch is blocked in readonly-exec; use get() instead"
       );
     },
-    console,
+    console: options.console ?? console,
     setTimeout,
     setInterval,
     clearTimeout,

package/dist/cli/router.js

@@ -1,4 +1,6 @@
 import { aiCommands } from "./commands/ai.js";
+import { authCommands } from "./commands/auth.js";
+import { billingCommands } from "./commands/billing.js";
 import { browserCommands } from "./commands/browser.js";
 import { deployCommand } from "./commands/deploy.js";
 import { executionCommands } from "./commands/execution.js";
@@ -11,6 +13,8 @@ const cliRoutes = {
   deploy: deployCommand,
   ...executionCommands,
   ai: aiCommands,
+  auth: authCommands,
+  billing: billingCommands,
   setup: setupCommand,
   status: statusCommand,
   snapshot: snapshotCommand

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

@@ -3,7 +3,6 @@ import { writeFile } from "node:fs/promises";
 import { cwd } from "node:process";
 import { isAbsolute, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
-import { loadEnv } from "../../shared/env/load-env.js";
 import {
   getDefaultWorkflowFromModuleExports,
   getWorkflowsFromModuleExports,
@@ -127,10 +126,6 @@ async function installHeadedWorkflowVisualization(args) {
 async function runIntegrationInternal(args, options) {
   const { logger } = options;
   const absolutePath = getAbsoluteIntegrationPath(args.integrationPath);
-  const envPath = loadEnv();
-  if (envPath) {
-    logger.info("loaded-env", { path: envPath });
-  }
   const workflow = await loadDefaultWorkflow(absolutePath);
   const signalPaths = getPauseSignalPaths(args.session);
   await removeSignalIfExists(signalPaths.pausedSignalPath);

package/dist/shared/state/session-state.d.ts

@@ -48,6 +48,7 @@ declare const SessionStateFileSchema: z.ZodObject<{
         name: z.ZodString;
         sessionId: z.ZodString;
     }, z.core.$strip>>;
+    daemonSocketPath: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type SessionStatus = z.infer<typeof SessionStatusSchema>;
 type SessionAccessMode = z.infer<typeof SessionAccessModeSchema>;

package/dist/shared/state/session-state.js

@@ -27,7 +27,8 @@ const SessionStateFileSchema = z.object({
   status: SessionStatusSchema.optional(),
   mode: SessionAccessModeSchema.default("write-access"),
   viewport: SessionViewportSchema.optional(),
-  provider: ProviderStateSchema.optional()
+  provider: ProviderStateSchema.optional(),
+  daemonSocketPath: z.string().optional()
 });
 function formatIssues(error) {
   return error.issues.map((issue) => {