opensteer 0.6.0 → 0.6.2

package/dist/cli/server.js

@@ -1,7 +1,11 @@
 import {
-  Opensteer,
-  normalizeError
-} from "../chunk-SGZYTGY3.js";
+  Opensteer
+} from "../chunk-F2VDVOJO.js";
+import {
+  normalizeError,
+  resolveCloudSelection,
+  resolveConfigWithEnv
+} from "../chunk-WDRMHPWL.js";
 import "../chunk-3H5RRIMZ.js";
 
 // src/cli/server.ts
@@ -57,6 +61,21 @@ var commands = {
   async state(opensteer) {
     return await opensteer.state();
   },
+  async cursor(opensteer, args) {
+    const mode = typeof args.mode === "string" ? args.mode : "status";
+    if (mode === "on") {
+      opensteer.setCursorEnabled(true);
+    } else if (mode === "off") {
+      opensteer.setCursorEnabled(false);
+    } else if (mode !== "status") {
+      throw new Error(
+        `Invalid cursor mode "${String(mode)}". Use "on", "off", or "status".`
+      );
+    }
+    return {
+      cursor: opensteer.getCursorState()
+    };
+  },
   async screenshot(opensteer, args) {
     const file = args.file || "screenshot.png";
     const type = file.endsWith(".jpg") || file.endsWith(".jpeg") ? "jpeg" : "png";
@@ -256,10 +275,175 @@ function getCommandHandler(name) {
   return commands[name];
 }
 
+// src/cli/cloud-profile-binding.ts
+function normalizeCloudProfileBinding(value) {
+  if (!value) {
+    return null;
+  }
+  const profileId = typeof value.profileId === "string" ? value.profileId.trim() : "";
+  if (!profileId) {
+    return null;
+  }
+  return {
+    profileId,
+    reuseIfActive: typeof value.reuseIfActive === "boolean" ? value.reuseIfActive : void 0
+  };
+}
+function resolveConfiguredCloudProfileBinding(config) {
+  if (!isCloudConfigured(config)) {
+    return null;
+  }
+  return normalizeCloudProfileBinding(config.cloud.browserProfile);
+}
+function resolveSessionCloudProfileBinding(config, requested) {
+  if (!isCloudConfigured(config)) {
+    return null;
+  }
+  return requested ?? resolveConfiguredCloudProfileBinding(config);
+}
+function assertCompatibleCloudProfileBinding(sessionId, active, requested) {
+  if (!requested) {
+    return;
+  }
+  if (!active) {
+    throw new Error(
+      [
+        `Session '${sessionId}' is already running without a bound cloud browser profile.`,
+        "Cloud browser profile selection only applies when the session is first opened.",
+        "Close this session or use a different --session to target another profile."
+      ].join(" ")
+    );
+  }
+  if (active.profileId === requested.profileId && active.reuseIfActive === requested.reuseIfActive) {
+    return;
+  }
+  throw new Error(
+    [
+      `Session '${sessionId}' is already bound to cloud browser profile ${formatCloudProfileBinding(active)}.`,
+      `Requested ${formatCloudProfileBinding(requested)} does not match.`,
+      "Use the same cloud profile for this session, or start a different --session."
+    ].join(" ")
+  );
+}
+function formatCloudProfileBinding(binding) {
+  if (binding.reuseIfActive === void 0) {
+    return `'${binding.profileId}'`;
+  }
+  return `'${binding.profileId}' (reuseIfActive=${String(
+    binding.reuseIfActive
+  )})`;
+}
+function isCloudConfigured(config) {
+  return Boolean(
+    config.cloud && typeof config.cloud === "object" && !Array.isArray(config.cloud)
+  );
+}
+
+// src/cli/open-cloud-auth.ts
+function normalizeCliOpenCloudAuth(value) {
+  if (value == null) {
+    return null;
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Invalid open request cloud auth payload.");
+  }
+  const record = value;
+  const apiKey = normalizeNonEmptyString(record.apiKey);
+  const accessToken = normalizeNonEmptyString(record.accessToken);
+  const baseUrl = normalizeNonEmptyString(record.baseUrl);
+  const authScheme = normalizeAuthScheme(record.authScheme);
+  if (!baseUrl) {
+    throw new Error("Open request cloud auth payload is missing baseUrl.");
+  }
+  if ((apiKey ? 1 : 0) + (accessToken ? 1 : 0) !== 1) {
+    throw new Error(
+      "Open request cloud auth payload must include exactly one credential."
+    );
+  }
+  if (accessToken && authScheme !== "bearer") {
+    throw new Error(
+      'Open request cloud auth payload must use authScheme "bearer" with accessToken.'
+    );
+  }
+  return {
+    ...apiKey ? { apiKey } : {},
+    ...accessToken ? { accessToken } : {},
+    baseUrl,
+    authScheme
+  };
+}
+function buildServerOpenConfig(options) {
+  const config = {
+    name: options.name,
+    storage: {
+      rootDir: options.scopeDir
+    },
+    cursor: {
+      enabled: options.cursorEnabled
+    },
+    browser: {
+      headless: options.headless ?? false,
+      connectUrl: options.connectUrl,
+      channel: options.channel,
+      profileDir: options.profileDir
+    }
+  };
+  if (!options.cloudAuth) {
+    return config;
+  }
+  const resolved = resolveConfigWithEnv(
+    {
+      storage: {
+        rootDir: options.scopeDir
+      }
+    },
+    {
+      env: options.env
+    }
+  );
+  const cloudSelection = resolveCloudSelection(
+    {
+      cloud: resolved.config.cloud
+    },
+    resolved.env
+  );
+  if (!cloudSelection.cloud) {
+    return config;
+  }
+  config.cloud = toOpensteerCloudOptions(options.cloudAuth);
+  return config;
+}
+function toOpensteerCloudOptions(auth) {
+  return {
+    ...auth.apiKey ? { apiKey: auth.apiKey } : {},
+    ...auth.accessToken ? { accessToken: auth.accessToken } : {},
+    baseUrl: auth.baseUrl,
+    authScheme: auth.authScheme
+  };
+}
+function normalizeNonEmptyString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function normalizeAuthScheme(value) {
+  if (value === "api-key" || value === "bearer") {
+    return value;
+  }
+  throw new Error(
+    'Open request cloud auth payload must use authScheme "api-key" or "bearer".'
+  );
+}
+
 // src/cli/server.ts
 var instance = null;
 var launchPromise = null;
 var selectorNamespace = null;
+var cloudProfileBinding = null;
+var cloudAuthOverride = null;
+var cursorEnabledPreference = readCursorPreferenceFromEnv();
 var requestQueue = Promise.resolve();
 var shuttingDown = false;
 function sanitizeNamespace(value) {
@@ -277,6 +461,36 @@ function invalidateInstance() {
   instance.close().catch(() => {
   });
   instance = null;
+  cloudProfileBinding = null;
+}
+function normalizeCursorFlag(value) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (value === 1) return true;
+    if (value === 0) return false;
+  }
+  throw new Error(
+    '--cursor must be a boolean value ("true" or "false").'
+  );
+}
+function readCursorPreferenceFromEnv() {
+  const value = process.env.OPENSTEER_CURSOR;
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true" || normalized === "1") {
+    return true;
+  }
+  if (normalized === "false" || normalized === "0") {
+    return false;
+  }
+  return null;
 }
 function attachLifecycleListeners(inst) {
   try {
@@ -386,7 +600,26 @@ async function handleRequest(request, socket) {
       const connectUrl = args["connect-url"];
       const channel = args.channel;
       const profileDir = args["profile-dir"];
+      const cloudProfileId = typeof args["cloud-profile-id"] === "string" ? args["cloud-profile-id"].trim() : void 0;
+      const cloudProfileReuseIfActive = typeof args["cloud-profile-reuse-if-active"] === "boolean" ? args["cloud-profile-reuse-if-active"] : void 0;
+      const requestedCloudProfileBinding = normalizeCloudProfileBinding({
+        profileId: cloudProfileId,
+        reuseIfActive: cloudProfileReuseIfActive
+      });
+      const requestedCloudAuth = normalizeCliOpenCloudAuth(
+        args["cloud-auth"]
+      );
+      if (cloudProfileReuseIfActive !== void 0 && !cloudProfileId) {
+        throw new Error(
+          "--cloud-profile-reuse-if-active requires --cloud-profile-id."
+        );
+      }
+      const requestedCursor = normalizeCursorFlag(args.cursor);
       const requestedName = typeof args.name === "string" && args.name.trim().length > 0 ? sanitizeNamespace(args.name) : null;
+      if (requestedCursor !== null) {
+        cursorEnabledPreference = requestedCursor;
+      }
+      const effectiveCursorEnabled = cursorEnabledPreference !== null ? cursorEnabledPreference : true;
       if (selectorNamespace && requestedName && requestedName !== selectorNamespace) {
         sendResponse(socket, {
           id,
@@ -410,6 +643,9 @@ async function handleRequest(request, socket) {
         selectorNamespace = requestedName ?? logicalSession;
       }
       const activeNamespace = selectorNamespace ?? logicalSession;
+      if (requestedCloudAuth) {
+        cloudAuthOverride = requestedCloudAuth;
+      }
       if (instance && !launchPromise) {
         try {
           if (instance.page.isClosed()) {
@@ -419,31 +655,59 @@ async function handleRequest(request, socket) {
           invalidateInstance();
         }
       }
+      if (instance && !launchPromise) {
+        assertCompatibleCloudProfileBinding(
+          logicalSession,
+          cloudProfileBinding,
+          requestedCloudProfileBinding
+        );
+      }
       if (!instance) {
-        instance = new Opensteer({
-          name: activeNamespace,
-          browser: {
-            headless: headless ?? false,
+        instance = new Opensteer(
+          buildServerOpenConfig({
+            scopeDir,
+            name: activeNamespace,
+            cursorEnabled: effectiveCursorEnabled,
+            headless,
             connectUrl,
             channel,
-            profileDir
-          }
-        });
+            profileDir,
+            cloudAuth: cloudAuthOverride
+          })
+        );
+        const nextCloudProfileBinding = resolveSessionCloudProfileBinding(
+          instance.getConfig(),
+          requestedCloudProfileBinding
+        );
+        if (requestedCloudProfileBinding && !nextCloudProfileBinding) {
+          instance = null;
+          throw new Error(
+            "--cloud-profile-id can only be used when cloud mode is enabled for this session."
+          );
+        }
         launchPromise = instance.launch({
           headless: headless ?? false,
+          cloudBrowserProfile: cloudProfileId ? {
+            profileId: cloudProfileId,
+            reuseIfActive: cloudProfileReuseIfActive
+          } : void 0,
           timeout: connectUrl ? 12e4 : 3e4
         });
         try {
           await launchPromise;
           attachLifecycleListeners(instance);
+          cloudProfileBinding = nextCloudProfileBinding;
         } catch (err) {
           instance = null;
+          cloudProfileBinding = null;
           throw err;
         } finally {
           launchPromise = null;
         }
       } else if (launchPromise) {
         await launchPromise;
+      } else if (requestedCursor !== null) {
+        instance.setCursorEnabled(requestedCursor);
       }
       if (url) {
         await instance.goto(url);
@@ -458,6 +722,7 @@ async function handleRequest(request, socket) {
           runtimeSession: session,
           scopeDir,
           name: activeNamespace,
+          cursor: instance.getCursorState(),
           cloudSessionId: instance.getCloudSessionId() ?? void 0,
           cloudSessionUrl: instance.getCloudSessionUrl() ?? void 0
         }
@@ -470,6 +735,41 @@ async function handleRequest(request, socket) {
     }
     return;
   }
+  if (command === "cursor") {
+    try {
+      const mode = typeof args.mode === "string" ? args.mode : "status";
+      if (mode === "on") {
+        cursorEnabledPreference = true;
+        instance?.setCursorEnabled(true);
+      } else if (mode === "off") {
+        cursorEnabledPreference = false;
+        instance?.setCursorEnabled(false);
+      } else if (mode !== "status") {
+        throw new Error(
+          `Invalid cursor mode "${mode}". Use "on", "off", or "status".`
+        );
+      }
+      const defaultEnabled = cursorEnabledPreference !== null ? cursorEnabledPreference : true;
+      const cursor = instance ? instance.getCursorState() : {
+        enabled: defaultEnabled,
+        active: false,
+        reason: "session_not_open"
+      };
+      sendResponse(socket, {
+        id,
+        ok: true,
+        result: {
+          cursor
+        }
+      });
+    } catch (err) {
+      sendResponse(
+        socket,
+        buildErrorResponse(id, err, "Failed to update cursor mode.")
+      );
+    }
+    return;
+  }
   if (command === "close") {
     try {
       if (instance) {