Serverless SDK

npm install @codmir/sdk

import { app, fn } from '@codmir/sdk/serverless';

import { app, fn } from '@codmir/sdk/serverless';

const myApp = app({ name: 'data-pipeline' });

const processData = fn(myApp, {
  cpu: 2,
  memory: '4GB',
  timeout: 300,
})(async (data: string) => {
  // Your code runs in the cloud
  return data.toUpperCase();
});

// Local development
const localResult = await processData.local('test data');

// Cloud execution
const remoteResult = await processData.remote('real data');

// Auto-select based on environment
const result = await processData.call('auto data');

import { CodmirApp, createApp } from '@codmir/sdk/serverless';

const app = new CodmirApp({
  name: 'my-app',
  image: 'python:3.11',
  secrets: ['OPENAI_API_KEY'],
  volumes: { '/data': 'my-volume' },
  grace: {
    enabled: true,
    preferGreen: true,
  },
});

const embed = app.function({
  cpu: 4,
  memory: '8GB',
  gpu: 'T4',
  timeout: 600,
  retries: 2,
  pool: 'auto',
})(async (texts: string[]) => {
  // Runs with 4 CPUs, 8GB RAM, and a T4 GPU
  return await generateEmbeddings(texts);
});

// Always runs locally (for development/testing)
const result = await embed.local(['hello', 'world']);

// Always runs in the cloud
const result = await embed.remote(['hello', 'world']);

// Auto-selects based on NODE_ENV
const result = await embed.call(['hello', 'world']);

const sandbox = app.sandbox({ image: 'python:3.11' });
await sandbox.spawn();

// Execute commands
await sandbox.exec('pip install numpy pandas');
const result = await sandbox.exec('python script.py');
console.log(result.stdout);

// Read and write files
await sandbox.writeFile('/app/data.json', JSON.stringify(data));
const content = await sandbox.readFile('/app/output.json');

// Clean up
await sandbox.terminate();

import { createImage } from '@codmir/sdk/serverless';

const mlImage = createImage({
  base: 'python:3.11-slim',
  pythonPackages: ['torch', 'transformers', 'numpy'],
  systemPackages: ['ffmpeg', 'libsndfile1'],
  runCommands: ['python -c "import torch; print(torch.__version__)"'],
  copyFiles: [{ from: './models', to: '/app/models' }],
  env: { TRANSFORMERS_CACHE: '/app/cache' },
  workdir: '/app',
});

import { createVolume } from '@codmir/sdk/serverless';

const dataVol = createVolume({
  name: 'training-data',
  size: 100, // GB
  region: 'us-east-1',
});

// Mount in a function
const train = fn(myApp, {
  gpu: 'A100',
  volumes: { '/data': 'training-data' },
})(async () => {
  // /data persists between runs
});

import { createSecret } from '@codmir/sdk/serverless';

const apiKey = createSecret({
  name: 'OPENAI_API_KEY',
  envVar: 'OPENAI_API_KEY',
});

const generate = fn(myApp, {
  secrets: ['OPENAI_API_KEY'],
})(async (prompt: string) => {
  // process.env.OPENAI_API_KEY is available
});

import { app, fn, web_endpoint, cron, method } from '@codmir/sdk/serverless';

const myApp = app({ name: 'my-service' });

// Basic function
const process = fn(myApp, { cpu: 2 })(async (data: string) => {
  return data.toUpperCase();
});

// Web endpoint
const api = web_endpoint(myApp, { method: 'POST' })(async (req) => {
  return { status: 'ok', data: req.body };
});

// Scheduled function (cron)
const dailyReport = cron(myApp, '0 9 * * *')(async () => {
  await generateDailyReport();
});

class DataProcessor {
  @method(myApp, { cpu: 4, memory: '8GB' })
  async process(data: string) {
    return data.toUpperCase();
  }
}

import { execute, executeAsync, executeLocal } from '@codmir/sdk/serverless';

interface ExecutionResult<T> {
  id: string;
  status: ExecutionStatus;
  result?: T;
  error?: string;
  metrics: {
    durationMs: number;
    queuedMs?: number;
    coldStartMs?: number;
    cpuUsage?: number;
    memoryUsageMb?: number;
    creditsUsed: number;
    carbonFootprint?: number;   // gCO2e
    pool: ExecutionPool;
  };
  logs?: string[];
  artifacts?: ExecutionArtifact[];
  checkpoint?: unknown;
}

import { logs, progress, checkpoint } from '@codmir/sdk/serverless';

const app = new CodmirApp({
  name: 'sensitive-pipeline',
  grace: {
    enabled: true,
    requireApproval: true,
    maxBudget: 100,           // Max credits per execution
    preferGreen: true,        // Route to low-carbon compute
    impactCategory: 'medium',
  },
});

import type {
  AppConfig,
  FunctionConfig,
  SandboxConfig,
  ImageConfig,
  VolumeConfig,
  SecretConfig,
  ExecutionResult,
  ExecutionStatus,
  ExecutionPool,
  ResourceSpec,
  GraceConfig,
  CallOptions,
  StreamEvent,
  BatchConfig,
  BatchResult,
} from '@codmir/sdk/serverless';