@squadbase/vite-server 0.1.3-dev.1 → 0.1.3-dev.10

package/dist/connectors/grafana.js

@@ -0,0 +1,638 @@
+// ../connectors/src/parameter-definition.ts
+var ParameterDefinition = class {
+  slug;
+  name;
+  description;
+  envVarBaseKey;
+  type;
+  secret;
+  required;
+  constructor(config) {
+    this.slug = config.slug;
+    this.name = config.name;
+    this.description = config.description;
+    this.envVarBaseKey = config.envVarBaseKey;
+    this.type = config.type;
+    this.secret = config.secret;
+    this.required = config.required;
+  }
+  /**
+   * Get the parameter value from a ConnectorConnectionObject.
+   */
+  getValue(connection2) {
+    const param = connection2.parameters.find(
+      (p) => p.parameterSlug === this.slug
+    );
+    if (!param || param.value == null) {
+      throw new Error(
+        `Parameter "${this.slug}" not found or has no value in connection "${connection2.id}"`
+      );
+    }
+    return param.value;
+  }
+  /**
+   * Try to get the parameter value. Returns undefined if not found (for optional params).
+   */
+  tryGetValue(connection2) {
+    const param = connection2.parameters.find(
+      (p) => p.parameterSlug === this.slug
+    );
+    if (!param || param.value == null) return void 0;
+    return param.value;
+  }
+};
+
+// ../connectors/src/connectors/grafana/parameters.ts
+var parameters = {
+  url: new ParameterDefinition({
+    slug: "url",
+    name: "Grafana URL",
+    description: "The base URL of the Grafana instance (e.g., https://your-org.grafana.net).",
+    envVarBaseKey: "GRAFANA_URL",
+    type: "text",
+    secret: false,
+    required: true
+  }),
+  apiKey: new ParameterDefinition({
+    slug: "api-key",
+    name: "Grafana API Key",
+    description: "A Grafana API Key or Service Account Token. Create one in Grafana under Administration > Service Accounts.",
+    envVarBaseKey: "GRAFANA_API_KEY",
+    type: "text",
+    secret: true,
+    required: true
+  })
+};
+
+// ../connectors/src/connectors/grafana/sdk/index.ts
+function createClient(params) {
+  const baseUrl = params[parameters.url.slug]?.replace(/\/+$/, "");
+  const apiKey = params[parameters.apiKey.slug];
+  if (!baseUrl || !apiKey) {
+    const required = [parameters.url.slug, parameters.apiKey.slug];
+    const missing = required.filter((s) => !params[s]);
+    throw new Error(
+      `grafana: missing required parameters: ${missing.join(", ")}`
+    );
+  }
+  function request(path2, init) {
+    const url = `${baseUrl}${path2.startsWith("/") ? "" : "/"}${path2}`;
+    const headers = new Headers(init?.headers);
+    headers.set("Authorization", `Bearer ${apiKey}`);
+    headers.set("Content-Type", "application/json");
+    headers.set("Accept", "application/json");
+    return fetch(url, { ...init, headers });
+  }
+  async function listDatasources() {
+    const response = await request("/api/datasources");
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(
+        `grafana: listDatasources failed (${response.status}): ${body}`
+      );
+    }
+    return await response.json();
+  }
+  async function getDatasource(uid) {
+    const response = await request(
+      `/api/datasources/uid/${encodeURIComponent(uid)}`
+    );
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(
+        `grafana: getDatasource failed (${response.status}): ${body}`
+      );
+    }
+    return await response.json();
+  }
+  async function queryDatasource(options) {
+    const response = await request("/api/ds/query", {
+      method: "POST",
+      body: JSON.stringify({
+        queries: options.queries,
+        from: options.from ?? "now-1h",
+        to: options.to ?? "now"
+      })
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(
+        `grafana: queryDatasource failed (${response.status}): ${body}`
+      );
+    }
+    return await response.json();
+  }
+  async function searchDashboards(options) {
+    const searchParams = new URLSearchParams();
+    if (options?.query) searchParams.set("query", options.query);
+    if (options?.tag) {
+      for (const t of options.tag) searchParams.append("tag", t);
+    }
+    if (options?.type) searchParams.set("type", options.type);
+    if (options?.limit != null)
+      searchParams.set("limit", String(options.limit));
+    const qs = searchParams.toString();
+    const response = await request(`/api/search${qs ? `?${qs}` : ""}`);
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(
+        `grafana: searchDashboards failed (${response.status}): ${body}`
+      );
+    }
+    return await response.json();
+  }
+  async function getDashboard(uid) {
+    const response = await request(
+      `/api/dashboards/uid/${encodeURIComponent(uid)}`
+    );
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(
+        `grafana: getDashboard failed (${response.status}): ${body}`
+      );
+    }
+    return await response.json();
+  }
+  return {
+    request,
+    listDatasources,
+    getDatasource,
+    queryDatasource,
+    searchDashboards,
+    getDashboard
+  };
+}
+
+// ../connectors/src/connector-onboarding.ts
+var ConnectorOnboarding = class {
+  /** Phase 1: Connection setup instructions (optional — some connectors don't need this) */
+  connectionSetupInstructions;
+  /** Phase 2: Data overview instructions */
+  dataOverviewInstructions;
+  constructor(config) {
+    this.connectionSetupInstructions = config.connectionSetupInstructions;
+    this.dataOverviewInstructions = config.dataOverviewInstructions;
+  }
+  getConnectionSetupPrompt(language) {
+    return this.connectionSetupInstructions?.[language] ?? null;
+  }
+  getDataOverviewInstructions(language) {
+    return this.dataOverviewInstructions[language];
+  }
+};
+
+// ../connectors/src/connector-tool.ts
+var ConnectorTool = class {
+  name;
+  description;
+  inputSchema;
+  outputSchema;
+  _execute;
+  constructor(config) {
+    this.name = config.name;
+    this.description = config.description;
+    this.inputSchema = config.inputSchema;
+    this.outputSchema = config.outputSchema;
+    this._execute = config.execute;
+  }
+  createTool(connections, config) {
+    return {
+      description: this.description,
+      inputSchema: this.inputSchema,
+      outputSchema: this.outputSchema,
+      execute: (input) => this._execute(input, connections, config)
+    };
+  }
+};
+
+// ../connectors/src/connector-plugin.ts
+var ConnectorPlugin = class _ConnectorPlugin {
+  slug;
+  authType;
+  name;
+  description;
+  iconUrl;
+  parameters;
+  releaseFlag;
+  proxyPolicy;
+  experimentalAttributes;
+  onboarding;
+  systemPrompt;
+  tools;
+  query;
+  checkConnection;
+  constructor(config) {
+    this.slug = config.slug;
+    this.authType = config.authType;
+    this.name = config.name;
+    this.description = config.description;
+    this.iconUrl = config.iconUrl;
+    this.parameters = config.parameters;
+    this.releaseFlag = config.releaseFlag;
+    this.proxyPolicy = config.proxyPolicy;
+    this.experimentalAttributes = config.experimentalAttributes;
+    this.onboarding = config.onboarding;
+    this.systemPrompt = config.systemPrompt;
+    this.tools = config.tools;
+    this.query = config.query;
+    this.checkConnection = config.checkConnection;
+  }
+  get connectorKey() {
+    return _ConnectorPlugin.deriveKey(this.slug, this.authType);
+  }
+  /**
+   * Create tools for connections that belong to this connector.
+   * Filters connections by connectorKey internally.
+   * Returns tools keyed as `${connectorKey}_${toolName}`.
+   */
+  createTools(connections, config) {
+    const myConnections = connections.filter(
+      (c) => _ConnectorPlugin.deriveKey(c.connector.slug, c.connector.authType) === this.connectorKey
+    );
+    const result = {};
+    for (const t of Object.values(this.tools)) {
+      result[`${this.connectorKey}_${t.name}`] = t.createTool(
+        myConnections,
+        config
+      );
+    }
+    return result;
+  }
+  static deriveKey(slug, authType) {
+    return authType ? `${slug}-${authType}` : slug;
+  }
+};
+
+// ../connectors/src/auth-types.ts
+var AUTH_TYPES = {
+  OAUTH: "oauth",
+  API_KEY: "api-key",
+  JWT: "jwt",
+  SERVICE_ACCOUNT: "service-account",
+  PAT: "pat",
+  USER_PASSWORD: "user-password"
+};
+
+// ../connectors/src/connectors/grafana/setup.ts
+var grafanaOnboarding = new ConnectorOnboarding({
+  dataOverviewInstructions: {
+    en: `1. Call grafana_request with GET /api/datasources to list all configured datasources
+2. Call grafana_request with GET /api/search?type=dash-db&limit=10 to list dashboards
+3. For a specific datasource, call grafana_request with POST /api/ds/query to run a test query`,
+    ja: `1. grafana_request \u3067 GET /api/datasources \u3092\u547C\u3073\u51FA\u3057\u3001\u8A2D\u5B9A\u6E08\u307F\u306E\u30C7\u30FC\u30BF\u30BD\u30FC\u30B9\u4E00\u89A7\u3092\u53D6\u5F97
+2. grafana_request \u3067 GET /api/search?type=dash-db&limit=10 \u3092\u547C\u3073\u51FA\u3057\u3001\u30C0\u30C3\u30B7\u30E5\u30DC\u30FC\u30C9\u4E00\u89A7\u3092\u53D6\u5F97
+3. \u7279\u5B9A\u306E\u30C7\u30FC\u30BF\u30BD\u30FC\u30B9\u306B\u5BFE\u3057\u3066 grafana_request \u3067 POST /api/ds/query \u3092\u547C\u3073\u51FA\u3057\u3001\u30C6\u30B9\u30C8\u30AF\u30A8\u30EA\u3092\u5B9F\u884C`
+  }
+});
+
+// ../connectors/src/connectors/grafana/tools/request.ts
+import { z } from "zod";
+var REQUEST_TIMEOUT_MS = 6e4;
+var inputSchema = z.object({
+  toolUseIntent: z.string().optional().describe(
+    "Brief description of what you intend to accomplish with this tool call"
+  ),
+  connectionId: z.string().describe("ID of the Grafana connection to use"),
+  method: z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]).describe(
+    "HTTP method. GET for reading resources (datasources, dashboards, alerts). POST for queries and creating resources. PUT/PATCH for updates. DELETE for removal."
+  ),
+  path: z.string().describe(
+    "API path relative to the Grafana base URL (e.g., '/api/datasources', '/api/search', '/api/ds/query'). Must start with '/'."
+  ),
+  body: z.record(z.string(), z.unknown()).optional().describe("Request body (JSON). Required for POST/PUT/PATCH requests.")
+});
+var outputSchema = z.discriminatedUnion("success", [
+  z.object({
+    success: z.literal(true),
+    status: z.number(),
+    data: z.unknown()
+  }),
+  z.object({
+    success: z.literal(false),
+    error: z.string()
+  })
+]);
+var requestTool = new ConnectorTool({
+  name: "request",
+  description: `Send authenticated requests to the Grafana HTTP API.
+Authentication is handled automatically using the configured API Key or Service Account Token via Bearer token.
+Use this tool to interact with Grafana resources: datasources, dashboards, alerts, annotations, and to execute datasource queries via the unified query API (/api/ds/query).
+The path must start with '/' and is appended to the configured Grafana instance URL.`,
+  inputSchema,
+  outputSchema,
+  async execute({ connectionId, method, path: path2, body }, connections) {
+    const connection2 = connections.find((c) => c.id === connectionId);
+    if (!connection2) {
+      return {
+        success: false,
+        error: `Connection ${connectionId} not found`
+      };
+    }
+    console.log(
+      `[connector-request] grafana/${connection2.name}: ${method} ${path2}`
+    );
+    try {
+      const baseUrl = parameters.url.getValue(connection2).replace(/\/+$/, "");
+      const apiKey = parameters.apiKey.getValue(connection2);
+      const url = `${baseUrl}${path2}`;
+      const controller = new AbortController();
+      const timeout = setTimeout(
+        () => controller.abort(),
+        REQUEST_TIMEOUT_MS
+      );
+      try {
+        const response = await fetch(url, {
+          method,
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json",
+            Accept: "application/json"
+          },
+          body: body ? JSON.stringify(body) : void 0,
+          signal: controller.signal
+        });
+        const data = await response.json();
+        if (!response.ok) {
+          const errorMessage = typeof data === "object" && data !== null && "message" in data ? String(data.message) : `HTTP ${response.status} ${response.statusText}`;
+          return { success: false, error: errorMessage };
+        }
+        return { success: true, status: response.status, data };
+      } finally {
+        clearTimeout(timeout);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { success: false, error: msg };
+    }
+  }
+});
+
+// ../connectors/src/connectors/grafana/index.ts
+var tools = { request: requestTool };
+var grafanaConnector = new ConnectorPlugin({
+  slug: "grafana",
+  authType: AUTH_TYPES.API_KEY,
+  name: "Grafana",
+  description: "Connect to Grafana for monitoring dashboards, datasource queries, and alerting.",
+  iconUrl: "https://images.ctfassets.net/9ncizv60xc5y/3nGaPhV94lXQsHcCtv4mXz/0559d42f83066e8ba79e78410806750c/grafana-icon.webp",
+  parameters,
+  releaseFlag: { dev1: true, dev2: false, prod: false },
+  onboarding: grafanaOnboarding,
+  systemPrompt: {
+    en: `### Tools
+
+- \`grafana_request\`: The only way to call the Grafana HTTP API. Use it to list datasources, search dashboards, execute datasource queries, manage alerts, and read annotations. Authentication is handled automatically via Bearer token. The path must start with \`/\`.
+
+### Business Logic
+
+The business logic type for this connector is "typescript". Use the connector SDK in your handler. Do NOT read credentials from environment variables.
+
+SDK methods (client created via \`connection(connectionId)\`):
+- \`client.request(path, init?)\` \u2014 low-level authenticated fetch
+- \`client.listDatasources()\` \u2014 list all datasources
+- \`client.getDatasource(uid)\` \u2014 get datasource by UID
+- \`client.queryDatasource({ queries, from?, to? })\` \u2014 execute queries via unified query API
+- \`client.searchDashboards({ query?, tag?, type?, limit? })\` \u2014 search dashboards
+- \`client.getDashboard(uid)\` \u2014 get dashboard by UID
+
+\`\`\`ts
+import type { Context } from "hono";
+import { connection } from "@squadbase/vite-server/connectors/grafana";
+
+const grafana = connection("<connectionId>");
+
+export default async function handler(c: Context) {
+  const datasources = await grafana.listDatasources();
+  return c.json(
+    datasources.map((ds) => ({
+      uid: ds.uid,
+      name: ds.name,
+      type: ds.type,
+    })),
+  );
+}
+\`\`\`
+
+### Grafana HTTP API Reference
+
+#### Datasources
+- \`GET /api/datasources\` \u2014 List all datasources
+- \`GET /api/datasources/uid/{uid}\` \u2014 Get a datasource by UID
+
+#### Unified Query API
+- \`POST /api/ds/query\` \u2014 Execute queries against datasources
+- Body: \`{ "queries": [{ "refId": "A", "datasource": { "type": "prometheus", "uid": "..." }, "expr": "up" }], "from": "now-1h", "to": "now" }\`
+
+#### Dashboard Search
+- \`GET /api/search\` \u2014 Search dashboards and folders
+- Query params: \`?query=keyword&tag=tagname&type=dash-db&limit=10\`
+
+#### Dashboards
+- \`GET /api/dashboards/uid/{uid}\` \u2014 Get dashboard by UID (includes panels and metadata)
+
+#### Alerts
+- \`GET /api/v1/provisioning/alert-rules\` \u2014 List alert rules
+- \`GET /api/annotations\` \u2014 List annotations (filter with \`?from=timestamp&to=timestamp\`)
+
+#### Organizations & Health
+- \`GET /api/org\` \u2014 Get current organization
+- \`GET /api/health\` \u2014 Health check`,
+    ja: `### \u30C4\u30FC\u30EB
+
+- \`grafana_request\`: Grafana HTTP API\u3092\u547C\u3073\u51FA\u3059\u552F\u4E00\u306E\u624B\u6BB5\u3067\u3059\u3002\u30C7\u30FC\u30BF\u30BD\u30FC\u30B9\u306E\u4E00\u89A7\u53D6\u5F97\u3001\u30C0\u30C3\u30B7\u30E5\u30DC\u30FC\u30C9\u691C\u7D22\u3001\u30C7\u30FC\u30BF\u30BD\u30FC\u30B9\u30AF\u30A8\u30EA\u306E\u5B9F\u884C\u3001\u30A2\u30E9\u30FC\u30C8\u7BA1\u7406\u3001\u30A2\u30CE\u30C6\u30FC\u30B7\u30E7\u30F3\u306E\u8AAD\u307F\u53D6\u308A\u306B\u4F7F\u7528\u3057\u307E\u3059\u3002\u8A8D\u8A3C\u306FBearer\u30C8\u30FC\u30AF\u30F3\u3067\u81EA\u52D5\u51E6\u7406\u3055\u308C\u307E\u3059\u3002\u30D1\u30B9\u306F \`/\` \u3067\u59CB\u3081\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002
+
+### Business Logic
+
+\u3053\u306E\u30B3\u30CD\u30AF\u30BF\u306E\u30D3\u30B8\u30CD\u30B9\u30ED\u30B8\u30C3\u30AF\u30BF\u30A4\u30D7\u306F "typescript" \u3067\u3059\u3002\u30CF\u30F3\u30C9\u30E9\u5185\u3067\u306F\u30B3\u30CD\u30AF\u30BFSDK\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u74B0\u5883\u5909\u6570\u304B\u3089\u8A8D\u8A3C\u60C5\u5831\u3092\u8AAD\u307F\u53D6\u3089\u306A\u3044\u3067\u304F\u3060\u3055\u3044\u3002
+
+SDK\u30E1\u30BD\u30C3\u30C9 (\`connection(connectionId)\` \u3067\u4F5C\u6210\u3057\u305F\u30AF\u30E9\u30A4\u30A2\u30F3\u30C8):
+- \`client.request(path, init?)\` \u2014 \u4F4E\u30EC\u30D9\u30EB\u306E\u8A8D\u8A3C\u4ED8\u304Dfetch
+- \`client.listDatasources()\` \u2014 \u5168\u30C7\u30FC\u30BF\u30BD\u30FC\u30B9\u306E\u4E00\u89A7\u53D6\u5F97
+- \`client.getDatasource(uid)\` \u2014 UID\u3067\u30C7\u30FC\u30BF\u30BD\u30FC\u30B9\u3092\u53D6\u5F97
+- \`client.queryDatasource({ queries, from?, to? })\` \u2014 \u7D71\u5408\u30AF\u30A8\u30EAAPI\u3067\u30AF\u30A8\u30EA\u5B9F\u884C
+- \`client.searchDashboards({ query?, tag?, type?, limit? })\` \u2014 \u30C0\u30C3\u30B7\u30E5\u30DC\u30FC\u30C9\u691C\u7D22
+- \`client.getDashboard(uid)\` \u2014 UID\u3067\u30C0\u30C3\u30B7\u30E5\u30DC\u30FC\u30C9\u3092\u53D6\u5F97
+
+\`\`\`ts
+import type { Context } from "hono";
+import { connection } from "@squadbase/vite-server/connectors/grafana";
+
+const grafana = connection("<connectionId>");
+
+export default async function handler(c: Context) {
+  const datasources = await grafana.listDatasources();
+  return c.json(
+    datasources.map((ds) => ({
+      uid: ds.uid,
+      name: ds.name,
+      type: ds.type,
+    })),
+  );
+}
+\`\`\`
+
+### Grafana HTTP API \u30EA\u30D5\u30A1\u30EC\u30F3\u30B9
+
+#### \u30C7\u30FC\u30BF\u30BD\u30FC\u30B9
+- \`GET /api/datasources\` \u2014 \u5168\u30C7\u30FC\u30BF\u30BD\u30FC\u30B9\u306E\u4E00\u89A7\u53D6\u5F97
+- \`GET /api/datasources/uid/{uid}\` \u2014 UID\u3067\u30C7\u30FC\u30BF\u30BD\u30FC\u30B9\u3092\u53D6\u5F97
+
+#### \u7D71\u5408\u30AF\u30A8\u30EAAPI
+- \`POST /api/ds/query\` \u2014 \u30C7\u30FC\u30BF\u30BD\u30FC\u30B9\u306B\u5BFE\u3057\u3066\u30AF\u30A8\u30EA\u3092\u5B9F\u884C
+- Body: \`{ "queries": [{ "refId": "A", "datasource": { "type": "prometheus", "uid": "..." }, "expr": "up" }], "from": "now-1h", "to": "now" }\`
+
+#### \u30C0\u30C3\u30B7\u30E5\u30DC\u30FC\u30C9\u691C\u7D22
+- \`GET /api/search\` \u2014 \u30C0\u30C3\u30B7\u30E5\u30DC\u30FC\u30C9\u3068\u30D5\u30A9\u30EB\u30C0\u3092\u691C\u7D22
+- \u30AF\u30A8\u30EA\u30D1\u30E9\u30E1\u30FC\u30BF: \`?query=keyword&tag=tagname&type=dash-db&limit=10\`
+
+#### \u30C0\u30C3\u30B7\u30E5\u30DC\u30FC\u30C9
+- \`GET /api/dashboards/uid/{uid}\` \u2014 UID\u3067\u30C0\u30C3\u30B7\u30E5\u30DC\u30FC\u30C9\u3092\u53D6\u5F97\uFF08\u30D1\u30CD\u30EB\u3068\u30E1\u30BF\u30C7\u30FC\u30BF\u3092\u542B\u3080\uFF09
+
+#### \u30A2\u30E9\u30FC\u30C8
+- \`GET /api/v1/provisioning/alert-rules\` \u2014 \u30A2\u30E9\u30FC\u30C8\u30EB\u30FC\u30EB\u4E00\u89A7
+- \`GET /api/annotations\` \u2014 \u30A2\u30CE\u30C6\u30FC\u30B7\u30E7\u30F3\u4E00\u89A7\uFF08\`?from=timestamp&to=timestamp\` \u3067\u30D5\u30A3\u30EB\u30BF\uFF09
+
+#### \u7D44\u7E54 & \u30D8\u30EB\u30B9\u30C1\u30A7\u30C3\u30AF
+- \`GET /api/org\` \u2014 \u73FE\u5728\u306E\u7D44\u7E54\u3092\u53D6\u5F97
+- \`GET /api/health\` \u2014 \u30D8\u30EB\u30B9\u30C1\u30A7\u30C3\u30AF`
+  },
+  tools
+});
+
+// src/connectors/create-connector-sdk.ts
+import { readFileSync } from "fs";
+import path from "path";
+
+// src/connector-client/env.ts
+function resolveEnvVar(entry, key, connectionId) {
+  const envVarName = entry.envVars[key];
+  if (!envVarName) {
+    throw new Error(`Connection "${connectionId}" is missing envVars mapping for key "${key}"`);
+  }
+  const value = process.env[envVarName];
+  if (!value) {
+    throw new Error(`Environment variable "${envVarName}" (for connection "${connectionId}", key "${key}") is not set`);
+  }
+  return value;
+}
+function resolveEnvVarOptional(entry, key) {
+  const envVarName = entry.envVars[key];
+  if (!envVarName) return void 0;
+  return process.env[envVarName] || void 0;
+}
+
+// src/connector-client/proxy-fetch.ts
+import { getContext } from "hono/context-storage";
+import { getCookie } from "hono/cookie";
+var APP_SESSION_COOKIE_NAME = "__Host-squadbase-session";
+function createSandboxProxyFetch(connectionId) {
+  return async (input, init) => {
+    const token = process.env.INTERNAL_SQUADBASE_OAUTH_MACHINE_CREDENTIAL;
+    const sandboxId = process.env.INTERNAL_SQUADBASE_SANDBOX_ID;
+    if (!token || !sandboxId) {
+      throw new Error(
+        "Connection proxy is not configured. Please check your deployment settings."
+      );
+    }
+    const originalUrl = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    const originalMethod = init?.method ?? "GET";
+    const originalBody = init?.body ? JSON.parse(init.body) : void 0;
+    const baseDomain = process.env["SQUADBASE_PREVIEW_BASE_DOMAIN"] ?? "preview.app.squadbase.dev";
+    const proxyUrl = `https://${sandboxId}.${baseDomain}/_sqcore/connections/${connectionId}/request`;
+    return fetch(proxyUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`
+      },
+      body: JSON.stringify({
+        url: originalUrl,
+        method: originalMethod,
+        body: originalBody
+      })
+    });
+  };
+}
+function createDeployedAppProxyFetch(connectionId) {
+  const projectId = process.env["SQUADBASE_PROJECT_ID"];
+  if (!projectId) {
+    throw new Error(
+      "Connection proxy is not configured. Please check your deployment settings."
+    );
+  }
+  const baseDomain = process.env["SQUADBASE_APP_BASE_DOMAIN"] ?? "squadbase.app";
+  const proxyUrl = `https://${projectId}.${baseDomain}/_sqcore/connections/${connectionId}/request`;
+  return async (input, init) => {
+    const originalUrl = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    const originalMethod = init?.method ?? "GET";
+    const originalBody = init?.body ? JSON.parse(init.body) : void 0;
+    const c = getContext();
+    const appSession = getCookie(c, APP_SESSION_COOKIE_NAME);
+    if (!appSession) {
+      throw new Error(
+        "No authentication method available for connection proxy."
+      );
+    }
+    return fetch(proxyUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${appSession}`
+      },
+      body: JSON.stringify({
+        url: originalUrl,
+        method: originalMethod,
+        body: originalBody
+      })
+    });
+  };
+}
+function createProxyFetch(connectionId) {
+  if (process.env.INTERNAL_SQUADBASE_SANDBOX_ID) {
+    return createSandboxProxyFetch(connectionId);
+  }
+  return createDeployedAppProxyFetch(connectionId);
+}
+
+// src/connectors/create-connector-sdk.ts
+function loadConnectionsSync() {
+  const filePath = process.env.CONNECTIONS_PATH ?? path.join(process.cwd(), ".squadbase/connections.json");
+  try {
+    const raw = readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function createConnectorSdk(plugin, createClient2) {
+  return (connectionId) => {
+    const connections = loadConnectionsSync();
+    const entry = connections[connectionId];
+    if (!entry) {
+      throw new Error(
+        `Connection "${connectionId}" not found in .squadbase/connections.json`
+      );
+    }
+    if (entry.connector.slug !== plugin.slug) {
+      throw new Error(
+        `Connection "${connectionId}" is not a ${plugin.slug} connection (got "${entry.connector.slug}")`
+      );
+    }
+    const params = {};
+    for (const param of Object.values(plugin.parameters)) {
+      if (param.required) {
+        params[param.slug] = resolveEnvVar(entry, param.slug, connectionId);
+      } else {
+        const val = resolveEnvVarOptional(entry, param.slug);
+        if (val !== void 0) params[param.slug] = val;
+      }
+    }
+    return createClient2(params, createProxyFetch(connectionId));
+  };
+}
+
+// src/connectors/entries/grafana.ts
+var connection = createConnectorSdk(grafanaConnector, createClient);
+export {
+  connection
+};