@yuchaocheng/yusijia 0.1.0-beta.1

package/dist/core.js

@@ -0,0 +1,87 @@
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+export const VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+export const LIMITS = { maxRequestBytes: 2097152, maxCandidates: 200, maxActions: 500, maxFileBytes: 15728640 };
+export const DEFAULT_SITE = 'https://yusijia.me';
+const messages = {
+    INVALID_INPUT: 'Invalid input. Check the command and typed plan.',
+    PAYLOAD_TOO_LARGE: 'Request exceeds 2 MiB. Simplify or split into a newly confirmed plan.',
+    LOCAL_STATE_TOO_LARGE: 'Private file exceeds 32 MiB. Resolve pending operations before adding more; no oversized file was written.',
+    AUTH_REQUIRED: 'Run auth login for this site.', INVALID_CREDENTIAL: 'Credential is invalid or revoked. Log in again.',
+    CREDENTIAL_EXPIRED: 'Credential expired. Log in again.', ACCOUNT_NOT_ALLOWED: 'Account is not allowed.',
+    FORBIDDEN: 'Operation is not permitted.', NOT_FOUND: 'Resource is unavailable.',
+    VERSION_CONFLICT: 'Target changed. Read it again and confirm a new plan.',
+    OPERATION_CONFLICT: 'Operation ID already belongs to another request.', BATCH_CLOSED: 'Import batch is closed.',
+    UNSUPPORTED_EDIT: 'Edit cannot preserve rich content. Use the website editor.', RATE_LIMITED: 'Rate limited. Retry later.',
+    STORAGE_UNAVAILABLE: 'Storage is unavailable.', RESULT_UNKNOWN: 'Result is uncertain. Resume using the original operation ID.',
+    PROTOCOL_MISMATCH: 'CLI and website are incompatible. Update the CLI or website; no legacy fallback.',
+    NETWORK_ERROR: 'Request failed. Remote result may be unknown; no automatic retry.',
+    UNSAFE_PATH: 'Unsafe path: check owner, permissions and symlinks.',
+    CONFIRMATION_REQUIRED: 'Plan hash or site/account does not match. Preview and confirm again.',
+    SOURCE_CHANGED: 'Source bytes changed. Scan and confirm a new plan.',
+    AUTH_DENIED: 'Authorization was declined.', AUTH_TIMEOUT: 'Authorization timed out.',
+    BROWSER_FAILED: 'Could not open the browser. Authorization was not completed.',
+    SAVE_FAILED: 'Credential could not be saved; revocation was attempted.',
+    REVOCATION_FAILED: 'Server credential has NOT been revoked; local credential was retained.',
+    SKILL_CONFLICT: 'Installed Skill has unknown or modified content; it was not overwritten.',
+    NOT_PUBLISHED: 'This private placeholder package is not published. Remote update is blocked until package ownership is verified.',
+    NOT_GLOBAL: 'Not a global npm installation. Update using the original local installation method.',
+    UPDATE_FAILED: 'npm update failed. No privilege escalation was attempted.',
+    INVALID_RESPONSE: 'Server returned an invalid response.', INTERNAL_ERROR: 'Command failed; sensitive diagnostics were suppressed.',
+    TOOL_UNAVAILABLE: 'Required macOS tool is missing: scans need /usr/bin/sips; zip input also needs /usr/bin/unzip.',
+};
+export class CliError extends Error {
+    code;
+    retryable;
+    status;
+    constructor(code, retryable = false, status) {
+        super(messages[code] ?? messages.INTERNAL_ERROR);
+        this.code = code;
+        this.retryable = retryable;
+        this.status = status;
+    }
+}
+export function safeError(error) {
+    if (error instanceof CliError && Object.hasOwn(messages, error.code))
+        return { code: error.code, message: messages[error.code], retryable: error.retryable };
+    return { code: 'INTERNAL_ERROR', message: messages.INTERNAL_ERROR, retryable: false };
+}
+export function normalizeSite(site = DEFAULT_SITE) {
+    let u;
+    try {
+        u = new URL(site);
+    }
+    catch {
+        throw new CliError('INVALID_INPUT');
+    }
+    const loopback = ['127.0.0.1', 'localhost', '[::1]'].includes(u.hostname);
+    if ((u.protocol !== 'https:' && !(u.protocol === 'http:' && loopback)) || u.username || u.password || u.search || u.hash || u.pathname !== '/')
+        throw new CliError('INVALID_INPUT');
+    return u.origin;
+}
+export function sha256(value) { return createHash('sha256').update(value).digest('hex'); }
+export function canonicalJson(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    const record = value;
+    return `{${Object.keys(record).filter(k => record[k] !== undefined).sort().map(k => `${JSON.stringify(k)}:${canonicalJson(record[k])}`).join(',')}}`;
+}
+export function checkBytes(value, max = LIMITS.maxRequestBytes) {
+    const json = JSON.stringify(value);
+    if (Buffer.byteLength(json, 'utf8') > max)
+        throw new CliError('PAYLOAD_TOO_LARGE');
+    return json;
+}
+export function publicOutput(value, allowImageUrls = false, parentKey = '') {
+    if (Array.isArray(value))
+        return value.map(v => publicOutput(v, allowImageUrls, parentKey));
+    if (value && typeof value === 'object')
+        return Object.fromEntries(Object.entries(value).filter(([k]) => !(k === 'code' && parentKey !== 'error') && !/^(token|authorization|verifier|state|challenge|policy|signature|fields|accessKeyId|accessKeySecret|securityToken)$/i.test(k)).map(([k, v]) => [k, publicOutput(v, allowImageUrls, k)]));
+    if (typeof value === 'string') {
+        const clean = value.replace(/fam_(?:cli|imp)_[A-Za-z0-9_-]+/g, '[redacted]');
+        return !allowImageUrls && /url$/i.test(parentKey) ? clean.replace(/(https?:\/\/[^\s?]+)\?[^\s]+/g, '$1?[redacted]') : clean;
+    }
+    return value;
+}

