@squadbase/connectors 0.0.2 → 0.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squadbase/connectors",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Squadbase Connectors",
   "type": "module",
   "main": "dist/index.js",
@@ -9,23 +9,18 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
-    },
-    "./ui": {
-      "types": "./dist/index.ui.d.ts",
-      "default": "./dist/index.ui.js"
     }
   },
   "files": [
     "dist"
   ],
+  "publishConfig": {
+    "access": "public"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/squadbase/squadbase-connectors"
   },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
-  },
   "scripts": {
     "build": "tsup",
     "add-connector": "tsx scripts/add-connector.ts",
@@ -37,34 +32,33 @@
   },
   "peerDependencies": {
     "ai": "^6.0.0",
-    "react": "^18.0.0 || ^19.0.0",
-    "zod": "^3.19.0"
+    "zod": "^3.19.0 || ^4.0.0"
   },
   "peerDependenciesMeta": {
     "ai": {
       "optional": true
-    },
-    "react": {
-      "optional": true
     }
   },
   "devDependencies": {
+    "@aws-sdk/client-athena": "^3.1007.0",
+    "@aws-sdk/client-redshift-data": "^3.1007.0",
+    "@databricks/sql": "^1.13.0",
+    "@google-cloud/bigquery": "^8.1.1",
     "@kintone/rest-api-client": "^6.1.1",
     "@squadbase/dashboard-types": "2.0.77",
     "@types/node": "^20.19.6",
     "@types/pg": "^8.16.0",
-    "@types/react": "^19.2.14",
     "ai": "^6.0.116",
     "dotenv-cli": "^11.0.0",
+    "google-auth-library": "^10.6.1",
+    "mysql2": "^3.19.1",
     "pg": "^8.18.0",
-    "react": "^19.2.4",
     "snowflake-sdk": "^2.3.4",
-    "strip-json-comments": "^5.0.3",
     "tsup": "^8.5.1",
     "tsx": "^4.19.2",
     "typescript": "^5.3.3",
     "vitest": "^4.0.18",
-    "zod": "^3.19.1"
+    "zod": "^4.3.6"
   },
   "engines": {
     "node": ">=18.0.0"

package/dist/index.ui.d.ts

@@ -1,14 +0,0 @@
-import { ComponentType } from 'react';
-
-interface DynamicToolProps {
-    toolName: string;
-    state: string;
-    input: unknown;
-    output: unknown;
-    errorText: string | undefined;
-    onSuggest?: (prompt: string, newThread: boolean) => void;
-}
-
-declare function getToolComponent(connectorKey: string, toolName: string): ComponentType<DynamicToolProps> | undefined;
-
-export { getToolComponent };

package/dist/index.ui.js

@@ -1,387 +0,0 @@
-// src/connector-plugin.ts
-var ConnectorPlugin = class {
-  slug;
-  authType;
-  name;
-  description;
-  iconUrl;
-  order;
-  parameters;
-  releaseFlag;
-  proxyPolicy;
-  systemPrompt;
-  tools;
-  createClient;
-  constructor(config) {
-    this.slug = config.slug;
-    this.authType = config.authType;
-    this.name = config.name;
-    this.description = config.description;
-    this.iconUrl = config.iconUrl;
-    this.order = config.order;
-    this.parameters = config.parameters;
-    this.releaseFlag = config.releaseFlag;
-    this.proxyPolicy = config.proxyPolicy;
-    this.systemPrompt = config.systemPrompt;
-    this.tools = config.tools;
-    this.createClient = config.createClient;
-  }
-  get connectorKey() {
-    return this.authType ? `${this.slug}-${this.authType}` : this.slug;
-  }
-};
-
-// src/auth-types.ts
-var AUTH_TYPES = {
-  OAUTH: "oauth",
-  API_KEY: "api-key",
-  JWT: "jwt",
-  SERVICE_ACCOUNT: "service-account",
-  PAT: "pat"
-};
-
-// 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;
-  }
-  /**
-   * Resolve a parameter value from a connection object (agent environment).
-   */
-  resolve(connection) {
-    const param = connection.parameters.find((p) => p.slug === this.slug);
-    if (!param || param.value == null) {
-      throw new Error(
-        `Parameter "${this.slug}" not found or has no value in connection "${connection.id}"`
-      );
-    }
-    return param.value;
-  }
-  /**
-   * Resolve the value of a connection parameter from environment variables (vite-server).
-   */
-  resolveEnvVar(entry, connectionId) {
-    const envVarName = entry.envVars[this.slug];
-    if (!envVarName) {
-      throw new Error(
-        `No env var mapping for parameter "${this.slug}" in connection "${connectionId}"`
-      );
-    }
-    const value = process.env[envVarName];
-    if (!value) {
-      throw new Error(
-        `Environment variable "${envVarName}" is not set (connection "${connectionId}", parameter "${this.slug}")`
-      );
-    }
-    return value;
-  }
-};
-
-// src/connectors/snowflake-pat/parameters.ts
-var parameters = {
-  account: new ParameterDefinition({
-    slug: "account",
-    name: "Snowflake Account",
-    description: "The Snowflake account identifier (e.g., xy12345.us-east-1).",
-    envVarBaseKey: "SNOWFLAKE_ACCOUNT",
-    type: "text",
-    secret: false,
-    required: true
-  }),
-  user: new ParameterDefinition({
-    slug: "user",
-    name: "Snowflake User",
-    description: "The username for Snowflake authentication.",
-    envVarBaseKey: "SNOWFLAKE_USER",
-    type: "text",
-    secret: false,
-    required: true
-  }),
-  role: new ParameterDefinition({
-    slug: "role",
-    name: "Snowflake Role",
-    description: "The role to use when connecting to Snowflake.",
-    envVarBaseKey: "SNOWFLAKE_ROLE",
-    type: "text",
-    secret: false,
-    required: true
-  }),
-  warehouse: new ParameterDefinition({
-    slug: "warehouse",
-    name: "Snowflake Warehouse",
-    description: "The warehouse to use for executing queries.",
-    envVarBaseKey: "SNOWFLAKE_WAREHOUSE",
-    type: "text",
-    secret: false,
-    required: true
-  }),
-  pat: new ParameterDefinition({
-    slug: "pat",
-    name: "Personal Access Token",
-    description: "Snowflake Personal Access Token (PAT) for authentication.",
-    envVarBaseKey: "SNOWFLAKE_PASSWORD",
-    type: "text",
-    secret: true,
-    required: true
-  })
-};
-
-// src/connectors/snowflake-pat/tools/execute-query/tool.ts
-import { z } from "zod";
-
-// 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)
-    };
-  }
-};
-
-// src/connectors/snowflake-pat/tools/execute-query/tool.ts
-var MAX_ROWS = 500;
-var QUERY_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 Snowflake connection to use"),
-  sql: z.string().describe(
-    "Snowflake SQL query. Use fully qualified names DB.SCHEMA.TABLE for table references."
-  )
-});
-var outputSchema = z.discriminatedUnion("success", [
-  z.object({
-    success: z.literal(true),
-    rowCount: z.number(),
-    truncated: z.boolean(),
-    rows: z.array(z.record(z.unknown()))
-  }),
-  z.object({
-    success: z.literal(false),
-    error: z.string()
-  })
-]);
-var executeQueryTool = new ConnectorTool({
-  name: "executeQuery",
-  description: `Execute SQL against Snowflake. Returns up to ${MAX_ROWS} rows.
-Use for: schema exploration (SHOW DATABASES/SCHEMAS/TABLES, DESCRIBE TABLE, INFORMATION_SCHEMA), data sampling, analytical queries.
-Avoid loading large amounts of data; always include LIMIT in queries.`,
-  inputSchema,
-  outputSchema,
-  async execute({ connectionId, sql }, connections) {
-    const connection = connections.find((c) => c.id === connectionId);
-    if (!connection) {
-      return {
-        success: false,
-        error: `Connection ${connectionId} not found`
-      };
-    }
-    console.log(
-      `[connector-query] snowflake-pat/${connection.name}: ${sql}`
-    );
-    try {
-      const snowflake = (await import("snowflake-sdk")).default;
-      snowflake.configure({ logLevel: "ERROR" });
-      const account = parameters.account.resolve(connection);
-      const user = parameters.user.resolve(connection);
-      const role = parameters.role.resolve(connection);
-      const warehouse = parameters.warehouse.resolve(connection);
-      const password = parameters.pat.resolve(connection);
-      const conn = snowflake.createConnection({
-        account,
-        username: user,
-        role,
-        warehouse,
-        password
-      });
-      await new Promise((resolve, reject) => {
-        conn.connect((err) => {
-          if (err)
-            reject(new Error(`Snowflake connect failed: ${err.message}`));
-          else resolve();
-        });
-      });
-      const allRows = await new Promise(
-        (resolve, reject) => {
-          const timeoutId = setTimeout(() => {
-            reject(
-              new Error(
-                "Snowflake query timeout: query exceeded 60 seconds"
-              )
-            );
-          }, QUERY_TIMEOUT_MS);
-          conn.execute({
-            sqlText: sql,
-            complete: (err, _stmt, rows) => {
-              clearTimeout(timeoutId);
-              if (err)
-                reject(new Error(`Snowflake query failed: ${err.message}`));
-              else resolve(rows ?? []);
-            }
-          });
-        }
-      );
-      conn.destroy((err) => {
-        if (err)
-          console.warn(
-            `[connector-query] Snowflake destroy error: ${err.message}`
-          );
-      });
-      const truncated = allRows.length > MAX_ROWS;
-      return {
-        success: true,
-        rowCount: Math.min(allRows.length, MAX_ROWS),
-        truncated,
-        rows: allRows.slice(0, MAX_ROWS)
-      };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { success: false, error: msg };
-    }
-  }
-});
-
-// src/connectors/snowflake-pat/index.ts
-var tools = [executeQueryTool];
-var snowflakePatConnector = new ConnectorPlugin({
-  slug: "snowflake",
-  authType: AUTH_TYPES.PAT,
-  name: "Snowflake (PAT)",
-  description: "Connect to Snowflake using a Personal Access Token (PAT).",
-  iconUrl: "https://images.ctfassets.net/9ncizv60xc5y/6oyVtAcP3pMlXaOrts9unk/b7a9dc25d15c388b66e983041b855447/snowflake.svg",
-  order: 11,
-  parameters: Object.values(parameters),
-  releaseFlag: { dev1: true, dev2: false, prod: false },
-  systemPrompt: `## Snowflake SQL Notes
-- Use fully qualified names DB.SCHEMA.TABLE for table references
-- Schema exploration commands:
-  - List databases: \`SHOW DATABASES\`
-  - List schemas: \`SHOW SCHEMAS IN DATABASE db_name\`
-  - List tables: \`SHOW TABLES IN SCHEMA db_name.schema_name\`
-  - List columns: \`DESCRIBE TABLE db_name.schema_name.table_name\`
-- INFORMATION_SCHEMA is also available: \`SELECT * FROM db_name.INFORMATION_SCHEMA.TABLES\``,
-  tools,
-  createClient(entry, connectionId) {
-    const account = parameters.account.resolveEnvVar(entry, connectionId);
-    const user = parameters.user.resolveEnvVar(entry, connectionId);
-    const role = parameters.role.resolveEnvVar(entry, connectionId);
-    const warehouse = parameters.warehouse.resolveEnvVar(entry, connectionId);
-    const password = parameters.pat.resolveEnvVar(entry, connectionId);
-    return {
-      async query(sql) {
-        const snowflake = (await import("snowflake-sdk")).default;
-        snowflake.configure({ logLevel: "ERROR" });
-        const conn = snowflake.createConnection({
-          account,
-          username: user,
-          role,
-          warehouse,
-          password
-        });
-        await new Promise((resolve, reject) => {
-          conn.connect((err) => {
-            if (err)
-              reject(new Error(`Snowflake connect failed: ${err.message}`));
-            else resolve();
-          });
-        });
-        const rows = await new Promise(
-          (resolve, reject) => {
-            conn.execute({
-              sqlText: sql,
-              complete: (err, _stmt, rows2) => {
-                if (err)
-                  reject(
-                    new Error(`Snowflake query failed: ${err.message}`)
-                  );
-                else resolve(rows2 ?? []);
-              }
-            });
-          }
-        );
-        conn.destroy((err) => {
-          if (err)
-            console.warn(
-              `[connector-client] Snowflake destroy error: ${err.message}`
-            );
-        });
-        return { rows };
-      }
-    };
-  }
-});
-
-// src/connectors/snowflake-pat/tools/execute-query/ui.tsx
-import { jsx, jsxs } from "react/jsx-runtime";
-var ExecuteQueryToolComponent = ({
-  state,
-  input,
-  output,
-  errorText
-}) => {
-  const inp = inputSchema.safeParse(input);
-  const out = outputSchema.safeParse(output);
-  const columns = out.success && out.data.success && out.data.rows.length > 0 ? Object.keys(out.data.rows[0]) : [];
-  return /* @__PURE__ */ jsxs("div", { children: [
-    inp.success && inp.data.sql && /* @__PURE__ */ jsx("pre", { style: { fontSize: 12, overflow: "auto", background: "#f5f5f5", padding: 8 }, children: /* @__PURE__ */ jsx("code", { children: inp.data.sql }) }),
-    state === "output-available" && out.success && out.data.success && /* @__PURE__ */ jsxs("div", { style: { overflow: "auto" }, children: [
-      /* @__PURE__ */ jsxs("table", { style: { fontSize: 12, borderCollapse: "collapse", width: "100%" }, children: [
-        /* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsx("tr", { children: columns.map((col) => /* @__PURE__ */ jsx("th", { style: { borderBottom: "1px solid #ddd", padding: "4px 8px", textAlign: "left" }, children: col }, col)) }) }),
-        /* @__PURE__ */ jsx("tbody", { children: out.data.rows.map((row, i) => /* @__PURE__ */ jsx("tr", { children: columns.map((col) => /* @__PURE__ */ jsx("td", { style: { borderBottom: "1px solid #eee", padding: "4px 8px" }, children: String(row[col] ?? "") }, col)) }, i)) })
-      ] }),
-      out.data.truncated && /* @__PURE__ */ jsxs("p", { style: { fontSize: 12, color: "#888" }, children: [
-        "Showing ",
-        out.data.rowCount,
-        " rows (results truncated)"
-      ] })
-    ] }),
-    out.success && !out.data.success && /* @__PURE__ */ jsx("p", { style: { fontSize: 12, color: "red" }, children: out.data.error }),
-    errorText && /* @__PURE__ */ jsx("p", { style: { fontSize: 12, color: "red" }, children: errorText })
-  ] });
-};
-
-// src/connectors/snowflake-pat/ui.ts
-var toolComponents = {
-  executeQuery: ExecuteQueryToolComponent
-};
-
-// src/connectors/registry.ui.ts
-var registry = [
-  { connector: snowflakePatConnector, components: toolComponents }
-];
-function getToolComponent(connectorKey, toolName) {
-  const entry = registry.find((e) => e.connector.connectorKey === connectorKey);
-  return entry?.components[toolName];
-}
-export {
-  getToolComponent
-};