opensteer 0.8.8 → 0.8.10

package/dist/cli/bin.js

@@ -1,77 +1,20 @@
 #!/usr/bin/env node
-import { assertProviderSupportsEngine, createOpensteerSemanticRuntime, OpensteerBrowserManager, dispatchSemanticOperation, pathExists, normalizeOpensteerProviderMode, discoverLocalCdpBrowsers, inspectCdpEndpoint, resolveOpensteerRuntimeConfig, resolveOpensteerEngineName, resolveOpensteerProvider, resolveFilesystemWorkspacePath, readPersistedLocalBrowserSessionRecord, readPersistedCloudSessionRecord, OpensteerCloudClient, isProcessRunning } from '../chunk-3QJGBVWT.js';
+import { assertProviderSupportsEngine, createOpensteerSemanticRuntime, OpensteerBrowserManager, dispatchSemanticOperation, loadEnvironment, normalizeOpensteerProviderMode, discoverLocalCdpBrowsers, inspectCdpEndpoint, resolveOpensteerRuntimeConfig, resolveOpensteerEngineName, resolveOpensteerProvider, resolveFilesystemWorkspacePath, FlowRecorderCollector, generateReplayScript, pathExists, readPersistedLocalBrowserSessionRecord, readPersistedCloudSessionRecord, OpensteerCloudClient, isProcessRunning } from '../chunk-F3X6UOEN.js';
 import process2 from 'process';
-import { readFile } from 'fs/promises';
-import path2 from 'path';
 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"};
