mitsupi 1.0.0

package/skills/sentry/scripts/search-logs.js

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+
+import { SENTRY_API_BASE, getAuthToken, fetchJson, formatTimestamp } from "../lib/auth.js";
+
+const LOG_FIELDS = [
+  "sentry.item_id",
+  "trace",
+  "sentry.severity",
+  "timestamp",
+  "message",
+];
+
+/**
+ * Parse a Sentry logs explorer URL
+ * Examples:
+ *   https://earendil.sentry.io/explore/logs/?project=123&statsPeriod=14d
+ *   https://sentry.io/organizations/myorg/explore/logs/?project=123
+ */
+function parseLogsUrl(urlStr) {
+  try {
+    const url = new URL(urlStr);
+    const params = url.searchParams;
+    const result = {};
+
+    // Extract org from subdomain (earendil.sentry.io) or path (/organizations/myorg/)
+    const subdomainMatch = url.hostname.match(/^([^.]+)\.sentry\.io$/);
+    if (subdomainMatch && subdomainMatch[1] !== "www") {
+      result.org = subdomainMatch[1];
+    } else {
+      const pathMatch = url.pathname.match(/\/organizations\/([^/]+)\//);
+      if (pathMatch) {
+        result.org = pathMatch[1];
+      }
+    }
+
+    // Extract project ID
+    if (params.has("project")) {
+      result.project = params.get("project");
+    }
+
+    // Extract time period
+    if (params.has("statsPeriod")) {
+      result.period = params.get("statsPeriod");
+    }
+
+    // Extract query
+    if (params.has("logsQuery")) {
+      result.query = params.get("logsQuery");
+    }
+
+    return result;
+  } catch {
+    return null;
+  }
+}
+
+function parseArgs(args) {
+  const options = {
+    org: null,
+    project: null,
+    query: null,
+    period: "24h",
+    limit: 100,
+    json: false,
+    help: false,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg === "--help" || arg === "-h") {
+      options.help = true;
+    } else if (arg === "--json") {
+      options.json = true;
+    } else if (arg === "--org" || arg === "-o") {
+      options.org = args[++i];
+    } else if (arg === "--project" || arg === "-p") {
+      options.project = args[++i];
+    } else if (arg === "--period" || arg === "-t") {
+      options.period = args[++i];
+    } else if (arg === "--limit" || arg === "-n") {
+      options.limit = parseInt(args[++i], 10);
+    } else if (!arg.startsWith("-")) {
+      // Check if it's a Sentry URL
+      if (arg.includes("sentry.io/") && arg.includes("/logs")) {
+        const urlOptions = parseLogsUrl(arg);
+        if (urlOptions) {
+          if (urlOptions.org) options.org = urlOptions.org;
+          if (urlOptions.project) options.project = urlOptions.project;
+          if (urlOptions.period) options.period = urlOptions.period;
+          if (urlOptions.query) options.query = urlOptions.query;
+        }
+      } else if (!options.query) {
+        options.query = arg;
+      }
+    }
+  }
+
+  return options;
+}
+
+function showHelp() {
+  console.log(`Usage: search-logs.js [query|url] [options]
+
+Search for logs in Sentry.
+
+Arguments:
+  query              Search query (e.g., "level:error", "user.id:123")
+  url                Sentry logs explorer URL (extracts org, project, period)
+
+Options:
+  --org, -o <org>    Organization slug (required unless URL provided)
+  --project, -p <p>  Project slug or ID to filter by
+  --period, -t <p>   Time period (default: 24h, e.g., 1h, 7d, 90d)
+  --limit, -n <n>    Max results (default: 100, max: 1000)
+  --json             Output raw JSON
+  -h, --help         Show this help
+
+Search Query Syntax:
+  level:error              Filter by log level (trace, debug, info, warn, error, fatal)
+  message:*timeout*        Search message text
+  trace:abc123             Filter by trace ID
+  project:my-project       Filter by project slug
+
+  Combine filters: level:error message:*failed*
+
+Examples:
+  search-logs.js --org myorg
+  search-logs.js "level:error" --org myorg --project backend
+  search-logs.js "message:*timeout*" --org myorg --period 7d
+  search-logs.js --org myorg --limit 50 --json
+
+  # Use a Sentry URL directly:
+  search-logs.js "https://myorg.sentry.io/explore/logs/?project=123&statsPeriod=7d"
+`);
+}
+
+function formatLogEntry(entry) {
+  const lines = [];
+
+  const ts = entry.timestamp || "N/A";
+  const severity = entry["sentry.severity"] || "info";
+  const message = entry.message || "(no message)";
+  const trace = entry.trace || null;
+
+  // Format timestamp for display
+  let displayTs = ts;
+  try {
+    const date = new Date(ts);
+    if (!isNaN(date.getTime())) {
+      displayTs = date.toISOString().replace("T", " ").slice(0, 19);
+    }
+  } catch {}
+
+  // Color-code severity in output
+  const severityDisplay = `[${severity.toUpperCase().padEnd(5)}]`;
+
+  lines.push(`${displayTs} ${severityDisplay} ${message}`);
+
+  if (trace) {
+    lines.push(`  trace: ${trace}`);
+  }
+
+  return lines.join("\n");
+}
+
+function formatOutput(data) {
+  if (!data.data || data.data.length === 0) {
+    return "No logs found matching your query.";
+  }
+
+  const lines = [];
+  lines.push(`Found ${data.data.length} log entries:\n`);
+
+  for (const entry of data.data) {
+    lines.push(formatLogEntry(entry));
+    lines.push("");
+  }
+
+  return lines.join("\n").trimEnd();
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const options = parseArgs(args);
+
+  if (options.help) {
+    showHelp();
+    process.exit(0);
+  }
+
+  if (!options.org) {
+    console.error("Error: --org is required");
+    console.error("Run with --help for usage information");
+    process.exit(1);
+  }
+
+  const token = getAuthToken();
+
+  // Build query parameters
+  const params = new URLSearchParams();
+  params.set("dataset", "logs");
+  params.set("statsPeriod", options.period);
+  params.set("per_page", Math.min(options.limit, 1000).toString());
+  params.set("sort", "-timestamp");
+
+  // Add fields
+  for (const field of LOG_FIELDS) {
+    params.append("field", field);
+  }
+
+  // Build search query
+  const queryParts = [];
+  if (options.project) {
+    queryParts.push(`project:${options.project}`);
+  }
+  if (options.query) {
+    queryParts.push(options.query);
+  }
+  if (queryParts.length > 0) {
+    params.set("query", queryParts.join(" "));
+  }
+
+  const url = `${SENTRY_API_BASE}/organizations/${encodeURIComponent(options.org)}/events/?${params.toString()}`;
+
+  try {
+    const data = await fetchJson(url, token);
+
+    if (options.json) {
+      console.log(JSON.stringify(data, null, 2));
+    } else {
+      console.log(formatOutput(data));
+    }
+  } catch (err) {
+    console.error("Error:", err.message);
+    process.exit(1);
+  }
+}
+
+main();

