@squadbase/connectors 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,144 @@
+import { Tool } from 'ai';
+import { ZodType } from 'zod';
+
+interface ReleaseFlag {
+    dev1: boolean;
+    dev2: boolean;
+    prod: boolean;
+}
+interface ProxyPolicyRule {
+    host?: string;
+    hostRegex?: string;
+    port?: number;
+    pathPrefix?: string;
+    methods?: ("GET" | "POST" | "PUT" | "PATCH" | "DELETE")[];
+    allowPrivateNetwork?: boolean;
+}
+interface ProxyPolicy {
+    allowlist: ProxyPolicyRule[];
+}
+interface ConnectorConnection {
+    id: string;
+    name: string;
+    parameters: {
+        slug: string;
+        value: string | null;
+    }[];
+}
+interface ConnectorToolsConfig {
+    oauthProxy: {
+        appApiKey: string;
+        projectId: string;
+        environmentId: string;
+        sandboxId: string;
+        appApiBaseUrl: string;
+        previewBaseDomain: string;
+    };
+}
+interface DatabaseClient {
+    query(sql: string, params?: unknown[]): Promise<{
+        rows: Record<string, unknown>[];
+    }>;
+}
+interface ConnectionEntry {
+    connector: {
+        slug: string;
+        authType?: string | null;
+    };
+    envVars: Record<string, string>;
+}
+interface DynamicToolProps {
+    toolName: string;
+    state: string;
+    input: unknown;
+    output: unknown;
+    errorText: string | undefined;
+    onSuggest?: (prompt: string, newThread: boolean) => void;
+}
+
+declare class ParameterDefinition {
+    readonly slug: string;
+    readonly name: string;
+    readonly description: string;
+    readonly envVarBaseKey: string;
+    readonly type: "text" | "base64EncodedJson";
+    readonly secret: boolean;
+    readonly required: boolean;
+    constructor(config: {
+        slug: string;
+        name: string;
+        description: string;
+        envVarBaseKey: string;
+        type: "text" | "base64EncodedJson";
+        secret: boolean;
+        required: boolean;
+    });
+    /**
+     * Resolve a parameter value from a connection object (agent environment).
+     */
+    resolve(connection: ConnectorConnection): string;
+    /**
+     * Resolve the value of a connection parameter from environment variables (vite-server).
+     */
+    resolveEnvVar(entry: ConnectionEntry, connectionId: string): string;
+}
+
+declare class ConnectorTool<I = any, O = any> {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: ZodType<I>;
+    readonly outputSchema: ZodType<O>;
+    private readonly _execute;
+    constructor(config: {
+        readonly name: string;
+        readonly description: string;
+        readonly inputSchema: ZodType<I>;
+        readonly outputSchema: ZodType<O>;
+        readonly execute: (input: I, connections: ConnectorConnection[], config: ConnectorToolsConfig) => Promise<O>;
+    });
+    createTool(connections: ConnectorConnection[], config: ConnectorToolsConfig): Tool;
+}
+
+declare class ConnectorPlugin {
+    readonly slug: string;
+    readonly authType: string | null;
+    readonly name: string;
+    readonly description: string;
+    readonly iconUrl: string;
+    readonly order?: number;
+    readonly parameters: readonly ParameterDefinition[];
+    readonly releaseFlag: ReleaseFlag;
+    readonly proxyPolicy?: ProxyPolicy;
+    readonly systemPrompt: string;
+    readonly tools: readonly ConnectorTool[];
+    readonly createClient?: (entry: ConnectionEntry, connectionId: string) => DatabaseClient;
+    constructor(config: {
+        slug: string;
+        authType: string | null;
+        name: string;
+        description: string;
+        iconUrl: string;
+        order?: number;
+        parameters: readonly ParameterDefinition[];
+        releaseFlag: ReleaseFlag;
+        proxyPolicy?: ProxyPolicy;
+        systemPrompt: string;
+        tools: readonly ConnectorTool[];
+        createClient?: (entry: ConnectionEntry, connectionId: string) => DatabaseClient;
+    });
+    get connectorKey(): string;
+}
+
+declare const AUTH_TYPES: {
+    readonly OAUTH: "oauth";
+    readonly API_KEY: "api-key";
+    readonly JWT: "jwt";
+    readonly SERVICE_ACCOUNT: "service-account";
+    readonly PAT: "pat";
+};
+
+declare const connectors: ConnectorPlugin[];
+
+declare const snowflakePatConnector: ConnectorPlugin;
+
+export { AUTH_TYPES, type ConnectionEntry, type ConnectorConnection, ConnectorPlugin, ConnectorTool, type ConnectorToolsConfig, type DatabaseClient, type DynamicToolProps, ParameterDefinition, type ProxyPolicy, type ProxyPolicyRule, type ReleaseFlag, connectors, snowflakePatConnector };

package/dist/index.js

@@ -0,0 +1,352 @@
+// 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/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/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/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";
+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/registry.ts
+var connectors = [
+  snowflakePatConnector
+];
+export {
+  AUTH_TYPES,
+  ConnectorPlugin,
+  ConnectorTool,
+  ParameterDefinition,
+  connectors,
+  snowflakePatConnector
+};

package/dist/index.ui.d.ts

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,387 @@
+// 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
+};

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@squadbase/connectors",
+  "version": "0.0.1",
+  "description": "Squadbase Connectors",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./ui": {
+      "types": "./dist/index.ui.d.ts",
+      "default": "./dist/index.ui.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "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",
+    "sync:dev1": "API_BASE_URL=https://dev1-api.squadbase.dev/v0 dotenv tsx scripts/sync-connectors.ts",
+    "sync:dev2": "API_BASE_URL=https://dev2-api.squadbase.dev/v0 dotenv tsx scripts/sync-connectors.ts",
+    "sync:prod": "API_BASE_URL=https://api.squadbase.dev/v0 dotenv tsx scripts/sync-connectors.ts",
+    "prepare-test-datasource": "tsx scripts/prepare-test-datasource.ts",
+    "test": "vitest"
+  },
+  "peerDependencies": {
+    "ai": "^6.0.0",
+    "react": "^18.0.0 || ^19.0.0",
+    "zod": "^3.19.0"
+  },
+  "peerDependenciesMeta": {
+    "ai": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@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",
+    "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"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}