cue-ai 0.9.0 → 0.9.2

package/resources/skills/skills/ssh/ssh-paste-image/SKILL.md

@@ -0,0 +1,149 @@
+---
+name: ssh-paste-image
+description: >-
+  Use when the user wants to paste a local clipboard image into Claude Code
+  running over SSH, says "paste image over ssh", "can't paste images on the
+  remote", "send screenshot to remote claude", or "/paste-image".
+tags: [ssh, clipboard, image, remote, paste]
+category: ssh
+triggers: ["paste image over ssh", "can't paste images on the remote", "/paste-image", "send screenshot to remote claude", "paste clipboard image remote"]
+allowed-tools: Bash(ccimg:*), Bash(go:*), Bash(systemctl:*), Bash(launchctl:*), Bash(scp:*), Read
+---
+
+# SSH paste-image
+
+Claude Code can't paste a clipboard image when you run it over SSH: the clipboard
+lives on your local machine, the agent runs on the remote host. This skill bridges
+the gap. A tiny daemon on your local machine reads the clipboard and serves the
+PNG; a client on the remote pulls it through the SSH connection and writes a temp
+file the agent can `Read`. The daemon and client are vendored under `scripts/`
+(Go source, MIT, from AlexZeitler/claude-ssh-image-skill).
+
+## When to activate
+
+- The user is in a Claude Code session on a remote SSH host and wants to share an image.
+- The user says "paste image over ssh", "I can't paste a screenshot on the server", "/paste-image", or "send this image to the remote session".
+- A task on the remote needs an image the user has on their local clipboard (a screenshot, a design, an error photo).
+
+Do NOT use this for local sessions (paste works natively) or for copying image files that already exist on the remote (use `ssh-copy`).
+
+## How it works
+
+```
+Local Machine                            Remote Server (SSH)
+┌──────────────────────┐                 ┌──────────────────────────┐
+│  Clipboard (PNG)     │                 │  Claude Code             │
+│        │             │                 │        │                 │
+│        ▼             │                 │        ▼                 │
+│  ccimgd (Port 9998)  │◄────────────────│  ssh-paste-image skill   │
+│  - wl-paste/xclip    │  SSH Reverse    │  - TCP request to ccimgd │
+│  - returns base64    │  Tunnel         │  - receives base64 image │
+│    image in response │  (Port 9998)    │  - saves a temp PNG      │
+│                      │                 │  - Read → agent sees it  │
+└──────────────────────┘                 └──────────────────────────┘
+```
+
+1. The skill runs `ccimg` on the remote, which opens a TCP request to `127.0.0.1:9998`.
+2. That port is forwarded over the SSH reverse tunnel to the local `ccimgd`.
+3. `ccimgd` reads the clipboard PNG (`wl-paste` on Wayland, `xclip` on X11, `pngpaste` on macOS) and returns base64 JSON.
+4. `ccimg` decodes it, writes `/tmp/clipboard-<pid>.png`, and prints the path.
+5. The skill uses `Read` on that path so the agent sees the image.
+
+## Prerequisites
+
+- **Build (anywhere with Go):** `go` 1.26+ for `bash scripts/build.sh`.
+- **Local machine, Linux Wayland:** `wl-paste` from `wl-clipboard` (apt: `sudo apt install -y wl-clipboard`).
+- **Local machine, Linux X11:** `xclip` (apt: `sudo apt install -y xclip`).
+- **Local machine, macOS:** `pngpaste` (brew: `brew install pngpaste`).
+- **Remote host:** Claude Code, plus the `ccimg` client binary (installed in step 3 below).
+
+## Setup (one time)
+
+### 1. Build the binaries
+
+From this skill's directory (where this SKILL.md lives):
+
+```bash
+bash scripts/build.sh
+```
+
+This writes static binaries for linux/amd64, linux/arm64, darwin/amd64, darwin/arm64 into `scripts/daemon/` and `scripts/client/`.
+
+### 2. Install the daemon on your LOCAL machine
+
+Linux (systemd user service):
+
+```bash
+cp scripts/daemon/ccimgd-linux-amd64 ~/.local/bin/ccimgd   # or -linux-arm64
+cp scripts/daemon/ccimgd.service ~/.config/systemd/user/
+systemctl --user daemon-reload
+systemctl --user enable --now ccimgd
+```
+
+macOS (launchd agent):
+
+```bash
+cp scripts/daemon/ccimgd-darwin-arm64 /usr/local/bin/ccimgd   # or -darwin-amd64 on Intel
+cp scripts/daemon/com.ccimgd.plist ~/Library/LaunchAgents/
+launchctl load ~/Library/LaunchAgents/com.ccimgd.plist
+```
+
+### 3. Install the client on the REMOTE host
+
+```bash
+scp scripts/client/ccimg-linux-amd64 your-server:~/.local/bin/ccimg   # match the server arch
+ssh your-server 'chmod +x ~/.local/bin/ccimg'
+```
+
+To skip the per-call permission prompt, add to the remote `~/.claude/settings.json`:
+
+```json
+{ "permissions": { "allow": ["Bash(ccimg)"] } }
+```
+
+### 4. Open the SSH reverse tunnel
+
+Connect with port 9998 forwarded back to your local daemon:
+
+```bash
+ssh -R 9998:localhost:9998 your-server
+```
+
+Or make it permanent in `~/.ssh/config` (see the `ssh-tunnel` skill for the pattern):
+
+```
+Host your-server
+    RemoteForward 9998 localhost:9998
+```
+
+## Usage
+
+On the remote session, copy an image to your LOCAL clipboard, then run the client and read the file it prints:
+
+```bash
+ccimg
+```
+
+Then `Read` the printed path (for example `/tmp/clipboard-12345.png`). The agent now sees the image.
+
+## Example
+
+> User (in an SSH Claude Code session): "here's the broken layout, /paste-image"
+
+1. Run `ccimg` with Bash. It prints `/tmp/clipboard-4821.png`.
+2. `Read` `/tmp/clipboard-4821.png`.
+3. The screenshot renders in the session and you can act on it.
+
+If `ccimg` prints `Failed to connect to ccimgd`, the reverse tunnel is not up (reconnect with `-R 9998:localhost:9998`). If it prints `Clipboard is empty or does not contain an image`, copy an image first (a file copy is not an image).
+
+## Rules
+
+- The reverse tunnel (`-R 9998:localhost:9998`) is required. No tunnel, no image. This is the most common failure.
+- `ccimgd` reads an IMAGE on the clipboard, not a file path. Copy the picture itself (screenshot tools do this).
+- Port 9998 is chosen so it can run alongside sshimg.nvim (port 9999) on the same machine.
+- The image crosses the existing SSH channel as base64. Nothing extra is exposed to the network.
+- Rebuild and reinstall both binaries after editing the Go source; the daemon and client must agree on the protocol.
+
+## Credits
+
+Daemon and client vendored from [claude-ssh-image-skill](https://github.com/AlexZeitler/claude-ssh-image-skill) by Alexander Zeitler, MIT licensed. See `LICENSE`. The `build.sh` adds a linux/arm64 target; the Go sources are otherwise unchanged.

package/resources/skills/skills/ssh/ssh-paste-image/scripts/build.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+cd "$(dirname "$0")"
+
+# Faithful to upstream, plus linux/arm64 for ARM servers (Graviton, Hetzner ARM,
+# Raspberry Pi). Each target is a static, CGO-free binary.
+platforms=(
+  "linux/amd64"
+  "linux/arm64"
+  "darwin/amd64"
+  "darwin/arm64"
+)
+
+for platform in "${platforms[@]}"; do
+  os="${platform%/*}"
+  arch="${platform#*/}"
+  suffix="${os}-${arch}"
+
+  echo "Building for ${os}/${arch}..."
+
+  echo "  ccimgd-${suffix}"
+  (cd daemon && CGO_ENABLED=0 GOOS="$os" GOARCH="$arch" go build -o "ccimgd-${suffix}" .)
+
+  echo "  ccimg-${suffix}"
+  (cd client && CGO_ENABLED=0 GOOS="$os" GOARCH="$arch" go build -o "ccimg-${suffix}" .)
+done
+
+echo "Done."

package/resources/skills/skills/ssh/ssh-paste-image/scripts/client/go.mod

@@ -0,0 +1,3 @@
+module github.com/AlexZeitler/claude-ssh-image-skill/client
+
+go 1.21

package/resources/skills/skills/ssh/ssh-paste-image/scripts/client/main.go

@@ -0,0 +1,79 @@
+package main
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"net"
+	"os"
+	"path/filepath"
+)
+
+const (
+	host = "127.0.0.1"
+	port = "9998"
+)
+
+type response struct {
+	OK    bool   `json:"ok"`
+	Image string `json:"image"`
+	Error string `json:"error"`
+}
+
+func main() {
+	conn, err := net.Dial("tcp", net.JoinHostPort(host, port))
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Failed to connect to ccimgd: %v\n", err)
+		os.Exit(1)
+	}
+	defer conn.Close()
+
+	_, err = conn.Write([]byte("{}\n"))
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Failed to send request: %v\n", err)
+		os.Exit(1)
+	}
+
+	var buf []byte
+	tmp := make([]byte, 65536)
+	for {
+		n, err := conn.Read(tmp)
+		if n > 0 {
+			buf = append(buf, tmp[:n]...)
+		}
+		if err != nil {
+			break
+		}
+		for _, b := range tmp[:n] {
+			if b == '\n' {
+				goto done
+			}
+		}
+	}
+done:
+
+	var resp response
+	if err := json.Unmarshal(buf, &resp); err != nil {
+		fmt.Fprintf(os.Stderr, "Failed to parse response: %v\n", err)
+		os.Exit(1)
+	}
+
+	if !resp.OK {
+		fmt.Fprintf(os.Stderr, "Error: %s\n", resp.Error)
+		os.Exit(1)
+	}
+
+	imgData, err := base64.StdEncoding.DecodeString(resp.Image)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Failed to decode image: %v\n", err)
+		os.Exit(1)
+	}
+
+	tmpFile := filepath.Join(os.TempDir(), fmt.Sprintf("clipboard-%d.png", os.Getpid()))
+	if err := os.WriteFile(tmpFile, imgData, 0644); err != nil {
+		fmt.Fprintf(os.Stderr, "Failed to write image: %v\n", err)
+		os.Exit(1)
+	}
+
+	fmt.Println(tmpFile)
+}

