Skip to main content
skill CX Codex

tigris-bucket-management — Claude Code skill: guide and install

tigris-bucket-management manages Tigris Storage buckets lifecycle, including creation, listing with pagination, status inspection, and safe deletion.

MIT 135 installs ★ 2 updated 2026-07-23

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add tigrisdata/skills --skill tigris-bucket-management -a claude-code
Open on GitHub

What tigris-bucket-management does

This skill equips coding agents with patterns for managing Tigris Storage buckets using @tigrisdata/storage. It covers TypeScript functions such as createBucket, listBuckets, getBucketInfo, and removeBucket across different tiers and regions.

The workflow requires the Tigris CLI available via @tigrisdata/cli. Buckets with snapshot features mandate the STANDARD storage tier, and names must remain globally unique.

What it helps with

  • create public or private Tigris buckets with regional placement
  • inspect bucket metadata and snapshot statuses
  • list existing storage buckets using pagination tokens
  • remove empty buckets or perform forced deletions

Example prompts for the agent

  • Create a public Tigris bucket named public-assets in the eu region
  • List all my Tigris storage buckets using pagination
  • Inspect the settings and snapshot status for my-bucket

How to install tigris-bucket-management

1Skills CLI (Vercel)

npx skills add tigrisdata/skills --skill tigris-bucket-management -a claude-code

2Manually: put the files in place

~/.claude/skills/tigris-bucket-management/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/tigris-bucket-management/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about tigris-bucket-management

How to install tigris-bucket-management in Claude Code?

Run npx skills add tigrisdata/skills --skill tigris-bucket-management -a claude-code in your terminal.

What does tigris-bucket-management do?

It guides the agent in handling Tigris Storage bucket operations, from bucket creation and region selection to deletion and info checks.

What are the prerequisites for this skill?

It requires the Tigris CLI installed globally via npm install -g @tigrisdata/cli.

Source text

SKILL.md · MIT
---
name: tigris-bucket-management
description: Use when creating, listing, inspecting, or deleting Tigris Storage buckets
---

# Tigris Bucket Management

## Prerequisites

**Before doing anything else**, install the Tigris CLI if it's not already available:

```bash
tigris help || npm install -g @tigrisdata/cli
```

If you need to install it, tell the user: "I'm installing the Tigris CLI (`@tigrisdata/cli`) so we can work with Tigris object storage."

## Overview

Buckets are containers for objects. This skill covers bucket lifecycle: create, list, inspect, and delete.

## Quick Reference

| Operation | Function                      | Key Parameters                       |
| --------- | ----------------------------- | ------------------------------------ |
| Create    | `createBucket(name, options)` | name, access, region, enableSnapshot |
| List      | `listBuckets(options)`        | limit, paginationToken               |
| Inspect   | `getBucketInfo(name)`         | bucketName                           |
| Delete    | `removeBucket(name, options)` | bucketName, force                    |

## Create Bucket

```typescript
import { createBucket } from "@tigrisdata/storage";

// Simple private bucket
const result = await createBucket("my-new-bucket");
if (result.error) {
  console.error("Error:", result.error);
} else {
  console.log("Created:", result.data);
}

// Public bucket (objects readable by anyone)
const result = await createBucket("public-assets", {
  access: "public",
});

// Snapshot-enabled bucket (for version control)
const result = await createBucket("my-snapshot-bucket", {
  enableSnapshot: true,
});

// Regional bucket
const result = await createBucket("eu-data", {
  region: "eu",
});

// Fork from existing bucket snapshot
const result = await createBucket("my-forked-bucket", {
  sourceBucketName: "parent-bucket",
  sourceBucketSnapshot: "1751631910169675092",
});
```

## Create Bucket Options

| Option               | Values                                  | Default  | Purpose                  |
| -------------------- | --------------------------------------- | -------- | ------------------------ |
| access               | public/private                          | private  | Object readability       |
| consistency          | default/strict                          | default  | Read consistency level   |
| defaultTier          | STANDARD/STANDARD_IA/GLACIER/GLACIER_IR | STANDARD | Default storage tier     |
| enableSnapshot       | boolean                                 | false    | Enable snapshots/forking |
| region               | string                                  | global   | Bucket region            |
| sourceBucketName     | string                                  | -        | Fork from this bucket    |
| sourceBucketSnapshot | string                                  | -        | Fork from this snapshot  |

**Note:** Snapshot-enabled buckets must use STANDARD tier.

## List Buckets

