libretto 0.5.3-experimental.5 → 0.5.3

package/dist/cli/commands/browser.js

@@ -2,17 +2,21 @@ import { z } from "zod";
 import {
   runClose as runCloseWithLogger,
   runCloseAll as runCloseAllWithLogger,
+  runConnect as runConnectWithLogger,
   runOpen,
   runPages,
   runSave
 } from "../core/browser.js";
-import { withSessionLogger } from "../core/context.js";
-import { assertSessionAvailableForStart } from "../core/session.js";
+import { createLoggerForSession, withSessionLogger } from "../core/context.js";
+import {
+  assertSessionAvailableForStart,
+  validateSessionName
+} from "../core/session.js";
 import { SimpleCLI } from "../framework/simple-cli.js";
 import {
-  loadSessionStateMiddleware,
-  resolveSessionMiddleware,
-  sessionOption
+  sessionOption,
+  withAutoSession,
+  withRequiredSession
 } from "./shared.js";
 function parseViewportArg(viewportArg) {
   if (!viewportArg) return void 0;
@@ -52,16 +56,32 @@ const openInput = SimpleCLI.input({
   (input) => !(input.headed && input.headless),
   "Cannot pass both --headed and --headless."
 );
-function createOpenCommand(logger) {
-  return SimpleCLI.command({
-    description: "Launch browser and open URL (headed by default)"
-  }).input(openInput).use(resolveSessionMiddleware).handle(async ({ input, ctx }) => {
-    assertSessionAvailableForStart(ctx.session, logger);
-    const headed = input.headed || !input.headless;
-    const viewport = parseViewportArg(input.viewport);
-    await runOpen(input.url, headed, ctx.session, logger, { viewport });
-  });
-}
+const openCommand = SimpleCLI.command({
+  description: "Launch browser and open URL (headed by default)"
+}).input(openInput).use(withAutoSession()).handle(async ({ input, ctx }) => {
+  assertSessionAvailableForStart(ctx.session, ctx.logger);
+  const headed = input.headed || !input.headless;
+  const viewport = parseViewportArg(input.viewport);
+  await runOpen(input.url, headed, ctx.session, ctx.logger, { viewport });
+});
+const connectInput = SimpleCLI.input({
+  positionals: [
+    SimpleCLI.positional("cdpUrl", z.string().optional(), {
+      help: "CDP endpoint URL (e.g. http://127.0.0.1:9222)"
+    })
+  ],
+  named: {
+    session: sessionOption()
+  }
+}).refine(
+  (input) => Boolean(input.cdpUrl),
+  `Usage: libretto connect <cdp-url> --session <name>`
+);
+const connectCommand = SimpleCLI.command({
+  description: "Connect to an existing Chrome DevTools Protocol (CDP) endpoint"
+}).input(connectInput).use(withAutoSession()).handle(async ({ input, ctx }) => {
+  await runConnectWithLogger(input.cdpUrl, ctx.session, ctx.logger);
+});
 const saveInput = SimpleCLI.input({
   positionals: [
     SimpleCLI.positional("urlOrDomain", z.string().optional(), {
@@ -73,72 +93,79 @@ const saveInput = SimpleCLI.input({
   }
 }).refine(
   (input) => Boolean(input.urlOrDomain),
-  `Usage: libretto save <url|domain> [--session <name>]`
+  `Usage: libretto save <url|domain> --session <name>`
 );
-function createSaveCommand(logger) {
-  return SimpleCLI.command({
-    description: "Save current browser session"
-  }).input(saveInput).use(resolveSessionMiddleware).use(loadSessionStateMiddleware).handle(async ({ input, ctx }) => {
-    await runSave(input.urlOrDomain, ctx.session, logger);
-  });
-}
+const saveCommand = SimpleCLI.command({
+  description: "Save current browser session"
+}).input(saveInput).use(withRequiredSession()).handle(async ({ input, ctx }) => {
+  await runSave(input.urlOrDomain, ctx.session, ctx.logger);
+});
 const pagesInput = SimpleCLI.input({
   positionals: [],
   named: {
     session: sessionOption()
   }
 });
-function createPagesCommand(logger) {
-  return SimpleCLI.command({
-    description: "List open pages in the session"
-  }).input(pagesInput).use(resolveSessionMiddleware).use(loadSessionStateMiddleware).handle(async ({ ctx }) => {
-    await runPages(ctx.session, logger);
-  });
-}
+const pagesCommand = SimpleCLI.command({
+  description: "List open pages in the session"
+}).input(pagesInput).use(withRequiredSession()).handle(async ({ ctx }) => {
+  await runPages(ctx.session, ctx.logger);
+});
 const closeInput = SimpleCLI.input({
   positionals: [],
   named: {
     session: sessionOption(),
-    all: SimpleCLI.flag({ help: "Close all tracked sessions in this workspace" }),
-    force: SimpleCLI.flag({ help: "Force kill sessions that ignore SIGTERM (requires --all)" })
+    all: SimpleCLI.flag({
+      help: "Close all tracked sessions in this workspace"
+    }),
+    force: SimpleCLI.flag({
+      help: "Force kill sessions that ignore SIGTERM (requires --all)"
+    })
+  }
+}).refine(
+  (input) => input.all || input.session,
+  `Usage: libretto close --session <name>
+Usage: libretto close --all [--force]`
+);
+const closeCommand = SimpleCLI.command({
+  description: "Close the browser"
+}).input(closeInput).handle(async ({ input }) => {
+  if (input.force && !input.all) {
+    throw new Error(`Usage: libretto close --all [--force]`);
   }
+  if (input.all) {
+    const logger2 = createLoggerForSession("cli");
+    await runCloseAllWithLogger(logger2, { force: input.force });
+    return;
+  }
+  validateSessionName(input.session);
+  const logger = createLoggerForSession(input.session);
+  await runCloseWithLogger(input.session, logger);
 });
-function createCloseCommand(logger) {
-  return SimpleCLI.command({
-    description: "Close the browser"
-  }).input(closeInput).use(resolveSessionMiddleware).handle(async ({ input, ctx }) => {
-    if (input.force && !input.all) {
-      throw new Error(`Usage: libretto close --all [--force]`);
-    }
-    if (input.all) {
-      await runCloseAllWithLogger(logger, { force: input.force });
-      return;
-    }
-    await runCloseWithLogger(ctx.session, logger);
-  });
-}
-function createBrowserCommands(logger) {
-  return {
-    open: createOpenCommand(logger),
-    save: createSaveCommand(logger),
-    pages: createPagesCommand(logger),
-    close: createCloseCommand(logger)
-  };
-}
+const browserCommands = {
+  open: openCommand,
+  connect: connectCommand,
+  save: saveCommand,
+  pages: pagesCommand,
+  close: closeCommand
+};
 async function runClose(session) {
   await withSessionLogger(session, async (logger) => {
     await runCloseWithLogger(session, logger);
   });
 }
 export {
+  browserCommands,
+  closeCommand,
   closeInput,
-  createBrowserCommands,
-  createCloseCommand,
-  createOpenCommand,
-  createPagesCommand,
-  createSaveCommand,
+  connectCommand,
+  connectInput,
+  openCommand,
   openInput,
+  pagesCommand,
   pagesInput,
+  parseViewportArg,
   runClose,
+  saveCommand,
   saveInput
 };

package/dist/cli/commands/deploy.js

@@ -0,0 +1,148 @@
+import { randomBytes } from "node:crypto";
+import { z } from "zod";
+import { buildHostedDeployTarball } from "../core/deploy-artifact.js";
+import { SimpleCLI } from "../framework/simple-cli.js";
+function generateDeploymentName() {
+  return `deploy-${Date.now().toString(36)}-${randomBytes(4).toString("hex")}`;
+}
+function getConfig() {
+  const apiUrl = process.env.LIBRETTO_API_URL;
+  const apiKey = process.env.LIBRETTO_API_KEY;
+  if (!apiUrl) {
+    throw new Error(
+      "LIBRETTO_API_URL environment variable is required."
+    );
+  }
+  if (!apiKey) {
+    throw new Error(
+      "LIBRETTO_API_KEY environment variable is required."
+    );
+  }
+  return { apiUrl: apiUrl.replace(/\/$/, ""), apiKey };
+}
+async function postJson(apiUrl, apiKey, path, input = {}) {
+  return fetch(`${apiUrl}${path}`, {
+    method: "POST",
+    headers: {
+      "x-api-key": apiKey,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ json: input })
+  });
+}
+async function pollDeployment(apiUrl, apiKey, deploymentId, pollIntervalMs, maxWaitMs) {
+  const start = Date.now();
+  let status = "building";
+  let deployment;
+  while (status === "building" && Date.now() - start < maxWaitMs) {
+    await new Promise((r) => setTimeout(r, pollIntervalMs));
+    const res = await postJson(apiUrl, apiKey, "/v1/deployments/get", {
+      id: deploymentId
+    });
+    const body = await res.json();
+    if (res.status !== 200) {
+      throw new Error(
+        `Failed to get deployment status (${res.status}): ${JSON.stringify(body)}`
+      );
+    }
+    status = body.json.status;
+    deployment = body.json;
+    process.stdout.write(".");
+  }
+  console.log();
+  if (!deployment) {
+    throw new Error("Deployment timed out before receiving a status update.");
+  }
+  return deployment;
+}
+const deployInput = SimpleCLI.input({
+  positionals: [
+    SimpleCLI.positional("sourceDir", z.string().default("."), {
+      help: "Path to source directory (default: current directory)"
+    })
+  ],
+  named: {
+    description: SimpleCLI.option(z.string().optional(), {
+      help: "Deployment description"
+    }),
+    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 keep out of the bundle and install into the deployed package"
+      }
+    )
+  }
+});
+const deployCommand = SimpleCLI.command({
+  description: "Deploy workflows to the hosted platform",
+  experimental: true
+}).input(deployInput).handle(async ({ input }) => {
+  const { apiUrl, apiKey } = getConfig();
+  const deploymentName = generateDeploymentName();
+  console.log("Bundling hosted deployment artifact...");
+  const { entryPoint, source } = await buildHostedDeployTarball({
+    additionalExternals: input.external,
+    deploymentName,
+    entryPoint: input.entryPoint,
+    sourceDir: input.sourceDir
+  });
+  const createPayload = {
+    source,
+    entry_point: entryPoint
+  };
+  if (input.description) createPayload.description = input.description;
+  console.log("Uploading deployment...");
+  const res = await postJson(
+    apiUrl,
+    apiKey,
+    "/v1/deployments/create",
+    createPayload
+  );
+  const body = await res.json();
+  if (res.status !== 200) {
+    throw new Error(
+      `Failed to create deployment (${res.status}): ${JSON.stringify(body)}`
+    );
+  }
+  const { deployment_id, status } = body.json;
+  console.log(`Deployment created: ${deployment_id}`);
+  console.log(`Status: ${status}`);
+  if (status === "building") {
+    process.stdout.write("Waiting for build");
+    const deployment = await pollDeployment(
+      apiUrl,
+      apiKey,
+      deployment_id,
+      1e4,
+      5 * 60 * 1e3
+    );
+    if (deployment.status === "failed") {
+      throw new Error(
+        `Build failed: ${deployment.build_error ?? "unknown error"}`
+      );
+    }
+    if (deployment.status === "ready") {
+      console.log(`Build complete.`);
+      if (deployment.workflows?.length) {
+        console.log(
+          `Workflows: ${deployment.workflows.join(", ")}`
+        );
+      }
+    } else {
+      console.log(
+        `Build still in progress (timed out waiting). Check status with deployment ID: ${deployment_id}`
+      );
+    }
+  }
+  return deployment_id;
+});
+export {
+  deployCommand,
+  deployInput
+};