@crewx/cli 0.8.0-rc.66 → 0.8.0-rc.82

package/dist/commands/execute.js

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * crewx execute handler.
+ * Parses args, loads config via Crewx SDK, and executes the task.
+ *
+ * Flags:
+ *   --thread <name>          Conversation thread name
+ *   --provider <cli/xxx>     Provider override
+ *   --metadata <json>        Extra metadata JSON (double-quoted object). Propagated to events/hooks/tracing.
+ *                           e.g. --metadata='{"workflow_id":"wf-1"}'
+ *   --verbose                Debug output mode (default: raw agent response only)
+ *   --config/-c <path>       Config file path override
+ *   --output-format <fmt>    Output format (json|text|stream-json)
+ *   --effort <level>         Model effort (high|medium|low)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleExecute = handleExecute;
+const sdk_1 = require("@crewx/sdk");
+const parse_agent_message_1 = require("./parse-agent-message");
+const parse_common_flags_1 = require("./parse-common-flags");
+const crewx_cli_1 = require("../bootstrap/crewx-cli");
+/**
+ * Handle `crewx execute <agentRef> <message>` command.
+ *
+ * Default output: raw agent response only (stdout).
+ * --verbose: debug info written to stderr, response to stdout.
+ */
+async function handleExecute(args) {
+    const { thread, provider, metadata, verbose, config, outputFormat, effort, rest } = (0, parse_common_flags_1.parseCommonFlags)(args);
+    const { agentRef: parsedAgentRef, message } = (0, parse_agent_message_1.parseAgentMessage)(rest);
+    // No @mention → default to @crewx agent (matches cli-bak behaviour)
+    const agentRef = parsedAgentRef || '@crewx';
+    if (!message) {
+        console.error('Usage: crewx execute [@agent] <task> [options]');
+        console.error('       crewx x [@agent] <task> [options]');
+        console.error('');
+        console.error('  @agent is optional. Defaults to @crewx when omitted.');
+        console.error('');
+        console.error('Options:');
+        console.error('  --thread <name>        Conversation thread name');
+        console.error('  --provider <cli/xxx>   Provider override');
+        console.error('  --metadata <json>      Extra metadata (JSON object, double-quoted).');
+        console.error('                         Propagated to events/hooks/tracing.');
+        console.error('                         Invalid JSON aborts with exit code 2.');
+        console.error('                         e.g. --metadata=\'{"workflow_id":"wf-1"}\'');
+        console.error('  --verbose              Debug output mode');
+        console.error('  --config/-c <path>     Config file path');
+        console.error('  --output-format <fmt>  Output format (json|text|stream-json)');
+        console.error('  --effort <level>       Model effort (high|medium|low)');
+        process.exit(1);
+    }
+    const configPath = config ?? process.env.CREWX_CONFIG ?? 'crewx.yaml';
+    // Only show exec audit span JSON in verbose mode
+    (0, sdk_1.setAuditVerbose)(verbose);
+    const crewx = await (0, crewx_cli_1.createCliCrewx)(configPath);
+    // file:// remote agent delegation is handled transparently inside Crewx.query/execute.
+    if (verbose) {
+        process.stderr.write(`📋 Task: ${message}\n`);
+        process.stderr.write(`🤖 Agent: ${agentRef}\n`);
+        if (thread)
+            process.stderr.write(`🔗 Thread: ${thread}\n`);
+        if (provider)
+            process.stderr.write(`🔌 Provider: ${provider}\n`);
+        if (outputFormat)
+            process.stderr.write(`📄 Output-format: ${outputFormat}\n`);
+        if (effort)
+            process.stderr.write(`⚡ Effort: ${effort}\n`);
+        process.stderr.write('─'.repeat(60) + '\n');
+    }
+    let parsedMetadata = {};
+    try {
+        parsedMetadata = (0, parse_common_flags_1.parseMetadata)(metadata);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`Error: ${msg}\n`);
+        process.exit(2);
+    }
+    let exitCode = 0;
+    try {
+        const result = await crewx.execute(agentRef, message, {
+            provider,
+            threadId: thread,
+            metadata: Object.keys(parsedMetadata).length > 0 ? parsedMetadata : undefined,
+        });
+        if (!result.ok) {
+            const errMsg = result.error?.message ?? 'Execute failed';
+            console.error(errMsg);
+            exitCode = 1;
+        }
+        else {
+            if (verbose) {
+                process.stderr.write(`\n📊 Results from ${agentRef}:\n`);
+                process.stderr.write('═'.repeat(60) + '\n');
+                process.stderr.write('🟢 Status: Success\n');
+                process.stderr.write(`🤖 Provider: ${result.meta.provider}\n`);
+                process.stderr.write(`⏱️  Duration: ${result.meta.durationMs}ms\n`);
+                process.stderr.write('\n📄 Response:\n');
+                process.stderr.write('─'.repeat(40) + '\n');
+            }
+            console.log(result.data);
+            if (verbose) {
+                process.stderr.write('\n✅ Execute completed successfully\n');
+            }
+        }
+    }
+    catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        console.error(`Error: ${errMsg}`);
+        exitCode = 1;
+    }
+    finally {
+        await crewx.close();
+    }
+    if (exitCode !== 0)
+        process.exit(exitCode);
+}