package/resources/skills/skills/ssh/ssh-paste-image/scripts/daemon/ccimgd.service

@@ -0,0 +1,12 @@
+[Unit]
+Description=Clipboard image daemon for Claude Code over SSH
+After=graphical-session.target
+
+[Service]
+Type=simple
+ExecStart=%h/.local/bin/ccimgd
+Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=default.target

package/resources/skills/skills/ssh/ssh-paste-image/scripts/daemon/com.ccimgd.plist

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>Label</key>
+	<string>com.ccimgd</string>
+	<key>ProgramArguments</key>
+	<array>
+		<string>/usr/local/bin/ccimgd</string>
+	</array>
+	<key>RunAtLoad</key>
+	<true/>
+	<key>KeepAlive</key>
+	<true/>
+	<key>StandardOutPath</key>
+	<string>/tmp/ccimgd.log</string>
+	<key>StandardErrorPath</key>
+	<string>/tmp/ccimgd.log</string>
+</dict>
+</plist>

package/resources/skills/skills/ssh/ssh-paste-image/scripts/daemon/go.mod

@@ -0,0 +1,3 @@
+module github.com/AlexZeitler/claude-ssh-image-skill/daemon
+
+go 1.21

package/resources/skills/skills/ssh/ssh-paste-image/scripts/daemon/main.go

