opc-agent 4.1.2 → 4.1.3

package/src/schema/oad.ts

@@ -1,217 +0,0 @@
-import { z } from 'zod';
-
-// ─── OAD Schema v1 ───────────────────────────────────────────
-
-export const SkillRefSchema = z.object({
-  name: z.string(),
-  description: z.string().optional(),
-  config: z.record(z.unknown()).optional(),
-});
-
-export const WorkflowStepSchema: z.ZodType<any> = z.lazy(() => z.object({
-  id: z.string(),
-  type: z.enum(['skill', 'tool', 'agent', 'condition', 'parallel']),
-  name: z.string(),
-  config: z.record(z.unknown()).optional(),
-  condition: z.string().optional(),
-  branches: z.object({ if: z.array(WorkflowStepSchema), else: z.array(WorkflowStepSchema).optional() }).optional(),
-  parallel: z.array(WorkflowStepSchema).optional(),
-  timeout: z.number().optional(),
-  retries: z.number().optional(),
-}));
-
-export const WorkflowSchema = z.object({
-  name: z.string(),
-  description: z.string().optional(),
-  version: z.string().optional(),
-  steps: z.array(WorkflowStepSchema).default([]),
-  onError: z.enum(['stop', 'skip', 'retry']).optional(),
-});
-
-export const VoiceSchema = z.object({
-  enabled: z.boolean().default(false),
-  sttProvider: z.string().optional(),
-  ttsProvider: z.string().optional(),
-  language: z.string().optional(),
-});
-
-export const WebhookSchema = z.object({
-  path: z.string().optional(),
-  secret: z.string().optional(),
-  retryAttempts: z.number().optional(),
-});
-
-export const HITLSchema = z.object({
-  enabled: z.boolean().default(false),
-  requireApproval: z.array(z.string()).default([]),
-  defaultTimeoutMs: z.number().default(60000),
-  defaultAction: z.enum(['approve', 'deny']).default('deny'),
-});
-
-export const PluginRefSchema = z.object({
-  name: z.string(),
-  config: z.record(z.unknown()).optional(),
-});
-
-export const AuthSchema = z.object({
-  enabled: z.boolean().default(false),
-  apiKeys: z.array(z.string()).default([]),
-  sessionIsolation: z.boolean().default(true),
-});
-
-export const ChannelSchema = z.object({
-  type: z.enum(['web', 'websocket', 'telegram', 'cli', 'voice', 'webhook', 'wechat', 'feishu', 'email', 'slack', 'discord']),
-  port: z.number().optional(),
-  config: z.record(z.unknown()).optional(),
-});
-
-export const LongTermMemorySchema = z.object({
-  provider: z.enum(['in-memory', 'deepbrain']).default('in-memory'),
-  collection: z.string().optional(),
-  config: z.object({
-    database: z.string().optional(),
-    embeddingProvider: z.string().optional(),
-    autoLearn: z.boolean().optional(),
-    autoRecall: z.boolean().optional(),
-    evolveInterval: z.number().optional(),
-  }).passthrough().optional(),
-});
-
-export const MemorySchema = z.object({
-  shortTerm: z.boolean().default(true),
-  longTerm: z.union([z.boolean(), LongTermMemorySchema]).default(false),
-  provider: z.string().optional(),
-});
-
-export const TrustLevel = z.enum(['sandbox', 'verified', 'certified', 'listed']);
-
-export const DTVSchema = z.object({
-  trust: z.object({
-    level: TrustLevel.default('sandbox'),
-  }).optional(),
-  value: z.object({
-    metrics: z.array(z.string()).default([]),
-  }).optional(),
-});
-
-export const ProviderSchema = z.object({
-  default: z.string().default('deepseek'),
-  allowed: z.array(z.string()).default(['openai', 'deepseek', 'qwen']),
-});
-
-export const MarketplaceSchema = z.object({
-  certified: z.boolean().default(false),
-  category: z.string().optional(),
-  pricing: z.enum(['free', 'freemium', 'paid', 'enterprise']).optional(),
-  tags: z.array(z.string()).optional(),
-});
-
-export const MetadataSchema = z.object({
-  name: z.string(),
-  version: z.string().default('1.0.0'),
-  description: z.string().optional(),
-  author: z.string().optional(),
-  license: z.string().default('Apache-2.0'),
-  marketplace: MarketplaceSchema.optional(),
-});
-
-export const RoomSchema = z.object({
-  name: z.string(),
-  agents: z.array(z.string()).default([]),
-  topics: z.array(z.string()).default([]),
-});
-
-export const StreamingSchema = z.object({
-  enabled: z.boolean().default(false),
-  chunkSize: z.number().optional(),
-});
-
-export const MCPServerSchema = z.object({
-  name: z.string(),
-  command: z.string(),
-  args: z.array(z.string()).optional(),
-  env: z.record(z.string()).optional(),
-});
-
-export const MCPServeSchema = z.object({
-  enabled: z.boolean().default(false),
-  mode: z.enum(['stdio', 'http']).default('stdio'),
-  port: z.number().default(3002),
-  exposedTools: z.array(z.string()).optional(),
-});
-
-export const ToolsSchema = z.object({
-  builtin: z.array(z.string()).optional(),
-  mcp: z.array(MCPServerSchema).optional(),
-});
-
-export const TelemetrySchema = z.object({
-  enabled: z.boolean().default(false),
-  exporter: z.enum(['console', 'file', 'otlp']).default('console'),
-  endpoint: z.string().optional(),
-  filePath: z.string().optional(),
-  maxSpans: z.number().optional(),
-});
-
-export const AGUIProtocolSchema = z.object({
-  enabled: z.boolean().default(false),
-  path: z.string().default('/agui'),
-});
-
-export const ProtocolsSchema = z.object({
-  a2a: z.object({
-    enabled: z.boolean().default(false),
-    port: z.number().optional(),
-  }).optional(),
-  agui: AGUIProtocolSchema.optional(),
-  mcp: MCPServeSchema.optional(),
-});
-
-export const GuardrailRuleSchema = z.object({
-  name: z.string(),
-  type: z.enum(['regex', 'keyword', 'llm', 'custom']),
-  action: z.enum(['block', 'warn', 'redact', 'log']),
-  config: z.record(z.any()).optional(),
-});
-
-export const GuardrailsSchema = z.object({
-  input: z.array(GuardrailRuleSchema).optional(),
-  output: z.array(GuardrailRuleSchema).optional(),
-});
-
-export const SpecSchema = z.object({
-  provider: ProviderSchema.optional(),
-  model: z.string().default('deepseek-chat'),
-  systemPrompt: z.string().optional(),
-  skills: z.array(SkillRefSchema).default([]),
-  channels: z.array(ChannelSchema).default([]),
-  memory: MemorySchema.optional(),
-  tools: ToolsSchema.optional(),
-  dtv: DTVSchema.optional(),
-  room: RoomSchema.optional(),
-  streaming: z.union([z.boolean(), StreamingSchema]).default(false),
-  locale: z.enum(['en', 'zh-CN']).optional(),
-  workflows: z.array(WorkflowSchema).optional(),
-  voice: VoiceSchema.optional(),
-  webhook: WebhookSchema.optional(),
-  hitl: HITLSchema.optional(),
-  auth: AuthSchema.optional(),
-  telemetry: TelemetrySchema.optional(),
-  protocols: ProtocolsSchema.optional(),
-  plugins: z.array(PluginRefSchema).optional(),
-  guardrails: GuardrailsSchema.optional(),
-});
-
-export const OADSchema = z.object({
-  apiVersion: z.literal('opc/v1'),
-  kind: z.literal('Agent'),
-  metadata: MetadataSchema,
-  spec: SpecSchema,
-});
-
-export type OADDocument = z.infer<typeof OADSchema>;
-export type SkillRef = z.infer<typeof SkillRefSchema>;
-export type Channel = z.infer<typeof ChannelSchema>;
-export type Metadata = z.infer<typeof MetadataSchema>;
-export type Spec = z.infer<typeof SpecSchema>;
-export type TrustLevelType = string;