package/dist/commands/hook/install.d.ts

@@ -0,0 +1,21 @@
+/**
+ * crewx hook install — Register crewx-hook-dispatch as a PreToolUse hook
+ * in <projectRoot>/.claude/settings.json and/or <projectRoot>/.codex/hooks.json.
+ *
+ * Security:
+ *   - Prompts user before modifying settings (R1)
+ *   - Uses absolute path for crewx binary (PATH manipulation prevention)
+ *   - Backs up original settings files
+ *   - Preserves existing user hooks
+ *   - Never traverses parent directories — project root determined by crewx.yaml
+ */
+import { type HookProvider } from './paths';
+export declare const CREWX_HOOK_COMMAND_MARKER = "crewx hook-dispatch";
+export declare function resolveCrewxBinary(): string;
+export interface HookInstallOpts {
+    projectRoot: string;
+    yes: boolean;
+    provider?: HookProvider;
+}
+export declare function handleHookInstall(opts: HookInstallOpts): Promise<void>;
+export declare function handleHookInstall(args: string[]): Promise<void>;

package/dist/commands/hook/install.js

@@ -0,0 +1,175 @@
+"use strict";
+/**
+ * crewx hook install — Register crewx-hook-dispatch as a PreToolUse hook
+ * in <projectRoot>/.claude/settings.json and/or <projectRoot>/.codex/hooks.json.
+ *
+ * Security:
+ *   - Prompts user before modifying settings (R1)
+ *   - Uses absolute path for crewx binary (PATH manipulation prevention)
+ *   - Backs up original settings files
+ *   - Preserves existing user hooks
+ *   - Never traverses parent directories — project root determined by crewx.yaml
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CREWX_HOOK_COMMAND_MARKER = void 0;
+exports.resolveCrewxBinary = resolveCrewxBinary;
+exports.handleHookInstall = handleHookInstall;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const cp = __importStar(require("child_process"));
+const paths_1 = require("./paths");
+exports.CREWX_HOOK_COMMAND_MARKER = 'crewx hook-dispatch';
+function getProviderConfigs(projectRoot, providers, crewxBin) {
+    return providers.map((provider) => ({
+        settingsPath: provider === 'claude'
+            ? (0, paths_1.getClaudeSettingsPath)(projectRoot)
+            : (0, paths_1.getCodexHooksPath)(projectRoot),
+        provider,
+        matcher: provider === 'claude' ? '' : 'Bash',
+        commandArg: `--provider ${provider}`,
+    }));
+}
+function resolveCrewxBinary() {
+    if (process.env.CREWX_CLI)
+        return process.env.CREWX_CLI;
+    try {
+        const which = cp.execSync('which crewx 2>/dev/null', { encoding: 'utf8' }).trim();
+        const isTmpProxy = which.includes('/T/crewx-proxy-') ||
+            which.includes('/tmp/crewx-proxy-') ||
+            /\/[Tt]e?mp\//.test(which);
+        if (which && !isTmpProxy)
+            return which;
+    }
+    catch { }
+    if (process.argv[1]) {
+        const scriptPath = (0, path_1.resolve)(process.argv[1]);
+        if ((0, fs_1.existsSync)(scriptPath)) {
+            return `${process.execPath} ${scriptPath}`;
+        }
+    }
+    return 'crewx';
+}
+function readSettingsTyped(settingsPath) {
+    return (0, paths_1.readSettings)(settingsPath);
+}
+function findCrewxEntry(preToolUse) {
+    if (!preToolUse)
+        return -1;
+    return preToolUse.findIndex((entry) => entry.hooks?.some((h) => h.command?.includes(exports.CREWX_HOOK_COMMAND_MARKER)));
+}
+function installForProvider(projectRoot, config, crewxBin, yes) {
+    const { settingsPath, provider, matcher, commandArg } = config;
+    const settings = readSettingsTyped(settingsPath);
+    if (!settings.hooks)
+        settings.hooks = {};
+    if (!settings.hooks.PreToolUse)
+        settings.hooks.PreToolUse = [];
+    const existingIdx = findCrewxEntry(settings.hooks.PreToolUse);
+    if (existingIdx >= 0) {
+        console.log(`[crewx] Hook already installed in ${settingsPath} (${provider})`);
+        return false;
+    }
+    if (!yes) {
+        console.log(`⚠️  crewx hook install will register crewx-hook-dispatch as a PreToolUse hook.\n` +
+            `   This gives crewx authority to allow/deny ALL ${provider} tool calls.\n` +
+            `   ${settingsPath} will be patched (backup at ${settingsPath}.crewx-backup).\n`);
+        return false;
+    }
+    if ((0, fs_1.existsSync)(settingsPath)) {
+        const backupPath = settingsPath + '.crewx-backup';
+        (0, fs_1.copyFileSync)(settingsPath, backupPath);
+        console.log(`[crewx] Backup created: ${backupPath}`);
+    }
+    if (provider === 'claude') {
+        (0, paths_1.ensureClaudeSettings)(projectRoot);
+    }
+    else {
+        (0, paths_1.ensureCodexHooks)(projectRoot);
+    }
+    const command = `${crewxBin} hook-dispatch ${commandArg}`;
+    settings.hooks.PreToolUse.push({
+        matcher,
+        hooks: [{ type: 'command', command }],
+    });
+    (0, fs_1.writeFileSync)(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf8');
+    console.log(`[crewx] Hook installed (${provider}): ${command}`);
+    console.log(`[crewx] Settings: ${settingsPath}`);
+    return true;
+}
+async function handleHookInstall(argsOrOpts) {
+    if (!Array.isArray(argsOrOpts)) {
+        const { projectRoot, yes, provider } = argsOrOpts;
+        const providers = (0, paths_1.providersFromFilter)(provider ?? 'all');
+        const crewxBin = resolveCrewxBinary();
+        const configs = getProviderConfigs(projectRoot, providers, crewxBin);
+        for (const config of configs) {
+            installForProvider(projectRoot, config, crewxBin, yes);
+        }
+        return;
+    }
+    const args = argsOrOpts;
+    const yes = args.includes('--yes') || args.includes('-y');
+    const cwd = process.cwd();
+    const projectRoot = (0, paths_1.findProjectRoot)(cwd);
+    if (!projectRoot) {
+        console.error('[crewx] No crewx.yaml found in current or ancestor directories.');
+        console.error('[crewx] Run this command from within a CrewX project.');
+        process.exitCode = 1;
+        return;
+    }
+    const providerFilter = (0, paths_1.parseProviderArg)(args);
+    const providers = (0, paths_1.providersFromFilter)(providerFilter);
+    const crewxBin = resolveCrewxBinary();
+    const configs = getProviderConfigs(projectRoot, providers, crewxBin);
+    if (!yes) {
+        const targets = configs.map((c) => `   - ${c.provider}: ${c.settingsPath}`).join('\n');
+        console.log(`⚠️  crewx hook install will register crewx-hook-dispatch as a PreToolUse hook.\n` +
+            `   This gives crewx authority to allow/deny ALL tool calls.\n` +
+            `   Target providers: ${providers.join(', ')}\n` +
+            `${targets}\n`);
+        process.stdout.write('Continue? [y/N] ');
+        const answer = await new Promise((resolve) => {
+            process.stdin.once('data', (data) => resolve(data.toString().trim().toLowerCase()));
+        });
+        if (answer !== 'y' && answer !== 'yes') {
+            console.log('Aborted.');
+            return;
+        }
+    }
+    for (const config of configs) {
+        installForProvider(projectRoot, config, crewxBin, true);
+    }
+}

package/dist/commands/hook/paths.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Shared path helpers for hook CLI commands.
+ *
+ * Project root = nearest ancestor containing crewx.yaml.
+ * Claude settings path = <projectRoot>/.claude/settings.json
+ * Codex hooks path     = <projectRoot>/.codex/hooks.json
+ */
+export type HookProvider = 'claude' | 'codex';
+export type HookProviderFilter = HookProvider | 'all';
+export declare function parseProviderArg(args: string[]): HookProviderFilter;
+export declare function providersFromFilter(filter: HookProviderFilter): HookProvider[];
+export declare function findProjectRoot(cwd: string): string | null;
+export declare function getClaudeSettingsPath(projectRoot: string): string;
+export declare function getCodexHooksPath(projectRoot: string): string;
+export declare function getProviderSettingsPath(projectRoot: string, provider: HookProvider): string;
+export declare function readSettings(settingsPath: string): Record<string, unknown>;
+export declare function ensureClaudeSettings(projectRoot: string): string;
+export declare function ensureCodexHooks(projectRoot: string): string;
+export declare function ensureProviderSettings(projectRoot: string, provider: HookProvider): string;

