opencode-skills-collection 4.0.16 → 4.0.18

package/bundled-skills/notebooklm/README.md

@@ -265,12 +265,13 @@ All data is stored locally within the skill directory:
 ```
 ~/.claude/skills/notebooklm/data/
 ├── library.json       - Your notebook library with metadata
-├── auth_info.json     - Authentication status info
-└── browser_state/     - Browser cookies and session data
+~/.local/share/agentic-awesome-skills/notebooklm/
+├── auth_info.json     - Authentication status info (0600)
+└── browser_state/     - Browser cookies and session data (0700)
 ```
 
 **Important Security Note:**
-- The `data/` directory contains sensitive authentication data and personal notebooks
+- The private per-user state directory contains sensitive authentication data and personal notebooks
 - It's automatically excluded from git via `.gitignore`
 - NEVER manually commit or share the contents of the `data/` directory
 

package/bundled-skills/notebooklm/SKILL.md

@@ -195,8 +195,8 @@ python -m patchright install chromium
 
 All data stored in `~/.claude/skills/notebooklm/data/`:
 - `library.json` - Notebook metadata
-- `auth_info.json` - Authentication status
-- `browser_state/` - Browser cookies and session
+- `~/.local/share/agentic-awesome-skills/notebooklm/auth_info.json` - private authentication status (`0600`)
+- `~/.local/share/agentic-awesome-skills/notebooklm/browser_state/` - private browser cookies and session (`0700`)
 
 **Security:** Protected by `.gitignore`, never commit to git.
 
@@ -263,7 +263,7 @@ Synthesize and respond to user
 **Important directories and files:**
 
 - `scripts/` - All automation scripts (ask_question.py, notebook_manager.py, etc.)
-- `data/` - Local storage for authentication and notebook library
+- `~/.local/share/agentic-awesome-skills/notebooklm/` - private per-user authentication and notebook storage
 - `references/` - Extended documentation:
   - `api_reference.md` - Detailed API documentation for all scripts
   - `troubleshooting.md` - Common issues and solutions

package/bundled-skills/notebooklm/scripts/auth_manager.py

@@ -25,7 +25,7 @@ from patchright.sync_api import sync_playwright, BrowserContext
 # Add parent directory to path
 sys.path.insert(0, str(Path(__file__).parent))
 
-from config import BROWSER_STATE_DIR, STATE_FILE, AUTH_INFO_FILE, DATA_DIR
+from config import BROWSER_STATE_DIR, STATE_FILE, AUTH_INFO_FILE, DATA_DIR, ensure_private_state
 from browser_utils import BrowserFactory
 
 
@@ -56,8 +56,7 @@ class AuthManager:
     def __init__(self):
         """Initialize the authentication manager"""
         # Ensure directories exist
-        DATA_DIR.mkdir(parents=True, exist_ok=True)
-        BROWSER_STATE_DIR.mkdir(parents=True, exist_ok=True)
+        ensure_private_state()
 
         self.state_file = STATE_FILE
         self.auth_info_file = AUTH_INFO_FILE
@@ -176,6 +175,7 @@ class AuthManager:
         try:
             # Save storage state (cookies, localStorage)
             context.storage_state(path=str(self.state_file))
+            self.state_file.chmod(0o600)
             print(f"  💾 Saved browser state to: {self.state_file}")
         except Exception as e:
             print(f"  ❌ Failed to save browser state: {e}")
@@ -190,6 +190,7 @@ class AuthManager:
             }
             with open(self.auth_info_file, 'w') as f:
                 json.dump(info, f, indent=2)
+            self.auth_info_file.chmod(0o600)
         except Exception:
             pass  # Non-critical
 
@@ -216,7 +217,8 @@ class AuthManager:
             # Clear entire browser state directory
             if self.browser_state_dir.exists():
                 shutil.rmtree(self.browser_state_dir)
