Files

AI Agent 69cf7e8a05 QwenClaw v2.0 - Complete Rebuild with ALL 81+ Skills

2026-02-26 20:08:00 +04:00

11 KiB

Raw Blame History

QwenClaw Integration Skill

Overview

This skill enables Qwen Code to directly trigger, control, and communicate with the QwenClaw daemon. It provides seamless integration between your interactive Qwen Code session and the persistent QwenClaw background processes.

Version: 1.0.0
Category: Integration
Author: QwenClaw Team

Features

1. Daemon Control

Start QwenClaw daemon from within Qwen Code
Check daemon status
Stop daemon gracefully
Auto-restart if daemon crashes

2. Message Passing

Send prompts to running daemon
Receive responses asynchronously
Forward responses to Telegram
Queue messages when daemon is offline

3. Task Orchestration

Delegate long-running tasks to daemon
Monitor task progress
Receive completion notifications
Handle task failures gracefully

4. Shared Context

Share session context between Qwen Code and QwenClaw
Synchronize settings and preferences
Share skill configurations
Unified logging and debugging

Installation

Prerequisites

QwenClaw installed:

git clone https://github.rommark.dev/admin/QwenClaw-with-Auth.git
cd QwenClaw-with-Auth
bun install

Qwen Code installed:
```
# Follow Qwen Code installation guide
```

Setup

Copy skill to Qwen Code:

# Copy this skill to Qwen Code skills directory
cp -r skills/qwenclaw-integration ~/.qwen/skills/qwenclaw-integration

Enable in Qwen Code: Edit ~/.qwen/settings.json:

{
  "enabledSkills": [
    "qwenclaw-integration"
  ]
}

Configure paths: Create ~/.qwen/skills/qwenclaw-integration/config.json:

{
  "qwenclawPath": "/path/to/qwenclaw",
  "autoStart": true,
  "checkInterval": 30000,
  "forwardToTelegram": false
}

Usage

From Qwen Code Chat

Start QwenClaw

Use qwenclaw-integration to start the daemon with web UI

Check Status

Use qwenclaw-integration to check if QwenClaw is running

Send Task

Use qwenclaw-integration to send this task to QwenClaw:
"Monitor my GitHub notifications and summarize new issues"

Schedule Task

Use qwenclaw-integration to schedule a daily standup at 9 AM

Forward to Telegram

Use qwenclaw-integration to forward the response to Telegram

API Reference

QwenClawClient Class

import { QwenClawClient } from './qwenclaw-integration';

const client = new QwenClawClient({
  qwenclawPath: '/path/to/qwenclaw',
  autoStart: true,
});

// Check if daemon is running
const status = await client.getStatus();
console.log(status); // { running: true, pid: 12345, ... }

// Start daemon
await client.start({ web: true, webPort: 4632 });

// Send message
const response = await client.send('Check my pending tasks');
console.log(response); // { success: true, output: '...' }

// Stop daemon
await client.stop();

Methods

`getStatus(): Promise<DaemonStatus>`

Check if QwenClaw daemon is running.

Returns:

interface DaemonStatus {
  running: boolean;
  pid?: number;
  uptime?: number;
  webEnabled?: boolean;
  webPort?: number;
  telegramEnabled?: boolean;
  jobsCount?: number;
}

`start(options?: StartOptions): Promise<void>`

Start QwenClaw daemon.

Options:

interface StartOptions {
  web?: boolean;
  webPort?: number;
  telegram?: boolean;
  debug?: boolean;
  trigger?: boolean;
  prompt?: string;
}

`stop(): Promise<void>`

Stop QwenClaw daemon gracefully.

`send(message: string, options?: SendOptions): Promise<SendResult>`

Send message to running daemon.

Options:

interface SendOptions {
  telegram?: boolean;
  waitForResponse?: boolean;
  timeout?: number;
}

Returns:

interface SendResult {
  success: boolean;
  output?: string;
  error?: string;
  exitCode?: number;
}

`schedule(job: ScheduledJob): Promise<void>`

Schedule a new job with QwenClaw.

Job:

