@seanmozeik/tripwire 0.7.0 → 0.7.2

package/src/lib/config.ts

@@ -1,174 +0,0 @@
-// Config system using Effect Schema for validation and Effect for safe loading.
-// Config file: ~/.config/tripwire/config.json
-// Falls back to defaults only if the file does not exist.
-
-import { readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-
-import { Cause, Data, Effect, Schema } from 'effect';
-
-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 GitConfigSchema = Schema.Struct({
-  protectedBranches: Schema.optional(Schema.Array(Schema.String)),
-  enforceConventionalCommits: Schema.optional(Schema.Boolean),
-});
-
-const SafePathsConfigSchema = Schema.Struct({
-  relative: Schema.optional(Schema.Array(Schema.String)),
-  absolute: Schema.optional(Schema.Array(Schema.String)),
-});
-
-const ToolPolicyMatchSchema = Schema.Struct({
-  argumentsIncludeAll: Schema.optional(Schema.Array(Schema.String)),
-  argumentsStartWith: Schema.optional(Schema.Array(Schema.String)),
-  shortFlagsIncludeAll: Schema.optional(Schema.Array(Schema.String)),
-});
-
-const ToolPolicySchema = Schema.Struct({
-  rule: Schema.String,
-  executables: Schema.Array(Schema.String),
-  action: Schema.Union([Schema.Literal('deny'), Schema.Literal('warn')]),
-  message: Schema.String,
-  match: Schema.optional(ToolPolicyMatchSchema),
-});
-
-const SecretScannerConfigSchema = Schema.Struct({
-  executable: Schema.String,
-  timeoutMs: Schema.Finite.check(Schema.isGreaterThan(0)),
-});
-
-const ConfigSchema = Schema.Struct({
-  git: Schema.optional(GitConfigSchema),
-  safePaths: Schema.optional(SafePathsConfigSchema),
-  toolPolicies: Schema.optional(Schema.Array(ToolPolicySchema)),
-  blockedCommands: Schema.optional(Schema.Array(BlockRuleSchema)),
-  allowedCommands: Schema.optional(Schema.Array(BlockRuleSchema)),
-  secretScanner: Schema.optional(SecretScannerConfigSchema),
-});
-
-const CONFIG_PATH = `${homedir()}/.config/tripwire/config.json`;
-
-class ConfigReadError extends Data.TaggedError('ConfigReadError')<{ readonly cause: unknown }> {}
-
-class ConfigParseError extends Data.TaggedError('ConfigParseError')<{ readonly cause: unknown }> {}
-
-const isMissingFile = (cause: unknown): boolean =>
-  cause instanceof Error && 'code' in cause && cause.code === 'ENOENT';
-
-const readConfigFile = (path: string): Effect.Effect<string | null, ConfigReadError> =>
-  Effect.try({
-    try: () => readFileSync(path, 'utf8'),
-    catch: (cause) => new ConfigReadError({ cause }),
-  }).pipe(
-    Effect.catchTag('ConfigReadError', (error) =>
-      isMissingFile(error.cause) ? Effect.succeed(null) : Effect.fail(error),
-    ),
-  );
-
-const parseConfigJson = (raw: string): Effect.Effect<unknown, Error> =>
-  Effect.try({
-    try: () => JSON.parse(raw) as unknown,
-    catch: (cause) => new ConfigParseError({ cause }),
-  });
-
-// Reject unknown keys so a misspelled policy cannot disappear silently.
-const decodeConfig = (unknown: unknown): Effect.Effect<Config, Error> =>
-  Schema.decodeUnknownEffect(ConfigSchema)(unknown, { onExcessProperty: 'error' });
-
-const getDefaultConfig = (): ResolvedConfig => ({
-  git: { protectedBranches: [], enforceConventionalCommits: false },
-  safePaths: {},
-  toolPolicies: [],
-  blockedCommands: [],
-  allowedCommands: [],
-  secretScanner: { executable: 'betterleaks', timeoutMs: 5000 },
-});
-
-const mergeWithDefaults = (partial: Config): ResolvedConfig => {
-  const defaults = getDefaultConfig();
-  return {
-    git: {
-      protectedBranches: partial.git?.protectedBranches ?? defaults.git.protectedBranches,
-      enforceConventionalCommits:
-        partial.git?.enforceConventionalCommits ?? defaults.git.enforceConventionalCommits,
-    },
-    safePaths: { ...defaults.safePaths, ...partial.safePaths },
-    toolPolicies: partial.toolPolicies ?? defaults.toolPolicies,
-    blockedCommands: partial.blockedCommands ?? defaults.blockedCommands,
-    allowedCommands: partial.allowedCommands ?? defaults.allowedCommands,
-    secretScanner: partial.secretScanner ?? defaults.secretScanner,
-  };
-};
-
-// A present but invalid config must not fall back to defaults because that
-// would drop custom safety policy. Only a missing file selects defaults.
-type ConfigLoad =
-  | { readonly ok: true; readonly config: ResolvedConfig }
-  | { readonly ok: false; readonly error: string };
-
-export const loadConfigResult = (path: string = CONFIG_PATH): Effect.Effect<ConfigLoad> =>
-  Effect.gen(function* loadConfigResultEffect() {
-    const raw = yield* readConfigFile(path);
-    if (raw === null) {
-      const result: ConfigLoad = { ok: true, config: getDefaultConfig() };
-      return result;
-    }
-
-    const parsed = yield* parseConfigJson(raw);
-    const config = yield* decodeConfig(parsed);
-    const result: ConfigLoad = { ok: true, config: mergeWithDefaults(config) };
-    return result;
-  }).pipe(
-    Effect.timeout(1000),
-    Effect.catchCause((cause) => {
-      const result: ConfigLoad = { ok: false, error: Cause.pretty(cause) };
-      return Effect.succeed(result);
-    }),
-  );
-
-// Library consumers get a loud failure instead of an unconfigured fallback.
-export const loadConfig = (path: string = CONFIG_PATH): Effect.Effect<ResolvedConfig> =>
-  loadConfigResult(path).pipe(
-    Effect.flatMap((result) =>
-      result.ok
-        ? Effect.succeed(result.config)
-        : Effect.die(new Error(`[tripwire] config load failed (${path}): ${result.error}`)),
-    ),
-  );
-
-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/src/lib/cursor.ts

@@ -1,336 +0,0 @@
-import type { HookEvent } from './event';
-
-type JsonRecord = Record<string, unknown>;
-
-type HookHost =
-  | { readonly kind: 'native' }
-  | { readonly kind: 'cursor'; readonly eventName: string; readonly post: boolean };
-
-interface NormalizedHookInput {
-  readonly event: unknown;
-  readonly host: HookHost;
-}
-
-const CURSOR_PRE_EVENTS = new Set([
-  'preToolUse',
-  'beforeShellExecution',
-  'beforeMCPExecution',
-  'beforeReadFile',
-  'beforeTabFileRead',
-]);
-
-const CURSOR_POST_EVENTS = new Set([
-  'postToolUse',
-  'postToolUseFailure',
-  'afterShellExecution',
-  'afterMCPExecution',
-  'afterFileEdit',
-  'afterTabFileEdit',
-]);
-
-const cursorHost = (eventName: string): HookHost => ({
-  kind: 'cursor',
-  eventName,
-  post: CURSOR_POST_EVENTS.has(eventName),
-});
-
-const isCursorEventName = (eventName: string): boolean =>
-  CURSOR_PRE_EVENTS.has(eventName) || CURSOR_POST_EVENTS.has(eventName);
-
-const isRecord = (value: unknown): value is JsonRecord =>
-  typeof value === 'object' && value !== null && !Array.isArray(value);
-
-const stringField = (value: JsonRecord, ...names: readonly string[]): string | undefined => {
-  for (const name of names) {
-    const candidate = value[name];
-    if (typeof candidate === 'string') {
-      return candidate;
-    }
-  }
-  return undefined;
-};
-
-const valueField = (value: JsonRecord, ...names: readonly string[]): unknown => {
-  for (const name of names) {
-    if (name in value) {
-      return value[name];
-    }
-  }
-  return undefined;
-};
-
-const inputStringField = (
-  raw: JsonRecord,
-  input: unknown,
-  ...names: readonly string[]
-): string | undefined => {
-  const fromRaw = stringField(raw, ...names);
-  if (fromRaw !== undefined) {
-    return fromRaw;
-  }
-  if (typeof input === 'string' && names.includes('command')) {
-    return input;
-  }
-  return isRecord(input) ? stringField(input, ...names) : undefined;
-};
-
-const requiredString = (value: string | undefined, label: string): string => {
-  if (value === undefined) {
-    throw new Error(`Cursor hook payload missing ${label}`);
-  }
-  return value;
-};
-
-const normalizeCursorToolName = (name: string): string => {
-  const normalized = name.toLowerCase();
-  if (
-    normalized === 'bash' ||
-    normalized === 'exec' ||
-    normalized === 'shell' ||
-    normalized === 'run_command'
-  ) {
-    return 'Bash';
-  }
-  if (normalized === 'read' || normalized === 'read_file') {
-    return 'Read';
-  }
-  if (normalized === 'write' || normalized === 'write_file') {
-    return 'Write';
-  }
-  if (
-    normalized === 'edit' ||
-    normalized === 'edit_file' ||
-    normalized === 'multiedit' ||
-    normalized === 'apply_patch'
-  ) {
-    return 'Edit';
-  }
-  return name;
-};
-
-const isFileTool = (tool: string): boolean =>
-  tool === 'Read' || tool === 'Write' || tool === 'Edit';
-
-const normalizeBashInput = (input: unknown, required: boolean) => {
-  let command: string | undefined;
-  if (typeof input === 'string') {
-    command = input;
-  } else if (isRecord(input)) {
-    command = stringField(input, 'command', 'cmd');
-  }
-  if (required && command === undefined) {
-    throw new Error('Cursor hook payload missing command');
-  }
-  if (typeof input === 'string') {
-    return { command: input };
-  }
-  if (!isRecord(input) || command === undefined) {
-    return input;
-  }
-  return { ...input, command };
-};
-
-const normalizeFileInput = (tool: string, input: JsonRecord, required: boolean): JsonRecord => {
-  const filePath = stringField(input, 'file_path', 'filePath', 'path');
-  if (required && filePath === undefined) {
-    throw new Error(`Cursor ${tool} hook payload missing file path`);
-  }
-  if (tool === 'Read') {
-    return { ...input, file_path: filePath ?? '' };
-  }
-  if (tool === 'Write') {
-    const content = stringField(input, 'content', 'fileText', 'text');
-    if (required && content === undefined) {
-      throw new Error('Cursor Write hook payload missing content');
-    }
-    return { ...input, file_path: filePath ?? '', content: content ?? '' };
-  }
-  if (tool === 'Edit') {
-    const oldString = stringField(input, 'old_string', 'oldString');
-    const newString = stringField(input, 'new_string', 'newString');
-    if (required && (oldString === undefined || newString === undefined)) {
-      throw new Error('Cursor Edit hook payload missing oldString or newString');
-    }
-    return {
-      ...input,
-      file_path: filePath ?? '',
-      old_string: oldString ?? '',
-      new_string: newString ?? '',
-    };
-  }
-  return input;
-};
-
-const normalizeToolInput = (tool: string, input: unknown, required = true): unknown => {
-  if (tool === 'Bash') {
-    return normalizeBashInput(input, required);
-  }
-  if (!isFileTool(tool)) {
-    return input;
-  }
-  if (!isRecord(input)) {
-    if (required) {
-      throw new Error(`Cursor ${tool} hook payload is missing tool input`);
-    }
-    return input;
-  }
-  return normalizeFileInput(tool, input, required);
-};
-
-const normalizeToolResponse = (tool: string, response: unknown) => {
-  if (typeof response !== 'string') {
-    return response;
-  }
-  if (tool === 'Bash') {
-    return { stdout: response, stderr: '' };
-  }
-  if (tool === 'Read') {
-    return { content: response };
-  }
-  return { content: response };
-};
-
-const cursorToolName = (eventName: string, raw: JsonRecord): string => {
-  if (eventName === 'beforeShellExecution' || eventName === 'afterShellExecution') {
-    return 'Bash';
-  }
-  if (
-    eventName === 'beforeReadFile' ||
-    eventName === 'beforeTabFileRead' ||
-    eventName === 'afterFileEdit' ||
-    eventName === 'afterTabFileEdit'
-  ) {
-    return eventName.startsWith('before') ? 'Read' : 'Edit';
-  }
-  const rawName = stringField(raw, 'tool_name', 'toolName');
-  if (rawName !== undefined) {
-    return normalizeCursorToolName(rawName);
-  }
-  const input = valueField(raw, 'tool_input', 'toolInput');
-  if (
-    stringField(raw, 'command', 'cmd') !== undefined ||
-    typeof input === 'string' ||
-    (isRecord(input) && stringField(input, 'command', 'cmd') !== undefined)
-  ) {
-    return 'Bash';
-  }
-  if (
-    stringField(raw, 'file_path', 'filePath', 'path') !== undefined ||
-    (isRecord(input) && stringField(input, 'file_path', 'filePath', 'path') !== undefined)
-  ) {
-    return 'Read';
-  }
-  return '';
-};
-
-const cursorTopLevelToolInput = (tool: string, raw: JsonRecord): JsonRecord => {
-  if (tool === 'Bash') {
-    return { command: inputStringField(raw, undefined, 'command', 'cmd') };
-  }
-  const input: JsonRecord = { file_path: stringField(raw, 'file_path', 'filePath', 'path') };
-  if (tool === 'Write') {
-    input['content'] = stringField(raw, 'content', 'fileText', 'text');
-  }
-  if (tool === 'Edit') {
-    input['old_string'] = stringField(raw, 'old_string', 'oldString');
-    input['new_string'] = stringField(raw, 'new_string', 'newString');
-  }
-  return input;
-};
-
-const cursorToolInput = (eventName: string, tool: string, raw: JsonRecord, post: boolean) => {
-  const input = valueField(raw, 'tool_input', 'toolInput');
-  const required = !post;
-  if (eventName === 'beforeShellExecution' || eventName === 'afterShellExecution') {
-    const command = inputStringField(raw, input, 'command', 'cmd');
-    return { command: required ? requiredString(command, 'command') : (command ?? '') };
-  }
-  if (
-    eventName === 'beforeReadFile' ||
-    eventName === 'beforeTabFileRead' ||
-    eventName === 'afterFileEdit' ||
-    eventName === 'afterTabFileEdit'
-  ) {
-    const filePath = inputStringField(raw, input, 'file_path', 'filePath', 'path');
-    return normalizeToolInput(
-      tool,
-      {
-        file_path: required ? requiredString(filePath, 'file path') : (filePath ?? ''),
-        ...(Array.isArray(raw['edits']) && { edits: raw['edits'] }),
-      },
-      required,
-    );
-  }
-  if (input === undefined && ['Bash', 'Read', 'Write', 'Edit'].includes(tool)) {
-    return normalizeToolInput(tool, cursorTopLevelToolInput(tool, raw), required);
-  }
-  return normalizeToolInput(tool, input, required);
-};
-
-const cursorToolResponse = (eventName: string, tool: string, raw: JsonRecord): unknown => {
-  if (eventName === 'afterShellExecution') {
-    return normalizeToolResponse(tool, stringField(raw, 'output') ?? '');
-  }
-  const response = valueField(
-    raw,
-    'tool_response',
-    'toolResponse',
-    'tool_output',
-    'toolOutput',
-    'result',
-    'result_json',
-  );
-  return normalizeToolResponse(tool, response);
-};
-
-const normalizeCursorEvent = (
-  raw: JsonRecord,
-  eventName: string,
-  post: boolean,
-): { readonly event: HookEvent; readonly host: HookHost } => {
-  const tool = cursorToolName(eventName, raw);
-  const input = cursorToolInput(eventName, tool, raw, post);
-  const response = post ? cursorToolResponse(eventName, tool, raw) : undefined;
-  const cwd = stringField(raw, 'cwd');
-  const sessionId = stringField(raw, 'conversation_id', 'session_id');
-  const toolUseId = stringField(raw, 'tool_use_id');
-  const event: HookEvent = {
-    hook_event_name: post ? 'PostToolUse' : 'PreToolUse',
-    ...(tool.length > 0 && { tool_name: tool }),
-    ...(input !== undefined && { tool_input: input }),
-    ...(response !== undefined && { tool_response: response }),
-    ...(cwd !== undefined && { cwd }),
-    ...(sessionId !== undefined && { session_id: sessionId }),
-    ...(toolUseId !== undefined && { tool_use_id: toolUseId }),
-  };
-  return { event, host: cursorHost(eventName) };
-};
-
-const normalizeHookInput = (raw: unknown, hintedEventName?: string): NormalizedHookInput => {
-  if (hintedEventName !== undefined && !isCursorEventName(hintedEventName)) {
-    throw new Error(`Unknown Cursor hook event "${hintedEventName}"`);
-  }
-  if (!isRecord(raw)) {
-    if (hintedEventName !== undefined) {
-      throw new Error(`Cursor ${hintedEventName} hook payload must be a JSON object`);
-    }
-    return { event: raw, host: { kind: 'native' } };
-  }
-  const eventName = hintedEventName ?? stringField(raw, 'hook_event_name');
-  if (eventName !== undefined && CURSOR_PRE_EVENTS.has(eventName)) {
-    return normalizeCursorEvent(raw, eventName, false);
-  }
-  if (eventName !== undefined && CURSOR_POST_EVENTS.has(eventName)) {
-    return normalizeCursorEvent(raw, eventName, true);
-  }
-  return { event: raw, host: { kind: 'native' } };
-};
-
-export {
-  CURSOR_POST_EVENTS,
-  CURSOR_PRE_EVENTS,
-  cursorHost,
-  normalizeHookInput,
-  type HookHost,
-  type NormalizedHookInput,
-};

package/src/lib/decision.ts

@@ -1,36 +0,0 @@
-// Decisions are ordered by restrictiveness:
-//   Allow — let the tool call proceed silently
-//   Warn  — let the tool call proceed but inject a system message so the
-//           Agent sees the advisory in its next turn
-//   Ask   — Claude Code prompts the user before letting the call proceed
-//   Deny  — block the tool call (PreToolUse) or refuse to surface its
-//           Output to the model (PostToolUse)
-//
-type DecisionKind = 'allow' | 'warn' | 'ask' | 'deny';
-
-interface Decision {
-  readonly kind: DecisionKind;
-  readonly rule: string;
-  readonly message: string;
-}
-
-const order: Record<DecisionKind, number> = { allow: 0, warn: 1, ask: 2, deny: 3 };
-
-const allow = (rule: string): Decision => ({ kind: 'allow', rule, message: '' });
-const warn = (rule: string, message: string): Decision => ({ kind: 'warn', rule, message });
-const ask = (rule: string, message: string): Decision => ({ kind: 'ask', rule, message });
-const deny = (rule: string, message: string): Decision => ({ kind: 'deny', rule, message });
-
-// Merge picks the most restrictive kind.
-const merge = (decisions: readonly Decision[]): Decision => {
-  let best: Decision = allow('none');
-  for (const d of decisions) {
-    if (order[d.kind] > order[best.kind]) {
-      best = d;
-    }
-  }
-  return best;
-};
-
-export type { Decision, DecisionKind };
-export { allow, ask, deny, merge, warn };

package/src/lib/diff.ts

@@ -1,29 +0,0 @@
-import { readFileSync } from 'node:fs';
-
-// Lines present in `next` but not in `prev`, compared trimmed.
-// Whitespace-only differences are ignored — we want semantic additions.
-const addedLines = (prev: string, next: string): string[] => {
-  const prevSet = new Set(
-    prev
-      .split('\n')
-      .map((l) => l.trim())
-      .filter((l) => l.length > 0),
-  );
-  return next
-    .split('\n')
-    .filter((l) => l.trim().length > 0)
-    .filter((l) => !prevSet.has(l.trim()));
-};
-
-const readFileOrEmpty = (path: string): string => {
-  try {
-    return readFileSync(path, 'utf8');
-  } catch (error) {
-    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
-      return '';
-    }
-    throw error;
-  }
-};
-
-export { addedLines, readFileOrEmpty };

