@astrosheep/square 0.3.5 → 0.3.6

package/dist/harness-claude.js

@@ -3,273 +3,66 @@ 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';
+import { stageReplacement } from './harness-stage.js';
 export const CLAUDE_PLUGIN_ID = SQUARE_IDENTITY.pluginId;
 export const CLAUDE_MARKETPLACE_NAME = SQUARE_IDENTITY.marketplaceName;
 export function claudeMarketplaceRoot(homeDir) {
     return path.join(homeDir, '.square', 'claude', 'marketplaces', CLAUDE_MARKETPLACE_NAME);
 }
-function packageAssets(relative) {
-    return fileURLToPath(new URL(relative, import.meta.url));
-}
-function runClaudeCommand(homeDir, args) {
+function runClaude(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,
+        encoding: 'utf8', env: { ...process.env, HOME: homeDir, CLAUDE_CONFIG_DIR: path.join(homeDir, '.claude') }, timeout: 30_000,
     });
     if (result.error)
         throw result.error;
     return { status: result.status ?? 1, stdout: result.stdout || '', stderr: result.stderr || '' };
 }
-function requireSuccess(result, operation) {
-    if (result.status === 0)
+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(`Claude ${operation} failed: ${result.stderr.trim() || result.stdout.trim() || `exit ${result.status}`}`);
 }
-function writeJsonAtomic(filePath, value) {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    const temporary = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-    fs.writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
-    fs.renameSync(temporary, filePath);
+function writeJson(file, value) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
 }
