Glowing Telegram Stream Manager

This skill provides expert guidance for working with the Glowing Telegram stream recording management system - a multi-service Rust workspace with AWS CDK infrastructure for video processing, audio transcription, and AI chat integration.

What This Skill Does

Helps you work effectively with the Glowing Telegram codebase by:

Repository Structure

```

├── Cargo.toml # Rust workspace with 18 member crates

├── cdk/ # AWS CDK infrastructure (TypeScript)

├── docs/ # Documentation and JSON schemas

├── scripts/ # Deployment and utility scripts

├── .github/workflows/ # CI/CD pipelines

├── docker-bake.hcl # Multi-service Docker build configuration

├── Dockerfile # Multi-stage Docker builds

└── [18 Rust crates] # Individual service directories

```

Key Services

Step-by-Step Instructions

1. Initial Setup and Build

**CRITICAL**: These commands take significant time. NEVER CANCEL them mid-execution.

```bash

First-time workspace check (4-5 minutes)

cargo check --workspace

Timeout: 10+ minutes

Incremental workspace build (2-3 minutes)

cargo build --workspace

Timeout: 10+ minutes

Release build (5-6 minutes)

cargo build --release --workspace

Timeout: 15+ minutes

Run tests (10-15 seconds)

cargo test --workspace

Timeout: 5+ minutes

CDK setup (30-45 seconds each)

cd cdk && npm ci

cd cdk && npm run build

cd cdk && npm test

```

2. Code Quality and Validation

Always run these after making changes:

```bash

Rust linting (30-45 seconds)

cargo clippy --workspace --all-targets

Rust formatting (fixes issues automatically)

cargo fmt

Note: cargo fmt --check WILL FAIL due to rustfmt.toml using unstable features

This is expected - just run `cargo fmt` to fix

TypeScript linting (25-30 seconds)

cd cdk && npx biome check .

CDK validation

cd cdk && npm run build && npm test

```

3. Schema and Type Management

When modifying JSON schemas in `docs/v2/schemas/`:

```bash

Regenerate types for both Rust and TypeScript

./types/import.sh

This updates:

- types/src/types.rs (Rust)

- types/src/types.ts (TypeScript)

```

4. Docker Builds

**WARNING**: Docker operations may fail in sandboxed environments due to network/SSL restrictions.

```bash

Build single service (15-30 minutes)

docker buildx bake <service_name>

Where service_name is one of: ai_chat_lambda, audio_transcriber, crud_api, etc.

Build all services (15-30 minutes)

docker buildx bake all

Timeout: 60+ minutes - NEVER CANCEL

```

5. Deployment

**REQUIRES**: AWS credentials and proper infrastructure setup.

```bash

Deploy single service

./scripts/push_image.sh <service_name>

Deploy all services

./scripts/push_all.sh

DO NOT attempt: npx cdk synth or npx cdk deploy

These fail due to Docker dependency issues

```

6. Running CLI Applications

**CRITICAL WARNING**: All CLI tools require extensive AWS environment configuration and will panic without it.

Required environment variables:

Example (only run with proper AWS setup):

```bash

./target/debug/video_ingestor <input_key>

./target/debug/audio_transcriber <item_key> <input_key> <initial_prompt> <language>

```

Common Workflows

Making Code Changes

1. Make your changes to Rust or TypeScript code

2. Run appropriate linting:

- Rust: `cargo clippy --workspace --all-targets`

- Rust: `cargo fmt`

- TypeScript: `cd cdk && npx biome check .`

3. Build to verify:

- Rust: `cargo build --workspace`

- CDK: `cd cdk && npm run build`

4. Run tests:

- Rust: `cargo test --workspace`

- CDK: `cd cdk && npm test`

Modifying Schemas

1. Edit JSON schema files in `docs/v2/schemas/`

2. Run `./types/import.sh` to regenerate types

3. Update code using the generated types

4. Follow "Making Code Changes" workflow above

Adding a New Service

1. Create new Rust crate in workspace

2. Add to `Cargo.toml` workspace members

3. Add Docker build target in `docker-bake.hcl`

4. Add deployment script in `scripts/`

5. Update CDK infrastructure in `cdk/` if needed

Important Constraints

Timing Expectations

Known Issues

AWS Dependencies

CI/CD

VS Code Integration

Tasks available via Command Palette:

Best Practices

1. **Always set generous timeouts** (10+ minutes for Rust, 60+ minutes for Docker)

2. **Never cancel long-running builds** - they need time to complete

3. **Run linting before committing** - CI will catch issues but local validation saves time

4. **Use `cargo fmt`** to auto-fix formatting (ignore unstable feature warnings)

5. **Validate CDK changes** with `npm run build && npm test` before pushing

6. **Regenerate types** after schema changes using `./types/import.sh`

7. **Don't attempt local runs** of CLI tools without proper AWS setup

Quick Command Reference

```bash

Essential development commands

cargo check --workspace # 4-5 min, NEVER CANCEL

cargo build --workspace # 2-3 min, NEVER CANCEL

cargo test --workspace # 10-15 sec

cargo clippy --workspace --all-targets # 30-45 sec

cargo fmt # Auto-fix formatting

CDK commands

cd cdk && npm ci # 30-45 sec

cd cdk && npm run build # 8-10 sec

cd cdk && npm test # 10-15 sec

cd cdk && npx biome check . # 25-30 sec

Type generation

./types/import.sh # Generate types from schemas

Docker (may fail in sandbox)

docker buildx bake <service> # 15-30 min, NEVER CANCEL

docker buildx bake all # 15-30 min, NEVER CANCEL

```

Remember: This is a complex multi-service system requiring AWS infrastructure. Always validate changes locally before pushing, respect build timing requirements, and ensure proper AWS configuration before attempting deployments or CLI usage.