@webpresso/agent-kit 0.21.0

package/dist/esm/cli/commands/init/scaffolders/gstack/index.js

@@ -0,0 +1,228 @@
+/**
+ * `gstack` scaffolder preset.
+ *
+ * gstack uses a canonical checkout installed at `~/.claude/skills/gstack/`.
+ * Agent-kit owns that checkout bootstrap, then lets gstack's own host-aware
+ * setup command materialize additional surfaces such as Codex from the same
+ * checkout.
+ *
+ * Detection for the canonical checkout is path-based, NOT PATH-based: gstack
+ * itself is not a CLI binary on $PATH. Checkout bootstrap is a clone +
+ * `./setup --team`. When Codex is detected, webpresso runs gstack's explicit
+ * `./setup --host codex --team` flow from that same checkout so Codex is
+ * materialized without accidentally fanning out to every host binary on PATH.
+ *
+ * Side-effect outside the consumer repo: writes to the user's home dir.
+ * This is intentional — gstack is global by design.
+ */
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { makeNoopSpinnerFactory } from '#cli/commands/init/scaffolders/spinner';
+const GSTACK_REPO = 'https://github.com/garrytan/gstack.git';
+function defaultInstallRoot() {
+    return path.join(process.env.HOME || homedir(), '.claude', 'skills', 'gstack');
+}
+function defaultCodexConfigPath() {
+    return path.join(process.env.HOME || homedir(), '.codex', 'config.toml');
+}
+function defaultCodexSkillsRoot() {
+    return path.join(process.env.HOME || homedir(), '.codex', 'skills');
+}
+function formatDurationMs(ms) {
+    return ms >= 1000 ? `${(ms / 1000).toFixed(1)}s` : `${ms}ms`;
+}
+function isVerboseGstack(env) {
+    return env.WP_VERBOSE_GSTACK === '1';
+}
+function parseHostList(value) {
+    const hosts = value
+        .split(',')
+        .map((host) => host.trim())
+        .filter(Boolean);
+    if (hosts.length === 0)
+        return null;
+    if (hosts.includes('auto'))
+        return ['auto'];
+    if (hosts.some((host) => host !== 'claude' && host !== 'codex'))
+        return null;
+    return [...new Set(hosts)];
+}
+function resolveSetupSteps(input) {
+    const explicitHosts = input.env.WP_GSTACK_HOSTS?.trim();
+    if (explicitHosts) {
+        const parsed = parseHostList(explicitHosts);
+        if (!parsed) {
+            input.log(`  gstack: ignoring invalid WP_GSTACK_HOSTS=${JSON.stringify(explicitHosts)}; falling back to default fast mode`);
+        }
+        else {
+            return parsed.map((host) => host === 'claude'
+                ? {
+                    args: ['--team'],
+                    command: '--team',
+                    label: 'refreshing Claude/team integration',
+                }
+                : host === 'codex'
+                    ? {
+                        args: ['--host', 'codex', '--team'],
+                        command: '--host codex --team',
+                        label: 'refreshing Codex integration',
+                    }
+                    : {
+                        args: ['--host', 'auto', '--team'],
+                        command: '--host auto --team',
+                        label: 'refreshing all detected gstack hosts',
+                    });
+        }
+    }
+    if (input.env.WP_GSTACK_MODE === 'full') {
+        return [
+            {
+                args: ['--host', 'auto', '--team'],
+                command: '--host auto --team',
+                label: 'refreshing all detected gstack hosts',
+            },
+        ];
+    }
+    const steps = [
+        {
+            args: ['--team'],
+            command: '--team',
+            label: 'refreshing Claude/team integration',
+        },
+    ];
+    if (input.codexDetected) {
+        steps.push({
+            args: ['--host', 'codex', '--team'],
+            command: '--host codex --team',
+            label: 'refreshing Codex integration',
+        });
+    }
+    return steps;
+}
+function runSetup(root, spawn, step, env, log, now) {
+    const startedAt = now();
+    const verbose = isVerboseGstack(env);
+    const args = verbose ? step.args : [...step.args, '--quiet'];
+    log(`  gstack: ${step.label}...`);
+    const result = spawn('./setup', args, { cwd: root, stdio: 'inherit' });
+    if (result.status === 0) {
+        log(`  gstack: ${step.label} done (${formatDurationMs(now() - startedAt)})`);
+    }
+    return {
+        ok: result.status === 0,
+        exitCode: result.status ?? -1,
+        command: step.command,
+    };
+}
+function defaultDetectCodex(input) {
+    if (input.exists(input.codexConfigPath))
+        return true;
+    const probe = input.spawn('codex', ['--version'], { stdio: 'ignore' });
+    return probe.status === 0;
+}
+/**
+ * Ensure gstack is installed and up-to-date.
+ * - Not present: clone from main + setup.
+ * - Already present: pull latest main + re-run setup.
+ * - If Codex is detected: materialize Codex skills from the canonical checkout.
+ */
+export function ensureGstack(input) {
+    if (input.options.dryRun)
+        return { kind: 'gstack-skipped-dry-run' };
+    const spawn = input.spawn ?? spawnSync;
+    const exists = input.exists ?? existsSync;
+    const detectCodex = input.detectCodex ?? defaultDetectCodex;
+    const env = input.env ?? process.env;
+    const log = input.log ?? console.log;
+    const now = input.now ?? Date.now;
+    const root = input.installRoot ?? defaultInstallRoot();
+    const codexConfigPath = input.codexConfigPath ?? defaultCodexConfigPath();
+    const codexSkillsRoot = input.codexSkillsRoot ?? defaultCodexSkillsRoot();
+    const spinner = (input.spinnerFactory ?? makeNoopSpinnerFactory())('gstack');
+    const hasSetup = exists(path.join(root, 'setup'));
+    const hasGitDir = exists(path.join(root, '.git'));
+    const codexDetected = detectCodex({
+        spawn,
+        exists,
+        codexConfigPath,
+    });
+    const hadCodexSkills = exists(path.join(codexSkillsRoot, 'gstack'));
+    const steps = resolveSetupSteps({ codexDetected, env, log });
+    const requestsCodex = steps.some((step) => step.command === '--host codex --team');
+    const usesAutoHosts = steps.some((step) => step.command === '--host auto --team');
+    const finalizeCodexResult = () => {
+        if (requestsCodex) {
+            return hadCodexSkills
+                ? { kind: 'gstack-codex-updated', skillsRoot: codexSkillsRoot }
+                : { kind: 'gstack-codex-installed', skillsRoot: codexSkillsRoot };
+        }
+        if (usesAutoHosts) {
+            if (!codexDetected) {
+                return {
+                    kind: 'gstack-codex-skipped',
+                    reason: 'not-detected',
+                    skillsRoot: codexSkillsRoot,
+                };
+            }
+            return hadCodexSkills
+                ? { kind: 'gstack-codex-updated', skillsRoot: codexSkillsRoot }
+                : { kind: 'gstack-codex-installed', skillsRoot: codexSkillsRoot };
+        }
+        if (!codexDetected) {
+            return {
+                kind: 'gstack-codex-skipped',
+                reason: 'not-detected',
+                skillsRoot: codexSkillsRoot,
+            };
+        }
+        return {
+            kind: 'gstack-codex-skipped',
+            reason: 'not-requested',
+            skillsRoot: codexSkillsRoot,
+        };
+    };
+    if (hasSetup) {
+        if (hasGitDir) {
+            spinner.start();
+            const pull = spawn('git', ['pull', '--ff-only', 'origin', 'main'], {
+                cwd: root,
+                stdio: 'inherit',
+            });
+            if (pull.status !== 0) {
+                spinner.fail('gstack pull failed');
+                return { kind: 'gstack-pull-failed', exitCode: pull.status ?? -1 };
+            }
+        }
+        for (const step of steps) {
+            const setup = runSetup(root, spawn, step, env, log, now);
+            if (!setup.ok) {
+                spinner.fail(step.command === '--team' ? 'gstack setup failed' : 'gstack codex setup failed');
+                return { kind: 'gstack-setup-failed', exitCode: setup.exitCode, command: setup.command };
+            }
+        }
+        const codex = finalizeCodexResult();
+        spinner.succeed('gstack updated');
+        return { kind: 'gstack-updated', root, codex };
+    }
+    spinner.start();
+    const clone = spawn('git', ['clone', '--depth', '1', GSTACK_REPO, root], {
+        stdio: 'inherit',
+    });
+    if (clone.status !== 0) {
+        spinner.fail('gstack clone failed');
+        return { kind: 'gstack-clone-failed', exitCode: clone.status ?? -1 };
+    }
+    for (const step of steps) {
+        const setup = runSetup(root, spawn, step, env, log, now);
+        if (!setup.ok) {
+            spinner.fail(step.command === '--team' ? 'gstack setup failed' : 'gstack codex setup failed');
+            return { kind: 'gstack-setup-failed', exitCode: setup.exitCode, command: setup.command };
+        }
+    }
+    const codex = finalizeCodexResult();
+    spinner.succeed('gstack installed');
+    return { kind: 'gstack-installed', root, codex };
+}
+//# sourceMappingURL=index.js.map

