@namzu/sdk 0.1.1 → 0.1.2

package/src/connector/execution/remote.ts

@@ -1,131 +1,129 @@
+import { BaseExecutionContext } from '../../execution/base.js'
 import type {
-  ExecutionEnvironment,
-  ExecutionCapability,
-  RemoteExecutionContextConfig,
-  RemoteTarget,
-  CommandOptions,
-  CommandResult,
-  RemoteCommandHandler,
-  ConnectorExecutionContextEvent,
+	CommandOptions,
+	CommandResult,
+	ExecutionCapability,
+	ExecutionEnvironment,
+	RemoteCommandHandler,
+	RemoteExecutionContextConfig,
+	RemoteTarget,
 } from '../../types/connector/index.js'
-import { BaseExecutionContext } from '../../execution/base.js'
 
 export interface RemoteExecutionContextOptions {
-  id: string
-  target: RemoteTarget
-  capabilities?: ExecutionCapability[]
-  commandHandler?: RemoteCommandHandler
+	id: string
+	target: RemoteTarget
+	capabilities?: ExecutionCapability[]
+	commandHandler?: RemoteCommandHandler
 }
 
 export class RemoteExecutionContext extends BaseExecutionContext {
-  readonly id: string
-  readonly environment: ExecutionEnvironment = 'remote'
-
-  private target: RemoteTarget
-  private connected = false
-  private capabilities: ExecutionCapability[]
-  private commandHandler: RemoteCommandHandler | undefined
-
-  constructor(options: RemoteExecutionContextOptions) {
-    super()
-    this.id = options.id
-    this.target = options.target
-    this.capabilities = options.capabilities ?? ['network']
-    this.commandHandler = options.commandHandler
-  }
-
-  protected async doInitialize(): Promise<void> {
-    this.validateTarget(this.target)
-    this.log.info(`Remote context initialized for ${this.target.type}://${this.target.host}`)
-  }
-
-  protected async doTeardown(): Promise<void> {
-    if (this.connected) {
-      this.connected = false
-      this.emit({
-        type: 'remote_disconnected',
-        contextId: this.id,
-        host: this.target.host,
-      })
-    }
-  }
-
-  async connect(): Promise<void> {
-    this.connected = true
-    this.emit({
-      type: 'remote_connected',
-      contextId: this.id,
-      target: this.target,
-    })
-    this.log.info(`Remote connected: ${this.target.type}://${this.target.host}:${this.target.port ?? 'default'}`)
-  }
-
-  async disconnect(): Promise<void> {
-    if (!this.connected) return
-    this.connected = false
-    this.emit({
-      type: 'remote_disconnected',
-      contextId: this.id,
-      host: this.target.host,
-    })
-    this.log.info(`Remote disconnected: ${this.target.host}`)
-  }
-
-  isConnected(): boolean {
-    return this.connected
-  }
-
-  getTarget(): RemoteTarget {
-    return { ...this.target }
-  }
-
-  getConnectionString(): string {
-    const port = this.target.port ? `:${this.target.port}` : ''
-    return `${this.target.type}://${this.target.host}${port}`
-  }
-
-  getCapabilities(): ExecutionCapability[] {
-    return [...this.capabilities]
-  }
-
-  hasCapability(cap: ExecutionCapability): boolean {
-    return this.capabilities.includes(cap)
-  }
-
-  setCommandHandler(handler: RemoteCommandHandler): void {
-    this.commandHandler = handler
-  }
-
-  async executeRemote(command: string, options?: CommandOptions): Promise<CommandResult> {
-    if (!this.commandHandler) {
-      throw new Error(
-        `No remote command handler configured for context "${this.id}". ` +
-        'Set one via setCommandHandler() before calling executeRemote().',
-      )
-    }
-    if (!this.connected) {
-      throw new Error(
-        `Remote context "${this.id}" is not connected. Call connect() first.`,
-      )
-    }
-    return this.commandHandler.executeRemote(command, options)
-  }
-
-  toConfig(): RemoteExecutionContextConfig {
-    return {
-      id: this.id,
-      environment: 'remote',
-      target: { ...this.target },
-      capabilities: this.capabilities,
-    }
-  }
-
-  private validateTarget(target: RemoteTarget): void {
-    if (!target.host) {
-      throw new Error('Remote target must have a host')
-    }
-    if (!['ssh', 'rdp', 'api'].includes(target.type)) {
-      throw new Error(`Unsupported remote target type: "${target.type}"`)
-    }
-  }
+	readonly id: string
+	readonly environment: ExecutionEnvironment = 'remote'
+
+	private target: RemoteTarget
+	private connected = false
+	private capabilities: ExecutionCapability[]
+	private commandHandler: RemoteCommandHandler | undefined
+
+	constructor(options: RemoteExecutionContextOptions) {
+		super()
+		this.id = options.id
+		this.target = options.target
+		this.capabilities = options.capabilities ?? ['network']
+		this.commandHandler = options.commandHandler
+	}
+
+	protected async doInitialize(): Promise<void> {
+		this.validateTarget(this.target)
+		this.log.info(`Remote context initialized for ${this.target.type}://${this.target.host}`)
+	}
+
+	protected async doTeardown(): Promise<void> {
+		if (this.connected) {
+			this.connected = false
+			this.emit({
+				type: 'remote_disconnected',
+				contextId: this.id,
+				host: this.target.host,
+			})
+		}
+	}
+
+	async connect(): Promise<void> {
+		this.connected = true
+		this.emit({
+			type: 'remote_connected',
+			contextId: this.id,
+			target: this.target,
+		})
+		this.log.info(
+			`Remote connected: ${this.target.type}://${this.target.host}:${this.target.port ?? 'default'}`,
+		)
+	}
+
+	async disconnect(): Promise<void> {
+		if (!this.connected) return
+		this.connected = false
+		this.emit({
+			type: 'remote_disconnected',
+			contextId: this.id,
+			host: this.target.host,
+		})
+		this.log.info(`Remote disconnected: ${this.target.host}`)
+	}
+
+	isConnected(): boolean {
+		return this.connected
+	}
+
+	getTarget(): RemoteTarget {
+		return { ...this.target }
+	}
+
+	getConnectionString(): string {
+		const port = this.target.port ? `:${this.target.port}` : ''
+		return `${this.target.type}://${this.target.host}${port}`
+	}
+
+	getCapabilities(): ExecutionCapability[] {
+		return [...this.capabilities]
+	}
+
+	hasCapability(cap: ExecutionCapability): boolean {
+		return this.capabilities.includes(cap)
+	}
+
+	setCommandHandler(handler: RemoteCommandHandler): void {
+		this.commandHandler = handler
+	}
+
+	async executeRemote(command: string, options?: CommandOptions): Promise<CommandResult> {
+		if (!this.commandHandler) {
+			throw new Error(
+				`No remote command handler configured for context "${this.id}". Set one via setCommandHandler() before calling executeRemote().`,
+			)
+		}
+		if (!this.connected) {
+			throw new Error(`Remote context "${this.id}" is not connected. Call connect() first.`)
+		}
+		return this.commandHandler.executeRemote(command, options)
+	}
+
+	toConfig(): RemoteExecutionContextConfig {
+		return {
+			id: this.id,
+			environment: 'remote',
+			target: { ...this.target },
+			capabilities: this.capabilities,
+		}
+	}
+
+	private validateTarget(target: RemoteTarget): void {
+		if (!target.host) {
+			throw new Error('Remote target must have a host')
+		}
+		if (!['ssh', 'rdp', 'api'].includes(target.type)) {
+			throw new Error(`Unsupported remote target type: "${target.type}"`)
+		}
+	}
 }

