opensteer 0.9.5 → 0.9.7

package/dist/{chunk-GSCQQKZZ.js → chunk-PJXN7HED.js}

@@ -1,4 +1,4 @@
-import { filePathToUri, resolveStoragePath, encodePathSegment, ensureDirectory, pathExists, readJsonFile, writeJsonFileAtomic, normalizeTimestamp, withFilesystemLock, resolveLocalViewPreferencesPath, resolveLocalViewServiceLockDir, readLocalViewServiceState, isLocalViewServiceStateLive, clearLocalViewServiceState, getLocalViewServiceStateLiveness, clearPersistedSessionRecord, writePersistedSessionRecord, isProcessRunning, readPersistedLocalBrowserSessionRecord, buildLocalViewSessionId, selectAttachBrowserCandidate, resolveChromeExecutablePath, readDevToolsActivePort, inspectCdpEndpoint, normalizeNonEmptyString, toCanonicalJsonValue, canonicalJsonString, sha256Hex, joinStoragePath, writeBufferIfMissing, writeJsonFileExclusive, isAlreadyExistsError, readBinaryFile, listJsonFiles, expandHome, createLocalViewSessionManifest, writeLocalViewSessionManifest, deleteLocalViewSessionManifest, CURRENT_PROCESS_OWNER, getProcessLiveness, processOwnersEqual, parseProcessOwner } from './chunk-T5P2QGZ3.js';
+import { filePathToUri, resolveStoragePath, encodePathSegment, ensureDirectory, pathExists, readJsonFile, writeJsonFileAtomic, normalizeTimestamp, withFilesystemLock, resolveLocalViewPreferencesPath, resolveLocalViewServiceLockDir, readLocalViewServiceState, isLocalViewServiceStateLive, clearLocalViewServiceState, getLocalViewServiceStateLiveness, clearPersistedSessionRecord, writePersistedSessionRecord, isAttachedLocalBrowserSessionReachable, isProcessRunning, readPersistedLocalBrowserSessionRecord, getPersistedLocalBrowserSessionOwnership, buildLocalViewSessionId, inspectCdpEndpoint, selectAttachBrowserCandidate, resolveChromeExecutablePath, readDevToolsActivePort, normalizeNonEmptyString, toCanonicalJsonValue, canonicalJsonString, sha256Hex, joinStoragePath, writeBufferIfMissing, writeJsonFileExclusive, isAlreadyExistsError, readBinaryFile, listJsonFiles, expandHome, createLocalViewSessionManifest, writeLocalViewSessionManifest, deleteLocalViewSessionManifest, CURRENT_PROCESS_OWNER, getProcessLiveness, processOwnersEqual, parseProcessOwner } from './chunk-U4BUCIZ4.js';
 import path7, { join, resolve, dirname, relative } from 'path';
 import { randomBytes, randomUUID } from 'crypto';
 import { spawn } from 'child_process';
@@ -295,6 +295,218 @@ function mediaTypeExtension(mediaType) {
   }
 }
 