@@ -0,0 +1,98 @@
+package main
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"net"
+	"os"
+	"os/exec"
+	"os/signal"
+	"runtime"
+	"syscall"
+)
+
+const (
+	host = "127.0.0.1"
+	port = "9998"
+)
+
+type response struct {
+	OK    bool   `json:"ok"`
+	Image string `json:"image,omitempty"`
+	Error string `json:"error,omitempty"`
+}
+
+func getClipboardImage() ([]byte, error) {
+	var cmd *exec.Cmd
+	switch {
+	case runtime.GOOS == "darwin":
+		cmd = exec.Command("pngpaste", "-")
+	case os.Getenv("WAYLAND_DISPLAY") != "":
+		cmd = exec.Command("wl-paste", "--type", "image/png")
+	default:
+		cmd = exec.Command("xclip", "-selection", "clipboard", "-target", "image/png", "-o")
+	}
+	out, err := cmd.Output()
+	if err != nil || len(out) == 0 {
+		return nil, fmt.Errorf("Clipboard is empty or does not contain an image")
+	}
+	return out, nil
+}
+
+func handleConn(conn net.Conn) {
+	defer conn.Close()
+
+	buf := make([]byte, 4096)
+	for {
+		n, err := conn.Read(buf)
+		if err != nil || n == 0 {
+			return
+		}
+		for _, b := range buf[:n] {
+			if b == '\n' {
+				goto ready
+			}
+		}
+	}
+ready:
+
+	var resp response
+	imgData, err := getClipboardImage()
+	if err != nil {
+		resp = response{OK: false, Error: err.Error()}
+	} else {
+		resp = response{OK: true, Image: base64.StdEncoding.EncodeToString(imgData)}
+	}
+
+	data, _ := json.Marshal(resp)
+	data = append(data, '\n')
+	conn.Write(data)
+}
+
+func main() {
+	listener, err := net.Listen("tcp", net.JoinHostPort(host, port))
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Failed to listen: %v\n", err)
+		os.Exit(1)
+	}
+	defer listener.Close()
+
+	fmt.Printf("ccimgd listening on %s:%s\n", host, port)
+
+	sig := make(chan os.Signal, 1)
+	signal.Notify(sig, syscall.SIGTERM, syscall.SIGINT)
+	go func() {
+		<-sig
+		listener.Close()
+		os.Exit(0)
+	}()
+
+	for {
+		conn, err := listener.Accept()
+		if err != nil {
+			break
+		}
+		handleConn(conn)
+	}
+}

