@teamvibe/poller 0.8.2-rc.2 → 0.8.3-rc.4

package/dist/pool-logging.d.ts

@@ -0,0 +1,18 @@
+import type { SessionLogger } from './logger.js';
+import type { ClaudeRateLimitInfo } from './claude-rate-limit.js';
+import { type AccountIdentity, type AccountUsageState, type PoolFetchResult, type SelectionOutcome } from './subscription-selection.js';
+export type PoolInfoLogger = Pick<SessionLogger, 'info'>;
+type LabeledAccount = AccountIdentity & {
+    label?: string;
+};
+export declare function poolInfo(log: PoolInfoLogger, message: string): void;
+export declare function poolLabel(account: {
+    label?: string;
+}): string;
+export declare function logPoolFetch(log: PoolInfoLogger, pool: PoolFetchResult): void;
+export declare function logPoolSelection<A extends LabeledAccount>(log: PoolInfoLogger, pool: PoolFetchResult<A>, states: Readonly<Record<string, AccountUsageState>>, model: string | undefined, now: number, selected: SelectionOutcome<A>, logAllExhausted?: boolean): void;
+/** Log the real store promise without changing its rejection or retry behavior. */
+export declare function logPoolUsageWrite(log: PoolInfoLogger, account: {
+    label?: string;
+}, info: ClaudeRateLimitInfo | undefined, write: () => Promise<void>, source?: 'passive' | 'quota'): Promise<void>;
+export {};

package/dist/pool-logging.js