package/dist/esm/cli/commands/init/scaffolders/lore-commits/index.d.ts

@@ -0,0 +1,12 @@
+import { type MergeOptions, type MergeResult } from '#cli/commands/init/merge';
+export interface ScaffoldLoreCommitsInput {
+    repoRoot: string;
+    options: MergeOptions;
+}
+/**
+ * Write the `.husky/commit-msg` hook for Lore trailer enforcement.
+ *
+ * Returns the merge result for the hook file.
+ */
+export declare function scaffoldLoreCommits(input: ScaffoldLoreCommitsInput): MergeResult;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/cli/commands/init/scaffolders/lore-commits/index.js

@@ -0,0 +1,24 @@
+/**
+ * `lore-commits` scaffolder preset.
+ *
+ * Writes a `.husky/commit-msg` hook that enforces Lore trailers via
+ * `wp audit commit-message --require-lore`.
+ *
+ * Safe to compose with `base-kit`: if the hook already exists with the
+ * correct content, it is a no-op.
+ */
+import path from 'node:path';
+import { writeFileMerged } from '#cli/commands/init/merge';
+const HOOK_CONTENT = `#!/bin/sh
+wp audit commit-message --require-lore --message-file "$1"
+`;
+/**
+ * Write the `.husky/commit-msg` hook for Lore trailer enforcement.
+ *
+ * Returns the merge result for the hook file.
+ */
+export function scaffoldLoreCommits(input) {
+    const hookPath = path.join(input.repoRoot, '.husky', 'commit-msg');
+    return writeFileMerged(hookPath, HOOK_CONTENT, input.options);
+}
+//# sourceMappingURL=index.js.map

