@huaweidevtools/aishell-dsh-credentials-store 0.0.7 → 0.0.9

package/lib/index-JlyJE1E8.d.ts

@@ -0,0 +1,219 @@
+//#region src/backends/keyring.d.ts
+
+type KeyringEntry = {
+  getPassword: () => string | null;
+  setPassword: (value: string) => void;
+  deletePassword: () => void;
+};
+/** Entry options bag; only the Linux store pin is used (see the module note). */
+type KeyringEntryOptions = {
+  linux?: {
+    store?: 'secret-service' | 'keyutils';
+  };
+};
+type KeyringModule = {
+  Entry: new (service: string, account: string, options?: KeyringEntryOptions) => KeyringEntry;
+};
+/** @internal Test hook: inject a mock keyring module (vi.mock cannot intercept createRequire). */
+declare function __setKeyringModule(mock: KeyringModule | undefined): void;
+/**
+ * OS-keyring {@link CredentialsStore}. Constructed with a shared service name;
+ * every entry is stored under `new Entry(service, account, { linux: { store:
+ * 'secret-service' } })`.
+ *
+ * Construction probes the keyring once — if the native module cannot be loaded
+ * (no prebuilt binding for this platform), or the Linux Secret Service is
+ * unavailable, it throws and {@link createCredentialsStore} falls back to the
+ * next backend. Without the pin the absent-service case does not throw; see
+ * the module note.
+ */
+declare class KeyringBackend implements CredentialsStore {
+  private readonly serviceName;
+  private readonly options;
+  private readonly Entry;
+  constructor(_config?: CredentialsStoreConfig);
+  get(account: string): string | undefined;
+  set(account: string, value: string): void;
+  delete(account: string): void;
+  has(account: string): boolean;
+} //#endregion
+//#region src/backends/fingerprint.d.ts
+/**
+ * Encrypted-file {@link CredentialsStore}. Each account is one entry in a
+ * single JSON map, encrypted as one file under the resolved credentials
+ * directory, named by the build's credential scope (see `../scope.ts`).
+ *
+ * Construction probes the machine ID + crypto — if `node-machine-id` cannot
+ * resolve a UUID, construction throws and the factory falls back to
+ * {@link MemoryBackend}.
+ */
+declare class FingerprintBackend implements CredentialsStore {
+  private readonly filePath;
+  private readonly fileDir;
+  constructor(config?: CredentialsStoreConfig);
+  /**
+   * Load + decrypt the file into a fresh map. Not cached — credentials are
+   * read, used, and dropped so plaintext does not linger in memory between
+   * operations. The file I/O + scrypt decrypt per call is acceptable: this is
+   * not a hot path (once per chat request, not per token).
+   */
+  private load;
+  /** Encrypt + write the map to disk with owner-only permissions. */
+  private persist;
+  get(account: string): string | undefined;
+  set(account: string, value: string): void;
+  delete(account: string): void;
+  has(account: string): boolean;
+}
+
+//#endregion
+//#region src/backends/memory.d.ts
+//# sourceMappingURL=fingerprint.d.ts.map
+/** Process-scoped {@link CredentialsStore}; entries vanish on exit. */
+declare class MemoryBackend implements CredentialsStore {
+  private readonly entries;
+  constructor(_config?: CredentialsStoreConfig);
+  get(account: string): string | undefined;
+  set(account: string, value: string): void;
+  delete(account: string): void;
+  has(account: string): boolean;
+}
+declare function sharedMemoryBackend(config?: CredentialsStoreConfig): MemoryBackend;
+/**
+ * Drop the shared instance.
+ *
+ * For tests, which need each case to start from an empty store. Not called in
+ * production: discarding the instance would discard every credential in it.
+ */
+declare function __resetSharedMemoryBackend(): void;
+
+//#endregion
+//#region src/failover.d.ts
+//# sourceMappingURL=memory.d.ts.map
+
+/** Options for {@link FailoverStore}. */
+interface FailoverStoreOptions {
+  /**
+   * Builds the store that takes over when the primary fails a write. Called
+   * at most once, lazily, on first need — a read miss or the first failed
+   * write — so a healthy keyring never pays for constructing it. Must not
+   * throw: the factory's closure ends in MemoryBackend.
+   */
+  readonly createFallback: () => CredentialsStore;
+}
+/**
+ * A {@link CredentialsStore} that delegates to a primary until the primary
+ * fails a write, then fails over — for the life of this store — to a
+ * fallback supplied by {@link FailoverStoreOptions.createFallback}.
+ *
+ * Stickiness is per instance, not per process: each plugin that consumes
+ * credentials builds its own store, so one instance failing over does not stop
+ * another from trying the primary. That is intended — the flag only exists to
+ * avoid re-hitting a primary already known to be unwritable from *this* store,
+ * and a second instance's attempt is one probe rather than a policy decision.
+ * Correctness across instances comes from the persisted record, not the flag.
+ *
+ * Constructed by {@link createCredentialsStore} around a KeyringBackend whose
+ * construction probe passed; not meant for direct use by upper layers.
+ */
+declare class FailoverStore implements CredentialsStore {
+  private readonly primary;
+  private readonly createFallback;
+  private fallback;
+  /** Set by the first failed primary write; routes writes thereafter. */
+  private failedOver;
+  constructor(primary: CredentialsStore, options: FailoverStoreOptions);
+  /** The lazily built fallback; constructed at most once per store. */
+  private get fallbackStore();
+  /**
+   * Drop the tombstone for `account`, if any.
+   *
+   * Paired with the value purge on every path that hands authority back to the
+   * primary. Best-effort: a tombstone that outlives its purpose costs one extra
+   * fallback lookup, which must never fail a write the keyring has accepted.
+   */
+  private clearTombstone;
+  get(account: string): string | undefined;
+  has(account: string): boolean;
+  set(account: string, value: string): void;
+  delete(account: string): void;
+  /**
+   * Record the deletion, or report its failure.
+   *
+   * Unlike the best-effort cleanups above, a tombstone that cannot be written
+   * means the delete silently did not happen and the credential will read back
+   * later. That is a failed clear, so it throws rather than being swallowed.
+   */
+  private writeTombstone;
+} //#endregion
+//#region src/index.d.ts
+
+//# sourceMappingURL=failover.d.ts.map
+/**
+ * Credential storage abstraction for aishell DSH plugins.
+ *
+ * Upper layers (aishell-llm's adapter, aishell-credentials' host half)
+ * call {@link createCredentialsStore} and get a {@link CredentialsStore} —
+ * they never learn which backend is serving. The factory probes backends in
+ * priority order (OS keyring first, process memory last) and returns the
+ * first that answers. New backends (fingerprint + encrypted file, etc.) slot
+ * into the chain without touching callers. A keyring that answers the probe
+ * but later rejects writes fails over to the next backend on first failure.
+ *
+ * This is a tool library, not a DSH plugin — no `dsh.client`, no
+ * `cordis.patch.yml`, no `apply`. DSH's own `ctx.credentials` is untouched;
+ * user-configured models and `.credentials.yaml` keep working.
+ *
+ * @module @huaweidevtools/aishell-dsh-credentials-store
+ */
+/** Options shared by every backend / the factory. */
+interface CredentialsStoreConfig {
+  /**
+   * Explicit directory for the fingerprint encrypted-file backend. When set,
+   * overrides the default `$DSH_HOME/credentials` resolution. Callers rarely
+   * need this — the host's `DSH_HOME` already places credentials alongside
+   * its other data.
+   */
+  readonly credentialsDir?: string;
+}
+/**
+ * Read/write a named credential. Backends are synchronous and per-call — no
+ * cache, so a credential changed from outside is visible on the next `get`.
+ * Absent credentials read as `undefined` / `has === false`; a backend that
+ * cannot serve (e.g. no D-Bus secret service) degrades the same way rather
+ * than throwing on read.
+ */
+interface CredentialsStore {
+  /** Read one credential; `undefined` when absent or backend unavailable. */
+  get(account: string): string | undefined;
+  /** Store one credential. Rejects an empty value; throws on backend errors. */
+  set(account: string, value: string): void;
+  /** Remove one credential; absent is a no-op. Throws on backend errors. */
+  delete(account: string): void;
+  /** Whether a credential is currently stored; `false` when absent or backend unavailable. */
+  has(account: string): boolean;
+}
+/**
+ * Probe backends in priority order and return the first that answers.
+ *
+ * Priority: OS keyring (durable, cross-process) → machine-fingerprint
+ * encrypted file (durable, same-machine) → process memory (volatile,
+ * last resort). A backend that cannot initialize — no D-Bus secret service
+ * on a headless Linux box, keychain locked, etc. — is skipped, not fatal.
+ *
+ * A keyring that passes the construction probe but is later found unwritable
+ * (GNOME login keyring locked: reads come back null, writes fail — the probe
+ * cannot see this) is wrapped in a {@link FailoverStore}: its first failed
+ * write fails the whole process over to the fingerprint backend, so saving
+ * credentials works instead of erroring. The wrapper also records which
+ * accounts the keyring must not answer for, so a credential saved while the
+ * collection was locked is not shadowed by the keyring's stale copy once it
+ * unlocks.
+ *
+ * @returns the highest-priority backend that could initialize.
+ */
+declare function createCredentialsStore(config?: CredentialsStoreConfig): CredentialsStore;
+
+//#endregion
+export { CredentialsStore, CredentialsStoreConfig, FailoverStore, FingerprintBackend, KeyringBackend, MemoryBackend, __resetSharedMemoryBackend, __setKeyringModule, createCredentialsStore, sharedMemoryBackend };
+//# sourceMappingURL=index-JlyJE1E8.d.ts.map