@@ -0,0 +1,79 @@
+import { redactStartupText } from './startup-auth.js';
+import { normalizePassiveUsage, selectSubscriptionAccount } from './subscription-selection.js';
+import { safeRateLimitInfo } from './subscription-usage-store.js';
+// Never serialize accounts, credentials, provider strings or caught errors.
+// Labels have already been checked by the pool client; JSON quoting keeps
+// arbitrary model/label whitespace on one physical log line.
+export function poolInfo(log, message) {
+    log.info(redactStartupText(`[Pool] ${message}`).replace(/[\r\n]/g, ' '));
+}
+export function poolLabel(account) {
+    const label = account.label;
+    return JSON.stringify(label && label.length <= 128 && !/sk-ant-|Bearer\s|[\r\n]/i.test(label) ? label : 'unlabeled');
+}
+export function logPoolFetch(log, pool) {
+    if (pool.kind === 'no_accounts_configured')
+        return;
+    // The API exposes usable members only; hidden disabled labels are unavailable.
+    const enabled = pool.kind === 'ready' ? pool.accounts.filter(a => a.enabled).length : pool.kind === 'fetch_unavailable' && pool.reason === 'no_usable_accounts' ? 0 : 'unknown';
+    const configured = pool.kind === 'ready' || pool.kind === 'fetch_unavailable' && pool.reason === 'no_usable_accounts' ? 'true' : 'unknown';
+    poolInfo(log, `fetch poolConfigured=${configured} enabled=${enabled} usable=${enabled} result=${pool.kind}${pool.kind === 'fetch_unavailable' ? ` reason=${pool.reason}` : ''}`);
+}
+export function logPoolSelection(log, pool, states, model, now, selected, logAllExhausted = true) {
+    if (pool.kind !== 'ready')
+        return;
+    for (const account of pool.accounts) {
+        if (!account.enabled) {
+            poolInfo(log, `skipped account=${poolLabel(account)} reason=disabled`);
+            continue;
+        }
+        const candidate = selectSubscriptionAccount({ pool: { ...pool, accounts: [account] }, states, model, now });
+        if (candidate.kind === 'deferred') {
+            const usageOnly = selectSubscriptionAccount({ pool: { ...pool, accounts: [account] }, states: { [account.accountId]: { usage: states[account.accountId]?.usage } }, model, now });
+            poolInfo(log, `skipped account=${poolLabel(account)} reason=${usageOnly.kind === 'deferred' ? `usage >=${account.useFullQuota ? 100 : 90}%` : 'reactive quota'} eligibleAt=${new Date(candidate.eligibleAt).toISOString()}`);
+        }
+        else if (candidate.kind === 'selected' && selected.kind === 'selected' && account.accountId !== selected.account.accountId) {
+            const reason = candidate.provenance === 'unknown' && selected.provenance === 'known' ? 'known observation preferred' : candidate.provenance === 'known' && selected.provenance === 'known' && candidate.score > selected.score ? 'higher usage score' : 'deterministic account order';
+            poolInfo(log, `skipped account=${poolLabel(account)} reason=${reason}`);
+        }
+    }
+    if (selected.kind === 'deferred' && logAllExhausted) {
+        // Ask the same policy about each observation so model scope, freshness and
+        // reset expiry stay identical to selection. An account must clear ALL its
+        // blockers; the pool can resume when its first account clears them.
+        const resets = pool.accounts.filter(a => a.enabled).map(account => {
+            const state = states[account.accountId];
+            const deadlines = [];
+            for (const window of state?.usage?.windows ?? []) {
+                const candidate = selectSubscriptionAccount({ pool: { ...pool, accounts: [account] }, states: { [account.accountId]: { usage: { ...state.usage, windows: [window] } } }, model, now });
+                if (candidate.kind === 'deferred')
+                    deadlines.push(window.resetAt);
+            }
+            for (const reactive of state?.reactive ?? []) {
+                const candidate = selectSubscriptionAccount({ pool: { ...pool, accounts: [account] }, states: { [account.accountId]: { reactive: [reactive] } }, model, now });
+                if (candidate.kind === 'deferred')
+                    deadlines.push(reactive.quota.resetAt ? Date.parse(reactive.quota.resetAt) : undefined);
+            }
+            return deadlines.length && deadlines.every(d => d !== undefined && Number.isFinite(d)) ? Math.max(...deadlines) : undefined;
+        });
+        const earliestResetAt = resets.length && resets.every(r => r !== undefined) ? new Date(Math.min(...resets)).toISOString() : 'unknown';
+        poolInfo(log, `deferred reason=all accounts exhausted earliestResetAt=${earliestResetAt} eligibleAt=${new Date(selected.eligibleAt).toISOString()}`);
+    }
+    if (selected.kind === 'selected') {
+        const score = selected.provenance === 'known' ? `${selected.score}% headroom=${100 - selected.score}%` : 'unknown (no observation)';
+        poolInfo(log, `selected account=${poolLabel(selected.account)} model=${JSON.stringify(model ?? 'CLI default')} score=${score}`);
+    }
+}
+/** Log the real store promise without changing its rejection or retry behavior. */
+export async function logPoolUsageWrite(log, account, info, write, source = 'passive') {
+    const windows = info ? normalizePassiveUsage(safeRateLimitInfo(info), Date.now()).windows.map(w => `${w.window}${source === 'passive' ? `/${w.scope}` : ''}:${w.percent === undefined ? 'unknown' : `${Number(w.percent.toFixed(2))}%`}`).join(',') : '';
+    try {
+        await write();
+        poolInfo(log, `usage write account=${poolLabel(account)} result=ok windows=${windows || 'none'} source=${source}`);
+    }
+    catch (error) {
+        const name = error instanceof Error && ['Error', 'TypeError', 'RangeError', 'AbortError', 'TimeoutError', 'SubscriptionUsageStoreError'].includes(error.name) ? error.name : 'UnknownError';
+        poolInfo(log, `usage write account=${poolLabel(account)} result=failed errorClass=${name} windows=${windows || 'none'} source=${source}`);
+        throw error;
+    }
+}

package/dist/pool-telemetry.d.ts

