@seanmozeik/tripwire 0.7.0 → 0.7.2

package/dist/types/dispatch.d.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env bun
+import { Effect } from 'effect';
+import { type Config, type ResolvedConfig, type SecretScannerConfig } from './lib/config';
+import { type Decision } from './lib/decision';
+import { type HookEvent } from './lib/event.ts';
+declare const normalizeToolName: (name: string) => string;
+type RuleFn = () => Decision;
+interface Rule {
+    readonly name: string;
+    readonly fn: RuleFn;
+}
+declare const collectPreToolUseRules: (tool: string, input: unknown, config: ResolvedConfig) => Rule[];
+declare const collectPostToolUseRules: (tool: string, response: unknown, secretScanner: SecretScannerConfig) => Rule[];
+declare const runRules: (rules: readonly Rule[], timeoutMs: number) => Effect.Effect<Decision>;
+declare const runRulesSync: (rules: readonly Rule[]) => Decision;
+declare const decide: (event: HookEvent, config?: Config) => Decision;
+declare const runHook: () => void;
+export { collectPostToolUseRules, collectPreToolUseRules, decide, normalizeToolName, runHook, runRules, runRulesSync, };

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export type { Decision } from './lib/decision';
+export type { HookEvent } from './lib/event';
+export type { Config, ConfigLoad, ResolvedConfig } from './lib/config';
+export { allow, deny, ask, warn } from './lib/decision';
+export { decide } from './dispatch';
+export { getDefaultConfig, loadConfig, loadConfigResult, mergeWithDefaults } from './lib/config';

package/dist/types/lib/bash.d.ts

@@ -0,0 +1,27 @@
+interface Segment {
+    readonly head: string;
+    readonly tokens: readonly string[];
+    readonly args: readonly string[];
+    readonly flags: readonly string[];
+    readonly redirects: readonly Redirect[];
+    readonly raw: string;
+}
+interface Redirect {
+    readonly op: '>' | '>>' | '<' | '<<' | '<<<' | '<>' | '>&' | '<&' | '&>' | '&>>';
+    readonly target: string;
+}
+declare const collectHeredocBodies: (cmd: string) => ReadonlyMap<string, string>;
+interface ExecSpec {
+    readonly execFlags: ReadonlySet<string>;
+    readonly placeholders: ReadonlySet<string>;
+    readonly pickRoot: (tokens: readonly string[], execFlagIdx: number) => string;
+}
+declare const EXEC_SPECS: Readonly<Record<string, ExecSpec>>;
+declare const unwrapStaticString: (value: string, heredocBodies?: ReadonlyMap<string, string>) => string;
+declare const UNSUPPORTED_SHELL_HEAD = "__tripwire_unsupported_shell__";
+declare const parseCommand: (cmd: string) => Segment[];
+declare const isSafePathTarget: (raw: string, extraRelative?: readonly string[], extraAbsolute?: readonly string[]) => boolean;
+declare const safeScopesSummary: (extraRelative?: readonly string[], extraAbsolute?: readonly string[]) => string;
+declare const hasBypass: (cmd: string) => boolean;
+export type { Redirect, Segment };
+export { EXEC_SPECS, UNSUPPORTED_SHELL_HEAD, collectHeredocBodies, hasBypass, isSafePathTarget, parseCommand, safeScopesSummary, unwrapStaticString, };

package/dist/types/lib/config.d.ts

