API Reference

export MOGPLEX_BASE_URL="https://www.mogplex.com/api/v1/mogplex"
export MOGPLEX_TOKEN="mog_..."

curl -sS \
  -H "Authorization: Bearer $MOGPLEX_TOKEN" \
  "$MOGPLEX_BASE_URL/repos?limit=20"

curl -sS \
  -X POST \
  -H "Authorization: Bearer $MOGPLEX_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{
    "repoId": "repo-uuid",
    "prompt": "Inspect the failing tests and implement the smallest safe fix.",
    "harness": "codex",
    "baseBranch": "main",
    "createBranch": true,
    "rootDirectory": "apps/web"
  }' \
  "$MOGPLEX_BASE_URL/runs"

Authorization: Bearer mog_...

Content-Type: application/json

Idempotency-Key: <unique value, at most 200 characters>

type MogplexApiSuccess<T> = {
  ok: true;
  data: T;
};

type MogplexApiErrorCode =
  | "BAD_REQUEST"
  | "CONFLICT"
  | "FORBIDDEN"
  | "IDEMPOTENCY_CONFLICT"
  | "INTERNAL_ERROR"
  | "NOT_FOUND"
  | "RATE_LIMITED"
  | "SERVICE_UNAVAILABLE"
  | "UNAUTHORIZED";

type MogplexApiError = {
  ok: false;
  error: {
    code: MogplexApiErrorCode;
    message: string;
  };
};

type ListReposQuery = {
  q?: string;       // Case-insensitive substring of owner/repo.
  limit?: number;   // 1 to 200. Default: 100.
};

type MogplexApiRepo = {
  id: string;
  full_name: string;
  installation_id: number;
  default_branch: string | null;
  root_directory: string | null;
};

type ListReposData = {
  repos: MogplexApiRepo[];
};

type MogplexApiAgent = {
  id: string;
  name: string;
  slug: string | null;
  model: string;
  description: string | null;
  category: string | null;
  preset: boolean;
};

type ListAgentsData = {
  agents: MogplexApiAgent[];
};

type MogplexApiModel = {
  id: string;
  provider: string;
  name: string;
  contextLength: number | null;
  capabilities: string[];
  pricing: {
    input: number | null;
    output: number | null;
  };
};

type ListModelsData = {
  models: MogplexApiModel[];
};

type MogplexApiSandbox = {
  id: string;
  sandbox_id: string | null;
  repo_id: string;
  status: string;
  base_branch: string;
  working_branch: string;
  root_directory: string | null;
  preview_url: string | null;
  created_at: string;
  last_active_at: string;
  error: string | null;
};

type ListSandboxesQuery = {
  repo_id?: string;
  status?: string;
  limit?: number;   // 1 to 200. Default: 100.
};

type CreateSandboxRequest = {
  repoId: string;
  baseBranch?: string | null;
  workingBranch?: string | null;
  createBranch?: boolean;
  rootDirectory?: string | null;
  restoreSnapshotId?: string | null;
  restoreSnapshotProjectId?: string | null;
  restoreSnapshotTeamId?: string | null;
};

{
  "repoId": "repo-uuid",
  "baseBranch": "main",
  "workingBranch": "agent/update-api-docs",
  "createBranch": true,
  "rootDirectory": "apps/web"
}

type SandboxLogsData = {
  sandbox: MogplexApiSandbox & {
    install_log: string | null;
    dev_log: string | null;
  };
  lifecycle_events: Array<{
    id: string;
    event_type: string;
    decision_code: string | null;
    worker_run_id: string | null;
    payload: Record<string, unknown>;
    created_at: string;
  }>;
};

type FlowNodeType =
  | "start"
  | "agent"
  | "condition"
  | "parallel"
  | "join"
  | "delay"
  | "await_event"
  | "set_variable"
  | "end";

type FlowGraphRequest = {
  nodes: Array<{
    id: string;
    type: FlowNodeType;
    position: { x: number; y: number };
    data: Record<string, unknown>;
  }>;
  edges: Array<{
    id: string;
    source: string;
    target: string;
    sourceHandle?: string | null;
    targetHandle?: string | null;
  }>;
  viewport?: {
    x: number;
    y: number;
    zoom: number; // Finite and greater than zero.
  };
};

type MogplexApiAutomationSummary = {
  id: string;
  installationId: number;
  name: string;
  description: string | null;
  status: "active" | "inactive";
  publishedVersionId: string | null;
  createdAt: string;
  updatedAt: string;
};

type MogplexApiAutomation = {
  id: string;
  installationId: number;
  name: string;
  description: string | null;
  notes: string | null;
  status: "active" | "inactive";
  draftGraph: FlowGraphRequest;
  publishedVersion: {
    id: string;
    versionNumber: number;
    graph: FlowGraphRequest;
    createdAt: string;
  } | null;
  createdAt: string;
  updatedAt: string;
  runSummary: {
    lastRunId: string | null;
    lastRunStatus: string | null;
    runningCount: number;
    pendingCount: number;
    failed24h: number;
  };
};

type ListAutomationsQuery = {
  limit?: number;   // 1 to 100. Default: 50.
  cursor?: string;  // Opaque nextCursor from the previous page.
};

type ListAutomationsData = {
  automations: MogplexApiAutomationSummary[];
  nextCursor: string | null;
};