@@ -0,0 +1,44 @@
+import type { SubscriptionAccount } from './subscription-pool-client.js';
+import { type StoredAccountUsage, type SubscriptionUsageStore } from './subscription-usage-store.js';
+import type { PoolAttempt } from './subscription-runtime.js';
+import type { SessionMetrics, TeamVibeQueueMessage } from './types.js';
+/** Explicit transport DTO: never serialize a pool account/credential envelope. */
+export declare function accountUsageTelemetry(account: SubscriptionAccount, state: StoredAccountUsage): {
+    reactive: {
+        observedAt: number;
+        window: import("./claude-rate-limit.js").ClaudeQuotaWindow | undefined;
+        scope: string;
+        resetAt: number | undefined;
+        eligibleAt: number;
+    }[];
+    lastRateLimitInfo?: import("./claude-rate-limit.js").ClaudeRateLimitInfo | undefined;
+    probeStatus?: import("./subscription-usage-store.js").ProbeStatus | undefined;
+    probeObservedAt?: number | undefined;
+    usage?: import("./subscription-selection.js").UsageObservation | undefined;
+    accountId: string;
+    accountLabel: string;
+    reportedAt: number;
+};
+export declare function emitCandidateUsage(msg: TeamVibeQueueMessage, accounts: readonly SubscriptionAccount[], store: SubscriptionUsageStore): Promise<void>;
+export declare function poolRunTelemetry(attempts: readonly PoolAttempt[], quotaDeferEpisodes?: number): {
+    chainLength: number;
+    switchedAccounts: boolean;
+    quotaDeferEpisodes: number;
+    attempts: {
+        accountId: string;
+        accountLabel: string;
+        sessionId: string | undefined;
+        model: string | undefined;
+        success: boolean;
+        exitCode: number | null;
+        observedAt: number | undefined;
+        quota: import("./claude-quota.js").ClaudeQuotaFailure | undefined;
+        metrics: SessionMetrics | undefined;
+        lastRateLimitInfo: import("./claude-rate-limit.js").ClaudeRateLimitInfo | undefined;
+    }[];
+    accountId?: string | undefined;
+    accountLabel?: string | undefined;
+    model?: string | undefined;
+    observedAt?: number | undefined;
+    lastRateLimitInfo?: import("./claude-rate-limit.js").ClaudeRateLimitInfo | undefined;
+};

package/dist/pool-telemetry.js

