@namzu/sdk 0.1.1

package/src/manager/connector/tenant.ts

@@ -0,0 +1,300 @@
+import type {
+  ConnectorConfig,
+  ConnectorInstance,
+  ConnectorExecuteParams,
+  ConnectorExecuteResult,
+  TenantDescriptor,
+  TenantRateLimitConfig,
+  CredentialVault,
+  ConnectorLifecycleEvent,
+  ConnectorEventListener,
+} from '../../types/connector/index.js'
+import type { TenantId, ConnectorInstanceId, CredentialId } from '../../types/ids/index.js'
+import type { BaseConnector } from '../../connector/BaseConnector.js'
+import { ConnectorManager, type ConnectorManagerConfig } from './lifecycle.js'
+import { ConnectorRegistry } from '../../registry/connector/definitions.js'
+import { getRootLogger, type Logger } from '../../utils/logger.js'
+import { toErrorMessage } from '../../utils/error.js'
+
+interface RateWindow {
+  timestamps: number[]
+}
+
+export interface TenantConnectorManagerConfig {
+  registry: ConnectorRegistry
+
+  credentialVault?: CredentialVault
+
+  defaultRateLimit?: TenantRateLimitConfig
+}
+
+interface TenantState {
+  descriptor: TenantDescriptor
+  manager: ConnectorManager
+  rateLimit?: TenantRateLimitConfig
+  rateWindows: Map<ConnectorInstanceId, RateWindow>
+}
+
+export class TenantConnectorManager {
+  private tenants: Map<TenantId, TenantState> = new Map()
+  private registry: ConnectorRegistry
+  private credentialVault: CredentialVault | undefined
+  private defaultRateLimit: TenantRateLimitConfig | undefined
+  private listeners: ConnectorEventListener[] = []
+  private log: Logger
+
+  constructor(config: TenantConnectorManagerConfig) {
+    this.registry = config.registry
+    this.credentialVault = config.credentialVault
+    this.defaultRateLimit = config.defaultRateLimit
+    this.log = getRootLogger().child({ component: 'TenantConnectorManager' })
+  }
+
+  registerTenant(
+    descriptor: TenantDescriptor,
+    rateLimit?: TenantRateLimitConfig,
+  ): void {
+    if (this.tenants.has(descriptor.id)) {
+      this.log.warn(`Tenant "${descriptor.id}" already registered, skipping.`)
+      return
+    }
+
+    const manager = new ConnectorManager({ registry: this.registry })
+
+    manager.on((event) => {
+      this.emitTenantEvent(descriptor.id, event)
+    })
+
+    this.tenants.set(descriptor.id, {
+      descriptor,
+      manager,
+      rateLimit: rateLimit ?? this.defaultRateLimit,
+      rateWindows: new Map(),
+    })
+
+    this.log.info(`Tenant registered: ${descriptor.id} (${descriptor.name})`)
+  }
+
+  async unregisterTenant(tenantId: TenantId): Promise<void> {
+    const state = this.tenants.get(tenantId)
+    if (!state) return
+
+    await state.manager.disconnectAll()
+    this.tenants.delete(tenantId)
+    this.log.info(`Tenant unregistered: ${tenantId}`)
+  }
+
+  getTenant(tenantId: TenantId): TenantDescriptor | undefined {
+    return this.tenants.get(tenantId)?.descriptor
+  }
+
+  listTenants(): TenantDescriptor[] {
+    return Array.from(this.tenants.values()).map((s) => s.descriptor)
+  }
+
+  setTenantRateLimit(tenantId: TenantId, rateLimit: TenantRateLimitConfig): void {
+    const state = this.getTenantOrThrow(tenantId)
+    state.rateLimit = rateLimit
+  }
+
+  private checkRateLimit(state: TenantState, instanceId: ConnectorInstanceId): boolean {
+    const limit = state.rateLimit
+    if (!limit) return true
+
+    const now = Date.now()
+    let window = state.rateWindows.get(instanceId)
+    if (!window) {
+      window = { timestamps: [] }
+      state.rateWindows.set(instanceId, window)
+    }
+
+    window.timestamps = window.timestamps.filter(
+      (t) => now - t < limit.windowMs,
+    )
+
+    if (window.timestamps.length >= limit.maxRequests) {
+      return false
+    }
+
+    window.timestamps.push(now)
+    return true
+  }
+
+  async createInstance(
+    tenantId: TenantId,
+    config: ConnectorConfig,
+    connector: BaseConnector<unknown>,
+  ): Promise<ConnectorInstance> {
+    const state = this.getTenantOrThrow(tenantId)
+    return state.manager.createInstance(config, connector)
+  }
+
+  async connect(tenantId: TenantId, instanceId: ConnectorInstanceId): Promise<void> {
+    const state = this.getTenantOrThrow(tenantId)
+
+    if (this.credentialVault) {
+      const instance = state.manager.getInstance(instanceId)
+      if (instance && !instance.config.auth) {
+        const creds = await this.credentialVault.list(tenantId, instance.connectorId)
+        if (creds.length > 0) {
+          const auth = await this.credentialVault.retrieve(creds[0]!.id)
+          if (auth) {
+            instance.config.auth = auth
+            this.log.info(
+              `Auto-resolved credential "${creds[0]!.id}" for instance "${instanceId}" (tenant: ${tenantId})`,
+            )
+          }
+        }
+      }
+    }
+
+    return state.manager.connect(instanceId)
+  }
+
+  async connectWithCredential(
+    tenantId: TenantId,
+    instanceId: ConnectorInstanceId,
+    credentialId: CredentialId,
+  ): Promise<void> {
+    if (!this.credentialVault) {
+      throw new Error('No credential vault configured on TenantConnectorManager')
+    }
+
+    const state = this.getTenantOrThrow(tenantId)
+    const instance = state.manager.getInstance(instanceId)
+    if (!instance) {
+      throw new Error(`Connector instance not found: "${instanceId}"`)
+    }
+
+    const auth = await this.credentialVault.retrieve(credentialId)
+    if (!auth) {
+      throw new Error(`Credential not found: "${credentialId}"`)
+    }
+
+    instance.config.auth = auth
+    this.log.info(
+      `Credential "${credentialId}" applied to instance "${instanceId}" (tenant: ${tenantId})`,
+    )
+    return state.manager.connect(instanceId)
+  }
+
+  async storeCredential(
+    tenantId: TenantId,
+    connectorId: string,
+    label: string,
+    auth: import('../../types/connector/index.js').AuthConfig,
+  ): Promise<import('../../types/connector/index.js').CredentialRef> {
+    if (!this.credentialVault) {
+      throw new Error('No credential vault configured on TenantConnectorManager')
+    }
+    this.getTenantOrThrow(tenantId)
+    return this.credentialVault.store(tenantId, connectorId, label, auth)
+  }
+
+  async listCredentials(
+    tenantId: TenantId,
+    connectorId?: string,
+  ): Promise<import('../../types/connector/index.js').CredentialRef[]> {
+    if (!this.credentialVault) {
+      return []
+    }
+    this.getTenantOrThrow(tenantId)
+    return this.credentialVault.list(tenantId, connectorId)
+  }
+
+  async revokeCredential(credentialId: CredentialId): Promise<boolean> {
+    if (!this.credentialVault) {
+      return false
+    }
+    return this.credentialVault.revoke(credentialId)
+  }
+
+  async disconnect(tenantId: TenantId, instanceId: ConnectorInstanceId): Promise<void> {
+    const state = this.getTenantOrThrow(tenantId)
+    return state.manager.disconnect(instanceId)
+  }
+
+  async execute(
+    tenantId: TenantId,
+    params: ConnectorExecuteParams,
+  ): Promise<ConnectorExecuteResult> {
+    const state = this.getTenantOrThrow(tenantId)
+
+    if (!this.checkRateLimit(state, params.instanceId)) {
+      return {
+        success: false,
+        output: null,
+        error: `Rate limit exceeded for tenant "${tenantId}" on instance "${params.instanceId}"`,
+        durationMs: 0,
+      }
+    }
+
+    return state.manager.execute(params)
+  }
+
+  async healthCheck(tenantId: TenantId, instanceId: ConnectorInstanceId): Promise<boolean> {
+    const state = this.getTenantOrThrow(tenantId)
+    return state.manager.healthCheck(instanceId)
+  }
+
+  async removeInstance(tenantId: TenantId, instanceId: ConnectorInstanceId): Promise<void> {
+    const state = this.getTenantOrThrow(tenantId)
+    return state.manager.removeInstance(instanceId)
+  }
+
+  listInstances(tenantId: TenantId): ConnectorInstance[] {
+    const state = this.getTenantOrThrow(tenantId)
+    return state.manager.listInstances()
+  }
+
+  listConnectedInstances(tenantId: TenantId): ConnectorInstance[] {
+    const state = this.getTenantOrThrow(tenantId)
+    return state.manager.listConnectedInstances()
+  }
+
+  getManagerForTenant(tenantId: TenantId): ConnectorManager {
+    return this.getTenantOrThrow(tenantId).manager
+  }
+
+  getCredentialVault(): CredentialVault | undefined {
+    return this.credentialVault
+  }
+
+  async disconnectAll(): Promise<void> {
+    const promises: Promise<void>[] = []
+    for (const state of this.tenants.values()) {
+      promises.push(state.manager.disconnectAll())
+    }
+    await Promise.allSettled(promises)
+  }
+
+  on(listener: ConnectorEventListener): void {
+    this.listeners.push(listener)
+  }
+
+  off(listener: ConnectorEventListener): void {
+    const index = this.listeners.indexOf(listener)
+    if (index >= 0) this.listeners.splice(index, 1)
+  }
+
+  private emitTenantEvent(tenantId: TenantId, event: ConnectorLifecycleEvent): void {
+    for (const listener of this.listeners) {
+      try {
+        listener(event)
+      } catch (err) {
+        this.log.error('Tenant event listener error', {
+          tenantId,
+          error: toErrorMessage(err),
+        })
+      }
+    }
+  }
+
+  private getTenantOrThrow(tenantId: TenantId): TenantState {
+    const state = this.tenants.get(tenantId)
+    if (!state) {
+      throw new Error(`Tenant not found: "${tenantId}". Register it first via registerTenant().`)
+    }
+    return state
+  }
+}

