@huaweidevtools/aishell-dsh-e2b 0.0.15 → 0.0.17

package/lib/index.js

@@ -901,10 +901,9 @@ defineMethod("transform", [
 /**
 * How many pages of a list response to follow before giving up.
 *
-* The gateway pages at 100 and reports more with a cursor, so this is a bound
-* of 1000 sandboxes. It exists to stop a filter that matches nothing from
-* walking an entire account one page at a time; no deployment this plugin is
-* used against should reach it.
+* Bounds one listing at 1000 sandboxes. A filter that matches nothing would
+* otherwise walk an entire account one page at a time; no deployment this
+* plugin is used against should reach the cap.
 */
 const MAX_LIST_PAGES = 10;
 /**
@@ -964,6 +963,41 @@ var SandboxClient = class {
 		return sandbox;
 	}
 	/**
+	* Walk the sandbox listing, following the pagination cursor.
+	*
+	* ## Why it follows the cursor
+	*
+	* The gateway pages at 100 and reports more with a cursor. A single page is
+	* enough for the common case and wrong for a busy account — and wrong in the
+	* direction that matters: the caller is told "these are all of them" when
+	* they are the first hundred, and a metadata search for one specific sandbox
+	* reports "none" because that sandbox happens to be on a later page.
+	*
+	* ## Why the bound and the sequential awaits
+	*
+	* `MAX_LIST_PAGES` caps a filter that matches nothing, which would otherwise
+	* walk the whole account one page at a time. The awaits are sequential by
+	* necessity: each page's cursor comes from the previous response, so the
+	* pages cannot be requested together.
+	*
+	* Shared by both listing calls so the two cannot drift in either respect.
+	*
+	* @param apiKey - the key to present.
+	* @param query - the SDK query, when one narrows the listing.
+	* @returns every row the walk collected.
+	*/
+	async collectPages(apiKey, query) {
+		const paginator = Sandbox.list({
+			apiKey,
+			domain: this.options.resolveDomain(),
+			requestTimeoutMs: this.options.resolveRequestTimeoutMs(),
+			...query
+		});
+		const collected = [];
+		for (let page = 0; page < MAX_LIST_PAGES && paginator.hasNext; page += 1) collected.push(...await paginator.nextItems());
+		return collected;
+	}
+	/**
 	* Find the sandboxes carrying one metadata pair.
 	*
 	* The SDK encodes the pair into the `metadata` query parameter and the
@@ -983,19 +1017,7 @@ var SandboxClient = class {
 	* @returns one row per matching sandbox.
 	*/
 	async findByMetadata(metadata, signal) {
-		const domain = this.options.resolveDomain();
-		const requestTimeoutMs = this.options.resolveRequestTimeoutMs();
-		const items = await this.runWithKeyRefresh(signal, async (apiKey) => {
-			const paginator = Sandbox.list({
-				apiKey,
-				domain,
-				requestTimeoutMs,
-				query: { metadata }
-			});
-			const found = [];
-			for (let page = 0; page < MAX_LIST_PAGES && paginator.hasNext; page += 1) found.push(...await paginator.nextItems());
-			return found;
-		});
+		const items = await this.runWithKeyRefresh(signal, (apiKey) => this.collectPages(apiKey, { query: { metadata } }));
 		return items.map((item) => ({
 			sandboxId: item.sandboxId,
 			state: item.state
@@ -1012,18 +1034,7 @@ var SandboxClient = class {
 	* @returns one row per sandbox, in the shape the tool renders.
 	*/
 	async list(signal) {
-		const domain = this.options.resolveDomain();
-		const requestTimeoutMs = this.options.resolveRequestTimeoutMs();
-		const items = await this.runWithKeyRefresh(signal, async (apiKey) => {
-			const paginator = Sandbox.list({
-				apiKey,
-				domain,
-				requestTimeoutMs
-			});
-			const all = [];
-			for (let page = 0; page < MAX_LIST_PAGES && paginator.hasNext; page += 1) all.push(...await paginator.nextItems());
-			return all;
-		});
+		const items = await this.runWithKeyRefresh(signal, (apiKey) => this.collectPages(apiKey, {}));
 		return items.map((item) => ({
 			sandboxId: item.sandboxId,
 			templateId: item.templateId,
@@ -1196,6 +1207,7 @@ function toStoredSection(key) {
 /** One key, read from the store and replaced when it expires or is refused. */
 var SandboxKeySource = class {
 	constructor(options) {
+		this.generation = 0;
 		this.options = options;
 		this.fetchImpl = options.fetchImpl ?? fetch;
 	}
@@ -1233,13 +1245,33 @@ var SandboxKeySource = class {
 	* Forget the key, so the next {@link get} creates a new one.
 	*
 	* Called when the gateway refuses the key as unauthenticated — the one
-	* signal that it has stopped working earlier than its expiry said. The
-	* replacement is a different key, and therefore a different tenant: sandboxes
-	* created under the old one stop being reachable through this plugin.
+	* signal that it has stopped working earlier than its expiry said — and when
+	* the stored credentials change.
+	*
+	* The replacement is a different key, and therefore a different tenant:
+	* sandboxes created under the old one stop being reachable through this
+	* plugin.
+	*
+	* ## Why the generation is bumped and `pending` is not cleared
+	*
+	* Clearing `pending` would let a concurrent caller start a second create
+	* immediately, which is two keys and two tenants — the thing the shared
+	* promise exists to prevent. Bumping the generation instead leaves the
+	* in-flight create shared, and makes it fail when it lands: its key was
+	* minted under credentials that no longer exist, so adopting it would put a
+	* credential granted under a cleared account back into the store.
+	*
+	* The clear is best-effort. A store that refuses the delete still has the key
+	* dropped from memory, and the fingerprint check rejects it on the next read
+	* anyway — throwing here would turn a refresh into a failure the caller
+	* cannot act on.
 	*/
 	invalidate() {
 		this.current = void 0;
-		clearE2BKey(this.options.store);
+		this.generation += 1;
+		try {
+			clearE2BKey(this.options.store);
+		} catch {}
 	}
 	/**
 	* Create a key, store it, and return it.
@@ -1247,9 +1279,12 @@ var SandboxKeySource = class {
 	* @param credentials - the pair to sign with; already read by {@link get},
 	*   so the fingerprint recorded on the key is the one it was minted under.
 	* @param signal - caller cancellation, forwarded to the fetch.
+	* @throws {SandboxKeyError} when the credentials changed while the request
+	*   was in flight, so the key that came back belongs to none of them.
 	*/
 	async createKey(credentials, signal) {
 		if (credentials === void 0) throw new SandboxKeyError("未进行华为云 IAM 认证，请认证后重试。 / Not authenticated with Huawei Cloud IAM. Please authenticate, then retry.");
+		const generation = this.generation;
 		const url = new URL(`${this.options.baseUrl}${KEYS_PATH}`);
 		const headers = sign("POST", url.host, url.pathname, {}, "", credentials);
 		const timeout = AbortSignal.timeout(this.options.timeoutMs);
@@ -1274,9 +1309,10 @@ var SandboxKeySource = class {
 			...await readCreatedKey(response),
 			akFingerprint: fingerprint(credentials.ak)
 		};
+		if (generation !== this.generation) throw new SandboxKeyError("aishell-e2b: the Huawei Cloud credentials changed while a sandbox key was being created, so that key belongs to the previous account and was discarded. Retry with the current credentials.");
 		try {
 			writeE2BKey(this.options.store, toStoredSection(created));
-		} catch (error) {}
+		} catch {}
 		return created;
 	}
 };
@@ -1579,16 +1615,37 @@ function describeInfo(info) {
 		...info.metadata === void 0 ? {} : { metadata: info.metadata }
 	};
 }
-/** How much of a command's output a result carries before it is elided. */
+/**
+* How much of a command's output a result carries before it is elided.
+*
+* Counted in code points, which is what a reader means by "characters" and what
+* the context budget is actually spent in. A UTF-16 code unit is a third of the
+* cost for a three-byte character, so measuring in units would let 30 000 CJK
+* characters through as 90 KB of text.
+*/
 const OUTPUT_LIMIT = 3e4;
-/** Keep a stream useful without letting one command flood the context. */
+/**
+* Keep a stream useful without letting one command flood the context.
+*
+* Truncation walks code points rather than slicing at a unit index: a slice at
+* an odd offset inside a surrogate pair leaves a lone surrogate, which is not
+* valid text and renders as a replacement character at the cut.
+*
+* @param text - the stream as received.
+* @returns the text, and whether any of it was dropped.
+*/
 function clip(text) {
 	if (text.length <= OUTPUT_LIMIT) return {
 		text,
 		truncated: false
 	};
+	const points = [...text];
+	if (points.length <= OUTPUT_LIMIT) return {
+		text,
+		truncated: false
+	};
 	return {
-		text: text.slice(0, OUTPUT_LIMIT),
+		text: points.slice(0, OUTPUT_LIMIT).join(""),
 		truncated: true
 	};
 }

package/lib/types/client.d.ts

@@ -68,6 +68,31 @@ export declare class SandboxClient {
         readonly metadata?: Record<string, string>;
         readonly signal?: AbortSignal;
     }): Promise<Sandbox>;
+    /**
+     * Walk the sandbox listing, following the pagination cursor.
+     *
+     * ## Why it follows the cursor
+     *
+     * The gateway pages at 100 and reports more with a cursor. A single page is
+     * enough for the common case and wrong for a busy account — and wrong in the
+     * direction that matters: the caller is told "these are all of them" when
+     * they are the first hundred, and a metadata search for one specific sandbox
+     * reports "none" because that sandbox happens to be on a later page.
+     *
+     * ## Why the bound and the sequential awaits
+     *
+     * `MAX_LIST_PAGES` caps a filter that matches nothing, which would otherwise
+     * walk the whole account one page at a time. The awaits are sequential by
+     * necessity: each page's cursor comes from the previous response, so the
+     * pages cannot be requested together.
+     *
+     * Shared by both listing calls so the two cannot drift in either respect.
+     *
+     * @param apiKey - the key to present.
+     * @param query - the SDK query, when one narrows the listing.
+     * @returns every row the walk collected.
+     */
+    private collectPages;
     /**
      * Find the sandboxes carrying one metadata pair.
      *

package/lib/types/credentials.d.ts

@@ -1,19 +1,17 @@
 /**
  * Reading the operator's Huawei Cloud credentials for control-plane requests.
  *
- * The read is delegated to `credentials-store/accounts`, which is now the one
- * place the account names and the pairing rule live. Every plugin in this set
- * that signs with the same key pair goes through it — this module, the LLM
- * adapter, the credential form's Host route and the ops tools — so they cannot
- * disagree about which keyring entries are the credentials or about what
- * "half a pair" means.
+ * The read is delegated to `credentials-store/accounts`, the one place the
+ * account names and the pairing rule live. Every plugin in this set that signs
+ * with the same key pair goes through it — this module, the LLM adapter, the
+ * credential form's Host route and the ops tools — so they cannot disagree
+ * about which keyring entries are the credentials, or about what "half a pair"
+ * means.
  *
- * It used to say here that the literals were re-declared because
- * `aishell-credentials` kept them unexported and the other packages each had
- * their own copy. That was an accurate description of a real hazard, not a
- * reason to keep it: a divergence in these names would not fail a build, it
- * would surface as one plugin working and another reporting "not
- * authenticated" on a machine where the operator had stored exactly one pair.
+ * Those names are a persistence contract: a second copy of them does not fail a
+ * build, it surfaces as one plugin working while another reports "not
+ * authenticated" on a machine where the operator has stored exactly one pair.
+ * One shared definition is what rules that out.
  *
  * @module @huaweidevtools/aishell-dsh-e2b/credentials
  */

package/lib/types/prompt.d.ts

@@ -10,15 +10,14 @@
  *
  * ## Why the split is stated three ways
  *
- * An earlier version drew the line at lifecycle alone: "does the result need to
- * outlive the task?" That is the property that actually decides the tier, but it
- * is one the model has to *infer* about work that has not been described in
- * those terms yet.
- *
- * Two things make it answerable instead:
+ * The deciding property is lifecycle — does the result need to outlive the
+ * task? — but that is one the model has to *infer* about work nobody has
+ * described in those terms yet. Two more signals make the same question
+ * answerable directly:
  *
  *   - **What the user asked for.** "A web page or a demo" versus "a production
- *     system" is a distinction a person can answer directly.
+ *     system" is a distinction a person can answer without knowing what a
+ *     sandbox is.
  *   - **What the work needs.** The one capability a sandbox has that this
  *     machine does not is a public address. A request to deploy something and
  *     get a URL back is the strongest signal there is, and it is stated first

package/lib/types/sandbox-key.d.ts

@@ -33,13 +33,12 @@
  *
  * ## Why the key is bound to the AK that minted it
  *
- * A stored key outlives the credentials that created it. Clearing or replacing
- * the AK/SK in the credential form therefore used to leave the old key — and so
- * the old tenant, with all its sandboxes — alive and usable, which contradicts
- * what clearing credentials is supposed to mean. A key with no expiry made that
- * permanent rather than temporary.
+ * A stored key outlives the credentials that created it, so clearing or
+ * replacing the AK/SK in the credential form has to take the key with it — a
+ * key with no expiry otherwise survives the credential for good, and the old
+ * tenant and all its sandboxes stay reachable.
  *
- * So the key records a fingerprint of the AK that minted it, and {@link get}
+ * The key records a fingerprint of the AK that minted it, and {@link get}
  * discards a stored key whose fingerprint no longer matches the stored
  * credentials. Three consequences are deliberate:
  *
@@ -143,6 +142,17 @@ export declare class SandboxKeySource {
     private current;
     /** The in-flight create, so concurrent callers share one request. */
     private pending;
+    /**
+     * Bumped by {@link invalidate}.
+     *
+     * A create signs with the credentials it was handed, and the network round
+     * trip is long enough to outlast them: a person can clear or replace their
+     * AK/SK while a key is being minted. The generation is how the finished
+     * create notices — its value is the one captured before the request, so a
+     * mismatch means the credentials it signed under are gone and the key it is
+     * holding must not be adopted or stored.
+     */
+    private generation;
     constructor(options: SandboxKeyOptions);
     /**
      * Return a usable API key.
@@ -161,9 +171,26 @@ export declare class SandboxKeySource {
      * Forget the key, so the next {@link get} creates a new one.
      *
      * Called when the gateway refuses the key as unauthenticated — the one
-     * signal that it has stopped working earlier than its expiry said. The
-     * replacement is a different key, and therefore a different tenant: sandboxes
-     * created under the old one stop being reachable through this plugin.
+     * signal that it has stopped working earlier than its expiry said — and when
+     * the stored credentials change.
+     *
+     * The replacement is a different key, and therefore a different tenant:
+     * sandboxes created under the old one stop being reachable through this
+     * plugin.
+     *
+     * ## Why the generation is bumped and `pending` is not cleared
+     *
+     * Clearing `pending` would let a concurrent caller start a second create
+     * immediately, which is two keys and two tenants — the thing the shared
+     * promise exists to prevent. Bumping the generation instead leaves the
+     * in-flight create shared, and makes it fail when it lands: its key was
+     * minted under credentials that no longer exist, so adopting it would put a
+     * credential granted under a cleared account back into the store.
+     *
+     * The clear is best-effort. A store that refuses the delete still has the key
+     * dropped from memory, and the fingerprint check rejects it on the next read
+     * anyway — throwing here would turn a refresh into a failure the caller
+     * cannot act on.
      */
     invalidate(): void;
     /**
@@ -172,6 +199,8 @@ export declare class SandboxKeySource {
      * @param credentials - the pair to sign with; already read by {@link get},
      *   so the fingerprint recorded on the key is the one it was minted under.
      * @param signal - caller cancellation, forwarded to the fetch.
+     * @throws {SandboxKeyError} when the credentials changed while the request
+     *   was in flight, so the key that came back belongs to none of them.
      */
     private createKey;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@huaweidevtools/aishell-dsh-e2b",
   "description": "Runs throwaway and preview deployments in E2B sandboxes on DSH — sandbox lifecycle, commands, and files as tools",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "publishConfig": {
     "access": "public"
   },
@@ -27,7 +27,7 @@
   "license": "Apache-2.0",
   "dependencies": {
     "e2b": "2.59.0",
-    "@huaweidevtools/aishell-dsh-credentials-store": "0.0.15"
+    "@huaweidevtools/aishell-dsh-credentials-store": "0.0.17"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.4",