package/src/security/approval.ts

@@ -1,131 +0,0 @@
-import { randomUUID } from 'crypto';
-
-export type ApprovalPolicy = 'always' | 'dangerous' | 'never';
-
-export interface ApprovalRequest {
-  id: string;
-  type: 'shell' | 'file_write' | 'file_delete' | 'network' | 'plugin';
-  command: string;
-  description: string;
-  requestedAt: Date;
-  status: 'pending' | 'approved' | 'denied';
-  approvedBy?: string;
-}
-
-export class ApprovalManager {
-  private policy: ApprovalPolicy;
-  private pendingApprovals: Map<string, ApprovalRequest> = new Map();
-  private allowlist: Set<string> = new Set();
-  private blocklist: Set<string> = new Set();
-
-  private static readonly DANGEROUS_PATTERNS = [
-    /rm\s+-rf/i, /del\s+\/s/i, /format\s+/i,
-    /DROP\s+TABLE/i, /DELETE\s+FROM/i,
-    /curl.*\|.*sh/i, /wget.*\|.*sh/i,
-    /chmod\s+777/i, /sudo\s+/i,
-    /npm\s+publish/i,
-  ];
-
-  constructor(policy: ApprovalPolicy = 'dangerous') {
-    this.policy = policy;
-  }
-
-  getPolicy(): ApprovalPolicy {
-    return this.policy;
-  }
-
-  setPolicy(policy: ApprovalPolicy): void {
-    this.policy = policy;
-  }
-
-  needsApproval(type: string, command: string): boolean {
-    // Blocklist always needs approval (effectively blocked)
-    if (this.isBlocked(command)) return true;
-    // Allowlist never needs approval
-    if (this.isAllowed(command)) return false;
-
-    if (this.policy === 'never') return false;
-    if (this.policy === 'always') return true;
-    // 'dangerous'
-    return this.isDangerous(type, command);
-  }
-
-  private isDangerous(_type: string, command: string): boolean {
-    return ApprovalManager.DANGEROUS_PATTERNS.some(p => p.test(command));
-  }
-
-  private isAllowed(command: string): boolean {
-    for (const pattern of this.allowlist) {
-      if (command.includes(pattern)) return true;
-    }
-    return false;
-  }
-
-  private isBlocked(command: string): boolean {
-    for (const pattern of this.blocklist) {
-      if (command.includes(pattern)) return true;
-    }
-    return false;
-  }
-
-  requestApproval(type: ApprovalRequest['type'], command: string, description: string): ApprovalRequest {
-    const request: ApprovalRequest = {
-      id: randomUUID(),
-      type,
-      command,
-      description,
-      requestedAt: new Date(),
-      status: 'pending',
-    };
-    this.pendingApprovals.set(request.id, request);
-    return request;
-  }
-
-  approve(id: string, approver: string): void {
-    const req = this.pendingApprovals.get(id);
-    if (!req) throw new Error(`Approval request ${id} not found`);
-    if (req.status !== 'pending') throw new Error(`Request ${id} is already ${req.status}`);
-    req.status = 'approved';
-    req.approvedBy = approver;
-  }
-
-  deny(id: string, approver: string): void {
-    const req = this.pendingApprovals.get(id);
-    if (!req) throw new Error(`Approval request ${id} not found`);
-    if (req.status !== 'pending') throw new Error(`Request ${id} is already ${req.status}`);
-    req.status = 'denied';
-    req.approvedBy = approver;
-  }
-
-  getRequest(id: string): ApprovalRequest | undefined {
-    return this.pendingApprovals.get(id);
-  }
-
-  addToAllowlist(pattern: string): void {
-    this.allowlist.add(pattern);
-  }
-
-  removeFromAllowlist(pattern: string): void {
-    this.allowlist.delete(pattern);
-  }
-
-  addToBlocklist(pattern: string): void {
-    this.blocklist.add(pattern);
-  }
-
-  removeFromBlocklist(pattern: string): void {
-    this.blocklist.delete(pattern);
-  }
-
-  getPending(): ApprovalRequest[] {
-    return Array.from(this.pendingApprovals.values()).filter(r => r.status === 'pending');
-  }
-
-  getAllowlist(): string[] {
-    return Array.from(this.allowlist);
-  }
-
-  getBlocklist(): string[] {
-    return Array.from(this.blocklist);
-  }
-}

