@bluelamp/cli-token 1.1.0 → 1.3.0-rc.0

package/dist/esm/index.js

@@ -11,7 +11,7 @@
  * - 失敗の返し方は消費側で分かれていたので、throw 版（readCliTokenSync）と
  *   null 版（tryReadCliToken）の両方を出す。片方に寄せると挙動が変わる。
  */
-import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from 'node:crypto';
+import { createCipheriv, createDecipheriv, createHash, createPrivateKey, createPublicKey, generateKeyPairSync, randomBytes, scryptSync, sign, } from 'node:crypto';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
@@ -54,8 +54,12 @@ export class CliTokenNotFoundError extends Error {
         this.name = 'CliTokenNotFoundError';
     }
 }
+// 入力が定数なので 1 回だけ導く（scrypt は 1 回数十 ms。札を読むたびに払わない）
+let derivedKeyCache = null;
 function derivedKey() {
-    return scryptSync(SECRET, KEY_SALT, KEY_LENGTH);
+    if (!derivedKeyCache)
+        derivedKeyCache = scryptSync(SECRET, KEY_SALT, KEY_LENGTH);
+    return derivedKeyCache;
 }
 // ── functional core（I/O を持たない。ここだけで判定と変換が閉じる）──────────────
 /** 平文を `<ivHex>:<payloadHex>` にする。IV は毎回ランダム。 */
@@ -141,8 +145,12 @@ export function loadPortalToken() {
     }
     return data;
 }
-/** トークンを暗号化保存する。フォーマット不正・書込失敗は throw。 */
-export function savePortalToken(token, userInfo = {}) {
+/**
+ * トークンを暗号化保存する。フォーマット不正・書込失敗は throw。
+ * n=3918: 置き場は 0600（フォルダ 0700）。一時ファイルに書いてから rename する＝読み手が書きかけを読まない。
+ * `binding` は機体に結んだ札だけが渡す（期限と機体の id）。
+ */
+export function savePortalToken(token, userInfo = {}, binding) {
     if (!validateTokenFormat(token)) {
         throw new Error('Invalid CLI token format');
     }
@@ -152,13 +160,33 @@ export function savePortalToken(token, userInfo = {}) {
         userInfo,
         version: '1.0',
         source: 'portal',
+        ...(binding ? { expiresAt: binding.expiresAt, deviceId: binding.deviceId } : {}),
     };
-    const filePath = getTokenFilePath();
-    const dir = path.dirname(filePath);
-    if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
+    writePrivateFileAtomic(getTokenFilePath(), encryptPayload(JSON.stringify(tokenData)));
+}
+/** 自分だけが読めるフォルダ（0700）を用意する。既に在るフォルダも 0700 に揃える */
+function ensurePrivateDir(dir) {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    fs.chmodSync(dir, 0o700);
+}
+/** 一時ファイル（0600）に書いて rename する。umask に依らず 0600 */
+function writePrivateFileAtomic(filePath, content) {
+    ensurePrivateDir(path.dirname(filePath));
+    const tmp = `${filePath}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`;
+    try {
+        fs.writeFileSync(tmp, content, { mode: 0o600, flag: 'wx' });
+        fs.chmodSync(tmp, 0o600);
+        fs.renameSync(tmp, filePath);
+    }
+    catch (e) {
+        try {
+            fs.unlinkSync(tmp);
+        }
+        catch {
+            // 書けていなければ無い
+        }
+        throw e;
     }
-    fs.writeFileSync(filePath, encryptPayload(JSON.stringify(tokenData)));
 }
 /** 保存済みトークンを削除する。ファイル無しは no-op。削除失敗は throw。 */
 export function deletePortalToken() {
@@ -356,4 +384,582 @@ async function decideFleetGate(options) {
     });
     return { allowed: isAllowedForScope(asked.status, asked.reason, scope), status: asked.status, reason: asked.reason, from: 'network' };
 }
