@modelprofile.com/authswitch 8.2.0 → 9.1.0

package/dist_ts/codexcontract.d.ts

@@ -0,0 +1,30 @@
+/**
+ * What managed Codex needs from the Codex it starts, checked at every start instead of pinning one release.
+ *
+ * The floor is `@modelprofile.com/mcp-crossharness`'s: 0.156.0 is the first release that publishes the
+ * `--listen unix://` alias managed Codex connects through, and every other surface it uses is older. Above
+ * the floor nothing is assumed. Codex describes its own app-server protocol (`app-server
+ * generate-json-schema`), and that description must still offer every request managed Codex sends and the one
+ * it answers, with the fields it sends. The external-token login in particular is marked unstable upstream,
+ * so a release that drops or reshapes it is refused at start, by name, rather than failing a session later
+ * -- the refresh callback, for one, would otherwise only be missed at the first expired token.
+ */
+export declare const MANAGED_CODEX_MINIMUM_VERSION = "0.156.0";
+/** The verified release, exactly as `codex --version` printed it; the app-server must report the same. */
+export interface IManagedCodexContract {
+    version: string;
+}
+export interface IManagedCodexContractOptions {
+    executable: string;
+    env: NodeJS.ProcessEnv;
+    /** A private, existing directory; the schema is written below it and removed before this returns. */
+    scratchDirectory: string;
+}
+/**
+ * Proves, before anything is recorded or started, that `executable` is a Codex managed Codex can run: its
+ * version is the floor or newer, and its own protocol description offers every surface managed Codex uses.
+ * Every refusal is `codex_unsupported` and names the version or the missing surface.
+ */
+export declare const verifyManagedCodexContract: (options: IManagedCodexContractOptions) => Promise<IManagedCodexContract>;
+/** The app-server a start connected to must be the release that was verified; Codex can replace itself. */
+export declare const requireVerifiedCodexServer: (contract: IManagedCodexContract, serverVersion: string | undefined) => void;

package/dist_ts/codexcontract.js

