@symerian/symi 3.0.16 → 3.0.18

package/skills/imsg/SKILL.md

@@ -1,122 +0,0 @@
----
-name: imsg
-description: iMessage/SMS CLI for listing chats, history, and sending messages via Messages.app.
-homepage: https://imsg.to
-metadata:
-  {
-    "symi":
-      {
-        "emoji": "📨",
-        "os": ["darwin"],
-        "requires": { "bins": ["imsg"] },
-        "install":
-          [
-            {
-              "id": "brew",
-              "kind": "brew",
-              "formula": "steipete/tap/imsg",
-              "bins": ["imsg"],
-              "label": "Install imsg (brew)",
-            },
-          ],
-      },
-  }
-triggers: [imsg]
----
-
-# imsg
-
-Use `imsg` to read and send iMessage/SMS via macOS Messages.app.
-
-## When to Use
-
-✅ **USE this skill when:**
-
-- User explicitly asks to send iMessage or SMS
-- Reading iMessage conversation history
-- Checking recent Messages.app chats
-- Sending to phone numbers or Apple IDs
-
-## When NOT to Use
-
-❌ **DON'T use this skill when:**
-
-- Telegram messages → use `message` tool with `channel:telegram`
-- Signal messages → use Signal channel if configured
-- WhatsApp messages → use WhatsApp channel if configured
-- Slack messages → use `slack` skill
-- Group chat management (adding/removing members) → not supported
-- Bulk/mass messaging → always confirm with user first
-- Replying in current conversation → just reply normally (Symi routes automatically)
-
-## Requirements
-
-- macOS with Messages.app signed in
-- Full Disk Access for terminal
-- Automation permission for Messages.app (for sending)
-
-## Common Commands
-
-### List Chats
-
-```bash
-imsg chats --limit 10 --json
-```
-
-### View History
-
-```bash
-# By chat ID
-imsg history --chat-id 1 --limit 20 --json
-
-# With attachments info
-imsg history --chat-id 1 --limit 20 --attachments --json
-```
-
-### Watch for New Messages
-
-```bash
-imsg watch --chat-id 1 --attachments
-```
-
-### Send Messages
-
-```bash
-# Text only
-imsg send --to "+14155551212" --text "Hello!"
-
-# With attachment
-imsg send --to "+14155551212" --text "Check this out" --file /path/to/image.jpg
-
-# Specify service
-imsg send --to "+14155551212" --text "Hi" --service imessage
-imsg send --to "+14155551212" --text "Hi" --service sms
-```
-
-## Service Options
-
-- `--service imessage` — Force iMessage (requires recipient has iMessage)
-- `--service sms` — Force SMS (green bubble)
-- `--service auto` — Let Messages.app decide (default)
-
-## Safety Rules
-
-1. **Always confirm recipient and message content** before sending
-2. **Never send to unknown numbers** without explicit user approval
-3. **Be careful with attachments** — confirm file path exists
-4. **Rate limit yourself** — don't spam
-
-## Example Workflow
-
-User: "Text mom that I'll be late"
-
-```bash
-# 1. Find mom's chat
-imsg chats --limit 20 --json | jq '.[] | select(.displayName | contains("Mom"))'
-
-# 2. Confirm with user
-# "Found Mom at +1555123456. Send 'I'll be late' via iMessage?"
-
-# 3. Send after confirmation
-imsg send --to "+1555123456" --text "I'll be late"
-```

package/skills/long-task/SKILL.md

