create-ironclaws 1.0.0

package/template/container/tools/slack_history_tool.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""
+Slack channel history tool for Byte agent.
+
+Usage:
+  # Fetch last 180 days of messages
+  python3 slack_history_tool.py history --channel C05DV1DU58R --days 180
+
+  # Fetch messages since a specific date
+  python3 slack_history_tool.py history --channel C05DV1DU58R --since 2026-01-01
+
+  # Fetch messages since a Unix timestamp (for incremental reads)
+  python3 slack_history_tool.py history --channel C05DV1DU58R --oldest 1700000000
+
+Environment variables (required):
+  SLACK_BOT_TOKEN    Bot token with channels:history or groups:history scope
+"""
+
+import argparse
+import json
+import os
+import sys
+from datetime import datetime, timedelta
+import urllib.request
+import urllib.parse
+
+SLACK_BOT_TOKEN = os.environ.get('SLACK_BOT_TOKEN', '')
+
+_user_cache: dict = {}
+
+
+def slack_api(method: str, params: dict) -> dict:
+    url = f'https://slack.com/api/{method}'
+    data = urllib.parse.urlencode(params).encode()
+    req = urllib.request.Request(url, data=data, method='POST')
+    # Authorization is optional — if token absent, OneCLI HTTPS proxy injects it.
+    if SLACK_BOT_TOKEN:
+        req.add_header('Authorization', f'Bearer {SLACK_BOT_TOKEN}')
+    req.add_header('Content-Type', 'application/x-www-form-urlencoded')
+    with urllib.request.urlopen(req, timeout=30) as response:
+        return json.loads(response.read())
+
+
+def resolve_user(user_id: str) -> str:
+    if not user_id:
+        return 'Unknown'
+    if user_id in _user_cache:
+        return _user_cache[user_id]
+    try:
+        result = slack_api('users.info', {'user': user_id})
+        name = (
+            result.get('user', {}).get('real_name')
+            or result.get('user', {}).get('name')
+            or user_id
+        )
+        _user_cache[user_id] = name
+        return name
+    except Exception:
+        _user_cache[user_id] = user_id
+        return user_id
+
+
+def fetch_history(channel: str, oldest: str) -> list:
+    messages = []
+    cursor = None
+
+    while True:
+        params: dict = {
+            'channel': channel,
+            'limit': 200,
+            'oldest': oldest,
+        }
+        if cursor:
+            params['cursor'] = cursor
+
+        result = slack_api('conversations.history', params)
+
+        if not result.get('ok'):
+            print(f"Error: {result.get('error', 'unknown')}", file=sys.stderr)
+            break
+
+        messages.extend(result.get('messages', []))
+
+        if not result.get('has_more'):
+            break
+
+        cursor = result.get('response_metadata', {}).get('next_cursor')
+        if not cursor:
+            break
+
+    return messages
+
+
+def format_messages(messages: list) -> str:
+    lines = []
+    # API returns newest first — reverse for chronological order
+    for msg in reversed(messages):
+        # Skip system messages (joins, topic changes, etc.)
+        if msg.get('subtype'):
+            continue
+        text = msg.get('text', '').strip()
+        if not text:
+            continue
+
+        ts = float(msg.get('ts', 0))
+        dt = datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M')
+        user_name = resolve_user(msg.get('user', ''))
+
+        lines.append(f'[{dt}] {user_name}: {text}')
+
+    return '\n'.join(lines)
+
+
+def main():
+    # SLACK_BOT_TOKEN is optional — if absent, OneCLI HTTPS proxy injects Authorization.
+    parser = argparse.ArgumentParser(description='Fetch Slack channel history')
+    subparsers = parser.add_subparsers(dest='command')
+
+    history_parser = subparsers.add_parser('history', help='Fetch channel message history')
+    history_parser.add_argument('--channel', required=True, help='Slack channel ID')
+    history_parser.add_argument('--days', type=int, default=180, help='Number of days back (default: 180)')
+    history_parser.add_argument('--since', help='Fetch since this date (ISO format: 2026-01-01)')
+    history_parser.add_argument('--oldest', help='Fetch since this Unix timestamp')
+
+    args = parser.parse_args()
+
+    if args.command == 'history':
+        if args.oldest:
+            oldest = args.oldest
+        elif args.since:
+            dt = datetime.fromisoformat(args.since)
+            oldest = str(dt.timestamp())
+        else:
+            dt = datetime.now() - timedelta(days=args.days)
+            oldest = str(dt.timestamp())
+
+        messages = fetch_history(args.channel, oldest=oldest)
+        print(format_messages(messages))
+    else:
+        parser.print_help()
+
+
+if __name__ == '__main__':
+    main()

package/template/container/tools/youtube_tool.py

@@ -0,0 +1,174 @@
+"""
+Standalone YouTube tool for Argus agents.
+Search YouTube channel videos and fetch transcripts.
+
+Usage:
+  # Search for videos in a channel
+  python3 youtube_tool.py search --query "security overview" --channel UC_CHANNEL_ID
+
+  # Get transcript for a specific video
+  python3 youtube_tool.py transcript --video-id dQw4w9WgXcQ
+
+Environment variables (required):
+  GOOGLE_ACCESS_TOKEN   Google OAuth2 access token (with YouTube Data API scope)
+
+Optional (for transcript fallback if youtube-transcript-api needs no auth):
+  None — transcript fetching uses youtube-transcript-api which is unauthenticated.
+"""
+
+import argparse
+import os
+import sys
+
+try:
+    import requests
+except ImportError:
+    print("ERROR: 'requests' is not installed.", file=sys.stderr)
+    sys.exit(1)
+
+YOUTUBE_API_BASE = "https://www.googleapis.com/youtube/v3"
+
+
+def get_access_token():
+    """Get Google access token for YouTube Data API."""
+    token = os.environ.get("GOOGLE_ACCESS_TOKEN", "").strip()
+    if not token:
+        print("ERROR: GOOGLE_ACCESS_TOKEN must be set.", file=sys.stderr)
+        sys.exit(1)
+    return token
+
+
+def cmd_search(args):
+    token = get_access_token()
+    query = args.query
+    channel_id = args.channel
+
+    params = {
+        "part": "snippet",
+        "q": query,
+        "type": "video",
+        "maxResults": 10,
+        "order": "relevance",
+    }
+    if channel_id:
+        params["channelId"] = channel_id
+
+    resp = requests.get(
+        f"{YOUTUBE_API_BASE}/search",
+        headers={"Authorization": f"Bearer {token}"},
+        params=params,
+        timeout=30,
+    )
+    resp.raise_for_status()
+    data = resp.json()
+
+    items = data.get("items", [])
+    if not items:
+        print("No videos found matching your query.")
+        return
+
+    print(f"# Search Results ({len(items)} videos)\n")
+    for item in items:
+        video_id = item.get("id", {}).get("videoId", "")
+        snippet = item.get("snippet", {})
+        title = snippet.get("title", "Untitled")
+        description = snippet.get("description", "")
+        published = snippet.get("publishedAt", "")
+        channel_title = snippet.get("channelTitle", "")
+        video_url = f"https://www.youtube.com/watch?v={video_id}"
+
+        print(f"## {title}")
+        print(f"**Video ID:** {video_id}")
+        print(f"**URL:** {video_url}")
+        if channel_title:
+            print(f"**Channel:** {channel_title}")
+        if published:
+            print(f"**Published:** {published}")
+        if description:
+            print(f"**Description:** {description}")
+        print()
+        print("---\n")
+
+
+def cmd_transcript(args):
+    video_id = args.video_id
+
+    # First, try to get video metadata via YouTube Data API (if token available)
+    title = ""
+    token = os.environ.get("GOOGLE_ACCESS_TOKEN", "").strip()
+    if token:
+        try:
+            resp = requests.get(
+                f"{YOUTUBE_API_BASE}/videos",
+                headers={"Authorization": f"Bearer {token}"},
+                params={"part": "snippet", "id": video_id},
+                timeout=30,
+            )
+            resp.raise_for_status()
+            items = resp.json().get("items", [])
+            if items:
+                title = items[0].get("snippet", {}).get("title", "")
+        except Exception:
+            pass  # Non-fatal — we still want the transcript
+
+    video_url = f"https://www.youtube.com/watch?v={video_id}"
+
+    # Fetch transcript using youtube-transcript-api
+    try:
+        from youtube_transcript_api import YouTubeTranscriptApi
+    except ImportError:
+        print(
+            "ERROR: 'youtube-transcript-api' is not installed. "
+            "Install it with: pip install youtube-transcript-api",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    try:
+        transcript_list = YouTubeTranscriptApi.get_transcript(video_id)
+    except Exception as e:
+        print(f"ERROR: Could not fetch transcript for video {video_id}: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    # Format transcript as plain text
+    transcript_text = "\n".join(entry.get("text", "") for entry in transcript_list)
+
+    if title:
+        print(f"# {title}")
+    print(f"**Video URL:** {video_url}")
+    print(f"**Video ID:** {video_id}")
+    print(f"\n## Transcript\n")
+    print(transcript_text)
+
+
+def parse_args():
+    p = argparse.ArgumentParser(description="YouTube tool for Argus agents")
+    sub = p.add_subparsers(dest="command")
+
+    s = sub.add_parser("search", help="Search YouTube videos")
+    s.add_argument("--query", required=True, help="Search query text")
+    s.add_argument("--channel", default=None, help="YouTube channel ID to search within (optional)")
+
+    t = sub.add_parser("transcript", help="Get transcript for a YouTube video")
+    t.add_argument("--video-id", required=True, help="YouTube video ID")
+
+    return p.parse_args()
+
+
+def main():
+    args = parse_args()
+    if not args.command:
+        print("ERROR: specify a command (search or transcript). Use --help for usage.", file=sys.stderr)
+        sys.exit(1)
+    try:
+        {"search": cmd_search, "transcript": cmd_transcript}[args.command](args)
+    except requests.HTTPError as e:
+        print(f"ERROR: YouTube API error: {e}\n{e.response.text}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/template/docker-compose.yml

@@ -0,0 +1,54 @@
+# IronClaws infrastructure
+# Starts OneCLI (credential proxy) and its PostgreSQL database.
+# NanoClaw itself runs on the host: npm run dev
+#
+# Usage:
+#   docker compose up -d        # start
+#   docker compose down         # stop
+#   docker compose logs onecli  # check logs
+
+services:
+  postgres:
+    image: postgres:18-alpine
+    environment:
+      POSTGRES_USER: onecli
+      POSTGRES_PASSWORD: onecli
+      POSTGRES_DB: onecli
+    volumes:
+      - onecli_postgres:/var/lib/postgresql/data
+    networks:
+      - onecli_net
+    restart: unless-stopped
+
+  onecli:
+    image: ghcr.io/onecli/onecli:latest
+    ports:
+      - "10254:10254"   # Management API
+      - "10255:10255"   # Credential proxy gateway
+    environment:
+      DATABASE_URL: postgresql://onecli:onecli@postgres:5432/onecli
+      APP_URL: http://0.0.0.0:10254
+      NEXT_PUBLIC_APP_URL: http://0.0.0.0:10254
+      AUTH_TRUST_HOST: "true"
+      NEXTAUTH_URL: http://localhost:10254
+    volumes:
+      - onecli_data:/app/data
+    networks:
+      - onecli_net
+    depends_on:
+      - postgres
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD-SHELL", "wget -qO- http://localhost:10254/api/health 2>/dev/null || wget -qO- http://localhost:10254 2>/dev/null | grep -q . && echo ok"]
+      interval: 5s
+      timeout: 5s
+      retries: 30
+      start_period: 10s
+
+volumes:
+  onecli_postgres:
+  onecli_data:
+
+networks:
+  onecli_net:
+    name: onecli_onecli