@@ -0,0 +1,107 @@
+import { emitEvent } from './event-queue.js';
+import { normalizePassiveUsage, reactiveEligibleAt, } from './subscription-selection.js';
+import { safeQuota, safeRateLimitInfo, } from './subscription-usage-store.js';
+function safeText(value) {
+    return value && value.length <= 128 && !/sk-ant-|Bearer\s|[\r\n]/i.test(value)
+        ? value
+        : undefined;
+}
+function safeMetrics(metrics) {
+    if (!metrics)
+        return undefined;
+    const result = {};
+    for (const key of [
+        'total_cost_usd',
+        'input_tokens',
+        'output_tokens',
+        'cache_read_input_tokens',
+        'cache_creation_input_tokens',
+        'duration_ms',
+        'duration_api_ms',
+        'num_turns',
+    ]) {
+        const value = metrics[key];
+        if (typeof value === 'number' && Number.isFinite(value) && value >= 0)
+            result[key] = value;
+    }
+    const model = safeText(metrics.model);
+    if (model)
+        result.model = model;
+    return result;
+}
+/** Explicit transport DTO: never serialize a pool account/credential envelope. */
+export function accountUsageTelemetry(account, state) {
+    const passive = state.passive
+        ? normalizePassiveUsage(state.passive.rateLimitInfo, state.passive.observedAt)
+        : undefined;
+    const probe = state.probe?.usage;
+    const usage = passive && (!probe || passive.observedAt >= probe.observedAt)
+        ? passive
+        : probe;
+    return {
+        accountId: account.accountId,
+        accountLabel: account.label ?? account.accountId,
+        reportedAt: Date.now(),
+        ...(usage ? { usage } : {}),
+        ...(state.probe
+            ? {
+                probeStatus: state.probe.status,
+                probeObservedAt: state.probe.observedAt,
+            }
+            : {}),
+        ...(state.passive
+            ? { lastRateLimitInfo: state.passive.rateLimitInfo }
+            : {}),
+        reactive: state.reactive.map((r) => ({
+            observedAt: r.observedAt,
+            window: r.quota.window,
+            scope: r.quota.modelScope ?? 'global',
+            resetAt: r.quota.resetAt ? Date.parse(r.quota.resetAt) : undefined,
+            eligibleAt: reactiveEligibleAt(r),
+        })),
+    };
+}
+export async function emitCandidateUsage(msg, accounts, store) {
+    // Usage storage is already local. Observability failures never change selection.
+    for (const account of accounts) {
+        try {
+            emitEvent('pool.usage_observed', msg.teamvibe.channelId, {
+                workspaceId: msg.teamvibe.workspaceId,
+                ...accountUsageTelemetry(account, await store.read(account)),
+            });
+        }
+        catch { }
+    }
+}
+export function poolRunTelemetry(attempts, quotaDeferEpisodes = 0) {
+    const safeAttempts = attempts.map((a) => ({
+        accountId: a.accountId,
+        accountLabel: safeText(a.accountLabel) ?? a.accountId,
+        sessionId: safeText(a.sessionId),
+        model: safeText(a.model),
+        success: a.success,
+        exitCode: a.exitCode,
+        observedAt: a.observedAt,
+        quota: a.quota ? safeQuota(a.quota) : undefined,
+        metrics: safeMetrics(a.metrics),
+        lastRateLimitInfo: a.rateLimitInfo
+            ? safeRateLimitInfo(a.rateLimitInfo)
+            : undefined,
+    }));
+    const last = safeAttempts.at(-1);
+    return {
+        ...(last
+            ? {
+                accountId: last.accountId,
+                accountLabel: last.accountLabel,
+                model: last.model,
+                observedAt: last.observedAt,
+                lastRateLimitInfo: last.lastRateLimitInfo,
+            }
+            : {}),
+        chainLength: attempts.length,
+        switchedAccounts: new Set(attempts.map((a) => a.accountId)).size > 1,
+        quotaDeferEpisodes,
+        attempts: safeAttempts,
+    };
+}

package/dist/quota-pause.d.ts

@@ -0,0 +1,16 @@
+import type { ClaudeQuotaFailure } from './claude-quota.js';
+export declare const UNKNOWN_QUOTA_RECHECK_MS: number;
+export declare class QuotaPausedError extends Error {
+    constructor();
+}
+export interface QuotaPause {
+    createdAt: number;
+    resumeAt: number;
+    brainPath: string;
+    threadId: string;
+}
+export declare function readQuotaPause(): QuotaPause | undefined;
+export declare function isQuotaPaused(): boolean;
+/** Persist before notification; only the first quota result owns the notice. */
+export declare function pauseForQuota(quota: ClaudeQuotaFailure, brainPath: string, threadId: string): boolean;
+export declare function clearQuotaPauseAfterSuccess(): void;

package/dist/quota-pause.js