@@ -1,58 +0,0 @@
----
-name: long-task
-description: Run long operations (deep scans, brute-forces, big builds, exhaustive enumeration) without hitting the agent-turn timeout. Detaches the command with setsid+nohup and schedules a cron monitor that polls status every 2-3 minutes. Use when a single exec call may exceed 15 minutes (deep nmap `-sS -sV -O` on /24 or larger, full hydra/gobuster/ffuf/masscan sweeps, multi-hour builds).
-triggers: [long-task, long, task]
----
-
-# Long-Running Task — detach + cron monitor pattern
-
-Deep scans (`nmap -sS -sV -O` on a /24, comprehensive `-sC` sweeps, full TCP/UDP, long brute-forces, big builds) routinely run 25–60 minutes. The agent-turn timeout (`agents.defaults.timeoutSeconds`, default 1800 = 30 min) is a hard ceiling, and a foreground-blocked exec tool call will SIGTERM the subprocess when the turn ends. **Do not foreground long tasks.** Use this two-part pattern instead.
-
-## Part 1 — Detach the task
-
-Launch with the helper script bundled with this skill:
-
-    <skill-dir>/scripts/detach-task.sh <task-id> <workdir> <command...>
-
-Where:
-
-- `<task-id>` is a short identifier you pick (e.g. `scan-192-168-10`)
-- `<workdir>` is a directory the state files will be written into (agent workspace is fine)
-- `<command...>` is the literal command you want to run
-
-The script creates in `<workdir>`:
-
-- `task-<id>.pid` — PID of the detached process
-- `task-<id>.cmd` — the literal command line
-- `task-<id>.started` — ISO-8601 start timestamp
-- `task-<id>.log` — merged stdout/stderr
-- `task-<id>.status` — `running` while alive, `complete rc=<N>` after exit
-
-After running, **return control to the user immediately** with: task id, PID, log path, your ETA, and a note that a cron monitor will be scheduled.
-
-## Part 2 — Schedule the cron monitor
-
-Use the `cron` tool with `action: add`. Schedule every 2–3 minutes. The job prompt must be self-contained — include the task-id, PID, log path, and status path literally, since a future agent turn will receive only that prompt.
-
-Example job prompt:
-
-> Check if PID <pid> is alive (`kill -0 <pid> 2>/dev/null`).
-> If alive: tail -n 20 <log-path>, post one-sentence progress update.
-> If not alive: read <status-path> and tail <log-path>, post final summary, then call the cron tool with `action: remove, id: <this-cron-id>` to clean up.
-
-## Part 3 — Cleanup
-
-The monitor cron job is responsible for removing itself when it detects `status=complete`. Do not leave stale monitors running.
-
-## Why this works
-
-- `setsid` puts the subprocess in a new session — it survives SIGHUP.
-- `nohup` ignores SIGHUP directly as belt-and-braces.
-- The outer shell exits immediately, so the agent-turn abort (which kills the process tree of the shell the agent spawned) never reaches the detached task — it's no longer a descendant.
-- Each agent turn stays short (initial detach <1 min, each cron check <30 sec, final summary <1 min), so the default 1800s ceiling never fires.
-
-## When NOT to use this pattern
-
-- Short scans (single host, small port range) that complete in under 10 minutes — foreground exec is simpler.
-- Interactive commands that need a TTY — the script closes stdin and redirects stdout/stderr.
-- Tasks where you need to stream output back to the user in real time — the cron-monitor pattern polls at 2–3 min intervals, not live.

package/skills/long-task/scripts/detach-task.sh