package/src/connector/index.ts

@@ -11,8 +11,8 @@ export type { TenantConnectorManagerConfig } from '../manager/connector/tenant.j
 
 export { EnvironmentConnectorManager } from '../manager/connector/environment.js'
 export type {
-  EnvironmentConnectorSetup,
-  EnvironmentConnectorManagerConfig,
+	EnvironmentConnectorSetup,
+	EnvironmentConnectorManagerConfig,
 } from '../manager/connector/environment.js'
 
 export { HttpConnector } from './builtins/http.js'
@@ -23,13 +23,13 @@ export { LocalExecutionContext } from '../execution/local.js'
 export type { LocalExecutionContextOptions } from '../execution/local.js'
 
 export {
-  RemoteExecutionContext,
-  HybridExecutionContext,
-  ExecutionContextFactory,
+	RemoteExecutionContext,
+	HybridExecutionContext,
+	ExecutionContextFactory,
 } from './execution/index.js'
 export type {
-  RemoteExecutionContextOptions,
-  HybridExecutionContextOptions,
+	RemoteExecutionContextOptions,
+	HybridExecutionContextOptions,
 } from './execution/index.js'
 
 export { StdioTransport } from './mcp/stdio.js'
@@ -38,12 +38,12 @@ export { HttpSseTransport } from './mcp/http-sse.js'
 export { MCPClient } from './mcp/client.js'
 
 export {
-  mcpToolToToolDefinition,
-  toolDefinitionToMCPTool,
-  mcpJsonSchemaToZod,
-  zodToMCPJsonSchema,
-  mcpToolResultToToolResult,
-  toolResultToMCPToolResult,
+	mcpToolToToolDefinition,
+	toolDefinitionToMCPTool,
+	mcpJsonSchemaToZod,
+	zodToMCPJsonSchema,
+	mcpToolResultToToolResult,
+	toolResultToMCPToolResult,
 } from './mcp/adapter.js'
 
 export { MCPToolDiscovery } from './mcp/discovery.js'