interface ScheduledJob {
  name: string;
  schedule: string; // Cron expression
  prompt: string;
  recurring: boolean;
  notify: boolean | 'error';
}

`listJobs(): Promise<ScheduledJob[]>`

List all scheduled jobs.

`cancelJob(name: string): Promise<void>`

Cancel a scheduled job.

Examples

Example 1: Auto-Start Daemon

import { QwenClawClient } from './qwenclaw-integration';

const client = new QwenClawClient({ autoStart: true });

// This will automatically start QwenClaw if not running
const status = await client.getStatus();
console.log(`QwenClaw is ${status.running ? 'running' : 'stopped'}`);

Example 2: Delegate Long Task

const client = new QwenClawClient();

// Delegate code review to daemon
const result = await client.send(
  'Review all TypeScript files in src/ for potential bugs and suggest improvements',
  { waitForResponse: true, timeout: 300000 }
);

console.log(result.output);

Example 3: Schedule Daily Report

await client.schedule({
  name: 'daily-report',
  schedule: '0 9 * * 1-5', // Weekdays at 9 AM
  prompt: 'Generate a daily report of my GitHub activity, pending PRs, and tasks',
  recurring: true,
  notify: true,
});

Example 4: Forward to Telegram

const result = await client.send(
  'Summarize my calendar for today',
  { telegram: true }
);

// Response will be sent to your Telegram

Integration Patterns

Pattern 1: Interactive + Background

┌─────────────────┐         ┌─────────────────┐
│   Qwen Code     │────────▶│   QwenClaw      │
│   (Interactive) │◀────────│   (Background)  │
└─────────────────┘         └─────────────────┘
       │                           │
       ▼                           ▼
  User Chat                   Long Tasks
  Quick Questions              Scheduled Jobs
  Code Review                  Monitoring

Use Case: Use Qwen Code for interactive work, delegate long-running tasks to QwenClaw.

Pattern 2: Multi-Session Coordination

┌─────────────────┐
│   Qwen Code     │
│   Session 1     │────┐
└─────────────────┘    │
                       ▼
┌─────────────────┐  ┌─────────────────┐
│   Qwen Code     │──▶│   QwenClaw      │
│   Session 2     │  │   (Shared)      │
└─────────────────┘  └─────────────────┘
                            │
                            ▼
                     ┌─────────────────┐
                     │    Telegram     │
                     │  Notifications  │
                     └─────────────────┘

Use Case: Multiple Qwen Code sessions share a single QwenClaw daemon for consistency.

Pattern 3: Task Pipeline

User Request
     │
     ▼
┌─────────────────┐
│   Qwen Code     │──▶ Analyze & Plan
└─────────────────┘
     │
     ▼
┌─────────────────┐
│   QwenClaw      │──▶ Execute Long Task
└─────────────────┘
     │
     ▼
┌─────────────────┐
│    Telegram     │◀── Notify Completion
└─────────────────┘

Use Case: Complex workflows spanning multiple systems.

Configuration

config.json

{
  "qwenclawPath": "/absolute/path/to/qwenclaw",
  "autoStart": true,
  "checkInterval": 30000,
  "forwardToTelegram": false,
  "telegramBotToken": "",
  "telegramAllowedUserIds": [],
  "webDashboard": {
    "enabled": true,
    "port": 4632,
    "host": "127.0.0.1"
  },
  "logging": {
    "level": "info",
    "file": "~/.qwen/qwenclaw/integration.log"
  }
}

Environment Variables

Variable	Description	Default
`QWENCLAW_PATH`	Path to QwenClaw installation	`~/qwenclaw`
`QWENCLAW_AUTO_START`	Auto-start daemon	`true`
`QWENCLAW_CHECK_INTERVAL`	Status check interval (ms)	`30000`
`QWENCLAW_TELEGRAM_TOKEN`	Telegram bot token	-
`QWENCLAW_LOG_LEVEL`	Logging level	`info`

Troubleshooting

Issue: "Daemon not found"

Solution:

# Verify QwenClaw installation
cd /path/to/qwenclaw
bun run status

# Reinstall if needed
bun install

Issue: "Cannot start daemon"

Solution:

