opensteer 0.8.9 → 0.8.11

package/dist/cli/bin.js

@@ -1,15 +1,16 @@
 #!/usr/bin/env node
-import { assertProviderSupportsEngine, createOpensteerSemanticRuntime, OpensteerBrowserManager, dispatchSemanticOperation, loadEnvironment, normalizeOpensteerProviderMode, discoverLocalCdpBrowsers, inspectCdpEndpoint, resolveOpensteerRuntimeConfig, resolveOpensteerEngineName, resolveOpensteerProvider, resolveFilesystemWorkspacePath, pathExists, readPersistedLocalBrowserSessionRecord, readPersistedCloudSessionRecord, OpensteerCloudClient, isProcessRunning } from '../chunk-RO6WAWWG.js';
+import { assertProviderSupportsEngine, createOpensteerSemanticRuntime, OpensteerBrowserManager, dispatchSemanticOperation, loadEnvironment, normalizeOpensteerProviderMode, discoverLocalCdpBrowsers, inspectCdpEndpoint, resolveOpensteerRuntimeConfig, resolveOpensteerEngineName, resolveOpensteerProvider, resolveFilesystemWorkspacePath, CloudSessionProxy, FlowRecorderCollector, generateReplayScript, pathExists, readPersistedLocalBrowserSessionRecord, readPersistedCloudSessionRecord, OpensteerCloudClient, isProcessRunning } from '../chunk-33FDEOQY.js';
 import process2 from 'process';
 import { spawn } from 'child_process';
 import { existsSync } from 'fs';
 import path from 'path';
 import { createRequire } from 'module';
 import { fileURLToPath } from 'url';