+/** 期限の何 ms 前から取り直すか（既定）。10 分の札で 9 分は使い回す */
+export const EXCHANGED_JWT_REFRESH_BUFFER_MS = 60_000;
+/** 他のプロセスが取り直している間に待つ上限（既定）。過ぎたら自分で取る（fail-open） */
+export const EXCHANGED_JWT_LOCK_WAIT_MS = 5_000;
+/** ロックがこれより古ければ持ち主は死んだと読む（exchange の打ち切りより長く取る） */
+export const EXCHANGED_JWT_LOCK_STALE_MS = 30_000;
+const LOCK_POLL_MS = 100;
+/**
+ * 置き場。`BLUELAMP_JWT_CACHE_DIR` が在ればそこ（消費側のテストが実機の置き場を触らないため）、無ければ
+ * `~/.bluelamp/jwt-cache`。テストで HOME を差し替えられるよう呼び出し時に解決する
+ */
+export function getExchangedJwtCacheDir() {
+    return process.env.BLUELAMP_JWT_CACHE_DIR || path.join(os.homedir(), '.bluelamp', 'jwt-cache');
+}
+/** 鍵（純関数）。sha256 の 16 進 64 文字＝そのままファイル名に使える */
+export function exchangedJwtCacheKey(k) {
+    const fingerprint = createHash('sha256').update(k.cliToken).digest('hex');
+    const material = JSON.stringify([k.baseUrl.replace(/\/+$/, ''), k.mcpId, [...k.scopes].sort(), fingerprint]);
+    return createHash('sha256').update(material).digest('hex');
+}
+/** キャッシュの中身を検める（純関数）。形が違えば null＝キャッシュ無しと同じ */
+export function parseCachedExchangedJwt(raw) {
+    let v;
+    try {
+        v = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    const o = v;
+    if (!o || typeof o.token !== 'string' || o.token.length === 0)
+        return null;
+    if (typeof o.expiresAt !== 'number' || !Number.isFinite(o.expiresAt))
+        return null;
+    return { token: o.token, expiresAt: o.expiresAt };
+}
+/** まだ使ってよいか（純関数）。期限の bufferMs 前を過ぎたら使わない */
+export function isCachedExchangedJwtUsable(c, nowMs, bufferMs) {
+    return nowMs < c.expiresAt - bufferMs;
+}
+function cacheFilePath(dir, key) {
+    return path.join(dir, `${exchangedJwtCacheKey(key)}.json`);
+}
+/** 読む。自分だけが読める（group/other のビットが立っていない）ファイルしか信じない */
+function readCachedJwt(file) {
+    try {
+        const st = fs.statSync(file);
+        if ((st.mode & 0o077) !== 0)
+            return null;
+        if (typeof process.getuid === 'function' && st.uid !== process.getuid())
+            return null;
+        return parseCachedExchangedJwt(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function writeCachedJwt(file, c) {
+    try {
+        fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+        const tmp = `${file}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`;
+        fs.writeFileSync(tmp, JSON.stringify(c) + '\n', { mode: 0o600 });
+        fs.chmodSync(tmp, 0o600); // umask に依らず 600
+        fs.renameSync(tmp, file);
+    }
+    catch {
+        // 書けなくても今回の JWT は返す（次のプロセスがもう 1 回取るだけ）
+    }
+}
+/** ロックを取る。取れたら true。古いロック（持ち主が死んだ）は 1 回だけ払って取り直す */
+function tryLock(lockFile, nowMs, staleMs = EXCHANGED_JWT_LOCK_STALE_MS) {
+    for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+            fs.mkdirSync(path.dirname(lockFile), { recursive: true, mode: 0o700 });
+            fs.closeSync(fs.openSync(lockFile, 'wx', 0o600));
+            return true;
+        }
+        catch (e) {
+            if (e.code !== 'EEXIST')
+                return false;
+            try {
+                if (nowMs - fs.statSync(lockFile).mtimeMs <= staleMs)
+                    return false;
+                fs.unlinkSync(lockFile);
+            }
+            catch {
+                return false;
+            }
+        }
+    }
+    return false;
+}
+function unlock(lockFile) {
+    try {
+        fs.unlinkSync(lockFile);
+    }
+    catch {
+        // 消えていても構わない
+    }
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+ * 機体で共有する JWT を返す。使える JWT がファイルに在れば口に出ない。
+ * 無い／切れかけなら、ロックを取った 1 プロセスだけが exchange して書く。他はその間ファイルを待つ
+ * （lockWaitMs を過ぎたら自分で取る）。exchange の失敗は throw のまま返す。
+ */
+export async function getExchangedJwt(options) {
+    const now = options.now ?? Date.now;
+    const bufferMs = options.refreshBufferMs ?? EXCHANGED_JWT_REFRESH_BUFFER_MS;
+    const file = cacheFilePath(options.cacheDir ?? getExchangedJwtCacheDir(), options.key);
+    const usable = () => {
+        const c = readCachedJwt(file);
+        return c && isCachedExchangedJwtUsable(c, now(), bufferMs) ? c.token : null;
+    };
+    const hit = usable();
+    if (hit)
+        return hit;
+    const lockFile = `${file}.lock`;
+    const waitUntil = now() + Math.max(0, options.lockWaitMs ?? EXCHANGED_JWT_LOCK_WAIT_MS);
+    let locked = tryLock(lockFile, now());
+    while (!locked && now() < waitUntil) {
+        await sleep(LOCK_POLL_MS);
+        const fresh = usable();
+        if (fresh)
+            return fresh;
+        locked = tryLock(lockFile, now());
+    }
+    try {
+        if (locked) {
+            // ロックを待っている間に他のプロセスが書いたかもしれない
+            const fresh = usable();
+            if (fresh)
+                return fresh;
+        }
+        const got = await options.exchange();
+        writeCachedJwt(file, { token: got.token, expiresAt: now() + got.expiresInSec * 1000 });
+        return got.token;
+    }
+    finally {
+        if (locked)
+            unlock(lockFile);
+    }
+}
+/**
+ * 受け手に拒まれた（401）JWT を捨てる。ファイルの中身が `rejectedToken` のときだけ消す
+ * （その間に他のプロセスが書いた新しい JWT は消さない）。throw しない。
+ */
+export function evictExchangedJwt(key, rejectedToken, cacheDir = getExchangedJwtCacheDir()) {
+    const file = cacheFilePath(cacheDir, key);
+    try {
+        if (parseCachedExchangedJwt(fs.readFileSync(file, 'utf8'))?.token === rejectedToken)
+            fs.unlinkSync(file);
+    }
+    catch {
+        // 無ければ何もしない
+    }
+}
+// ── 機体の鍵と札の延長（箱 n=3918）─────────────────────────────────────────────
+//
+// 🩸 なぜ: CLI の札は期限なしで、1 本写せばどの機体からでも金庫・連携の鍵・合言葉の変更まで届いた。
+// 🔑 線（箱 n=3918 の設計が正本）:
+// - 機体の鍵は Ed25519。`~/.musuhi/device-key.pem`（PKCS8・0600・フォルダ 0700）。OS ユーザー 1 つに鍵 1 つ。
+//   ⛔ OS の鍵束に置かない（SSH・launchd の予約の便で開かない）
+// - 口座ごとの機体の id は `~/.musuhi/device.json`（0600）に `{ "<user_id>": "<device_id>" }`
+// - 機体に結んだ札は 1 時間。残り 15 分を切ったら、`~/.musuhi/token-refresh.lock`（O_EXCL）を取れた
+//   1 手だけが延ばし、他は読む（機体ごとに 1 か所）。2 分より古いロックは持ち主が死んだと読んで払う
+// - 延ばす口は機体の鍵で署名する。普段の要求は今までどおり札だけ（1 回ごとに署名しない）
+// - ⛔ 札・署名・鍵をログ・例外文・返り値の detail に出さない。throw しない（延ばせなくても本線を落とさない）
+/** 機体の鍵の置き場。テストで HOME を差し替えられるよう呼び出し時に解決する */
+export function getDeviceKeyPath() {
+    return path.join(os.homedir(), '.musuhi', 'device-key.pem');
+}
+/** 口座ごとの機体の id の置き場 */
+export function getDeviceMapPath() {
+    return path.join(os.homedir(), '.musuhi', 'device.json');
+}
+/** 札を延ばす 1 手を選ぶロック */
+export function getTokenRefreshLockPath() {
+    return path.join(os.homedir(), '.musuhi', 'token-refresh.lock');
+}
+/** 機体の鍵が読めない（権限が開いている・形が壊れている）。文面に鍵の中身は載せない */
+export class DeviceKeyError extends Error {
+    constructor(detail) {
+        super(`機体の鍵を使えません（${getDeviceKeyPath()}）: ${detail}`);
+        this.name = 'DeviceKeyError';
+    }
+}
+function deviceKeyFromPem(pem) {
+    const privateKey = createPrivateKey({ key: pem, format: 'pem' });
+    if (privateKey.asymmetricKeyType !== 'ed25519') {
+        throw new DeviceKeyError(`鍵の種類が ed25519 でない（${String(privateKey.asymmetricKeyType)}）`);
+    }
+    const publicKeyPem = createPublicKey(privateKey).export({ type: 'spki', format: 'pem' }).toString();
+    return { privateKey, publicKeyPem };
+}
+/**
+ * 機体の鍵を読む。無ければ null。
+ * 自分以外が読める（group/other のビットが立っている）・持ち主が違う鍵は使わない＝DeviceKeyError
+ * （ssh が開いた秘密鍵を拒むのと同じ線。黙って直さない）。
+ */
+export function readDeviceKey() {
+    const keyPath = getDeviceKeyPath();
+    let st;
+    try {
+        st = fs.statSync(keyPath);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return null;
+        throw new DeviceKeyError(`読めない: ${e.message}`);
+    }
+    if ((st.mode & 0o077) !== 0) {
+        throw new DeviceKeyError(`権限が 600 でない（${(st.mode & 0o777).toString(8)}）`);
+    }
+    if (typeof process.getuid === 'function' && st.uid !== process.getuid()) {
+        throw new DeviceKeyError('持ち主がこの OS ユーザーでない');
+    }
+    try {
+        return deviceKeyFromPem(fs.readFileSync(keyPath, 'utf8'));
+    }
+    catch (e) {
+        if (e instanceof DeviceKeyError)
+            throw e;
+        throw new DeviceKeyError('鍵の形が読めない');
+    }
+}
+/**
+ * 機体の鍵を読む。無ければ作る（0600・フォルダ 0700）。
+ * 同時に 2 つが作ろうとしても 'wx' で 1 つだけが書き、負けた側は書かれた鍵を読む。
+ */
+export function loadOrCreateDeviceKey() {
+    const existing = readDeviceKey();
+    if (existing)
+        return existing;
+    const keyPath = getDeviceKeyPath();
+    ensurePrivateDir(path.dirname(keyPath));
+    const { privateKey } = generateKeyPairSync('ed25519');
+    const pem = privateKey.export({ type: 'pkcs8', format: 'pem' }).toString();
+    try {
+        fs.writeFileSync(keyPath, pem, { mode: 0o600, flag: 'wx' });
+        fs.chmodSync(keyPath, 0o600);
+    }
+    catch (e) {
+        if (e.code !== 'EEXIST')
+            throw e;
+        const won = readDeviceKey();
+        if (won)
+            return won;
+        throw new DeviceKeyError('作ったはずの鍵が読めない');
+    }
+    return deviceKeyFromPem(pem);
+}
+/** 署名する文（純関数）: 登録の待ちの問い合わせ */
+export function devicePollMessage(deviceCode, ts) {
+    return `bluelamp-device-poll\n${deviceCode}\n${ts}`;
+}
+/** 署名する文（純関数）: 札の延長 */
+export function tokenRefreshMessage(deviceId, ts, nonce) {
+    return `bluelamp-token-refresh\n${deviceId}\n${ts}\n${nonce}`;
+}
+/** 機体の鍵で署名する。返りは Ed25519 の署名の base64（標準・パディングあり） */
+export function signWithDeviceKey(key, message) {
+    return sign(null, Buffer.from(message, 'utf8'), key.privateKey).toString('base64');
+}
+/** 口座ごとの機体の id を読む。無い・壊れている＝空 */
+export function readDeviceMap() {
+    try {
+        const v = JSON.parse(fs.readFileSync(getDeviceMapPath(), 'utf8'));
+        if (!v || typeof v !== 'object' || Array.isArray(v))
+            return {};
+        const out = {};
+        for (const [k, val] of Object.entries(v)) {
+            if (typeof val === 'string' && val.length > 0)
+                out[k] = val;
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+/** この口座の機体の id。無ければ null */
+export function readDeviceId(userId) {
+    return readDeviceMap()[userId] ?? null;
+}
+/** この口座の機体の id を書く（他の口座の行は残す・0600・rename） */
+export function saveDeviceId(userId, deviceId) {
+    const map = readDeviceMap();
+    map[userId] = deviceId;
+    writePrivateFileAtomic(getDeviceMapPath(), JSON.stringify(map, null, 2) + '\n');
+}
+/** 残りがこれを切ったら延ばす */
+export const CLI_TOKEN_REFRESH_BEFORE_MS = 15 * 60_000;
+/** 延ばすロックがこれより古ければ持ち主は死んだと読む */
+export const TOKEN_REFRESH_LOCK_STALE_MS = 2 * 60_000;
+/** 他の手が延ばしている間に待つ上限（既定）。過ぎたら今の札のまま返す */
+export const TOKEN_REFRESH_LOCK_WAIT_MS = 5_000;
+const TOKEN_REFRESH_TIMEOUT_MS = 10_000;
+/** サーバの期限（ISO 文字列・epoch 秒・epoch ms のどれか）を epoch ms に（純関数）。読めなければ null */
+export function parseExpiresAt(v) {
+    if (typeof v === 'number' && Number.isFinite(v) && v > 0)
+        return v < 1e12 ? v * 1000 : v;
+    if (typeof v === 'string' && v.length > 0) {
+        const ms = Date.parse(v);
+        return Number.isFinite(ms) ? ms : null;
+    }
+    return null;
+}
+/** 延ばすべきか（純関数）。古い札（期限・機体の id が無い）は延ばさない */
+export function needsRefresh(data, nowMs, beforeMs) {
+    if (typeof data.expiresAt !== 'number' || !data.deviceId)
+        return false;
+    return data.expiresAt - nowMs <= beforeMs;
+}
+function loadPortalTokenQuiet() {
+    try {
+        return loadPortalToken();
+    }
+    catch {
+        return null;
+    }
+}
+function portalBase(explicit) {
+    return (explicit ?? (process.env.BLUELAMP_PORTAL_API_BASE_URL || process.env.PORTAL_URL || FLEET_DEFAULT_BASE)).replace(/\/+$/, '');
+}
+async function postRefresh(url, current, key, nowMs, fetchFn, timeoutMs) {
+    const deviceId = current.deviceId;
+    const ts = Math.floor(nowMs / 1000);
+    const nonce = randomBytes(16).toString('hex');
+    const signature = signWithDeviceKey(key, tokenRefreshMessage(deviceId, ts, nonce));
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), timeoutMs);
+    let res;
+    try {
+        res = await fetchFn(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', 'X-CLI-Token': current.token },
+            body: JSON.stringify({ device_id: deviceId, ts, nonce, signature }),
+            signal: ac.signal,
+        });
+    }
+    catch (e) {
+        return { status: 'error', detail: ac.signal.aborted ? `timeout ${timeoutMs}ms` : `network: ${e.message}` };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    let body = null;
+    try {
+        body = (await res.json());
+    }
+    catch {
+        body = null;
+    }
+    if (!res.ok) {
+        const code = typeof body?.code === 'string' ? body.code : null;
+        if (res.status === 409 && code === 'device_over_quota')
+            return { status: 'device_over_quota', detail: 'http 409' };
+        if (res.status >= 400 && res.status < 500)
+            return { status: 'rejected', detail: `http ${res.status}${code ? ` ${code}` : ''}` };
+        return { status: 'error', detail: `http ${res.status}` };
+    }
+    const data = (body && typeof body.data === 'object' && body.data !== null ? body.data : body);
+    const token = data?.token;
+    const expiresAt = parseExpiresAt(data?.expires_at);
+    if (!validateTokenFormat(token) || expiresAt === null)
+        return { status: 'error', detail: 'invalid response' };
+    const newDeviceId = typeof data?.device_id === 'string' && data.device_id ? data.device_id : deviceId;
+    try {
+        savePortalToken(token, current.userInfo ?? {}, { expiresAt, deviceId: newDeviceId });
+    }
+    catch (e) {
+        return { status: 'error', detail: `save failed: ${e.message}` };
+    }
+    return { status: 'refreshed', expiresAt };
+}
+/**
+ * 札を延ばす（機体ごとに 1 か所）。**throw しない**。
+ * 残りが 15 分を切った機体に結んだ札だけ、ロックを取れた 1 手が `POST {base}/cli/token/refresh` を撃ち、
+ * 新しい札を一時ファイル→rename（0600）で置き場に書く。他の手はその間待ってから今の置き場を読めばよい。
+ * 期限が過ぎていても撃つ（サーバは期限切れ 30 日までの同じ機体の札を受ける）。
+ */
+export async function ensureFreshCliToken(options = {}) {
+    const now = options.now ?? Date.now;
+    const beforeMs = options.refreshBeforeMs ?? CLI_TOKEN_REFRESH_BEFORE_MS;
+    const initial = loadPortalTokenQuiet();
+    if (!initial || !initial.token)
+        return { status: 'no_token' };
+    if (typeof initial.expiresAt !== 'number' || !initial.deviceId)
+        return { status: 'legacy' };
+    if (!needsRefresh(initial, now(), beforeMs))
+        return { status: 'fresh', expiresAt: initial.expiresAt };
+    const lockFile = getTokenRefreshLockPath();
+    if (!tryLock(lockFile, Date.now(), TOKEN_REFRESH_LOCK_STALE_MS)) {
+        // 他の手が延ばしている。札が替わるまで少し待つ（替わらなくても今の札のまま返す）
+        // 待ちは実時間で測る（now は期限の判定のための時計で、試験では止まっている）
+        const waitUntil = Date.now() + Math.max(0, options.lockWaitMs ?? TOKEN_REFRESH_LOCK_WAIT_MS);
+        while (Date.now() < waitUntil) {
+            await new Promise((r) => setTimeout(r, LOCK_POLL_MS));
+            const cur = loadPortalTokenQuiet();
+            if (cur && cur.token !== initial.token)
+                return { status: 'locked', expiresAt: cur.expiresAt };
+        }
+        return { status: 'locked', detail: 'another refresher holds the lock' };
+    }
+    try {
+        // ロックを取る間に他の手が延ばしたかもしれない
+        const current = loadPortalTokenQuiet();
+        if (!current || !current.token)
+            return { status: 'no_token' };
+        if (typeof current.expiresAt !== 'number' || !current.deviceId)
+            return { status: 'legacy' };
+        if (!needsRefresh(current, now(), beforeMs))
+            return { status: 'fresh', expiresAt: current.expiresAt };
+        let key;
+        try {
+            key = readDeviceKey();
+        }
+        catch (e) {
+            return { status: 'error', detail: e.message };
+        }
+        if (!key)
+            return { status: 'error', detail: 'device key missing' };
+        const fetchFn = options.fetch ?? globalThis.fetch;
+        if (typeof fetchFn !== 'function')
+            return { status: 'error', detail: 'fetch unavailable' };
+        return await postRefresh(`${portalBase(options.baseUrl)}/cli/token/refresh`, current, key, now(), fetchFn, options.timeoutMs ?? TOKEN_REFRESH_TIMEOUT_MS);
+    }
+    finally {
+        unlock(lockFile);
+    }
+}
+/**
+ * 延ばしてから札を読む（読めなければ null・throw しない）。
+ * 401 を受けた読み手が「置き場を読み直して 1 回だけ撃ち直す」ときの読み直しに使う。
+ */
+export async function readFreshCliToken(options = {}) {
+    await ensureFreshCliToken(options);
+    return tryReadCliToken();
+}
+async function postJson(url, body, opts) {
+    const fetchFn = opts.fetch ?? globalThis.fetch;
+    if (typeof fetchFn !== 'function')
+        return { ok: false, detail: 'fetch unavailable' };
+    const timeoutMs = opts.timeoutMs ?? TOKEN_REFRESH_TIMEOUT_MS;
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), timeoutMs);
+    try {
+        const res = await fetchFn(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+            signal: ac.signal,
+        });
+        let json = null;
+        try {
+            json = (await res.json());
+        }
+        catch {
+            json = null;
+        }
+        return { ok: true, status: res.status, json };
+    }
+    catch (e) {
+        return { ok: false, detail: ac.signal.aborted ? `timeout ${timeoutMs}ms` : `network: ${e.message}` };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** `{success, data}` で包まれていても素でも中身を取る（純関数） */
+function unwrapData(json) {
+    if (json && typeof json.data === 'object' && json.data !== null && !Array.isArray(json.data)) {
+        return json.data;
+    }
+    return json;
+}
+/** 登録を始める（番号をもらう）。公開鍵を送る＝秘密鍵は機体から出ない */
+export async function startDeviceRegistration(key, req, opts = {}) {
+    const r = await postJson(`${portalBase(opts.baseUrl)}/cli/device/start`, {
+        public_key: key.publicKeyPem,
+        device_name: req.deviceName,
+        platform: req.platform,
+        arch: req.arch,
+        os_user: req.osUser,
+        client: req.client,
+        ...(req.pinTenantId ? { pin_tenant_id: req.pinTenantId } : {}),
+    }, opts);
+    if (!r.ok)
+        return { ok: false, httpStatus: null, code: null, detail: r.detail };
+    const d = unwrapData(r.json);
+    const code = typeof r.json?.code === 'string' ? r.json.code : null;
+    if (r.status < 200 || r.status >= 300) {
+        const message = typeof r.json?.message === 'string' ? r.json.message : `http ${r.status}`;
+        return { ok: false, httpStatus: r.status, code, detail: message };
+    }
+    const deviceCode = d?.device_code;
+    const userCode = d?.user_code;
+    const verificationUri = d?.verification_uri;
+    if (typeof deviceCode !== 'string' || !deviceCode || typeof userCode !== 'string' || !userCode || typeof verificationUri !== 'string') {
+        return { ok: false, httpStatus: r.status, code, detail: 'invalid response' };
+    }
+    const num = (v, dflt) => (typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : dflt);
+    return {
+        ok: true,
+        start: {
+            deviceCode,
+            userCode,
+            verificationUri,
+            expiresInSec: num(d?.expires_in, 600),
+            intervalSec: num(d?.interval, 5),
+        },
+    };
+}
+/** 承認を 1 回だけ問い合わせる（機体の鍵で署名する） */
+export async function pollDeviceRegistration(key, deviceCode, opts = {}) {
+    const ts = Math.floor((opts.now ?? Date.now)() / 1000);
+    const signature = signWithDeviceKey(key, devicePollMessage(deviceCode, ts));
+    const r = await postJson(`${portalBase(opts.baseUrl)}/cli/device/poll`, { device_code: deviceCode, ts, signature }, opts);
+    if (!r.ok)
+        return { status: 'error', detail: r.detail };
+    if (r.status < 200 || r.status >= 300)
+        return { status: 'error', detail: `http ${r.status}` };
+    const d = unwrapData(r.json);
+    const status = d?.status;
+    if (status === 'pending' || status === 'denied' || status === 'expired')
+        return { status };
+    if (status !== 'approved')
+        return { status: 'error', detail: 'invalid response' };
+    const token = d?.token;
+    const expiresAt = parseExpiresAt(d?.expires_at);
+    const deviceId = d?.device_id;
+    if (!validateTokenFormat(token) || expiresAt === null || typeof deviceId !== 'string' || !deviceId) {
+        return { status: 'error', detail: 'invalid response' };
+    }
+    const user = (d?.user && typeof d.user === 'object' ? d.user : {});
+    return { status: 'approved', token, expiresAt, deviceId, user };
+}
+/** 承認された札を置き場に書く（札＋期限＋機体の id、口座ごとの機体の id）。書けなければ throw */
+export function saveApprovedDevice(approved) {
+    const u = approved.user;
+    const userInfo = {
+        id: u.id,
+        name: u.name,
+        email: u.email,
+        role: u.rank ?? u.role,
+        language: u.language ?? 'ja',
+        active_tenant_id: u.active_tenant_id ?? null,
+    };
+    savePortalToken(approved.token, userInfo, { expiresAt: approved.expiresAt, deviceId: approved.deviceId });
+    if (u.id)
+        saveDeviceId(u.id, approved.deviceId);
+    return userInfo;
+}
+/**
+ * 承認・拒否・期限切れまで interval ごとに問い合わせる（網の一時の不調は待ちを続ける）。
+ * 返りは最後の答え。approved のときは置き場にまだ書いていない（saveApprovedDevice は呼び出し側）。
+ */
+export async function awaitDeviceApproval(key, start, opts = {}) {
+    const now = opts.now ?? Date.now;
+    const wait = opts.sleep ?? sleep;
+    const deadline = now() + start.expiresInSec * 1000;
+    let lastError = null;
+    while (now() < deadline) {
+        await wait(start.intervalSec * 1000);
+        const r = await pollDeviceRegistration(key, start.deviceCode, opts);
+        if (r.status === 'pending') {
+            opts.onPending?.();
+            continue;
+        }
+        if (r.status === 'error') {
+            lastError = r.detail;
+            continue;
+        }
+        return r;
+    }
+    return lastError ? { status: 'error', detail: lastError } : { status: 'expired' };
+}
 //# sourceMappingURL=index.js.map