@namzu/sdk 0.1.1 → 0.1.2

package/src/connector/builtins/http.ts

@@ -1,189 +1,187 @@
 import { z } from 'zod'
-import { BaseConnector } from '../BaseConnector.js'
 import type {
-  ConnectionType,
-  ConnectorMethod,
-  ConnectorExecuteResult,
-  AuthConfig,
-  HttpConnectorConfig,
-  HttpRequestInput,
-  HttpResponseOutput,
+	AuthConfig,
+	ConnectionType,
+	ConnectorExecuteResult,
+	ConnectorMethod,
+	HttpConnectorConfig,
+	HttpRequestInput,
+	HttpResponseOutput,
 } from '../../types/connector/index.js'
+import { BaseConnector } from '../BaseConnector.js'
 
 const HttpConnectorConfigSchema = z.object({
-  baseUrl: z.string().url(),
-  defaultHeaders: z.record(z.string()).optional(),
-  timeoutMs: z.number().positive().optional().default(30_000),
+	baseUrl: z.string().url(),
+	defaultHeaders: z.record(z.string()).optional(),
+	timeoutMs: z.number().positive().optional().default(30_000),
 })
 
 const HttpRequestInputSchema = z.object({
-  method: z.enum(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD']),
-  path: z.string(),
-  headers: z.record(z.string()).optional(),
-  query: z.record(z.string()).optional(),
-  body: z.unknown().optional(),
+	method: z.enum(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD']),
+	path: z.string(),
+	headers: z.record(z.string()).optional(),
+	query: z.record(z.string()).optional(),
+	body: z.unknown().optional(),
 })
 
 export class HttpConnector extends BaseConnector<HttpConnectorConfig> {
-  readonly id = 'http'
-  readonly name = 'HTTP Connector'
-  readonly description = 'Generic HTTP/REST API connector for making HTTP requests'
-  readonly connectionType: ConnectionType = 'http'
-  readonly configSchema = HttpConnectorConfigSchema
-  readonly methods: ConnectorMethod[] = [
-    {
-      name: 'request',
-      description: 'Make an HTTP request to the configured base URL',
-      inputSchema: HttpRequestInputSchema,
-    },
-  ]
-
-  private baseUrl = ''
-  private defaultHeaders: Record<string, string> = {}
-  private timeoutMs = 30_000
-
-  async connect(config: HttpConnectorConfig, auth?: AuthConfig): Promise<void> {
-    this.config = config
-    this.auth = auth
-    this.baseUrl = config.baseUrl.replace(/\/+$/, '')
-    this.defaultHeaders = config.defaultHeaders ?? {}
-    this.timeoutMs = config.timeoutMs ?? 30_000
-
-    if (auth) {
-      Object.assign(this.defaultHeaders, this.resolveAuthHeaders(auth))
-    }
-
-    this.log.info(`HTTP connector connected to ${this.baseUrl}`)
-  }
-
-  async disconnect(): Promise<void> {
-    this.config = null
-    this.auth = undefined
-    this.baseUrl = ''
-    this.defaultHeaders = {}
-    this.log.info('HTTP connector disconnected')
-  }
-
-  async healthCheck(): Promise<boolean> {
-    if (!this.baseUrl) return false
-    try {
-      const controller = new AbortController()
-      const timeout = setTimeout(() => controller.abort(), 5_000)
-      const response = await fetch(this.baseUrl, {
-        method: 'HEAD',
-        signal: controller.signal,
-      })
-      clearTimeout(timeout)
-      return response.ok || response.status < 500
-    } catch {
-      return false
-    }
-  }
-
-  async execute(method: string, input: unknown): Promise<ConnectorExecuteResult> {
-    this.requireMethod(method)
-    const validated = this.validateInput(
-      this.requireMethod(method),
-      input,
-    ) as HttpRequestInput
-
-    const { result, durationMs } = await this.measureExecution(() =>
-      this.doRequest(validated),
-    )
-
-    return {
-      success: result.status >= 200 && result.status < 400,
-      output: result,
-      durationMs,
-      metadata: {
-        status: result.status,
-        statusText: result.statusText,
-      },
-    }
-  }
-
-  private async doRequest(input: HttpRequestInput): Promise<HttpResponseOutput> {
-    const url = new URL(input.path, this.baseUrl + '/')
-    if (input.query) {
-      for (const [key, value] of Object.entries(input.query)) {
-        url.searchParams.set(key, value)
-      }
-    }
-
-    const headers: Record<string, string> = {
-      ...this.defaultHeaders,
-      ...input.headers,
-    }
-
-    if (input.body && !headers['content-type'] && !headers['Content-Type']) {
-      headers['Content-Type'] = 'application/json'
-    }
-
-    const controller = new AbortController()
-    const timeout = setTimeout(() => controller.abort(), this.timeoutMs)
-
-    try {
-      const response = await fetch(url.toString(), {
-        method: input.method,
-        headers,
-        body: input.body !== undefined ? JSON.stringify(input.body) : undefined,
-        signal: controller.signal,
-      })
-
-      const responseHeaders: Record<string, string> = {}
-      response.headers.forEach((value, key) => {
-        responseHeaders[key] = value
-      })
-
-      let body: unknown
-      const contentType = response.headers.get('content-type') ?? ''
-      if (contentType.includes('application/json')) {
-        body = await response.json()
-      } else {
-        body = await response.text()
-      }
-
-      return {
-        status: response.status,
-        statusText: response.statusText,
-        headers: responseHeaders,
-        body,
-      }
-    } finally {
-      clearTimeout(timeout)
-    }
-  }
-
-  private resolveAuthHeaders(auth: AuthConfig): Record<string, string> {
-    const creds = auth.credentials ?? {}
-    switch (auth.type) {
-      case 'api_key': {
-        const apiKey = creds['apiKey']
-        if (!apiKey) throw new Error('AuthConfig api_key: missing required credential "apiKey"')
-        return {
-          [creds['headerName'] ?? 'X-API-Key']: apiKey,
-        }
-      }
-      case 'bearer': {
-        const token = creds['token']
-        if (!token) throw new Error('AuthConfig bearer: missing required credential "token"')
-        return { Authorization: `Bearer ${token}` }
-      }
-      case 'basic': {
-        const username = creds['username']
-        const password = creds['password']
-        if (!username || !password) throw new Error('AuthConfig basic: missing required credentials "username" and "password"')
-        const encoded = btoa(`${username}:${password}`)
-        return { Authorization: `Basic ${encoded}` }
-      }
-      case 'none':
-      case 'oauth2':
-      case 'custom':
-        return {}
-      default: {
-        const _exhaustive: never = auth.type
-        throw new Error(`Unhandled auth type: ${_exhaustive}`)
-      }
-    }
-  }
+	readonly id = 'http'
+	readonly name = 'HTTP Connector'
+	readonly description = 'Generic HTTP/REST API connector for making HTTP requests'
+	readonly connectionType: ConnectionType = 'http'
+	readonly configSchema = HttpConnectorConfigSchema
+	readonly methods: ConnectorMethod[] = [
+		{
+			name: 'request',
+			description: 'Make an HTTP request to the configured base URL',
+			inputSchema: HttpRequestInputSchema,
+		},
+	]
+
+	private baseUrl = ''
+	private defaultHeaders: Record<string, string> = {}
+	private timeoutMs = 30_000
+
+	async connect(config: HttpConnectorConfig, auth?: AuthConfig): Promise<void> {
+		this.config = config
+		this.auth = auth
+		this.baseUrl = config.baseUrl.replace(/\/+$/, '')
+		this.defaultHeaders = config.defaultHeaders ?? {}
+		this.timeoutMs = config.timeoutMs ?? 30_000
+
+		if (auth) {
+			Object.assign(this.defaultHeaders, this.resolveAuthHeaders(auth))
+		}
+
+		this.log.info(`HTTP connector connected to ${this.baseUrl}`)
+	}
+
+	async disconnect(): Promise<void> {
+		this.config = null
+		this.auth = undefined
+		this.baseUrl = ''
+		this.defaultHeaders = {}
+		this.log.info('HTTP connector disconnected')
+	}
+
+	async healthCheck(): Promise<boolean> {
+		if (!this.baseUrl) return false
+		try {
+			const controller = new AbortController()
+			const timeout = setTimeout(() => controller.abort(), 5_000)
+			const response = await fetch(this.baseUrl, {
+				method: 'HEAD',
+				signal: controller.signal,
+			})
+			clearTimeout(timeout)
+			return response.ok || response.status < 500
+		} catch {
+			return false
+		}
+	}
+
+	async execute(method: string, input: unknown): Promise<ConnectorExecuteResult> {
+		this.requireMethod(method)
+		const validated = this.validateInput(this.requireMethod(method), input) as HttpRequestInput
+
+		const { result, durationMs } = await this.measureExecution(() => this.doRequest(validated))
+
+		return {
+			success: result.status >= 200 && result.status < 400,
+			output: result,
+			durationMs,
+			metadata: {
+				status: result.status,
+				statusText: result.statusText,
+			},
+		}
+	}
+
+	private async doRequest(input: HttpRequestInput): Promise<HttpResponseOutput> {
+		const url = new URL(input.path, `${this.baseUrl}/`)
+		if (input.query) {
+			for (const [key, value] of Object.entries(input.query)) {
+				url.searchParams.set(key, value)
+			}
+		}
+
+		const headers: Record<string, string> = {
+			...this.defaultHeaders,
+			...input.headers,
+		}
+
+		if (input.body && !headers['content-type'] && !headers['Content-Type']) {
+			headers['Content-Type'] = 'application/json'
+		}
+
+		const controller = new AbortController()
+		const timeout = setTimeout(() => controller.abort(), this.timeoutMs)
+
+		try {
+			const response = await fetch(url.toString(), {
+				method: input.method,
+				headers,
+				body: input.body !== undefined ? JSON.stringify(input.body) : undefined,
+				signal: controller.signal,
+			})
+
+			const responseHeaders: Record<string, string> = {}
+			response.headers.forEach((value, key) => {
+				responseHeaders[key] = value
+			})
+
+			let body: unknown
+			const contentType = response.headers.get('content-type') ?? ''
+			if (contentType.includes('application/json')) {
+				body = await response.json()
+			} else {
+				body = await response.text()
+			}
+
+			return {
+				status: response.status,
+				statusText: response.statusText,
+				headers: responseHeaders,
+				body,
+			}
+		} finally {
+			clearTimeout(timeout)
+		}
+	}
+
+	private resolveAuthHeaders(auth: AuthConfig): Record<string, string> {
+		const creds = auth.credentials ?? {}
+		switch (auth.type) {
+			case 'api_key': {
+				const apiKey = creds.apiKey
+				if (!apiKey) throw new Error('AuthConfig api_key: missing required credential "apiKey"')
+				return {
+					[creds.headerName ?? 'X-API-Key']: apiKey,
+				}
+			}
+			case 'bearer': {
+				const token = creds.token
+				if (!token) throw new Error('AuthConfig bearer: missing required credential "token"')
+				return { Authorization: `Bearer ${token}` }
+			}
+			case 'basic': {
+				const username = creds.username
+				const password = creds.password
+				if (!username || !password)
+					throw new Error(
+						'AuthConfig basic: missing required credentials "username" and "password"',
+					)
+				const encoded = btoa(`${username}:${password}`)
+				return { Authorization: `Basic ${encoded}` }
+			}
+			case 'none':
+			case 'oauth2':
+			case 'custom':
+				return {}
+			default: {
+				const _exhaustive: never = auth.type
+				throw new Error(`Unhandled auth type: ${_exhaustive}`)
+			}
+		}
+	}
 }

package/src/connector/builtins/webhook.ts

@@ -1,153 +1,146 @@
-import { z } from 'zod'
 import { createHmac } from 'node:crypto'
-import { BaseConnector } from '../BaseConnector.js'
+import { z } from 'zod'
 import type {
-  ConnectionType,
-  ConnectorMethod,
-  ConnectorExecuteResult,
-  AuthConfig,
-  WebhookConnectorConfig,
-  WebhookSendInput,
-  WebhookSendOutput,
+	AuthConfig,
+	ConnectionType,
+	ConnectorExecuteResult,
+	ConnectorMethod,
+	WebhookConnectorConfig,
+	WebhookSendInput,
+	WebhookSendOutput,
 } from '../../types/connector/index.js'
+import { BaseConnector } from '../BaseConnector.js'
 
 const WebhookConnectorConfigSchema = z.object({
-  url: z.string().url(),
-  secret: z.string().optional(),
-  defaultHeaders: z.record(z.string()).optional(),
-  timeoutMs: z.number().positive().optional().default(30_000),
+	url: z.string().url(),
+	secret: z.string().optional(),
+	defaultHeaders: z.record(z.string()).optional(),
+	timeoutMs: z.number().positive().optional().default(30_000),
 })
 
 const WebhookSendInputSchema = z.object({
-  payload: z.unknown(),
-  headers: z.record(z.string()).optional(),
-  url: z.string().url().optional(),
+	payload: z.unknown(),
+	headers: z.record(z.string()).optional(),
+	url: z.string().url().optional(),
 })
 
 export class WebhookConnector extends BaseConnector<WebhookConnectorConfig> {
-  readonly id = 'webhook'
-  readonly name = 'Webhook Connector'
-  readonly description = 'Send webhook payloads to configured endpoints with optional HMAC signing'
-  readonly connectionType: ConnectionType = 'webhook'
-  readonly configSchema = WebhookConnectorConfigSchema
-  readonly methods: ConnectorMethod[] = [
-    {
-      name: 'send',
-      description: 'Send a webhook payload to the configured URL',
-      inputSchema: WebhookSendInputSchema,
-    },
-  ]
-
-  private url = ''
-  private secret: string | undefined
-  private defaultHeaders: Record<string, string> = {}
-  private timeoutMs = 30_000
-
-  async connect(config: WebhookConnectorConfig, auth?: AuthConfig): Promise<void> {
-    this.config = config
-    this.auth = auth
-    this.url = config.url
-    this.secret = config.secret
-    this.defaultHeaders = config.defaultHeaders ?? {}
-    this.timeoutMs = config.timeoutMs ?? 30_000
-
-    if (auth?.type === 'bearer' && auth.credentials?.['token']) {
-      this.defaultHeaders['Authorization'] = `Bearer ${auth.credentials['token']}`
-    }
-
-    this.log.info(`Webhook connector connected to ${this.url}`)
-  }
-
-  async disconnect(): Promise<void> {
-    this.config = null
-    this.auth = undefined
-    this.url = ''
-    this.secret = undefined
-    this.defaultHeaders = {}
-    this.log.info('Webhook connector disconnected')
-  }
-
-  async healthCheck(): Promise<boolean> {
-    if (!this.url) return false
-    try {
-      const controller = new AbortController()
-      const timeout = setTimeout(() => controller.abort(), 5_000)
-      const response = await fetch(this.url, {
-        method: 'HEAD',
-        signal: controller.signal,
-      })
-      clearTimeout(timeout)
-      return response.ok || response.status < 500
-    } catch {
-      return false
-    }
-  }
-
-  async execute(method: string, input: unknown): Promise<ConnectorExecuteResult> {
-    this.requireMethod(method)
-    const validated = this.validateInput(
-      this.requireMethod(method),
-      input,
-    ) as WebhookSendInput
-
-    const { result, durationMs } = await this.measureExecution(() =>
-      this.doSend(validated),
-    )
-
-    return {
-      success: result.status >= 200 && result.status < 400,
-      output: result,
-      durationMs,
-      metadata: {
-        status: result.status,
-        deliveredAt: result.deliveredAt,
-      },
-    }
-  }
-
-  private async doSend(input: WebhookSendInput): Promise<WebhookSendOutput> {
-    const targetUrl = input.url ?? this.url
-    const bodyStr = JSON.stringify(input.payload)
-
-    const headers: Record<string, string> = {
-      'Content-Type': 'application/json',
-      ...this.defaultHeaders,
-      ...input.headers,
-    }
-
-    if (this.secret) {
-      const signature = createHmac('sha256', this.secret)
-        .update(bodyStr)
-        .digest('hex')
-      headers['X-Webhook-Signature'] = `sha256=${signature}`
-    }
-
-    const controller = new AbortController()
-    const timeout = setTimeout(() => controller.abort(), this.timeoutMs)
-
-    try {
-      const response = await fetch(targetUrl, {
-        method: 'POST',
-        headers,
-        body: bodyStr,
-        signal: controller.signal,
-      })
-
-      let body: unknown
-      const contentType = response.headers.get('content-type') ?? ''
-      if (contentType.includes('application/json')) {
-        body = await response.json()
-      } else {
-        body = await response.text()
-      }
-
-      return {
-        status: response.status,
-        body,
-        deliveredAt: Date.now(),
-      }
-    } finally {
-      clearTimeout(timeout)
-    }
-  }
+	readonly id = 'webhook'
+	readonly name = 'Webhook Connector'
+	readonly description = 'Send webhook payloads to configured endpoints with optional HMAC signing'
+	readonly connectionType: ConnectionType = 'webhook'
+	readonly configSchema = WebhookConnectorConfigSchema
+	readonly methods: ConnectorMethod[] = [
+		{
+			name: 'send',
+			description: 'Send a webhook payload to the configured URL',
+			inputSchema: WebhookSendInputSchema,
+		},
+	]
+
+	private url = ''
+	private secret: string | undefined
+	private defaultHeaders: Record<string, string> = {}
+	private timeoutMs = 30_000
+
+	async connect(config: WebhookConnectorConfig, auth?: AuthConfig): Promise<void> {
+		this.config = config
+		this.auth = auth
+		this.url = config.url
+		this.secret = config.secret
+		this.defaultHeaders = config.defaultHeaders ?? {}
+		this.timeoutMs = config.timeoutMs ?? 30_000
+
+		if (auth?.type === 'bearer' && auth.credentials?.token) {
+			this.defaultHeaders.Authorization = `Bearer ${auth.credentials.token}`
+		}
+
+		this.log.info(`Webhook connector connected to ${this.url}`)
+	}
+
+	async disconnect(): Promise<void> {
+		this.config = null
+		this.auth = undefined
+		this.url = ''
+		this.secret = undefined
+		this.defaultHeaders = {}
+		this.log.info('Webhook connector disconnected')
+	}
+
+	async healthCheck(): Promise<boolean> {
+		if (!this.url) return false
+		try {
+			const controller = new AbortController()
+			const timeout = setTimeout(() => controller.abort(), 5_000)
+			const response = await fetch(this.url, {
+				method: 'HEAD',
+				signal: controller.signal,
+			})
+			clearTimeout(timeout)
+			return response.ok || response.status < 500
+		} catch {
+			return false
+		}
+	}
+
+	async execute(method: string, input: unknown): Promise<ConnectorExecuteResult> {
+		this.requireMethod(method)
+		const validated = this.validateInput(this.requireMethod(method), input) as WebhookSendInput
+
+		const { result, durationMs } = await this.measureExecution(() => this.doSend(validated))
+
+		return {
+			success: result.status >= 200 && result.status < 400,
+			output: result,
+			durationMs,
+			metadata: {
+				status: result.status,
+				deliveredAt: result.deliveredAt,
+			},
+		}
+	}
+
+	private async doSend(input: WebhookSendInput): Promise<WebhookSendOutput> {
+		const targetUrl = input.url ?? this.url
+		const bodyStr = JSON.stringify(input.payload)
+
+		const headers: Record<string, string> = {
+			'Content-Type': 'application/json',
+			...this.defaultHeaders,
+			...input.headers,
+		}
+
+		if (this.secret) {
+			const signature = createHmac('sha256', this.secret).update(bodyStr).digest('hex')
+			headers['X-Webhook-Signature'] = `sha256=${signature}`
+		}
+
+		const controller = new AbortController()
+		const timeout = setTimeout(() => controller.abort(), this.timeoutMs)
+
+		try {
+			const response = await fetch(targetUrl, {
+				method: 'POST',
+				headers,
+				body: bodyStr,
+				signal: controller.signal,
+			})
+
+			let body: unknown
+			const contentType = response.headers.get('content-type') ?? ''
+			if (contentType.includes('application/json')) {
+				body = await response.json()
+			} else {
+				body = await response.text()
+			}
+
+			return {
+				status: response.status,
+				body,
+				deliveredAt: Date.now(),
+			}
+		} finally {
+			clearTimeout(timeout)
+		}
+	}
 }