Xpersona
T

Tencent Cloud Lighthouse

CLAWHUB · Unverified

Load when: user mentions Lighthouse, 轻量应用服务器, 轻量服务器, or asks to check/create/manage/deploy Lighthouse instances, deploy applications to Lighthouse, manage Li... Skill: Tencent Cloud Lighthouse Owner: lhanyun Summary: Load when: user mentions Lighthouse, 轻量应用服务器, 轻量服务器, or asks to check/create/manage/deploy Lighthouse instances, deploy applications to Lighthouse, manage Li... Tags: latest:1.0.2 Version history: v1.0.2 | 2026-05-08T08:59:06.217Z | user No functional or documentation changes detected for version 1.0.2. - No file modifications present compared to the previous ve

62
Rank
84
Safety
14k
Downloads

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 13.6K downloads reported by the source. Last updated 11/16/2026.

Avoid when

  • Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Install and run

Setup complexity: low.

clawhub skill install s17dn21jdk3pt92srtpncvyzch85qvaq:tencentcloud-lighthouse-skill
  1. Setup complexity is LOW. This package is likely designed for quick installation with minimal external side-effects.
  2. Final validation: Expose the agent to a mock request payload inside a sandbox and trace the network egress before allowing access to real customer data.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-lhanyun-tencentcloud-lighthouse-skill-se-skill-2/snapshot"

Run-check

$0.02 USD

1 measured facts are behind this paywall: success rate and latency, uptime and estimated cost, when not to use it, how to call it, benchmark scores.

Agents pay $0.02 in USDC. A card payment is $0.50, the smallest a card allows.

Documentation

CLAWHUB

65,110 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: tencentcloud-lighthouse-skill
description: 'Load when: user mentions Lighthouse, 轻量应用服务器, 轻量服务器, or asks to check/create/manage/deploy Lighthouse instances, deploy applications to Lighthouse, manage Lighthouse firewall rules, reset Lighthouse password, view Lighthouse snapshots/images/traffic, monitor Lighthouse metrics, run commands on Lighthouse via TAT, or asks to get/identify the current instance ID. Trigger phrases: "查看轻量服务器", "Lighthouse实例", "轻量应用服务器", "部署应用", "部署程序", "部署到Lighthouse", "管理防火墙规则", "重置密码", "查看快照", "查看流量包", "获取实例ID", "查看实例ID", "当前实例", "实例IP", "check Lighthouse", "create Lighthouse", "deploy app", "deploy application", "Lighthouse firewall", "Lighthouse snapshot", "instance ID", "whoami". NOT for CVM, CBS, VPC, or other non-Lighthouse products.'
metadata:
  {
    "openclaw":
      {
        "emoji": "☁️",
        "requires": {},
        "install":
          [
            {
              "id": "pip",
              "kind": "pip",
              "package": "tccli",
              "bins": ["tccli"],
              "label": "Install TCCLI",
            },
          ],
        "references":
          [
            "instance-management",
            "application-deployment",
            "monitoring-alerting",
            "firewall-management",
            "remote-command-tat",
            "snapshot-blueprint",
            "traffic-package",
          ],
      },
  }
---

# Lighthouse Cloud Server Operations

Manage Tencent Cloud Lighthouse instances via tccli CLI.

Your knowledge of tccli parameters and API limits may be outdated.
**Always use `tccli <service> <action> --help` to verify parameters before execution.**

## Prerequisites

```bash
tccli --version
```

If not installed: `pip install tccli`

## Credential Setup

| Method | Security | Expiry | Recommendation |
|--------|----------|--------|----------------|
| OAuth browser login | High | Temporary, expires in 2 hours | Recommended |
| AK/SK key pair | Low | Permanent unless revoked | Special cases only |

When the user has not chosen a method, default to OAuth.

### OAuth Login (Recommended)

Use `script/tccli-oauth-helper.sh` for non-interactive OAuth login:

```bash
# Step 1: Check credential status
bash script/tccli-oauth-helper.sh --status

# Step 2: Generate authorization URL (if credentials are missing or expired)
bash script/tccli-oauth-helper.sh --get-url

# Step 3: User opens the URL in browser, completes login, and gets a base64 code

# Step 4: Complete login with the code
bash script/tccli-oauth-helper.sh --code "base64_code_from_browser"

# Step 5: Verify
tccli lighthouse DescribeRegions
```

**Workflow:**
1. Run `--status` to check existing credentials
2. If expired/missing, run `--get-url` — show the URL to user
3. User opens URL → logs in → copies the base64 code from browser
4. Run `--code` with the base64 code to complete login
5. Verify with `tccli lighthouse DescribeRegions`

**Notes:**
- Credentials are temporary (expires in ~2 hours)
- State is val

README.md

# Tencent Cloud Lighthouse Skill

An OpenClaw Skill for managing Tencent Cloud Lighthouse instances via tccli CLI.

Supports instance management, monitoring & alerting, firewall configuration, remote command execution (TAT), snapshots, and traffic package management.

## Structure

```
SKILL.md                              # Main skill definition
references/
  instance-management.md              # Instance query, start/stop/reboot, password reset
  monitoring-alerting.md              # CPU/memory/bandwidth metrics, alarm policies
  firewall-management.md              # Firewall rule CRUD, security best practices
  remote-command-tat.md               # TAT remote command execution
  snapshot-blueprint.md               # Snapshot and custom image management
  traffic-package.md                  # Traffic package usage query
```

## Quick Start

1. Install tccli: `pip install tccli`
2. Configure credentials via OAuth login or AK/SK
3. Refer to SKILL.md for usage

_meta.json

