@astrosheep/square 0.3.7 → 0.3.9

package/codex-plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "description": "Shared Square activity with reliable participant attention at Codex boundaries.",
   "author": {
     "name": "Square"

package/dist/cli/context.js

@@ -133,7 +133,7 @@ export function parseGlobalArgs(rawArgs) {
         validateName(name);
     const explicitSquarePath = requestedPath !== undefined;
     const command = args[0];
-    const resolved = !explicitSquarePath && !['ls', 'list', 'version'].includes(command ?? '')
+    const resolved = !explicitSquarePath && !['ls', 'list', 'version', 'install', 'uninstall'].includes(command ?? '')
         ? resolveDefaultSquarePath()
         : { path: requestedPath ?? DEFAULT_SQUARE_PATH, multiple: false };
     return { squarePath: resolved.path, explicitSquarePath, multipleSquares: resolved.multiple, name, args };

package/dist/cli/harness-command.js

@@ -1,34 +1,77 @@
 import os from 'node:os';
 import { executeHarnessTarget, harnessTargets, } from '../harness.js';
+function installTargets(intent, action) {
+    const available = harnessTargets().filter((target) => target.capabilities.includes(action));
+    const names = intent.all ? available.map((target) => target.name) : [...new Set(intent.targets)];
+    if (names.length === 0)
+        throw new Error(`${action} requires one or more targets, or --all`);
+    for (const name of names) {
+        if (!available.some((target) => target.name === name)) {
+            throw new Error(`Unknown ${action} target: ${name}`);
+        }
+    }
+    return names;
+}
+function parseInstall(argv, action) {
+    const all = argv.includes('--all');
+    const force = argv.includes('-f') || argv.includes('--force');
+    const allowedOptions = action === 'install' ? ['--all', '-f', '--force'] : ['--all'];
+    const option = argv.find((argument) => argument.startsWith('-') && !allowedOptions.includes(argument));
+    if (option !== undefined)
+        throw new Error(`Unknown ${action} option: ${option}`);
+    if (action === 'uninstall' && force)
+        throw new Error(`Unknown uninstall option: ${argv.find((item) => item === '-f' || item === '--force')}`);
+    const targets = argv.filter((argument) => !argument.startsWith('-'));
+    if (all && targets.length > 0)
+        throw new Error(`Cannot combine ${action} --all with named targets`);
+    return { targets, all, force };
+}
+function targetCommand(action) {
+    return {
+        parse(argv) { return parseInstall(argv, action); },
+        async execute(intent, context) {
+            const results = [];
+            for (const target of installTargets(intent, action)) {
+                results.push(await executeHarnessTarget(target, action, {
+                    homeDir: context.homeDir,
+                    squarePath: context.squarePath,
+                    force: intent.force,
+                }));
+            }
+            return {
+                notes: results.flatMap((result) => result.notes),
+                lines: results.flatMap((result) => result.lines),
+            };
+        },
+        present(result) { process.stdout.write(formatHarnessResult(result)); },
+    };
+}
+export const installCommand = targetCommand('install');
+export const uninstallCommand = targetCommand('uninstall');
 export const harnessCommand = {
     parse(argv) {
-        const action = argv[0];
-        if (action !== 'install' && action !== 'uninstall' && action !== 'doctor') {
-            throw new Error('harness requires install, uninstall, or doctor');
-        }
+        if (argv[0] !== 'doctor')
+            throw new Error('harness only supports doctor');
         const rest = argv.slice(1);
-        const option = rest.find((argument) => argument.startsWith('-') && argument !== '-f' && argument !== '--force');
+        const option = rest.find((argument) => argument.startsWith('-'));
         if (option !== undefined)
             throw new Error(`Unknown harness option: ${option}`);
+        if (rest.length > 1)
+            throw new Error('harness doctor accepts at most one target');
         return {
-            action,
-            target: rest.find((argument) => !argument.startsWith('-')),
-            force: rest.includes('-f') || rest.includes('--force'),
+            target: rest[0],
         };
     },
     async execute(intent, context) {
-        if (intent.target === undefined && intent.action !== 'doctor') {
-            throw new Error('harness install/uninstall requires an explicit target: skills | claude | codex | opencode | pi');
-        }
         const targetNames = intent.target === undefined
             ? harnessTargets().map((target) => target.name)
             : [intent.target];
         const results = [];
         for (const target of targetNames) {
-            results.push(await executeHarnessTarget(target, intent.action, {
+            results.push(await executeHarnessTarget(target, 'doctor', {
                 homeDir: context.homeDir,
                 squarePath: context.squarePath,
-                force: intent.force,
+                force: false,
             }));
         }
         return {

package/dist/cli/registry.js

@@ -1,6 +1,6 @@
 import { buildCommand, compactCommand, doneCommand, expressCommand, holdCommand, joinCommand, resumeCommand } from './square-commands.js';
 import { doctorCommand } from './maintenance-commands.js';
-import { harnessCommand } from './harness-command.js';
+import { harnessCommand, installCommand, uninstallCommand } from './harness-command.js';
 import { helpCommand, versionCommand } from './meta-commands.js';
 import { catchCommand, claudeHookCommand, codexHookCommand, historyCommand, inboxCommand, listCommand, participantsCommand, statusCommand, streamCommand, warmupCommand, } from './observation-commands.js';
 /** Every public command is an executable adapter, including aliases and utility commands. */
@@ -17,6 +17,8 @@ export const commandRegistry = [
     { names: ['done'], spec: doneCommand },
     { names: ['hold'], spec: holdCommand },
     { names: ['resume'], spec: resumeCommand },
+    { names: ['install'], spec: installCommand },
+    { names: ['uninstall'], spec: uninstallCommand },
     { names: ['harness'], spec: harnessCommand },
     { names: ['compact'], spec: compactCommand },
     { names: ['doctor'], spec: doctorCommand },

package/dist/harness-claude.js

@@ -33,6 +33,7 @@ export async function installClaudePlugin(homeDir, run = runClaude) {
         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,
+            owner: { name: 'Square' },
             plugins: [{ name: SQUARE_IDENTITY.pluginName, source: './plugins/square' }],
         });
     });

package/dist/harness-codex.js

@@ -12,8 +12,33 @@ 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 configuredMarketplaceRoot(homeDir, configText) {
+    const lines = configText.split('\n');
+    const header = `[marketplaces.${CODEX_MARKETPLACE_NAME}]`;
+    const start = lines.findIndex((line) => line.trim() === header);
+    if (start < 0)
+        return undefined;
+    const end = lines.findIndex((line, index) => index > start && /^\s*\[[^\]]+\]/.test(line));
+    const section = lines.slice(start + 1, end < 0 ? undefined : end);
+    const sourceType = section.find((line) => /^\s*source_type\s*=/.test(line));
+    if (sourceType && !/=\s*["']local["']\s*$/.test(sourceType))
+        return undefined;
+    const source = section.find((line) => /^\s*source\s*=/.test(line));
+    const match = source?.match(/^\s*source\s*=\s*("(?:\\.|[^"])*"|'[^']*')\s*$/);
+    if (!match)
+        return undefined;
+    const value = match[1].startsWith('"') ? JSON.parse(match[1]) : match[1].slice(1, -1);
+    return path.isAbsolute(value) ? value : path.resolve(codexHome(homeDir), value);
+}
+function activeMarketplaceRoot(homeDir, configText) {
+    return configuredMarketplaceRoot(homeDir, configText) ?? codexMarketplaceRoot(homeDir);
+}
+export function codexPluginRoot(homeDir, marketplaceRoot = codexMarketplaceRoot(homeDir)) {
+    return path.join(marketplaceRoot, 'plugins', SQUARE_IDENTITY.pluginName);
+}
+export function codexPluginHooksPath(homeDir, marketplaceRoot = codexMarketplaceRoot(homeDir)) {
+    return path.join(codexPluginRoot(homeDir, marketplaceRoot), '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'); }
@@ -53,9 +78,9 @@ function writeAtomic(file, text) {
     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 root = activeMarketplaceRoot(homeDir, current);
     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 });
@@ -88,7 +113,7 @@ export async function installCodexPlugin(homeDir, run = runCodex) {
             notes.push(`retired ${pluginId}`);
         }
         staged.finalize();
-        return { configPath: config, marketplaceRoot: root, pluginRoot: codexPluginRoot(homeDir), ...(installedPath ? { installedPath } : {}), notes };
+        return { configPath: config, marketplaceRoot: root, pluginRoot: codexPluginRoot(homeDir, root), ...(installedPath ? { installedPath } : {}), notes };
     }
     catch (error) {
         staged.rollback();
@@ -96,24 +121,27 @@ export async function installCodexPlugin(homeDir, run = runCodex) {
     }
 }
 export async function uninstallCodexPlugin(homeDir, run = runCodex) {
+    const config = codexConfigPath(homeDir);
+    const current = fs.existsSync(config) ? fs.readFileSync(config, 'utf8') : '';
+    const root = activeMarketplaceRoot(homeDir, current);
     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 current = fs.existsSync(config) ? fs.readFileSync(config, 'utf8') : '';
+    const root = activeMarketplaceRoot(homeDir, current);
     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}`,
+        /^hooks\s*=\s*true$/m.test(current) ? `✓ features.hooks=true in ${config}` : `○ features.hooks missing in ${config}`,
+        fs.existsSync(codexPluginHooksPath(homeDir, root)) ? `✓ Square plugin hooks ${codexPluginHooksPath(homeDir, root)}` : `○ 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

@@ -22,17 +22,21 @@ export function installHarnessLinks(links, force = false) {
         if (!fs.existsSync(link.source)) {
             throw new Error(`Harness link source is missing: ${link.source}`);
         }
+        const existing = lstatMaybe(link.target);
         return {
             ...link,
-            existing: lstatMaybe(link.target),
+            existing,
             sourceIsDirectory: fs.statSync(link.source).isDirectory(),
+            alreadyManaged: existing !== undefined && sameLink(link.source, link.target),
         };
     });
-    for (const { target, existing } of prepared) {
-        if (existing !== undefined && !force)
+    for (const { target, existing, alreadyManaged } of prepared) {
+        if (existing !== undefined && !alreadyManaged && !force)
             throw new Error(`Refusing to overwrite existing link: ${target}\nPass -f to replace it.`);
     }
-    for (const { source, target, existing, sourceIsDirectory } of prepared) {
+    for (const { source, target, existing, sourceIsDirectory, alreadyManaged } of prepared) {
+        if (alreadyManaged)
+            continue;
         fs.mkdirSync(path.dirname(target), { recursive: true });
         if (existing !== undefined)
             fs.rmSync(target, { recursive: true, force: true });

package/dist/help.js

@@ -48,9 +48,19 @@ const COMMANDS = [
     { names: ['hold'], usage: '--as <name> hold [reason | -]', usesSquare: true, group: 'participant', summary: 'Raise a hand and pause participant activity.' },
     { names: ['resume'], usage: '--as <name> resume', usesSquare: true, group: 'participant', summary: 'Lower the raised hand and resume activity.' },
     {
-        names: ['harness'], usage: 'harness <install <skills|claude|codex|opencode|pi> [-f] | uninstall <skills|claude|codex|opencode|pi> | doctor [skills|claude|codex|opencode|pi|delivery]>', usesSquare: true, group: 'maintenance',
-        summary: 'Install, remove, or diagnose official harness adapters.',
-        details: ['Targets:', '  skills, claude, codex, opencode, pi  Install, remove, or diagnose one adapter.', '  delivery                              Diagnose delivery only; skips when no readable artifact is selected.'],
+        names: ['install'], usage: 'install (--all | <target>...) [-f]', group: 'maintenance',
+        summary: 'Install Square support for one or more agent hosts.',
+        details: ['Targets:', '  skills, claude, codex, opencode, pi', '', 'Options:', '  --all       Install every supported target.', '  -f, --force Replace existing managed links.'],
+    },
+    {
+        names: ['uninstall'], usage: 'uninstall (--all | <target>...)', group: 'maintenance',
+        summary: 'Remove Square support from one or more agent hosts.',
+        details: ['Targets:', '  skills, claude, codex, opencode, pi', '', 'Options:', '  --all  Remove every supported target.'],
+    },
+    {
+        names: ['harness'], usage: 'harness doctor [skills|claude|codex|opencode|pi|delivery]', usesSquare: true, group: 'maintenance', hiddenFromIndex: true,
+        summary: 'Diagnose installed agent-host support.',
+        details: ['Targets:', '  skills, claude, codex, opencode, pi  Diagnose one installed adapter.', '  delivery                              Diagnose delivery for the selected square.'],
     },
     { names: ['compact'], usage: 'compact [--keep N]', usesSquare: true, group: 'host', summary: 'Move older activity out of the working artifact while keeping the latest N.' },
     {
@@ -69,7 +79,7 @@ export function renderGlobalHelp() {
     const groups = [
         { key: 'participant', title: 'In the square:', order: ['join', 'express', 'catch', 'history', 'status', 'hold', 'resume', 'done'] },
         { key: 'host', title: 'Prepare and manage:', order: ['build', 'list', 'participants', 'warmup', 'compact'] },
-        { key: 'maintenance', title: 'Setup and repair:', order: ['harness', 'doctor'] },
+        { key: 'maintenance', title: 'Setup and repair:', order: ['install', 'uninstall', 'doctor'] },
     ];
     const commandLines = groups.flatMap(({ key, title, order }) => [
         title,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/square",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "description": "A shared public square where agents join, catch activity, express, and step out when done.",
   "type": "module",
   "bin": {

package/skills/square/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "description": "Native Claude Code turn-boundary delivery for Square participants",
   "author": {
     "name": "Square"