@kin-tio/cli 0.6.1 → 0.7.0

package/dist/src/ilink/login-manager.js

@@ -1,10 +1,11 @@
-import { IlinkLoginStore } from './login-store.js';
-import { IlinkClient, IlinkProtocolError, normalizeIlinkBaseUrl, } from './protocol/client.js';
-import { renderIlinkQrPng } from './qr.js';
+import { IlinkLoginStore, } from './login-store.js';
+import { DEFAULT_ILINK_BASE_URL, IlinkClient, IlinkProtocolError, normalizeIlinkBaseUrl, } from './protocol/client.js';
+import { assertIlinkQrContent } from './qr.js';
 import { IlinkSecretBox } from './secret-box.js';
 import { IlinkSqliteStore } from './sqlite-store.js';
-import { createIlinkAccountKey } from './store-types.js';
+import { createIlinkAccountKey, } from './store-types.js';
 const POLL_INTERVAL_MS = 1_000;
+const MAX_EXPIRY_TIMER_MS = 10 * 60 * 1_000;
 function sleep(milliseconds, signal) {
     if (signal.aborted)
         return Promise.reject(signal.reason);
@@ -30,16 +31,18 @@ export class IlinkLoginManager {
     #client;
     #logger;
     #maxAccounts;
+    #baseUrl;
     #clock;
     #onAccountsChanged;
     #sleep;
     #running = new Map();
     #closed = false;
-    constructor({ offers, accounts, secretBox, client = new IlinkClient(), maxAccounts = 20, clock = Date.now, onAccountsChanged = () => undefined, logger = console, sleep: sleepFunction = sleep, }) {
+    constructor({ offers, accounts, secretBox, client = new IlinkClient(), baseUrl = DEFAULT_ILINK_BASE_URL, maxAccounts = 20, clock = Date.now, onAccountsChanged = () => undefined, logger = console, sleep: sleepFunction = sleep, }) {
         this.#offers = offers;
         this.#accounts = accounts;
         this.#secrets = secretBox;
         this.#client = client;
+        this.#baseUrl = normalizeIlinkBaseUrl(baseUrl);
         this.#maxAccounts = maxAccounts;
         this.#clock = clock;
         this.#onAccountsChanged = onAccountsChanged;
@@ -49,58 +52,88 @@ export class IlinkLoginManager {
     async start() {
         if (this.#closed)
             throw new Error('iLink login manager is closed');
-        for (const offer of this.#offers.listActive())
-            this.#startPolling(offer);
+        for (const offer of this.#offers.listActive()) {
+            if (offer.initiatorKind === 'local_operator') {
+                this.#offers.finish(offer.offerId, 'cancelled');
+            }
+            else
+                this.#startPolling(offer);
+        }
     }
-    async offer(sessionToken) {
+    async offer(source, options = {}) {
         if (this.#closed)
             throw new Error('iLink login manager is closed');
-        if (this.#offers.findForSession(sessionToken)) {
+        if (this.#offers.find(source)) {
             throw new Error('An iLink login offer is already pending');
         }
-        if (this.#accounts.listActiveAccounts().length +
-            this.#offers.listActive().length >= this.#maxAccounts) {
+        if (source.kind !== 'terminal' &&
+            this.#accounts.listActiveAccounts().length +
+                this.#offers.listActive().length >= this.#maxAccounts) {
             throw new Error('iLink account limit reached');
         }
-        const localTokens = this.#accounts.listActiveAccountsWithSecrets()
-            .slice(-10)
-            .reverse()
+        const localAccounts = this.#accounts.listActiveAccountsWithSecrets()
+            .slice(source.kind === 'terminal' ? -1 : -10)
+            .reverse();
+        const localTokens = localAccounts
             .map(({ account, secret }) => this.#secrets.open(secret.sealedBotToken, {
             secretKind: 'bot_token',
             accountId: account.accountKey,
             peerId: account.ownerPeerId,
             generation: secret.accountGeneration,
         }));
-        const created = await this.#client.createQr({ local_token_list: localTokens });
-        if (this.#accounts.listActiveAccounts().length +
-            this.#offers.listActive().length >= this.#maxAccounts) {
+        const created = await this.#client.createQr({ local_token_list: localTokens }, options.signal ? { signal: options.signal } : {});
+        if (options.signal?.aborted)
+            throw options.signal.reason;
+        assertIlinkQrContent(created.qrcode_img_content);
+        if (source.kind !== 'terminal' &&
+            this.#accounts.listActiveAccounts().length +
+                this.#offers.listActive().length >= this.#maxAccounts) {
             throw new Error('iLink account limit reached');
         }
         const offer = this.#offers.create({
-            sessionToken,
+            source,
             qrCode: created.qrcode,
-            apiBaseUrl: normalizeIlinkBaseUrl('https://ilinkai.weixin.qq.com/'),
+            apiBaseUrl: this.#baseUrl,
+            candidateAccountKeys: source.kind === 'terminal'
+                ? localAccounts.map(({ account }) => account.accountKey)
+                : [],
         });
-        let png;
-        try {
-            png = await renderIlinkQrPng(created.qrcode_img_content);
-        }
-        catch (error) {
-            this.#offers.finish(offer.offerId, 'failed');
-            throw error;
-        }
         this.#startPolling(offer);
-        return { offerId: offer.offerId, png };
+        return {
+            offerId: offer.offerId,
+            qrContent: created.qrcode_img_content,
+            expiresAt: offer.expiresAt,
+        };
+    }
+    status(offerId) {
+        const status = this.#offers.status(offerId);
+        if (status.status !== 'waiting' && status.status !== 'scanned') {
+            this.#running.get(offerId)?.controller.abort();
+        }
+        return status;
     }
     cancel(offerId) {
         this.#running.get(offerId)?.controller.abort();
-        this.#offers.finish(offerId, 'cancelled');
+        return this.#offers.finish(offerId, 'cancelled');
     }
     #startPolling(offer) {
         if (this.#running.has(offer.offerId) || this.#closed)
             return;
         const controller = new AbortController();
+        const expiryTimer = setTimeout(() => {
+            try {
+                this.#offers.finish(offer.offerId, 'expired');
+            }
+            catch {
+                this.#logger.warn?.('[ilink-login] expired offer cleanup failed');
+            }
+            finally {
+                controller.abort(new Error('iLink login offer expired'));
+            }
+        }, Math.max(0, Math.min(MAX_EXPIRY_TIMER_MS, offer.expiresAt - Number(this.#clock()))));
+        expiryTimer.unref();
         const task = this.#poll(offer, controller.signal).finally(() => {
+            clearTimeout(expiryTimer);
             if (this.#running.get(offer.offerId)?.controller === controller) {
                 this.#running.delete(offer.offerId);
             }
@@ -125,7 +158,36 @@ export class IlinkLoginManager {
                     return;
                 }
                 if (result.status === 'binded_redirect') {
-                    this.#offers.finish(offer.offerId, 'cancelled');
+                    if (offer.initiatorKind === 'local_operator') {
+                        const candidates = offer.candidateAccountKeys;
+                        let reported;
+                        try {
+                            if (result.ilink_bot_id) {
+                                reported = createIlinkAccountKey(String(result.ilink_bot_id));
+                            }
+                        }
+                        catch {
+                            reported = undefined;
+                        }
+                        const accountKey = reported && candidates.includes(reported)
+                            ? reported
+                            : candidates.length === 1
+                                ? candidates[0]
+                                : undefined;
+                        if (!accountKey) {
+                            this.#offers.finish(offer.offerId, 'failed');
+                            this.#logger.warn?.('[ilink-login] already-connected account could not be identified');
+                            return;
+                        }
+                        this.#accounts.confirmExistingEnrollment({
+                            offerId: offer.offerId,
+                            accountKey,
+                            now: Number(this.#clock()),
+                        });
+                    }
+                    else {
+                        this.#offers.finish(offer.offerId, 'already_connected');
+                    }
                     this.#logger.info?.('[ilink-login] account is already connected');
                     return;
                 }
@@ -138,6 +200,11 @@ export class IlinkLoginManager {
                 else if (result.status === 'scaned') {
                     offer = this.#offers.update(offer.offerId, { status: 'scanned' });
                 }
+                else if (result.status === 'need_verifycode' ||
+                    result.status === 'verify_code_blocked') {
+                    this.#offers.finish(offer.offerId, 'verification_required');
+                    return;
+                }
                 else if (result.status !== 'wait') {
                     this.#offers.finish(offer.offerId, result.status === 'expired' ? 'expired' : 'failed');
                     return;
@@ -194,5 +261,10 @@ export class IlinkLoginManager {
             running.controller.abort();
         await Promise.allSettled([...this.#running.values()].map(({ task }) => task));
         this.#running.clear();
+        for (const offer of this.#offers.listActive()) {
+            if (offer.initiatorKind === 'local_operator') {
+                this.#offers.finish(offer.offerId, 'cancelled');
+            }
+        }
     }
 }

package/dist/src/ilink/login-store.js

@@ -1,8 +1,11 @@
 import { createHash, randomBytes } from 'node:crypto';
 import { normalizeIlinkBaseUrl } from './protocol/client.js';
 import { IlinkSecretBox } from './secret-box.js';
-const DEFAULT_TTL_MS = 5 * 60 * 1_000;
+import { assertIlinkAccountKey, } from './store-types.js';
+const ILINK_LOGIN_TTL_MS = 5 * 60 * 1_000;
 const MAX_TTL_MS = 10 * 60 * 1_000;
+const TERMINAL_ACCOUNT_ID = 'local';
+const TERMINAL_PEER_ID = 'operator';
 function sha256(value) {
     return createHash('sha256').update(value).digest('hex');
 }
@@ -15,9 +18,7 @@ function rowAs(value) {
 function mapped(row) {
     return {
         offerId: row.offer_id,
-        sourceMessageKey: row.source_message_key,
-        sourceOpenKfId: row.source_open_kfid,
-        sourceExternalUserId: row.source_external_userid,
+        initiatorKind: row.initiator_kind,
         apiBaseUrl: row.api_base_url,
         status: row.status,
         expiresAt: Number(row.expires_at),
@@ -57,20 +58,52 @@ export class IlinkLoginStore {
     `).get(offerId));
     }
     #runtime(row) {
+        const candidates = JSON.parse(row.candidate_account_keys_json);
+        if (!Array.isArray(candidates) || candidates.length > 10) {
+            throw new Error('Invalid iLink login candidate accounts');
+        }
+        for (const accountKey of candidates) {
+            if (typeof accountKey !== 'string') {
+                throw new Error('Invalid iLink login candidate account');
+            }
+            assertIlinkAccountKey(accountKey);
+        }
         return {
             ...mapped(row),
+            candidateAccountKeys: Object.freeze([...candidates]),
             qrCode: this.#secrets.open({
                 nonce: row.nonce,
                 ciphertext: row.ciphertext,
                 authTag: row.auth_tag,
             }, {
                 secretKind: 'qr_token',
-                accountId: row.source_open_kfid,
-                peerId: row.source_external_userid,
+                accountId: row.source_account_id,
+                peerId: row.source_peer_id,
                 generation: row.secret_generation,
             }),
         };
     }
+    #source(source) {
+        if (source.kind === 'terminal') {
+            return {
+                initiatorKind: 'local_operator',
+                channel: source.kind,
+                messageKey: '',
+                accountId: TERMINAL_ACCOUNT_ID,
+                peerId: TERMINAL_PEER_ID,
+            };
+        }
+        const session = this.#store.getAgentSession(source.sessionToken);
+        if (session.channel !== 'wechat_kf')
+            throw new Error('Wrong channel for iLink offer');
+        return {
+            initiatorKind: 'remote_adapter',
+            channel: source.kind,
+            messageKey: session.messageKey,
+            accountId: session.accountKey,
+            peerId: session.peerId,
+        };
+    }
     #expire(now = Number(this.#clock())) {
         const expired = this.#database.prepare(`
       SELECT * FROM ilink_login_offers
@@ -82,43 +115,46 @@ export class IlinkLoginStore {
     #finishRow(row, result, accountKey, now) {
         this.#database.prepare(`
       INSERT INTO ilink_enrollment_audit (
-        offer_id, source_message_key, source_open_kfid,
-        source_external_userid, account_key, result, offered_at, completed_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        offer_id, initiator_kind, source_channel, source_message_key,
+        source_account_id, source_peer_id,
+        account_key, result, offered_at, completed_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(offer_id) DO NOTHING
-    `).run(row.offer_id, row.source_message_key, row.source_open_kfid, row.source_external_userid, accountKey, result, row.created_at, now);
+    `).run(row.offer_id, row.initiator_kind, row.source_channel, row.source_message_key, row.source_account_id, row.source_peer_id, accountKey, result, row.created_at, now);
         this.#database.prepare(`
       DELETE FROM ilink_login_offers WHERE offer_id = ?
     `).run(row.offer_id);
     }
-    findForSession(sessionToken) {
-        const session = this.#store.getAgentSession(sessionToken);
-        if (session.channel !== 'wechat_kf')
-            throw new Error('Wrong channel for iLink offer');
+    find(source) {
+        const identity = this.#source(source);
         return this.#transaction(() => {
             this.#expire();
             const row = rowAs(this.#database.prepare(`
         SELECT * FROM ilink_login_offers
-        WHERE source_open_kfid = ? AND source_external_userid = ?
+        WHERE source_channel = ? AND source_account_id = ? AND source_peer_id = ?
           AND status IN ('waiting', 'scanned')
-      `).get(session.accountKey, session.peerId));
+      `).get(identity.channel, identity.accountId, identity.peerId));
             return row ? mapped(row) : undefined;
         });
     }
-    create({ sessionToken, qrCode, apiBaseUrl, ttlMs = DEFAULT_TTL_MS, }) {
-        const session = this.#store.getAgentSession(sessionToken);
-        if (session.channel !== 'wechat_kf')
-            throw new Error('Wrong channel for iLink offer');
+    create({ source, qrCode, apiBaseUrl, ttlMs = ILINK_LOGIN_TTL_MS, candidateAccountKeys = [], }) {
+        const identity = this.#source(source);
         if (!qrCode || Buffer.byteLength(qrCode, 'utf8') > 8_192) {
             throw new Error('Invalid iLink QR token');
         }
         const lifetime = Math.max(1_000, Math.min(Number(ttlMs) || 0, MAX_TTL_MS));
         const offerId = `qo_${randomBytes(20).toString('base64url')}`;
         const generation = secretGeneration(offerId);
+        if (candidateAccountKeys.length > 10) {
+            throw new Error('Too many iLink login candidate accounts');
+        }
+        for (const accountKey of candidateAccountKeys)
+            assertIlinkAccountKey(accountKey);
+        const candidates = JSON.stringify([...new Set(candidateAccountKeys)]);
         const sealed = this.#secrets.seal(qrCode, {
             secretKind: 'qr_token',
-            accountId: session.accountKey,
-            peerId: session.peerId,
+            accountId: identity.accountId,
+            peerId: identity.peerId,
             generation,
         });
         const now = Number(this.#clock());
@@ -126,19 +162,20 @@ export class IlinkLoginStore {
             this.#expire(now);
             const existing = this.#database.prepare(`
         SELECT 1 FROM ilink_login_offers
-        WHERE source_open_kfid = ? AND source_external_userid = ?
+        WHERE source_channel = ? AND source_account_id = ? AND source_peer_id = ?
           AND status IN ('waiting', 'scanned')
-      `).get(session.accountKey, session.peerId);
+      `).get(identity.channel, identity.accountId, identity.peerId);
             if (existing)
                 throw new Error('An iLink login offer is already pending');
             this.#database.prepare(`
         INSERT INTO ilink_login_offers (
-          offer_id, source_message_key, source_open_kfid,
-          source_external_userid, secret_generation,
-          nonce, ciphertext, auth_tag, api_base_url, status,
+          offer_id, initiator_kind, source_channel, source_message_key,
+          source_account_id, source_peer_id, secret_generation,
+          candidate_account_keys_json, nonce, ciphertext, auth_tag,
+          api_base_url, status,
           expires_at, last_polled_at, created_at, updated_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'waiting', ?, 0, ?, ?)
-      `).run(offerId, session.messageKey, session.accountKey, session.peerId, generation, sealed.nonce, sealed.ciphertext, sealed.authTag, normalizeIlinkBaseUrl(apiBaseUrl), now + lifetime, now, now);
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'waiting', ?, 0, ?, ?)
+      `).run(offerId, identity.initiatorKind, identity.channel, identity.messageKey, identity.accountId, identity.peerId, generation, candidates, sealed.nonce, sealed.ciphertext, sealed.authTag, normalizeIlinkBaseUrl(apiBaseUrl), now + lifetime, now, now);
             return this.#runtime(this.#row(offerId));
         });
     }
@@ -158,6 +195,18 @@ export class IlinkLoginStore {
         AND expires_at > ?
     `).get(offerId, Number(this.#clock())));
     }
+    status(offerId) {
+        return this.#transaction(() => {
+            this.#expire();
+            const active = this.#row(offerId);
+            if (active)
+                return { status: active.status };
+            const audit = rowAs(this.#database.prepare(`
+        SELECT result FROM ilink_enrollment_audit WHERE offer_id = ?
+      `).get(offerId));
+            return { status: audit?.result || 'unknown' };
+        });
+    }
     update(offerId, input) {
         const now = Number(this.#clock());
         return this.#transaction(() => {

package/dist/src/ilink/qr.js

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { PNG } from 'pngjs';
-import { create } from 'qrcode';
+import { create, toBuffer } from 'qrcode';
 const MAX_QR_CONTENT_BYTES = 2_048;
 const MAX_QR_PNG_BYTES = 512 * 1_024;
 const CARD_WIDTH = 720;
@@ -11,10 +11,13 @@ const QR_REGION_X = 120;
 const QR_REGION_Y = 220;
 const QR_REGION_SIZE = 480;
 const QUIET_ZONE_MODULES = 4;
+const RAW_QR_SCALE = 6;
 const QR_DARK = Object.freeze([0x11, 0x18, 0x14, 0xff]);
 const PNG_SIGNATURE = Buffer.from([
     0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
 ]);
+const TERMINAL_INK = '\u001b[47m\u001b[30m';
+const TERMINAL_RESET = '\u001b[0m';
 function templatePath() {
     const moduleDirectory = path.dirname(fileURLToPath(import.meta.url));
     const sourcePath = path.resolve(moduleDirectory, '../../assets/ilink-login-card.png');
@@ -42,7 +45,7 @@ export class IlinkQrRenderError extends Error {
         this.code = code;
     }
 }
-function validateContent(content) {
+export function assertIlinkQrContent(content) {
     if (typeof content !== 'string' ||
         content.trim().length === 0 ||
         Buffer.byteLength(content, 'utf8') > MAX_QR_CONTENT_BYTES) {
@@ -91,7 +94,7 @@ function renderCard(content) {
     });
 }
 export async function renderIlinkQrPng(content) {
-    validateContent(content);
+    assertIlinkQrContent(content);
     let png;
     try {
         png = renderCard(content);
@@ -107,3 +110,64 @@ export async function renderIlinkQrPng(content) {
     }
     return png;
 }
+export async function renderIlinkRawQrPng(content) {
+    assertIlinkQrContent(content);
+    let png;
+    try {
+        png = await toBuffer(content, {
+            errorCorrectionLevel: 'M',
+            margin: QUIET_ZONE_MODULES,
+            scale: RAW_QR_SCALE,
+            type: 'png',
+            color: {
+                dark: '#111814ff',
+                light: '#ffffffff',
+            },
+        });
+    }
+    catch {
+        throw new IlinkQrRenderError('qr_render_failed', 'Unable to render iLink QR image');
+    }
+    if (png.length < PNG_SIGNATURE.length || !png.subarray(0, 8).equals(PNG_SIGNATURE)) {
+        throw new IlinkQrRenderError('invalid_qr_png', 'Rendered iLink QR image is invalid');
+    }
+    if (png.length > MAX_QR_PNG_BYTES) {
+        throw new IlinkQrRenderError('qr_png_too_large', 'Rendered iLink QR image is too large');
+    }
+    return png;
+}
+export function renderIlinkQrTerminal(content) {
+    assertIlinkQrContent(content);
+    let qr;
+    try {
+        qr = create(content, { errorCorrectionLevel: 'M' });
+    }
+    catch {
+        throw new IlinkQrRenderError('qr_render_failed', 'Unable to render iLink QR code');
+    }
+    const matrixSize = qr.modules.size;
+    const columns = matrixSize + QUIET_ZONE_MODULES * 2;
+    const rows = Math.ceil(columns / 2);
+    const dark = (row, column) => {
+        const matrixRow = row - QUIET_ZONE_MODULES;
+        const matrixColumn = column - QUIET_ZONE_MODULES;
+        return (matrixRow >= 0 && matrixRow < matrixSize &&
+            matrixColumn >= 0 && matrixColumn < matrixSize &&
+            Boolean(qr.modules.get(matrixRow, matrixColumn)));
+    };
+    const lines = [];
+    for (let row = 0; row < columns; row += 2) {
+        let line = TERMINAL_INK;
+        for (let column = 0; column < columns; column += 1) {
+            const top = dark(row, column);
+            const bottom = dark(row + 1, column);
+            line += top ? (bottom ? '█' : '▀') : (bottom ? '▄' : ' ');
+        }
+        lines.push(`${line}${TERMINAL_RESET}`);
+    }
+    return Object.freeze({
+        text: `${lines.join('\n')}\n`,
+        columns,
+        rows,
+    });
+}

package/dist/src/ilink/secret-box.js

@@ -1,4 +1,7 @@
 import { createCipheriv, createDecipheriv, createSecretKey, randomBytes, } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertTrustedDirectory, ensurePrivateDirectory, } from '../lib/private-directory.js';
 const KEY_BYTES = 32;
 const NONCE_BYTES = 12;
 const AUTH_TAG_BYTES = 16;
@@ -27,6 +30,76 @@ function decodeConfiguredKey(configuredKey) {
     }
     return decoded;
 }
+export function readOrCreateIlinkStorageKey(filePath, { allowCreate }) {
+    const target = path.resolve(filePath);
+    const parent = ensurePrivateDirectory(path.dirname(target));
+    assertTrustedDirectory(parent, 'iLink storage key directory', true);
+    try {
+        const stat = fs.lstatSync(target);
+        if (!stat.isFile() || stat.isSymbolicLink()) {
+            throw new Error(`iLink storage key is not a regular file: ${target}`);
+        }
+        if (process.platform !== 'win32') {
+            const uid = process.getuid?.();
+            if ((uid !== undefined && stat.uid !== uid) || (stat.mode & 0o077) !== 0) {
+                throw new Error(`iLink storage key has unsafe permissions: ${target}`);
+            }
+        }
+        const configuredKey = fs.readFileSync(target, 'utf8').trim();
+        const decoded = decodeConfiguredKey(configuredKey);
+        decoded.fill(0);
+        return configuredKey;
+    }
+    catch (error) {
+        if (!(error instanceof Error && 'code' in error && error.code === 'ENOENT')) {
+            throw error;
+        }
+    }
+    if (!allowCreate) {
+        throw new Error('iLink storage key is missing for existing encrypted state');
+    }
+    const configuredKey = randomBytes(KEY_BYTES).toString('base64url');
+    let descriptor;
+    let created = false;
+    try {
+        descriptor = fs.openSync(target, 'wx', 0o600);
+        created = true;
+        fs.writeFileSync(descriptor, `${configuredKey}\n`, 'utf8');
+        fs.fsyncSync(descriptor);
+        fs.closeSync(descriptor);
+        descriptor = undefined;
+        if (process.platform !== 'win32') {
+            const parentDescriptor = fs.openSync(parent, 'r');
+            try {
+                fs.fsyncSync(parentDescriptor);
+            }
+            finally {
+                fs.closeSync(parentDescriptor);
+            }
+        }
+        return configuredKey;
+    }
+    catch (error) {
+        if (descriptor !== undefined) {
+            try {
+                fs.closeSync(descriptor);
+            }
+            catch { }
+        }
+        if (created) {
+            try {
+                fs.unlinkSync(target);
+            }
+            catch (cleanupError) {
+                throw new AggregateError([error, cleanupError], 'iLink storage key creation and cleanup both failed');
+            }
+        }
+        if (error instanceof Error && 'code' in error && error.code === 'EEXIST') {
+            return readOrCreateIlinkStorageKey(target, { allowCreate });
+        }
+        throw error;
+    }
+}
 function boundedScopeText(value) {
     return typeof value === 'string' &&
         value.length > 0 &&