@astrosheep/square 0.3.4 → 0.3.6

package/dist/harness-codex.js

@@ -0,0 +1,119 @@
+import { 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 { stageReplacement } from './harness-stage.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;
+const LEGACY_MARKETPLACES = ['astrosheep-square'];
+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 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 runCodex(homeDir, args) {
+    const result = spawnSync(process.env.SQUARE_CODEX_BIN || 'codex', args, {
+        encoding: 'utf8', env: { ...process.env, HOME: homeDir, CODEX_HOME: codexHome(homeDir) }, timeout: 30_000,
+    });
+    if (result.error)
+        throw result.error;
+    return { status: result.status ?? 1, stdout: result.stdout || '', stderr: result.stderr || '' };
+}
+function requireSuccess(result, operation, allowMissing = false) {
+    if (result.status === 0 || (allowMissing && /not configured|not installed|not found/i.test(result.stderr)))
+        return;
+    throw new Error(`Codex ${operation} failed: ${result.stderr.trim() || result.stdout.trim() || `exit ${result.status}`}`);
+}
+export function upsertTomlSectionKey(text, section, key, value) {
+    const lines = text.replace(/\n$/, '').split('\n').filter((line, i) => line !== '' || i < text.length);
+    const header = `[${section}]`;
+    const start = lines.findIndex((line) => line.trim() === header);
+    if (start < 0)
+        return `${text.trimEnd()}${text.trim() ? '\n\n' : ''}${header}\n${key} = ${value}\n`;
+    const end = lines.findIndex((line, i) => i > start && /^\s*\[[^\]]+\]/.test(line));
+    const stop = end < 0 ? lines.length : end;
+    const match = new RegExp(`^\\s*${key.replace(/[.*+?^${}()|[\\]\\]/g, '\\$&')}\\s*=`);
+    const existing = lines.findIndex((line, i) => i > start && i < stop && match.test(line));
+    if (existing < 0)
+        lines.splice(stop, 0, `${key} = ${value}`);
+    else
+        lines[existing] = `${key} = ${value}`;
+    return `${lines.join('\n')}\n`;
+}
+function writeAtomic(file, text) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const temp = `${file}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(temp, text, { mode: 0o600 });
+    fs.renameSync(temp, file);
+}
+export async function installCodexPlugin(homeDir, run = runCodex) {
+    const root = codexMarketplaceRoot(homeDir);
+    const config = codexConfigPath(homeDir);
+    const current = fs.existsSync(config) ? fs.readFileSync(config, 'utf8') : '';
+    const staged = stageReplacement(root, (stage) => {
+        const plugin = path.join(stage, 'plugins', SQUARE_IDENTITY.pluginName);
+        fs.cpSync(fileURLToPath(new URL('../codex-plugin/', import.meta.url)), plugin, { recursive: true });
+        const skill = path.join(plugin, 'skills', 'square', 'SKILL.md');
+        fs.mkdirSync(path.dirname(skill), { recursive: true });
+        fs.copyFileSync(path.join(fileURLToPath(new URL('../skills/square/', import.meta.url)), 'SKILL.md'), skill);
+        writeAtomic(path.join(stage, '.agents', 'plugins', 'marketplace.json'), `${JSON.stringify({ name: CODEX_MARKETPLACE_NAME, plugins: [{ name: SQUARE_IDENTITY.pluginName, source: { source: 'local', path: './plugins/square' } }] }, null, 2)}\n`);
+    });
+    const notes = [];
+    try {
+        writeAtomic(config, upsertTomlSectionKey(current, 'features', 'hooks', 'true'));
+        requireSuccess(run(homeDir, ['plugin', 'marketplace', 'add', root, '--json']), 'marketplace install', true);
+        const installed = run(homeDir, ['plugin', 'add', CODEX_PLUGIN_ID, '--json']);
+        requireSuccess(installed, 'plugin install');
+        let installedPath;
+        try {
+            const value = JSON.parse(installed.stdout).installedPath;
+            if (typeof value === 'string')
+                installedPath = value;
+        }
+        catch {
+            notes.push('Codex returned non-JSON installation output.');
+        }
+        for (const marketplace of LEGACY_MARKETPLACES) {
+            const pluginId = `${SQUARE_IDENTITY.pluginName}@${marketplace}`;
+            if (!current.includes(`[marketplaces.${marketplace}]`) && !current.includes(`[plugins."${pluginId}"]`))
+                continue;
+            requireSuccess(run(homeDir, ['plugin', 'remove', pluginId, '--json']), 'legacy plugin removal', true);
+            requireSuccess(run(homeDir, ['plugin', 'marketplace', 'remove', marketplace, '--json']), 'legacy marketplace removal', true);
+            notes.push(`retired ${pluginId}`);
+        }
+        staged.finalize();
+        return { configPath: config, marketplaceRoot: root, pluginRoot: codexPluginRoot(homeDir), ...(installedPath ? { installedPath } : {}), notes };
+    }
+    catch (error) {
+        staged.rollback();
+        throw error;
+    }
+}
+export async function uninstallCodexPlugin(homeDir, run = runCodex) {
+    requireSuccess(run(homeDir, ['plugin', 'remove', CODEX_PLUGIN_ID, '--json']), 'plugin removal', true);
+    requireSuccess(run(homeDir, ['plugin', 'marketplace', 'remove', CODEX_MARKETPLACE_NAME, '--json']), 'marketplace removal', true);
+    for (const marketplace of LEGACY_MARKETPLACES) {
+        requireSuccess(run(homeDir, ['plugin', 'remove', `${SQUARE_IDENTITY.pluginName}@${marketplace}`, '--json']), 'legacy plugin removal', true);
+        requireSuccess(run(homeDir, ['plugin', 'marketplace', 'remove', marketplace, '--json']), 'legacy marketplace removal', true);
+    }
+    const root = codexMarketplaceRoot(homeDir);
+    fs.rmSync(root, { recursive: true, force: true });
+    fs.rmSync(codexHomeHooksPath(homeDir), { force: true });
+    return { paths: [root, codexConfigPath(homeDir), codexHomeHooksPath(homeDir)], notes: [] };
+}
+export async function doctorCodexPlugin(homeDir, run = runCodex) {
+    const root = codexMarketplaceRoot(homeDir);
+    const config = codexConfigPath(homeDir);
+    const listed = run(homeDir, ['plugin', 'list', '--json']);
+    return [
+        /^hooks\s*=\s*true$/m.test(fs.existsSync(config) ? fs.readFileSync(config, 'utf8') : '') ? `✓ features.hooks=true in ${config}` : `○ features.hooks missing in ${config}`,
+        fs.existsSync(codexPluginHooksPath(homeDir)) ? `✓ Square plugin hooks ${codexPluginHooksPath(homeDir)}` : `○ Square plugin bundle missing ${root}`,
+        listed.status === 0 && listed.stdout.includes(CODEX_PLUGIN_ID) ? `✓ ${CODEX_PLUGIN_ID} installed` : `○ ${CODEX_PLUGIN_ID} unavailable`,
+    ];
+}

package/dist/harness-links.js

@@ -0,0 +1,123 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+function packageRoot() {
+    // Emitted modules live in dist; package assets are one level above them.
+    return fileURLToPath(new URL('../', import.meta.url));
+}
+function lstatMaybe(target) {
+    try {
+        return fs.lstatSync(target);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+}
+export function installHarnessLinks(links, force = false) {
+    const prepared = links.map((link) => {
+        if (!fs.existsSync(link.source)) {
+            throw new Error(`Harness link source is missing: ${link.source}`);
+        }
+        return {
+            ...link,
+            existing: lstatMaybe(link.target),
+            sourceIsDirectory: fs.statSync(link.source).isDirectory(),
+        };
+    });
+    for (const { target, existing } of prepared) {
+        if (existing !== undefined && !force)
+            throw new Error(`Refusing to overwrite existing link: ${target}\nPass -f to replace it.`);
+    }
+    for (const { source, target, existing, sourceIsDirectory } of prepared) {
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        if (existing !== undefined)
+            fs.rmSync(target, { recursive: true, force: true });
+        const symlinkType = os.platform() === 'win32' && sourceIsDirectory ? 'junction' : 'file';
+        fs.symlinkSync(source, target, symlinkType);
+    }
+    return prepared.map(({ target }) => target);
+}
+function sameLink(source, target) {
+    try {
+        return fs.realpathSync(source) === fs.realpathSync(target);
+    }
+    catch {
+        return false;
+    }
+}
+export function uninstallHarnessLinks(links) {
+    const removed = [];
+    for (const link of links) {
+        try {
+            if (fs.lstatSync(link.target).isSymbolicLink() && sameLink(link.source, link.target)) {
+                fs.rmSync(link.target, { force: true });
+                removed.push(link.target);
+            }
+        }
+        catch {
+            // A missing or user-owned target is preserved.
+        }
+    }
+    return removed;
+}
+export function doctorHarnessLinks(links) {
+    return links.map((link) => sameLink(link.source, link.target)
+        ? `✓ Square ${link.kind ?? 'link'} ${link.target}`
+        : `○ Square ${link.kind ?? 'link'} missing ${link.target}`);
+}
+function runOpenCode(homeDir, args) {
+    const result = spawnSync(process.env.SQUARE_OPENCODE_BIN || 'opencode', args, {
+        encoding: 'utf8',
+        env: { ...process.env, HOME: homeDir, XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME ?? path.join(homeDir, '.config') },
+        timeout: 30_000,
+    });
+    if (result.error)
+        throw result.error;
+    return { status: result.status ?? 1, stdout: result.stdout || '', stderr: result.stderr || '' };
+}
+/** Verify that OpenCode accepts its resolved runtime configuration after links are installed. */
+export function verifyOpenCodeRuntime(homeDir, run = runOpenCode) {
+    try {
+        const result = run(homeDir, ['debug', 'config']);
+        if (result.status !== 0) {
+            return `✕ OpenCode debug config failed: ${result.stderr.trim() || result.stdout.trim() || `exit ${result.status}`}`;
+        }
+        let config;
+        try {
+            config = JSON.parse(result.stdout);
+        }
+        catch {
+            return '✕ OpenCode debug config returned invalid JSON';
+        }
+        const plugin = config.config?.plugin;
+        const expected = pathToFileURL(opencodeExtensionLink(homeDir).target).href;
+        if (Array.isArray(plugin) && plugin.includes(expected))
+            return '✓ OpenCode debug config loaded';
+        return `○ OpenCode plugin not loaded: ${expected}`;
+    }
+    catch (error) {
+        return `○ OpenCode runtime unavailable (${error instanceof Error ? error.message : String(error)})`;
+    }
+}
+export function skillLinks(homeDir = os.homedir(), parents = ['.claude', '.agents']) {
+    return parents.flatMap((parent) => ['square', 'brainstorm'].map((name) => ({
+        source: path.join(packageRoot(), 'skills', name),
+        target: path.join(homeDir, parent, 'skills', name),
+        kind: 'skill',
+    })));
+}
+export function opencodeExtensionLink(homeDir = os.homedir()) {
+    const configHome = process.env.XDG_CONFIG_HOME ?? path.join(homeDir, '.config');
+    return {
+        source: path.join(packageRoot(), 'extensions', 'square-opencode.js'),
+        target: path.join(configHome, 'opencode', 'plugins', 'square.js'),
+        kind: 'extension',
+    };
+}
+export function piExtensionLink(homeDir = os.homedir()) {
+    return { source: path.join(packageRoot(), 'extensions', 'square-pi.js'), target: path.join(homeDir, '.pi', 'agent', 'extensions', 'square.js'), kind: 'extension' };
+}

package/dist/harness-stage.js

@@ -0,0 +1,36 @@
+import fs from 'node:fs';
+import path from 'node:path';
+/** Replace a file or directory while retaining the previous value for rollback. */
+export function stageReplacement(root, populate) {
+    const token = `${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}`;
+    const stage = `${root}.${token}.stage`;
+    const backup = `${root}.${token}.previous`;
+    let replaced = false;
+    let hadOriginal = false;
+    fs.mkdirSync(path.dirname(root), { recursive: true });
+    try {
+        populate(stage);
+        hadOriginal = fs.existsSync(root);
+        if (hadOriginal)
+            fs.renameSync(root, backup);
+        fs.renameSync(stage, root);
+        replaced = true;
+    }
+    catch (error) {
+        fs.rmSync(stage, { recursive: true, force: true });
+        if (hadOriginal && fs.existsSync(backup) && !fs.existsSync(root))
+            fs.renameSync(backup, root);
+        throw error;
+    }
+    return {
+        rollback() {
+            if (replaced)
+                fs.rmSync(root, { recursive: true, force: true });
+            if (hadOriginal && fs.existsSync(backup))
+                fs.renameSync(backup, root);
+        },
+        finalize() {
+            fs.rmSync(backup, { recursive: true, force: true });
+        },
+    };
+}