@namzu/sdk 0.1.1 → 0.1.3

package/src/execution/base.ts

@@ -1,80 +1,77 @@
-import type {
-  ExecutionEnvironment,
-  ExecutionContextLifecycle,
-} from '../types/execution/index.js'
-import { getRootLogger, type Logger } from '../utils/logger.js'
+import type { ExecutionContextLifecycle, ExecutionEnvironment } from '../types/execution/index.js'
 import { toErrorMessage } from '../utils/error.js'
+import { type Logger, getRootLogger } from '../utils/logger.js'
 
 export interface BaseExecutionEvent {
-  type: string
-  contextId: string
-  [key: string]: unknown
+	type: string
+	contextId: string
+	[key: string]: unknown
 }
 
 export type ExecutionEventListener = (event: BaseExecutionEvent) => void
 
 export abstract class BaseExecutionContext implements ExecutionContextLifecycle {
-  abstract readonly id: string
-  abstract readonly environment: ExecutionEnvironment
+	abstract readonly id: string
+	abstract readonly environment: ExecutionEnvironment
 
-  protected log: Logger
-  protected ready = false
-  private listeners: ExecutionEventListener[] = []
+	protected log: Logger
+	protected ready = false
+	private listeners: ExecutionEventListener[] = []
 
-  constructor() {
-    this.log = getRootLogger().child({ component: this.constructor.name })
-  }
+	constructor() {
+		this.log = getRootLogger().child({ component: this.constructor.name })
+	}
 
-  async initialize(): Promise<void> {
-    try {
-      await this.doInitialize()
-      this.ready = true
-      this.emit({ type: 'context_initialized', contextId: this.id, environment: this.environment })
-      this.emit({ type: 'context_ready', contextId: this.id })
-      this.log.info(`Execution context initialized: ${this.id} (${this.environment})`)
-    } catch (err) {
-      const message = toErrorMessage(err)
-      this.emit({ type: 'context_error', contextId: this.id, error: message })
-      this.log.error(`Execution context initialization failed: ${this.id}`, { error: message })
-      throw err
-    }
-  }
+	async initialize(): Promise<void> {
+		try {
+			await this.doInitialize()
+			this.ready = true
+			this.emit({ type: 'context_initialized', contextId: this.id, environment: this.environment })
+			this.emit({ type: 'context_ready', contextId: this.id })
+			this.log.info(`Execution context initialized: ${this.id} (${this.environment})`)
+		} catch (err) {
+			const message = toErrorMessage(err)
+			this.emit({ type: 'context_error', contextId: this.id, error: message })
+			this.log.error(`Execution context initialization failed: ${this.id}`, { error: message })
+			throw err
+		}
+	}
 
-  isReady(): boolean {
-    return this.ready
-  }
+	isReady(): boolean {
+		return this.ready
+	}
 
-  async teardown(): Promise<void> {
-    try {
-      await this.doTeardown()
-    } finally {
-      this.ready = false
-      this.emit({ type: 'context_teardown', contextId: this.id })
-      this.log.info(`Execution context torn down: ${this.id}`)
-    }
-  }
+	async teardown(): Promise<void> {
+		try {
+			await this.doTeardown()
+		} finally {
+			this.ready = false
+			this.emit({ type: 'context_teardown', contextId: this.id })
+			this.log.info(`Execution context torn down: ${this.id}`)
+		}
+	}
 
-  on(listener: ExecutionEventListener): void {
-    this.listeners.push(listener)
-  }
+	on(listener: ExecutionEventListener): void {
+		this.listeners.push(listener)
+	}
 
-  off(listener: ExecutionEventListener): void {
-    const index = this.listeners.indexOf(listener)
-    if (index >= 0) this.listeners.splice(index, 1)
-  }
+	off(listener: ExecutionEventListener): void {
+		const index = this.listeners.indexOf(listener)
+		if (index >= 0) this.listeners.splice(index, 1)
+	}
 
-  protected emit(event: BaseExecutionEvent): void {
-    for (const listener of this.listeners) {
-      try {
-        listener(event)
-      } catch (err) {
-        this.log.error('Execution context event listener error', {
-          error: toErrorMessage(err),
-        })
-      }
-    }
-  }
+	protected emit(event: BaseExecutionEvent): void {
+		for (const listener of this.listeners) {
+			try {
+				listener(event)
+			} catch (err) {
+				this.log.error('Execution context event listener error', {
+					error: toErrorMessage(err),
+				})
+			}
+		}
+	}
 
-  protected abstract doInitialize(): Promise<void>
-  protected abstract doTeardown(): Promise<void>
+	protected abstract doInitialize(): Promise<void>
+	protected abstract doTeardown(): Promise<void>
 }