package/lib/index-JlyJE1E8.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-JlyJE1E8.d.ts","names":[],"sources":["../../src/backends/keyring.ts","../../src/backends/fingerprint.ts","../../src/backends/memory.ts","../../src/failover.ts","../../src/index.ts"],"sourcesContent":null,"mappings":";;KAuCK,YAAA;;;;;;KAMA,mBAAA;;ICyCQ,KAAA,CAAA,EAAA,gBAAmB,GAAA,UAAA;EAAA,CAAA;CAAA;KDxC3B,aAAA,GCwCsC;EAAgB,KAAA,EAAA,KAAA,OAAA,EAAA,MAAA,EAAA,OAAA,EAAA,MAAA,EAAA,OAAA,CAAA,EDvCD,mBCuCC,EAAA,GDvCuB,YCuCvB;;;iBDlC3C,kBAAA,OAAyB;;AEtBzC;;;;AAAsD;AAsDtD;;;;AAAuF;cFZ1E,cAAA,YAA0B;;;;wBAKhB;;EEkBP,GAAA,CAAA,OAAA,EAAA,MAAA,EAAA,KAAA,EAAA,MAA0B,CAAA,EAAA,IAAA;;;;;;;;;;;;;AFvB1C;AAA4B,cCcf,kBAAA,YAA8B,gBDdf,CAAA;EAAA,iBAKL,QAAA;EAA2B,iBALX,OAAA;EAAgB,WAAA,CAAA,MAAA,CAAA,ECkBjC,sBDlBiC;;;;;;;;;;;;;ECc1C,GAAA,CAAA,OAAA,EAAA,MAAA,CAAA,EAAmB,OAAA;;;;;;;cCxDnB,aAAA,YAAyB;;wBAGf;;;;;;iBAmDP,mBAAA,UAA4B,yBAA8B;;ADE1E;;;;AAA2D;iBCS3C,0BAAA,CAAA;;;;;;;UCKC,oBAAA;;;AAyBjB;;;;EAOsE,SAPhC,cAAA,EAAA,GAAA,GAlBL,gBAkBK;AAAgB;;;;;;;;;;;;;;;;cAAzC,aAAA,YAAyB;;;;;;ECrGrB,WAAA,CAAA,OAAA,ED4GM,gBC5GgB,EAAA,OAAA,ED4GW,oBC5GX;;;;;;;;AAiBvC;;;;;;;;;;;;;;;;;;;;AJT2E;AAO1D;AAMO;;;;AAEsE;;AAK9F;;;;;;;;;UI5BiB,sBAAA;;;AJgDjB;;;;EAAuD,SAAA,cAAA,CAAA,EAAA,MAAA;;;;;;;;;UI/BtC,gBAAA;;;;EH6CJ,GAAA,CAAA,OAAA,EAAA,MAAA,EAAmB,KAAA,EAAA,MAAA,CAAA,EAAA,IAAA;EAAA;EAAA,MAIV,CAAA,OAAA,EAAA,MAAA,CAAA,EAAA,IAAA;EAA2B;EAJU,GAAA,CAAA,OAAA,EAAA,MAAA,CAAA,EAAA,OAAA;;;;;ACxD3D;;;;AAAsD;AAsDtD;;;;AAAuF;;;;;;;AAWvE,iBExBA,sBAAA,CFwB0B,MAAA,CAAA,EExBK,sBFwBL,CAAA,EExBmC,gBFwBnC"}

