openclaw-node-harness 2.0.0

package/skills/google-drive/SKILL.md

@@ -0,0 +1,320 @@
+---
+name: google-drive
+description: "Google Drive API integration with managed OAuth via Maton gateway. List, search, create, download, share, and manage files and folders. Use when users want to interact with Google Drive."
+compatibility: Requires network access and valid Maton API key
+triggers:
+  - "google drive"
+  - "upload to drive"
+  - "list drive files"
+  - "download from google drive"
+  - "share a google doc"
+negative_triggers:
+  - "local filesystem"
+  - "dropbox"
+  - "icloud"
+  - "google sheets formulas"
+metadata:
+  author: maton
+  version: "1.0"
+---
+
+# Google Drive
+
+Access the Google Drive API with managed OAuth authentication. List, search, create, and manage files and folders.
+
+## Quick Start
+
+```bash
+# List files
+curl -s -X GET 'https://gateway.maton.ai/google-drive/drive/v3/files?pageSize=10' \
+  -H 'Authorization: Bearer YOUR_API_KEY'
+```
+
+## Base URL
+
+```
+https://gateway.maton.ai/google-drive/{native-api-path}
+```
+
+Replace `{native-api-path}` with the actual Google Drive API endpoint path. The gateway proxies requests to `www.googleapis.com` and automatically injects your OAuth token.
+
+## Authentication
+
+All requests require the Maton API key in the Authorization header:
+
+```
+Authorization: Bearer YOUR_API_KEY
+```
+
+**Environment Variable:** Set your API key as `MATON_API_KEY`:
+
+```bash
+export MATON_API_KEY="YOUR_API_KEY"
+```
+
+### Getting Your API Key
+
+1. Sign in or create an account at [maton.ai](https://maton.ai)
+2. Go to [maton.ai/settings](https://maton.ai/settings)
+3. Copy your API key
+
+## Connection Management
+
+Manage your Google OAuth connections at `https://ctrl.maton.ai`.
+
+### List Connections
+
+```bash
+curl -s -X GET 'https://ctrl.maton.ai/connections?app=google-drive&status=ACTIVE' \
+  -H 'Authorization: Bearer YOUR_API_KEY'
+```
+
+### Create Connection
+
+```bash
+curl -s -X POST 'https://ctrl.maton.ai/connections' \
+  -H 'Content-Type: application/json' \
+  -H 'Authorization: Bearer YOUR_API_KEY' \
+  -d '{"app": "google-drive"}'
+```
+
+### Get Connection
+
+```bash
+curl -s -X GET 'https://ctrl.maton.ai/connections/{connection_id}' \
+  -H 'Authorization: Bearer YOUR_API_KEY'
+```
+
+**Response:**
+```json
+{
+  "connection": {
+    "connection_id": "21fd90f9-5935-43cd-b6c8-bde9d915ca80",
+    "status": "ACTIVE",
+    "creation_time": "2025-12-08T07:20:53.488460Z",
+    "last_updated_time": "2026-01-31T20:03:32.593153Z",
+    "url": "https://connect.maton.ai/?session_token=...",
+    "app": "google-drive",
+    "metadata": {}
+  }
+}
+```
+
+Open the returned `url` in a browser to complete OAuth authorization.
+
+### Delete Connection
+
+```bash
+curl -s -X DELETE 'https://ctrl.maton.ai/connections/{connection_id}' \
+  -H 'Authorization: Bearer YOUR_API_KEY'
+```
+
+### Specifying Connection
+
+If you have multiple Google Drive connections, specify which one to use with the `Maton-Connection` header:
+
+```bash
+curl -s -X GET 'https://gateway.maton.ai/google-drive/drive/v3/files?pageSize=10' \
+  -H 'Authorization: Bearer YOUR_API_KEY' \
+  -H 'Maton-Connection: 21fd90f9-5935-43cd-b6c8-bde9d915ca80'
+```
+
+If omitted, the gateway uses the default (oldest) active connection.
+
+## API Reference
+
+### List Files
+
+```bash
+GET /google-drive/drive/v3/files?pageSize=10
+```
+
+With query:
+
+```bash
+GET /google-drive/drive/v3/files?q=name%20contains%20'report'&pageSize=10
+```
+
+Only folders:
+
+```bash
+GET /google-drive/drive/v3/files?q=mimeType='application/vnd.google-apps.folder'
+```
+
+Files in specific folder:
+
+```bash
+GET /google-drive/drive/v3/files?q='FOLDER_ID'+in+parents
+```
+
+With fields:
+
+```bash
+GET /google-drive/drive/v3/files?fields=files(id,name,mimeType,createdTime,modifiedTime,size)
+```
+
+### Get File Metadata
+
+```bash
+GET /google-drive/drive/v3/files/{fileId}?fields=id,name,mimeType,size,createdTime
+```
+
+### Download File Content
+
+```bash
+GET /google-drive/drive/v3/files/{fileId}?alt=media
+```
+
+### Export Google Docs
+
+```bash
+GET /google-drive/drive/v3/files/{fileId}/export?mimeType=application/pdf
+```
+
+### Create File (metadata only)
+
+```bash
+POST /google-drive/drive/v3/files
+Content-Type: application/json
+
+{
+  "name": "New Document",
+  "mimeType": "application/vnd.google-apps.document"
+}
+```
+
+### Create Folder
+
+```bash
+POST /google-drive/drive/v3/files
+Content-Type: application/json
+
+{
+  "name": "New Folder",
+  "mimeType": "application/vnd.google-apps.folder"
+}
+```
+
+### Update File Metadata
+
+```bash
+PATCH /google-drive/drive/v3/files/{fileId}
+Content-Type: application/json
+
+{
+  "name": "Renamed File"
+}
+```
+
+### Move File to Folder
+
+```bash
+PATCH /google-drive/drive/v3/files/{fileId}?addParents=NEW_FOLDER_ID&removeParents=OLD_FOLDER_ID
+```
+
+### Delete File
+
+```bash
+DELETE /google-drive/drive/v3/files/{fileId}
+```
+
+### Copy File
+
+```bash
+POST /google-drive/drive/v3/files/{fileId}/copy
+Content-Type: application/json
+
+{
+  "name": "Copy of File"
+}
+```
+
+### Share File
+
+```bash
+POST /google-drive/drive/v3/files/{fileId}/permissions
+Content-Type: application/json
+
+{
+  "role": "reader",
+  "type": "user",
+  "emailAddress": "user@example.com"
+}
+```
+
+## Query Operators
+
+Use in the `q` parameter:
+- `name = 'exact name'`
+- `name contains 'partial'`
+- `mimeType = 'application/pdf'`
+- `'folderId' in parents`
+- `trashed = false`
+- `modifiedTime > '2024-01-01T00:00:00'`
+
+Combine with `and`:
+```
+name contains 'report' and mimeType = 'application/pdf'
+```
+
+## Common MIME Types
+
+- `application/vnd.google-apps.document` - Google Docs
+- `application/vnd.google-apps.spreadsheet` - Google Sheets
+- `application/vnd.google-apps.presentation` - Google Slides
+- `application/vnd.google-apps.folder` - Folder
+- `application/pdf` - PDF
+
+## Code Examples
+
+### JavaScript
+
+```javascript
+const response = await fetch(
+  'https://gateway.maton.ai/google-drive/drive/v3/files?pageSize=10',
+  {
+    headers: {
+      'Authorization': `Bearer ${process.env.MATON_API_KEY}`
+    }
+  }
+);
+```
+
+### Python
+
+```python
+import os
+import requests
+
+response = requests.get(
+    'https://gateway.maton.ai/google-drive/drive/v3/files',
+    headers={'Authorization': f'Bearer {os.environ["MATON_API_KEY"]}'},
+    params={'pageSize': 10}
+)
+```
+
+## Notes
+
+- Use `fields` parameter to limit response data
+- Pagination uses `pageToken` from previous response's `nextPageToken`
+- Export is for Google Workspace files only
+
+## Error Handling
+
+| Status | Meaning |
+|--------|---------|
+| 400 | Missing Google Drive connection |
+| 401 | Invalid or missing Maton API key |
+| 429 | Rate limited (10 req/sec per account) |
+| 4xx/5xx | Passthrough error from Google Drive API |
+
+## Resources
+
+- [Drive API Overview](https://developers.google.com/drive/api/reference/rest/v3)
+- [List Files](https://developers.google.com/drive/api/reference/rest/v3/files/list)
+- [Get File](https://developers.google.com/drive/api/reference/rest/v3/files/get)
+- [Create File](https://developers.google.com/drive/api/reference/rest/v3/files/create)
+- [Update File](https://developers.google.com/drive/api/reference/rest/v3/files/update)
+- [Delete File](https://developers.google.com/drive/api/reference/rest/v3/files/delete)
+- [Export File](https://developers.google.com/drive/api/reference/rest/v3/files/export)
+- [Search Query Syntax](https://developers.google.com/drive/api/guides/search-files)

package/skills/growth-loop/SKILL.md

@@ -0,0 +1,270 @@
+---
+name: growth-loop
+description: "Closed-loop content/growth operations engine. Platform-agnostic, objective-agnostic. Runs the cycle: Research → Generate → Distribute → Measure → Diagnose → Iterate. Use when user wants to set up a content pipeline, growth experiment, marketing loop, outreach system, or any systematic produce-distribute-measure-learn workflow."
+triggers:
+  - "set up a content pipeline"
+  - "build a growth loop"
+  - "create a marketing loop"
+  - "run a growth experiment"
+  - "set up an outreach system"
+negative_triggers:
+  - "write a single blog post"
+  - "just do some research"
+  - "marketing strategy advice"
+metadata:
+  openclaw:
+    version: "1.0.0"
+    author: "Daedalus"
+    license: "MIT"
+    tags: ["growth", "content", "marketing", "automation", "analytics", "loop"]
+    category: "operations"
+  clawdbot:
+    emoji: "🔄"
+    requires:
+      bins: ["jq"]
+---
+
+# Growth Loop
+
+Closed-loop engine for systematic content/growth operations. Platform-agnostic, objective-agnostic.
+
+## The Loop
+
+```
+ ┌─────────────────────────────────────────┐
+ │                                         │
+ │   1. RESEARCH ──► 2. GENERATE           │
+ │        ▲               │                │
+ │        │               ▼                │
+ │   6. ITERATE     3. DISTRIBUTE          │
+ │        ▲               │                │
+ │        │               ▼                │
+ │   5. DIAGNOSE ◄── 4. MEASURE            │
+ │                                         │
+ └─────────────────────────────────────────┘
+```
+
+Every growth activity — TikTok slideshows, blog SEO, email sequences, product listings, outreach, dev marketing — is an instance of this loop with different config.
+
+## When to Use
+
+- Setting up a new content/growth channel
+- Running a produce → distribute → measure experiment
+- Building an outreach or lead-gen pipeline
+- Optimizing any conversion funnel
+- Any task where you generate something, put it in front of people, and want to learn from the results
+
+## When NOT to Use
+
+- One-off content creation (just write it directly)
+- Pure research with no distribution intent
+- Tasks where measurement isn't possible or relevant
+
+## Phases
+
+### Phase 1: RESEARCH
+
+**Goal:** Understand what works in the target space before producing anything.
+
+**Actions:**
+- Identify 5-10 top performers in the space (competitors, influencers, reference points)
+- Catalog what they do: format, frequency, tone, hooks, distribution channels
+- Note engagement patterns: what gets signal (likes, shares, saves, conversions) vs noise
+- Identify gaps: what's underserved, what's stale, where's the opening
+
+**Output:** `campaign/research.md` — competitive landscape, engagement patterns, identified gaps, initial hypotheses.
+
+**Tools to consider:** `tavily-search`, `web-search`, `deep-research`, `twitter` (timeline reads), platform-specific APIs.
+
+### Phase 2: GENERATE
+
+**Goal:** Produce content/assets based on research insights and current generation rules.
+
+**Actions:**
+- Define the content spec: format, length, tone, hook structure, CTA
+- Generate a batch (not one piece — enough to test variations)
+- Quality-check against research findings (does this match what works?)
+- Stage for review — human approves before anything goes live
+
+**Output:** `campaign/drafts/` — generated assets ready for human review.
+
+**Rules file:** `campaign/gen-rules.md` — the living document that defines *how* to generate. Updated in Phase 6.
+
+**Tools to consider:** `openai-image-gen`, `humanizer` (for text), platform-specific content tools.
+
+### Phase 3: DISTRIBUTE
+
+**Goal:** Push approved content to the target platform. Drafts first, never auto-publish.
+
+**Actions:**
+- Push to platform via API or manual staging (depends on channel)
+- Tag/label for tracking (campaign ID, variant ID, timestamp)
+- Log what was published, where, when, with what parameters
+
+**Output:** `campaign/distribution-log.jsonl` — append-only log of every piece distributed.
+
+```jsonl
+{"id":"001","platform":"twitter","published_at":"2026-02-17T20:00:00-05:00","variant":"hook-a","content_ref":"drafts/tweet-001.md","status":"live"}
+```
+
+**Tools to consider:** `twitter` (post), platform APIs, scheduling tools.
+
+### Phase 4: MEASURE
+
+**Goal:** Pull performance data back. Raw numbers, no interpretation yet.
+
+**Actions:**
+- Collect platform metrics per piece (impressions, clicks, engagement, conversions)
+- Collect business metrics if available (revenue, signups, leads generated)
+- Merge with distribution log to create unified dataset
+
+**Output:** `campaign/metrics.jsonl` — raw performance data keyed to distribution log entries.
+
+```jsonl
+{"id":"001","measured_at":"2026-02-18T20:00:00-05:00","impressions":1200,"clicks":45,"conversions":3,"revenue":0}
+```
+
+**Cadence:** Define measurement windows per channel (e.g., 24h for social, 7d for SEO, 30d for email sequences).
+
+### Phase 5: DIAGNOSE
+
+**Goal:** Figure out *why* things worked or didn't. Cross-reference engagement with actual outcomes.
+
+**Actions:**
+- Rank content by objective metric (not vanity — conversions, revenue, qualified leads)
+- Identify patterns in winners vs losers: hook type, format, topic, timing, audience
+- Find funnel breaks: high impressions but no clicks? High clicks but no conversions?
+- Compare against research hypotheses — were we right about what works?
+
+**Output:** `campaign/diagnosis.md` — what worked, what didn't, why, and where the funnel breaks.
+
+**Diagnosis framework:**
+```
+For each piece/variant:
+  - Reach: did people see it? (impressions)
+  - Hook: did they stop? (click-through rate)
+  - Hold: did they stay? (engagement rate, time on page)
+  - Convert: did they act? (conversion rate)
+  - Value: was the action worth it? (revenue per conversion)
+
+The bottleneck is the first stage that drops below threshold.
+```
+
+### Phase 6: ITERATE
+
+**Goal:** Update the generation rules based on diagnosis, then loop back to Phase 2.
+
+**Actions:**
+- Update `campaign/gen-rules.md` with specific, testable changes
+- Document what was changed and why (for future diagnosis)
+- Retire underperforming approaches explicitly (don't just hope)
+- Identify new hypotheses to test in the next batch
+
+**Output:** Updated `campaign/gen-rules.md` + `campaign/iteration-log.md` entry.
+
+**Iteration log entry format:**
+```markdown
+## Iteration N — YYYY-MM-DD HH:MM
+
+### What diagnosis showed
+- [key findings]
+
+### Changes to gen-rules
+- [specific rule changes with rationale]
+
+### Hypotheses for next batch
+- [what we're testing and expected outcome]
+
+### Retired approaches
+- [what we're stopping and why]
+```
+
+## Campaign Setup
+
+To instantiate a new loop, create a campaign directory:
+
+```
+campaign-name/
+├── config.json          # Platform, objective, audience, constraints
+├── research.md          # Phase 1 output
+├── gen-rules.md         # Living generation rules (updated each iteration)
+├── drafts/              # Phase 2 output (human reviews before distribution)
+├── distribution-log.jsonl  # Phase 3 log
+├── metrics.jsonl        # Phase 4 data
+├── diagnosis.md         # Phase 5 analysis (rewritten each cycle)
+├── iteration-log.md     # Phase 6 changelog (append-only)
+└── archive/             # Old drafts, superseded rules, etc.
+```
+
+### config.json
+
+```json
+{
+  "name": "campaign-name",
+  "platform": "twitter|blog|email|marketplace|github|outreach|custom",
+  "objective": "what success looks like in one sentence",
+  "audience": "who we're reaching",
+  "kpi": "primary metric we optimize for",
+  "secondary_kpis": ["other metrics worth tracking"],
+  "constraints": {
+    "budget": "0|amount",
+    "frequency": "pieces per period",
+    "tone": "brand voice notes",
+    "human_approval": true
+  },
+  "measurement_window": "24h|7d|30d",
+  "created_at": "ISO timestamp",
+  "status": "research|generating|distributing|measuring|diagnosing|iterating|paused"
+}
+```
+
+## Platform Playbooks
+
+These are starting-point `gen-rules.md` templates. Each gets refined by the loop.
+
+### Social (Twitter, TikTok, Instagram)
+- Hook in first line/3 seconds
+- One idea per post
+- Native format (no external links in feed posts — thread or carousel instead)
+- Post frequency: test 1-3x/day, measure, adjust
+- KPI: engagement rate → profile visits → link clicks → conversions
+
+### Blog / SEO
+- Target specific long-tail keyword per piece
+- Structure: hook → problem → solution → proof → CTA
+- Internal linking to conversion pages
+- KPI: organic traffic → time on page → conversion rate
+
+### Email
+- Subject line = everything (test 3 variants minimum)
+- One CTA per email
+- Sequence logic: trigger → value → value → soft ask → hard ask → break
+- KPI: open rate → click rate → conversion rate → unsubscribe rate (ceiling)
+
+### Outreach (Sales, Partnerships, PR)
+- Personalization in first sentence (prove you know them)
+- Value prop in second sentence (what's in it for them)
+- CTA = low friction (reply, not signup)
+- Follow-up cadence: day 3, day 7, day 14, stop
+- KPI: response rate → meeting rate → close rate
+
+### Product Listings (Marketplace, App Store)
+- Title optimization: primary keyword + differentiator
+- Images: hero shot, feature callouts, social proof, size/scale reference
+- Description: benefit-led, scannable, keyword-rich
+- KPI: impressions → click-through → conversion rate → reviews
+
+### Dev Marketing (GitHub, DevRel)
+- README = landing page (problem → solution → quickstart → proof)
+- Example projects > documentation walls
+- Community engagement: answer issues fast, ship what people ask for
+- KPI: stars → clones → issues opened → contributors → downstream usage
+
+## Scripts
+
+- `scripts/init-campaign.sh <name> <platform>` — scaffold a new campaign directory with config template and platform-specific gen-rules starter.
+
+## References
+
+- `references/diagnosis-framework.md` — expanded funnel diagnosis methodology.
+- `references/platform-benchmarks.md` — baseline metrics by platform (what "good" looks like).

package/skills/growth-loop/_meta.json

@@ -0,0 +1,9 @@
+{
+  "owner": "daedalus",
+  "slug": "growth-loop",
+  "displayName": "Growth Loop",
+  "latest": {
+    "version": "1.0.0",
+    "publishedAt": 1739836800000
+  }
+}

package/skills/growth-loop/references/diagnosis-framework.md

@@ -0,0 +1,84 @@
+# Diagnosis Framework
+
+## The Funnel
+
+Every piece of content passes through a funnel. Diagnosis means finding where it breaks.
+
+```
+REACH → HOOK → HOLD → CONVERT → VALUE
+  │       │       │       │        │
+  │       │       │       │        └─ Revenue per conversion
+  │       │       │       └─ Conversion rate (action taken)
+  │       │       └─ Engagement / time on page / watch time
+  │       └─ Click-through rate / stop rate
+  └─ Impressions / deliverability
+```
+
+**The bottleneck is the first stage that drops below threshold.**
+
+Don't optimize Hook if Reach is the problem. Don't optimize Convert if nobody's staying past the first 3 seconds.
+
+## Stage Thresholds (starting points — calibrate with platform benchmarks)
+
+| Stage | Metric | Poor | OK | Good |
+|-------|--------|------|----|------|
+| Reach | Impressions relative to audience size | <1% | 1-5% | >5% |
+| Hook | CTR / stop rate | <1% | 1-3% | >3% |
+| Hold | Engagement rate / avg time | <10s / <5% | 10-30s / 5-15% | >30s / >15% |
+| Convert | Conversion rate | <0.5% | 0.5-2% | >2% |
+| Value | Revenue per conversion | Below CAC | At CAC | Above CAC |
+
+These vary wildly by platform and audience. Replace with your own baselines after 2-3 measurement cycles.
+
+## Diagnosis Protocol
+
+### Step 1: Sort by Objective
+
+Rank all pieces by the KPI that matters (usually conversions or revenue, not impressions).
+
+### Step 2: Compare Winners vs Losers
+
+For top 20% vs bottom 20%, compare:
+- Content attributes: topic, format, length, hook type, CTA type
+- Distribution attributes: time of day, day of week, channel variant
+- Audience attributes: segment, source, device (if available)
+
+### Step 3: Identify the Break Point
+
+For underperformers, walk the funnel:
+1. Did people see it? (Reach) — if no: distribution problem
+2. Did they stop/click? (Hook) — if no: hook/headline problem
+3. Did they stay? (Hold) — if no: content quality or format problem
+4. Did they act? (Convert) — if no: CTA, offer, or trust problem
+5. Was the action valuable? (Value) — if no: targeting or offer-market fit problem
+
+### Step 4: Formulate Testable Hypotheses
+
+Bad: "We need better content"
+Good: "Hook-style A (question) outperformed hook-style B (statement) by 2.3x CTR. Next batch: 70% question hooks, test a third style (bold claim)."
+
+### Step 5: Update Gen-Rules
+
+Every diagnosis should produce at least one specific, testable change to `gen-rules.md`. If diagnosis doesn't change anything, the measurement wasn't granular enough.
+
+## Common Patterns
+
+### High Reach, Low Hook
+- Headlines/hooks aren't stopping people
+- Fix: test different hook archetypes (question, bold claim, number, story, controversy)
+
+### High Hook, Low Hold
+- Content doesn't deliver on the hook's promise
+- Fix: front-load value, reduce fluff, match hook specificity
+
+### High Hold, Low Convert
+- People like the content but don't take action
+- Fix: CTA clarity, reduce friction, add urgency or social proof near CTA
+
+### High Convert, Low Value
+- Getting conversions but they're not worth much
+- Fix: targeting (wrong audience), offer mismatch, or qualification step needed
+
+### Everything Low
+- Wrong channel, wrong audience, or wrong offer entirely
+- Fix: go back to Phase 1 (Research). This isn't an optimization problem, it's a strategy problem.