package/src/lib/event.ts

@@ -1,105 +0,0 @@
-import { Schema } from 'effect';
-
-const HookEvent = Schema.Struct({
-  hook_event_name: Schema.String,
-  tool_name: Schema.optional(Schema.String),
-  tool_input: Schema.optional(Schema.Unknown),
-  tool_response: Schema.optional(Schema.Unknown),
-  cwd: Schema.optional(Schema.String),
-  session_id: Schema.optional(Schema.String),
-  // Codex extension: present on every PreToolUse / PostToolUse event.
-  turn_id: Schema.optional(Schema.String),
-  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;
-}
-
-// PostToolUse `tool_response` shape varies by tool. Bash returns
-// Stdout/stderr/interrupted; Read returns content; others vary. We extract
-// Any string-ish payload we can find for scanning purposes.
-interface BashResponse {
-  readonly stdout?: string;
-  readonly stderr?: string;
-  readonly interrupted?: boolean;
-}
-
-interface ReadResponse {
-  readonly content?: string;
-  readonly file?: { readonly content?: string };
-}
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === 'object' && value !== null && !Array.isArray(value);
-
-const isBashInput = (x: unknown): x is BashInput => isRecord(x) && typeof x['command'] === 'string';
-
-const isEditInput = (x: unknown): x is EditInput =>
-  isRecord(x) &&
-  typeof x['file_path'] === 'string' &&
-  typeof x['old_string'] === 'string' &&
-  typeof x['new_string'] === 'string';
-
-const isWriteInput = (x: unknown): x is WriteInput =>
-  isRecord(x) && typeof x['file_path'] === 'string' && typeof x['content'] === 'string';
-
-const isReadInput = (x: unknown): x is ReadInput =>
-  isRecord(x) && typeof x['file_path'] === 'string';
-
-// Extract any string payload from a tool_response we can scan for secrets.
-// Returns concatenated stdout/stderr for Bash, content for Read, or '' if
-// Nothing is recognizable.
-const extractResponseText = (toolName: string, response: unknown): string => {
-  if (!isRecord(response)) {
-    return '';
-  }
-  if (toolName === 'Bash') {
-    const stdout = typeof response['stdout'] === 'string' ? response['stdout'] : '';
-    const stderr = typeof response['stderr'] === 'string' ? response['stderr'] : '';
-    return [stdout, stderr].filter((text) => text.length > 0).join('\n');
-  }
-  if (toolName === 'Read') {
-    if (typeof response['content'] === 'string') {
-      return response['content'];
-    }
-    const { file } = response;
-    return isRecord(file) && typeof file['content'] === 'string' ? file['content'] : '';
-  }
-  // Best-effort fallback: stringify and let the scanner do its thing.
-  return typeof response['content'] === 'string' ? response['content'] : '';
-};
-
-export type {
-  BashInput,
-  BashResponse,
-  EditInput,
-  HookEventType as HookEvent,
-  ReadInput,
-  ReadResponse,
-  WriteInput,
-};
-export {
-  HookEvent as HookEventSchema,
-  extractResponseText,
-  isBashInput,
-  isEditInput,
-  isReadInput,
-  isWriteInput,
-};