slingit 0.1.0 → 0.1.1

package/README.md

@@ -12,7 +12,13 @@ npx slingit shot analysis.md
 cat analysis.md | npx slingit shot
 
 # Send the link by email (the email contains the full working link)
-npx slingit shot analysis.md --tomail someone@company.com
+npx slingit shot analysis.md --mailto someone@company.com
+
+# Add a short message visible only in the email
+npx slingit shot analysis.md --mailto someone@company.com --mailmessage "Context before you open this"
+
+# Add a sender signature to the note page and email
+npx slingit shot analysis.md --from "Marcin"
 
 # Public note: no encryption, server-side render, SEO
 npx slingit shot analysis.md --public
@@ -22,6 +28,9 @@ npx slingit shot analysis.md --expire 7
 
 # Skill for Claude Code ("send these findings to X's email")
 npx slingit install-skill
+
+# Skill for Codex
+npx slingit install-skill --target codex
 ```
 
 ## Configuration
@@ -42,17 +51,31 @@ Env takes precedence over the file; the file takes precedence over the built-in
 | Flag | Description | Default |
 |---|---|---|
 | `--public` | Disables encryption, enables server-side render (SEO/preview) | off (encrypted) |
-| `--tomail [email]` | Send the link by email; without a value, uses `defaultToMail` | off |
+| `--mailto [email]` | Send the link by email; without a value, uses `defaultToMail` | off |
+| `--mailmessage <text>` | Add an optional message/comment to the email body; requires `--mailto` | off |
 | `--expire <days>` | Delete the note after X days (1-365) | no TTL |
 | `--title <text>` | Title (with `--public`, used for preview/SEO) | first `# H1` |
+| `--from <text>` | Optional sender/signature shown on the note page and email | hidden |
 | `--copy` | Copy the link to the clipboard | off |
 
+## Skill installation
+
+```bash
+npx slingit install-skill                    # Claude Code, user profile
+npx slingit install-skill --project          # Claude Code, current repo
+npx slingit install-skill --target codex     # Codex, user profile
+npx slingit install-skill --target all       # Claude Code + Codex
+```
+
+Claude Code installs to `~/.claude/skills/slingit/` or `./.claude/skills/slingit/`.
+Codex installs to `~/.agents/skills/slingit/` or `./.agents/skills/slingit/`.
+
 ## Privacy model
 
 - **Default (encrypted):** content is encrypted with AES-256-GCM locally; only the
   ciphertext goes to the server. The key in the `#` URL fragment is never sent by the
   browser — full zero-knowledge.
-- **`--tomail` + encrypted:** the key passes through the server (in transit, not stored)
+- **`--mailto` + encrypted:** the key passes through the server (in transit, not stored)
   and the mail — a deliberate decision: since the recipient needs the key anyway, they
   get the full link. Security model: capability URL — whoever has the link can read it.
 - **`--public`:** a deliberate opt-out from encryption (plaintext, SEO, nice preview).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slingit",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Fire-and-forget: share formatted Markdown notes via link. Encrypted by default (key in #URL), optional email delivery.",
   "type": "module",
   "bin": {
@@ -26,4 +26,4 @@
   ],
   "author": "BTA Systems",
   "license": "MIT"
-}
+}

package/skill/SKILL.md

@@ -9,49 +9,104 @@ You publish formatted Markdown notes with `npx slingit shot`. Each note gets a s
 link `https://slingit.dev/{id}`; by default it is **end-to-end encrypted** — the AES-256
 key lives only in the `#` fragment of the URL, so the server cannot read the content.
 