package/dist/commands/hook/paths.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * Shared path helpers for hook CLI commands.
+ *
+ * Project root = nearest ancestor containing crewx.yaml.
+ * Claude settings path = <projectRoot>/.claude/settings.json
+ * Codex hooks path     = <projectRoot>/.codex/hooks.json
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseProviderArg = parseProviderArg;
+exports.providersFromFilter = providersFromFilter;
+exports.findProjectRoot = findProjectRoot;
+exports.getClaudeSettingsPath = getClaudeSettingsPath;
+exports.getCodexHooksPath = getCodexHooksPath;
+exports.getProviderSettingsPath = getProviderSettingsPath;
+exports.readSettings = readSettings;
+exports.ensureClaudeSettings = ensureClaudeSettings;
+exports.ensureCodexHooks = ensureCodexHooks;
+exports.ensureProviderSettings = ensureProviderSettings;
+const fs_1 = require("fs");
+const path_1 = require("path");
+function parseProviderArg(args) {
+    const idx = args.indexOf('--provider');
+    if (idx === -1 || idx + 1 >= args.length)
+        return 'all';
+    const val = args[idx + 1];
+    if (val === 'claude' || val === 'codex')
+        return val;
+    console.error(`[crewx] Invalid --provider value: "${val}". Expected: claude | codex`);
+    process.exit(1);
+}
+function providersFromFilter(filter) {
+    return filter === 'all' ? ['claude', 'codex'] : [filter];
+}
+function findProjectRoot(cwd) {
+    let dir = (0, path_1.resolve)(cwd);
+    for (;;) {
+        if ((0, fs_1.existsSync)((0, path_1.resolve)(dir, 'crewx.yaml')))
+            return dir;
+        const parent = (0, path_1.dirname)(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+function getClaudeSettingsPath(projectRoot) {
+    return (0, path_1.resolve)(projectRoot, '.claude', 'settings.json');
+}
+function getCodexHooksPath(projectRoot) {
+    return (0, path_1.resolve)(projectRoot, '.codex', 'hooks.json');
+}
+function getProviderSettingsPath(projectRoot, provider) {
+    return provider === 'claude'
+        ? getClaudeSettingsPath(projectRoot)
+        : getCodexHooksPath(projectRoot);
+}
+function readSettings(settingsPath) {
+    if (!(0, fs_1.existsSync)(settingsPath))
+        return {};
+    try {
+        return JSON.parse((0, fs_1.readFileSync)(settingsPath, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+function ensureClaudeSettings(projectRoot) {
+    const settingsPath = getClaudeSettingsPath(projectRoot);
+    const settingsDir = (0, path_1.dirname)(settingsPath);
+    if (!(0, fs_1.existsSync)(settingsDir)) {
+        (0, fs_1.mkdirSync)(settingsDir, { recursive: true });
+    }
+    if (!(0, fs_1.existsSync)(settingsPath)) {
+        (0, fs_1.writeFileSync)(settingsPath, '{}\n', 'utf8');
+    }
+    return settingsPath;
+}
+function ensureCodexHooks(projectRoot) {
+    const hooksPath = getCodexHooksPath(projectRoot);
+    const hooksDir = (0, path_1.dirname)(hooksPath);
+    if (!(0, fs_1.existsSync)(hooksDir)) {
+        (0, fs_1.mkdirSync)(hooksDir, { recursive: true });
+    }
+    if (!(0, fs_1.existsSync)(hooksPath)) {
+        (0, fs_1.writeFileSync)(hooksPath, '{}\n', 'utf8');
+    }
+    return hooksPath;
+}
+function ensureProviderSettings(projectRoot, provider) {
+    return provider === 'claude'
+        ? ensureClaudeSettings(projectRoot)
+        : ensureCodexHooks(projectRoot);
+}

package/dist/commands/hook/status.d.ts

@@ -0,0 +1,7 @@
+/**
+ * crewx hook status — Show hook installation status and registered plugins.
+ *
+ * Displays status for both Claude (.claude/settings.json) and
+ * Codex (.codex/hooks.json) provider settings.
+ */
+export declare function handleHookStatus(_args: string[]): Promise<void>;

package/dist/commands/hook/status.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * crewx hook status — Show hook installation status and registered plugins.
+ *
+ * Displays status for both Claude (.claude/settings.json) and
+ * Codex (.codex/hooks.json) provider settings.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleHookStatus = handleHookStatus;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const sdk_1 = require("@crewx/sdk");
+const paths_1 = require("./paths");
+const CREWX_HOOK_COMMAND_MARKER = 'crewx hook-dispatch';
+function showProviderStatus(projectRoot, provider) {
+    const settingsPath = provider === 'claude'
+        ? (0, paths_1.getClaudeSettingsPath)(projectRoot)
+        : (0, paths_1.getCodexHooksPath)(projectRoot);
+    console.log(`  [${provider.toUpperCase()}]`);
+    if (!(0, fs_1.existsSync)(settingsPath)) {
+        console.log(`    Settings: not found (${settingsPath})`);
+        console.log(`    Status:   NOT INSTALLED`);
+        return;
+    }
+    console.log(`    Settings: ${settingsPath}`);
+    try {
+        const settings = JSON.parse((0, fs_1.readFileSync)(settingsPath, 'utf8'));
+        const preHooks = settings.hooks?.PreToolUse ?? [];
+        const crewxEntry = preHooks.find((entry) => entry.hooks?.some((h) => h.command?.includes(CREWX_HOOK_COMMAND_MARKER)));
+        if (crewxEntry) {
+            const command = crewxEntry.hooks.find((h) => h.command?.includes(CREWX_HOOK_COMMAND_MARKER))?.command;
+            console.log(`    Status:   INSTALLED`);
+            console.log(`    Command:  ${command}`);
+        }
+        else {
+            console.log(`    Status:   NOT INSTALLED`);
+        }
+    }
+    catch {
+        console.log(`    Status:   ERROR (failed to parse settings)`);
+    }
+    const backupPath = settingsPath + '.crewx-backup';
+    if ((0, fs_1.existsSync)(backupPath)) {
+        console.log(`    Backup:   ${backupPath}`);
+    }
+}
+async function handleHookStatus(_args) {
+    const cwd = process.cwd();
+    const projectRoot = (0, paths_1.findProjectRoot)(cwd);
+    if (!projectRoot) {
+        console.error('[crewx] No crewx.yaml found in current or ancestor directories.');
+        console.error('[crewx] Run this command from within a CrewX project.');
+        process.exitCode = 1;
+        return;
+    }
+    console.log('Hook Installation Status');
+    console.log('─'.repeat(40));
+    showProviderStatus(projectRoot, 'claude');
+    showProviderStatus(projectRoot, 'codex');
+    const configPath = (0, path_1.resolve)(projectRoot, 'crewx.yaml');
+    console.log('');
+    console.log('Registered HookPlugins (crewx.yaml)');
+    console.log('─'.repeat(40));
+    console.log(`  Config: ${configPath}`);
+    let config;
+    try {
+        config = (0, sdk_1.loadYamlFile)(configPath);
+    }
+    catch {
+        console.log('  ERROR: failed to parse crewx.yaml');
+        return;
+    }
+    const hookDefs = Array.isArray(config.hooks) ? config.hooks : [];
+    if (hookDefs.length === 0) {
+        console.log('  No hooks defined in crewx.yaml');
+        return;
+    }
+    for (const hook of hookDefs) {
+        console.log(`  - provider: ${hook.provider ?? '(any)'}`);
+        console.log(`    event:    ${hook.event ?? 'PreToolUse'}`);
+        console.log(`    plugin:   ${hook.plugin ?? '(undefined)'}`);
+        if (hook.agents) {
+            console.log(`    agents:   ${JSON.stringify(hook.agents)} (reserved — Phase 1)`);
+        }
+    }
+}

package/dist/commands/hook/uninstall.d.ts

@@ -0,0 +1,8 @@
+/**
+ * crewx hook uninstall — Remove crewx-hook-dispatch from provider settings files.
+ *
+ * Only removes entries whose command contains the crewx hook-dispatch marker.
+ * Preserves all other user hooks. Cleans up empty PreToolUse/hooks fields.
+ * Never traverses parent directories — project root determined by crewx.yaml.
+ */
+export declare function handleHookUninstall(args: string[]): Promise<void>;

package/dist/commands/hook/uninstall.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * crewx hook uninstall — Remove crewx-hook-dispatch from provider settings files.
+ *
+ * Only removes entries whose command contains the crewx hook-dispatch marker.
+ * Preserves all other user hooks. Cleans up empty PreToolUse/hooks fields.
+ * Never traverses parent directories — project root determined by crewx.yaml.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleHookUninstall = handleHookUninstall;
+const fs_1 = require("fs");
+const paths_1 = require("./paths");
+const CREWX_HOOK_COMMAND_MARKER = 'crewx hook-dispatch';
+function getSettingsPath(projectRoot, provider) {
+    return provider === 'claude'
+        ? (0, paths_1.getClaudeSettingsPath)(projectRoot)
+        : (0, paths_1.getCodexHooksPath)(projectRoot);
+}
+function uninstallFromProvider(projectRoot, provider) {
+    const settingsPath = getSettingsPath(projectRoot, provider);
+    if (!(0, fs_1.existsSync)(settingsPath)) {
+        console.log(`[crewx] No settings file found for ${provider} (${settingsPath})`);
+        return;
+    }
+    let settings;
+    try {
+        settings = JSON.parse((0, fs_1.readFileSync)(settingsPath, 'utf8'));
+    }
+    catch {
+        console.error(`[crewx] Failed to parse ${settingsPath}`);
+        return;
+    }
+    if (!settings.hooks?.PreToolUse?.length) {
+        console.log(`[crewx] No PreToolUse hooks found for ${provider}`);
+        return;
+    }
+    const before = settings.hooks.PreToolUse.length;
+    settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter((entry) => !entry.hooks?.some((h) => h.command?.includes(CREWX_HOOK_COMMAND_MARKER)));
+    const removed = settings.hooks.PreToolUse.length < before;
+    if (settings.hooks.PreToolUse.length === 0) {
+        delete settings.hooks.PreToolUse;
+    }
+    if (settings.hooks && Object.keys(settings.hooks).length === 0) {
+        delete settings.hooks;
+    }
+    if (!removed) {
+        console.log(`[crewx] crewx hook not found for ${provider}`);
+        return;
+    }
+    (0, fs_1.writeFileSync)(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf8');
+    console.log(`[crewx] Hook uninstalled (${provider})`);
+    const backupPath = settingsPath + '.crewx-backup';
+    if ((0, fs_1.existsSync)(backupPath)) {
+        console.log(`[crewx] Backup available: ${backupPath}`);
+    }
+}
+async function handleHookUninstall(args) {
+    const cwd = process.cwd();
+    const projectRoot = (0, paths_1.findProjectRoot)(cwd);
+    if (!projectRoot) {
+        console.error('[crewx] No crewx.yaml found in current or ancestor directories.');
+        console.error('[crewx] Run this command from within a CrewX project.');
+        process.exitCode = 1;
+        return;
+    }
+    const providerFilter = (0, paths_1.parseProviderArg)(args);
+    const providers = (0, paths_1.providersFromFilter)(providerFilter);
+    for (const provider of providers) {
+        uninstallFromProvider(projectRoot, provider);
+    }
+}

package/dist/commands/hook-dispatch.d.ts

@@ -0,0 +1,15 @@
+/**
+ * crewx hook-dispatch — CLI subcommand invoked by Claude/Codex PreToolUse hook.
+ *
+ * Reads stdin JSON from the provider, loads HookPlugins from crewx.yaml,
+ * evaluates them, and writes stdout JSON response back.
+ *
+ * Protocol:
+ *   stdin  → ClaudeHookInput JSON
+ *   stdout → ClaudeHookOutput JSON
+ *   exit 0 → allow, exit 2 → deny
+ *
+ * Security (M1):
+ *   --provider argument is REQUIRED. Missing → process.exit(1) fail-closed.
+ */
+export declare function handleHookDispatch(args: string[]): Promise<void>;