package/src/connector/mcp/adapter.ts

@@ -1,131 +1,131 @@
 import { z } from 'zod'
 import { zodToJsonSchema } from 'zod-to-json-schema'
-import type { ToolDefinition, ToolContext, ToolResult } from '../../types/tool/index.js'
 import type {
-  MCPToolDefinition,
-  MCPJsonSchema,
-  MCPToolResult,
+	MCPJsonSchema,
+	MCPToolDefinition,
+	MCPToolResult,
 } from '../../types/connector/index.js'
+import type { ToolContext, ToolDefinition, ToolResult } from '../../types/tool/index.js'
 import type { MCPClient } from './client.js'
 
 export function mcpJsonSchemaToZod(schema: MCPJsonSchema): z.ZodType {
-  if (!schema.properties || Object.keys(schema.properties).length === 0) {
-    return z.object({}).passthrough()
-  }
-
-  const shape: Record<string, z.ZodType> = {}
-  const required = new Set(schema.required ?? [])
-
-  for (const [key, propSchema] of Object.entries(schema.properties)) {
-    let field = jsonSchemaPropertyToZod(propSchema)
-    if (!required.has(key)) {
-      field = field.optional()
-    }
-    shape[key] = field
-  }
-
-  return z.object(shape).passthrough()
+	if (!schema.properties || Object.keys(schema.properties).length === 0) {
+		return z.object({}).passthrough()
+	}
+
+	const shape: Record<string, z.ZodType> = {}
+	const required = new Set(schema.required ?? [])
+
+	for (const [key, propSchema] of Object.entries(schema.properties)) {
+		let field = jsonSchemaPropertyToZod(propSchema)
+		if (!required.has(key)) {
+			field = field.optional()
+		}
+		shape[key] = field
+	}
+
+	return z.object(shape).passthrough()
 }
 
 function jsonSchemaPropertyToZod(prop: unknown): z.ZodType {
-  if (typeof prop !== 'object' || prop === null) return z.unknown()
-  const schema = prop as Record<string, unknown>
-
-  switch (schema['type']) {
-    case 'string':
-      return z.string()
-    case 'number':
-    case 'integer':
-      return z.number()
-    case 'boolean':
-      return z.boolean()
-    case 'array':
-      return z.array(z.unknown())
-    case 'object':
-      return z.record(z.unknown())
-    default:
-      return z.unknown()
-  }
+	if (typeof prop !== 'object' || prop === null) return z.unknown()
+	const schema = prop as Record<string, unknown>
+
+	switch (schema.type) {
+		case 'string':
+			return z.string()
+		case 'number':
+		case 'integer':
+			return z.number()
+		case 'boolean':
+			return z.boolean()
+		case 'array':
+			return z.array(z.unknown())
+		case 'object':
+			return z.record(z.unknown())
+		default:
+			return z.unknown()
+	}
 }
 
 export function zodToMCPJsonSchema(zodSchema: z.ZodType): MCPJsonSchema {
-  const jsonSchema = zodToJsonSchema(zodSchema, { target: 'openApi3' })
-  return {
-    type: 'object',
-    ...jsonSchema,
-  } as MCPJsonSchema
+	const jsonSchema = zodToJsonSchema(zodSchema, { target: 'openApi3' })
+	return {
+		type: 'object',
+		...jsonSchema,
+	} as MCPJsonSchema
 }
 
 export function mcpToolToToolDefinition(
-  tool: MCPToolDefinition,
-  client: MCPClient,
-  serverName: string,
+	tool: MCPToolDefinition,
+	client: MCPClient,
+	serverName: string,
 ): ToolDefinition {
-  const inputSchema = mcpJsonSchemaToZod(tool.inputSchema)
-  const toolName = `mcp_${serverName}_${tool.name}`
-
-  return {
-    name: toolName,
-    description: tool.description
-      ? `[MCP:${serverName}] ${tool.description}`
-      : `[MCP:${serverName}] ${tool.name}`,
-    inputSchema,
-    category: 'network',
-    permissions: ['network_access'],
-    isReadOnly: () => tool.annotations?.readOnlyHint ?? false,
-    isDestructive: () => tool.annotations?.destructiveHint ?? false,
-    isConcurrencySafe: () => true,
-
-    async execute(input: unknown, _context: ToolContext): Promise<ToolResult> {
-      const result = await client.callTool(tool.name, input as Record<string, unknown>)
-      return mcpToolResultToToolResult(result)
-    },
-  }
+	const inputSchema = mcpJsonSchemaToZod(tool.inputSchema)
+	const toolName = `mcp_${serverName}_${tool.name}`
+
+	return {
+		name: toolName,
+		description: tool.description
+			? `[MCP:${serverName}] ${tool.description}`
+			: `[MCP:${serverName}] ${tool.name}`,
+		inputSchema,
+		category: 'network',
+		permissions: ['network_access'],
+		isReadOnly: () => tool.annotations?.readOnlyHint ?? false,
+		isDestructive: () => tool.annotations?.destructiveHint ?? false,
+		isConcurrencySafe: () => true,
+
+		async execute(input: unknown, _context: ToolContext): Promise<ToolResult> {
+			const result = await client.callTool(tool.name, input as Record<string, unknown>)
+			return mcpToolResultToToolResult(result)
+		},
+	}
 }
 
 export function toolDefinitionToMCPTool(tool: ToolDefinition): MCPToolDefinition {
-  return {
-    name: tool.name,
-    description: tool.description,
-    inputSchema: zodToMCPJsonSchema(tool.inputSchema),
-    annotations: {
-      readOnlyHint: tool.isReadOnly?.(undefined as never),
-      destructiveHint: tool.isDestructive?.(undefined as never),
-    },
-  }
+	return {
+		name: tool.name,
+		description: tool.description,
+		inputSchema: zodToMCPJsonSchema(tool.inputSchema),
+		annotations: {
+			readOnlyHint: tool.isReadOnly?.(undefined as never),
+			destructiveHint: tool.isDestructive?.(undefined as never),
+		},
+	}
 }
 
 export function mcpToolResultToToolResult(result: MCPToolResult): ToolResult {
-  const textContent = result.content
-    .filter((block): block is { type: 'text'; text: string } => block.type === 'text')
-    .map((block) => block.text)
-    .join('\n')
-
-  return {
-    success: !result.isError,
-    output: textContent,
-    data: result.content,
-    error: result.isError ? textContent : undefined,
-  }
+	const textContent = result.content
+		.filter((block): block is { type: 'text'; text: string } => block.type === 'text')
+		.map((block) => block.text)
+		.join('\n')
+
+	return {
+		success: !result.isError,
+		output: textContent,
+		data: result.content,
+		error: result.isError ? textContent : undefined,
+	}
 }
 
 export function toolResultToMCPToolResult(result: ToolResult): MCPToolResult {
-  const content: MCPToolResult['content'] = []
+	const content: MCPToolResult['content'] = []
 
-  if (result.output) {
-    content.push({ type: 'text', text: result.output })
-  }
+	if (result.output) {
+		content.push({ type: 'text', text: result.output })
+	}
 
-  if (!result.success && result.error) {
-    content.push({ type: 'text', text: result.error })
-  }
+	if (!result.success && result.error) {
+		content.push({ type: 'text', text: result.error })
+	}
 
-  if (content.length === 0) {
-    content.push({ type: 'text', text: '' })
-  }
+	if (content.length === 0) {
+		content.push({ type: 'text', text: '' })
+	}
 
-  return {
-    content,
-    isError: !result.success,
-  }
+	return {
+		content,
+		isError: !result.success,
+	}
 }