package/src/manager/index.ts

@@ -0,0 +1,18 @@
+export { RunPersistence, SessionManager } from './run/persistence.js'
+
+export { ConnectorManager } from './connector/lifecycle.js'
+export type { ConnectorManagerConfig } from './connector/lifecycle.js'
+
+export { TenantConnectorManager } from './connector/tenant.js'
+export type { TenantConnectorManagerConfig } from './connector/tenant.js'
+
+export { EnvironmentConnectorManager } from './connector/environment.js'
+export type {
+  EnvironmentConnectorSetup,
+  EnvironmentConnectorManagerConfig,
+} from './connector/environment.js'
+
+export { PlanManager } from './plan/lifecycle.js'
+export type { PlanEvent, PlanEventListener, PlanApprovalHandler } from './plan/lifecycle.js'
+
+export { AgentManager } from './agent/lifecycle.js'

package/src/manager/plan/lifecycle.ts

@@ -0,0 +1,238 @@
+import type { RunId } from '../../types/ids/index.js'
+import type {
+  Plan,
+  PlanStep,
+  PlanStatus,
+  PlanApprovalRequest,
+  PlanApprovalResponse,
+} from '../../types/plan/index.js'
+import { isTerminalPlanStatus } from '../../types/plan/index.js'
+import { generatePlanId } from '../../utils/id.js'
+
+export interface PlanEvent {
+  type: 'plan.generating' | 'plan.ready' | 'plan.approved' | 'plan.rejected' | 'plan.executing' | 'plan.step_updated' | 'plan.completed' | 'plan.failed'
+  plan: Plan
+  step?: PlanStep
+}
+
+export type PlanEventListener = (event: PlanEvent) => void
+
+export type PlanApprovalHandler = (request: PlanApprovalRequest) => Promise<PlanApprovalResponse>
+
+export class PlanManager {
+  private currentPlan: Plan | null = null
+  private runId: RunId
+  private listeners: PlanEventListener[] = []
+  private approvalHandler?: PlanApprovalHandler
+
+  constructor(runId: RunId, approvalHandler?: PlanApprovalHandler) {
+    this.runId = runId
+    this.approvalHandler = approvalHandler
+  }
+
+  setApprovalHandler(handler: PlanApprovalHandler): void {
+    this.approvalHandler = handler
+  }
+
+  on(listener: PlanEventListener): () => void {
+    this.listeners.push(listener)
+    return () => {
+      this.listeners = this.listeners.filter((l) => l !== listener)
+    }
+  }
+
+  private emit(event: PlanEvent): void {
+    for (const listener of this.listeners) {
+      try {
+        listener(event)
+      } catch {
+      }
+    }
+  }
+
+  get active(): Plan | null {
+    return this.currentPlan
+  }
+
+  get isActive(): boolean {
+    return this.currentPlan !== null && !isTerminalPlanStatus(this.currentPlan.status)
+  }
+
+  get needsApproval(): boolean {
+    return this.currentPlan?.status === 'pending_approval'
+  }
+
+  startGenerating(title: string): Plan {
+    const plan: Plan = {
+      id: generatePlanId(),
+      runId: this.runId,
+      status: 'generating',
+      title,
+      steps: [],
+      createdAt: Date.now(),
+    }
+
+    this.currentPlan = plan
+    this.emit({ type: 'plan.generating', plan })
+    return plan
+  }
+
+  addStep(step: Omit<PlanStep, 'status'>): PlanStep | null {
+    if (!this.currentPlan) return null
+    if (this.currentPlan.status !== 'generating') return null
+
+    const planStep: PlanStep = {
+      ...step,
+      status: 'pending',
+    }
+
+    this.currentPlan.steps.push(planStep)
+    return planStep
+  }
+
+  markReady(summary?: string): Plan | null {
+    if (!this.currentPlan) return null
+    if (this.currentPlan.status !== 'generating') return null
+
+    this.currentPlan.status = 'ready'
+    this.currentPlan.summary = summary
+    this.currentPlan.readyAt = Date.now()
+    this.emit({ type: 'plan.ready', plan: this.currentPlan })
+    return this.currentPlan
+  }
+
+  async requestApproval(): Promise<PlanApprovalResponse> {
+    if (!this.currentPlan) {
+      return { approved: false, feedback: 'No active plan' }
+    }
+
+    this.currentPlan.status = 'pending_approval'
+
+    if (!this.approvalHandler) {
+      this.currentPlan.status = 'rejected'
+      this.currentPlan.rejectedAt = Date.now()
+      this.currentPlan.rejectionReason = 'No approval handler configured'
+      this.emit({ type: 'plan.rejected', plan: this.currentPlan })
+      return { approved: false, feedback: 'No approval handler configured' }
+    }
+
+    const request: PlanApprovalRequest = {
+      planId: this.currentPlan.id,
+      runId: this.runId,
+      title: this.currentPlan.title,
+      steps: this.currentPlan.steps,
+      summary: this.currentPlan.summary,
+    }
+
+    const response = await this.approvalHandler(request)
+
+    if (response.approved) {
+      if (response.modifiedSteps) {
+        this.currentPlan.steps = response.modifiedSteps
+      }
+      this.currentPlan.status = 'approved'
+      this.currentPlan.approvedAt = Date.now()
+      this.emit({ type: 'plan.approved', plan: this.currentPlan })
+    } else {
+      this.currentPlan.status = 'rejected'
+      this.currentPlan.rejectedAt = Date.now()
+      this.currentPlan.rejectionReason = response.feedback
+      this.emit({ type: 'plan.rejected', plan: this.currentPlan })
+    }
+
+    return response
+  }
+
+  approve(modifiedSteps?: PlanStep[]): Plan | null {
+    if (!this.currentPlan) return null
+    if (this.currentPlan.status !== 'pending_approval' && this.currentPlan.status !== 'ready') return null
+
+    if (modifiedSteps) {
+      this.currentPlan.steps = modifiedSteps
+    }
+    this.currentPlan.status = 'approved'
+    this.currentPlan.approvedAt = Date.now()
+    this.emit({ type: 'plan.approved', plan: this.currentPlan })
+    return this.currentPlan
+  }
+
+  startExecution(): Plan | null {
+    if (!this.currentPlan) return null
+    if (this.currentPlan.status !== 'approved') return null
+
+    this.currentPlan.status = 'executing'
+    this.emit({ type: 'plan.executing', plan: this.currentPlan })
+    return this.currentPlan
+  }
+
+  updateStepStatus(
+    stepId: string,
+    status: PlanStep['status'],
+    error?: string,
+  ): PlanStep | null {
+    if (!this.currentPlan) return null
+
+    const step = this.currentPlan.steps.find((s) => s.id === stepId)
+    if (!step) return null
+
+    step.status = status
+    if (error) step.error = error
+
+    this.emit({ type: 'plan.step_updated', plan: this.currentPlan, step })
+    return step
+  }
+
+  completePlan(): Plan | null {
+    if (!this.currentPlan) return null
+
+    const allDone = this.currentPlan.steps.every(
+      (s) => s.status === 'completed' || s.status === 'skipped',
+    )
+
+    this.currentPlan.status = allDone ? 'completed' : 'failed'
+    this.currentPlan.completedAt = Date.now()
+    this.emit({
+      type: allDone ? 'plan.completed' : 'plan.failed',
+      plan: this.currentPlan,
+    })
+    return this.currentPlan
+  }
+
+  failPlan(error: string): Plan | null {
+    if (!this.currentPlan) return null
+
+    this.currentPlan.status = 'failed'
+    this.currentPlan.completedAt = Date.now()
+
+    for (const step of this.currentPlan.steps) {
+      if (step.status === 'pending' || step.status === 'running') {
+        step.status = 'skipped'
+      }
+    }
+
+    this.emit({ type: 'plan.failed', plan: this.currentPlan })
+    return this.currentPlan
+  }
+
+  getNextPendingStep(): PlanStep | null {
+    if (!this.currentPlan) return null
+    if (this.currentPlan.status !== 'executing') return null
+
+    for (const step of this.currentPlan.steps) {
+      if (step.status !== 'pending') continue
+
+      const depsResolved = step.dependsOn.every((depId) => {
+        const dep = this.currentPlan!.steps.find((s) => s.id === depId)
+        return dep && (dep.status === 'completed' || dep.status === 'skipped')
+      })
+
+      if (depsResolved) return step
+    }
+
+    return null
+  }
+
+  reset(): void {
+    this.currentPlan = null
+  }
+}