@modelprofile.com/authswitch 6.5.0 → 7.0.0

package/dist_ts/authorityrehearsal.child.js

@@ -0,0 +1,395 @@
+import * as plugins from './plugins.js';
+import { AuthSwitchAuthorityDatabase } from './classes.authoritydatabase.js';
+import { assertStoredAuthorityMeta } from './classes.authoritymodels.js';
+import { AuthorityRehearsalFramedTransport, authorityRehearsalMaximumFrameBytes, parseAuthorityRehearsalChildMessage, parseAuthorityRehearsalParentMessage, parseAuthorityRehearsalWireEntry, } from './classes.authorityrehearsal.js';
+const spoolHeaderBytes = 4 + 12 + 16;
+const childReceiveTimeoutMs = 24 * 60 * 60 * 1000;
+const writeAll = async (file, bytes) => {
+    let offset = 0;
+    while (offset < bytes.byteLength) {
+        const result = await file.write(bytes, offset, bytes.byteLength - offset, null);
+        if (result.bytesWritten < 1)
+            throw new Error('Encrypted rehearsal staging stopped making progress.');
+        offset += result.bytesWritten;
+    }
+};
+const readExact = async (file, bytes, position) => {
+    let offset = 0;
+    while (offset < bytes.byteLength) {
+        const result = await file.read(bytes, offset, bytes.byteLength - offset, position + offset);
+        if (result.bytesRead === 0) {
+            if (offset === 0)
+                return true;
+            throw new Error('Encrypted rehearsal staging ended within a frame.');
+        }
+        offset += result.bytesRead;
+    }
+    return false;
+};
+/** Append-only encrypted staging. The key exists only in this child and every plaintext buffer is wiped. */
+class EncryptedRehearsalSpool {
+    path;
+    domain;
+    key;
+    parse;
+    appendFile;
+    readFiles = new Set();
+    appendSequence = 0;
+    finished = false;
+    constructor(path, domain, key, parse) {
+        this.path = path;
+        this.domain = domain;
+        this.key = key;
+        this.parse = parse;
+    }
+    async open() {
+        if (this.appendFile)
+            throw new Error('Encrypted rehearsal staging is already open.');
+        this.appendFile = await plugins.fs.promises.open(this.path, 'wx', 0o600);
+    }
+    async append(value) {
+        if (!this.appendFile || this.finished)
+            throw new Error('Encrypted rehearsal staging is not writable.');
+        const plaintext = Buffer.from(JSON.stringify(value), 'utf8');
+        if (plaintext.byteLength < 1 || plaintext.byteLength > authorityRehearsalMaximumFrameBytes) {
+            plaintext.fill(0);
+            throw new Error('Encrypted rehearsal staging entry exceeds its size bound.');
+        }
+        const nonce = plugins.crypto.randomBytes(12);
+        const aad = Buffer.from(JSON.stringify(['authswitch-rehearsal-stage-v1', this.domain,
+            this.appendSequence]), 'utf8');
+        let ciphertext;
+        try {
+            const cipher = plugins.crypto.createCipheriv('aes-256-gcm', this.key, nonce);
+            cipher.setAAD(aad);
+            ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+            const tag = cipher.getAuthTag();
+            const frame = Buffer.allocUnsafe(spoolHeaderBytes + ciphertext.byteLength);
+            frame.writeUInt32BE(ciphertext.byteLength, 0);
+            nonce.copy(frame, 4);
+            tag.copy(frame, 16);
+            ciphertext.copy(frame, spoolHeaderBytes);
+            try {
+                await writeAll(this.appendFile, frame);
+            }
+            finally {
+                frame.fill(0);
+                tag.fill(0);
+            }
+            this.appendSequence++;
+        }
+        finally {
+            plaintext.fill(0);
+            nonce.fill(0);
+            aad.fill(0);
+            ciphertext?.fill(0);
+        }
+    }
+    async finish() {
+        if (this.finished)
+            return;
+        this.finished = true;
+        const file = this.appendFile;
+        this.appendFile = undefined;
+        if (file)
+            await file.close();
+    }
+    async *values() {
+        if (!this.finished)
+            throw new Error('Encrypted rehearsal staging is not complete.');
+        const file = await plugins.fs.promises.open(this.path, 'r');
+        this.readFiles.add(file);
+        let position = 0;
+        let itemSequence = 0;
+        try {
+            while (true) {
+                const header = Buffer.alloc(spoolHeaderBytes);
+                const ended = await readExact(file, header, position);
+                if (ended)
+                    return;
+                const length = header.readUInt32BE(0);
+                if (length < 1 || length > authorityRehearsalMaximumFrameBytes) {
+                    header.fill(0);
+                    throw new Error('Encrypted rehearsal staging frame exceeds its size bound.');
+                }
+                const ciphertext = Buffer.allocUnsafe(length);
+                try {
+                    if (await readExact(file, ciphertext, position + spoolHeaderBytes)) {
+                        throw new Error('Encrypted rehearsal staging ended within a frame.');
+                    }
+                    const aad = Buffer.from(JSON.stringify(['authswitch-rehearsal-stage-v1', this.domain,
+                        itemSequence]), 'utf8');
+                    let plaintext;
+                    try {
+                        const decipher = plugins.crypto.createDecipheriv('aes-256-gcm', this.key, header.subarray(4, 16));
+                        decipher.setAAD(aad);
+                        decipher.setAuthTag(header.subarray(16, spoolHeaderBytes));
+                        plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+                        let decoded;
+                        try {
+                            decoded = JSON.parse(plaintext.toString('utf8'));
+                        }
+                        catch {
+                            throw new Error('Encrypted rehearsal staging contains invalid JSON.');
+                        }
+                        yield this.parse(decoded);
+                    }
+                    finally {
+                        aad.fill(0);
+                        plaintext?.fill(0);
+                    }
+                }
+                finally {
+                    header.fill(0);
+                    ciphertext.fill(0);
+                }
+                position += spoolHeaderBytes + length;
+                itemSequence++;
+            }
+        }
+        finally {
+            this.readFiles.delete(file);
+            await file.close();
+        }
+    }
+    async close() {
+        const errors = [];
+        const appendFile = this.appendFile;
+        this.appendFile = undefined;
+        if (appendFile)
+            try {
+                await appendFile.close();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        for (const file of this.readFiles) {
+            try {
+                await file.close();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        this.readFiles.clear();
+        if (errors.length)
+            throw new AggregateError(errors, 'Encrypted rehearsal staging cleanup failed.');
+    }
+}
+const validateRoot = async (rootInput) => {
+    if (!plugins.path.isAbsolute(rootInput))
+        throw new Error('Rehearsal root must be absolute.');
+    const root = await plugins.fs.promises.realpath(rootInput);
+    if (root !== rootInput)
+        throw new Error('Rehearsal root must be canonical.');
+    const stat = await plugins.fs.promises.lstat(root);
+    if (!stat.isDirectory() || stat.isSymbolicLink() || stat.uid !== process.getuid?.()
+        || (stat.mode & 0o077) !== 0)
+        throw new Error('Rehearsal root is not private.');
+    return root;
+};
+const recordKey = (record) => `${record.model}\u0000${record.id}`;
+const parseRecord = (value) => {
+    const entry = parseAuthorityRehearsalWireEntry(value);
+    if ('kind' in entry)
+        throw new Error('Encrypted record staging contains a source.');
+    return entry;
+};
+const parseSource = (value) => {
+    const entry = parseAuthorityRehearsalWireEntry(value);
+    if (!('kind' in entry))
+        throw new Error('Encrypted source staging contains a record.');
+    return entry;
+};
+const run = async () => {
+    // tsrun deliberately presents script arguments from argv[0], while built Node entrypoints retain argv[0..1].
+    const root = await validateRoot(process.argv.at(-1) ?? '');
+    const reader = plugins.fs.createReadStream('', { fd: 3, autoClose: false });
+    const writer = plugins.fs.createWriteStream('', { fd: 4, autoClose: false });
+    const transport = new AuthorityRehearsalFramedTransport({ readable: reader, writable: writer,
+        parseIncoming: parseAuthorityRehearsalParentMessage,
+        validateOutgoing: parseAuthorityRehearsalChildMessage });
+    const key = plugins.crypto.randomBytes(32);
+    const metaSpool = new EncryptedRehearsalSpool(plugins.path.join(root, 'meta.stage'), 'meta', key, parseRecord);
+    const recordSpool = new EncryptedRehearsalSpool(plugins.path.join(root, 'records.stage'), 'records', key, parseRecord);
+    const sourceSpool = new EncryptedRehearsalSpool(plugins.path.join(root, 'sources.stage'), 'sources', key, parseSource);
+    let database;
+    let recordRestoreIterator;
+    let recordReadbackIterator;
+    let sourceReadbackIterator;
+    let expectedSequence = 0;
+    let metaCount = 0;
+    let recordsStarted = false;
+    let lastRecordKey = '';
+    let inputComplete = false;
+    let restored = false;
+    let recordsReadbackDone = false;
+    let phase = 'staging';
+    let cleanClose = false;
+    const cleanup = async () => {
+        const errors = [];
+        for (const iterator of [recordRestoreIterator, recordReadbackIterator, sourceReadbackIterator]) {
+            if (iterator?.return)
+                try {
+                    await iterator.return();
+                }
+                catch (error) {
+                    errors.push(error);
+                }
+        }
+        if (database)
+            try {
+                await database.stop();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        database = undefined;
+        for (const spool of [metaSpool, recordSpool, sourceSpool]) {
+            try {
+                await spool.close();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        key.fill(0);
+        if (errors.length)
+            throw new AggregateError(errors, 'Rehearsal child cleanup failed.');
+    };
+    try {
+        await Promise.all([metaSpool.open(), recordSpool.open(), sourceSpool.open()]);
+        await transport.send({ version: 1, type: 'ready' }, childReceiveTimeoutMs);
+        while (true) {
+            const message = await transport.receive(childReceiveTimeoutMs);
+            if (message.type === 'stage') {
+                phase = 'staging';
+                if (inputComplete || message.sequence !== expectedSequence) {
+                    throw new Error('Rehearsal stage sequence is invalid.');
+                }
+                const entry = message.entry;
+                if ('kind' in entry) {
+                    if (recordsStarted)
+                        throw new Error('Rehearsal sources must precede records.');
+                    await sourceSpool.append(entry);
+                }
+                else {
+                    recordsStarted = true;
+                    const keyValue = recordKey(entry);
+                    if (keyValue <= lastRecordKey)
+                        throw new Error('Rehearsal records must be strictly ordered.');
+                    lastRecordKey = keyValue;
+                    if (entry.model === 'authswitch_authority_meta') {
+                        if (++metaCount !== 1)
+                            throw new Error('Rehearsal input contains duplicate metadata.');
+                        await metaSpool.append(entry);
+                    }
+                    else
+                        await recordSpool.append(entry);
+                }
+                expectedSequence++;
+                await transport.send({ version: 1, type: 'staged', sequence: message.sequence }, childReceiveTimeoutMs);
+                continue;
+            }
+            if (message.type === 'finish') {
+                phase = 'staging';
+                if (inputComplete || message.sequence !== expectedSequence || metaCount !== 1) {
+                    throw new Error('Rehearsal input is incomplete.');
+                }
+                await Promise.all([metaSpool.finish(), recordSpool.finish(), sourceSpool.finish()]);
+                inputComplete = true;
+                recordRestoreIterator = recordSpool.values()[Symbol.asyncIterator]();
+                await transport.send({ version: 1, type: 'input.complete' }, childReceiveTimeoutMs);
+                continue;
+            }
+            if (message.type === 'restore.next') {
+                phase = 'restore';
+                if (!inputComplete || restored)
+                    throw new Error('Rehearsal restore state is invalid.');
+                if (!database) {
+                    database = new AuthSwitchAuthorityDatabase({ dataDirectory: plugins.path.join(root, 'database'),
+                        socketPath: plugins.path.join(root, 'run', 'database.sock') });
+                    await database.start({ mode: 'closed_restore' });
+                    const metaIterator = metaSpool.values()[Symbol.asyncIterator]();
+                    try {
+                        const first = await metaIterator.next();
+                        const second = await metaIterator.next();
+                        if (first.done || !second.done)
+                            throw new Error('Rehearsal metadata staging is not singular.');
+                        assertStoredAuthorityMeta(first.value.value);
+                        const meta = first.value.value;
+                        await database.restoreClosedMeta(meta);
+                    }
+                    finally {
+                        await metaIterator.return?.(undefined);
+                    }
+                    await transport.send({ version: 1, type: 'restore.progress', done: false }, childReceiveTimeoutMs);
+                    continue;
+                }
+                const next = await recordRestoreIterator.next();
+                if (!next.done) {
+                    await database.insertClosedRestoredRecord(next.value);
+                    await transport.send({ version: 1, type: 'restore.progress', done: false }, childReceiveTimeoutMs);
+                    continue;
+                }
+                await database.stop();
+                database = new AuthSwitchAuthorityDatabase({ dataDirectory: plugins.path.join(root, 'database'),
+                    socketPath: plugins.path.join(root, 'run', 'database.sock') });
+                await database.start();
+                recordReadbackIterator = database.readStoredRecords({ pageSize: 64 })[Symbol.asyncIterator]();
+                sourceReadbackIterator = sourceSpool.values()[Symbol.asyncIterator]();
+                restored = true;
+                await transport.send({ version: 1, type: 'restore.progress', done: true }, childReceiveTimeoutMs);
+                continue;
+            }
+            if (message.type === 'record.next') {
+                phase = 'readback';
+                if (!restored || recordsReadbackDone)
+                    throw new Error('Rehearsal record readback state is invalid.');
+                const next = await recordReadbackIterator.next();
+                if (next.done)
+                    recordsReadbackDone = true;
+                await transport.send({ version: 1, type: 'record', record: next.done ? null : next.value }, childReceiveTimeoutMs);
+                continue;
+            }
+            if (message.type === 'source.next') {
+                phase = 'readback';
+                if (!restored || !recordsReadbackDone)
+                    throw new Error('Rehearsal source readback state is invalid.');
+                const next = await sourceReadbackIterator.next();
+                await transport.send({ version: 1, type: 'source', source: next.done ? null : next.value }, childReceiveTimeoutMs);
+                continue;
+            }
+            if (message.type === 'close') {
+                phase = 'cleanup';
+                await cleanup();
+                await transport.send({ version: 1, type: 'closed' }, childReceiveTimeoutMs);
+                await transport.finishWritable();
+                cleanClose = true;
+                return;
+            }
+            throw new Error('Unknown rehearsal request.');
+        }
+    }
+    catch {
+        try {
+            await cleanup();
+        }
+        catch {
+            phase = 'cleanup';
+        }
+        try {
+            await transport.send({ version: 1, type: 'failed', phase }, childReceiveTimeoutMs);
+            await transport.finishWritable();
+        }
+        catch { /* The parent may already have closed the control channel. */ }
+        process.exitCode = 1;
+    }
+    finally {
+        if (!cleanClose)
+            key.fill(0);
+        transport.destroy();
+    }
+};
+await run().catch(() => { process.exitCode = 1; });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authorityrehearsal.child.js","sourceRoot":"","sources":["../ts/authorityrehearsal.child.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.accountlist.js

@@ -25,7 +25,8 @@ export const readAccountList = async (harnessesArg) => {
             result.saveUnavailableReason = state.saveUnavailableReason;
             result.credentialDrift = state.credentialDrift ?? [];
             result.accounts = rows.map(({ account, status }) => ({
-                id: account.id, label: account.label, isActive: account.isActive, isStashed: account.isStashed,
+                id: account.id, providerAccountId: account.providerAccountId, label: account.label,
+                isActive: account.isActive, isStashed: account.isStashed,
                 savedAt: account.savedAt, details: [...account.details], ...(account.slotId === undefined ? {} : { slotId: account.slotId }),
                 status: publicStatus(status),
             }));
@@ -36,9 +37,9 @@ export const readAccountList = async (harnessesArg) => {
         harnesses.push(result);
     }
     return {
-        schemaVersion: 2, generatedAt: new Date().toISOString(),
+        schemaVersion: 3, generatedAt: new Date().toISOString(),
         complete: harnesses.every(harness => !harness.problems.length && harness.accounts.every(account => !account.status.problems.length)),
         harnesses,
     };
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.authoritybackup.d.ts

@@ -0,0 +1,134 @@
+import * as plugins from './plugins.js';
+import { type IAuthorityStoredRecord } from './classes.authorityregistry.js';
+import type { IAuthSwitchSecretCodec } from './classes.authoritysecrets.js';
+import type { IRemoteControlEnrollment } from './interfaces.js';
+/** This ID preserves Codex's complete three-column enrollment key, without email matching. */
+export declare const authorityEnrollmentId: (row: IRemoteControlEnrollment) => string;
+export type IAuthorityBackupRecord = IAuthorityStoredRecord;
+export interface IAuthorityBackupSourceCapsule {
+    kind: string;
+    id: string;
+    linkedModel: string;
+    linkedId: string;
+    linkedDigestField: 'sourceDigest' | 'before.credentialDigest' | 'before.configDigest';
+    /** Exact bytes re-read under the native owner's exclusion; the caller retains and wipes its buffer. */
+    bytes: Uint8Array;
+}
+export interface IAuthorityBackupSnapshotAttempt {
+    epoch: string;
+    revision: number;
+    records: AsyncIterable<IAuthorityBackupRecord>;
+    sources: AsyncIterable<IAuthorityBackupSourceCapsule>;
+}
+/** Implement with one SmartData session.withTransaction; each retry invokes visit anew. */
+export interface IAuthorityBackupSnapshotSource {
+    capture(visit: (attempt: IAuthorityBackupSnapshotAttempt) => Promise<void>): Promise<void>;
+}
+export interface IAuthorityBackupObjectStore {
+    prepare(signal?: AbortSignal): Promise<void>;
+    putExact(path: string, bytes: Uint8Array, signal?: AbortSignal): Promise<void>;
+    get(path: string, maxBytes: number, signal?: AbortSignal): Promise<Uint8Array>;
+}
+/** Thin adapter over SmartBucket's provider-probed, create-only exact upload API. */
+export declare class AuthoritySmartBucketStore implements IAuthorityBackupObjectStore {
+    private readonly bucket;
+    private capability?;
+    constructor(bucket: plugins.smartbucket.Bucket);
+    prepare(signal?: AbortSignal): Promise<void>;
+    putExact(path: string, bytes: Uint8Array, signal?: AbortSignal): Promise<void>;
+    get(path: string, maxBytes: number, signal?: AbortSignal): Promise<Uint8Array>;
+}
+export interface IAuthorityRestoredRecord extends IAuthorityBackupRecord {
+}
+export interface IAuthorityRestoredSource {
+    kind: 'source';
+    sourceKind: string;
+    sourceId: string;
+    sourceDigest: string;
+    linkedModel: string;
+    linkedId: string;
+    linkedDigestField: IAuthorityBackupSourceCapsule['linkedDigestField'];
+    bytes: Uint8Array;
+}
+export type TAuthorityRestoredEntry = IAuthorityRestoredRecord | IAuthorityRestoredSource;
+export interface IAuthorityBackupRehearsalReadback {
+    records: AsyncIterable<IAuthorityRestoredRecord>;
+    sources: AsyncIterable<IAuthorityRestoredSource>;
+    /** Stops the isolated database and child, then removes every disposable artifact. */
+    close(): Promise<void>;
+}
+/** Must restore into an isolated, runtime-closed target and read its stored postimage back. */
+export interface IAuthorityBackupRehearsal {
+    restoreClosed(entries: AsyncIterable<TAuthorityRestoredEntry>): Promise<IAuthorityBackupRehearsalReadback>;
+}
+export interface IAuthorityBackupSourceProof {
+    kind: string;
+    id: string;
+    linkedModel: string;
+    linkedId: string;
+    linkedDigestField: IAuthorityBackupSourceCapsule['linkedDigestField'];
+    digest: string;
+}
+/** Factual portable proof only. Production admission must additionally bind configured bucket and key custody. */
+export interface IAuthorityBackupVerification {
+    backupId: string;
+    manifestPath: string;
+    manifestDigest: string;
+    snapshotDigest: string;
+    sourceEpoch: string;
+    sourceRevision: number;
+    restoredEpoch: string;
+    recordCount: number;
+    sources: IAuthorityBackupSourceProof[];
+    rehearsalDigest: string;
+    verifiedAt: string;
+    /** Portable recovery proves data integrity, never that a surviving native writer has stopped. */
+    restoreAdmission: 'closed_pending_codex_and_native_reconciliation';
+}
+/** An object locator and digest only; this carries no recoverability or deletion authority. */
+export interface IAuthorityBackupPublication {
+    backupId: string;
+    manifestPath: string;
+    manifestDigest: string;
+    sourceEpoch: string;
+    sourceRevision: number;
+    snapshotDigest: string;
+}
+export declare class AuthorityBackupPublicationUnknownError extends Error {
+    readonly path: string;
+    constructor(path: string, cause: unknown);
+}
+interface IAuthorityBackupCommonOptions {
+    store: IAuthorityBackupObjectStore;
+    secrets: IAuthSwitchSecretCodec;
+    prefix: string;
+    recipientKeyId: string;
+    signal?: AbortSignal;
+}
+export interface IAuthorityBackupPublisherOptions extends IAuthorityBackupCommonOptions {
+    source: IAuthorityBackupSnapshotSource;
+    recipientPublicKey: Uint8Array;
+}
+export interface IAuthorityBackupVerifierOptions extends IAuthorityBackupCommonOptions {
+    rehearsal: IAuthorityBackupRehearsal;
+    recipientPrivateKey: Uint8Array;
+}
+export type TAuthorityBackupOptions = IAuthorityBackupPublisherOptions | IAuthorityBackupVerifierOptions;
+/** Portable backup codec; the daemon's SmartData repository supplies the snapshot and persists the verified receipt. */
+export declare class AuthSwitchAuthorityBackup {
+    private readonly options;
+    constructor(options: TAuthorityBackupOptions);
+    private publisher;
+    private verifier;
+    private secretFor;
+    private sourceDigestInRecord;
+    private assertPreparedClaudeSourceCoverage;
+    private stage;
+    private publish;
+    publishSnapshot(): Promise<IAuthorityBackupPublication>;
+    /** Rehearse a previously published object set; no caller-supplied success flag is accepted. */
+    rehearsePublished(input: IAuthorityBackupPublication): Promise<IAuthorityBackupVerification>;
+    private verifyPublished;
+    private restoreRecord;
+}
+export {};