-## Steps
-
-1. Collect the session's findings into a `.md` file (in a temp/scratchpad directory).
-   Format it properly: `##` headings, code blocks with a language tag (```php, ```ts etc.),
-   first line as `# Title`.
-2. Run the CLI (works out of the box — no token or configuration required):
-   ```bash
-   npx slingit shot <file.md> [flags]
-   ```
-3. Return the full link from stdout to the user in chat (for an encrypted note the link
-   contains the key after `#` — without it the content cannot be decrypted).
+## Choose the input method first
+
+Use the method that matches the user's request:
+
+1. **Conversation/session content**: if the user asks to send findings, a summary, details
+   from this conversation, or anything you are about to compose, pipe Markdown directly to
+   `npx slingit shot`. Do **not** create a temporary `.md` file just to pass generated
+   conversation content.
+2. **Existing Markdown file**: if the user gives a specific `.md` file or asks to publish
+   a file from the workspace, pass that file path to `npx slingit shot <file.md>`.
+
+Always format the Markdown properly: first line as `# Title`, `##` headings, and code
+blocks with language tags (```php, ```ts, ```bash, etc.).
+
+## Commands
+
+For generated conversation content, use stdin/pipe:
+
+```bash
+cat <<'EOF' | npx slingit shot [flags]
+# Title
+
+Markdown content from the conversation.
+EOF
+```
+
+In PowerShell, use a here-string:
+
+```powershell
+@'
+# Title
+
+Markdown content from the conversation.
+'@ | npx slingit shot [flags]
+```
+
+For an existing Markdown file, use the file path:
+
+```bash
+npx slingit shot <file.md> [flags]
+```
+
+Return the full link from stdout to the user in chat. For an encrypted note the link
+contains the key after `#`; without it the content cannot be decrypted.
 
 ## Choosing flags based on the user's intent
 
 | Intent | Flags |
 |---|---|
-| "send it to X's email" | `--tomail X` (the email contains the full working link) |
-| "maximum privacy" | **no** `--tomail` — the default; the link with the key stays in chat only, the user shares it themselves |
+| "send it to X's email" | `--mailto X` (the email contains the full working link) |
+| "include this message/comment in the email" | `--mailmessage "..."` (only together with `--mailto`) |
+| "maximum privacy" | **no** `--mailto` — the default; the link with the key stays in chat only, the user shares it themselves |
 | "public link" (for a PR, docs, SEO) | `--public` (no encryption, server-side render) |
 | "make it disappear after X days" | `--expire X` |
+| "send from X", "signed by X", "from me/Marcin/team name" | `--from "X"` |
 | title different from the H1 | `--title "..."` |
 
-Flags can be combined, e.g. `--public --tomail x@y.z --expire 7`.
+Flags can be combined, e.g. `--public --mailto x@y.z --mailmessage "Read the summary first" --from "Marcin" --expire 7`.
 
 ## Rules (do not break these)
 
 - Encryption is the **default** — there is no `--encrypt` flag; `--public` is a deliberate
   opt-out (use it only when the user explicitly wants a public/indexable note).
-- The encryption key must **never** end up in files, logs, or storage. With `--tomail`,
+- The encryption key must **never** end up in files, logs, or storage. With `--mailto`,
   the CLI passes it to the server only in the `mailFragment` field, used solely to compose
   the link inside the email (transit only, never stored). Do not print the key separately —
   only as part of the full link.
-- When the user asks for "maximum privacy", skip `--tomail` even if you know the address —
+- When the user asks for "maximum privacy", skip `--mailto` even if you know the address —
   zero-knowledge only holds when the key never leaves the terminal/chat.
 - No token is required — the CLI ships with a built-in one. `SLINGIT_TOKEN` (env) or
   `"token"` in `~/.slingit/config.json` are optional overrides (e.g. a self-hosted
   instance) — never invent a token.
+- Use `--from` only when the user explicitly gives a sender/signature. If it is not
+  provided, do not invent one.
+- Use `--mailmessage` only when the user explicitly asks to add a message/comment to
+  the email. It requires `--mailto` and is not part of the note page.
 
 ## Example
 
+Conversation content:
+
 ```
-> /slingit boss@company.com
-1. Save the findings to analysis.md (with a # Title and language-tagged code blocks)
-2. npx slingit shot analysis.md --tomail boss@company.com
+User asks: "Send these findings to boss@company.com from Marcin."
+1. Compose Markdown directly from the conversation.
+2. Pipe it to:
+   cat <<'EOF' | npx slingit shot --mailto boss@company.com --mailmessage "Please read the recommendation first." --from "Marcin"
+   # Title
+
+   ...
+   EOF
 3. Reply: "Sent. Link (contains the decryption key): https://slingit.dev/aX7k2mQp9f#Hk3..."
 ```
+
+Existing file:
+
+```
+User asks: "Send docs/review.md to boss@company.com."
+1. Use the file directly:
+   npx slingit shot docs/review.md --mailto boss@company.com
+2. Reply with the full link from stdout.
+```

package/src/cli.js

@@ -7,17 +7,24 @@ const HELP = `slingit — share Markdown notes via link (encrypted by default)
 
 Usage:
   slingit shot [file.md] [flags]     publish a note (file or stdin)
-  slingit install-skill [--project]  install the Claude Code skill
+  slingit install-skill [flags]      install the agent skill
   slingit help                       this help
 
 Flags (shot):
   --public           disable encryption: plaintext, server-side render, SEO
-  --tomail [email]   send the link by email (Resend); if omitted, uses
+  --mailto [email]   send the link by email (Resend); if omitted, uses
                      defaultToMail from ~/.slingit/config.json
+  --mailmessage <text>
+                     optional message included in the email only; requires --mailto
   --expire <days>    delete the note after X days (1-365)
   --title <text>     note title (with --public, used for preview/SEO)
+  --from <text>      optional sender/signature shown on the note page and email
   --copy             copy the link to the clipboard
 
+Flags (install-skill):
+  --target <name>     claude (default), codex, or all
+  --project           install into this repository instead of your user profile
+
 Configuration (optional — the CLI works out of the box, no config needed):
   SLINGIT_TOKEN      override the built-in bearer token (e.g. self-hosted instance)
   SLINGIT_URL        server address (defaults to the official SlingIt instance)

package/src/install-skill.js

@@ -3,22 +3,53 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-/**
- * Copies SKILL.md to ~/.claude/skills/slingit/ (default)
- * or ./.claude/skills/slingit/ with --project.
- */
 export async function installSkill(args) {
-  const project = args.includes('--project');
+  const opts = parseArgs(args);
   const source = fileURLToPath(new URL('../skill/SKILL.md', import.meta.url));
-  const targetDir = project
-    ? join(process.cwd(), '.claude', 'skills', 'slingit')
-    : join(homedir(), '.claude', 'skills', 'slingit');
+  const targets = opts.target === 'all' ? ['claude', 'codex'] : [opts.target];
 
-  await mkdir(targetDir, { recursive: true });
-  const target = join(targetDir, 'SKILL.md');
-  await copyFile(source, target);
+  for (const targetName of targets) {
+    const targetDir = targetPath(targetName, opts.project);
+    await mkdir(targetDir, { recursive: true });
+    const target = join(targetDir, 'SKILL.md');
+    await copyFile(source, target);
+    console.log(`✔ Skill installed (${targetName}): ${target}`);
+  }
 
-  console.log(`✔ Skill installed: ${target}`);
-  console.log('  In a Claude Code session, ask e.g.: "send these findings to X\'s email" or "/slingit".');
+  console.log('  Ask e.g.: "send these findings to X\'s email" or invoke the slingit skill directly.');
   console.log('  Works out of the box — no token or configuration needed.');
 }
+
+function parseArgs(args) {
+  const opts = { project: false, target: 'claude' };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    switch (a) {
+      case '--project':
+        opts.project = true;
+        break;
+      case '--target': {
+        const target = args[++i];
+        if (!['claude', 'codex', 'all'].includes(target)) {
+          throw new Error('--target must be one of: claude, codex, all');
+        }
+        opts.target = target;
+        break;
+      }
+      default:
+        throw new Error(`unknown flag "${a}". See: slingit help`);
+    }
+  }
+  return opts;
+}
+
+function targetPath(target, project) {
+  if (target === 'claude') {
+    return project
+      ? join(process.cwd(), '.claude', 'skills', 'slingit')
+      : join(homedir(), '.claude', 'skills', 'slingit');
+  }
+  return project
+    ? join(process.cwd(), '.agents', 'skills', 'slingit')
+    : join(homedir(), '.agents', 'skills', 'slingit');
+}

package/src/shot.js

@@ -10,23 +10,29 @@ export async function shot(args) {
   const config = await loadConfig();
 
   let sentTo = null;
-  if (opts.tomail !== undefined) {
-    sentTo = opts.tomail || config.defaultToMail;
+  if (opts.mailto !== undefined) {
+    sentTo = opts.mailto || config.defaultToMail;
     if (!sentTo) {
-      throw new Error('--tomail given without an address and no defaultToMail in ~/.slingit/config.json');
+      throw new Error('--mailto given without an address and no defaultToMail in ~/.slingit/config.json');
     }
     if (!EMAIL_RE.test(sentTo)) throw new Error(`invalid email address: ${sentTo}`);
   }
+  if (opts.mailmessage && !sentTo) {
+    throw new Error('--mailmessage can only be used together with --mailto');
+  }
 
   const markdown = await readInput(opts.file);
   if (!markdown.trim()) throw new Error('empty note — nothing to publish');
 
   const title = opts.title || extractTitle(markdown);
+  const signature = opts.from ? opts.from.trim().slice(0, 120) : '';
 
   const body = {
     mode: opts.public ? 'public' : 'encrypted',
     expireDays: opts.expire ?? null,
     sentTo,
+    mailMessage: opts.mailmessage ? opts.mailmessage.trim().slice(0, 1000) : '',
+    signature,
     sourceSession: process.env.CLAUDE_SESSION_ID || null,
     sourceCwd: process.cwd(),
   };
@@ -70,7 +76,16 @@ export async function shot(args) {
 }
 
 function parseArgs(args) {
-  const opts = { file: null, public: false, copy: false, tomail: undefined, expire: null, title: null };
+  const opts = {
+    file: null,
+    public: false,
+    copy: false,
+    mailto: undefined,
+    mailmessage: null,
+    expire: null,
+    title: null,
+    from: null,
+  };
   for (let i = 0; i < args.length; i++) {
     const a = args[i];
     switch (a) {
@@ -80,11 +95,17 @@ function parseArgs(args) {
       case '--copy':
         opts.copy = true;
         break;
-      case '--tomail':
+      case '--mailto':
         if (args[i + 1] && !args[i + 1].startsWith('-')) {
-          opts.tomail = args[++i];
+          opts.mailto = args[++i];
         } else {
-          opts.tomail = null; // use defaultToMail from the config
+          opts.mailto = null; // use defaultToMail from the config
+        }
+        break;
+      case '--mailmessage':
+        opts.mailmessage = args[++i];
+        if (opts.mailmessage === undefined || opts.mailmessage.startsWith('-')) {
+          throw new Error('--mailmessage requires a value');
         }
         break;
       case '--expire': {
@@ -99,6 +120,10 @@ function parseArgs(args) {
         opts.title = args[++i];
         if (opts.title === undefined) throw new Error('--title requires a value');
         break;
+      case '--from':
+        opts.from = args[++i];
+        if (opts.from === undefined || opts.from.startsWith('-')) throw new Error('--from requires a value');
+        break;
       default:
         if (a.startsWith('-')) throw new Error(`unknown flag "${a}". See: slingit help`);
         if (opts.file) throw new Error('only one file can be given');