@tool-bridge/server 0.1.0 → 0.3.0

package/dist/shodan-SGRKU4KS.js

@@ -0,0 +1,303 @@
+import {
+  createProviderPlugin,
+  guardedFetch,
+  requireApiKey,
+  upstreamError
+} from "./chunk-CSJEZHQO.js";
+import "./chunk-K7FVSFUX.js";
+import {
+  TBError,
+  external_exports
+} from "./chunk-JLTYA2B3.js";
+import "./chunk-MLKGABMK.js";
+
+// ../plugins/src/shodan/api.ts
+var SERVICE = "shodan";
+var API_BASE = "https://api.shodan.io";
+var API_INFO_PATH = "/api-info";
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function invalidResponse(field) {
+  return upstreamError(502, `Shodan ${field} response is invalid`);
+}
+function requiredText(value, field) {
+  if (typeof value !== "string" || value.trim() === "") throw invalidResponse(field);
+  return value.trim();
+}
+function requiredCount(value, field) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) throw invalidResponse(field);
+  return value;
+}
+function optionalCount(value, field) {
+  return value === void 0 ? void 0 : requiredCount(value, field);
+}
+function optionalFlag(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function objectArray(value, field) {
+  if (!Array.isArray(value) || value.some((item) => record(item) === void 0)) throw invalidResponse(field);
+  return value;
+}
+function textArray(value, field) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || item.trim() === "")) {
+    throw invalidResponse(field);
+  }
+  return value.map((item) => item.trim());
+}
+function compact(input) {
+  return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0));
+}
+function errorMessage(payload, status) {
+  if (typeof payload === "string" && payload.trim() !== "") return payload.trim();
+  const body = record(payload);
+  for (const key of ["error", "message"]) {
+    const value = body?.[key];
+    if (typeof value === "string" && value.trim() !== "") return value.trim();
+  }
+  return `Shodan request failed with ${status || 500}`;
+}
+async function request(ctx, path, query = {}) {
+  const url = new URL(path, API_BASE);
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== void 0) url.searchParams.set(key, String(value));
+  }
+  url.searchParams.set("key", requireApiKey(ctx, SERVICE));
+  let response;
+  let raw;
+  try {
+    response = await guardedFetch(url.toString(), { method: "GET", headers: { accept: "application/json" } });
+    raw = await response.text();
+  } catch (error) {
+    const message = error instanceof Error ? `Shodan request failed: ${error.message}` : "Shodan request failed";
+    throw upstreamError(502, message);
+  }
+  let payload = null;
+  if (raw !== "") {
+    try {
+      payload = JSON.parse(raw);
+    } catch {
+      if (response.ok) throw upstreamError(502, "Shodan returned invalid JSON");
+      payload = raw;
+    }
+  }
+  if (!response.ok) throw upstreamError(response.status, errorMessage(payload, response.status));
+  const body = record(payload);
+  if (body === void 0) throw upstreamError(502, "Shodan returned an invalid JSON response");
+  return body;
+}
+function joinCommaList(values, field) {
+  if (values === void 0 || values.length === 0) {
+    throw new TBError("invalid_argument", `${field} is required`);
+  }
+  return values.map((item, index) => {
+    const trimmed = item.trim();
+    if (trimmed === "") throw new TBError("invalid_argument", `${field}[${index}] is required`);
+    if (trimmed.includes(",")) throw new TBError("invalid_argument", `${field}[${index}] must not contain commas`);
+    return trimmed;
+  }).join(",");
+}
+async function getApiInfo(_input, ctx) {
+  const payload = await request(ctx, API_INFO_PATH);
+  return compact({
+    plan: requiredText(payload.plan, "plan"),
+    https: optionalFlag(payload.https),
+    monitored_ips: requiredCount(payload.monitored_ips, "monitored_ips"),
+    query_credits: requiredCount(payload.query_credits, "query_credits"),
+    scan_credits: requiredCount(payload.scan_credits, "scan_credits"),
+    telnet: optionalFlag(payload.telnet),
+    unlocked: optionalFlag(payload.unlocked),
+    unlocked_left: optionalCount(payload.unlocked_left, "unlocked_left"),
+    usage_limits: record(payload.usage_limits)
+  });
+}
+async function searchHosts(input, ctx) {
+  const payload = await request(ctx, "/shodan/host/search", {
+    query: input.query,
+    facets: input.facets,
+    page: input.page,
+    minify: input.minify
+  });
+  return compact({
+    matches: objectArray(payload.matches, "matches"),
+    total: requiredCount(payload.total, "total"),
+    facets: record(payload.facets)
+  });
+}
+async function countSearchResults(input, ctx) {
+  const payload = await request(ctx, "/shodan/host/count", { query: input.query, facets: input.facets });
+  return compact({
+    total: requiredCount(payload.total, "total"),
+    facets: record(payload.facets)
+  });
+}
+async function getHost(input, ctx) {
+  const path = `/shodan/host/${encodeURIComponent(input.ip)}`;
+  return { host: await request(ctx, path, { history: input.history, minify: input.minify }) };
+}
+async function getDomainInfo(input, ctx) {
+  if (input.domain === void 0 || input.domain.trim() === "") {
+    throw new TBError("invalid_argument", "domain is required");
+  }
+  const payload = await request(ctx, `/dns/domain/${encodeURIComponent(input.domain.trim())}`);
+  return {
+    domain: requiredText(payload.domain, "domain"),
+    tags: textArray(payload.tags, "tags"),
+    data: payload.data === void 0 ? [] : objectArray(payload.data, "data"),
+    subdomains: textArray(payload.subdomains, "subdomains"),
+    more: optionalFlag(payload.more) ?? false
+  };
+}
+async function resolveHostnames(input, ctx) {
+  const payload = await request(ctx, "/dns/resolve", {
+    hostnames: joinCommaList(input.hostnames, "hostnames")
+  });
+  const entries = Object.entries(payload).flatMap(([key, value]) => {
+    if (value === null) return [];
+    if (typeof value !== "string" || value.trim() === "") throw invalidResponse("results");
+    return [[key, value.trim()]];
+  });
+  return { results: Object.fromEntries(entries) };
+}
+async function reverseDnsLookup(input, ctx) {
+  const payload = await request(ctx, "/dns/reverse", { ips: joinCommaList(input.ips, "ips") });
+  const entries = Object.entries(payload).map(([key, value]) => {
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || item.trim() === "")) {
+      throw invalidResponse("results");
+    }
+    return [key, value.map((item) => item.trim())];
+  });
+  return { results: Object.fromEntries(entries) };
+}
+
+// ../plugins/src/shodan/schema.ts
+var getApiInfoInput = external_exports.strictObject({}).describe("Input parameters for retrieving Shodan API account information.");
+var getApiInfoOutput = external_exports.strictObject({
+  plan: external_exports.string().min(1).describe("Subscription plan name returned by Shodan."),
+  https: external_exports.boolean().describe("Whether HTTPS scanning access is enabled for the API key.").optional(),
+  monitored_ips: external_exports.int().min(0).describe("Number of monitored IP addresses currently tracked by the account."),
+  query_credits: external_exports.int().min(0).describe("Remaining query credits available to the API key."),
+  scan_credits: external_exports.int().min(0).describe("Remaining scan credits available to the API key."),
+  telnet: external_exports.boolean().describe("Whether telnet access is enabled for the API key.").optional(),
+  unlocked: external_exports.boolean().describe("Whether unlocked search filters are enabled for the API key.").optional(),
+  unlocked_left: external_exports.int().min(0).describe("Remaining unlocked query credits available to the API key.").optional(),
+  usage_limits: external_exports.looseObject({}).describe("Raw JSON object returned by Shodan.").optional()
+}).describe("API account information returned by Shodan.");
+var searchHostsInput = external_exports.strictObject({
+  query: external_exports.string().min(1).describe("Search query string passed to the Shodan host search endpoint."),
+  facets: external_exports.string().min(1).describe("Facet aggregation string such as org:5,country:3.").optional(),
+  page: external_exports.int().min(1).describe("1-based results page to request from Shodan.").optional(),
+  minify: external_exports.boolean().describe("Whether to request minified banner results from Shodan.").optional()
+}).describe("Input parameters for searching hosts in Shodan.");
+var searchHostsOutput = external_exports.strictObject({
+  matches: external_exports.array(external_exports.looseObject({}).describe("Raw JSON object returned by Shodan.")).describe("List of raw JSON objects returned by Shodan."),
+  total: external_exports.int().min(0).describe("Total number of matching hosts."),
+  facets: external_exports.looseObject({}).describe("Raw JSON object returned by Shodan.").optional()
+}).describe("Normalized host search results returned by Shodan.");
+var countSearchResultsInput = external_exports.strictObject({
+  query: external_exports.string().min(1).describe("Search query string passed to the Shodan host count endpoint."),
+  facets: external_exports.string().min(1).describe("Facet aggregation string such as org:5,country:3.").optional()
+}).describe("Input parameters for counting Shodan host search results.");
+var countSearchResultsOutput = external_exports.strictObject({
+  total: external_exports.int().min(0).describe("Total number of matching hosts."),
+  facets: external_exports.looseObject({}).describe("Raw JSON object returned by Shodan.").optional()
+}).describe("Normalized host count results returned by Shodan.");
+var getHostInput = external_exports.strictObject({
+  ip: external_exports.string().min(1).describe("IPv4 or IPv6 address to inspect in Shodan."),
+  history: external_exports.boolean().describe("Whether to include historical banners for the host.").optional(),
+  minify: external_exports.boolean().describe("Whether to request a minified host payload from Shodan.").optional()
+}).describe("Input parameters for retrieving Shodan host details.");
+var getHostOutput = external_exports.strictObject({
+  host: external_exports.looseObject({}).describe("Raw JSON object returned by Shodan.").optional()
+}).describe("Normalized host details returned by Shodan.");
+var getDomainInfoInput = external_exports.strictObject({
+  domain: external_exports.string().min(1).describe("Domain name to inspect in the Shodan DNS endpoint.").optional()
+}).describe("Input parameters for retrieving Shodan domain information.");
+var getDomainInfoOutput = external_exports.strictObject({
+  domain: external_exports.string().min(1).describe("Domain name returned by Shodan.").optional(),
+  tags: external_exports.array(external_exports.string().min(1).describe("One tag returned by Shodan for the requested domain.")).describe("Tags returned by Shodan for the requested domain.").optional(),
+  data: external_exports.array(external_exports.looseObject({}).describe("Raw JSON object returned by Shodan.")).describe("List of raw JSON objects returned by Shodan.").optional(),
+  subdomains: external_exports.array(external_exports.string().min(1).describe("One subdomain label returned by Shodan.")).describe("Known subdomain labels returned by Shodan.").optional(),
+  more: external_exports.boolean().describe("Whether Shodan has additional subdomain data beyond the current payload.").optional()
+}).describe("Normalized domain information returned by Shodan.");
+var resolveHostnamesInput = external_exports.strictObject({
+  hostnames: external_exports.array(external_exports.string().min(1).describe("One hostname to resolve in Shodan.")).min(1).describe("Hostnames to resolve with Shodan.").optional()
+}).describe("Input parameters for resolving hostnames with Shodan.");
+var resolveHostnamesOutput = external_exports.strictObject({
+  results: external_exports.record(external_exports.string(), external_exports.string().min(1).describe("Resolved IP address returned by Shodan.")).describe("Mapping of hostname to resolved IP address returned by Shodan.").optional()
+}).describe("Normalized hostname resolution results returned by Shodan.");
+var reverseDnsLookupInput = external_exports.strictObject({
+  ips: external_exports.array(external_exports.string().min(1).describe("One IP address to reverse-resolve in Shodan.")).min(1).describe("IP addresses to reverse-resolve with Shodan.").optional()
+}).describe("Input parameters for reverse-resolving IP addresses with Shodan.");
+var reverseDnsLookupOutput = external_exports.strictObject({
+  results: external_exports.record(external_exports.string(), external_exports.array(external_exports.string().min(1).describe("One hostname returned by Shodan for the IP address.")).describe("Hostnames returned by Shodan for one IP address.")).describe("Mapping of IP address to hostnames returned by Shodan.").optional()
+}).describe("Normalized reverse DNS results returned by Shodan.");
+var shodanActions = {
+  get_api_info: {
+    description: "Get API account information and remaining credits from Shodan.",
+    effect: "read",
+    inputSchema: getApiInfoInput,
+    outputSchema: external_exports.toJSONSchema(getApiInfoOutput, { io: "output", unrepresentable: "any" })
+  },
+  search_hosts: {
+    description: "Search Shodan hosts with a query string and optional facet aggregation.",
+    effect: "read",
+    inputSchema: searchHostsInput,
+    outputSchema: external_exports.toJSONSchema(searchHostsOutput, { io: "output", unrepresentable: "any" })
+  },
+  count_search_results: {
+    description: "Count Shodan hosts matching a query and optionally return facet aggregations.",
+    effect: "read",
+    inputSchema: countSearchResultsInput,
+    outputSchema: external_exports.toJSONSchema(countSearchResultsOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_host: {
+    description: "Get Shodan host details for one IP address.",
+    effect: "read",
+    inputSchema: getHostInput,
+    outputSchema: external_exports.toJSONSchema(getHostOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_domain_info: {
+    description: "Get DNS domain information and known subdomains from Shodan.",
+    effect: "read",
+    inputSchema: getDomainInfoInput,
+    outputSchema: external_exports.toJSONSchema(getDomainInfoOutput, { io: "output", unrepresentable: "any" })
+  },
+  resolve_hostnames: {
+    description: "Resolve hostnames to IP addresses with the Shodan DNS resolve endpoint.",
+    effect: "write",
+    inputSchema: resolveHostnamesInput,
+    outputSchema: external_exports.toJSONSchema(resolveHostnamesOutput, { io: "output", unrepresentable: "any" })
+  },
+  reverse_dns_lookup: {
+    description: "Reverse-resolve IP addresses to hostnames with the Shodan DNS reverse endpoint.",
+    effect: "write",
+    inputSchema: reverseDnsLookupInput,
+    outputSchema: external_exports.toJSONSchema(reverseDnsLookupOutput, { io: "output", unrepresentable: "any" })
+  }
+};
+
+// ../plugins/src/shodan/index.ts
+function createShodanPlugin() {
+  return createProviderPlugin({
+    description: "Shodan",
+    actions: shodanActions,
+    // 上游 credentialValidators 打的就是 /api-info;它只读、无入参,且不消耗 query credits。
+    credentialProbe: "get_api_info",
+    handlers: {
+      get_api_info: getApiInfo,
+      search_hosts: searchHosts,
+      count_search_results: countSearchResults,
+      get_host: getHost,
+      get_domain_info: getDomainInfo,
+      resolve_hostnames: resolveHostnames,
+      reverse_dns_lookup: reverseDnsLookup
+    }
+  });
+}
+var shodan_default = createShodanPlugin();
+export {
+  createShodanPlugin,
+  shodan_default as default
+};