-var ENV_FILENAMES = [".env", ".env.local"];
+  version: "0.8.9"};
+
+// src/cli/env-loader.ts
 async function loadCliEnvironment(cwd) {
-  const protectedKeys = new Set(Object.keys(process.env));
-  const directories = collectDirectories(cwd);
-  for (const directory of directories) {
-    for (const filename of ENV_FILENAMES) {
-      const filePath = path2.join(directory, filename);
-      if (!await pathExists(filePath)) {
-        continue;
-      }
-      const parsed = parseEnvFile(await readFile(filePath, "utf8"));
-      for (const [key, value] of Object.entries(parsed)) {
-        if (protectedKeys.has(key)) {
-          continue;
-        }
-        process.env[key] = value;
-      }
-    }
-  }
-}
-function collectDirectories(cwd) {
-  const directories = [];
-  let current = path2.resolve(cwd);
-  for (; ; ) {
-    directories.unshift(current);
-    const parent = path2.dirname(current);
-    if (parent === current) {
-      return directories;
-    }
-    current = parent;
-  }
-}
-function parseEnvFile(contents) {
-  const parsed = {};
-  for (const rawLine of contents.split(/\r?\n/u)) {
-    const trimmed = rawLine.trim();
-    if (!trimmed || trimmed.startsWith("#")) {
-      continue;
-    }
-    const line = trimmed.startsWith("export ") ? trimmed.slice("export ".length) : trimmed;
-    const separatorIndex = line.indexOf("=");
-    if (separatorIndex <= 0) {
-      continue;
-    }
-    const key = line.slice(0, separatorIndex).trim();
-    if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(key)) {
-      continue;
-    }
-    const rawValue = line.slice(separatorIndex + 1).trim();
-    parsed[key] = parseEnvValue(rawValue);
-  }
-  return parsed;
-}
-function parseEnvValue(rawValue) {
-  if (rawValue.length >= 2 && rawValue.startsWith('"') && rawValue.endsWith('"')) {
-    return rawValue.slice(1, -1).replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\"/g, '"');
-  }
-  if (rawValue.length >= 2 && rawValue.startsWith("'") && rawValue.endsWith("'")) {
-    return rawValue.slice(1, -1);
-  }
-  return rawValue.replace(/\s+#.*$/u, "").trimEnd();
+  loadEnvironment(cwd);
 }
 function createOpensteerSkillsInvocation(input) {
   const cliArgs = ["add", input.skillSourcePath];
@@ -106,22 +49,22 @@ function createOpensteerSkillsInvocation(input) {
 function resolveOpensteerSkillsCliPath() {
   const require2 = createRequire(import.meta.url);
   const skillsPackagePath = require2.resolve("skills/package.json");
-  const skillsPackageDir = path2.dirname(skillsPackagePath);
-  const cliPath = path2.join(skillsPackageDir, "bin", "cli.mjs");
+  const skillsPackageDir = path.dirname(skillsPackagePath);
+  const cliPath = path.join(skillsPackageDir, "bin", "cli.mjs");
   if (!existsSync(cliPath)) {
     throw new Error(`skills CLI entrypoint was not found at "${cliPath}".`);
   }
   return cliPath;
 }
 function resolveOpensteerSkillSourcePath() {
-  let ancestor = path2.dirname(fileURLToPath(import.meta.url));
+  let ancestor = path.dirname(fileURLToPath(import.meta.url));
   for (let index = 0; index < 6; index += 1) {
-    const candidate = path2.join(ancestor, "skills");
-    const skillManifest = path2.join(candidate, "opensteer", "SKILL.md");
+    const candidate = path.join(ancestor, "skills");
+    const skillManifest = path.join(candidate, "opensteer", "SKILL.md");
     if (existsSync(skillManifest)) {
       return candidate;
     }
-    ancestor = path2.resolve(ancestor, "..");
+    ancestor = path.resolve(ancestor, "..");
   }
   throw new Error("Unable to find the packaged Opensteer skill source directory.");
 }
@@ -246,7 +189,7 @@ function describeLocalLane(record, current) {
       summary: "none"
     };
   }
-  const browser = record.executablePath ? path2.basename(record.executablePath).replace(/\.[A-Za-z0-9]+$/u, "") : void 0;
+  const browser = record.executablePath ? path.basename(record.executablePath).replace(/\.[A-Za-z0-9]+$/u, "") : void 0;
   return {
     provider: "local",
     status: "active",
@@ -272,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;
@@ -318,6 +263,121 @@ 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);
+    }
+  }
+}
+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 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}`;
+  }
+}
 
 // src/cli/bin.ts
 var OPERATION_ALIASES = /* @__PURE__ */ new Map([
@@ -409,6 +469,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(" ")}`);
@@ -553,6 +617,83 @@ 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);
+  if (provider.mode !== "local") {
+    throw new Error(
+      'record requires provider=local. Set "--provider local" or clear OPENSTEER_PROVIDER.'
+    );
+  }
+  const engineName = resolveCliEngineName(parsed);
+  if (engineName !== "playwright") {
+    throw new Error("record requires engine=playwright.");
+  }
+  if (parsed.options.browser !== void 0 && parsed.options.browser !== "persistent") {
+    throw new Error('record only supports "--browser persistent".');
+  }
+  if (parsed.options.launch?.headless === true) {
+    throw new Error('record requires a headed browser. Remove "--headless true".');
+  }
+  const rootDir = process2.cwd();
+  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;
@@ -633,6 +774,45 @@ 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-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;
@@ -646,18 +826,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;
   }
@@ -688,6 +893,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");
@@ -719,6 +926,8 @@ 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 },
@@ -831,7 +1040,7 @@ async function handleStatusCommand(parsed) {
   const runtimeProvider = buildCliRuntimeProvider(parsed, provider.mode);
   const runtimeConfig = resolveOpensteerRuntimeConfig({
     ...runtimeProvider === void 0 ? {} : { provider: runtimeProvider },
-    ...process2.env.OPENSTEER_PROVIDER === void 0 ? {} : { environmentProvider: process2.env.OPENSTEER_PROVIDER }
+    environment: process2.env
   });
   const status = await collectOpensteerStatus({
     rootDir: process2.cwd(),
@@ -918,6 +1127,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;
@@ -935,6 +1147,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]
 
@@ -952,6 +1165,8 @@ Common options:
   --help
   --version
   --workspace <id>
+  --url <url>
+  --output <path>
   --provider local|cloud
   --cloud-base-url <url>
   --cloud-api-key <key>