عزل تنفيذ كود وكلاء الذكاء الاصطناعي باستخدام Microsoft MXC وTypeScript

pnpm add @microsoft/mxc-sdk

{
  "compilerOptions": {
    "moduleResolution": "bundler",
    "target": "ES2022",
    "lib": ["ES2022"],
    "strict": true
  }
}

// src/sandbox/platform.ts
import { getPlatformSupport } from '@microsoft/mxc-sdk';
 
export async function requireSandboxSupport() {
  const support = await getPlatformSupport();
 
  if (support.backends.length === 0) {
    throw new Error(
      `MXC غير متاح على هذه المنصة. ` +
      `نظام التشغيل: ${support.os}، النواة: ${support.kernelVersion}`
    );
  }
 
  // تفضيل microvm للعزل الأقوى؛ مع الرجوع لـ process عند عدم توفره
  const preferred = support.backends.includes('microvm') ? 'microvm' : 'process';
 
  console.log(`MXC جاهز — يستخدم واجهة "${preferred}"`);
  return { ...support, preferred };
}

// src/sandbox/policy.ts
import {
  createConfigFromPolicy,
  getAvailableToolsPolicy,
  getTemporaryFilesPolicy,
  type MxcPolicy,
} from '@microsoft/mxc-sdk';
import * as os from 'node:os';
import * as path from 'node:path';
 
export function buildAgentToolPolicy(projectRoot: string): MxcPolicy {
  const tmpDir = path.join(os.tmpdir(), 'mxc-agent-sandbox');
 
  return {
    network: 'none',
    filesystem: {
      readonlyPaths: [projectRoot],
      readWritePaths: [tmpDir],
      denyPaths: [os.homedir(), '/etc/passwd', '/etc/shadow'],
    },
    process: {
      maxPid: 32,
      allowedExecutables: ['/bin/sh', '/usr/bin/node', '/usr/bin/python3'],
    },
    resources: {
      timeoutSeconds: 30,
      memoryMb: 256,
      cpuPercent: 50,
    },
  };
}
 
export async function buildComposedPolicy() {
  const toolsPolicy = await getAvailableToolsPolicy();
  const tempPolicy = await getTemporaryFilesPolicy();
 
  return {
    ...toolsPolicy,
    ...tempPolicy,
    network: 'none' as const,
  };
}

// src/sandbox/exec.ts
import { spawnSandboxFromConfig, createConfigFromPolicy } from '@microsoft/mxc-sdk';
import { buildAgentToolPolicy } from './policy.js';
 
export interface ExecResult {
  exitCode: number;
  stdout: string;
  stderr: string;
  durationMs: number;
}
 
export async function execInSandbox(
  command: string,
  args: string[],
  projectRoot: string,
): Promise<ExecResult> {
  const policy = buildAgentToolPolicy(projectRoot);
  const config = await createConfigFromPolicy(policy);
 
  const start = Date.now();
 
  const result = await spawnSandboxFromConfig(config, {
    command,
    args,
    cwd: projectRoot,
    env: {
      HOME: '/tmp',
      PATH: '/usr/bin:/bin',
    },
  });
 
  return {
    exitCode: result.exitCode,
    stdout: result.stdout,
    stderr: result.stderr,
    durationMs: Date.now() - start,
  };
}

import { execInSandbox } from './src/sandbox/exec.js';
 
const result = await execInSandbox('node', ['--version'], process.cwd());
console.log(result.stdout.trim()); // v26.x.x
console.log('كود الخروج:', result.exitCode); // 0

// src/sandbox/session.ts
import {
  createConfigFromPolicy,
  type MxcSandbox,
} from '@microsoft/mxc-sdk';
import { buildAgentToolPolicy } from './policy.js';
 
export class SandboxSession {
  private sandbox: MxcSandbox | null = null;
 
  constructor(private readonly projectRoot: string) {}
 