@@ -0,0 +1,110 @@
+import { Effect, Schema } from 'effect';
+declare const BlockRuleSchema: Schema.Struct<{
+    readonly pattern: Schema.String;
+    readonly message: Schema.String;
+    readonly action: Schema.optional<Schema.Union<readonly [Schema.Literal<"deny">, Schema.Literal<"ask">]>>;
+    readonly requiresFlags: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly forbidsFlagValues: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly flag: Schema.String;
+        readonly values: Schema.$Array<Schema.String>;
+    }>>>;
+}>;
+declare const GitConfigSchema: Schema.Struct<{
+    readonly protectedBranches: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly enforceConventionalCommits: Schema.optional<Schema.Boolean>;
+}>;
+declare const SafePathsConfigSchema: Schema.Struct<{
+    readonly relative: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly absolute: Schema.optional<Schema.$Array<Schema.String>>;
+}>;
+declare const ToolPolicySchema: Schema.Struct<{
+    readonly rule: Schema.String;
+    readonly executables: Schema.$Array<Schema.String>;
+    readonly action: Schema.Union<readonly [Schema.Literal<"deny">, Schema.Literal<"warn">]>;
+    readonly message: Schema.String;
+    readonly match: Schema.optional<Schema.Struct<{
+        readonly argumentsIncludeAll: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly argumentsStartWith: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly shortFlagsIncludeAll: Schema.optional<Schema.$Array<Schema.String>>;
+    }>>;
+}>;
+declare const SecretScannerConfigSchema: Schema.Struct<{
+    readonly executable: Schema.String;
+    readonly timeoutMs: Schema.Finite;
+}>;
+declare const ConfigSchema: Schema.Struct<{
+    readonly git: Schema.optional<Schema.Struct<{
+        readonly protectedBranches: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly enforceConventionalCommits: Schema.optional<Schema.Boolean>;
+    }>>;
+    readonly safePaths: Schema.optional<Schema.Struct<{
+        readonly relative: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly absolute: Schema.optional<Schema.$Array<Schema.String>>;
+    }>>;
+    readonly toolPolicies: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly rule: Schema.String;
+        readonly executables: Schema.$Array<Schema.String>;
+        readonly action: Schema.Union<readonly [Schema.Literal<"deny">, Schema.Literal<"warn">]>;
+        readonly message: Schema.String;
+        readonly match: Schema.optional<Schema.Struct<{
+            readonly argumentsIncludeAll: Schema.optional<Schema.$Array<Schema.String>>;
+            readonly argumentsStartWith: Schema.optional<Schema.$Array<Schema.String>>;
+            readonly shortFlagsIncludeAll: Schema.optional<Schema.$Array<Schema.String>>;
+        }>>;
+    }>>>;
+    readonly blockedCommands: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly pattern: Schema.String;
+        readonly message: Schema.String;
+        readonly action: Schema.optional<Schema.Union<readonly [Schema.Literal<"deny">, Schema.Literal<"ask">]>>;
+        readonly requiresFlags: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly forbidsFlagValues: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly flag: Schema.String;
+            readonly values: Schema.$Array<Schema.String>;
+        }>>>;
+    }>>>;
+    readonly allowedCommands: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly pattern: Schema.String;
+        readonly message: Schema.String;
+        readonly action: Schema.optional<Schema.Union<readonly [Schema.Literal<"deny">, Schema.Literal<"ask">]>>;
+        readonly requiresFlags: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly forbidsFlagValues: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly flag: Schema.String;
+            readonly values: Schema.$Array<Schema.String>;
+        }>>>;
+    }>>>;
+    readonly secretScanner: Schema.optional<Schema.Struct<{
+        readonly executable: Schema.String;
+        readonly timeoutMs: Schema.Finite;
+    }>>;
+}>;
+declare const CONFIG_PATH: string;
+declare const getDefaultConfig: () => ResolvedConfig;
+declare const mergeWithDefaults: (partial: Config) => ResolvedConfig;
+type ConfigLoad = {
+    readonly ok: true;
+    readonly config: ResolvedConfig;
+} | {
+    readonly ok: false;
+    readonly error: string;
+};
+export declare const loadConfigResult: (path?: string) => Effect.Effect<ConfigLoad>;
+export declare const loadConfig: (path?: string) => Effect.Effect<ResolvedConfig>;
+export type BlockRule = typeof BlockRuleSchema.Type;
+export type GitConfig = typeof GitConfigSchema.Type;
+export type SafePathsConfig = typeof SafePathsConfigSchema.Type;
+export type ToolPolicy = typeof ToolPolicySchema.Type;
+export type SecretScannerConfig = typeof SecretScannerConfigSchema.Type;
+export type Config = typeof ConfigSchema.Type;
+export interface ResolvedConfig {
+    readonly git: {
+        readonly protectedBranches: readonly string[];
+        readonly enforceConventionalCommits: boolean;
+    };
+    readonly safePaths: SafePathsConfig;
+    readonly toolPolicies: readonly ToolPolicy[];
+    readonly blockedCommands: readonly BlockRule[];
+    readonly allowedCommands: readonly BlockRule[];
+    readonly secretScanner: SecretScannerConfig;
+}
+export type { ConfigLoad };
+export { CONFIG_PATH, ConfigSchema, SecretScannerConfigSchema, getDefaultConfig, mergeWithDefaults, };

