libretto 0.6.11 → 0.6.12

package/dist/shared/ipc/ipc.spec.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/shared/ipc/ipc.spec.js

@@ -0,0 +1,114 @@
+import { EventEmitter } from "node:events";
+import { expect, test as base } from "vitest";
+import {
+  createIpcPeer
+} from "./ipc.js";
+const test = base.extend({
+  peers: async ({}, use) => {
+    const channel = new EventEmitter();
+    const a = createIpcPeer({
+      send(message) {
+        channel.emit("b", message);
+      },
+      listen(callback) {
+        channel.on("a", callback);
+        return () => channel.off("a", callback);
+      }
+    }, {
+      greet(name) {
+        return `hello ${name}`;
+      }
+    });
+    const b = createIpcPeer({
+      send(message) {
+        channel.emit("a", message);
+      },
+      listen(callback) {
+        channel.on("b", callback);
+        return () => channel.off("b", callback);
+      }
+    }, {
+      async add(left, right) {
+        return left + right;
+      },
+      async fail() {
+        throw new Error("expected failure");
+      },
+      async failWithCause() {
+        throw new Error("outer failure", {
+          cause: new Error("inner failure", {
+            cause: new TypeError("root failure")
+          })
+        });
+      },
+      async failWithCode() {
+        const error = new Error("coded failure");
+        error.code = "ERR_EXPECTED";
+        throw error;
+      },
+      async failWithNonError() {
+        throw "plain failure";
+      },
+      async wait() {
+        return new Promise(() => {
+        });
+      }
+    });
+    await use({ a, b });
+    a.destroy();
+    b.destroy();
+  },
+  a: async ({ peers }, use) => {
+    await use(peers.a);
+  },
+  b: async ({ peers }, use) => {
+    await use(peers.b);
+  }
+});
+test("calls handlers on the remote peer", async ({ a, b }) => {
+  await expect(a.call.add(2, 3)).resolves.toBe(5);
+  await expect(b.call.greet("Ada")).resolves.toBe("hello Ada");
+});
+test("rejects with the remote handler error", async ({ a }) => {
+  await expect(a.call.fail()).rejects.toThrow("fail > expected failure");
+});
+test("rejects with the remote handler error cause chain", async ({ a }) => {
+  const error = await getRejectedError(a.call.failWithCause());
+  expect(error.message).toBe("failWithCause > outer failure");
+  expect(error.stack).toContain("outer failure");
+  const cause = getErrorCause(error);
+  expect(cause.message).toBe("inner failure");
+  const rootCause = getErrorCause(cause);
+  expect(rootCause.name).toBe("TypeError");
+  expect(rootCause.message).toBe("root failure");
+});
+test("rejects with the remote handler error code", async ({ a }) => {
+  const error = await getRejectedError(a.call.failWithCode());
+  expect(error.message).toBe("failWithCode > coded failure");
+  expect(error.code).toBe("ERR_EXPECTED");
+  expect(error.stack).toContain("coded failure");
+});
+test("rejects with a serialized non-error thrown value", async ({ a }) => {
+  const error = await getRejectedError(a.call.failWithNonError());
+  expect(error.name).toBe("NonError");
+  expect(error.message).toBe("failWithNonError > plain failure");
+  expect(error.stack).toContain("failWithNonError");
+});
+test("rejects pending calls when destroyed", async ({ a }) => {
+  const result = a.call.wait();
+  a.destroy();
+  await expect(result).rejects.toThrow("IPC peer destroyed");
+});
+async function getRejectedError(promise) {
+  try {
+    await promise;
+  } catch (error) {
+    expect(error).toBeInstanceOf(Error);
+    return error;
+  }
+  throw new Error("Expected promise to reject");
+}
+function getErrorCause(error) {
+  expect(error.cause).toBeInstanceOf(Error);
+  return error.cause;
+}

package/dist/shared/ipc/socket-transport.d.ts

