@codmir/sdk 0.1.1 → 0.1.2

package/dist/serverless/index.js

@@ -0,0 +1,1213 @@
+import "../chunk-MLKGABMK.js";
+
+// src/serverless/execution.ts
+var POOL_CONFIG = {
+  modal: {
+    maxTimeout: 3600,
+    // 1 hour
+    coldStartMs: 300,
+    costPerMinute: 2,
+    gpuSupport: true,
+    carbonScore: 60
+  },
+  fargate: {
+    maxTimeout: 86400,
+    // 24 hours
+    coldStartMs: 6e4,
+    costPerMinute: 1,
+    gpuSupport: false,
+    carbonScore: 50
+  },
+  github: {
+    maxTimeout: 21600,
+    // 6 hours
+    coldStartMs: 3e4,
+    costPerMinute: 0,
+    gpuSupport: false,
+    carbonScore: 70
+  },
+  community: {
+    maxTimeout: 3600,
+    coldStartMs: 5e3,
+    costPerMinute: 0.5,
+    gpuSupport: false,
+    carbonScore: 80
+  },
+  local: {
+    maxTimeout: Infinity,
+    coldStartMs: 0,
+    costPerMinute: 0,
+    gpuSupport: false,
+    carbonScore: 100
+  },
+  auto: {
+    maxTimeout: Infinity,
+    coldStartMs: 0,
+    costPerMinute: 0,
+    gpuSupport: true,
+    carbonScore: 50
+  }
+};
+function selectPool(config, grace) {
+  if (config.pool && config.pool !== "auto") {
+    return config.pool;
+  }
+  const timeout = config.timeout || 300;
+  const needsGpu = !!config.gpu;
+  const preferGreen = grace?.preferGreen ?? false;
+  if (needsGpu) {
+    return "modal";
+  }
+  if (timeout > 3600) {
+    return "fargate";
+  }
+  if (grace?.maxBudget !== void 0 && grace.maxBudget < 10) {
+    return "github";
+  }
+  if (preferGreen) {
+    return timeout > 3600 ? "fargate" : "github";
+  }
+  return "modal";
+}
+async function execute(request) {
+  const startTime = Date.now();
+  const pool = selectPool(request.config, request.grace);
+  const executionId = `exec_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+  console.log(`[codmir] Executing ${request.functionName} on ${pool}`);
+  try {
+    let result;
+    switch (pool) {
+      case "local":
+        throw new Error("Use executeLocal for local execution");
+      case "modal":
+        result = await executeOnModal(request);
+        break;
+      case "fargate":
+        result = await executeOnFargate(request);
+        break;
+      case "github":
+        result = await executeOnGitHub(request);
+        break;
+      case "community":
+        result = await executeOnCommunity(request);
+        break;
+      default:
+        result = await executeOnModal(request);
+    }
+    const durationMs = Date.now() - startTime;
+    const creditsUsed = Math.ceil(durationMs / 6e4) * POOL_CONFIG[pool].costPerMinute;
+    return {
+      id: executionId,
+      status: "completed",
+      result,
+      metrics: {
+        durationMs,
+        coldStartMs: POOL_CONFIG[pool].coldStartMs,
+        creditsUsed,
+        carbonFootprint: estimateCarbonFootprint(durationMs, pool),
+        pool
+      }
+    };
+  } catch (error) {
+    return {
+      id: executionId,
+      status: "failed",
+      error: error instanceof Error ? error.message : "Unknown error",
+      metrics: {
+        durationMs: Date.now() - startTime,
+        creditsUsed: 0,
+        pool
+      }
+    };
+  }
+}
+async function executeAsync(request) {
+  const executionId = `exec_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+  const pool = selectPool(request.config, request.grace);
+  console.log(`[codmir] Spawning async execution ${executionId} on ${pool}`);
+  setImmediate(async () => {
+    try {
+      await execute(request);
+    } catch (error) {
+      console.error(`[codmir] Async execution ${executionId} failed:`, error);
+    }
+  });
+  return executionId;
+}
+async function executeLocal(handler, args) {
+  return handler(...args);
+}
+async function executeOnModal(request) {
+  const apiUrl = process.env.CODMIR_API_URL || "https://codmir.com";
+  const apiKey = process.env.CODMIR_API_KEY;
+  if (!apiKey) {
+    throw new Error("CODMIR_API_KEY is required for remote execution");
+  }
+  const response = await fetch(`${apiUrl}/api/cloud/jobs`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      pool: "modal",
+      appName: request.appName,
+      functionName: request.functionName,
+      args: request.args,
+      config: request.config,
+      grace: request.grace
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`Modal execution failed: ${response.statusText}`);
+  }
+  const data = await response.json();
+  if (request.wait !== false) {
+    return await pollForResult(data.jobId);
+  }
+  return data.jobId;
+}
+async function executeOnFargate(request) {
+  const apiUrl = process.env.CODMIR_API_URL || "https://codmir.com";
+  const apiKey = process.env.CODMIR_API_KEY;
+  if (!apiKey) {
+    throw new Error("CODMIR_API_KEY is required for remote execution");
+  }
+  const response = await fetch(`${apiUrl}/api/cloud/jobs`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      pool: "fargate",
+      appName: request.appName,
+      functionName: request.functionName,
+      args: request.args,
+      config: request.config,
+      grace: request.grace
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`Fargate execution failed: ${response.statusText}`);
+  }
+  const data = await response.json();
+  if (request.wait !== false) {
+    return await pollForResult(data.jobId);
+  }
+  return data.jobId;
+}
+async function executeOnGitHub(request) {
+  const apiUrl = process.env.CODMIR_API_URL || "https://codmir.com";
+  const apiKey = process.env.CODMIR_API_KEY;
+  if (!apiKey) {
+    throw new Error("CODMIR_API_KEY is required for remote execution");
+  }
+  const response = await fetch(`${apiUrl}/api/cloud/jobs`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      pool: "github",
+      appName: request.appName,
+      functionName: request.functionName,
+      args: request.args,
+      config: request.config,
+      grace: request.grace
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`GitHub execution failed: ${response.statusText}`);
+  }
+  const data = await response.json();
+  if (request.wait !== false) {
+    return await pollForResult(data.jobId);
+  }
+  return data.jobId;
+}
+async function executeOnCommunity(request) {
+  return executeOnModal(request);
+}
+async function pollForResult(jobId) {
+  const apiUrl = process.env.CODMIR_API_URL || "https://codmir.com";
+  const apiKey = process.env.CODMIR_API_KEY;
+  const maxWait = 3e5;
+  const pollInterval = 1e3;
+  const startTime = Date.now();
+  while (Date.now() - startTime < maxWait) {
+    const response = await fetch(`${apiUrl}/api/cloud/jobs/${jobId}`, {
+      headers: {
+        "Authorization": `Bearer ${apiKey}`
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to get job status: ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (data.status === "COMPLETED") {
+      return data.output;
+    }
+    if (data.status === "FAILED") {
+      throw new Error(data.error || "Execution failed");
+    }
+    if (data.status === "CANCELLED") {
+      throw new Error("Execution was cancelled");
+    }
+    await sleep(pollInterval);
+  }
+  throw new Error("Execution timed out waiting for result");
+}
+function estimateCarbonFootprint(durationMs, pool) {
+  const baseEmission = 0.5;
+  const minutes = durationMs / 6e4;
+  const carbonScore = POOL_CONFIG[pool].carbonScore;
+  const multiplier = 2 - carbonScore / 100;
+  return baseEmission * minutes * multiplier;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/serverless/function.ts
+var CodmirFunction = class {
+  name;
+  config;
+  app;
+  handler;
+  executionCount = 0;
+  constructor(app2, config, handler) {
+    this.app = app2;
+    this.config = config;
+    this.handler = handler;
+    this.name = config.name || this.generateName();
+  }
+  generateName() {
+    return `${this.app.name}_fn_${Date.now().toString(36)}`;
+  }
+  /**
+   * Execute the function (auto-selects local/remote based on environment).
+   */
+  async call(...args) {
+    if (this.shouldRunLocally()) {
+      return this.local(...args);
+    }
+    return this.remote(...args);
+  }
+  /**
+   * Execute locally (for development).
+   */
+  async local(...args) {
+    const startTime = Date.now();
+    this.executionCount++;
+    try {
+      const result = await executeLocal(this.handler, args);
+      console.log(`[codmir] ${this.name} completed locally in ${Date.now() - startTime}ms`);
+      return result;
+    } catch (error) {
+      console.error(`[codmir] ${this.name} failed locally:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Execute remotely in the cloud.
+   */
+  async remote(...args) {
+    const result = await execute({
+      appName: this.app.name,
+      functionName: this.name,
+      args,
+      config: this.config,
+      grace: this.config.grace
+    });
+    if (result.status === "completed" && result.result !== void 0) {
+      return result.result;
+    }
+    if (result.status === "failed") {
+      throw new Error(result.error || "Remote execution failed");
+    }
+    throw new Error(`Unexpected execution status: ${result.status}`);
+  }
+  /**
+   * Execute asynchronously and return execution ID.
+   */
+  async spawn(...args) {
+    const executionId = await executeAsync({
+      appName: this.app.name,
+      functionName: this.name,
+      args,
+      config: this.config,
+      grace: this.config.grace
+    });
+    return executionId;
+  }
+  /**
+   * Execute with streaming results.
+   */
+  async *stream(...args) {
+    const executionId = await this.spawn(...args);
+    yield { type: "started", executionId };
+    yield { type: "progress", percent: 0, message: "Starting..." };
+    try {
+      const result = await this.remote(...args);
+      yield { type: "progress", percent: 100, message: "Completed" };
+      yield { type: "completed", result };
+    } catch (error) {
+      yield { type: "failed", error: error instanceof Error ? error.message : "Unknown error" };
+    }
+  }
+  /**
+   * Execute in batch with multiple inputs.
+   */
+  async map(inputs, config = {}) {
+    const { maxConcurrency = 10, continueOnError = true } = config;
+    const successful = [];
+    const failed = [];
+    const startTime = Date.now();
+    let totalCredits = 0;
+    for (let i = 0; i < inputs.length; i += maxConcurrency) {
+      const batch = inputs.slice(i, i + maxConcurrency);
+      const promises = batch.map(async (input, batchIndex) => {
+        const index = i + batchIndex;
+        try {
+          const result = await this.call(input);
+          successful.push({ index, result });
+        } catch (error) {
+          if (!continueOnError) throw error;
+          failed.push({
+            index,
+            error: error instanceof Error ? error.message : "Unknown error"
+          });
+        }
+      });
+      await Promise.all(promises);
+      if (config.onProgress) {
+        config.onProgress(successful.length + failed.length, inputs.length);
+      }
+    }
+    return {
+      total: inputs.length,
+      successful,
+      failed,
+      metrics: {
+        totalDurationMs: Date.now() - startTime,
+        totalCreditsUsed: totalCredits,
+        totalCarbonFootprint: 0
+        // Would be calculated from execution metrics
+      }
+    };
+  }
+  /**
+   * Execute with specific options.
+   */
+  async withOptions(options, ...args) {
+    const mergedConfig = {
+      ...this.config,
+      timeout: options.timeout ?? this.config.timeout,
+      pool: options.pool ?? this.config.pool,
+      grace: { ...this.config.grace, ...options.grace }
+    };
+    const result = await execute({
+      appName: this.app.name,
+      functionName: this.name,
+      args,
+      config: mergedConfig,
+      grace: mergedConfig.grace,
+      wait: options.wait ?? true,
+      callbackUrl: options.callbackUrl
+    });
+    if (result.status === "completed" && result.result !== void 0) {
+      return result.result;
+    }
+    throw new Error(result.error || `Execution ${result.status}`);
+  }
+  /**
+   * Get execution status by ID.
+   */
+  async getStatus(executionId) {
+    return {
+      id: executionId,
+      status: "pending",
+      metrics: {
+        durationMs: 0,
+        creditsUsed: 0,
+        pool: "auto"
+      }
+    };
+  }
+  /**
+   * Cancel an execution.
+   */
+  async cancel(executionId) {
+    console.log(`[codmir] Cancelling execution: ${executionId}`);
+  }
+  /**
+   * Check if function should run locally.
+   */
+  shouldRunLocally() {
+    const env = process.env.NODE_ENV || "development";
+    const forceRemote = process.env.CODMIR_FORCE_REMOTE === "true";
+    const forceLocal = process.env.CODMIR_FORCE_LOCAL === "true";
+    if (forceRemote) return false;
+    if (forceLocal) return true;
+    if (env === "development") return true;
+    return false;
+  }
+  /**
+   * Make the function callable directly.
+   */
+  [/* @__PURE__ */ Symbol.for("nodejs.util.promisify.custom")](...args) {
+    return this.call(...args);
+  }
+};
+function createFunction(app2, config, handler) {
+  return new CodmirFunction(app2, config, handler);
+}
+
+// src/serverless/sandbox.ts
+var CodmirSandbox = class {
+  name;
+  config;
+  app;
+  sandboxId;
+  status = "created";
+  tunnelUrl;
+  constructor(app2, config) {
+    this.app = app2;
+    this.config = config;
+    this.name = config.name || `sandbox_${Date.now().toString(36)}`;
+  }
+  /**
+   * Spawn the sandbox environment.
+   */
+  async spawn() {
+    if (this.status !== "created") {
+      throw new Error(`Sandbox is already ${this.status}`);
+    }
+    this.status = "spawning";
+    console.log(`[codmir] Spawning sandbox: ${this.name}`);
+    this.sandboxId = `sb_${Date.now().toString(36)}`;
+    this.status = "running";
+    if (this.config.webAccess) {
+      this.tunnelUrl = `https://${this.sandboxId}.sandbox.codmir.run`;
+      console.log(`[codmir] Tunnel available at: ${this.tunnelUrl}`);
+    }
+    console.log(`[codmir] Sandbox ${this.name} is ready`);
+    return this;
+  }
+  /**
+   * Execute a command in the sandbox.
+   */
+  async exec(command, options = {}) {
+    this.ensureRunning();
+    const startTime = Date.now();
+    console.log(`[codmir] exec: ${command}`);
+    return {
+      stdout: "",
+      stderr: "",
+      exitCode: 0,
+      durationMs: Date.now() - startTime
+    };
+  }
+  /**
+   * Execute a command and stream output.
+   */
+  async *execStream(command) {
+    this.ensureRunning();
+    yield { type: "started", executionId: `exec_${Date.now()}` };
+    yield { type: "log", message: `$ ${command}`, level: "info" };
+    yield { type: "completed", result: { exitCode: 0 } };
+  }
+  /**
+   * Write a file to the sandbox.
+   */
+  async writeFile(path, content) {
+    this.ensureRunning();
+    console.log(`[codmir] writeFile: ${path} (${content.length} bytes)`);
+  }
+  /**
+   * Read a file from the sandbox.
+   */
+  async readFile(path) {
+    this.ensureRunning();
+    console.log(`[codmir] readFile: ${path}`);
+    return "";
+  }
+  /**
+   * List files in a directory.
+   */
+  async listFiles(path = "/") {
+    this.ensureRunning();
+    const result = await this.exec(`ls -la ${path}`);
+    return result.stdout.split("\n").filter(Boolean);
+  }
+  /**
+   * Open a tunnel for web access.
+   */
+  async tunnel(port) {
+    this.ensureRunning();
+    if (!this.config.webAccess) {
+      throw new Error("Web access not enabled for this sandbox");
+    }
+    const url = `https://${this.sandboxId}-${port}.sandbox.codmir.run`;
+    console.log(`[codmir] Tunnel opened: ${url} -> localhost:${port}`);
+    return url;
+  }
+  /**
+   * Get the tunnel URL (if web access enabled).
+   */
+  getTunnelUrl() {
+    return this.tunnelUrl;
+  }
+  /**
+   * Check if sandbox is running.
+   */
+  isRunning() {
+    return this.status === "running";
+  }
+  /**
+   * Get sandbox status.
+   */
+  getStatus() {
+    return this.status;
+  }
+  /**
+   * Terminate the sandbox.
+   */
+  async terminate() {
+    if (this.status === "terminated") {
+      return;
+    }
+    console.log(`[codmir] Terminating sandbox: ${this.name}`);
+    this.status = "terminated";
+    this.sandboxId = void 0;
+    this.tunnelUrl = void 0;
+  }
+  /**
+   * Keep sandbox alive (extend timeout).
+   */
+  async keepAlive(durationSeconds = 300) {
+    this.ensureRunning();
+    console.log(`[codmir] Extending sandbox timeout by ${durationSeconds}s`);
+  }
+  /**
+   * Create a checkpoint of the current state.
+   */
+  async checkpoint(name) {
+    this.ensureRunning();
+    const checkpointId = `cp_${Date.now().toString(36)}`;
+    console.log(`[codmir] Created checkpoint: ${checkpointId}`);
+    return checkpointId;
+  }
+  /**
+   * Restore from a checkpoint.
+   */
+  async restore(checkpointId) {
+    this.ensureRunning();
+    console.log(`[codmir] Restoring from checkpoint: ${checkpointId}`);
+  }
+  ensureRunning() {
+    if (this.status !== "running") {
+      throw new Error(`Sandbox is not running (status: ${this.status})`);
+    }
+  }
+};
+function createSandbox(app2, config) {
+  return new CodmirSandbox(app2, config);
+}
+
+// src/serverless/app.ts
+var CodmirApp = class {
+  name;
+  config;
+  functions = /* @__PURE__ */ new Map();
+  sandboxes = /* @__PURE__ */ new Map();
+  deployed = false;
+  constructor(config) {
+    this.name = config.name;
+    this.config = {
+      grace: { enabled: true, preferGreen: false },
+      ...config
+    };
+  }
+  /**
+   * Create a serverless function.
+   * 
+   * @example
+   * ```typescript
+   * const processData = app.function({ cpu: 2, timeout: 300 })(
+   *   async (data: string) => {
+   *     return data.toUpperCase();
+   *   }
+   * );
+   * ```
+   */
+  function(config = {}) {
+    return (handler) => {
+      const mergedConfig = {
+        ...config,
+        image: config.image || this.config.image,
+        secrets: [...this.config.secrets || [], ...config.secrets || []],
+        volumes: { ...this.config.volumes, ...config.volumes },
+        grace: { ...this.config.grace, ...config.grace }
+      };
+      const fn2 = createFunction(this, mergedConfig, handler);
+      this.functions.set(fn2.name, fn2);
+      return fn2;
+    };
+  }
+  /**
+   * Create a sandbox for interactive execution.
+   * 
+   * @example
+   * ```typescript
+   * const sandbox = await app.sandbox({ image: 'python:3.11' }).spawn();
+   * await sandbox.exec('pip install numpy');
+   * const result = await sandbox.exec('python -c "import numpy; print(numpy.__version__)"');
+   * await sandbox.terminate();
+   * ```
+   */
+  sandbox(config) {
+    const mergedConfig = {
+      ...config,
+      secrets: [...this.config.secrets || [], ...config.secrets || []],
+      volumes: { ...this.config.volumes, ...config.volumes },
+      grace: { ...this.config.grace, ...config.grace }
+    };
+    const sandbox = createSandbox(this, mergedConfig);
+    this.sandboxes.set(sandbox.name, sandbox);
+    return sandbox;
+  }
+  /**
+   * Create a scheduled function (cron).
+   */
+  cron(schedule, config = {}) {
+    return this.function({ ...config, schedule });
+  }
+  /**
+   * Create a web endpoint function.
+   */
+  webEndpoint(config = {}) {
+    return this.function({ ...config });
+  }
+  /**
+   * Deploy the app to Codmir cloud.
+   */
+  async deploy() {
+    if (this.deployed) {
+      throw new Error(`App ${this.name} is already deployed`);
+    }
+    const manifest = {
+      name: this.name,
+      config: this.config,
+      functions: Array.from(this.functions.entries()).map(([name, fn2]) => ({
+        name,
+        config: fn2.config
+      }))
+    };
+    console.log(`[codmir] Deploying app: ${this.name}`);
+    console.log(`[codmir] Functions: ${this.functions.size}`);
+    this.deployed = true;
+    return {
+      url: `https://${this.name}.codmir.run`,
+      functions: Array.from(this.functions.keys())
+    };
+  }
+  /**
+   * Get a registered function by name.
+   */
+  getFunction(name) {
+    return this.functions.get(name);
+  }
+  /**
+   * List all registered functions.
+   */
+  listFunctions() {
+    return Array.from(this.functions.keys());
+  }
+  /**
+   * Update Grace configuration.
+   */
+  withGrace(grace) {
+    this.config.grace = { ...this.config.grace, ...grace };
+    return this;
+  }
+  /**
+   * Serve the app locally for development.
+   */
+  async serve(port = 8e3) {
+    console.log(`[codmir] Starting local server on port ${port}`);
+    console.log(`[codmir] Functions available:`);
+    for (const name of this.functions.keys()) {
+      console.log(`  - ${name}: http://localhost:${port}/${name}`);
+    }
+  }
+};
+function createApp(config) {
+  return new CodmirApp(config);
+}
+
+// src/serverless/image.ts
+var CodmirImage = class {
+  config;
+  constructor(config) {
+    if (typeof config === "string") {
+      this.config = { base: config };
+    } else {
+      this.config = config;
+    }
+  }
+  /**
+   * Install Python packages via pip.
+   */
+  pip(...packages) {
+    this.config.pythonPackages = [
+      ...this.config.pythonPackages || [],
+      ...packages
+    ];
+    return this;
+  }
+  /**
+   * Install Python packages from requirements.txt.
+   */
+  pipRequirements(path) {
+    this.config.pipRequirements = path;
+    return this;
+  }
+  /**
+   * Install system packages via apt-get.
+   */
+  apt(...packages) {
+    this.config.systemPackages = [
+      ...this.config.systemPackages || [],
+      ...packages
+    ];
+    return this;
+  }
+  /**
+   * Run a command during image build.
+   */
+  run(command) {
+    this.config.runCommands = [
+      ...this.config.runCommands || [],
+      command
+    ];
+    return this;
+  }
+  /**
+   * Copy files into the image.
+   */
+  copy(from, to) {
+    this.config.copyFiles = [
+      ...this.config.copyFiles || [],
+      { from, to }
+    ];
+    return this;
+  }
+  /**
+   * Set environment variables.
+   */
+  env(vars) {
+    this.config.env = {
+      ...this.config.env,
+      ...vars
+    };
+    return this;
+  }
+  /**
+   * Set working directory.
+   */
+  workdir(path) {
+    this.config.workdir = path;
+    return this;
+  }
+  /**
+   * Get the image configuration.
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Generate Dockerfile content.
+   */
+  toDockerfile() {
+    const lines = [];
+    lines.push(`FROM ${this.config.base}`);
+    lines.push("");
+    if (this.config.systemPackages?.length) {
+      lines.push("RUN apt-get update && apt-get install -y \\");
+      lines.push(`    ${this.config.systemPackages.join(" \\\n    ")} \\`);
+      lines.push("    && rm -rf /var/lib/apt/lists/*");
+      lines.push("");
+    }
+    if (this.config.workdir) {
+      lines.push(`WORKDIR ${this.config.workdir}`);
+      lines.push("");
+    }
+    if (this.config.copyFiles?.length) {
+      for (const { from, to } of this.config.copyFiles) {
+        lines.push(`COPY ${from} ${to}`);
+      }
+      lines.push("");
+    }
+    if (this.config.pipRequirements) {
+      lines.push(`COPY ${this.config.pipRequirements} /tmp/requirements.txt`);
+      lines.push("RUN pip install --no-cache-dir -r /tmp/requirements.txt");
+      lines.push("");
+    }
+    if (this.config.pythonPackages?.length) {
+      lines.push(`RUN pip install --no-cache-dir ${this.config.pythonPackages.join(" ")}`);
+      lines.push("");
+    }
+    if (this.config.runCommands?.length) {
+      for (const cmd of this.config.runCommands) {
+        lines.push(`RUN ${cmd}`);
+      }
+      lines.push("");
+    }
+    if (this.config.env) {
+      for (const [key, value] of Object.entries(this.config.env)) {
+        lines.push(`ENV ${key}="${value}"`);
+      }
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+};
+function createImage(config) {
+  return new CodmirImage(config);
+}
+
+// src/serverless/volume.ts
+var CodmirVolume = class {
+  name;
+  config;
+  constructor(config) {
+    this.name = config.name;
+    this.config = {
+      size: 10,
+      // Default 10GB
+      ...config
+    };
+  }
+  /**
+   * Get the volume mount path.
+   */
+  getPath() {
+    return `/volumes/${this.name}`;
+  }
+  /**
+   * Create the volume in the cloud.
+   */
+  async create() {
+    console.log(`[codmir] Creating volume: ${this.name} (${this.config.size}GB)`);
+  }
+  /**
+   * Delete the volume.
+   */
+  async delete() {
+    console.log(`[codmir] Deleting volume: ${this.name}`);
+  }
+  /**
+   * Get volume usage statistics.
+   */
+  async stats() {
+    return {
+      usedBytes: 0,
+      totalBytes: (this.config.size || 10) * 1024 * 1024 * 1024
+    };
+  }
+  /**
+   * List files in the volume.
+   */
+  async listFiles(path = "/") {
+    return [];
+  }
+  /**
+   * Upload a file to the volume.
+   */
+  async upload(localPath, remotePath) {
+    console.log(`[codmir] Uploading ${localPath} to ${this.name}:${remotePath}`);
+  }
+  /**
+   * Download a file from the volume.
+   */
+  async download(remotePath, localPath) {
+    console.log(`[codmir] Downloading ${this.name}:${remotePath} to ${localPath}`);
+  }
+};
+function createVolume(config) {
+  return new CodmirVolume(config);
+}
+
+// src/serverless/secret.ts
+var CodmirSecret = class {
+  name;
+  config;
+  constructor(config) {
+    if (typeof config === "string") {
+      this.name = config;
+      this.config = { name: config };
+    } else {
+      this.name = config.name;
+      this.config = config;
+    }
+  }
+  /**
+   * Get the environment variable name.
+   */
+  getEnvVar() {
+    return this.config.envVar || this.name;
+  }
+  /**
+   * Set the secret value (for initial setup).
+   */
+  async set(value) {
+    console.log(`[codmir] Setting secret: ${this.name}`);
+  }
+  /**
+   * Delete the secret.
+   */
+  async delete() {
+    console.log(`[codmir] Deleting secret: ${this.name}`);
+  }
+  /**
+   * Check if the secret exists.
+   */
+  async exists() {
+    return false;
+  }
+  /**
+   * Get secret metadata (not the value).
+   */
+  async metadata() {
+    return {
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+};
+function createSecret(config) {
+  return new CodmirSecret(config);
+}
+
+// src/serverless/decorators.ts
+function app(config) {
+  return createApp(config);
+}
+function fn(appInstance, config = {}) {
+  return appInstance.function(config);
+}
+function method(appInstance, config = {}) {
+  return function(target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    const fnName = `${target.constructor.name}_${String(propertyKey)}`;
+    const codmirFn = appInstance.function({
+      ...config,
+      name: fnName
+    })(originalMethod);
+    descriptor.value = function(...args) {
+      return codmirFn.call(...args);
+    };
+    return descriptor;
+  };
+}
+function web_endpoint(appInstance, config = {}) {
+  return appInstance.function({
+    ...config,
+    name: config.name || `endpoint_${config.method || "GET"}_${Date.now().toString(36)}`
+  });
+}
+function cron(appInstance, schedule, config = {}) {
+  return appInstance.function({
+    ...config,
+    schedule,
+    name: config.name || `cron_${schedule.replace(/\s+/g, "_")}_${Date.now().toString(36)}`
+  });
+}
+
+// src/serverless/utils.ts
+var logs = {
+  /**
+   * Log a debug message.
+   */
+  debug(message, metadata) {
+    logWithLevel("debug", message, metadata);
+  },
+  /**
+   * Log an info message.
+   */
+  info(message, metadata) {
+    logWithLevel("info", message, metadata);
+  },
+  /**
+   * Log a warning message.
+   */
+  warn(message, metadata) {
+    logWithLevel("warn", message, metadata);
+  },
+  /**
+   * Log an error message.
+   */
+  error(message, metadata) {
+    logWithLevel("error", message, metadata);
+  },
+  /**
+   * Log with custom level.
+   */
+  log(level, message, metadata) {
+    logWithLevel(level, message, metadata);
+  }
+};
+function logWithLevel(level, message, metadata) {
+  const entry = {
+    level,
+    message,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    metadata
+  };
+  const prefix = `[codmir:${level.toUpperCase()}]`;
+  const metaStr = metadata ? ` ${JSON.stringify(metadata)}` : "";
+  switch (level) {
+    case "debug":
+      console.debug(`${prefix} ${message}${metaStr}`);
+      break;
+    case "info":
+      console.log(`${prefix} ${message}${metaStr}`);
+      break;
+    case "warn":
+      console.warn(`${prefix} ${message}${metaStr}`);
+      break;
+    case "error":
+      console.error(`${prefix} ${message}${metaStr}`);
+      break;
+  }
+}
+var progress = {
+  _total: 0,
+  _current: 0,
+  /**
+   * Start progress tracking.
+   */
+  start(total, message) {
+    this._total = total;
+    this._current = 0;
+    this.report({ percent: 0, message: message || "Starting..." });
+  },
+  /**
+   * Update progress.
+   */
+  update(current, message) {
+    this._current = current;
+    const percent = this._total > 0 ? Math.round(current / this._total * 100) : 0;
+    this.report({ percent, message });
+  },
+  /**
+   * Increment progress by one.
+   */
+  increment(message) {
+    this.update(this._current + 1, message);
+  },
+  /**
+   * Mark progress as complete.
+   */
+  complete(message) {
+    this.report({ percent: 100, message: message || "Completed" });
+  },
+  /**
+   * Report progress update.
+   */
+  report(update) {
+    console.log(`[codmir:PROGRESS] ${update.percent}% - ${update.message || ""}`);
+  },
+  /**
+   * Get current progress percentage.
+   */
+  getPercent() {
+    return this._total > 0 ? Math.round(this._current / this._total * 100) : 0;
+  }
+};
+var checkpoint = {
+  _data: null,
+  /**
+   * Save a checkpoint.
+   */
+  async save(data, name) {
+    const id = `cp_${Date.now().toString(36)}`;
+    const cp = {
+      id,
+      name,
+      data,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this._data = cp;
+    console.log(`[codmir:CHECKPOINT] Saved: ${id}${name ? ` (${name})` : ""}`);
+    return id;
+  },
+  /**
+   * Restore from the latest checkpoint.
+   */
+  async restore() {
+    return this._data;
+  },
+  /**
+   * Restore from a specific checkpoint.
+   */
+  async restoreById(id) {
+    if (this._data?.id === id) {
+      return this._data;
+    }
+    return null;
+  },
+  /**
+   * List available checkpoints.
+   */
+  async list() {
+    if (this._data) {
+      return [{ id: this._data.id, name: this._data.name, timestamp: this._data.timestamp }];
+    }
+    return [];
+  },
+  /**
+   * Clear all checkpoints.
+   */
+  async clear() {
+    this._data = null;
+    console.log("[codmir:CHECKPOINT] Cleared");
+  },
+  /**
+   * Delete a specific checkpoint.
+   */
+  async delete(id) {
+    if (this._data?.id === id) {
+      this._data = null;
+    }
+    console.log(`[codmir:CHECKPOINT] Deleted: ${id}`);
+  }
+};
+export {
+  CodmirApp,
+  CodmirFunction,
+  CodmirImage,
+  CodmirSandbox,
+  CodmirSecret,
+  CodmirVolume,
+  app,
+  checkpoint,
+  createApp,
+  createFunction,
+  createImage,
+  createSandbox,
+  createSecret,
+  createVolume,
+  cron,
+  execute,
+  executeAsync,
+  executeLocal,
+  fn,
+  logs,
+  method,
+  progress,
+  web_endpoint
+};