+// ../protocol/src/json.ts
+var JSON_SCHEMA_DRAFT_2020_12 = "https://json-schema.org/draft/2020-12/schema";
+function defineSchema(schema) {
+  return schema;
+}
+function stringSchema(options = {}) {
+  return defineSchema({
+    type: "string",
+    ...options
+  });
+}
+function numberSchema(options = {}) {
+  return defineSchema({
+    type: "number",
+    ...options
+  });
+}
+function integerSchema(options = {}) {
+  return defineSchema({
+    type: "integer",
+    ...options
+  });
+}
+function literalSchema(value, options = {}) {
+  return defineSchema({
+    const: value,
+    ...options
+  });
+}
+function enumSchema(values, options = {}) {
+  return defineSchema({
+    enum: values,
+    ...options
+  });
+}
+function arraySchema(items, options = {}) {
+  return defineSchema({
+    type: "array",
+    items,
+    ...options
+  });
+}
+function objectSchema(properties, options = {}) {
+  const { required, additionalProperties, ...rest } = options;
+  return defineSchema({
+    type: "object",
+    properties,
+    ...rest,
+    ...required === void 0 ? {} : { required },
+    ...additionalProperties === void 0 ? { additionalProperties: false } : { additionalProperties }
+  });
+}
+function recordSchema(valueSchema, options = {}) {
+  return defineSchema({
+    type: "object",
+    additionalProperties: valueSchema,
+    ...options
+  });
+}
+function oneOfSchema(members, options = {}) {
+  return defineSchema({
+    oneOf: members,
+    ...options
+  });
+}
+
+// ../protocol/src/capabilities.ts
+var opensteerCapabilities = [
+  "sessions.manage",
+  "pages.manage",
+  "pages.navigate",
+  "input.pointer",
+  "input.keyboard",
+  "input.touch",
+  "artifacts.screenshot",
+  "execution.pause",
+  "execution.resume",
+  "execution.freeze",
+  "inspect.pages",
+  "inspect.frames",
+  "inspect.html",
+  "inspect.domSnapshot",
+  "inspect.text",
+  "inspect.attributes",
+  "inspect.hitTest",
+  "inspect.viewportMetrics",
+  "inspect.network",
+  "inspect.networkBodies",
+  "inspect.cookies",
+  "inspect.localStorage",
+  "inspect.sessionStorage",
+  "inspect.indexedDb",
+  "transport.sessionHttp",
+  "instrumentation.initScripts",
+  "instrumentation.routing",
+  "events.pageLifecycle",
+  "events.dialog",
+  "events.download",
+  "events.chooser",
+  "events.worker",
+  "events.console",
+  "events.pageError",
+  "events.websocket",
+  "events.eventStream",
+  "events.executionState",
+  "surface.rest",
+  "surface.mcp"
+];
+var opensteerCapabilitySchema = enumSchema(opensteerCapabilities, {
+  title: "OpensteerCapability"
+});
+var opensteerCapabilitySetSchema = arraySchema(opensteerCapabilitySchema, {
+  title: "OpensteerCapabilitySet",
+  uniqueItems: true
+});
+var opensteerCapabilityDescriptorSchema = objectSchema(
+  {
+    key: opensteerCapabilitySchema,
+    description: stringSchema(),
+    stability: enumSchema(["stable", "experimental"])
+  },
+  {
+    title: "OpensteerCapabilityDescriptor",
+    required: ["key", "description", "stability"]
+  }
+);
+arraySchema(
+  opensteerCapabilityDescriptorSchema,
+  {
+    title: "OpensteerCapabilityDescriptorList",
+    uniqueItems: true
+  }
+);
+
+// ../protocol/src/errors.ts
+var opensteerErrorCodes = [
+  "invalid-request",
+  "invalid-argument",
+  "invalid-ref",
+  "unsupported-version",
+  "unsupported-operation",
+  "unsupported-capability",
+  "not-found",
+  "stale-node-ref",
+  "session-closed",
+  "page-closed",
+  "frame-detached",
+  "timeout",
+  "navigation-failed",
+  "permission-denied",
+  "conflict",
+  "profile-unavailable",
+  "auth-failure",
+  "auth-recovery-failed",
+  "browser-required",
+  "rate-limited",
+  "operation-failed",
+  "internal"
+];
+var OpensteerProtocolError = class extends Error {
+  code;
+  retriable;
+  capability;
+  details;
+  constructor(code, message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = "OpensteerProtocolError";
+    this.code = code;
+    this.retriable = options.retriable ?? false;
+    this.capability = options.capability;
+    this.details = options.details;
+  }
+};
+function createOpensteerError(code, message, options = {}) {
+  return {
+    code,
+    message,
+    retriable: options.retriable ?? false,
+    ...options.capability === void 0 ? {} : { capability: options.capability },
+    ...options.details === void 0 ? {} : { details: options.details }
+  };
+}
+function isOpensteerProtocolError(value) {
+  return value instanceof OpensteerProtocolError;
+}
+function toOpensteerError(error) {
+  return createOpensteerError(error.code, error.message, {
+    retriable: error.retriable,
+    ...error.capability === void 0 ? {} : { capability: error.capability },
+    ...error.details === void 0 ? {} : { details: error.details }
+  });
+}
+var opensteerErrorCodeSchema = {
+  title: "OpensteerErrorCode",
+  enum: opensteerErrorCodes
+};
+var opensteerErrorSchema = objectSchema(
+  {
+    code: opensteerErrorCodeSchema,
+    message: stringSchema(),
+    retriable: {
+      type: "boolean"
+    },
+    capability: opensteerCapabilitySchema,
+    details: recordSchema({})
+  },
+  {
+    title: "OpensteerError",
+    required: ["code", "message", "retriable"]
+  }
+);
+
 // ../runtime-core/src/observation-utils.ts
 var REDACTED = "[REDACTED]";
 var SENSITIVE_KEY_PATTERN = /(authorization|proxy[_-]?authorization|cookie|set-cookie|api[_-]?key|access[_-]?token|refresh[_-]?token|auth[_-]?token|token|secret|password|passwd|private[_-]?key|database[_-]?url|db[_-]?url|session(?:id)?|csrf(?:token)?)/i;