package/dist/types/lib/cursor.d.ts

@@ -0,0 +1,16 @@
+type HookHost = {
+    readonly kind: 'native';
+} | {
+    readonly kind: 'cursor';
+    readonly eventName: string;
+    readonly post: boolean;
+};
+interface NormalizedHookInput {
+    readonly event: unknown;
+    readonly host: HookHost;
+}
+declare const CURSOR_PRE_EVENTS: Set<string>;
+declare const CURSOR_POST_EVENTS: Set<string>;
+declare const cursorHost: (eventName: string) => HookHost;
+declare const normalizeHookInput: (raw: unknown, hintedEventName?: string) => NormalizedHookInput;
+export { CURSOR_POST_EVENTS, CURSOR_PRE_EVENTS, cursorHost, normalizeHookInput, type HookHost, type NormalizedHookInput, };

package/dist/types/lib/decision.d.ts

@@ -0,0 +1,13 @@
+type DecisionKind = 'allow' | 'warn' | 'ask' | 'deny';
+interface Decision {
+    readonly kind: DecisionKind;
+    readonly rule: string;
+    readonly message: string;
+}
+declare const allow: (rule: string) => Decision;
+declare const warn: (rule: string, message: string) => Decision;
+declare const ask: (rule: string, message: string) => Decision;
+declare const deny: (rule: string, message: string) => Decision;
+declare const merge: (decisions: readonly Decision[]) => Decision;
+export type { Decision, DecisionKind };
+export { allow, ask, deny, merge, warn };

package/dist/types/lib/diff.d.ts

@@ -0,0 +1,3 @@
+declare const addedLines: (prev: string, next: string) => string[];
+declare const readFileOrEmpty: (path: string) => string;
+export { addedLines, readFileOrEmpty };

package/dist/types/lib/event.d.ts

@@ -0,0 +1,45 @@
+import { Schema } from 'effect';
+declare const HookEvent: Schema.Struct<{
+    readonly hook_event_name: Schema.String;
+    readonly tool_name: Schema.optional<Schema.String>;
+    readonly tool_input: Schema.optional<Schema.Unknown>;
+    readonly tool_response: Schema.optional<Schema.Unknown>;
+    readonly cwd: Schema.optional<Schema.String>;
+    readonly session_id: Schema.optional<Schema.String>;
+    readonly turn_id: Schema.optional<Schema.String>;
+    readonly tool_use_id: Schema.optional<Schema.String>;
+}>;
+type HookEventType = typeof HookEvent.Type;
+interface BashInput {
+    readonly command: string;
+}
+interface EditInput {
+    readonly file_path: string;
+    readonly old_string: string;
+    readonly new_string: string;
+}
+interface WriteInput {
+    readonly file_path: string;
+    readonly content: string;
+}
+interface ReadInput {
+    readonly file_path: string;
+}
+interface BashResponse {
+    readonly stdout?: string;
+    readonly stderr?: string;
+    readonly interrupted?: boolean;
+}
+interface ReadResponse {
+    readonly content?: string;
+    readonly file?: {
+        readonly content?: string;
+    };
+}
+declare const isBashInput: (x: unknown) => x is BashInput;
+declare const isEditInput: (x: unknown) => x is EditInput;
+declare const isWriteInput: (x: unknown) => x is WriteInput;
+declare const isReadInput: (x: unknown) => x is ReadInput;
+declare const extractResponseText: (toolName: string, response: unknown) => string;
+export type { BashInput, BashResponse, EditInput, HookEventType as HookEvent, ReadInput, ReadResponse, WriteInput, };
+export { HookEvent as HookEventSchema, extractResponseText, isBashInput, isEditInput, isReadInput, isWriteInput, };

package/dist/types/lib/log.d.ts

@@ -0,0 +1,2 @@
+declare const logError: (rule: string, err: unknown) => void;
+export { logError };

package/dist/types/lib/secrets.d.ts

