@modelprofile.com/authswitch 6.3.0 → 6.5.0

package/dist_ts/classes.authoritysecrets.d.ts

@@ -0,0 +1,9 @@
+export interface IAuthSwitchSecretCodec {
+    seal(accountId: string, plaintext: Uint8Array): Promise<string>;
+    unseal(accountId: string, ciphertext: string): Promise<Uint8Array>;
+}
+/** TPM-sealed byte payloads live only as ciphertext in SmartData. */
+export declare class AuthSwitchTpmSecretCodec implements IAuthSwitchSecretCodec {
+    seal(accountId: string, plaintext: Uint8Array): Promise<string>;
+    unseal(accountId: string, ciphertext: string): Promise<Uint8Array>;
+}

package/dist_ts/classes.authoritysecrets.js

@@ -0,0 +1,30 @@
+import * as plugins from './plugins.js';
+const secretName = (accountId) => {
+    if (!/^[a-f0-9]{64}$/.test(accountId))
+        throw new Error('Invalid account identity for secret custody.');
+    return `authswitch.account.${accountId}`;
+};
+/** TPM-sealed byte payloads live only as ciphertext in SmartData. */
+export class AuthSwitchTpmSecretCodec {
+    async seal(accountId, plaintext) {
+        const ciphertext = await plugins.smartsecret.sealSmartSecretTpm2Credential(secretName(accountId), plaintext);
+        try {
+            return Buffer.from(ciphertext).toString('base64url');
+        }
+        finally {
+            ciphertext.fill(0);
+        }
+    }
+    async unseal(accountId, ciphertext) {
+        if (!/^[A-Za-z0-9_-]{1,131072}$/.test(ciphertext))
+            throw new Error('Invalid sealed account credential.');
+        const bytes = Buffer.from(ciphertext, 'base64url');
+        try {
+            return await plugins.smartsecret.unsealSmartSecretTpm2Credential(secretName(accountId), bytes);
+        }
+        finally {
+            bytes.fill(0);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5hdXRob3JpdHlzZWNyZXRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvY2xhc3Nlcy5hdXRob3JpdHlzZWNyZXRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBT3hDLE1BQU0sVUFBVSxHQUFHLENBQUMsU0FBaUIsRUFBVSxFQUFFO0lBQy9DLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDO1FBQUUsTUFBTSxJQUFJLEtBQUssQ0FBQyw4Q0FBOEMsQ0FBQyxDQUFDO0lBQ3ZHLE9BQU8sc0JBQXNCLFNBQVMsRUFBRSxDQUFDO0FBQzNDLENBQUMsQ0FBQztBQUVGLHFFQUFxRTtBQUNyRSxNQUFNLE9BQU8sd0JBQXdCO0lBQzVCLEtBQUssQ0FBQyxJQUFJLENBQUMsU0FBaUIsRUFBRSxTQUFxQjtRQUN4RCxNQUFNLFVBQVUsR0FBRyxNQUFNLE9BQU8sQ0FBQyxXQUFXLENBQUMsNkJBQTZCLENBQUMsVUFBVSxDQUFDLFNBQVMsQ0FBQyxFQUFFLFNBQVMsQ0FBQyxDQUFDO1FBQzdHLElBQUksQ0FBQztZQUFDLE9BQU8sTUFBTSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQyxRQUFRLENBQUMsV0FBVyxDQUFDLENBQUM7UUFBQyxDQUFDO2dCQUNyRCxDQUFDO1lBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUFDLENBQUM7SUFDakMsQ0FBQztJQUVNLEtBQUssQ0FBQyxNQUFNLENBQUMsU0FBaUIsRUFBRSxVQUFrQjtRQUN2RCxJQUFJLENBQUMsMkJBQTJCLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQztZQUFFLE1BQU0sSUFBSSxLQUFLLENBQUMsb0NBQW9DLENBQUMsQ0FBQztRQUN6RyxNQUFNLEtBQUssR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBRSxXQUFXLENBQUMsQ0FBQztRQUNuRCxJQUFJLENBQUM7WUFBQyxPQUFPLE1BQU0sT0FBTyxDQUFDLFdBQVcsQ0FBQywrQkFBK0IsQ0FBQyxVQUFVLENBQUMsU0FBUyxDQUFDLEVBQUUsS0FBSyxDQUFDLENBQUM7UUFBQyxDQUFDO2dCQUMvRixDQUFDO1lBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUFDLENBQUM7SUFDNUIsQ0FBQztDQUNGIn0=

package/dist_ts/classes.authorityservice.d.ts

@@ -0,0 +1,28 @@
+import * as plugins from './plugins.js';
+export interface IAuthSwitchAuthorityPaths {
+    runtimeDirectory: string;
+    dataDirectory: string;
+    databaseSocketPath: string;
+    authoritySocketPath: string;
+    runtimeSocketPath: string;
+    runtimeSocketDirectory: string;
+}
+/** Canonical per-user paths. An explicit runtime directory is also usable by a trusted container host. */
+export declare const resolveAuthSwitchAuthorityPaths: (runtimeDirectory?: string | undefined) => IAuthSwitchAuthorityPaths;
+/** Explicit installer and lifecycle operations for a user-scoped systemd service. */
+export declare class AuthSwitchAuthorityService {
+    readonly unit: plugins.smartdaemon.SystemdUnit;
+    readonly unitFile: plugins.smartdaemon.SystemdUnitFile;
+    readonly definition: plugins.smartdaemon.SystemdServiceDefinition;
+    constructor(runtimeDirectory: string, unitDirectory?: string);
+    install(): Promise<Readonly<{
+        changed: boolean;
+        masked: boolean;
+        sha256: string;
+    }>>;
+    inspect(): Promise<plugins.smartdaemon.ISystemdUnitState>;
+    enable(): Promise<plugins.smartdaemon.ISystemdUnitState>;
+    start(): Promise<plugins.smartdaemon.ISystemdUnitState>;
+    stop(): Promise<plugins.smartdaemon.ISystemdUnitState>;
+}
+export declare const runAuthSwitchAuthorityDaemon: (paths?: IAuthSwitchAuthorityPaths) => Promise<void>;

package/dist_ts/classes.authorityservice.js

@@ -0,0 +1,71 @@
+import * as plugins from './plugins.js';
+import { AuthSwitchAuthorityDaemon } from './classes.authoritydaemon.js';
+/** Canonical per-user paths. An explicit runtime directory is also usable by a trusted container host. */
+export const resolveAuthSwitchAuthorityPaths = (runtimeDirectory = process.env.XDG_RUNTIME_DIR) => {
+    if (!runtimeDirectory || !plugins.path.isAbsolute(runtimeDirectory)) {
+        throw new Error('A private XDG_RUNTIME_DIR is required for authswitch authority.');
+    }
+    const home = plugins.os.userInfo().homedir;
+    const dataHome = process.env.XDG_DATA_HOME || plugins.path.join(home, '.local/share');
+    if (!plugins.path.isAbsolute(dataHome))
+        throw new Error('XDG_DATA_HOME must be an absolute path.');
+    const socketDirectory = plugins.path.join(runtimeDirectory, 'authswitch');
+    const runtimeSocketDirectory = plugins.path.join(socketDirectory, 'runtime');
+    return {
+        runtimeDirectory,
+        dataDirectory: plugins.path.join(dataHome, 'authswitch', 'authority'),
+        databaseSocketPath: plugins.path.join(socketDirectory, 'internal', 'db.sock'),
+        authoritySocketPath: plugins.path.join(socketDirectory, 'management', 'authority.sock'),
+        runtimeSocketPath: plugins.path.join(runtimeSocketDirectory, 'runtime.sock'),
+        runtimeSocketDirectory,
+    };
+};
+/** Explicit installer and lifecycle operations for a user-scoped systemd service. */
+export class AuthSwitchAuthorityService {
+    unit;
+    unitFile;
+    definition;
+    constructor(runtimeDirectory, unitDirectory) {
+        const packageRoot = plugins.path.dirname(plugins.path.dirname(plugins.fileURLToPath(import.meta.url)));
+        const options = { unitName: 'authswitch-authority.service', scope: 'user', runtimeDirectory };
+        this.unit = new plugins.smartdaemon.SystemdUnit(options);
+        this.unitFile = new plugins.smartdaemon.SystemdUnitFile({ ...options, unitDirectory });
+        this.definition = new plugins.smartdaemon.SystemdServiceDefinition({
+            unitName: options.unitName, scope: 'user', description: 'Authswitch account authority', executable: process.execPath,
+            args: [plugins.path.join(packageRoot, 'cli.js'), 'authority', 'daemon'],
+            workingDirectory: packageRoot, restart: 'on-failure', killMode: 'mixed', timeoutStopSeconds: 60,
+        });
+    }
+    async install() {
+        const previous = await this.unitFile.inspect();
+        const result = await this.unitFile.install(this.definition, previous?.sha256 ?? null);
+        return { changed: result.changed, masked: result.masked, sha256: result.record.sha256 };
+    }
+    inspect() { return this.unit.inspect(); }
+    enable() { return this.unit.enable(); }
+    start() { return this.unit.start(); }
+    stop() { return this.unit.stop(); }
+}
+export const runAuthSwitchAuthorityDaemon = async (paths = resolveAuthSwitchAuthorityPaths()) => {
+    const daemon = new AuthSwitchAuthorityDaemon({
+        dataDirectory: paths.dataDirectory,
+        socketPath: paths.databaseSocketPath,
+        authoritySocketPath: paths.authoritySocketPath,
+        runtimeSocketPath: paths.runtimeSocketPath,
+    });
+    await daemon.start();
+    await new Promise((resolve, reject) => {
+        let stopping = false;
+        const stop = () => {
+            if (stopping)
+                return;
+            stopping = true;
+            process.off('SIGINT', stop);
+            process.off('SIGTERM', stop);
+            void daemon.close().then(resolve, reject);
+        };
+        process.on('SIGINT', stop);
+        process.on('SIGTERM', stop);
+    });
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.codexmanaged.d.ts

@@ -0,0 +1,80 @@
+import * as plugins from './plugins.js';
+import type { AuthSwitchAuthorityBroker } from './classes.authoritybroker.js';
+export interface IAuthSwitchManagedCodexOptions {
+    /** Private runtime root; only the disposable control socket lives here. */
+    runtimeDirectory: string;
+    /** Caller-owned, durable native Codex state home, reserved to one account and scope by SmartData. */
+    codexHomeDirectory: string;
+    workspaceDirectory: string;
+    executable?: string;
+    /** The daemon is the sole owner of this binding and its capability. */
+    broker: AuthSwitchAuthorityBroker;
+    bindingId: string;
+    capability: string;
+    onNotification?: (notification: plugins.crossharness.ICodexAppServerNotification) => void;
+    onServerRequest?: (request: plugins.crossharness.ICodexAppServerRequest, reply: {
+        respond: (result: unknown) => boolean;
+        reject: (code: number, message: string) => boolean;
+    }) => void;
+    onUnavailable?: () => void;
+    onPreparedRun: (socketPath: string) => Promise<void>;
+    onChildSpawned: (pid: number, startedAt: string) => Promise<void>;
+}
+export interface IAuthSwitchCodexInteractiveCommand {
+    executable: string;
+    args: string[];
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+}
+/** Same-user process inspection: a unique private --listen socket is the pre-PID crash identity. */
+export declare const findManagedCodexProcess: (socketPath: string) => Promise<{
+    pid: number;
+    startedAt: string;
+} | null>;
+/** Daemon-owned Codex app-server. Only access tokens, never refresh grants, enter Codex. */
+export declare class AuthSwitchManagedCodex {
+    private readonly options;
+    private child?;
+    private childExited?;
+    private client?;
+    private runDirectory?;
+    private homeDirectory?;
+    private socketPath?;
+    private workspaceId?;
+    private grantedGeneration?;
+    private startPromise?;
+    private closePromise?;
+    private closed;
+    private ready;
+    constructor(options: IAuthSwitchManagedCodexOptions);
+    get isReady(): boolean;
+    private environment;
+    private requireVersion;
+    start(): Promise<void>;
+    private performStart;
+    private handleServerRequest;
+    /** The interactive CLI attaches to the owned app-server; the daemon remains its auth control peer. */
+    interactiveCommand(): IAuthSwitchCodexInteractiveCommand;
+    /** Native app-server thread/turn API for noninteractive consumers; notifications go to onNotification. */
+    startThread(options: {
+        approvalPolicy: 'never' | 'on-request';
+        model?: string;
+        signal?: AbortSignal;
+    }): Promise<string>;
+    resumeThread(threadId: string, options: {
+        approvalPolicy: 'never' | 'on-request';
+        model?: string;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    startTextTurn(text: string, options: {
+        approvalPolicy: 'never' | 'on-request';
+        model?: string;
+        threadId?: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        threadId: string;
+        turnId: string;
+    }>;
+    close(): Promise<void>;
+    private performClose;
+}

package/dist_ts/classes.codexmanaged.js

@@ -0,0 +1,343 @@
+import * as plugins from './plugins.js';
+import { commitinfo } from './00_commitinfo_data.js';
+const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const isAlive = (child) => child.exitCode === null && child.signalCode === null;
+const wait = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+/** Same-user process inspection: a unique private --listen socket is the pre-PID crash identity. */
+export const findManagedCodexProcess = async (socketPath) => {
+    if (process.platform === 'win32')
+        throw new Error('Managed Codex Unix socket process inspection is unavailable on Windows.');
+    const output = await new Promise((resolve, reject) => {
+        plugins.childProcess.execFile('ps', ['-ww', '-u', String(process.getuid?.()), '-o', 'pid=,lstart=,args='], { timeout: 5_000, maxBuffer: 8 * 1024 * 1024, env: { ...process.env, LC_ALL: 'C' } }, (error, stdout) => error ? reject(new Error('Managed Codex process inspection failed.')) : resolve(stdout));
+    });
+    const marker = `app-server --listen unix://${socketPath}`;
+    const matches = [];
+    for (const line of output.split('\n')) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length < 8)
+            continue;
+        const pid = Number(parts[0]);
+        const date = Date.parse(parts.slice(1, 6).join(' '));
+        const args = parts.slice(6).join(' ');
+        if (Number.isSafeInteger(pid) && pid > 0 && Number.isFinite(date) && args.includes(marker)) {
+            matches.push({ pid, startedAt: new Date(date).toISOString() });
+        }
+    }
+    if (matches.length > 1)
+        throw new Error('Multiple managed Codex processes claim one private socket.');
+    return matches[0] ?? null;
+};
+/** Daemon-owned Codex app-server. Only access tokens, never refresh grants, enter Codex. */
+export class AuthSwitchManagedCodex {
+    options;
+    child;
+    childExited;
+    client;
+    runDirectory;
+    homeDirectory;
+    socketPath;
+    workspaceId;
+    grantedGeneration;
+    startPromise;
+    closePromise;
+    closed = false;
+    ready = false;
+    constructor(options) {
+        this.options = options;
+        if (!plugins.path.isAbsolute(options.runtimeDirectory) || !plugins.path.isAbsolute(options.workspaceDirectory)
+            || !plugins.path.isAbsolute(options.codexHomeDirectory)) {
+            throw new Error('Managed Codex requires absolute runtime, home and workspace directories.');
+        }
+    }
+    get isReady() { return this.ready && this.client?.state === 'connected' && !this.closed; }
+    environment() {
+        const picked = {};
+        for (const key of ['PATH', 'HOME', 'USER', 'LOGNAME', 'LANG', 'LC_ALL', 'TERM', 'TMPDIR', 'XDG_RUNTIME_DIR']) {
+            if (process.env[key] !== undefined)
+                picked[key] = process.env[key];
+        }
+        picked.CODEX_HOME = this.homeDirectory;
+        return picked;
+    }
+    async requireVersion() {
+        const executable = this.options.executable ?? 'codex';
+        const output = await new Promise((resolve, reject) => {
+            plugins.childProcess.execFile(executable, ['--version'], { timeout: 5_000, maxBuffer: 4096,
+                windowsHide: true, env: this.environment() }, (error, stdout) => {
+                if (error)
+                    reject(new Error('Managed Codex version probe failed.'));
+                else
+                    resolve(stdout.trim());
+            });
+        });
+        if (output !== 'codex-cli 0.155.1')
+            throw new Error('Managed Codex requires verified codex-cli 0.155.1.');
+    }
+    start() {
+        if (this.closed || this.startPromise)
+            throw new Error('Managed Codex can start only once.');
+        this.startPromise = this.performStart();
+        return this.startPromise;
+    }
+    async performStart() {
+        try {
+            const root = this.options.runtimeDirectory;
+            await plugins.fs.promises.mkdir(root, { recursive: true, mode: 0o700 });
+            const rootStat = await plugins.fs.promises.lstat(root);
+            if (!rootStat.isDirectory() || rootStat.isSymbolicLink() || rootStat.uid !== process.getuid?.()) {
+                throw new Error('Managed Codex runtime directory is not private.');
+            }
+            await plugins.fs.promises.chmod(root, 0o700);
+            this.runDirectory = await plugins.fs.promises.mkdtemp(plugins.path.join(root, 'codex-'));
+            await plugins.fs.promises.chmod(this.runDirectory, 0o700);
+            this.homeDirectory = this.options.codexHomeDirectory;
+            this.socketPath = plugins.path.join(this.runDirectory, 'app.sock');
+            if (Buffer.byteLength(this.socketPath, 'utf8') > 100)
+                throw new Error('Managed Codex socket path is too long.');
+            const homeStat = await plugins.fs.promises.lstat(this.homeDirectory);
+            if (!homeStat.isDirectory() || homeStat.isSymbolicLink() || homeStat.uid !== process.getuid?.()
+                || (homeStat.mode & 0o077) !== 0 || await plugins.fs.promises.realpath(this.homeDirectory) !== this.homeDirectory) {
+                throw new Error('Managed Codex home is not a private owned directory.');
+            }
+            try {
+                await plugins.fs.promises.lstat(plugins.path.join(this.homeDirectory, 'auth.json'));
+                throw new Error('Managed Codex home contains a native credential file.');
+            }
+            catch (error) {
+                if (!isRecord(error) || error.code !== 'ENOENT')
+                    throw error;
+            }
+            await this.requireVersion();
+            if (this.closed)
+                throw new Error('Managed Codex startup was cancelled.');
+            const initial = await this.options.broker.resolveAccess(this.options.bindingId, this.options.capability, 60_000);
+            if (this.closed)
+                throw new Error('Managed Codex startup was cancelled.');
+            this.workspaceId = initial.accountId;
+            this.grantedGeneration = initial.grantGeneration;
+            await this.options.onPreparedRun(this.socketPath);
+            if (this.closed)
+                throw new Error('Managed Codex startup was cancelled.');
+            const child = plugins.childProcess.spawn(this.options.executable ?? 'codex', [
+                'app-server', '--listen', `unix://${this.socketPath}`, '--strict-config',
+                '-c', 'cli_auth_credentials_store="ephemeral"',
+            ], { cwd: this.options.workspaceDirectory, env: this.environment(), shell: false,
+                detached: process.platform !== 'win32', stdio: 'ignore', windowsHide: true });
+            this.child = child;
+            this.childExited = new Promise(resolve => {
+                child.once('error', () => resolve());
+                child.once('exit', () => resolve());
+            });
+            if (!child.pid)
+                throw new Error('Managed Codex app-server process has no PID.');
+            let observed = null;
+            for (let attempt = 0; attempt < 20 && !observed; attempt++) {
+                observed = await findManagedCodexProcess(this.socketPath);
+                if (!observed)
+                    await wait(25);
+            }
+            if (!observed || observed.pid !== child.pid)
+                throw new Error('Managed Codex app-server process identity could not be verified.');
+            await this.options.onChildSpawned(observed.pid, observed.startedAt);
+            const deadline = Date.now() + 10_000;
+            while (true) {
+                if (this.closed)
+                    throw new Error('Managed Codex startup was cancelled.');
+                if (!isAlive(child))
+                    throw new Error('Managed Codex app-server exited before accepting connections.');
+                try {
+                    if ((await plugins.fs.promises.lstat(this.socketPath)).isSocket())
+                        break;
+                }
+                catch (error) {
+                    if (!isRecord(error) || error.code !== 'ENOENT')
+                        throw error;
+                }
+                if (Date.now() >= deadline)
+                    throw new Error('Managed Codex app-server socket startup timed out.');
+                await wait(25);
+            }
+            const client = new plugins.crossharness.CodexAppServerClient({
+                transport: { type: 'unix', socketPath: this.socketPath },
+                clientInfo: { name: 'authswitch', title: 'Authswitch', version: commitinfo.version },
+                experimentalApi: true, handshakeTimeoutMs: 5_000, initializeTimeoutMs: 5_000,
+                onNotification: notification => this.options.onNotification?.(notification),
+                onServerRequest: request => { void this.handleServerRequest(request); },
+                onClose: () => {
+                    const wasReady = this.ready;
+                    this.ready = false;
+                    if (wasReady && !this.closed)
+                        this.options.onUnavailable?.();
+                },
+            });
+            this.client = client;
+            await client.connect();
+            if (client.serverVersion !== '0.155.1')
+                throw new Error('Managed Codex app-server version changed.');
+            const login = await client.request('account/login/start', {
+                type: 'chatgptAuthTokens', accessToken: initial.accessToken, chatgptAccountId: initial.accountId,
+            }, 5_000);
+            if (!isRecord(login) || login.type !== 'chatgptAuthTokens') {
+                throw new Error('Managed Codex external-token login was not acknowledged.');
+            }
+            if (this.closed)
+                throw new Error('Managed Codex startup was cancelled.');
+            this.ready = true;
+        }
+        catch (error) {
+            try {
+                await this.close();
+            }
+            catch (cleanupError) {
+                throw new AggregateError([error, cleanupError], 'Managed Codex startup and cleanup failed.');
+            }
+            throw error;
+        }
+    }
+    async handleServerRequest(request) {
+        const client = this.client;
+        if (!client || this.closed || !this.ready)
+            return;
+        if (request.method !== 'account/chatgptAuthTokens/refresh') {
+            if (!this.options.onServerRequest) {
+                client.rejectRequest(request.id, -32601, 'Managed Codex request requires an owner handler.');
+                return;
+            }
+            try {
+                this.options.onServerRequest(request, {
+                    respond: result => client.respond(request.id, result),
+                    reject: (code, message) => client.rejectRequest(request.id, code, message),
+                });
+            }
+            catch {
+                client.rejectRequest(request.id, -32603, 'Managed Codex owner request failed.');
+            }
+            return;
+        }
+        const prior = this.grantedGeneration;
+        const workspaceId = this.workspaceId;
+        const params = request.params;
+        if (params.reason !== 'unauthorized' || !workspaceId || prior === undefined
+            || (params.previousAccountId !== undefined && params.previousAccountId !== null
+                && params.previousAccountId !== workspaceId)) {
+            client.rejectRequest(request.id, -32602, 'Managed Codex account identity is invalid.');
+            return;
+        }
+        try {
+            const refreshed = await this.options.broker.resolveAccess(this.options.bindingId, this.options.capability, 60_000, prior);
+            if (this.closed || request.signal.aborted)
+                return;
+            if (refreshed.accountId !== workspaceId || refreshed.grantGeneration <= prior) {
+                client.rejectRequest(request.id, -32603, 'Managed Codex account refresh did not advance.');
+                return;
+            }
+            this.grantedGeneration = refreshed.grantGeneration;
+            client.respond(request.id, { accessToken: refreshed.accessToken,
+                chatgptAccountId: refreshed.accountId, chatgptPlanType: null });
+        }
+        catch {
+            if (!request.signal.aborted)
+                client.rejectRequest(request.id, -32603, 'Managed Codex account needs reauthentication.');
+        }
+    }
+    /** The interactive CLI attaches to the owned app-server; the daemon remains its auth control peer. */
+    interactiveCommand() {
+        if (!this.isReady || !this.socketPath)
+            throw new Error('Managed Codex is unavailable.');
+        return { executable: this.options.executable ?? 'codex', args: ['--remote', `unix://${this.socketPath}`],
+            cwd: this.options.workspaceDirectory, env: this.environment() };
+    }
+    /** Native app-server thread/turn API for noninteractive consumers; notifications go to onNotification. */
+    async startThread(options) {
+        if (!this.isReady || !this.client || !options || !['never', 'on-request'].includes(options.approvalPolicy)
+            || (options.model !== undefined && (typeof options.model !== 'string' || options.model.length > 128))) {
+            throw new Error('Managed Codex thread request is unavailable or invalid.');
+        }
+        const started = await this.client.request('thread/start', {
+            cwd: this.options.workspaceDirectory, approvalPolicy: options.approvalPolicy,
+            ...(options.model ? { model: options.model } : {}),
+        }, 30_000, options.signal);
+        if (!isRecord(started) || !isRecord(started.thread) || typeof started.thread.id !== 'string') {
+            throw new Error('Managed Codex returned an invalid thread.');
+        }
+        return started.thread.id;
+    }
+    async resumeThread(threadId, options) {
+        if (!this.isReady || !this.client || typeof threadId !== 'string' || !threadId || threadId.length > 256
+            || !options || !['never', 'on-request'].includes(options.approvalPolicy)
+            || (options.model !== undefined && (typeof options.model !== 'string' || options.model.length > 128))) {
+            throw new Error('Managed Codex resume request is unavailable or invalid.');
+        }
+        const resumed = await this.client.request('thread/resume', { threadId,
+            cwd: this.options.workspaceDirectory, approvalPolicy: options.approvalPolicy,
+            ...(options.model ? { model: options.model } : {}),
+        }, 30_000, options.signal);
+        if (!isRecord(resumed) || !isRecord(resumed.thread) || resumed.thread.id !== threadId) {
+            throw new Error('Managed Codex could not resume the requested thread from its assigned home.');
+        }
+    }
+    async startTextTurn(text, options) {
+        if (!this.isReady || !this.client || typeof text !== 'string' || !text.trim() || text.length > 1_000_000
+            || !options || !['never', 'on-request'].includes(options.approvalPolicy)
+            || (options.model !== undefined && (typeof options.model !== 'string' || options.model.length > 128))
+            || (options.threadId !== undefined && (typeof options.threadId !== 'string' || options.threadId.length > 256))) {
+            throw new Error('Managed Codex turn request is unavailable or invalid.');
+        }
+        let threadId = options.threadId;
+        if (threadId) {
+            await this.resumeThread(threadId, options);
+        }
+        else {
+            threadId = await this.startThread(options);
+        }
+        const turn = await this.client.request('turn/start', { threadId,
+            input: [{ type: 'text', text, text_elements: [] }],
+            approvalPolicy: options.approvalPolicy,
+            ...(options.model ? { model: options.model } : {}),
+        }, 30_000, options.signal);
+        if (!isRecord(turn) || !isRecord(turn.turn) || typeof turn.turn.id !== 'string') {
+            throw new Error('Managed Codex returned an invalid turn.');
+        }
+        return { threadId, turnId: turn.turn.id };
+    }
+    close() {
+        if (this.closePromise)
+            return this.closePromise;
+        const wasReady = this.ready;
+        this.closed = true;
+        this.ready = false;
+        this.closePromise = this.performClose();
+        if (wasReady)
+            this.options.onUnavailable?.();
+        return this.closePromise;
+    }
+    async performClose() {
+        this.client?.close('Managed Codex stopped.');
+        const child = this.child;
+        if (child && isAlive(child) && child.pid) {
+            try {
+                process.kill(process.platform === 'win32' ? child.pid : -child.pid, 'SIGTERM');
+            }
+            catch (error) {
+                if (!isRecord(error) || error.code !== 'ESRCH')
+                    throw error;
+            }
+            await Promise.race([this.childExited, wait(3_000)]);
+            if (isAlive(child)) {
+                try {
+                    process.kill(process.platform === 'win32' ? child.pid : -child.pid, 'SIGKILL');
+                }
+                catch (error) {
+                    if (!isRecord(error) || error.code !== 'ESRCH')
+                        throw error;
+                }
+                await Promise.race([this.childExited, wait(3_000)]);
+            }
+            if (isAlive(child))
+                throw new Error('Managed Codex process did not stop.');
+        }
+        if (this.runDirectory)
+            await plugins.fs.promises.rm(this.runDirectory, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.codexmanaged.js","sourceRoot":"","sources":["../ts/classes.codexmanaged.ts"],"names":[],"mappings":"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"}

package/dist_ts/index.d.ts

@@ -23,4 +23,7 @@ export * from './classes.service.js';
 export * from './classes.watch.js';
 export * from './classes.watchlock.js';
 export * from './watchpolicy.js';
+export * from './classes.authorityclient.js';
+export * from './classes.authoritydaemon.js';
+export * from './classes.authorityservice.js';
 export declare const runCli: (argvArg?: string[]) => Promise<void>;