@frost1994/agentic-core 1.0.0

package/dist/index-DHqclwK8.cjs

@@ -0,0 +1,618 @@
+"use strict";
+const ErrorCodes = {
+  NETWORK: "NETWORK",
+  TIMEOUT: "TIMEOUT",
+  AUTH: "AUTH",
+  FORBIDDEN: "FORBIDDEN",
+  RATE_LIMIT: "RATE_LIMIT",
+  MODEL_UNAVAILABLE: "MODEL_UNAVAILABLE",
+  TOOL_FAILED: "TOOL_FAILED",
+  SQL_FORBIDDEN: "SQL_FORBIDDEN",
+  SQL_SENSITIVE: "SQL_SENSITIVE",
+  PARSE: "PARSE",
+  ABORTED: "ABORTED",
+  UNKNOWN: "UNKNOWN"
+};
+const DEFAULT_RETRIABILITY = {
+  NETWORK: true,
+  TIMEOUT: true,
+  AUTH: false,
+  FORBIDDEN: false,
+  RATE_LIMIT: true,
+  MODEL_UNAVAILABLE: true,
+  TOOL_FAILED: false,
+  SQL_FORBIDDEN: false,
+  SQL_SENSITIVE: false,
+  PARSE: false,
+  ABORTED: false,
+  UNKNOWN: false
+};
+function createError(code, message, retriable, details) {
+  const error = new Error(message);
+  error.code = code;
+  error.retriable = retriable ?? DEFAULT_RETRIABILITY[code] ?? false;
+  error.details = details;
+  return error;
+}
+function isRetriable(error) {
+  if (error instanceof Error && "retriable" in error) {
+    return Boolean(error.retriable);
+  }
+  return false;
+}
+function isAborted(error) {
+  if (error instanceof Error && "code" in error) {
+    return error.code === "ABORTED";
+  }
+  return false;
+}
+function generateId(prefix = "") {
+  return `${prefix}${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 7)}`;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isNumber(value) {
+  return typeof value === "number" && !Number.isNaN(value);
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function debounce(fn, waitMs, immediate = false) {
+  let timeoutId = null;
+  let lastArgs = null;
+  let lastResult;
+  const invoke = () => {
+    timeoutId = null;
+    if (lastArgs) {
+      lastResult = fn(...lastArgs);
+      lastArgs = null;
+    }
+    return lastResult;
+  };
+  const debounced = (...args) => {
+    lastArgs = args;
+    if (timeoutId) clearTimeout(timeoutId);
+    if (immediate && !timeoutId) {
+      lastResult = fn(...args);
+      timeoutId = setTimeout(() => {
+        timeoutId = null;
+      }, waitMs);
+      return lastResult;
+    }
+    timeoutId = setTimeout(invoke, waitMs);
+    return void 0;
+  };
+  debounced.cancel = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+    lastArgs = null;
+  };
+  debounced.flush = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      return invoke();
+    }
+    return lastResult;
+  };
+  return debounced;
+}
+function throttle(fn, waitMs, options = {}) {
+  const { leading = true, trailing = true } = options;
+  let timeoutId = null;
+  let lastArgs = null;
+  let lastResult;
+  let lastCallTime = 0;
+  const invoke = () => {
+    timeoutId = null;
+    if (lastArgs && trailing) {
+      lastResult = fn(...lastArgs);
+      lastArgs = null;
+      lastCallTime = Date.now();
+    }
+  };
+  const throttled = (...args) => {
+    const now = Date.now();
+    const remaining = waitMs - (now - lastCallTime);
+    lastArgs = args;
+    if (remaining <= 0 || remaining > waitMs) {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      if (leading) {
+        lastResult = fn(...args);
+        lastCallTime = now;
+      } else {
+        lastCallTime = now;
+        if (trailing) {
+          timeoutId = setTimeout(invoke, waitMs);
+        }
+      }
+      return lastResult;
+    }
+    if (!timeoutId && trailing) {
+      timeoutId = setTimeout(invoke, remaining);
+    }
+    return lastResult;
+  };
+  throttled.cancel = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+    lastArgs = null;
+    lastCallTime = 0;
+  };
+  return throttled;
+}
+function deepClone(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (value instanceof Date) return new Date(value.getTime());
+  if (value instanceof RegExp) return new RegExp(value.source, value.flags);
+  if (Array.isArray(value)) {
+    return value.map((item) => deepClone(item));
+  }
+  const cloned = {};
+  for (const key of Object.keys(value)) {
+    cloned[key] = deepClone(value[key]);
+  }
+  return cloned;
+}
+function formatDate(input, options) {
+  const d = input instanceof Date ? input : new Date(input);
+  if (Number.isNaN(d.getTime())) return String(input);
+  return d.toLocaleString("zh-CN", {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    ...options
+  });
+}
+function formatDuration(ms) {
+  if (ms < 0) ms = 0;
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  if (hours > 0) {
+    return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m ${seconds % 60}s`;
+  }
+  if (seconds > 0) {
+    return `${seconds}s`;
+  }
+  return `${ms}ms`;
+}
+class SqlGuard {
+  constructor(options = {}) {
+    this.sensitiveTables = options.sensitiveTables ?? [];
+    this.allowedOperations = options.allowedOperations ?? ["SELECT"];
+    this.rejectComments = options.rejectComments ?? true;
+    this.rejectUnion = options.rejectUnion ?? true;
+    this.readOnlyAccount = options.readOnlyAccount ?? true;
+  }
+  /**
+   * Validate a SQL string against all guard rules.
+   *
+   * Checks (in order):
+   * 1. Read-only account enforcement
+   * 2. Comment detection (SQL injection vector)
+   * 3. UNION / stacked query detection
+   * 4. Operation type whitelist
+   * 5. Sensitive table access
+   */
+  validate(sql) {
+    const normalized = sql.trim();
+    if (!normalized) {
+      return { allowed: false, reason: "SQL is empty" };
+    }
+    const upper = normalized.toUpperCase();
+    if (this.readOnlyAccount) {
+      const writeOps = ["INSERT", "UPDATE", "DELETE", "DROP", "ALTER", "CREATE", "TRUNCATE", "REPLACE", "MERGE"];
+      for (const op of writeOps) {
+        if (this._hasWord(upper, op)) {
+          return {
+            allowed: false,
+            reason: `Write operation "${op}" is forbidden in read-only mode`
+          };
+        }
+      }
+    }
+    if (this.rejectComments) {
+      if (normalized.includes("--") || normalized.includes("/*") || normalized.includes("*/")) {
+        return {
+          allowed: false,
+          reason: "SQL comments are not allowed (injection risk)"
+        };
+      }
+    }
+    if (this.rejectUnion) {
+      if (this._hasWord(upper, "UNION")) {
+        return {
+          allowed: false,
+          reason: "UNION queries are not allowed"
+        };
+      }
+      const semicolonCount = this._countSemicolonsOutsideStrings(normalized);
+      if (semicolonCount > 1) {
+        return {
+          allowed: false,
+          reason: "Stacked / multiple queries are not allowed"
+        };
+      }
+    }
+    const detectedOp = this._detectOperation(upper);
+    if (detectedOp && !this.allowedOperations.includes(detectedOp)) {
+      return {
+        allowed: false,
+        reason: `SQL operation "${detectedOp}" is not in the allowed list: [${this.allowedOperations.join(", ")}]`
+      };
+    }
+    for (const table of this.sensitiveTables) {
+      const tablePattern = new RegExp(`\\b${this._escapeRegex(table)}\\b`, "i");
+      if (tablePattern.test(normalized)) {
+        return {
+          allowed: false,
+          reason: `Access to sensitive table "${table}" is forbidden`
+        };
+      }
+    }
+    return { allowed: true, sanitizedSql: normalized };
+  }
+  /** Quick check: does the SQL contain any forbidden pattern? */
+  isSafe(sql) {
+    return this.validate(sql).allowed;
+  }
+  // -------------------------------------------------------------------------
+  // Private helpers
+  // -------------------------------------------------------------------------
+  /** Check if a whole word exists in the text. */
+  _hasWord(text, word) {
+    const re = new RegExp(`\\b${word}\\b`);
+    return re.test(text);
+  }
+  /** Detect the primary SQL operation (first keyword). */
+  _detectOperation(sql) {
+    const match = sql.match(/^\\s*(\\w+)/);
+    return match ? match[1].toUpperCase() : null;
+  }
+  /** Count semicolons that are outside quoted string literals. */
+  _countSemicolonsOutsideStrings(sql) {
+    let count = 0;
+    let inString = false;
+    let stringChar = null;
+    let escaped = false;
+    for (let i = 0; i < sql.length; i++) {
+      const ch = sql[i];
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (!inString) {
+        if (ch === "'" || ch === '"') {
+          inString = true;
+          stringChar = ch;
+        } else if (ch === ";") {
+          count++;
+        }
+      } else {
+        if (ch === stringChar) {
+          inString = false;
+          stringChar = null;
+        }
+      }
+    }
+    return count;
+  }
+  _escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+}
+class SseClient {
+  constructor() {
+    this.reader = null;
+    this.abortCtrl = null;
+    this.heartbeatTimer = null;
+    this.timeoutTimer = null;
+    this.reconnect = { attempt: 0, timer: null };
+    this.lastSeq = 0;
+    this.buffer = "";
+    this.status = "idle";
+    this.options = null;
+    this.destroyed = false;
+  }
+  /** Current connection status */
+  get connectionStatus() {
+    return this.status;
+  }
+  /** Current reconnect attempt count */
+  get reconnectAttempt() {
+    return this.reconnect.attempt;
+  }
+  /** Last acknowledged sequence number */
+  get currentSeq() {
+    return this.lastSeq;
+  }
+  // -------------------------------------------------------------------------
+  // Lifecycle
+  // -------------------------------------------------------------------------
+  async start(options) {
+    if (this.destroyed) {
+      throw createError("UNKNOWN", "SseClient has been destroyed", false);
+    }
+    this.options = options;
+    this.lastSeq = options.lastSeq ?? 0;
+    this._setStatus("connecting");
+    await this._connect();
+  }
+  /** Abort the current connection (does not destroy). */
+  abort() {
+    this._clearTimers();
+    this._cancelReader();
+    this._setStatus("closed");
+  }
+  /** Permanently destroy — no further connections allowed. */
+  destroy() {
+    this.destroyed = true;
+    this.abort();
+    this._clearReconnectTimer();
+  }
+  // -------------------------------------------------------------------------
+  // Connection
+  // -------------------------------------------------------------------------
+  async _connect() {
+    var _a;
+    const opts = this.options;
+    if (!opts || this.destroyed) return;
+    this._clearReconnectTimer();
+    this.abortCtrl = new AbortController();
+    if (opts.signal) {
+      const onAbort = () => {
+        var _a2;
+        return (_a2 = this.abortCtrl) == null ? void 0 : _a2.abort();
+      };
+      if (opts.signal.aborted) {
+        onAbort();
+        return;
+      }
+      opts.signal.addEventListener("abort", onAbort, { once: true });
+    }
+    const timeoutMs = opts.timeoutMs ?? 9e4;
+    this.timeoutTimer = setTimeout(() => {
+      this._handleError(createError("TIMEOUT", `Request timed out after ${timeoutMs}ms`, true));
+    }, timeoutMs);
+    const isReconnect = this.reconnect.attempt > 0;
+    const resumeFields = isReconnect ? ((_a = opts.resume) == null ? void 0 : _a.call(opts)) ?? {} : {};
+    const resumeSeq = typeof resumeFields.lastSeq === "number" ? resumeFields.lastSeq : this.lastSeq;
+    try {
+      const res = await fetch(opts.url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "text/event-stream",
+          ...opts.headers
+        },
+        body: JSON.stringify({
+          ...typeof opts.body === "object" && opts.body !== null ? opts.body : {},
+          ...resumeFields,
+          lastSeq: resumeSeq
+        }),
+        signal: this.abortCtrl.signal
+      });
+      if (!res.ok) {
+        const status = res.status;
+        if (status === 401 || status === 403) {
+          throw createError("AUTH", `Authentication failed (${status})`, false);
+        }
+        if (status === 429) {
+          throw createError("RATE_LIMIT", "Rate limit exceeded", true);
+        }
+        throw createError("NETWORK", `HTTP ${status}: ${res.statusText}`, status >= 500);
+      }
+      if (!res.body) {
+        throw createError("NETWORK", "Response body is empty", true);
+      }
+      this._setStatus("streaming");
+      this._resetReconnect();
+      this._startHeartbeat(opts.heartbeatMs ?? 15e3);
+      this.reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      while (true) {
+        const { done, value } = await this.reader.read();
+        if (done) break;
+        this._processChunk(decoder.decode(value, { stream: true }));
+      }
+      this._setStatus("closed");
+    } catch (err) {
+      if (this.destroyed) return;
+      if (err instanceof Error && err.name === "AbortError") {
+        this._setStatus("closed");
+        return;
+      }
+      this._handleError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      this._clearTimers();
+      this._cancelReader();
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Stream parsing
+  // -------------------------------------------------------------------------
+  _processChunk(chunk) {
+    this.buffer += chunk;
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      this._processLine(line);
+    }
+  }
+  _processLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    if (trimmed.startsWith(":")) {
+      this._handleHeartbeat();
+      return;
+    }
+    if (trimmed.startsWith("data:")) {
+      const payload = trimmed.slice(5).trim();
+      if (!payload) return;
+      this._parseEvent(payload);
+      return;
+    }
+  }
+  _parseEvent(payload) {
+    var _a, _b, _c, _d;
+    try {
+      const event = JSON.parse(payload);
+      if (typeof event.seq === "number") {
+        this.lastSeq = event.seq;
+      }
+      if (event.type === "heartbeat") {
+        this._handleHeartbeat();
+        return;
+      }
+      (_b = (_a = this.options) == null ? void 0 : _a.onEvent) == null ? void 0 : _b.call(_a, event);
+    } catch (err) {
+      (_d = (_c = this.options) == null ? void 0 : _c.onError) == null ? void 0 : _d.call(
+        _c,
+        createError("PARSE", `Failed to parse SSE payload: ${payload.slice(0, 200)}`, false, err)
+      );
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Heartbeat
+  // -------------------------------------------------------------------------
+  _startHeartbeat(ms) {
+    this._clearHeartbeat();
+    this.heartbeatTimer = setTimeout(() => {
+      this._handleError(createError("TIMEOUT", "Heartbeat timeout — no data received", true));
+    }, ms * 2);
+  }
+  _handleHeartbeat() {
+    var _a, _b, _c;
+    this._startHeartbeat(((_a = this.options) == null ? void 0 : _a.heartbeatMs) ?? 15e3);
+    (_c = (_b = this.options) == null ? void 0 : _b.onEvent) == null ? void 0 : _c.call(_b, { type: "heartbeat", ts: Date.now() });
+  }
+  // -------------------------------------------------------------------------
+  // Error & Reconnect
+  // -------------------------------------------------------------------------
+  _handleError(error) {
+    var _a, _b, _c, _d, _e;
+    this._setStatus("error");
+    (_b = (_a = this.options) == null ? void 0 : _a.onError) == null ? void 0 : _b.call(_a, error);
+    const cfg = (_c = this.options) == null ? void 0 : _c.reconnect;
+    if (!cfg) return;
+    if (this.reconnect.attempt >= cfg.max) {
+      this._setStatus("error");
+      (_e = (_d = this.options) == null ? void 0 : _d.onError) == null ? void 0 : _e.call(
+        _d,
+        createError("NETWORK", `Max reconnect attempts (${cfg.max}) exceeded`, false)
+      );
+      return;
+    }
+    this._scheduleReconnect(cfg);
+  }
+  _scheduleReconnect(cfg) {
+    this._setStatus("reconnecting");
+    const base = cfg.baseMs ?? 1e3;
+    const maxMs = cfg.maxMs ?? 3e4;
+    const delayMs = clamp(base * 2 ** this.reconnect.attempt, base, maxMs);
+    const jitter = delayMs * 0.25 * (Math.random() * 2 - 1);
+    const finalDelay = Math.max(0, Math.floor(delayMs + jitter));
+    this.reconnect.attempt++;
+    this.reconnect.timer = setTimeout(() => {
+      if (!this.destroyed) {
+        this._connect();
+      }
+    }, finalDelay);
+  }
+  _resetReconnect() {
+    this.reconnect.attempt = 0;
+    this._clearReconnectTimer();
+  }
+  // -------------------------------------------------------------------------
+  // Helpers
+  // -------------------------------------------------------------------------
+  _setStatus(next) {
+    var _a, _b;
+    if (this.status === next) return;
+    this.status = next;
+    (_b = (_a = this.options) == null ? void 0 : _a.onStatusChange) == null ? void 0 : _b.call(_a, next);
+  }
+  _cancelReader() {
+    if (this.reader) {
+      this.reader.cancel().catch(() => {
+      });
+      this.reader = null;
+    }
+    if (this.abortCtrl) {
+      try {
+        this.abortCtrl.abort();
+      } catch {
+      }
+      this.abortCtrl = null;
+    }
+  }
+  _clearTimers() {
+    if (this.timeoutTimer) {
+      clearTimeout(this.timeoutTimer);
+      this.timeoutTimer = null;
+    }
+    this._clearHeartbeat();
+  }
+  _clearHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearTimeout(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  _clearReconnectTimer() {
+    if (this.reconnect.timer) {
+      clearTimeout(this.reconnect.timer);
+      this.reconnect.timer = null;
+    }
+  }
+}
+exports.ErrorCodes = ErrorCodes;
+exports.SqlGuard = SqlGuard;
+exports.SseClient = SseClient;
+exports.clamp = clamp;
+exports.createError = createError;
+exports.debounce = debounce;
+exports.deepClone = deepClone;
+exports.delay = delay;
+exports.formatDate = formatDate;
+exports.formatDuration = formatDuration;
+exports.generateId = generateId;
+exports.isAborted = isAborted;
+exports.isArray = isArray;
+exports.isFunction = isFunction;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isRetriable = isRetriable;
+exports.isString = isString;
+exports.throttle = throttle;
+//# sourceMappingURL=index-DHqclwK8.cjs.map