@@ -2092,7 +2304,8 @@ function normalizeOpensteerEngineName(value, source = "engine") {
   if (normalized === "playwright" || normalized === "abp") {
     return normalized;
   }
-  throw new Error(
+  throw new OpensteerProtocolError(
+    "invalid-argument",
     `${source} must be one of ${OPENSTEER_ENGINE_NAMES.join(", ")}; received "${value}".`
   );
 }
@@ -2101,7 +2314,8 @@ function assertSupportedEngineOptions(input) {
     return;
   }
   if (typeof input.browser === "object" && input.browser !== null && input.browser.mode === "attach") {
-    throw new Error(
+    throw new OpensteerProtocolError(
+      "invalid-argument",
       'ABP engine does not support browser.mode="attach". Use the Playwright engine for attach flows.'
     );
   }
@@ -2109,7 +2323,8 @@ function assertSupportedEngineOptions(input) {
   if (unsupportedContextOptionNames.length === 0) {
     return;
   }
-  throw new Error(
+  throw new OpensteerProtocolError(
+    "invalid-argument",
     `ABP engine does not support ${unsupportedContextOptionNames.join(", ")}. Supported ABP context options: context.viewport.`
   );
 }
@@ -3258,7 +3473,7 @@ var OpensteerBrowserManager = class {
     }
     const liveRecord = await this.readLivePersistentBrowser(await this.ensureWorkspaceStore());
     return {
-      mode: this.mode,
+      mode: liveRecord?.ownership === "attached" ? "attach" : this.mode,
       engine: liveRecord?.engine ?? this.engineName,
       ...this.workspace === void 0 ? {} : { workspace: this.workspace },
       live: liveRecord !== void 0
@@ -3386,6 +3601,7 @@ var OpensteerBrowserManager = class {
       });
       const liveRecord = {
         mode: "persistent",
+        ownership: "owned",
         engine: "abp",
         baseUrl: launched.baseUrl,
         remoteDebuggingUrl: launched.remoteDebuggingUrl,
@@ -3472,11 +3688,78 @@ var OpensteerBrowserManager = class {
   }
   async createAttachEngine() {
     const endpoint = await resolveAttachEndpoint(this.browserOptions);
-    return this.createAttachedEngine({
-      endpoint,
-      ...this.browserOptions?.headers === void 0 ? {} : { headers: this.browserOptions.headers },
-      freshTab: this.browserOptions?.freshTab ?? true,
-      onDispose: async () => void 0
+    if (this.workspace === void 0) {
+      return this.createAttachedEngine({
+        endpoint,
+        ...this.browserOptions?.headers === void 0 ? {} : { headers: this.browserOptions.headers },
+        freshTab: this.browserOptions?.freshTab ?? true,
+        onDispose: async () => void 0
+      });
+    }
+    const workspace = await this.ensureWorkspaceStore();
+    return workspace.lock(async () => {
+      const live = await this.readLivePersistentBrowser(workspace);
+      if (live) {
+        if (live.engine !== "playwright") {
+          throw new Error(
+            `workspace "${this.workspace}" already has a live ${live.engine} browser. Close it before attaching a Playwright browser.`
+          );
+        }
+        if (live.ownership !== "attached") {
+          throw new Error(
+            `workspace "${this.workspace}" already has a live Opensteer-owned browser. Close it before attaching another browser.`
+          );
+        }
+        if (live.endpoint === void 0) {
+          throw new Error("workspace live browser record is missing a DevTools endpoint.");
+        }
+        if (live.endpoint !== endpoint) {
+          throw new Error(
+            `workspace "${this.workspace}" is already attached to a different browser endpoint. Close it before reattaching.`
+          );
+        }
+        await bestEffortRegisterLocalViewSession({
+          rootPath: workspace.rootPath,
+          ...this.workspace === void 0 ? {} : { workspace: this.workspace },
+          live: toPersistedLocalBrowserSessionRecord(this.workspace, live),
+          ownership: "attached"
+        });
+        return this.createAttachedEngine({
+          endpoint: live.endpoint,
+          ...this.browserOptions?.headers === void 0 ? {} : { headers: this.browserOptions.headers },
+          freshTab: this.browserOptions?.freshTab ?? true,
+          onDispose: async () => void 0
+        });
+      }
+      const liveRecord = {
+        mode: "persistent",
+        ownership: "attached",
+        engine: "playwright",
+        endpoint,
+        pid: 0,
+        startedAt: Date.now(),
+        userDataDir: workspace.browserUserDataDir
+      };
+      await this.writeLivePersistentBrowser(workspace, liveRecord);
+      const persistedLiveRecord = toPersistedLocalBrowserSessionRecord(this.workspace, liveRecord);
+      await bestEffortRegisterLocalViewSession({
+        rootPath: workspace.rootPath,
+        ...this.workspace === void 0 ? {} : { workspace: this.workspace },
+        live: persistedLiveRecord,
+        ownership: "attached"
+      });
+      try {
+        return await this.createAttachedEngine({
+          endpoint,
+          ...this.browserOptions?.headers === void 0 ? {} : { headers: this.browserOptions.headers },
+          freshTab: this.browserOptions?.freshTab ?? true,
+          onDispose: async () => void 0
+        });
+      } catch (error) {
+        await this.unregisterLocalViewSessionForRecord(workspace.rootPath, persistedLiveRecord);
+        await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
+        throw error;
+      }
     });
   }
   async createPersistentEngine() {
@@ -3496,7 +3779,7 @@ var OpensteerBrowserManager = class {
           rootPath: workspace.rootPath,
           ...this.workspace === void 0 ? {} : { workspace: this.workspace },
           live: toPersistedLocalBrowserSessionRecord(this.workspace, live),
-          ownership: "owned"
+          ownership: live.ownership
         });
         return this.createAttachedEngine({
           endpoint: live.endpoint,
@@ -3512,6 +3795,7 @@ var OpensteerBrowserManager = class {
       });
       const liveRecord = {
         mode: "persistent",
+        ownership: "owned",
         engine: "playwright",
         endpoint: launched.endpoint,
         pid: launched.pid,
@@ -3641,7 +3925,20 @@ var OpensteerBrowserManager = class {
     if (live === void 0) {
       return void 0;
     }
+    if (live.ownership === "attached") {
+      const attachedRecord = toPersistedLocalBrowserSessionRecord(this.workspace, live);
+      if (!await isAttachedLocalBrowserSessionReachable(attachedRecord)) {
+        await this.unregisterLocalViewSessionForRecord(workspace.rootPath, attachedRecord);
+        await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
+        return void 0;
+      }
+      return live;
+    }
     if (!isProcessRunning(live.pid)) {
+      await this.unregisterLocalViewSessionForRecord(
+        workspace.rootPath,
+        toPersistedLocalBrowserSessionRecord(this.workspace, live)
+      );
       await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
       return void 0;
     }
@@ -3689,6 +3986,10 @@ var OpensteerBrowserManager = class {
       workspace.rootPath,
       toPersistedLocalBrowserSessionRecord(this.workspace, live)
     );
+    if (live.ownership === "attached") {
+      await clearPersistedSessionRecord(workspace.rootPath, "local").catch(() => void 0);
+      return;
+    }
     if (live.engine === "playwright") {
       if (live.endpoint !== void 0) {
         await requestBrowserClose(live.endpoint).catch(() => void 0);
@@ -3717,10 +4018,18 @@ var OpensteerBrowserManager = class {
   }
   async unregisterLocalViewSessionForRecord(rootPath, record) {
     await bestEffortUnregisterLocalViewSession(
-      buildLocalViewSessionId({
+      getPersistedLocalBrowserSessionOwnership(record) === "attached" ? buildLocalViewSessionId({
+        rootPath,
+        startedAt: record.startedAt,
+        ownership: "attached",
+        ...record.endpoint === void 0 ? {} : { endpoint: record.endpoint },
+        ...record.baseUrl === void 0 ? {} : { baseUrl: record.baseUrl },
+        ...record.remoteDebuggingUrl === void 0 ? {} : { remoteDebuggingUrl: record.remoteDebuggingUrl }
+      }) : buildLocalViewSessionId({
         rootPath,
-        pid: record.pid,
-        startedAt: record.startedAt
+        startedAt: record.startedAt,
+        ownership: "owned",
+        pid: record.pid
       })
     );
   }
@@ -3755,6 +4064,7 @@ function toPersistedLocalBrowserSessionRecord(workspace, live) {
     version: 1,
     provider: "local",
     ...workspace === void 0 ? {} : { workspace },
+    ownership: live.ownership,
     engine: live.engine,
     ...live.endpoint === void 0 ? {} : { endpoint: live.endpoint },
     ...live.baseUrl === void 0 ? {} : { baseUrl: live.baseUrl },
@@ -3770,6 +4080,7 @@ function toPersistedLocalBrowserSessionRecord(workspace, live) {
 function toWorkspaceLiveBrowserRecord(record) {
   return {
     mode: "persistent",
+    ownership: getPersistedLocalBrowserSessionOwnership(record),
     engine: record.engine,
     ...record.endpoint === void 0 ? {} : { endpoint: record.endpoint },
     ...record.baseUrl === void 0 ? {} : { baseUrl: record.baseUrl },
@@ -3796,7 +4107,12 @@ function isAttachBrowserOptions(browser) {
 async function resolveAttachEndpoint(browser) {
   const endpoint = browser?.endpoint?.trim();
   if (endpoint && endpoint.length > 0) {
-    return endpoint;
+    const inspected = await inspectCdpEndpoint({
+      endpoint,
+      ...browser?.headers === void 0 ? {} : { headers: browser.headers },
+      timeoutMs: DEFAULT_TIMEOUT_MS
+    });
+    return inspected.endpoint;
   }
   const selection = await selectAttachBrowserCandidate({
     timeoutMs: DEFAULT_TIMEOUT_MS
@@ -4142,6 +4458,6 @@ async function sleep2(ms) {
   await new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 
-export { DEFAULT_OPENSTEER_ENGINE, OPENSTEER_ENGINE_NAMES, OPENSTEER_FILESYSTEM_WORKSPACE_LAYOUT, OPENSTEER_FILESYSTEM_WORKSPACE_VERSION, OpensteerBrowserManager, assertSupportedEngineOptions, buildLocalViewSessionUrl, createArtifactStore, createFilesystemOpensteerWorkspace, createObservationStore, ensureLocalViewServiceRunning, manifestToExternalBinaryLocation, normalizeObservabilityConfig, normalizeObservationContext, normalizeOpensteerEngineName, normalizeWorkspaceId, resolveFilesystemWorkspacePath, resolveOpensteerEngineName, setLocalViewMode, stopLocalViewService };
-//# sourceMappingURL=chunk-GSCQQKZZ.js.map
-//# sourceMappingURL=chunk-GSCQQKZZ.js.map
+export { DEFAULT_OPENSTEER_ENGINE, JSON_SCHEMA_DRAFT_2020_12, OPENSTEER_ENGINE_NAMES, OPENSTEER_FILESYSTEM_WORKSPACE_LAYOUT, OPENSTEER_FILESYSTEM_WORKSPACE_VERSION, OpensteerBrowserManager, OpensteerProtocolError, arraySchema, assertSupportedEngineOptions, buildLocalViewSessionUrl, createArtifactStore, createFilesystemOpensteerWorkspace, createObservationStore, createOpensteerError, defineSchema, ensureLocalViewServiceRunning, enumSchema, integerSchema, isOpensteerProtocolError, literalSchema, manifestToExternalBinaryLocation, normalizeObservabilityConfig, normalizeObservationContext, normalizeOpensteerEngineName, normalizeWorkspaceId, numberSchema, objectSchema, oneOfSchema, opensteerCapabilitySetSchema, opensteerErrorCodes, opensteerErrorSchema, recordSchema, resolveFilesystemWorkspacePath, resolveOpensteerEngineName, setLocalViewMode, stopLocalViewService, stringSchema, toOpensteerError };
+//# sourceMappingURL=chunk-PJXN7HED.js.map
+//# sourceMappingURL=chunk-PJXN7HED.js.map