type CreateAutomationRequest = {
  installationId: number; // Required positive safe integer.
  name?: string;
  description?: string | null;
  notes?: string | null;
  graph?: FlowGraphRequest;
  publish?: boolean;
};

{
  "installationId": 12345678,
  "name": "Review pull requests",
  "description": "Review new pull requests and report actionable findings.",
  "publish": false
}

type UpdateAutomationRequest = {
  name?: string;
  description?: string | null;
  notes?: string | null;
  installationId?: number; // Positive safe integer when present.
  graph?: FlowGraphRequest; // Complete draft replacement.
};

type SetAutomationModelRequest = {
  nodeId: string;
  modelId: string | null; // null clears the override.
  publish?: boolean;
};

{
  "nodeId": "agent-review",
  "modelId": "provider/model-id",
  "publish": false
}

type TriggerAutomationRequest = {
  repoId: string;
  input?: Record<string, unknown>;
};

{
  "repoId": "repo-uuid",
  "input": {
    "pull_request_number": 699
  }
}

type TriggerAutomationData = {
  run: {
    automationId: string;
    jobRunId: string | null;
    outcome: string;
    reason: string | null;
    started: boolean;
    status: string;
    runtime: {
      provider: string | null;
      runId: string | null;
    } | null;
  };
};

type ListAutomationRunsQuery = {
  limit?: number; // 1 to 50. Default: 20.
};

type MogplexApiRunStatus =
  | "pending"
  | "streaming"
  | "success"
  | "failed"
  | "cancelled";

type MogplexApiRunDetail = {
  runId: string;
  aiCallId: string;
  sandboxRecordId: string | null;
  sandboxId: string | null;
  repoId: string;
  harness: "codex" | "claude-code";
  status: MogplexApiRunStatus;
  branch: {
    base: string;
    working: string;
    createBranch: boolean;
  };
  rootDirectory: string | null;
  eventsUrl: string;
  cancelUrl: string;
  createdAt: string;
  updatedAt: string;
  error: string | null;
  runtime: {
    provider: string | null;
    runId: string | null;
  };
};

type StartRunRequest = {
  repoId: string;
  prompt: string; // At most 100,000 characters.
  harness?: "codex" | "claude-code"; // Default: codex.
  baseBranch?: string;
  workingBranch?: string;
  createBranch?: boolean;
  rootDirectory?: string | null;
  conversationId?: string;
  workspaceSessionId?: string;
  mode?: string;
};

type ListRunEventsQuery = {
  limit?: number; // 1 to 200. Default: 100.
};

type PresentedAiCallEvent = {
  id: string;
  type: string;
  toolName: string | null;
  message: string | null;
  payload: Record<string, unknown>;
  createdAt: string;
};

type RunEventsData = {
  run: MogplexApiRunDetail;
  events: PresentedAiCallEvent[];
};

type CancelRunData = {
  run: MogplexApiRunDetail;
  status: MogplexApiRunStatus;
  alreadyTerminal: boolean;
};

type MogplexApiMcpServer = {
  name: string;
  enabled: boolean;
  config: Record<string, unknown>;
};

type ListMcpServersData = {
  servers: MogplexApiMcpServer[];
};

type StdioMcpConfig = {
  command: string;
  args?: string[];
  env?: Record<string, string>;
};

type HttpMcpConfig = {
  url: string;
  http_headers?: Record<string, string>;
};

https://www.mogplex.com/api/v1/mogplex/mcp

type JsonRpcRequest = {
  jsonrpc: "2.0";
  id?: string | number | null;
  method:
    | "initialize"
    | "notifications/initialized"
    | "ping"
    | "tools/list"
    | "tools/call";
  params?: Record<string, unknown>;
};

{
  "jsonrpc": "2.0",
  "id": 42,
  "method": "tools/call",
  "params": {
    "name": "mogplex_list_automations",
    "arguments": {
      "limit": 20
    }
  }
}

type JsonRpcId = string | number | null;

type JsonRpcSuccess<T> = {
  jsonrpc: "2.0";
  id: JsonRpcId;
  result: T;
};

type JsonRpcError = {
  jsonrpc: "2.0";
  id?: JsonRpcId;
  error: {
    code: number;
    message: string;
    data?: unknown;
  };
};

type McpToolResult = {
  content: Array<{ type: "text"; text: string }>;
  structuredContent?: Record<string, unknown>;
  isError: boolean;
};

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "protocolVersion": "2025-11-25",
    "capabilities": { "tools": { "listChanged": false } },
    "serverInfo": { "name": "mogplex", "version": "0.1.0" }
  }
}

{
  "jsonrpc": "2.0",
  "id": 42,
  "result": {
    "content": [
      { "type": "text", "text": "Found 0 Mogplex automation summaries." }
    ],
    "structuredContent": { "automations": [] },
    "isError": false
  }
}

{
  "jsonrpc": "2.0",
  "id": 42,
  "error": {
    "code": -32602,
    "message": "repoId: Required"
  }
}

{
  "jsonrpc": "2.0",
  "id": 43,
  "result": {
    "content": [
      { "type": "text", "text": "Run not found. List repos or runs again and pass an id owned by this token." }
    ],
    "structuredContent": {
      "error": {
        "code": "NOT_FOUND",
        "status": 404,
        "message": "Run not found",
        "suggestion": "List repos or runs again and pass an id owned by this token."
      }
    },
    "isError": true
  }
}