@seanmozeik/tripwire 0.1.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seanmozeik/tripwire",
-  "version": "0.1.0",
+  "version": "0.4.0",
   "description": "Opinionated hooks dispatcher for AI coding agents with configurable safety rules",
   "license": "MIT",
   "bin": {

package/src/cli.ts

@@ -3,62 +3,25 @@
 // Dispatcher and pretty-print the decision. Indispensable for tuning
 // Rules without going through Claude Code.
 //
+// `tripwire install <target>` — install tripwire hooks for AI agents.
+//
 // Usage:
 //   Bun src/cli.ts test 'rm -rf /etc'
 //   Bun src/cli.ts test --tool=Read --path=.env
 //   Bun src/cli.ts test --post --tool=Bash --stdout='ghp_<token>'
+//   Bun src/cli.ts install claude
+//   Bun src/cli.ts install codex
+//   Bun src/cli.ts install pi
+//   Bun src/cli.ts install all
 
-import { spawnSync } from 'node:child_process';
-
-const DISPATCH_BIN = `${import.meta.dir}/../dist/tripwire.js`;
+import { BunServices } from '@effect/platform-bun';
+import { Effect, Option } from 'effect';
+import { Argument, Command, Flag } from 'effect/unstable/cli';
 
-interface CliArgs {
-  readonly tool: string;
-  readonly post: boolean;
-  readonly path: string | undefined;
-  readonly command: string | undefined;
-  readonly stdout: string | undefined;
-  readonly stderr: string | undefined;
-  readonly content: string | undefined;
-}
+import pkg from '../package.json' with { type: 'json' };
+import { installAll, installClaude, installCodex, installPi } from './lib/install';
 
-const parseArgs = (argv: readonly string[]): CliArgs => {
-  let tool = 'Bash';
-  let post = false;
-  let path: string | undefined;
-  let command: string | undefined;
-  let stdout: string | undefined;
-  let stderr: string | undefined;
-  let content: string | undefined;
-  for (const a of argv) {
-    if (a === '--post') {
-      post = true;
-      continue;
-    }
-    if (a.startsWith('--tool=')) {
-      tool = a.slice('--tool='.length);
-      continue;
-    }
-    if (a.startsWith('--path=')) {
-      path = a.slice('--path='.length);
-      continue;
-    }
-    if (a.startsWith('--stdout=')) {
-      stdout = a.slice('--stdout='.length);
-      continue;
-    }
-    if (a.startsWith('--stderr=')) {
-      stderr = a.slice('--stderr='.length);
-      continue;
-    }
-    if (a.startsWith('--content=')) {
-      content = a.slice('--content='.length);
-      continue;
-    }
-    command ??= a;
-  }
-  return { tool, post, path, command, stdout, stderr, content };
-};
+const DISPATCH_BIN = `${import.meta.dir}/../dist/tripwire.js`;
 
 interface BuiltEvent {
   hook_event_name: string;
@@ -69,80 +32,209 @@ interface BuiltEvent {
   tool_response?: unknown;
 }
 
-const buildToolInput = (tool: string, args: CliArgs): unknown => {
+const buildToolInput = (
+  tool: string,
+  command: string | undefined,
+  path: string | undefined,
+  content: string | undefined,
+): unknown => {
   if (tool === 'Bash') {
-    return { command: args.command ?? '' };
+    return { command: command ?? '' };
   }
   if (tool === 'Read') {
-    return { file_path: args.path ?? '' };
+    return { file_path: path ?? '' };
   }
   if (tool === 'Write') {
-    return { file_path: args.path ?? '', content: args.content ?? '' };
+    return { file_path: path ?? '', content: content ?? '' };
   }
   if (tool === 'Edit' || tool === 'MultiEdit') {
-    return { file_path: args.path ?? '', old_string: '', new_string: args.content ?? '' };
+    return { file_path: path ?? '', old_string: '', new_string: content ?? '' };
   }
   return undefined;
 };
 
-const buildEvent = (args: CliArgs): BuiltEvent => {
-  const eventName = args.post ? 'PostToolUse' : 'PreToolUse';
-  const tool = args.tool;
+interface EventParams {
+  readonly tool: string;
+  readonly post: boolean;
+  readonly command: string | undefined;
+  readonly path: string | undefined;
+  readonly stdout: string | undefined;
+  readonly stderr: string | undefined;
+  readonly content: string | undefined;
+}
+
+const buildEvent = (params: EventParams): BuiltEvent => {
+  const { tool, post, command, path, stdout, stderr, content } = params;
+  const eventName = post ? 'PostToolUse' : 'PreToolUse';
   const event: BuiltEvent = {
     hook_event_name: eventName,
     tool_name: tool,
     cwd: process.cwd(),
     session_id: 'tripwire-cli-test',
-    tool_input: buildToolInput(tool, args),
+    tool_input: buildToolInput(tool, command, path, content),
   };
-  if (args.post) {
+  if (post) {
     event.tool_response =
-      tool === 'Bash'
-        ? { stdout: args.stdout ?? '', stderr: args.stderr ?? '' }
-        : { content: args.content ?? '' };
+      tool === 'Bash' ? { stdout: stdout ?? '', stderr: stderr ?? '' } : { content: content ?? '' };
   }
   return event;
 };
 
-const printUsage = (): void => {
-  process.stdout.write(
-    [
-      'tripwire CLI — synthetic-event tester',
-      '',
-      'Usage:',
-      "  tripwire test '<command>'                 # PreToolUse Bash",
-      '  tripwire test --tool=Read --path=.env     # PreToolUse Read',
-      "  tripwire test --tool=Write --path=foo.ts --content='TODO finish'",
-      "  tripwire test --post --tool=Bash --stdout='ghp_REAL_TOKEN'  # PostToolUse",
-      '',
-    ].join('\n'),
-  );
-};
+const runTest = (config: {
+  readonly command: string | undefined;
+  readonly content: string | undefined;
+  readonly path: string | undefined;
+  readonly post: boolean;
+  readonly stderr: string | undefined;
+  readonly stdout: string | undefined;
+  readonly tool: string;
+}): Effect.Effect<void> =>
+  Effect.sync(() => {
+    const { command, content, path, post, stderr, stdout, tool } = config;
+    const event = buildEvent({ tool, post, command, path, stdout, stderr, content });
+    const result = Bun.spawnSync([DISPATCH_BIN], {
+      stdin: new TextEncoder().encode(JSON.stringify(event)),
+      timeout: 10_000,
+      stdout: 'pipe',
+      stderr: 'pipe',
+    });
+    if (result.exitCode !== 0) {
+      const errorOutput = new TextDecoder().decode(result.stderr);
+      console.error(`error: ${errorOutput}`);
+      process.exit(1);
+    }
+    const output = new TextDecoder().decode(result.stdout);
+    try {
+      const parsed = JSON.parse(output) as unknown;
+      console.log(JSON.stringify(parsed, null, 2));
+    } catch {
+      console.log(output);
+    }
+  });
 
-const main = (): void => {
-  const argv = process.argv.slice(2);
-  if (argv.length === 0 || argv[0] !== 'test') {
-    printUsage();
-    process.exit(0);
-  }
-  const args = parseArgs(argv.slice(1));
-  const event = buildEvent(args);
-  const result = spawnSync(DISPATCH_BIN, [], {
-    input: JSON.stringify(event),
-    encoding: 'utf8',
-    timeout: 10_000,
+const testCommand = Command.make(
+  'test',
+  {
+    command: Argument.string('command').pipe(
+      Argument.optional,
+      Argument.withDescription('Command to test (for Bash tool)'),
+    ),
+    content: Flag.string('content').pipe(
+      Flag.optional,
+      Flag.withDescription('Content for Write/Edit tools'),
+    ),
+    path: Flag.string('path').pipe(
+      Flag.optional,
+      Flag.withDescription('File path for Read/Write/Edit tools'),
+    ),
+    post: Flag.boolean('post').pipe(Flag.withDescription('Test PostToolUse instead of PreToolUse')),
+    stderr: Flag.string('stderr').pipe(
+      Flag.optional,
+      Flag.withDescription('Stderr for PostToolUse Bash'),
+    ),
+    stdout: Flag.string('stdout').pipe(
+      Flag.optional,
+      Flag.withDescription('Stdout for PostToolUse Bash'),
+    ),
+    tool: Flag.string('tool').pipe(
+      Flag.withDefault('Bash'),
+      Flag.withDescription('Tool name (Bash, Read, Write, Edit, MultiEdit)'),
+    ),
+  },
+  ({ command, content, path, post, stderr, stdout, tool }) =>
+    runTest({
+      command: Option.getOrUndefined(command),
+      content: Option.getOrUndefined(content),
+      path: Option.getOrUndefined(path),
+      post,
+      stderr: Option.getOrUndefined(stderr),
+      stdout: Option.getOrUndefined(stdout),
+      tool,
+    }),
+).pipe(Command.withDescription('Test a synthetic hook event'));
+
+const runInstall = (target: string): Effect.Effect<void> =>
+  Effect.gen(function* () {
+    if (!['claude', 'codex', 'pi', 'all'].includes(target)) {
+      console.error(`error: unknown target "${target}"`);
+      console.error('Valid targets: claude, codex, pi, all');
+      process.exit(1);
+    }
+
+    let results: {
+      readonly target: string;
+      readonly result: { readonly success: boolean; readonly message: string };
+    }[];
+
+    switch (target) {
+      case 'claude': {
+        const result = yield* Effect.promise(() => installClaude());
+        results = [{ target: 'claude', result }];
+        break;
+      }
+      case 'codex': {
+        const result = yield* Effect.promise(() => installCodex());
+        results = [{ target: 'codex', result }];
+        break;
+      }
+      case 'pi': {
+        const result = yield* Effect.promise(() => installPi());
+        results = [{ target: 'pi', result }];
+        break;
+      }
+      case 'all': {
+        const installResults = yield* Effect.promise(() => installAll());
+        results = installResults.map((r) => ({ target: r.target, result: r }));
+        break;
+      }
+      default: {
+        results = [];
+        break;
+      }
+    }
+
+    let hasFailure = false;
+    for (const { target: t, result: r } of results) {
+      if (r.success) {
+        const symbol = r.message.startsWith('Already configured') ? '⊙' : '✓';
+        console.log(`${symbol} [${t}] ${r.message}`);
+      } else {
+        console.error(`✗ [${t}] ${r.message}`);
+        hasFailure = true;
+      }
+    }
+
+    if (hasFailure) {
+      process.exit(1);
+    }
   });
-  if (result.error !== undefined) {
-    process.stderr.write(`error: ${String(result.error)}\n`);
-    process.exit(1);
-  }
-  const stdout: string = result.stdout;
+
+const installCommand = Command.make(
+  'install',
+  {
+    target: Argument.string('target').pipe(
+      Argument.withDescription('Target agent (claude, codex, pi, or all)'),
+    ),
+  },
+  ({ target }) => runInstall(target),
+).pipe(Command.withDescription('Install tripwire hooks for AI agents'));
+
+const app = Command.make('tripwire').pipe(
+  Command.withDescription('Opinionated hooks dispatcher for AI coding agents'),
+  Command.withSubcommands([testCommand, installCommand]),
+);
+
+const program = Command.run(app, { version: pkg.version });
+
+const main = async (): Promise<void> => {
   try {
-    const parsed = JSON.parse(stdout) as unknown;
-    process.stdout.write(`${JSON.stringify(parsed, null, 2)}\n`);
-  } catch {
-    process.stdout.write(stdout);
+    await Effect.runPromise(program.pipe(Effect.provide(BunServices.layer)));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    process.exitCode = 1;
   }
 };
 
-main();
+// oxlint-disable-next-line no-void, unicorn/prefer-top-level-await
+void main();

package/src/dispatch.ts

@@ -19,7 +19,7 @@ import { BunRuntime } from '@effect/platform-bun';
 import { Cause, Effect, Exit, Schema } from 'effect';
 
 import { parseCommand } from './lib/bash';
-import { loadConfig, type Config } from './lib/config';
+import { getDefaultConfig, loadConfig, mergeWithDefaults, type Config } from './lib/config';
 import { type Decision, allow, merge } from './lib/decision';
 import {
   type BashInput,
@@ -48,9 +48,6 @@ import { pathProtect } from './rules/path-protect';
 import { postSecretScrub } from './rules/post-secret-scrub';
 import { readProtect } from './rules/read-protect';
 
-const RULE_TIMEOUT_MS = 250;
-const POST_RULE_TIMEOUT_MS = 5000; // Betterleaks subprocess can take longer
-
 const readStdin = async (): Promise<string> => {
   const chunks: Buffer[] = [];
   for await (const chunk of process.stdin) {
@@ -243,6 +240,25 @@ const runRules = (rules: readonly Rule[], timeoutMs: number): Effect.Effect<Deci
     return merge(decisions);
   });
 
+const runRulesSync = (rules: readonly Rule[]): Decision => {
+  if (rules.length === 0) {
+    return allow('no-rules');
+  }
+  return merge(rules.map((r) => r.fn()));
+};
+
+const decide = (event: HookEvent, config: Config = getDefaultConfig()): Decision => {
+  const mergedConfig = mergeWithDefaults(config);
+  const tool = normalizeToolName(event.tool_name ?? '');
+  if (event.hook_event_name === 'PreToolUse') {
+    return runRulesSync(collectPreToolUseRules(tool, event.tool_input, mergedConfig));
+  }
+  if (event.hook_event_name === 'PostToolUse') {
+    return runRulesSync(collectPostToolUseRules(tool, event.tool_response));
+  }
+  return allow('no-rules');
+};
+
 const handleBashAllow = (event: HookEvent, decision: Decision, config: Config): void => {
   // After the gate passes (allow or warn), apply rtk command-rewrite. If
   // Rtk doesn't change the command, fall through to normal allow / warn.
@@ -302,11 +318,9 @@ const program = Effect.gen(function* () {
     return;
   }
   const event = decodeExit.value;
-  const tool = normalizeToolName(event.tool_name ?? '');
 
   if (event.hook_event_name === 'PreToolUse') {
-    const rules = collectPreToolUseRules(tool, event.tool_input, config);
-    const decision = yield* runRules(rules, RULE_TIMEOUT_MS);
+    const decision = decide(event, config);
     if (decision.kind === 'deny' || decision.kind === 'ask') {
       writePreToolGate(event.hook_event_name, decision);
       return;
@@ -316,8 +330,7 @@ const program = Effect.gen(function* () {
   }
 
   if (event.hook_event_name === 'PostToolUse') {
-    const rules = collectPostToolUseRules(tool, event.tool_response);
-    const decision = yield* runRules(rules, POST_RULE_TIMEOUT_MS);
+    const decision = decide(event, config);
     if (decision.kind === 'deny') {
       writePostToolBlock(decision);
       return;
@@ -337,4 +350,15 @@ const handled = program.pipe(
   }),
 );
 
-BunRuntime.runMain(handled);
+if (import.meta.main) {
+  BunRuntime.runMain(handled);
+}
+
+export {
+  collectPostToolUseRules,
+  collectPreToolUseRules,
+  decide,
+  normalizeToolName,
+  runRules,
+  runRulesSync,
+};

package/src/index.ts

@@ -2,3 +2,5 @@ export type { Decision } from './lib/decision.ts';
 export type { HookEvent } from './lib/event.ts';
 export type { Config } from './lib/config.ts';
 export { allow, deny, ask, warn } from './lib/decision.ts';
+export { decide } from './dispatch.ts';
+export { getDefaultConfig, loadConfig, mergeWithDefaults } from './lib/config.ts';

package/src/lib/config.ts

@@ -11,6 +11,10 @@ const BlockRuleSchema = Schema.Struct({
   pattern: Schema.String,
   message: Schema.String,
   action: Schema.optional(Schema.Union([Schema.Literal('deny'), Schema.Literal('ask')])),
+  requiresFlags: Schema.optional(Schema.Array(Schema.String)),
+  forbidsFlagValues: Schema.optional(
+    Schema.Array(Schema.Struct({ flag: Schema.String, values: Schema.Array(Schema.String) })),
+  ),
 });
 
 const RtkConfigSchema = Schema.Struct({
@@ -89,7 +93,7 @@ export const loadConfig = (): Effect.Effect<Config> =>
     return mergeWithDefaults(config);
   }).pipe(
     Effect.timeout(1000),
-    // eslint-disable-next-line promise/prefer-await-to-then
+    // oxlint-disable-next-line promise/prefer-await-to-then
     Effect.catch(() => {
       // Log error but return defaults to never block the agent
       console.error('[tripwire] Config loading failed, using defaults');
@@ -103,4 +107,4 @@ export type GitConfig = typeof GitConfigSchema.Type;
 export type SafePathsConfig = typeof SafePathsConfigSchema.Type;
 export type Config = typeof ConfigSchema.Type;
 
-export { CONFIG_PATH, ConfigSchema };
+export { CONFIG_PATH, ConfigSchema, getDefaultConfig, mergeWithDefaults };