@sulala/agent-os 0.1.4 → 0.1.6

package/data/skills/weather/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: weather
+description: Get current weather and forecasts (no API key required). Use when the user asks for weather, temperature, or forecast in a city or location.
+homepage: https://wttr.in/:help
+metadata:
+  clawdbot:
+    emoji: "🌤️"
+    requires:
+      bins:
+        - curl
+---
+
+# Weather
+
+Two free services, no API keys needed. Use the **exec** tool (no `skill_id` needed for curl, or use `skill_id: "weather"` if running from skill dir). Commands below use **curl**.
+
+## wttr.in (primary)
+
+Quick one-liner:
+
+```bash
+curl -s "wttr.in/London?format=3"
+# Output: London: ⛅️ +8°C
+```
+
+Compact format:
+
+```bash
+curl -s "wttr.in/London?format=%l:+%c+%t+%h+%w"
+# Output: London: ⛅️ +8°C 71% ↙5km/h
+```
+
+Full forecast:
+
+```bash
+curl -s "wttr.in/London?T"
+```
+
+Format codes: `%c` condition · `%t` temp · `%h` humidity · `%w` wind · `%l` location · `%m` moon
+
+Tips:
+
+- URL-encode spaces: `wttr.in/New+York`
+- Airport codes: `wttr.in/JFK`
+- Units: `?m` (metric) `?u` (USCS)
+- Today only: `?1` · Current only: `?0`
+- PNG: `curl -s "wttr.in/Berlin.png" -o /tmp/weather.png`
+
+## Open-Meteo (fallback, JSON)
+
+Free, no key, good for programmatic use:
+
+```bash
+curl -s "https://api.open-meteo.com/v1/forecast?latitude=51.5&longitude=-0.12&current_weather=true"
+```
+
+Find coordinates for a city, then query. Returns JSON with temp, windspeed, weathercode.
+
+Docs: https://open-meteo.com/en/docs

