@tool-bridge/server 0.21.1 → 0.22.1

package/dist/brave_search-TAATLZOS.js

@@ -0,0 +1,302 @@
+import {
+  createAuthedClient
+} from "./chunk-RTW5VRTK.js";
+import "./chunk-BNMLA2RC.js";
+import {
+  asJsonObject,
+  compactDefined,
+  trimmedText
+} from "./chunk-JXHMDBAY.js";
+import {
+  createProviderPlugin,
+  upstreamError
+} from "./chunk-X7ZUTKHR.js";
+import "./chunk-7ISGFRC6.js";
+import "./chunk-UY6ANCOY.js";
+import {
+  TBError
+} from "./chunk-HA4BGL6C.js";
+import "./chunk-U67V476Y.js";
+
+// ../plugins/src/brave_search/api.ts
+var SERVICE = "brave_search";
+var API_BASE = "https://api.search.brave.com";
+var RATE_LIMIT_CODES = /* @__PURE__ */ new Set(["QUOTA_LIMITED", "RATE_LIMITED", "USAGE_LIMIT_EXCEEDED"]);
+var AUTH_CODES = /* @__PURE__ */ new Set(["SUBSCRIPTION_TOKEN_INVALID", "SUBSCRIPTION_NOT_FOUND"]);
+var INVALID_CODES = /* @__PURE__ */ new Set(["RESOURCE_NOT_ALLOWED", "OPTION_NOT_IN_PLAN", "INVALID_URL"]);
+function nullableRecord(value) {
+  return value === null ? null : asJsonObject(value);
+}
+function requireRecord(value, label) {
+  const result = asJsonObject(value);
+  if (result === void 0) {
+    throw new TBError("unavailable", `${label}\u4E0D\u662F\u5BF9\u8C61`, { retryable: true });
+  }
+  return result;
+}
+function objectArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  return value.map((item) => requireRecord(item, "Brave Search \u7ED3\u679C\u9879"));
+}
+function searchTerm(value) {
+  const term = trimmedText(value);
+  if (term === void 0) throw new TBError("invalid_argument", "q \u4E0D\u80FD\u662F\u7A7A\u767D");
+  return term;
+}
+function goggles(value) {
+  if (value === void 0 || typeof value === "string") return trimmedText(value);
+  const items = value.map((item) => trimmedText(item)).filter((item) => item !== void 0);
+  return items.length > 0 ? items : void 0;
+}
+function braveSearchError(status, payload) {
+  const error = asJsonObject(asJsonObject(payload)?.error);
+  const message = trimmedText(error?.detail) ?? trimmedText(error?.code) ?? `Brave Search \u8FD4\u56DE HTTP ${status}`;
+  const code = trimmedText(error?.code);
+  if (code !== void 0) {
+    if (RATE_LIMIT_CODES.has(code)) return upstreamError(429, message);
+    if (AUTH_CODES.has(code)) return upstreamError(401, message);
+    if (INVALID_CODES.has(code)) return upstreamError(400, message);
+  }
+  return upstreamError(status, message);
+}
+var http = createAuthedClient({
+  baseUrl: `${API_BASE}/`,
+  service: SERVICE,
+  auth: { kind: "header", name: "x-subscription-token" },
+  headers: { accept: "application/json" },
+  // 稳定错误码码表比 HTTP 状态准,整段覆写而不用标准键序提取。
+  mapError: ({ data: payload, status }) => braveSearchError(status, payload)
+});
+async function request(ctx, path, query) {
+  const { data } = await http.request(ctx, {
+    path,
+    method: "GET",
+    query: Object.entries(query),
+    invalidJsonMessage: "Brave Search \u8FD4\u56DE\u4E86\u975E JSON \u54CD\u5E94"
+  });
+  return data ?? null;
+}
+function normalizeWebSearch(payload) {
+  const result = requireRecord(payload, "Brave Search \u54CD\u5E94");
+  return compactDefined({
+    type: trimmedText(result.type) ?? "search",
+    query: nullableRecord(result.query),
+    web: nullableRecord(result.web),
+    news: nullableRecord(result.news),
+    videos: nullableRecord(result.videos),
+    locations: nullableRecord(result.locations),
+    discussions: nullableRecord(result.discussions),
+    faq: nullableRecord(result.faq),
+    infobox: nullableRecord(result.infobox),
+    mixed: nullableRecord(result.mixed),
+    summarizer: nullableRecord(result.summarizer),
+    rich: nullableRecord(result.rich)
+  });
+}
+function normalizeCollection(payload, withExtra) {
+  const result = requireRecord(payload, "Brave Search \u54CD\u5E94");
+  return compactDefined({
+    type: trimmedText(result.type) ?? "search",
+    query: nullableRecord(result.query),
+    results: objectArray(result.results),
+    extra: withExtra ? nullableRecord(result.extra) : void 0
+  });
+}
+async function webSearch(input, ctx) {
+  return normalizeWebSearch(await request(ctx, "/res/v1/web/search", {
+    q: searchTerm(input.q),
+    search_lang: trimmedText(input.search_lang),
+    ui_lang: trimmedText(input.ui_lang),
+    country: trimmedText(input.country),
+    safesearch: trimmedText(input.safesearch),
+    count: input.count,
+    offset: input.offset,
+    spellcheck: input.spellcheck,
+    freshness: trimmedText(input.freshness),
+    result_filter: trimmedText(input.result_filter),
+    extra_snippets: input.extra_snippets,
+    goggles: goggles(input.goggles),
+    text_decorations: input.text_decorations,
+    units: trimmedText(input.units),
+    operators: input.operators,
+    include_fetch_metadata: input.include_fetch_metadata
+  }));
+}
+async function newsSearch(input, ctx) {
+  const payload = await request(ctx, "/res/v1/news/search", {
+    q: searchTerm(input.q),
+    search_lang: trimmedText(input.search_lang),
+    ui_lang: trimmedText(input.ui_lang),
+    country: trimmedText(input.country),
+    safesearch: trimmedText(input.safesearch),
+    count: input.count,
+    offset: input.offset,
+    spellcheck: input.spellcheck,
+    freshness: trimmedText(input.freshness),
+    extra_snippets: input.extra_snippets,
+    goggles: goggles(input.goggles),
+    operators: input.operators,
+    include_fetch_metadata: input.include_fetch_metadata
+  });
+  return normalizeCollection(payload, false);
+}
+async function videoSearch(input, ctx) {
+  const payload = await request(ctx, "/res/v1/videos/search", {
+    q: searchTerm(input.q),
+    search_lang: trimmedText(input.search_lang),
+    ui_lang: trimmedText(input.ui_lang),
+    country: trimmedText(input.country),
+    safesearch: trimmedText(input.safesearch),
+    count: input.count,
+    offset: input.offset,
+    spellcheck: input.spellcheck,
+    freshness: trimmedText(input.freshness),
+    operators: input.operators,
+    include_fetch_metadata: input.include_fetch_metadata
+  });
+  return normalizeCollection(payload, true);
+}
+async function imageSearch(input, ctx) {
+  const payload = await request(ctx, "/res/v1/images/search", {
+    q: searchTerm(input.q),
+    search_lang: trimmedText(input.search_lang),
+    country: trimmedText(input.country),
+    safesearch: trimmedText(input.safesearch),
+    count: input.count,
+    spellcheck: input.spellcheck
+  });
+  return normalizeCollection(payload, true);
+}
+
+// ../plugins/src/brave_search/schema.ts
+import { z } from "zod/v4";
+var webSearchInput = z.strictObject({
+  q: z.string().min(1).max(400).describe("The user's search query term. Maximum of 400 characters."),
+  search_lang: z.string().min(2).describe("The preferred search result language code.").optional(),
+  ui_lang: z.string().min(2).describe("The preferred user interface language for response formatting.").optional(),
+  country: z.string().min(2).max(3).describe("The two-letter country code for result localization, or ALL for worldwide results.").optional(),
+  safesearch: z.enum(["off", "moderate", "strict"]).describe("Filters adult content from web results.").optional(),
+  count: z.int().min(1).max(20).describe("The maximum number of web results to return.").optional(),
+  offset: z.int().min(0).max(9).describe("The zero-based results page offset used for pagination.").optional(),
+  spellcheck: z.boolean().describe("Whether Brave Search should spellcheck the query before searching.").optional(),
+  freshness: z.union([z.enum(["pd", "pw", "pm", "py"]).describe("A predefined freshness window such as past day or past year."), z.string().min(1).describe("A custom date range in the format YYYY-MM-DDtoYYYY-MM-DD.")]).describe("Filters web results by page age.").optional(),
+  result_filter: z.string().min(1).describe("A comma-delimited list of result types to include, such as web,news,videos,locations,discussions,faq,infobox,mixed,summarizer or rich.").optional(),
+  extra_snippets: z.boolean().describe("Whether Brave Search should return extra alternate snippets.").optional(),
+  goggles: z.union([z.string().min(1).describe("One goggle URL or inline definition."), z.array(z.string().min(1).describe("One goggle URL or inline definition.")).min(1).describe("Multiple goggles to apply to the search request.")]).describe("One or more Brave Search goggles used to rerank results.").optional(),
+  text_decorations: z.boolean().describe("Whether display strings should include decoration markers such as highlights.").optional(),
+  units: z.enum(["metric", "imperial"]).describe("The measurement units used for localized results.").optional(),
+  operators: z.boolean().describe("Whether Brave Search should apply search operators.").optional(),
+  include_fetch_metadata: z.boolean().describe("Whether Brave Search should include fetch metadata in results when available.").optional()
+}).describe("Input parameters for a Brave Search web search request.");
+var webSearchOutput = z.strictObject({
+  type: z.string().describe("The Brave Search response type."),
+  query: z.looseObject({}).describe("Query metadata returned by Brave Search.").nullable().optional(),
+  web: z.looseObject({}).describe("Web result payload returned by Brave Search.").nullable().optional(),
+  news: z.looseObject({}).describe("News result payload returned by Brave Search.").nullable().optional(),
+  videos: z.looseObject({}).describe("Video result payload returned by Brave Search.").nullable().optional(),
+  locations: z.looseObject({}).describe("Location result payload returned by Brave Search.").nullable().optional(),
+  discussions: z.looseObject({}).describe("Discussion clusters returned by Brave Search.").nullable().optional(),
+  faq: z.looseObject({}).describe("Frequently asked questions returned by Brave Search.").nullable().optional(),
+  infobox: z.looseObject({}).describe("Infobox payload returned by Brave Search.").nullable().optional(),
+  mixed: z.looseObject({}).describe("Mixed ranking payload returned by Brave Search.").nullable().optional(),
+  summarizer: z.looseObject({}).describe("Summary metadata returned by Brave Search.").nullable().optional(),
+  rich: z.looseObject({}).describe("Rich result callback payload returned by Brave Search.").nullable().optional()
+}).describe("A normalized Brave Search web search response.");
+var newsSearchInput = z.strictObject({
+  q: z.string().min(1).max(400).describe("The user's search query term. Maximum of 400 characters."),
+  search_lang: z.string().min(2).describe("The preferred search result language code.").optional(),
+  ui_lang: z.string().min(2).describe("The preferred user interface language for response formatting.").optional(),
+  country: z.string().min(2).max(3).describe("The two-letter country code for result localization, or ALL for worldwide results.").optional(),
+  safesearch: z.enum(["off", "moderate", "strict"]).describe("Filters adult content from news results.").optional(),
+  count: z.int().min(1).max(50).describe("The maximum number of results to return.").optional(),
+  offset: z.int().min(0).max(9).describe("The zero-based results page offset used for pagination.").optional(),
+  spellcheck: z.boolean().describe("Whether Brave Search should spellcheck the query before searching.").optional(),
+  freshness: z.union([z.enum(["pd", "pw", "pm", "py"]).describe("A predefined freshness window such as past day or past year."), z.string().min(1).describe("A custom date range in the format YYYY-MM-DDtoYYYY-MM-DD.")]).describe("Filters news results by page age.").optional(),
+  extra_snippets: z.boolean().describe("Whether Brave Search should return extra alternate snippets.").optional(),
+  goggles: z.union([z.string().min(1).describe("One goggle URL or inline definition."), z.array(z.string().min(1).describe("One goggle URL or inline definition.")).min(1).describe("Multiple goggles to apply to the search request.")]).describe("One or more Brave Search goggles used to rerank results.").optional(),
+  operators: z.boolean().describe("Whether Brave Search should apply search operators.").optional(),
+  include_fetch_metadata: z.boolean().describe("Whether Brave Search should include fetch metadata in results when available.").optional()
+}).describe("Input parameters for a Brave Search news request.");
+var newsSearchOutput = z.strictObject({
+  type: z.string().describe("The Brave Search response type."),
+  query: z.looseObject({}).describe("Query metadata returned by Brave Search.").nullable().optional(),
+  results: z.array(z.looseObject({}).describe("One news result item returned by Brave Search.")).describe("The list of news results returned by Brave Search.").optional()
+}).describe("A normalized Brave Search news response.");
+var videoSearchInput = z.strictObject({
+  q: z.string().min(1).max(400).describe("The user's search query term. Maximum of 400 characters."),
+  search_lang: z.string().min(2).describe("The preferred search result language code.").optional(),
+  ui_lang: z.string().min(2).describe("The preferred user interface language for response formatting.").optional(),
+  country: z.string().min(2).max(3).describe("The two-letter country code for result localization, or ALL for worldwide results.").optional(),
+  safesearch: z.enum(["off", "moderate", "strict"]).describe("Filters adult content from video results.").optional(),
+  count: z.int().min(1).max(50).describe("The maximum number of results to return.").optional(),
+  offset: z.int().min(0).max(9).describe("The zero-based results page offset used for pagination.").optional(),
+  spellcheck: z.boolean().describe("Whether Brave Search should spellcheck the query before searching.").optional(),
+  freshness: z.union([z.enum(["pd", "pw", "pm", "py"]).describe("A predefined freshness window such as past day or past year."), z.string().min(1).describe("A custom date range in the format YYYY-MM-DDtoYYYY-MM-DD.")]).describe("Filters video results by page age.").optional(),
+  operators: z.boolean().describe("Whether Brave Search should apply search operators.").optional(),
+  include_fetch_metadata: z.boolean().describe("Whether Brave Search should include fetch metadata in results when available.").optional()
+}).describe("Input parameters for a Brave Search video request.");
+var videoSearchOutput = z.strictObject({
+  type: z.string().describe("The Brave Search response type."),
+  query: z.looseObject({}).describe("Query metadata returned by Brave Search.").nullable().optional(),
+  results: z.array(z.looseObject({}).describe("One video result item returned by Brave Search.")).describe("The list of video results returned by Brave Search.").optional(),
+  extra: z.looseObject({}).describe("Additional metadata returned with the video results.").nullable().optional()
+}).describe("A normalized Brave Search video response.");
+var imageSearchInput = z.strictObject({
+  q: z.string().min(1).max(400).describe("The user's search query term. Maximum of 400 characters."),
+  search_lang: z.string().min(2).describe("The preferred search result language code.").optional(),
+  country: z.string().min(2).max(3).describe("The two-letter country code for result localization, or ALL for worldwide results.").optional(),
+  safesearch: z.enum(["off", "strict"]).describe("Filters adult content from image results.").optional(),
+  count: z.int().min(1).max(200).describe("The maximum number of image results to return.").optional(),
+  spellcheck: z.boolean().describe("Whether Brave Search should spellcheck the query before searching.").optional()
+}).describe("Input parameters for a Brave Search image request.");
+var imageSearchOutput = z.strictObject({
+  type: z.string().describe("The Brave Search response type."),
+  query: z.looseObject({}).describe("Query metadata returned by Brave Search.").nullable().optional(),
+  results: z.array(z.looseObject({}).describe("One image result item returned by Brave Search.")).describe("The list of image results returned by Brave Search.").optional(),
+  extra: z.looseObject({}).describe("Additional metadata returned with the image results.").nullable().optional()
+}).describe("A normalized Brave Search image response.");
+var braveSearchActions = {
+  web_search: {
+    description: "Search the Brave Search web index and return the selected result families.",
+    effect: "write",
+    inputSchema: webSearchInput,
+    outputSchema: z.toJSONSchema(webSearchOutput, { io: "output", unrepresentable: "any" })
+  },
+  news_search: {
+    description: "Search Brave's news index for recent articles related to a query.",
+    effect: "write",
+    inputSchema: newsSearchInput,
+    outputSchema: z.toJSONSchema(newsSearchOutput, { io: "output", unrepresentable: "any" })
+  },
+  video_search: {
+    description: "Search Brave's video index for videos related to a query.",
+    effect: "write",
+    inputSchema: videoSearchInput,
+    outputSchema: z.toJSONSchema(videoSearchOutput, { io: "output", unrepresentable: "any" })
+  },
+  image_search: {
+    description: "Search Brave's image index for images related to a query.",
+    effect: "write",
+    inputSchema: imageSearchInput,
+    outputSchema: z.toJSONSchema(imageSearchOutput, { io: "output", unrepresentable: "any" })
+  }
+};
+
+// ../plugins/src/brave_search/index.ts
+function createBraveSearchPlugin() {
+  return createProviderPlugin({
+    description: "Brave Search",
+    actions: braveSearchActions,
+    handlers: {
+      web_search: webSearch,
+      news_search: newsSearch,
+      video_search: videoSearch,
+      image_search: imageSearch
+    }
+  });
+}
+var brave_search_default = createBraveSearchPlugin();
+export {
+  createBraveSearchPlugin,
+  brave_search_default as default
+};

