tracer-sh 0.2.7 → 0.3.0

package/packages/server/dist/index.js

@@ -24,9 +24,784 @@ import {
 import {
   __commonJS,
   __export,
+  __require,
   __toESM
 } from "./chunk-WOL2ZWU7.js";
 
+// ../../node_modules/.pnpm/better-sqlite3@12.9.0/node_modules/better-sqlite3/lib/util.js
+var require_util = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@12.9.0/node_modules/better-sqlite3/lib/util.js"(exports) {
+    "use strict";
+    exports.getBooleanOption = (options, key) => {
+      let value = false;
+      if (key in options && typeof (value = options[key]) !== "boolean") {
+        throw new TypeError(`Expected the "${key}" option to be a boolean`);
+      }
+      return value;
+    };
+    exports.cppdb = /* @__PURE__ */ Symbol();
+    exports.inspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@12.9.0/node_modules/better-sqlite3/lib/sqlite-error.js
+var require_sqlite_error = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@12.9.0/node_modules/better-sqlite3/lib/sqlite-error.js"(exports, module) {
+    "use strict";
+    var descriptor = { value: "SqliteError", writable: true, enumerable: false, configurable: true };
+    function SqliteError(message, code) {
+      if (new.target !== SqliteError) {
+        return new SqliteError(message, code);
+      }
+      if (typeof code !== "string") {
+        throw new TypeError("Expected second argument to be a string");
+      }
+      Error.call(this, message);
+      descriptor.value = "" + message;
+      Object.defineProperty(this, "message", descriptor);
+      Error.captureStackTrace(this, SqliteError);
+      this.code = code;
+    }
+    Object.setPrototypeOf(SqliteError, Error);
+    Object.setPrototypeOf(SqliteError.prototype, Error.prototype);
+    Object.defineProperty(SqliteError.prototype, "name", descriptor);
+    module.exports = SqliteError;
+  }
+});
+
+// ../../node_modules/.pnpm/file-uri-to-path@1.0.0/node_modules/file-uri-to-path/index.js
+var require_file_uri_to_path = __commonJS({
+  "../../node_modules/.pnpm/file-uri-to-path@1.0.0/node_modules/file-uri-to-path/index.js"(exports, module) {
+    "use strict";
+    var sep2 = __require("path").sep || "/";
+    module.exports = fileUriToPath;
+    function fileUriToPath(uri) {
+      if ("string" != typeof uri || uri.length <= 7 || "file://" != uri.substring(0, 7)) {
+        throw new TypeError("must pass in a file:// URI to convert to a file path");
+      }
+      var rest = decodeURI(uri.substring(7));
+      var firstSlash = rest.indexOf("/");
+      var host = rest.substring(0, firstSlash);
+      var path = rest.substring(firstSlash + 1);
+      if ("localhost" == host) host = "";
+      if (host) {
+        host = sep2 + sep2 + host;
+      }
+      path = path.replace(/^(.+)\|/, "$1:");
+      if (sep2 == "\\") {
+        path = path.replace(/\//g, "\\");
+      }
+      if (/^.+\:/.test(path)) {
+      } else {
+        path = sep2 + path;
+      }
+      return host + path;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/bindings@1.5.0/node_modules/bindings/bindings.js
+var require_bindings = __commonJS({
+  "../../node_modules/.pnpm/bindings@1.5.0/node_modules/bindings/bindings.js"(exports, module) {
+    "use strict";
+    var fs = __require("fs");
+    var path = __require("path");
+    var fileURLToPath3 = require_file_uri_to_path();
+    var join5 = path.join;
+    var dirname4 = path.dirname;
+    var exists2 = fs.accessSync && function(path2) {
+      try {
+        fs.accessSync(path2);
+      } catch (e) {
+        return false;
+      }
+      return true;
+    } || fs.existsSync || path.existsSync;
+    var defaults = {
+      arrow: process.env.NODE_BINDINGS_ARROW || " \u2192 ",
+      compiled: process.env.NODE_BINDINGS_COMPILED_DIR || "compiled",
+      platform: process.platform,
+      arch: process.arch,
+      nodePreGyp: "node-v" + process.versions.modules + "-" + process.platform + "-" + process.arch,
+      version: process.versions.node,
+      bindings: "bindings.node",
+      try: [
+        // node-gyp's linked version in the "build" dir
+        ["module_root", "build", "bindings"],
+        // node-waf and gyp_addon (a.k.a node-gyp)
+        ["module_root", "build", "Debug", "bindings"],
+        ["module_root", "build", "Release", "bindings"],
+        // Debug files, for development (legacy behavior, remove for node v0.9)
+        ["module_root", "out", "Debug", "bindings"],
+        ["module_root", "Debug", "bindings"],
+        // Release files, but manually compiled (legacy behavior, remove for node v0.9)
+        ["module_root", "out", "Release", "bindings"],
+        ["module_root", "Release", "bindings"],
+        // Legacy from node-waf, node <= 0.4.x
+        ["module_root", "build", "default", "bindings"],
+        // Production "Release" buildtype binary (meh...)
+        ["module_root", "compiled", "version", "platform", "arch", "bindings"],
+        // node-qbs builds
+        ["module_root", "addon-build", "release", "install-root", "bindings"],
+        ["module_root", "addon-build", "debug", "install-root", "bindings"],
+        ["module_root", "addon-build", "default", "install-root", "bindings"],
+        // node-pre-gyp path ./lib/binding/{node_abi}-{platform}-{arch}
+        ["module_root", "lib", "binding", "nodePreGyp", "bindings"]
+      ]
+    };
+    function bindings(opts) {
+      if (typeof opts == "string") {
+        opts = { bindings: opts };
+      } else if (!opts) {
+        opts = {};
+      }
+      Object.keys(defaults).map(function(i2) {
+        if (!(i2 in opts)) opts[i2] = defaults[i2];
+      });
+      if (!opts.module_root) {
+        opts.module_root = exports.getRoot(exports.getFileName());
+      }
+      if (path.extname(opts.bindings) != ".node") {
+        opts.bindings += ".node";
+      }
+      var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
+      var tries = [], i = 0, l = opts.try.length, n, b, err;
+      for (; i < l; i++) {
+        n = join5.apply(
+          null,
+          opts.try[i].map(function(p) {
+            return opts[p] || p;
+          })
+        );
+        tries.push(n);
+        try {
+          b = opts.path ? requireFunc.resolve(n) : requireFunc(n);
+          if (!opts.path) {
+            b.path = n;
+          }
+          return b;
+        } catch (e) {
+          if (e.code !== "MODULE_NOT_FOUND" && e.code !== "QUALIFIED_PATH_RESOLUTION_FAILED" && !/not find/i.test(e.message)) {
+            throw e;
+          }
+        }
+      }
+      err = new Error(
+        "Could not locate the bindings file. Tried:\n" + tries.map(function(a) {
+          return opts.arrow + a;
+        }).join("\n")
+      );
+      err.tries = tries;
+      throw err;
+    }
+    module.exports = exports = bindings;
+    exports.getFileName = function getFileName(calling_file) {
+      var origPST = Error.prepareStackTrace, origSTL = Error.stackTraceLimit, dummy = {}, fileName;
+      Error.stackTraceLimit = 10;
+      Error.prepareStackTrace = function(e, st) {
+        for (var i = 0, l = st.length; i < l; i++) {
+          fileName = st[i].getFileName();
+          if (fileName !== __filename) {
+            if (calling_file) {
+              if (fileName !== calling_file) {
+                return;
+              }
+            } else {
+              return;
+            }
+          }
+        }
+      };
+      Error.captureStackTrace(dummy);
+      dummy.stack;
+      Error.prepareStackTrace = origPST;
+      Error.stackTraceLimit = origSTL;
+      var fileSchema = "file://";
+      if (fileName.indexOf(fileSchema) === 0) {
+        fileName = fileURLToPath3(fileName);
+      }
+      return fileName;
+    };
+    exports.getRoot = function getRoot(file2) {
+      var dir = dirname4(file2), prev;
+      while (true) {
+        if (dir === ".") {
+          dir = process.cwd();
+        }
+        if (exists2(join5(dir, "package.json")) || exists2(join5(dir, "node_modules"))) {
+          return dir;
+        }
+        if (prev === dir) {
+          throw new Error(
+            'Could not find module root given file: "' + file2 + '". Do you have a `package.json` file? '
+          );
+        }
+        prev = dir;
+        dir = join5(dir, "..");
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@12.9.0/node_modules/better-sqlite3/lib/methods/wrappers.js
+var require_wrappers = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@12.9.0/node_modules/better-sqlite3/lib/methods/wrappers.js"(exports) {
+    "use strict";
+    var { cppdb } = require_util();
+    exports.prepare = function prepare(sql2) {
+      return this[cppdb].prepare(sql2, this, false);
+    };
+    exports.exec = function exec2(sql2) {
+      this[cppdb].exec(sql2);
+      return this;
+    };
+    exports.close = function close() {
+      this[cppdb].close();
+      return this;
+    };
+    exports.loadExtension = function loadExtension(...args) {
+      this[cppdb].loadExtension(...args);
+      return this;
+    };
+    exports.defaultSafeIntegers = function defaultSafeIntegers(...args) {
+      this[cppdb].defaultSafeIntegers(...args);
+      return this;
+    };
+    exports.unsafeMode = function unsafeMode(...args) {
+      this[cppdb].unsafeMode(...args);
+      return this;
+    };
+    exports.getters = {
+      name: {
+        get: function name26() {
+          return this[cppdb].name;
+        },
+        enumerable: true
+      },
+      open: {
+        get: function open() {
+          return this[cppdb].open;
+        },
+        enumerable: true
+      },
+      inTransaction: {
+        get: function inTransaction() {
+          return this[cppdb].inTransaction;
+        },
+        enumerable: true
+      },
+      readonly: {
+        get: function readonly2() {
+          return this[cppdb].readonly;
+        },
+        enumerable: true
+      },
+      memory: {
+        get: function memory() {
+          return this[cppdb].memory;
+        },
+        enumerable: true
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@12.9.0/node_modules/better-sqlite3/lib/methods/transaction.js
+var require_transaction = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@12.9.0/node_modules/better-sqlite3/lib/methods/transaction.js"(exports, module) {
+    "use strict";
+    var { cppdb } = require_util();
+    var controllers = /* @__PURE__ */ new WeakMap();
+    module.exports = function transaction(fn) {
+      if (typeof fn !== "function") throw new TypeError("Expected first argument to be a function");
+      const db2 = this[cppdb];
+      const controller = getController(db2, this);
+      const { apply } = Function.prototype;
+      const properties = {
+        default: { value: wrapTransaction(apply, fn, db2, controller.default) },
+        deferred: { value: wrapTransaction(apply, fn, db2, controller.deferred) },
+        immediate: { value: wrapTransaction(apply, fn, db2, controller.immediate) },
+        exclusive: { value: wrapTransaction(apply, fn, db2, controller.exclusive) },
+        database: { value: this, enumerable: true }
+      };
+      Object.defineProperties(properties.default.value, properties);
+      Object.defineProperties(properties.deferred.value, properties);
+      Object.defineProperties(properties.immediate.value, properties);
+      Object.defineProperties(properties.exclusive.value, properties);
+      return properties.default.value;
+    };
+    var getController = (db2, self) => {
+      let controller = controllers.get(db2);
+      if (!controller) {
+        const shared = {
+          commit: db2.prepare("COMMIT", self, false),
+          rollback: db2.prepare("ROLLBACK", self, false),
+          savepoint: db2.prepare("SAVEPOINT `	_bs3.	`", self, false),
+          release: db2.prepare("RELEASE `	_bs3.	`", self, false),
+          rollbackTo: db2.prepare("ROLLBACK TO `	_bs3.	`", self, false)
+        };
+        controllers.set(db2, controller = {
+          default: Object.assign({ begin: db2.prepare("BEGIN", self, false) }, shared),
+          deferred: Object.assign({ begin: db2.prepare("BEGIN DEFERRED", self, false) }, shared),
+          immediate: Object.assign({ begin: db2.prepare("BEGIN IMMEDIATE", self, false) }, shared),
+          exclusive: Object.assign({ begin: db2.prepare("BEGIN EXCLUSIVE", self, false) }, shared)
+        });
+      }
+      return controller;
+    };
+    var wrapTransaction = (apply, fn, db2, { begin, commit, rollback, savepoint, release, rollbackTo }) => function sqliteTransaction() {
+      let before, after, undo;
+      if (db2.inTransaction) {
+        before = savepoint;
+        after = release;
+        undo = rollbackTo;
+      } else {
+        before = begin;
+        after = commit;
+        undo = rollback;
+      }
+      before.run();
+      try {
+        const result = apply.call(fn, this, arguments);
+        if (result && typeof result.then === "function") {
+          throw new TypeError("Transaction function cannot return a promise");
+        }
+        after.run();
+        return result;
+      } catch (ex) {
+        if (db2.inTransaction) {
+          undo.run();
+          if (undo !== rollback) after.run();
+        }
+        throw ex;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@12.9.0/node_modules/better-sqlite3/lib/methods/pragma.js
+var require_pragma = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@12.9.0/node_modules/better-sqlite3/lib/methods/pragma.js"(exports, module) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module.exports = function pragma(source, options) {
+      if (options == null) options = {};
+      if (typeof source !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      const simple = getBooleanOption(options, "simple");
+      const stmt = this[cppdb].prepare(`PRAGMA ${source}`, this, true);
+      return simple ? stmt.pluck().get() : stmt.all();
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@12.9.0/node_modules/better-sqlite3/lib/methods/backup.js
+var require_backup = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@12.9.0/node_modules/better-sqlite3/lib/methods/backup.js"(exports, module) {
+    "use strict";
+    var fs = __require("fs");
+    var path = __require("path");
+    var { promisify } = __require("util");
+    var { cppdb } = require_util();
+    var fsAccess = promisify(fs.access);
+    module.exports = async function backup(filename, options) {
+      if (options == null) options = {};
+      if (typeof filename !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      filename = filename.trim();
+      const attachedName = "attached" in options ? options.attached : "main";
+      const handler = "progress" in options ? options.progress : null;
+      if (!filename) throw new TypeError("Backup filename cannot be an empty string");
+      if (filename === ":memory:") throw new TypeError('Invalid backup filename ":memory:"');
+      if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
+      if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
+      if (handler != null && typeof handler !== "function") throw new TypeError('Expected the "progress" option to be a function');
+      await fsAccess(path.dirname(filename)).catch(() => {
+        throw new TypeError("Cannot save backup because the directory does not exist");
+      });
+      const isNewFile = await fsAccess(filename).then(() => false, () => true);
+      return runBackup(this[cppdb].backup(this, attachedName, filename, isNewFile), handler || null);
+    };
+    var runBackup = (backup, handler) => {
+      let rate = 0;
+      let useDefault = true;
+      return new Promise((resolve4, reject) => {
+        setImmediate(function step() {
+          try {
+            const progress = backup.transfer(rate);
+            if (!progress.remainingPages) {
+              backup.close();
+              resolve4(progress);
+              return;
+            }
+            if (useDefault) {
+              useDefault = false;
+              rate = 100;
+            }
+            if (handler) {
+              const ret = handler(progress);
+              if (ret !== void 0) {
+                if (typeof ret === "number" && ret === ret) rate = Math.max(0, Math.min(2147483647, Math.round(ret)));
+                else throw new TypeError("Expected progress callback to return a number or undefined");
+              }
+            }
+            setImmediate(step);
+          } catch (err) {
+            backup.close();
+            reject(err);
+          }
+        });
+      });
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@12.9.0/node_modules/better-sqlite3/lib/methods/serialize.js
+var require_serialize = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@12.9.0/node_modules/better-sqlite3/lib/methods/serialize.js"(exports, module) {
+    "use strict";
+    var { cppdb } = require_util();
+    module.exports = function serialize2(options) {
+      if (options == null) options = {};
+      if (typeof options !== "object") throw new TypeError("Expected first argument to be an options object");
+      const attachedName = "attached" in options ? options.attached : "main";
+      if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
+      if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
+      return this[cppdb].serialize(attachedName);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@12.9.0/node_modules/better-sqlite3/lib/methods/function.js
+var require_function = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@12.9.0/node_modules/better-sqlite3/lib/methods/function.js"(exports, module) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module.exports = function defineFunction(name26, options, fn) {
+      if (options == null) options = {};
+      if (typeof options === "function") {
+        fn = options;
+        options = {};
+      }
+      if (typeof name26 !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof fn !== "function") throw new TypeError("Expected last argument to be a function");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      if (!name26) throw new TypeError("User-defined function name cannot be an empty string");
+      const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
+      const deterministic = getBooleanOption(options, "deterministic");
+      const directOnly = getBooleanOption(options, "directOnly");
+      const varargs = getBooleanOption(options, "varargs");
+      let argCount = -1;
+      if (!varargs) {
+        argCount = fn.length;
+        if (!Number.isInteger(argCount) || argCount < 0) throw new TypeError("Expected function.length to be a positive integer");
+        if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
+      }
+      this[cppdb].function(fn, name26, argCount, safeIntegers, deterministic, directOnly);
+      return this;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@12.9.0/node_modules/better-sqlite3/lib/methods/aggregate.js
+var require_aggregate = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@12.9.0/node_modules/better-sqlite3/lib/methods/aggregate.js"(exports, module) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module.exports = function defineAggregate(name26, options) {
+      if (typeof name26 !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object" || options === null) throw new TypeError("Expected second argument to be an options object");
+      if (!name26) throw new TypeError("User-defined function name cannot be an empty string");
+      const start = "start" in options ? options.start : null;
+      const step = getFunctionOption(options, "step", true);
+      const inverse = getFunctionOption(options, "inverse", false);
+      const result = getFunctionOption(options, "result", false);
+      const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
+      const deterministic = getBooleanOption(options, "deterministic");
+      const directOnly = getBooleanOption(options, "directOnly");
+      const varargs = getBooleanOption(options, "varargs");
+      let argCount = -1;
+      if (!varargs) {
+        argCount = Math.max(getLength(step), inverse ? getLength(inverse) : 0);
+        if (argCount > 0) argCount -= 1;
+        if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
+      }
+      this[cppdb].aggregate(start, step, inverse, result, name26, argCount, safeIntegers, deterministic, directOnly);
+      return this;
+    };
+    var getFunctionOption = (options, key, required2) => {
+      const value = key in options ? options[key] : null;
+      if (typeof value === "function") return value;
+      if (value != null) throw new TypeError(`Expected the "${key}" option to be a function`);
+      if (required2) throw new TypeError(`Missing required option "${key}"`);
+      return null;
+    };
+    var getLength = ({ length }) => {
+      if (Number.isInteger(length) && length >= 0) return length;
+      throw new TypeError("Expected function.length to be a positive integer");
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@12.9.0/node_modules/better-sqlite3/lib/methods/table.js
+var require_table = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@12.9.0/node_modules/better-sqlite3/lib/methods/table.js"(exports, module) {
+    "use strict";
+    var { cppdb } = require_util();
+    module.exports = function defineTable(name26, factory11) {
+      if (typeof name26 !== "string") throw new TypeError("Expected first argument to be a string");
+      if (!name26) throw new TypeError("Virtual table module name cannot be an empty string");
+      let eponymous = false;
+      if (typeof factory11 === "object" && factory11 !== null) {
+        eponymous = true;
+        factory11 = defer(parseTableDefinition(factory11, "used", name26));
+      } else {
+        if (typeof factory11 !== "function") throw new TypeError("Expected second argument to be a function or a table definition object");
+        factory11 = wrapFactory(factory11);
+      }
+      this[cppdb].table(factory11, name26, eponymous);
+      return this;
+    };
+    function wrapFactory(factory11) {
+      return function virtualTableFactory(moduleName, databaseName, tableName, ...args) {
+        const thisObject = {
+          module: moduleName,
+          database: databaseName,
+          table: tableName
+        };
+        const def = apply.call(factory11, thisObject, args);
+        if (typeof def !== "object" || def === null) {
+          throw new TypeError(`Virtual table module "${moduleName}" did not return a table definition object`);
+        }
+        return parseTableDefinition(def, "returned", moduleName);
+      };
+    }
+    function parseTableDefinition(def, verb, moduleName) {
+      if (!hasOwnProperty.call(def, "rows")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "rows" property`);
+      }
+      if (!hasOwnProperty.call(def, "columns")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "columns" property`);
+      }
+      const rows = def.rows;
+      if (typeof rows !== "function" || Object.getPrototypeOf(rows) !== GeneratorFunctionPrototype) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "rows" property (should be a generator function)`);
+      }
+      let columns = def.columns;
+      if (!Array.isArray(columns) || !(columns = [...columns]).every((x) => typeof x === "string")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "columns" property (should be an array of strings)`);
+      }
+      if (columns.length !== new Set(columns).size) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate column names`);
+      }
+      if (!columns.length) {
+        throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with zero columns`);
+      }
+      let parameters;
+      if (hasOwnProperty.call(def, "parameters")) {
+        parameters = def.parameters;
+        if (!Array.isArray(parameters) || !(parameters = [...parameters]).every((x) => typeof x === "string")) {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "parameters" property (should be an array of strings)`);
+        }
+      } else {
+        parameters = inferParameters(rows);
+      }
+      if (parameters.length !== new Set(parameters).size) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate parameter names`);
+      }
+      if (parameters.length > 32) {
+        throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with more than the maximum number of 32 parameters`);
+      }
+      for (const parameter of parameters) {
+        if (columns.includes(parameter)) {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with column "${parameter}" which was ambiguously defined as both a column and parameter`);
+        }
+      }
+      let safeIntegers = 2;
+      if (hasOwnProperty.call(def, "safeIntegers")) {
+        const bool = def.safeIntegers;
+        if (typeof bool !== "boolean") {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "safeIntegers" property (should be a boolean)`);
+        }
+        safeIntegers = +bool;
+      }
+      let directOnly = false;
+      if (hasOwnProperty.call(def, "directOnly")) {
+        directOnly = def.directOnly;
+        if (typeof directOnly !== "boolean") {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "directOnly" property (should be a boolean)`);
+        }
+      }
+      const columnDefinitions = [
+        ...parameters.map(identifier).map((str) => `${str} HIDDEN`),
+        ...columns.map(identifier)
+      ];
+      return [
+        `CREATE TABLE x(${columnDefinitions.join(", ")});`,
+        wrapGenerator(rows, new Map(columns.map((x, i) => [x, parameters.length + i])), moduleName),
+        parameters,
+        safeIntegers,
+        directOnly
+      ];
+    }
+    function wrapGenerator(generator, columnMap, moduleName) {
+      return function* virtualTable(...args) {
+        const output = args.map((x) => Buffer.isBuffer(x) ? Buffer.from(x) : x);
+        for (let i = 0; i < columnMap.size; ++i) {
+          output.push(null);
+        }
+        for (const row of generator(...args)) {
+          if (Array.isArray(row)) {
+            extractRowArray(row, output, columnMap.size, moduleName);
+            yield output;
+          } else if (typeof row === "object" && row !== null) {
+            extractRowObject(row, output, columnMap, moduleName);
+            yield output;
+          } else {
+            throw new TypeError(`Virtual table module "${moduleName}" yielded something that isn't a valid row object`);
+          }
+        }
+      };
+    }
+    function extractRowArray(row, output, columnCount, moduleName) {
+      if (row.length !== columnCount) {
+        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an incorrect number of columns`);
+      }
+      const offset = output.length - columnCount;
+      for (let i = 0; i < columnCount; ++i) {
+        output[i + offset] = row[i];
+      }
+    }
+    function extractRowObject(row, output, columnMap, moduleName) {
+      let count = 0;
+      for (const key of Object.keys(row)) {
+        const index2 = columnMap.get(key);
+        if (index2 === void 0) {
+          throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an undeclared column "${key}"`);
+        }
+        output[index2] = row[key];
+        count += 1;
+      }
+      if (count !== columnMap.size) {
+        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with missing columns`);
+      }
+    }
+    function inferParameters({ length }) {
+      if (!Number.isInteger(length) || length < 0) {
+        throw new TypeError("Expected function.length to be a positive integer");
+      }
+      const params = [];
+      for (let i = 0; i < length; ++i) {
+        params.push(`$${i + 1}`);
+      }
+      return params;
+    }
+    var { hasOwnProperty } = Object.prototype;
+    var { apply } = Function.prototype;
+    var GeneratorFunctionPrototype = Object.getPrototypeOf(function* () {
+    });
+    var identifier = (str) => `"${str.replace(/"/g, '""')}"`;
+    var defer = (x) => () => x;
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@12.9.0/node_modules/better-sqlite3/lib/methods/inspect.js
+var require_inspect = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@12.9.0/node_modules/better-sqlite3/lib/methods/inspect.js"(exports, module) {
+    "use strict";
+    var DatabaseInspection = function Database3() {
+    };
+    module.exports = function inspect(depth, opts) {
+      return Object.assign(new DatabaseInspection(), this);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@12.9.0/node_modules/better-sqlite3/lib/database.js
+var require_database = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@12.9.0/node_modules/better-sqlite3/lib/database.js"(exports, module) {
+    "use strict";
+    var fs = __require("fs");
+    var path = __require("path");
+    var util2 = require_util();
+    var SqliteError = require_sqlite_error();
+    var DEFAULT_ADDON;
+    function Database3(filenameGiven, options) {
+      if (new.target == null) {
+        return new Database3(filenameGiven, options);
+      }
+      let buffer;
+      if (Buffer.isBuffer(filenameGiven)) {
+        buffer = filenameGiven;
+        filenameGiven = ":memory:";
+      }
+      if (filenameGiven == null) filenameGiven = "";
+      if (options == null) options = {};
+      if (typeof filenameGiven !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      if ("readOnly" in options) throw new TypeError('Misspelled option "readOnly" should be "readonly"');
+      if ("memory" in options) throw new TypeError('Option "memory" was removed in v7.0.0 (use ":memory:" filename instead)');
+      const filename = filenameGiven.trim();
+      const anonymous = filename === "" || filename === ":memory:";
+      const readonly2 = util2.getBooleanOption(options, "readonly");
+      const fileMustExist = util2.getBooleanOption(options, "fileMustExist");
+      const timeout = "timeout" in options ? options.timeout : 5e3;
+      const verbose = "verbose" in options ? options.verbose : null;
+      const nativeBinding = "nativeBinding" in options ? options.nativeBinding : null;
+      if (readonly2 && anonymous && !buffer) throw new TypeError("In-memory/temporary databases cannot be readonly");
+      if (!Number.isInteger(timeout) || timeout < 0) throw new TypeError('Expected the "timeout" option to be a positive integer');
+      if (timeout > 2147483647) throw new RangeError('Option "timeout" cannot be greater than 2147483647');
+      if (verbose != null && typeof verbose !== "function") throw new TypeError('Expected the "verbose" option to be a function');
+      if (nativeBinding != null && typeof nativeBinding !== "string" && typeof nativeBinding !== "object") throw new TypeError('Expected the "nativeBinding" option to be a string or addon object');
+      let addon;
+      if (nativeBinding == null) {
+        addon = DEFAULT_ADDON || (DEFAULT_ADDON = require_bindings()("better_sqlite3.node"));
+      } else if (typeof nativeBinding === "string") {
+        const requireFunc = typeof __non_webpack_require__ === "function" ? __non_webpack_require__ : __require;
+        addon = requireFunc(path.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
+      } else {
+        addon = nativeBinding;
+      }
+      if (!addon.isInitialized) {
+        addon.setErrorConstructor(SqliteError);
+        addon.isInitialized = true;
+      }
+      if (!anonymous && !filename.startsWith("file:") && !fs.existsSync(path.dirname(filename))) {
+        throw new TypeError("Cannot open database because the directory does not exist");
+      }
+      Object.defineProperties(this, {
+        [util2.cppdb]: { value: new addon.Database(filename, filenameGiven, anonymous, readonly2, fileMustExist, timeout, verbose || null, buffer || null) },
+        ...wrappers.getters
+      });
+    }
+    var wrappers = require_wrappers();
+    Database3.prototype.prepare = wrappers.prepare;
+    Database3.prototype.transaction = require_transaction();
+    Database3.prototype.pragma = require_pragma();
+    Database3.prototype.backup = require_backup();
+    Database3.prototype.serialize = require_serialize();
+    Database3.prototype.function = require_function();
+    Database3.prototype.aggregate = require_aggregate();
+    Database3.prototype.table = require_table();
+    Database3.prototype.loadExtension = wrappers.loadExtension;
+    Database3.prototype.exec = wrappers.exec;
+    Database3.prototype.close = wrappers.close;
+    Database3.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
+    Database3.prototype.unsafeMode = wrappers.unsafeMode;
+    Database3.prototype[util2.inspect] = require_inspect();
+    module.exports = Database3;
+  }
+});
+
+// ../../node_modules/.pnpm/better-sqlite3@12.9.0/node_modules/better-sqlite3/lib/index.js
+var require_lib = __commonJS({
+  "../../node_modules/.pnpm/better-sqlite3@12.9.0/node_modules/better-sqlite3/lib/index.js"(exports, module) {
+    "use strict";
+    module.exports = require_database();
+    module.exports.SqliteError = require_sqlite_error();
+  }
+});
+
 // ../../node_modules/.pnpm/@vercel+oidc@3.2.0/node_modules/@vercel/oidc/dist/get-context.js
 var require_get_context = __commonJS({
   "../../node_modules/.pnpm/@vercel+oidc@3.2.0/node_modules/@vercel/oidc/dist/get-context.js"(exports, module) {
@@ -1842,7 +2617,7 @@ function sql(strings, ...params) {
     return new SQL([new StringChunk(str)]);
   }
   sql2.raw = raw2;
-  function join4(chunks, separator) {
+  function join5(chunks, separator) {
     const result = [];
     for (const [i, chunk] of chunks.entries()) {
       if (i > 0 && separator !== void 0) {
@@ -1852,7 +2627,7 @@ function sql(strings, ...params) {
     }
     return new SQL(result);
   }
-  sql2.join = join4;
+  sql2.join = join5;
   function identifier(value) {
     return new Name(value);
   }
@@ -16761,7 +17536,7 @@ function checkForUpdateBackground() {
     const available = isNewerVersion(latest, current);
     cachedStatus = { available, currentVersion: current, latestVersion: latest, method };
     if (available) {
-      const hint = method === "global" ? "click the version in the sidebar to update from the app" : method === "npx" ? "re-run: npx tracer-sh@latest" : "git pull && pnpm install && pnpm build";
+      const hint = method === "global" ? "click the version in the sidebar to update from the app" : method === "npx" ? "re-run: npx tracer-sh@latest" : "git pull, then restart tracer-sh \u2014 the launcher rebuilds automatically";
       console.log(`Update available: v${current} \u2192 v${latest} (${hint})`);
     }
   }).catch(() => {
@@ -16804,12 +17579,12 @@ function requestRestart() {
 
 // src/db/client.ts
 import { homedir } from "os";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import { chmodSync, mkdirSync } from "fs";
-import Database from "better-sqlite3";
+import Database2 from "better-sqlite3-multiple-ciphers";
 
 // ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_better-sqlite3@12.9.0/node_modules/drizzle-orm/better-sqlite3/driver.js
-import Client from "better-sqlite3";
+var import_better_sqlite3 = __toESM(require_lib(), 1);
 
 // ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.0_@types+better-sqlite3@7.6.13_better-sqlite3@12.9.0/node_modules/drizzle-orm/selection-proxy.js
 var SelectionProxyHandler = class _SelectionProxyHandler {
@@ -18495,7 +19270,7 @@ var SQLiteSelectQueryBuilderBase = class extends TypedQueryBuilder {
       const baseTableName = this.tableName;
       const tableName = getTableLikeName(table);
       for (const item of extractUsedTable(table)) this.usedTables.add(item);
-      if (typeof tableName === "string" && this.config.joins?.some((join4) => join4.alias === tableName)) {
+      if (typeof tableName === "string" && this.config.joins?.some((join5) => join5.alias === tableName)) {
         throw new Error(`Alias "${tableName}" is already used in this query`);
       }
       if (!this.isPartialSelect) {
@@ -19354,7 +20129,7 @@ var SQLiteUpdateBase = class extends QueryPromise {
   createJoin(joinType) {
     return (table, on) => {
       const tableName = getTableLikeName(table);
-      if (typeof tableName === "string" && this.config.joins.some((join4) => join4.alias === tableName)) {
+      if (typeof tableName === "string" && this.config.joins.some((join5) => join5.alias === tableName)) {
         throw new Error(`Alias "${tableName}" is already used in this query`);
       }
       if (typeof on === "function") {
@@ -20349,7 +21124,7 @@ function construct(client, config2 = {}) {
 }
 function drizzle(...params) {
   if (params[0] === void 0 || typeof params[0] === "string") {
-    const instance = params[0] === void 0 ? new Client() : new Client(params[0]);
+    const instance = params[0] === void 0 ? new import_better_sqlite3.default() : new import_better_sqlite3.default(params[0]);
     return construct(instance, params[1]);
   }
   if (isConfig(params[0])) {
@@ -20357,10 +21132,10 @@ function drizzle(...params) {
     if (client) return construct(client, drizzleConfig);
     if (typeof connection === "object") {
       const { source, ...options } = connection;
-      const instance2 = new Client(source, options);
+      const instance2 = new import_better_sqlite3.default(source, options);
       return construct(instance2, drizzleConfig);
     }
-    const instance = new Client(connection);
+    const instance = new import_better_sqlite3.default(connection);
     return construct(instance, drizzleConfig);
   }
   return construct(params[0], params[1]);
@@ -20522,13 +21297,145 @@ var agentRuns = sqliteTable("agent_runs", {
   index("idx_agent_runs_type").on(t2.agentType)
 ]);
 
+// src/db/db-key.ts
+import { createRequire } from "module";
+import { join as join2 } from "path";
+import { randomBytes } from "crypto";
+import { existsSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+var requireCjs = createRequire(import.meta.url);
+var SERVICE = "tracer-sh";
+var ACCOUNT = "db-key";
+function isValidKeyHex(value) {
+  return /^[0-9a-f]{64}$/i.test(value);
+}
+function generateKeyHex() {
+  return randomBytes(32).toString("hex");
+}
+function resolveDbKey(tracerHome) {
+  const envKey = process.env.TRACER_DB_KEY?.trim();
+  if (envKey) {
+    if (!isValidKeyHex(envKey)) {
+      throw new Error("TRACER_DB_KEY must be 64 hex characters (a 32-byte key).");
+    }
+    return envKey.toLowerCase();
+  }
+  return tryKeychain() ?? resolveKeyFile(tracerHome);
+}
+function tryKeychain() {
+  try {
+    const { Entry } = requireCjs("@napi-rs/keyring");
+    const entry = new Entry(SERVICE, ACCOUNT);
+    let existing = null;
+    try {
+      existing = entry.getPassword();
+    } catch {
+      existing = null;
+    }
+    if (existing && isValidKeyHex(existing)) return existing.toLowerCase();
+    const fresh = generateKeyHex();
+    entry.setPassword(fresh);
+    return fresh;
+  } catch {
+    return null;
+  }
+}
+function resolveKeyFile(tracerHome) {
+  const keyPath = join2(tracerHome, "db-key");
+  if (existsSync(keyPath)) {
+    const fromFile = readFileSync2(keyPath, "utf8").trim();
+    if (isValidKeyHex(fromFile)) {
+      warnKeyFile(keyPath);
+      return fromFile.toLowerCase();
+    }
+  }
+  const fresh = generateKeyHex();
+  writeFileSync(keyPath, fresh, { mode: 384 });
+  warnKeyFile(keyPath);
+  return fresh;
+}
+function warnKeyFile(keyPath) {
+  console.warn(
+    `[tracer] OS keychain unavailable \u2014 storing the database encryption key in a file at ${keyPath}. It is created owner-only (0600) on macOS/Linux; on Windows it relies on the data directory's ACLs. Anyone who can read this file can read the database \u2014 set TRACER_DB_KEY to supply the key yourself instead.`
+  );
+}
+
+// src/db/db-encryption.ts
+import { renameSync, rmSync, existsSync as existsSync2, copyFileSync, openSync, readSync, closeSync } from "fs";
+import Database from "better-sqlite3-multiple-ciphers";
+var SQLITE_MAGIC = "SQLite format 3\0";
+function applyKey(conn, keyHex2) {
+  conn.pragma("cipher='sqlcipher'");
+  conn.pragma(`key="x'${keyHex2}'"`);
+}
+function isPlaintext(dbPath2) {
+  if (!existsSync2(dbPath2)) return false;
+  let fd;
+  try {
+    fd = openSync(dbPath2, "r");
+    const header = Buffer.alloc(16);
+    const bytes = readSync(fd, header, 0, 16, 0);
+    return bytes === 16 && header.toString("latin1") === SQLITE_MAGIC;
+  } finally {
+    if (fd !== void 0) closeSync(fd);
+  }
+}
+function migratePlaintextToEncrypted(dbPath2, keyHex2) {
+  const tmpPath = `${dbPath2}.enc.tmp`;
+  cleanupTmp(tmpPath);
+  const plain = new Database(dbPath2);
+  try {
+    plain.pragma("wal_checkpoint(TRUNCATE)");
+  } finally {
+    plain.close();
+  }
+  try {
+    copyFileSync(dbPath2, tmpPath);
+    const enc = new Database(tmpPath);
+    enc.pragma("cipher='sqlcipher'");
+    enc.pragma(`rekey="x'${keyHex2}'"`);
+    enc.pragma("wal_checkpoint(TRUNCATE)");
+    enc.close();
+  } catch (err) {
+    cleanupTmp(tmpPath);
+    throw new Error(`Database encryption migration failed: ${err.message}`);
+  }
+  try {
+    if (isPlaintext(tmpPath)) throw new Error("encrypted copy is still readable as plaintext");
+    const verify = new Database(tmpPath);
+    applyKey(verify, keyHex2);
+    const result = verify.pragma("integrity_check", { simple: true });
+    verify.close();
+    if (result !== "ok") throw new Error(`integrity check returned "${String(result)}"`);
+  } catch (err) {
+    cleanupTmp(tmpPath);
+    throw new Error(`Database encryption verification failed: ${err.message}`);
+  }
+  rmSync(`${dbPath2}-wal`, { force: true });
+  rmSync(`${dbPath2}-shm`, { force: true });
+  rmSync(`${dbPath2}-journal`, { force: true });
+  renameSync(tmpPath, dbPath2);
+  rmSync(`${tmpPath}-wal`, { force: true });
+  rmSync(`${tmpPath}-shm`, { force: true });
+}
+function cleanupTmp(tmpPath) {
+  rmSync(tmpPath, { force: true });
+  rmSync(`${tmpPath}-wal`, { force: true });
+  rmSync(`${tmpPath}-shm`, { force: true });
+}
+
 // src/db/client.ts
-var TRACER_HOME = process.env.TRACER_HOME || join2(homedir(), ".tracer");
-var dataDir = join2(TRACER_HOME, "data");
+var TRACER_HOME = process.env.TRACER_HOME || join3(homedir(), ".tracer");
+var dataDir = join3(TRACER_HOME, "data");
 mkdirSync(dataDir, { recursive: true });
 chmodSync(TRACER_HOME, 448);
 chmodSync(dataDir, 448);
-var sqlite = new Database(join2(dataDir, "tracer.db"));
+var dbPath = join3(dataDir, "tracer.db");
+var keyHex = resolveDbKey(TRACER_HOME);
+if (isPlaintext(dbPath)) {
+  migratePlaintextToEncrypted(dbPath, keyHex);
+}
+var sqlite = new Database2(dbPath);
+applyKey(sqlite, keyHex);
 sqlite.pragma("journal_mode = WAL");
 sqlite.pragma("synchronous = NORMAL");
 sqlite.pragma("busy_timeout = 5000");
@@ -46952,8 +47859,8 @@ var NewRelicProvider = class extends BaseProvider {
 };
 
 // src/mcp/mcp-provider.ts
-import { createRequire } from "module";
-import { readFileSync as readFileSync2 } from "fs";
+import { createRequire as createRequire2 } from "module";
+import { readFileSync as readFileSync3 } from "fs";
 import { dirname as dirname2, resolve as resolve2 } from "path";
 
 // ../../node_modules/.pnpm/pkce-challenge@5.0.1/node_modules/pkce-challenge/dist/index.node.js
@@ -46969,8 +47876,8 @@ async function random(size) {
   const evenDistCutoff = Math.pow(2, 8) - Math.pow(2, 8) % mask.length;
   let result = "";
   while (result.length < size) {
-    const randomBytes = await getRandomValues(size - result.length);
-    for (const randomByte of randomBytes) {
+    const randomBytes2 = await getRandomValues(size - result.length);
+    for (const randomByte of randomBytes2) {
       if (randomByte < evenDistCutoff) {
         result += mask[randomByte % mask.length];
       }
@@ -49702,11 +50609,11 @@ var McpProvider = class extends BaseProvider {
     this.clients = [];
   }
 };
-var require2 = createRequire(import.meta.url);
+var require2 = createRequire2(import.meta.url);
 function resolveLocalBin(pkg) {
   try {
     const pkgJsonPath = require2.resolve(`${pkg}/package.json`);
-    const pkgJson = JSON.parse(readFileSync2(pkgJsonPath, "utf-8"));
+    const pkgJson = JSON.parse(readFileSync3(pkgJsonPath, "utf-8"));
     const bin = pkgJson.bin;
     if (!bin) return null;
     const entry = typeof bin === "string" ? bin : Object.values(bin)[0];
@@ -49977,8 +50884,8 @@ function isTransportError(err) {
 }
 
 // src/providers/gcp/gcp-auth.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { join as join3 } from "path";
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join4 } from "path";
 var REAUTH_CMD = "Run: gcloud auth application-default login";
 var TOKEN_TTL_MS = 55 * 60 * 1e3;
 var tokenCache = null;
@@ -49989,10 +50896,10 @@ async function getGcpAuth() {
   if (tokenCache && Date.now() < tokenCache.expiresAt) {
     return { ok: true, token: tokenCache.token };
   }
-  const credPath = process.env.GOOGLE_APPLICATION_CREDENTIALS || join3(process.env.HOME ?? "", ".config", "gcloud", "application_default_credentials.json");
+  const credPath = process.env.GOOGLE_APPLICATION_CREDENTIALS || join4(process.env.HOME ?? "", ".config", "gcloud", "application_default_credentials.json");
   let creds;
   try {
-    creds = JSON.parse(readFileSync3(credPath, "utf-8"));
+    creds = JSON.parse(readFileSync4(credPath, "utf-8"));
   } catch {
     return { ok: false, code: "no_credentials", message: `No GCP credentials found. ${REAUTH_CMD}` };
   }
@@ -57355,9 +58262,144 @@ var updateRouter = router({
   })
 });
 
+// src/integrations/jira/jira.client.ts
+function normalizeJiraDomain(raw2) {
+  return raw2.trim().replace(/^https?:\/\//i, "").replace(/\/+$/, "").replace(/\.atlassian\.net$/i, "");
+}
+function toPlainText(value) {
+  if (value == null) return null;
+  if (typeof value === "string") return value;
+  const parts = [];
+  const walk = (node) => {
+    if (!node || typeof node !== "object") return;
+    const n = node;
+    if (typeof n.text === "string") parts.push(n.text);
+    if (Array.isArray(n.content)) n.content.forEach(walk);
+  };
+  walk(value);
+  return parts.join("") || null;
+}
+var JiraClient = class {
+  baseUrl;
+  authHeader;
+  constructor({ domain: domain2, email: email3, apiToken }) {
+    this.baseUrl = `https://${normalizeJiraDomain(domain2)}.atlassian.net`;
+    this.authHeader = "Basic " + Buffer.from(`${email3}:${apiToken}`).toString("base64");
+  }
+  async request(path, init) {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      ...init,
+      headers: {
+        Authorization: this.authHeader,
+        Accept: "application/json",
+        ...init?.body ? { "Content-Type": "application/json" } : {},
+        ...init?.headers
+      },
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (!res.ok) {
+      const text3 = await res.text().catch(() => "");
+      throw new Error(`Jira ${res.status}: ${text3.slice(0, 300) || res.statusText}`);
+    }
+    return res;
+  }
+  /** Validate credentials by fetching the current user. */
+  async validate() {
+    try {
+      await this.request("/rest/api/2/myself");
+      return { ok: true };
+    } catch (err) {
+      return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  async getIssue(key) {
+    const res = await this.request(
+      `/rest/api/2/issue/${encodeURIComponent(key)}?fields=summary,description,status`
+    );
+    const data = await res.json();
+    const fields = data.fields ?? {};
+    return {
+      key: data.key ?? key,
+      summary: fields.summary ?? "",
+      description: toPlainText(fields.description),
+      status: fields.status?.name ?? "Unknown"
+    };
+  }
+  async addComment(key, body) {
+    const res = await this.request(`/rest/api/2/issue/${encodeURIComponent(key)}/comment`, {
+      method: "POST",
+      body: JSON.stringify({ body })
+    });
+    const data = await res.json().catch(() => ({}));
+    const id = data.id ?? null;
+    return {
+      id,
+      url: id ? `${this.baseUrl}/browse/${key}?focusedCommentId=${id}` : `${this.baseUrl}/browse/${key}`
+    };
+  }
+};
+
+// src/integrations/jira/config.ts
+var JIRA_CONFIG_KEY = "integration:jira";
+function readJiraConfig(db2) {
+  return readAppSetting(db2, JIRA_CONFIG_KEY);
+}
+function writeJiraConfig(db2, config2) {
+  writeAppSetting(db2, JIRA_CONFIG_KEY, config2);
+}
+function deleteJiraConfig(db2) {
+  db2.delete(appSettings).where(eq(appSettings.key, JIRA_CONFIG_KEY)).run();
+}
+
+// src/trpc/routers/integrations.router.ts
+function maskToken(token) {
+  return token.length <= 4 ? "\u2022\u2022\u2022\u2022" : "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022" + token.slice(-4);
+}
+var integrationsRouter = router({
+  getJira: publicProcedure.query(({ ctx }) => {
+    const config2 = readJiraConfig(ctx.db);
+    if (!config2) return { configured: false, config: null };
+    return {
+      configured: true,
+      config: {
+        domain: config2.domain,
+        email: config2.email,
+        apiToken: maskToken(config2.apiToken)
+      }
+    };
+  }),
+  saveJira: publicProcedure.input(
+    external_exports.object({
+      domain: external_exports.string().min(1),
+      email: external_exports.string().min(1),
+      apiToken: external_exports.string().min(1)
+    })
+  ).mutation(async ({ ctx, input }) => {
+    const domain2 = normalizeJiraDomain(input.domain);
+    if (!/^[a-z0-9][a-z0-9-]*$/i.test(domain2)) {
+      return {
+        success: false,
+        error: 'Enter just your Jira site name, e.g. "yourco" for yourco.atlassian.net'
+      };
+    }
+    const config2 = { domain: domain2, email: input.email.trim(), apiToken: input.apiToken.trim() };
+    const result = await new JiraClient(config2).validate();
+    if (!result.ok) {
+      return { success: false, error: result.error ?? "Connection failed" };
+    }
+    writeJiraConfig(ctx.db, config2);
+    return { success: true };
+  }),
+  removeJira: publicProcedure.mutation(({ ctx }) => {
+    deleteJiraConfig(ctx.db);
+    return { success: true };
+  })
+});
+
 // src/trpc/router.ts
 var appRouter = router({
   provider: providerRouter,
+  integrations: integrationsRouter,
   settings: settingsRouter,
   memory: memoryRouter,
   sessions: sessionsRouter,
@@ -58036,8 +59078,51 @@ async function runChatAgent({ sessionId, messages, summary, summaryUpTo, context
   return { stream: stream2 };
 }
 
+// src/integrations/jira/tools.ts
+var JIRA_PROMPT_FRAGMENT = `## Jira
+You can read Jira issues and post comments via the jira tools.
+- Use get_jira_issue when the user references a ticket key (LETTERS-NUMBER, e.g. PROJ-123) or asks what a ticket says.
+- Use add_jira_comment ONLY when the user explicitly asks to comment on, post to, or update a ticket. Never post proactively or as a side effect of analysis.
+- Before posting, show the exact comment text and target issue key. Comment bodies are plain text. Report the resulting comment URL on success.`;
+function getJiraChatTools(db2) {
+  const config2 = readJiraConfig(db2);
+  if (!config2) return null;
+  const client = new JiraClient(config2);
+  const tools = {
+    get_jira_issue: tool({
+      description: "Read a Jira issue's summary, description, and status by its issue key (e.g. PROJ-123).",
+      inputSchema: external_exports.object({
+        issueKey: external_exports.string().describe("Jira issue key, e.g. PROJ-123")
+      }),
+      execute: async ({ issueKey }) => {
+        try {
+          return { issue: await client.getIssue(issueKey) };
+        } catch (err) {
+          return { error: err instanceof Error ? err.message : String(err) };
+        }
+      }
+    }),
+    add_jira_comment: tool({
+      description: "Post a plain-text comment to a Jira issue. Only call when the user explicitly asks to comment on or update a ticket.",
+      inputSchema: external_exports.object({
+        issueKey: external_exports.string().describe("Jira issue key, e.g. PROJ-123"),
+        body: external_exports.string().min(1).describe("Plain-text comment body")
+      }),
+      execute: async ({ issueKey, body }) => {
+        try {
+          const result = await client.addComment(issueKey, body);
+          return { posted: true, commentId: result.id, url: result.url };
+        } catch (err) {
+          return { posted: false, error: err instanceof Error ? err.message : String(err) };
+        }
+      }
+    })
+  };
+  return { tools, promptFragment: JIRA_PROMPT_FRAGMENT };
+}
+
 // src/tools/shared-tool-setup.ts
-function collectBaseTools(registry2, db2, writer, mode, activeProvider) {
+function collectBaseTools(registry2, db2, writer, mode, activeProvider, includeIntegrations = false) {
   const memories = db2.select().from(toolMemories).all();
   const tools = {};
   const promptFragments = [];
@@ -58070,7 +59155,12 @@ function collectBaseTools(registry2, db2, writer, mode, activeProvider) {
       }
     }
   }
-  const systemPrompt = mode === "unified" ? promptFragments.length > 0 ? injectMemories(
+  const jiraKit = includeIntegrations ? getJiraChatTools(db2) : null;
+  if (jiraKit) {
+    Object.assign(tools, jiraKit.tools);
+    promptFragments.push(jiraKit.promptFragment);
+  }
+  let systemPrompt = mode === "unified" ? promptFragments.length > 0 ? injectMemories(
     buildUnifiedModePrompt(promptFragments, maxSteps ?? DEFAULTS.directModeMaxSteps),
     // Unified holds every connected provider's tools, so surface all their memories
     // (direct mode injects the active provider's memories via its own systemPrompt).
@@ -58079,6 +59169,9 @@ function collectBaseTools(registry2, db2, writer, mode, activeProvider) {
       existingMemories: memories.filter((m) => connectedProviders.some((p) => p.type === m.toolName))
     }
   ) : void 0 : systemPrompts.length > 0 ? systemPrompts.join("\n\n---\n\n") : void 0;
+  if (mode !== "unified" && jiraKit && systemPrompt) {
+    systemPrompt += "\n\n" + jiraKit.promptFragment;
+  }
   const afterComplete = afterCompleteCallbacks.length > 0 ? (params) => {
     for (const cb of afterCompleteCallbacks) cb(params);
   } : void 0;
@@ -58087,8 +59180,8 @@ function collectBaseTools(registry2, db2, writer, mode, activeProvider) {
 
 // src/tools/chat-tools.ts
 function collectChatTools(registry2, db2, writer, activeProvider, mode = DEFAULT_CHAT_MODE) {
-  const { tools, promptFragments, systemPrompt, maxSteps, afterComplete, connectedProviders } = collectBaseTools(registry2, db2, writer, mode, activeProvider);
-  if (connectedProviders.length === 0) {
+  const { tools, promptFragments, systemPrompt, maxSteps, afterComplete, connectedProviders } = collectBaseTools(registry2, db2, writer, mode, activeProvider, true);
+  if (connectedProviders.length === 0 && (!tools || Object.keys(tools).length === 0)) {
     return { tools: void 0, promptFragments: [] };
   }
   return { tools, promptFragments, systemPrompt, maxSteps, afterComplete };
@@ -59054,7 +60147,7 @@ function registerApiRoutes(app, context2) {
 }
 
 // src/http/static.ts
-import { readFileSync as readFileSync4, existsSync, statSync } from "fs";
+import { readFileSync as readFileSync5, existsSync as existsSync3, statSync } from "fs";
 import { resolve as resolve3, dirname as dirname3, extname } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var MIME_TYPES = {
@@ -59076,9 +60169,9 @@ function mountStaticFiles(app) {
     resolve3(process.cwd(), "packages/web/dist")
     // dev production build from repo root
   ];
-  const webRoot = webCandidates.find((d) => existsSync(resolve3(d, "index.html")));
+  const webRoot = webCandidates.find((d) => existsSync3(resolve3(d, "index.html")));
   if (!webRoot) return;
-  const indexHtml = readFileSync4(resolve3(webRoot, "index.html"), "utf-8");
+  const indexHtml = readFileSync5(resolve3(webRoot, "index.html"), "utf-8");
   const fileCache = /* @__PURE__ */ new Map();
   app.use("*", async (c, next) => {
     const reqPath = c.req.path.slice(1);
@@ -59089,7 +60182,7 @@ function mountStaticFiles(app) {
     let file2 = fileCache.get(reqPath);
     if (!file2) {
       const filePath = resolve3(webRoot, reqPath);
-      if (!filePath.startsWith(webRoot) || !existsSync(filePath) || statSync(filePath).isDirectory()) {
+      if (!filePath.startsWith(webRoot) || !existsSync3(filePath) || statSync(filePath).isDirectory()) {
         await next();
         return;
       }
@@ -59098,7 +60191,7 @@ function mountStaticFiles(app) {
       if (reqPath.startsWith("assets/")) {
         headers["Cache-Control"] = "public, max-age=31536000, immutable";
       }
-      file2 = { body: readFileSync4(filePath), headers };
+      file2 = { body: readFileSync5(filePath), headers };
       fileCache.set(reqPath, file2);
     }
     return c.body(file2.body, { headers: file2.headers });