package/skills/tmux/SKILL.md

@@ -0,0 +1,105 @@
+---
+name: tmux
+description: "Remote control tmux sessions for interactive CLIs (python, gdb, etc.) by sending keystrokes and scraping pane output."
+license: Vibecoded
+---
+
+# tmux Skill
+
+Use tmux as a programmable terminal multiplexer for interactive work. Works on Linux and macOS with stock tmux; avoid custom config by using a private socket.
+
+## Quickstart (isolated socket)
+
+```bash
+SOCKET_DIR=${TMPDIR:-/tmp}/claude-tmux-sockets  # well-known dir for all agent sockets
+mkdir -p "$SOCKET_DIR"
+SOCKET="$SOCKET_DIR/claude.sock"                # keep agent sessions separate from your personal tmux
+SESSION=claude-python                           # slug-like names; avoid spaces
+tmux -S "$SOCKET" new -d -s "$SESSION" -n shell
+tmux -S "$SOCKET" send-keys -t "$SESSION":0.0 -- 'python3 -q' Enter
+tmux -S "$SOCKET" capture-pane -p -J -t "$SESSION":0.0 -S -200  # watch output
+tmux -S "$SOCKET" kill-session -t "$SESSION"                   # clean up
+```
+
+After starting a session ALWAYS tell the user how to monitor the session by giving them a command to copy paste:
+
+```
+To monitor this session yourself:
+  tmux -S "$SOCKET" attach -t claude-lldb
+
+Or to capture the output once:
+  tmux -S "$SOCKET" capture-pane -p -J -t claude-lldb:0.0 -S -200
+```
+
+This must ALWAYS be printed right after a session was started and once again at the end of the tool loop.  But the earlier you send it, the happier the user will be.
+
+## Socket convention
+
+- Agents MUST place tmux sockets under `CLAUDE_TMUX_SOCKET_DIR` (defaults to `${TMPDIR:-/tmp}/claude-tmux-sockets`) and use `tmux -S "$SOCKET"` so we can enumerate/clean them. Create the dir first: `mkdir -p "$CLAUDE_TMUX_SOCKET_DIR"`.
+- Default socket path to use unless you must isolate further: `SOCKET="$CLAUDE_TMUX_SOCKET_DIR/claude.sock"`.
+
+## Targeting panes and naming
+
+- Target format: `{session}:{window}.{pane}`, defaults to `:0.0` if omitted. Keep names short (e.g., `claude-py`, `claude-gdb`).
+- Use `-S "$SOCKET"` consistently to stay on the private socket path. If you need user config, drop `-f /dev/null`; otherwise `-f /dev/null` gives a clean config.
+- Inspect: `tmux -S "$SOCKET" list-sessions`, `tmux -S "$SOCKET" list-panes -a`.
+
+## Finding sessions
+
+- List sessions on your active socket with metadata: `./scripts/find-sessions.sh -S "$SOCKET"`; add `-q partial-name` to filter.
+- Scan all sockets under the shared directory: `./scripts/find-sessions.sh --all` (uses `CLAUDE_TMUX_SOCKET_DIR` or `${TMPDIR:-/tmp}/claude-tmux-sockets`).
+
+## Sending input safely
+
+- Prefer literal sends to avoid shell splitting: `tmux -L "$SOCKET" send-keys -t target -l -- "$cmd"`
+- When composing inline commands, use single quotes or ANSI C quoting to avoid expansion: `tmux ... send-keys -t target -- $'python3 -m http.server 8000'`.
+- To send control keys: `tmux ... send-keys -t target C-c`, `C-d`, `C-z`, `Escape`, etc.
+
+## Watching output
+
+- Capture recent history (joined lines to avoid wrapping artifacts): `tmux -L "$SOCKET" capture-pane -p -J -t target -S -200`.
+- For continuous monitoring, poll with the helper script (below) instead of `tmux wait-for` (which does not watch pane output).
+- You can also temporarily attach to observe: `tmux -L "$SOCKET" attach -t "$SESSION"`; detach with `Ctrl+b d`.
+- When giving instructions to a user, **explicitly print a copy/paste monitor command** alongside the action don't assume they remembered the command.
+
+## Spawning Processes
+
+Some special rules for processes:
+
+- when asked to debug, use lldb by default
+- when starting a python interactive shell, always set the `PYTHON_BASIC_REPL=1` environment variable. This is very important as the non-basic console interferes with your send-keys.
+
+## Synchronizing / waiting for prompts
+
+- Use timed polling to avoid races with interactive tools. Example: wait for a Python prompt before sending code:
+  ```bash
+  ./scripts/wait-for-text.sh -t "$SESSION":0.0 -p '^>>>' -T 15 -l 4000
+  ```
+- For long-running commands, poll for completion text (`"Type quit to exit"`, `"Program exited"`, etc.) before proceeding.
+
+## Interactive tool recipes
+
+- **Python REPL**: `tmux ... send-keys -- 'python3 -q' Enter`; wait for `^>>>`; send code with `-l`; interrupt with `C-c`. Always with `PYTHON_BASIC_REPL`.
+- **gdb**: `tmux ... send-keys -- 'gdb --quiet ./a.out' Enter`; disable paging `tmux ... send-keys -- 'set pagination off' Enter`; break with `C-c`; issue `bt`, `info locals`, etc.; exit via `quit` then confirm `y`.
+- **Other TTY apps** (ipdb, psql, mysql, node, bash): same pattern—start the program, poll for its prompt, then send literal text and Enter.
+
+## Cleanup
+
+- Kill a session when done: `tmux -S "$SOCKET" kill-session -t "$SESSION"`.
+- Kill all sessions on a socket: `tmux -S "$SOCKET" list-sessions -F '#{session_name}' | xargs -r -n1 tmux -S "$SOCKET" kill-session -t`.
+- Remove everything on the private socket: `tmux -S "$SOCKET" kill-server`.
+
+## Helper: wait-for-text.sh
+
+`./scripts/wait-for-text.sh` polls a pane for a regex (or fixed string) with a timeout. Works on Linux/macOS with bash + tmux + grep.
+
+```bash
+./scripts/wait-for-text.sh -t session:0.0 -p 'pattern' [-F] [-T 20] [-i 0.5] [-l 2000]
+```
+
+- `-t`/`--target` pane target (required)
+- `-p`/`--pattern` regex to match (required); add `-F` for fixed string
+- `-T` timeout seconds (integer, default 15)
+- `-i` poll interval seconds (default 0.5)
+- `-l` history lines to search from the pane (integer, default 1000)
+- Exits 0 on first match, 1 on timeout. On failure prints the last captured text to stderr to aid debugging.