package/dist/esm/cli/commands/init/scaffolders/omc/index.d.ts

@@ -0,0 +1,41 @@
+import type { MergeOptions } from '#cli/commands/init/merge';
+export declare const OMC_MARKETPLACE = "https://github.com/Yeachan-Heo/oh-my-claudecode";
+export declare const OMC_PLUGIN_ID = "oh-my-claudecode";
+export declare const OMC_SETUP_COMMAND = "/oh-my-claudecode:omc-setup";
+export type OmcSetupScope = 'user' | 'project';
+export interface EnsureOmcInput {
+    options: MergeOptions;
+    scope?: OmcSetupScope;
+    commandExists?: (command: string) => boolean;
+    runCommand?: (command: string, args: readonly string[]) => number;
+}
+export type EnsureOmcResult = {
+    kind: 'omc-installed';
+    pluginId: string;
+    scope: OmcSetupScope;
+} | {
+    kind: 'omc-skipped-dry-run';
+    scope: OmcSetupScope;
+} | {
+    kind: 'omc-skipped-opt-out';
+    scope: OmcSetupScope;
+} | {
+    kind: 'omc-skipped-no-cli';
+    scope: OmcSetupScope;
+} | {
+    kind: 'omc-failed';
+    pluginId: string;
+    scope: OmcSetupScope;
+    step: 'marketplace-add' | 'plugin-install';
+    exitCode: number;
+};
+/**
+ * Install/refresh Oh My ClaudeCode through Claude Code's plugin system.
+ *
+ * Upstream OMC does not support direct npm/bun installation; the supported
+ * path is Claude Code plugin marketplace add + plugin install, followed by the
+ * OMC setup skill inside Claude Code when the operator wants to materialize
+ * global/project CLAUDE.md defaults.
+ */
+export declare function ensureOmc(input: EnsureOmcInput): EnsureOmcResult;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/cli/commands/init/scaffolders/omc/index.js