package/src/execution/local.ts

@@ -1,159 +1,158 @@
+import { spawn } from 'node:child_process'
 import { existsSync } from 'node:fs'
 import { resolve } from 'node:path'
-import { spawn } from 'node:child_process'
+import type { LocalExecutionContextConfig } from '../types/connector/index.js'
 import type {
-  ExecutionEnvironment,
-  ExecutionCapability,
-  CommandOptions,
-  CommandResult,
-  CommandExecutor,
+	CommandExecutor,
+	CommandOptions,
+	CommandResult,
+	ExecutionCapability,
+	ExecutionEnvironment,
 } from '../types/execution/index.js'
-import type { LocalExecutionContextConfig } from '../types/connector/index.js'
 import { BaseExecutionContext } from './base.js'
 
 export interface LocalExecutionContextOptions {
-  id: string
-  cwd: string
-  fsAccess?: boolean
-  envVars?: Record<string, string>
-  capabilities?: ExecutionCapability[]
-  shell?: string
+	id: string
+	cwd: string
+	fsAccess?: boolean
+	envVars?: Record<string, string>
+	capabilities?: ExecutionCapability[]
+	shell?: string
 }
 
 export class LocalExecutionContext extends BaseExecutionContext implements CommandExecutor {
-  readonly id: string
-  readonly environment: ExecutionEnvironment = 'local'
-
-  private cwd: string
-  private fsAccess: boolean
-  private envVars: Record<string, string>
-  private capabilities: ExecutionCapability[]
-  private shell: string | undefined
-
-  constructor(options: LocalExecutionContextOptions) {
-    super()
-    this.id = options.id
-    this.cwd = resolve(options.cwd)
-    this.fsAccess = options.fsAccess ?? true
-    this.envVars = options.envVars ?? {}
-    this.capabilities = options.capabilities ?? ['filesystem', 'process', 'shell']
-    this.shell = options.shell
-  }
-
-  protected async doInitialize(): Promise<void> {
-    if (!existsSync(this.cwd)) {
-      throw new Error(`Working directory does not exist: ${this.cwd}`)
-    }
-    this.log.info(`Local context initialized at ${this.cwd}`)
-  }
-
-  protected async doTeardown(): Promise<void> {
-  }
-
-  getCwd(): string {
-    return this.cwd
-  }
-
-  setCwd(newCwd: string): void {
-    const resolved = resolve(newCwd)
-    if (!existsSync(resolved)) {
-      throw new Error(`Working directory does not exist: ${resolved}`)
-    }
-    this.cwd = resolved
-  }
-
-  hasFsAccess(): boolean {
-    return this.fsAccess
-  }
-
-  resolvePath(relativePath: string): string {
-    return resolve(this.cwd, relativePath)
-  }
-
-  getEnvVar(key: string): string | undefined {
-    return this.envVars[key] ?? process.env[key]
-  }
-
-  getEnvVars(): Record<string, string> {
-    return { ...this.envVars }
-  }
-
-  getCapabilities(): ExecutionCapability[] {
-    return [...this.capabilities]
-  }
-
-  hasCapability(cap: ExecutionCapability): boolean {
-    return this.capabilities.includes(cap)
-  }
-
-  async executeCommand(
-    command: string,
-    args: string[] = [],
-    options?: CommandOptions,
-  ): Promise<CommandResult> {
-    if (!this.hasCapability('process') && !this.hasCapability('shell')) {
-      return {
-        exitCode: 1,
-        stdout: '',
-        stderr: 'Command execution not available: context lacks process/shell capability',
-        durationMs: 0,
-      }
-    }
-
-    const cwd = options?.cwd ? resolve(this.cwd, options.cwd) : this.cwd
-    const env = { ...process.env, ...this.envVars, ...options?.env }
-    const timeoutMs = options?.timeoutMs ?? 30_000
-    const shell = options?.shell ?? this.shell ?? true
-
-    return new Promise<CommandResult>((resolvePromise) => {
-      const start = performance.now()
-      const proc = spawn(command, args, {
-        cwd,
-        env,
-        shell,
-        timeout: timeoutMs,
-      })
-
-      let stdout = ''
-      let stderr = ''
-
-      proc.stdout?.on('data', (data: Buffer) => {
-        stdout += data.toString()
-      })
-
-      proc.stderr?.on('data', (data: Buffer) => {
-        stderr += data.toString()
-      })
-
-      proc.on('close', (code) => {
-        resolvePromise({
-          exitCode: code ?? 1,
-          stdout,
-          stderr,
-          durationMs: Math.round(performance.now() - start),
-        })
-      })
-
-      proc.on('error', (err) => {
-        resolvePromise({
-          exitCode: 1,
-          stdout,
-          stderr: err.message,
-          durationMs: Math.round(performance.now() - start),
-        })
-      })
-    })
-  }
-
-  toConfig(): LocalExecutionContextConfig {
-    return {
-      id: this.id,
-      environment: 'local',
-      cwd: this.cwd,
-      fsAccess: this.fsAccess,
-      envVars: this.envVars,
-      capabilities: this.capabilities,
-      shell: this.shell,
-    }
-  }
+	readonly id: string
+	readonly environment: ExecutionEnvironment = 'local'
+
+	private cwd: string
+	private fsAccess: boolean
+	private envVars: Record<string, string>
+	private capabilities: ExecutionCapability[]
+	private shell: string | undefined
+
+	constructor(options: LocalExecutionContextOptions) {
+		super()
+		this.id = options.id
+		this.cwd = resolve(options.cwd)
+		this.fsAccess = options.fsAccess ?? true
+		this.envVars = options.envVars ?? {}
+		this.capabilities = options.capabilities ?? ['filesystem', 'process', 'shell']
+		this.shell = options.shell
+	}
+
+	protected async doInitialize(): Promise<void> {
+		if (!existsSync(this.cwd)) {
+			throw new Error(`Working directory does not exist: ${this.cwd}`)
+		}
+		this.log.info(`Local context initialized at ${this.cwd}`)
+	}
+
+	protected async doTeardown(): Promise<void> {}
+
+	getCwd(): string {
+		return this.cwd
+	}
+
+	setCwd(newCwd: string): void {
+		const resolved = resolve(newCwd)
+		if (!existsSync(resolved)) {
+			throw new Error(`Working directory does not exist: ${resolved}`)
+		}
+		this.cwd = resolved
+	}
+
+	hasFsAccess(): boolean {
+		return this.fsAccess
+	}
+
+	resolvePath(relativePath: string): string {
+		return resolve(this.cwd, relativePath)
+	}
+
+	getEnvVar(key: string): string | undefined {
+		return this.envVars[key] ?? process.env[key]
+	}
+
+	getEnvVars(): Record<string, string> {
+		return { ...this.envVars }
+	}
+
+	getCapabilities(): ExecutionCapability[] {
+		return [...this.capabilities]
+	}
+
+	hasCapability(cap: ExecutionCapability): boolean {
+		return this.capabilities.includes(cap)
+	}
+
+	async executeCommand(
+		command: string,
+		args: string[] = [],
+		options?: CommandOptions,
+	): Promise<CommandResult> {
+		if (!this.hasCapability('process') && !this.hasCapability('shell')) {
+			return {
+				exitCode: 1,
+				stdout: '',
+				stderr: 'Command execution not available: context lacks process/shell capability',
+				durationMs: 0,
+			}
+		}
+
+		const cwd = options?.cwd ? resolve(this.cwd, options.cwd) : this.cwd
+		const env = { ...process.env, ...this.envVars, ...options?.env }
+		const timeoutMs = options?.timeoutMs ?? 30_000
+		const shell = options?.shell ?? this.shell ?? true
+
+		return new Promise<CommandResult>((resolvePromise) => {
+			const start = performance.now()
+			const proc = spawn(command, args, {
+				cwd,
+				env,
+				shell,
+				timeout: timeoutMs,
+			})
+
+			let stdout = ''
+			let stderr = ''
+
+			proc.stdout?.on('data', (data: Buffer) => {
+				stdout += data.toString()
+			})
+
+			proc.stderr?.on('data', (data: Buffer) => {
+				stderr += data.toString()
+			})
+
+			proc.on('close', (code) => {
+				resolvePromise({
+					exitCode: code ?? 1,
+					stdout,
+					stderr,
+					durationMs: Math.round(performance.now() - start),
+				})
+			})
+
+			proc.on('error', (err) => {
+				resolvePromise({
+					exitCode: 1,
+					stdout,
+					stderr: err.message,
+					durationMs: Math.round(performance.now() - start),
+				})
+			})
+		})
+	}
+
+	toConfig(): LocalExecutionContextConfig {
+		return {
+			id: this.id,
+			environment: 'local',
+			cwd: this.cwd,
+			fsAccess: this.fsAccess,
+			envVars: this.envVars,
+			capabilities: this.capabilities,
+			shell: this.shell,
+		}
+	}
 }