-                self.browser_state_dir.mkdir(parents=True, exist_ok=True)
+                self.browser_state_dir.mkdir(parents=True, exist_ok=True, mode=0o700)
+                self.browser_state_dir.chmod(0o700)
                 print("  ✅ Cleared browser data")
 
             return True

package/bundled-skills/notebooklm/scripts/browser_utils.py

@@ -8,7 +8,7 @@ import time
 import random
 
 from patchright.sync_api import Playwright, BrowserContext, Page
-from config import BROWSER_PROFILE_DIR, STATE_FILE, BROWSER_ARGS, USER_AGENT
+from config import BROWSER_PROFILE_DIR, STATE_FILE, BROWSER_ARGS, USER_AGENT, ensure_private_state
 
 
 class BrowserFactory:
@@ -25,6 +25,7 @@ class BrowserFactory:
         and cookie workaround.
         """
         # Launch persistent context
+        ensure_private_state()
         context = playwright.chromium.launch_persistent_context(
             user_data_dir=user_data_dir,
             channel="chrome",  # Use real Chrome

package/bundled-skills/notebooklm/scripts/config.py

@@ -3,17 +3,47 @@ Configuration for NotebookLM Skill
 Centralizes constants, selectors, and paths
 """
 
+import os
 from pathlib import Path
 
 # Paths
 SKILL_DIR = Path(__file__).parent.parent
-DATA_DIR = SKILL_DIR / "data"
+LEGACY_DATA_DIR = SKILL_DIR / "data"
+DATA_DIR = Path(os.environ.get(
+    "AAS_NOTEBOOKLM_DATA_DIR",
+    Path.home() / ".local" / "share" / "agentic-awesome-skills" / "notebooklm",
+)).expanduser()
 BROWSER_STATE_DIR = DATA_DIR / "browser_state"
 BROWSER_PROFILE_DIR = BROWSER_STATE_DIR / "browser_profile"
 STATE_FILE = BROWSER_STATE_DIR / "state.json"
 AUTH_INFO_FILE = DATA_DIR / "auth_info.json"
 LIBRARY_FILE = DATA_DIR / "library.json"
 