@@ -0,0 +1,96 @@
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { config } from './config.js';
+import { logger } from './logger.js';
+export const UNKNOWN_QUOTA_RECHECK_MS = 15 * 60_000;
+export class QuotaPausedError extends Error {
+    constructor() {
+        super('Claude account is paused for quota');
+    }
+}
+// The ambient credential path retains the original poller-wide pause.
+// Configured subscription pools use per-account usage and per-thread pool-defer.
+function markerPath() {
+    return join(config.TEAMVIBE_DATA_DIR, 'quota-pause.json');
+}
+const unreadableMarkers = new Set();
+const cleanupFailures = new Set();
+export function readQuotaPause() {
+    const path = markerPath();
+    try {
+        const pause = JSON.parse(readFileSync(path, 'utf8'));
+        if (pause && Number.isFinite(pause.createdAt) && Number.isFinite(pause.resumeAt)
+            && Number.isFinite(pause.resumeAt - pause.createdAt) && pause.resumeAt > pause.createdAt
+            && typeof pause.brainPath === 'string' && typeof pause.threadId === 'string') {
+            unreadableMarkers.delete(path);
+            return pause;
+        }
+        throw new Error('Invalid quota pause marker');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            unreadableMarkers.delete(path);
+            return undefined;
+        }
+        if (!unreadableMarkers.has(path)) {
+            unreadableMarkers.add(path);
+            logger.warn('[QuotaPause] Unreadable marker treated as expired', error instanceof Error ? error.message : String(error));
+        }
+        try {
+            rmSync(path, { recursive: true, force: true });
+        }
+        catch {
+            // A directory or unreadable file can still be moved out of the way.
+            // Cleanup failure must never stop the watcher from resuming saved work.
+            try {
+                renameSync(path, `${path}.invalid`);
+            }
+            catch { }
+        }
+        return undefined;
+    }
+}
+export function isQuotaPaused() {
+    const pause = readQuotaPause();
+    if (!pause)
+        return false;
+    const now = Date.now();
+    // A backward clock correction must not extend the original pause duration.
+    const bound = pause.resumeAt - pause.createdAt;
+    return now >= pause.createdAt && now < pause.resumeAt && pause.resumeAt - now <= bound;
+}
+/** Persist before notification; only the first quota result owns the notice. */
+export function pauseForQuota(quota, brainPath, threadId) {
+    if (isQuotaPaused())
+        return false;
+    const now = Date.now();
+    const reset = quota.resetAt ? Date.parse(quota.resetAt) : NaN;
+    const pause = {
+        createdAt: now,
+        resumeAt: Number.isFinite(reset) && reset > now ? reset : now + UNKNOWN_QUOTA_RECHECK_MS,
+        brainPath,
+        threadId,
+    };
+    mkdirSync(config.TEAMVIBE_DATA_DIR, { recursive: true });
+    const path = markerPath();
+    writeFileSync(`${path}.tmp`, JSON.stringify(pause), { mode: 0o600 });
+    renameSync(`${path}.tmp`, path);
+    return true;
+}
+export function clearQuotaPauseAfterSuccess() {
+    // An already-running request may succeed after another thread exhausted the
+    // account. Its success must not erase that thread's newly active pause.
+    const path = markerPath();
+    try {
+        if (!isQuotaPaused()) {
+            rmSync(path, { recursive: true, force: true });
+            cleanupFailures.delete(path);
+        }
+    }
+    catch (error) {
+        if (!unreadableMarkers.has(path) && !cleanupFailures.has(path)) {
+            cleanupFailures.add(path);
+            logger.warn('[QuotaPause] Marker cleanup failed after success', error instanceof Error ? error.message : String(error));
+        }
+    }
+}

package/dist/session-store.d.ts