@@ -0,0 +1,9 @@
+import { Server } from 'node:net';
+import { IpcTransport, IpcProtocolMessage } from './ipc.js';
+
+declare function connectToIpcSocket(socketPath: string): Promise<IpcTransport<IpcProtocolMessage>>;
+declare function createIpcSocketServer(onConnection: (transport: IpcTransport<IpcProtocolMessage>) => void): Server;
+declare function listenForIpcConnections(socketPath: string, onConnection: (transport: IpcTransport<IpcProtocolMessage>) => void): Promise<Server>;
+declare function listenOnIpcSocket(server: Server, socketPath: string): Promise<void>;
+
+export { connectToIpcSocket, createIpcSocketServer, listenForIpcConnections, listenOnIpcSocket };

package/dist/shared/ipc/socket-transport.js

@@ -0,0 +1,143 @@
+import { rm } from "node:fs/promises";
+import {
+  createServer,
+  createConnection
+} from "node:net";
+import { dirname } from "node:path";
+import { mkdir } from "node:fs/promises";
+function createJsonSocketTransport(socket) {
+  socket.setEncoding("utf8");
+  return {
+    send(message) {
+      return new Promise((resolve, reject) => {
+        const line = `${JSON.stringify(message)}
+`;
+        socket.write(line, (error) => {
+          if (error) reject(error);
+          else resolve();
+        });
+      });
+    },
+    listen(callback) {
+      let buffer = "";
+      const onData = (chunk) => {
+        buffer += chunk;
+        while (true) {
+          const newlineIndex = buffer.indexOf("\n");
+          if (newlineIndex === -1) break;
+          const line = buffer.slice(0, newlineIndex);
+          buffer = buffer.slice(newlineIndex + 1);
+          if (line.length === 0) continue;
+          let message;
+          try {
+            message = JSON.parse(line);
+          } catch (error) {
+            socket.destroy(
+              new Error(
+                `Invalid IPC socket message: ${error instanceof Error ? error.message : String(error)}`
+              )
+            );
+            return;
+          }
+          if (!isIpcProtocolMessage(message)) {
+            socket.destroy(new Error("Invalid IPC socket protocol message."));
+            return;
+          }
+          callback(message);
+        }
+      };
+      socket.on("data", onData);
+      return () => socket.off("data", onData);
+    },
+    onClose(callback) {
+      let closeError;
+      const onError = (error) => {
+        closeError = error;
+      };
+      const onClose = () => callback(closeError);
+      socket.on("error", onError);
+      socket.on("close", onClose);
+      return () => {
+        socket.off("error", onError);
+        socket.off("close", onClose);
+      };
+    },
+    close() {
+      socket.destroy();
+    }
+  };
+}
+async function connectToIpcSocket(socketPath) {
+  const socket = await connectSocket(socketPath);
+  return createJsonSocketTransport(socket);
+}
+function createIpcSocketServer(onConnection) {
+  return createServer((socket) => {
+    onConnection(createJsonSocketTransport(socket));
+  });
+}
+async function listenForIpcConnections(socketPath, onConnection) {
+  const server = createIpcSocketServer(onConnection);
+  await listenOnIpcSocket(server, socketPath);
+  return server;
+}
+async function listenOnIpcSocket(server, socketPath) {
+  await mkdir(dirname(socketPath), { recursive: true });
+  await rm(socketPath, { force: true });
+  const originalClose = server.close.bind(server);
+  server.close = ((callback) => {
+    return originalClose((error) => {
+      void rm(socketPath, { force: true }).finally(() => callback?.(error));
+    });
+  });
+  await new Promise((resolve, reject) => {
+    const onError = (error) => {
+      server.off("listening", onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(socketPath);
+  });
+}
+async function connectSocket(socketPath) {
+  const socket = createConnection(socketPath);
+  return new Promise((resolve, reject) => {
+    const onError = (error) => {
+      socket.off("connect", onConnect);
+      reject(error);
+    };
+    const onConnect = () => {
+      socket.off("error", onError);
+      resolve(socket);
+    };
+    socket.once("error", onError);
+    socket.once("connect", onConnect);
+  });
+}
+function isIpcProtocolMessage(message) {
+  if (!isRecord(message)) return false;
+  if (message.type === "ipc-request") {
+    return typeof message.id === "string" && typeof message.method === "string" && Array.isArray(message.args);
+  }
+  if (message.type === "ipc-response") {
+    return typeof message.id === "string" && typeof message.method === "string" && (message.error === void 0 || isSerializedError(message.error));
+  }
+  return false;
+}
+function isSerializedError(value) {
+  return isRecord(value) && typeof value.name === "string" && typeof value.message === "string" && (value.stack === void 0 || typeof value.stack === "string");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+export {
+  connectToIpcSocket,
+  createIpcSocketServer,
+  listenForIpcConnections,
+  listenOnIpcSocket
+};

package/dist/shared/ipc/socket-transport.spec.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/shared/ipc/socket-transport.spec.js

@@ -0,0 +1,117 @@
+import { mkdtemp, stat, writeFile } from "node:fs/promises";
+import { createConnection } from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { expect, test as base } from "vitest";
+import { createIpcPeer } from "./ipc.js";
+import {
+  connectToIpcSocket,
+  listenForIpcConnections
+} from "./socket-transport.js";
+const test = base.extend({
+  socketPath: async ({}, use) => {
+    const directory = await mkdtemp(join(tmpdir(), "libretto-ipc-"));
+    await use(join(directory, "daemon.sock"));
+  }
+});
+test("sends concurrent calls over one socket", async ({ socketPath }) => {
+  await writeFile(socketPath, "stale");
+  const serverPeers = [];
+  const server = await listenForIpcConnections(socketPath, (transport) => {
+    serverPeers.push(
+      createIpcPeer(transport, {
+        async double(value) {
+          return value * 2;
+        },
+        async wait() {
+          return "done";
+        }
+      })
+    );
+  });
+  const client = createIpcPeer(
+    await connectToIpcSocket(socketPath),
+    {
+      ping() {
+        return "pong";
+      }
+    }
+  );
+  await expect(
+    Promise.all([client.call.double(2), client.call.double(21)])
+  ).resolves.toEqual([4, 42]);
+  client.destroy();
+  for (const peer of serverPeers) peer.destroy();
+  await new Promise((resolve, reject) => {
+    server.close((error) => error ? reject(error) : resolve());
+  });
+  await expect(stat(socketPath)).rejects.toThrow();
+});
+test("rejects pending calls when the socket closes", async ({ socketPath }) => {
+  const serverPeers = [];
+  const server = await listenForIpcConnections(socketPath, (transport) => {
+    serverPeers.push(
+      createIpcPeer(transport, {
+        async double(value) {
+          return value * 2;
+        },
+        async wait() {
+          return new Promise(() => {
+          });
+        }
+      })
+    );
+  });
+  const client = createIpcPeer(
+    await connectToIpcSocket(socketPath),
+    {
+      ping() {
+        return "pong";
+      }
+    }
+  );
+  const pending = client.call.wait();
+  for (const peer of serverPeers) peer.destroy();
+  await expect(pending).rejects.toThrow(/IPC transport closed|ECONNRESET/);
+  client.destroy();
+  await new Promise((resolve, reject) => {
+    server.close((error) => error ? reject(error) : resolve());
+  });
+});
+test("closes malformed socket messages without stopping the server", async ({
+  socketPath
+}) => {
+  const server = await listenForIpcConnections(socketPath, (transport) => {
+    createIpcPeer(transport, {
+      async double(value) {
+        return value * 2;
+      },
+      async wait() {
+        return "done";
+      }
+    });
+  });
+  const malformedClient = createConnection(socketPath);
+  await new Promise((resolve, reject) => {
+    malformedClient.once("connect", resolve);
+    malformedClient.once("error", reject);
+  });
+  const malformedClosed = new Promise((resolve) => {
+    malformedClient.once("close", () => resolve());
+  });
+  malformedClient.write("not-json\n");
+  await malformedClosed;
+  const validClient = createIpcPeer(
+    await connectToIpcSocket(socketPath),
+    {
+      ping() {
+        return "pong";
+      }
+    }
+  );
+  await expect(validClient.call.double(4)).resolves.toBe(8);
+  validClient.destroy();
+  await new Promise((resolve, reject) => {
+    server.close((error) => error ? reject(error) : resolve());
+  });
+});

package/dist/shared/package-manager.d.ts

@@ -0,0 +1,7 @@
+type PackageManager = "npm" | "pnpm" | "yarn" | "bun";
+declare function detectPackageManager(root?: string, env?: NodeJS.ProcessEnv): PackageManager;
+declare function detectProjectPackageManager(root?: string): PackageManager;
+declare function installCommand(packageManager?: PackageManager): string;
+declare function librettoCommand(args?: string, packageManager?: PackageManager): string;
+
+export { type PackageManager, detectPackageManager, detectProjectPackageManager, installCommand, librettoCommand };

package/dist/shared/package-manager.js

@@ -0,0 +1,60 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { resolveLibrettoRepoRoot } from "./paths/repo-root.js";
+function packageManagerFromUserAgent(env = process.env) {
+  const userAgent = env.npm_config_user_agent ?? "";
+  if (userAgent.startsWith("pnpm")) return "pnpm";
+  if (userAgent.startsWith("yarn")) return "yarn";
+  if (userAgent.startsWith("bun")) return "bun";
+  if (userAgent.startsWith("npm")) return "npm";
+  return null;
+}
+function packageManagerFromLockfile(root) {
+  if (existsSync(join(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(root, "yarn.lock"))) return "yarn";
+  if (existsSync(join(root, "bun.lockb")) || existsSync(join(root, "bun.lock")))
+    return "bun";
+  return null;
+}
+function detectPackageManager(root = resolveLibrettoRepoRoot(), env = process.env) {
+  const fromUserAgent = packageManagerFromUserAgent(env);
+  if (fromUserAgent) return fromUserAgent;
+  return packageManagerFromLockfile(root) ?? "npm";
+}
+function detectProjectPackageManager(root = resolveLibrettoRepoRoot()) {
+  return packageManagerFromLockfile(root) ?? "npm";
+}
+function installCommand(packageManager = detectProjectPackageManager()) {
+  switch (packageManager) {
+    case "yarn":
+      return "yarn add";
+    case "bun":
+      return "bun add";
+    case "pnpm":
+      return "pnpm add";
+    default:
+      return "npm install";
+  }
+}
+function librettoRunner(packageManager = detectPackageManager()) {
+  switch (packageManager) {
+    case "pnpm":
+      return "pnpm exec";
+    case "yarn":
+      return "yarn";
+    case "bun":
+      return "bunx";
+    default:
+      return "npx";
+  }
+}
+function librettoCommand(args = "", packageManager = detectPackageManager()) {
+  const suffix = args.trim();
+  return `${librettoRunner(packageManager)} libretto${suffix ? ` ${suffix}` : ""}`;
+}
+export {
+  detectPackageManager,
+  detectProjectPackageManager,
+  installCommand,
+  librettoCommand
+};

package/dist/shared/paths/paths.d.ts

@@ -1,10 +1,3 @@
-declare function getLibrettoPauseSignalDir(sessionName: string, cwd?: string): string;
-declare function getRunnerLogPathForDir(logDir: string): string;
-declare function getPauseSignalPathForDir(signalDir: string, sessionName: string, signal: "paused" | "resume"): string;
-declare function getLibrettoPausedSignalPath(sessionName: string, cwd?: string): string;
-declare function getLibrettoResumeSignalPath(sessionName: string, cwd?: string): string;
 declare function ensureLibrettoSessionStatePath(sessionName: string, cwd?: string): string;
-declare function ensureLibrettoPauseSignalDir(sessionName: string, cwd?: string): string;
-declare function ensureLibrettoRunnerLogDir(sessionName: string, cwd?: string): string;
 
-export { ensureLibrettoPauseSignalDir, ensureLibrettoRunnerLogDir, ensureLibrettoSessionStatePath, getLibrettoPauseSignalDir, getLibrettoPausedSignalPath, getLibrettoResumeSignalPath, getPauseSignalPathForDir, getRunnerLogPathForDir };
+export { ensureLibrettoSessionStatePath };

package/dist/shared/paths/paths.js

@@ -4,10 +4,6 @@ import { resolveLibrettoRepoRoot } from "./repo-root.js";
 const LIBRETTO_DIRNAME = ".libretto";
 const LIBRETTO_SESSIONS_DIRNAME = "sessions";
 const SESSION_STATE_FILENAME = "state.json";
-const RUNNER_LOG_DIRNAME = "logs";
-const RUNNER_LOG_FILENAME = "logs.jsonl";
-const PAUSED_SIGNAL_SUFFIX = "paused";
-const RESUME_SIGNAL_SUFFIX = "resume";
 function getLibrettoRoot(cwd = process.cwd()) {
   return join(resolveLibrettoRepoRoot(cwd), LIBRETTO_DIRNAME);
 }
@@ -20,55 +16,11 @@ function getLibrettoSessionDir(sessionName, cwd = process.cwd()) {
 function getLibrettoSessionStatePath(sessionName, cwd = process.cwd()) {
   return join(getLibrettoSessionDir(sessionName, cwd), SESSION_STATE_FILENAME);
 }
-function getLibrettoPauseSignalDir(sessionName, cwd = process.cwd()) {
-  return getLibrettoSessionDir(sessionName, cwd);
-}
-function getLibrettoRunnerLogDir(sessionName, cwd = process.cwd()) {
-  return join(getLibrettoSessionDir(sessionName, cwd), RUNNER_LOG_DIRNAME);
-}
-function getRunnerLogPathForDir(logDir) {
-  return join(logDir, RUNNER_LOG_FILENAME);
-}
-function getPauseSignalPathForDir(signalDir, sessionName, signal) {
-  const suffix = signal === "paused" ? PAUSED_SIGNAL_SUFFIX : RESUME_SIGNAL_SUFFIX;
-  return join(signalDir, `${sessionName}.${suffix}`);
-}
-function getLibrettoPausedSignalPath(sessionName, cwd = process.cwd()) {
-  return getPauseSignalPathForDir(
-    getLibrettoPauseSignalDir(sessionName, cwd),
-    sessionName,
-    "paused"
-  );
-}
-function getLibrettoResumeSignalPath(sessionName, cwd = process.cwd()) {
-  return getPauseSignalPathForDir(
-    getLibrettoPauseSignalDir(sessionName, cwd),
-    sessionName,
-    "resume"
-  );
-}
 function ensureLibrettoSessionStatePath(sessionName, cwd = process.cwd()) {
   const filePath = getLibrettoSessionStatePath(sessionName, cwd);
   mkdirSync(dirname(filePath), { recursive: true });
   return filePath;
 }
-function ensureLibrettoPauseSignalDir(sessionName, cwd = process.cwd()) {
-  const dir = getLibrettoPauseSignalDir(sessionName, cwd);
-  mkdirSync(dir, { recursive: true });
-  return dir;
-}
-function ensureLibrettoRunnerLogDir(sessionName, cwd = process.cwd()) {
-  const dir = getLibrettoRunnerLogDir(sessionName, cwd);
-  mkdirSync(dir, { recursive: true });
-  return dir;
-}
 export {
-  ensureLibrettoPauseSignalDir,
-  ensureLibrettoRunnerLogDir,
-  ensureLibrettoSessionStatePath,
-  getLibrettoPauseSignalDir,
-  getLibrettoPausedSignalPath,
-  getLibrettoResumeSignalPath,
-  getPauseSignalPathForDir,
-  getRunnerLogPathForDir
+  ensureLibrettoSessionStatePath
 };

package/dist/shared/snapshot/capture-snapshot.d.ts

@@ -0,0 +1,9 @@
+import { Page } from 'playwright';
+import { Snapshot, SnapshotNode } from './types.js';
+export { SnapshotAvailableFrame, SnapshotFrame, SnapshotPrimitive, SnapshotUnavailableFrame } from './types.js';
+
+declare function snapshot(page: Page): Promise<Snapshot>;
+declare function findSnapshotNodeByRef(snapshotTree: Snapshot, ref: string): SnapshotNode;
+declare function scopeSnapshotToRef(snapshotTree: Snapshot, ref: string): Snapshot;
+
+export { Snapshot, SnapshotNode, findSnapshotNodeByRef, scopeSnapshotToRef, snapshot };