  async open() {
    const policy = buildAgentToolPolicy(this.projectRoot);
    const config = await createConfigFromPolicy(policy);
 
    this.sandbox = await config.provision();
    await this.sandbox.start();
  }
 
  async exec(command: string, args: string[] = []) {
    if (!this.sandbox) throw new Error('الجلسة غير مفتوحة');
 
    return this.sandbox.exec({
      command,
      args,
      cwd: this.projectRoot,
      env: { HOME: '/tmp', PATH: '/usr/bin:/bin' },
    });
  }
 
  async close() {
    if (!this.sandbox) return;
    await this.sandbox.stop();
    await this.sandbox.deprovision();
    this.sandbox = null;
  }
}

const session = new SandboxSession(process.cwd());
await session.open();
 
try {
  const install = await session.exec('npm', ['ci', '--ignore-scripts']);
  console.log('خروج التثبيت:', install.exitCode);
 
  const tests = await session.exec('npm', ['test']);
  console.log(tests.stdout);
} finally {
  await session.close();
}

// src/agent/sandbox-agent.ts
import Anthropic from '@anthropic-ai/sdk';
import { execInSandbox } from '../sandbox/exec.js';
 
const client = new Anthropic();
 
const BASH_TOOL: Anthropic.Tool = {
  name: 'bash',
  description: 'تشغيل أمر في الصدفة وإرجاع المخرجات.',
  input_schema: {
    type: 'object' as const,
    properties: {
      command: {
        type: 'string',
        description: 'الأمر المراد تنفيذه.',
      },
    },
    required: ['command'],
  },
};
 
export async function runSandboxedAgent(userPrompt: string): Promise<string> {
  const messages: Anthropic.MessageParam[] = [
    { role: 'user', content: userPrompt },
  ];
 
  while (true) {
    const response = await client.messages.create({
      model: 'claude-sonnet-5',
      max_tokens: 4096,
      tools: [BASH_TOOL],
      messages,
    });
 
    messages.push({ role: 'assistant', content: response.content });
 
    if (response.stop_reason === 'end_turn') {
      const text = response.content.find(b => b.type === 'text');
      return text?.type === 'text' ? text.text : '';
    }
 
    if (response.stop_reason !== 'tool_use') break;
 
    const toolResults: Anthropic.ToolResultBlockParam[] = [];
 
    for (const block of response.content) {
      if (block.type !== 'tool_use') continue;
 
      const input = block.input as { command: string };
 
      try {
        const result = await execInSandbox(
          '/bin/sh',
          ['-c', input.command],
          process.cwd(),
        );
 
        const output =
          result.stdout + (result.stderr ? `\nSTDERR: ${result.stderr}` : '');
 
        toolResults.push({
          type: 'tool_result',
          tool_use_id: block.id,
          content: output || `(كود الخروج ${result.exitCode})`,
        });
      } catch (err) {
        toolResults.push({
          type: 'tool_result',
          tool_use_id: block.id,
          is_error: true,
          content: err instanceof Error ? err.message : 'خطأ غير معروف في الصندوق الرملي',
        });
      }
    }
 
    messages.push({ role: 'user', content: toolResults });
  }
 
  return '';
}

import {
  MxcTimeoutError,
  MxcPolicyViolationError,
  MxcBackendUnavailableError,
} from '@microsoft/mxc-sdk';
 
try {
  await execInSandbox('/bin/sh', ['-c', 'sleep 60'], process.cwd());
} catch (err) {
  if (err instanceof MxcTimeoutError) {
    console.error('انتهت المهلة بعد', err.timeoutMs, 'مللي ثانية');
  } else if (err instanceof MxcPolicyViolationError) {
    console.error('انتهاك السياسة — المورد المرفوض:', err.deniedResource);
  } else if (err instanceof MxcBackendUnavailableError) {
    console.error('لا توجد واجهة MXC متاحة على هذا المضيف');
  } else {
    throw err;
  }
}