@@ -0,0 +1,41 @@
+import { Schema } from 'effect';
+import type { SecretScannerConfig } from './config';
+declare const BetterleaksFindingSchema: Schema.Struct<{
+    readonly RuleID: Schema.String;
+    readonly Description: Schema.String;
+    readonly StartLine: Schema.Finite;
+    readonly EndLine: Schema.Finite;
+    readonly Secret: Schema.String;
+    readonly Match: Schema.String;
+}>;
+type BetterleaksFinding = typeof BetterleaksFindingSchema.Type;
+interface ScanSuccess {
+    readonly ok: true;
+    readonly hits: readonly {
+        readonly rule: string;
+        readonly count: number;
+    }[];
+    readonly redacted: string;
+}
+type ScanFailureCategory = 'missing-executable' | 'timeout' | 'non-zero-exit' | 'malformed-json';
+interface ScanFailure {
+    readonly ok: false;
+    readonly category: ScanFailureCategory;
+}
+type ScanResult = ScanSuccess | ScanFailure;
+interface ScannerInvocation {
+    readonly executable: string;
+    readonly args: readonly string[];
+    readonly input: string;
+    readonly timeoutMs: number;
+}
+interface ScannerProcessResult {
+    readonly status: number | null;
+    readonly stdout: string;
+    readonly error?: unknown;
+}
+type ScannerRunner = (invocation: ScannerInvocation) => ScannerProcessResult;
+declare const escapeRegExp: (value: string) => string;
+declare const scanAndRedact: (input: string, config: SecretScannerConfig, runner?: ScannerRunner) => ScanResult;
+export type { BetterleaksFinding, ScanFailure, ScanFailureCategory, ScannerInvocation, ScannerProcessResult, ScannerRunner, ScanResult, ScanSuccess, };
+export { escapeRegExp, scanAndRedact };

package/dist/types/rules/bash-deny.d.ts

@@ -0,0 +1,5 @@
+import { type Segment } from '../lib/bash';
+import { type Decision } from '../lib/decision';
+declare const UNBYPASSABLE_RULES: ReadonlySet<string>;
+declare const bashDeny: (segments: readonly Segment[], cmd: string) => Decision;
+export { bashDeny, UNBYPASSABLE_RULES };

package/dist/types/rules/bash-git.d.ts

@@ -0,0 +1,5 @@
+import { type Segment } from '../lib/bash';
+import type { GitConfig } from '../lib/config';
+import { type Decision } from '../lib/decision';
+declare const bashGit: (segments: readonly Segment[], cmd: string, config: GitConfig) => Decision;
+export { bashGit };

package/dist/types/rules/bash-network-install.d.ts

@@ -0,0 +1,4 @@
+import { type Segment } from '../lib/bash';
+import { type Decision } from '../lib/decision';
+declare const bashNetworkInstall: (segments: readonly Segment[], cmd: string) => Decision;
+export { bashNetworkInstall };

package/dist/types/rules/bash-redirect.d.ts

@@ -0,0 +1,4 @@
+import { type Segment } from '../lib/bash';
+import { type Decision } from '../lib/decision';
+declare const bashRedirect: (segments: readonly Segment[], cmd: string) => Decision;
+export { bashRedirect };

package/dist/types/rules/bash-scoped-rm.d.ts

@@ -0,0 +1,5 @@
+import { type Segment } from '../lib/bash';
+import type { SafePathsConfig } from '../lib/config';
+import { type Decision } from '../lib/decision';
+declare const bashScopedRm: (segments: readonly Segment[], cmd: string, config: SafePathsConfig) => Decision;
+export { bashScopedRm };

package/dist/types/rules/bash-tar-explosion.d.ts

@@ -0,0 +1,4 @@
+import { type Segment } from '../lib/bash';
+import { type Decision } from '../lib/decision';
+declare const bashTarExplosion: (segments: readonly Segment[], cmd: string) => Decision;
+export { bashTarExplosion };

package/dist/types/rules/config-custom.d.ts

@@ -0,0 +1,6 @@
+import { type Segment } from '../lib/bash';
+import type { BlockRule } from '../lib/config';
+import { type Decision } from '../lib/decision';
+declare const matchPattern: (segments: readonly Segment[], rule: BlockRule) => boolean;
+export declare const configCustom: (segments: readonly Segment[], cmd: string, blockedCommands: readonly BlockRule[], allowedCommands: readonly BlockRule[]) => Decision;
+export { matchPattern };

