dsh-opendesign-corouter 0.1.4 → 0.1.5

package/lib/index.js

@@ -2194,7 +2194,7 @@ import { randomUUID } from "node:crypto";
 
 // src/device-auth.ts
 var DEVICE_AUTH_ENDPOINT = "https://amr-api.open-design.ai/api/v1/cli/device-authorizations";
-var DEVICE_AUTH_PLUGIN_VERSION = "0.1.4";
+var DEVICE_AUTH_PLUGIN_VERSION = "0.1.5";
 var DEVICE_REQUEST_TIMEOUT_MS = 2e4;
 var DEVICE_RESPONSE_MAX_BYTES = 65536;
 var DEVICE_POLL_MIN_MS = 1e3;
@@ -2406,6 +2406,11 @@ var ConsoleLogin = class {
       } : {}
     };
   }
+  /** Host-only: the live approval link, so the Host can open it in a bounded window. */
+  activationLink() {
+    const status = this.status();
+    return status.state === "waiting" ? status.activationUrl : void 0;
+  }
   /** Synchronous/non-blocking and idempotent while capture/network/commit is pending. */
   start(request) {
     if (this.disposed) throw new LoginError("opendesign/login-disposed");
@@ -2421,7 +2426,8 @@ var ConsoleLogin = class {
       status: { jobId: null, state: "launching", startedAt: new Date(started).toISOString(), message: "\u6B63\u5728\u7533\u8BF7\u5B98\u65B9\u8BBE\u5907\u6388\u6743\u7801" },
       captured: void 0,
       committing: false,
-      cancelRequested: false
+      cancelRequested: false,
+      settled: false
     };
     job.status.jobId = job.id;
     this.job = job;
@@ -2446,7 +2452,11 @@ var ConsoleLogin = class {
   }
   dispose() {
     this.disposed = true;
-    if (this.job) this.requestCancellation(this.job, "\u670D\u52A1\u5DF2\u5378\u8F7D\uFF0C\u767B\u5F55\u5DF2\u53D6\u6D88");
+    const job = this.job;
+    if (job) {
+      this.requestCancellation(job, "\u670D\u52A1\u5DF2\u5378\u8F7D\uFF0C\u767B\u5F55\u5DF2\u53D6\u6D88");
+      this.settle(job);
+    }
   }
   alive(job) {
     return this.job === job && !this.disposed && !job.controller.signal.aborted && ACTIVE.has(job.status.state);
@@ -2495,6 +2505,16 @@ var ConsoleLogin = class {
     this.clearCode(job);
     this.stopTimer(job);
     job.controller.abort();
+    this.settle(job);
+  }
+  /** Report one terminal transition per job, exactly once. */
+  settle(job) {
+    if (job.settled) return;
+    job.settled = true;
+    try {
+      this.options.onSettled?.();
+    } catch {
+    }
   }
   async run(job) {
     const signal = job.controller.signal;
@@ -2514,7 +2534,7 @@ var ConsoleLogin = class {
     }
     this.armExpiry(job);
     job.status.state = "waiting";
-    job.status.message = "\u8BF7\u5728\u5E38\u7528\u6D4F\u89C8\u5668\u6253\u5F00\u5B98\u65B9\u6388\u6743\u9875\uFF0C\u4F7F\u7528\u5DF2\u4FDD\u5B58\u7684\u5BC6\u7801\u767B\u5F55\u5E76\u786E\u8BA4\u8BBE\u5907\u7801";
+    job.status.message = "\u8BF7\u5728\u6388\u6743\u7A97\u53E3\u6216\u5E38\u7528\u6D4F\u89C8\u5668\u6253\u5F00\u5B98\u65B9\u6388\u6743\u9875\uFF0C\u767B\u5F55\u5E76\u786E\u8BA4\u8BBE\u5907\u7801";
     job.status.activationUrl = device.activationUrl;
     job.status.userCode = device.userCode;
     job.status.expiresAt = new Date(job.deadline).toISOString();
@@ -2572,6 +2592,258 @@ function failureMessage(error) {
   return "\u8BBE\u5907\u6388\u6743\u8BF7\u6C42\u5931\u8D25\uFF0C\u8BF7\u91CD\u65B0\u5F00\u59CB";
 }
 
+// src/browser-open.ts
+var ACTIVATION_NAVIGATE_TIMEOUT_MS = 15e3;
+var ACTIVATION_OPEN_BUDGET_MS = 2e4;
+var ACTIVATION_CLOSE_TIMEOUT_MS = 5e3;
+function chromeLaunchOptions() {
+  return {
+    channel: "chrome",
+    headless: false,
+    chromiumSandbox: true,
+    ignoreDefaultArgs: ["--enable-automation"],
+    args: ["--disable-blink-features=AutomationControlled"]
+  };
+}
+var ActivationLauncher = class {
+  browser;
+  page;
+  pending;
+  disposal;
+  /** In-flight window closure, shared so disposal can join it. */
+  closing;
+  /** Closures of handles that were never adopted; disposal joins them too. */
+  tracked = [];
+  /** Chrome starts in flight, so disposal waits for the handle they will produce. */
+  starting = [];
+  disposed = false;
+  /** Bumped by `close()`: an attempt from an older session must not resurrect a window. */
+  session = 0;
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /**
+   * Show `url` in the temporary window, reusing one already open. Concurrent calls share
+   * a single attempt: the caller's button stays honest about what actually happened.
+   */
+  async open(url) {
+    if (validateActivationUrl(url) === null) return { code: "invalid-url", opened: false };
+    if (this.disposed) return { code: "failed", opened: false };
+    if (this.pending) return this.pending;
+    const attempt = this.attempt(url);
+    this.pending = attempt;
+    try {
+      return await attempt;
+    } finally {
+      if (this.pending === attempt) this.pending = void 0;
+    }
+  }
+  /**
+   * Close the temporary window and stay usable: a cancelled or expired job takes its
+   * window away, while the next login may open a new one.
+   */
+  async close() {
+    this.session++;
+    await this.closeCurrent();
+  }
+  /**
+   * Retire the launcher for good. Cleanup is best-effort and bounded: it joins in-flight
+   * starts and closures, but a browser that ignores `close()` may outlive the 5 s wait.
+   */
+  async dispose() {
+    this.disposed = true;
+    this.session++;
+    if (this.disposal) return this.disposal;
+    this.disposal = (async () => {
+      await this.bounded(Date.now() + ACTIVATION_CLOSE_TIMEOUT_MS, async () => {
+        await Promise.allSettled(this.starting);
+      });
+      await this.closing;
+      await this.closeCurrent();
+      await this.bounded(Date.now() + ACTIVATION_CLOSE_TIMEOUT_MS, async () => {
+        await Promise.all(this.tracked);
+      });
+    })();
+    return this.disposal;
+  }
+  /**
+   * Close the window this launcher owns right now. Ownership is taken before the async
+   * close, so a job that adopts a new window afterwards is not affected by this closure.
+   * The closure promise is shared so a later `dispose()` joins it.
+   */
+  async closeCurrent() {
+    if (this.closing === void 0) {
+      const browser = this.browser;
+      this.browser = void 0;
+      this.page = void 0;
+      if (browser === void 0) return;
+      this.closing = closeBounded(browser);
+    }
+    const closing = this.closing;
+    try {
+      await closing;
+    } finally {
+      if (this.closing === closing) this.closing = void 0;
+    }
+  }
+  async attempt(url) {
+    const session = this.session;
+    const budget = this.options.timeoutMs ?? ACTIVATION_OPEN_BUDGET_MS;
+    const deadline = Date.now() + budget;
+    try {
+      if (this.options.available?.() === false) return { code: "unavailable", opened: false };
+      const browser = await this.ensureBrowser(session, deadline);
+      if (browser === void 0) return { code: this.stale(session) ? "failed" : "unavailable", opened: false };
+      if (this.stale(session)) {
+        await this.bounded(deadline, () => this.closeCurrent());
+        return { code: "failed", opened: false };
+      }
+      const page = await this.ensurePage(browser, session, deadline);
+      if (page === void 0) {
+        await this.bounded(deadline, () => this.closeCurrent());
+        return { code: "failed", opened: false };
+      }
+      const remaining = Math.max(1, Math.min(ACTIVATION_NAVIGATE_TIMEOUT_MS, deadline - Date.now()));
+      await page.goto(url, { waitUntil: "domcontentloaded", timeout: remaining });
+      if (this.stale(session)) {
+        await this.bounded(deadline, () => this.closeCurrent());
+        return { code: "failed", opened: false };
+      }
+      return { code: "opened", opened: true };
+    } catch {
+      await this.bounded(deadline, () => this.closeCurrent());
+      return { code: "failed", opened: false };
+    }
+  }
+  /** The job that started this attempt ended, or the launcher retired. */
+  stale(session) {
+    return this.disposed || session !== this.session;
+  }
+  async ensureBrowser(session, deadline) {
+    const open = this.browser;
+    if (open !== void 0) {
+      try {
+        if (open.isConnected()) return open;
+      } catch {
+      }
+      await this.bounded(deadline, () => this.closeCurrent());
+    }
+    for (let round = 0; round < 2; round++) {
+      await this.bounded(deadline, async () => {
+        await Promise.allSettled([this.closing, ...this.tracked, ...this.starting]);
+      });
+      if (this.stale(session) || Date.now() >= deadline) return void 0;
+      if (this.closing === void 0 && this.tracked.length === 0 && this.starting.length === 0) break;
+    }
+    if (this.stale(session) || Date.now() >= deadline) return void 0;
+    const launch = this.options.launch ?? defaultLaunch;
+    const starting = launch();
+    this.starting.push(starting);
+    const browser = await this.bounded(deadline, () => starting);
+    void starting.then((handle) => {
+      if (handle !== browser) void this.trackClose(handle);
+    }).catch(() => void 0).finally(() => {
+      this.starting = this.starting.filter((item) => item !== starting);
+    });
+    if (browser === void 0) return void 0;
+    if (this.stale(session)) {
+      void this.trackClose(browser);
+      return void 0;
+    }
+    this.adopt(browser);
+    return browser;
+  }
+  async ensurePage(browser, session, deadline) {
+    if (this.page !== void 0) return this.page;
+    const page = await this.bounded(deadline, () => browser.newPage(), (late) => {
+      void this.trackPageClose(late);
+    });
+    if (page === void 0) return void 0;
+    if (this.stale(session) || this.browser !== browser) {
+      await this.bounded(deadline, () => this.closeCurrent());
+      return void 0;
+    }
+    this.page = page;
+    return page;
+  }
+  /** A handle that arrived too late is closed, and still counts as work disposal joins. */
+  trackClose(browser) {
+    const closing = closeBounded(browser);
+    this.tracked.push(closing);
+    void closing.finally(() => {
+      this.tracked = this.tracked.filter((item) => item !== closing);
+    });
+    return closing;
+  }
+  trackPageClose(page) {
+    try {
+      return Promise.resolve(page.close?.()).catch(() => void 0);
+    } catch {
+      return Promise.resolve();
+    }
+  }
+  adopt(browser) {
+    this.browser = browser;
+    browser.on?.("disconnected", () => {
+      if (this.browser === browser) {
+        this.browser = void 0;
+        this.page = void 0;
+      }
+    });
+  }
+  /**
+   * Bound one launch step by the attempt's shared deadline. A step that settles only
+   * after that deadline still hands its handle back: dropping it would leak a Chrome
+   * process nobody can close.
+   */
+  async bounded(deadline, start, discardOnLate) {
+    let timer;
+    let expired = false;
+    const work = (async () => {
+      try {
+        return await start();
+      } catch {
+        return void 0;
+      }
+    })().then((value) => {
+      if (expired && value !== void 0) discardOnLate?.(value);
+      return value;
+    });
+    const timeout = new Promise((resolve) => {
+      timer = setTimeout(() => {
+        expired = true;
+        resolve(void 0);
+      }, Math.max(1, deadline - Date.now()));
+    });
+    try {
+      return await Promise.race([work, timeout]);
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+    }
+  }
+};
+function closeBounded(browser) {
+  let timer;
+  return Promise.race([
+    (async () => {
+      try {
+        await browser.close();
+      } catch {
+      }
+    })(),
+    new Promise((resolve) => {
+      timer = setTimeout(resolve, ACTIVATION_CLOSE_TIMEOUT_MS);
+    })
+  ]).finally(() => {
+    if (timer !== void 0) clearTimeout(timer);
+  });
+}
+async function defaultLaunch() {
+  const playwright = await import("playwright-core");
+  return playwright.chromium.launch(chromeLaunchOptions());
+}
+
 // src/quota.ts
 import { attributionHeaders as attributionHeaders3 } from "@deepseek-ai/dsh-llm";
 var API_BASE = "https://amr-api.open-design.ai/api/v1";
@@ -2859,6 +3131,7 @@ var MAX_API_KEY = 16384;
 var HTTP_ASCII = /^[\x21-\x7e]+$/u;
 var ENV_REF = /^[A-Za-z_][A-Za-z0-9_]*$/u;
 var MODEL_ID2 = /^[A-Za-z0-9._:/-]{1,128}$/u;
+var ACTIVATION_OPEN_CODES = ["opened", "no-link", "invalid-url", "unavailable", "failed"];
 var LOGIN_PHASES = ["idle", "launching", "waiting", "verifying", "success", "cancelled", "error"];
 var QUOTA_STATES = ["ok", "partial", "need-login", "error"];
 var SESSION_SOURCES = ["desktop", "login", "environment"];
@@ -3034,6 +3307,10 @@ function parseSaveApiKeyRequest(value) {
   if (key.length > MAX_API_KEY) throw new Error(`API Key \u4E0D\u80FD\u8D85\u8FC7 ${MAX_API_KEY} \u5B57\u7B26`);
   return { value: key, expectedRevision: text(value.expectedRevision, "\u914D\u7F6E\u7248\u672C", MAX_REVISION) };
 }
+function parseActivationOpenState(value) {
+  if (!record(value)) throw new Error("\u6388\u6743\u9875\u6253\u5F00\u7ED3\u679C\u5FC5\u987B\u662F\u5BF9\u8C61");
+  return { code: member(value.code, ACTIVATION_OPEN_CODES, "\u6388\u6743\u9875\u6253\u5F00\u7ED3\u679C"), opened: flag(value.opened, "\u6388\u6743\u9875\u662F\u5426\u5DF2\u6253\u5F00") };
+}
 
 // src/index.ts
 var name = "llm-opendesign-corouter";
@@ -3048,14 +3325,15 @@ function grantOf(value) {
   if (typeof value.payload.cookie !== "string") return;
   return { cookie: value.payload.cookie, ...typeof value.payload.expiresAt === "number" ? { expiresAt: value.payload.expiresAt } : {} };
 }
-var _saveApiKey_dec, _cancelLogin_dec, _loginStatus_dec, _startLogin_dec, _refreshQuotaNow_dec, _refreshQuota_dec, _refreshModels_dec, _status_dec, _a, _init;
-var OpenDesignCoRouterService = class extends (_a = TypertRemoteService, _status_dec = [Remote("status")], _refreshModels_dec = [Remote("refreshModels")], _refreshQuota_dec = [Remote("refreshQuota")], _refreshQuotaNow_dec = [Remote("refreshQuotaNow")], _startLogin_dec = [Remote("startLogin")], _loginStatus_dec = [Remote("loginStatus")], _cancelLogin_dec = [Remote("cancelLogin")], _saveApiKey_dec = [Remote("saveApiKey")], _a) {
+var _saveApiKey_dec, _openActivationPage_dec, _cancelLogin_dec, _loginStatus_dec, _startLogin_dec, _refreshQuotaNow_dec, _refreshQuota_dec, _refreshModels_dec, _status_dec, _a, _init;
+var OpenDesignCoRouterService = class extends (_a = TypertRemoteService, _status_dec = [Remote("status")], _refreshModels_dec = [Remote("refreshModels")], _refreshQuota_dec = [Remote("refreshQuota")], _refreshQuotaNow_dec = [Remote("refreshQuotaNow")], _startLogin_dec = [Remote("startLogin")], _loginStatus_dec = [Remote("loginStatus")], _cancelLogin_dec = [Remote("cancelLogin")], _openActivationPage_dec = [Remote("openActivationPage")], _saveApiKey_dec = [Remote("saveApiKey")], _a) {
   constructor(ctx, config, dependencies = { resolveSession, readQuota, readDesktopQuota }) {
     super(ctx, "openDesignCoRouter");
     this.dependencies = dependencies;
     __runInitializers(_init, 5, this);
     __publicField(this, "_config");
     __publicField(this, "_login");
+    __publicField(this, "_activation");
     __publicField(this, "_lifetime", new AbortController());
     __publicField(this, "_revision", randomUUID2());
     __publicField(this, "_fingerprint", "");
@@ -3098,10 +3376,19 @@ var OpenDesignCoRouterService = class extends (_a = TypertRemoteService, _status
         this._modelsFingerprint = "";
         this._invalidateModels();
       }
-    }, dependencies.loginOptions);
+    }, {
+      ...dependencies.loginOptions,
+      // The Host owns the temporary window, so it closes it on every terminal transition —
+      // including expiry, which happens on a timer even when no UI is polling.
+      onSettled: () => {
+        void this._activation.close();
+      }
+    });
+    this._activation = new ActivationLauncher(dependencies.activationOptions);
     ctx.effect(() => () => {
       this._lifetime.abort();
       this._login.dispose();
+      return this._activation.dispose();
     });
   }
   dependencies;
@@ -3353,6 +3640,12 @@ var OpenDesignCoRouterService = class extends (_a = TypertRemoteService, _status
   cancelLogin(input) {
     return parseLoginState(this._login.cancel(parseCancelLoginRequest(input)));
   }
+  async openActivationPage() {
+    const url = this._login.activationLink();
+    if (url === void 0) return { code: "no-link", opened: false };
+    const result = await this._activation.open(url);
+    return parseActivationOpenState({ code: result.code, opened: result.opened });
+  }
   async saveApiKey(input) {
     const request = parseSaveApiKeyRequest(input), state = await this._state();
     this._expect(request.expectedRevision);
@@ -3372,6 +3665,7 @@ __decorateElement(_init, 1, "refreshQuotaNow", _refreshQuotaNow_dec, OpenDesignC
 __decorateElement(_init, 1, "startLogin", _startLogin_dec, OpenDesignCoRouterService);
 __decorateElement(_init, 1, "loginStatus", _loginStatus_dec, OpenDesignCoRouterService);
 __decorateElement(_init, 1, "cancelLogin", _cancelLogin_dec, OpenDesignCoRouterService);
+__decorateElement(_init, 1, "openActivationPage", _openActivationPage_dec, OpenDesignCoRouterService);
 __decorateElement(_init, 1, "saveApiKey", _saveApiKey_dec, OpenDesignCoRouterService);
 __decoratorMetadata(_init, OpenDesignCoRouterService);
 function apply(ctx, config) {