package/resources/skills/skills/ssh/ssh-tunnel/SKILL.md

@@ -0,0 +1,96 @@
+---
+name: ssh-tunnel
+description: >-
+  Use when the user wants SSH port forwarding: a local tunnel (-L) to reach a
+  remote service, a reverse tunnel (-R) to expose a local one, or a dynamic
+  SOCKS proxy (-D). Triggers: "ssh tunnel", "forward a port", "reverse tunnel".
+tags: [ssh, tunnel, port-forwarding, socks]
+category: ssh
+triggers: ["ssh tunnel", "forward a port", "reverse tunnel", "socks proxy", "port forward over ssh", "ssh -L", "ssh -R"]
+allowed-tools: Bash(ssh:*), Bash(autossh:*)
+---
+
+# SSH tunnel
+
+SSH can forward TCP ports across the encrypted connection. Three directions cover
+almost every case: pull a remote service to your machine (`-L`), push a local
+service to the remote (`-R`), or send all traffic through the host as a proxy
+(`-D`). This skill picks the right flag and keeps the tunnel alive.
+
+## When to activate
+
+- The user wants to reach a remote-only service (a database, an admin UI) from their laptop.
+- The user wants a remote host to reach a service running on their laptop (the paste-image daemon, a local API).
+- The user wants to browse through a remote host as a SOCKS proxy.
+- The user says "tunnel a port", "port forward over ssh", or "reverse tunnel".
+
+## Steps
+
+### Local forward (-L): reach a remote service locally
+
+```bash
+ssh -L 5432:localhost:5432 user@dbhost
+```
+
+Now `localhost:5432` on your machine reaches the database bound to `localhost:5432` on `dbhost`. The pattern is `-L <local_port>:<target_host>:<target_port>`, where the target is resolved FROM the remote side.
+
+### Reverse forward (-R): expose a local service on the remote
+
+```bash
+ssh -R 9998:localhost:9998 user@server
+```
+
+Now `localhost:9998` on `server` reaches port 9998 on your machine. This is exactly what the `ssh-paste-image` skill needs. To let other remote hosts (not just localhost) use it, set `GatewayPorts yes` in the server's sshd config.
+
+### Dynamic proxy (-D): SOCKS through the host
+
+```bash
+ssh -D 1080 user@host
+```
+
+Point a browser or tool at SOCKS5 `localhost:1080` to route its traffic through `host`.
+
+### Run a tunnel with no shell, in the background
+
+```bash
+ssh -fN -L 5432:localhost:5432 user@dbhost
+```
+
+`-N` means no remote command, `-f` backgrounds after auth. Find and stop it with `pgrep -af 'ssh -fN'` then `kill <pid>`.
+
+### Make it permanent in ~/.ssh/config
+
+```
+Host dbhost
+    HostName db.example.com
+    User app
+    LocalForward 5432 localhost:5432
+```
+
+### Auto-reconnecting tunnel
+
+```bash
+autossh -M 0 -fN -L 5432:localhost:5432 user@dbhost
+```
+
+`autossh` restarts the tunnel if it drops. Pair with `ServerAliveInterval` from the `ssh-config` skill.
+
+## Prerequisites
+
+- `ssh` (OpenSSH client). apt: `sudo apt install -y openssh-client`.
+- `autossh` for auto-reconnect (optional). apt: `sudo apt install -y autossh` · brew: `brew install autossh`.
+
+## Example
+
+> User: "I need to hit the staging Postgres on the bastion from my laptop with psql."
+
+1. `ssh -fN -L 5432:localhost:5432 user@bastion`.
+2. `psql -h localhost -p 5432 -U app staging` connects through the tunnel.
+3. To make it stick, add a `LocalForward 5432 localhost:5432` line to the `Host bastion` block.
+
+## Rules
+
+- `-L` resolves the target from the REMOTE side; `-R` resolves it from YOUR side. Mixing these two up is the usual reason a tunnel "does nothing".
+- Reverse forwards reach only `localhost` on the server unless `GatewayPorts yes` is set in sshd.
+- A privileged local port (<1024) needs root; pick a high port instead.
+- Background tunnels (`-fN`) are easy to forget. Track them with `pgrep -af ssh` and stop them when done.

