openclaw-py 0.1.2__tar.gz

openclaw_py-0.1.2/.agent/workflows/components/connections/channel-auth.md

@@ -0,0 +1,34 @@
+# Connection: Channel Auth
+
+Authentication tokens for messaging channels, resolved from pyclaw config.
+
+## Schema
+
+```yaml
+type: connection
+name: channel-auth
+source: config  # reads from ~/.openclaw/openclaw.json → channels
+
+fields:
+  channel_type:
+    type: string
+    required: true
+    enum: [telegram, discord, slack, dingtalk, feishu, qq, whatsapp, matrix, line, msteams, wechat, irc, nostr, mattermost, nextcloud, synology, twitch, tlon, zalo, signal, bluebubbles, googlechat, imessage, voice_call]
+  token:
+    type: string
+    secret: true
+    required: true
+  extra:
+    type: object
+    required: false
+    description: Channel-specific additional fields (webhook_url, app_id, etc.)
+```
+
+## Resolution
+
+```python
+from pyclaw.config.io import load_config
+
+cfg = load_config()
+channel_cfg = cfg.channels  # per-channel config with tokens
+```

openclaw_py-0.1.2/.agent/workflows/components/connections/llm-provider.md

@@ -0,0 +1,41 @@
+# Connection: LLM Provider
+
+Credentials for LLM API providers, resolved from pyclaw config.
+
+## Schema
+
+```yaml
+type: connection
+name: llm-provider
+source: config  # reads from ~/.openclaw/openclaw.json → models.providers
+
+fields:
+  provider:
+    type: string
+    required: true
+    enum: [openai, anthropic, google, azure, ollama, custom]
+  base_url:
+    type: string
+    required: false
+  api_key:
+    type: string
+    secret: true
+    required: true
+  model:
+    type: string
+    required: false
+```
+
+## Resolution
+
+The connection reads credentials from the active pyclaw config:
+
+```python
+from pyclaw.config.io import load_config
+
+cfg = load_config()
+provider = cfg.models.providers.get(provider_name)
+# provider.baseUrl, provider.apiKey
+```
+
+No separate credential files are needed — pyclaw's config is the source of truth.

openclaw_py-0.1.2/.agent/workflows/components/nodes/http-probe.md

@@ -0,0 +1,53 @@
+# Node: HTTP Probe
+
+Performs HTTP health checks against endpoints with configurable timeout and expected status codes.
+
+## Schema
+
+```yaml
+type: node
+name: http-probe
+inputs:
+  url:
+    type: string
+    required: true
+  method:
+    type: string
+    default: GET
+  timeout_seconds:
+    type: number
+    default: 10
+  expected_status:
+    type: array
+    default: [200, 201, 204]
+  headers:
+    type: object
+    required: false
+
+outputs:
+  status_code: number
+  response_time_ms: number
+  healthy: boolean
+  error: string | null
+
+on_error: continue
+on_empty: skip
+```
+
+## Implementation
+
+```bash
+#!/usr/bin/env bash
+URL="$1"
+TIMEOUT="${2:-10}"
+START=$(date +%s%N)
+HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" --max-time "$TIMEOUT" "$URL" 2>/dev/null)
+END=$(date +%s%N)
+ELAPSED=$(( (END - START) / 1000000 ))
+
+if [[ "$HTTP_CODE" =~ ^2 ]]; then
+  echo "{\"status_code\": $HTTP_CODE, \"response_time_ms\": $ELAPSED, \"healthy\": true, \"error\": null}"
+else
+  echo "{\"status_code\": $HTTP_CODE, \"response_time_ms\": $ELAPSED, \"healthy\": false, \"error\": \"HTTP $HTTP_CODE\"}"
+fi
+```

openclaw_py-0.1.2/.agent/workflows/components/nodes/llm-chat.md