package/lib/index.d.ts

@@ -1,218 +1,3 @@
-//#region src/backends/keyring.d.ts
-
-type KeyringEntry = {
-  getPassword: () => string | null;
-  setPassword: (value: string) => void;
-  deletePassword: () => void;
-};
-/** Entry options bag; only the Linux store pin is used (see the module note). */
-type KeyringEntryOptions = {
-  linux?: {
-    store?: 'secret-service' | 'keyutils';
-  };
-};
-type KeyringModule = {
-  Entry: new (service: string, account: string, options?: KeyringEntryOptions) => KeyringEntry;
-};
-/** @internal Test hook: inject a mock keyring module (vi.mock cannot intercept createRequire). */
-declare function __setKeyringModule(mock: KeyringModule | undefined): void;
-/**
- * OS-keyring {@link CredentialsStore}. Constructed with a shared service name;
- * every entry is stored under `new Entry(service, account, { linux: { store:
- * 'secret-service' } })`.
- *
- * Construction probes the keyring once — if the native module cannot be loaded
- * (no prebuilt binding for this platform), or the Linux Secret Service is
- * unavailable, it throws and {@link createCredentialsStore} falls back to the
- * next backend. Without the pin the absent-service case does not throw; see
- * the module note.
- */
-declare class KeyringBackend implements CredentialsStore {
-  private readonly serviceName;
-  private readonly options;
-  private readonly Entry;
-  constructor(config?: CredentialsStoreConfig);
-  get(account: string): string | undefined;
-  set(account: string, value: string): void;
-  delete(account: string): void;
-  has(account: string): boolean;
-} //#endregion
-//#region src/backends/fingerprint.d.ts
-/**
- * Encrypted-file {@link CredentialsStore}. Each account is one entry in a
- * single JSON map, encrypted as one file under the resolved credentials
- * directory (`$DSH_HOME/credentials/credentials.enc` by default).
- *
- * Construction probes the machine ID + crypto — if `node-machine-id` cannot
- * resolve a UUID, construction throws and the factory falls back to
- * {@link MemoryBackend}.
- */
-declare class FingerprintBackend implements CredentialsStore {
-  private readonly filePath;
-  private readonly fileDir;
-  constructor(config?: CredentialsStoreConfig);
-  /**
-   * Load + decrypt the file into a fresh map. Not cached — credentials are
-   * read, used, and dropped so plaintext does not linger in memory between
-   * operations. The file I/O + scrypt decrypt per call is acceptable: this is
-   * not a hot path (once per chat request, not per token).
-   */
-  private load;
-  /** Encrypt + write the map to disk with owner-only permissions. */
-  private persist;
-  get(account: string): string | undefined;
-  set(account: string, value: string): void;
-  delete(account: string): void;
-  has(account: string): boolean;
-}
-
-//#endregion
-//#region src/backends/memory.d.ts
-//# sourceMappingURL=fingerprint.d.ts.map
-/** Process-scoped {@link CredentialsStore}; entries vanish on exit. */
-declare class MemoryBackend implements CredentialsStore {
-  private readonly entries;
-  constructor(_config?: CredentialsStoreConfig);
-  get(account: string): string | undefined;
-  set(account: string, value: string): void;
-  delete(account: string): void;
-  has(account: string): boolean;
-}
-
-//#endregion
-//#region src/failover.d.ts
-//# sourceMappingURL=memory.d.ts.map
-
-/** Options for {@link FailoverStore}. */
-interface FailoverStoreOptions {
-  /**
-   * Builds the store that takes over when the primary fails a write. Called
-   * at most once, lazily, on first need — a read miss or the first failed
-   * write — so a healthy keyring never pays for constructing it. Must not
-   * throw: the factory's closure ends in MemoryBackend.
-   */
-  readonly createFallback: () => CredentialsStore;
-}
-/**
- * A {@link CredentialsStore} that delegates to a primary until the primary
- * fails a write, then fails over — for the life of this store — to a
- * fallback supplied by {@link FailoverStoreOptions.createFallback}.
- *
- * Stickiness is per instance, not per process: each plugin that consumes
- * credentials builds its own store, so one instance failing over does not stop
- * another from trying the primary. That is intended — the flag only exists to
- * avoid re-hitting a primary already known to be unwritable from *this* store,
- * and a second instance's attempt is one probe rather than a policy decision.
- * Correctness across instances comes from the persisted record, not the flag.
- *
- * Constructed by {@link createCredentialsStore} around a KeyringBackend whose
- * construction probe passed; not meant for direct use by upper layers.
- */
-declare class FailoverStore implements CredentialsStore {
-  private readonly primary;
-  private readonly createFallback;
-  private fallback;
-  /** Set by the first failed primary write; routes writes thereafter. */
-  private failedOver;
-  constructor(primary: CredentialsStore, options: FailoverStoreOptions);
-  /** The lazily built fallback; constructed at most once per store. */
-  private get fallbackStore();
-  /**
-   * Drop the tombstone for `account`, if any.
-   *
-   * Paired with the value purge on every path that hands authority back to the
-   * primary. Best-effort: a tombstone that outlives its purpose costs one extra
-   * fallback lookup, which must never fail a write the keyring has accepted.
-   */
-  private clearTombstone;
-  get(account: string): string | undefined;
-  has(account: string): boolean;
-  set(account: string, value: string): void;
-  delete(account: string): void;
-  /**
-   * Record the deletion, or report its failure.
-   *
-   * Unlike the best-effort cleanups above, a tombstone that cannot be written
-   * means the delete silently did not happen and the credential will read back
-   * later. That is a failed clear, so it throws rather than being swallowed.
-   */
-  private writeTombstone;
-} //#endregion
-//#region src/index.d.ts
-
-//# sourceMappingURL=failover.d.ts.map
-/**
- * Credential storage abstraction for aishell DSH plugins.
- *
- * Upper layers (aishell-llm's adapter, aishell-credentials' host half)
- * call {@link createCredentialsStore} and get a {@link CredentialsStore} —
- * they never learn which backend is serving. The factory probes backends in
- * priority order (OS keyring first, process memory last) and returns the
- * first that answers. New backends (fingerprint + encrypted file, etc.) slot
- * into the chain without touching callers. A keyring that answers the probe
- * but later rejects writes fails over to the next backend on first failure.
- *
- * This is a tool library, not a DSH plugin — no `dsh.client`, no
- * `cordis.patch.yml`, no `apply`. DSH's own `ctx.credentials` is untouched;
- * user-configured models and `.credentials.yaml` keep working.
- *
- * @module @huaweidevtools/aishell-dsh-credentials-store
- */
-/** Options shared by every backend / the factory. */
-interface CredentialsStoreConfig {
-  /**
-   * Backend-scoped identity. For the OS-keyring backend this is the keyring
-   * service name; every entry is stored under `new Entry(service, account)`.
-   * Defaults to `'aishell-dsh'`.
-   */
-  readonly service?: string;
-  /**
-   * Explicit directory for the fingerprint encrypted-file backend. When set,
-   * overrides the default `$DSH_HOME/credentials` resolution. Callers rarely
-   * need this — the host's `DSH_HOME` already places credentials alongside
-   * its other data.
-   */
-  readonly credentialsDir?: string;
-}
-/**
- * Read/write a named credential. Backends are synchronous and per-call — no
- * cache, so a credential changed from outside is visible on the next `get`.
- * Absent credentials read as `undefined` / `has === false`; a backend that
- * cannot serve (e.g. no D-Bus secret service) degrades the same way rather
- * than throwing on read.
- */
-interface CredentialsStore {
-  /** Read one credential; `undefined` when absent or backend unavailable. */
-  get(account: string): string | undefined;
-  /** Store one credential. Rejects an empty value; throws on backend errors. */
-  set(account: string, value: string): void;
-  /** Remove one credential; absent is a no-op. Throws on backend errors. */
-  delete(account: string): void;
-  /** Whether a credential is currently stored; `false` when absent or backend unavailable. */
-  has(account: string): boolean;
-}
-/**
- * Probe backends in priority order and return the first that answers.
- *
- * Priority: OS keyring (durable, cross-process) → machine-fingerprint
- * encrypted file (durable, same-machine) → process memory (volatile,
- * last resort). A backend that cannot initialize — no D-Bus secret service
- * on a headless Linux box, keychain locked, etc. — is skipped, not fatal.
- *
- * A keyring that passes the construction probe but is later found unwritable
- * (GNOME login keyring locked: reads come back null, writes fail — the probe
- * cannot see this) is wrapped in a {@link FailoverStore}: its first failed
- * write fails the whole process over to the fingerprint backend, so saving
- * credentials works instead of erroring. The wrapper also records which
- * accounts the keyring must not answer for, so a credential saved while the
- * collection was locked is not shadowed by the keyring's stale copy once it
- * unlocks.
- *
- * @param config - optional service name override.
- * @returns the highest-priority backend that could initialize.
- */
-declare function createCredentialsStore(config?: CredentialsStoreConfig): CredentialsStore;
-
-//#endregion
-export { CredentialsStore, CredentialsStoreConfig, FailoverStore, FingerprintBackend, KeyringBackend, MemoryBackend, __setKeyringModule, createCredentialsStore };
-//# sourceMappingURL=index.d.ts.map
+import { CREDENTIALS_FILE_NAME$1 as CREDENTIALS_FILE_NAME, CREDENTIAL_SCOPE$1 as CREDENTIAL_SCOPE, DEFAULT_SCOPE$1 as DEFAULT_SCOPE, KEYRING_SERVICE$1 as KEYRING_SERVICE } from "./scope-CFetnbG3.js";
+import { CredentialsStore, CredentialsStoreConfig, FailoverStore, FingerprintBackend, KeyringBackend, MemoryBackend, __resetSharedMemoryBackend, __setKeyringModule, createCredentialsStore, sharedMemoryBackend } from "./index-JlyJE1E8.js";
+export { CREDENTIALS_FILE_NAME, CREDENTIAL_SCOPE, CredentialsStore, CredentialsStoreConfig, DEFAULT_SCOPE, FailoverStore, FingerprintBackend, KEYRING_SERVICE, KeyringBackend, MemoryBackend, __resetSharedMemoryBackend, __setKeyringModule, createCredentialsStore, sharedMemoryBackend };