-function stageClaudeBundle(homeDir, marketplaceRoot) {
-    const token = `${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}`;
-    const stage = `${marketplaceRoot}.${token}.stage`;
-    const backup = `${marketplaceRoot}.${token}.previous`;
-    const pluginRoot = path.join(stage, 'plugins', SQUARE_IDENTITY.pluginName);
-    fs.mkdirSync(path.dirname(marketplaceRoot), { recursive: true });
-    try {
-        fs.cpSync(packageAssets('../skills/square/'), pluginRoot, { recursive: true });
-        writeJsonAtomic(path.join(stage, '.claude-plugin', 'marketplace.json'), {
+export async function installClaudePlugin(homeDir, run = runClaude) {
+    const marketplaceRoot = claudeMarketplaceRoot(homeDir);
+    const staged = stageReplacement(marketplaceRoot, (stage) => {
+        const plugin = path.join(stage, 'plugins', SQUARE_IDENTITY.pluginName);
+        fs.cpSync(fileURLToPath(new URL('../skills/square/', import.meta.url)), plugin, { recursive: true });
+        writeJson(path.join(stage, '.claude-plugin', 'marketplace.json'), {
             name: CLAUDE_MARKETPLACE_NAME,
-            description: `${SQUARE_IDENTITY.productName} harness integrations`,
-            owner: { name: SQUARE_IDENTITY.productName },
-            plugins: [{ name: SQUARE_IDENTITY.pluginName, description: `Native Claude Code delivery for ${SQUARE_IDENTITY.productName}`, source: './plugins/square' }],
+            plugins: [{ name: SQUARE_IDENTITY.pluginName, source: './plugins/square' }],
         });
-        if (fs.existsSync(marketplaceRoot))
-            fs.renameSync(marketplaceRoot, backup);
-        fs.renameSync(stage, marketplaceRoot);
-    }
-    catch (error) {
-        try {
-            fs.rmSync(stage, { recursive: true, force: true });
-        }
-        catch { }
-        if (fs.existsSync(backup) && !fs.existsSync(marketplaceRoot))
-            fs.renameSync(backup, marketplaceRoot);
-        throw error;
-    }
-    return {
-        desired: { marketplaceName: CLAUDE_MARKETPLACE_NAME, marketplaceRoot, pluginId: CLAUDE_PLUGIN_ID },
-        rollback() {
-            fs.rmSync(marketplaceRoot, { recursive: true, force: true });
-            if (fs.existsSync(backup))
-                fs.renameSync(backup, marketplaceRoot);
-        },
-        finalize() { fs.rmSync(backup, { recursive: true, force: true }); },
-    };
-}
-function isRecord(value) {
-    return value !== null && typeof value === 'object';
-}
-function isManagedSource(managedRoot, source) {
-    const relative = path.relative(path.resolve(managedRoot), path.resolve(source));
-    return relative === '' || (relative !== '..' &&
-        !relative.startsWith(`..${path.sep}`) &&
-        !path.isAbsolute(relative));
-}
-function isCurrentManagedMarketplace(marketplace, managedRoot) {
-    return marketplace.name === CLAUDE_MARKETPLACE_NAME &&
-        marketplace.local &&
-        isManagedSource(managedRoot, marketplace.source);
-}
-function parseClaudeMarketplaceRegistration(value) {
-    if (!isRecord(value)) {
-        throw new Error('Claude marketplace inventory entry is invalid.');
-    }
-    const name = value.name;
-    const source = value.source;
-    const installLocation = value.installLocation;
-    if (typeof name !== 'string' ||
-        typeof source !== 'string' ||
-        typeof installLocation !== 'string') {
-        throw new Error('Claude marketplace inventory entry is malformed.');
-    }
-    if (source === 'directory') {
-        const sourcePath = value.path;
-        if (typeof sourcePath !== 'string') {
-            throw new Error('Claude directory marketplace entry is malformed.');
-        }
-        return { name, source: sourcePath, local: true };
-    }
-    const stableSource = typeof value.repo === 'string' ? value.repo : name;
-    return { name, source: `${source}:${stableSource}`, local: false };
-}
-function parseInventory(stdout) {
+    });
     try {
-        const payload = JSON.parse(stdout);
-        if (!Array.isArray(payload)) {
-            throw new Error('Claude marketplace inventory must be a JSON array.');
-        }
-        const marketplaces = payload.map(parseClaudeMarketplaceRegistration);
-        return { marketplaces };
+        const add = run(homeDir, ['plugin', 'marketplace', 'add', marketplaceRoot]);
+        requireSuccess(add, 'marketplace install', true);
+        requireSuccess(run(homeDir, ['plugin', 'install', CLAUDE_PLUGIN_ID]), 'plugin install');
+        requireSuccess(run(homeDir, ['plugin', 'update', CLAUDE_PLUGIN_ID]), 'plugin update');
+        staged.finalize();
     }
     catch (error) {
-        throw error instanceof Error ? error : new Error(String(error));
-    }
-}
-function parseClaudePluginInventory(stdout) {
-    try {
-        const parsed = JSON.parse(stdout);
-        return Array.isArray(parsed) ? parsed : [];
-    }
-    catch {
-        throw new Error('Claude plugin inventory returned invalid JSON.');
+        staged.rollback();
+        throw error;
     }
-}
-function isVerifiedClaudePlugin(entry) {
-    if (!isRecord(entry))
-        return false;
-    return entry.id === CLAUDE_PLUGIN_ID &&
-        entry.enabled === true &&
-        entry.version === SQUARE_IDENTITY.packageVersion;
-}
-function claudeProtocol(run) {
-    return {
-        host: 'claude',
-        marketplaceName: CLAUDE_MARKETPLACE_NAME,
-        pluginId: CLAUDE_PLUGIN_ID,
-        managedRoot: (homeDir) => path.join(homeDir, '.square', 'claude'),
-        stageBundle: stageClaudeBundle,
-        inspectInventory(homeDir) {
-            const result = run(homeDir, ['plugin', 'marketplace', 'list', '--json']);
-            requireSuccess(result, 'marketplace inventory');
-            return parseInventory(result.stdout);
-        },
-        registerMarketplace(homeDir, desired) {
-            const result = run(homeDir, ['plugin', 'marketplace', 'add', desired.marketplaceRoot]);
-            requireSuccess(result, 'marketplace install');
-        },
-        installOrUpdate(homeDir, desired) {
-            requireSuccess(run(homeDir, ['plugin', 'install', desired.pluginId]), 'plugin install');
-            requireSuccess(run(homeDir, ['plugin', 'update', desired.pluginId]), 'plugin update');
-        },
-        verifyPluginAndHooks(homeDir, desired) {
-            const hooksPath = path.join(desired.marketplaceRoot, 'plugins', SQUARE_IDENTITY.pluginName, 'hooks', 'hooks.json');
-            if (!fs.existsSync(hooksPath)) {
-                throw new Error(`Claude plugin hooks missing from ${desired.marketplaceRoot}`);
-            }
-            const listed = run(homeDir, ['plugin', 'list', '--json']);
-            requireSuccess(listed, 'plugin inventory');
-            const plugins = parseClaudePluginInventory(listed.stdout);
-            if (!plugins.some(isVerifiedClaudePlugin)) {
-                throw new Error(`Claude did not verify ${CLAUDE_PLUGIN_ID} as installed and enabled.`);
-            }
-        },
-        removePlugin(homeDir, pluginId) {
-            const result = run(homeDir, ['plugin', 'remove', pluginId]);
-            const isMissing = result.stderr.includes('is not configured or installed');
-            if (result.status !== 0 && !isMissing) {
-                requireSuccess(result, 'plugin removal');
-            }
-        },
-        removeMarketplace(homeDir, marketplaceName) {
-            const result = run(homeDir, ['plugin', 'marketplace', 'remove', marketplaceName]);
-            const isMissing = result.stderr.includes('is not configured or installed');
-            if (result.status !== 0 && !isMissing) {
-                requireSuccess(result, 'marketplace removal');
-            }
-        },
-        removeManagedSource(source) {
-            fs.rmSync(source, { recursive: true, force: true });
-        },
-        retireDirectDelivery(homeDir) {
-            const legacySkill = path.join(homeDir, '.claude', 'skills', 'square');
-            try {
-                if (fs.lstatSync(legacySkill).isSymbolicLink()) {
-                    fs.rmSync(legacySkill, { force: true });
-                }
-            }
-            catch { }
-        },
-        removeManagedRoot(homeDir) {
-            fs.rmSync(path.join(homeDir, '.square', 'claude'), { recursive: true, force: true });
-        },
-    };
-}
-export async function installClaudePlugin(homeDir, run = runClaudeCommand) {
-    const protocol = claudeProtocol(run);
-    const inventory = await reconcileInstall(homeDir, protocol);
-    const managedRoot = protocol.managedRoot(homeDir);
-    const marketplaceRoot = inventory.marketplaces.find((entry) => isCurrentManagedMarketplace(entry, managedRoot))?.source ?? claudeMarketplaceRoot(homeDir);
-    const pluginRoot = path.join(marketplaceRoot, 'plugins', SQUARE_IDENTITY.pluginName);
-    return { marketplaceRoot, pluginRoot };
-}
-export async function uninstallClaudePlugin(homeDir, run = runClaudeCommand) {
-    const base = claudeProtocol(run);
-    const protocol = {
-        ...base,
-        async inspectInventory(currentHome) {
-            const inventory = await base.inspectInventory(currentHome);
-            const managedRoot = base.managedRoot(currentHome);
-            const hasManagedMarketplace = inventory.marketplaces.some((entry) => entry.local && isManagedSource(managedRoot, entry.source));
-            if (hasManagedMarketplace)
-                return inventory;
-            const fallback = {
-                name: CLAUDE_MARKETPLACE_NAME,
-                source: claudeMarketplaceRoot(currentHome),
-                local: true,
-                pluginIds: [CLAUDE_PLUGIN_ID],
-            };
-            return { marketplaces: [...inventory.marketplaces, fallback] };
-        },
-    };
-    await reconcileUninstall(homeDir, protocol);
-    return { paths: [claudeMarketplaceRoot(homeDir)], notes: [] };
-}
-export async function doctorClaudePlugin(homeDir, run = runClaudeCommand) {
-    const protocol = claudeProtocol(run);
-    const inventory = await protocol.inspectInventory(homeDir);
-    const managedRoot = protocol.managedRoot(homeDir);
-    const current = inventory.marketplaces.find((entry) => isCurrentManagedMarketplace(entry, managedRoot));
-    const root = current?.source ?? claudeMarketplaceRoot(homeDir);
-    const desired = {
-        marketplaceName: CLAUDE_MARKETPLACE_NAME,
-        marketplaceRoot: root,
-        pluginId: CLAUDE_PLUGIN_ID,
-    };
-    const stale = staleManagedRegistrations(inventory, managedRoot, desired);
-    let pluginStatus;
+    return { marketplaceRoot, pluginRoot: path.join(marketplaceRoot, 'plugins', SQUARE_IDENTITY.pluginName) };
+}
+export async function uninstallClaudePlugin(homeDir, run = runClaude) {
+    const root = claudeMarketplaceRoot(homeDir);
+    requireSuccess(run(homeDir, ['plugin', 'remove', CLAUDE_PLUGIN_ID]), 'plugin removal', true);
+    requireSuccess(run(homeDir, ['plugin', 'marketplace', 'remove', CLAUDE_MARKETPLACE_NAME]), 'marketplace removal', true);
+    fs.rmSync(root, { recursive: true, force: true });
+    return { paths: [root], notes: [] };
+}
+export async function doctorClaudePlugin(homeDir, run = runClaude) {
+    const root = claudeMarketplaceRoot(homeDir);
+    const bundle = path.join(root, 'plugins', SQUARE_IDENTITY.pluginName);
     const listed = run(homeDir, ['plugin', 'list', '--json']);
-    if (listed.status !== 0) {
-        pluginStatus = `○ ${CLAUDE_PLUGIN_ID} plugin inventory unavailable`;
-    }
-    else {
-        try {
-            const plugins = parseClaudePluginInventory(listed.stdout);
-            const valid = plugins.some(isVerifiedClaudePlugin);
-            pluginStatus = valid
-                ? `✓ ${CLAUDE_PLUGIN_ID} installed, enabled, and version ${SQUARE_IDENTITY.packageVersion}`
-                : `○ ${CLAUDE_PLUGIN_ID} is not installed, enabled, and version ${SQUARE_IDENTITY.packageVersion}`;
-        }
-        catch {
-            pluginStatus = `○ ${CLAUDE_PLUGIN_ID} plugin inventory unavailable`;
-        }
-    }
-    const bundlePath = path.join(root, 'plugins', SQUARE_IDENTITY.pluginName);
-    const bundleStatus = fs.existsSync(bundlePath)
-        ? `✓ Square Claude plugin bundle ${root}`
-        : `○ Square Claude plugin bundle missing ${root}`;
-    const marketplaceStatus = current !== undefined
-        ? `✓ ${CLAUDE_PLUGIN_ID} marketplace registered`
-        : `○ ${CLAUDE_PLUGIN_ID} marketplace is not registered`;
+    const installed = listed.status === 0 && listed.stdout.includes(CLAUDE_PLUGIN_ID);
     return [
-        bundleStatus,
-        marketplaceStatus,
-        pluginStatus,
-        ...(stale.length === 0 ? [] : [`✕ ${stale.length} stale Square marketplace registration(s)`]),
+        fs.existsSync(bundle) ? `✓ Square Claude plugin bundle ${root}` : `○ Square Claude plugin bundle missing ${root}`,
+        installed ? `✓ ${CLAUDE_PLUGIN_ID} installed` : `○ ${CLAUDE_PLUGIN_ID} unavailable`,
     ];
 }
-export const claudeHarness = Object.freeze({ install: installClaudePlugin, uninstall: uninstallClaudePlugin, doctor: doctorClaudePlugin });