{
  "ownerId": "kn75kc19fpd7fhjt8pfak7x3j180v1jy",
  "slug": "tencentcloud-lighthouse-skill",
  "version": "1.0.2",
  "publishedAt": 1778230746217
}

references/application-deployment.md

# Application Deployment

Deploy applications to Lighthouse instances and verify successful deployment.

## Pre-deployment Checklist

Before deploying, gather information about the application:

1. **Instance readiness** — Verify the target instance is running
2. **Environment** — Check OS, runtime, and dependencies
3. **Application type** — Identify how the app starts and validates

## Step 1: Research Application Startup

Ask the user or analyze the application to determine:

| Question | Why it matters |
|----------|----------------|
| What type of application? | Node.js, Python, Java, Go, Docker, etc. |
| How to start the app? | Command like `npm start`, `python app.py`, `java -jar app.jar` |
| What port does it listen on? | Need to open firewall and verify access |
| Does it need a database? | May need to set up MySQL, Redis, etc. |
| Any environment variables? | Config like `NODE_ENV`, `DATABASE_URL` |
| How to verify it's running? | Health check endpoint, process name, log file |

### Common Application Types

```bash
# Check what's installed on the instance
tccli tat RunCommand --region <region> \
  --InstanceIds '["lhins-xxx"]' \
  --Content "which node python java docker && docker --version 2>/dev/null && node --version 2>/dev/null && python3 --version 2>/dev/null"
```

## Step 2: Prepare the Environment

```bash
# Install runtime if needed (example: Node.js)
tccli tat RunCommand --region <region> \
  --InstanceIds '["lhins-xxx"]' \
  --Content "curl -fsSL https://rpm.nodesource.com/setup_18.x | sudo bash - && sudo yum install -y nodejs"

# Or for Docker-based deployment
tccli tat RunCommand --region <region> \
  --InstanceIds '["lhins-xxx"]' \
  --Content "sudo yum install -y docker && sudo systemctl start docker && sudo systemctl enable docker"
```

## Step 3: Deploy the Application

### Option A: Git Clone + Build

```bash
# Clone repository
tccli tat RunCommand --region <region> \
  --InstanceIds '["lhins-xxx"]' \
  --Content "cd /opt && sudo git clone <repo-url> myapp && sudo chown -R lighthouse:lighthouse myapp"

# Install dependencies and build
tccli tat RunCommand --region <region> \
  --InstanceIds '["lhins-xxx"]' \
  --Content "cd /opt/myapp && npm install && npm run build" \
  --Timeout 300

# Start the application
tccli tat RunCommand --region <region> \
  --InstanceIds '["lhins-xxx"]' \
  --Content "cd /opt/myapp && nohup npm start > /var/log/myapp.log 2>&1 &"
```

### Option B: Docker Deployment

```bash
# Pull and run container
tccli tat RunCommand --region <region> \
  --InstanceIds '["lhins-xxx"]' \
  --Content "sudo docker run -d --name myapp -p 3000:3000 --restart always <image-name>"
```

### Option C: Upload Files + Run

For custom deployments, ask the user to provide files or commands.

## Step 4: Open Firewall Ports

```bash
# Open the application port (e.g., 3000)
tccli lighthouse CreateFirewallRules --region <region> \
  --InstanceId lhins-xxx \
  --FirewallRules '[{"Protocol":"TCP","Port":"3000","CidrBlock":"0.

references/firewall-management.md

# Lighthouse Firewall Management

## Query Firewall Rules

```bash
tccli lighthouse DescribeFirewallRules --region ap-guangzhou \
  --InstanceId lhins-xxxxxxxx
```

## Add Firewall Rules

```bash
tccli lighthouse CreateFirewallRules --region ap-guangzhou \
  --InstanceId lhins-xxxxxxxx \
  --FirewallRules '[{"Protocol":"TCP","Port":"8080","CidrBlock":"0.0.0.0/0","Action":"ACCEPT","FirewallRuleDescription":"Open port 8080"}]'
```

### FirewallRule Fields

| Field | Required | Description |
|-------|----------|-------------|
| Protocol | Yes | TCP, UDP, ICMP, ALL |
| Port | Yes | Single port (80), range (8000-9000), or ALL |
| CidrBlock | No | Source IP CIDR, default 0.0.0.0/0 |
| Action | Yes | ACCEPT or DROP |
| FirewallRuleDescription | No | Rule description |

### Common Port Presets

```bash
# HTTP
--FirewallRules '[{"Protocol":"TCP","Port":"80","CidrBlock":"0.0.0.0/0","Action":"ACCEPT","FirewallRuleDescription":"HTTP"}]'

# HTTPS
--FirewallRules '[{"Protocol":"TCP","Port":"443","CidrBlock":"0.0.0.0/0","Action":"ACCEPT","FirewallRuleDescription":"HTTPS"}]'

# SSH (restrict source IP for security)
--FirewallRules '[{"Protocol":"TCP","Port":"22","CidrBlock":"1.2.3.4/32","Action":"ACCEPT","FirewallRuleDescription":"SSH from trusted IP"}]'
```

## Delete Firewall Rules

```bash
tccli lighthouse DeleteFirewallRules --region ap-guangzhou \
  --InstanceId lhins-xxxxxxxx \
  --FirewallRules '[{"Protocol":"TCP","Port":"8080"}]'
```

## Security Best Practices

- Restrict SSH (port 22) to specific trusted IPs, never open to 0.0.0.0/0
- Only open ports that are actually needed
- Always review existing rules before adding new ones
- Firewall changes take effect immediately — confirm with user before executing

Sponsored

Ads related to Tencent Cloud Lighthouse and adjacent AI workflows.