package/lib/index.js

@@ -1,7 +1,8 @@
-import { createRequire } from "node:module";
+import { CREDENTIALS_FILE_NAME, CREDENTIAL_SCOPE, DEFAULT_SCOPE, KEYRING_SERVICE } from "./scope-QmrHZaZt.js";
+import { credentialsDir } from "./paths-DtFRzop6.js";
 import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "node:crypto";
+import { createRequire } from "node:module";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
 import machineIdModule from "node-machine-id";
 
@@ -28,8 +29,8 @@ function loadKeyring() {
 * the module note.
 */
 var KeyringBackend = class {
-	constructor(config = {}) {
-		this.serviceName = config.service ?? "aishell-dsh";
+	constructor(_config = {}) {
+		this.serviceName = KEYRING_SERVICE;
 		this.options = { linux: { store: "secret-service" } };
 		this.Entry = loadKeyring().Entry;
 		new this.Entry(this.serviceName, "__probe__", this.options).getPassword();
@@ -102,26 +103,20 @@ function fingerprintDecrypt(data) {
 /**
 * Resolve the directory holding the encrypted credentials file.
 *
-* Priority: an explicit `config.credentialsDir` override → the host's
-* `DSH_HOME` (so credentials live alongside the rest of that host's data —
-* `~/.aishell/credentials` for the desktop app, `~/.dsh/credentials` for the
-* dsh CLI) → a standalone `~/.aishell-dsh` fallback for headless / library
-* use where no DSH host is involved.
+* An explicit `config.credentialsDir` wins; otherwise `<DSH_HOME>/credentials`,
+* resolved by the shared `paths` module so the terraform cache in
+* `aishell-deploy` cannot drift to a different home.
 *
-* The `service` config still names the keyring service (and the fallback
-* directory name when neither `credentialsDir` nor `DSH_HOME` is set).
+* Builds are separated by the *file name* — see `../scope.ts` — not by the
+* directory.
 */
 function resolveCredentialsDir(config) {
-	if (config.credentialsDir !== void 0) return config.credentialsDir;
-	const dshHome = process.env.DSH_HOME;
-	if (dshHome !== void 0 && dshHome.trim() !== "") return join(dshHome, "credentials");
-	const dirName = config.service ?? "aishell-dsh";
-	return join(homedir(), `.${dirName}`);
+	return config.credentialsDir ?? credentialsDir();
 }
 /**
 * Encrypted-file {@link CredentialsStore}. Each account is one entry in a
 * single JSON map, encrypted as one file under the resolved credentials
-* directory (`$DSH_HOME/credentials/credentials.enc` by default).
+* directory, named by the build's credential scope (see `../scope.ts`).
 *
 * Construction probes the machine ID + crypto — if `node-machine-id` cannot
 * resolve a UUID, construction throws and the factory falls back to
@@ -130,7 +125,7 @@ function resolveCredentialsDir(config) {
 var FingerprintBackend = class {
 	constructor(config = {}) {
 		this.fileDir = resolveCredentialsDir(config);
-		this.filePath = join(this.fileDir, "credentials.enc");
+		this.filePath = join(this.fileDir, CREDENTIALS_FILE_NAME);
 		deriveKey();
 	}
 	/**
@@ -197,6 +192,46 @@ var MemoryBackend = class {
 		return this.entries.has(account);
 	}
 };
+/**
+* The one memory backend the factory hands to every caller in this process.
+*
+* ## Why a module-level instance and not a class singleton
+*
+* `createCredentialsStore()` is called once per plugin — four of them — and
+* the memory backend is the only one of the three that is not shared by
+* construction. The keyring is a daemon and the encrypted file is a path, so
+* two callers reaching either are reading the same bytes; two `Map`s are not.
+* Without this, a machine with no keyring would have one plugin storing a
+* credential and another unable to see it.
+*
+* Held here rather than on the class so `new MemoryBackend()` stays
+* independent, which the specs depend on.
+*
+* ## Why the lazily-created shape
+*
+* The instance is created on first use rather than at module load, so
+* importing this module has no effect a test has to account for — the specs
+* that swap the keyring module in and out must not leave a populated store
+* behind.
+*
+* @param config - forwarded on first construction only; later callers reuse
+*   the instance, since the memory backend keeps nothing config decides.
+* @returns the shared backend.
+*/
+let shared;
+function sharedMemoryBackend(config = {}) {
+	shared ??= new MemoryBackend(config);
+	return shared;
+}
+/**
+* Drop the shared instance.
+*
+* For tests, which need each case to start from an empty store. Not called in
+* production: discarding the instance would discard every credential in it.
+*/
+function __resetSharedMemoryBackend() {
+	shared = void 0;
+}
 
 //#endregion
 //#region src/failover.ts
@@ -334,7 +369,6 @@ var FailoverStore = class {
 * collection was locked is not shadowed by the keyring's stale copy once it
 * unlocks.
 *
-* @param config - optional service name override.
 * @returns the highest-priority backend that could initialize.
 */
 function createCredentialsStore(config = {}) {
@@ -353,9 +387,9 @@ function createFallbackStore(config) {
 	try {
 		return new FingerprintBackend(config);
 	} catch {}
-	return new MemoryBackend(config);
+	return sharedMemoryBackend(config);
 }
 
 //#endregion
-export { FailoverStore, FingerprintBackend, KeyringBackend, MemoryBackend, __setKeyringModule, createCredentialsStore };
+export { CREDENTIALS_FILE_NAME, CREDENTIAL_SCOPE, DEFAULT_SCOPE, FailoverStore, FingerprintBackend, KEYRING_SERVICE, KeyringBackend, MemoryBackend, __resetSharedMemoryBackend, __setKeyringModule, createCredentialsStore, sharedMemoryBackend };
 //# sourceMappingURL=index.js.map