@@ -0,0 +1,54 @@
+import { spawnSync } from 'node:child_process';
+export const OMC_MARKETPLACE = 'https://github.com/Yeachan-Heo/oh-my-claudecode';
+export const OMC_PLUGIN_ID = 'oh-my-claudecode';
+export const OMC_SETUP_COMMAND = '/oh-my-claudecode:omc-setup';
+function defaultCommandExists(command) {
+    const result = spawnSync('which', [command], { stdio: 'ignore' });
+    return result.status === 0;
+}
+function defaultRunCommand(command, args) {
+    const result = spawnSync(command, [...args], {
+        stdio: 'inherit',
+        env: process.env,
+    });
+    if (result.error)
+        throw result.error;
+    return result.status ?? 1;
+}
+/**
+ * Install/refresh Oh My ClaudeCode through Claude Code's plugin system.
+ *
+ * Upstream OMC does not support direct npm/bun installation; the supported
+ * path is Claude Code plugin marketplace add + plugin install, followed by the
+ * OMC setup skill inside Claude Code when the operator wants to materialize
+ * global/project CLAUDE.md defaults.
+ */
+export function ensureOmc(input) {
+    const scope = input.scope ?? 'user';
+    if (input.options.dryRun)
+        return { kind: 'omc-skipped-dry-run', scope };
+    if (process.env.WP_SKIP_OMC === '1')
+        return { kind: 'omc-skipped-opt-out', scope };
+    const commandExists = input.commandExists ?? defaultCommandExists;
+    if (!commandExists('claude'))
+        return { kind: 'omc-skipped-no-cli', scope };
+    const runCommand = input.runCommand ?? defaultRunCommand;
+    const steps = [
+        {
+            step: 'marketplace-add',
+            args: ['plugin', 'marketplace', 'add', '--scope', scope, OMC_MARKETPLACE],
+        },
+        {
+            step: 'plugin-install',
+            args: ['plugin', 'install', '--scope', scope, OMC_PLUGIN_ID],
+        },
+    ];
+    for (const { step, args } of steps) {
+        const exitCode = runCommand('claude', args);
+        if (exitCode !== 0) {
+            return { kind: 'omc-failed', pluginId: OMC_PLUGIN_ID, scope, step, exitCode };
+        }
+    }
+    return { kind: 'omc-installed', pluginId: OMC_PLUGIN_ID, scope };
+}
+//# sourceMappingURL=index.js.map

package/dist/esm/cli/commands/init/scaffolders/omx/index.d.ts

@@ -0,0 +1,63 @@
+/**
+ * `omx` scaffolder preset.
+ *
+ * Ensures `omx` is installed, then chains `omx setup --yes --scope user` after the
+ * webpresso scaffold completes. OMX (oh-my-codex) is the operator-workflow
+ * execution layer; it manages its own scaffolding idempotently.
+ *
+ * Required when downstream features rely on `omx team` (see
+ * `cli/commands/blueprint/execution.ts`).
+ */
+import { spawnSync } from 'node:child_process';
+import type { MergeOptions } from '#cli/commands/init/merge';
+export interface EnsureOmxInput {
+    repoRoot: string;
+    options: MergeOptions;
+    scope?: OmxSetupScope;
+    /** Dependency-injection seam for tests; defaults to node's child_process.spawnSync. */
+    spawn?: typeof spawnSync;
+    /** Test seam — override `$CODEX_HOME/config.toml` or `~/.codex/config.toml`. */
+    configPath?: string;
+}
+export type EnsureOmxResult = {
+    kind: 'omx-ok';
+    installed: boolean;
+    removedProjectFiles: string[];
+    codexGlobalHooks: {
+        readonly repaired: boolean;
+        readonly targetPath: string;
+    };
+} | {
+    kind: 'omx-skipped-dry-run';
+} | {
+    kind: 'omx-not-found';
+    hint: string;
+} | {
+    kind: 'omx-spawn-failed';
+    exitCode: number;
+};
+type OmxSetupScope = 'user' | 'project';
+/**
+ * Removes ALL hook trust state blocks when duplicate `[hooks.state."..."]` keys
+ * are detected.
+ *
+ * The TOML spec forbids duplicate keys; Codex CLI rejects the config outright.
+ * Older OMX versions wrote blocks terminated by `# End OMX-owned Codex hook
+ * trust state` but without a leading start marker. OMX's own
+ * `stripManagedCodexHookTrustState` only strips START→END bounded blocks, so
+ * legacy entries accumulate on every `wp setup` run.
+ *
+ * Detection contract: count unique vs total `[hooks.state."..."]` section
+ * headers. If any key appears more than once the file is TOML-invalid. When
+ * duplicates exist we strip all hook trust content (entries + OMX block marker
+ * comments) so `omx setup --yes --scope user` can rewrite exactly one clean managed block.
+ */
+export declare function deduplicateCodexHookTrustState(config: string): string;
+export declare function migrateDeprecatedCodexHooksFeatureFlag(raw: string): string;
+/**
+ * Ensure `omx` is on PATH then run `omx setup --yes --scope user` in the consumer repo.
+ * Idempotent: safe to run on every `wp setup`.
+ */
+export declare function ensureOmx(input: EnsureOmxInput): EnsureOmxResult;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/cli/commands/init/scaffolders/omx/index.js