@@ -1,4 +1,4 @@
-import type { SessionRecord, SessionStatus } from './types.js';
+import type { SessionRecord, SessionStatus, SubscriptionPin } from './types.js';
 export declare function getSession(threadId: string): Promise<SessionRecord | null>;
 export declare function createSession(threadId: string, workspacePath: string): Promise<SessionRecord>;
 export interface AcquireLockResult {
@@ -7,6 +7,6 @@ export interface AcquireLockResult {
     lockToken: string | null;
 }
 export declare function acquireSessionLock(threadId: string, workspacePath: string): Promise<AcquireLockResult>;
-export declare function updateSessionId(threadId: string, lockToken: string, newSessionId: string): Promise<void>;
+export declare function updateSessionId(threadId: string, lockToken: string, newSessionId: string, pin?: SubscriptionPin): Promise<boolean>;
 export declare function releaseSessionLock(threadId: string, lockToken: string, newStatus?: SessionStatus, lastMessageTs?: string): Promise<void>;
 export declare function forceReleaseStalelock(threadId: string, maxAgeMs: number): Promise<boolean>;

package/dist/session-store.js

@@ -43,6 +43,7 @@ function generateLockToken() {
 export async function getSession(threadId) {
     const key = buildKey(threadId);
     const result = await createDocClient().send(new GetCommand({
+        ConsistentRead: true,
         TableName: getTableName(),
         Key: key,
     }));
@@ -149,25 +150,27 @@ export async function acquireSessionLock(threadId, workspacePath) {
         throw error;
     }
 }
-export async function updateSessionId(threadId, lockToken, newSessionId) {
+export async function updateSessionId(threadId, lockToken, newSessionId, pin) {
     try {
         await createDocClient().send(new UpdateCommand({
             TableName: getTableName(),
             Key: buildKey(threadId),
-            UpdateExpression: 'SET session_id = :newSessionId',
+            UpdateExpression: pin ? 'SET session_id = :newSessionId, subscription_pin = :pin' : 'SET session_id = :newSessionId',
             ConditionExpression: 'lock_token = :lockToken',
             ExpressionAttributeValues: {
                 ':newSessionId': newSessionId,
+                ...(pin ? { ':pin': Object.fromEntries(Object.entries(pin).filter(([, value]) => value !== undefined)) } : {}),
                 ':lockToken': lockToken,
             },
         }));
         logger.info(`Updated session_id for thread ${threadId} to ${newSessionId}`);
+        return true;
     }
     catch (error) {
         if (error.name === 'ConditionalCheckFailedException') {
             logger.warn(`Lock token mismatch when updating session_id for ${threadId}`);
             emitError('session', `Lock token mismatch when updating session_id for ${threadId}`, { severity: 'warn' });
-            return;
+            return false;
         }
         throw error;
     }

package/dist/slack-client.d.ts

@@ -3,7 +3,10 @@ export declare function getUserInfo(botToken: string, userId: string): Promise<{
     name: string;
     realName: string;
 }>;
-export declare function sendSlackMessage(msg: TeamVibeQueueMessage, text: string): Promise<void>;
+export declare function sendSlackMessage(msg: TeamVibeQueueMessage, text: string, options?: {
+    clientMessageId: string;
+    reconcile?: boolean;
+}): Promise<void>;
 export declare function sendSlackError(msg: TeamVibeQueueMessage, error: string): Promise<void>;
 export declare function addReaction(msg: TeamVibeQueueMessage, emoji: string): Promise<void>;
 export declare function setThreadStatus(msg: TeamVibeQueueMessage, status: string): Promise<void>;

package/dist/slack-client.js

@@ -45,19 +45,37 @@ export async function getUserInfo(botToken, userId) {
     userCache.set(userId, fallback);
     return fallback;
 }
-export async function sendSlackMessage(msg, text) {
+export async function sendSlackMessage(msg, text, options) {
     if (!msg.response_context.slack) {
         logger.error('No Slack context in message, cannot respond');
         return;
     }
     const { channel, thread_ts } = msg.response_context.slack;
     const slack = getSlackClient(msg.teamvibe.botToken);
+    if (options?.reconcile) {
+        let cursor;
+        // A claim may have reached Slack before the process/connection died.
+        // Reconcile by stable episode ID; absence or read failure never reposts it.
+        for (let page = 0; page < 20; page++) {
+            const response = await slack.conversations.replies({ channel, ts: thread_ts, limit: 100, cursor, include_all_metadata: true });
+            if (response.messages?.some(message => {
+                const payload = message.metadata?.event_payload;
+                return ('client_msg_id' in message && message.client_msg_id === options.clientMessageId) || (payload !== null && typeof payload === 'object' && 'episodeId' in payload && payload.episodeId === options.clientMessageId);
+            }))
+                return;
+            cursor = response.response_metadata?.next_cursor;
+            if (!cursor)
+                break;
+        }
+        throw new Error('Pool notice delivery remains unresolved');
+    }
     await slack.chat.postMessage({
         channel,
         thread_ts,
         text,
         unfurl_links: false,
         unfurl_media: false,
+        ...(options ? { client_msg_id: options.clientMessageId, metadata: { event_type: 'subscription_pool_defer', event_payload: { episodeId: options.clientMessageId } } } : {}),
     });
 }
 export async function sendSlackError(msg, error) {

package/dist/subscription-pool-client.d.ts

@@ -0,0 +1,35 @@
+import type { AccountIdentity, PoolFetchResult } from './subscription-selection.js';
+/** Unwrap only at the optional Claude probe or future child-spawn boundary. */
+export declare class SubscriptionCredential {
+    #private;
+    constructor(token: string);
+    unwrap(): string;
+    toJSON(): string;
+    toString(): string;
+}
+export interface SubscriptionAccount extends AccountIdentity {
+    harness: 'CLAUDE';
+    label?: string;
+    credential: SubscriptionCredential;
+}
+export interface PoolFetchInput {
+    workspaceId: string;
+    channelId?: string;
+    pollerId: string;
+    accountId?: string;
+    requestId?: string;
+    credentialVersion?: string;
+}
+export interface PoolClientOptions {
+    apiUrl: string;
+    pollerToken: string;
+    fetch?: typeof fetch;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+/** Deadline covers response headers AND body, even for an uncooperative adapter. */
+export declare function boundedRequest<T>(work: (signal: AbortSignal) => Promise<T>, signal?: AbortSignal, timeoutMs?: number): Promise<T>;
+/** Bounded, ephemeral raw body. Neither it nor caught errors leave this module. */
+export declare function readSubscriptionJson(response: Response): Promise<unknown>;
+/** No global config, logging, workspace fallback or credential cache. */
+export declare function fetchSubscriptionPool(input: PoolFetchInput, options: PoolClientOptions): Promise<PoolFetchResult<SubscriptionAccount>>;

package/dist/subscription-pool-client.js

@@ -0,0 +1,143 @@
+import { record } from './subscription-selection.js';
+/** Unwrap only at the optional Claude probe or future child-spawn boundary. */
+export class SubscriptionCredential {
+    #token;
+    constructor(token) { this.#token = token; }
+    unwrap() { return this.#token; }
+    toJSON() { return '[REDACTED]'; }
+    toString() { return '[SubscriptionCredential REDACTED]'; }
+    [Symbol.for('nodejs.util.inspect.custom')]() { return this.toString(); }
+}
+/** Deadline covers response headers AND body, even for an uncooperative adapter. */
+export async function boundedRequest(work, signal, timeoutMs = 15_000) {
+    const controller = new AbortController();
+    const cancel = () => controller.abort();
+    signal?.addEventListener('abort', cancel, { once: true });
+    const timer = setTimeout(cancel, timeoutMs);
+    if (signal?.aborted)
+        cancel();
+    let onAbort = () => { };
+    try {
+        return await Promise.race([
+            new Promise((_, reject) => {
+                onAbort = () => reject(new Error('Subscription request interrupted'));
+                controller.signal.addEventListener('abort', onAbort, { once: true });
+                if (controller.signal.aborted)
+                    onAbort();
+            }),
+            Promise.resolve().then(() => {
+                if (controller.signal.aborted)
+                    throw new Error('Subscription request interrupted');
+                return work(controller.signal);
+            }),
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+        signal?.removeEventListener('abort', cancel);
+        controller.signal.removeEventListener('abort', onAbort);
+    }
+}
+/** Bounded, ephemeral raw body. Neither it nor caught errors leave this module. */
+export async function readSubscriptionJson(response) {
+    const reader = response.body?.getReader();
+    if (!reader)
+        throw new Error('Invalid subscription response');
+    const chunks = [];
+    let size = 0;
+    try {
+        while (true) {
+            const chunk = await reader.read();
+            if (chunk.done)
+                break;
+            size += chunk.value.byteLength;
+            if (size > 1024 * 1024)
+                throw new Error('Subscription response too large');
+            chunks.push(chunk.value);
+        }
+        const bytes = new Uint8Array(size);
+        let offset = 0;
+        for (const chunk of chunks) {
+            bytes.set(chunk, offset);
+            offset += chunk.byteLength;
+        }
+        return JSON.parse(new TextDecoder().decode(bytes));
+    }
+    finally {
+        void reader.cancel().catch(() => { });
+    }
+}
+/** No global config, logging, workspace fallback or credential cache. */
+export async function fetchSubscriptionPool(input, options) {
+    let url;
+    try {
+        if (!input.pollerId || !input.workspaceId || (!input.channelId && !input.requestId) || !options.pollerToken)
+            throw new Error('Missing configuration');
+        url = new URL('/subscription-accounts/spawn', options.apiUrl);
+        if (!['https:', 'http:'].includes(url.protocol) || url.username || url.password)
+            throw new Error('Invalid URL');
+        url.searchParams.set('pollerId', input.pollerId);
+        url.searchParams.set('workspaceId', input.workspaceId);
+        if (input.channelId)
+            url.searchParams.set('channelId', input.channelId);
+        for (const name of ['accountId', 'requestId', 'credentialVersion'])
+            if (input[name])
+                url.searchParams.set(name, input[name]);
+    }
+    catch {
+        return { kind: 'fetch_unavailable', reason: 'configuration' };
+    }
+    try {
+        return await boundedRequest(async (signal) => {
+            const response = await (options.fetch ?? fetch)(url, {
+                method: 'GET', signal,
+                headers: { Authorization: `Bearer ${options.pollerToken}`, 'Cache-Control': 'no-store' },
+                redirect: 'error',
+            });
+            if (response.status === 401 || response.status === 403)
+                return { kind: 'fetch_unauthorized', status: response.status };
+            if (!response.ok)
+                return { kind: 'fetch_unavailable', reason: 'http', status: response.status };
+            let body;
+            try {
+                body = await readSubscriptionJson(response);
+            }
+            catch {
+                return { kind: 'fetch_unavailable', reason: 'invalid_response' };
+            }
+            const envelope = record(body);
+            const raw = envelope['accounts'];
+            if (!Array.isArray(raw) || raw.length > 1000)
+                return { kind: 'fetch_unavailable', reason: 'invalid_response' };
+            const poolConfigured = envelope['poolConfigured'];
+            if (('poolConfigured' in envelope && typeof poolConfigured !== 'boolean') ||
+                (poolConfigured === false && raw.length > 0))
+                return { kind: 'fetch_unavailable', reason: 'invalid_response' };
+            const accounts = [];
+            const ids = new Set();
+            for (const value of raw) {
+                const item = record(value);
+                const credential = record(item['credential']);
+                if (typeof item['accountId'] !== 'string' || !item['accountId'] || ids.has(item['accountId']) ||
+                    item['workspaceId'] !== input.workspaceId || item['enabled'] !== true || item['harness'] !== 'CLAUDE' ||
+                    typeof item['credentialVersion'] !== 'string' || !item['credentialVersion'] ||
+                    credential['type'] !== 'claude-setup-token' || typeof credential['token'] !== 'string' || !credential['token']) {
+                    return { kind: 'fetch_unavailable', reason: 'invalid_response' };
+                }
+                ids.add(item['accountId']);
+                accounts.push({ accountId: item['accountId'], workspaceId: input.workspaceId, credentialVersion: item['credentialVersion'], enabled: true, useFullQuota: item['useFullQuota'] === true, harness: 'CLAUDE', ...(typeof item['label'] === 'string' && item['label'].length <= 128 && !/sk-ant-|Bearer\s|[\r\n]/i.test(item['label']) ? { label: item['label'] } : {}), credential: new SubscriptionCredential(credential['token']) });
+            }
+            if (accounts.length)
+                return { kind: 'ready', accounts };
+            if (poolConfigured === false)
+                return { kind: 'no_accounts_configured' };
+            if (poolConfigured === true)
+                return { kind: 'fetch_unavailable', reason: 'no_usable_accounts' };
+            // Older platforms cannot distinguish an absent pool from disabled members.
+            return { kind: 'unknown_pool_state' };
+        }, options.signal, options.timeoutMs);
+    }
+    catch {
+        return { kind: 'fetch_unavailable', reason: options.signal?.aborted ? 'cancelled' : 'network' };
+    }
+}