package/dist/types/rules/lazy-code.d.ts

@@ -0,0 +1,4 @@
+import { type Decision } from '../lib/decision';
+import type { EditInput, WriteInput } from '../lib/event';
+declare const lazyCode: (input: EditInput | WriteInput) => Decision;
+export { lazyCode };

package/dist/types/rules/path-protect.d.ts

@@ -0,0 +1,12 @@
+import { type Decision } from '../lib/decision';
+import type { EditInput, WriteInput } from '../lib/event';
+interface ProtectedPathSpec {
+    readonly pattern: RegExp;
+    readonly rule: string;
+    readonly message: string;
+}
+type PathAccess = 'read' | 'write';
+declare const classifyProtectedPath: (submittedPath: string, access: PathAccess, specs: readonly ProtectedPathSpec[]) => ProtectedPathSpec | null;
+declare const pathProtect: (input: EditInput | WriteInput) => Decision;
+export type { PathAccess, ProtectedPathSpec };
+export { classifyProtectedPath, pathProtect };

package/dist/types/rules/post-secret-scrub.d.ts

@@ -0,0 +1,12 @@
+import type { SecretScannerConfig } from '../lib/config';
+import { type Decision } from '../lib/decision';
+import { type ScannerRunner } from '../lib/secrets';
+interface PostInput {
+    readonly toolName: string;
+    readonly response: unknown;
+    readonly secretScanner: SecretScannerConfig;
+    readonly scannerRunner?: ScannerRunner;
+}
+declare const postSecretScrub: (input: PostInput) => Decision;
+export type { PostInput };
+export { postSecretScrub };

package/dist/types/rules/read-protect.d.ts

@@ -0,0 +1,4 @@
+import { type Decision } from '../lib/decision';
+import type { ReadInput } from '../lib/event';
+declare const readProtect: (input: ReadInput) => Decision;
+export { readProtect };

package/dist/types/rules/tool-policy.d.ts

@@ -0,0 +1,5 @@
+import { type Segment } from '../lib/bash';
+import type { ToolPolicy } from '../lib/config';
+import { type Decision } from '../lib/decision';
+declare const toolPolicy: (segments: readonly Segment[], command: string, policies: readonly ToolPolicy[]) => Decision;
+export { toolPolicy };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seanmozeik/tripwire",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Configurable safety hooks for Claude Code, Codex, Cursor, Pi, and Oh My Pi",
   "keywords": [
     "ai-agents",
@@ -22,26 +22,26 @@
     "url": "git+https://github.com/seanmozeik/tripwire.git"
   },
   "bin": {
-    "tripwire": "./scripts/tripwire-cli",
-    "tripwire-hook": "./dist/tripwire"
+    "tripwire": "./dist/tripwire-cli.js",
+    "tripwire-hook": "./dist/tripwire-hook.js"
   },
+  "workspaces": [
+    "packages/*"
+  ],
   "files": [
-    "dist/tripwire-pi.js",
+    "dist",
     "LICENSE",
     "package.json",
-    "scripts/tripwire-cli",
-    "src",
     "README.md"
   ],
-  "os": [
-    "darwin"
-  ],
-  "cpu": [
-    "arm64"
-  ],
   "type": "module",
+  "types": "./dist/types/index.d.ts",
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
   },
   "publishConfig": {
     "access": "public"
@@ -77,6 +77,9 @@
     "@effect/platform-bun": "4.0.0-rc.112",
     "effect": "4.0.0-rc.112"
   },
+  "optionalDependencies": {
+    "@seanmozeik/tripwire-darwin-arm64": "0.7.2"
+  },
   "engines": {
     "bun": ">=1.4"
   }

package/scripts/tripwire-cli

@@ -1,12 +0,0 @@
-#!/bin/sh
-
-case $0 in
-  */*) launcher_directory=${0%/*} ;;
-  *)
-    launcher_path=$(command -v "$0") || exit 127
-    launcher_directory=${launcher_path%/*}
-    ;;
-esac
-
-[ -n "$launcher_directory" ] || launcher_directory=/
-exec "$launcher_directory/tripwire-hook" --tripwire-force-cli "$@"