From 7bc2dfb6c8c8b27f26b6a1c90ad0828b05818491 Mon Sep 17 00:00:00 2001 From: Jason Woltje Date: Mon, 20 Jul 2026 18:04:53 -0500 Subject: [PATCH] skills: add glpi-* family (solve, followup, sweep, list, create) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit GLPI helpdesk workflow skills written against the portable tools/glpi/ tooling (session-init.sh, ticket-list.sh, ticket-create.sh), cross-linked via [[glpi-*]]: - glpi-solve — close a ticket by setting status Solved (5); GLPI auto-closes - glpi-followup — add a followup via the top-level /ITILFollowup endpoint - glpi-sweep — read-only hunt for done-but-open tickets needing Solve - glpi-list — query tickets by status/recency - glpi-create — open a new ticket Core rule encoded: completing work means setting status Solved, not just posting a resolution followup (a followup documents; only Solved auto-closes). Note: illustrative examples in the bodies are USC-flavored (M2M / helpdesk ticket numbers) and can be genericized in review if preferred. Co-Authored-By: Claude Opus 4.8 Claude-Session: https://claude.ai/code/session_019GjBgrb9tHgvq414Fqj37c --- skills/glpi-create/SKILL.md | 50 ++++++++++++++++++ skills/glpi-followup/SKILL.md | 56 +++++++++++++++++++++ skills/glpi-list/SKILL.md | 57 +++++++++++++++++++++ skills/glpi-solve/SKILL.md | 95 +++++++++++++++++++++++++++++++++++ skills/glpi-sweep/SKILL.md | 62 +++++++++++++++++++++++ 5 files changed, 320 insertions(+) create mode 100644 skills/glpi-create/SKILL.md create mode 100644 skills/glpi-followup/SKILL.md create mode 100644 skills/glpi-list/SKILL.md create mode 100644 skills/glpi-solve/SKILL.md create mode 100644 skills/glpi-sweep/SKILL.md diff --git a/skills/glpi-create/SKILL.md b/skills/glpi-create/SKILL.md new file mode 100644 index 00000000..6708b10a --- /dev/null +++ b/skills/glpi-create/SKILL.md @@ -0,0 +1,50 @@ +# Skill: glpi-create — Open a New GLPI Ticket + +> Create a new GLPI helpdesk ticket. Mutates GLPI — confirm the details before running. + +## When to use + +- Logging a new incident or request that should live in the helpdesk queue. + +## Required information + +- **title** — short subject line. +- **content** — description of the issue / request. + +## Optional + +- **priority** — `1`=VeryLow, `2`=Low, `3`=Medium (default), `4`=High, `5`=VeryHigh, `6`=Major. +- **type** — `1`=Incident (default), `2`=Request. + +## Command + +Wraps the existing tooling: + +```bash +~/.config/mosaic/tools/glpi/ticket-create.sh \ + -t "" \ + -c "<content>" \ + [-p <priority>] \ + [-y <type>] \ + [-f json] +``` + +Example: + +```bash +~/.config/mosaic/tools/glpi/ticket-create.sh \ + -t "Paint-area camera install" \ + -c "Ordered 2 cameras for Paint and stock; schedule mounting + NVR config." \ + -p 3 -y 2 +``` + +## After creating + +- Note the returned **ticket ID** — you'll need it for **[[glpi-followup]]** and + **[[glpi-solve]]**. +- If it should also be tracked as brain work, add a matching task (see the `add-task` skill). + +## Guardrails + +- Confirm title/content/priority with the user before creating — a ticket is outward-facing. +- Never echo GLPI tokens. diff --git a/skills/glpi-followup/SKILL.md b/skills/glpi-followup/SKILL.md new file mode 100644 index 00000000..31a159fe --- /dev/null +++ b/skills/glpi-followup/SKILL.md @@ -0,0 +1,56 @@ +# Skill: glpi-followup — Add a Followup to a GLPI Ticket + +> Post a followup (comment / progress note / resolution writeup) to a GLPI ticket. +> This documents work but does **not** change the ticket status — to close a ticket +> out, follow with **[[glpi-solve]]** to set status to Solved. + +## When to use + +- Recording progress, a decision, or a root-cause/resolution note on a ticket. +- The documentation step that usually precedes closing a ticket out (`glpi-solve`). + +## Critical quirk + +Use the **top-level `/ITILFollowup` endpoint**, NOT `/Ticket/<id>/ITILFollowup`. The +sub-resource path returns permission errors even with a Super-Admin profile. + +## Procedure + +### 1. Session + creds + +```bash +SESSION=$(~/.config/mosaic/tools/glpi/session-init.sh -q) +source ~/.config/mosaic/tools/_lib/credentials.sh && load_credentials glpi +``` + +### 2. Post the followup + +```bash +TICKET_ID=<id> +CONTENT="<the followup text>" +curl -sk -X POST "${GLPI_URL}/ITILFollowup" \ + -H "App-Token: $GLPI_APP_TOKEN" \ + -H "Session-Token: $SESSION" \ + -H "Content-Type: application/json" \ + -d "$(jq -n --argjson id "$TICKET_ID" --arg c "$CONTENT" \ + '{input:{itemtype:"Ticket", items_id:$id, content:$c}}')" +``` + +Expect HTTP 201. Building the payload with `jq` keeps quotes/newlines in the content safe. + +### 3. Long or multi-paragraph content + +Write the note to a file first, then read it into the payload: + +```bash +curl -sk -X POST "${GLPI_URL}/ITILFollowup" \ + -H "App-Token: $GLPI_APP_TOKEN" -H "Session-Token: $SESSION" \ + -H "Content-Type: application/json" \ + -d "$(jq -n --argjson id "$TICKET_ID" --rawfile c /path/to/note.md \ + '{input:{itemtype:"Ticket", items_id:$id, content:$c}}')" +``` + +## Guardrails + +- Never echo the GLPI app/user/session tokens. +- A followup alone leaves the ticket open. If the work is done, run **[[glpi-solve]]** next. diff --git a/skills/glpi-list/SKILL.md b/skills/glpi-list/SKILL.md new file mode 100644 index 00000000..215367c6 --- /dev/null +++ b/skills/glpi-list/SKILL.md @@ -0,0 +1,57 @@ +# Skill: glpi-list — Query GLPI Tickets + +> Quick lookups of GLPI helpdesk tickets by status or recency. Read-only. + +## When to use + +- "What tickets are open / pending?" · "Show recent tickets" · finding a ticket ID + before running **[[glpi-followup]]** or **[[glpi-solve]]**. + +## Command + +Wraps the existing tooling: + +```bash +GLPI=~/.config/mosaic/tools/glpi + +# Most recent tickets (default 50, newest first) +"$GLPI/ticket-list.sh" + +# Filter by status: new | processing | pending | solved | closed +"$GLPI/ticket-list.sh" -s pending + +# JSON output (for parsing / piping to jq) and a custom limit +"$GLPI/ticket-list.sh" -s processing -f json -l 20 +``` + +Status IDs: 1 New · 2/3 Processing · 4 Pending · 5 Solved · 6 Closed. + +## Details lookup for one ticket + +When you have an ID and want the full record: + +```bash +SESSION=$(~/.config/mosaic/tools/glpi/session-init.sh -q) +source ~/.config/mosaic/tools/_lib/credentials.sh && load_credentials glpi +curl -sk "${GLPI_URL}/Ticket/<id>?expand_dropdowns=true" \ + -H "App-Token: $GLPI_APP_TOKEN" -H "Session-Token: $SESSION" \ + | jq '{id, name, status, date, date_mod}' + +# Followups on a ticket +curl -sk "${GLPI_URL}/Ticket/<id>/ITILFollowup" \ + -H "App-Token: $GLPI_APP_TOKEN" -H "Session-Token: $SESSION" \ + | jq '.[] | {date, content}' +``` + +(Reading followups via the sub-resource is fine — only _creating_ them requires the +top-level `/ITILFollowup` endpoint. See **[[glpi-followup]]**.) + +## Present to user + +Group by status, one line per ticket: `#<id> · <title> · <status> · <last-modified>`. +Use neutral phrasing — no "OVERDUE"/"URGENT". + +## Guardrails + +- Read-only. Never echo GLPI tokens. +- To sync tickets into brain data instead, use `python tools/sync_glpi.py` (not this skill). diff --git a/skills/glpi-solve/SKILL.md b/skills/glpi-solve/SKILL.md new file mode 100644 index 00000000..55f3df80 --- /dev/null +++ b/skills/glpi-solve/SKILL.md @@ -0,0 +1,95 @@ +# Skill: glpi-solve — Close Out a GLPI Ticket + +> Properly close out a completed GLPI helpdesk ticket. Completing the work is not +> enough — the ticket **status must be set to "Solved"**, which is what triggers +> GLPI's config-driven auto-close. Posting a resolution followup documents the work +> but does **not** change status, so a ticket left at Solved-less status stays open. + +## When to use + +- Any time work on a GLPI ticket is finished and it should be closed out. +- After posting a root-cause / resolution writeup as an `/ITILFollowup`. +- During a cleanup sweep of tickets that are done in reality but still open in GLPI. + +## The rule (from Jason, 2026-07-20) + +**"Solved" is the correct terminal state to set — not "Closed."** GLPI is configured +to auto-close Solved tickets after its delay. If you only post a followup and never set +status, the ticket sits open (this bit us on the M2M #2607200002 and Brad tickets, which +Jason had to mark Solved by hand). + +Close-out = **followup (optional but preferred) + set status to Solved.** + +## GLPI status IDs + +| ID | Status | | +| ----- | --------------------- | -------------------------------------------- | +| 1 | New | | +| 2 | Processing (assigned) | | +| 3 | Processing (planned) | | +| 4 | Pending / Waiting | | +| **5** | **Solved** | ← set this on close-out | +| 6 | Closed | ← happens automatically; do not set manually | + +## Procedure + +### 1. Get a session token + +```bash +SESSION=$(~/.config/mosaic/tools/glpi/session-init.sh -q) +source ~/.config/mosaic/tools/_lib/credentials.sh && load_credentials glpi +``` + +### 2. (Preferred) Post the resolution followup + +Use the **top-level `/ITILFollowup` endpoint** — the `/Ticket/<id>/ITILFollowup` +sub-resource returns permission errors even as Super-Admin (known GLPI quirk). + +```bash +TICKET_ID=<id> +curl -sk -X POST "${GLPI_URL}/ITILFollowup" \ + -H "App-Token: $GLPI_APP_TOKEN" \ + -H "Session-Token: $SESSION" \ + -H "Content-Type: application/json" \ + -d "{\"input\":{\"itemtype\":\"Ticket\",\"items_id\":${TICKET_ID},\"content\":\"<resolution summary>\"}}" +``` + +### 3. Set status to Solved (the step that actually closes it out) + +```bash +curl -sk -X PUT "${GLPI_URL}/Ticket/${TICKET_ID}" \ + -H "App-Token: $GLPI_APP_TOKEN" \ + -H "Session-Token: $SESSION" \ + -H "Content-Type: application/json" \ + -d "{\"input\":{\"id\":${TICKET_ID},\"status\":5}}" +``` + +Expect HTTP 200/201. GLPI will auto-close it later per its config — leave status at 5. + +### 4. Verify + +```bash +curl -sk "${GLPI_URL}/Ticket/${TICKET_ID}?expand_dropdowns=true" \ + -H "App-Token: $GLPI_APP_TOKEN" -H "Session-Token: $SESSION" \ + | jq '{id, name, status}' +``` + +`status` should read `Solved` (or `5`). + +## Optional: sweep for done-but-open tickets + +List tickets still open (New/Processing/Pending) to spot ones whose work is actually +finished but were never marked Solved: + +```bash +~/.config/mosaic/tools/glpi/ticket-list.sh -s processing -f table +~/.config/mosaic/tools/glpi/ticket-list.sh -s pending -f table +``` + +Review each; for any that are genuinely resolved, run steps 2–3. + +## Guardrails + +- Read-only until you intend to close — confirm the ticket is actually done first. +- Never echo the GLPI app/user/session tokens. +- Set **Solved (5)**, never Closed (6) — auto-close owns that transition. diff --git a/skills/glpi-sweep/SKILL.md b/skills/glpi-sweep/SKILL.md new file mode 100644 index 00000000..ec7e30b6 --- /dev/null +++ b/skills/glpi-sweep/SKILL.md @@ -0,0 +1,62 @@ +# Skill: glpi-sweep — Find Done-But-Open Tickets + +> Read-only sweep for tickets that are finished in reality but still sitting open in +> GLPI (never moved to Solved). Surfaces the exact miss Jason caught on 2026-07-20 +> (M2M #2607200002 and the Brad ticket had resolution followups posted but were left +> open). For each one that's genuinely done, close it out with **[[glpi-solve]]**. + +## When to use + +- Periodic hygiene pass (e.g. before a weekly update or month-end). +- After a burst of ticket work, to catch any you resolved-in-followup but never Solved. + +## Why this exists + +Posting an `/ITILFollowup` documents work but does **not** change status. Tickets only +auto-close once set to **Solved (status 5)**. Anything left at New/Processing/Pending +stays open indefinitely. This sweep finds those. + +## Procedure + +### 1. List still-open tickets by status + +```bash +GLPI=~/.config/mosaic/tools/glpi +"$GLPI/ticket-list.sh" -s new -f table +"$GLPI/ticket-list.sh" -s processing -f table +"$GLPI/ticket-list.sh" -s pending -f table +``` + +(GLPI status IDs: 1 New · 2/3 Processing · 4 Pending · 5 Solved · 6 Closed.) + +### 2. Triage + +For each open ticket, judge whether the underlying work is actually finished — check +its latest followups and cross-reference brain tasks / recent work. Read-only here; +change nothing yet. + +Reasonable "probably done" signals: + +- A resolution/root-cause followup already posted, but status never advanced. +- The related brain task is `done`, or the fix shipped and was confirmed. +- Requester confirmed resolution but the ticket was never Solved. + +### 3. Present the candidates + +List them for review before touching anything — never bulk-solve blindly: + +``` +Open tickets that look resolved: +- #<id> "<title>" — <why it looks done> → glpi-solve? +``` + +### 4. Close out the confirmed ones + +For each ticket the user (or clear evidence) confirms is done, run **[[glpi-solve]]** +(optionally **[[glpi-followup]]** first if a closing note is warranted). + +## Guardrails + +- Read-only until a ticket is confirmed done — do not auto-solve on a guess. +- Never echo GLPI tokens. +- Set **Solved (5)**, never Closed (6) — GLPI auto-close owns that transition.