package/dist/execute.d.ts

@@ -0,0 +1,128 @@
+import { z } from 'zod';
+import { safeError } from './core.js';
+import { ApiClient } from './http.js';
+import { type Plan, type ResultRefs } from './plan.js';
+import type { Candidate } from './manifest.js';
+export declare const progressSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    origin: z.ZodString;
+    userId: z.ZodString;
+    entries: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodObject<{
+        fingerprint: z.ZodString;
+        requestHash: z.ZodOptional<z.ZodString>;
+        request: z.ZodOptional<z.ZodObject<{
+            path: z.ZodString;
+            method: z.ZodEnum<{
+                POST: "POST";
+                PATCH: "PATCH";
+            }>;
+            body: z.ZodJSONSchema;
+            version: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        status: z.ZodEnum<{
+            unknown: "unknown";
+            success: "success";
+            failed: "failed";
+        }>;
+        result: z.ZodOptional<z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            status: z.ZodOptional<z.ZodString>;
+            replayed: z.ZodOptional<z.ZodBoolean>;
+            candidateId: z.ZodOptional<z.ZodString>;
+            candidates: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                localCandidateId: z.ZodString;
+                id: z.ZodString;
+            }, z.core.$strip>>>;
+            photoIds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>>;
+        error: z.ZodOptional<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+            retryable: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strict>, z.ZodTransform<{
+        requestHash: string;
+        fingerprint: string;
+        status: "unknown" | "success" | "failed";
+        request?: {
+            path: string;
+            method: "POST" | "PATCH";
+            body: z.core.util.JSONType;
+            version?: string | undefined;
+        } | undefined;
+        result?: {
+            id: string;
+            type?: string | undefined;
+            version?: string | undefined;
+            status?: string | undefined;
+            replayed?: boolean | undefined;
+            candidateId?: string | undefined;
+            candidates?: {
+                localCandidateId: string;
+                id: string;
+            }[] | undefined;
+            photoIds?: Record<string, string> | undefined;
+        } | undefined;
+        error?: {
+            code: string;
+            message: string;
+            retryable: boolean;
+        } | undefined;
+    }, {
+        fingerprint: string;
+        status: "unknown" | "success" | "failed";
+        requestHash?: string | undefined;
+        request?: {
+            path: string;
+            method: "POST" | "PATCH";
+            body: z.core.util.JSONType;
+            version?: string | undefined;
+        } | undefined;
+        result?: {
+            id: string;
+            type?: string | undefined;
+            version?: string | undefined;
+            status?: string | undefined;
+            replayed?: boolean | undefined;
+            candidateId?: string | undefined;
+            candidates?: {
+                localCandidateId: string;
+                id: string;
+            }[] | undefined;
+            photoIds?: Record<string, string> | undefined;
+        } | undefined;
+        error?: {
+            code: string;
+            message: string;
+            retryable: boolean;
+        } | undefined;
+    }>>>;
+}, z.core.$strict>;
+export type Progress = z.infer<typeof progressSchema>;
+type ItemResult = {
+    operationId: string;
+    status: 'success' | 'failed' | 'unknown' | 'skipped';
+    result?: ResultRefs;
+    error?: ReturnType<typeof safeError>;
+    candidates?: ItemResult[];
+};
+export type ExecutionResult = {
+    ok: boolean;
+    items: ItemResult[];
+    progress: Progress;
+};
+export declare function stepId(operationId: string, step: string): string;
+declare const uploadSchema: z.ZodObject<{
+    endpoint: z.ZodURL;
+    key: z.ZodString;
+    expiresAt: z.ZodISODateTime;
+    fields: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strip>;
+export declare function uploadPhoto(api: ApiClient, upload: z.infer<typeof uploadSchema>, file: string, candidate: Candidate): Promise<void>;
+export declare function executePlan(input: Plan, hash: string, identity: {
+    origin: string;
+    userId: string;
+}, api: ApiClient, previous: unknown, save: (progress: Progress) => Promise<void>): Promise<ExecutionResult>;
+export {};

package/dist/execute.js

@@ -0,0 +1,210 @@
+import { z } from 'zod';
+import { canonicalJson, checkBytes, CliError, safeError, sha256 } from './core.js';
+import { actionRequest, refsIn, resultSchema, verifyPlan } from './plan.js';
+import { readPhoto } from './scan.js';
+import { serializePrivateJson } from './storage.js';
+const requestSchema = z.object({ path: z.string(), method: z.enum(['POST', 'PATCH']), body: z.json(), version: z.string().optional() }).strict();
+const entrySchema = z.object({
+    fingerprint: z.string(), requestHash: z.string().regex(/^[a-f0-9]{64}$/).optional(), request: requestSchema.optional(),
+    status: z.enum(['success', 'unknown', 'failed']), result: resultSchema.optional(),
+    error: z.object({ code: z.string(), message: z.string(), retryable: z.boolean() }).optional(),
+}).strict().superRefine((entry, ctx) => {
+    if (entry.status !== 'success' && !entry.request || entry.status === 'success' && (!entry.result || !entry.requestHash && !entry.request)) {
+        ctx.addIssue({ code: 'custom', message: 'Incomplete operation progress' });
+    }
+    if (entry.request && entry.requestHash && entry.requestHash !== sha256(canonicalJson(entry.request))) {
+        ctx.addIssue({ code: 'custom', message: 'Frozen request hash mismatch' });
+    }
+}).transform(entry => {
+    const normalized = { ...entry, requestHash: entry.requestHash ?? sha256(canonicalJson(entry.request)) };
+    // Legacy success entries are compacted without dropping their identity or receipt.
+    if (normalized.status === 'success') {
+        delete normalized.request;
+        delete normalized.error;
+    }
+    return normalized;
+});
+export const progressSchema = z.object({ schemaVersion: z.literal(1), origin: z.string(), userId: z.string(), entries: z.record(z.string(), entrySchema) }).strict();
+export function stepId(operationId, step) {
+    const hex = sha256(`${operationId}:${step}`).slice(0, 32).split('');
+    hex[12] = '4';
+    hex[16] = '8';
+    const h = hex.join('');
+    return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+}
+const uploadSchema = z.object({ endpoint: z.url(), key: z.string(), expiresAt: z.iso.datetime(), fields: z.record(z.string(), z.string()) });
+export async function uploadPhoto(api, upload, file, candidate) {
+    const url = new URL(upload.endpoint);
+    if (url.protocol !== 'https:' || url.username || url.password || url.search || url.hash || upload.fields['x-oss-object-acl'] !== 'private' || upload.fields.key !== upload.key || upload.fields['Content-Type'] !== candidate.mimeType || !upload.fields['x-oss-security-token'] || Date.parse(upload.expiresAt) <= Date.now())
+        throw new CliError('INVALID_RESPONSE');
+    const bytes = await readPhoto(file, candidate);
+    const form = new FormData();
+    for (const [key, value] of Object.entries(upload.fields)) {
+        if (key.toLowerCase() === 'file')
+            throw new CliError('INVALID_RESPONSE');
+        form.append(key, value);
+    }
+    form.append('file', new Blob([new Uint8Array(bytes)], { type: candidate.mimeType }), candidate.originalName);
+    let res;
+    try {
+        res = await api.fetcher(url, { method: 'POST', body: form, redirect: 'manual', signal: AbortSignal.timeout(120000) });
+    }
+    catch {
+        throw new CliError('RESULT_UNKNOWN', true);
+    }
+    await res.body?.cancel();
+    if (!res.ok)
+        throw new CliError('STORAGE_UNAVAILABLE', true);
+}
+export async function executePlan(input, hash, identity, api, previous, save) {
+    const plan = verifyPlan(input, hash, identity);
+    const progress = previous ? progressSchema.parse(previous) : { schemaVersion: 1, origin: plan.origin, userId: plan.userId, entries: {} };
+    let persistenceFailed = false;
+    async function persist() { try {
+        serializePrivateJson(progress);
+        await save(progress);
+    }
+    catch (e) {
+        persistenceFailed = true;
+        throw e;
+    } }
+    if (progress.origin !== plan.origin || progress.userId !== plan.userId)
+        throw new CliError('CONFIRMATION_REQUIRED');
+    await api.negotiate();
+    if (plan.items.length > api.limits.maxActions)
+        throw new CliError('PAYLOAD_TOO_LARGE');
+    // Preflight every known payload and source before the first remote content write.
+    for (const item of plan.items) {
+        checkBytes(item.payload, api.limits.maxRequestBytes);
+        if (item.action === 'photos.import') {
+            if (item.payload.manifest.candidates.length > api.limits.maxCandidates)
+                throw new CliError('PAYLOAD_TOO_LARGE');
+            for (const c of item.payload.manifest.candidates.filter(c => c.status === 'SELECTED')) {
+                if (c.fileSize > api.limits.maxFileBytes)
+                    throw new CliError('PAYLOAD_TOO_LARGE');
+                if (progress.entries[stepId(item.operationId, `${c.localCandidateId}:complete`)]?.status !== 'success' && progress.entries[stepId(item.operationId, `${c.localCandidateId}:publish`)]?.status !== 'success')
+                    await readPhoto(item.files[c.localCandidateId], c);
+            }
+        }
+        const entry = progress.entries[item.operationId];
+        if (entry && entry.fingerprint !== sha256(canonicalJson(item)))
+            throw new CliError('OPERATION_CONFLICT');
+    }
+    await persist();
+    async function perform(operationId, fingerprint, request, ephemeral = false) {
+        checkBytes(request.body, api.limits.maxRequestBytes);
+        const requestHash = sha256(canonicalJson(request));
+        let entry = progress.entries[operationId];
+        if (entry && (entry.fingerprint !== fingerprint || entry.requestHash !== requestHash))
+            throw new CliError('OPERATION_CONFLICT');
+        if (entry && !ephemeral && entry.status !== 'failed') {
+            try {
+                const result = resultSchema.parse(await api.request(`/operations/${operationId}`));
+                entry.status = 'success';
+                entry.result = result;
+                delete entry.request;
+                delete entry.error;
+                await persist();
+                return result;
+            }
+            catch (e) {
+                if (persistenceFailed || !(e instanceof CliError && e.code === 'NOT_FOUND') || entry.status === 'success')
+                    throw e;
+            }
+        }
+        entry = { fingerprint, requestHash, request: requestSchema.parse(request), status: 'unknown' };
+        progress.entries[operationId] = entry;
+        await persist();
+        let raw;
+        try {
+            raw = await api.request(request.path, { method: request.method, body: request.body, version: request.version, operationId });
+            const result = resultSchema.parse(raw);
+            entry.status = 'success';
+            entry.result = result;
+            delete entry.request;
+        }
+        catch (e) {
+            entry.status = e instanceof CliError && !['RESULT_UNKNOWN', 'NETWORK_ERROR', 'INVALID_RESPONSE', 'STORAGE_UNAVAILABLE'].includes(e.code) ? 'failed' : 'unknown';
+            entry.error = safeError(e);
+            await persist();
+            throw e;
+        }
+        await persist();
+        return ephemeral ? { ...entry.result, upload: uploadSchema.parse(raw.upload) } : entry.result;
+    }
+    async function importPhotos(item) {
+        const fingerprint = sha256(canonicalJson(item));
+        const batch = await perform(item.operationId, fingerprint, actionRequest(item, {}));
+        if (!batch.candidates || batch.candidates.length !== item.payload.manifest.candidates.length || new Set(batch.candidates.map(c => c.localCandidateId)).size !== batch.candidates.length)
+            throw new CliError('INVALID_RESPONSE');
+        const state = await api.request(`/imports/${encodeURIComponent(batch.id)}`);
+        if (!Array.isArray(state.candidates))
+            throw new CliError('INVALID_RESPONSE');
+        const selected = item.payload.manifest.candidates.filter(c => c.status === 'SELECTED');
+        const details = [];
+        const paths = new Map();
+        for (const candidate of selected) {
+            const mapping = batch.candidates.find(c => c.localCandidateId === candidate.localCandidateId);
+            if (!mapping)
+                throw new CliError('INVALID_RESPONSE');
+            const path = `/imports/${encodeURIComponent(batch.id)}/candidates/${encodeURIComponent(mapping.id)}`;
+            paths.set(candidate.localCandidateId, path);
+            const current = state.candidates.find(c => c.id === mapping.id && c.localCandidateId === candidate.localCandidateId);
+            if (!current)
+                throw new CliError('INVALID_RESPONSE');
+            if (current.verified || current.publishedPhotoId)
+                continue;
+            const uploadId = stepId(item.operationId, `${candidate.localCandidateId}:upload`);
+            try {
+                const authorization = await perform(uploadId, fingerprint, { path: `${path}/upload`, method: 'POST', body: {} }, true);
+                await uploadPhoto(api, authorization.upload, item.files[candidate.localCandidateId], candidate);
+                await perform(stepId(item.operationId, `${candidate.localCandidateId}:complete`), fingerprint, { path: `${path}/complete`, method: 'POST', body: {} });
+            }
+            catch (e) {
+                if (persistenceFailed)
+                    throw e;
+                details.push({ operationId: uploadId, status: e instanceof CliError && e.code === 'RESULT_UNKNOWN' ? 'unknown' : 'failed', error: safeError(e) });
+            }
+        }
+        // Do not silently publish only the uploaded subset of the confirmed selection.
+        if (details.length)
+            return { operationId: item.operationId, status: 'failed', result: batch, candidates: details };
+        const photoIds = {};
+        for (const candidate of selected) {
+            const operationId = stepId(item.operationId, `${candidate.localCandidateId}:publish`);
+            const expected = item.expectations[candidate.localCandidateId];
+            try {
+                const result = await perform(operationId, fingerprint, { path: `${paths.get(candidate.localCandidateId)}/publish`, method: 'POST', body: { expectedPhoto: expected.mode === 'create' ? null : { id: expected.photoId, version: expected.version } } });
+                photoIds[candidate.localCandidateId] = result.id;
+                details.push({ operationId, status: 'success', result });
+            }
+            catch (e) {
+                if (persistenceFailed)
+                    throw e;
+                details.push({ operationId, status: progress.entries[operationId]?.status === 'unknown' ? 'unknown' : 'failed', error: safeError(e) });
+            }
+        }
+        return { operationId: item.operationId, status: details.every(d => d.status === 'success') ? 'success' : 'failed', result: { ...batch, photoIds }, candidates: details };
+    }
+    const results = {};
+    const items = [];
+    for (const item of plan.items) {
+        if (refsIn(item).some(r => !results[r.ref])) {
+            items.push({ operationId: item.operationId, status: 'skipped' });
+            continue;
+        }
+        try {
+            const entry = progress.entries[item.operationId];
+            const outcome = item.action === 'photos.import' ? await importPhotos(item) : { operationId: item.operationId, status: 'success', result: await perform(item.operationId, sha256(canonicalJson(item)), entry?.request ?? actionRequest(item, results)) };
+            items.push(outcome);
+            if (outcome.status === 'success')
+                results[item.operationId] = outcome.result;
+        }
+        catch (e) {
+            if (persistenceFailed)
+                throw e;
+            items.push({ operationId: item.operationId, status: progress.entries[item.operationId]?.status === 'unknown' ? 'unknown' : 'failed', error: safeError(e) });
+        }
+    }
+    return { ok: items.every(i => i.status === 'success'), items, progress };
+}

package/dist/http.d.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+export declare function compatibleVersion(version: string, range: string): boolean;
+export declare const userSchema: z.ZodObject<{
+    id: z.ZodString;
+    email: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+    role: z.ZodEnum<{
+        FAMILY: "FAMILY";
+        ADMIN: "ADMIN";
+    }>;
+}, z.core.$strip>;
+export declare const meSchema: z.ZodObject<{
+    id: z.ZodString;
+    email: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+    role: z.ZodEnum<{
+        FAMILY: "FAMILY";
+        ADMIN: "ADMIN";
+    }>;
+    expiresAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type RequestOptions = {
+    method?: 'GET' | 'POST' | 'PATCH';
+    body?: unknown;
+    operationId?: string;
+    version?: string;
+    anonymous?: boolean;
+};
+export declare class ApiClient {
+    token?: string | undefined;
+    readonly fetcher: typeof fetch;
+    readonly origin: string;
+    limits: {
+        maxRequestBytes: number;
+        maxCandidates: number;
+        maxActions: number;
+        maxFileBytes: number;
+    };
+    private negotiated;
+    constructor(site: string, token?: string | undefined, fetcher?: typeof fetch);
+    negotiate(): Promise<void>;
+    request<T = Record<string, unknown>>(path: string, options?: RequestOptions): Promise<T>;
+    private raw;
+}

package/dist/http.js

@@ -0,0 +1,146 @@
+import { z } from 'zod';
+import { checkBytes, CliError, LIMITS, normalizeSite, VERSION } from './core.js';
+export function compatibleVersion(version, range) {
+    const parse = (v) => {
+        const m = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-beta\.(0|[1-9]\d*))?$/.exec(v);
+        if (!m)
+            return null;
+        const parts = m.slice(1, 4).map(Number);
+        if (!parts.every(Number.isSafeInteger) || (m[4] !== undefined && !Number.isSafeInteger(Number(m[4]))))
+            return null;
+        return [...parts, m[4] === undefined ? Infinity : Number(m[4])];
+    };
+    const actual = parse(version);
+    if (!actual)
+        return false;
+    const compare = (a, b) => { for (let i = 0; i < 4; i++)
+        if (a[i] !== b[i])
+            return a[i] > b[i] ? 1 : -1; return 0; };
+    return range.split('||').some(clause => {
+        const terms = clause.trim().split(/\s+/);
+        // Prereleases require an explicit comparator for the same release tuple.
+        if (actual[3] !== Infinity && !terms.some(term => {
+            const v = parse(term.replace(/^(>=|<=|>|<|=|\^|~)/, ''));
+            return v && v[3] !== Infinity && v.slice(0, 3).every((n, i) => n === actual[i]);
+        }))
+            return false;
+        return terms.every(term => {
+            if (term === '*')
+                return true;
+            const m = /^(>=|<=|>|<|=|\^|~)?(\d+\.\d+\.\d+(?:-beta\.\d+)?)$/.exec(term);
+            if (!m)
+                return false;
+            const v = parse(m[2]);
+            if (!v)
+                return false;
+            const c = compare(actual, v);
+            if (m[1] === '^' || m[1] === '~') {
+                const upper = [...v.slice(0, 3), -1];
+                const index = m[1] === '~' ? 1 : v[0] ? 0 : v[1] ? 1 : 2;
+                upper[index]++;
+                for (let i = index + 1; i < 3; i++)
+                    upper[i] = 0;
+                return c >= 0 && compare(actual, upper) < 0;
+            }
+            return m[1] === '>=' ? c >= 0 : m[1] === '<=' ? c <= 0 : m[1] === '>' ? c > 0 : m[1] === '<' ? c < 0 : c === 0;
+        });
+    });
+}
+const metaSchema = z.object({ protocolVersion: z.literal(1), cliVersionRange: z.string(), limits: z.object({ maxRequestBytes: z.number().int().positive(), maxCandidates: z.number().int().positive(), maxActions: z.number().int().positive(), maxFileBytes: z.number().int().positive() }).strict() }).strict();
+export const userSchema = z.object({ id: z.string(), email: z.string(), name: z.string().nullable(), role: z.enum(['FAMILY', 'ADMIN']) });
+export const meSchema = userSchema.extend({ expiresAt: z.iso.datetime() });
+export class ApiClient {
+    token;
+    fetcher;
+    origin;
+    limits = { ...LIMITS };
+    negotiated = false;
+    constructor(site, token, fetcher = fetch) {
+        this.token = token;
+        this.fetcher = fetcher;
+        this.origin = normalizeSite(site);
+    }
+    async negotiate() {
+        if (this.negotiated)
+            return;
+        let meta;
+        try {
+            meta = metaSchema.parse(await this.raw('/meta', { anonymous: true }));
+        }
+        catch (e) {
+            if (e instanceof CliError && e.code === 'NETWORK_ERROR')
+                throw e;
+            throw new CliError('PROTOCOL_MISMATCH');
+        }
+        if (!compatibleVersion(VERSION, meta.cliVersionRange))
+            throw new CliError('PROTOCOL_MISMATCH');
+        for (const k of Object.keys(LIMITS))
+            this.limits[k] = Math.min(LIMITS[k], meta.limits[k]);
+        this.negotiated = true;
+    }
+    async request(path, options = {}) {
+        if (!/^\/[a-z][^\\#]*$/.test(path) || /(?:^|\/)\.\.(?:\/|$)/.test(path))
+            throw new CliError('INVALID_INPUT');
+        if (options.body !== undefined)
+            checkBytes(options.body, this.limits.maxRequestBytes);
+        await this.negotiate();
+        return this.raw(path, options);
+    }
+    async raw(path, options) {
+        const headers = { Accept: 'application/json', 'X-Yusijia-Protocol': '1' };
+        if (!options.anonymous) {
+            if (!this.token)
+                throw new CliError('AUTH_REQUIRED');
+            headers.Authorization = `Bearer ${this.token}`;
+        }
+        if (options.operationId)
+            headers['Idempotency-Key'] = options.operationId;
+        if (options.version)
+            headers['If-Match'] = options.version;
+        if (options.body !== undefined)
+            headers['Content-Type'] = 'application/json';
+        let response;
+        try {
+            response = await this.fetcher(`${this.origin}/api/agent/v1${path}`, { method: options.method ?? 'GET', headers, body: options.body === undefined ? undefined : checkBytes(options.body, this.limits.maxRequestBytes), redirect: 'manual', signal: AbortSignal.timeout(30000) });
+        }
+        catch {
+            throw new CliError(options.method && options.method !== 'GET' ? 'RESULT_UNKNOWN' : 'NETWORK_ERROR', true);
+        }
+        if (response.status >= 300 && response.status < 400)
+            throw new CliError('INVALID_RESPONSE');
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new CliError('INVALID_RESPONSE');
+        const parts = [];
+        let bytes = 0;
+        try {
+            while (true) {
+                const chunk = await reader.read();
+                if (chunk.done)
+                    break;
+                bytes += chunk.value.length;
+                if (bytes > 8 * 1024 * 1024) {
+                    await reader.cancel();
+                    throw new CliError('INVALID_RESPONSE');
+                }
+                ;
+                parts.push(chunk.value);
+            }
+        }
+        catch (e) {
+            if (e instanceof CliError)
+                throw e;
+            throw new CliError('RESULT_UNKNOWN', true);
+        }
+        let envelope;
+        try {
+            envelope = JSON.parse(Buffer.concat(parts).toString('utf8'));
+        }
+        catch {
+            throw new CliError(response.status >= 500 ? 'RESULT_UNKNOWN' : 'INVALID_RESPONSE', response.status >= 500);
+        }
+        if (!envelope || envelope.ok !== true || !response.ok)
+            throw new CliError(envelope?.error?.code ?? (response.status >= 500 ? 'RESULT_UNKNOWN' : 'INVALID_RESPONSE'), envelope?.error?.retryable === true, response.status);
+        return envelope.data;
+    }
+}