package/data/skills/web-search/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: web-search
+description: Search the web and get titles, snippets, and URLs. Use when the user says "search the web for …", "find recent info on …", "look up …", "what's the latest on …".
+credentials:
+  - SERPER_API_KEY
+metadata:
+  clawdbot:
+    emoji: "🔍"
+    requires:
+      bins:
+        - curl
+---
+
+# Web search
+
+Search the web via the **Serper** API (Google search). Results are returned as JSON (organic results with title, link, snippet). Use the **exec** tool with **skill_id: "web-search"** so `SERPER_API_KEY` is injected from skill config.
+
+## Prerequisites
+
+1. Add the **web-search** skill to the agent.
+2. Set **SERPER_API_KEY** in Skills → web-search → Setup (see **Setup** below).
+
+## Setup
+
+Get an API key from [serper.dev](https://serper.dev). Free tier: 2,500 searches/month.
+
+1. Sign up at https://serper.dev
+2. Copy your API key from the dashboard.
+3. In the dashboard: **Skills** → **web-search** → ⋮ → **Setup** → paste the key as **Serper API key** → Save.
+
+## Usage
+
+Run the script with a single argument (the search query). From the skill directory:
+
+- **skill_id:** `web-search`
+- **command:** `./scripts/search.sh "what is the capital of France"`
+
+The script POSTs to Serper and returns JSON. Example response shape (abbreviated):
+
+```json
+{
+  "organic": [
+    { "title": "...", "link": "https://...", "snippet": "..." },
+    ...
+  ]
+}
+```
+
+Summarize the `organic` array (title, link, snippet) for the user. For "latest" or news-style queries, use the same command; results are ordered by relevance/recency.
+
+## Tips
+
+- Quote the query in the command so multi-word searches work: `./scripts/search.sh "best practices for TypeScript 2024"`.
+- If the response is large, the agent can summarize the first few results or filter by relevance.
+- Serper also supports images, news, places; the default script uses `/search`. For news-only, the API endpoint is `https://google.serper.dev/news` with the same body and key.

package/data/skills/web-search/config.schema.json

@@ -0,0 +1,12 @@
+{
+  "type": "object",
+  "properties": {
+    "SERPER_API_KEY": {
+      "type": "string",
+      "format": "password",
+      "title": "Serper API key",
+      "description": "API key from serper.dev. Free tier: 2500 searches/month. Set in skill config."
+    }
+  },
+  "required": ["SERPER_API_KEY"]
+}

package/data/skills/web-search/scripts/search.sh

@@ -0,0 +1,21 @@
+#!/bin/sh
+# Search the web via Serper (Google) API. SERPER_API_KEY from skill config (injected as env by exec).
+# Usage: search.sh "your search query"
+if [ -z "$SERPER_API_KEY" ]; then
+  echo "SERPER_API_KEY is not set. Configure it in the web-search skill settings (Skills → web-search → Setup)." >&2
+  exit 1
+fi
+if [ -z "$1" ]; then
+  echo "Usage: search.sh \"search query\"" >&2
+  exit 1
+fi
+# Build JSON body safely (jq preferred; fallback to simple printf)
+if command -v jq >/dev/null 2>&1; then
+  body=$(jq -n --arg q "$1" '{q: $q}')
+else
+  body="{\"q\": \"$(printf '%s' "$1" | sed 's/\\/\\\\/g; s/"/\\"/g')\"}"
+fi
+curl -sS -X POST "https://google.serper.dev/search" \
+  -H "X-API-KEY: $SERPER_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d "$body"

package/data/skills/webhook/SKILL.md

@@ -0,0 +1,101 @@
+---
+name: webhook
+description: Send a notification or message to a configurable webhook URL (e.g. Slack, Discord). Use when the user says "notify me when …", "send this to Slack", "post a reminder", "send to webhook", "notify …".
+credentials:
+  - WEBHOOK_URL
+metadata:
+  clawdbot:
+    emoji: "🔔"
+    requires:
+      bins:
+        - curl
+---
+
+# Webhook / Notify
+
+POST a JSON body to a URL configured in the skill. The **webhook URL** is stored in skill config (Skills → webhook → Configure) so the agent never sees it. Use the **exec** tool with **skill_id: "webhook"** so `WEBHOOK_URL` is injected from config.
+
+## Prerequisites
+
+1. Add the **webhook** skill to the agent.
+2. Configure **WEBHOOK_URL** in the skill (Skills → webhook → ⋮ → Setup). See **Setup** below for where to get the URL.
+
+## Setup
+
+Set **WEBHOOK_URL** in Skills → webhook → Setup. Where to get it:
+
+### Slack — Incoming Webhook URL
+
+1. Open [Slack API apps](https://api.slack.com/apps) and sign in.
+2. **Create an app** → **From scratch** (or use an existing app).
+3. Open the app → **Incoming Webhooks** in the left sidebar → turn **Activate Incoming Webhooks** **On**.
+4. At the bottom, click **Add New Webhook to Workspace**.
+5. Pick the **channel** where messages should go (e.g. `#general` or `#notifications`) → **Allow**.
+6. Copy the **Webhook URL** (looks like `https://hooks.slack.com/services/T00000000/B00000000/xxxxxxxxxxxxxxxxxxxxxxxx`).
+
+That URL is your **WEBHOOK_URL** for Slack. Each “Add New Webhook to Workspace” creates one URL; you can add more for other channels.
+
+Docs: [Slack Incoming Webhooks](https://api.slack.com/messaging/webhooks).
+
+### Discord — Webhook URL
+
+1. Open your Discord server.
+2. Go to **Server settings** (gear by the server name) → **Integrations** → **Webhooks** (or right‑click the channel → **Edit channel** → **Integrations** → **Webhooks**).
+3. Click **New Webhook** (or **Create Webhook**).
+4. Name it (e.g. “Agent notifications”), choose the **channel**, then **Copy Webhook URL**.
+
+The URL looks like: `https://discord.com/api/webhooks/1234567890123456789/AbCdEfGhIjKlMnOpQrStUvWxYz...`
+
+That’s your **WEBHOOK_URL** for Discord.
+
+Docs: [Discord Webhooks](https://discord.com/developers/docs/resources/webhook).
+
+## Send a message (script)
+
+Use the **exec** tool with **skill_id: "webhook"** and a **command** that runs the script. The script receives the JSON body as its first argument; `WEBHOOK_URL` comes from skill config (injected as env).
+
+**Example (Slack-style):**
+
+- `skill_id`: `webhook`
+- `command`: `./scripts/post.sh '{"text":"Hello from the agent"}'`
+
+**Example (Discord-style):**
+
+- `skill_id`: `webhook`
+- `command`: `./scripts/post.sh '{"content":"Reminder: standup in 5 min"}'`
+
+Slack incoming webhooks expect:
+
+```json
+{"text": "Your message here"}
+```
+
+Discord webhooks often expect:
+
+```json
+{"content": "Your message here"}
+```
+
+Or with username:
+
+```json
+{"content": "Reminder: standup in 5 min", "username": "Agent"}
+```
+
+Use the format required by your endpoint. The script sends the body as-is with `Content-Type: application/json`.
+
+## Direct curl (if URL is not sensitive)
+
+If the user provides the webhook URL in the message (e.g. "post this to https://hooks.slack.com/..."), you can use exec **without** skill_id and run curl directly:
+
+```bash
+curl -sS -X POST -H "Content-Type: application/json" -d '{"text":"Message"}' "https://user-provided-url"
+```
+
+Prefer the script + skill config when the URL should stay private.
+
+## Tips
+
+- Escape the JSON properly in the shell: use single quotes around the JSON and escape any single quotes inside (e.g. `'"'"'` to embed a quote).
+- For Slack, keep the payload to `{"text": "..."}` for simple messages.
+- For "notify me when X" or "remind me", send a short, clear message to the webhook; the agent does not schedule future notifications (that would require a scheduler or external service).

package/data/skills/webhook/config.schema.json

@@ -0,0 +1,11 @@
+{
+  "type": "object",
+  "properties": {
+    "WEBHOOK_URL": {
+      "type": "string",
+      "title": "Webhook URL",
+      "description": "Full URL to POST to (e.g. Slack incoming webhook, Discord webhook, or any HTTP endpoint). Set in skill config so the agent can send notifications without seeing the URL."
+    }
+  },
+  "required": ["WEBHOOK_URL"]
+}

package/data/skills/webhook/scripts/post.sh

@@ -0,0 +1,13 @@
+#!/bin/sh
+# POST a JSON body to WEBHOOK_URL (from skill config, injected as env by exec).
+# Usage: post.sh '<json>'
+# Example: post.sh '{"text":"Hello from the agent"}'
+if [ -z "$WEBHOOK_URL" ]; then
+  echo "WEBHOOK_URL is not set. Configure it in the webhook skill settings." >&2
+  exit 1
+fi
+if [ -z "$1" ]; then
+  echo "Usage: post.sh '<json body>'" >&2
+  exit 1
+fi
+curl -sS -X POST -H "Content-Type: application/json" -d "$1" "$WEBHOOK_URL"

package/data/skills/youtube/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: youtube
+description: Upload videos (or Shorts) to YouTube using a local OAuth setup. Uses a script in the skill directory; run it via the exec tool. Use when the user wants to upload a video, publish to YouTube, or upload Shorts.
+credentials:
+  - YOUTUBE_CLIENT_SECRET_JSON
+---
+
+
+# YouTube upload
+
+Upload videos to **YouTube** using a **script** in this skill. Credentials are stored in the skill directory (`client_secret.json` + `token.json`). Use the **exec** tool to run the script; no static upload code in the loader.
+
+## Overview
+
+1. **One-time setup**: Enable YouTube Data API v3, create an OAuth Desktop client, add the client JSON via Skills → Configure (or place `client_secret.json` in the skill). Install Node dependencies with **npm install** (see below). Run the upload script once to complete browser OAuth; `token.json` is saved for reuse.
+2. **Upload**: Use **exec** with `skill_id: "youtube"` and a `command` that runs **node scripts/youtube_upload.js** (recommended) or the Python script, with `--file`, `--title`, and optional `--description`, `--tags`, `--privacy`.
+
+## Setup
+
+Follow these steps so the skill can upload to your YouTube account. The **Skills → YouTube → Configure** dialog (Setup button) shows this section and a field for the client JSON.
+
+1. **Google Cloud project**  
+   Go to [Google Cloud Console](https://console.cloud.google.com/). Create or select a project.
+
+2. **Enable YouTube Data API v3**  
+   APIs & Services → Library → search “YouTube Data API v3” → Enable.
+
+3. **Create OAuth 2.0 credentials**  
+   APIs & Services → Credentials → Create Credentials → **OAuth client ID**.  
+   - If asked, configure the OAuth consent screen (e.g. External, add your email).  
+   - Application type: **Web application** (so you can set a redirect URI).  
+   - Name: e.g. “YouTube upload”.  
+   - Under **Authorized redirect URIs**, click Add URI and add exactly:  
+     **`http://localhost:8090/`**  
+     (If this is missing, you will get “Error 400: redirect_uri_mismatch” when signing in.)  
+   - Create. Copy or download the client JSON.
+
+4. **Add the client JSON to this skill**  
+   Paste the **full JSON** (the whole file content) into the **OAuth client JSON** field below (Skills → YouTube → Configure), then Save.  
+   Alternatively, save the file as `scripts/client_secret.json` in the YouTube skill directory.
+
+5. **Install Node dependencies**  
+   From the skill directory run: `npm install`. The agent can do this via exec with `skill_id: "youtube"`, `command: "npm install"`.
+
+6. **First sign-in**  
+   Run the upload script once (e.g. with a test video). A browser opens; sign in with your Google account and allow access. After that, `token.json` is saved and future uploads do not require signing in again.
+
+Details: [references/youtube-upload.md](references/youtube-upload.md).
+
+## Install dependencies (agent must do this when needed)
+
+**Preferred (Node):** If the Node script fails with "Missing npm dependencies", or before first upload, install with **exec** and `skill_id: "youtube"`, `command: "npm install"`. Then retry. No system Python or pip needed.
+
+**Optional (Python):** If using the Python script and it reports missing Google API packages, use a virtual environment; the agent cannot install into system Python on externally-managed systems (e.g. macOS).
+
+## Upload video (exec tool)
+
+Use **exec** with `skill_id: "youtube"` (command runs in the skill directory).
+
+**Recommended — Node script (no Python/pip):**  
+`node scripts/youtube_upload.js --file <path> --title "<title>" [--description "<desc>"] [--tags "tag1,tag2"] [--privacy public|private|unlisted]`
+
+Example:
+
+```json
+{
+  "skill_id": "youtube",
+  "command": "node scripts/youtube_upload.js --file /path/to/video.mp4 --title \"My video\" --description \"Optional\" --tags \"shorts,demo\" --privacy public"
+}
+```
+
+**Optional — Python script** (requires venv + pip): `python3 scripts/youtube_upload.py --file ... --title ...`
+
+- **--file**: Path to the video file (absolute or relative to skill dir). Must be reachable where the agent runs.
+- **--title**: Required. **--description**, **--tags**, **--privacy** optional (default: `public`).
+
+**Interpreting exec result:** After running the upload script, check **stdout**. If it contains a line like `Uploaded: https://youtube.com/watch?v=...`, the upload **succeeded**. Tell the user the video was uploaded and give them that URL. Do not say authorization is required when stdout shows a success URL. If exitCode is non-zero but stdout contains the upload URL, still report success (the script may have been interrupted after writing the URL). Only when stdout has no upload URL and stderr says "Open this URL in your browser" should you ask the user to authorize.
+
+Full script options: [references/youtube-upload.md](references/youtube-upload.md).
+
+## Skill layout
+
+- **scripts/youtube_upload.js** — Node upload script (recommended): `--file`, `--title`, `--description`, `--tags`, `--privacy`. No Python/pip required.
+- **scripts/youtube_upload.py** — Python upload script (optional; requires venv + pip install).
+- **package.json** — Node dependencies (googleapis). Run `npm install` in the skill dir.
+- **config.schema.json** — defines `YOUTUBE_CLIENT_SECRET_JSON` for the Skills config UI.
+- **scripts/client_secret.json** — (optional) OAuth client JSON if not set via Skills → Configure.
+- **scripts/token.json** — (created on first run) stored credentials; shared by both scripts.
+- **requirements.txt** — pip dependencies for the Python script only.
+- **references/youtube-upload.md** — setup, usage, and exec examples.
+- **SKILL.md** — this file.

package/data/skills/youtube/config.schema.json

@@ -0,0 +1,11 @@
+{
+  "type": "object",
+  "properties": {
+    "YOUTUBE_CLIENT_SECRET_JSON": {
+      "type": "string",
+      "format": "password",
+      "title": "OAuth client JSON",
+      "description": "Paste the full content of client_secret.json from Google Cloud Console (Desktop OAuth 2.0 client, YouTube Data API v3 enabled). Alternatively place the file as scripts/client_secret.json in this skill directory."
+    }
+  }
+}

package/data/skills/youtube/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "youtube-skill",
+  "private": true,
+  "description": "YouTube upload script dependencies",
+  "dependencies": {
+    "googleapis": "^144.0.0"
+  }
+}

package/data/skills/youtube/references/youtube-upload.md

@@ -0,0 +1,65 @@
+# YouTube upload script
+
+Upload a video to YouTube using OAuth credentials. The script reads credentials from **Skills config** (env `YOUTUBE_CLIENT_SECRET_JSON`, set via Dashboard → Skills → YouTube → Configure) or from `scripts/client_secret.json`, and saves `token.json` after the first browser OAuth flow.
+
+## Prerequisites
+
+- **Google Cloud project** with YouTube Data API v3 enabled.
+- **OAuth 2.0 Client** (Desktop app): add the JSON via **Skills → YouTube → Configure** (paste full content), or save as `data/skills/youtube/scripts/client_secret.json`.
+- **Python 3** with pip packages from `data/skills/youtube/requirements.txt`:
+  ```bash
+  pip install -r data/skills/youtube/requirements.txt
+  ```
+  Or: `google-api-python-client`, `google-auth-oauthlib`, `google-auth-httplib2`.
+
+## One-time setup
+
+1. In [Google Cloud Console](https://console.cloud.google.com/): create or select a project → APIs & Services → Enable **YouTube Data API v3**.
+2. Create **OAuth 2.0 Client ID** (Application type: Desktop app). Download the JSON.
+3. Add the JSON via **Skills → YouTube → Configure** (paste the full content), or save as `client_secret.json` in the skill’s **scripts** directory.
+4. Run the script once with any test args; a browser will open to sign in. After authorizing, `token.json` is created in the same directory. Future runs use this token (refreshed automatically).
+
+## Usage
+
+From the skill directory (or use **exec** with `skill_id: "youtube"` so cwd is the skill dir):
+
+```bash
+python3 scripts/youtube_upload.py \
+  --file /path/to/video.mp4 \
+  --title "My video title" \
+  --description "Optional description" \
+  --tags "shorts,demo" \
+  --privacy public
+```
+
+## Options
+
+| Option         | Required | Description                                      |
+|----------------|----------|--------------------------------------------------|
+| `--file`       | Yes      | Path to video file (absolute or relative to script dir). |
+| `--title`      | Yes      | Video title.                                     |
+| `--description`| No       | Video description (default: empty).              |
+| `--tags`       | No       | Comma-separated tags (e.g. `shorts,demo`).       |
+| `--privacy`    | No       | `public`, `private`, or `unlisted` (default: public).    |
+
+## Agent usage (exec tool)
+
+Use the **exec** tool with `skill_id: "youtube"` so the command runs in the YouTube skill directory:
+
+```json
+{
+  "skill_id": "youtube",
+  "command": "python3 scripts/youtube_upload.py --file /path/to/video.mp4 --title \"My title\" --description \"Description\" --tags \"tag1,tag2\" --privacy public"
+}
+```
+
+Ensure the video file path is accessible from the environment where the agent runs (e.g. workspace path or absolute path). Quotes inside the command string must be escaped as required by the shell.
+
+## Troubleshooting
+
+| Problem                    | Cause                          | Action                                      |
+|----------------------------|---------------------------------|---------------------------------------------|
+| client_secret.json not found / YOUTUBE_CLIENT_SECRET_JSON not set | Credentials missing | Add via Skills → YouTube → Configure or place `scripts/client_secret.json`. |
+| Token expired / invalid    | First run or token revoked     | Delete `token.json` and run again to re-auth. |
+| File not found             | Wrong path for `--file`        | Use absolute path or path relative to script dir. |
+| Quota exceeded             | YouTube API quota              | Check quota in Cloud Console; wait or request increase. |

package/data/skills/youtube/requirements.txt

@@ -0,0 +1,3 @@
+google-api-python-client
+google-auth-oauthlib
+google-auth-httplib2

package/data/skills/youtube/scripts/youtube_upload.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+/**
+ * Upload a video to YouTube. Uses OAuth credentials from YOUTUBE_CLIENT_SECRET_JSON
+ * (Skills config) or scripts/client_secret.json. Saves token.json in scripts/ for reuse.
+ *
+ * Usage: node scripts/youtube_upload.js --file VIDEO.mp4 --title "Title" [--description "..." ] [--tags "a,b"] [--privacy public|private|unlisted]
+ *
+ * Dependencies: npm install (in the skill directory). Agent can run: exec with skill_id "youtube", command "npm install".
+ */
+
+const fs = require("fs");
+const path = require("path");
+const http = require("http");
+
+const SCRIPT_DIR = path.resolve(path.dirname(__filename));
+const SKILL_DIR = path.resolve(SCRIPT_DIR, "..");
+const TOKEN_PATH = path.join(SCRIPT_DIR, "token.json");
+const SCOPES = ["https://www.googleapis.com/auth/youtube.upload"];
+const REDIRECT_URI = "http://localhost:8090/";
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const out = { file: null, title: null, description: "", tags: "", privacy: "public" };
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--file" && args[i + 1]) out.file = args[++i];
+    else if (args[i] === "--title" && args[i + 1]) out.title = args[++i];
+    else if (args[i] === "--description" && args[i + 1]) out.description = args[++i];
+    else if (args[i] === "--tags" && args[i + 1]) out.tags = args[++i];
+    else if (args[i] === "--privacy" && args[i + 1]) out.privacy = args[++i];
+  }
+  return out;
+}
+
+function getClientSecret() {
+  const fromEnv = process.env.YOUTUBE_CLIENT_SECRET_JSON;
+  if (fromEnv && fromEnv.trim()) {
+    try {
+      return JSON.parse(fromEnv.trim());
+    } catch (e) {
+      console.error("ERROR: YOUTUBE_CLIENT_SECRET_JSON is not valid JSON.", e.message);
+      process.exit(1);
+    }
+  }
+  const p = path.join(SCRIPT_DIR, "client_secret.json");
+  if (!fs.existsSync(p)) {
+    console.error("ERROR: client_secret.json not found and YOUTUBE_CLIENT_SECRET_JSON not set.");
+    console.error("Add via Skills → YouTube → Configure or place scripts/client_secret.json.");
+    process.exit(1);
+  }
+  return JSON.parse(fs.readFileSync(p, "utf8"));
+}
+
+function getOAuth2Client(credentials) {
+  const { google } = require("googleapis");
+  const client = credentials.installed || credentials.web;
+  if (!client) {
+    console.error("ERROR: client_secret JSON must have 'installed' or 'web' with client_id and client_secret.");
+    process.exit(1);
+  }
+  return new google.auth.OAuth2(client.client_id, client.client_secret, REDIRECT_URI);
+}
+
+function loadSavedToken() {
+  if (!fs.existsSync(TOKEN_PATH)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(TOKEN_PATH, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function saveToken(tokens) {
+  fs.writeFileSync(TOKEN_PATH, JSON.stringify(tokens, null, 2), "utf8");
+}
+
+function authorize(oauth2Client) {
+  return new Promise((resolve, reject) => {
+    const authUrl = oauth2Client.generateAuthUrl({
+      access_type: "offline",
+      scope: SCOPES,
+      prompt: "consent",
+    });
+    const server = http
+      .createServer(async (req, res) => {
+        const url = new URL(req.url || "", `http://localhost`);
+        const code = url.searchParams.get("code");
+        res.writeHead(200, { "Content-Type": "text/plain" });
+        if (code) {
+          res.end("Authorized. You can close this tab.");
+          server.close();
+          try {
+            const { tokens } = await oauth2Client.getToken(code);
+            oauth2Client.setCredentials(tokens);
+            saveToken(tokens);
+            resolve(oauth2Client);
+          } catch (e) {
+            reject(e);
+          }
+        } else {
+          res.end("Missing code. Try again.");
+        }
+      })
+      .listen(8090, "localhost", () => {
+        console.error("Open this URL in your browser to authorize:");
+        console.error(authUrl);
+        const op = require("child_process").spawn(
+          process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open",
+          [authUrl],
+          { stdio: "ignore" }
+        );
+        op.on("error", () => {});
+      });
+    server.on("error", reject);
+  });
+}
+
+async function getAuthenticatedClient() {
+  let credentials;
+  try {
+    credentials = getClientSecret();
+  } catch (e) {
+    console.error("ERROR:", e.message);
+    process.exit(1);
+  }
+  const oauth2Client = getOAuth2Client(credentials);
+  const token = loadSavedToken();
+  if (token) {
+    oauth2Client.setCredentials(token);
+    oauth2Client.on("tokens", (tokens) => {
+      const creds = oauth2Client.credentials;
+      if (tokens.refresh_token) creds.refresh_token = tokens.refresh_token;
+      saveToken(creds);
+    });
+    return oauth2Client;
+  }
+  return authorize(oauth2Client);
+}
+
+async function uploadVideo(oauth2Client, filePath, title, description, tagsList, privacy) {
+  const { google } = require("googleapis");
+  const youtube = google.youtube({ version: "v3", auth: oauth2Client });
+  const body = {
+    snippet: {
+      title,
+      description: description || "",
+      tags: tagsList,
+      categoryId: "22",
+    },
+    status: { privacyStatus: privacy },
+  };
+  const media = {
+    body: fs.createReadStream(filePath),
+  };
+  const res = await youtube.videos.insert({
+    part: "snippet,status",
+    requestBody: body,
+    media,
+  });
+  const videoId = res.data.id;
+  console.log("Uploaded: https://youtube.com/watch?v=" + videoId);
+  return videoId;
+}
+
+async function main() {
+  const args = parseArgs();
+  if (!args.file || !args.title) {
+    console.error("Usage: node youtube_upload.js --file <path> --title \"Title\" [--description \"...\"] [--tags \"a,b\"] [--privacy public|private|unlisted]");
+    process.exit(1);
+  }
+  if (!["public", "private", "unlisted"].includes(args.privacy)) {
+    console.error("ERROR: --privacy must be public, private, or unlisted");
+    process.exit(1);
+  }
+  let filePath = path.resolve(args.file);
+  if (!path.isAbsolute(args.file)) filePath = path.resolve(SCRIPT_DIR, args.file);
+  if (!fs.existsSync(filePath)) {
+    console.error("ERROR: File not found:", filePath);
+    process.exit(1);
+  }
+  const tagsList = args.tags ? args.tags.split(",").map((t) => t.trim()).filter(Boolean) : [];
+
+  try {
+    const auth = await getAuthenticatedClient();
+    await uploadVideo(auth, filePath, args.title, args.description, tagsList, args.privacy);
+    const creds = auth.credentials;
+    if (creds && (creds.access_token || creds.refresh_token)) saveToken(creds);
+    process.exit(0);
+  } catch (e) {
+    if (e.code === "MODULE_NOT_FOUND" && (e.message || "").includes("googleapis")) {
+      console.error("ERROR: Missing npm dependencies. Install with:");
+      console.error("  npm install");
+      console.error("Run that from the skill directory (exec with skill_id 'youtube', command 'npm install'), then retry.");
+      process.exit(1);
+    }
+    console.error("ERROR:", e.message || e);
+    process.exit(1);
+  }
+}
+
+main();