# Check if port is in use
lsof -i :4632

# Check logs
cat ~/.qwen/qwenclaw/logs/*.log

Issue: "Messages not delivered"

Solution:

Check daemon is running: qwenclaw status
Verify network connectivity
Check firewall settings
Review integration logs

Best Practices

1. Use for Appropriate Tasks

✅ Good for QwenClaw:

Long-running analyses
Scheduled monitoring
Background notifications
Multi-step workflows

❌ Better for Qwen Code:

Quick questions
Interactive coding
Real-time collaboration
Exploratory work

2. Manage Resources

// Don't spawn too many daemon tasks
const client = new QwenClawClient();

// Queue tasks instead of parallel execution
await client.send('Task 1');
await client.send('Task 2'); // Waits for Task 1

3. Handle Errors Gracefully

try {
  const result = await client.send('Complex task');
  if (!result.success) {
    console.error('Task failed:', result.error);
  }
} catch (err) {
  console.error('Communication error:', err);
  // Fallback to direct Qwen Code execution
}

4. Monitor Daemon Health

setInterval(async () => {
  const status = await client.getStatus();
  if (!status.running) {
    console.log('Daemon stopped, restarting...');
    await client.start();
  }
}, 60000); // Check every minute

Security Considerations

1. API Key Protection

Never commit API keys to version control:

# Use environment variables
export QWEN_API_KEY="your-key"
export TELEGRAM_BOT_TOKEN="your-token"

2. Access Control

Limit Telegram access to trusted users:

{
  "telegramAllowedUserIds": [123456789, 987654321]
}

3. Network Security

Bind web dashboard to localhost:

{
  "webDashboard": {
    "host": "127.0.0.1",
    "port": 4632
  }
}

Resources

QwenClaw Repo: https://github.rommark.dev/admin/QwenClaw-with-Auth
Documentation: docs/README.md in QwenClaw repo
Skills: skills/ directory
Issues: https://github.rommark.dev/admin/QwenClaw-with-Auth/issues

Changelog

v1.0.0 (2026-02-26)

Initial release
Daemon control (start/stop/status)
Message passing
Task scheduling
Telegram forwarding
Shared context

License

MIT License - See LICENSE file for details.

Skill ready for Qwen Code integration! 🐾🤖

11 KiB Raw Blame History

QwenClaw Integration Skill

Overview

Features

1. Daemon Control

2. Message Passing

3. Task Orchestration

4. Shared Context

Installation

Prerequisites

Setup

Usage

From Qwen Code Chat

Start QwenClaw

Check Status

Send Task

Schedule Task

Forward to Telegram

API Reference

QwenClawClient Class

Methods

getStatus(): Promise<DaemonStatus>

start(options?: StartOptions): Promise<void>

stop(): Promise<void>

send(message: string, options?: SendOptions): Promise<SendResult>

schedule(job: ScheduledJob): Promise<void>

listJobs(): Promise<ScheduledJob[]>

cancelJob(name: string): Promise<void>

Examples

Example 1: Auto-Start Daemon

Example 2: Delegate Long Task

Example 3: Schedule Daily Report

Example 4: Forward to Telegram

Integration Patterns

Pattern 1: Interactive + Background

Pattern 2: Multi-Session Coordination

Pattern 3: Task Pipeline

Configuration

config.json

Environment Variables

Troubleshooting

Issue: "Daemon not found"

Issue: "Cannot start daemon"

Issue: "Messages not delivered"

Best Practices

1. Use for Appropriate Tasks

2. Manage Resources

3. Handle Errors Gracefully

4. Monitor Daemon Health

Security Considerations

1. API Key Protection

2. Access Control

3. Network Security

Resources

Changelog

v1.0.0 (2026-02-26)

License

11 KiB

Raw Blame History

`getStatus(): Promise<DaemonStatus>`

`start(options?: StartOptions): Promise<void>`

`stop(): Promise<void>`

`send(message: string, options?: SendOptions): Promise<SendResult>`

`schedule(job: ScheduledJob): Promise<void>`

`listJobs(): Promise<ScheduledJob[]>`

`cancelJob(name: string): Promise<void>`