aisnitch 0.2.18 → 0.2.20

package/dist/cli/index.cjs

@@ -41,7 +41,7 @@ var import_commander = require("commander");
 
 // src/package-info.ts
 var AISNITCH_PACKAGE_NAME = "aisnitch";
-var AISNITCH_VERSION = "0.2.18";
+var AISNITCH_VERSION = "0.2.20";
 var AISNITCH_DESCRIPTION = "Universal bridge for AI coding tool activity \u2014 capture, normalize, stream.";
 
 // src/core/events/schema.ts
@@ -123,8 +123,8 @@ function createUuidV7() {
   return (0, import_uuid.v7)();
 }
 var ToolInputSchema = import_zod.z.strictObject({
-  filePath: import_zod.z.string().min(1).optional(),
-  command: import_zod.z.string().min(1).optional()
+  filePath: import_zod.z.string().min(1).max(4096).optional(),
+  command: import_zod.z.string().min(1).max(1e4).optional()
 }).refine(
   (value) => value.filePath !== void 0 || value.command !== void 0,
   "toolInput must include filePath or command"
@@ -135,35 +135,35 @@ var ErrorTypeSchema = import_zod.z.enum(ERROR_TYPES);
 var CESPCategorySchema = import_zod.z.enum(CESP_CATEGORIES);
 var EventDataSchema = import_zod.z.strictObject({
   state: AISnitchEventTypeSchema,
-  project: import_zod.z.string().min(1).optional(),
-  projectPath: import_zod.z.string().min(1).optional(),
+  project: import_zod.z.string().min(1).max(255).optional(),
+  projectPath: import_zod.z.string().min(1).max(4096).optional(),
   duration: import_zod.z.number().int().min(0).optional(),
-  toolName: import_zod.z.string().min(1).optional(),
+  toolName: import_zod.z.string().min(1).max(100).optional(),
   toolInput: ToolInputSchema.optional(),
-  activeFile: import_zod.z.string().min(1).optional(),
-  model: import_zod.z.string().min(1).optional(),
+  activeFile: import_zod.z.string().min(1).max(4096).optional(),
+  model: import_zod.z.string().min(1).max(200).optional(),
   tokensUsed: import_zod.z.number().int().min(0).optional(),
-  errorMessage: import_zod.z.string().min(1).optional(),
+  errorMessage: import_zod.z.string().min(1).max(1e4).optional(),
   errorType: ErrorTypeSchema.optional(),
   raw: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
-  terminal: import_zod.z.string().min(1).optional(),
-  cwd: import_zod.z.string().min(1).optional(),
+  terminal: import_zod.z.string().min(1).max(100).optional(),
+  cwd: import_zod.z.string().min(1).max(4096).optional(),
   pid: import_zod.z.number().int().positive().optional(),
-  instanceId: import_zod.z.string().min(1).optional(),
+  instanceId: import_zod.z.string().min(1).max(255).optional(),
   instanceIndex: import_zod.z.number().int().min(1).optional(),
   instanceTotal: import_zod.z.number().int().min(1).optional()
 });
 var AISnitchEventSchema = import_zod.z.strictObject({
   specversion: import_zod.z.literal("1.0"),
   id: import_zod.z.string().refine(isUuidV7, "id must be a valid UUIDv7 string"),
-  source: import_zod.z.string().refine(
+  source: import_zod.z.string().max(2e3).refine(
     isValidUriReference,
     "source must be a valid non-empty CloudEvents URI-reference"
   ),
   type: AISnitchEventTypeSchema,
   time: ISO_TIMESTAMP_SCHEMA,
   "aisnitch.tool": ToolNameSchema,
-  "aisnitch.sessionid": import_zod.z.string().min(1),
+  "aisnitch.sessionid": import_zod.z.string().min(1).max(500),
   "aisnitch.seqnum": import_zod.z.number().int().min(1),
   data: EventDataSchema
 });
@@ -3351,6 +3351,346 @@ function isPidRunning(pid) {
   }
 }
 
+// src/core/errors.ts
+var AISnitchError = class _AISnitchError extends Error {
+  /**
+   * Machine-readable error code for programmatic handling.
+   * Format: `SUBCATEGORY_SPECIFIC_DETAIL` (uppercase with underscores).
+   */
+  code;
+  /**
+   * Arbitrary context bag forwarded to the logger for structured debugging.
+   */
+  context;
+  constructor(message, code, context) {
+    super(message);
+    this.name = "AISnitchError";
+    this.code = code;
+    this.context = context;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _AISnitchError);
+    }
+  }
+  /**
+   * Full error chain for logging: `[name] code — message`.
+   */
+  toString() {
+    return `${this.name} [${this.code}] \u2014 ${this.message}`;
+  }
+  /**
+   * JSON serialization friendly to pino serializers.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      context: this.context,
+      stack: this.stack
+    };
+  }
+};
+function isAISnitchError(error) {
+  return error instanceof AISnitchError;
+}
+function isRetryableError(error) {
+  if (!isAISnitchError(error)) {
+    if (error instanceof Error) {
+      const code = error.code;
+      const retryableCodes = /* @__PURE__ */ new Set([
+        "ECONNREFUSED",
+        "ECONNRESET",
+        "ETIMEDOUT",
+        "ENOTFOUND",
+        "EHOSTUNREACH",
+        "EPIPE",
+        "EPERM"
+        // sometimes transient on macOS file locks
+      ]);
+      if (typeof code === "string" && retryableCodes.has(code)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  const retryableCategories = /* @__PURE__ */ new Set(["TIMEOUT", "NETWORK"]);
+  for (const category of retryableCategories) {
+    if (error.code.startsWith(category)) {
+      return true;
+    }
+  }
+  const retryablePatterns = [
+    /^ADAPTER_.*_(FILE_IO|NETWORK|PROCESS_DETECT)_ERROR$/,
+    /^PIPELINE_.*_(RETRY|RECONNECT)_ERROR$/
+  ];
+  for (const pattern of retryablePatterns) {
+    if (pattern.test(error.code)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/core/circuit-breaker.ts
+var CircuitOpenError = class _CircuitOpenError extends AISnitchError {
+  constructor(circuitId, state) {
+    super(
+      `Circuit "${circuitId}" is OPEN \u2014 operation rejected`,
+      "CIRCUIT_OPEN",
+      { circuitId, failures: state.failures, lastFailureAt: state.lastFailureAt }
+    );
+    this.circuitId = circuitId;
+    this.state = state;
+    this.name = "CircuitOpenError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _CircuitOpenError);
+    }
+  }
+  toString() {
+    return `${this.name} [${this.code}] "${this.circuitId}" \u2014 failures=${this.state.failures}`;
+  }
+};
+var DEFAULT_OPTIONS = {
+  failureThreshold: 5,
+  halfOpenAfterMs: 3e4,
+  id: "unnamed",
+  resetOnSuccess: true,
+  shouldCountAsFailure: isRetryableError,
+  windowMs: 6e4
+};
+var CircuitBreaker = class {
+  failures = 0;
+  lastFailureAt = null;
+  state = "closed";
+  halfOpenTestStartedAt = null;
+  options;
+  constructor(options = {}) {
+    this.options = {
+      ...DEFAULT_OPTIONS,
+      ...options,
+      // Re-spread to ensure all fields have defaults
+      failureThreshold: options.failureThreshold ?? DEFAULT_OPTIONS.failureThreshold,
+      halfOpenAfterMs: options.halfOpenAfterMs ?? DEFAULT_OPTIONS.halfOpenAfterMs,
+      id: options.id ?? DEFAULT_OPTIONS.id,
+      resetOnSuccess: options.resetOnSuccess ?? DEFAULT_OPTIONS.resetOnSuccess,
+      shouldCountAsFailure: options.shouldCountAsFailure ?? DEFAULT_OPTIONS.shouldCountAsFailure,
+      windowMs: options.windowMs ?? DEFAULT_OPTIONS.windowMs
+    };
+  }
+  /**
+   * Executes an async operation through the circuit breaker.
+   *
+   * - If the circuit is CLOSED → runs `fn` and updates state based on result
+   * - If the circuit is HALF-OPEN → runs `fn` once to test recovery
+   * - If the circuit is OPEN → throws `CircuitOpenError` immediately (no call)
+   *
+   * @param fn - The async operation to protect
+   * @returns The result of `fn` if successful
+   * @throws CircuitOpenError if the circuit is OPEN
+   * @throws The error from `fn` if it throws (and `shouldCountAsFailure` returns true)
+   */
+  async execute(fn) {
+    switch (this.state) {
+      case "closed":
+        return this.executeClosed(fn);
+      case "half-open":
+        return this.executeHalfOpen(fn);
+      case "open":
+        if (this.shouldTransitionToHalfOpen()) {
+          this.transitionToHalfOpen();
+          return this.executeHalfOpen(fn);
+        }
+        throw new CircuitOpenError(this.options.id, this.getState());
+    }
+  }
+  /**
+   * Returns the current observable circuit state.
+   */
+  getState() {
+    return {
+      failures: this.failures,
+      lastFailureAt: this.lastFailureAt,
+      state: this.state
+    };
+  }
+  /**
+   * Forces the circuit to CLOSED (resets failure count and state).
+   * Useful for manual recovery after a known-fix or after a maintenance window.
+   */
+  reset() {
+    this.failures = 0;
+    this.lastFailureAt = null;
+    this.state = "closed";
+    this.halfOpenTestStartedAt = null;
+    logger.debug({ circuitId: this.options.id }, "Circuit breaker manually reset");
+  }
+  /**
+   * Pre-warms the circuit by performing one test call in HALF-OPEN state.
+   * If the circuit is already HALF-OPEN, this does nothing.
+   * If the circuit is CLOSED, this does nothing.
+   */
+  async preWarm(fn) {
+    if (this.state !== "open") {
+      return;
+    }
+    this.transitionToHalfOpen();
+    try {
+      await fn();
+      this.transitionToClosed();
+    } catch {
+      this.transitionToOpen();
+    }
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Private methods
+  // ─────────────────────────────────────────────────────────────────────────
+  async executeClosed(fn) {
+    try {
+      const result = await fn();
+      this.onSuccess();
+      return result;
+    } catch (error) {
+      this.onFailure(error);
+      throw error;
+    }
+  }
+  async executeHalfOpen(fn) {
+    this.halfOpenTestStartedAt = Date.now();
+    try {
+      const result = await fn();
+      this.transitionToClosed();
+      return result;
+    } catch (error) {
+      this.transitionToOpen();
+      throw error;
+    }
+  }
+  onSuccess() {
+    if (this.options.resetOnSuccess) {
+      this.failures = 0;
+      this.lastFailureAt = null;
+    } else {
+      this.failures = Math.max(0, this.failures - 1);
+      if (this.failures === 0) {
+        this.lastFailureAt = null;
+      }
+    }
+    logger.debug(
+      {
+        circuitId: this.options.id,
+        failures: this.failures
+      },
+      "Circuit breaker operation succeeded"
+    );
+  }
+  onFailure(error) {
+    if (!this.options.shouldCountAsFailure(error)) {
+      logger.debug(
+        { circuitId: this.options.id, error },
+        "Circuit breaker operation failed but error is not counted as failure"
+      );
+      return;
+    }
+    this.failures += 1;
+    this.lastFailureAt = Date.now();
+    if (this.failures >= this.options.failureThreshold) {
+      this.transitionToOpen();
+    } else {
+      logger.debug(
+        {
+          circuitId: this.options.id,
+          failures: this.failures,
+          threshold: this.options.failureThreshold
+        },
+        "Circuit breaker recorded failure"
+      );
+    }
+  }
+  transitionToOpen() {
+    if (this.state === "open") {
+      return;
+    }
+    this.state = "open";
+    this.halfOpenTestStartedAt = null;
+    logger.warn(
+      {
+        circuitId: this.options.id,
+        failures: this.failures,
+        windowMs: this.options.windowMs
+      },
+      "\u{1F534} Circuit breaker OPEN \u2014 blocking operations"
+    );
+  }
+  transitionToHalfOpen() {
+    this.state = "half-open";
+    this.halfOpenTestStartedAt = Date.now();
+    logger.info(
+      { circuitId: this.options.id },
+      "\u{1F7E1} Circuit breaker HALF-OPEN \u2014 testing recovery"
+    );
+  }
+  transitionToClosed() {
+    this.state = "closed";
+    this.failures = 0;
+    this.lastFailureAt = null;
+    this.halfOpenTestStartedAt = null;
+    logger.info(
+      { circuitId: this.options.id },
+      "\u{1F7E2} Circuit breaker CLOSED \u2014 recovery successful"
+    );
+  }
+  shouldTransitionToHalfOpen() {
+    if (this.lastFailureAt === null) {
+      return true;
+    }
+    const elapsed = Date.now() - this.lastFailureAt;
+    return elapsed >= this.options.halfOpenAfterMs;
+  }
+};
+var SHARED_BREAKERS = Object.freeze({
+  /**
+   * Breaker for adapter event emission.
+   * Threshold: 5 failures in 60s → open for 30s → half-open test.
+   */
+  adapterEmit: new CircuitBreaker({
+    id: "adapter.emit",
+    failureThreshold: 5,
+    halfOpenAfterMs: 3e4,
+    shouldCountAsFailure: isRetryableError,
+    windowMs: 6e4
+  }),
+  /**
+   * Breaker for file system operations (transcript reading, config loading).
+   * More tolerant: 10 failures in 60s → open for 30s.
+   */
+  fileSystem: new CircuitBreaker({
+    id: "filesystem",
+    failureThreshold: 10,
+    halfOpenAfterMs: 3e4,
+    windowMs: 6e4
+  }),
+  /**
+   * Breaker for HTTP/HTTPS requests.
+   * Stricter: 3 failures in 30s → open for 15s.
+   */
+  httpRequest: new CircuitBreaker({
+    id: "http-request",
+    failureThreshold: 3,
+    halfOpenAfterMs: 15e3,
+    windowMs: 3e4
+  }),
+  /**
+   * Breaker for process detection operations.
+   * Most tolerant: 20 failures in 60s → open for 10s.
+   */
+  processDetection: new CircuitBreaker({
+    id: "process-detection",
+    failureThreshold: 20,
+    halfOpenAfterMs: 1e4,
+    windowMs: 6e4
+  })
+});
+
 // src/core/engine/event-bus.ts
 var import_eventemitter3 = require("eventemitter3");
 var EventBus = class {
@@ -11116,6 +11456,50 @@ var Pipeline = class {
   }
 };
 
+// src/core/timeout.ts
+var DEFAULT_TIMEOUTS = Object.freeze({
+  /**
+   * File read/write operations (JSONL transcripts, config files).
+   * Default: 5 seconds
+   */
+  fileOperation: 5e3,
+  /**
+   * HTTP requests to health endpoint or external APIs.
+   * Default: 30 seconds
+   */
+  httpRequest: 3e4,
+  /**
+   * Process detection commands (`pgrep`, `ps aux`).
+   * Default: 3 seconds
+   */
+  processDetection: 3e3,
+  /**
+   * Adapter startup (file watchers, hook bridges, pollers).
+   * Default: 10 seconds
+   */
+  adapterStartup: 1e4,
+  /**
+   * Adapter shutdown (graceful cleanup, watcher close).
+   * Default: 5 seconds — after this, resources are force-closed
+   */
+  adapterShutdown: 5e3,
+  /**
+   * Daemon graceful shutdown (stop all components in order).
+   * Default: 30 seconds
+   */
+  daemonShutdown: 3e4,
+  /**
+   * WebSocket connection establishment.
+   * Default: 10 seconds
+   */
+  wsConnection: 1e4,
+  /**
+   * Overall pipeline start (all components).
+   * Default: 15 seconds
+   */
+  pipelineStartup: 15e3
+});
+
 // src/tui/index.tsx
 var import_ink13 = require("ink");
 var import_fullscreen_ink = require("fullscreen-ink");