@opengeni/codemode 0.2.2 → 0.4.2

package/dist/environment.d.ts

@@ -1,8 +1,11 @@
 import { CodemodeClient, type CodemodeToolFunction } from "./index.js";
 export declare const CODEMODE_ENVIRONMENT: {
     readonly url: "OPENGENI_CODEMODE_URL";
+    readonly token: "OPENGENI_CODEMODE_TOKEN";
     readonly tokenFile: "OPENGENI_CODEMODE_TOKEN_FILE";
 };
+/** Minimal environment shape; public declarations must not require `@types/node`. */
+export type CodemodeEnvironment = Readonly<Record<string, string | undefined>>;
 export type CodemodeClientProvider = () => CodemodeClient | Promise<CodemodeClient>;
 /** A lazy catalog path. Every nested property remains callable at runtime. */
 export type CodemodeDynamicTool = CodemodeToolFunction & {
@@ -19,7 +22,7 @@ export type CodemodeToolsNamespace = CodemodeDynamicTools & CodemodeGeneratedToo
  * Build (or reuse) the persistent client for the exact sandbox attempt.
  * The bearer file is reread for every HTTP request so worker renewal is live.
  */
-export declare function environmentCodemodeClient(environment?: NodeJS.ProcessEnv): CodemodeClient;
+export declare function environmentCodemodeClient(environment?: CodemodeEnvironment): CodemodeClient;
 /**
  * Lazy namespace used by ordinary sandbox programs:
  * `await tools.slack.search({ query: "..." })`.

package/dist/index.js

@@ -20,19 +20,21 @@ import {
 import { readFile } from "fs/promises";
 var CODEMODE_ENVIRONMENT = {
   url: "OPENGENI_CODEMODE_URL",
+  token: "OPENGENI_CODEMODE_TOKEN",
   tokenFile: "OPENGENI_CODEMODE_TOKEN_FILE"
 };
 var cachedEnvironmentClient = null;
 function environmentCodemodeClient(environment = process.env) {
   const baseUrl = requiredEnvironment(environment, CODEMODE_ENVIRONMENT.url);
-  const tokenFile = requiredEnvironment(environment, CODEMODE_ENVIRONMENT.tokenFile);
-  const key = `${baseUrl}\0${tokenFile}`;
+  const directTokenConfigured = environment[CODEMODE_ENVIRONMENT.token] !== void 0;
+  const tokenFile = directTokenConfigured ? void 0 : requiredEnvironment(environment, CODEMODE_ENVIRONMENT.tokenFile);
+  const key = `${baseUrl}\0${directTokenConfigured ? "direct" : `file:${tokenFile}`}`;
   if (environment === process.env && cachedEnvironmentClient?.key === key) {
     return cachedEnvironmentClient.client;
   }
   const client = new CodemodeClient({
     baseUrl,
-    token: async () => await readBearerFile(tokenFile)
+    token: directTokenConfigured ? async () => requiredEnvironment(environment, CODEMODE_ENVIRONMENT.token) : async () => await readBearerFile(tokenFile)
   });
   if (environment === process.env) cachedEnvironmentClient = { key, client };
   return client;
@@ -294,13 +296,17 @@ var PATH2 = {
   browserTabs: ["interaction", "browser", "tabs"],
   browserObserve: ["interaction", "browser", "observe"],
   browserAct: ["interaction", "browser", "act"],
+  browserClipboard: ["interaction", "browser", "clipboard"],
   browserDebug: ["interaction", "browser", "debug"],
+  browserAuth: ["interaction", "browser", "auth"],
+  requestHuman: ["interaction", "requestHuman"],
   browserIdentity: ["interaction", "browser", "identity"],
   browserPublish: ["interaction", "browser", "publish"],
   browserLifecycle: ["interaction", "browser", "lifecycle"],
   computerOpen: ["interaction", "computer", "open"],
   computerTargets: ["interaction", "computer", "targets"],
   computerObserve: ["interaction", "computer", "observe"],
+  computerClipboard: ["interaction", "computer", "clipboard"],
   computerAct: ["interaction", "computer", "act"],
   computerLifecycle: ["interaction", "computer", "lifecycle"]
 };
@@ -308,15 +314,20 @@ var OpenGeniCodemode = class {
   browsers;
   computers;
   artifacts;
+  auth;
   constructor(client = () => environmentCodemodeClient()) {
     const provider = codemodeClientProvider(client);
     this.browsers = new CodemodeBrowserCollection(provider);
     this.computers = new CodemodeComputerCollection(provider);
     this.artifacts = new CodemodeArtifactCollection(provider);
+    this.auth = new CodemodeAuth(provider);
   }
   async discover(options = {}, callOptions = {}) {
     return await callStructured(this.browsers.client, PATH2.discover, options, callOptions);
   }
+  async requestHuman(request, callOptions = {}) {
+    return await callStructured(this.browsers.client, PATH2.requestHuman, request, callOptions);
+  }
 };
 var CodemodeBrowserCollection = class {
   constructor(client) {
@@ -365,14 +376,27 @@ var CodemodeBrowserIdentityCollection = class {
     const response = await callStructured(this.client, PATH2.browserIdentity, { operation: "revisions", identityId }, callOptions);
     return response.result;
   }
+  async update(identityId, update, callOptions = {}) {
+    const response = await callStructured(
+      this.client,
+      PATH2.browserIdentity,
+      { operation: "update", identityId, ...update },
+      callOptions
+    );
+    return response.result;
+  }
 };
 var CodemodeBrowser = class {
   constructor(client, id) {
     this.client = client;
     this.id = id;
     this.tabs = new CodemodeBrowserTabCollection(client, id);
+    this.auth = new CodemodeBrowserAuth(client, id);
+    this.clipboard = new CodemodeBrowserClipboard(client, id, this.tabs);
   }
   tabs;
+  auth;
+  clipboard;
   async refresh(callOptions = {}) {
     const result = await callStructured(
       this.client,
@@ -427,6 +451,69 @@ var CodemodeBrowser = class {
     );
   }
 };
+var CodemodeBrowserClipboard = class {
+  constructor(client, browserSessionId, tabs) {
+    this.client = client;
+    this.browserSessionId = browserSessionId;
+    this.tabs = tabs;
+  }
+  async read(callOptions = {}) {
+    return await callStructured(
+      this.client,
+      PATH2.browserClipboard,
+      { browserSessionId: this.browserSessionId },
+      callOptions
+    );
+  }
+  async write(text, options = {}, callOptions = {}) {
+    return await this.act({ type: "clipboard", operation: "write", text }, options, callOptions);
+  }
+  async clear(options = {}, callOptions = {}) {
+    return await this.act({ type: "clipboard", operation: "clear" }, options, callOptions);
+  }
+  async copy(options = {}, callOptions = {}) {
+    const {
+      targetId,
+      expectedTargetGeneration,
+      expectedDocumentGeneration,
+      expectedFrameId,
+      ...copy
+    } = options;
+    return await this.act(
+      { type: "clipboard", operation: "copy", ...copy },
+      {
+        targetId,
+        expectedTargetGeneration,
+        expectedDocumentGeneration,
+        expectedFrameId
+      },
+      callOptions
+    );
+  }
+  async paste(options = {}, callOptions = {}) {
+    const {
+      targetId,
+      expectedTargetGeneration,
+      expectedDocumentGeneration,
+      expectedFrameId,
+      ...paste
+    } = options;
+    return await this.act(
+      { type: "clipboard", operation: "paste", ...paste },
+      {
+        targetId,
+        expectedTargetGeneration,
+        expectedDocumentGeneration,
+        expectedFrameId
+      },
+      callOptions
+    );
+  }
+  async act(action, options, callOptions) {
+    const { targetId, ...fences } = options;
+    return await this.tabs.use(await this.tabs.resolveId(targetId, callOptions)).act(action, fences, callOptions);
+  }
+};
 var CodemodeBrowserTabCollection = class {
   constructor(client, browserSessionId) {
     this.client = client;
@@ -523,6 +610,30 @@ var CodemodeBrowserTab = class {
   async navigate(url, callOptions = {}) {
     return await this.act({ type: "navigate", url }, {}, callOptions);
   }
+  async setPermission(permission, setting, fences = {}, callOptions = {}) {
+    return await this.act({ type: "permission", permission, setting }, fences, callOptions);
+  }
+  async requestHuman(reason, options = {}, callOptions = {}) {
+    const observation = await this.observe(callOptions);
+    return await callStructured(
+      this.client,
+      PATH2.requestHuman,
+      {
+        operation: "request",
+        resourceKind: "browser_session",
+        resourceId: this.browserSessionId,
+        targetId: this.id,
+        expectedControllerGeneration: observation.target.controllerGeneration,
+        expectedTargetGeneration: observation.target.targetGeneration,
+        expectedDocumentGeneration: observation.target.documentGeneration,
+        kind: options.kind ?? "other",
+        reason,
+        ...options.authRunId ? { authRunId: options.authRunId } : {},
+        ...options.expiresInSeconds === void 0 ? {} : { expiresInSeconds: options.expiresInSeconds }
+      },
+      callOptions
+    );
+  }
   getByRole(role, options = {}) {
     return new CodemodeBrowserLocator(this, { kind: "role", role, ...options });
   }
@@ -579,6 +690,147 @@ var CodemodeBrowserLocator = class {
     return await this.tab.act({ type: "check", locator: this.locator, checked }, {}, callOptions);
   }
 };
+var CodemodeAuth = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async listConnections(options = {}, callOptions = {}) {
+    const response = await callStructured(this.client, PATH2.browserAuth, { operation: "list_connections", ...options }, callOptions);
+    return response.result;
+  }
+  async getConnection(siteAuthConnectionId, callOptions = {}) {
+    const response = await callStructured(
+      this.client,
+      PATH2.browserAuth,
+      { operation: "get_connection", siteAuthConnectionId },
+      callOptions
+    );
+    return response.result;
+  }
+  async listRuns(options = {}, callOptions = {}) {
+    const response = await callStructured(
+      this.client,
+      PATH2.browserAuth,
+      { operation: "list_runs", ...options },
+      callOptions
+    );
+    return response.result;
+  }
+  async getRun(authRunId, callOptions = {}) {
+    const response = await callStructured(
+      this.client,
+      PATH2.browserAuth,
+      { operation: "get_run", authRunId },
+      callOptions
+    );
+    return response.result;
+  }
+  use(browserSessionId, authRunId) {
+    return new CodemodeAuthRun(this.client, browserSessionId, authRunId);
+  }
+};
+var CodemodeBrowserAuth = class {
+  constructor(client, browserSessionId) {
+    this.client = client;
+    this.browserSessionId = browserSessionId;
+  }
+  async listRuns(options = {}, callOptions = {}) {
+    const response = await callStructured(
+      this.client,
+      PATH2.browserAuth,
+      { operation: "list_runs", browserSessionId: this.browserSessionId, ...options },
+      callOptions
+    );
+    return response.result;
+  }
+  async start(request, callOptions = {}) {
+    const response = await callStructured(
+      this.client,
+      PATH2.browserAuth,
+      { operation: "start", browserSessionId: this.browserSessionId, ...request },
+      callOptions
+    );
+    return this.use(response.result.run.id);
+  }
+  use(authRunId) {
+    return new CodemodeAuthRun(this.client, this.browserSessionId, authRunId);
+  }
+};
+var CodemodeAuthRun = class {
+  constructor(client, browserSessionId, id) {
+    this.client = client;
+    this.browserSessionId = browserSessionId;
+    this.id = id;
+  }
+  async get(callOptions = {}) {
+    const response = await callStructured(
+      this.client,
+      PATH2.browserAuth,
+      { operation: "get_run", authRunId: this.id },
+      callOptions
+    );
+    if (response.result.browserSessionId !== this.browserSessionId) {
+      throw new Error("Auth run belongs to another BrowserSession");
+    }
+    return response.result;
+  }
+  async report(request, callOptions = {}) {
+    const response = await callStructured(
+      this.client,
+      PATH2.browserAuth,
+      {
+        operation: "report",
+        browserSessionId: this.browserSessionId,
+        authRunId: this.id,
+        ...request
+      },
+      callOptions
+    );
+    return response.result;
+  }
+  async protectedFill(request, callOptions = {}) {
+    const response = await callStructured(
+      this.client,
+      PATH2.browserAuth,
+      {
+        operation: "protected_fill",
+        browserSessionId: this.browserSessionId,
+        authRunId: this.id,
+        ...request
+      },
+      callOptions
+    );
+    return response.result;
+  }
+  async advanceExternal(request, callOptions = {}) {
+    const response = await callStructured(
+      this.client,
+      PATH2.browserAuth,
+      {
+        operation: "advance_external",
+        browserSessionId: this.browserSessionId,
+        authRunId: this.id,
+        ...request
+      },
+      callOptions
+    );
+    return response.result;
+  }
+  async verify(request, callOptions = {}) {
+    const response = await callStructured(
+      this.client,
+      PATH2.browserAuth,
+      {
+        operation: "verify",
+        browserSessionId: this.browserSessionId,
+        authRunId: this.id,
+        ...request
+      },
+      callOptions
+    );
+    return response.result;
+  }
+};
 var CodemodeComputerCollection = class {
   constructor(client) {
     this.client = client;
@@ -605,9 +857,11 @@ var CodemodeComputer = class {
     this.id = id;
     this.targets = new CodemodeComputerTargetCollection(client, id);
     this.apps = this.targets;
+    this.clipboard = new CodemodeComputerClipboard(client, id, this.targets);
   }
   targets;
   apps;
+  clipboard;
   async refresh(callOptions = {}) {
     const result = await callStructured(
       this.client,
@@ -637,6 +891,37 @@ var CodemodeComputer = class {
     );
   }
 };
+var CodemodeComputerClipboard = class {
+  constructor(client, computerSessionId, targets) {
+    this.client = client;
+    this.computerSessionId = computerSessionId;
+    this.targets = targets;
+  }
+  async read(callOptions = {}) {
+    return await callStructured(
+      this.client,
+      PATH2.computerClipboard,
+      { computerSessionId: this.computerSessionId },
+      callOptions
+    );
+  }
+  async write(text, options = {}, callOptions = {}) {
+    return await this.mutate({ type: "clipboard", operation: "write", text }, options, callOptions);
+  }
+  async clear(options = {}, callOptions = {}) {
+    return await this.mutate({ type: "clipboard", operation: "clear" }, options, callOptions);
+  }
+  async copy(options = {}, callOptions = {}) {
+    return await this.mutate({ type: "clipboard", operation: "copy" }, options, callOptions);
+  }
+  async paste(options = {}, callOptions = {}) {
+    return await this.mutate({ type: "clipboard", operation: "paste" }, options, callOptions);
+  }
+  async mutate(action, options, callOptions) {
+    const targetId = await this.targets.resolveSeatId(options.targetId, callOptions);
+    return await this.targets.use(targetId).act(action, {}, callOptions);
+  }
+};
 var CodemodeComputerTargetCollection = class {
   constructor(client, computerSessionId) {
     this.client = client;
@@ -671,6 +956,13 @@ var CodemodeComputerTargetCollection = class {
       throw new Error("Computer has no app, window, or screen targets");
     throw new Error("Computer target is ambiguous; select an exact app or window");
   }
+  async resolveSeatId(targetId, callOptions) {
+    if (targetId) return await this.resolveId(targetId, callOptions);
+    const listed = await this.list(callOptions);
+    const screens = listed.targets.filter((target) => target.kind === "screen");
+    if (screens.length === 1) return screens[0].id;
+    return await this.resolveId(void 0, callOptions);
+  }
 };
 var CodemodeComputerTarget = class {
   constructor(client, computerSessionId, id) {
@@ -694,6 +986,26 @@ var CodemodeComputerTarget = class {
       callOptions
     );
   }
+  async requestHuman(reason, options = {}, callOptions = {}) {
+    const observation = await this.observe(callOptions);
+    return await callStructured(
+      this.client,
+      PATH2.requestHuman,
+      {
+        operation: "request",
+        resourceKind: "computer_session",
+        resourceId: this.computerSessionId,
+        targetId: this.id,
+        expectedControllerGeneration: observation.target.controllerGeneration,
+        expectedTargetGeneration: observation.target.targetGeneration,
+        expectedDocumentGeneration: null,
+        kind: options.kind ?? "other",
+        reason,
+        ...options.expiresInSeconds === void 0 ? {} : { expiresInSeconds: options.expiresInSeconds }
+      },
+      callOptions
+    );
+  }
   getByRole(role, options = {}) {
     return new CodemodeComputerLocator(this, { kind: "role", role, ...options });
   }
@@ -1206,7 +1518,12 @@ var CodemodeClient = class {
       method: "POST",
       ...signal ? { signal } : {},
       headers: { "content-type": "application/json" },
-      body: JSON.stringify({ operationId, catalogDigest, identity, arguments: argumentsValue })
+      body: JSON.stringify({
+        operationId,
+        catalogDigest,
+        identity,
+        arguments: argumentsValue
+      })
     });
     return CodemodeCallSubmission.parse(await response.json()).operation;
   }
@@ -1390,6 +1707,8 @@ function assertCatalogSize(catalog) {
     throw new AttemptToolCatalogTooLargeError();
   }
 }
+var COMPILED_CATALOG_SCHEMA_CACHE_MAX_ENTRIES = 512;
+var compiledCatalogSchemaCache = /* @__PURE__ */ new Map();
 function createSchemaValidators() {
   const options = {
     allErrors: false,
@@ -1406,9 +1725,22 @@ function createSchemaValidators() {
 }
 function compileCatalogSchema(validators, schema) {
   const dialect = typeof schema.$schema === "string" ? schema.$schema : "";
-  if (dialect.includes("2020-12")) return validators.draft2020.compile(schema);
-  if (dialect.includes("2019-09")) return validators.draft2019.compile(schema);
-  return validators.draft7.compile(schema);
+  const family = dialect.includes("2020-12") ? "2020-12" : dialect.includes("2019-09") ? "2019-09" : "draft7";
+  const cacheKey = `${family}:${digestCanonicalJson(schema)}`;
+  const cached = compiledCatalogSchemaCache.get(cacheKey);
+  if (cached) {
+    compiledCatalogSchemaCache.delete(cacheKey);
+    compiledCatalogSchemaCache.set(cacheKey, cached);
+    return cached;
+  }
+  const compiled = family === "2020-12" ? validators.draft2020.compile(schema) : family === "2019-09" ? validators.draft2019.compile(schema) : validators.draft7.compile(schema);
+  while (compiledCatalogSchemaCache.size >= COMPILED_CATALOG_SCHEMA_CACHE_MAX_ENTRIES) {
+    const oldest = compiledCatalogSchemaCache.keys().next().value;
+    if (oldest === void 0) break;
+    compiledCatalogSchemaCache.delete(oldest);
+  }
+  compiledCatalogSchemaCache.set(cacheKey, compiled);
+  return compiled;
 }
 function allocateCodemodePaths(definitions) {
   const bases = definitions.map(
@@ -1501,7 +1833,11 @@ export {
   CodemodeArtifact,
   CodemodeArtifactCollection,
   CodemodeArtifactExport,
+  CodemodeAuth,
+  CodemodeAuthRun,
   CodemodeBrowser,
+  CodemodeBrowserAuth,
+  CodemodeBrowserClipboard,
   CodemodeBrowserCollection,
   CodemodeBrowserIdentityCollection,
   CodemodeBrowserLocator,
@@ -1509,6 +1845,7 @@ export {
   CodemodeBrowserTabCollection,
   CodemodeClient,
   CodemodeComputer,
+  CodemodeComputerClipboard,
   CodemodeComputerCollection,
   CodemodeComputerLocator,
   CodemodeComputerTarget,