package/resources/skills/skills/strapi/building-with-strapi/SKILL.md

@@ -0,0 +1,112 @@
+---
+name: building-with-strapi
+description: 'Use when building a Strapi v5 backend: project structure, content-types, components, dynamic zones, the Content-Type Builder, and Document Service queries in custom code.'
+tags: [strapi, cms, content-types, document-service, backend]
+---
+
+# Building With Strapi
+
+Model content and customize the backend of a Strapi v5 project.
+
+## Use This Skill For
+
+- Understanding the project layout and where code lives
+- Creating content-types, components, and dynamic zones
+- Querying and mutating content from custom code via the Document Service
+
+## Prerequisites
+
+- A running Strapi v5 project in dev mode (`npm run develop`). See
+  `strapi-cli` to scaffold one.
+- Content-Type Builder only works in `develop` mode (it writes schema files
+  and restarts the server).
+
+## Project Structure
+
+```
+my-strapi-project/
+├── config/            server.ts, database.ts, admin.ts, api.ts, plugins.ts, middlewares.ts
+├── src/
+│   ├── api/<name>/     content-types/, controllers/, services/, routes/
+│   ├── components/     reusable field groups
+│   ├── extensions/     overrides for installed plugins
+│   ├── plugins/        local plugins
+│   └── index.ts        register() / bootstrap() lifecycle
+├── database/migrations/
+└── public/uploads/     media library files
+```
+
+Each entry under `src/api/<name>/` is one content-type with its schema,
+controller, service, and routes.
+
+## Modeling Content
+
+Build content-types in the admin **Content-Type Builder**
+(`/admin/plugins/content-type-builder`):
+
+- **Collection type**: many entries (e.g. `restaurant` → `/api/restaurants`).
+- **Single type**: one entry (e.g. `homepage` → `/api/homepage`).
+- **Component**: a reusable group of fields embedded in types.
+- **Dynamic zone**: a slot that accepts a chosen list of components per entry.
+
+The builder writes `schema.json` files under
+`src/api/<name>/content-types/`. Commit those; they are your schema source
+of truth.
+
+## documentId, Not id
+
+Strapi 5 identifies every entry by a 24-character `documentId`, stable across
+locales and draft/published versions. The numeric `id` is a physical record
+detail and may disappear in future versions.
+
+- Query and relate by `documentId`.
+- Treat `id` as legacy; do not hardcode it in clients or relations.
+
+## Document Service API (in custom code)
+
+Inside controllers, services, and plugins, use the Document Service. It sits
+above the Query Engine and understands components, dynamic zones, draft &
+publish, and i18n.
+
+```ts
+// list (nothing populates by default — ask for it)
+const articles = await strapi.documents('api::article.article').findMany({
+  filters: { title: { $containsi: 'strapi' } },
+  populate: { cover: true, author: { fields: ['name'] } },
+  sort: 'publishedAt:desc',
+  status: 'published',
+});
+
+// fetch one by documentId
+const one = await strapi.documents('api::article.article').findOne({
+  documentId,
+  populate: ['cover'],
+});
+
+// create / update / delete
+const created = await strapi.documents('api::article.article').create({ data });
+await strapi.documents('api::article.article').update({ documentId, data });
+await strapi.documents('api::article.article').delete({ documentId });
+
+// draft & publish (when enabled on the type)
+await strapi.documents('api::article.article').publish({ documentId });
+await strapi.documents('api::article.article').unpublish({ documentId });
+```
+
+Need raw DB access below the content model? Drop to the Query Engine
+(`strapi.db.query(...)`), but prefer the Document Service for anything that
+touches components, dynamic zones, or publication state.
+
+## Rules
+
+- Model in `develop`; the builder is disabled in `start`.
+- Always pass `populate`/`fields` explicitly; defaults return top-level
+  scalars only.
+- Use the Document Service over the removed Entity Service path and over raw
+  Query Engine unless you specifically need lower-level access.
+- Commit `schema.json` files; they define the data model.
+
+## Next Step
+
+Expose this content over HTTP with `strapi-content-api`, or package custom
+features as a plugin with `strapi-plugins`.