package/src/security/approvals.ts

@@ -1,143 +0,0 @@
-/**
- * Approvals Module - v1.0.0
- * Policy-based exec approval system with queue, expiry, history, and callbacks.
- */
-
-import { randomUUID } from 'crypto';
-
-export type ExecApprovalPolicy = 'always' | 'elevated-only' | 'never' | 'allowlist';
-
-export interface ExecApprovalRequest {
-  id: string;
-  command: string;
-  elevated: boolean;
-  requestedAt: number;
-  expiresAt: number;
-  status: 'pending' | 'approved' | 'denied' | 'expired';
-  approvedBy?: string;
-  reason?: string;
-}
-
-export interface ExecApprovalHistory {
-  request: ExecApprovalRequest;
-  resolvedAt: number;
-}
-
-export type ApprovalRequestCallback = (request: ExecApprovalRequest) => void;
-
-export class ExecApprovalManager {
-  private policy: ExecApprovalPolicy;
-  private pending: Map<string, ExecApprovalRequest> = new Map();
-  private history: ExecApprovalHistory[] = [];
-  private allowedCommands: Set<string> = new Set();
-  private expiryMs: number;
-  private onRequestCallback?: ApprovalRequestCallback;
-  private expiryTimer?: ReturnType<typeof setInterval>;
-
-  constructor(options: {
-    policy?: ExecApprovalPolicy;
-    expiryMs?: number;
-    allowedCommands?: string[];
-    onRequest?: ApprovalRequestCallback;
-  } = {}) {
-    this.policy = options.policy ?? 'elevated-only';
-    this.expiryMs = options.expiryMs ?? 300_000; // 5 min default
-    this.onRequestCallback = options.onRequest;
-    if (options.allowedCommands) {
-      for (const cmd of options.allowedCommands) this.allowedCommands.add(cmd);
-    }
-    this.expiryTimer = setInterval(() => this.expirePending(), 10_000);
-    if (this.expiryTimer.unref) this.expiryTimer.unref();
-  }
-
-  getPolicy(): ExecApprovalPolicy { return this.policy; }
-  setPolicy(p: ExecApprovalPolicy): void { this.policy = p; }
-
-  addAllowedCommand(cmd: string): void { this.allowedCommands.add(cmd); }
-  removeAllowedCommand(cmd: string): void { this.allowedCommands.delete(cmd); }
-  getAllowedCommands(): string[] { return [...this.allowedCommands]; }
-
-  needsApproval(command: string, elevated: boolean): boolean {
-    switch (this.policy) {
-      case 'never': return false;
-      case 'always': return true;
-      case 'elevated-only': return elevated;
-      case 'allowlist': return !this.isAllowed(command);
-    }
-  }
-
-  private isAllowed(command: string): boolean {
-    for (const allowed of this.allowedCommands) {
-      if (command.startsWith(allowed) || command === allowed) return true;
-    }
-    return false;
-  }
-
-  request(command: string, elevated: boolean = false): ExecApprovalRequest {
-    const now = Date.now();
-    const req: ExecApprovalRequest = {
-      id: randomUUID(),
-      command,
-      elevated,
-      requestedAt: now,
-      expiresAt: now + this.expiryMs,
-      status: 'pending',
-    };
-    this.pending.set(req.id, req);
-    this.onRequestCallback?.(req);
-    return req;
-  }
-
-  approve(id: string, approver: string): ExecApprovalRequest {
-    const req = this.pending.get(id);
-    if (!req) throw new Error(`Request ${id} not found`);
-    if (req.status !== 'pending') throw new Error(`Request ${id} already ${req.status}`);
-    req.status = 'approved';
-    req.approvedBy = approver;
-    this.pending.delete(id);
-    this.history.push({ request: req, resolvedAt: Date.now() });
-    return req;
-  }
-
-  deny(id: string, approver: string, reason?: string): ExecApprovalRequest {
-    const req = this.pending.get(id);
-    if (!req) throw new Error(`Request ${id} not found`);
-    if (req.status !== 'pending') throw new Error(`Request ${id} already ${req.status}`);
-    req.status = 'denied';
-    req.approvedBy = approver;
-    req.reason = reason;
-    this.pending.delete(id);
-    this.history.push({ request: req, resolvedAt: Date.now() });
-    return req;
-  }
-
-  getPending(): ExecApprovalRequest[] {
-    return [...this.pending.values()];
-  }
-
-  getHistory(): ExecApprovalHistory[] {
-    return [...this.history];
-  }
-
-  getRequest(id: string): ExecApprovalRequest | undefined {
-    return this.pending.get(id) ?? this.history.find(h => h.request.id === id)?.request;
-  }
-
-  private expirePending(): void {
-    const now = Date.now();
-    for (const [id, req] of this.pending) {
-      if (now >= req.expiresAt) {
-        req.status = 'expired';
-        this.pending.delete(id);
-        this.history.push({ request: req, resolvedAt: now });
-      }
-    }
-  }
-
-  /** Force expire check (for testing) */
-  checkExpiry(): void { this.expirePending(); }
-
-  destroy(): void {
-    if (this.expiryTimer) clearInterval(this.expiryTimer);
-  }
-}

