@integrity-labs/agt-cli 0.28.318 → 0.28.320

package/dist/{chunk-4DHYHNCV.js → chunk-NAS4DZNG.js}

@@ -149,6 +149,13 @@ function probeMcpEnvSubstitution(args) {
 
 // ../../packages/core/dist/types/agent.js
 var DEFAULT_FRAMEWORK = "claude-code";
+var FRAMEWORK_DEPRECATION = {
+  "claude-code": false,
+  "opencode": false
+};
+function isDeprecatedFramework(id) {
+  return FRAMEWORK_DEPRECATION[id] === true;
+}
 
 // ../../packages/core/dist/types/models.js
 function claudeModelAlias(primaryModel) {
@@ -5067,7 +5074,12 @@ var INTEGRATION_REGISTRY = [
       },
       // ENG-5857 mints the real session id; default empty so the header
       // resolves cleanly (no profile bound → ephemeral session) until then.
-      envDefaults: { ANCHOR_BROWSER_SESSION_ID: "" }
+      envDefaults: { ANCHOR_BROWSER_SESSION_ID: "" },
+      // ENG-7748: route through the stdio remote-MCP proxy so the api-key and
+      // the minted anchor-session-id headers are read LIVE per request. A
+      // re-minted session id then takes effect with no agent respawn (a direct-
+      // HTTP header would be frozen at spawn).
+      liveHeaderRefresh: true
     }
   },
   {
@@ -5763,6 +5775,174 @@ var INSTALLABLE_NATIVE_INTEGRATION_IDS = INSTALLABLE_NATIVE_INTEGRATIONS.map((i)
 var MB2 = 1024 * 1024;
 var DIRECT_CHAT_UPLOAD_MAX_BYTES = 10 * MB2;
 
+// ../../packages/core/dist/anchor/types.js
+var ANCHOR_API_BASE_URL = "https://api.anchorbrowser.io/v1";
+var ANCHOR_API_KEY_HEADER = "anchor-api-key";
+
+// ../../packages/core/dist/anchor/client.js
+var AnchorApiError = class extends Error {
+  status;
+  body;
+  constructor(status, message, body) {
+    super(message);
+    this.name = "AnchorApiError";
+    this.status = status;
+    this.body = body;
+  }
+};
+function buildCreateSessionBody(input) {
+  const browser = {};
+  if (input.profileName) {
+    browser["profile"] = { name: input.profileName, persist: Boolean(input.persist) };
+  }
+  if (input.dedicatedStickyIp) {
+    browser["dedicated_sticky_ip"] = true;
+  }
+  const timeout = {};
+  if (typeof input.maxDurationMinutes === "number")
+    timeout["max_duration"] = input.maxDurationMinutes;
+  if (typeof input.idleTimeoutMinutes === "number")
+    timeout["idle_timeout"] = input.idleTimeoutMinutes;
+  const body = {};
+  if (Object.keys(browser).length > 0)
+    body["browser"] = browser;
+  if (Object.keys(timeout).length > 0)
+    body["session"] = { timeout };
+  return body;
+}
+function extractSessionId(raw) {
+  if (!raw || typeof raw !== "object")
+    return null;
+  const obj = raw;
+  const data = obj["data"];
+  const candidates = [
+    data && typeof data === "object" ? data["id"] : void 0,
+    data && typeof data === "object" ? data["session_id"] : void 0,
+    obj["id"],
+    obj["session_id"],
+    obj["sessionId"]
+  ];
+  for (const c of candidates) {
+    if (typeof c === "string" && c.length > 0)
+      return c;
+  }
+  return null;
+}
+function extractLiveViewUrl(raw) {
+  if (!raw || typeof raw !== "object")
+    return null;
+  const obj = raw;
+  const data = obj["data"];
+  const dataObj = data && typeof data === "object" ? data : void 0;
+  const candidates = [
+    dataObj?.["live_view_url"],
+    dataObj?.["liveViewUrl"],
+    obj["live_view_url"],
+    obj["liveViewUrl"]
+  ];
+  for (const c of candidates) {
+    if (typeof c === "string" && c.length > 0)
+      return c;
+  }
+  return null;
+}
+var AnchorSessionClient = class {
+  apiKey;
+  baseUrl;
+  timeoutMs;
+  fetchImpl;
+  constructor(opts) {
+    if (!opts.apiKey) {
+      throw new Error("AnchorSessionClient requires an apiKey");
+    }
+    this.apiKey = opts.apiKey;
+    this.baseUrl = (opts.baseUrl ?? ANCHOR_API_BASE_URL).replace(/\/+$/, "");
+    this.timeoutMs = opts.timeoutMs ?? 3e4;
+    this.fetchImpl = opts.fetchImpl ?? fetch;
+  }
+  /**
+   * Mint a session (`POST /sessions`). With a `profileName` the session resumes
+   * that profile's authenticated state; without one it is a fresh stateless
+   * browser. Throws {@link AnchorApiError} on a non-2xx, or a plain Error when
+   * the response carries no locatable session id.
+   */
+  async createSession(input = {}) {
+    const raw = await this.request("POST", "/sessions", buildCreateSessionBody(input));
+    const sessionId = extractSessionId(raw);
+    if (!sessionId) {
+      throw new Error("Anchor createSession returned no locatable session id");
+    }
+    const liveViewUrl = extractLiveViewUrl(raw);
+    return { sessionId, ...liveViewUrl ? { liveViewUrl } : {}, raw };
+  }
+  /**
+   * Snapshot a running session's authenticated state into a named profile
+   * (`POST /profiles` with `source: 'session'`). This is the explicit SAVE step
+   * for onboarding - separating it from `endSession` means an aborted onboarding
+   * can just end the session and persist NOTHING (a persist-on-end session would
+   * flush partial/unauthenticated state and could clobber a good profile).
+   * // anchor-verify: body shape from the ENG-5854 spike (verified live there).
+   */
+  async saveProfileFromSession(name, sessionId, opts = {}) {
+    await this.request("POST", "/profiles", {
+      name,
+      source: "session",
+      session_id: sessionId,
+      ...opts.dedicatedStickyIp ? { dedicated_sticky_ip: true } : {}
+    });
+  }
+  /**
+   * End a session (`DELETE /sessions/:id`). Best-effort by contract: a 404 (the
+   * session already expired) is treated as success - the goal state (no live
+   * session) is reached either way.
+   */
+  async endSession(sessionId) {
+    try {
+      await this.request("DELETE", `/sessions/${encodeURIComponent(sessionId)}`);
+    } catch (err) {
+      if (err instanceof AnchorApiError && err.status === 404)
+        return;
+      throw err;
+    }
+  }
+  // --- internals ----------------------------------------------------------
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    let res;
+    let text;
+    try {
+      res = await this.fetchImpl(url, {
+        method,
+        headers: {
+          [ANCHOR_API_KEY_HEADER]: this.apiKey,
+          ...body !== void 0 ? { "Content-Type": "application/json" } : {}
+        },
+        body: body !== void 0 ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      text = await res.text();
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      throw new AnchorApiError(0, `Anchor request failed: ${reason}`, void 0);
+    } finally {
+      clearTimeout(timer);
+    }
+    let parsed;
+    try {
+      parsed = text ? JSON.parse(text) : void 0;
+    } catch {
+      parsed = text;
+    }
+    if (!res.ok) {
+      const detail = typeof parsed === "object" && parsed !== null && "error" in parsed ? String(parsed.error) : res.statusText;
+      throw new AnchorApiError(res.status, `Anchor returned ${res.status}: ${detail}`, parsed);
+    }
+    return parsed;
+  }
+};
+
 // ../../packages/core/dist/onboarding/state-machine.js
 var AREA_ORDER = [
   "framing",
@@ -9722,6 +9902,7 @@ export {
   wrapScheduledTaskPrompt,
   buildScheduledTaskContextBlocks,
   DEFAULT_FRAMEWORK,
+  isDeprecatedFramework,
   registerFramework,
   getFramework,
   MAX_AVATAR_ENV_URL_BYTES,
@@ -9760,6 +9941,7 @@ export {
   probeComposioAccount,
   probeComposioMcpToolCall,
   probeHttpProvider,
+  AnchorSessionClient,
   isOnboardingArea,
   describeOnboardingChannel,
   coerceOnboardingState,
@@ -9845,4 +10027,4 @@ export {
   stopAllSessionsAndWait,
   getProjectDir
 };
-//# sourceMappingURL=chunk-4DHYHNCV.js.map
+//# sourceMappingURL=chunk-NAS4DZNG.js.map