@nimbus-dev/connectors 0.1.0

package/connectors/google-photos/src/server.ts

@@ -0,0 +1,139 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+import {
+  fetchBearerAuthorizedJson,
+  resolveUrlWithBase,
+} from "../../../shared/fetch-bearer-json.ts";
+import { createRegisterSimpleTool, createZodToolRegistrar } from "../../../shared/mcp-tool-kit.ts";
+import { makeRestToolRegistrar } from "../../../shared/rest-tool-kit.ts";
+
+const PHOTOS_BASE = "https://photoslibrary.googleapis.com/v1";
+
+async function photosFetch(
+  token: string,
+  path: string,
+  init?: RequestInit,
+): Promise<{ ok: boolean; status: number; json: unknown; text: string }> {
+  const url = resolveUrlWithBase(PHOTOS_BASE, path);
+  return fetchBearerAuthorizedJson(url, token, init, { "Content-Type": "application/json" });
+}
+
+const server = new McpServer({ name: "nimbus-google-photos", version: "0.1.0" });
+
+const registerSimpleTool = createRegisterSimpleTool(server);
+const reg = createZodToolRegistrar(registerSimpleTool);
+
+/** Standard Photos tool: token → photosFetch(buildPath[, buildInit]) → mcpJsonResultIfOk("Google Photos API"). */
+const registerPhotosTool = makeRestToolRegistrar({
+  registrar: reg,
+  tokenEnv: "GOOGLE_OAUTH_ACCESS_TOKEN",
+  serviceLabel: "Google Photos API",
+  fetch: photosFetch,
+});
+
+const gphotosAlbumListArgs = z.object({
+  pageSize: z.number().int().min(1).max(50).optional(),
+  pageToken: z.string().optional(),
+});
+
+registerPhotosTool(
+  "gphotos_album_list",
+  "List Google Photos albums (metadata). Pagination via pageToken.",
+  gphotosAlbumListArgs,
+  (parsed) => {
+    const u = new URL(`${PHOTOS_BASE}/albums`);
+    u.searchParams.set("pageSize", String(parsed.pageSize ?? 25));
+    if (parsed.pageToken !== undefined && parsed.pageToken !== "") {
+      u.searchParams.set("pageToken", parsed.pageToken);
+    }
+    return `${u.pathname}${u.search}`;
+  },
+);
+
+const gphotosAlbumGetArgs = z.object({
+  albumId: z.string().min(1),
+});
+
+registerPhotosTool(
+  "gphotos_album_get",
+  "Get a single album by id (title, mediaItemsCount, coverPhotoBaseUrl).",
+  gphotosAlbumGetArgs,
+  (parsed) => `/albums/${encodeURIComponent(parsed.albumId)}`,
+);
+
+const gphotosMediaListArgs = z.object({
+  albumId: z.string().min(1).optional(),
+  pageSize: z.number().int().min(1).max(100).optional(),
+  pageToken: z.string().optional(),
+});
+
+registerPhotosTool(
+  "gphotos_media_list",
+  "List media items (metadata + baseUrl/productUrl only). Optional albumId scopes to one album.",
+  gphotosMediaListArgs,
+  () => "/mediaItems:search",
+  (parsed) => {
+    const body: Record<string, unknown> = {
+      pageSize: parsed.pageSize ?? 50,
+    };
+    if (parsed.pageToken !== undefined && parsed.pageToken !== "") {
+      body["pageToken"] = parsed.pageToken;
+    }
+    if (parsed.albumId !== undefined && parsed.albumId !== "") {
+      body["albumId"] = parsed.albumId;
+    }
+    return { method: "POST", body: JSON.stringify(body) };
+  },
+);
+
+const gphotosMediaGetArgs = z.object({
+  mediaItemId: z.string().min(1),
+});
+
+registerPhotosTool(
+  "gphotos_media_get",
+  "Get a single media item metadata by id.",
+  gphotosMediaGetArgs,
+  (parsed) => `/mediaItems/${encodeURIComponent(parsed.mediaItemId)}`,
+);
+
+const gphotosMediaSearchArgs = z.object({
+  albumId: z.string().min(1).optional(),
+  pageSize: z.number().int().min(1).max(100).optional(),
+  pageToken: z.string().optional(),
+  includeArchivedMedia: z.boolean().optional(),
+  excludeNonAppCreatedData: z.boolean().optional(),
+});
+
+registerPhotosTool(
+  "gphotos_media_search",
+  "Search media items (metadata only). Optional album filter; supports pagination.",
+  gphotosMediaSearchArgs,
+  () => "/mediaItems:search",
+  (parsed) => {
+    const body: Record<string, unknown> = {
+      pageSize: parsed.pageSize ?? 50,
+    };
+    if (parsed.pageToken !== undefined && parsed.pageToken !== "") {
+      body["pageToken"] = parsed.pageToken;
+    }
+    if (parsed.albumId !== undefined && parsed.albumId !== "") {
+      body["albumId"] = parsed.albumId;
+    }
+    const filters: Record<string, unknown> = {};
+    if (parsed.includeArchivedMedia === true) {
+      filters["includeArchivedMedia"] = true;
+    }
+    if (parsed.excludeNonAppCreatedData === true) {
+      filters["excludeNonAppCreatedData"] = true;
+    }
+    if (Object.keys(filters).length > 0) {
+      body["filters"] = filters;
+    }
+    return { method: "POST", body: JSON.stringify(body) };
+  },
+);
+
+await server.connect(new StdioServerTransport());