@@ -0,0 +1,174 @@
+import * as plugins from './plugins.js';
+import { AuthSwitchRefusal } from './authority-contract.js';
+/**
+ * What managed Codex needs from the Codex it starts, checked at every start instead of pinning one release.
+ *
+ * The floor is `@modelprofile.com/mcp-crossharness`'s: 0.156.0 is the first release that publishes the
+ * `--listen unix://` alias managed Codex connects through, and every other surface it uses is older. Above
+ * the floor nothing is assumed. Codex describes its own app-server protocol (`app-server
+ * generate-json-schema`), and that description must still offer every request managed Codex sends and the one
+ * it answers, with the fields it sends. The external-token login in particular is marked unstable upstream,
+ * so a release that drops or reshapes it is refused at start, by name, rather than failing a session later
+ * -- the refresh callback, for one, would otherwise only be missed at the first expired token.
+ */
+export const MANAGED_CODEX_MINIMUM_VERSION = plugins.crossharness.CODEX_UNIX_SOCKET_MINIMUM_VERSION;
+const supportInstruction = 'Managed Codex needs an authswitch release that supports this Codex, or a Codex '
+    + 'release that still offers it.';
+const maximumSchemaFileBytes = 16 * 1024 * 1024;
+const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const strings = (value) => Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+const run = (executable, args, env, timeoutMs) => new Promise(resolve => {
+    plugins.childProcess.execFile(executable, args, { timeout: timeoutMs, maxBuffer: 64 * 1024,
+        windowsHide: true, env }, (error, stdout) => resolve(error ? null : stdout));
+});
+/** Follows local `#/definitions/<name>` references; any other reference resolves to nothing. */
+const resolve = (root, node) => {
+    let current = node;
+    for (let depth = 0; depth < 8 && isRecord(current); depth++) {
+        const ref = current.$ref;
+        if (typeof ref !== 'string')
+            return current;
+        const match = /^#\/definitions\/([^/]+)$/.exec(ref);
+        const definitions = root.definitions;
+        current = match && isRecord(definitions) ? definitions[match[1]] : undefined;
+    }
+    return null;
+};
+/** The schema alternatives a node offers: itself, or each member of its `oneOf`/`anyOf`. */
+const alternatives = (root, node) => {
+    const resolved = resolve(root, node);
+    if (!resolved)
+        return [];
+    const members = [...(Array.isArray(resolved.oneOf) ? resolved.oneOf : []),
+        ...(Array.isArray(resolved.anyOf) ? resolved.anyOf : [])];
+    return members.length ? members.flatMap(member => alternatives(root, member)) : [resolved];
+};
+/** Every string a node accepts as an enum value, through references and alternatives. */
+const enumValues = (root, node) => alternatives(root, node).flatMap(member => strings(member.enum));
+const acceptsNull = (root, node) => alternatives(root, node)
+    .some(member => member.type === 'null' || strings(member.type).includes('null'));
+/** The object alternative whose `discriminator` property is exactly `value`, or the node itself. */
+const variant = (root, node, discriminator, value) => alternatives(root, node).find(member => {
+    const properties = member.properties;
+    const tag = isRecord(properties) ? resolve(root, properties[discriminator]) : null;
+    return tag !== null && strings(tag.enum).length === 1 && strings(tag.enum)[0] === value;
+}) ?? null;
+/** Declares every field managed Codex sends, and requires none it does not send. */
+const acceptsFields = (object, sent) => {
+    if (!object || !isRecord(object.properties))
+        return false;
+    const properties = object.properties;
+    return sent.every(field => Object.hasOwn(properties, field))
+        && strings(object.required).every(field => sent.includes(field));
+};
+const property = (object, name) => object && isRecord(object.properties) ? object.properties[name] : undefined;
+const requestMethods = (root) => alternatives(root, root)
+    .flatMap(member => isRecord(member.properties) ? strings(resolve(root, member.properties.method)?.enum) : []);
+/**
+ * Each surface managed Codex uses, and whether a protocol description still offers it. Reads nothing but
+ * the schema files named here, so a release that moves a file fails the element that needs it.
+ */
+const elements = [
+    {
+        name: 'the requests account/login/start, thread/start, thread/resume and turn/start',
+        files: ['ClientRequest.json'],
+        offered: ([client]) => ['account/login/start', 'thread/start', 'thread/resume', 'turn/start']
+            .every(method => requestMethods(client).includes(method)),
+    },
+    {
+        name: 'the external ChatGPT token login (account/login/start chatgptAuthTokens)',
+        files: ['v2/LoginAccountParams.json', 'v2/LoginAccountResponse.json'],
+        offered: ([params, response]) => acceptsFields(variant(params, params, 'type', 'chatgptAuthTokens'), ['type', 'accessToken', 'chatgptAccountId'])
+            && variant(response, response, 'type', 'chatgptAuthTokens') !== null,
+    },
+    {
+        name: 'the token refresh callback (account/chatgptAuthTokens/refresh)',
+        files: ['ServerRequest.json', 'ChatgptAuthTokensRefreshParams.json', 'ChatgptAuthTokensRefreshResponse.json'],
+        offered: ([server, params, response]) => requestMethods(server).includes('account/chatgptAuthTokens/refresh')
+            && enumValues(params, property(params, 'reason')).includes('unauthorized')
+            && acceptsFields(response, ['accessToken', 'chatgptAccountId', 'chatgptPlanType'])
+            && acceptsNull(response, property(response, 'chatgptPlanType')),
+    },
+    {
+        name: 'thread/start and thread/resume with a working directory, approval policy and model',
+        files: ['v2/ThreadStartParams.json', 'v2/ThreadResumeParams.json'],
+        offered: ([start, resume]) => acceptsFields(start, ['cwd', 'approvalPolicy', 'model'])
+            && acceptsFields(resume, ['threadId', 'cwd', 'approvalPolicy', 'model'])
+            && [start, resume].every(schema => ['never', 'on-request']
+                .every(policy => enumValues(schema, property(schema, 'approvalPolicy')).includes(policy))),
+    },
+    {
+        name: 'turn/start with text input, approval policy and model',
+        files: ['v2/TurnStartParams.json'],
+        offered: ([turn]) => {
+            if (!acceptsFields(turn, ['threadId', 'input', 'approvalPolicy', 'model']))
+                return false;
+            const input = resolve(turn, property(turn, 'input'));
+            return acceptsFields(variant(turn, input?.items, 'type', 'text'), ['type', 'text', 'text_elements'])
+                && ['never', 'on-request']
+                    .every(policy => enumValues(turn, property(turn, 'approvalPolicy')).includes(policy));
+        },
+    },
+];
+const readSchema = async (directory, relative) => {
+    try {
+        const file = plugins.path.join(directory, ...relative.split('/'));
+        const stat = await plugins.fs.promises.lstat(file);
+        if (!stat.isFile() || stat.size > maximumSchemaFileBytes)
+            return null;
+        const value = JSON.parse(await plugins.fs.promises.readFile(file, 'utf8'));
+        return isRecord(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+};
+const refuse = (instruction) => { throw new AuthSwitchRefusal('codex_unsupported', instruction); };
+/**
+ * Proves, before anything is recorded or started, that `executable` is a Codex managed Codex can run: its
+ * version is the floor or newer, and its own protocol description offers every surface managed Codex uses.
+ * Every refusal is `codex_unsupported` and names the version or the missing surface.
+ */
+export const verifyManagedCodexContract = async (options) => {
+    const printed = await run(options.executable, ['--version'], options.env, 5_000);
+    const version = /^codex-cli (\S+)$/.exec(printed?.trim() ?? '')?.[1] ?? null;
+    try {
+        plugins.crossharness.requireCodexVersion(version, MANAGED_CODEX_MINIMUM_VERSION);
+    }
+    catch (error) {
+        if (!(error instanceof plugins.crossharness.CodexVersionUnsupportedError))
+            throw error;
+        refuse(error.reason === 'unreadable'
+            ? `This Codex did not report a readable version. Install Codex ${MANAGED_CODEX_MINIMUM_VERSION} or newer.`
+            : `Codex ${version} is older than ${MANAGED_CODEX_MINIMUM_VERSION}, the first release managed Codex runs. `
+                + 'Update Codex, then start managed Codex again.');
+    }
+    const verified = version;
+    const directory = await plugins.fs.promises.mkdtemp(plugins.path.join(options.scratchDirectory, 'schema-'));
+    try {
+        if (await run(options.executable, ['app-server', 'generate-json-schema', '--out', directory], options.env, 30_000) === null) {
+            refuse(`Codex ${verified} did not describe its app-server protocol, so managed Codex cannot check it. `
+                + supportInstruction);
+        }
+        for (const element of elements) {
+            const schemas = await Promise.all(element.files.map(file => readSchema(directory, file)));
+            if (schemas.some(schema => schema === null) || !element.offered(schemas)) {
+                refuse(`Codex ${verified} does not offer ${element.name}. ${supportInstruction}`);
+            }
+        }
+    }
+    finally {
+        await plugins.fs.promises.rm(directory, { recursive: true, force: true });
+    }
+    return { version: verified };
+};
+/** The app-server a start connected to must be the release that was verified; Codex can replace itself. */
+export const requireVerifiedCodexServer = (contract, serverVersion) => {
+    if (serverVersion === contract.version)
+        return;
+    const reported = serverVersion !== undefined && plugins.crossharness.parseCodexVersion(serverVersion)
+        ? `Codex ${serverVersion}` : 'an unreadable version';
+    refuse(`The Codex app-server reports ${reported}, not the checked Codex ${contract.version}; Codex was `
+        + 'replaced while managed Codex started. Start managed Codex again.');
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"codexcontract.js","sourceRoot":"","sources":["../ts/codexcontract.ts"],"names":[],"mappings":"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"}

package/dist_ts/ts_migration/0004_container_setup_owner.d.ts

@@ -0,0 +1,12 @@
+import * as plugins from '../plugins.js';
+/**
+ * Refuses a store holding a Claude container setup grant that a native tool would own.
+ *
+ * Until 9.1.0 the grant record allowed a container setup grant to be owned by `legacy_native`. No release
+ * ever wrote one: the importer creates only Claude host, OpenCode and managed OpenAI grants, and no route
+ * creates a container setup grant at all. 9.1.0 narrows the record to what the authority means by it -- the
+ * authority holds that token, or nobody does -- so a row outside that would fail every read of its account.
+ * Such a row was never written by this package, and nothing about it can be repaired by guessing, so the
+ * store is refused before the first write and left exactly as it was.
+ */
+export declare const refuseNativeContainerSetupOwners: (db: plugins.nosqldb.SmartdataDb) => Promise<void>;

package/dist_ts/ts_migration/0004_container_setup_owner.js

@@ -0,0 +1,19 @@
+import * as plugins from '../plugins.js';
+/**
+ * Refuses a store holding a Claude container setup grant that a native tool would own.
+ *
+ * Until 9.1.0 the grant record allowed a container setup grant to be owned by `legacy_native`. No release
+ * ever wrote one: the importer creates only Claude host, OpenCode and managed OpenAI grants, and no route
+ * creates a container setup grant at all. 9.1.0 narrows the record to what the authority means by it -- the
+ * authority holds that token, or nobody does -- so a row outside that would fail every read of its account.
+ * Such a row was never written by this package, and nothing about it can be repaired by guessing, so the
+ * store is refused before the first write and left exactly as it was.
+ */
+export const refuseNativeContainerSetupOwners = async (db) => {
+    const grants = db.mongoDb.collection('authswitch_authority_grants');
+    if (await grants.findOne({ purpose: 'claude_container_setup', owner: { $nin: ['daemon', 'none'] } })) {
+        throw new Error('Authswitch authority store holds a Claude container setup login owned by a native tool, '
+            + 'which no release could have recorded; set the store aside and sign in to each account again.');
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDAwNF9jb250YWluZXJfc2V0dXBfb3duZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy90c19taWdyYXRpb24vMDAwNF9jb250YWluZXJfc2V0dXBfb3duZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxlQUFlLENBQUM7QUFFekM7Ozs7Ozs7OztHQVNHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sZ0NBQWdDLEdBQUcsS0FBSyxFQUFFLEVBQStCLEVBQWlCLEVBQUU7SUFDdkcsTUFBTSxNQUFNLEdBQUcsRUFBRSxDQUFDLE9BQU8sQ0FBQyxVQUFVLENBQUMsNkJBQTZCLENBQUMsQ0FBQztJQUNwRSxJQUFJLE1BQU0sTUFBTSxDQUFDLE9BQU8sQ0FBQyxFQUFFLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxLQUFLLEVBQUUsRUFBRSxJQUFJLEVBQUUsQ0FBQyxRQUFRLEVBQUUsTUFBTSxDQUFDLEVBQUUsRUFBRSxDQUFDLEVBQUUsQ0FBQztRQUNyRyxNQUFNLElBQUksS0FBSyxDQUFDLDBGQUEwRjtjQUN0Ryw4RkFBOEYsQ0FBQyxDQUFDO0lBQ3RHLENBQUM7QUFDSCxDQUFDLENBQUMifQ==

package/dist_ts/ts_migration/index.js

@@ -2,6 +2,7 @@ import * as plugins from '../plugins.js';
 import { migrateAuthorityMeta } from './0001_authority_meta.js';
 import { removeAuthorityBackupRecords } from './0002_remove_backup_records.js';
 import { addClaudeHandoffProofFailure } from './0003_claude_handoff_proof.js';
+import { refuseNativeContainerSetupOwners } from './0004_container_setup_owner.js';
 /**
  * Runs on every start of an existing store, in this fixed order. Each module recognises the published shapes it
  * upgrades and leaves the current shape untouched, so the stored document itself records completion.
@@ -10,5 +11,6 @@ export const runAuthorityMigrations = async (db) => {
     await migrateAuthorityMeta(db);
     await removeAuthorityBackupRecords(db);
     await addClaudeHandoffProofFailure(db);
+    await refuseNativeContainerSetupOwners(db);
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy90c19taWdyYXRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDaEUsT0FBTyxFQUFFLDRCQUE0QixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDL0UsT0FBTyxFQUFFLDRCQUE0QixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFFOUU7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sc0JBQXNCLEdBQUcsS0FBSyxFQUFFLEVBQStCLEVBQWlCLEVBQUU7SUFDN0YsTUFBTSxvQkFBb0IsQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUMvQixNQUFNLDRCQUE0QixDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ3ZDLE1BQU0sNEJBQTRCLENBQUMsRUFBRSxDQUFDLENBQUM7QUFDekMsQ0FBQyxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy90c19taWdyYXRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDaEUsT0FBTyxFQUFFLDRCQUE0QixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDL0UsT0FBTyxFQUFFLDRCQUE0QixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDOUUsT0FBTyxFQUFFLGdDQUFnQyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFFbkY7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sc0JBQXNCLEdBQUcsS0FBSyxFQUFFLEVBQStCLEVBQWlCLEVBQUU7SUFDN0YsTUFBTSxvQkFBb0IsQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUMvQixNQUFNLDRCQUE0QixDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ3ZDLE1BQU0sNEJBQTRCLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDdkMsTUFBTSxnQ0FBZ0MsQ0FBQyxFQUFFLENBQUMsQ0FBQztBQUM3QyxDQUFDLENBQUMifQ==

package/dist_ts/ts_migration/legacysources/authswitchstores.js

@@ -189,7 +189,10 @@ export const readAuthSwitchStores = (locations) => {
     catch (error) {
         if (error.code === 'ENOENT')
             return { sources, problems };
-        return { sources, problems: [`${locations.authSwitchHome} could not be listed`] };
+        // The store is named by what it is, never by where it is: this report goes to a CLI and to a backend,
+        // and the location of a credential store is not something either of them may be told. Everything
+        // below names an entry inside the store instead, which is what the owner needs to find it.
+        return { sources, problems: ['the authswitch store could not be listed'] };
     }
     for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
         const path = plugins.path.join(locations.authSwitchHome, entry.name);
@@ -241,4 +244,4 @@ export const readAuthSwitchStores = (locations) => {
     }
     return { sources, problems };
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authswitchstores.js","sourceRoot":"","sources":["../../../ts/ts_migration/legacysources/authswitchstores.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authswitchstores.js","sourceRoot":"","sources":["../../../ts/ts_migration/legacysources/authswitchstores.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelprofile.com/authswitch",
-  "version": "8.2.0",
+  "version": "9.1.0",
   "private": false,
   "description": "Manage Codex, OpenCode and Claude Code accounts with guided switching and live usage status",
   "main": "dist_ts/index.js",
@@ -53,10 +53,10 @@
     "authswitch": "./cli.js"
   },
   "devDependencies": {
-    "@git.zone/tsbuild": "^4.5.0",
-    "@git.zone/tsrun": "^2.0.6",
-    "@git.zone/tstest": "^6.1.1",
-    "@types/node": "26.5.1",
+    "@git.zone/tsbuild": "^5.0.0",
+    "@git.zone/tsrun": "^3.0.0",
+    "@git.zone/tstest": "^6.3.0",
+    "@types/node": "26.6.2",
     "@types/ws": "8.18.1",
     "esbuild": "^0.28.2",
     "ws": "8.21.2"
@@ -64,13 +64,13 @@
   "dependencies": {
     "@api.global/typedrequest": "8.1.0",
     "@api.global/typedrequest-interfaces": "7.1.0",
-    "@lossless.org/client": "1.2.0",
-    "@lossless.org/nosqldb": "10.3.0",
-    "@modelprofile.com/flexharness-models": "^8.0.0",
-    "@modelprofile.com/flexharness-providers": "^8.0.0",
-    "@modelprofile.com/mcp-crossharness": "5.4.0",
+    "@lossless.org/client": "1.6.0",
+    "@lossless.org/nosqldb": "10.6.0",
+    "@modelprofile.com/flexharness-models": "^9.0.0",
+    "@modelprofile.com/flexharness-providers": "^9.0.0",
+    "@modelprofile.com/mcp-crossharness": "5.6.0",
     "@push.rocks/smartconsole": "^1.3.0",
-    "@push.rocks/smartdaemon": "2.7.0",
+    "@push.rocks/smartdaemon": "2.7.2",
     "@push.rocks/smartsecret": "1.8.0",
     "@types/proper-lockfile": "^4.1.4",
     "proper-lockfile": "^4.1.2"