```typescript
import { listBuckets } from "@tigrisdata/storage";

// List all buckets
const result = await listBuckets();
if (result.error) {
  console.error("Error:", result.error);
} else {
  console.log("Buckets:", result.data?.buckets);
  console.log("Owner:", result.data?.owner);
}

// Paginated list
const allBuckets = [];
let currentPage = await listBuckets({ limit: 10 });
allBuckets.push(...currentPage.data?.buckets);

while (currentPage.data?.paginationToken) {
  currentPage = await listBuckets({
    limit: 10,
    paginationToken: currentPage.data?.paginationToken,
  });
  allBuckets.push(...currentPage.data?.buckets);
}
```

## Get Bucket Info

```typescript
import { getBucketInfo } from "@tigrisdata/storage";

const result = await getBucketInfo("my-bucket");
if (result.error) {
  console.error("Error:", result.error);
} else {
  console.log("Info:", result.data);
  // {
  //   isSnapshotEnabled: true,
  //   hasForks: false,
  //   sourceBucketName: undefined,
  //   sourceBucketSnapshot: undefined
  // }
}
```

## Delete Bucket

```typescript
import { removeBucket } from "@tigrisdata/storage";

// Delete empty bucket
const result = await removeBucket("my-bucket");
if (result.error) {
  console.error("Error:", result.error);
} else {
  console.log("Deleted successfully");
}

// Force delete (even if not empty)
const result = await removeBucket("my-bucket", {
  force: true,
});
```

**Warning:** Force delete is irreversible. All objects will be lost.

## Bucket Access Levels

| Level   | Behavior                  | Use Case                      |
| ------- | ------------------------- | ----------------------------- |
| private | Objects require auth      | Default, sensitive data       |
| public  | Objects publicly readable | Static assets, public content |

## Consistency Levels

| Level   | Behavior                           | Trade-off      |
| ------- | ---------------------------------- | -------------- |
| default | Low latency, eventual consistency  | Most workloads |
| strict  | Strong consistency, higher latency | Critical data  |

## Storage Tiers

| Tier        | Use Case                    | Cost                           |
| ----------- | --------------------------- | ------------------------------ |
| STANDARD    | General purpose             | Standard                       |
| STANDARD_IA | Infrequently accessed       | Lower cost                     |
| GLACIER     | Long-term archive           | Lowest cost                    |
| GLACIER_IR  | Rare access, fast retrieval | Archive with occasional access |

## Regions

Specify region for data locality or compliance:

```typescript
await createBucket("data-eu", { region: "eu" });
await createBucket("data-asia", { region: "asia-south-1" });
```

Leave empty for global bucket (recommended for most use cases).

## Common Mistakes

| Mistake                                         | Fix                                    |
| ----------------------------------------------- | -------------------------------------- |
| Enable snapshot with non-STANDARD tier          | Snapshot requires STANDARD tier        |
| Not checking bucket exists before delete        | Use `getBucketInfo` first              |
| Trying to delete non-empty bucket without force | Use `force: true` or empty bucket first |
| Name conflicts                                  | Bucket names must be globally unique   |

## Forking and Snapshots

For version control (snapshots/forking), see the **tigris-snapshots-forking** skill.

© tigrisdata · MIT · tigrisdata/skills

Similar skills

All skills for Cloud: AWS, Azure, GCP →

From the same set11

The whole set →
tigris-agent-kit tigris-agent-kit — a skill for Tigris object storage workflows: isolated dataset forks, per-agent buckets with TTL, snapshots and bucket webhooks. CX Codex +1 3,800installs tigris-s3-migration tigris-s3-migration — a skill that walks an object-storage migration from AWS S3, GCS or Azure Blob to Tigris. Useful when a bucket has to switch over without taking production down. CX Codex +1 3,800installs tigris-static-assets tigris-static-assets deploys static assets to Tigris object storage for global CDN delivery, configuring Cache-Control headers and build pipelines across web frameworks. CX Codex +1 3,800installs tigris-image-optimization tigris-image-optimization — a skill for images stored in Tigris: it builds variants at upload time, serves them from a public bucket and points you to the right framework guide. CX Codex +1 3,800installs tigris-sdk-guide tigris-sdk-guide tells your agent which Tigris SDK or CLI to reach for: native packages for TypeScript, Go and Python, AWS-compatible clients for Ruby and PHP. CX Codex +1 3,800installs file-storage file-storage helps configure Tigris Object Storage buckets via CLI and handle file uploads in Node.js, Rails, or Laravel. CX Codex +1 3,800installs tigris-snapshots-forking tigris-snapshots-forking — a skill for Claude Code, Codex, Cursor and other agents that takes Tigris bucket snapshots and forks them into isolated copies. Deletions inside a fork leave the source bucket untouched. CX Codex +1 453installs conventional-commits Enforces the Conventional Commits specification, adds AI tool attribution, and applies signoff flags for standardized git workflows. CX Codex +1 105installs

Project sponsors

Companies that keep this analytics open