+import { mkdir, writeFile } from 'fs/promises';
 
 // package.json
 var package_default = {
-  version: "0.8.8"};
+  version: "0.8.10"};
 
 // src/cli/env-loader.ts
 async function loadCliEnvironment(cwd) {
@@ -214,9 +215,11 @@ async function describeCloudLane(input) {
     status: "connected",
     current: input.current,
     summary: input.record.sessionId,
-    detail: input.record.baseUrl,
     sessionId: input.record.sessionId,
-    baseUrl: input.record.baseUrl
+    ...input.cloudConfig === void 0 ? {} : {
+      detail: input.cloudConfig.baseUrl,
+      baseUrl: input.cloudConfig.baseUrl
+    }
   };
   if (input.cloudConfig === void 0) {
     return base;
@@ -260,6 +263,214 @@ function formatLaneRow(input) {
   const summary = input.summary.padEnd(16, " ");
   return `${input.marker} ${provider} ${status} ${summary}${input.detail ?? ""}`.trimEnd();
 }
+async function runOpensteerRecordCommand(input) {
+  const stdout = input.stdout ?? process.stdout;
+  const stderr = input.stderr ?? process.stderr;
+  const outputPath = resolveRecordOutputPath({
+    rootDir: input.rootDir,
+    workspace: input.workspace,
+    ...input.outputPath === void 0 ? {} : { outputPath: input.outputPath }
+  });
+  const runtime = input.runtime;
+  const collector = new FlowRecorderCollector(createRecorderRuntimeAdapter(runtime), {
+    ...input.pollIntervalMs === void 0 ? {} : { pollIntervalMs: input.pollIntervalMs },
+    onAction: (action) => {
+      stderr.write(`${formatRecordedAction(action)}
+`);
+    }
+  });
+  stderr.write(
+    `Recording browser actions for workspace "${input.workspace}". Click "Stop recording" in the browser when you're done.
+`
+  );
+  let closed = false;
+  try {
+    const opened = await runtime.open({
+      url: input.url
+    });
+    await collector.install();
+    collector.start();
+    await collector.waitForStop();
+    const actions = await collector.stop();
+    const script = generateReplayScript({
+      actions,
+      workspace: input.workspace,
+      startUrl: opened.url
+    });
+    await mkdir(path.dirname(outputPath), { recursive: true });
+    await writeFile(outputPath, script, "utf8");
+    if (input.closeSession !== void 0) {
+      await input.closeSession();
+      closed = true;
+    }
+    stdout.write(`${outputPath}
+`);
+    stderr.write(`Wrote replay script to ${outputPath}
+`);
+  } finally {
+    if (!closed) {
+      await runtime.disconnect().catch(() => void 0);
+    }
+  }
+}
+async function runOpensteerCloudRecordCommand(input) {
+  const stdout = input.stdout ?? process.stdout;
+  const stderr = input.stderr ?? process.stderr;
+  const outputPath = resolveRecordOutputPath({
+    rootDir: input.rootDir,
+    workspace: input.workspace,
+    ...input.outputPath === void 0 ? {} : { outputPath: input.outputPath }
+  });
+  let cloud;
+  const resolveCloud = () => {
+    cloud ??= new OpensteerCloudClient(input.cloudConfig);
+    return cloud;
+  };
+  const runtime = input.runtime ?? new CloudSessionProxy(resolveCloud(), {
+    rootDir: input.rootDir,
+    workspace: input.workspace
+  });
+  const client = input.client ?? resolveCloud();
+  const sleep = input.sleep ?? delay;
+  let closed = false;
+  try {
+    await runtime.open({
+      url: input.url,
+      ...input.browser === void 0 ? {} : { browser: input.browser },
+      ...input.launch === void 0 ? {} : { launch: input.launch },
+      ...input.context === void 0 ? {} : { context: input.context }
+    });
+    const sessionId = await resolveCloudRecordingSessionId(runtime);
+    const sessionUrl = buildCloudRecordingSessionUrl(input.cloudConfig, sessionId);
+    await client.startSessionRecording(sessionId);
+    stderr.write(
+      `Recording browser actions for workspace "${input.workspace}". Open ${sessionUrl} and click "Stop recording" in the browser session toolbar when you're done.
+`
+    );
+    const completed = await waitForCloudRecordingCompletion({
+      client,
+      sessionId,
+      ...input.pollIntervalMs === void 0 ? {} : { pollIntervalMs: input.pollIntervalMs },
+      sleep
+    });
+    if (completed.result === void 0) {
+      throw new Error("Cloud recording completed without a replay script.");
+    }
+    await mkdir(path.dirname(outputPath), { recursive: true });
+    await writeFile(outputPath, completed.result.script, "utf8");
+    await runtime.close();
+    closed = true;
+    stdout.write(`${outputPath}
+`);
+    stderr.write(`Cloud browser session: ${sessionUrl}
+`);
+    stderr.write(`Wrote replay script to ${outputPath}
+`);
+  } finally {
+    if (!closed) {
+      await runtime.close().catch(() => void 0);
+    }
+  }
+}
+function resolveRecordOutputPath(input) {
+  if (input.outputPath !== void 0) {
+    return path.resolve(input.rootDir, input.outputPath);
+  }
+  return path.join(
+    resolveFilesystemWorkspacePath({
+      rootDir: input.rootDir,
+      workspace: input.workspace
+    }),
+    "recorded-flow.ts"
+  );
+}
+function createRecorderRuntimeAdapter(runtime) {
+  return {
+    addInitScript: (input) => runtime.addInitScript(input),
+    evaluate: async (input) => {
+      const output = await runtime.evaluate({
+        script: input.script,
+        ...input.pageRef === void 0 ? {} : { pageRef: input.pageRef }
+      });
+      return output.value;
+    },
+    listPages: async () => {
+      const output = await runtime.listPages();
+      return {
+        pages: output.pages.map((page) => ({
+          pageRef: page.pageRef,
+          url: page.url,
+          ...page.openerPageRef === void 0 ? {} : { openerPageRef: page.openerPageRef }
+        }))
+      };
+    }
+  };
+}
+function buildCloudRecordingSessionUrl(cloudConfig, sessionId) {
+  const baseUrl = cloudConfig.appBaseUrl;
+  if (!baseUrl || baseUrl.trim().length === 0) {
+    throw new Error(
+      'record with provider=cloud requires OPENSTEER_CLOUD_APP_BASE_URL or "--cloud-app-base-url".'
+    );
+  }
+  return `${baseUrl.replace(/\/+$/, "")}/browsers/${encodeURIComponent(sessionId)}`;
+}
+async function resolveCloudRecordingSessionId(runtime) {
+  const info = await runtime.info();
+  if (typeof info.sessionId !== "string" || info.sessionId.length === 0) {
+    throw new Error("Cloud recording could not resolve the created session id.");
+  }
+  return info.sessionId;
+}
+async function waitForCloudRecordingCompletion(input) {
+  const pollIntervalMs = input.pollIntervalMs ?? 1e3;
+  for (; ; ) {
+    const state = await input.client.getSessionRecording(input.sessionId);
+    if (state.status === "completed") {
+      return state;
+    }
+    if (state.status === "failed") {
+      throw new Error(state.error ?? "Cloud recording failed.");
+    }
+    await input.sleep(pollIntervalMs);
+  }
+}
+function formatRecordedAction(action) {
+  const time = new Date(action.timestamp).toISOString().slice(11, 19);
+  switch (action.kind) {
+    case "click":
+      return `[${time}] click ${action.pageId} -> ${action.selector ?? "<unknown>"}`;
+    case "dblclick":
+      return `[${time}] dblclick ${action.pageId} -> ${action.selector ?? "<unknown>"}`;
+    case "type":
+      return `[${time}] type ${action.pageId} -> ${action.selector ?? "<unknown>"} -> ${JSON.stringify(action.detail.text)}`;
+    case "keypress":
+      return `[${time}] keypress ${action.pageId} -> ${action.detail.key}`;
+    case "scroll":
+      return `[${time}] scroll ${action.pageId} -> (${String(action.detail.deltaX)}, ${String(action.detail.deltaY)})`;
+    case "select-option":
+      return `[${time}] select ${action.pageId} -> ${action.selector ?? "<unknown>"} -> ${JSON.stringify(action.detail.value)}`;
+    case "navigate":
+      return `[${time}] navigate ${action.pageId} -> ${action.detail.url}`;
+    case "new-tab":
+      return `[${time}] new-tab ${action.pageId} -> ${action.detail.initialUrl}`;
+    case "close-tab":
+      return `[${time}] close-tab ${action.pageId}`;
+    case "switch-tab":
+      return `[${time}] switch-tab -> ${action.detail.toPageId}`;
+    case "go-back":
+      return `[${time}] go-back ${action.pageId}`;
+    case "go-forward":
+      return `[${time}] go-forward ${action.pageId}`;
+    case "reload":
+      return `[${time}] reload ${action.pageId}`;
+  }
+}
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
 
 // src/cli/bin.ts
 var OPERATION_ALIASES = /* @__PURE__ */ new Map([
@@ -351,6 +562,10 @@ async function main() {
     await handleStatusCommand(parsed);
     return;
   }
+  if (parsed.command[0] === "record") {
+    await handleRecordCommandEntry(parsed);
+    return;
+  }
   const operation = parsed.command[0] === "run" ? parsed.rest[0] : resolveOperation(parsed.command);
   if (!operation) {
     throw new Error(`Unknown command: ${parsed.command.join(" ")}`);
@@ -495,6 +710,100 @@ async function handleBrowserCommand(parsed) {
       throw new Error(`Unknown browser command: ${parsed.command.join(" ")}`);
   }
 }
+async function handleRecordCommandEntry(parsed) {
+  if (parsed.options.workspace === void 0) {
+    throw new Error('record requires "--workspace <id>".');
+  }
+  const url = parsed.options.url ?? parsed.rest[0];
+  if (url === void 0) {
+    throw new Error('record requires "--url <value>" or a positional URL.');
+  }
+  const provider = resolveCliProvider(parsed);
+  assertCloudCliOptionsMatchProvider(parsed, provider.mode);
+  const engineName = resolveCliEngineName(parsed);
+  if (engineName !== "playwright") {
+    throw new Error("record requires engine=playwright.");
+  }
+  const rootDir = process2.cwd();
+  const recordBrowser = parsed.options.browser;
+  if (provider.mode === "cloud") {
+    if (typeof recordBrowser === "object") {
+      throw new Error('record does not support browser.mode="attach".');
+    }
+    const runtimeProvider = buildCliRuntimeProvider(parsed, provider.mode);
+    const runtimeConfig = resolveOpensteerRuntimeConfig({
+      ...runtimeProvider === void 0 ? {} : { provider: runtimeProvider },
+      environment: process2.env
+    });
+    await runOpensteerCloudRecordCommand({
+      cloudConfig: runtimeConfig.cloud,
+      workspace: parsed.options.workspace,
+      url,
+      rootDir,
+      ...recordBrowser === void 0 ? {} : { browser: recordBrowser },
+      ...parsed.options.launch === void 0 ? {} : { launch: parsed.options.launch },
+      ...parsed.options.context === void 0 ? {} : { context: parsed.options.context },
+      ...parsed.options.output === void 0 ? {} : { outputPath: parsed.options.output }
+    });
+    return;
+  }
+  if (parsed.options.launch?.headless === true) {
+    throw new Error('record requires a headed browser. Remove "--headless true".');
+  }
+  if (recordBrowser !== void 0 && recordBrowser !== "persistent") {
+    throw new Error('record only supports "--browser persistent".');
+  }
+  const launch = {
+    ...parsed.options.launch ?? {},
+    headless: false
+  };
+  const browserManager = new OpensteerBrowserManager({
+    rootDir,
+    workspace: parsed.options.workspace,
+    engineName,
+    browser: "persistent",
+    launch,
+    ...parsed.options.context === void 0 ? {} : { context: parsed.options.context }
+  });
+  const runtime = createOpensteerSemanticRuntime({
+    provider: {
+      mode: "local"
+    },
+    engine: engineName,
+    runtimeOptions: {
+      rootPath: browserManager.rootPath,
+      cleanupRootOnClose: browserManager.cleanupRootOnDisconnect,
+      workspace: parsed.options.workspace,
+      browser: "persistent",
+      launch,
+      ...parsed.options.context === void 0 ? {} : { context: parsed.options.context }
+    }
+  });
+  await runOpensteerRecordCommand({
+    runtime,
+    closeSession: () => closeOwnedLocalBrowserSession(runtime, browserManager),
+    workspace: parsed.options.workspace,
+    url,
+    rootDir,
+    ...parsed.options.output === void 0 ? {} : { outputPath: parsed.options.output }
+  });
+}
+async function closeOwnedLocalBrowserSession(runtime, browserManager) {
+  let closeError;
+  try {
+    await runtime.close();
+  } catch (error) {
+    closeError = error;
+  }
+  try {
+    await browserManager.close();
+  } catch (error) {
+    closeError ??= error;
+  }
+  if (closeError !== void 0) {
+    throw closeError;
+  }
+}
 function buildOperationInput(operation, parsed) {
   if (parsed.options.inputJson !== void 0) {
     return parsed.options.inputJson;
@@ -575,6 +884,46 @@ function resolveOperation(command) {
   }
   return void 0;
 }
+var CLI_OPTION_SPECS = {
+  workspace: { kind: "value" },
+  url: { kind: "value" },
+  output: { kind: "value" },
+  engine: { kind: "value" },
+  provider: { kind: "value" },
+  "cloud-base-url": { kind: "value" },
+  "cloud-api-key": { kind: "value" },
+  "cloud-app-base-url": { kind: "value" },
+  "cloud-profile-id": { kind: "value" },
+  "cloud-profile-reuse-if-active": { kind: "boolean" },
+  json: { kind: "boolean" },
+  agent: { kind: "value", multiple: true },
+  skill: { kind: "value", multiple: true },
+  global: { kind: "boolean" },
+  yes: { kind: "boolean" },
+  copy: { kind: "boolean" },
+  all: { kind: "boolean" },
+  list: { kind: "boolean" },
+  browser: { kind: "value" },
+  "attach-endpoint": { kind: "value" },
+  "attach-header": { kind: "value", multiple: true },
+  "fresh-tab": { kind: "boolean" },
+  headless: { kind: "boolean" },
+  "executable-path": { kind: "value" },
+  arg: { kind: "value", multiple: true },
+  "timeout-ms": { kind: "value" },
+  "context-json": { kind: "value" },
+  "input-json": { kind: "value" },
+  "schema-json": { kind: "value" },
+  "source-user-data-dir": { kind: "value" },
+  "source-profile-directory": { kind: "value" },
+  selector: { kind: "value" },
+  description: { kind: "value" },
+  element: { kind: "value" },
+  text: { kind: "value" },
+  "press-enter": { kind: "boolean" },
+  direction: { kind: "value" },
+  amount: { kind: "value" }
+};
 function parseCommandLine(argv) {
   const leadingTokens = [];
   let index = 0;
@@ -588,18 +937,43 @@ function parseCommandLine(argv) {
   const rawOptions = /* @__PURE__ */ new Map();
   while (index < argv.length) {
     const token = argv[index];
+    if (token === "--") {
+      rest.push(...argv.slice(index + 1));
+      break;
+    }
     if (!token.startsWith("--")) {
       rest.push(token);
       index += 1;
       continue;
     }
-    const key = token.slice(2);
-    const next = argv[index + 1];
-    if (next === void 0 || next.startsWith("--")) {
-      rawOptions.set(key, [...rawOptions.get(key) ?? [], "true"]);
+    const separator = token.indexOf("=");
+    const key = token.slice(2, separator === -1 ? void 0 : separator);
+    const spec = CLI_OPTION_SPECS[key];
+    if (spec === void 0) {
+      throw new Error(`Unknown option: --${key}.`);
+    }
+    if (separator !== -1) {
+      const value = token.slice(separator + 1);
+      rawOptions.set(key, [...rawOptions.get(key) ?? [], value]);
       index += 1;
       continue;
     }
+    const next = argv[index + 1];
+    if (spec.kind === "boolean") {
+      if (next === void 0 || next.startsWith("--")) {
+        rawOptions.set(key, [...rawOptions.get(key) ?? [], "true"]);
+        index += 1;
+        continue;
+      }
+      rawOptions.set(key, [...rawOptions.get(key) ?? [], next]);
+      index += 2;
+      continue;
+    }
+    if (next === void 0 || next.startsWith("--")) {
+      throw new Error(
+        `Option "--${key}" requires a value.${next?.startsWith("--") === true ? ` Use "--${key}=<value>" when the value begins with "--".` : ``}`
+      );
+    }
     rawOptions.set(key, [...rawOptions.get(key) ?? [], next]);
     index += 2;
   }
@@ -630,6 +1004,8 @@ function parseCommandLine(argv) {
     ...timeoutMs === void 0 ? {} : { timeoutMs }
   };
   const workspace = readSingle(rawOptions, "workspace");
+  const url = readSingle(rawOptions, "url");
+  const output = readSingle(rawOptions, "output");
   const sourceUserDataDir = readSingle(rawOptions, "source-user-data-dir");
   const sourceProfileDirectory = readSingle(rawOptions, "source-profile-directory");
   const selector = readSingle(rawOptions, "selector");
@@ -646,6 +1022,7 @@ function parseCommandLine(argv) {
   const provider = providerValue === void 0 ? void 0 : normalizeOpensteerProviderMode(providerValue, "--provider");
   const cloudBaseUrl = readSingle(rawOptions, "cloud-base-url");
   const cloudApiKey = readSingle(rawOptions, "cloud-api-key");
+  const cloudAppBaseUrl = readSingle(rawOptions, "cloud-app-base-url");
   const cloudProfileId = readSingle(rawOptions, "cloud-profile-id");
   const cloudProfileReuseIfActive = readOptionalBoolean(
     rawOptions,
@@ -661,10 +1038,13 @@ function parseCommandLine(argv) {
   const list = readOptionalBoolean(rawOptions, "list");
   const options = {
     ...workspace === void 0 ? {} : { workspace },
+    ...url === void 0 ? {} : { url },
+    ...output === void 0 ? {} : { output },
     ...requestedEngineName === void 0 ? {} : { requestedEngineName },
     ...provider === void 0 ? {} : { provider },
     ...cloudBaseUrl === void 0 ? {} : { cloudBaseUrl },
     ...cloudApiKey === void 0 ? {} : { cloudApiKey },
+    ...cloudAppBaseUrl === void 0 ? {} : { cloudAppBaseUrl },
     ...cloudProfileId === void 0 ? {} : { cloudProfileId },
     ...cloudProfileReuseIfActive === void 0 ? {} : { cloudProfileReuseIfActive },
     ...json === void 0 ? {} : { json },
@@ -749,7 +1129,7 @@ function buildCliRuntimeProvider(parsed, providerMode) {
     return explicitProvider?.mode === "local" ? explicitProvider : void 0;
   }
   const browserProfile = buildCliBrowserProfile(parsed);
-  const hasCloudOverrides = parsed.options.cloudBaseUrl !== void 0 || parsed.options.cloudApiKey !== void 0 || browserProfile !== void 0;
+  const hasCloudOverrides = parsed.options.cloudBaseUrl !== void 0 || parsed.options.cloudApiKey !== void 0 || parsed.options.cloudAppBaseUrl !== void 0 || browserProfile !== void 0;
   if (!hasCloudOverrides && explicitProvider?.mode !== "cloud") {
     return void 0;
   }
@@ -757,11 +1137,12 @@ function buildCliRuntimeProvider(parsed, providerMode) {
     mode: "cloud",
     ...parsed.options.cloudBaseUrl === void 0 ? {} : { baseUrl: parsed.options.cloudBaseUrl },
     ...parsed.options.cloudApiKey === void 0 ? {} : { apiKey: parsed.options.cloudApiKey },
+    ...parsed.options.cloudAppBaseUrl === void 0 ? {} : { appBaseUrl: parsed.options.cloudAppBaseUrl },
     ...browserProfile === void 0 ? {} : { browserProfile }
   };
 }
 function assertCloudCliOptionsMatchProvider(parsed, providerMode) {
-  if (providerMode !== "cloud" && (parsed.options.cloudBaseUrl !== void 0 || parsed.options.cloudApiKey !== void 0 || parsed.options.cloudProfileId !== void 0 || parsed.options.cloudProfileReuseIfActive === true)) {
+  if (providerMode !== "cloud" && (parsed.options.cloudBaseUrl !== void 0 || parsed.options.cloudApiKey !== void 0 || parsed.options.cloudAppBaseUrl !== void 0 || parsed.options.cloudProfileId !== void 0 || parsed.options.cloudProfileReuseIfActive === true)) {
     throw new Error(
       'Cloud-specific options require provider=cloud. Set "--provider cloud" or OPENSTEER_PROVIDER=cloud.'
     );
@@ -860,6 +1241,9 @@ function resolveCommandLength(tokens) {
   if (tokens[0] === "status") {
     return 1;
   }
+  if (tokens[0] === "record") {
+    return 1;
+  }
   for (let length = Math.min(3, tokens.length); length >= 1; length -= 1) {
     if (OPERATION_ALIASES.has(tokens.slice(0, length).join(" "))) {
       return length;
@@ -877,6 +1261,7 @@ Usage:
   opensteer click --workspace <id> (--element <n> | --selector <css> | --description <text>)
   opensteer input --workspace <id> --text <value> (--element <n> | --selector <css> | --description <text>)
   opensteer extract --workspace <id> --description <text> [--schema-json <json>]
+  opensteer record --workspace <id> --url <url> [--output <path>]
   opensteer close --workspace <id>
   opensteer status [--workspace <id>] [--json]
 
@@ -894,9 +1279,12 @@ Common options:
   --help
   --version
   --workspace <id>
+  --url <url>
+  --output <path>
   --provider local|cloud
   --cloud-base-url <url>
   --cloud-api-key <key>
+  --cloud-app-base-url <url>
   --cloud-profile-id <id>
   --cloud-profile-reuse-if-active <true|false>
   --json <true|false>