@astrosheep/square 0.3.4 → 0.3.5

package/dist/harness-lifecycle.js

@@ -0,0 +1,102 @@
+import path from 'node:path';
+export class HarnessLifecycleError extends Error {
+    host;
+    phase;
+    retryCommand;
+    constructor(host, phase, retryCommand, cause) {
+        super(`${host} ${phase} failed: ${cause instanceof Error ? cause.message : String(cause)}\n» ${retryCommand}`);
+        this.host = host;
+        this.phase = phase;
+        this.retryCommand = retryCommand;
+        this.name = 'HarnessLifecycleError';
+    }
+}
+function containsPath(root, target) {
+    const relative = path.relative(path.resolve(root), path.resolve(target));
+    return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
+}
+function staleRegistrations(inventory, managedRoot, desired) {
+    return inventory.marketplaces.filter((registration) => registration.local &&
+        containsPath(managedRoot, registration.source) &&
+        (registration.name !== desired.marketplaceName || path.resolve(registration.source) !== path.resolve(desired.marketplaceRoot)));
+}
+function pluginIdForRegistration(desired, registration) {
+    if (registration.pluginIds !== undefined && registration.pluginIds.length > 0)
+        return registration.pluginIds;
+    const pluginName = desired.pluginId.split('@', 1)[0];
+    return [`${pluginName}@${registration.name}`];
+}
+/**
+ * Reconcile a host from Square-owned desired state. Cleanup deliberately begins
+ * only after plugin activation and hook verification, so an old registration is
+ * still usable when staging, registration, install, or verification fails.
+ */
+export async function reconcileInstall(homeDir, protocol, retryCommand = `square harness install ${protocol.host}`) {
+    let staged;
+    let activated = false;
+    let phase = 'stage';
+    try {
+        const before = await protocol.inspectInventory(homeDir);
+        const managedRoot = protocol.managedRoot(homeDir);
+        const current = before.marketplaces.find((registration) => registration.name === protocol.marketplaceName &&
+            registration.local &&
+            containsPath(managedRoot, registration.source));
+        const marketplaceRoot = current?.source ?? path.join(managedRoot, 'marketplaces', protocol.marketplaceName);
+        staged = await protocol.stageBundle(homeDir, marketplaceRoot);
+        const stale = staleRegistrations(before, protocol.managedRoot(homeDir), staged.desired);
+        if (current === undefined) {
+            phase = 'register';
+            await protocol.registerMarketplace(homeDir, staged.desired);
+        }
+        phase = 'install';
+        await protocol.installOrUpdate(homeDir, staged.desired);
+        phase = 'verify';
+        await protocol.verifyPluginAndHooks(homeDir, staged.desired);
+        activated = true;
+        phase = 'cleanup';
+        for (const registration of stale) {
+            for (const pluginId of pluginIdForRegistration(staged.desired, registration)) {
+                await protocol.removePlugin(homeDir, pluginId, registration.name);
+            }
+            await protocol.removeMarketplace(homeDir, registration.name);
+            if (path.resolve(registration.source) !== path.resolve(staged.desired.marketplaceRoot)) {
+                await protocol.removeManagedSource?.(registration.source);
+            }
+        }
+        await protocol.retireDirectDelivery?.(homeDir);
+        await staged.finalize?.();
+        return await protocol.inspectInventory(homeDir);
+    }
+    catch (error) {
+        if (!activated && staged !== undefined) {
+            try {
+                await staged.rollback();
+            }
+            catch {
+                // The original failure is the actionable phase; rollback is best effort.
+            }
+        }
+        if (error instanceof HarnessLifecycleError)
+            throw error;
+        throw new HarnessLifecycleError(protocol.host, phase, retryCommand, error);
+    }
+}
+export async function reconcileUninstall(homeDir, protocol) {
+    const inventory = await protocol.inspectInventory(homeDir);
+    const root = protocol.managedRoot(homeDir);
+    const pluginName = protocol.pluginId.split('@', 1)[0];
+    for (const registration of inventory.marketplaces) {
+        if (!registration.local || !containsPath(root, registration.source))
+            continue;
+        for (const pluginId of registration.pluginIds ?? [`${pluginName}@${registration.name}`]) {
+            await protocol.removePlugin(homeDir, pluginId, registration.name);
+        }
+        await protocol.removeMarketplace(homeDir, registration.name);
+        await protocol.removeManagedSource?.(registration.source);
+    }
+    await protocol.retireDirectDelivery?.(homeDir);
+    await protocol.removeManagedRoot?.(homeDir);
+}
+export function staleManagedRegistrations(inventory, managedRoot, desired) {
+    return staleRegistrations(inventory, managedRoot, desired);
+}

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' };
+}