@profullstack/threatcrush 0.1.16 → 0.2.1

package/dist/daemon.js

@@ -0,0 +1,4334 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/parser.js
+var require_parser = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/parser.js"(exports2, module2) {
+    "use strict";
+    var ParserEND = 1114112;
+    var ParserError = class _ParserError extends Error {
+      /* istanbul ignore next */
+      constructor(msg, filename, linenumber) {
+        super("[ParserError] " + msg, filename, linenumber);
+        this.name = "ParserError";
+        this.code = "ParserError";
+        if (Error.captureStackTrace) Error.captureStackTrace(this, _ParserError);
+      }
+    };
+    var State = class {
+      constructor(parser) {
+        this.parser = parser;
+        this.buf = "";
+        this.returned = null;
+        this.result = null;
+        this.resultTable = null;
+        this.resultArr = null;
+      }
+    };
+    var Parser = class {
+      constructor() {
+        this.pos = 0;
+        this.col = 0;
+        this.line = 0;
+        this.obj = {};
+        this.ctx = this.obj;
+        this.stack = [];
+        this._buf = "";
+        this.char = null;
+        this.ii = 0;
+        this.state = new State(this.parseStart);
+      }
+      parse(str) {
+        if (str.length === 0 || str.length == null) return;
+        this._buf = String(str);
+        this.ii = -1;
+        this.char = -1;
+        let getNext;
+        while (getNext === false || this.nextChar()) {
+          getNext = this.runOne();
+        }
+        this._buf = null;
+      }
+      nextChar() {
+        if (this.char === 10) {
+          ++this.line;
+          this.col = -1;
+        }
+        ++this.ii;
+        this.char = this._buf.codePointAt(this.ii);
+        ++this.pos;
+        ++this.col;
+        return this.haveBuffer();
+      }
+      haveBuffer() {
+        return this.ii < this._buf.length;
+      }
+      runOne() {
+        return this.state.parser.call(this, this.state.returned);
+      }
+      finish() {
+        this.char = ParserEND;
+        let last;
+        do {
+          last = this.state.parser;
+          this.runOne();
+        } while (this.state.parser !== last);
+        this.ctx = null;
+        this.state = null;
+        this._buf = null;
+        return this.obj;
+      }
+      next(fn) {
+        if (typeof fn !== "function") throw new ParserError("Tried to set state to non-existent state: " + JSON.stringify(fn));
+        this.state.parser = fn;
+      }
+      goto(fn) {
+        this.next(fn);
+        return this.runOne();
+      }
+      call(fn, returnWith) {
+        if (returnWith) this.next(returnWith);
+        this.stack.push(this.state);
+        this.state = new State(fn);
+      }
+      callNow(fn, returnWith) {
+        this.call(fn, returnWith);
+        return this.runOne();
+      }
+      return(value) {
+        if (this.stack.length === 0) throw this.error(new ParserError("Stack underflow"));
+        if (value === void 0) value = this.state.buf;
+        this.state = this.stack.pop();
+        this.state.returned = value;
+      }
+      returnNow(value) {
+        this.return(value);
+        return this.runOne();
+      }
+      consume() {
+        if (this.char === ParserEND) throw this.error(new ParserError("Unexpected end-of-buffer"));
+        this.state.buf += this._buf[this.ii];
+      }
+      error(err) {
+        err.line = this.line;
+        err.col = this.col;
+        err.pos = this.pos;
+        return err;
+      }
+      /* istanbul ignore next */
+      parseStart() {
+        throw new ParserError("Must declare a parseStart method");
+      }
+    };
+    Parser.END = ParserEND;
+    Parser.Error = ParserError;
+    module2.exports = Parser;
+  }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-datetime.js
+var require_create_datetime = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-datetime.js"(exports2, module2) {
+    "use strict";
+    module2.exports = (value) => {
+      const date = new Date(value);
+      if (isNaN(date)) {
+        throw new TypeError("Invalid Datetime");
+      } else {
+        return date;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/format-num.js
+var require_format_num = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/format-num.js"(exports2, module2) {
+    "use strict";
+    module2.exports = (d, num) => {
+      num = String(num);
+      while (num.length < d) num = "0" + num;
+      return num;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-datetime-float.js
+var require_create_datetime_float = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-datetime-float.js"(exports2, module2) {
+    "use strict";
+    var f = require_format_num();
+    var FloatingDateTime = class extends Date {
+      constructor(value) {
+        super(value + "Z");
+        this.isFloating = true;
+      }
+      toISOString() {
+        const date = `${this.getUTCFullYear()}-${f(2, this.getUTCMonth() + 1)}-${f(2, this.getUTCDate())}`;
+        const time = `${f(2, this.getUTCHours())}:${f(2, this.getUTCMinutes())}:${f(2, this.getUTCSeconds())}.${f(3, this.getUTCMilliseconds())}`;
+        return `${date}T${time}`;
+      }
+    };
+    module2.exports = (value) => {
+      const date = new FloatingDateTime(value);
+      if (isNaN(date)) {
+        throw new TypeError("Invalid Datetime");
+      } else {
+        return date;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-date.js
+var require_create_date = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-date.js"(exports2, module2) {
+    "use strict";
+    var f = require_format_num();
+    var DateTime = global.Date;
+    var Date2 = class extends DateTime {
+      constructor(value) {
+        super(value);
+        this.isDate = true;
+      }
+      toISOString() {
+        return `${this.getUTCFullYear()}-${f(2, this.getUTCMonth() + 1)}-${f(2, this.getUTCDate())}`;
+      }
+    };
+    module2.exports = (value) => {
+      const date = new Date2(value);
+      if (isNaN(date)) {
+        throw new TypeError("Invalid Datetime");
+      } else {
+        return date;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-time.js
+var require_create_time = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-time.js"(exports2, module2) {
+    "use strict";
+    var f = require_format_num();
+    var Time = class extends Date {
+      constructor(value) {
+        super(`0000-01-01T${value}Z`);
+        this.isTime = true;
+      }
+      toISOString() {
+        return `${f(2, this.getUTCHours())}:${f(2, this.getUTCMinutes())}:${f(2, this.getUTCSeconds())}.${f(3, this.getUTCMilliseconds())}`;
+      }
+    };
+    module2.exports = (value) => {
+      const date = new Time(value);
+      if (isNaN(date)) {
+        throw new TypeError("Invalid Datetime");
+      } else {
+        return date;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/toml-parser.js
+var require_toml_parser = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/toml-parser.js"(exports, module) {
+    "use strict";
+    module.exports = makeParserClass(require_parser());
+    module.exports.makeParserClass = makeParserClass;
+    var TomlError = class _TomlError extends Error {
+      constructor(msg) {
+        super(msg);
+        this.name = "TomlError";
+        if (Error.captureStackTrace) Error.captureStackTrace(this, _TomlError);
+        this.fromTOML = true;
+        this.wrapped = null;
+      }
+    };
+    TomlError.wrap = (err) => {
+      const terr = new TomlError(err.message);
+      terr.code = err.code;
+      terr.wrapped = err;
+      return terr;
+    };
+    module.exports.TomlError = TomlError;
+    var createDateTime = require_create_datetime();
+    var createDateTimeFloat = require_create_datetime_float();
+    var createDate = require_create_date();
+    var createTime = require_create_time();
+    var CTRL_I = 9;
+    var CTRL_J = 10;
+    var CTRL_M = 13;
+    var CTRL_CHAR_BOUNDARY = 31;
+    var CHAR_SP = 32;
+    var CHAR_QUOT = 34;
+    var CHAR_NUM = 35;
+    var CHAR_APOS = 39;
+    var CHAR_PLUS = 43;
+    var CHAR_COMMA = 44;
+    var CHAR_HYPHEN = 45;
+    var CHAR_PERIOD = 46;
+    var CHAR_0 = 48;
+    var CHAR_1 = 49;
+    var CHAR_7 = 55;
+    var CHAR_9 = 57;
+    var CHAR_COLON = 58;
+    var CHAR_EQUALS = 61;
+    var CHAR_A = 65;
+    var CHAR_E = 69;
+    var CHAR_F = 70;
+    var CHAR_T = 84;
+    var CHAR_U = 85;
+    var CHAR_Z = 90;
+    var CHAR_LOWBAR = 95;
+    var CHAR_a = 97;
+    var CHAR_b = 98;
+    var CHAR_e = 101;
+    var CHAR_f = 102;
+    var CHAR_i = 105;
+    var CHAR_l = 108;
+    var CHAR_n = 110;
+    var CHAR_o = 111;
+    var CHAR_r = 114;
+    var CHAR_s = 115;
+    var CHAR_t = 116;
+    var CHAR_u = 117;
+    var CHAR_x = 120;
+    var CHAR_z = 122;
+    var CHAR_LCUB = 123;
+    var CHAR_RCUB = 125;
+    var CHAR_LSQB = 91;
+    var CHAR_BSOL = 92;
+    var CHAR_RSQB = 93;
+    var CHAR_DEL = 127;
+    var SURROGATE_FIRST = 55296;
+    var SURROGATE_LAST = 57343;
+    var escapes = {
+      [CHAR_b]: "\b",
+      [CHAR_t]: "	",
+      [CHAR_n]: "\n",
+      [CHAR_f]: "\f",
+      [CHAR_r]: "\r",
+      [CHAR_QUOT]: '"',
+      [CHAR_BSOL]: "\\"
+    };
+    function isDigit(cp) {
+      return cp >= CHAR_0 && cp <= CHAR_9;
+    }
+    function isHexit(cp) {
+      return cp >= CHAR_A && cp <= CHAR_F || cp >= CHAR_a && cp <= CHAR_f || cp >= CHAR_0 && cp <= CHAR_9;
+    }
+    function isBit(cp) {
+      return cp === CHAR_1 || cp === CHAR_0;
+    }
+    function isOctit(cp) {
+      return cp >= CHAR_0 && cp <= CHAR_7;
+    }
+    function isAlphaNumQuoteHyphen(cp) {
+      return cp >= CHAR_A && cp <= CHAR_Z || cp >= CHAR_a && cp <= CHAR_z || cp >= CHAR_0 && cp <= CHAR_9 || cp === CHAR_APOS || cp === CHAR_QUOT || cp === CHAR_LOWBAR || cp === CHAR_HYPHEN;
+    }
+    function isAlphaNumHyphen(cp) {
+      return cp >= CHAR_A && cp <= CHAR_Z || cp >= CHAR_a && cp <= CHAR_z || cp >= CHAR_0 && cp <= CHAR_9 || cp === CHAR_LOWBAR || cp === CHAR_HYPHEN;
+    }
+    var _type = /* @__PURE__ */ Symbol("type");
+    var _declared = /* @__PURE__ */ Symbol("declared");
+    var hasOwnProperty = Object.prototype.hasOwnProperty;
+    var defineProperty = Object.defineProperty;
+    var descriptor = { configurable: true, enumerable: true, writable: true, value: void 0 };
+    function hasKey(obj, key) {
+      if (hasOwnProperty.call(obj, key)) return true;
+      if (key === "__proto__") defineProperty(obj, "__proto__", descriptor);
+      return false;
+    }
+    var INLINE_TABLE = /* @__PURE__ */ Symbol("inline-table");
+    function InlineTable() {
+      return Object.defineProperties({}, {
+        [_type]: { value: INLINE_TABLE }
+      });
+    }
+    function isInlineTable(obj) {
+      if (obj === null || typeof obj !== "object") return false;
+      return obj[_type] === INLINE_TABLE;
+    }
+    var TABLE = /* @__PURE__ */ Symbol("table");
+    function Table() {
+      return Object.defineProperties({}, {
+        [_type]: { value: TABLE },
+        [_declared]: { value: false, writable: true }
+      });
+    }
+    function isTable(obj) {
+      if (obj === null || typeof obj !== "object") return false;
+      return obj[_type] === TABLE;
+    }
+    var _contentType = /* @__PURE__ */ Symbol("content-type");
+    var INLINE_LIST = /* @__PURE__ */ Symbol("inline-list");
+    function InlineList(type) {
+      return Object.defineProperties([], {
+        [_type]: { value: INLINE_LIST },
+        [_contentType]: { value: type }
+      });
+    }
+    function isInlineList(obj) {
+      if (obj === null || typeof obj !== "object") return false;
+      return obj[_type] === INLINE_LIST;
+    }
+    var LIST = /* @__PURE__ */ Symbol("list");
+    function List() {
+      return Object.defineProperties([], {
+        [_type]: { value: LIST }
+      });
+    }
+    function isList(obj) {
+      if (obj === null || typeof obj !== "object") return false;
+      return obj[_type] === LIST;
+    }
+    var _custom;
+    try {
+      const utilInspect = eval("require('util').inspect");
+      _custom = utilInspect.custom;
+    } catch (_) {
+    }
+    var _inspect = _custom || "inspect";
+    var BoxedBigInt = class {
+      constructor(value) {
+        try {
+          this.value = global.BigInt.asIntN(64, value);
+        } catch (_) {
+          this.value = null;
+        }
+        Object.defineProperty(this, _type, { value: INTEGER });
+      }
+      isNaN() {
+        return this.value === null;
+      }
+      /* istanbul ignore next */
+      toString() {
+        return String(this.value);
+      }
+      /* istanbul ignore next */
+      [_inspect]() {
+        return `[BigInt: ${this.toString()}]}`;
+      }
+      valueOf() {
+        return this.value;
+      }
+    };
+    var INTEGER = /* @__PURE__ */ Symbol("integer");
+    function Integer(value) {
+      let num = Number(value);
+      if (Object.is(num, -0)) num = 0;
+      if (global.BigInt && !Number.isSafeInteger(num)) {
+        return new BoxedBigInt(value);
+      } else {
+        return Object.defineProperties(new Number(num), {
+          isNaN: { value: function() {
+            return isNaN(this);
+          } },
+          [_type]: { value: INTEGER },
+          [_inspect]: { value: () => `[Integer: ${value}]` }
+        });
+      }
+    }
+    function isInteger(obj) {
+      if (obj === null || typeof obj !== "object") return false;
+      return obj[_type] === INTEGER;
+    }
+    var FLOAT = /* @__PURE__ */ Symbol("float");
+    function Float(value) {
+      return Object.defineProperties(new Number(value), {
+        [_type]: { value: FLOAT },
+        [_inspect]: { value: () => `[Float: ${value}]` }
+      });
+    }
+    function isFloat(obj) {
+      if (obj === null || typeof obj !== "object") return false;
+      return obj[_type] === FLOAT;
+    }
+    function tomlType(value) {
+      const type = typeof value;
+      if (type === "object") {
+        if (value === null) return "null";
+        if (value instanceof Date) return "datetime";
+        if (_type in value) {
+          switch (value[_type]) {
+            case INLINE_TABLE:
+              return "inline-table";
+            case INLINE_LIST:
+              return "inline-list";
+            /* istanbul ignore next */
+            case TABLE:
+              return "table";
+            /* istanbul ignore next */
+            case LIST:
+              return "list";
+            case FLOAT:
+              return "float";
+            case INTEGER:
+              return "integer";
+          }
+        }
+      }
+      return type;
+    }
+    function makeParserClass(Parser) {
+      class TOMLParser extends Parser {
+        constructor() {
+          super();
+          this.ctx = this.obj = Table();
+        }
+        /* MATCH HELPER */
+        atEndOfWord() {
+          return this.char === CHAR_NUM || this.char === CTRL_I || this.char === CHAR_SP || this.atEndOfLine();
+        }
+        atEndOfLine() {
+          return this.char === Parser.END || this.char === CTRL_J || this.char === CTRL_M;
+        }
+        parseStart() {
+          if (this.char === Parser.END) {
+            return null;
+          } else if (this.char === CHAR_LSQB) {
+            return this.call(this.parseTableOrList);
+          } else if (this.char === CHAR_NUM) {
+            return this.call(this.parseComment);
+          } else if (this.char === CTRL_J || this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
+            return null;
+          } else if (isAlphaNumQuoteHyphen(this.char)) {
+            return this.callNow(this.parseAssignStatement);
+          } else {
+            throw this.error(new TomlError(`Unknown character "${this.char}"`));
+          }
+        }
+        // HELPER, this strips any whitespace and comments to the end of the line
+        // then RETURNS. Last state in a production.
+        parseWhitespaceToEOL() {
+          if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
+            return null;
+          } else if (this.char === CHAR_NUM) {
+            return this.goto(this.parseComment);
+          } else if (this.char === Parser.END || this.char === CTRL_J) {
+            return this.return();
+          } else {
+            throw this.error(new TomlError("Unexpected character, expected only whitespace or comments till end of line"));
+          }
+        }
+        /* ASSIGNMENT: key = value */
+        parseAssignStatement() {
+          return this.callNow(this.parseAssign, this.recordAssignStatement);
+        }
+        recordAssignStatement(kv) {
+          let target = this.ctx;
+          let finalKey = kv.key.pop();
+          for (let kw of kv.key) {
+            if (hasKey(target, kw) && (!isTable(target[kw]) || target[kw][_declared])) {
+              throw this.error(new TomlError("Can't redefine existing key"));
+            }
+            target = target[kw] = target[kw] || Table();
+          }
+          if (hasKey(target, finalKey)) {
+            throw this.error(new TomlError("Can't redefine existing key"));
+          }
+          if (isInteger(kv.value) || isFloat(kv.value)) {
+            target[finalKey] = kv.value.valueOf();
+          } else {
+            target[finalKey] = kv.value;
+          }
+          return this.goto(this.parseWhitespaceToEOL);
+        }
+        /* ASSSIGNMENT expression, key = value possibly inside an inline table */
+        parseAssign() {
+          return this.callNow(this.parseKeyword, this.recordAssignKeyword);
+        }
+        recordAssignKeyword(key) {
+          if (this.state.resultTable) {
+            this.state.resultTable.push(key);
+          } else {
+            this.state.resultTable = [key];
+          }
+          return this.goto(this.parseAssignKeywordPreDot);
+        }
+        parseAssignKeywordPreDot() {
+          if (this.char === CHAR_PERIOD) {
+            return this.next(this.parseAssignKeywordPostDot);
+          } else if (this.char !== CHAR_SP && this.char !== CTRL_I) {
+            return this.goto(this.parseAssignEqual);
+          }
+        }
+        parseAssignKeywordPostDot() {
+          if (this.char !== CHAR_SP && this.char !== CTRL_I) {
+            return this.callNow(this.parseKeyword, this.recordAssignKeyword);
+          }
+        }
+        parseAssignEqual() {
+          if (this.char === CHAR_EQUALS) {
+            return this.next(this.parseAssignPreValue);
+          } else {
+            throw this.error(new TomlError('Invalid character, expected "="'));
+          }
+        }
+        parseAssignPreValue() {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else {
+            return this.callNow(this.parseValue, this.recordAssignValue);
+          }
+        }
+        recordAssignValue(value) {
+          return this.returnNow({ key: this.state.resultTable, value });
+        }
+        /* COMMENTS: #...eol */
+        parseComment() {
+          do {
+            if (this.char === Parser.END || this.char === CTRL_J) {
+              return this.return();
+            }
+          } while (this.nextChar());
+        }
+        /* TABLES AND LISTS, [foo] and [[foo]] */
+        parseTableOrList() {
+          if (this.char === CHAR_LSQB) {
+            this.next(this.parseList);
+          } else {
+            return this.goto(this.parseTable);
+          }
+        }
+        /* TABLE [foo.bar.baz] */
+        parseTable() {
+          this.ctx = this.obj;
+          return this.goto(this.parseTableNext);
+        }
+        parseTableNext() {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else {
+            return this.callNow(this.parseKeyword, this.parseTableMore);
+          }
+        }
+        parseTableMore(keyword) {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else if (this.char === CHAR_RSQB) {
+            if (hasKey(this.ctx, keyword) && (!isTable(this.ctx[keyword]) || this.ctx[keyword][_declared])) {
+              throw this.error(new TomlError("Can't redefine existing key"));
+            } else {
+              this.ctx = this.ctx[keyword] = this.ctx[keyword] || Table();
+              this.ctx[_declared] = true;
+            }
+            return this.next(this.parseWhitespaceToEOL);
+          } else if (this.char === CHAR_PERIOD) {
+            if (!hasKey(this.ctx, keyword)) {
+              this.ctx = this.ctx[keyword] = Table();
+            } else if (isTable(this.ctx[keyword])) {
+              this.ctx = this.ctx[keyword];
+            } else if (isList(this.ctx[keyword])) {
+              this.ctx = this.ctx[keyword][this.ctx[keyword].length - 1];
+            } else {
+              throw this.error(new TomlError("Can't redefine existing key"));
+            }
+            return this.next(this.parseTableNext);
+          } else {
+            throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
+          }
+        }
+        /* LIST [[a.b.c]] */
+        parseList() {
+          this.ctx = this.obj;
+          return this.goto(this.parseListNext);
+        }
+        parseListNext() {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else {
+            return this.callNow(this.parseKeyword, this.parseListMore);
+          }
+        }
+        parseListMore(keyword) {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else if (this.char === CHAR_RSQB) {
+            if (!hasKey(this.ctx, keyword)) {
+              this.ctx[keyword] = List();
+            }
+            if (isInlineList(this.ctx[keyword])) {
+              throw this.error(new TomlError("Can't extend an inline array"));
+            } else if (isList(this.ctx[keyword])) {
+              const next = Table();
+              this.ctx[keyword].push(next);
+              this.ctx = next;
+            } else {
+              throw this.error(new TomlError("Can't redefine an existing key"));
+            }
+            return this.next(this.parseListEnd);
+          } else if (this.char === CHAR_PERIOD) {
+            if (!hasKey(this.ctx, keyword)) {
+              this.ctx = this.ctx[keyword] = Table();
+            } else if (isInlineList(this.ctx[keyword])) {
+              throw this.error(new TomlError("Can't extend an inline array"));
+            } else if (isInlineTable(this.ctx[keyword])) {
+              throw this.error(new TomlError("Can't extend an inline table"));
+            } else if (isList(this.ctx[keyword])) {
+              this.ctx = this.ctx[keyword][this.ctx[keyword].length - 1];
+            } else if (isTable(this.ctx[keyword])) {
+              this.ctx = this.ctx[keyword];
+            } else {
+              throw this.error(new TomlError("Can't redefine an existing key"));
+            }
+            return this.next(this.parseListNext);
+          } else {
+            throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
+          }
+        }
+        parseListEnd(keyword) {
+          if (this.char === CHAR_RSQB) {
+            return this.next(this.parseWhitespaceToEOL);
+          } else {
+            throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
+          }
+        }
+        /* VALUE string, number, boolean, inline list, inline object */
+        parseValue() {
+          if (this.char === Parser.END) {
+            throw this.error(new TomlError("Key without value"));
+          } else if (this.char === CHAR_QUOT) {
+            return this.next(this.parseDoubleString);
+          }
+          if (this.char === CHAR_APOS) {
+            return this.next(this.parseSingleString);
+          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
+            return this.goto(this.parseNumberSign);
+          } else if (this.char === CHAR_i) {
+            return this.next(this.parseInf);
+          } else if (this.char === CHAR_n) {
+            return this.next(this.parseNan);
+          } else if (isDigit(this.char)) {
+            return this.goto(this.parseNumberOrDateTime);
+          } else if (this.char === CHAR_t || this.char === CHAR_f) {
+            return this.goto(this.parseBoolean);
+          } else if (this.char === CHAR_LSQB) {
+            return this.call(this.parseInlineList, this.recordValue);
+          } else if (this.char === CHAR_LCUB) {
+            return this.call(this.parseInlineTable, this.recordValue);
+          } else {
+            throw this.error(new TomlError("Unexpected character, expecting string, number, datetime, boolean, inline array or inline table"));
+          }
+        }
+        recordValue(value) {
+          return this.returnNow(value);
+        }
+        parseInf() {
+          if (this.char === CHAR_n) {
+            return this.next(this.parseInf2);
+          } else {
+            throw this.error(new TomlError('Unexpected character, expected "inf", "+inf" or "-inf"'));
+          }
+        }
+        parseInf2() {
+          if (this.char === CHAR_f) {
+            if (this.state.buf === "-") {
+              return this.return(-Infinity);
+            } else {
+              return this.return(Infinity);
+            }
+          } else {
+            throw this.error(new TomlError('Unexpected character, expected "inf", "+inf" or "-inf"'));
+          }
+        }
+        parseNan() {
+          if (this.char === CHAR_a) {
+            return this.next(this.parseNan2);
+          } else {
+            throw this.error(new TomlError('Unexpected character, expected "nan"'));
+          }
+        }
+        parseNan2() {
+          if (this.char === CHAR_n) {
+            return this.return(NaN);
+          } else {
+            throw this.error(new TomlError('Unexpected character, expected "nan"'));
+          }
+        }
+        /* KEYS, barewords or basic, literal, or dotted */
+        parseKeyword() {
+          if (this.char === CHAR_QUOT) {
+            return this.next(this.parseBasicString);
+          } else if (this.char === CHAR_APOS) {
+            return this.next(this.parseLiteralString);
+          } else {
+            return this.goto(this.parseBareKey);
+          }
+        }
+        /* KEYS: barewords */
+        parseBareKey() {
+          do {
+            if (this.char === Parser.END) {
+              throw this.error(new TomlError("Key ended without value"));
+            } else if (isAlphaNumHyphen(this.char)) {
+              this.consume();
+            } else if (this.state.buf.length === 0) {
+              throw this.error(new TomlError("Empty bare keys are not allowed"));
+            } else {
+              return this.returnNow();
+            }
+          } while (this.nextChar());
+        }
+        /* STRINGS, single quoted (literal) */
+        parseSingleString() {
+          if (this.char === CHAR_APOS) {
+            return this.next(this.parseLiteralMultiStringMaybe);
+          } else {
+            return this.goto(this.parseLiteralString);
+          }
+        }
+        parseLiteralString() {
+          do {
+            if (this.char === CHAR_APOS) {
+              return this.return();
+            } else if (this.atEndOfLine()) {
+              throw this.error(new TomlError("Unterminated string"));
+            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I) {
+              throw this.errorControlCharInString();
+            } else {
+              this.consume();
+            }
+          } while (this.nextChar());
+        }
+        parseLiteralMultiStringMaybe() {
+          if (this.char === CHAR_APOS) {
+            return this.next(this.parseLiteralMultiString);
+          } else {
+            return this.returnNow();
+          }
+        }
+        parseLiteralMultiString() {
+          if (this.char === CTRL_M) {
+            return null;
+          } else if (this.char === CTRL_J) {
+            return this.next(this.parseLiteralMultiStringContent);
+          } else {
+            return this.goto(this.parseLiteralMultiStringContent);
+          }
+        }
+        parseLiteralMultiStringContent() {
+          do {
+            if (this.char === CHAR_APOS) {
+              return this.next(this.parseLiteralMultiEnd);
+            } else if (this.char === Parser.END) {
+              throw this.error(new TomlError("Unterminated multi-line string"));
+            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I && this.char !== CTRL_J && this.char !== CTRL_M) {
+              throw this.errorControlCharInString();
+            } else {
+              this.consume();
+            }
+          } while (this.nextChar());
+        }
+        parseLiteralMultiEnd() {
+          if (this.char === CHAR_APOS) {
+            return this.next(this.parseLiteralMultiEnd2);
+          } else {
+            this.state.buf += "'";
+            return this.goto(this.parseLiteralMultiStringContent);
+          }
+        }
+        parseLiteralMultiEnd2() {
+          if (this.char === CHAR_APOS) {
+            return this.return();
+          } else {
+            this.state.buf += "''";
+            return this.goto(this.parseLiteralMultiStringContent);
+          }
+        }
+        /* STRINGS double quoted */
+        parseDoubleString() {
+          if (this.char === CHAR_QUOT) {
+            return this.next(this.parseMultiStringMaybe);
+          } else {
+            return this.goto(this.parseBasicString);
+          }
+        }
+        parseBasicString() {
+          do {
+            if (this.char === CHAR_BSOL) {
+              return this.call(this.parseEscape, this.recordEscapeReplacement);
+            } else if (this.char === CHAR_QUOT) {
+              return this.return();
+            } else if (this.atEndOfLine()) {
+              throw this.error(new TomlError("Unterminated string"));
+            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I) {
+              throw this.errorControlCharInString();
+            } else {
+              this.consume();
+            }
+          } while (this.nextChar());
+        }
+        recordEscapeReplacement(replacement) {
+          this.state.buf += replacement;
+          return this.goto(this.parseBasicString);
+        }
+        parseMultiStringMaybe() {
+          if (this.char === CHAR_QUOT) {
+            return this.next(this.parseMultiString);
+          } else {
+            return this.returnNow();
+          }
+        }
+        parseMultiString() {
+          if (this.char === CTRL_M) {
+            return null;
+          } else if (this.char === CTRL_J) {
+            return this.next(this.parseMultiStringContent);
+          } else {
+            return this.goto(this.parseMultiStringContent);
+          }
+        }
+        parseMultiStringContent() {
+          do {
+            if (this.char === CHAR_BSOL) {
+              return this.call(this.parseMultiEscape, this.recordMultiEscapeReplacement);
+            } else if (this.char === CHAR_QUOT) {
+              return this.next(this.parseMultiEnd);
+            } else if (this.char === Parser.END) {
+              throw this.error(new TomlError("Unterminated multi-line string"));
+            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I && this.char !== CTRL_J && this.char !== CTRL_M) {
+              throw this.errorControlCharInString();
+            } else {
+              this.consume();
+            }
+          } while (this.nextChar());
+        }
+        errorControlCharInString() {
+          let displayCode = "\\u00";
+          if (this.char < 16) {
+            displayCode += "0";
+          }
+          displayCode += this.char.toString(16);
+          return this.error(new TomlError(`Control characters (codes < 0x1f and 0x7f) are not allowed in strings, use ${displayCode} instead`));
+        }
+        recordMultiEscapeReplacement(replacement) {
+          this.state.buf += replacement;
+          return this.goto(this.parseMultiStringContent);
+        }
+        parseMultiEnd() {
+          if (this.char === CHAR_QUOT) {
+            return this.next(this.parseMultiEnd2);
+          } else {
+            this.state.buf += '"';
+            return this.goto(this.parseMultiStringContent);
+          }
+        }
+        parseMultiEnd2() {
+          if (this.char === CHAR_QUOT) {
+            return this.return();
+          } else {
+            this.state.buf += '""';
+            return this.goto(this.parseMultiStringContent);
+          }
+        }
+        parseMultiEscape() {
+          if (this.char === CTRL_M || this.char === CTRL_J) {
+            return this.next(this.parseMultiTrim);
+          } else if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return this.next(this.parsePreMultiTrim);
+          } else {
+            return this.goto(this.parseEscape);
+          }
+        }
+        parsePreMultiTrim() {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else if (this.char === CTRL_M || this.char === CTRL_J) {
+            return this.next(this.parseMultiTrim);
+          } else {
+            throw this.error(new TomlError("Can't escape whitespace"));
+          }
+        }
+        parseMultiTrim() {
+          if (this.char === CTRL_J || this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
+            return null;
+          } else {
+            return this.returnNow();
+          }
+        }
+        parseEscape() {
+          if (this.char in escapes) {
+            return this.return(escapes[this.char]);
+          } else if (this.char === CHAR_u) {
+            return this.call(this.parseSmallUnicode, this.parseUnicodeReturn);
+          } else if (this.char === CHAR_U) {
+            return this.call(this.parseLargeUnicode, this.parseUnicodeReturn);
+          } else {
+            throw this.error(new TomlError("Unknown escape character: " + this.char));
+          }
+        }
+        parseUnicodeReturn(char) {
+          try {
+            const codePoint = parseInt(char, 16);
+            if (codePoint >= SURROGATE_FIRST && codePoint <= SURROGATE_LAST) {
+              throw this.error(new TomlError("Invalid unicode, character in range 0xD800 - 0xDFFF is reserved"));
+            }
+            return this.returnNow(String.fromCodePoint(codePoint));
+          } catch (err) {
+            throw this.error(TomlError.wrap(err));
+          }
+        }
+        parseSmallUnicode() {
+          if (!isHexit(this.char)) {
+            throw this.error(new TomlError("Invalid character in unicode sequence, expected hex"));
+          } else {
+            this.consume();
+            if (this.state.buf.length >= 4) return this.return();
+          }
+        }
+        parseLargeUnicode() {
+          if (!isHexit(this.char)) {
+            throw this.error(new TomlError("Invalid character in unicode sequence, expected hex"));
+          } else {
+            this.consume();
+            if (this.state.buf.length >= 8) return this.return();
+          }
+        }
+        /* NUMBERS */
+        parseNumberSign() {
+          this.consume();
+          return this.next(this.parseMaybeSignedInfOrNan);
+        }
+        parseMaybeSignedInfOrNan() {
+          if (this.char === CHAR_i) {
+            return this.next(this.parseInf);
+          } else if (this.char === CHAR_n) {
+            return this.next(this.parseNan);
+          } else {
+            return this.callNow(this.parseNoUnder, this.parseNumberIntegerStart);
+          }
+        }
+        parseNumberIntegerStart() {
+          if (this.char === CHAR_0) {
+            this.consume();
+            return this.next(this.parseNumberIntegerExponentOrDecimal);
+          } else {
+            return this.goto(this.parseNumberInteger);
+          }
+        }
+        parseNumberIntegerExponentOrDecimal() {
+          if (this.char === CHAR_PERIOD) {
+            this.consume();
+            return this.call(this.parseNoUnder, this.parseNumberFloat);
+          } else if (this.char === CHAR_E || this.char === CHAR_e) {
+            this.consume();
+            return this.next(this.parseNumberExponentSign);
+          } else {
+            return this.returnNow(Integer(this.state.buf));
+          }
+        }
+        parseNumberInteger() {
+          if (isDigit(this.char)) {
+            this.consume();
+          } else if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnder);
+          } else if (this.char === CHAR_E || this.char === CHAR_e) {
+            this.consume();
+            return this.next(this.parseNumberExponentSign);
+          } else if (this.char === CHAR_PERIOD) {
+            this.consume();
+            return this.call(this.parseNoUnder, this.parseNumberFloat);
+          } else {
+            const result = Integer(this.state.buf);
+            if (result.isNaN()) {
+              throw this.error(new TomlError("Invalid number"));
+            } else {
+              return this.returnNow(result);
+            }
+          }
+        }
+        parseNoUnder() {
+          if (this.char === CHAR_LOWBAR || this.char === CHAR_PERIOD || this.char === CHAR_E || this.char === CHAR_e) {
+            throw this.error(new TomlError("Unexpected character, expected digit"));
+          } else if (this.atEndOfWord()) {
+            throw this.error(new TomlError("Incomplete number"));
+          }
+          return this.returnNow();
+        }
+        parseNoUnderHexOctBinLiteral() {
+          if (this.char === CHAR_LOWBAR || this.char === CHAR_PERIOD) {
+            throw this.error(new TomlError("Unexpected character, expected digit"));
+          } else if (this.atEndOfWord()) {
+            throw this.error(new TomlError("Incomplete number"));
+          }
+          return this.returnNow();
+        }
+        parseNumberFloat() {
+          if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnder, this.parseNumberFloat);
+          } else if (isDigit(this.char)) {
+            this.consume();
+          } else if (this.char === CHAR_E || this.char === CHAR_e) {
+            this.consume();
+            return this.next(this.parseNumberExponentSign);
+          } else {
+            return this.returnNow(Float(this.state.buf));
+          }
+        }
+        parseNumberExponentSign() {
+          if (isDigit(this.char)) {
+            return this.goto(this.parseNumberExponent);
+          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
+            this.consume();
+            this.call(this.parseNoUnder, this.parseNumberExponent);
+          } else {
+            throw this.error(new TomlError("Unexpected character, expected -, + or digit"));
+          }
+        }
+        parseNumberExponent() {
+          if (isDigit(this.char)) {
+            this.consume();
+          } else if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnder);
+          } else {
+            return this.returnNow(Float(this.state.buf));
+          }
+        }
+        /* NUMBERS or DATETIMES  */
+        parseNumberOrDateTime() {
+          if (this.char === CHAR_0) {
+            this.consume();
+            return this.next(this.parseNumberBaseOrDateTime);
+          } else {
+            return this.goto(this.parseNumberOrDateTimeOnly);
+          }
+        }
+        parseNumberOrDateTimeOnly() {
+          if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnder, this.parseNumberInteger);
+          } else if (isDigit(this.char)) {
+            this.consume();
+            if (this.state.buf.length > 4) this.next(this.parseNumberInteger);
+          } else if (this.char === CHAR_E || this.char === CHAR_e) {
+            this.consume();
+            return this.next(this.parseNumberExponentSign);
+          } else if (this.char === CHAR_PERIOD) {
+            this.consume();
+            return this.call(this.parseNoUnder, this.parseNumberFloat);
+          } else if (this.char === CHAR_HYPHEN) {
+            return this.goto(this.parseDateTime);
+          } else if (this.char === CHAR_COLON) {
+            return this.goto(this.parseOnlyTimeHour);
+          } else {
+            return this.returnNow(Integer(this.state.buf));
+          }
+        }
+        parseDateTimeOnly() {
+          if (this.state.buf.length < 4) {
+            if (isDigit(this.char)) {
+              return this.consume();
+            } else if (this.char === CHAR_COLON) {
+              return this.goto(this.parseOnlyTimeHour);
+            } else {
+              throw this.error(new TomlError("Expected digit while parsing year part of a date"));
+            }
+          } else {
+            if (this.char === CHAR_HYPHEN) {
+              return this.goto(this.parseDateTime);
+            } else {
+              throw this.error(new TomlError("Expected hyphen (-) while parsing year part of date"));
+            }
+          }
+        }
+        parseNumberBaseOrDateTime() {
+          if (this.char === CHAR_b) {
+            this.consume();
+            return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerBin);
+          } else if (this.char === CHAR_o) {
+            this.consume();
+            return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerOct);
+          } else if (this.char === CHAR_x) {
+            this.consume();
+            return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerHex);
+          } else if (this.char === CHAR_PERIOD) {
+            return this.goto(this.parseNumberInteger);
+          } else if (isDigit(this.char)) {
+            return this.goto(this.parseDateTimeOnly);
+          } else {
+            return this.returnNow(Integer(this.state.buf));
+          }
+        }
+        parseIntegerHex() {
+          if (isHexit(this.char)) {
+            this.consume();
+          } else if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnderHexOctBinLiteral);
+          } else {
+            const result = Integer(this.state.buf);
+            if (result.isNaN()) {
+              throw this.error(new TomlError("Invalid number"));
+            } else {
+              return this.returnNow(result);
+            }
+          }
+        }
+        parseIntegerOct() {
+          if (isOctit(this.char)) {
+            this.consume();
+          } else if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnderHexOctBinLiteral);
+          } else {
+            const result = Integer(this.state.buf);
+            if (result.isNaN()) {
+              throw this.error(new TomlError("Invalid number"));
+            } else {
+              return this.returnNow(result);
+            }
+          }
+        }
+        parseIntegerBin() {
+          if (isBit(this.char)) {
+            this.consume();
+          } else if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnderHexOctBinLiteral);
+          } else {
+            const result = Integer(this.state.buf);
+            if (result.isNaN()) {
+              throw this.error(new TomlError("Invalid number"));
+            } else {
+              return this.returnNow(result);
+            }
+          }
+        }
+        /* DATETIME */
+        parseDateTime() {
+          if (this.state.buf.length < 4) {
+            throw this.error(new TomlError("Years less than 1000 must be zero padded to four characters"));
+          }
+          this.state.result = this.state.buf;
+          this.state.buf = "";
+          return this.next(this.parseDateMonth);
+        }
+        parseDateMonth() {
+          if (this.char === CHAR_HYPHEN) {
+            if (this.state.buf.length < 2) {
+              throw this.error(new TomlError("Months less than 10 must be zero padded to two characters"));
+            }
+            this.state.result += "-" + this.state.buf;
+            this.state.buf = "";
+            return this.next(this.parseDateDay);
+          } else if (isDigit(this.char)) {
+            this.consume();
+          } else {
+            throw this.error(new TomlError("Incomplete datetime"));
+          }
+        }
+        parseDateDay() {
+          if (this.char === CHAR_T || this.char === CHAR_SP) {
+            if (this.state.buf.length < 2) {
+              throw this.error(new TomlError("Days less than 10 must be zero padded to two characters"));
+            }
+            this.state.result += "-" + this.state.buf;
+            this.state.buf = "";
+            return this.next(this.parseStartTimeHour);
+          } else if (this.atEndOfWord()) {
+            return this.returnNow(createDate(this.state.result + "-" + this.state.buf));
+          } else if (isDigit(this.char)) {
+            this.consume();
+          } else {
+            throw this.error(new TomlError("Incomplete datetime"));
+          }
+        }
+        parseStartTimeHour() {
+          if (this.atEndOfWord()) {
+            return this.returnNow(createDate(this.state.result));
+          } else {
+            return this.goto(this.parseTimeHour);
+          }
+        }
+        parseTimeHour() {
+          if (this.char === CHAR_COLON) {
+            if (this.state.buf.length < 2) {
+              throw this.error(new TomlError("Hours less than 10 must be zero padded to two characters"));
+            }
+            this.state.result += "T" + this.state.buf;
+            this.state.buf = "";
+            return this.next(this.parseTimeMin);
+          } else if (isDigit(this.char)) {
+            this.consume();
+          } else {
+            throw this.error(new TomlError("Incomplete datetime"));
+          }
+        }
+        parseTimeMin() {
+          if (this.state.buf.length < 2 && isDigit(this.char)) {
+            this.consume();
+          } else if (this.state.buf.length === 2 && this.char === CHAR_COLON) {
+            this.state.result += ":" + this.state.buf;
+            this.state.buf = "";
+            return this.next(this.parseTimeSec);
+          } else {
+            throw this.error(new TomlError("Incomplete datetime"));
+          }
+        }
+        parseTimeSec() {
+          if (isDigit(this.char)) {
+            this.consume();
+            if (this.state.buf.length === 2) {
+              this.state.result += ":" + this.state.buf;
+              this.state.buf = "";
+              return this.next(this.parseTimeZoneOrFraction);
+            }
+          } else {
+            throw this.error(new TomlError("Incomplete datetime"));
+          }
+        }
+        parseOnlyTimeHour() {
+          if (this.char === CHAR_COLON) {
+            if (this.state.buf.length < 2) {
+              throw this.error(new TomlError("Hours less than 10 must be zero padded to two characters"));
+            }
+            this.state.result = this.state.buf;
+            this.state.buf = "";
+            return this.next(this.parseOnlyTimeMin);
+          } else {
+            throw this.error(new TomlError("Incomplete time"));
+          }
+        }
+        parseOnlyTimeMin() {
+          if (this.state.buf.length < 2 && isDigit(this.char)) {
+            this.consume();
+          } else if (this.state.buf.length === 2 && this.char === CHAR_COLON) {
+            this.state.result += ":" + this.state.buf;
+            this.state.buf = "";
+            return this.next(this.parseOnlyTimeSec);
+          } else {
+            throw this.error(new TomlError("Incomplete time"));
+          }
+        }
+        parseOnlyTimeSec() {
+          if (isDigit(this.char)) {
+            this.consume();
+            if (this.state.buf.length === 2) {
+              return this.next(this.parseOnlyTimeFractionMaybe);
+            }
+          } else {
+            throw this.error(new TomlError("Incomplete time"));
+          }
+        }
+        parseOnlyTimeFractionMaybe() {
+          this.state.result += ":" + this.state.buf;
+          if (this.char === CHAR_PERIOD) {
+            this.state.buf = "";
+            this.next(this.parseOnlyTimeFraction);
+          } else {
+            return this.return(createTime(this.state.result));
+          }
+        }
+        parseOnlyTimeFraction() {
+          if (isDigit(this.char)) {
+            this.consume();
+          } else if (this.atEndOfWord()) {
+            if (this.state.buf.length === 0) throw this.error(new TomlError("Expected digit in milliseconds"));
+            return this.returnNow(createTime(this.state.result + "." + this.state.buf));
+          } else {
+            throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
+          }
+        }
+        parseTimeZoneOrFraction() {
+          if (this.char === CHAR_PERIOD) {
+            this.consume();
+            this.next(this.parseDateTimeFraction);
+          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
+            this.consume();
+            this.next(this.parseTimeZoneHour);
+          } else if (this.char === CHAR_Z) {
+            this.consume();
+            return this.return(createDateTime(this.state.result + this.state.buf));
+          } else if (this.atEndOfWord()) {
+            return this.returnNow(createDateTimeFloat(this.state.result + this.state.buf));
+          } else {
+            throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
+          }
+        }
+        parseDateTimeFraction() {
+          if (isDigit(this.char)) {
+            this.consume();
+          } else if (this.state.buf.length === 1) {
+            throw this.error(new TomlError("Expected digit in milliseconds"));
+          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
+            this.consume();
+            this.next(this.parseTimeZoneHour);
+          } else if (this.char === CHAR_Z) {
+            this.consume();
+            return this.return(createDateTime(this.state.result + this.state.buf));
+          } else if (this.atEndOfWord()) {
+            return this.returnNow(createDateTimeFloat(this.state.result + this.state.buf));
+          } else {
+            throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
+          }
+        }
+        parseTimeZoneHour() {
+          if (isDigit(this.char)) {
+            this.consume();
+            if (/\d\d$/.test(this.state.buf)) return this.next(this.parseTimeZoneSep);
+          } else {
+            throw this.error(new TomlError("Unexpected character in datetime, expected digit"));
+          }
+        }
+        parseTimeZoneSep() {
+          if (this.char === CHAR_COLON) {
+            this.consume();
+            this.next(this.parseTimeZoneMin);
+          } else {
+            throw this.error(new TomlError("Unexpected character in datetime, expected colon"));
+          }
+        }
+        parseTimeZoneMin() {
+          if (isDigit(this.char)) {
+            this.consume();
+            if (/\d\d$/.test(this.state.buf)) return this.return(createDateTime(this.state.result + this.state.buf));
+          } else {
+            throw this.error(new TomlError("Unexpected character in datetime, expected digit"));
+          }
+        }
+        /* BOOLEAN */
+        parseBoolean() {
+          if (this.char === CHAR_t) {
+            this.consume();
+            return this.next(this.parseTrue_r);
+          } else if (this.char === CHAR_f) {
+            this.consume();
+            return this.next(this.parseFalse_a);
+          }
+        }
+        parseTrue_r() {
+          if (this.char === CHAR_r) {
+            this.consume();
+            return this.next(this.parseTrue_u);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        parseTrue_u() {
+          if (this.char === CHAR_u) {
+            this.consume();
+            return this.next(this.parseTrue_e);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        parseTrue_e() {
+          if (this.char === CHAR_e) {
+            return this.return(true);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        parseFalse_a() {
+          if (this.char === CHAR_a) {
+            this.consume();
+            return this.next(this.parseFalse_l);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        parseFalse_l() {
+          if (this.char === CHAR_l) {
+            this.consume();
+            return this.next(this.parseFalse_s);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        parseFalse_s() {
+          if (this.char === CHAR_s) {
+            this.consume();
+            return this.next(this.parseFalse_e);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        parseFalse_e() {
+          if (this.char === CHAR_e) {
+            return this.return(false);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        /* INLINE LISTS */
+        parseInlineList() {
+          if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M || this.char === CTRL_J) {
+            return null;
+          } else if (this.char === Parser.END) {
+            throw this.error(new TomlError("Unterminated inline array"));
+          } else if (this.char === CHAR_NUM) {
+            return this.call(this.parseComment);
+          } else if (this.char === CHAR_RSQB) {
+            return this.return(this.state.resultArr || InlineList());
+          } else {
+            return this.callNow(this.parseValue, this.recordInlineListValue);
+          }
+        }
+        recordInlineListValue(value) {
+          if (this.state.resultArr) {
+            const listType = this.state.resultArr[_contentType];
+            const valueType = tomlType(value);
+            if (listType !== valueType) {
+              throw this.error(new TomlError(`Inline lists must be a single type, not a mix of ${listType} and ${valueType}`));
+            }
+          } else {
+            this.state.resultArr = InlineList(tomlType(value));
+          }
+          if (isFloat(value) || isInteger(value)) {
+            this.state.resultArr.push(value.valueOf());
+          } else {
+            this.state.resultArr.push(value);
+          }
+          return this.goto(this.parseInlineListNext);
+        }
+        parseInlineListNext() {
+          if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M || this.char === CTRL_J) {
+            return null;
+          } else if (this.char === CHAR_NUM) {
+            return this.call(this.parseComment);
+          } else if (this.char === CHAR_COMMA) {
+            return this.next(this.parseInlineList);
+          } else if (this.char === CHAR_RSQB) {
+            return this.goto(this.parseInlineList);
+          } else {
+            throw this.error(new TomlError("Invalid character, expected whitespace, comma (,) or close bracket (])"));
+          }
+        }
+        /* INLINE TABLE */
+        parseInlineTable() {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else if (this.char === Parser.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) {
+            throw this.error(new TomlError("Unterminated inline array"));
+          } else if (this.char === CHAR_RCUB) {
+            return this.return(this.state.resultTable || InlineTable());
+          } else {
+            if (!this.state.resultTable) this.state.resultTable = InlineTable();
+            return this.callNow(this.parseAssign, this.recordInlineTableValue);
+          }
+        }
+        recordInlineTableValue(kv) {
+          let target = this.state.resultTable;
+          let finalKey = kv.key.pop();
+          for (let kw of kv.key) {
+            if (hasKey(target, kw) && (!isTable(target[kw]) || target[kw][_declared])) {
+              throw this.error(new TomlError("Can't redefine existing key"));
+            }
+            target = target[kw] = target[kw] || Table();
+          }
+          if (hasKey(target, finalKey)) {
+            throw this.error(new TomlError("Can't redefine existing key"));
+          }
+          if (isInteger(kv.value) || isFloat(kv.value)) {
+            target[finalKey] = kv.value.valueOf();
+          } else {
+            target[finalKey] = kv.value;
+          }
+          return this.goto(this.parseInlineTableNext);
+        }
+        parseInlineTableNext() {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else if (this.char === Parser.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) {
+            throw this.error(new TomlError("Unterminated inline array"));
+          } else if (this.char === CHAR_COMMA) {
+            return this.next(this.parseInlineTable);
+          } else if (this.char === CHAR_RCUB) {
+            return this.goto(this.parseInlineTable);
+          } else {
+            throw this.error(new TomlError("Invalid character, expected whitespace, comma (,) or close bracket (])"));
+          }
+        }
+      }
+      return TOMLParser;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-pretty-error.js
+var require_parse_pretty_error = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-pretty-error.js"(exports2, module2) {
+    "use strict";
+    module2.exports = prettyError;
+    function prettyError(err, buf) {
+      if (err.pos == null || err.line == null) return err;
+      let msg = err.message;
+      msg += ` at row ${err.line + 1}, col ${err.col + 1}, pos ${err.pos}:
+`;
+      if (buf && buf.split) {
+        const lines = buf.split(/\n/);
+        const lineNumWidth = String(Math.min(lines.length, err.line + 3)).length;
+        let linePadding = " ";
+        while (linePadding.length < lineNumWidth) linePadding += " ";
+        for (let ii = Math.max(0, err.line - 1); ii < Math.min(lines.length, err.line + 2); ++ii) {
+          let lineNum = String(ii + 1);
+          if (lineNum.length < lineNumWidth) lineNum = " " + lineNum;
+          if (err.line === ii) {
+            msg += lineNum + "> " + lines[ii] + "\n";
+            msg += linePadding + "  ";
+            for (let hh = 0; hh < err.col; ++hh) {
+              msg += " ";
+            }
+            msg += "^\n";
+          } else {
+            msg += lineNum + ": " + lines[ii] + "\n";
+          }
+        }
+      }
+      err.message = msg + "\n";
+      return err;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-string.js
+var require_parse_string = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-string.js"(exports2, module2) {
+    "use strict";
+    module2.exports = parseString;
+    var TOMLParser = require_toml_parser();
+    var prettyError = require_parse_pretty_error();
+    function parseString(str) {
+      if (global.Buffer && global.Buffer.isBuffer(str)) {
+        str = str.toString("utf8");
+      }
+      const parser = new TOMLParser();
+      try {
+        parser.parse(str);
+        return parser.finish();
+      } catch (err) {
+        throw prettyError(err, str);
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-async.js
+var require_parse_async = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-async.js"(exports2, module2) {
+    "use strict";
+    module2.exports = parseAsync;
+    var TOMLParser = require_toml_parser();
+    var prettyError = require_parse_pretty_error();
+    function parseAsync(str, opts) {
+      if (!opts) opts = {};
+      const index = 0;
+      const blocksize = opts.blocksize || 40960;
+      const parser = new TOMLParser();
+      return new Promise((resolve, reject) => {
+        setImmediate(parseAsyncNext, index, blocksize, resolve, reject);
+      });
+      function parseAsyncNext(index2, blocksize2, resolve, reject) {
+        if (index2 >= str.length) {
+          try {
+            return resolve(parser.finish());
+          } catch (err) {
+            return reject(prettyError(err, str));
+          }
+        }
+        try {
+          parser.parse(str.slice(index2, index2 + blocksize2));
+          setImmediate(parseAsyncNext, index2 + blocksize2, blocksize2, resolve, reject);
+        } catch (err) {
+          reject(prettyError(err, str));
+        }
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-stream.js
+var require_parse_stream = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-stream.js"(exports2, module2) {
+    "use strict";
+    module2.exports = parseStream;
+    var stream = require("stream");
+    var TOMLParser = require_toml_parser();
+    function parseStream(stm) {
+      if (stm) {
+        return parseReadable(stm);
+      } else {
+        return parseTransform(stm);
+      }
+    }
+    function parseReadable(stm) {
+      const parser = new TOMLParser();
+      stm.setEncoding("utf8");
+      return new Promise((resolve, reject) => {
+        let readable;
+        let ended = false;
+        let errored = false;
+        function finish() {
+          ended = true;
+          if (readable) return;
+          try {
+            resolve(parser.finish());
+          } catch (err) {
+            reject(err);
+          }
+        }
+        function error(err) {
+          errored = true;
+          reject(err);
+        }
+        stm.once("end", finish);
+        stm.once("error", error);
+        readNext();
+        function readNext() {
+          readable = true;
+          let data;
+          while ((data = stm.read()) !== null) {
+            try {
+              parser.parse(data);
+            } catch (err) {
+              return error(err);
+            }
+          }
+          readable = false;
+          if (ended) return finish();
+          if (errored) return;
+          stm.once("readable", readNext);
+        }
+      });
+    }
+    function parseTransform() {
+      const parser = new TOMLParser();
+      return new stream.Transform({
+        objectMode: true,
+        transform(chunk, encoding, cb) {
+          try {
+            parser.parse(chunk.toString(encoding));
+          } catch (err) {
+            this.emit("error", err);
+          }
+          cb();
+        },
+        flush(cb) {
+          try {
+            this.push(parser.finish());
+          } catch (err) {
+            this.emit("error", err);
+          }
+          cb();
+        }
+      });
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse.js
+var require_parse = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse.js"(exports2, module2) {
+    "use strict";
+    module2.exports = require_parse_string();
+    module2.exports.async = require_parse_async();
+    module2.exports.stream = require_parse_stream();
+    module2.exports.prettyError = require_parse_pretty_error();
+  }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/stringify.js
+var require_stringify = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/stringify.js"(exports2, module2) {
+    "use strict";
+    module2.exports = stringify;
+    module2.exports.value = stringifyInline;
+    function stringify(obj) {
+      if (obj === null) throw typeError("null");
+      if (obj === void 0) throw typeError("undefined");
+      if (typeof obj !== "object") throw typeError(typeof obj);
+      if (typeof obj.toJSON === "function") obj = obj.toJSON();
+      if (obj == null) return null;
+      const type = tomlType2(obj);
+      if (type !== "table") throw typeError(type);
+      return stringifyObject("", "", obj);
+    }
+    function typeError(type) {
+      return new Error("Can only stringify objects, not " + type);
+    }
+    function arrayOneTypeError() {
+      return new Error("Array values can't have mixed types");
+    }
+    function getInlineKeys(obj) {
+      return Object.keys(obj).filter((key) => isInline(obj[key]));
+    }
+    function getComplexKeys(obj) {
+      return Object.keys(obj).filter((key) => !isInline(obj[key]));
+    }
+    function toJSON(obj) {
+      let nobj = Array.isArray(obj) ? [] : Object.prototype.hasOwnProperty.call(obj, "__proto__") ? { ["__proto__"]: void 0 } : {};
+      for (let prop of Object.keys(obj)) {
+        if (obj[prop] && typeof obj[prop].toJSON === "function" && !("toISOString" in obj[prop])) {
+          nobj[prop] = obj[prop].toJSON();
+        } else {
+          nobj[prop] = obj[prop];
+        }
+      }
+      return nobj;
+    }
+    function stringifyObject(prefix, indent, obj) {
+      obj = toJSON(obj);
+      var inlineKeys;
+      var complexKeys;
+      inlineKeys = getInlineKeys(obj);
+      complexKeys = getComplexKeys(obj);
+      var result = [];
+      var inlineIndent = indent || "";
+      inlineKeys.forEach((key) => {
+        var type = tomlType2(obj[key]);
+        if (type !== "undefined" && type !== "null") {
+          result.push(inlineIndent + stringifyKey(key) + " = " + stringifyAnyInline(obj[key], true));
+        }
+      });
+      if (result.length > 0) result.push("");
+      var complexIndent = prefix && inlineKeys.length > 0 ? indent + "  " : "";
+      complexKeys.forEach((key) => {
+        result.push(stringifyComplex(prefix, complexIndent, key, obj[key]));
+      });
+      return result.join("\n");
+    }
+    function isInline(value) {
+      switch (tomlType2(value)) {
+        case "undefined":
+        case "null":
+        case "integer":
+        case "nan":
+        case "float":
+        case "boolean":
+        case "string":
+        case "datetime":
+          return true;
+        case "array":
+          return value.length === 0 || tomlType2(value[0]) !== "table";
+        case "table":
+          return Object.keys(value).length === 0;
+        /* istanbul ignore next */
+        default:
+          return false;
+      }
+    }
+    function tomlType2(value) {
+      if (value === void 0) {
+        return "undefined";
+      } else if (value === null) {
+        return "null";
+      } else if (typeof value === "bigint" || Number.isInteger(value) && !Object.is(value, -0)) {
+        return "integer";
+      } else if (typeof value === "number") {
+        return "float";
+      } else if (typeof value === "boolean") {
+        return "boolean";
+      } else if (typeof value === "string") {
+        return "string";
+      } else if ("toISOString" in value) {
+        return isNaN(value) ? "undefined" : "datetime";
+      } else if (Array.isArray(value)) {
+        return "array";
+      } else {
+        return "table";
+      }
+    }
+    function stringifyKey(key) {
+      var keyStr = String(key);
+      if (/^[-A-Za-z0-9_]+$/.test(keyStr)) {
+        return keyStr;
+      } else {
+        return stringifyBasicString(keyStr);
+      }
+    }
+    function stringifyBasicString(str) {
+      return '"' + escapeString(str).replace(/"/g, '\\"') + '"';
+    }
+    function stringifyLiteralString(str) {
+      return "'" + str + "'";
+    }
+    function numpad(num, str) {
+      while (str.length < num) str = "0" + str;
+      return str;
+    }
+    function escapeString(str) {
+      return str.replace(/\\/g, "\\\\").replace(/[\b]/g, "\\b").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\f/g, "\\f").replace(/\r/g, "\\r").replace(/([\u0000-\u001f\u007f])/, (c) => "\\u" + numpad(4, c.codePointAt(0).toString(16)));
+    }
+    function stringifyMultilineString(str) {
+      let escaped = str.split(/\n/).map((str2) => {
+        return escapeString(str2).replace(/"(?="")/g, '\\"');
+      }).join("\n");
+      if (escaped.slice(-1) === '"') escaped += "\\\n";
+      return '"""\n' + escaped + '"""';
+    }
+    function stringifyAnyInline(value, multilineOk) {
+      let type = tomlType2(value);
+      if (type === "string") {
+        if (multilineOk && /\n/.test(value)) {
+          type = "string-multiline";
+        } else if (!/[\b\t\n\f\r']/.test(value) && /"/.test(value)) {
+          type = "string-literal";
+        }
+      }
+      return stringifyInline(value, type);
+    }
+    function stringifyInline(value, type) {
+      if (!type) type = tomlType2(value);
+      switch (type) {
+        case "string-multiline":
+          return stringifyMultilineString(value);
+        case "string":
+          return stringifyBasicString(value);
+        case "string-literal":
+          return stringifyLiteralString(value);
+        case "integer":
+          return stringifyInteger(value);
+        case "float":
+          return stringifyFloat(value);
+        case "boolean":
+          return stringifyBoolean(value);
+        case "datetime":
+          return stringifyDatetime(value);
+        case "array":
+          return stringifyInlineArray(value.filter((_) => tomlType2(_) !== "null" && tomlType2(_) !== "undefined" && tomlType2(_) !== "nan"));
+        case "table":
+          return stringifyInlineTable(value);
+        /* istanbul ignore next */
+        default:
+          throw typeError(type);
+      }
+    }
+    function stringifyInteger(value) {
+      return String(value).replace(/\B(?=(\d{3})+(?!\d))/g, "_");
+    }
+    function stringifyFloat(value) {
+      if (value === Infinity) {
+        return "inf";
+      } else if (value === -Infinity) {
+        return "-inf";
+      } else if (Object.is(value, NaN)) {
+        return "nan";
+      } else if (Object.is(value, -0)) {
+        return "-0.0";
+      }
+      var chunks = String(value).split(".");
+      var int = chunks[0];
+      var dec = chunks[1] || 0;
+      return stringifyInteger(int) + "." + dec;
+    }
+    function stringifyBoolean(value) {
+      return String(value);
+    }
+    function stringifyDatetime(value) {
+      return value.toISOString();
+    }
+    function isNumber(type) {
+      return type === "float" || type === "integer";
+    }
+    function arrayType(values) {
+      var contentType = tomlType2(values[0]);
+      if (values.every((_) => tomlType2(_) === contentType)) return contentType;
+      if (values.every((_) => isNumber(tomlType2(_)))) return "float";
+      return "mixed";
+    }
+    function validateArray(values) {
+      const type = arrayType(values);
+      if (type === "mixed") {
+        throw arrayOneTypeError();
+      }
+      return type;
+    }
+    function stringifyInlineArray(values) {
+      values = toJSON(values);
+      const type = validateArray(values);
+      var result = "[";
+      var stringified = values.map((_) => stringifyInline(_, type));
+      if (stringified.join(", ").length > 60 || /\n/.test(stringified)) {
+        result += "\n  " + stringified.join(",\n  ") + "\n";
+      } else {
+        result += " " + stringified.join(", ") + (stringified.length > 0 ? " " : "");
+      }
+      return result + "]";
+    }
+    function stringifyInlineTable(value) {
+      value = toJSON(value);
+      var result = [];
+      Object.keys(value).forEach((key) => {
+        result.push(stringifyKey(key) + " = " + stringifyAnyInline(value[key], false));
+      });
+      return "{ " + result.join(", ") + (result.length > 0 ? " " : "") + "}";
+    }
+    function stringifyComplex(prefix, indent, key, value) {
+      var valueType = tomlType2(value);
+      if (valueType === "array") {
+        return stringifyArrayOfTables(prefix, indent, key, value);
+      } else if (valueType === "table") {
+        return stringifyComplexTable(prefix, indent, key, value);
+      } else {
+        throw typeError(valueType);
+      }
+    }
+    function stringifyArrayOfTables(prefix, indent, key, values) {
+      values = toJSON(values);
+      validateArray(values);
+      var firstValueType = tomlType2(values[0]);
+      if (firstValueType !== "table") throw typeError(firstValueType);
+      var fullKey = prefix + stringifyKey(key);
+      var result = "";
+      values.forEach((table) => {
+        if (result.length > 0) result += "\n";
+        result += indent + "[[" + fullKey + "]]\n";
+        result += stringifyObject(fullKey + ".", indent, table);
+      });
+      return result;
+    }
+    function stringifyComplexTable(prefix, indent, key, value) {
+      var fullKey = prefix + stringifyKey(key);
+      var result = "";
+      if (getInlineKeys(value).length > 0) {
+        result += indent + "[" + fullKey + "]\n";
+      }
+      return result + stringifyObject(fullKey + ".", indent, value);
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/toml.js
+var require_toml = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/toml.js"(exports2) {
+    "use strict";
+    exports2.parse = require_parse();
+    exports2.stringify = require_stringify();
+  }
+});
+
+// src/daemon/index.ts
+var import_node_fs9 = require("fs");
+var import_node_path6 = require("path");
+
+// src/daemon/paths.ts
+var import_node_fs = require("fs");
+var import_node_os = require("os");
+var import_node_path = require("path");
+function canWriteSystemPaths() {
+  if (process.platform !== "linux") return false;
+  if (process.getuid && process.getuid() === 0) return true;
+  try {
+    if (!(0, import_node_fs.existsSync)("/etc/threatcrush")) return false;
+    (0, import_node_fs.mkdirSync)("/etc/threatcrush/.probe", { recursive: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var systemMode = canWriteSystemPaths();
+var userBase = (0, import_node_path.join)((0, import_node_os.homedir)(), ".threatcrush");
+var PATHS = systemMode ? {
+  mode: "system",
+  configDir: "/etc/threatcrush",
+  configFile: "/etc/threatcrush/threatcrushd.conf",
+  confD: "/etc/threatcrush/threatcrushd.conf.d",
+  moduleDir: "/etc/threatcrush/modules",
+  logDir: "/var/log/threatcrush",
+  logFile: "/var/log/threatcrush/threatcrushd.log",
+  stateDir: "/var/lib/threatcrush",
+  stateDb: "/var/lib/threatcrush/state.db",
+  runDir: "/var/run/threatcrush",
+  pidFile: "/var/run/threatcrush/threatcrushd.pid",
+  socket: "/var/run/threatcrush/threatcrushd.sock"
+} : {
+  mode: "user",
+  configDir: userBase,
+  configFile: (0, import_node_path.join)(userBase, "threatcrushd.conf"),
+  confD: (0, import_node_path.join)(userBase, "threatcrushd.conf.d"),
+  moduleDir: (0, import_node_path.join)(userBase, "modules"),
+  logDir: (0, import_node_path.join)(userBase, "logs"),
+  logFile: (0, import_node_path.join)(userBase, "logs", "threatcrushd.log"),
+  stateDir: (0, import_node_path.join)(userBase, "state"),
+  stateDb: (0, import_node_path.join)(userBase, "state", "state.db"),
+  runDir: (0, import_node_path.join)(userBase, "run"),
+  pidFile: (0, import_node_path.join)(userBase, "run", "threatcrushd.pid"),
+  socket: (0, import_node_path.join)(userBase, "run", "threatcrushd.sock")
+};
+function ensureRuntimeDirs() {
+  for (const dir of [PATHS.configDir, PATHS.confD, PATHS.moduleDir, PATHS.logDir, PATHS.stateDir, PATHS.runDir]) {
+    try {
+      (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+    } catch {
+    }
+  }
+}
+
+// src/daemon/pidfile.ts
+var import_node_fs2 = require("fs");
+function writePidFile() {
+  ensureRuntimeDirs();
+  (0, import_node_fs2.writeFileSync)(PATHS.pidFile, String(process.pid), "utf-8");
+}
+function readPidFile() {
+  if (!(0, import_node_fs2.existsSync)(PATHS.pidFile)) return null;
+  const raw = (0, import_node_fs2.readFileSync)(PATHS.pidFile, "utf-8").trim();
+  const pid = parseInt(raw, 10);
+  return Number.isFinite(pid) ? pid : null;
+}
+function removePidFile() {
+  try {
+    if ((0, import_node_fs2.existsSync)(PATHS.pidFile)) (0, import_node_fs2.unlinkSync)(PATHS.pidFile);
+  } catch {
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findRunningDaemon() {
+  const pid = readPidFile();
+  if (pid && isProcessAlive(pid)) return pid;
+  if (pid) removePidFile();
+  return null;
+}
+
+// src/daemon/ipc-server.ts
+var import_node_net = require("net");
+var import_node_fs3 = require("fs");
+
+// src/daemon/event-bus.ts
+var import_node_events = require("events");
+var EventBus = class extends import_node_events.EventEmitter {
+  publish(event) {
+    this.emit("event", event);
+    if (event.severity === "high" || event.severity === "critical") {
+      this.emit("alert", event);
+    }
+  }
+  announceModule(name, status, detail) {
+    this.emit("module", { name, status, detail });
+  }
+};
+var bus = new EventBus();
+bus.setMaxListeners(50);
+
+// src/core/state.ts
+var import_better_sqlite3 = __toESM(require("better-sqlite3"));
+var db = null;
+var dbUnavailable = false;
+function initStateDB(dbPath = "/var/lib/threatcrush/state.db") {
+  if (db) return db;
+  if (dbUnavailable) {
+    throw new Error("state db unavailable (previous init failed)");
+  }
+  try {
+    try {
+      db = new import_better_sqlite3.default(dbPath);
+    } catch {
+      db = new import_better_sqlite3.default(":memory:");
+    }
+  } catch (err) {
+    dbUnavailable = true;
+    throw err;
+  }
+  db.pragma("journal_mode = WAL");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      timestamp TEXT NOT NULL,
+      module TEXT NOT NULL,
+      category TEXT NOT NULL,
+      severity TEXT NOT NULL,
+      message TEXT NOT NULL,
+      source_ip TEXT,
+      details TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS module_state (
+      module TEXT NOT NULL,
+      key TEXT NOT NULL,
+      value TEXT,
+      PRIMARY KEY (module, key)
+    );
+
+    CREATE TABLE IF NOT EXISTS stats (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp);
+    CREATE INDEX IF NOT EXISTS idx_events_module ON events(module);
+    CREATE INDEX IF NOT EXISTS idx_events_severity ON events(severity);
+    CREATE INDEX IF NOT EXISTS idx_events_source_ip ON events(source_ip);
+  `);
+  return db;
+}
+function insertEvent(event) {
+  const database = tryDb();
+  if (!database) return -1;
+  const stmt = database.prepare(`
+    INSERT INTO events (timestamp, module, category, severity, message, source_ip, details)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `);
+  const result = stmt.run(
+    event.timestamp.toISOString(),
+    event.module,
+    event.category,
+    event.severity,
+    event.message,
+    event.source_ip || null,
+    event.details ? JSON.stringify(event.details) : null
+  );
+  return result.lastInsertRowid;
+}
+function tryDb() {
+  if (db) return db;
+  if (dbUnavailable) return null;
+  try {
+    return initStateDB();
+  } catch {
+    return null;
+  }
+}
+function getRecentEvents(limit = 50) {
+  const database = tryDb();
+  if (!database) return [];
+  const rows = database.prepare(`
+    SELECT * FROM events ORDER BY timestamp DESC LIMIT ?
+  `).all(limit);
+  return rows.map(rowToEvent);
+}
+function getEventCount(since) {
+  const database = tryDb();
+  if (!database) return 0;
+  if (since) {
+    return database.prepare(`SELECT COUNT(*) as count FROM events WHERE timestamp >= ?`).get(since.toISOString()).count;
+  }
+  return database.prepare(`SELECT COUNT(*) as count FROM events`).get().count;
+}
+function getThreatCount(since) {
+  const database = tryDb();
+  if (!database) return 0;
+  const severities = "('medium','high','critical')";
+  if (since) {
+    return database.prepare(
+      `SELECT COUNT(*) as count FROM events WHERE severity IN ${severities} AND timestamp >= ?`
+    ).get(since.toISOString()).count;
+  }
+  return database.prepare(
+    `SELECT COUNT(*) as count FROM events WHERE severity IN ${severities}`
+  ).get().count;
+}
+function getTopSources(limit = 10) {
+  const database = tryDb();
+  if (!database) return [];
+  return database.prepare(`
+    SELECT source_ip as ip, COUNT(*) as count FROM events
+    WHERE source_ip IS NOT NULL
+    GROUP BY source_ip ORDER BY count DESC LIMIT ?
+  `).all(limit);
+}
+function getModuleState(module2, key) {
+  const database = db || initStateDB();
+  const row = database.prepare(`SELECT value FROM module_state WHERE module = ? AND key = ?`).get(module2, key);
+  if (!row) return void 0;
+  try {
+    return JSON.parse(row.value);
+  } catch {
+    return row.value;
+  }
+}
+function setModuleState(module2, key, value) {
+  const database = db || initStateDB();
+  database.prepare(`
+    INSERT OR REPLACE INTO module_state (module, key, value) VALUES (?, ?, ?)
+  `).run(module2, key, JSON.stringify(value));
+}
+function rowToEvent(row) {
+  return {
+    id: row.id,
+    timestamp: new Date(row.timestamp),
+    module: row.module,
+    category: row.category,
+    severity: row.severity,
+    message: row.message,
+    source_ip: row.source_ip,
+    details: row.details ? JSON.parse(row.details) : void 0
+  };
+}
+function closeDB() {
+  if (db) {
+    db.close();
+    db = null;
+  }
+}
+
+// src/daemon/ipc-server.ts
+var IpcServer = class {
+  constructor(version, moduleHost) {
+    this.version = version;
+    this.moduleHost = moduleHost;
+    bus.on("event", (event) => {
+      this.counters.events++;
+      if (event.severity === "medium" || event.severity === "high" || event.severity === "critical") {
+        this.counters.threats++;
+      }
+      this.broadcast({ push: "event", payload: event }, "event");
+    });
+    bus.on("alert", () => {
+      this.counters.alerts++;
+    });
+    bus.on("module", (info) => {
+      this.broadcast({ push: "module", payload: info }, "module");
+    });
+  }
+  version;
+  moduleHost;
+  server = null;
+  clients = /* @__PURE__ */ new Map();
+  nextClientId = 1;
+  startedAt = /* @__PURE__ */ new Date();
+  counters = { events: 0, threats: 0, alerts: 0 };
+  async start() {
+    if ((0, import_node_fs3.existsSync)(PATHS.socket)) {
+      try {
+        (0, import_node_fs3.unlinkSync)(PATHS.socket);
+      } catch {
+      }
+    }
+    return new Promise((resolve, reject) => {
+      this.server = (0, import_node_net.createServer)((sock) => this.handleClient(sock));
+      this.server.on("error", reject);
+      this.server.listen(PATHS.socket, () => {
+        try {
+          require("fs").chmodSync(PATHS.socket, 432);
+        } catch {
+        }
+        resolve();
+      });
+    });
+  }
+  async stop() {
+    for (const c of this.clients.values()) {
+      try {
+        c.socket.destroy();
+      } catch {
+      }
+    }
+    this.clients.clear();
+    return new Promise((resolve) => {
+      if (!this.server) {
+        try {
+          if ((0, import_node_fs3.existsSync)(PATHS.socket)) (0, import_node_fs3.unlinkSync)(PATHS.socket);
+        } catch {
+        }
+        return resolve();
+      }
+      this.server.close(() => {
+        try {
+          if ((0, import_node_fs3.existsSync)(PATHS.socket)) (0, import_node_fs3.unlinkSync)(PATHS.socket);
+        } catch {
+        }
+        resolve();
+      });
+    });
+  }
+  handleClient(socket) {
+    const id = this.nextClientId++;
+    const state = { id, socket, buffer: "", subscriptions: /* @__PURE__ */ new Set() };
+    this.clients.set(id, state);
+    socket.setEncoding("utf-8");
+    socket.on("data", (chunk) => {
+      state.buffer += chunk.toString();
+      let idx;
+      while ((idx = state.buffer.indexOf("\n")) >= 0) {
+        const line = state.buffer.slice(0, idx);
+        state.buffer = state.buffer.slice(idx + 1);
+        if (!line.trim()) continue;
+        this.handleLine(state, line).catch((err) => {
+          this.send(state, { id: 0, ok: false, error: String(err?.message || err) });
+        });
+      }
+    });
+    socket.on("close", () => {
+      this.clients.delete(id);
+    });
+    socket.on("error", () => {
+      this.clients.delete(id);
+    });
+  }
+  async handleLine(client, line) {
+    let req;
+    try {
+      req = JSON.parse(line);
+    } catch {
+      return this.send(client, { id: 0, ok: false, error: "invalid json" });
+    }
+    switch (req.method) {
+      case "ping":
+        return this.send(client, { id: req.id, ok: true, result: "pong" });
+      case "status": {
+        const status = {
+          pid: process.pid,
+          startedAt: this.startedAt.toISOString(),
+          uptimeSeconds: Math.floor((Date.now() - this.startedAt.getTime()) / 1e3),
+          version: this.version,
+          mode: PATHS.mode,
+          paths: {
+            config: PATHS.configFile,
+            log: PATHS.logFile,
+            state: PATHS.stateDb,
+            socket: PATHS.socket
+          },
+          modules: this.moduleHost.summary(),
+          counters: { ...this.counters }
+        };
+        return this.send(client, { id: req.id, ok: true, result: status });
+      }
+      case "recent_events": {
+        const limit = req.params?.limit ?? 50;
+        const events = getRecentEvents(limit);
+        return this.send(client, { id: req.id, ok: true, result: events });
+      }
+      case "top_sources": {
+        const limit = req.params?.limit ?? 10;
+        return this.send(client, { id: req.id, ok: true, result: getTopSources(limit) });
+      }
+      case "counters": {
+        return this.send(client, {
+          id: req.id,
+          ok: true,
+          result: {
+            total: getEventCount(),
+            threats: getThreatCount(),
+            last24h: getEventCount(new Date(Date.now() - 864e5)),
+            threats24h: getThreatCount(new Date(Date.now() - 864e5))
+          }
+        });
+      }
+      case "module_list":
+        return this.send(client, { id: req.id, ok: true, result: this.moduleHost.summary() });
+      case "subscribe":
+        for (const ch of req.params.channels) client.subscriptions.add(ch);
+        return this.send(client, { id: req.id, ok: true, result: { subscribed: [...client.subscriptions] } });
+      case "shutdown":
+        this.send(client, { id: req.id, ok: true, result: "shutting down" });
+        setTimeout(() => process.emit("SIGTERM"), 50);
+        return;
+    }
+  }
+  send(client, msg) {
+    try {
+      client.socket.write(JSON.stringify(msg) + "\n");
+    } catch {
+    }
+  }
+  broadcast(msg, channel) {
+    for (const client of this.clients.values()) {
+      if (!client.subscriptions.has(channel)) continue;
+      this.send(client, msg);
+    }
+  }
+};
+
+// src/daemon/module-host.ts
+var import_node_fs6 = require("fs");
+var import_node_path3 = require("path");
+var import_node_url = require("url");
+var import_toml2 = __toESM(require_toml());
+
+// src/daemon/watchers/log-watcher.ts
+var import_node_fs4 = require("fs");
+var import_node_readline = require("readline");
+
+// src/core/log-parser.ts
+var NGINX_REGEX = /^(\S+) \S+ \S+ \[([^\]]+)\] "(\S+) (\S+) \S+" (\d{3}) (\d+) "[^"]*" "([^"]*)"/;
+var AUTH_REGEX = /^(\w+\s+\d+\s+[\d:]+)\s+\S+\s+(\S+?)(?:\[\d+\])?:\s+(.*)/;
+var SYSLOG_REGEX = /^(\w+\s+\d+\s+[\d:]+)\s+\S+\s+(\S+?)(?:\[\d+\])?:\s+(.*)/;
+var IP_REGEX = /(?:from|FROM)\s+(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})/;
+var USER_REGEX = /(?:for|user)\s+(\S+?)(?:\s+from|\s*$)/;
+var ATTACK_PATTERNS = {
+  sqli: [
+    /(?:union\s+(?:all\s+)?select)/i,
+    /(?:select\s+.*\s+from\s+)/i,
+    /(?:insert\s+into\s+)/i,
+    /(?:drop\s+(?:table|database))/i,
+    /(?:or\s+1\s*=\s*1)/i,
+    /(?:'\s*(?:or|and)\s+')/i,
+    /(?:--\s*$|;\s*--)/,
+    /(?:\/\*.*\*\/)/
+  ],
+  xss: [
+    /<script[^>]*>/i,
+    /javascript\s*:/i,
+    /on(?:load|error|click|mouseover)\s*=/i,
+    /eval\s*\(/i,
+    /document\.(?:cookie|write|location)/i
+  ],
+  path_traversal: [
+    /\.\.\//,
+    /\.\.\\/,
+    /etc\/(?:passwd|shadow|hosts)/,
+    /proc\/self/,
+    /windows\/system32/i
+  ],
+  rfi: [
+    /(?:https?|ftp):\/\/.*\?/i,
+    /php:\/\/(?:input|filter)/i,
+    /data:\/\//i
+  ]
+};
+function parseNginxLog(line) {
+  const match = line.match(NGINX_REGEX);
+  if (!match) return null;
+  return {
+    timestamp: parseNginxTimestamp(match[2]),
+    raw: line,
+    source: "nginx",
+    fields: {
+      ip: match[1],
+      method: match[3],
+      path: match[4],
+      status: match[5],
+      size: match[6],
+      user_agent: match[7]
+    }
+  };
+}
+function parseAuthLog(line) {
+  const match = line.match(AUTH_REGEX);
+  if (!match) return null;
+  const ipMatch = match[3].match(IP_REGEX);
+  const userMatch = match[3].match(USER_REGEX);
+  return {
+    timestamp: parseSyslogTimestamp(match[1]),
+    raw: line,
+    source: "auth",
+    fields: {
+      process: match[2],
+      message: match[3],
+      ip: ipMatch?.[1],
+      user: userMatch?.[1]
+    }
+  };
+}
+function parseSyslog(line) {
+  const match = line.match(SYSLOG_REGEX);
+  if (!match) return null;
+  return {
+    timestamp: parseSyslogTimestamp(match[1]),
+    raw: line,
+    source: "syslog",
+    fields: {
+      facility: "syslog",
+      process: match[2],
+      message: match[3]
+    }
+  };
+}
+function detectAttackPattern(path) {
+  for (const [type, patterns] of Object.entries(ATTACK_PATTERNS)) {
+    for (const pattern of patterns) {
+      if (pattern.test(path)) {
+        return type;
+      }
+    }
+  }
+  return null;
+}
+function autoDetectParser(line) {
+  const nginx = parseNginxLog(line);
+  if (nginx) return nginx;
+  const auth = parseAuthLog(line);
+  if (auth) return auth;
+  return parseSyslog(line);
+}
+function parseNginxTimestamp(s) {
+  try {
+    const cleaned = s.replace(/(\d{2})\/(\w{3})\/(\d{4}):/, "$2 $1, $3 ");
+    return new Date(cleaned);
+  } catch {
+    return /* @__PURE__ */ new Date();
+  }
+}
+function parseSyslogTimestamp(s) {
+  try {
+    const withYear = `${s} ${(/* @__PURE__ */ new Date()).getFullYear()}`;
+    return new Date(withYear);
+  } catch {
+    return /* @__PURE__ */ new Date();
+  }
+}
+
+// src/daemon/watchers/log-watcher.ts
+var DEFAULT_SOURCES = [
+  { path: "/var/log/auth.log", module: "ssh-guard", category: "auth" },
+  { path: "/var/log/secure", module: "ssh-guard", category: "auth" },
+  { path: "/var/log/nginx/access.log", module: "log-watcher", category: "web" },
+  { path: "/var/log/syslog", module: "log-watcher", category: "system" }
+];
+var LogWatcher = class {
+  constructor(bus2, sources = DEFAULT_SOURCES) {
+    this.bus = bus2;
+    this.sources = sources;
+  }
+  bus;
+  sources;
+  timers = /* @__PURE__ */ new Map();
+  positions = /* @__PURE__ */ new Map();
+  active = /* @__PURE__ */ new Set();
+  start() {
+    const started = [];
+    for (const src of this.sources) {
+      if (!(0, import_node_fs4.existsSync)(src.path)) continue;
+      try {
+        (0, import_node_fs4.accessSync)(src.path, import_node_fs4.constants.R_OK);
+      } catch {
+        continue;
+      }
+      this.tail(src);
+      started.push(src.path);
+    }
+    return started;
+  }
+  stop() {
+    for (const t of this.timers.values()) clearInterval(t);
+    this.timers.clear();
+    this.positions.clear();
+    this.active.clear();
+  }
+  activeModules() {
+    return [...this.active];
+  }
+  tail(src) {
+    try {
+      this.positions.set(src.path, (0, import_node_fs4.statSync)(src.path).size);
+    } catch {
+      this.positions.set(src.path, 0);
+    }
+    const timer = setInterval(() => this.poll(src), 1e3);
+    this.timers.set(src.path, timer);
+    this.active.add(src.module);
+  }
+  poll(src) {
+    let stat;
+    try {
+      stat = (0, import_node_fs4.statSync)(src.path);
+    } catch {
+      return;
+    }
+    const prev = this.positions.get(src.path) ?? 0;
+    if (stat.size < prev) {
+      this.positions.set(src.path, 0);
+      return;
+    }
+    if (stat.size === prev) return;
+    const stream = (0, import_node_fs4.createReadStream)(src.path, { start: prev, encoding: "utf-8" });
+    stream.on("error", () => this.positions.set(src.path, stat.size));
+    const rl = (0, import_node_readline.createInterface)({ input: stream });
+    rl.on("error", () => {
+    });
+    rl.on("line", (line) => {
+      if (!line.trim()) return;
+      this.process(line, src);
+    });
+    rl.on("close", () => this.positions.set(src.path, stat.size));
+  }
+  process(line, src) {
+    const parsed = autoDetectParser(line);
+    if (!parsed) return;
+    let severity = "info";
+    let message = line;
+    let sourceIp;
+    if (parsed.source === "auth") {
+      const entry = parseAuthLog(line);
+      if (!entry) return;
+      sourceIp = entry.fields.ip;
+      const msg = entry.fields.message;
+      if (/failed password/i.test(msg)) {
+        severity = "high";
+        message = `Failed SSH login for ${entry.fields.user || "unknown"} from ${entry.fields.ip || "unknown"}`;
+      } else if (/invalid user/i.test(msg)) {
+        severity = "high";
+        message = `Invalid SSH user: ${entry.fields.user || "unknown"} from ${entry.fields.ip || "unknown"}`;
+      } else if (/accepted/i.test(msg)) {
+        severity = "info";
+        message = `SSH login accepted for ${entry.fields.user || "unknown"}`;
+      } else {
+        return;
+      }
+    } else if (parsed.source === "nginx") {
+      const entry = parseNginxLog(line);
+      if (!entry) return;
+      sourceIp = entry.fields.ip;
+      const status = parseInt(entry.fields.status, 10);
+      const attack = detectAttackPattern(entry.fields.path);
+      if (attack) {
+        severity = "critical";
+        message = `Attack [${attack.toUpperCase()}]: ${entry.fields.method} ${entry.fields.path}`;
+      } else if (status >= 500) {
+        severity = "medium";
+        message = `Server error ${status}: ${entry.fields.method} ${entry.fields.path}`;
+      } else if (status >= 400) {
+        severity = "low";
+        message = `Client error ${status}: ${entry.fields.method} ${entry.fields.path}`;
+      } else {
+        return;
+      }
+    } else {
+      return;
+    }
+    const event = {
+      timestamp: /* @__PURE__ */ new Date(),
+      module: src.module,
+      category: src.category,
+      severity,
+      message,
+      source_ip: sourceIp
+    };
+    try {
+      insertEvent(event);
+    } catch {
+    }
+    this.bus.publish(event);
+  }
+};
+
+// src/daemon/watchers/journal-watcher.ts
+var import_node_child_process = require("child_process");
+var JournalWatcher = class _JournalWatcher {
+  constructor(bus2) {
+    this.bus = bus2;
+  }
+  bus;
+  proc = null;
+  buffer = "";
+  moduleName = "user-journal";
+  active = false;
+  static isAvailable() {
+    const probe = (0, import_node_child_process.spawnSync)("journalctl", ["--user", "-n", "0", "--no-pager"], {
+      stdio: ["ignore", "ignore", "ignore"]
+    });
+    return probe.status === 0;
+  }
+  start() {
+    if (!_JournalWatcher.isAvailable()) return false;
+    const child = (0, import_node_child_process.spawn)(
+      "journalctl",
+      ["--user", "-o", "json", "-f", "--since", "now"],
+      { stdio: ["ignore", "pipe", "pipe"] }
+    );
+    if (!child.stdout) return false;
+    child.stdout.setEncoding("utf-8");
+    child.stdout.on("data", (chunk) => this.onData(chunk));
+    child.on("exit", () => {
+      this.proc = null;
+      this.active = false;
+    });
+    this.proc = child;
+    this.active = true;
+    return true;
+  }
+  stop() {
+    if (this.proc) {
+      try {
+        this.proc.kill("SIGTERM");
+      } catch {
+      }
+      this.proc = null;
+    }
+    this.active = false;
+  }
+  isActive() {
+    return this.active;
+  }
+  moduleNameValue() {
+    return this.moduleName;
+  }
+  onData(chunk) {
+    this.buffer += chunk;
+    let idx;
+    while ((idx = this.buffer.indexOf("\n")) >= 0) {
+      const line = this.buffer.slice(0, idx);
+      this.buffer = this.buffer.slice(idx + 1);
+      if (!line.trim()) continue;
+      this.handleLine(line);
+    }
+  }
+  handleLine(line) {
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      return;
+    }
+    const message = entry.MESSAGE;
+    if (!message) return;
+    const priority = parseInt(entry.PRIORITY ?? "6", 10);
+    const severity = priorityToSeverity(priority);
+    const ident = entry.SYSLOG_IDENTIFIER || entry._COMM || "journal";
+    const bumpedSeverity = bumpForIdent(ident, message, severity);
+    const event = {
+      timestamp: realtimeToDate(entry.__REALTIME_TIMESTAMP) || /* @__PURE__ */ new Date(),
+      module: this.moduleName,
+      category: "system",
+      severity: bumpedSeverity,
+      message: `[${ident}] ${message}`.slice(0, 500)
+    };
+    try {
+      insertEvent(event);
+    } catch {
+    }
+    this.bus.publish(event);
+  }
+};
+function priorityToSeverity(priority) {
+  if (priority <= 2) return "critical";
+  if (priority === 3) return "high";
+  if (priority === 4) return "medium";
+  if (priority === 5) return "low";
+  return "info";
+}
+function bumpForIdent(ident, message, base) {
+  if (/sudo/i.test(ident) && /authentication failure|incorrect password|FAILED/i.test(message)) {
+    return "high";
+  }
+  if (/sshd/i.test(ident) && /failed|invalid user|break-in/i.test(message)) {
+    return "high";
+  }
+  return base;
+}
+function realtimeToDate(rt) {
+  if (!rt) return null;
+  const us = parseInt(rt, 10);
+  if (!Number.isFinite(us)) return null;
+  return new Date(Math.floor(us / 1e3));
+}
+
+// src/core/config.ts
+var import_node_fs5 = require("fs");
+var import_node_path2 = require("path");
+var import_toml = __toESM(require_toml());
+var DEFAULT_CONFIG_PATH = "/etc/threatcrush/threatcrushd.conf";
+var DEFAULT_CONFDIR = "/etc/threatcrush/threatcrushd.conf.d";
+var DEFAULT_CONFIG = {
+  daemon: {
+    pid_file: "/var/run/threatcrush/threatcrushd.pid",
+    log_level: "info",
+    log_file: "/var/log/threatcrush/threatcrushd.log",
+    state_db: "/var/lib/threatcrush/state.db"
+  },
+  api: {
+    enabled: true,
+    bind: "127.0.0.1:9393",
+    tls: false
+  },
+  alerts: {},
+  modules: {
+    auto_update: true,
+    update_interval: "24h",
+    module_dir: "/etc/threatcrush/modules",
+    config_dir: DEFAULT_CONFDIR
+  }
+};
+function loadConfig(configPath) {
+  const path = configPath || DEFAULT_CONFIG_PATH;
+  if (!(0, import_node_fs5.existsSync)(path)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const raw = (0, import_node_fs5.readFileSync)(path, "utf-8");
+    const parsed = import_toml.default.parse(raw);
+    return {
+      daemon: { ...DEFAULT_CONFIG.daemon, ...parsed.daemon },
+      api: { ...DEFAULT_CONFIG.api, ...parsed.api },
+      alerts: parsed.alerts || {},
+      modules: { ...DEFAULT_CONFIG.modules, ...parsed.modules },
+      license: parsed.license
+    };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function loadModuleConfigs(confDir) {
+  const dir = confDir || DEFAULT_CONFDIR;
+  const configs = /* @__PURE__ */ new Map();
+  if (!(0, import_node_fs5.existsSync)(dir)) {
+    return configs;
+  }
+  const files = (0, import_node_fs5.readdirSync)(dir).filter((f) => f.endsWith(".conf"));
+  for (const file of files) {
+    try {
+      const raw = (0, import_node_fs5.readFileSync)((0, import_node_path2.join)(dir, file), "utf-8");
+      const parsed = import_toml.default.parse(raw);
+      for (const [name, config] of Object.entries(parsed)) {
+        configs.set(name, config);
+      }
+    } catch {
+    }
+  }
+  return configs;
+}
+
+// src/daemon/module-host.ts
+var ModuleHost = class {
+  constructor(bus2) {
+    this.bus = bus2;
+    bus2.on("event", (event) => {
+      const mod = this.modules.get(event.module);
+      if (mod) mod.events++;
+      for (const hosted of this.modules.values()) {
+        if (hosted.status !== "running" || !hosted.instance?.onEvent) continue;
+        void hosted.instance.onEvent(event).catch((err) => {
+          hosted.status = "error";
+          hosted.detail = `onEvent failed: ${String(err.message || err)}`;
+          this.bus.announceModule(hosted.name, "error", hosted.detail);
+        });
+      }
+    });
+  }
+  bus;
+  modules = /* @__PURE__ */ new Map();
+  logWatcher = null;
+  journalWatcher = null;
+  async start() {
+    this.registerBuiltins();
+    await this.discoverAndStartInstalled();
+    this.logWatcher = new LogWatcher(this.bus);
+    const watched = this.logWatcher.start();
+    for (const modName of this.logWatcher.activeModules()) {
+      const mod = this.modules.get(modName);
+      if (mod) {
+        mod.status = "running";
+        mod.detail = `watching ${watched.length} log source(s)`;
+        this.bus.announceModule(modName, "running", mod.detail);
+      }
+    }
+    this.journalWatcher = new JournalWatcher(this.bus);
+    if (this.journalWatcher.start()) {
+      const mod = this.modules.get("user-journal");
+      if (mod) {
+        mod.status = "running";
+        mod.detail = "tailing journalctl --user";
+        this.bus.announceModule("user-journal", "running", mod.detail);
+      }
+    }
+  }
+  async stop() {
+    this.logWatcher?.stop();
+    this.journalWatcher?.stop();
+    for (const mod of this.modules.values()) {
+      try {
+        if (mod.instance && mod.status === "running") {
+          await mod.instance.stop();
+        }
+      } catch (err) {
+        mod.status = "error";
+        mod.detail = `stop failed: ${String(err.message || err)}`;
+        this.bus.announceModule(mod.name, "error", mod.detail);
+        continue;
+      }
+      mod.status = "loaded";
+      this.bus.announceModule(mod.name, "stopped");
+    }
+  }
+  summary() {
+    return [...this.modules.values()].map((m) => ({
+      name: m.name,
+      status: m.status,
+      events: m.events,
+      detail: m.detail
+    }));
+  }
+  registerBuiltins() {
+    const builtins = [
+      { name: "log-watcher", version: "0.1.0", source: "builtin", status: "loaded", events: 0 },
+      { name: "ssh-guard", version: "0.1.0", source: "builtin", status: "loaded", events: 0 },
+      { name: "user-journal", version: "0.1.0", source: "builtin", status: "loaded", events: 0 }
+    ];
+    for (const m of builtins) this.modules.set(m.name, m);
+  }
+  async discoverAndStartInstalled() {
+    if (!(0, import_node_fs6.existsSync)(PATHS.moduleDir)) return;
+    const configs = loadModuleConfigs(PATHS.confD);
+    const entries = (0, import_node_fs6.readdirSync)(PATHS.moduleDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const manifestPath = (0, import_node_path3.join)(PATHS.moduleDir, entry.name, "mod.toml");
+      if (!(0, import_node_fs6.existsSync)(manifestPath)) continue;
+      try {
+        const manifest = import_toml2.default.parse((0, import_node_fs6.readFileSync)(manifestPath, "utf-8"));
+        const name = manifest.module?.name || entry.name;
+        const defaults = manifest.module?.config?.defaults || {};
+        const config = {
+          enabled: true,
+          ...defaults,
+          ...configs.get(name) || {}
+        };
+        const hosted = {
+          name,
+          version: manifest.module?.version || "0.0.0",
+          source: "installed",
+          status: config.enabled === false ? "disabled" : "loaded",
+          events: 0,
+          path: (0, import_node_path3.join)(PATHS.moduleDir, entry.name),
+          config
+        };
+        this.modules.set(name, hosted);
+        if (config.enabled === false) continue;
+        await this.startInstalled(hosted);
+      } catch (err) {
+        const name = entry.name;
+        this.modules.set(name, {
+          name,
+          version: "0.0.0",
+          source: "installed",
+          status: "error",
+          events: 0,
+          detail: `manifest load failed: ${String(err.message || err)}`,
+          path: (0, import_node_path3.join)(PATHS.moduleDir, entry.name)
+        });
+      }
+    }
+  }
+  async startInstalled(hosted) {
+    const entrypoint = this.installedEntrypoint(hosted.path);
+    if (!entrypoint) {
+      hosted.status = "loaded";
+      hosted.detail = "no built entrypoint found; run npm install && npm run build in the module directory";
+      return;
+    }
+    try {
+      const imported = await import((0, import_node_url.pathToFileURL)(entrypoint).href);
+      const exported = imported.default || imported.module || imported;
+      const instance = typeof exported === "function" ? new exported() : exported;
+      if (!this.isThreatCrushModule(instance)) {
+        throw new Error("entrypoint does not export a ThreatCrush module");
+      }
+      hosted.instance = instance;
+      await instance.init(this.contextFor(hosted));
+      await instance.start();
+      hosted.status = "running";
+      hosted.detail = `started from ${entrypoint}`;
+      this.bus.announceModule(hosted.name, "running", hosted.detail);
+    } catch (err) {
+      hosted.status = "error";
+      hosted.detail = String(err.message || err);
+      this.bus.announceModule(hosted.name, "error", hosted.detail);
+    }
+  }
+  installedEntrypoint(modulePath) {
+    const packageJson = (0, import_node_path3.join)(modulePath, "package.json");
+    const candidates = [];
+    if ((0, import_node_fs6.existsSync)(packageJson)) {
+      try {
+        const pkg = JSON.parse((0, import_node_fs6.readFileSync)(packageJson, "utf-8"));
+        if (pkg.main) candidates.push((0, import_node_path3.join)(modulePath, pkg.main));
+      } catch {
+      }
+    }
+    candidates.push((0, import_node_path3.join)(modulePath, "dist", "index.js"), (0, import_node_path3.join)(modulePath, "index.js"));
+    return candidates.find((candidate) => (0, import_node_fs6.existsSync)(candidate)) || null;
+  }
+  isThreatCrushModule(value) {
+    return Boolean(
+      value && typeof value === "object" && typeof value.init === "function" && typeof value.start === "function" && typeof value.stop === "function"
+    );
+  }
+  contextFor(hosted) {
+    return {
+      config: hosted.config || { enabled: true },
+      logger: this.loggerFor(hosted.name),
+      emit: (event) => this.bus.publish(event),
+      subscribe: (eventType, handler) => {
+        this.bus.on("event", (event) => {
+          if (event.category === eventType || event.module === eventType) handler(event);
+        });
+      },
+      alert: (alert) => {
+        this.bus.emit("alert", alert.event || {
+          timestamp: /* @__PURE__ */ new Date(),
+          module: hosted.name,
+          category: "system",
+          severity: alert.severity,
+          message: alert.title,
+          details: alert.body ? { body: alert.body } : void 0
+        });
+      },
+      getState: (key) => getModuleState(hosted.name, key),
+      setState: (key, value) => setModuleState(hosted.name, key, value)
+    };
+  }
+  loggerFor(moduleName) {
+    return {
+      debug: (msg, ...args) => console.debug(`[${moduleName}] ${msg}`, ...args),
+      info: (msg, ...args) => console.info(`[${moduleName}] ${msg}`, ...args),
+      warn: (msg, ...args) => console.warn(`[${moduleName}] ${msg}`, ...args),
+      error: (msg, ...args) => console.error(`[${moduleName}] ${msg}`, ...args)
+    };
+  }
+};
+
+// src/daemon/alerts/smtp.ts
+var transporter = null;
+var nodemailer = null;
+var SEVERITY_RANK = {
+  info: 0,
+  low: 1,
+  medium: 2,
+  high: 3,
+  critical: 4
+};
+async function ensureTransporter(config) {
+  if (!config.host || !config.from) return null;
+  if (transporter) return transporter;
+  if (!nodemailer) {
+    try {
+      nodemailer = await import("nodemailer");
+    } catch {
+      return null;
+    }
+  }
+  transporter = nodemailer.createTransport({
+    host: config.host,
+    port: config.port ?? 587,
+    secure: config.secure ?? false,
+    auth: config.user && config.pass ? { user: config.user, pass: config.pass } : void 0
+  });
+  return transporter;
+}
+function meetsSeverity(event, min) {
+  if (!min) return true;
+  return (SEVERITY_RANK[event.severity] ?? 0) >= (SEVERITY_RANK[min] ?? 0);
+}
+function renderBody(event) {
+  const ts = event.timestamp.toISOString();
+  const ip = event.source_ip ? `
+Source IP: ${event.source_ip}` : "";
+  const text = `[${event.severity.toUpperCase()}] ${event.module}
+
+${event.message}${ip}
+
+When: ${ts}
+Category: ${event.category}`;
+  const html = `<div style="font-family:system-ui,sans-serif;line-height:1.5"><h2 style="margin:0 0 8px">\u26A0 ${event.severity.toUpperCase()} \u2014 ${event.module}</h2><p>${event.message}</p>` + (event.source_ip ? `<p><strong>Source IP:</strong> <code>${event.source_ip}</code></p>` : "") + `<p style="color:#888;margin-top:16px"><small>${ts} \xB7 ${event.category}</small></p></div>`;
+  return { text, html };
+}
+function smtpChannel(config) {
+  return async (event) => {
+    if (!meetsSeverity(event, config.min_severity)) return;
+    const t = await ensureTransporter(config);
+    if (!t) return;
+    const to = Array.isArray(config.to) ? config.to.join(", ") : config.to;
+    if (!to) return;
+    const { text, html } = renderBody(event);
+    await t.sendMail({
+      from: config.from,
+      to,
+      subject: `[ThreatCrush ${event.severity}] ${event.module} \u2014 ${event.message.slice(0, 60)}`,
+      text,
+      html
+    });
+  };
+}
+
+// src/daemon/alerts/index.ts
+var AlertDispatcher = class {
+  constructor(bus2, config) {
+    this.bus = bus2;
+    this.config = config;
+    this.bindChannels();
+    bus2.on("alert", (event) => {
+      void this.dispatch(event);
+    });
+  }
+  bus;
+  config;
+  channels = [];
+  bindChannels() {
+    const alerts = this.config.alerts || {};
+    for (const [name, raw] of Object.entries(alerts)) {
+      const cfg = raw;
+      if (!cfg.enabled) continue;
+      if (name === "webhook" && typeof cfg.url === "string") {
+        this.channels.push(webhookChannel(cfg.url, cfg.secret));
+      }
+      if (name === "slack" && typeof cfg.webhook_url === "string") {
+        this.channels.push(slackChannel(cfg.webhook_url));
+      }
+      if (name === "email" && typeof cfg.host === "string" && typeof cfg.from === "string") {
+        this.channels.push(smtpChannel(cfg));
+      }
+    }
+  }
+  async dispatch(event) {
+    await Promise.all(this.channels.map((ch) => ch(event).catch(() => {
+    })));
+  }
+};
+function webhookChannel(url, secret) {
+  return async (event) => {
+    const body = JSON.stringify({ event });
+    const headers = { "Content-Type": "application/json" };
+    if (secret) headers["X-Threatcrush-Signature"] = secret;
+    await fetch(url, { method: "POST", headers, body });
+  };
+}
+function slackChannel(webhookUrl) {
+  return async (event) => {
+    const emoji = event.severity === "critical" ? ":rotating_light:" : ":warning:";
+    const text = `${emoji} *[${event.severity.toUpperCase()}]* \`${event.module}\` \u2014 ${event.message}${event.source_ip ? ` (from ${event.source_ip})` : ""}`;
+    await fetch(webhookUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ text })
+    });
+  };
+}
+
+// src/core/cli-config.ts
+var import_node_fs7 = require("fs");
+var import_node_path4 = require("path");
+var import_node_os2 = require("os");
+var CLI_CONFIG_DIR = (0, import_node_path4.join)((0, import_node_os2.homedir)(), ".threatcrush");
+var CLI_CONFIG_PATH = (0, import_node_path4.join)(CLI_CONFIG_DIR, "config.json");
+function readCliConfig() {
+  try {
+    return JSON.parse((0, import_node_fs7.readFileSync)(CLI_CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function isLoggedIn() {
+  const cfg = readCliConfig();
+  if (!cfg.token) return false;
+  if (cfg.expires_at && cfg.expires_at * 1e3 < Date.now()) return false;
+  return true;
+}
+function authHeaders() {
+  const cfg = readCliConfig();
+  const headers = { "Content-Type": "application/json" };
+  if (cfg.token) headers["Authorization"] = `Bearer ${cfg.token}`;
+  return headers;
+}
+
+// src/commands/scan.ts
+var import_node_fs8 = require("fs");
+var import_node_path5 = require("path");
+
+// ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+var styles = {
+  modifier: {
+    reset: [0, 0],
+    // 21 isn't widely supported and 22 does the same thing
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    // Bright color
+    blackBright: [90, 39],
+    gray: [90, 39],
+    // Alias of `blackBright`
+    grey: [90, 39],
+    // Alias of `blackBright`
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    // Bright color
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    // Alias of `bgBlackBright`
+    bgGrey: [100, 49],
+    // Alias of `bgBlackBright`
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
+  }
+};
+var modifierNames = Object.keys(styles.modifier);
+var foregroundColorNames = Object.keys(styles.color);
+var backgroundColorNames = Object.keys(styles.bgColor);
+var colorNames = [...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = /* @__PURE__ */ new Map();
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          /* eslint-disable no-bitwise */
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+var ansiStyles = assembleStyles();
+var ansi_styles_default = ansiStyles;
+
+// ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/supports-color/index.js
+var import_node_process = __toESM(require("process"), 1);
+var import_node_os3 = __toESM(require("os"), 1);
+var import_node_tty = __toESM(require("tty"), 1);
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : import_node_process.default.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+var { env } = import_node_process.default;
+var flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+  flagForceColor = 0;
+} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+  flagForceColor = 1;
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== void 0) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === void 0) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (import_node_process.default.platform === "win32") {
+    const osRelease = import_node_os3.default.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
+      return 3;
+    }
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var supportsColor = {
+  stdout: createSupportsColor({ isTTY: import_node_tty.default.isatty(1) }),
+  stderr: createSupportsColor({ isTTY: import_node_tty.default.isatty(2) })
+};
+var supports_color_default = supportsColor;
+
+// ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    endIndex = index + 1;
+    index = string.indexOf("\n", endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+
+// ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/index.js
+var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
+var GENERATOR = /* @__PURE__ */ Symbol("GENERATOR");
+var STYLER = /* @__PURE__ */ Symbol("STYLER");
+var IS_EMPTY = /* @__PURE__ */ Symbol("IS_EMPTY");
+var levelMapping = [
+  "ansi",
+  "ansi",
+  "ansi256",
+  "ansi16m"
+];
+var styles2 = /* @__PURE__ */ Object.create(null);
+var applyOptions = (object, options = {}) => {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+    throw new Error("The `level` option should be an integer from 0 to 3");
+  }
+  const colorLevel = stdoutColor ? stdoutColor.level : 0;
+  object.level = options.level === void 0 ? colorLevel : options.level;
+};
+var chalkFactory = (options) => {
+  const chalk2 = (...strings) => strings.join(" ");
+  applyOptions(chalk2, options);
+  Object.setPrototypeOf(chalk2, createChalk.prototype);
+  return chalk2;
+};
+function createChalk(options) {
+  return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+  styles2[styleName] = {
+    get() {
+      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+      Object.defineProperty(this, styleName, { value: builder });
+      return builder;
+    }
+  };
+}
+styles2.visible = {
+  get() {
+    const builder = createBuilder(this, this[STYLER], true);
+    Object.defineProperty(this, "visible", { value: builder });
+    return builder;
+  }
+};
+var getModelAnsi = (model, level, type, ...arguments_) => {
+  if (model === "rgb") {
+    if (level === "ansi16m") {
+      return ansi_styles_default[type].ansi16m(...arguments_);
+    }
+    if (level === "ansi256") {
+      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+    }
+    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+  }
+  if (model === "hex") {
+    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+  }
+  return ansi_styles_default[type][model](...arguments_);
+};
+var usedModels = ["rgb", "hex", "ansi256"];
+for (const model of usedModels) {
+  styles2[model] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+  styles2[bgModel] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+}
+var proto = Object.defineProperties(() => {
+}, {
+  ...styles2,
+  level: {
+    enumerable: true,
+    get() {
+      return this[GENERATOR].level;
+    },
+    set(level) {
+      this[GENERATOR].level = level;
+    }
+  }
+});
+var createStyler = (open, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === void 0) {
+    openAll = open;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open;
+    closeAll = close + parent.closeAll;
+  }
+  return {
+    open,
+    close,
+    openAll,
+    closeAll,
+    parent
+  };
+};
+var createBuilder = (self, _styler, _isEmpty) => {
+  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+  Object.setPrototypeOf(builder, proto);
+  builder[GENERATOR] = self;
+  builder[STYLER] = _styler;
+  builder[IS_EMPTY] = _isEmpty;
+  return builder;
+};
+var applyStyle = (self, string) => {
+  if (self.level <= 0 || !string) {
+    return self[IS_EMPTY] ? "" : string;
+  }
+  let styler = self[STYLER];
+  if (styler === void 0) {
+    return string;
+  }
+  const { openAll, closeAll } = styler;
+  if (string.includes("\x1B")) {
+    while (styler !== void 0) {
+      string = stringReplaceAll(string, styler.close, styler.open);
+      styler = styler.parent;
+    }
+  }
+  const lfIndex = string.indexOf("\n");
+  if (lfIndex !== -1) {
+    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+  }
+  return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles2);
+var chalk = createChalk();
+var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+var source_default = chalk;
+
+// src/core/logger.ts
+var SEVERITY_COLORS = {
+  info: source_default.green,
+  low: source_default.cyan,
+  medium: source_default.yellow,
+  high: source_default.red,
+  critical: source_default.bgRed.white.bold
+};
+var LEVEL_COLORS = {
+  debug: source_default.gray,
+  info: source_default.green,
+  warn: source_default.yellow,
+  error: source_default.red
+};
+
+// src/core/run-result.ts
+var import_node_os4 = __toESM(require("os"));
+function emptyCounts() {
+  return { critical: 0, high: 0, medium: 0, low: 0, info: 0 };
+}
+function summarize(findings) {
+  const counts = emptyCounts();
+  for (const f of findings) counts[f.severity] = (counts[f.severity] || 0) + 1;
+  return counts;
+}
+function workerId() {
+  return `${import_node_os4.default.hostname()}/${process.pid}`;
+}
+
+// src/commands/scan.ts
+var SECRET_PATTERNS = [
+  { name: "AWS Access Key", pattern: /(?:AKIA[0-9A-Z]{16})/g, severity: "critical" },
+  { name: "AWS Secret Key", pattern: /(?:aws_secret_access_key|AWS_SECRET)\s*[=:]\s*['"]?([A-Za-z0-9/+=]{40})['"]?/gi, severity: "critical" },
+  { name: "GitHub Token", pattern: /(?:ghp_[A-Za-z0-9]{36}|github_pat_[A-Za-z0-9_]{82})/g, severity: "critical" },
+  { name: "Generic API Key", pattern: /(?:api[_-]?key|apikey)\s*[=:]\s*['"]([A-Za-z0-9\-_]{20,})['"]?/gi, severity: "high" },
+  { name: "Generic Secret", pattern: /(?:secret|password|passwd|pwd)\s*[=:]\s*['"]([^'"]{8,})['"]?/gi, severity: "high" },
+  { name: "Private Key", pattern: /-----BEGIN (?:RSA |EC |DSA )?PRIVATE KEY-----/g, severity: "critical" },
+  { name: "JWT Token", pattern: /eyJ[A-Za-z0-9-_]+\.eyJ[A-Za-z0-9-_]+\.[A-Za-z0-9-_.+/=]*/g, severity: "high" },
+  { name: "Slack Token", pattern: /xox[bpors]-[A-Za-z0-9-]{10,}/g, severity: "critical" },
+  { name: "Stripe Key", pattern: /(?:sk_live_|pk_live_|sk_test_|pk_test_)[A-Za-z0-9]{20,}/g, severity: "critical" },
+  { name: "Database URL", pattern: /(?:postgres|mysql|mongodb|redis):\/\/[^\s'"]+/gi, severity: "high" },
+  { name: "Bearer Token", pattern: /Bearer\s+[A-Za-z0-9\-_\.]{20,}/g, severity: "medium" },
+  { name: "Hex Token (32+)", pattern: /(?:token|key|secret|auth)\s*[=:]\s*['"]?([0-9a-f]{32,})['"]?/gi, severity: "medium" }
+];
+var MISCONFIG_FILES = [
+  { pattern: ".env", message: ".env file found \u2014 may contain secrets" },
+  { pattern: ".env.local", message: ".env.local file found \u2014 may contain secrets" },
+  { pattern: ".env.production", message: ".env.production file found \u2014 may contain secrets" },
+  { pattern: "id_rsa", message: "Private SSH key found" },
+  { pattern: "id_ed25519", message: "Private SSH key found" },
+  { pattern: ".pem", message: "PEM certificate/key file found" },
+  { pattern: ".p12", message: "PKCS#12 keystore found" },
+  { pattern: ".keystore", message: "Keystore file found" }
+];
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  "dist",
+  "build",
+  "__pycache__",
+  ".venv",
+  "vendor",
+  ".terraform",
+  "coverage",
+  ".cache"
+]);
+var SCAN_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".js",
+  ".tsx",
+  ".jsx",
+  ".py",
+  ".rb",
+  ".go",
+  ".java",
+  ".php",
+  ".rs",
+  ".c",
+  ".cpp",
+  ".h",
+  ".yml",
+  ".yaml",
+  ".json",
+  ".toml",
+  ".ini",
+  ".cfg",
+  ".conf",
+  ".env",
+  ".sh",
+  ".bash",
+  ".tf",
+  ".hcl",
+  ".xml",
+  ".properties",
+  ".gradle"
+]);
+async function runScan(targetPath) {
+  const findings = [];
+  try {
+    scanDirectory(targetPath, targetPath, findings, () => {
+    });
+  } catch (err) {
+    return {
+      type: "scan",
+      target: targetPath,
+      findings: [],
+      severity_summary: { critical: 0, high: 0, medium: 0, low: 0, info: 0 },
+      summary: `Scan failed: ${err.message}`,
+      error: err.message
+    };
+  }
+  const structured = findings.map((f) => ({
+    type: f.type,
+    severity: f.severity,
+    message: f.message,
+    location: `${f.file}:${f.line}`,
+    details: { file: f.file, line: f.line, snippet: f.snippet }
+  }));
+  const summary = summarize(structured);
+  return {
+    type: "scan",
+    target: targetPath,
+    findings: structured,
+    severity_summary: summary,
+    summary: findings.length === 0 ? "No security issues found" : `${findings.length} issue(s): ${summary.critical}C ${summary.high}H ${summary.medium}M ${summary.low}L`
+  };
+}
+function scanDirectory(basePath, currentPath, findings, onFile) {
+  let entries;
+  try {
+    entries = (0, import_node_fs8.readdirSync)(currentPath, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = (0, import_node_path5.join)(currentPath, entry.name);
+    if (entry.isDirectory()) {
+      if (SKIP_DIRS.has(entry.name)) continue;
+      scanDirectory(basePath, fullPath, findings, onFile);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    for (const mc of MISCONFIG_FILES) {
+      if (entry.name === mc.pattern || entry.name.endsWith(mc.pattern)) {
+        findings.push({
+          file: (0, import_node_path5.relative)(basePath, fullPath),
+          line: 0,
+          type: "Sensitive File",
+          severity: "high",
+          message: mc.message,
+          snippet: ""
+        });
+      }
+    }
+    const ext = (0, import_node_path5.extname)(entry.name).toLowerCase();
+    if (!SCAN_EXTENSIONS.has(ext) && !entry.name.startsWith(".env")) continue;
+    try {
+      const stat = (0, import_node_fs8.statSync)(fullPath);
+      if (stat.size > 1024 * 1024) continue;
+    } catch {
+      continue;
+    }
+    onFile();
+    let content;
+    try {
+      content = (0, import_node_fs8.readFileSync)(fullPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.trim().startsWith("//") && !line.includes("password") && !line.includes("secret")) continue;
+      for (const pattern of SECRET_PATTERNS) {
+        pattern.pattern.lastIndex = 0;
+        if (pattern.pattern.test(line)) {
+          findings.push({
+            file: (0, import_node_path5.relative)(basePath, fullPath),
+            line: i + 1,
+            type: pattern.name,
+            severity: pattern.severity,
+            message: `Possible ${pattern.name} detected`,
+            snippet: line.length > 120 ? line.slice(0, 120) + "..." : line
+          });
+        }
+      }
+    }
+  }
+}
+
+// src/commands/pentest.ts
+var PENTEST_CHECKS = [
+  {
+    name: "XSS Reflected",
+    test: (html) => /<script>alert\(1\)<\/script>|<img\s+src=x\s+onerror=alert/i.test(html),
+    severity: "critical",
+    message: "Reflected XSS payload rendered in response"
+  },
+  {
+    name: "Open Redirect",
+    test: (url, body) => body.includes("location.href") || body.includes("window.location"),
+    severity: "medium",
+    message: "Potential open redirect detected"
+  },
+  {
+    name: "Missing Security Headers",
+    test: (_url, _body, headers) => {
+      const required = ["x-content-type-options", "x-frame-options", "strict-transport-security"];
+      const missing = required.filter((h) => !headers[h.toLowerCase()]);
+      return missing.length > 2;
+    },
+    severity: "low",
+    message: "Missing critical security headers (X-Content-Type-Options, X-Frame-Options, HSTS)"
+  },
+  {
+    name: "Server Version Disclosure",
+    test: (_url, _body, headers) => {
+      return !!(headers["server"] && /apache|nginx|iis|tomcat/i.test(headers["server"]));
+    },
+    severity: "low",
+    message: "Server version disclosed in response header"
+  },
+  {
+    name: "Directory Listing",
+    test: (html) => /Index of\s*\/|<title>Directory Listing/i.test(html),
+    severity: "medium",
+    message: "Directory listing enabled"
+  },
+  {
+    name: "Error Page Information Disclosure",
+    test: (html) => /stack trace|traceback|exception|at\s+\w+\.\w+\(/i.test(html),
+    severity: "medium",
+    message: "Error page reveals internal information"
+  }
+];
+async function runPentest(rawUrl) {
+  const targetUrl = rawUrl.startsWith("http") ? rawUrl : `https://${rawUrl}`;
+  const results = await collectPentestResults(targetUrl);
+  const structured = results.map((r) => ({
+    type: r.type,
+    severity: r.severity === "low" ? "low" : r.severity,
+    message: r.message,
+    location: r.url,
+    details: r.details ? { detail: r.details } : void 0
+  }));
+  const counts = summarize(structured);
+  return {
+    type: "pentest",
+    target: targetUrl,
+    findings: structured,
+    severity_summary: counts,
+    summary: structured.length === 0 ? "No vulnerabilities detected" : `${structured.length} issue(s): ${counts.critical}C ${counts.high}H ${counts.medium}M ${counts.low}L`
+  };
+}
+async function collectPentestResults(targetUrl) {
+  const results = [];
+  try {
+    const resp = await fetch(targetUrl, { redirect: "manual" });
+    const headers = {};
+    resp.headers.forEach((v, k) => {
+      headers[k] = v;
+    });
+    const body = await resp.text();
+    for (const check of PENTEST_CHECKS) {
+      try {
+        if (check.test(body, body, headers)) {
+          results.push({ url: targetUrl, type: check.name, severity: check.severity, message: check.message });
+        }
+      } catch {
+      }
+    }
+  } catch {
+    return results;
+  }
+  const sqliPayloads = ["' OR 1=1--", "1' UNION SELECT NULL--", "' AND '1'='1"];
+  for (const payload of sqliPayloads) {
+    try {
+      const testUrl = `${targetUrl}?id=${encodeURIComponent(payload)}`;
+      const resp = await fetch(testUrl, { redirect: "manual", signal: AbortSignal.timeout(5e3) });
+      const body = await resp.text();
+      if (/sql\s+(syntax|error|exception)|mysql|postgres|ORA-\d+/i.test(body)) {
+        results.push({ url: testUrl, type: "SQL Injection", severity: "critical", message: `SQL error with payload: ${payload}` });
+      }
+    } catch {
+    }
+  }
+  const traversalPaths = ["../../etc/passwd", "..%2F..%2Fetc%2Fpasswd", "....//....//etc/passwd"];
+  for (const path of traversalPaths) {
+    try {
+      const testUrl = `${targetUrl}/${path}`;
+      const resp = await fetch(testUrl, { redirect: "manual", signal: AbortSignal.timeout(5e3) });
+      const body = await resp.text();
+      if (/root:.*:0:0:|daemon:.*:1:1:|nobody:.*:65534/i.test(body)) {
+        results.push({ url: testUrl, type: "Path Traversal", severity: "critical", message: `Possible /etc/passwd disclosure: ${path}` });
+      }
+    } catch {
+    }
+  }
+  const methods = ["OPTIONS", "TRACE", "DELETE", "PUT"];
+  for (const method of methods) {
+    try {
+      const resp = await fetch(targetUrl, { method, signal: AbortSignal.timeout(5e3) });
+      if (resp.status < 400 && method !== "OPTIONS") {
+        results.push({ url: targetUrl, type: `Unsafe HTTP Method: ${method}`, severity: "medium", message: `${method} allowed (status ${resp.status})` });
+      }
+      if (method === "OPTIONS") {
+        const allow = resp.headers.get("allow");
+        if (allow && /DELETE|PUT|TRACE/i.test(allow)) {
+          results.push({ url: targetUrl, type: "HTTP Methods", severity: "low", message: `Allowed methods: ${allow}` });
+        }
+      }
+    } catch {
+    }
+  }
+  return results;
+}
+
+// src/daemon/workers/runs-worker.ts
+var API_URL = process.env.THREATCRUSH_API_URL || "https://threatcrush.com";
+var POLL_INTERVAL_MS = 3e4;
+var SCHEDULE_INTERVAL_MS = 12e4;
+var RunsWorker = class {
+  constructor(bus2) {
+    this.bus = bus2;
+  }
+  bus;
+  pollTimer = null;
+  scheduleTimer = null;
+  running = false;
+  orgIds = [];
+  async start() {
+    if (!isLoggedIn()) return;
+    try {
+      await this.refreshOrgs();
+    } catch {
+    }
+    this.bus.announceModule("runs-worker", "running", `poll ${POLL_INTERVAL_MS / 1e3}s`);
+    this.tick();
+    this.scheduleTick();
+    this.pollTimer = setInterval(() => this.tick(), POLL_INTERVAL_MS);
+    this.scheduleTimer = setInterval(() => this.scheduleTick(), SCHEDULE_INTERVAL_MS);
+  }
+  stop() {
+    if (this.pollTimer) clearInterval(this.pollTimer);
+    if (this.scheduleTimer) clearInterval(this.scheduleTimer);
+    this.pollTimer = null;
+    this.scheduleTimer = null;
+    this.bus.announceModule("runs-worker", "stopped");
+  }
+  async scheduleTick() {
+    if (!isLoggedIn()) return;
+    try {
+      if (this.orgIds.length === 0) await this.refreshOrgs();
+      for (const orgId of this.orgIds) {
+        try {
+          await fetch(`${API_URL}/api/orgs/${orgId}/schedules/tick`, {
+            method: "POST",
+            headers: authHeaders()
+          });
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  async tick() {
+    if (this.running) return;
+    if (!isLoggedIn()) return;
+    this.running = true;
+    try {
+      if (this.orgIds.length === 0) await this.refreshOrgs();
+      for (const orgId of this.orgIds) {
+        const claimed = await this.claimOne(orgId);
+        if (!claimed) continue;
+        const result = await this.execute(claimed);
+        await this.finalize(orgId, claimed, result);
+      }
+    } catch {
+    } finally {
+      this.running = false;
+    }
+  }
+  async refreshOrgs() {
+    const res = await fetch(`${API_URL}/api/orgs`, { headers: authHeaders() });
+    if (!res.ok) return;
+    const data = await res.json();
+    this.orgIds = (data.organizations || []).map((o) => o.id);
+  }
+  async claimOne(orgId) {
+    try {
+      const res = await fetch(`${API_URL}/api/orgs/${orgId}/runs/pending`, {
+        method: "POST",
+        headers: authHeaders(),
+        body: JSON.stringify({ worker_id: workerId() })
+      });
+      if (!res.ok) return null;
+      const data = await res.json();
+      return data.run ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async execute(run) {
+    const target = run.property?.target;
+    if (!target) {
+      return {
+        type: run.type,
+        target: "",
+        findings: [],
+        severity_summary: { critical: 0, high: 0, medium: 0, low: 0, info: 0 },
+        summary: "property target missing",
+        error: "property target missing"
+      };
+    }
+    this.bus.announceModule("runs-worker", "running", `${run.type} ${run.property?.name || target}`);
+    try {
+      if (run.type === "scan") return await runScan(target);
+      return await runPentest(target);
+    } catch (err) {
+      return {
+        type: run.type,
+        target,
+        findings: [],
+        severity_summary: { critical: 0, high: 0, medium: 0, low: 0, info: 0 },
+        summary: `failed: ${err.message}`,
+        error: err.message
+      };
+    }
+  }
+  async finalize(orgId, claimed, result) {
+    try {
+      await fetch(
+        `${API_URL}/api/orgs/${orgId}/properties/${claimed.property_id}/runs/${claimed.id}`,
+        {
+          method: "PATCH",
+          headers: authHeaders(),
+          body: JSON.stringify({
+            status: result.error ? "failed" : "succeeded",
+            findings_count: result.findings.length,
+            severity_summary: result.severity_summary,
+            summary: result.summary,
+            findings: result.findings,
+            error: result.error,
+            source: "daemon",
+            worker_id: workerId()
+          })
+        }
+      );
+    } catch {
+    } finally {
+      this.bus.announceModule("runs-worker", "idle");
+    }
+  }
+};
+
+// src/core/telemetry.ts
+var ready = false;
+var sentry = null;
+async function loadSentry() {
+  if (sentry) return;
+  try {
+    sentry = await import("@sentry/node");
+  } catch {
+    sentry = null;
+  }
+}
+async function initTelemetry(context) {
+  if (ready) return;
+  const dsn = process.env.SENTRY_DSN;
+  if (!dsn) return;
+  await loadSentry();
+  if (!sentry) return;
+  sentry.init({
+    dsn,
+    environment: process.env.NODE_ENV || "production",
+    release: process.env.SENTRY_RELEASE,
+    serverName: context,
+    tracesSampleRate: 0,
+    beforeSend(event) {
+      const req = event.request;
+      if (req?.headers) {
+        delete req.headers.authorization;
+        delete req.headers.cookie;
+      }
+      return event;
+    }
+  });
+  ready = true;
+}
+function captureException(err) {
+  if (!ready || !sentry) return;
+  sentry.captureException(err);
+}
+async function flushTelemetry(timeoutMs = 2e3) {
+  if (!ready || !sentry) return;
+  try {
+    await sentry.flush(timeoutMs);
+  } catch {
+  }
+}
+
+// src/daemon/index.ts
+function readVersion() {
+  try {
+    const pkg = JSON.parse((0, import_node_fs9.readFileSync)((0, import_node_path6.join)(__dirname, "..", "package.json"), "utf-8"));
+    return pkg.version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function logLine(line) {
+  try {
+    (0, import_node_fs9.appendFileSync)(PATHS.logFile, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
+`);
+  } catch {
+  }
+}
+async function runDaemon() {
+  if (findRunningDaemon()) {
+    console.error(`threatcrushd already running (pid file at ${PATHS.pidFile}).`);
+    process.exit(1);
+  }
+  ensureRuntimeDirs();
+  writePidFile();
+  await initTelemetry("daemon");
+  process.on("uncaughtException", (err) => {
+    logLine(`[daemon] uncaughtException: ${err.message}`);
+    captureException(err);
+  });
+  process.on("unhandledRejection", (reason) => {
+    logLine(`[daemon] unhandledRejection: ${String(reason)}`);
+    captureException(reason);
+  });
+  const version = readVersion();
+  logLine(`[daemon] starting threatcrushd v${version} mode=${PATHS.mode}`);
+  try {
+    initStateDB(PATHS.stateDb);
+  } catch (err) {
+    logLine(`[daemon] state db unavailable: ${err.message}`);
+  }
+  const config = loadConfig((0, import_node_fs9.existsSync)(PATHS.configFile) ? PATHS.configFile : void 0);
+  bus.on("event", (event) => {
+    logLine(`[event] ${event.severity} ${event.module} ${event.message}`);
+  });
+  const moduleHost = new ModuleHost(bus);
+  await moduleHost.start();
+  new AlertDispatcher(bus, config);
+  const runsWorker = new RunsWorker(bus);
+  try {
+    await runsWorker.start();
+  } catch (err) {
+    logLine(`[daemon] runs-worker failed to start: ${err.message}`);
+  }
+  const ipc = new IpcServer(version, moduleHost);
+  await ipc.start();
+  logLine(`[daemon] ipc listening on ${PATHS.socket}`);
+  const shutdown = async (signal) => {
+    logLine(`[daemon] received ${signal}, shutting down`);
+    try {
+      runsWorker.stop();
+    } catch {
+    }
+    try {
+      await moduleHost.stop();
+    } catch {
+    }
+    try {
+      await ipc.stop();
+    } catch {
+    }
+    try {
+      closeDB();
+    } catch {
+    }
+    try {
+      await flushTelemetry();
+    } catch {
+    }
+    removePidFile();
+    process.exit(0);
+  };
+  process.on("SIGINT", () => {
+    void shutdown("SIGINT");
+  });
+  process.on("SIGTERM", () => {
+    void shutdown("SIGTERM");
+  });
+  process.on("SIGHUP", () => {
+    void shutdown("SIGHUP");
+  });
+  setInterval(() => {
+  }, 1 << 30);
+}
+
+// src/daemon-entry.ts
+runDaemon().catch((err) => {
+  console.error("threatcrushd failed to start:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=daemon.js.map