package/connectors/grafana/nimbus.extension.json

@@ -0,0 +1,15 @@
+{
+  "id": "com.nimbus.grafana",
+  "displayName": "Grafana",
+  "version": "0.1.0",
+  "description": "Grafana HTTP API connector (dashboards, datasources, alerting). Always user-configured — the target host is read from grafana.url at spawn time and merged into permissions.network by the Gateway. Read-focused.",
+  "author": "Nimbus",
+  "entrypoint": "dist/server.js",
+  "runtime": "bun",
+  "permissions": {
+    "network": []
+  },
+  "hitlRequired": [],
+  "syncInterval": 600,
+  "minNimbusVersion": "0.2.0"
+}

package/connectors/grafana/src/server.ts

@@ -0,0 +1,61 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+import {
+  createRegisterSimpleTool,
+  createZodToolRegistrar,
+  mcpJsonResult as jsonResult,
+} from "../../../shared/mcp-tool-kit.ts";
+
+function baseUrl(): string {
+  const u = process.env["GRAFANA_URL"]?.trim();
+  if (u === undefined || u === "") {
+    throw new Error("GRAFANA_URL is not set");
+  }
+  return u.replace(/\/$/, "");
+}
+
+function authHeaders(): Record<string, string> {
+  const tok = process.env["GRAFANA_API_TOKEN"]?.trim();
+  if (tok === undefined || tok === "") {
+    throw new Error("GRAFANA_API_TOKEN is not set");
+  }
+  return { Authorization: `Bearer ${tok}`, Accept: "application/json" };
+}
+
+async function grafanaGet(path: string): Promise<unknown> {
+  const pathPart = path.startsWith("/") ? path : `/${path}`;
+  const res = await fetch(`${baseUrl()}${pathPart}`, {
+    headers: authHeaders(),
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    throw new Error(`Grafana ${String(res.status)}: ${text.slice(0, 400)}`);
+  }
+  try {
+    return JSON.parse(text) as unknown;
+  } catch {
+    return { raw: text };
+  }
+}
+
+const mcp = new McpServer({ name: "nimbus-grafana", version: "0.1.0" });
+const reg = createZodToolRegistrar(createRegisterSimpleTool(mcp));
+
+reg("grafana_alert_list", "List alert rules (Ruler API).", z.object({}), async () =>
+  jsonResult(await grafanaGet("/api/ruler/grafana/api/v1/rules")),
+);
+
+reg(
+  "grafana_dashboard_list",
+  "Search dashboards.",
+  z.object({ query: z.string().optional() }),
+  async (p) => {
+    const q = p.query ?? "";
+    return jsonResult(await grafanaGet(`/api/search?type=dash-db&query=${encodeURIComponent(q)}`));
+  },
+);
+
+const transport = new StdioServerTransport();
+await mcp.connect(transport);

package/connectors/great-expectations/nimbus.extension.json

@@ -0,0 +1,16 @@
+{
+  "id": "com.nimbus.great-expectations",
+  "displayName": "Great Expectations",
+  "version": "0.1.0",
+  "description": "Great Expectations validation-result metadata connector (Tier-3, no-row-data). Reads GX validation-result JSON artefacts written by CI runs from a configured local directory and indexes the validation METADATA per expectation — suite name, batch id, expectation type, column, success/failure, the aggregate observed value (a count/fraction/mean metric), element and unexpected counts, and run time. It NEVER reads or indexes the failing-data SAMPLES (unexpected_list / partial_unexpected_list / partial_unexpected_index_list / unexpected_index_list / partial_unexpected_counts) — those carry real data cell values (row data) and are stripped on read. No network, no live credentials. Read-only; no write tools.",
+  "author": "Nimbus",
+  "entrypoint": "dist/server.js",
+  "runtime": "bun",
+  "permissions": {
+    "network": [],
+    "filesystem": { "read": [], "write": [] }
+  },
+  "hitlRequired": [],
+  "syncInterval": 600,
+  "minNimbusVersion": "0.2.0"
+}

package/connectors/great-expectations/src/gx-parse.ts

@@ -0,0 +1,292 @@
+import { readdir, readFile } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+
+/**
+ * Tier-3 no-row-data reader for Great Expectations validation-result JSON
+ * artefacts. This module is the MCP-server-side counterpart of the gateway's
+ * pure `mapGreatExpectationsResultToItem` mapper: BOTH strip the failing-data
+ * SAMPLE lists so no real data cell value ever leaves the artefact dir.
+ *
+ * GX validation-result `result` objects carry aggregate metrics (observed_value
+ * scalar, element_count, unexpected_count, unexpected_percent) AND, for failing
+ * expectations, sampled rows of the actual unexpected DATA in:
+ *   - unexpected_list
+ *   - partial_unexpected_list
+ *   - partial_unexpected_index_list
+ *   - unexpected_index_list
+ *   - partial_unexpected_counts
+ * Those carry real data cell values (row data) and MUST NEVER be read into a
+ * tool result. We copy ONLY the aggregate scalars; if observed_value is itself
+ * an array/object of sampled values, it is DROPPED.
+ */
+
+const MAX_FILES = 1000;
+const MAX_FILE_BYTES = 4 * 1024 * 1024; // skip artefacts larger than ~4 MiB
+const MAX_WALK_DEPTH = 12;
+
+/** Sample/row-data keys that MUST never be copied out of a GX `result` object. */
+export const FORBIDDEN_RESULT_KEYS: ReadonlySet<string> = new Set([
+  "unexpected_list",
+  "partial_unexpected_list",
+  "partial_unexpected_index_list",
+  "unexpected_index_list",
+  "partial_unexpected_counts",
+]);
+
+export interface GxExpectationMeta {
+  readonly suiteName: string;
+  readonly batchId: string;
+  readonly runId: string | null;
+  readonly runTime: string | null;
+  readonly expectationType: string;
+  readonly column: string | null;
+  readonly success: boolean;
+  /** Aggregate scalar only — never an array/object of sampled values. */
+  readonly observedValue: number | string | boolean | null;
+  readonly elementCount: number | null;
+  readonly unexpectedCount: number | null;
+  readonly unexpectedPercent: number | null;
+  readonly successPercent: number | null;
+  /** Stable composite id: `<suite>::<batch>::<expectationType>::<column ?? "_">`. */
+  readonly externalId: string;
+  /** Source artefact path (relative to the results dir). */
+  readonly sourceFile: string;
+}
+
+function isRecord(v: unknown): v is Record<string, unknown> {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+
+function strField(r: Record<string, unknown>, key: string): string | null {
+  const v = r[key];
+  return typeof v === "string" && v !== "" ? v : null;
+}
+
+function numField(r: Record<string, unknown>, key: string): number | null {
+  const v = r[key];
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+
+/**
+ * Pull the aggregate observed value ONLY when it is a scalar (number / string /
+ * boolean). Some expectations (e.g. distinct-value checks) return an array or
+ * object of sampled values for observed_value — those are DROPPED (null) so no
+ * row data leaks.
+ */
+function scalarObservedValue(result: Record<string, unknown>): number | string | boolean | null {
+  const v = result["observed_value"];
+  if (typeof v === "number" && Number.isFinite(v)) {
+    return v;
+  }
+  if (typeof v === "string" || typeof v === "boolean") {
+    return v;
+  }
+  return null;
+}
+
+function deriveRunId(meta: Record<string, unknown>): string | null {
+  const runId = meta["run_id"];
+  if (typeof runId === "string" && runId !== "") {
+    return runId;
+  }
+  if (isRecord(runId)) {
+    return strField(runId, "run_name") ?? strField(runId, "run_time");
+  }
+  return null;
+}
+
+function deriveRunTime(meta: Record<string, unknown>): string | null {
+  const runId = meta["run_id"];
+  if (isRecord(runId)) {
+    const rt = strField(runId, "run_time");
+    if (rt !== null) {
+      return rt;
+    }
+  }
+  return strField(meta, "run_time") ?? strField(meta, "validation_time");
+}
+
+function deriveBatchId(meta: Record<string, unknown>): string {
+  const direct = strField(meta, "batch_id") ?? strField(meta, "active_batch_definition_id") ?? null;
+  if (direct !== null) {
+    return direct;
+  }
+  const def = meta["active_batch_definition"];
+  if (isRecord(def)) {
+    const name =
+      strField(def, "batch_identifiers") ??
+      strField(def, "data_asset_name") ??
+      strField(def, "datasource_name");
+    if (name !== null) {
+      return name;
+    }
+  }
+  const spec = meta["batch_spec"];
+  if (isRecord(spec)) {
+    const p = strField(spec, "path") ?? strField(spec, "table_name");
+    if (p !== null) {
+      return p;
+    }
+  }
+  return "_";
+}
+
+function clampId(id: string): string {
+  // Keep composite external ids bounded; hash-suffix when overly long.
+  if (id.length <= 256) {
+    return id;
+  }
+  let h = 0;
+  for (let i = 0; i < id.length; i += 1) {
+    h = (h * 31 + (id.codePointAt(i) ?? 0)) | 0; // NOSONAR S7767: `| 0` is 32-bit wraparound (Java-style hashCode), not truncation; Math.trunc would let h exceed 2^53 and corrupt the hash.
+  }
+  return `${id.slice(0, 240)}#${(h >>> 0).toString(16)}`;
+}
+
+/**
+ * Parse one GX validation-result JSON document into per-expectation metadata
+ * rows — METADATA / AGGREGATES ONLY. The forbidden sample lists are never read.
+ */
+export function parseValidationResult(parsed: unknown, sourceFile: string): GxExpectationMeta[] {
+  const root = isRecord(parsed) ? parsed : undefined;
+  if (root === undefined) {
+    return [];
+  }
+  const meta = isRecord(root["meta"]) ? root["meta"] : {};
+  const suiteName = strField(meta, "expectation_suite_name") ?? "_";
+  const batchId = deriveBatchId(meta);
+  const runId = deriveRunId(meta);
+  const runTime = deriveRunTime(meta);
+
+  const statistics = isRecord(root["statistics"]) ? root["statistics"] : {};
+  const successPercent = numField(statistics, "success_percent");
+
+  const results = Array.isArray(root["results"]) ? root["results"] : [];
+  const out: GxExpectationMeta[] = [];
+  for (const entry of results) {
+    if (!isRecord(entry)) {
+      continue;
+    }
+    const config = isRecord(entry["expectation_config"]) ? entry["expectation_config"] : {};
+    const expectationType = strField(config, "expectation_type") ?? "unknown";
+    const kwargs = isRecord(config["kwargs"]) ? config["kwargs"] : {};
+    const column = strField(kwargs, "column");
+    const success = entry["success"] === true;
+
+    const result = isRecord(entry["result"]) ? entry["result"] : {};
+    const observedValue = scalarObservedValue(result);
+    const elementCount = numField(result, "element_count");
+    const unexpectedCount = numField(result, "unexpected_count");
+    const unexpectedPercent = numField(result, "unexpected_percent");
+
+    const externalId = clampId(`${suiteName}::${batchId}::${expectationType}::${column ?? "_"}`);
+
+    out.push({
+      suiteName,
+      batchId,
+      runId,
+      runTime,
+      expectationType,
+      column,
+      success,
+      observedValue,
+      elementCount,
+      unexpectedCount,
+      unexpectedPercent,
+      successPercent,
+      externalId,
+      sourceFile,
+    });
+  }
+  return out;
+}
+
+/**
+ * Resolve the configured GX results dir from the environment. Throws when unset
+ * so the MCP tools surface a clear error rather than reading an empty path.
+ */
+export function resultsDir(): string {
+  const dir = process.env["GREAT_EXPECTATIONS_RESULTS_DIR"]?.trim();
+  if (dir === undefined || dir === "") {
+    throw new Error("GREAT_EXPECTATIONS_RESULTS_DIR is not set");
+  }
+  return resolve(dir);
+}
+
+/**
+ * Path-traversal guard: confirm `candidate` (an absolute resolved path) is the
+ * results dir itself or a descendant of it. Rejects `..`-escaping inputs. This
+ * is the filesystem analog of the argv flag-smuggling guard.
+ */
+export function assertWithinResultsDir(candidate: string, root: string): void {
+  const rel = relative(root, candidate);
+  if (rel === "") {
+    return; // the dir itself
+  }
+  if (rel.startsWith("..") || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
+    throw new Error("path escapes the configured Great Expectations results dir");
+  }
+}
+
+/** Recursively collect `*.json` artefact paths under `root` (bounded). */
+async function collectJsonFiles(root: string): Promise<string[]> {
+  const found: string[] = [];
+  async function walk(dir: string, depth: number): Promise<void> {
+    if (depth > MAX_WALK_DEPTH || found.length >= MAX_FILES) {
+      return;
+    }
+    let entries: import("node:fs").Dirent[];
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (found.length >= MAX_FILES) {
+        return;
+      }
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full, depth + 1);
+      } else if (entry.isFile() && entry.name.toLowerCase().endsWith(".json")) {
+        found.push(full);
+      }
+    }
+  }
+  await walk(root, 0);
+  return found;
+}
+
+async function readArtefact(path: string): Promise<unknown> {
+  try {
+    // Read first (no check-then-use race): readFile throws on a directory or a
+    // missing file, and the buffer length bounds the size — no stat-gated read.
+    const buf = await readFile(path);
+    if (buf.byteLength > MAX_FILE_BYTES) {
+      return null;
+    }
+    return JSON.parse(buf.toString("utf8")) as unknown;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Read all GX validation-result artefacts under the configured results dir and
+ * return the flattened per-expectation METADATA rows. Bad / oversized /
+ * unparseable artefacts are skipped. NEVER reads any sample list.
+ */
+export async function listAllExpectations(): Promise<GxExpectationMeta[]> {
+  const root = resultsDir();
+  const files = await collectJsonFiles(root);
+  const out: GxExpectationMeta[] = [];
+  for (const file of files) {
+    assertWithinResultsDir(file, root);
+    const parsed = await readArtefact(file);
+    if (parsed === null) {
+      continue;
+    }
+    out.push(...parseValidationResult(parsed, relative(root, file)));
+  }
+  return out;
+}

package/connectors/great-expectations/src/server.ts

@@ -0,0 +1,6 @@
+import { runReadOnlyMcpConnector } from "../../../shared/run-read-only-mcp-connector.ts";
+import { registerGreatExpectationsTools } from "./tools.ts";
+
+await runReadOnlyMcpConnector("nimbus-great-expectations", (reg) => {
+  registerGreatExpectationsTools(reg);
+});

package/connectors/great-expectations/src/tools.ts

@@ -0,0 +1,91 @@
+import { z } from "zod";
+import { mcpJsonResult as jsonResult } from "../../../shared/mcp-tool-kit.ts";
+import type { ZodToolRegistrar } from "../../../shared/run-read-only-mcp-connector.ts";
+import { type GxExpectationMeta, listAllExpectations } from "./gx-parse.ts";
+
+/**
+ * Great Expectations (Tier-3, no-row-data) MCP tool surface. ALL tools index
+ * validation-result METADATA only (suite name, batch id, expectation type,
+ * column, success/failure, the aggregate observed value, element/unexpected
+ * counts, run time). NONE return the failing-data SAMPLE lists (unexpected_list
+ * / partial_unexpected_list / …) — those carry real data cell values (row data)
+ * and are stripped by `gx-parse.ts` before they ever reach a tool result. The
+ * names are introspected by the `assertNoRowDataTools` contract test, so they
+ * must never contain a row-data segment (rows/records/sample/values/scan/…).
+ */
+export const GREAT_EXPECTATIONS_TOOL_NAMES = [
+  "great_expectations_list",
+  "great_expectations_get",
+  "great_expectations_search",
+] as const;
+
+function toEnvelope(m: GxExpectationMeta): Record<string, unknown> {
+  return {
+    externalId: m.externalId,
+    suiteName: m.suiteName,
+    batchId: m.batchId,
+    runId: m.runId,
+    runTime: m.runTime,
+    expectationType: m.expectationType,
+    column: m.column,
+    success: m.success,
+    observedValue: m.observedValue,
+    elementCount: m.elementCount,
+    unexpectedCount: m.unexpectedCount,
+    unexpectedPercent: m.unexpectedPercent,
+    successPercent: m.successPercent,
+    sourceFile: m.sourceFile,
+  };
+}
+
+/**
+ * Register the read-only, metadata-only Great Expectations tools onto the given
+ * registrar. Shared between `server.ts` (live) and the contract test
+ * (introspection).
+ */
+export function registerGreatExpectationsTools(reg: ZodToolRegistrar): void {
+  reg(
+    "great_expectations_list",
+    "List recent Great Expectations validation results — METADATA ONLY. Reads the GX validation-result JSON artefacts under the configured results dir and returns one entry per (suite, batch, expectation) carrying suiteName, batchId, expectationType, column, success/failure, the aggregate observedValue, and element/unexpected counts. Never returns the failing-data sample lists (unexpected_list / partial_unexpected_list / …).",
+    z.object({
+      limit: z.number().int().min(1).max(500).optional(),
+    }),
+    async (p) => {
+      const all = await listAllExpectations();
+      const limit = p.limit ?? 100;
+      return jsonResult({ results: all.slice(0, limit).map(toEnvelope) });
+    },
+  );
+
+  reg(
+    "great_expectations_get",
+    "Fetch one Great Expectations validation result by its external id (`<suite>::<batch>::<expectationType>::<column>`) — METADATA ONLY. Returns the single expectation's metadata (success/failure, aggregate observedValue, element/unexpected counts). Never returns row/cell sample data.",
+    z.object({
+      externalId: z.string().min(1),
+    }),
+    async (p) => {
+      const all = await listAllExpectations();
+      const match = all.find((m) => m.externalId === p.externalId);
+      return jsonResult(match === undefined ? { match: null } : { match: toEnvelope(match) });
+    },
+  );
+
+  reg(
+    "great_expectations_search",
+    "Substring search over Great Expectations suite names and expectation types (case-insensitive) — METADATA ONLY. Returns a `{ matches: [...] }` envelope of metadata entries whose suiteName, expectationType, or column contains the query. Never returns row/cell sample data.",
+    z.object({
+      query: z.string().min(1),
+      limit: z.number().int().min(1).max(500).optional(),
+    }),
+    async (p) => {
+      const all = await listAllExpectations();
+      const q = p.query.toLowerCase();
+      const matches = all.filter((m) => {
+        const hay = `${m.suiteName} ${m.expectationType} ${m.column ?? ""}`.toLowerCase();
+        return hay.includes(q);
+      });
+      const limit = p.limit ?? 100;
+      return jsonResult({ matches: matches.slice(0, limit).map(toEnvelope) });
+    },
+  );
+}

package/connectors/greenhouse/nimbus.extension.json

@@ -0,0 +1,15 @@
+{
+  "id": "com.nimbus.greenhouse",
+  "displayName": "Greenhouse",
+  "version": "0.1.0",
+  "description": "Greenhouse connector (read-only). Surfaces the company's Greenhouse Harvest job openings as `greenhouse:job` items in the local index — the job name, the department + office names/locations, the workflow status, the requisition id, the confidential flag, and the open/close/created/updated timestamps. Useful for answering recruiting questions (\"which engineering jobs are open?\", \"find the job for the staff SRE requisition\") without leaving Nimbus. HTTP Basic auth where the Harvest API key is the username and the password is empty (`Authorization: Basic base64(<api_key>:)` — the trailing colon is the empty password; never logged). The SaaS host (harvest.greenhouse.io) is fixed. Greenhouse paginates `/v1/jobs` with `?per_page=100&page=N` returning a bare JSON array `[ ...jobs... ]` (NOT an envelope) — increment `page` while the array is a full page of 100, stop on a short/empty page. `created_at` / `updated_at` are ISO-8601 strings parsed to epoch MILLISECONDS. The canonical URL is null (the Harvest API exposes no per-job public URL without a board token). Candidates / applications are deliberately deferred (candidate PII; out of scope for v1) — v1 indexes job openings only.",
+  "author": "Nimbus",
+  "entrypoint": "dist/server.js",
+  "runtime": "bun",
+  "permissions": {
+    "network": ["harvest.greenhouse.io"]
+  },
+  "hitlRequired": [],
+  "syncInterval": 600,
+  "minNimbusVersion": "0.2.0"
+}