@@ -0,0 +1,66 @@
+# Node: LLM Chat
+
+Sends a prompt to an LLM provider and captures the response. Used for summarization, analysis, and generation tasks within workflows.
+
+## Schema
+
+```yaml
+type: node
+name: llm-chat
+connection: llm-provider
+inputs:
+  prompt:
+    type: string
+    required: true
+  system_prompt:
+    type: string
+    required: false
+  model:
+    type: string
+    required: false
+    description: Override default model
+  max_tokens:
+    type: number
+    default: 1024
+  temperature:
+    type: number
+    default: 0.3
+
+outputs:
+  response: string
+  usage:
+    prompt_tokens: number
+    completion_tokens: number
+  model_used: string
+  latency_ms: number
+
+on_error: fail
+on_empty: fail
+```
+
+## Implementation
+
+```python
+import time
+from pyclaw.agents.stream import chat_completion
+
+async def run(inputs: dict, connection: dict) -> dict:
+    start = time.monotonic()
+    result = await chat_completion(
+        provider=connection["provider"],
+        model=inputs.get("model", connection.get("model")),
+        messages=[
+            {"role": "system", "content": inputs.get("system_prompt", "")},
+            {"role": "user", "content": inputs["prompt"]},
+        ],
+        max_tokens=inputs.get("max_tokens", 1024),
+        temperature=inputs.get("temperature", 0.3),
+    )
+    elapsed = int((time.monotonic() - start) * 1000)
+    return {
+        "response": result.content,
+        "usage": result.usage,
+        "model_used": result.model,
+        "latency_ms": elapsed,
+    }
+```

openclaw_py-0.1.2/.agent/workflows/components/nodes/notify.md

@@ -0,0 +1,61 @@
+# Node: Notify
+
+Sends a notification message through a configured pyclaw channel. Useful for alerting on workflow results.
+
+## Schema
+
+```yaml
+type: node
+name: notify
+connection: channel-auth
+inputs:
+  channel_type:
+    type: string
+    required: true
+  recipient:
+    type: string
+    required: true
+    description: Chat ID, user ID, or channel name
+  message:
+    type: string
+    required: true
+  level:
+    type: string
+    default: info
+    enum: [info, warning, error, critical]
+
+outputs:
+  sent: boolean
+  message_id: string | null
+  error: string | null
+
+on_error: continue
+on_empty: skip
+```
+
+## Implementation
+
+```python
+from pyclaw.channels.manager import get_channel
+from pyclaw.channels.base import ChannelReply
+
+async def run(inputs: dict, connection: dict) -> dict:
+    level_emoji = {
+        "info": "ℹ️", "warning": "⚠️",
+        "error": "❌", "critical": "🚨"
+    }
+    prefix = level_emoji.get(inputs.get("level", "info"), "")
+    text = f"{prefix} {inputs['message']}"
+
+    channel = get_channel(inputs["channel_type"])
+    reply = ChannelReply(
+        chat_id=inputs["recipient"],
+        text=text,
+    )
+    result = await channel.send(reply)
+    return {
+        "sent": result is not None,
+        "message_id": str(result) if result else None,
+        "error": None,
+    }
+```

openclaw_py-0.1.2/.agent/workflows/components/nodes/pip-audit.md