+# Browser profiles and storage-state files contain live Google credentials.
+# A restrictive umask also covers files created later by Chromium.
+os.umask(0o077)
+
+
+def ensure_private_state():
+    """Create/repair the private state tree and migrate the legacy skill-local tree."""
+    import shutil
+    if LEGACY_DATA_DIR.exists() and LEGACY_DATA_DIR != DATA_DIR and not DATA_DIR.exists():
+        DATA_DIR.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+        shutil.move(str(LEGACY_DATA_DIR), str(DATA_DIR))
+        print(f"⚠️ Migrated sensitive NotebookLM state to private user storage: {DATA_DIR}")
+    for directory in (DATA_DIR.parent.parent, DATA_DIR.parent, DATA_DIR, BROWSER_STATE_DIR, BROWSER_PROFILE_DIR):
+        directory.mkdir(parents=True, exist_ok=True, mode=0o700)
+        try:
+            directory.chmod(0o700)
+        except OSError:
+            pass
+    for file_path in (STATE_FILE, AUTH_INFO_FILE, LIBRARY_FILE):
+        if file_path.exists() and not file_path.is_symlink():
+            try:
+                file_path.chmod(0o600)
+            except OSError:
+                pass
+
 # NotebookLM Selectors
 QUERY_INPUT_SELECTORS = [
     "textarea.query-box-input",  # Primary

package/bundled-skills/pptx-official/scripts/html2pptx.js

@@ -26,13 +26,44 @@
  */
 
 const { chromium } = require('playwright');
+const fs = require('fs');
 const path = require('path');
+const { fileURLToPath } = require('url');
 const sharp = require('sharp');
 
 const PT_PER_PX = 0.75;
 const PX_PER_IN = 96;
 const EMU_PER_IN = 914400;
 
+function resolveTrustedAsset(assetValue, allowedRoot) {
+  let candidate;
+  try {
+    const parsed = new URL(assetValue, `file://${allowedRoot}${path.sep}`);
+    if (parsed.protocol !== 'file:') throw new Error('only local file assets are supported');
+    candidate = fileURLToPath(parsed);
+  } catch (error) {
+    throw new Error(`Unsafe slide asset ${JSON.stringify(assetValue)}: ${error.message}`);
+  }
+  const realRoot = fs.realpathSync(allowedRoot);
+  const realAsset = fs.realpathSync(candidate);
+  const relativeAsset = path.relative(realRoot, realAsset);
+  if (relativeAsset.startsWith('..') || path.isAbsolute(relativeAsset)) {
+    throw new Error(`Slide asset escapes the HTML directory: ${assetValue}`);
+  }
+  const stat = fs.lstatSync(realAsset);
+  if (!stat.isFile() || stat.isSymbolicLink()) throw new Error(`Slide asset must be a regular file: ${assetValue}`);
+  return realAsset;
+}
+
+function constrainSlideAssets(slideData, allowedRoot) {
+  if (slideData.background?.type === 'image' && slideData.background.path) {
+    slideData.background.path = resolveTrustedAsset(slideData.background.path, allowedRoot);
+  }
+  for (const element of slideData.elements) {
+    if (element.type === 'image') element.src = resolveTrustedAsset(element.src, allowedRoot);
+  }
+}
+
 // Helper: Get body dimensions and check for overflow
 async function getBodyDimensions(page) {
   const bodyDimensions = await page.evaluate(() => {
@@ -120,10 +151,7 @@ function validateTextBoxPosition(slideData, bodyDimensions) {
 // Helper: Add background to slide
 async function addBackground(slideData, targetSlide, tmpDir) {
   if (slideData.background.type === 'image' && slideData.background.path) {
-    let imagePath = slideData.background.path.startsWith('file://')
-      ? slideData.background.path.replace('file://', '')
-      : slideData.background.path;
-    targetSlide.background = { path: imagePath };
+    targetSlide.background = { path: slideData.background.path };
   } else if (slideData.background.type === 'color' && slideData.background.value) {
     targetSlide.background = { color: slideData.background.value };
   }
@@ -133,9 +161,8 @@ async function addBackground(slideData, targetSlide, tmpDir) {
 function addElements(slideData, targetSlide, pres) {
   for (const el of slideData.elements) {
     if (el.type === 'image') {
-      let imagePath = el.src.startsWith('file://') ? el.src.replace('file://', '') : el.src;
       targetSlide.addImage({
-        path: imagePath,
+        path: el.src,
         x: el.position.x,
         y: el.position.y,
         w: el.position.w,
@@ -911,7 +938,8 @@ async function html2pptx(htmlFile, pres, options = {}) {
     let bodyDimensions;
     let slideData;
 
-    const filePath = path.isAbsolute(htmlFile) ? htmlFile : path.join(process.cwd(), htmlFile);
+    const filePath = fs.realpathSync(path.isAbsolute(htmlFile) ? htmlFile : path.join(process.cwd(), htmlFile));
+    const assetRoot = path.dirname(filePath);
     const validationErrors = [];
 
     try {
@@ -931,6 +959,7 @@ async function html2pptx(htmlFile, pres, options = {}) {
       });
 
       slideData = await extractSlideData(page);
+      constrainSlideAssets(slideData, assetRoot);
     } finally {
       await browser.close();
     }
@@ -976,4 +1005,4 @@ async function html2pptx(htmlFile, pres, options = {}) {
   }
 }
 
-module.exports = html2pptx;
+module.exports = html2pptx;

package/bundled-skills/senior-frontend/scripts/frontend_scaffolder.py

@@ -13,6 +13,7 @@ Usage:
 
 import argparse
 import json
+import re
 import os
 import sys
 from pathlib import Path
@@ -854,6 +855,11 @@ def scaffold_project(
 ) -> Dict:
     """Scaffold a complete frontend project."""
     features = features or []
+    if not re.fullmatch(r"[a-z0-9]+(?:-[a-z0-9]+)*", name) or len(name) > 64:
+        return {"error": "Project name must be 1-64 lowercase letters, digits, or hyphen-separated words"}
+    output_dir = output_dir.resolve()
+    if output_dir.is_symlink():
+        return {"error": "Output directory must not be a symbolic link"}
     project_path = output_dir / name
 
     if project_path.exists() and not dry_run:

package/bundled-skills/skill-creator/scripts/init_skill.py

@@ -12,6 +12,7 @@ Examples:
 """
 
 import sys
+import re
 from pathlib import Path
 
 
@@ -204,6 +205,16 @@ def title_case_skill_name(skill_name):
     return ' '.join(word.capitalize() for word in skill_name.split('-'))
 
 
+SKILL_NAME_RE = re.compile(r"\A[a-z0-9]+(?:-[a-z0-9]+)*\Z")
+
+
+def validate_skill_name(skill_name):
+    """Accept only one portable directory component."""
+    if not SKILL_NAME_RE.fullmatch(skill_name) or len(skill_name) > 64:
+        raise ValueError("skill name must be 1-64 lowercase letters, digits, or hyphen-separated words")
+    return skill_name
+
+
 def init_skill(skill_name, path):
     """
     Initialize a new skill directory with template SKILL.md.
@@ -215,8 +226,13 @@ def init_skill(skill_name, path):
     Returns:
         Path to created skill directory, or None if error
     """
-    # Determine skill directory path
-    skill_dir = safe_user_path(path).resolve() / skill_name
+    # Determine skill directory path. Validation prevents absolute paths,
+    # separators, dot segments, and traversal from becoming filesystem names.
+    skill_name = validate_skill_name(skill_name)
+    parent_dir = safe_user_path(path).resolve()
+    if parent_dir.is_symlink():
+        raise ValueError("skill parent must not be a symbolic link")
+    skill_dir = parent_dir / skill_name
 
     # Check if directory already exists
     if skill_dir.exists():

package/bundled-skills/telegram/SKILL.md

@@ -379,7 +379,7 @@ app = Flask(__name__)
 TOKEN = "SEU_TOKEN"
 BASE = f"https://api.telegram.org/bot{TOKEN}"
 
-@app.route(f"/webhook/{TOKEN}", methods=["POST"])
+@app.route("/webhook", methods=["POST"])
 def webhook():
     update = request.get_json()
     if "message" in update and "text" in update["message"]:
@@ -394,7 +394,7 @@ def webhook():
 ## Registrar Webhook
 
 requests.post(f"{BASE}/setWebhook", json={
-    "url": "https://seu-dominio.com/webhook/" + TOKEN,
+    "url": "https://seu-dominio.com/webhook",
     "allowed_updates": ["message", "callback_query"],
     "secret_token": "seu_secret_seguro_aqui"
 })

package/bundled-skills/telegram/assets/boilerplate/nodejs/.env.example

@@ -3,7 +3,7 @@ TELEGRAM_BOT_TOKEN=123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11
 
 # Webhook Configuration (optional - for production)
 WEBHOOK_URL=https://your-domain.com
-WEBHOOK_SECRET=your-secret-token-here
+WEBHOOK_SECRET=replace-with-at-least-32-random-characters
 PORT=3000
 
 # AI Integration (optional)

package/bundled-skills/telegram/assets/boilerplate/nodejs/src/bot-client.ts

@@ -17,17 +17,18 @@ export class TelegramBotClient {
     console.log(`Bot @${me.username} (${me.first_name}) started with polling`);
   }
 
-  async startWebhook(port: number, webhookUrl: string, secret?: string): Promise<void> {
+  async startWebhook(port: number, webhookUrl: string, secret: string): Promise<void> {
+    if (!/^[A-Za-z0-9_-]{32,256}$/.test(secret)) {
+      throw new Error('WEBHOOK_SECRET must contain 32-256 random letters, digits, underscores, or hyphens');
+    }
     const app = express();
     app.disable('x-powered-by');
     app.use(express.json());
 
     app.post('/webhook', async (req, res) => {
-      if (secret) {
-        const headerSecret = req.headers['x-telegram-bot-api-secret-token'];
-        if (headerSecret !== secret) {
-          return res.sendStatus(403);
-        }
+      const headerSecret = req.headers['x-telegram-bot-api-secret-token'];
+      if (headerSecret !== secret) {
+        return res.sendStatus(403);
       }
 
       await this.bot.handleUpdate(req.body, res);

package/bundled-skills/telegram/assets/boilerplate/nodejs/src/index.ts

@@ -21,6 +21,9 @@ async function main() {
     const port = parseInt(process.env.PORT || '3000');
     const webhookUrl = process.env.WEBHOOK_URL!;
     const secret = process.env.WEBHOOK_SECRET;
+    if (!secret) {
+      throw new Error('WEBHOOK_SECRET is required in webhook mode');
+    }
     await client.startWebhook(port, webhookUrl, secret);
     console.log(`Bot running in webhook mode on port ${port}`);
   } else {

package/bundled-skills/telegram/assets/boilerplate/python/.env.example

@@ -3,7 +3,7 @@ TELEGRAM_BOT_TOKEN=123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11
 
 # Webhook Configuration (optional - for production)
 WEBHOOK_URL=https://your-domain.com
-WEBHOOK_SECRET=your-secret-token-here
+WEBHOOK_SECRET=replace-with-at-least-32-random-characters
 PORT=5000
 
 # AI Integration (optional)

package/bundled-skills/telegram/assets/boilerplate/python/webhook_server.py

@@ -7,6 +7,8 @@ Usage:
 """
 
 import os
+import hmac
+import re
 import logging
 import asyncio
 from dotenv import load_dotenv
@@ -23,7 +25,7 @@ logger = logging.getLogger(__name__)
 
 TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
 WEBHOOK_URL = os.getenv("WEBHOOK_URL")
-WEBHOOK_SECRET = os.getenv("WEBHOOK_SECRET", "default-secret")
+WEBHOOK_SECRET = os.getenv("WEBHOOK_SECRET", "")
 PORT = int(os.getenv("PORT", "5000"))
 
 flask_app = Flask(__name__)
@@ -50,12 +52,12 @@ application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, echo))
 
 # --- Flask Routes ---
 
-@flask_app.route(f"/webhook/{TOKEN}", methods=["POST"])
+@flask_app.route("/webhook", methods=["POST"])
 def webhook():
     """Handle incoming Telegram updates."""
     # Validate secret token
     secret = request.headers.get("X-Telegram-Bot-Api-Secret-Token")
-    if secret != WEBHOOK_SECRET:
+    if not secret or not hmac.compare_digest(secret, WEBHOOK_SECRET):
         logger.warning("Invalid secret token received")
         return "Forbidden", 403
 
@@ -85,7 +87,7 @@ def register_webhook():
     import requests as req
     url = f"https://api.telegram.org/bot{TOKEN}/setWebhook"
     resp = req.post(url, json={
-        "url": f"{WEBHOOK_URL}/webhook/{TOKEN}",
+        "url": f"{WEBHOOK_URL.rstrip('/')}/webhook",
         "allowed_updates": ["message", "callback_query", "inline_query"],
         "secret_token": WEBHOOK_SECRET,
         "max_connections": 40
@@ -104,6 +106,9 @@ if __name__ == "__main__":
     if not WEBHOOK_URL:
         logger.error("Set WEBHOOK_URL in .env")
         exit(1)
+    if len(WEBHOOK_SECRET) < 32 or len(WEBHOOK_SECRET) > 256 or not re.fullmatch(r"[A-Za-z0-9_-]+", WEBHOOK_SECRET):
+        logger.error("Set WEBHOOK_SECRET to 32-256 random characters using letters, digits, _ or -")
+        exit(1)
 
     register_webhook()
     logger.info(f"Starting webhook server on port {PORT}")

package/bundled-skills/telegram/references/webhook-setup.md

@@ -26,7 +26,7 @@ Webhooks sao a forma recomendada para producao. O Telegram envia updates via HTT
 ```
 POST https://api.telegram.org/bot<TOKEN>/setWebhook
 {
-  "url": "https://seu-dominio.com/webhook/<TOKEN>",
+  "url": "https://seu-dominio.com/webhook",
   "allowed_updates": ["message", "callback_query", "inline_query"],
   "max_connections": 40,
   "secret_token": "seu_token_secreto_256chars_max"
@@ -55,7 +55,8 @@ import { Telegraf } from 'telegraf';
 const app = express();
 const TOKEN = process.env.TELEGRAM_BOT_TOKEN!;
 const WEBHOOK_URL = process.env.WEBHOOK_URL!; // https://seu-dominio.com
-const SECRET_TOKEN = process.env.WEBHOOK_SECRET || 'meu-secret-seguro';
+const SECRET_TOKEN = process.env.WEBHOOK_SECRET;
+if (!SECRET_TOKEN || !/^[A-Za-z0-9_-]{32,256}$/.test(SECRET_TOKEN)) throw new Error('WEBHOOK_SECRET invalido');
 
 const bot = new Telegraf(TOKEN);
 
@@ -109,7 +110,7 @@ from telegram.ext import Application, CommandHandler, MessageHandler, filters
 
 TOKEN = os.getenv('TELEGRAM_BOT_TOKEN')
 WEBHOOK_URL = os.getenv('WEBHOOK_URL')
-SECRET_TOKEN = os.getenv('WEBHOOK_SECRET', 'meu-secret-seguro')
+SECRET_TOKEN = os.environ['WEBHOOK_SECRET']
 
 flask_app = Flask(__name__)
 
@@ -121,7 +122,7 @@ async def start(update: Update, context):
 
 application.add_handler(CommandHandler('start', start))
 
-@flask_app.route(f'/webhook/{TOKEN}', methods=['POST'])
+@flask_app.route('/webhook', methods=['POST'])
 async def webhook():
     # Validar secret token
     secret = request.headers.get('X-Telegram-Bot-Api-Secret-Token')
@@ -141,7 +142,7 @@ import requests
 requests.post(
     f'https://api.telegram.org/bot{TOKEN}/setWebhook',
     json={
-        'url': f'{WEBHOOK_URL}/webhook/{TOKEN}',
+        'url': f'{WEBHOOK_URL}/webhook',
         'allowed_updates': ['message', 'callback_query'],
         'secret_token': SECRET_TOKEN,
         'max_connections': 40
@@ -161,7 +162,7 @@ from telegram.ext import Application, CommandHandler, MessageHandler, filters
 
 TOKEN = os.getenv('TELEGRAM_BOT_TOKEN')
 WEBHOOK_URL = os.getenv('WEBHOOK_URL')
-SECRET_TOKEN = os.getenv('WEBHOOK_SECRET', 'meu-secret-seguro')
+SECRET_TOKEN = os.environ['WEBHOOK_SECRET']
 
 app = FastAPI()
 application = Application.builder().token(TOKEN).build()
@@ -184,7 +185,7 @@ async def on_startup():
 async def on_shutdown():
     await application.shutdown()
 
-@app.post(f'/webhook/{TOKEN}')
+@app.post('/webhook')
 async def webhook(request: Request):
     secret = request.headers.get('x-telegram-bot-api-secret-token')
     if secret != SECRET_TOKEN:
@@ -216,7 +217,7 @@ ngrok fornece URL tipo `https://abc123.ngrok-free.app`. Use essa URL para regist
 ```bash
 curl -X POST "https://api.telegram.org/bot$TOKEN/setWebhook" \
   -H "Content-Type: application/json" \
-  -d "{\"url\": \"https://abc123.ngrok-free.app/webhook/$TOKEN\"}"
+  -d "{\"url\": \"https://abc123.ngrok-free.app/webhook\"}"
 ```
 
 **Alternativa gratuita:** localtunnel
@@ -290,7 +291,7 @@ CMD ["node", "dist/index.js"]
 ## Seguranca
 
 1. **Secret Token:** Sempre use `secret_token` ao registrar webhook e valide o header `X-Telegram-Bot-Api-Secret-Token`
-2. **URL com token:** Inclua o token na URL do webhook para uma camada extra de seguranca
+2. **URL sem token:** Nao exponha o bot token na URL; autentique sempre pelo header secreto do Telegram
 3. **IP whitelist:** Telegram envia webhooks dos IPs:
    - `149.154.160.0/20`
    - `91.108.4.0/22`

package/bundled-skills/youtube-notetaker/SKILL.md

@@ -76,7 +76,7 @@ default. **Do not use em dashes (—) or arrows (→) in notes/titles.**
 
 ### 1. Resolve the id and check embeddability
 ```
-scripts/setup.sh "<youtube_url_or_id>"
+bash scripts/setup.sh "<youtube_url_or_id>"
 ```
 Prints the 11-char `YTID`, the scratch dir, the target library path, and whether YouTube
 **embedding is allowed** (oembed 200) or **blocked** (oembed 401, e.g. some university talks).

package/bundled-skills/youtube-notetaker/scripts/extract_slides.py

@@ -12,11 +12,13 @@ in title + note for each. idx here is just the sequence number; ordering is by t
 
 The img URL is served by serve.py at /api/video-deepdives/_media/<file>.
 """
-import subprocess, sys, os, json
+import subprocess, sys, os, json, re, tempfile
+from pathlib import Path
 
 LIB = os.path.expanduser(os.environ.get("VIDEO_LIBRARY_DIR", "~/video-deepdives"))
 MEDIA = os.path.join(LIB, "_media")
 IMG_PREFIX = "/api/video-deepdives/_media"  # served by serve.py
+YTID_RE = re.compile(r"\A[A-Za-z0-9_-]{11}\Z")
 
 def mmss(t):
     t=int(round(float(t))); return f"{t//60:02d}:{t%60:02d}"
@@ -24,19 +26,30 @@ def mmss(t):
 def main():
     if len(sys.argv)!=4: sys.exit("usage: extract_slides.py <YTID> <video.mp4> <keep.txt>")
     ytid,video,keep=sys.argv[1],sys.argv[2],sys.argv[3]
+    if not YTID_RE.fullmatch(ytid): sys.exit("YTID must be an exact 11-character YouTube video id")
     times=sorted({float(l.strip()) for l in open(keep) if l.strip()})
     if not times: sys.exit("keep.txt is empty")
-    os.makedirs(MEDIA,exist_ok=True)
+    media = Path(MEDIA).expanduser()
+    if media.is_symlink(): sys.exit("library media directory must not be a symbolic link")
+    media.mkdir(parents=True,exist_ok=True)
+    media = media.resolve()
     scaffold=[]
     for i,t in enumerate(times,1):
         fn=f"{ytid}-slide-{i:02d}.jpg"
-        out=os.path.join(MEDIA,fn)
-        subprocess.run(["ffmpeg","-hide_banner","-loglevel","error","-ss",f"{t}",
-                        "-i",video,"-frames:v","1","-vf","scale=1280:-1","-q:v","3","-y",out],check=True)
+        out=media / fn
+        with tempfile.NamedTemporaryFile(prefix=".slide-", suffix=".jpg", dir=media, delete=False) as tmp:
+            temporary = Path(tmp.name)
+        try:
+            subprocess.run(["ffmpeg","-hide_banner","-loglevel","error","-ss",f"{t}",
+                            "-i",video,"-frames:v","1","-vf","scale=1280:-1","-q:v","3","-y",str(temporary)],check=True)
+            os.chmod(temporary, 0o600)
+            os.replace(temporary, out)
+        finally:
+            temporary.unlink(missing_ok=True)
         scaffold.append({"idx":i,"t":round(t,1),"mmss":mmss(t),"title":"","note":"",
                          "img":f"{IMG_PREFIX}/{fn}"})
         print(f"  wrote {fn}  @ {mmss(t)}",file=sys.stderr)
-    print(f"\nInstalled {len(scaffold)} slides to {MEDIA}",file=sys.stderr)
+    print(f"\nInstalled {len(scaffold)} slides to {media}",file=sys.stderr)
     print("--- slides.json scaffold on stdout; redirect to a file, then fill in title + note ---",file=sys.stderr)
     print(json.dumps(scaffold,indent=2))
 

package/bundled-skills/youtube-notetaker/scripts/setup.sh

@@ -12,6 +12,7 @@ LIB="${VIDEO_LIBRARY_DIR:-$HOME/video-deepdives}"
 YTID="$(printf '%s' "$IN" | sed -nE 's#.*(youtu\.be/|v=|/embed/|/shorts/)([A-Za-z0-9_-]{11}).*#\2#p')"
 [ -z "$YTID" ] && [ "${#IN}" -eq 11 ] && YTID="$IN"
 [ -z "$YTID" ] && { echo "Could not parse a YouTube id from: $IN" >&2; exit 1; }
+[[ "$YTID" =~ ^[A-Za-z0-9_-]{11}$ ]] || { echo "Invalid YouTube id" >&2; exit 1; }
 
 SCRATCH="/tmp/ytnote-$YTID"
 mkdir -p "$SCRATCH"

package/bundled-skills/youtube-notetaker/scripts/write_library_item.py

@@ -18,7 +18,7 @@ slides.json: a JSON array of slide objects. Each:
 Writes  $VIDEO_LIBRARY_DIR/<YTID>.md  (default ~/video-deepdives/<YTID>.md)
 with YAML frontmatter + transcript body. No em dashes or arrows in titles/notes.
 """
-import argparse, json, os, sys, datetime
+import argparse, json, os, re, sys, datetime
 from pathlib import Path
 
 
@@ -39,6 +39,7 @@ except ImportError:
     sys.exit("pip install pyyaml")
 
 LIB = os.path.expanduser(os.environ.get("VIDEO_LIBRARY_DIR", "~/video-deepdives"))
+YTID_RE = re.compile(r"\A[A-Za-z0-9_-]{11}\Z")
 
 def main():
     ap=argparse.ArgumentParser()
@@ -50,6 +51,8 @@ def main():
     ap.add_argument("--transcript",required=True)
     ap.add_argument("--created",default=datetime.date.today().isoformat())
     a=ap.parse_args()
+    if not YTID_RE.fullmatch(a.id):
+        sys.exit("--id must be an exact 11-character YouTube video id")
 
     slides=json.load(open(a.slides))
     slides=sorted(slides,key=lambda s:s["t"])
@@ -70,9 +73,17 @@ def main():
         "slides":slides,
     }
     body=open(a.transcript,encoding="utf-8").read().strip()
-    os.makedirs(LIB,exist_ok=True)
-    path=os.path.join(LIB,f"{a.id}.md")
-    with safe_user_path(path).open("w",encoding="utf-8") as f:
+    library = Path(LIB).expanduser()
+    if library.is_symlink():
+        sys.exit("VIDEO_LIBRARY_DIR must not be a symbolic link")
+    library.mkdir(parents=True, exist_ok=True)
+    library = library.resolve()
+    path = library / f"{a.id}.md"
+    flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC
+    if hasattr(os, "O_NOFOLLOW"):
+        flags |= os.O_NOFOLLOW
+    fd = os.open(path, flags, 0o600)
+    with os.fdopen(fd, "w", encoding="utf-8") as f:
         f.write("---\n")
         yaml.safe_dump(fm,f,sort_keys=False,allow_unicode=True,width=100)
         f.write("---\n## Transcript\n")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-skills-collection",
-  "version": "4.0.16",
+  "version": "4.0.18",
   "description": "OpenCode CLI plugin that automatically downloads and keeps skills up to date.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",