@astrosheep/square 0.3.4 → 0.3.5

package/dist/harness-codex.js

@@ -0,0 +1,653 @@
+import { spawn, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { SQUARE_IDENTITY } from './identity.js';
+import { reconcileInstall, reconcileUninstall, staleManagedRegistrations, } from './harness-lifecycle.js';
+export const CODEX_HOOK_COMMAND = SQUARE_IDENTITY.hookCommand;
+export const SQUARE_CODEX_MARKER = SQUARE_IDENTITY.hookMarker;
+export const CODEX_PLUGIN_ID = SQUARE_IDENTITY.pluginId;
+export const CODEX_MARKETPLACE_NAME = SQUARE_IDENTITY.marketplaceName;
+export function codexMarketplaceRoot(homeDir) {
+    return path.join(homeDir, '.square', 'codex', 'marketplaces', CODEX_MARKETPLACE_NAME);
+}
+export function codexPluginRoot(homeDir) {
+    return path.join(codexMarketplaceRoot(homeDir), 'plugins', SQUARE_IDENTITY.pluginName);
+}
+export function codexPluginHooksPath(homeDir) {
+    return path.join(codexPluginRoot(homeDir), 'hooks', 'hooks.json');
+}
+function codexHome(homeDir) {
+    return process.env.CODEX_HOME?.trim() || path.join(homeDir, '.codex');
+}
+export function codexHomeHooksPath(homeDir) {
+    return path.join(codexHome(homeDir), 'hooks.json');
+}
+export function codexConfigPath(homeDir) {
+    return path.join(codexHome(homeDir), 'config.toml');
+}
+function managedHooksPath(homeDir) {
+    return path.join(homeDir, '.square', 'codex', 'hooks.json');
+}
+function sectionRange(lines, section) {
+    const escaped = section.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const header = new RegExp(`^\\s*\\[${escaped}\\]\\s*(?:#.*)?$`);
+    const start = lines.findIndex((line) => header.test(line));
+    if (start < 0)
+        return undefined;
+    const next = lines.findIndex((line, index) => index > start && /^\s*\[[^\]]+\]\s*(?:#.*)?$/.test(line));
+    return { start, end: next < 0 ? lines.length : next };
+}
+export function upsertTomlSectionKey(text, section, key, value) {
+    const lines = text === '' ? [] : text.replace(/\n$/, '').split('\n');
+    const range = sectionRange(lines, section);
+    const assignment = `${key} = ${value}`;
+    if (range === undefined) {
+        if (lines.length > 0 && lines.at(-1) !== '')
+            lines.push('');
+        lines.push(`[${section}]`, assignment);
+        return `${lines.join('\n')}\n`;
+    }
+    const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const keyPattern = new RegExp(`^\\s*${escaped}\\s*=`);
+    const existing = lines.findIndex((line, index) => index > range.start && index < range.end && keyPattern.test(line));
+    if (existing < 0)
+        lines.splice(range.end, 0, assignment);
+    else
+        lines[existing] = assignment;
+    return `${lines.join('\n')}\n`;
+}
+function writeAtomic(filePath, contents) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const temporary = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(temporary, contents, { mode: 0o600 });
+    fs.renameSync(temporary, filePath);
+}
+function writeJsonAtomic(filePath, value) {
+    writeAtomic(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+function backup(filePath) {
+    const backupPath = `${filePath}.square-bak`;
+    if (fs.existsSync(filePath) && !fs.existsSync(backupPath))
+        fs.copyFileSync(filePath, backupPath);
+}
+function requireSuccess(result, operation) {
+    if (result.status === 0)
+        return;
+    const detail = result.stderr.trim() || result.stdout.trim() || `exit ${result.status}`;
+    throw new Error(`Codex ${operation} failed: ${detail}`);
+}
+function runCodex(homeDir, args) {
+    const result = spawnSync(process.env.SQUARE_CODEX_BIN || 'codex', args, {
+        encoding: 'utf8',
+        env: {
+            ...process.env,
+            HOME: homeDir,
+            CODEX_HOME: codexHome(homeDir),
+        },
+        maxBuffer: 4 * 1024 * 1024,
+        timeout: 30_000,
+    });
+    if (result.error)
+        throw result.error;
+    return {
+        status: result.status ?? 1,
+        stdout: result.stdout || '',
+        stderr: result.stderr || '',
+    };
+}
+function packageAsset(relative) {
+    return fileURLToPath(new URL(relative, import.meta.url));
+}
+function isSquareGroup(group) {
+    if (group === null || typeof group !== 'object')
+        return false;
+    const hooks = group.hooks;
+    if (!Array.isArray(hooks))
+        return false;
+    return hooks.some((hook) => {
+        if (hook === null || typeof hook !== 'object')
+            return false;
+        const command = hook.command;
+        const statusMessage = hook.statusMessage;
+        return command === CODEX_HOOK_COMMAND || statusMessage === SQUARE_CODEX_MARKER;
+    });
+}
+export function stripSquareCodexHooks(filePath) {
+    if (!fs.existsSync(filePath))
+        return false;
+    const root = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    if (root === null || typeof root !== 'object' || root.hooks === undefined || typeof root.hooks !== 'object') {
+        return false;
+    }
+    let changed = false;
+    for (const [event, groups] of Object.entries(root.hooks)) {
+        if (!Array.isArray(groups))
+            continue;
+        const remaining = groups.filter((group) => !isSquareGroup(group));
+        if (remaining.length === groups.length)
+            continue;
+        changed = true;
+        if (remaining.length === 0)
+            delete root.hooks[event];
+        else
+            root.hooks[event] = remaining;
+    }
+    if (!changed)
+        return false;
+    if (Object.keys(root.hooks).length === 0)
+        fs.rmSync(filePath, { force: true });
+    else
+        writeJsonAtomic(filePath, root);
+    return true;
+}
+function codexMarketplaceDocument() {
+    return {
+        name: CODEX_MARKETPLACE_NAME,
+        interface: { displayName: SQUARE_IDENTITY.productName },
+        plugins: [
+            {
+                name: SQUARE_IDENTITY.pluginName,
+                source: { source: 'local', path: './plugins/square' },
+                policy: { installation: 'AVAILABLE', authentication: 'ON_USE' },
+                category: 'Developer Tools',
+            },
+        ],
+    };
+}
+function stageCodexBundle(_homeDir, marketplaceRoot) {
+    const token = `${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}`;
+    const stage = `${marketplaceRoot}.${token}.stage`;
+    const backupPath = `${marketplaceRoot}.${token}.previous`;
+    const pluginRoot = path.join(stage, 'plugins', SQUARE_IDENTITY.pluginName);
+    fs.mkdirSync(path.dirname(marketplaceRoot), { recursive: true });
+    try {
+        fs.cpSync(packageAsset('../codex-plugin/'), pluginRoot, { recursive: true });
+        const skill = path.join(pluginRoot, 'skills', 'square', 'SKILL.md');
+        fs.mkdirSync(path.dirname(skill), { recursive: true });
+        fs.copyFileSync(path.join(packageAsset('../skills/square/'), 'SKILL.md'), skill);
+        writeJsonAtomic(path.join(stage, '.agents', 'plugins', 'marketplace.json'), codexMarketplaceDocument());
+        if (fs.existsSync(marketplaceRoot))
+            fs.renameSync(marketplaceRoot, backupPath);
+        fs.renameSync(stage, marketplaceRoot);
+    }
+    catch (error) {
+        try {
+            fs.rmSync(stage, { recursive: true, force: true });
+        }
+        catch {
+            // Keep the source error; staging cleanup is best effort.
+        }
+        if (fs.existsSync(backupPath) && !fs.existsSync(marketplaceRoot)) {
+            fs.renameSync(backupPath, marketplaceRoot);
+        }
+        throw error;
+    }
+    return {
+        desired: {
+            marketplaceName: CODEX_MARKETPLACE_NAME,
+            marketplaceRoot,
+            pluginId: CODEX_PLUGIN_ID,
+        },
+        rollback() {
+            fs.rmSync(marketplaceRoot, { recursive: true, force: true });
+            if (fs.existsSync(backupPath))
+                fs.renameSync(backupPath, marketplaceRoot);
+        },
+        finalize() {
+            fs.rmSync(backupPath, { recursive: true, force: true });
+        },
+    };
+}
+function parseInventory(stdout) {
+    let payload;
+    try {
+        payload = JSON.parse(stdout);
+    }
+    catch {
+        throw new Error('Codex marketplace inventory returned invalid JSON.');
+    }
+    if (payload === null || typeof payload !== 'object' || !Array.isArray(payload.marketplaces)) {
+        throw new Error('Codex marketplace inventory is malformed.');
+    }
+    const marketplaces = payload.marketplaces.map(parseMarketplaceRegistration);
+    return { marketplaces };
+}
+function parseMarketplaceRegistration(value) {
+    if (value === null || typeof value !== 'object') {
+        throw new Error('Codex marketplace inventory entry is invalid.');
+    }
+    const entry = value;
+    if (typeof entry.name !== 'string' || typeof entry.root !== 'string') {
+        throw new Error('Codex marketplace inventory entry is malformed.');
+    }
+    const source = entry.marketplaceSource;
+    if (source === undefined)
+        return { name: entry.name, source: entry.root, local: false };
+    if (source === null || typeof source !== 'object')
+        throw new Error('Codex marketplace source is malformed.');
+    const marketplaceSource = source;
+    if (typeof marketplaceSource.sourceType !== 'string') {
+        throw new Error('Codex marketplace source is malformed.');
+    }
+    if (marketplaceSource.sourceType !== 'local') {
+        const stableSource = typeof marketplaceSource.source === 'string'
+            ? marketplaceSource.source
+            : entry.root;
+        return {
+            name: entry.name,
+            source: `${marketplaceSource.sourceType}:${stableSource}`,
+            local: false,
+        };
+    }
+    if (typeof marketplaceSource.source !== 'string') {
+        throw new Error('Codex local marketplace inventory entry is malformed.');
+    }
+    return { name: entry.name, source: marketplaceSource.source, local: true };
+}
+function pluginHooksFromList(result) {
+    const entries = result?.data;
+    if (!Array.isArray(entries))
+        throw new Error('Codex hooks/list returned invalid data.');
+    const hooks = [];
+    for (const entry of entries) {
+        if (!Array.isArray(entry.hooks))
+            continue;
+        for (const value of entry.hooks) {
+            if (value === null || typeof value !== 'object')
+                continue;
+            const hook = value;
+            if (hook.pluginId !== CODEX_PLUGIN_ID)
+                continue;
+            if (typeof hook.key !== 'string' ||
+                typeof hook.eventName !== 'string' ||
+                typeof hook.enabled !== 'boolean' ||
+                typeof hook.currentHash !== 'string' ||
+                typeof hook.trustStatus !== 'string') {
+                throw new Error('Codex hooks/list returned an invalid Square hook.');
+            }
+            hooks.push({
+                key: hook.key,
+                eventName: hook.eventName,
+                pluginId: CODEX_PLUGIN_ID,
+                enabled: hook.enabled,
+                currentHash: hook.currentHash,
+                trustStatus: hook.trustStatus,
+            });
+        }
+    }
+    return hooks;
+}
+function expectedHooks(hooks) {
+    if (hooks.length !== 2 || hooks.some((hook) => !hook.enabled))
+        return false;
+    const events = hooks.map((hook) => hook.eventName).sort();
+    return events[0] === 'stop' && events[1] === 'userPromptSubmit';
+}
+function trustUpdate(hooks) {
+    return Object.fromEntries(hooks.map((hook) => [hook.key, { trusted_hash: hook.currentHash }]));
+}
+export function inspectCodexPluginHooks(homeDir, trust) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(process.env.SQUARE_CODEX_BIN || 'codex', ['app-server', '--stdio'], {
+            env: {
+                ...process.env,
+                HOME: homeDir,
+                CODEX_HOME: codexHome(homeDir),
+            },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        const finish = (error, hooks) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            child.kill('SIGTERM');
+            if (error !== undefined)
+                reject(error);
+            else
+                resolve(hooks ?? []);
+        };
+        const timer = setTimeout(() => finish(new Error(`Codex hooks API timed out${stderr.trim() ? `: ${stderr.trim()}` : ''}`)), 30_000);
+        const send = (message) => child.stdin.write(`${JSON.stringify(message)}\n`);
+        const requestHooks = (id) => {
+            send({ id, method: 'hooks/list', params: { cwds: [process.cwd()] } });
+        };
+        const sendTrust = (hooks) => {
+            send({
+                id: 2,
+                method: 'config/batchWrite',
+                params: {
+                    edits: [{ keyPath: 'hooks.state', value: trustUpdate(hooks), mergeStrategy: 'upsert' }],
+                    reloadUserConfig: true,
+                },
+            });
+        };
+        const failForMessage = (message) => {
+            if (message.error === undefined)
+                return false;
+            const detail = typeof message.error.message === 'string'
+                ? message.error.message
+                : JSON.stringify(message.error);
+            finish(new Error(`Codex hooks API failed: ${detail}`));
+            return true;
+        };
+        const handleMessage = (message) => {
+            if (failForMessage(message))
+                return;
+            if (message.id === 0) {
+                send({ method: 'initialized', params: {} });
+                requestHooks(1);
+                return;
+            }
+            if (message.id === 1) {
+                const hooks = pluginHooksFromList(message.result);
+                if (!trust) {
+                    finish(undefined, hooks);
+                    return;
+                }
+                if (!expectedHooks(hooks)) {
+                    finish(new Error(`Codex discovered an unexpected hook set for ${CODEX_PLUGIN_ID}.`));
+                    return;
+                }
+                sendTrust(hooks);
+                return;
+            }
+            if (message.id === 2) {
+                requestHooks(3);
+                return;
+            }
+            if (message.id === 3)
+                finish(undefined, pluginHooksFromList(message.result));
+        };
+        const consumeStdout = (chunk) => {
+            stdout += String(chunk);
+            while (stdout.includes('\n')) {
+                const newline = stdout.indexOf('\n');
+                const line = stdout.slice(0, newline);
+                stdout = stdout.slice(newline + 1);
+                if (!line.trim())
+                    continue;
+                try {
+                    handleMessage(JSON.parse(line));
+                }
+                catch (error) {
+                    const diagnostic = error instanceof Error ? error : new Error(String(error));
+                    if (diagnostic instanceof SyntaxError) {
+                        finish(new Error(`Codex hooks API returned invalid JSON: ${line}`));
+                    }
+                    else {
+                        finish(diagnostic);
+                    }
+                    return;
+                }
+            }
+        };
+        child.on('error', (error) => finish(error));
+        child.stdin.on('error', (error) => finish(error));
+        child.stderr.on('data', (chunk) => {
+            stderr += String(chunk);
+        });
+        child.stdout.on('data', consumeStdout);
+        child.on('exit', (code) => {
+            if (!settled) {
+                const suffix = stderr.trim() ? `: ${stderr.trim()}` : '';
+                finish(new Error(`Codex hooks API exited ${code ?? 'without status'}${suffix}`));
+            }
+        });
+        send({
+            id: 0,
+            method: 'initialize',
+            params: {
+                clientInfo: {
+                    name: SQUARE_IDENTITY.clientName,
+                    title: SQUARE_IDENTITY.productName,
+                    version: SQUARE_IDENTITY.packageVersion,
+                },
+            },
+        });
+    });
+}
+function codexProtocol(run, hooksRuntime, notes, installed) {
+    const inspectInventory = (homeDir) => {
+        const result = run(homeDir, ['plugin', 'marketplace', 'list', '--json']);
+        requireSuccess(result, 'marketplace inventory');
+        return parseInventory(result.stdout);
+    };
+    const stageBundle = (homeDir, marketplaceRoot) => {
+        const config = codexConfigPath(homeDir);
+        const hooks = codexHomeHooksPath(homeDir);
+        backup(config);
+        backup(hooks);
+        const current = fs.existsSync(config) ? fs.readFileSync(config, 'utf8') : '';
+        writeAtomic(config, upsertTomlSectionKey(current, 'features', 'hooks', 'true'));
+        return stageCodexBundle(homeDir, marketplaceRoot);
+    };
+    const registerMarketplace = (homeDir, marketplaceRoot) => {
+        const result = run(homeDir, ['plugin', 'marketplace', 'add', marketplaceRoot, '--json']);
+        requireSuccess(result, 'marketplace install');
+    };
+    const installOrUpdate = (homeDir, pluginId) => {
+        const result = run(homeDir, ['plugin', 'add', pluginId, '--json']);
+        requireSuccess(result, 'plugin install');
+        try {
+            const payload = JSON.parse(result.stdout);
+            if (typeof payload.installedPath === 'string')
+                installed.path = payload.installedPath;
+        }
+        catch {
+            notes.push('Codex installed the plugin but returned non-JSON output.');
+        }
+    };
+    const verifyPluginAndHooks = async (homeDir, marketplaceName, pluginId) => {
+        const listed = run(homeDir, ['plugin', 'list', '--marketplace', marketplaceName, '--json']);
+        requireSuccess(listed, 'plugin inventory');
+        let entries;
+        try {
+            entries = JSON.parse(listed.stdout).installed;
+        }
+        catch {
+            throw new Error('Codex plugin inventory returned invalid JSON.');
+        }
+        const installedAndEnabled = Array.isArray(entries) && entries.some((entry) => {
+            if (entry === null || typeof entry !== 'object')
+                return false;
+            const plugin = entry;
+            return plugin.pluginId === pluginId && plugin.installed === true && plugin.enabled === true;
+        });
+        if (!installedAndEnabled) {
+            throw new Error(`Codex did not verify ${pluginId} as installed and enabled.`);
+        }
+        const hooks = await hooksRuntime(homeDir, true);
+        if (!expectedHooks(hooks)) {
+            throw new Error(`Codex did not discover both Square plugin hooks for ${pluginId}.`);
+        }
+        const untrusted = hooks.filter((hook) => hook.trustStatus !== 'trusted');
+        if (untrusted.length > 0) {
+            throw new Error(`Codex did not trust Square plugin hooks: ${untrusted.map((hook) => hook.key).join(', ')}`);
+        }
+    };
+    const removePlugin = (homeDir, pluginId) => {
+        const result = run(homeDir, ['plugin', 'remove', pluginId, '--json']);
+        if (result.status !== 0 && !result.stderr.includes('is not configured or installed')) {
+            requireSuccess(result, 'plugin removal');
+        }
+    };
+    const removeMarketplace = (homeDir, marketplaceName) => {
+        const result = run(homeDir, ['plugin', 'marketplace', 'remove', marketplaceName, '--json']);
+        if (result.status !== 0 && !result.stderr.includes('is not configured or installed')) {
+            requireSuccess(result, 'marketplace removal');
+        }
+    };
+    const retireDirectDelivery = (homeDir) => {
+        const hooks = codexHomeHooksPath(homeDir);
+        try {
+            if (stripSquareCodexHooks(hooks))
+                notes.push(`Removed legacy Square handlers from ${hooks}.`);
+        }
+        catch (error) {
+            notes.push(`Legacy hooks were left untouched: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        fs.rmSync(managedHooksPath(homeDir), { force: true });
+    };
+    return {
+        host: 'codex',
+        marketplaceName: CODEX_MARKETPLACE_NAME,
+        pluginId: CODEX_PLUGIN_ID,
+        managedRoot: (homeDir) => path.join(homeDir, '.square', 'codex'),
+        stageBundle,
+        inspectInventory,
+        registerMarketplace(homeDir, desired) {
+            registerMarketplace(homeDir, desired.marketplaceRoot);
+        },
+        installOrUpdate(homeDir, desired) {
+            installOrUpdate(homeDir, desired.pluginId);
+        },
+        verifyPluginAndHooks(homeDir, desired) {
+            return verifyPluginAndHooks(homeDir, desired.marketplaceName, desired.pluginId);
+        },
+        removePlugin(homeDir, pluginId) {
+            removePlugin(homeDir, pluginId);
+        },
+        removeMarketplace(homeDir, marketplaceName) {
+            removeMarketplace(homeDir, marketplaceName);
+        },
+        removeManagedSource(source) {
+            fs.rmSync(source, { recursive: true, force: true });
+        },
+        retireDirectDelivery,
+        removeManagedRoot(homeDir) {
+            fs.rmSync(path.join(homeDir, '.square', 'codex'), { recursive: true, force: true });
+        },
+    };
+}
+function isManagedMarketplace(homeDir, registration) {
+    if (!registration.local)
+        return false;
+    const root = path.join(homeDir, '.square', 'codex');
+    const relative = path.relative(path.resolve(root), path.resolve(registration.source));
+    return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
+}
+function marketplaceRootFromInventory(homeDir, inventory) {
+    return inventory.marketplaces.find((entry) => entry.name === CODEX_MARKETPLACE_NAME && isManagedMarketplace(homeDir, entry))?.source ?? codexMarketplaceRoot(homeDir);
+}
+export async function installCodexPlugin(homeDir, run = runCodex, hooksRuntime = inspectCodexPluginHooks) {
+    const notes = [];
+    const installed = {};
+    const protocol = codexProtocol(run, hooksRuntime, notes, installed);
+    const inventory = await reconcileInstall(homeDir, protocol);
+    const marketplaceRoot = marketplaceRootFromInventory(homeDir, inventory);
+    return {
+        configPath: codexConfigPath(homeDir),
+        marketplaceRoot,
+        pluginRoot: path.join(marketplaceRoot, 'plugins', SQUARE_IDENTITY.pluginName),
+        ...(installed.path === undefined ? {} : { installedPath: installed.path }),
+        notes,
+    };
+}
+export async function uninstallCodexPlugin(homeDir, run = runCodex) {
+    const notes = [];
+    const base = codexProtocol(run, async () => [], notes, {});
+    const protocol = {
+        ...base,
+        async inspectInventory(currentHome) {
+            const inventory = await base.inspectInventory(currentHome);
+            if (inventory.marketplaces.some((entry) => isManagedMarketplace(currentHome, entry))) {
+                return inventory;
+            }
+            return {
+                marketplaces: [
+                    ...inventory.marketplaces,
+                    {
+                        name: CODEX_MARKETPLACE_NAME,
+                        source: codexMarketplaceRoot(currentHome),
+                        local: true,
+                        pluginIds: [CODEX_PLUGIN_ID],
+                    },
+                ],
+            };
+        },
+    };
+    await reconcileUninstall(homeDir, protocol);
+    const root = codexMarketplaceRoot(homeDir);
+    fs.rmSync(root, { recursive: true, force: true });
+    fs.rmSync(managedHooksPath(homeDir), { force: true });
+    return { paths: [root, codexHomeHooksPath(homeDir), managedHooksPath(homeDir)], notes };
+}
+function pluginHooksInstalled(filePath) {
+    try {
+        const contents = fs.readFileSync(filePath, 'utf8');
+        const hooks = JSON.parse(contents);
+        return Array.isArray(hooks.hooks?.UserPromptSubmit) && Array.isArray(hooks.hooks?.Stop);
+    }
+    catch {
+        return false;
+    }
+}
+function codexPluginStatus(homeDir, run) {
+    const listed = run(homeDir, ['plugin', 'list', '--marketplace', CODEX_MARKETPLACE_NAME, '--json']);
+    if (listed.status !== 0)
+        return `○ ${CODEX_PLUGIN_ID} unavailable`;
+    try {
+        const payload = JSON.parse(listed.stdout);
+        const plugin = payload.installed?.find((item) => item.pluginId === CODEX_PLUGIN_ID);
+        return plugin?.installed === true && plugin.enabled === true
+            ? `✓ ${CODEX_PLUGIN_ID} installed and enabled`
+            : `○ ${CODEX_PLUGIN_ID} is not installed and enabled`;
+    }
+    catch {
+        return `○ ${CODEX_PLUGIN_ID} unavailable`;
+    }
+}
+async function codexHookStatus(homeDir, hooksRuntime) {
+    try {
+        const hooks = await hooksRuntime(homeDir, false);
+        const trusted = hooks.every((hook) => hook.trustStatus === 'trusted');
+        return expectedHooks(hooks) && trusted
+            ? `✓ ${CODEX_PLUGIN_ID} hooks trusted by Codex`
+            : `✕ Codex runtime did not discover both ${CODEX_PLUGIN_ID} hooks`;
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        return `✕ Codex hooks runtime unavailable (${detail})`;
+    }
+}
+export async function doctorCodexPlugin(homeDir, run = runCodex, hooksRuntime = inspectCodexPluginHooks) {
+    const protocol = codexProtocol(run, hooksRuntime, [], {});
+    const inventory = await protocol.inspectInventory(homeDir);
+    const marketplaceRoot = marketplaceRootFromInventory(homeDir, inventory);
+    const stale = staleManagedRegistrations(inventory, protocol.managedRoot(homeDir), {
+        marketplaceName: CODEX_MARKETPLACE_NAME,
+        marketplaceRoot,
+        pluginId: CODEX_PLUGIN_ID,
+    });
+    const current = inventory.marketplaces.some((entry) => entry.name === CODEX_MARKETPLACE_NAME && isManagedMarketplace(homeDir, entry));
+    const config = codexConfigPath(homeDir);
+    const configText = fs.existsSync(config) ? fs.readFileSync(config, 'utf8') : '';
+    const bundleRoot = path.join(marketplaceRoot, 'plugins', SQUARE_IDENTITY.pluginName);
+    const bundleHooks = path.join(bundleRoot, 'hooks', 'hooks.json');
+    const lines = [
+        /^hooks = true$/m.test(configText)
+            ? `✓ features.hooks=true in ${config}`
+            : `○ features.hooks missing in ${config}`,
+        pluginHooksInstalled(bundleHooks)
+            ? `✓ Square plugin hooks ${bundleHooks}`
+            : `○ Square plugin bundle missing ${bundleRoot}`,
+        current
+            ? `✓ ${CODEX_PLUGIN_ID} marketplace registered`
+            : `○ ${CODEX_PLUGIN_ID} marketplace is not registered`,
+        codexPluginStatus(homeDir, run),
+        await codexHookStatus(homeDir, hooksRuntime),
+    ];
+    if (stale.length > 0)
+        lines.push(`✕ ${stale.length} stale Square marketplace registration(s)`);
+    return lines;
+}
+export const codexHarness = Object.freeze({
+    install: installCodexPlugin,
+    uninstall: uninstallCodexPlugin,
+    doctor: doctorCodexPlugin,
+});