package/dist/chunk-2IAI3XQM.js

@@ -0,0 +1,302 @@
+import {
+  TBError,
+  createEncryptionKeyring
+} from "./chunk-HA4BGL6C.js";
+
+// src/bootstrapState.ts
+import {
+  createHash,
+  randomBytes,
+  randomUUID,
+  timingSafeEqual
+} from "crypto";
+import { chmod, mkdir, readFile, stat, unlink } from "fs/promises";
+import writeFileAtomic from "write-file-atomic";
+import lockfile from "proper-lockfile";
+import { join } from "path";
+import { z } from "zod";
+var stateSchema = z.strictObject({
+  instanceId: z.uuid(),
+  revision: z.number().int().positive(),
+  phase: z.enum(["setup", "installing", "initialized"]),
+  databaseUrl: z.string().optional(),
+  redisUrl: z.string().optional(),
+  internalS3Origin: z.string().optional(),
+  port: z.number().int().min(0).max(65535).default(8787),
+  host: z.string().default("0.0.0.0")
+});
+var BootstrapStateStore = class {
+  constructor(directory) {
+    this.directory = directory;
+  }
+  directory;
+  path(name) {
+    return join(this.directory, name);
+  }
+  async exclusive(run, retries = 0) {
+    await mkdir(this.directory, { recursive: true, mode: 448 });
+    const release = await lockfile.lock(this.directory, {
+      retries,
+      stale: 6e4,
+      update: 1e4
+    }).catch((error) => {
+      if (error.code === "ELOCKED") {
+        throw new TBError("conflict", "another local maintenance operation is running");
+      }
+      throw error;
+    });
+    try {
+      return await run();
+    } finally {
+      await release();
+    }
+  }
+  async read(name) {
+    try {
+      const path = this.path(name);
+      const info = await stat(path);
+      if (process.platform !== "win32" && (info.mode & 63) !== 0) {
+        throw new TBError(
+          "unavailable",
+          "bootstrap files must be readable only by their owner"
+        );
+      }
+      return JSON.parse(await readFile(path, "utf8"));
+    } catch (error) {
+      if (error.code === "ENOENT") return void 0;
+      throw error;
+    }
+  }
+  async write(name, value) {
+    await writeFileAtomic(this.path(name), JSON.stringify(value) + "\n", {
+      mode: 384,
+      fsync: true
+    });
+  }
+  async state() {
+    const value = await this.read("bootstrap.json");
+    return value === void 0 ? void 0 : stateSchema.parse(value);
+  }
+  async initialize() {
+    return this.exclusive(async () => {
+      const current = await this.state();
+      if (current) {
+        if (await this.read("initialized.json"))
+          return { ...current, phase: "initialized" };
+        return current;
+      }
+      if (await this.read("identity.json"))
+        throw new TBError(
+          "unavailable",
+          "bootstrap state requires local recovery"
+        );
+      const state = {
+        instanceId: randomUUID(),
+        revision: 1,
+        phase: "setup",
+        port: 8787,
+        host: "0.0.0.0"
+      };
+      await this.write("identity.json", { instanceId: state.instanceId });
+      await this.write("keys.json", {
+        keyring: createEncryptionKeyring(randomBytes(32).toString("base64url")),
+        storeTokenKeyring: createEncryptionKeyring(
+          randomBytes(32).toString("base64url")
+        ),
+        oauthKey: randomBytes(32).toString("base64url"),
+        adminSk: `tb_sk_${randomBytes(32).toString("base64url")}`
+      });
+      await this.write("bootstrap.json", state);
+      await this.pair(state.instanceId, "setup");
+      return state;
+    }, 5);
+  }
+  async pair(instanceId, mode) {
+    const token = randomBytes(32).toString("base64url");
+    await this.write("pairing.json", {
+      instanceId,
+      mode,
+      tokenHash: this.hash(token),
+      expiresAt: Date.now() + 36e5
+    });
+    await writeFileAtomic(this.path("pairing-token"), token + "\n", {
+      mode: 384
+    });
+    return token;
+  }
+  async createLocalPairing(mode) {
+    return this.exclusive(async () => {
+      let state;
+      try {
+        state = await this.state();
+      } catch {
+      }
+      if (!state && mode === "recovery") {
+        const identity = await this.read(
+          "identity.json"
+        );
+        if (!identity || !z.uuid().safeParse(identity.instanceId).success)
+          throw new TBError(
+            "unavailable",
+            "instance identity requires a local backup"
+          );
+        const initialized = await this.read("initialized.json");
+        let keys = await this.read("keys.json");
+        if (!keys && !initialized) {
+          keys = {
+            keyring: createEncryptionKeyring(
+              randomBytes(32).toString("base64url")
+            ),
+            storeTokenKeyring: createEncryptionKeyring(
+              randomBytes(32).toString("base64url")
+            ),
+            oauthKey: randomBytes(32).toString("base64url"),
+            adminSk: `tb_sk_${randomBytes(32).toString("base64url")}`
+          };
+          await this.write("keys.json", keys);
+        }
+        state = {
+          instanceId: identity.instanceId,
+          phase: initialized ? "initialized" : "installing",
+          revision: 1,
+          port: 8787,
+          host: "0.0.0.0"
+        };
+        await this.write("bootstrap.json", state);
+      }
+      if (!state)
+        throw new TBError("unavailable", "bootstrap state unavailable");
+      if (mode === "setup" && (state.phase === "initialized" || await this.read("initialized.json")))
+        throw new TBError("permission_denied", "initial setup is closed");
+      return this.pair(state.instanceId, mode);
+    });
+  }
+  hash(value) {
+    return createHash("sha256").update(value).digest("hex");
+  }
+  async authorize(token, mode) {
+    const state = await this.state();
+    const pair = await this.read("pairing.json");
+    const initialized = await this.read(
+      "initialized.json"
+    );
+    if (!token || !state || !pair || pair.instanceId !== state.instanceId || pair.mode !== mode || pair.expiresAt <= Date.now() || initialized && initialized.instanceId !== state.instanceId || mode === "setup" && (state.phase === "initialized" || initialized !== void 0) || !/^[0-9a-f]{64}$/.test(pair.tokenHash) || !timingSafeEqual(
+      Buffer.from(this.hash(token)),
+      Buffer.from(pair.tokenHash)
+    )) {
+      throw new TBError(
+        "permission_denied",
+        "a valid local pairing credential is required"
+      );
+    }
+    return initialized ? { ...state, phase: "initialized" } : state;
+  }
+  async finish(state) {
+    await this.write("initialized.json", { instanceId: state.instanceId });
+    await this.write("bootstrap.json", {
+      ...state,
+      phase: "initialized",
+      revision: state.revision + 1
+    });
+    await unlink(this.path("pairing.json")).catch(() => {
+    });
+    await unlink(this.path("pairing-token")).catch(() => {
+    });
+  }
+  async defaults() {
+    return this.read(
+      "install-defaults.json"
+    );
+  }
+  async secureDirectory() {
+    await chmod(this.directory, 448);
+  }
+};
+
+// package.json
+var package_default = {
+  name: "@tool-bridge/server",
+  version: "0.22.1",
+  description: "Self-hosted Tool Bridge Node server with PostgreSQL, S3 object storage and WebSocket device channels",
+  type: "module",
+  license: "MIT",
+  main: "src/index.ts",
+  exports: {
+    ".": "./src/index.ts"
+  },
+  bin: {
+    "tool-bridge-server": "./dist/main.js",
+    "tool-bridge-admin": "./dist/admin.js"
+  },
+  files: [
+    "dist"
+  ],
+  engines: {
+    node: ">=22"
+  },
+  publishConfig: {
+    access: "public",
+    main: "./dist/index.js",
+    types: "./dist/index.d.ts",
+    exports: {
+      ".": {
+        types: "./dist/index.d.ts",
+        import: "./dist/index.js"
+      }
+    }
+  },
+  keywords: [
+    "self-hosted",
+    "docker",
+    "mcp",
+    "htbp",
+    "tool-bridge",
+    "agent-tools"
+  ],
+  scripts: {
+    typecheck: "tsc --noEmit",
+    test: "vitest run",
+    build: "tsup",
+    start: "tsx src/main.ts"
+  },
+  dependencies: {
+    "@hono/node-server": "catalog:",
+    "@tool-bridge/dashboard": "workspace:*",
+    hono: "catalog:",
+    ioredis: "^6.0.0",
+    postgres: "^3.4.9",
+    ws: "catalog:",
+    "@aws-sdk/client-s3": "^3.1127.0",
+    "@smithy/node-http-handler": "^4.12.1",
+    "ipaddr.js": "^2.5.0",
+    "write-file-atomic": "^7.0.0",
+    "proper-lockfile": "^4.1.2",
+    zod: "catalog:",
+    commander: "~15.0.0",
+    "p-retry": "^7.1.1",
+    negotiator: "^1.0.0"
+  },
+  devDependencies: {
+    "@tool-bridge/app": "workspace:*",
+    "@tool-bridge/core": "workspace:*",
+    "@tool-bridge/plugins": "workspace:*",
+    "@types/node": "catalog:",
+    "@types/ws": "catalog:",
+    tsup: "catalog:",
+    tsx: "catalog:",
+    vitest: "catalog:",
+    "@types/write-file-atomic": "^4.0.3",
+    "@types/proper-lockfile": "^4.1.4",
+    "@types/negotiator": "^0.6.4"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/TokenRollAI/tool-bridge.git",
+    directory: "packages/server"
+  }
+};
+
+export {
+  BootstrapStateStore,
+  package_default
+};