package/src/gateway/local.ts

@@ -1,112 +1,112 @@
 import type { AgentManager } from '../manager/agent/lifecycle.js'
-import type { AgentTaskContext } from '../types/agent/task.js'
 import type { AgentInput } from '../types/agent/base.js'
-import type {
-  TaskGateway,
-  TaskHandle,
-  CreateTaskOptions,
-} from '../types/agent/gateway.js'
-import type { RunEventListener } from '../types/run/events.js'
+import type { CreateTaskOptions, TaskGateway, TaskHandle } from '../types/agent/gateway.js'
+import type { AgentTaskContext } from '../types/agent/task.js'
 import type { TaskId } from '../types/ids/index.js'
 import { createUserMessage } from '../types/message/index.js'
+import type { RunEventListener } from '../types/run/events.js'
 
 export class LocalTaskGateway implements TaskGateway {
-  private agentManager: AgentManager
-  private taskContext: AgentTaskContext
-  private listener: RunEventListener | undefined
-  private trackedTaskIds: Set<TaskId> = new Set()
+	private agentManager: AgentManager
+	private taskContext: AgentTaskContext
+	private listener: RunEventListener | undefined
+	private trackedTaskIds: Set<TaskId> = new Set()
 
-  private parentInput?: Pick<AgentInput, 'taskStore' | 'runtimeToolOverrides'>
+	private parentInput?: Pick<AgentInput, 'taskStore' | 'runtimeToolOverrides'>
 
-  private completionListeners: Set<(handle: TaskHandle) => void> = new Set()
+	private completionListeners: Set<(handle: TaskHandle) => void> = new Set()
 
-  constructor(
-    agentManager: AgentManager,
-    taskContext: AgentTaskContext,
-    listener?: RunEventListener,
-    parentInput?: Pick<AgentInput, 'taskStore' | 'runtimeToolOverrides'>,
-  ) {
-    this.agentManager = agentManager
-    this.taskContext = taskContext
-    this.listener = listener
-    this.parentInput = parentInput
-  }
+	constructor(
+		agentManager: AgentManager,
+		taskContext: AgentTaskContext,
+		listener?: RunEventListener,
+		parentInput?: Pick<AgentInput, 'taskStore' | 'runtimeToolOverrides'>,
+	) {
+		this.agentManager = agentManager
+		this.taskContext = taskContext
+		this.listener = listener
+		this.parentInput = parentInput
+	}
 
-  async createTask(options: CreateTaskOptions): Promise<TaskHandle> {
-    const task = await this.agentManager.sendMessage(
-      {
-        agentId: options.agentId,
-        input: {
-          messages: [createUserMessage(options.prompt)],
-          workingDirectory: options.workingDirectory,
-          taskStore: this.parentInput?.taskStore,
-          runtimeToolOverrides: this.parentInput?.runtimeToolOverrides,
-        },
-      },
-      { ...this.taskContext, budgetTracker: { ...this.taskContext.budgetTracker } },
-      this.listener,
-    )
+	async createTask(options: CreateTaskOptions): Promise<TaskHandle> {
+		const task = await this.agentManager.sendMessage(
+			{
+				agentId: options.agentId,
+				input: {
+					messages: [createUserMessage(options.prompt)],
+					workingDirectory: options.workingDirectory,
+					taskStore: this.parentInput?.taskStore,
+					runtimeToolOverrides: this.parentInput?.runtimeToolOverrides,
+				},
+			},
+			{ ...this.taskContext, budgetTracker: { ...this.taskContext.budgetTracker } },
+			this.listener,
+		)
 
-    this.trackedTaskIds.add(task.taskId)
+		this.trackedTaskIds.add(task.taskId)
 
-    this.agentManager.waitForCompletion(task.taskId).then(() => {
-      const completed = this.agentManager.getInstance(task.taskId)
-      if (completed) {
-        const handle = toHandle(completed)
-        for (const cb of this.completionListeners) {
-          cb(handle)
-        }
-      }
-    }).catch(() => {
-    })
+		this.agentManager
+			.waitForCompletion(task.taskId)
+			.then(() => {
+				const completed = this.agentManager.getInstance(task.taskId)
+				if (completed) {
+					const handle = toHandle(completed)
+					for (const cb of this.completionListeners) {
+						cb(handle)
+					}
+				}
+			})
+			.catch(() => {})
 
-    return toHandle(task)
-  }
+		return toHandle(task)
+	}
 
-  async waitForTask(taskId: TaskId): Promise<TaskHandle> {
-    await this.agentManager.waitForCompletion(taskId)
-    const task = this.agentManager.getInstance(taskId)
-    if (!task) {
-      throw new Error(`Task ${taskId} not found after completion`)
-    }
-    return toHandle(task)
-  }
+	async waitForTask(taskId: TaskId): Promise<TaskHandle> {
+		await this.agentManager.waitForCompletion(taskId)
+		const task = this.agentManager.getInstance(taskId)
+		if (!task) {
+			throw new Error(`Task ${taskId} not found after completion`)
+		}
+		return toHandle(task)
+	}
 
-  async continueTask(taskId: TaskId, message: string): Promise<void> {
-    await this.agentManager.continueTask(taskId, message)
-  }
+	async continueTask(taskId: TaskId, message: string): Promise<void> {
+		await this.agentManager.continueTask(taskId, message)
+	}
 
-  cancelTask(taskId: TaskId): void {
-    this.agentManager.cancel(taskId)
-  }
+	cancelTask(taskId: TaskId): void {
+		this.agentManager.cancel(taskId)
+	}
 
-  getTask(taskId: TaskId): TaskHandle | undefined {
-    const task = this.agentManager.getInstance(taskId)
-    return task ? toHandle(task) : undefined
-  }
+	getTask(taskId: TaskId): TaskHandle | undefined {
+		const task = this.agentManager.getInstance(taskId)
+		return task ? toHandle(task) : undefined
+	}
 
-  listTasks(): TaskHandle[] {
-    const handles: TaskHandle[] = []
-    for (const taskId of this.trackedTaskIds) {
-      const task = this.agentManager.getInstance(taskId)
-      if (task) handles.push(toHandle(task))
-    }
-    return handles
-  }
+	listTasks(): TaskHandle[] {
+		const handles: TaskHandle[] = []
+		for (const taskId of this.trackedTaskIds) {
+			const task = this.agentManager.getInstance(taskId)
+			if (task) handles.push(toHandle(task))
+		}
+		return handles
+	}
 
-  onTaskCompleted(callback: (handle: TaskHandle) => void): () => void {
-    this.completionListeners.add(callback)
-    return () => { this.completionListeners.delete(callback) }
-  }
+	onTaskCompleted(callback: (handle: TaskHandle) => void): () => void {
+		this.completionListeners.add(callback)
+		return () => {
+			this.completionListeners.delete(callback)
+		}
+	}
 }
 
 function toHandle(task: import('../types/agent/task.js').AgentTask): TaskHandle {
-  return {
-    taskId: task.taskId,
-    agentId: task.agentId,
-    state: task.state,
-    result: task.result,
-    createdAt: task.createdAt,
-    completedAt: task.completedAt,
-  }
+	return {
+		taskId: task.taskId,
+		agentId: task.agentId,
+		state: task.state,
+		result: task.result,
+		createdAt: task.createdAt,
+		completedAt: task.completedAt,
+	}
 }