package/src/security/elevated.ts

@@ -1,105 +0,0 @@
-/**
- * Elevated Permissions Module - v1.0.0
- * Elevation mode management with allowed commands, auto-revoke, and audit log.
- */
-
-export type ElevationMode = 'off' | 'ask' | 'on';
-
-export interface ElevationAuditEntry {
-  timestamp: number;
-  action: 'elevate' | 'revoke' | 'execute' | 'deny';
-  command?: string;
-  reason?: string;
-}
-
-export class ElevatedManager {
-  private mode: ElevationMode;
-  private elevated: boolean = false;
-  private allowedCommands: RegExp[] = [];
-  private auditLog: ElevationAuditEntry[] = [];
-  private revokeTimer?: ReturnType<typeof setTimeout>;
-  private autoRevokeMs: number;
-
-  constructor(options: {
-    mode?: ElevationMode;
-    allowedCommands?: (string | RegExp)[];
-    autoRevokeMs?: number;
-  } = {}) {
-    this.mode = options.mode ?? 'ask';
-    this.autoRevokeMs = options.autoRevokeMs ?? 600_000; // 10 min
-    if (options.allowedCommands) {
-      for (const cmd of options.allowedCommands) {
-        this.allowedCommands.push(cmd instanceof RegExp ? cmd : new RegExp(`^${cmd.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`));
-      }
-    }
-  }
-
-  getMode(): ElevationMode { return this.mode; }
-  setMode(mode: ElevationMode): void { this.mode = mode; }
-  isElevated(): boolean { return this.elevated; }
-
-  addAllowedCommand(pattern: string | RegExp): void {
-    this.allowedCommands.push(pattern instanceof RegExp ? pattern : new RegExp(`^${pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`));
-  }
-
-  isCommandAllowed(command: string): boolean {
-    return this.allowedCommands.some(r => r.test(command));
-  }
-
-  elevate(reason?: string): boolean {
-    if (this.mode === 'off') return false;
-    this.elevated = true;
-    this.auditLog.push({ timestamp: Date.now(), action: 'elevate', reason });
-    this.startAutoRevoke();
-    return true;
-  }
-
-  revoke(reason?: string): void {
-    this.elevated = false;
-    this.clearAutoRevoke();
-    this.auditLog.push({ timestamp: Date.now(), action: 'revoke', reason });
-  }
-
-  canExecute(command: string): { allowed: boolean; needsElevation: boolean } {
-    if (this.isCommandAllowed(command)) return { allowed: true, needsElevation: false };
-    if (this.mode === 'off') return { allowed: true, needsElevation: false };
-    if (this.mode === 'on') {
-      if (!this.elevated) this.elevate('auto-on mode');
-      this.auditLog.push({ timestamp: Date.now(), action: 'execute', command });
-      return { allowed: true, needsElevation: false };
-    }
-    // ask mode
-    if (this.elevated) {
-      this.auditLog.push({ timestamp: Date.now(), action: 'execute', command });
-      return { allowed: true, needsElevation: false };
-    }
-    return { allowed: false, needsElevation: true };
-  }
-
-  getAuditLog(): ElevationAuditEntry[] {
-    return [...this.auditLog];
-  }
-
-  clearAuditLog(): void {
-    this.auditLog = [];
-  }
-
-  private startAutoRevoke(): void {
-    this.clearAutoRevoke();
-    this.revokeTimer = setTimeout(() => {
-      this.revoke('auto-revoke timer');
-    }, this.autoRevokeMs);
-    if (this.revokeTimer.unref) this.revokeTimer.unref();
-  }
-
-  private clearAutoRevoke(): void {
-    if (this.revokeTimer) {
-      clearTimeout(this.revokeTimer);
-      this.revokeTimer = undefined;
-    }
-  }
-
-  destroy(): void {
-    this.clearAutoRevoke();
-  }
-}