package/skills/tmux/scripts/find-sessions.sh

@@ -0,0 +1,112 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  cat <<'USAGE'
+Usage: find-sessions.sh [-L socket-name|-S socket-path|-A] [-q pattern]
+
+List tmux sessions on a socket (default tmux socket if none provided).
+
+Options:
+  -L, --socket       tmux socket name (passed to tmux -L)
+  -S, --socket-path  tmux socket path (passed to tmux -S)
+  -A, --all          scan all sockets under CLAUDE_TMUX_SOCKET_DIR
+  -q, --query        case-insensitive substring to filter session names
+  -h, --help         show this help
+USAGE
+}
+
+socket_name=""
+socket_path=""
+query=""
+scan_all=false
+socket_dir="${CLAUDE_TMUX_SOCKET_DIR:-${TMPDIR:-/tmp}/claude-tmux-sockets}"
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    -L|--socket)      socket_name="${2-}"; shift 2 ;;
+    -S|--socket-path) socket_path="${2-}"; shift 2 ;;
+    -A|--all)         scan_all=true; shift ;;
+    -q|--query)       query="${2-}"; shift 2 ;;
+    -h|--help)        usage; exit 0 ;;
+    *) echo "Unknown option: $1" >&2; usage; exit 1 ;;
+  esac
+done
+
+if [[ "$scan_all" == true && ( -n "$socket_name" || -n "$socket_path" ) ]]; then
+  echo "Cannot combine --all with -L or -S" >&2
+  exit 1
+fi
+
+if [[ -n "$socket_name" && -n "$socket_path" ]]; then
+  echo "Use either -L or -S, not both" >&2
+  exit 1
+fi
+
+if ! command -v tmux >/dev/null 2>&1; then
+  echo "tmux not found in PATH" >&2
+  exit 1
+fi
+
+list_sessions() {
+  local label="$1"; shift
+  local tmux_cmd=(tmux "$@")
+
+  if ! sessions="$("${tmux_cmd[@]}" list-sessions -F '#{session_name}\t#{session_attached}\t#{session_created_string}' 2>/dev/null)"; then
+    echo "No tmux server found on $label" >&2
+    return 1
+  fi
+
+  if [[ -n "$query" ]]; then
+    sessions="$(printf '%s\n' "$sessions" | grep -i -- "$query" || true)"
+  fi
+
+  if [[ -z "$sessions" ]]; then
+    echo "No sessions found on $label"
+    return 0
+  fi
+
+  echo "Sessions on $label:"
+  printf '%s\n' "$sessions" | while IFS=$'\t' read -r name attached created; do
+    attached_label=$([[ "$attached" == "1" ]] && echo "attached" || echo "detached")
+    printf '  - %s (%s, started %s)\n' "$name" "$attached_label" "$created"
+  done
+}
+
+if [[ "$scan_all" == true ]]; then
+  if [[ ! -d "$socket_dir" ]]; then
+    echo "Socket directory not found: $socket_dir" >&2
+    exit 1
+  fi
+
+  shopt -s nullglob
+  sockets=("$socket_dir"/*)
+  shopt -u nullglob
+
+  if [[ "${#sockets[@]}" -eq 0 ]]; then
+    echo "No sockets found under $socket_dir" >&2
+    exit 1
+  fi
+
+  exit_code=0
+  for sock in "${sockets[@]}"; do
+    if [[ ! -S "$sock" ]]; then
+      continue
+    fi
+    list_sessions "socket path '$sock'" -S "$sock" || exit_code=$?
+  done
+  exit "$exit_code"
+fi
+
+tmux_cmd=(tmux)
+socket_label="default socket"
+
+if [[ -n "$socket_name" ]]; then
+  tmux_cmd+=(-L "$socket_name")
+  socket_label="socket name '$socket_name'"
+elif [[ -n "$socket_path" ]]; then
+  tmux_cmd+=(-S "$socket_path")
+  socket_label="socket path '$socket_path'"
+fi
+
+list_sessions "$socket_label" "${tmux_cmd[@]:1}"

package/skills/tmux/scripts/wait-for-text.sh

@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  cat <<'USAGE'
+Usage: wait-for-text.sh -t target -p pattern [options]
+
+Poll a tmux pane for text and exit when found.
+
+Options:
+  -t, --target    tmux target (session:window.pane), required
+  -p, --pattern   regex pattern to look for, required
+  -F, --fixed     treat pattern as a fixed string (grep -F)
+  -T, --timeout   seconds to wait (integer, default: 15)
+  -i, --interval  poll interval in seconds (default: 0.5)
+  -l, --lines     number of history lines to inspect (integer, default: 1000)
+  -h, --help      show this help
+USAGE
+}
+
+target=""
+pattern=""
+grep_flag="-E"
+timeout=15
+interval=0.5
+lines=1000
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    -t|--target)   target="${2-}"; shift 2 ;;
+    -p|--pattern)  pattern="${2-}"; shift 2 ;;
+    -F|--fixed)    grep_flag="-F"; shift ;;
+    -T|--timeout)  timeout="${2-}"; shift 2 ;;
+    -i|--interval) interval="${2-}"; shift 2 ;;
+    -l|--lines)    lines="${2-}"; shift 2 ;;
+    -h|--help)     usage; exit 0 ;;
+    *) echo "Unknown option: $1" >&2; usage; exit 1 ;;
+  esac
+done
+
+if [[ -z "$target" || -z "$pattern" ]]; then
+  echo "target and pattern are required" >&2
+  usage
+  exit 1
+fi
+
+if ! [[ "$timeout" =~ ^[0-9]+$ ]]; then
+  echo "timeout must be an integer number of seconds" >&2
+  exit 1
+fi
+
+if ! [[ "$lines" =~ ^[0-9]+$ ]]; then
+  echo "lines must be an integer" >&2
+  exit 1
+fi
+
+if ! command -v tmux >/dev/null 2>&1; then
+  echo "tmux not found in PATH" >&2
+  exit 1
+fi
+
+# End time in epoch seconds (integer, good enough for polling)
+start_epoch=$(date +%s)
+deadline=$((start_epoch + timeout))
+
+while true; do
+  # -J joins wrapped lines, -S uses negative index to read last N lines
+  pane_text="$(tmux capture-pane -p -J -t "$target" -S "-${lines}" 2>/dev/null || true)"
+
+  if printf '%s\n' "$pane_text" | grep $grep_flag -- "$pattern" >/dev/null 2>&1; then
+    exit 0
+  fi
+
+  now=$(date +%s)
+  if (( now >= deadline )); then
+    echo "Timed out after ${timeout}s waiting for pattern: $pattern" >&2
+    echo "Last ${lines} lines from $target:" >&2
+    printf '%s\n' "$pane_text" >&2
+    exit 1
+  fi
+
+  sleep "$interval"
+done

package/skills/web-browser/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: web-browser
+description: "Allows to interact with web pages by performing actions such as clicking buttons, filling out forms, and navigating links. It works by remote controlling Google Chrome or Chromium browsers using the Chrome DevTools Protocol (CDP). When Claude needs to browse the web, it can use this skill to do so."
+license: Stolen from Mario
+---
+
+# Web Browser Skill
+
+Minimal CDP tools for collaborative site exploration.
+
+## Start Chrome
+
+```bash
+./scripts/start.js              # Fresh profile
+./scripts/start.js --profile    # Copy your profile (cookies, logins)
+```
+
+Start Chrome on `:9222` with remote debugging.
+
+## Navigate
+
+```bash
+./scripts/nav.js https://example.com
+./scripts/nav.js https://example.com --new
+```
+
+Navigate current tab or open new tab.
+
+## Evaluate JavaScript
+
+```bash
+./scripts/eval.js 'document.title'
+./scripts/eval.js 'document.querySelectorAll("a").length'
+./scripts/eval.js 'JSON.stringify(Array.from(document.querySelectorAll("a")).map(a => ({ text: a.textContent.trim(), href: a.href })).filter(link => !link.href.startsWith("https://")))'
+```
+
+Execute JavaScript in active tab (async context).  Be careful with string escaping, best to use single quotes.
+
+## Screenshot
+
+```bash
+./scripts/screenshot.js
+```
+
+Screenshot current viewport, returns temp file path
+
+## Pick Elements
+
+```bash
+./scripts/pick.js "Click the submit button"
+```
+
+Interactive element picker. Click to select, Cmd/Ctrl+Click for multi-select, Enter to finish.
+
+## Dismiss Cookie Dialogs
+
+```bash
+./scripts/dismiss-cookies.js          # Accept cookies
+./scripts/dismiss-cookies.js --reject # Reject cookies (where possible)
+```
+
+Automatically dismisses EU cookie consent dialogs.
+
+Run after navigating to a page:
+```bash
+./scripts/nav.js https://example.com && ./scripts/dismiss-cookies.js
+```
+
+## Background Logging (Console + Errors + Network)
+
+Automatically started by `start.js` and writes JSONL logs to:
+
+```
+~/.cache/agent-web/logs/YYYY-MM-DD/<targetId>.jsonl
+```
+
+Manually start:
+```bash
+./scripts/watch.js
+```
+
+Tail latest log:
+```bash
+./scripts/logs-tail.js           # dump current log and exit
+./scripts/logs-tail.js --follow  # keep following
+```
+
+Summarize network responses:
+```bash
+./scripts/net-summary.js
+```