@@ -0,0 +1,251 @@
+/**
+ * `omx` scaffolder preset.
+ *
+ * Ensures `omx` is installed, then chains `omx setup --yes --scope user` after the
+ * webpresso scaffold completes. OMX (oh-my-codex) is the operator-workflow
+ * execution layer; it manages its own scaffolding idempotently.
+ *
+ * Required when downstream features rely on `omx team` (see
+ * `cli/commands/blueprint/execution.ts`).
+ */
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, rmdirSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve, sep } from 'node:path';
+import { defaultCodexHooksPathFromConfig, normalizeGlobalCodexHooksFile, resolveBinaryOnPath, } from '#cli/commands/init/scaffolders/agent-hooks/codex-global-normalize';
+const NOT_FOUND_HINT = 'omx (oh-my-codex) is not on PATH after `vp install -g oh-my-codex`. Install it manually and re-run.';
+function shouldSkipOmxRefresh(env = process.env) {
+    return env.WP_SKIP_UPDATE_CHECK === '1';
+}
+function defaultCodexConfigPath() {
+    const codexHome = process.env.CODEX_HOME || join(process.env.HOME || homedir(), '.codex');
+    return join(codexHome, 'config.toml');
+}
+/** Matches any `[hooks.state."<key>"]` TOML section header written by OMX. */
+const HOOK_STATE_SECTION_RE = /^\[hooks\.state\.".+"\]$/;
+/**
+ * Removes ALL hook trust state blocks when duplicate `[hooks.state."..."]` keys
+ * are detected.
+ *
+ * The TOML spec forbids duplicate keys; Codex CLI rejects the config outright.
+ * Older OMX versions wrote blocks terminated by `# End OMX-owned Codex hook
+ * trust state` but without a leading start marker. OMX's own
+ * `stripManagedCodexHookTrustState` only strips START→END bounded blocks, so
+ * legacy entries accumulate on every `wp setup` run.
+ *
+ * Detection contract: count unique vs total `[hooks.state."..."]` section
+ * headers. If any key appears more than once the file is TOML-invalid. When
+ * duplicates exist we strip all hook trust content (entries + OMX block marker
+ * comments) so `omx setup --yes --scope user` can rewrite exactly one clean managed block.
+ */
+export function deduplicateCodexHookTrustState(config) {
+    const allKeys = [...config.matchAll(/^\[hooks\.state\.".+"\]$/gm)].map((m) => m[0]);
+    if (allKeys.length === new Set(allKeys).size)
+        return config;
+    const lines = config.split(/\r?\n/);
+    const kept = [];
+    let i = 0;
+    while (i < lines.length) {
+        const trimmed = lines[i].trim();
+        if (HOOK_STATE_SECTION_RE.test(trimmed)) {
+            i += 1;
+            if (i < lines.length && /^trusted_hash\s*=/.test(lines[i]?.trim() ?? '')) {
+                i += 1;
+            }
+            continue;
+        }
+        // Strip OMX block-marker comment lines by prefix — resilient to minor wording changes.
+        if (trimmed.startsWith('# OMX-owned Codex hook trust state') ||
+            trimmed.startsWith('# End OMX-owned Codex hook trust state') ||
+            trimmed === '# Trusts only setup-managed codex-native-hook.js wrappers.') {
+            i += 1;
+            continue;
+        }
+        kept.push(lines[i]);
+        i += 1;
+    }
+    return (kept
+        .join('\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trimEnd() + '\n');
+}
+export function migrateDeprecatedCodexHooksFeatureFlag(raw) {
+    const lines = raw.split(/\r?\n/);
+    const featuresStart = lines.findIndex((line) => /^\s*\[features\]\s*$/.test(line));
+    if (featuresStart < 0)
+        return raw;
+    let sectionEnd = lines.length;
+    for (let i = featuresStart + 1; i < lines.length; i += 1) {
+        if (/^\s*\[\[?[^\]]+\]?\]\s*$/.test(lines[i])) {
+            sectionEnd = i;
+            break;
+        }
+    }
+    let hooksIdx = -1;
+    let codexHooksIdx = -1;
+    let codexHooksValue = 'true';
+    let codexHooksIndent = '';
+    for (let i = featuresStart + 1; i < sectionEnd; i += 1) {
+        const line = lines[i];
+        if (/^\s*hooks\s*=/.test(line)) {
+            hooksIdx = i;
+            continue;
+        }
+        const match = line.match(/^(\s*)codex_hooks\s*=\s*(.+)$/);
+        if (!match)
+            continue;
+        codexHooksIdx = i;
+        codexHooksIndent = match[1] ?? '';
+        codexHooksValue = match[2] ?? 'true';
+    }
+    if (codexHooksIdx < 0)
+        return raw;
+    const replacement = `${codexHooksIndent}hooks = ${codexHooksValue}`;
+    if (hooksIdx >= 0) {
+        const nextLines = [...lines];
+        nextLines[hooksIdx] = replacement;
+        return nextLines
+            .filter((line, idx) => idx === hooksIdx || !/^\s*codex_hooks\s*=/.test(line))
+            .join('\n');
+    }
+    return lines
+        .flatMap((line, idx) => {
+        if (idx === codexHooksIdx)
+            return [replacement];
+        if (/^\s*codex_hooks\s*=/.test(line))
+            return [];
+        return [line];
+    })
+        .join('\n');
+}
+function migrateDeprecatedCodexHooksFeatureFlagInConfig(configPath) {
+    if (!existsSync(configPath))
+        return;
+    const existing = readFileSync(configPath, 'utf8');
+    const next = migrateDeprecatedCodexHooksFeatureFlag(existing);
+    if (next === existing)
+        return;
+    mkdirSync(dirname(configPath), { recursive: true });
+    writeFileSync(configPath, next, 'utf8');
+}
+function readPersistedOmxSetupScope(repoRoot) {
+    const scopePath = join(repoRoot, '.omx', 'setup-scope.json');
+    if (!existsSync(scopePath))
+        return undefined;
+    const parsed = JSON.parse(readFileSync(scopePath, 'utf8'));
+    if (parsed.scope === 'project' || parsed.scope === 'project-local')
+        return 'project';
+    if (parsed.scope === 'user')
+        return 'user';
+    return undefined;
+}
+function removeTrackedProjectScopedOmxFiles(repoRoot, spawn) {
+    const listed = spawn('git', ['ls-files', '-z', '--', '.codex', '.omx'], {
+        cwd: repoRoot,
+        encoding: 'utf8',
+    });
+    if (listed.error) {
+        throw new Error(`could not list tracked OMX project files: ${listed.error.message}`);
+    }
+    if (listed.status !== 0) {
+        throw new Error(`could not list tracked OMX project files: git exited ${listed.status ?? -1}`);
+    }
+    const files = decodeSpawnStdout(listed.stdout).split('\0').filter(isProjectScopedOmxPath);
+    for (const file of files) {
+        rmSync(resolveSafeRepoPath(repoRoot, file), { force: true });
+        pruneEmptyProjectScopedDirs(repoRoot, file);
+    }
+    return files;
+}
+function decodeSpawnStdout(stdout) {
+    if (typeof stdout === 'string')
+        return stdout;
+    if (Buffer.isBuffer(stdout))
+        return stdout.toString('utf8');
+    return '';
+}
+function isProjectScopedOmxPath(path) {
+    return (path === '.codex' || path.startsWith('.codex/') || path === '.omx' || path.startsWith('.omx/'));
+}
+function resolveSafeRepoPath(repoRoot, relativePath) {
+    const root = resolve(repoRoot);
+    const absolute = resolve(root, relativePath);
+    if (absolute === root || !absolute.startsWith(`${root}${sep}`)) {
+        throw new Error(`refusing to remove path outside repo: ${relativePath}`);
+    }
+    return absolute;
+}
+function pruneEmptyProjectScopedDirs(repoRoot, relativeFile) {
+    let dir = dirname(relativeFile);
+    while (isProjectScopedOmxPath(dir)) {
+        try {
+            rmdirSync(resolveSafeRepoPath(repoRoot, dir));
+        }
+        catch {
+            return;
+        }
+        if (dir === '.codex' || dir === '.omx')
+            return;
+        dir = dirname(dir);
+    }
+}
+/**
+ * Ensure `omx` is on PATH then run `omx setup --yes --scope user` in the consumer repo.
+ * Idempotent: safe to run on every `wp setup`.
+ */
+export function ensureOmx(input) {
+    if (input.options.dryRun)
+        return { kind: 'omx-skipped-dry-run' };
+    const spawn = input.spawn ?? spawnSync;
+    const configPath = input.configPath ?? defaultCodexConfigPath();
+    const scope = input.scope ?? 'user';
+    const previousScope = readPersistedOmxSetupScope(input.repoRoot);
+    // Pre-repair: remove legacy duplicate hook trust blocks before omx setup runs.
+    if (existsSync(configPath)) {
+        const existing = readFileSync(configPath, 'utf8');
+        const repaired = deduplicateCodexHookTrustState(existing);
+        if (repaired !== existing) {
+            mkdirSync(dirname(configPath), { recursive: true });
+            writeFileSync(configPath, repaired, 'utf8');
+        }
+    }
+    let installed = false;
+    let probe = spawn('omx', ['--version'], { encoding: 'utf8' });
+    if (probe.error || (probe.status !== null && probe.status !== 0)) {
+        const install = spawn('vp', ['install', '-g', 'oh-my-codex'], { stdio: 'inherit' });
+        if (install.status !== 0) {
+            return { kind: 'omx-not-found', hint: NOT_FOUND_HINT };
+        }
+        installed = true;
+        probe = spawn('omx', ['--version'], { encoding: 'utf8' });
+        if (probe.error || (probe.status !== null && probe.status !== 0)) {
+            return { kind: 'omx-not-found', hint: NOT_FOUND_HINT };
+        }
+    }
+    else if (!shouldSkipOmxRefresh()) {
+        spawn('vp', ['update', '-g', 'oh-my-codex'], { stdio: 'inherit' });
+    }
+    const result = spawn('omx', ['setup', '--yes', '--scope', scope], {
+        cwd: input.repoRoot,
+        stdio: ['ignore', 'inherit', 'inherit'],
+    });
+    if (result.status !== 0) {
+        return { kind: 'omx-spawn-failed', exitCode: result.status ?? -1 };
+    }
+    migrateDeprecatedCodexHooksFeatureFlagInConfig(configPath);
+    const nodeBinary = resolveBinaryOnPath('node');
+    const globalHooksResult = normalizeGlobalCodexHooksFile(defaultCodexHooksPathFromConfig(configPath), { nodeBinary }, input.options);
+    const removedProjectFiles = scope === 'user' && previousScope === 'project'
+        ? removeTrackedProjectScopedOmxFiles(input.repoRoot, spawn)
+        : [];
+    return {
+        kind: 'omx-ok',
+        installed,
+        removedProjectFiles,
+        codexGlobalHooks: {
+            repaired: globalHooksResult.action === 'overwritten' || globalHooksResult.action === 'created',
+            targetPath: globalHooksResult.targetPath,
+        },
+    };
+}
+//# sourceMappingURL=index.js.map