@squadbase/vite-server 0.1.3-dev.3 → 0.1.3-dev.5

package/dist/connectors/{slack.d.ts → google-calendar.d.ts}

@@ -1,5 +1,5 @@
 import * as _squadbase_connectors_sdk from '@squadbase/connectors/sdk';
 
-declare const connection: (connectionId: string) => _squadbase_connectors_sdk.SlackConnectorSdk;
+declare const connection: (connectionId: string) => _squadbase_connectors_sdk.GoogleCalendarConnectorSdk;
 
 export { connection };

package/dist/connectors/google-calendar.js

@@ -0,0 +1,655 @@
+// ../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/google-calendar/sdk/index.ts
+import * as crypto from "crypto";
+
+// ../connectors/src/connectors/google-calendar/parameters.ts
+var parameters = {
+  serviceAccountKeyJsonBase64: new ParameterDefinition({
+    slug: "service-account-key-json-base64",
+    name: "Google Cloud Service Account JSON",
+    description: "The service account JSON key used to authenticate with Google Cloud Platform. Ensure that the service account has the necessary permissions to access Google Calendar, and that calendars are shared with the service account email.",
+    envVarBaseKey: "GOOGLE_CALENDAR_SERVICE_ACCOUNT_JSON_BASE64",
+    type: "base64EncodedJson",
+    secret: true,
+    required: true
+  }),
+  calendarId: new ParameterDefinition({
+    slug: "calendar-id",
+    name: "Default Calendar ID",
+    description: "The default Google Calendar ID to use (e.g., 'primary' or an email address like 'user@example.com'). If not set, 'primary' is used.",
+    envVarBaseKey: "GOOGLE_CALENDAR_CALENDAR_ID",
+    type: "text",
+    secret: false,
+    required: false
+  })
+};
+
+// ../connectors/src/connectors/google-calendar/sdk/index.ts
+var TOKEN_URL = "https://oauth2.googleapis.com/token";
+var BASE_URL = "https://www.googleapis.com/calendar/v3";
+var SCOPE = "https://www.googleapis.com/auth/calendar.readonly https://www.googleapis.com/auth/calendar.events.readonly";
+function base64url(input) {
+  const buf = typeof input === "string" ? Buffer.from(input) : input;
+  return buf.toString("base64url");
+}
+function buildJwt(clientEmail, privateKey, nowSec) {
+  const header = base64url(JSON.stringify({ alg: "RS256", typ: "JWT" }));
+  const payload = base64url(
+    JSON.stringify({
+      iss: clientEmail,
+      scope: SCOPE,
+      aud: TOKEN_URL,
+      iat: nowSec,
+      exp: nowSec + 3600
+    })
+  );
+  const signingInput = `${header}.${payload}`;
+  const sign = crypto.createSign("RSA-SHA256");
+  sign.update(signingInput);
+  sign.end();
+  const signature = base64url(sign.sign(privateKey));
+  return `${signingInput}.${signature}`;
+}
+function createClient(params) {
+  const serviceAccountKeyJsonBase64 = params[parameters.serviceAccountKeyJsonBase64.slug];
+  const defaultCalendarId = params[parameters.calendarId.slug] ?? "primary";
+  if (!serviceAccountKeyJsonBase64) {
+    throw new Error(
+      `google-calendar: missing required parameter: ${parameters.serviceAccountKeyJsonBase64.slug}`
+    );
+  }
+  let serviceAccountKey;
+  try {
+    const decoded = Buffer.from(
+      serviceAccountKeyJsonBase64,
+      "base64"
+    ).toString("utf-8");
+    serviceAccountKey = JSON.parse(decoded);
+  } catch {
+    throw new Error(
+      "google-calendar: failed to decode service account key JSON from base64"
+    );
+  }
+  if (!serviceAccountKey.client_email || !serviceAccountKey.private_key) {
+    throw new Error(
+      "google-calendar: service account key JSON must contain client_email and private_key"
+    );
+  }
+  let cachedToken = null;
+  let tokenExpiresAt = 0;
+  async function getAccessToken() {
+    const nowSec = Math.floor(Date.now() / 1e3);
+    if (cachedToken && nowSec < tokenExpiresAt - 60) {
+      return cachedToken;
+    }
+    const jwt = buildJwt(
+      serviceAccountKey.client_email,
+      serviceAccountKey.private_key,
+      nowSec
+    );
+    const response = await fetch(TOKEN_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
+        assertion: jwt
+      })
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(
+        `google-calendar: token exchange failed (${response.status}): ${text}`
+      );
+    }
+    const data = await response.json();
+    cachedToken = data.access_token;
+    tokenExpiresAt = nowSec + data.expires_in;
+    return cachedToken;
+  }
+  function resolveCalendarId(override) {
+    return override ?? defaultCalendarId;
+  }
+  return {
+    async request(path2, init) {
+      const accessToken = await getAccessToken();
+      const resolvedPath = path2.replace(
+        /\{calendarId\}/g,
+        defaultCalendarId
+      );
+      const url = `${BASE_URL}${resolvedPath.startsWith("/") ? "" : "/"}${resolvedPath}`;
+      const headers = new Headers(init?.headers);
+      headers.set("Authorization", `Bearer ${accessToken}`);
+      return fetch(url, { ...init, headers });
+    },
+    async listCalendars() {
+      const response = await this.request("/users/me/calendarList", {
+        method: "GET"
+      });
+      if (!response.ok) {
+        const text = await response.text();
+        throw new Error(
+          `google-calendar: listCalendars failed (${response.status}): ${text}`
+        );
+      }
+      const data = await response.json();
+      return data.items ?? [];
+    },
+    async listEvents(options, calendarId) {
+      const cid = resolveCalendarId(calendarId);
+      const searchParams = new URLSearchParams();
+      if (options?.timeMin) searchParams.set("timeMin", options.timeMin);
+      if (options?.timeMax) searchParams.set("timeMax", options.timeMax);
+      if (options?.maxResults)
+        searchParams.set("maxResults", String(options.maxResults));
+      if (options?.q) searchParams.set("q", options.q);
+      if (options?.singleEvents != null)
+        searchParams.set("singleEvents", String(options.singleEvents));
+      if (options?.orderBy) searchParams.set("orderBy", options.orderBy);
+      if (options?.pageToken) searchParams.set("pageToken", options.pageToken);
+      const qs = searchParams.toString();
+      const path2 = `/calendars/${encodeURIComponent(cid)}/events${qs ? `?${qs}` : ""}`;
+      const response = await this.request(path2, { method: "GET" });
+      if (!response.ok) {
+        const text = await response.text();
+        throw new Error(
+          `google-calendar: listEvents failed (${response.status}): ${text}`
+        );
+      }
+      return await response.json();
+    },
+    async getEvent(eventId, calendarId) {
+      const cid = resolveCalendarId(calendarId);
+      const path2 = `/calendars/${encodeURIComponent(cid)}/events/${encodeURIComponent(eventId)}`;
+      const response = await this.request(path2, { method: "GET" });
+      if (!response.ok) {
+        const text = await response.text();
+        throw new Error(
+          `google-calendar: getEvent failed (${response.status}): ${text}`
+        );
+      }
+      return await response.json();
+    }
+  };
+}
+
+// ../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/google-calendar/setup.ts
+var googleCalendarOnboarding = new ConnectorOnboarding({
+  dataOverviewInstructions: {
+    en: `1. Call google-calendar_request with GET /calendars/{calendarId} to get the default calendar's metadata
+2. Call google-calendar_request with GET /users/me/calendarList to list all accessible calendars
+3. Call google-calendar_request with GET /calendars/{calendarId}/events with query params timeMin (RFC3339) and maxResults=10 to sample upcoming events`,
+    ja: `1. google-calendar_request \u3067 GET /calendars/{calendarId} \u3092\u547C\u3073\u51FA\u3057\u3001\u30C7\u30D5\u30A9\u30EB\u30C8\u30AB\u30EC\u30F3\u30C0\u30FC\u306E\u30E1\u30BF\u30C7\u30FC\u30BF\u3092\u53D6\u5F97
+2. google-calendar_request \u3067 GET /users/me/calendarList \u3092\u547C\u3073\u51FA\u3057\u3001\u30A2\u30AF\u30BB\u30B9\u53EF\u80FD\u306A\u5168\u30AB\u30EC\u30F3\u30C0\u30FC\u306E\u4E00\u89A7\u3092\u53D6\u5F97
+3. google-calendar_request \u3067 GET /calendars/{calendarId}/events \u3092\u30AF\u30A8\u30EA\u30D1\u30E9\u30E1\u30FC\u30BF timeMin\uFF08RFC3339\u5F62\u5F0F\uFF09\u3068 maxResults=10 \u3067\u547C\u3073\u51FA\u3057\u3001\u76F4\u8FD1\u306E\u30A4\u30D9\u30F3\u30C8\u3092\u30B5\u30F3\u30D7\u30EA\u30F3\u30B0`
+  }
+});
+
+// ../connectors/src/connectors/google-calendar/tools/request.ts
+import { z } from "zod";
+var BASE_URL2 = "https://www.googleapis.com/calendar/v3";
+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 Google Calendar connection to use"),
+  method: z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]).describe("HTTP method"),
+  path: z.string().describe(
+    "API path appended to https://www.googleapis.com/calendar/v3 (e.g., '/calendars/{calendarId}/events'). {calendarId} is automatically replaced."
+  ),
+  queryParams: z.record(z.string(), z.string()).optional().describe("Query parameters to append to the URL"),
+  body: z.record(z.string(), z.unknown()).optional().describe("Request body (JSON) for POST/PUT/PATCH methods")
+});
+var outputSchema = z.discriminatedUnion("success", [
+  z.object({
+    success: z.literal(true),
+    status: z.number(),
+    data: z.record(z.string(), z.unknown())
+  }),
+  z.object({
+    success: z.literal(false),
+    error: z.string()
+  })
+]);
+var requestTool = new ConnectorTool({
+  name: "request",
+  description: `Send authenticated requests to the Google Calendar API v3.
+Authentication is handled automatically using a service account.
+{calendarId} in the path is automatically replaced with the connection's default calendar ID.`,
+  inputSchema,
+  outputSchema,
+  async execute({ connectionId, method, path: path2, queryParams, body }, connections) {
+    const connection2 = connections.find((c) => c.id === connectionId);
+    if (!connection2) {
+      return {
+        success: false,
+        error: `Connection ${connectionId} not found`
+      };
+    }
+    console.log(
+      `[connector-request] google-calendar/${connection2.name}: ${method} ${path2}`
+    );
+    try {
+      const { GoogleAuth } = await import("google-auth-library");
+      const keyJsonBase64 = parameters.serviceAccountKeyJsonBase64.getValue(connection2);
+      const calendarId = parameters.calendarId.tryGetValue(connection2) ?? "primary";
+      const credentials = JSON.parse(
+        Buffer.from(keyJsonBase64, "base64").toString("utf-8")
+      );
+      const auth = new GoogleAuth({
+        credentials,
+        scopes: [
+          "https://www.googleapis.com/auth/calendar.readonly",
+          "https://www.googleapis.com/auth/calendar.events.readonly"
+        ]
+      });
+      const token = await auth.getAccessToken();
+      if (!token) {
+        return {
+          success: false,
+          error: "Failed to obtain access token"
+        };
+      }
+      const resolvedPath = path2.replace(/\{calendarId\}/g, calendarId);
+      let url = `${BASE_URL2}${resolvedPath.startsWith("/") ? "" : "/"}${resolvedPath}`;
+      if (queryParams) {
+        const searchParams = new URLSearchParams(queryParams);
+        url += `?${searchParams.toString()}`;
+      }
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+      try {
+        const response = await fetch(url, {
+          method,
+          headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json"
+          },
+          body: body && ["POST", "PUT", "PATCH"].includes(method) ? JSON.stringify(body) : void 0,
+          signal: controller.signal
+        });
+        if (method === "DELETE" && response.status === 204) {
+          return {
+            success: true,
+            status: 204,
+            data: { message: "Deleted successfully" }
+          };
+        }
+        const data = await response.json();
+        if (!response.ok) {
+          const errorObj = data?.error;
+          return {
+            success: false,
+            error: errorObj?.message ?? `HTTP ${response.status} ${response.statusText}`
+          };
+        }
+        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/google-calendar/index.ts
+var tools = { request: requestTool };
+var googleCalendarConnector = new ConnectorPlugin({
+  slug: "google-calendar",
+  authType: AUTH_TYPES.SERVICE_ACCOUNT,
+  name: "Google Calendar",
+  description: "Connect to Google Calendar for calendar and event data access using a service account.",
+  iconUrl: "https://images.ctfassets.net/9ncizv60xc5y/5D9eTiMxiL7MaezWXyAaLG/dbcf25e1d51ab877548b3d77e4b02c6d/google-calendar.svg",
+  parameters,
+  releaseFlag: { dev1: true, dev2: true, prod: true },
+  onboarding: googleCalendarOnboarding,
+  systemPrompt: {
+    en: `### Tools
+
+- \`google-calendar_request\`: The only way to call the Google Calendar API. Use it to list calendars, get events, and manage calendar data. Authentication is handled automatically using a service account. The {calendarId} placeholder in paths is automatically replaced with the configured default calendar ID.
+
+### 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.listCalendars()\` \u2014 list all accessible calendars
+- \`client.listEvents(options?, calendarId?)\` \u2014 list events with optional filters
+- \`client.getEvent(eventId, calendarId?)\` \u2014 get a single event by ID
+- \`client.request(path, init?)\` \u2014 low-level authenticated fetch
+
+\`\`\`ts
+import type { Context } from "hono";
+import { connection } from "@squadbase/vite-server/connectors/google-calendar";
+
+const calendar = connection("<connectionId>");
+
+export default async function handler(c: Context) {
+  const now = new Date().toISOString();
+  const { items } = await calendar.listEvents({
+    timeMin: now,
+    maxResults: 10,
+    singleEvents: true,
+    orderBy: "startTime",
+  });
+
+  return c.json(
+    items.map((event) => ({
+      id: event.id,
+      summary: event.summary,
+      start: event.start.dateTime ?? event.start.date,
+      end: event.end.dateTime ?? event.end.date,
+      location: event.location,
+    })),
+  );
+}
+\`\`\`
+
+### Google Calendar API v3 Reference
+
+#### Available Endpoints
+- GET \`/calendars/{calendarId}\` \u2014 Get calendar metadata
+- GET \`/users/me/calendarList\` \u2014 List all calendars accessible by the authenticated user
+- GET \`/calendars/{calendarId}/events\` \u2014 List events on a calendar
+- GET \`/calendars/{calendarId}/events/{eventId}\` \u2014 Get a single event
+
+#### Common Query Parameters for Event Listing
+- \`timeMin\` \u2014 Lower bound (RFC3339 timestamp, e.g., "2024-01-01T00:00:00Z")
+- \`timeMax\` \u2014 Upper bound (RFC3339 timestamp)
+- \`maxResults\` \u2014 Maximum number of events (default 250, max 2500)
+- \`singleEvents=true\` \u2014 Expand recurring events into individual instances
+- \`orderBy=startTime\` \u2014 Order by start time (requires singleEvents=true)
+- \`q\` \u2014 Free text search terms
+
+#### Tips
+- Use \`{calendarId}\` placeholder in paths \u2014 it is automatically replaced with the configured default calendar ID
+- Set \`singleEvents=true\` to expand recurring events into individual instances
+- When using \`orderBy=startTime\`, you must also set \`singleEvents=true\`
+- Use RFC3339 format for time parameters (e.g., "2024-01-15T09:00:00Z" or "2024-01-15T09:00:00+09:00")
+- The default calendar ID is "primary" if not configured`,
+    ja: `### \u30C4\u30FC\u30EB
+
+- \`google-calendar_request\`: Google Calendar API\u3092\u547C\u3073\u51FA\u3059\u552F\u4E00\u306E\u624B\u6BB5\u3067\u3059\u3002\u30AB\u30EC\u30F3\u30C0\u30FC\u306E\u4E00\u89A7\u53D6\u5F97\u3001\u30A4\u30D9\u30F3\u30C8\u306E\u53D6\u5F97\u3001\u30AB\u30EC\u30F3\u30C0\u30FC\u30C7\u30FC\u30BF\u306E\u7BA1\u7406\u306B\u4F7F\u7528\u3057\u307E\u3059\u3002\u30B5\u30FC\u30D3\u30B9\u30A2\u30AB\u30A6\u30F3\u30C8\u3092\u4F7F\u7528\u3057\u3066\u8A8D\u8A3C\u306F\u81EA\u52D5\u7684\u306B\u51E6\u7406\u3055\u308C\u307E\u3059\u3002\u30D1\u30B9\u5185\u306E{calendarId}\u30D7\u30EC\u30FC\u30B9\u30DB\u30EB\u30C0\u30FC\u306F\u8A2D\u5B9A\u6E08\u307F\u306E\u30C7\u30D5\u30A9\u30EB\u30C8\u30AB\u30EC\u30F3\u30C0\u30FCID\u3067\u81EA\u52D5\u7684\u306B\u7F6E\u63DB\u3055\u308C\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.listCalendars()\` \u2014 \u30A2\u30AF\u30BB\u30B9\u53EF\u80FD\u306A\u5168\u30AB\u30EC\u30F3\u30C0\u30FC\u306E\u4E00\u89A7\u53D6\u5F97
+- \`client.listEvents(options?, calendarId?)\` \u2014 \u30D5\u30A3\u30EB\u30BF\u30FC\u4ED8\u304D\u30A4\u30D9\u30F3\u30C8\u4E00\u89A7\u53D6\u5F97
+- \`client.getEvent(eventId, calendarId?)\` \u2014 ID\u306B\u3088\u308B\u5358\u4E00\u30A4\u30D9\u30F3\u30C8\u53D6\u5F97
+- \`client.request(path, init?)\` \u2014 \u4F4E\u30EC\u30D9\u30EB\u306E\u8A8D\u8A3C\u4ED8\u304Dfetch
+
+\`\`\`ts
+import type { Context } from "hono";
+import { connection } from "@squadbase/vite-server/connectors/google-calendar";
+
+const calendar = connection("<connectionId>");
+
+export default async function handler(c: Context) {
+  const now = new Date().toISOString();
+  const { items } = await calendar.listEvents({
+    timeMin: now,
+    maxResults: 10,
+    singleEvents: true,
+    orderBy: "startTime",
+  });
+
+  return c.json(
+    items.map((event) => ({
+      id: event.id,
+      summary: event.summary,
+      start: event.start.dateTime ?? event.start.date,
+      end: event.end.dateTime ?? event.end.date,
+      location: event.location,
+    })),
+  );
+}
+\`\`\`
+
+### Google Calendar API v3 \u30EA\u30D5\u30A1\u30EC\u30F3\u30B9
+
+#### \u5229\u7528\u53EF\u80FD\u306A\u30A8\u30F3\u30C9\u30DD\u30A4\u30F3\u30C8
+- GET \`/calendars/{calendarId}\` \u2014 \u30AB\u30EC\u30F3\u30C0\u30FC\u306E\u30E1\u30BF\u30C7\u30FC\u30BF\u3092\u53D6\u5F97
+- GET \`/users/me/calendarList\` \u2014 \u8A8D\u8A3C\u30E6\u30FC\u30B6\u30FC\u304C\u30A2\u30AF\u30BB\u30B9\u53EF\u80FD\u306A\u5168\u30AB\u30EC\u30F3\u30C0\u30FC\u306E\u4E00\u89A7
+- GET \`/calendars/{calendarId}/events\` \u2014 \u30AB\u30EC\u30F3\u30C0\u30FC\u4E0A\u306E\u30A4\u30D9\u30F3\u30C8\u4E00\u89A7
+- GET \`/calendars/{calendarId}/events/{eventId}\` \u2014 \u5358\u4E00\u30A4\u30D9\u30F3\u30C8\u306E\u53D6\u5F97
+
+#### \u30A4\u30D9\u30F3\u30C8\u4E00\u89A7\u306E\u4E3B\u8981\u30AF\u30A8\u30EA\u30D1\u30E9\u30E1\u30FC\u30BF
+- \`timeMin\` \u2014 \u4E0B\u9650\uFF08RFC3339\u30BF\u30A4\u30E0\u30B9\u30BF\u30F3\u30D7\u3001\u4F8B: "2024-01-01T00:00:00Z"\uFF09
+- \`timeMax\` \u2014 \u4E0A\u9650\uFF08RFC3339\u30BF\u30A4\u30E0\u30B9\u30BF\u30F3\u30D7\uFF09
+- \`maxResults\` \u2014 \u6700\u5927\u30A4\u30D9\u30F3\u30C8\u6570\uFF08\u30C7\u30D5\u30A9\u30EB\u30C8250\u3001\u6700\u59272500\uFF09
+- \`singleEvents=true\` \u2014 \u7E70\u308A\u8FD4\u3057\u30A4\u30D9\u30F3\u30C8\u3092\u500B\u5225\u30A4\u30F3\u30B9\u30BF\u30F3\u30B9\u306B\u5C55\u958B
+- \`orderBy=startTime\` \u2014 \u958B\u59CB\u6642\u9593\u9806\u306B\u4E26\u3079\u66FF\u3048\uFF08singleEvents=true\u304C\u5FC5\u8981\uFF09
+- \`q\` \u2014 \u30D5\u30EA\u30FC\u30C6\u30AD\u30B9\u30C8\u691C\u7D22\u8A9E
+
+#### \u30D2\u30F3\u30C8
+- \u30D1\u30B9\u306B \`{calendarId}\` \u30D7\u30EC\u30FC\u30B9\u30DB\u30EB\u30C0\u30FC\u3092\u4F7F\u7528 \u2014 \u8A2D\u5B9A\u6E08\u307F\u306E\u30C7\u30D5\u30A9\u30EB\u30C8\u30AB\u30EC\u30F3\u30C0\u30FCID\u3067\u81EA\u52D5\u7684\u306B\u7F6E\u63DB\u3055\u308C\u307E\u3059
+- \`singleEvents=true\` \u3092\u8A2D\u5B9A\u3059\u308B\u3068\u3001\u7E70\u308A\u8FD4\u3057\u30A4\u30D9\u30F3\u30C8\u304C\u500B\u5225\u306E\u30A4\u30F3\u30B9\u30BF\u30F3\u30B9\u306B\u5C55\u958B\u3055\u308C\u307E\u3059
+- \`orderBy=startTime\` \u3092\u4F7F\u7528\u3059\u308B\u5834\u5408\u3001\`singleEvents=true\` \u3082\u8A2D\u5B9A\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059
+- \u6642\u9593\u30D1\u30E9\u30E1\u30FC\u30BF\u306B\u306FRFC3339\u5F62\u5F0F\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044\uFF08\u4F8B: "2024-01-15T09:00:00Z" \u3084 "2024-01-15T09:00:00+09:00"\uFF09
+- \u30C7\u30D5\u30A9\u30EB\u30C8\u30AB\u30EC\u30F3\u30C0\u30FCID\u306F\u8A2D\u5B9A\u3055\u308C\u3066\u3044\u306A\u3044\u5834\u5408 "primary" \u304C\u4F7F\u7528\u3055\u308C\u307E\u3059`
+  },
+  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/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);
+  };
+}
+
+// src/connectors/entries/google-calendar.ts
+var connection = createConnectorSdk(googleCalendarConnector, createClient);
+export {
+  connection
+};

package/dist/connectors/google-sheets-oauth.js

@@ -227,7 +227,8 @@ var AUTH_TYPES = {
   API_KEY: "api-key",
   JWT: "jwt",
   SERVICE_ACCOUNT: "service-account",
-  PAT: "pat"
+  PAT: "pat",
+  USER_PASSWORD: "user-password"
 };
 
 // ../connectors/src/connectors/google-sheets-oauth/tools/request.ts
@@ -402,7 +403,7 @@ var tools = { request: requestTool };
 var googleSheetsOauthConnector = new ConnectorPlugin({
   slug: "google-sheets",
   authType: AUTH_TYPES.OAUTH,
-  name: "Google Sheets (OAuth)",
+  name: "Google Sheets",
   description: "Connect to Google Sheets for spreadsheet data access using OAuth.",
   iconUrl: "https://images.ctfassets.net/9ncizv60xc5y/1UPQuggyiZmbb26CuaSr2h/032770e8739b183fa00b7625f024e536/google-sheets.svg",
   parameters,