@astrosheep/square 0.3.2

package/dist/harness.js

@@ -0,0 +1,584 @@
+import { spawn, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const CODEX_HOOK_COMMAND = 'square codex-hook';
+export const SQUARE_CODEX_MARKER = 'square-codex-hook';
+export const CODEX_PLUGIN_ID = 'square@astrosheep-square';
+export const CODEX_MARKETPLACE_NAME = 'astrosheep-square';
+export const CLAUDE_PLUGIN_ID = 'square@astrosheep-square';
+export const CLAUDE_MARKETPLACE_NAME = 'astrosheep-square';
+function sectionRange(lines, section) {
+    const header = new RegExp(`^\\s*\\[${section.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\]\\s*(?:#.*)?$`);
+    const start = lines.findIndex((line) => header.test(line));
+    if (start < 0)
+        return undefined;
+    let end = lines.length;
+    for (let index = start + 1; index < lines.length; index++) {
+        if (/^\s*\[[^\]]+\]\s*(?:#.*)?$/.test(lines[index])) {
+            end = index;
+            break;
+        }
+    }
+    return { start, end };
+}
+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) {
+        if (lines.length > 0 && lines.at(-1) !== '')
+            lines.push('');
+        lines.push(`[${section}]`, assignment);
+        return `${lines.join('\n')}\n`;
+    }
+    const keyPattern = new RegExp(`^\\s*${key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*=`);
+    const existing = lines.findIndex((line, index) => index > range.start && index < range.end && keyPattern.test(line));
+    if (existing >= 0) {
+        if (lines[existing] === assignment)
+            return text.endsWith('\n') ? text : `${text}\n`;
+        lines[existing] = assignment;
+    }
+    else {
+        lines.splice(range.end, 0, assignment);
+    }
+    return `${lines.join('\n')}\n`;
+}
+function isSquareGroup(group) {
+    if (group === null || typeof group !== 'object')
+        return false;
+    const handlers = group.hooks;
+    return (Array.isArray(handlers) &&
+        handlers.some((handler) => handler !== null &&
+            typeof handler === 'object' &&
+            (handler.command === CODEX_HOOK_COMMAND ||
+                handler.statusMessage === SQUARE_CODEX_MARKER)));
+}
+function writeJsonAtomic(filePath, value) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const temp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(temp, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(temp, filePath);
+}
+function writeTextAtomic(filePath, text) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const temp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(temp, text, { mode: 0o600 });
+    fs.renameSync(temp, filePath);
+}
+function backupFile(filePath) {
+    if (!fs.existsSync(filePath))
+        return undefined;
+    const backup = `${filePath}.square-bak`;
+    if (!fs.existsSync(backup))
+        fs.copyFileSync(filePath, backup);
+    return backup;
+}
+export function codexMarketplaceRoot(homeDir) {
+    return path.join(homeDir, '.square', 'codex', 'marketplace');
+}
+export function codexPluginRoot(homeDir) {
+    return path.join(codexMarketplaceRoot(homeDir), 'plugins', 'square');
+}
+export function codexPluginHooksPath(homeDir) {
+    return path.join(codexPluginRoot(homeDir), 'hooks', 'hooks.json');
+}
+function activeCodexHome(homeDir) {
+    return process.env['CODEX_HOME']?.trim() || path.join(homeDir, '.codex');
+}
+export function codexHomeHooksPath(homeDir) {
+    return path.join(activeCodexHome(homeDir), 'hooks.json');
+}
+export function codexConfigPath(homeDir) {
+    return path.join(activeCodexHome(homeDir), 'config.toml');
+}
+function legacyManagedHooksPath(homeDir) {
+    return path.join(homeDir, '.square', 'codex', 'hooks.json');
+}
+export function stripSquareCodexHooks(filePath) {
+    if (!fs.existsSync(filePath))
+        return false;
+    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`Invalid Codex hooks file: ${filePath}`);
+    }
+    const root = parsed;
+    const hooksValue = root['hooks'];
+    if (hooksValue === undefined)
+        return false;
+    if (hooksValue === null || typeof hooksValue !== 'object' || Array.isArray(hooksValue)) {
+        throw new Error(`Invalid Codex hooks map: ${filePath}`);
+    }
+    const hooks = hooksValue;
+    let changed = false;
+    for (const event of Object.keys(hooks)) {
+        const value = hooks[event];
+        if (!Array.isArray(value))
+            continue;
+        const next = value.filter((group) => !isSquareGroup(group));
+        if (next.length !== value.length) {
+            changed = true;
+            if (next.length === 0)
+                delete hooks[event];
+            else
+                hooks[event] = next;
+        }
+    }
+    if (!changed)
+        return false;
+    if (Object.keys(hooks).length === 0)
+        fs.rmSync(filePath, { force: true });
+    else
+        writeJsonAtomic(filePath, root);
+    return true;
+}
+function codexPluginSourcePath() {
+    return fileURLToPath(new URL('../codex-plugin/', import.meta.url));
+}
+function claudePluginSourcePath() {
+    return fileURLToPath(new URL('../skills/square/', import.meta.url));
+}
+function squareSkillSourcePath() {
+    return fileURLToPath(new URL('../skills/square/', import.meta.url));
+}
+function runClaudeCommand(homeDir, args) {
+    const result = spawnSync(process.env['SQUARE_CLAUDE_BIN'] || 'claude', args, {
+        encoding: 'utf8',
+        env: {
+            ...process.env,
+            HOME: homeDir,
+            CLAUDE_CONFIG_DIR: path.join(homeDir, '.claude'),
+        },
+        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 runCodexCommand(homeDir, args) {
+    const result = spawnSync(process.env['SQUARE_CODEX_BIN'] || 'codex', args, {
+        encoding: 'utf8',
+        env: {
+            ...process.env,
+            HOME: homeDir,
+            CODEX_HOME: activeCodexHome(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 requireCodexSuccess(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 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 expectedPluginHooks(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';
+}
+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: activeCodexHome(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)
+                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 failForMessage = (message) => {
+            if (!message.error)
+                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 requestHooks = (id) => send({ id, method: 'hooks/list', params: { cwds: [process.cwd()] } });
+        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', (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;
+                let message;
+                try {
+                    message = JSON.parse(line);
+                }
+                catch {
+                    finish(new Error(`Codex hooks API returned invalid JSON: ${line}`));
+                    return;
+                }
+                if (failForMessage(message))
+                    return;
+                if (message.id === 0) {
+                    send({ method: 'initialized', params: {} });
+                    requestHooks(1);
+                    continue;
+                }
+                if (message.id === 1) {
+                    let hooks;
+                    try {
+                        hooks = pluginHooksFromList(message.result);
+                    }
+                    catch (error) {
+                        finish(error instanceof Error ? error : new Error(String(error)));
+                        return;
+                    }
+                    if (!trust) {
+                        finish(undefined, hooks);
+                        return;
+                    }
+                    if (!expectedPluginHooks(hooks)) {
+                        finish(new Error(`Codex discovered an unexpected hook set for ${CODEX_PLUGIN_ID}.`));
+                        return;
+                    }
+                    const updates = Object.fromEntries(hooks.map((hook) => [hook.key, { trusted_hash: hook.currentHash }]));
+                    send({
+                        id: 2,
+                        method: 'config/batchWrite',
+                        params: {
+                            edits: [{ keyPath: 'hooks.state', value: updates, mergeStrategy: 'upsert' }],
+                            reloadUserConfig: true,
+                        },
+                    });
+                    continue;
+                }
+                if (message.id === 2) {
+                    requestHooks(3);
+                    continue;
+                }
+                if (message.id === 3) {
+                    try {
+                        finish(undefined, pluginHooksFromList(message.result));
+                    }
+                    catch (error) {
+                        finish(error instanceof Error ? error : new Error(String(error)));
+                    }
+                }
+            }
+        });
+        child.on('exit', (code) => {
+            if (!settled) {
+                finish(new Error(`Codex hooks API exited ${code ?? 'without status'}${stderr.trim() ? `: ${stderr.trim()}` : ''}`));
+            }
+        });
+        send({
+            id: 0,
+            method: 'initialize',
+            params: {
+                clientInfo: { name: 'astrosheep_square', title: 'Square', version: '0.3.2' },
+            },
+        });
+    });
+}
+function claudeMarketplaceDocument() {
+    return {
+        name: CLAUDE_MARKETPLACE_NAME,
+        description: 'Square harness integrations',
+        owner: { name: 'Square' },
+        plugins: [
+            {
+                name: 'square',
+                description: 'Native Claude Code turn-boundary delivery for Square',
+                source: './plugins/square',
+            },
+        ],
+    };
+}
+function marketplaceDocument() {
+    return {
+        name: CODEX_MARKETPLACE_NAME,
+        interface: { displayName: 'Square' },
+        plugins: [
+            {
+                name: 'square',
+                source: { source: 'local', path: './plugins/square' },
+                policy: { installation: 'AVAILABLE', authentication: 'ON_USE' },
+                category: 'Developer Tools',
+            },
+        ],
+    };
+}
+function stageClaudePlugin(homeDir) {
+    const marketplaceRoot = path.join(homeDir, '.square', 'claude', 'marketplace');
+    const stage = `${marketplaceRoot}.${process.pid}.${Date.now()}.stage`;
+    const pluginRoot = path.join(stage, 'plugins', 'square');
+    fs.mkdirSync(path.dirname(marketplaceRoot), { recursive: true });
+    fs.rmSync(stage, { recursive: true, force: true });
+    try {
+        fs.cpSync(claudePluginSourcePath(), pluginRoot, { recursive: true });
+        writeJsonAtomic(path.join(stage, '.claude-plugin', 'marketplace.json'), claudeMarketplaceDocument());
+        fs.rmSync(marketplaceRoot, { recursive: true, force: true });
+        fs.renameSync(stage, marketplaceRoot);
+    }
+    catch (error) {
+        fs.rmSync(stage, { recursive: true, force: true });
+        throw error;
+    }
+    return { marketplaceRoot, pluginRoot: path.join(marketplaceRoot, 'plugins', 'square') };
+}
+function stageCodexPlugin(homeDir) {
+    const marketplaceRoot = codexMarketplaceRoot(homeDir);
+    const parent = path.dirname(marketplaceRoot);
+    const stage = `${marketplaceRoot}.${process.pid}.${Date.now()}.stage`;
+    const pluginRoot = path.join(stage, 'plugins', 'square');
+    fs.mkdirSync(parent, { recursive: true });
+    fs.rmSync(stage, { recursive: true, force: true });
+    try {
+        fs.cpSync(codexPluginSourcePath(), pluginRoot, { recursive: true });
+        const stagedSkill = path.join(pluginRoot, 'skills', 'square', 'SKILL.md');
+        fs.mkdirSync(path.dirname(stagedSkill), { recursive: true });
+        fs.copyFileSync(path.join(squareSkillSourcePath(), 'SKILL.md'), stagedSkill);
+        writeJsonAtomic(path.join(stage, '.agents', 'plugins', 'marketplace.json'), marketplaceDocument());
+        fs.rmSync(marketplaceRoot, { recursive: true, force: true });
+        fs.renameSync(stage, marketplaceRoot);
+    }
+    catch (error) {
+        fs.rmSync(stage, { recursive: true, force: true });
+        throw error;
+    }
+    return { marketplaceRoot, pluginRoot: codexPluginRoot(homeDir) };
+}
+function pluginHooksInstalled(filePath) {
+    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    return (Array.isArray(parsed.hooks?.UserPromptSubmit) &&
+        parsed.hooks.UserPromptSubmit.some(isSquareGroup) &&
+        Array.isArray(parsed.hooks?.Stop) &&
+        parsed.hooks.Stop.some(isSquareGroup));
+}
+/** Install the Square Claude plugin and retire the skill-directory-only install. */
+export function installClaudePlugin(homeDir, run = runClaudeCommand) {
+    const staged = stageClaudePlugin(homeDir);
+    requireCodexSuccess(run(homeDir, ['plugin', 'marketplace', 'add', staged.marketplaceRoot]), 'Claude marketplace install');
+    requireCodexSuccess(run(homeDir, ['plugin', 'install', CLAUDE_PLUGIN_ID]), 'Claude plugin install');
+    requireCodexSuccess(run(homeDir, ['plugin', 'update', CLAUDE_PLUGIN_ID]), 'Claude plugin update');
+    const legacySkill = path.join(homeDir, '.claude', 'skills', 'square');
+    if (lstatMaybeForHarness(legacySkill)?.isSymbolicLink())
+        fs.rmSync(legacySkill, { force: true });
+    return staged;
+}
+function lstatMaybeForHarness(target) {
+    try {
+        return fs.lstatSync(target);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+}
+/** Install the Square Codex plugin and migrate away from direct home hook edits. */
+export async function installCodexPlugin(homeDir, run = runCodexCommand, hooksRuntime = inspectCodexPluginHooks) {
+    const configPath = codexConfigPath(homeDir);
+    const activeHooksPath = codexHomeHooksPath(homeDir);
+    const notes = [];
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    backupFile(configPath);
+    backupFile(activeHooksPath);
+    const configText = fs.existsSync(configPath) ? fs.readFileSync(configPath, 'utf8') : '';
+    const normalizedConfig = configText === '' || configText.endsWith('\n') ? configText : `${configText}\n`;
+    const nextConfig = upsertTomlSectionKey(configText, 'features', 'hooks', 'true');
+    if (nextConfig !== normalizedConfig)
+        writeTextAtomic(configPath, nextConfig);
+    const staged = stageCodexPlugin(homeDir);
+    const marketplace = run(homeDir, [
+        'plugin',
+        'marketplace',
+        'add',
+        staged.marketplaceRoot,
+        '--json',
+    ]);
+    requireCodexSuccess(marketplace, 'marketplace install');
+    const installed = run(homeDir, ['plugin', 'add', CODEX_PLUGIN_ID, '--json']);
+    requireCodexSuccess(installed, 'plugin install');
+    let installedPath;
+    try {
+        const result = JSON.parse(installed.stdout);
+        if (typeof result.installedPath === 'string')
+            installedPath = result.installedPath;
+    }
+    catch {
+        notes.push('Codex installed the plugin but returned non-JSON output.');
+    }
+    const runtimeHooks = await hooksRuntime(homeDir, true);
+    if (!expectedPluginHooks(runtimeHooks)) {
+        throw new Error(`Codex did not discover both Square plugin hooks for ${CODEX_PLUGIN_ID}.`);
+    }
+    const untrusted = runtimeHooks.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(', ')}`);
+    }
+    try {
+        if (stripSquareCodexHooks(activeHooksPath))
+            notes.push(`Removed legacy Square handlers from ${activeHooksPath}.`);
+    }
+    catch (error) {
+        notes.push(`Legacy hooks were left untouched: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    fs.rmSync(legacyManagedHooksPath(homeDir), { force: true });
+    return {
+        configPath,
+        marketplaceRoot: staged.marketplaceRoot,
+        pluginRoot: staged.pluginRoot,
+        ...(installedPath ? { installedPath } : {}),
+        notes,
+    };
+}
+export function uninstallCodexPlugin(homeDir, run = runCodexCommand) {
+    const notes = [];
+    const removed = run(homeDir, ['plugin', 'remove', CODEX_PLUGIN_ID, '--json']);
+    requireCodexSuccess(removed, 'plugin removal');
+    const marketplace = run(homeDir, ['plugin', 'marketplace', 'remove', CODEX_MARKETPLACE_NAME, '--json']);
+    if (marketplace.status !== 0 && !marketplace.stderr.includes('is not configured or installed')) {
+        requireCodexSuccess(marketplace, 'marketplace removal');
+    }
+    const activeHooksPath = codexHomeHooksPath(homeDir);
+    if (stripSquareCodexHooks(activeHooksPath))
+        notes.push(`Removed legacy Square handlers from ${activeHooksPath}.`);
+    const marketplaceRoot = codexMarketplaceRoot(homeDir);
+    const managedHooksPath = legacyManagedHooksPath(homeDir);
+    fs.rmSync(marketplaceRoot, { recursive: true, force: true });
+    fs.rmSync(managedHooksPath, { force: true });
+    return { paths: [marketplaceRoot, activeHooksPath, managedHooksPath], notes };
+}
+export async function doctorCodexPlugin(homeDir, run = runCodexCommand, hooksRuntime = inspectCodexPluginHooks) {
+    const lines = [];
+    const configPath = codexConfigPath(homeDir);
+    const configText = fs.existsSync(configPath) ? fs.readFileSync(configPath, 'utf8') : '';
+    const features = sectionRange(configText.split('\n'), 'features');
+    const hooksEnabled = features !== undefined &&
+        configText
+            .split('\n')
+            .slice(features.start + 1, features.end)
+            .some((line) => /^\s*hooks\s*=\s*true\s*(?:#.*)?$/.test(line));
+    lines.push(hooksEnabled ? `✓ features.hooks=true in ${configPath}` : `○ features.hooks missing in ${configPath}`);
+    const hooksPath = codexPluginHooksPath(homeDir);
+    if (!fs.existsSync(hooksPath)) {
+        lines.push(`○ Square plugin bundle missing ${codexPluginRoot(homeDir)}`);
+    }
+    else {
+        try {
+            lines.push(pluginHooksInstalled(hooksPath)
+                ? `✓ Square plugin hooks ${hooksPath}`
+                : `✕ Square plugin hooks incomplete ${hooksPath}`);
+        }
+        catch {
+            lines.push(`✕ invalid Square plugin hooks ${hooksPath}`);
+        }
+    }
+    const listed = run(homeDir, ['plugin', 'list', '--marketplace', CODEX_MARKETPLACE_NAME, '--json']);
+    if (listed.status !== 0) {
+        lines.push(`○ ${CODEX_PLUGIN_ID} unavailable (${listed.stderr.trim() || `exit ${listed.status}`})`);
+    }
+    else {
+        try {
+            const payload = JSON.parse(listed.stdout);
+            const plugin = payload.installed?.find((entry) => entry.pluginId === CODEX_PLUGIN_ID);
+            lines.push(plugin?.installed === true && plugin.enabled === true
+                ? `✓ ${CODEX_PLUGIN_ID} installed and enabled`
+                : `○ ${CODEX_PLUGIN_ID} is not installed and enabled`);
+        }
+        catch {
+            lines.push('✕ Codex returned invalid plugin inventory JSON');
+        }
+    }
+    try {
+        const runtimeHooks = await hooksRuntime(homeDir, false);
+        if (!expectedPluginHooks(runtimeHooks)) {
+            lines.push(`✕ Codex runtime did not discover both ${CODEX_PLUGIN_ID} hooks`);
+        }
+        else {
+            const untrusted = runtimeHooks.filter((hook) => hook.trustStatus !== 'trusted');
+            lines.push(untrusted.length === 0
+                ? `✓ ${CODEX_PLUGIN_ID} hooks trusted by Codex`
+                : `✕ ${untrusted.length} ${CODEX_PLUGIN_ID} hooks need trust`);
+        }
+    }
+    catch (error) {
+        lines.push(`✕ Codex hooks runtime unavailable (${error instanceof Error ? error.message : String(error)})`);
+    }
+    const activeHooksPath = codexHomeHooksPath(homeDir);
+    if (fs.existsSync(activeHooksPath)) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(activeHooksPath, 'utf8'));
+            const legacy = Object.values(parsed.hooks ?? {}).some((groups) => Array.isArray(groups) && groups.some(isSquareGroup));
+            if (legacy)
+                lines.push(`▲ legacy Square handlers still present in ${activeHooksPath}`);
+        }
+        catch {
+            lines.push(`✕ invalid hooks file ${activeHooksPath}`);
+        }
+    }
+    return lines;
+}