rl-rock 1.2.1

package/dist/index.mjs

@@ -0,0 +1,1950 @@
+import { z } from 'zod';
+import axios3, { AxiosError } from 'axios';
+import https from 'https';
+import 'os';
+import { join, resolve } from 'path';
+import winston from 'winston';
+import { existsSync, mkdirSync, statSync, readFileSync, appendFileSync } from 'fs';
+import { randomUUID } from 'crypto';
+import { spawn } from 'child_process';
+
+// src/types/codes.ts
+var Codes = /* @__PURE__ */ ((Codes2) => {
+  Codes2[Codes2["OK"] = 2e3] = "OK";
+  Codes2[Codes2["BAD_REQUEST"] = 4e3] = "BAD_REQUEST";
+  Codes2[Codes2["INTERNAL_SERVER_ERROR"] = 5e3] = "INTERNAL_SERVER_ERROR";
+  Codes2[Codes2["COMMAND_ERROR"] = 6e3] = "COMMAND_ERROR";
+  return Codes2;
+})(Codes || {});
+var ReasonPhrases = {
+  [2e3 /* OK */]: "OK",
+  [4e3 /* BAD_REQUEST */]: "Bad Request",
+  [5e3 /* INTERNAL_SERVER_ERROR */]: "Internal Server Error",
+  [6e3 /* COMMAND_ERROR */]: "Command Error"
+};
+function getReasonPhrase(code) {
+  return ReasonPhrases[code] ?? "";
+}
+function isSuccess(code) {
+  return code >= 2e3 && code <= 2999;
+}
+function isClientError(code) {
+  return code >= 4e3 && code <= 4999;
+}
+function isServerError(code) {
+  return code >= 5e3 && code <= 5999;
+}
+function isCommandError(code) {
+  return code >= 6e3 && code <= 6999;
+}
+function isError(code) {
+  return code >= 4e3 && code <= 6999;
+}
+var CommandSchema = z.object({
+  command: z.union([z.string(), z.array(z.string())]),
+  timeout: z.number().optional().default(1200),
+  env: z.record(z.string()).optional(),
+  cwd: z.string().optional()
+});
+var CreateBashSessionRequestSchema = z.object({
+  session: z.string().default("default"),
+  startupSource: z.array(z.string()).default([]),
+  envEnable: z.boolean().default(false),
+  env: z.record(z.string()).optional(),
+  remoteUser: z.string().optional()
+});
+var BashActionSchema = z.object({
+  command: z.string(),
+  session: z.string().default("default"),
+  timeout: z.number().optional(),
+  check: z.enum(["silent", "raise", "ignore"]).default("raise")
+});
+var WriteFileRequestSchema = z.object({
+  content: z.string(),
+  path: z.string()
+});
+var ReadFileRequestSchema = z.object({
+  path: z.string(),
+  encoding: z.string().optional(),
+  errors: z.string().optional()
+});
+var UploadRequestSchema = z.object({
+  sourcePath: z.string(),
+  targetPath: z.string()
+});
+var CloseSessionRequestSchema = z.object({
+  session: z.string().default("default")
+});
+var ChownRequestSchema = z.object({
+  remoteUser: z.string(),
+  paths: z.array(z.string()).default([]),
+  recursive: z.boolean().default(false)
+});
+var ChmodRequestSchema = z.object({
+  paths: z.array(z.string()).default([]),
+  mode: z.string().default("755"),
+  recursive: z.boolean().default(false)
+});
+var SandboxResponseSchema = z.object({
+  code: z.nativeEnum(Codes).optional(),
+  exitCode: z.number().optional(),
+  failureReason: z.string().optional()
+});
+var IsAliveResponseSchema = z.object({
+  isAlive: z.boolean(),
+  message: z.string().default("")
+});
+var SandboxStatusResponseSchema = z.object({
+  sandboxId: z.string().optional(),
+  status: z.record(z.unknown()).optional(),
+  portMapping: z.record(z.unknown()).optional(),
+  hostName: z.string().optional(),
+  hostIp: z.string().optional(),
+  isAlive: z.boolean().default(true),
+  image: z.string().optional(),
+  gatewayVersion: z.string().optional(),
+  sweRexVersion: z.string().optional(),
+  userId: z.string().optional(),
+  experimentId: z.string().optional(),
+  namespace: z.string().optional(),
+  cpus: z.number().optional(),
+  memory: z.string().optional()
+});
+var CommandResponseSchema = z.object({
+  stdout: z.string().default(""),
+  stderr: z.string().default(""),
+  exitCode: z.number().optional()
+});
+var WriteFileResponseSchema = z.object({
+  success: z.boolean().default(false),
+  message: z.string().default("")
+});
+var ReadFileResponseSchema = z.object({
+  content: z.string().default("")
+});
+var UploadResponseSchema = z.object({
+  success: z.boolean().default(false),
+  message: z.string().default(""),
+  fileName: z.string().optional()
+});
+var ObservationSchema = z.object({
+  output: z.string().default(""),
+  exitCode: z.number().optional(),
+  failureReason: z.string().default(""),
+  expectString: z.string().default("")
+});
+var CreateSessionResponseSchema = z.object({
+  output: z.string().default("")
+});
+var CloseSessionResponseSchema = z.object({});
+var CloseResponseSchema = z.object({});
+var ChownResponseSchema = z.object({
+  success: z.boolean().default(false),
+  message: z.string().default("")
+});
+var ChmodResponseSchema = z.object({
+  success: z.boolean().default(false),
+  message: z.string().default("")
+});
+var ExecuteBashSessionResponseSchema = z.object({
+  success: z.boolean().default(false),
+  message: z.string().default("")
+});
+var OssSetupResponseSchema = z.object({
+  success: z.boolean().default(false),
+  message: z.string().default("")
+});
+
+// src/common/constants.ts
+var RunMode = {
+  NORMAL: "normal",
+  NOHUP: "nohup"
+};
+var Constants = class {
+  static BASE_URL_PRODUCT = "";
+  static BASE_URL_ALIYUN = "";
+  static BASE_URL_INNER = "";
+  static BASE_URL_PRE = "";
+  static BASE_URL_LOCAL = "";
+  static REQUEST_TIMEOUT_SECONDS = 180;
+};
+var PID_PREFIX = "__ROCK_PID_START__";
+var PID_SUFFIX = "__ROCK_PID_END__";
+
+// src/common/exceptions.ts
+var RockException = class extends Error {
+  _code = null;
+  constructor(message, code) {
+    super(message);
+    this.name = "RockException";
+    this._code = code ?? null;
+  }
+  get code() {
+    return this._code;
+  }
+};
+var InvalidParameterRockException = class extends RockException {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidParameterRockException";
+  }
+};
+var BadRequestRockError = class extends RockException {
+  constructor(message, code = 4e3 /* BAD_REQUEST */) {
+    super(message, code);
+    this.name = "BadRequestRockError";
+  }
+};
+var InternalServerRockError = class extends RockException {
+  constructor(message, code = 5e3 /* INTERNAL_SERVER_ERROR */) {
+    super(message, code);
+    this.name = "InternalServerRockError";
+  }
+};
+var CommandRockError = class extends RockException {
+  constructor(message, code = 6e3 /* COMMAND_ERROR */) {
+    super(message, code);
+    this.name = "CommandRockError";
+  }
+};
+function raiseForCode(code, message) {
+  if (code === null || code === void 0 || isSuccessCode(code)) {
+    return;
+  }
+  if (isClientErrorCode(code)) {
+    throw new BadRequestRockError(message, code);
+  }
+  if (isServerErrorCode(code)) {
+    throw new InternalServerRockError(message, code);
+  }
+  if (isCommandErrorCode(code)) {
+    throw new CommandRockError(message, code);
+  }
+  throw new RockException(message, code);
+}
+function fromRockException(e) {
+  return {
+    code: e.code ?? void 0,
+    exitCode: 1,
+    failureReason: e.message
+  };
+}
+function isSuccessCode(code) {
+  return code >= 2e3 && code <= 2999;
+}
+function isClientErrorCode(code) {
+  return code >= 4e3 && code <= 4999;
+}
+function isServerErrorCode(code) {
+  return code >= 5e3 && code <= 5999;
+}
+function isCommandErrorCode(code) {
+  return code >= 6e3 && code <= 6999;
+}
+var HttpUtils = class {
+  static defaultTimeout = 3e5;
+  // 5 minutes
+  static defaultConnectTimeout = 3e5;
+  /**
+   * Create axios instance with default config
+   */
+  static createClient(config) {
+    return axios3.create({
+      timeout: config?.timeout ?? this.defaultTimeout,
+      headers: {
+        "Content-Type": "application/json",
+        ...config?.headers
+      },
+      httpsAgent: new https.Agent({
+        rejectUnauthorized: true
+      })
+    });
+  }
+  /**
+   * Send POST request
+   */
+  static async post(url, headers, data, readTimeout) {
+    const client = this.createClient({
+      timeout: readTimeout ?? this.defaultTimeout,
+      headers
+    });
+    try {
+      const response = await client.post(url, data);
+      return response.data;
+    } catch (error) {
+      if (error instanceof AxiosError) {
+        throw new Error(`Failed to POST ${url}: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Send GET request
+   */
+  static async get(url, headers) {
+    const client = this.createClient({ headers });
+    try {
+      const response = await client.get(url);
+      return response.data;
+    } catch (error) {
+      if (error instanceof AxiosError) {
+        throw new Error(`Failed to GET ${url}: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Send multipart/form-data request
+   */
+  static async postMultipart(url, headers, data, files) {
+    const formData = new FormData();
+    if (data) {
+      for (const [key, value] of Object.entries(data)) {
+        if (value !== void 0 && value !== null) {
+          formData.append(key, String(value));
+        }
+      }
+    }
+    if (files) {
+      for (const [fieldName, fileData] of Object.entries(files)) {
+        if (fileData !== void 0 && fileData !== null) {
+          if (Array.isArray(fileData)) {
+            const [filename, content, contentType] = fileData;
+            const blob = new Blob([content], { type: contentType });
+            formData.append(fieldName, blob, filename);
+          } else if (fileData instanceof Buffer) {
+            const blob = new Blob([fileData], { type: "application/octet-stream" });
+            formData.append(fieldName, blob, "file");
+          } else if (fileData instanceof File) {
+            formData.append(fieldName, fileData);
+          }
+        }
+      }
+    }
+    const client = this.createClient({
+      headers: {
+        ...headers,
+        "Content-Type": "multipart/form-data"
+      }
+    });
+    try {
+      const response = await client.post(url, formData);
+      return response.data;
+    } catch (error) {
+      if (error instanceof AxiosError) {
+        throw new Error(`Failed to POST multipart ${url}: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Guess MIME type from filename
+   */
+  static guessContentType(filename) {
+    const ext = filename.split(".").pop()?.toLowerCase();
+    const mimeTypes = {
+      txt: "text/plain",
+      html: "text/html",
+      css: "text/css",
+      js: "application/javascript",
+      json: "application/json",
+      xml: "application/xml",
+      pdf: "application/pdf",
+      zip: "application/zip",
+      tar: "application/x-tar",
+      gz: "application/gzip",
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      gif: "image/gif",
+      svg: "image/svg+xml"
+    };
+    return mimeTypes[ext ?? ""] ?? "application/octet-stream";
+  }
+};
+
+// src/utils/retry.ts
+function retryAsync(fn, options = {}) {
+  const {
+    maxAttempts = 3,
+    delaySeconds = 1,
+    backoff = 1,
+    jitter = false
+  } = options;
+  return retryAsyncImpl(fn, {
+    maxAttempts,
+    delaySeconds,
+    backoff,
+    jitter
+  });
+}
+async function retryAsyncImpl(fn, options) {
+  const { maxAttempts, delaySeconds, backoff, jitter } = options;
+  let lastError = null;
+  let currentDelay = delaySeconds;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (e) {
+      lastError = e instanceof Error ? e : new Error(String(e));
+      if (attempt === maxAttempts) {
+        break;
+      }
+      let sleepTime = currentDelay;
+      if (jitter) {
+        sleepTime = Math.random() * currentDelay * 2;
+      }
+      await sleep(sleepTime * 1e3);
+      currentDelay *= backoff;
+    }
+  }
+  throw lastError ?? new Error("All retry attempts failed");
+}
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+function withRetry(fn, options = {}) {
+  return (async (...args) => {
+    return retryAsync(() => fn(...args), options);
+  });
+}
+
+// src/utils/deprecated.ts
+function deprecated(reason = "") {
+  return function(target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = function(...args) {
+      console.warn(
+        `${String(propertyKey)} is deprecated. ${reason}`
+      );
+      return originalMethod.apply(this, args);
+    };
+    return descriptor;
+  };
+}
+function deprecatedClass(reason = "") {
+  return function(constructor) {
+    return class extends constructor {
+      constructor(...args) {
+        console.warn(`${constructor.name} is deprecated. ${reason}`);
+        super(...args);
+      }
+    };
+  };
+}
+
+// src/utils/system.ts
+function isNode() {
+  return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+}
+function isBrowser() {
+  return typeof globalThis !== "undefined" && "window" in globalThis && typeof globalThis.window !== "undefined";
+}
+function getEnv(key, defaultValue) {
+  if (isNode()) {
+    return process.env[key] ?? defaultValue;
+  }
+  return defaultValue;
+}
+function getRequiredEnv(key) {
+  const value = getEnv(key);
+  if (value === void 0) {
+    throw new Error(`Required environment variable ${key} is not set`);
+  }
+  return value;
+}
+function isEnvSet(key) {
+  if (isNode()) {
+    return key in process.env;
+  }
+  return false;
+}
+var envVars = {
+  // Logging
+  get ROCK_LOGGING_PATH() {
+    return getEnv("ROCK_LOGGING_PATH");
+  },
+  get ROCK_LOGGING_FILE_NAME() {
+    return getEnv("ROCK_LOGGING_FILE_NAME", "rocklet.log");
+  },
+  get ROCK_LOGGING_LEVEL() {
+    return getEnv("ROCK_LOGGING_LEVEL", "INFO");
+  },
+  // Base URLs
+  get ROCK_BASE_URL() {
+    return getEnv("ROCK_BASE_URL", "http://localhost:8080");
+  },
+  get ROCK_SANDBOX_STARTUP_TIMEOUT_SECONDS() {
+    return parseInt(getEnv("ROCK_SANDBOX_STARTUP_TIMEOUT_SECONDS", "180"), 10);
+  },
+  // EnvHub
+  get ROCK_ENVHUB_BASE_URL() {
+    return getEnv("ROCK_ENVHUB_BASE_URL", "http://localhost:8081");
+  },
+  // Model Service
+  get ROCK_MODEL_SERVICE_DATA_DIR() {
+    return getEnv("ROCK_MODEL_SERVICE_DATA_DIR", "/data/logs");
+  }};
+
+// src/envhub/schema.ts
+var EnvHubClientConfigSchema = z.object({
+  baseUrl: z.string().default(envVars.ROCK_ENVHUB_BASE_URL)
+});
+var RockEnvInfoSchema = z.object({
+  envName: z.string(),
+  image: z.string(),
+  owner: z.string().default(""),
+  createAt: z.string().default(""),
+  updateAt: z.string().default(""),
+  description: z.string().default(""),
+  tags: z.array(z.string()).default([]),
+  extraSpec: z.record(z.unknown()).optional()
+});
+function createRockEnvInfo(data) {
+  return RockEnvInfoSchema.parse({
+    envName: data.env_name ?? data.envName,
+    image: data.image,
+    owner: data.owner ?? "",
+    createAt: data.create_at ?? data.createAt ?? "",
+    updateAt: data.update_at ?? data.updateAt ?? "",
+    description: data.description ?? "",
+    tags: data.tags ?? [],
+    extraSpec: data.extra_spec ?? data.extraSpec
+  });
+}
+function rockEnvInfoToDict(env) {
+  return {
+    env_name: env.envName,
+    image: env.image,
+    owner: env.owner,
+    create_at: env.createAt,
+    update_at: env.updateAt,
+    description: env.description,
+    tags: env.tags,
+    extra_spec: env.extraSpec
+  };
+}
+
+// src/envhub/client.ts
+var EnvHubError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EnvHubError";
+  }
+};
+var EnvHubClient = class {
+  config;
+  baseUrl;
+  headers;
+  constructor(config) {
+    this.config = EnvHubClientConfigSchema.parse(config ?? {});
+    this.baseUrl = this.config.baseUrl;
+    this.headers = { "Content-Type": "application/json" };
+  }
+  /**
+   * Register or update an environment
+   */
+  async register(options) {
+    const url = `${this.baseUrl}/env/register`;
+    const payload = {
+      env_name: options.envName,
+      image: options.image,
+      owner: options.owner ?? "",
+      description: options.description ?? "",
+      tags: options.tags ?? [],
+      extra_spec: options.extraSpec
+    };
+    try {
+      const response = await HttpUtils.post(
+        url,
+        this.headers,
+        payload
+      );
+      return createRockEnvInfo(response);
+    } catch (e) {
+      throw new EnvHubError(`Failed to register environment: ${e}`);
+    }
+  }
+  /**
+   * Get environment by name
+   */
+  async getEnv(envName) {
+    const url = `${this.baseUrl}/env/get`;
+    const payload = { env_name: envName };
+    try {
+      const response = await HttpUtils.post(
+        url,
+        this.headers,
+        payload
+      );
+      return createRockEnvInfo(response);
+    } catch (e) {
+      throw new EnvHubError(`Failed to get environment ${envName}: ${e}`);
+    }
+  }
+  /**
+   * List environments
+   */
+  async listEnvs(options) {
+    const url = `${this.baseUrl}/env/list`;
+    const payload = {
+      owner: options?.owner,
+      tags: options?.tags
+    };
+    try {
+      const response = await HttpUtils.post(
+        url,
+        this.headers,
+        payload
+      );
+      const envsData = response.envs ?? [];
+      return envsData.map((envData) => createRockEnvInfo(envData));
+    } catch (e) {
+      throw new EnvHubError(`Failed to list environments: ${e}`);
+    }
+  }
+  /**
+   * Delete environment
+   */
+  async deleteEnv(envName) {
+    const url = `${this.baseUrl}/env/delete`;
+    const payload = { env_name: envName };
+    try {
+      await HttpUtils.post(url, this.headers, payload);
+      return true;
+    } catch (e) {
+      const errorMessage = e instanceof Error ? e.message : String(e);
+      if (errorMessage.includes("404")) {
+        return false;
+      }
+      throw new EnvHubError(`Failed to delete environment ${envName}: ${e}`);
+    }
+  }
+  /**
+   * Health check
+   */
+  async healthCheck() {
+    const url = `${this.baseUrl}/health`;
+    try {
+      const response = await HttpUtils.get(
+        url,
+        this.headers
+      );
+      return response;
+    } catch (e) {
+      throw new EnvHubError(`Failed to health check: ${e}`);
+    }
+  }
+};
+var levels = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  http: 3,
+  debug: 4
+};
+var colors = {
+  error: "red",
+  warn: "yellow",
+  info: "green",
+  http: "magenta",
+  debug: "cyan"
+};
+winston.addColors(colors);
+var consoleFormat = winston.format.combine(
+  winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss.SSS" }),
+  winston.format.colorize({ all: true }),
+  winston.format.printf((info) => {
+    const { timestamp, level, message, ...meta } = info;
+    const metaStr = Object.keys(meta).length ? JSON.stringify(meta) : "";
+    return `${timestamp} ${level}: ${message} ${metaStr}`;
+  })
+);
+var fileFormat = winston.format.combine(
+  winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss.SSS" }),
+  winston.format.json()
+);
+function getLogLevel() {
+  const level = envVars.ROCK_LOGGING_LEVEL.toUpperCase();
+  if (level in levels) {
+    return level.toLowerCase();
+  }
+  return "info";
+}
+var loggerCache = /* @__PURE__ */ new Map();
+function initLogger(name = "rock", fileName) {
+  if (loggerCache.has(name)) {
+    return loggerCache.get(name);
+  }
+  const transports = [];
+  const logLevel = getLogLevel();
+  const logPath = envVars.ROCK_LOGGING_PATH;
+  const logFileName = envVars.ROCK_LOGGING_FILE_NAME;
+  if (logPath) {
+    if (!existsSync(logPath)) {
+      mkdirSync(logPath, { recursive: true });
+    }
+    transports.push(
+      new winston.transports.File({
+        filename: join(logPath, logFileName),
+        format: fileFormat,
+        level: logLevel
+      })
+    );
+  } else {
+    transports.push(
+      new winston.transports.Console({
+        format: consoleFormat,
+        level: logLevel
+      })
+    );
+  }
+  const logger11 = winston.createLogger({
+    levels,
+    defaultMeta: { service: name },
+    transports
+  });
+  loggerCache.set(name, logger11);
+  return logger11;
+}
+initLogger("rock");
+
+// src/envs/rock_env.ts
+var logger = initLogger("rock.envs");
+var RockEnv = class {
+  envId;
+  sandboxId = null;
+  isClosed = false;
+  client;
+  constructor(config) {
+    this.envId = config.envId;
+    this.client = axios3.create({
+      baseURL: envVars.ROCK_BASE_URL,
+      timeout: 3e5,
+      headers: { "Content-Type": "application/json" }
+    });
+    try {
+      this.initializeEnvironment();
+    } catch (e) {
+      throw new Error(`Failed to initialize environment: ${e}`);
+    }
+  }
+  /**
+   * Initialize environment instance
+   */
+  initializeEnvironment() {
+    logger.debug(`Initializing environment: ${this.envId}`);
+  }
+  /**
+   * Execute an action step
+   *
+   * @param action - Action ID to execute
+   * @returns Tuple containing observation, reward, terminated, truncated, info
+   */
+  async step(action) {
+    this.ensureNotClosed();
+    const params = {
+      sandbox_id: this.sandboxId,
+      action
+    };
+    try {
+      const response = await this.client.post(
+        "/apis/v1/envs/gem/step",
+        params
+      );
+      return this.parseStepResult(response.data);
+    } catch (e) {
+      throw new Error(`Failed to execute step with action ${action}: ${e}`);
+    }
+  }
+  /**
+   * Reset environment to initial state
+   *
+   * @param seed - Optional random seed
+   * @returns Tuple containing initial observation and info
+   */
+  async reset(seed) {
+    this.ensureNotClosed();
+    const params = { sandbox_id: this.sandboxId };
+    if (seed !== void 0) {
+      params.seed = seed;
+    }
+    try {
+      const response = await this.client.post(
+        "/apis/v1/envs/gem/reset",
+        params
+      );
+      return this.parseResetResult(response.data);
+    } catch (e) {
+      throw new Error(`Failed to reset environment: ${e}`);
+    }
+  }
+  /**
+   * Close environment and clean up resources
+   */
+  async close() {
+    if (this.isClosed || !this.sandboxId) {
+      return;
+    }
+    try {
+      await this.client.post("/apis/v1/envs/gem/close", {
+        sandbox_id: this.sandboxId
+      });
+    } catch (e) {
+      throw new Error(`Failed to close environment: ${e}`);
+    } finally {
+      this.isClosed = true;
+      this.sandboxId = null;
+    }
+  }
+  /**
+   * Parse step result from API response
+   */
+  parseStepResult(data) {
+    return [
+      data.observation,
+      data.reward,
+      data.terminated,
+      data.truncated,
+      data.info
+    ];
+  }
+  /**
+   * Parse reset result from API response
+   */
+  parseResetResult(data) {
+    return [data.observation, data.info];
+  }
+  /**
+   * Ensure environment is not closed
+   */
+  ensureNotClosed() {
+    if (this.isClosed) {
+      throw new Error("Environment is closed");
+    }
+  }
+};
+
+// src/envs/registration.ts
+function make(envId, options) {
+  return new RockEnv({ envId, ...options });
+}
+var BaseConfigSchema = z.object({
+  baseUrl: z.string().default(envVars.ROCK_BASE_URL),
+  xrlAuthorization: z.string().optional(),
+  extraHeaders: z.record(z.string()).default({})
+});
+var SandboxConfigSchema = BaseConfigSchema.extend({
+  image: z.string().default("python:3.11"),
+  autoClearSeconds: z.number().default(300),
+  routeKey: z.string().optional(),
+  startupTimeout: z.number().default(envVars.ROCK_SANDBOX_STARTUP_TIMEOUT_SECONDS),
+  memory: z.string().default("8g"),
+  cpus: z.number().default(2),
+  userId: z.string().optional(),
+  experimentId: z.string().optional(),
+  cluster: z.string().default("zb"),
+  namespace: z.string().optional()
+});
+var SandboxGroupConfigSchema = SandboxConfigSchema.extend({
+  size: z.number().default(2),
+  startConcurrency: z.number().default(2),
+  startRetryTimes: z.number().default(3)
+});
+function createSandboxConfig(config) {
+  return SandboxConfigSchema.parse(config ?? {});
+}
+function createSandboxGroupConfig(config) {
+  return SandboxGroupConfigSchema.parse(config ?? {});
+}
+var logger2 = initLogger("rock.sandbox.deploy");
+var Deploy = class {
+  sandbox;
+  workingDir = null;
+  constructor(sandbox) {
+    this.sandbox = sandbox;
+  }
+  /**
+   * Get the current working directory
+   */
+  getWorkingDir() {
+    return this.workingDir;
+  }
+  /**
+   * Deploy local directory to sandbox
+   *
+   * @param localPath - Local directory path
+   * @param targetPath - Target path in sandbox (optional)
+   * @returns The target path in sandbox
+   */
+  async deployWorkingDir(localPath, targetPath) {
+    const localAbs = resolve(localPath);
+    if (!existsSync(localAbs)) {
+      throw new Error(`local_path not found: ${localAbs}`);
+    }
+    const stats = statSync(localAbs);
+    if (!stats.isDirectory()) {
+      throw new Error(`local_path must be a directory: ${localAbs}`);
+    }
+    const target = targetPath ?? `/tmp/rock_workdir_${randomUUID().replace(/-/g, "")}`;
+    const sandboxId = this.sandbox.getSandboxId();
+    logger2.info(`[${sandboxId}] Deploying working_dir: ${localAbs} -> ${target}`);
+    const uploadResult = await this.sandbox.getFs().uploadDir(localAbs, target);
+    if (uploadResult.exitCode !== 0) {
+      throw new Error(`Failed to upload directory: ${uploadResult.failureReason}`);
+    }
+    this.workingDir = target;
+    logger2.info(`[${sandboxId}] working_dir deployed: ${target}`);
+    return target;
+  }
+  /**
+   * Format command template supporting ${} and <<>> syntax
+   *
+   * @param template - Template string with placeholders
+   * @param kwargs - Additional substitution variables
+   * @returns Formatted string
+   */
+  format(template, kwargs = {}) {
+    const subs = {
+      ...kwargs,
+      ...this.workingDir ? { working_dir: this.workingDir } : {}
+    };
+    let result = template;
+    for (const key of Object.keys(subs)) {
+      result = result.replace(new RegExp(`<<${key}>>`, "g"), `\${${key}}`);
+    }
+    for (const [key, value] of Object.entries(subs)) {
+      if (value !== void 0) {
+        result = result.replace(new RegExp(`\\$\\{${key}\\}`, "g"), value);
+      }
+    }
+    return result;
+  }
+};
+
+// src/sandbox/file_system.ts
+var logger3 = initLogger("rock.sandbox.fs");
+var FileSystem = class {
+  sandbox;
+  constructor(sandbox) {
+    this.sandbox = sandbox;
+  }
+};
+var LinuxFileSystem = class extends FileSystem {
+  constructor(sandbox) {
+    super(sandbox);
+  }
+  async chown(request) {
+    const { paths, recursive, remoteUser } = request;
+    if (!paths || paths.length === 0) {
+      throw new Error("paths is empty");
+    }
+    const command = ["chown"];
+    if (recursive) {
+      command.push("-R");
+    }
+    command.push(`${remoteUser}:${remoteUser}`, ...paths);
+    logger3.info(`chown command: ${command.join(" ")}`);
+    const response = await this.sandbox.execute({ command, timeout: 300 });
+    if (response.exitCode !== 0) {
+      return { success: false, message: JSON.stringify(response) };
+    }
+    return { success: true, message: JSON.stringify(response) };
+  }
+  async chmod(request) {
+    const { paths, recursive, mode } = request;
+    if (!paths || paths.length === 0) {
+      throw new Error("paths is empty");
+    }
+    const command = ["chmod"];
+    if (recursive) {
+      command.push("-R");
+    }
+    command.push(mode, ...paths);
+    logger3.info(`chmod command: ${command.join(" ")}`);
+    const response = await this.sandbox.execute({ command, timeout: 300 });
+    if (response.exitCode !== 0) {
+      return { success: false, message: JSON.stringify(response) };
+    }
+    return { success: true, message: JSON.stringify(response) };
+  }
+  async uploadDir(sourceDir, targetDir, extractTimeout = 600) {
+    logger3.info(`uploadDir: ${sourceDir} -> ${targetDir}`);
+    return {
+      output: `uploaded ${sourceDir} -> ${targetDir}`,
+      exitCode: 0,
+      failureReason: "",
+      expectString: ""
+    };
+  }
+};
+
+// src/sandbox/types.ts
+var SpeedupType = /* @__PURE__ */ ((SpeedupType2) => {
+  SpeedupType2["APT"] = "apt";
+  SpeedupType2["PIP"] = "pip";
+  SpeedupType2["GITHUB"] = "github";
+  return SpeedupType2;
+})(SpeedupType || {});
+
+// src/sandbox/network.ts
+var logger4 = initLogger("rock.sandbox.network");
+var Network = class {
+  sandbox;
+  constructor(sandbox) {
+    this.sandbox = sandbox;
+  }
+  /**
+   * Configure acceleration for package managers or network resources
+   *
+   * @param speedupType - Type of speedup configuration
+   * @param speedupValue - Speedup value (mirror URL or IP address)
+   * @param timeout - Execution timeout in seconds
+   * @returns Observation with execution result
+   */
+  async speedup(speedupType, speedupValue, timeout = 300) {
+    const sandboxId = this.sandbox.getSandboxId();
+    logger4.info(
+      `[${sandboxId}] Configuring ${speedupType} speedup: ${speedupValue}`
+    );
+    let command;
+    switch (speedupType) {
+      case "apt" /* APT */:
+        command = this.buildAptSpeedupCommand(speedupValue);
+        break;
+      case "pip" /* PIP */:
+        command = this.buildPipSpeedupCommand(speedupValue);
+        break;
+      case "github" /* GITHUB */:
+        command = this.buildGithubSpeedupCommand(speedupValue);
+        break;
+      default:
+        throw new Error(`Unsupported speedup type: ${speedupType}`);
+    }
+    const result = await this.sandbox.arun(command, {
+      mode: "nohup",
+      waitTimeout: timeout
+    });
+    return result;
+  }
+  buildAptSpeedupCommand(mirrorUrl) {
+    return `cat > /etc/apt/sources.list << 'EOF'
+deb ${mirrorUrl} $(lsb_release -cs) main restricted universe multiverse
+deb ${mirrorUrl} $(lsb_release -cs)-updates main restricted universe multiverse
+deb ${mirrorUrl} $(lsb_release -cs)-backports main restricted universe multiverse
+deb ${mirrorUrl} $(lsb_release -cs)-security main restricted universe multiverse
+EOF
+apt-get update`;
+  }
+  buildPipSpeedupCommand(mirrorUrl) {
+    const safeUrl = mirrorUrl.replace(/'/g, "'\\''");
+    return `mkdir -p ~/.pip && cat > ~/.pip/pip.conf << 'EOF'
+[global]
+index-url = ${safeUrl}
+trusted-host = $(echo ${safeUrl} | sed 's|https\\?://||' | cut -d'/' -f1)
+EOF`;
+  }
+  buildGithubSpeedupCommand(ipAddress) {
+    return `echo "${ipAddress} github.com" >> /etc/hosts`;
+  }
+};
+
+// src/sandbox/process.ts
+var logger5 = initLogger("rock.sandbox.process");
+var Process = class {
+  sandbox;
+  constructor(sandbox) {
+    this.sandbox = sandbox;
+  }
+  /**
+   * Execute a script in the sandbox
+   *
+   * @param scriptContent - The script content to execute
+   * @param scriptName - Optional custom script name
+   * @param waitTimeout - Maximum time to wait for script completion
+   * @param waitInterval - Interval between process checks
+   * @param cleanup - Whether to delete the script file after execution
+   * @returns Observation with execution result
+   */
+  async executeScript(options) {
+    const {
+      scriptContent,
+      scriptName,
+      waitTimeout = 300,
+      cleanup = true
+    } = options;
+    const sandboxId = this.sandbox.getSandboxId();
+    const timestamp = Date.now();
+    const name = scriptName ?? `script_${timestamp}.sh`;
+    const scriptPath = `/tmp/${name}`;
+    try {
+      logger5.info(`[${sandboxId}] Uploading script to ${scriptPath}`);
+      const writeResult = await this.sandbox.write_file({
+        content: scriptContent,
+        path: scriptPath
+      });
+      if (!writeResult.success) {
+        const errorMsg = `Failed to upload script: ${writeResult.message}`;
+        logger5.error(errorMsg);
+        return { output: errorMsg, exitCode: 1, failureReason: "Script upload failed", expectString: "" };
+      }
+      logger5.info(`[${sandboxId}] Executing script: ${scriptPath} (timeout=${waitTimeout}s)`);
+      const result = await this.sandbox.arun(`bash ${scriptPath}`, {
+        mode: "nohup",
+        waitTimeout
+      });
+      return result;
+    } catch (e) {
+      const errorMsg = `Script execution failed: ${e}`;
+      logger5.error(errorMsg);
+      return { output: errorMsg, exitCode: 1, failureReason: errorMsg, expectString: "" };
+    } finally {
+      if (cleanup) {
+        try {
+          logger5.info(`[${sandboxId}] Cleaning up script: ${scriptPath}`);
+          await this.sandbox.execute({ command: ["rm", "-f", scriptPath], timeout: 30 });
+        } catch (e) {
+          logger5.warn(`Failed to cleanup script ${scriptPath}: ${e}`);
+        }
+      }
+    }
+  }
+};
+
+// src/sandbox/remote_user.ts
+var logger6 = initLogger("rock.sandbox.user");
+var RemoteUser = class {
+  sandbox;
+  currentUser = "root";
+  constructor(sandbox) {
+    this.sandbox = sandbox;
+  }
+  getCurrentUser() {
+    return this.currentUser;
+  }
+};
+var LinuxRemoteUser = class extends RemoteUser {
+  constructor(sandbox) {
+    super(sandbox);
+  }
+  async createRemoteUser(userName) {
+    try {
+      if (await this.isUserExist(userName)) {
+        return true;
+      }
+      const response = await this.sandbox.execute({
+        command: ["useradd", "-m", "-s", "/bin/bash", userName],
+        timeout: 30
+      });
+      logger6.info(`user add execute response: ${JSON.stringify(response)}`);
+      if (response.exitCode !== 0) {
+        return false;
+      }
+      return true;
+    } catch (e) {
+      logger6.error("create_remote_user failed", e);
+      throw e;
+    }
+  }
+  async isUserExist(userName) {
+    try {
+      const response = await this.sandbox.execute({
+        command: ["id", userName],
+        timeout: 30
+      });
+      if (response.exitCode === 0) {
+        logger6.info(`user ${userName} already exists`);
+        return true;
+      }
+      return false;
+    } catch (e) {
+      logger6.info(`is_user_exist exception: ${e}`);
+      throw e;
+    }
+  }
+};
+
+// src/sandbox/utils.ts
+var logger7 = initLogger("rock.sandbox.utils");
+function getCallerLoggerName() {
+  const stack = new Error().stack;
+  if (!stack) return "unknown";
+  const lines = stack.split("\n");
+  for (let i = 2; i < lines.length; i++) {
+    const line = lines[i];
+    if (line && !line.includes("utils.ts")) {
+      const match = line.match(/at\s+(?:(?:async\s+)?(?:\w+\.)?(\w+)|(\w+))/);
+      if (match) {
+        return match[1] ?? match[2] ?? "unknown";
+      }
+    }
+  }
+  return "unknown";
+}
+function withTimeLogging(operationName) {
+  return function(target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+      const startTime = Date.now();
+      const name = getCallerLoggerName();
+      const log = initLogger(name);
+      log.debug(`${operationName} started`);
+      try {
+        const result = await originalMethod.apply(this, args);
+        const elapsed = Date.now() - startTime;
+        log.info(`${operationName} completed (elapsed: ${elapsed / 1e3}s)`);
+        return result;
+      } catch (e) {
+        const elapsed = Date.now() - startTime;
+        log.error(`${operationName} failed: ${e} (elapsed: ${elapsed / 1e3}s)`);
+        throw e;
+      }
+    };
+    return descriptor;
+  };
+}
+async function arunWithRetry(sandbox, cmd, session, mode, options = {}) {
+  const {
+    waitTimeout = 300,
+    waitInterval = 10,
+    maxAttempts = 3,
+    errorMsg = "Command failed"
+  } = options;
+  let lastError = null;
+  let currentDelay = 5e3;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const result = await sandbox.arun(cmd, {
+        session,
+        mode,
+        waitTimeout,
+        waitInterval
+      });
+      if (result.exitCode !== 0) {
+        throw new Error(
+          `${errorMsg} with exit code: ${result.exitCode}, output: ${result.output}`
+        );
+      }
+      return result;
+    } catch (e) {
+      lastError = e instanceof Error ? e : new Error(String(e));
+      logger7.warn(`Attempt ${attempt}/${maxAttempts} failed: ${lastError.message}`);
+      if (attempt < maxAttempts) {
+        await sleep(currentDelay);
+        currentDelay *= 2;
+      }
+    }
+  }
+  throw lastError ?? new Error(`${errorMsg}: all attempts failed`);
+}
+function extractNohupPid(output) {
+  const PID_PREFIX2 = "__ROCK_PID_START__";
+  const PID_SUFFIX2 = "__ROCK_PID_END__";
+  const pattern = new RegExp(`${PID_PREFIX2}(\\d+)${PID_SUFFIX2}`);
+  const match = output.match(pattern);
+  if (match?.[1]) {
+    return parseInt(match[1], 10);
+  }
+  return null;
+}
+
+// src/sandbox/client.ts
+var logger8 = initLogger("rock.sandbox");
+var AbstractSandbox = class {
+};
+var Sandbox = class extends AbstractSandbox {
+  config;
+  url;
+  routeKey;
+  sandboxId = null;
+  hostName = null;
+  hostIp = null;
+  cluster;
+  // Sub-components
+  deploy;
+  fs;
+  network;
+  process;
+  remoteUser;
+  constructor(config = {}) {
+    super();
+    this.config = createSandboxConfig(config);
+    this.url = `${this.config.baseUrl}/apis/envs/sandbox/v1`;
+    this.routeKey = this.config.routeKey ?? randomUUID().replace(/-/g, "");
+    this.cluster = this.config.cluster;
+    this.deploy = new Deploy(this);
+    this.fs = new LinuxFileSystem(this);
+    this.network = new Network(this);
+    this.process = new Process(this);
+    this.remoteUser = new LinuxRemoteUser(this);
+  }
+  // Getters
+  getSandboxId() {
+    if (!this.sandboxId) {
+      throw new Error("Sandbox not started");
+    }
+    return this.sandboxId;
+  }
+  getHostName() {
+    return this.hostName;
+  }
+  getHostIp() {
+    return this.hostIp;
+  }
+  getCluster() {
+    return this.cluster;
+  }
+  getUrl() {
+    return this.url;
+  }
+  getFs() {
+    return this.fs;
+  }
+  getNetwork() {
+    return this.network;
+  }
+  getProcess() {
+    return this.process;
+  }
+  getRemoteUser() {
+    return this.remoteUser;
+  }
+  getDeploy() {
+    return this.deploy;
+  }
+  getConfig() {
+    return this.config;
+  }
+  // Build headers
+  buildHeaders() {
+    const headers = {
+      "ROUTE-KEY": this.routeKey,
+      "X-Cluster": this.cluster
+    };
+    if (this.config.extraHeaders) {
+      Object.assign(headers, this.config.extraHeaders);
+    }
+    this.addUserDefinedTags(headers);
+    return headers;
+  }
+  addUserDefinedTags(headers) {
+    if (this.config.userId) {
+      headers["X-User-Id"] = this.config.userId;
+    }
+    if (this.config.experimentId) {
+      headers["X-Experiment-Id"] = this.config.experimentId;
+    }
+    if (this.config.namespace) {
+      headers["X-Namespace"] = this.config.namespace;
+    }
+  }
+  // Lifecycle methods
+  async start() {
+    const url = `${this.url}/start_async`;
+    const headers = this.buildHeaders();
+    const data = {
+      image: this.config.image,
+      auto_clear_time: this.config.autoClearSeconds / 60,
+      auto_clear_time_minutes: this.config.autoClearSeconds / 60,
+      startup_timeout: this.config.startupTimeout,
+      memory: this.config.memory,
+      cpus: this.config.cpus
+    };
+    try {
+      const response = await HttpUtils.post(
+        url,
+        headers,
+        data
+      );
+      logger8.debug(`Start sandbox response: ${JSON.stringify(response)}`);
+      if (response.status !== "Success") {
+        throw new Error(`Failed to start sandbox: ${JSON.stringify(response)}`);
+      }
+      this.sandboxId = response.result?.sandbox_id ?? null;
+      this.hostName = response.result?.host_name ?? null;
+      this.hostIp = response.result?.host_ip ?? null;
+      const startTime = Date.now();
+      while (Date.now() - startTime < this.config.startupTimeout * 1e3) {
+        const status = await this.getStatus();
+        if (status.isAlive) {
+          return;
+        }
+        await sleep(3e3);
+      }
+      throw new Error(`Failed to start sandbox within ${this.config.startupTimeout}s`);
+    } catch (e) {
+      throw new Error(`Failed to start sandbox: ${e}`);
+    }
+  }
+  async stop() {
+    if (!this.sandboxId) return;
+    try {
+      const url = `${this.url}/stop`;
+      const headers = this.buildHeaders();
+      await HttpUtils.post(url, headers, { sandbox_id: this.sandboxId });
+    } catch (e) {
+      logger8.warn(`Failed to stop sandbox, IGNORE: ${e}`);
+    }
+  }
+  async isAlive() {
+    try {
+      const status = await this.getStatus();
+      return {
+        isAlive: status.isAlive,
+        message: status.hostName ?? ""
+      };
+    } catch (e) {
+      throw new Error(`Failed to get is alive: ${e}`);
+    }
+  }
+  async getStatus() {
+    const url = `${this.url}/get_status?sandbox_id=${this.sandboxId}`;
+    const headers = this.buildHeaders();
+    const response = await HttpUtils.get(url, headers);
+    if (response.status !== "Success") {
+      throw new Error(`Failed to get status: ${JSON.stringify(response)}`);
+    }
+    return response.result;
+  }
+  // Command execution
+  async execute(command) {
+    const url = `${this.url}/execute`;
+    const headers = this.buildHeaders();
+    const data = {
+      command: command.command,
+      sandbox_id: this.sandboxId,
+      timeout: command.timeout,
+      cwd: command.cwd,
+      env: command.env
+    };
+    try {
+      const response = await HttpUtils.post(
+        url,
+        headers,
+        data
+      );
+      if (response.status !== "Success") {
+        throw new Error(`Failed to execute command: ${JSON.stringify(response)}`);
+      }
+      return response.result;
+    } catch (e) {
+      throw new Error(`Failed to execute command: ${e}`);
+    }
+  }
+  // Session management
+  async createSession(request) {
+    const url = `${this.url}/create_session`;
+    const headers = this.buildHeaders();
+    const data = {
+      sandbox_id: this.sandboxId,
+      ...request
+    };
+    try {
+      const response = await HttpUtils.post(
+        url,
+        headers,
+        data
+      );
+      if (response.status !== "Success") {
+        throw new Error(`Failed to create session: ${JSON.stringify(response)}`);
+      }
+      return response.result;
+    } catch (e) {
+      throw new Error(`Failed to create session: ${e}`);
+    }
+  }
+  async closeSession(request) {
+    const url = `${this.url}/close_session`;
+    const headers = this.buildHeaders();
+    const data = {
+      sandbox_id: this.sandboxId,
+      ...request
+    };
+    try {
+      const response = await HttpUtils.post(
+        url,
+        headers,
+        data
+      );
+      if (response.status !== "Success") {
+        throw new Error(`Failed to close session: ${JSON.stringify(response)}`);
+      }
+      return response.result ?? {};
+    } catch (e) {
+      throw new Error(`Failed to close session: ${e}`);
+    }
+  }
+  // Run command in session
+  async arun(cmd, options = {}) {
+    const {
+      session,
+      mode = "normal",
+      waitTimeout = 300,
+      waitInterval = 10
+    } = options;
+    if (mode === "normal") {
+      return this.runInSession({ command: cmd, session: session ?? "default" });
+    }
+    return this.arunWithNohup(cmd, options);
+  }
+  async runInSession(action) {
+    const url = `${this.url}/run_in_session`;
+    const headers = this.buildHeaders();
+    const data = {
+      action_type: "bash",
+      session: action.session,
+      command: action.command,
+      sandbox_id: this.sandboxId,
+      timeout: action.timeout
+    };
+    try {
+      const response = await HttpUtils.post(
+        url,
+        headers,
+        data,
+        action.timeout
+      );
+      if (response.status !== "Success") {
+        throw new Error(`Failed to execute command: ${JSON.stringify(response)}`);
+      }
+      return response.result;
+    } catch (e) {
+      throw new Error(`Failed to run in session: ${e}`);
+    }
+  }
+  async arunWithNohup(cmd, options) {
+    const {
+      session,
+      waitTimeout = 300,
+      waitInterval = 10,
+      responseLimitedBytesInNohup,
+      ignoreOutput = false,
+      outputFile
+    } = options;
+    const timestamp = Date.now();
+    const tmpSession = session ?? `bash-${timestamp}`;
+    if (!session) {
+      await this.createSession({ session: tmpSession, startupSource: [], envEnable: false });
+    }
+    const tmpFile = outputFile ?? `/tmp/tmp_${timestamp}.out`;
+    const nohupCommand = `nohup ${cmd} < /dev/null > ${tmpFile} 2>&1 & echo __ROCK_PID_START__$!__ROCK_PID_END__;disown`;
+    const response = await this.runInSession({
+      command: nohupCommand,
+      session: tmpSession,
+      timeout: 30
+    });
+    if (response.exitCode !== 0) {
+      return response;
+    }
+    const pid = extractNohupPid(response.output);
+    if (!pid) {
+      return {
+        output: "Failed to submit command, nohup failed to extract PID",
+        exitCode: 1,
+        failureReason: "PID extraction failed",
+        expectString: ""
+      };
+    }
+    const success = await this.waitForProcessCompletion(pid, tmpSession, waitTimeout, waitInterval);
+    if (ignoreOutput) {
+      return {
+        output: `Command executed in nohup mode. Output file: ${tmpFile}`,
+        exitCode: success ? 0 : 1,
+        failureReason: success ? "" : "Process did not complete successfully",
+        expectString: ""
+      };
+    }
+    const readCmd = responseLimitedBytesInNohup ? `head -c ${responseLimitedBytesInNohup} ${tmpFile}` : `cat ${tmpFile}`;
+    const outputResult = await this.runInSession({
+      command: readCmd,
+      session: tmpSession
+    });
+    return {
+      output: outputResult.output,
+      exitCode: success ? 0 : 1,
+      failureReason: success ? "" : "Process did not complete successfully",
+      expectString: ""
+    };
+  }
+  async waitForProcessCompletion(pid, session, waitTimeout, waitInterval) {
+    const startTime = Date.now();
+    const checkInterval = Math.max(5, waitInterval);
+    const effectiveInterval = Math.min(checkInterval * 2, waitTimeout);
+    while (Date.now() - startTime < waitTimeout * 1e3) {
+      try {
+        await this.runInSession({
+          command: `kill -0 ${pid}`,
+          session,
+          timeout: effectiveInterval
+        });
+        await sleep(checkInterval * 1e3);
+      } catch {
+        return true;
+      }
+    }
+    return false;
+  }
+  // File operations
+  async write_file(request) {
+    const url = `${this.url}/write_file`;
+    const headers = this.buildHeaders();
+    const data = {
+      content: request.content,
+      path: request.path,
+      sandbox_id: this.sandboxId
+    };
+    const response = await HttpUtils.post(url, headers, data);
+    if (response.status !== "Success") {
+      return { success: false, message: `Failed to write file ${request.path}` };
+    }
+    return { success: true, message: `Successfully write content to file ${request.path}` };
+  }
+  async read_file(request) {
+    const url = `${this.url}/read_file`;
+    const headers = this.buildHeaders();
+    const data = {
+      path: request.path,
+      encoding: request.encoding,
+      errors: request.errors,
+      sandbox_id: this.sandboxId
+    };
+    const response = await HttpUtils.post(
+      url,
+      headers,
+      data
+    );
+    return { content: response.result?.content ?? "" };
+  }
+  // Upload
+  async upload(request) {
+    return this.uploadByPath(request.sourcePath, request.targetPath);
+  }
+  async uploadByPath(sourcePath, targetPath) {
+    const url = `${this.url}/upload`;
+    const headers = this.buildHeaders();
+    try {
+      const fs = await import('fs');
+      if (!fs.existsSync(sourcePath)) {
+        return { success: false, message: `File not found: ${sourcePath}` };
+      }
+      const fileBuffer = fs.readFileSync(sourcePath);
+      const fileName = sourcePath.split("/").pop() ?? "file";
+      const response = await HttpUtils.postMultipart(
+        url,
+        headers,
+        { target_path: targetPath, sandbox_id: this.sandboxId ?? "" },
+        { file: [fileName, fileBuffer, "application/octet-stream"] }
+      );
+      if (response.status !== "Success") {
+        return { success: false, message: "Upload failed" };
+      }
+      return { success: true, message: `Successfully uploaded file ${fileName} to ${targetPath}` };
+    } catch (e) {
+      return { success: false, message: `Upload failed: ${e}` };
+    }
+  }
+  // Close
+  async close() {
+    await this.stop();
+  }
+  toString() {
+    return `Sandbox(sandboxId=${this.sandboxId}, hostName=${this.hostName}, image=${this.config.image}, cluster=${this.cluster})`;
+  }
+};
+var SandboxGroup = class {
+  config;
+  sandboxList;
+  constructor(config = {}) {
+    this.config = createSandboxGroupConfig(config);
+    this.sandboxList = Array.from(
+      { length: this.config.size },
+      () => new Sandbox(this.config)
+    );
+  }
+  getSandboxList() {
+    return this.sandboxList;
+  }
+  async start() {
+    const concurrency = this.config.startConcurrency;
+    const retryTimes = this.config.startRetryTimes;
+    const startSandbox = async (index, sandbox) => {
+      logger8.info(`Starting sandbox ${index} with ${sandbox.getConfig().image}...`);
+      for (let attempt = 0; attempt < retryTimes; attempt++) {
+        try {
+          await sandbox.start();
+          return;
+        } catch (e) {
+          if (attempt === retryTimes - 1) {
+            logger8.error(`Failed to start sandbox after ${retryTimes} attempts: ${e}`);
+            throw e;
+          }
+          logger8.warn(`Failed to start sandbox (attempt ${attempt + 1}/${retryTimes}): ${e}, retrying...`);
+          await sleep(1e3);
+        }
+      }
+    };
+    for (let i = 0; i < this.sandboxList.length; i += concurrency) {
+      const batch = this.sandboxList.slice(i, i + concurrency);
+      const promises = batch.map((sandbox, idx) => startSandbox(i + idx, sandbox));
+      await Promise.all(promises);
+    }
+    logger8.info(`Successfully started ${this.sandboxList.length} sandboxes`);
+  }
+  async stop() {
+    const promises = this.sandboxList.map((sandbox) => sandbox.stop());
+    await Promise.allSettled(promises);
+    logger8.info(`Stopped ${this.sandboxList.length} sandboxes`);
+  }
+};
+var logger9 = initLogger("rock.model.client");
+var REQUEST_START_MARKER = "__REQUEST_START__";
+var REQUEST_END_MARKER = "__REQUEST_END__";
+var RESPONSE_START_MARKER = "__RESPONSE_START__";
+var RESPONSE_END_MARKER = "__RESPONSE_END__";
+var SESSION_END_MARKER = "__SESSION_END__";
+var ModelClient = class {
+  logFile;
+  constructor(config) {
+    this.logFile = config?.logFileName ?? envVars.ROCK_MODEL_SERVICE_DATA_DIR + "/model.log";
+  }
+  /**
+   * Anti-call LLM - input is response, output is next request
+   */
+  async antiCallLlm(index, lastResponse) {
+    if (index < 0) {
+      throw new Error("index must be greater than 0");
+    }
+    if (index === 0) {
+      if (lastResponse !== void 0) {
+        throw new Error("lastResponse must be undefined when index is 0");
+      }
+      await this.waitForFirstRequest();
+      return this.popRequest(index + 1);
+    }
+    if (lastResponse === void 0) {
+      throw new Error("lastResponse must not be undefined when index is greater than 0");
+    }
+    await this.pushResponse(index, lastResponse);
+    return this.popRequest(index + 1);
+  }
+  /**
+   * Push response to log file
+   */
+  async pushResponse(index, lastResponse) {
+    const content = this.constructResponse(lastResponse, index);
+    const lastResponseLine = await this.readLastResponseLine();
+    if (lastResponseLine === null) {
+      this.appendResponse(content);
+      return;
+    }
+    const { meta } = this.parseResponseLine(lastResponseLine);
+    const lastResponseIndex = meta.index;
+    if (index < lastResponseIndex) {
+      throw new Error(`index ${index} must not be smaller than last_response_index ${lastResponseIndex}`);
+    }
+    if (index === lastResponseIndex) {
+      logger9.debug(`response index ${index} already exists, skip`);
+      return;
+    }
+    this.appendResponse(content);
+  }
+  /**
+   * Pop request from log file
+   */
+  async popRequest(index) {
+    while (true) {
+      const lastRequestLine = await this.readLastRequestLine();
+      const { requestJson, meta } = this.parseRequestLine(lastRequestLine);
+      if (requestJson === SESSION_END_MARKER) {
+        return SESSION_END_MARKER;
+      }
+      if (meta.index === index) {
+        return requestJson;
+      }
+      logger9.debug(`Last request is not the index ${index} we want, waiting...`);
+      await this.sleep(1e3);
+    }
+  }
+  /**
+   * Wait for first request
+   */
+  async waitForFirstRequest() {
+    while (true) {
+      if (!existsSync(this.logFile)) {
+        logger9.debug(`Log file ${this.logFile} not found, waiting...`);
+        await this.sleep(1e3);
+        continue;
+      }
+      const content = readFileSync(this.logFile, "utf-8");
+      const lines = content.split("\n").filter((l) => l.trim());
+      if (lines.length === 0) {
+        logger9.debug(`Log file ${this.logFile} is empty, waiting for the first request...`);
+        await this.sleep(1e3);
+        continue;
+      }
+      return;
+    }
+  }
+  parseRequestLine(lineContent) {
+    if (lineContent.includes(SESSION_END_MARKER)) {
+      return { requestJson: SESSION_END_MARKER, meta: {} };
+    }
+    const parts = lineContent.split(REQUEST_END_MARKER);
+    const metaJson = parts[1] ?? "";
+    const requestJson = parts[0]?.split(REQUEST_START_MARKER)[1] ?? "";
+    const meta = JSON.parse(metaJson);
+    return { requestJson, meta };
+  }
+  parseResponseLine(lineContent) {
+    const parts = lineContent.split(RESPONSE_END_MARKER);
+    const metaJson = parts[1] ?? "";
+    const responseJson = parts[0]?.split(RESPONSE_START_MARKER)[1] ?? "";
+    const meta = JSON.parse(metaJson);
+    return { responseJson, meta };
+  }
+  async readLastRequestLine() {
+    const content = readFileSync(this.logFile, "utf-8");
+    const lines = content.split("\n").filter((l) => l.trim());
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const line = lines[i];
+      if (line && (line.includes(REQUEST_START_MARKER) || line.includes(SESSION_END_MARKER))) {
+        return line;
+      }
+    }
+    throw new Error(`No request found in log file ${this.logFile}`);
+  }
+  async readLastResponseLine() {
+    const content = readFileSync(this.logFile, "utf-8");
+    const lines = content.split("\n").filter((l) => l.trim());
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const line = lines[i];
+      if (line && line.includes(RESPONSE_START_MARKER)) {
+        return line;
+      }
+    }
+    return null;
+  }
+  appendResponse(content) {
+    appendFileSync(this.logFile, content);
+  }
+  constructResponse(lastResponse, index) {
+    const meta = {
+      timestamp: Date.now(),
+      index
+    };
+    const metaJson = JSON.stringify(meta);
+    return `${RESPONSE_START_MARKER}${lastResponse}${RESPONSE_END_MARKER}${metaJson}
+`;
+  }
+  sleep(ms) {
+    return new Promise((resolve3) => setTimeout(resolve3, ms));
+  }
+};
+initLogger("rock.model.service");
+var ModelService = class {
+  process = null;
+  /**
+   * Start sandbox service
+   */
+  startSandboxService(config = {}) {
+    const {
+      modelServiceType = "local",
+      configFile,
+      host,
+      port,
+      proxyBaseUrl,
+      retryableStatusCodes,
+      requestTimeout
+    } = config;
+    const cmd = ["node", "main.js", "--type", modelServiceType];
+    if (configFile) {
+      cmd.push("--config-file", configFile);
+    }
+    if (host) {
+      cmd.push("--host", host);
+    }
+    if (port) {
+      cmd.push("--port", String(port));
+    }
+    if (proxyBaseUrl) {
+      cmd.push("--proxy-base-url", proxyBaseUrl);
+    }
+    if (retryableStatusCodes) {
+      cmd.push("--retryable-status-codes", retryableStatusCodes);
+    }
+    if (requestTimeout) {
+      cmd.push("--request-timeout", String(requestTimeout));
+    }
+    const command = cmd[0] ?? "node";
+    this.process = spawn(command, cmd.slice(1), {
+      cwd: resolve(__dirname, "server"),
+      stdio: "inherit"
+    });
+    if (!this.process) {
+      throw new Error("Failed to spawn model service process");
+    }
+    return this.process;
+  }
+  /**
+   * Start and wait for service to be available
+   */
+  async start(config = {}) {
+    const { timeoutSeconds = 30, ...serviceConfig } = config;
+    const process2 = this.startSandboxService(serviceConfig);
+    const pid = process2.pid?.toString();
+    if (!pid) {
+      throw new Error("Failed to start model service");
+    }
+    const success = await this.waitServiceAvailable(
+      timeoutSeconds,
+      serviceConfig.host ?? "127.0.0.1",
+      serviceConfig.port ?? 8080
+    );
+    if (!success) {
+      await this.stop(pid);
+      throw new Error("Model service start failed");
+    }
+    return pid;
+  }
+  /**
+   * Start watching agent
+   */
+  async startWatchAgent(agentPid, host = "127.0.0.1", port = 8080) {
+    await axios3.post(`http://${host}:${port}/v1/agent/watch`, { pid: agentPid });
+  }
+  /**
+   * Stop service
+   */
+  async stop(pid) {
+    const { execSync } = await import('child_process');
+    try {
+      execSync(`kill -9 ${pid}`);
+    } catch {
+    }
+  }
+  /**
+   * Wait for service to be available
+   */
+  async waitServiceAvailable(timeoutSeconds, host, port) {
+    const startTime = Date.now();
+    while ((Date.now() - startTime) / 1e3 < timeoutSeconds) {
+      try {
+        await axios3.get(`http://${host}:${port}/health`);
+        return true;
+      } catch {
+        await this.sleep(1e3);
+      }
+    }
+    return false;
+  }
+  sleep(ms) {
+    return new Promise((resolve3) => setTimeout(resolve3, ms));
+  }
+};
+
+// src/index.ts
+var VERSION = "1.2.1";
+
+export { BadRequestRockError, BashActionSchema, ChmodRequestSchema, ChmodResponseSchema, ChownRequestSchema, ChownResponseSchema, CloseResponseSchema, CloseSessionRequestSchema, CloseSessionResponseSchema, Codes, CommandResponseSchema, CommandRockError, CommandSchema, Constants, CreateBashSessionRequestSchema, CreateSessionResponseSchema, Deploy, EnvHubClient, EnvHubClientConfigSchema, EnvHubError, ExecuteBashSessionResponseSchema, HttpUtils, InternalServerRockError, InvalidParameterRockException, IsAliveResponseSchema, LinuxFileSystem, LinuxRemoteUser, ModelClient, ModelService, Network, ObservationSchema, OssSetupResponseSchema, PID_PREFIX, PID_SUFFIX, Process, ReadFileRequestSchema, ReadFileResponseSchema, ReasonPhrases, RockEnv, RockEnvInfoSchema, RockException, RunMode, Sandbox, SandboxConfigSchema, SandboxGroup, SandboxGroupConfigSchema, SandboxResponseSchema, SandboxStatusResponseSchema, SpeedupType, UploadRequestSchema, UploadResponseSchema, VERSION, WriteFileRequestSchema, WriteFileResponseSchema, arunWithRetry, createRockEnvInfo, createSandboxConfig, createSandboxGroupConfig, deprecated, deprecatedClass, extractNohupPid as extractNohupPidFromSandbox, fromRockException, getEnv, getReasonPhrase, getRequiredEnv, isBrowser, isClientError, isCommandError, isEnvSet, isError, isNode, isServerError, isSuccess, make, raiseForCode, retryAsync, rockEnvInfoToDict, sleep, withRetry, withTimeLogging };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map