@@ -1,187 +0,0 @@
-#!/usr/bin/env bash
-# detach-task.sh — launch a long-running command fully detached from the
-# calling agent turn, so it survives the agent-turn timeout (default 30 min).
-#
-# Usage:
-#   detach-task.sh <task-id> <workdir> <command...>
-#
-# Creates in <workdir>:
-#   task-<id>.pid       — PID of the detached process
-#   task-<id>.cmd       — literal command line (for future agent turns to see)
-#   task-<id>.started   — ISO-8601 start timestamp
-#   task-<id>.log       — combined stdout + stderr (grows as task runs)
-#   task-<id>.status    — "running pid=<N> started=<ISO>"
-#                         → "complete rc=<N> ended=<ISO>" on clean exit
-#                         → "aborted rc=<N> signal=<NAME>" on SIGTERM/INT/HUP
-#
-# Exit code: 0 on successful spawn, 1 on missing args, 2 on invalid args,
-#            3 on workdir creation failure, 4 on task-id collision (a task
-#            with the same id is already running).
-#
-# Hardening notes (2.7.0):
-# - task-id is validated against an allow-list ([a-zA-Z0-9._-], 1–60 chars,
-#   must not start with '.' or '-'). Prevents path traversal via task-id.
-# - workdir must be an absolute path.
-# - Status file is written via tmp + mv so concurrent readers never see a
-#   half-written file and the "stuck at running after SIGTERM" failure mode
-#   is eliminated.
-# - Child shell has a TERM/INT/HUP trap that records an "aborted" status
-#   before exiting, so external kill signals leave a deterministic record.
-#
-# Hardening notes (post-2.8.12):
-# - Pre-flight collision check: refuses to overwrite the state files of a
-#   task-id whose recorded PID is still alive (exit code 4).
-# - Log file is bounded by LONG_TASK_LOG_MAX_BYTES (default 104857600 =
-#   100 MiB; override via env). Once exceeded, a single marker line is
-#   written and further output is silently discarded — the producer keeps
-#   running, never gets SIGPIPE.
-#
-# Design notes:
-# - setsid + nohup + disown: triple-armor against SIGHUP when the parent
-#   shell exits. The subprocess gets its own session.
-# - stdin closed, stdout/stderr redirected to the log file. No terminal.
-# - The wrapper shell exits immediately after spawning; does NOT wait.
-
-set -euo pipefail
-
-if [[ $# -lt 3 ]]; then
-  echo "usage: $0 <task-id> <workdir> <command...>" >&2
-  exit 1
-fi
-
-raw_task_id="$1"
-workdir="$2"
-shift 2
-
-# --- task-id validation -----------------------------------------------------
-if [[ -z "$raw_task_id" ]]; then
-  echo "detach-task: task-id must not be empty" >&2
-  exit 2
-fi
-if [[ ${#raw_task_id} -gt 60 ]]; then
-  echo "detach-task: task-id exceeds 60 chars" >&2
-  exit 2
-fi
-if [[ "$raw_task_id" =~ [^a-zA-Z0-9._-] ]]; then
-  echo "detach-task: task-id contains illegal chars (allowed: alphanumeric, dot, dash, underscore): $raw_task_id" >&2
-  exit 2
-fi
-case "$raw_task_id" in
-  .* | -*)
-    echo "detach-task: task-id must not start with dot or dash: $raw_task_id" >&2
-    exit 2
-    ;;
-esac
-task_id="$raw_task_id"
-
-# --- workdir validation -----------------------------------------------------
-if [[ "$workdir" != /* ]]; then
-  echo "detach-task: workdir must be an absolute path: $workdir" >&2
-  exit 2
-fi
-if ! mkdir -p "$workdir"; then
-  echo "detach-task: cannot create workdir: $workdir" >&2
-  exit 3
-fi
-
-# --- log size cap -----------------------------------------------------------
-log_max_bytes="${LONG_TASK_LOG_MAX_BYTES:-104857600}"
-if ! [[ "$log_max_bytes" =~ ^[0-9]+$ ]] || (( log_max_bytes < 1 )); then
-  echo "detach-task: LONG_TASK_LOG_MAX_BYTES must be a positive integer (got: $log_max_bytes)" >&2
-  exit 2
-fi
-
-pid_file="$workdir/task-${task_id}.pid"
-cmd_file="$workdir/task-${task_id}.cmd"
-started_file="$workdir/task-${task_id}.started"
-log_file="$workdir/task-${task_id}.log"
-status_file="$workdir/task-${task_id}.status"
-
-# --- collision check --------------------------------------------------------
-# If a pid file exists and the recorded PID is still alive, a prior task with
-# this id is already running. Refuse to clobber its log/status files.
-# Stale pid files (process already dead) are silently overwritten below.
-if [[ -f "$pid_file" ]]; then
-  prior_pid="$(tr -dc '0-9' < "$pid_file" 2>/dev/null || true)"
-  if [[ -n "$prior_pid" ]] && kill -0 "$prior_pid" 2>/dev/null; then
-    echo "detach-task: task-id '$task_id' is already running (pid=$prior_pid). Pick a different id or wait for it to finish." >&2
-    exit 4
-  fi
-fi
-
-# --- atomic status writer (parent) -----------------------------------------
-write_status_atomic() {
-  local _payload="$1"
-  local _tmp="${status_file}.$$.${RANDOM}.tmp"
-  printf '%s\n' "$_payload" > "$_tmp"
-  mv -f "$_tmp" "$status_file"
-}
-
-printf '%s\n' "$*" > "$cmd_file"
-started_at="$(date -u -Iseconds)"
-printf '%s\n' "$started_at" > "$started_file"
-write_status_atomic "running started=$started_at"
-
-# --- detached child --------------------------------------------------------
-# The inner `bash -c` inherits status/log paths as positional args so we
-# never string-interpolate paths into the script body. The inner script
-# re-implements the atomic writer (functions don't cross process boundaries
-# via `bash -c`). A TERM/INT/HUP trap catches external kill signals and
-# writes a terminal "aborted" status before exiting with the signal's code.
-setsid nohup bash -c '
-  set -u
-  _status="$1"
-  _log="$2"
-  _max="$3"
-  shift 3
-  _write() {
-    local _tmp="${_status}.$$.${RANDOM}.tmp"
-    printf "%s\n" "$1" > "$_tmp" && mv -f "$_tmp" "$_status"
-  }
-  _on_signal() {
-    local _sig="$1"
-    local _rc=$?
-    _write "aborted rc=$_rc signal=$_sig ended=$(date -u -Iseconds)" 2>/dev/null || true
-    exit "$_rc"
-  }
-  # Reads stdin line-by-line, prints to its stdout (which the caller
-  # redirects to the log file) up to _max total bytes, then writes one
-  # cap marker and silently discards the rest. Reading continues until
-  # EOF so the producing pipe never receives SIGPIPE.
-  _log_capper() {
-    local _total=0
-    local _capped=0
-    local _line
-    local _ls
-    while IFS= read -r _line; do
-      if (( _capped )); then
-        continue
-      fi
-      _ls=$(( ${#_line} + 1 ))
-      if (( _total + _ls > _max )); then
-        printf "[long-task: log capped at %s bytes; further output discarded]\n" "$_max"
-        _capped=1
-        continue
-      fi
-      printf "%s\n" "$_line"
-      _total=$(( _total + _ls ))
-    done
-  }
-  trap "_on_signal TERM" TERM
-  trap "_on_signal INT"  INT
-  trap "_on_signal HUP"  HUP
-  "$@" 2>&1 | _log_capper >> "$_log"
-  rc=${PIPESTATUS[0]}
-  _write "complete rc=$rc ended=$(date -u -Iseconds)"
-' -- "$status_file" "$log_file" "$log_max_bytes" "$@" < /dev/null > /dev/null 2>&1 &
-
-pid=$!
-disown "$pid" 2>/dev/null || true
-printf '%d\n' "$pid" > "$pid_file"
-
-# Finalise the parent status with the PID once known. The child may race us
-# and overwrite with "complete" if the command was very fast — that's fine,
-# the mv is atomic and the final state wins.
-write_status_atomic "running pid=$pid started=$started_at"
-
-echo "spawned task=$task_id pid=$pid log=$log_file status=$status_file"

package/skills/nano-banana-pro/SKILL.md

@@ -1,59 +0,0 @@
----
-name: nano-banana-pro
-description: Generate or edit images via Gemini 3 Pro Image (Nano Banana Pro).
-homepage: https://ai.google.dev/
-metadata:
-  {
-    "symi":
-      {
-        "emoji": "🍌",
-        "requires": { "bins": ["uv"], "env": ["GEMINI_API_KEY"] },
-        "primaryEnv": "GEMINI_API_KEY",
-        "install":
-          [
-            {
-              "id": "uv-brew",
-              "kind": "brew",
-              "formula": "uv",
-              "bins": ["uv"],
-              "label": "Install uv (brew)",
-            },
-          ],
-      },
-  }
-triggers: [nano-banana-pro, nano, banana, pro]
----
-
-# Nano Banana Pro (Gemini 3 Pro Image)
-
-Use the bundled script to generate or edit images.
-
-Generate
-
-```bash
-uv run {baseDir}/scripts/generate_image.py --prompt "your image description" --filename "output.png" --resolution 1K
-```
-
-Edit (single image)
-
-```bash
-uv run {baseDir}/scripts/generate_image.py --prompt "edit instructions" --filename "output.png" -i "/path/in.png" --resolution 2K
-```
-
-Multi-image composition (up to 14 images)
-
-```bash
-uv run {baseDir}/scripts/generate_image.py --prompt "combine these into one scene" --filename "output.png" -i img1.png -i img2.png -i img3.png
-```
-
-API key
-
-- `GEMINI_API_KEY` env var
-- Or set `skills."nano-banana-pro".apiKey` / `skills."nano-banana-pro".env.GEMINI_API_KEY` in `~/.symi/symi.json`
-
-Notes
-
-- Resolutions: `1K` (default), `2K`, `4K`.
-- Use timestamps in filenames: `yyyy-mm-dd-hh-mm-ss-name.png`.
-- The script prints a `MEDIA:` line for Symi to auto-attach on supported chat providers.
-- Do not read the image back; report the saved path only.

package/skills/nano-banana-pro/scripts/generate_image.py

@@ -1,184 +0,0 @@
-#!/usr/bin/env python3
-# /// script
-# requires-python = ">=3.10"
-# dependencies = [
-#     "google-genai>=1.0.0",
-#     "pillow>=10.0.0",
-# ]
-# ///
-"""
-Generate images using Google's Nano Banana Pro (Gemini 3 Pro Image) API.
-
-Usage:
-    uv run generate_image.py --prompt "your image description" --filename "output.png" [--resolution 1K|2K|4K] [--api-key KEY]
-
-Multi-image editing (up to 14 images):
-    uv run generate_image.py --prompt "combine these images" --filename "output.png" -i img1.png -i img2.png -i img3.png
-"""
-
-import argparse
-import os
-import sys
-from pathlib import Path
-
-
-def get_api_key(provided_key: str | None) -> str | None:
-    """Get API key from argument first, then environment."""
-    if provided_key:
-        return provided_key
-    return os.environ.get("GEMINI_API_KEY")
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Generate images using Nano Banana Pro (Gemini 3 Pro Image)"
-    )
-    parser.add_argument(
-        "--prompt", "-p",
-        required=True,
-        help="Image description/prompt"
-    )
-    parser.add_argument(
-        "--filename", "-f",
-        required=True,
-        help="Output filename (e.g., sunset-mountains.png)"
-    )
-    parser.add_argument(
-        "--input-image", "-i",
-        action="append",
-        dest="input_images",
-        metavar="IMAGE",
-        help="Input image path(s) for editing/composition. Can be specified multiple times (up to 14 images)."
-    )
-    parser.add_argument(
-        "--resolution", "-r",
-        choices=["1K", "2K", "4K"],
-        default="1K",
-        help="Output resolution: 1K (default), 2K, or 4K"
-    )
-    parser.add_argument(
-        "--api-key", "-k",
-        help="Gemini API key (overrides GEMINI_API_KEY env var)"
-    )
-
-    args = parser.parse_args()
-
-    # Get API key
-    api_key = get_api_key(args.api_key)
-    if not api_key:
-        print("Error: No API key provided.", file=sys.stderr)
-        print("Please either:", file=sys.stderr)
-        print("  1. Provide --api-key argument", file=sys.stderr)
-        print("  2. Set GEMINI_API_KEY environment variable", file=sys.stderr)
-        sys.exit(1)
-
-    # Import here after checking API key to avoid slow import on error
-    from google import genai
-    from google.genai import types
-    from PIL import Image as PILImage
-
-    # Initialise client
-    client = genai.Client(api_key=api_key)
-
-    # Set up output path
-    output_path = Path(args.filename)
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-
-    # Load input images if provided (up to 14 supported by Nano Banana Pro)
-    input_images = []
-    output_resolution = args.resolution
-    if args.input_images:
-        if len(args.input_images) > 14:
-            print(f"Error: Too many input images ({len(args.input_images)}). Maximum is 14.", file=sys.stderr)
-            sys.exit(1)
-
-        max_input_dim = 0
-        for img_path in args.input_images:
-            try:
-                img = PILImage.open(img_path)
-                input_images.append(img)
-                print(f"Loaded input image: {img_path}")
-
-                # Track largest dimension for auto-resolution
-                width, height = img.size
-                max_input_dim = max(max_input_dim, width, height)
-            except Exception as e:
-                print(f"Error loading input image '{img_path}': {e}", file=sys.stderr)
-                sys.exit(1)
-
-        # Auto-detect resolution from largest input if not explicitly set
-        if args.resolution == "1K" and max_input_dim > 0:  # Default value
-            if max_input_dim >= 3000:
-                output_resolution = "4K"
-            elif max_input_dim >= 1500:
-                output_resolution = "2K"
-            else:
-                output_resolution = "1K"
-            print(f"Auto-detected resolution: {output_resolution} (from max input dimension {max_input_dim})")
-
-    # Build contents (images first if editing, prompt only if generating)
-    if input_images:
-        contents = [*input_images, args.prompt]
-        img_count = len(input_images)
-        print(f"Processing {img_count} image{'s' if img_count > 1 else ''} with resolution {output_resolution}...")
-    else:
-        contents = args.prompt
-        print(f"Generating image with resolution {output_resolution}...")
-
-    try:
-        response = client.models.generate_content(
-            model="gemini-3-pro-image-preview",
-            contents=contents,
-            config=types.GenerateContentConfig(
-                response_modalities=["TEXT", "IMAGE"],
-                image_config=types.ImageConfig(
-                    image_size=output_resolution
-                )
-            )
-        )
-
-        # Process response and convert to PNG
-        image_saved = False
-        for part in response.parts:
-            if part.text is not None:
-                print(f"Model response: {part.text}")
-            elif part.inline_data is not None:
-                # Convert inline data to PIL Image and save as PNG
-                from io import BytesIO
-
-                # inline_data.data is already bytes, not base64
-                image_data = part.inline_data.data
-                if isinstance(image_data, str):
-                    # If it's a string, it might be base64
-                    import base64
-                    image_data = base64.b64decode(image_data)
-
-                image = PILImage.open(BytesIO(image_data))
-
-                # Ensure RGB mode for PNG (convert RGBA to RGB with white background if needed)
-                if image.mode == 'RGBA':
-                    rgb_image = PILImage.new('RGB', image.size, (255, 255, 255))
-                    rgb_image.paste(image, mask=image.split()[3])
-                    rgb_image.save(str(output_path), 'PNG')
-                elif image.mode == 'RGB':
-                    image.save(str(output_path), 'PNG')
-                else:
-                    image.convert('RGB').save(str(output_path), 'PNG')
-                image_saved = True
-
-        if image_saved:
-            full_path = output_path.resolve()
-            print(f"\nImage saved: {full_path}")
-            # Symi parses MEDIA tokens and will attach the file on supported providers.
-            print(f"MEDIA: {full_path}")
-        else:
-            print("Error: No image was generated in the response.", file=sys.stderr)
-            sys.exit(1)
-
-    except Exception as e:
-        print(f"Error generating image: {e}", file=sys.stderr)
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

package/skills/nano-pdf/SKILL.md

@@ -1,39 +0,0 @@
----
-name: nano-pdf
-description: Edit PDFs with natural-language instructions using the nano-pdf CLI.
-homepage: https://pypi.org/project/nano-pdf/
-metadata:
-  {
-    "symi":
-      {
-        "emoji": "📄",
-        "requires": { "bins": ["nano-pdf"] },
-        "install":
-          [
-            {
-              "id": "uv",
-              "kind": "uv",
-              "package": "nano-pdf",
-              "bins": ["nano-pdf"],
-              "label": "Install nano-pdf (uv)",
-            },
-          ],
-      },
-  }
-triggers: [nano-pdf, nano, pdf]
----
-
-# nano-pdf
-
-Use `nano-pdf` to apply edits to a specific page in a PDF using a natural-language instruction.
-
-## Quick start
-
-```bash
-nano-pdf edit deck.pdf 1 "Change the title to 'Q3 Results' and fix the typo in the subtitle"
-```
-
-Notes:
-
-- Page numbers are 0-based or 1-based depending on the tool’s version/config; if the result looks off by one, retry with the other.
-- Always sanity-check the output PDF before sending it out.