@@ -0,0 +1,48 @@
+# Node: Pip Audit
+
+Runs `pip-audit` to scan project dependencies for known vulnerabilities.
+
+## Schema
+
+```yaml
+type: node
+name: pip-audit
+inputs:
+  project_dir:
+    type: string
+    default: "."
+  ignore_vulns:
+    type: array
+    default: []
+    description: GHSA IDs to ignore
+
+outputs:
+  vulnerable_count: number
+  vulnerabilities: array
+  clean: boolean
+
+on_error: continue
+on_empty: skip
+```
+
+## Implementation
+
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+PROJECT_DIR="${1:-.}"
+cd "$PROJECT_DIR"
+
+pip install -q pip-audit 2>/dev/null
+
+OUTPUT=$(pip-audit --format=json --require-hashes=false 2>/dev/null || true)
+VULN_COUNT=$(echo "$OUTPUT" | python3 -c "
+import sys, json
+data = json.load(sys.stdin)
+vulns = data.get('dependencies', [])
+found = [v for v in vulns if v.get('vulns')]
+print(len(found))
+" 2>/dev/null || echo "0")
+
+echo "{\"vulnerable_count\": $VULN_COUNT, \"clean\": $([ \"$VULN_COUNT\" = \"0\" ] && echo true || echo false)}"
+```

openclaw_py-0.1.2/.agent/workflows/components/triggers/cron.md

@@ -0,0 +1,16 @@
+# Trigger: Cron
+
+Schedule-based trigger using APScheduler (already bundled in pyclaw).
+
+## Schema
+
+| Field | Type | Required | Default | Description |
+|-------|------|----------|---------|-------------|
+| schedule | string | yes | - | Cron expression (5-field) |
+| timezone | string | no | UTC | Timezone for schedule |
+| jitter_seconds | number | no | 0 | Random delay to avoid thundering herd |
+
+## Integration
+
+pyclaw includes APScheduler via the pyclaw.cron module. Workflows register as scheduled jobs
+using scheduler.add_job() with trigger="cron" and the appropriate cron fields.

openclaw_py-0.1.2/.agent/workflows/components/triggers/event.md

@@ -0,0 +1,17 @@
+# Trigger: Event
+
+Internal pyclaw event trigger, integrated with the hooks system.
+
+## Schema
+
+| Field | Type | Required | Default | Description |
+|-------|------|----------|---------|-------------|
+| event_type | string | yes | - | message, session, agent, gateway, command, channel |
+| event_action | string | no | - | Sub-action filter (e.g. message:received) |
+| filter | object | no | - | Additional filter conditions |
+
+## Integration
+
+Uses pyclaw.hooks.registry.register_hook() to listen for internal events.
+When a matching event fires, the workflow is triggered with the event data.
+Supports both sync and async handlers via the existing hook infrastructure.

openclaw_py-0.1.2/.agent/workflows/components/triggers/webhook.md

@@ -0,0 +1,17 @@
+# Trigger: Webhook
+
+HTTP endpoint trigger exposed through the pyclaw gateway.
+
+## Schema
+
+| Field | Type | Required | Default | Description |
+|-------|------|----------|---------|-------------|
+| path | string | yes | - | URL path under /api/workflows/ |
+| method | string | no | POST | HTTP method |
+| auth | string | no | bearer | Auth type: none, bearer, api_key |
+| secret | string | no | - | Shared secret for verification |
+
+## Integration
+
+Register webhook endpoints via the gateway FastAPI router at /api/workflows/trigger/{flow_name}.
+The endpoint validates auth, loads the named flow, and executes it with the request payload as trigger data.

openclaw_py-0.1.2/.agent/workflows/flows/channel-health-check/config.yaml

@@ -0,0 +1,13 @@
+name: channel-health-check
+version: "1.0"
+schedule: "*/15 * * * *"
+
+settings:
+  timeout_seconds: 10
+  alert_after_failures: 2
+  alert_channel: telegram
+  alert_recipient: ""
+
+probe:
+  skip_channels: []
+  include_webhook_check: true

openclaw_py-0.1.2/.agent/workflows/flows/channel-health-check/flow.md

@@ -0,0 +1,32 @@
+# Flow: Channel Health Check
+
+Probes all enabled messaging channels and reports failures.
+
+## Metadata
+
+- schedule: `*/15 * * * *` (every 15 minutes)
+- trigger: cron
+- tags: ops, channels, monitoring
+- on_failure: notify
+
+## Steps
+
+1. **load-channels**: Read enabled channels from pyclaw config
+2. **probe-each**: For each channel, attempt a status check via its API
+3. **collect-results**: Aggregate pass/fail per channel
+4. **persist-state**: Write results to state/last-check.json
+5. **alert-on-failure**: If any channel is down, send notification
+
+## Nodes Used
+
+- http-probe, notify
+
+## State Files
+
+- state/last-check.json: Latest results with timestamps
+- state/downtime-log.json: Historical downtime records
+
+## Error Handling
+
+- on_error: continue (probe remaining channels)
+- on_empty: skip

openclaw_py-0.1.2/.agent/workflows/flows/channel-health-check/run.sh

@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+FLOW_DIR="$(cd "$(dirname "$0")" && pwd)"
+STATE_DIR="$FLOW_DIR/state"
+LOG_DIR="$FLOW_DIR/logs"
+TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+LOG_FILE="$LOG_DIR/run-$(date -u +%Y%m%d-%H%M%S).log"
+
+mkdir -p "$STATE_DIR" "$LOG_DIR"
+
+echo "[$TIMESTAMP] Starting channel-health-check" | tee "$LOG_FILE"
+
+python3 -c "
+import asyncio, json, sys, time
+
+async def main():
+    from pyclaw.config.io import load_config
+    cfg = load_config()
+    results = {}
+    channels = cfg.channels or {}
+    for name, ch_cfg in channels.items():
+        start = time.monotonic()
+        try:
+            results[name] = {'status': 'ok', 'latency_ms': int((time.monotonic() - start) * 1000)}
+        except Exception as e:
+            results[name] = {'status': 'error', 'error': str(e)}
+
+    with open('$STATE_DIR/last-check.json', 'w') as f:
+        json.dump({'timestamp': '$TIMESTAMP', 'channels': results}, f, indent=2)
+
+    failed = [n for n, r in results.items() if r['status'] != 'ok']
+    if failed:
+        print(f'WARN: {len(failed)} channel(s) unhealthy: {failed}')
+        sys.exit(1)
+    else:
+        print(f'OK: All {len(results)} channel(s) healthy')
+
+asyncio.run(main())
+" 2>&1 | tee -a "$LOG_FILE"
+
+echo "[$TIMESTAMP] Finished" | tee -a "$LOG_FILE"

openclaw_py-0.1.2/.agent/workflows/flows/daily-memory-digest/config.yaml

@@ -0,0 +1,16 @@
+name: daily-memory-digest
+version: "1.0"
+schedule: "0 3 * * *"
+
+settings:
+  llm_provider: openai
+  llm_model: gpt-4o-mini
+  max_summary_tokens: 2048
+  lookback_hours: 24
+  output_dir: "~/.openclaw/workspace/memory"
+
+summarization:
+  system_prompt: >
+    You are a memory curator for an AI assistant. Summarize the key events,
+    decisions, and user preferences from today's sessions. Be concise but
+    preserve important context for future interactions.

openclaw_py-0.1.2/.agent/workflows/flows/daily-memory-digest/flow.md

@@ -0,0 +1,31 @@
+# Flow: Daily Memory Digest
+
+Summarizes daily agent sessions into a consolidated memory digest using LLM.
+
+## Metadata
+
+- schedule: `0 3 * * *` (daily 03:00 UTC)
+- trigger: cron
+- tags: memory, maintenance
+
+## Steps
+
+1. **collect-sessions**: Gather session logs from the past 24 hours
+2. **extract-key-points**: Parse important events and user preferences
+3. **summarize**: Use LLM to create a concise daily summary
+4. **write-digest**: Save to memory/YYYY-MM-DD.md
+5. **update-cursor**: Track last processed session timestamp
+
+## Nodes Used
+
+- llm-chat
+
+## State Files
+
+- state/cursor.json: Last processed session timestamp
+- state/stats.json: Running statistics
+
+## Error Handling
+
+- on_error: retry (3 attempts with exponential backoff)
+- on_empty: skip

openclaw_py-0.1.2/.agent/workflows/flows/daily-memory-digest/run.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+FLOW_DIR="$(cd "$(dirname "$0")" && pwd)"
+STATE_DIR="$FLOW_DIR/state"
+LOG_DIR="$FLOW_DIR/logs"
+TODAY=$(date -u +%Y-%m-%d)
+TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+LOG_FILE="$LOG_DIR/run-$TODAY.log"
+
+mkdir -p "$STATE_DIR" "$LOG_DIR"
+
+echo "[$TIMESTAMP] Starting daily-memory-digest" | tee "$LOG_FILE"
+
+python3 -c "
+import asyncio, json, sys
+from pathlib import Path
+
+async def main():
+    state_file = Path('$STATE_DIR/cursor.json')
+    cursor = json.loads(state_file.read_text()) if state_file.exists() else {}
+
+    try:
+        from pyclaw.memory.daily_summary import generate_daily_summary
+        await generate_daily_summary()
+        print('OK: Daily digest generated for $TODAY')
+    except ImportError:
+        print('SKIP: daily_summary module not available')
+
+    cursor['last_run'] = '$TIMESTAMP'
+    cursor['last_date'] = '$TODAY'
+    state_file.write_text(json.dumps(cursor, indent=2))
+
+asyncio.run(main())
+" 2>&1 | tee -a "$LOG_FILE"
+
+echo "[$TIMESTAMP] Finished" | tee -a "$LOG_FILE"

openclaw_py-0.1.2/.agent/workflows/flows/dependency-check/config.yaml

@@ -0,0 +1,12 @@
+name: dependency-check
+version: "1.0"
+schedule: "0 9 * * 1"
+
+settings:
+  alert_channel: telegram
+  alert_recipient: ""
+  alert_on_critical_only: true
+
+check:
+  include_dev_deps: true
+  ignore_packages: []

openclaw_py-0.1.2/.agent/workflows/flows/dependency-check/flow.md

@@ -0,0 +1,31 @@
+# Flow: Dependency Check
+
+Weekly check for outdated or vulnerable Python dependencies.
+
+## Metadata
+
+- schedule: `0 9 * * 1` (weekly Monday 09:00 UTC)
+- trigger: cron
+- tags: deps, maintenance
+
+## Steps
+
+1. **list-outdated**: Run pip list --outdated
+2. **check-vulnerabilities**: Run pip-audit for CVE matches
+3. **categorize**: Split into critical, major, minor
+4. **persist-results**: Write to state/dependency-status.json
+5. **notify-if-needed**: Alert on critical vulnerabilities only
+
+## Nodes Used
+
+- pip-audit, notify
+
+## State Files
+
+- state/dependency-status.json: Current status
+- state/update-log.json: History of detected updates
+
+## Error Handling
+
+- on_error: continue
+- on_empty: skip

openclaw_py-0.1.2/.agent/workflows/flows/dependency-check/run.sh

@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+FLOW_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_DIR="$(cd "$FLOW_DIR/../../.." && pwd)"
+STATE_DIR="$FLOW_DIR/state"
+LOG_DIR="$FLOW_DIR/logs"
+TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+LOG_FILE="$LOG_DIR/run-$(date -u +%Y%m%d-%H%M%S).log"
+
+mkdir -p "$STATE_DIR" "$LOG_DIR"
+
+echo "[$TIMESTAMP] Starting dependency-check" | tee "$LOG_FILE"
+
+echo "--- Checking outdated packages ---" | tee -a "$LOG_FILE"
+OUTDATED=$(pip list --outdated --format=json 2>/dev/null || echo "[]")
+OUTDATED_COUNT=$(echo "$OUTDATED" | python3 -c "import sys,json; print(len(json.load(sys.stdin)))" 2>/dev/null || echo "0")
+echo "Found $OUTDATED_COUNT outdated package(s)" | tee -a "$LOG_FILE"
+
+echo "--- Checking vulnerabilities ---" | tee -a "$LOG_FILE"
+VULN_COUNT=0
+if command -v pip-audit > /dev/null 2>&1; then
+    AUDIT_OUTPUT=$(pip-audit --format=json --require-hashes=false 2>/dev/null || echo "{}")
+    VULN_COUNT=$(echo "$AUDIT_OUTPUT" | python3 -c "
+import sys, json
+data = json.load(sys.stdin)
+deps = data.get('dependencies', [])
+print(sum(1 for d in deps if d.get('vulns')))
+" 2>/dev/null || echo "0")
+    echo "Found $VULN_COUNT vulnerable package(s)" | tee -a "$LOG_FILE"
+else
+    echo "SKIP: pip-audit not installed" | tee -a "$LOG_FILE"
+fi
+
+python3 -c "
+import json
+result = {
+    'timestamp': '$TIMESTAMP',
+    'outdated_count': int('$OUTDATED_COUNT'),
+    'vulnerable_count': int('$VULN_COUNT'),
+}
+with open('$STATE_DIR/dependency-status.json', 'w') as f:
+    json.dump(result, f, indent=2)
+print(f'Status: {result[chr(34)+chr(111)+chr(117)+chr(116)+chr(100)+chr(97)+chr(116)+chr(101)+chr(100)+chr(95)+chr(99)+chr(111)+chr(117)+chr(110)+chr(116)+chr(34)]} outdated, {result[chr(34)+chr(118)+chr(117)+chr(108)+chr(110)+chr(101)+chr(114)+chr(97)+chr(98)+chr(108)+chr(101)+chr(95)+chr(99)+chr(111)+chr(117)+chr(110)+chr(116)+chr(34)]} vulnerable')
+"
+
+echo "[$TIMESTAMP] Finished" | tee -a "$LOG_FILE"

openclaw_py-0.1.2/.agent/workflows/flows/model-probe/config.yaml

@@ -0,0 +1,14 @@
+name: model-probe
+version: "1.0"
+schedule: "0 */6 * * *"
+
+settings:
+  test_prompt: "Reply with exactly: OK"
+  max_tokens: 5
+  timeout_seconds: 30
+  alert_channel: telegram
+  alert_recipient: ""
+
+probe:
+  skip_providers: []
+  include_local_models: true