ticketlens 0.31.0 → 0.32.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticketlens",
-  "version": "0.31.0",
+  "version": "0.32.0",
   "description": "Jira CLI for developers — fetch ticket context, triage your queue, and stop tab-switching. Zero dependencies, all local.",
   "type": "module",
   "bin": {

package/skills/jtb/scripts/lib/adapters/jira-adapter.mjs

@@ -1,4 +1,7 @@
 import { fetchTicket, fetchCurrentUser, searchTickets, fetchStatuses, fetchProjects, fetchIssueTypes, postComment, getTransitions, postTransition, assignIssue, escapeJql, getIssueLinkTypes, postIssueLink, updateIssue, createIssue } from '../jira-client.mjs';
+import { uploadAttachment, resolveMediaId } from '../jira-attachment-client.mjs';
+import { readAttachments } from '../attachment-uploader.mjs';
+import { buildMediaNode } from '../adf-converter.mjs';
 import { buildJiraEnv } from '../config.mjs';
 
 /**
@@ -149,5 +152,54 @@ export function createJiraAdapter(conn, { fetcher = globalThis.fetch } = {}) {
 
     /** Real, currently-configured issue types for one project. */
     listIssueTypes: (projectKey, opts = {}) => fetchIssueTypes(projectKey, { ...base, ...opts }),
+
+    /**
+     * Best-effort, per-file: one bad path or one failed upload never blocks
+     * the rest (same `{applied/uploaded, errors}` shape convention as
+     * updateFields' GitHub label loop). Two different inline-thumbnail
+     * mechanisms per apiVersion, both real:
+     *  - Server/DC (v2, plain-string bodies): legacy wiki markup
+     *    `!filename|thumbnail!`, resolved by filename — returned as
+     *    `inlineMarkup`, a plain string the caller appends to body text.
+     *  - Cloud (v3, ADF): a real `mediaSingle`/`media` ADF node — returned
+     *    as `adfMediaNode`, an object the caller threads through
+     *    `postComment`'s `extraAdfNodes`. Requires one extra call
+     *    (`resolveMediaId`) to resolve the Media Services UUID; if that
+     *    fails, `adfMediaNode` stays null — the classic attachment above
+     *    already succeeded and is genuinely visible on the issue either
+     *    way, so this failure is swallowed, not surfaced as an error.
+     * Both are image-only; non-image files get neither.
+     */
+    async attachFiles(key, filePaths, opts = {}) {
+      const { files, droppedCount } = readAttachments(filePaths);
+      const uploaded = [];
+      const errors = [];
+      for (const f of files) {
+        if (!f.ok) {
+          errors.push({ path: f.path, message: f.error });
+          continue;
+        }
+        try {
+          const result = await uploadAttachment(key, f, { ...base, ...opts });
+          const isImage = f.mimeType.startsWith('image/');
+          let inlineMarkup = null;
+          let adfMediaNode = null;
+          if (isImage && apiVersion === 2) {
+            inlineMarkup = `!${result.filename}|thumbnail!`;
+          } else if (isImage && apiVersion === 3 && result.url) {
+            try {
+              const mediaId = await resolveMediaId(result.url, { ...base, ...opts });
+              adfMediaNode = buildMediaNode(mediaId, key);
+            } catch {
+              // Enhancement only — see doc comment above.
+            }
+          }
+          uploaded.push({ filename: result.filename, size: result.size, url: result.url, inlineMarkup, adfMediaNode });
+        } catch (err) {
+          errors.push({ path: f.path, message: err.message });
+        }
+      }
+      return { uploaded, errors, droppedCount };
+    },
   };
 }

package/skills/jtb/scripts/lib/adapters/linear-adapter.mjs

@@ -1,4 +1,6 @@
 import { tokenize } from '../duplicate-scorer.mjs';
+import { readAttachments } from '../attachment-uploader.mjs';
+import { isSafeRedirectUrl, validateResolvedHost, defaultLookupFor } from '../jira-client.mjs';
 
 const LINEAR_API = 'https://api.linear.app/graphql';
 
@@ -487,5 +489,77 @@ export function createLinearAdapter(conn, { fetcher = globalThis.fetch } = {}) {
       );
       return (data.teams?.nodes ?? []).map(t => ({ key: t.key, name: t.name }));
     },
+
+    /**
+     * Linear's fileUpload mutation is workspace-scoped, not issue-scoped —
+     * unlike Jira, there is no issue key involved in the upload itself, so
+     * this works identically whether the target issue already exists
+     * (comment) or was just created (create). Two-step, both officially
+     * documented: request a signed PUT URL, then PUT the bytes directly to
+     * it. Linear renders any Markdown image URL inline automatically — no
+     * separate node-graph system the way Jira's ADF has, so this is the one
+     * tracker in this family with a fully working, gap-free thumbnail path.
+     * Best-effort per file, same `{uploaded, errors}` shape as Jira's
+     * attachFiles.
+     */
+    async attachFiles(key, filePaths, opts = {}) {
+      const signal = AbortSignal.timeout(opts.timeoutMs ?? 30_000);
+      const { lookup = defaultLookupFor(fetcher), allowPrivateIp = false } = opts;
+      const { files, droppedCount } = readAttachments(filePaths);
+      const uploaded = [];
+      const errors = [];
+      for (const f of files) {
+        if (!f.ok) {
+          errors.push({ path: f.path, message: f.error });
+          continue;
+        }
+        try {
+          const data = await gql(
+            `mutation ($contentType: String!, $filename: String!, $size: Int!) {
+              fileUpload(contentType: $contentType, filename: $filename, size: $size) {
+                success
+                uploadFile { uploadUrl assetUrl headers { key value } }
+              }
+            }`,
+            { contentType: f.mimeType, filename: f.filename, size: f.size },
+            { token, fetcher, signal },
+          );
+          const target = data.fileUpload?.uploadFile;
+          if (!data.fileUpload?.success || !target) {
+            errors.push({ path: f.path, message: 'Linear fileUpload did not return an upload target' });
+            continue;
+          }
+          if (!isSafeRedirectUrl(target.uploadUrl)) {
+            errors.push({ path: f.path, message: 'refusing an unsafe upload URL returned by Linear (non-HTTPS or a private/internal host)' });
+            continue;
+          }
+          // DNS-rebinding guard, same as every other server-supplied URL
+          // this codebase connects to (see jira-client.mjs's guardedFetch) —
+          // isSafeRedirectUrl above only checks the hostname string; this
+          // resolves it. redirect:'manual' + the explicit 3xx refusal below
+          // mirrors guardedFetch's "never follow a redirect on a write" rule.
+          await validateResolvedHost(new URL(target.uploadUrl).hostname, lookup, allowPrivateIp);
+          const putHeaders = Object.fromEntries((target.headers ?? []).map(h => [h.key, h.value]));
+          const putRes = await fetcher(target.uploadUrl, { method: 'PUT', headers: putHeaders, body: f.buffer, signal, redirect: 'manual' });
+          if (putRes.status >= 300 && putRes.status < 400) {
+            errors.push({ path: f.path, message: `upload PUT redirected unexpectedly (status ${putRes.status}) — refusing to follow` });
+            continue;
+          }
+          if (!putRes.ok) {
+            errors.push({ path: f.path, message: `upload PUT failed with ${putRes.status}` });
+            continue;
+          }
+          uploaded.push({
+            filename: f.filename,
+            size: f.size,
+            url: target.assetUrl,
+            inlineMarkup: f.mimeType.startsWith('image/') ? `![${f.filename}](${target.assetUrl})` : `[${f.filename}](${target.assetUrl})`,
+          });
+        } catch (err) {
+          errors.push({ path: f.path, message: err.message });
+        }
+      }
+      return { uploaded, errors, droppedCount };
+    },
   };
 }

package/skills/jtb/scripts/lib/adf-converter.mjs

@@ -23,6 +23,32 @@ export function textToAdf(text) {
   };
 }
 
+/**
+ * Builds an ADF mediaSingle+media node embedding an already-uploaded Jira
+ * attachment as a real inline image. `collection` does NOT need to be
+ * Jira's actual internal Media Services collection — real-instance
+ * verification against a live Jira Cloud site confirmed the image renders
+ * correctly regardless of the collection value given (including the
+ * ticket key, used here as a stable value requiring no extra lookup);
+ * the content-scoped access token embedded when resolving `id` is what
+ * actually grants read access, not this field.
+ */
+export function buildMediaNode(mediaId, collection) {
+  return {
+    type: 'mediaSingle',
+    attrs: { layout: 'center' },
+    content: [{ type: 'media', attrs: { type: 'file', id: mediaId, collection } }],
+  };
+}
+
+/**
+ * Appends block-level nodes (e.g. a media node) after an ADF doc's existing
+ * content, without mutating the original doc.
+ */
+export function appendNodesToAdf(adfDoc, extraNodes) {
+  return { ...adfDoc, content: [...adfDoc.content, ...extraNodes] };
+}
+
 export function adfToText(value) {
   if (value == null) return '';
   if (typeof value === 'string') return value;

package/skills/jtb/scripts/lib/attachment-downloader.mjs

@@ -159,7 +159,7 @@ function makeResult(attachment, localPath, skipReason, error) {
   };
 }
 
-function sanitizeFilename(filename) {
+export function sanitizeFilename(filename) {
   // Strip directory components, replace unsafe chars, preserve extension
   return path.basename(filename).replace(/[^a-zA-Z0-9._\-]/g, '_');
 }

package/skills/jtb/scripts/lib/attachment-uploader.mjs

@@ -0,0 +1,96 @@
+/**
+ * Validates and reads local files for upload to a tracker (Jira attachment
+ * API, Linear fileUpload). Shared across trackers — the read/validate step
+ * is identical regardless of where the bytes end up.
+ *
+ * No path allowlist: the caller (a human, or an AI harness the human is
+ * directing) is trusted to supply a legitimate path — the same trust
+ * boundary already extended to every other free-text write field in this
+ * ticket-write family (comment bodies, summaries). This was a deliberate,
+ * reviewed choice, not an oversight — see the security-reviewer pass for
+ * this feature.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { sanitizeFilename } from './attachment-downloader.mjs';
+
+export const MAX_ATTACHMENTS = 20; // mirrors attachment-downloader.mjs's download-side cap
+export const MAX_FILE_BYTES = 10 * 1024 * 1024; // 10 MB — same
+export const MAX_TOTAL_BYTES = 50 * 1024 * 1024; // 50 MB aggregate per call — bounds worst-case memory use across a whole batch
+
+const MIME_TYPES = {
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.pdf': 'application/pdf',
+  '.txt': 'text/plain',
+  '.log': 'text/plain',
+  '.md': 'text/markdown',
+  '.csv': 'text/csv',
+  '.json': 'application/json',
+  '.zip': 'application/zip',
+};
+
+function mimeTypeFor(filePath) {
+  return MIME_TYPES[path.extname(filePath).toLowerCase()] ?? 'application/octet-stream';
+}
+
+/**
+ * Size is checked via a stat call BEFORE reading the file into memory — a
+ * path to a huge file is rejected without ever buffering it.
+ *
+ * @returns {{ path: string, filename: string, buffer: Buffer, mimeType: string, size: number }
+ *          | { path: string, error: 'not-found'|'not-a-file'|'empty'|'too-large' }}
+ */
+export function readAttachmentFile(filePath) {
+  let stat;
+  try {
+    stat = fs.statSync(filePath);
+  } catch {
+    return { path: filePath, error: 'not-found' };
+  }
+  if (!stat.isFile()) return { path: filePath, error: 'not-a-file' };
+  if (stat.size === 0) return { path: filePath, error: 'empty' };
+  if (stat.size > MAX_FILE_BYTES) return { path: filePath, error: 'too-large' };
+
+  return {
+    path: filePath,
+    filename: sanitizeFilename(path.basename(filePath)),
+    buffer: fs.readFileSync(filePath),
+    mimeType: mimeTypeFor(filePath),
+    size: stat.size,
+  };
+}
+
+/**
+ * Reads a batch of paths, best-effort — one bad path never blocks the rest.
+ * Paths beyond MAX_ATTACHMENTS are dropped and counted, not silently read.
+ * A cheap pre-stat tracks the running total so a file that would push the
+ * batch over MAX_TOTAL_BYTES is rejected without ever being buffered — same
+ * "reject before read" principle as the per-file size cap. The pre-stat's
+ * own errors are ignored here; readAttachmentFile below produces the real,
+ * specific error (not-found/not-a-file/etc.) for those paths.
+ *
+ * @param {string[]} paths
+ * @returns {{ files: Array<{ok: boolean} & (ReturnType<typeof readAttachmentFile>)>, droppedCount: number }}
+ */
+export function readAttachments(paths) {
+  const capped = paths.slice(0, MAX_ATTACHMENTS);
+  const files = [];
+  let totalBytes = 0;
+  for (const p of capped) {
+    let precheckSize = 0;
+    try { precheckSize = fs.statSync(p).size; } catch { /* handled below */ }
+    if (precheckSize > 0 && totalBytes + precheckSize > MAX_TOTAL_BYTES) {
+      files.push({ ok: false, path: p, error: 'total-size-exceeded' });
+      continue;
+    }
+    const result = readAttachmentFile(p);
+    if (!result.error) totalBytes += result.size;
+    files.push({ ok: !result.error, ...result });
+  }
+  return { files, droppedCount: paths.length - capped.length };
+}

package/skills/jtb/scripts/lib/help.mjs

@@ -670,20 +670,24 @@ export function printCommentHelp({ stream = process.stdout } = {}) {
   const s = createStyler({ isTTY: stream.isTTY });
   const lines = [
     '',
-    `  ${s.bold(s.brand('ticketlens'))} ${s.bold('comment')} ${s.dim('TICKET-KEY --body="..."')}  ${s.dim('[Pro]')}`,
+    `  ${s.bold(s.brand('ticketlens'))} ${s.bold('comment')} ${s.dim('TICKET-KEY --body="..." [--attach=path1,path2]')}  ${s.dim('[Pro]')}`,
     '',
     `  Post a comment directly to the ticket in its tracker (Jira/GitHub/Linear). ${s.dim('[Pro]')}`,
     `  Writes to the real tracker — this is not a local Recall note.`,
     '',
     `  ${s.bold('OPTIONS')}`,
     '',
-    `    ${s.brand('--body')}=${s.dim('TEXT')}    Comment body ${s.dim('(required)')}`,
-    `    ${s.brand('--profile')}=${s.dim('NAME')} Connection profile to use ${s.dim('(optional)')}`,
-    `    ${s.brand('-h')}, ${s.brand('--help')}   Show this help`,
+    `    ${s.brand('--body')}=${s.dim('TEXT')}      Comment body ${s.dim('(required)')}`,
+    `    ${s.brand('--attach')}=${s.dim('PATHS')}   Comma-separated local file paths to attach ${s.dim('(optional)')}`,
+    `                    Images render as an inline thumbnail on Jira and Linear.`,
+    `                    Not supported on GitHub — no attachment upload API exists there.`,
+    `    ${s.brand('--profile')}=${s.dim('NAME')}   Connection profile to use ${s.dim('(optional)')}`,
+    `    ${s.brand('-h')}, ${s.brand('--help')}     Show this help`,
     '',
     `  ${s.bold('EXAMPLES')}`,
     '',
     `    ${s.dim('$')} ticketlens comment PROD-123 --body="Looks good, merging."`,
+    `    ${s.dim('$')} ticketlens comment PROD-123 --body="See screenshot" --attach=./bug.png`,
     '',
   ];
   stream.write(lines.join('\n') + '\n');
@@ -861,6 +865,8 @@ export function printCreateHelp({ stream = process.stdout } = {}) {
     `    ${s.brand('--type')}=${s.dim('NAME')}       Issue type ${s.dim('(Jira only, required there)')}`,
     `    ${s.brand('--summary')}=${s.dim('TEXT')}    Ticket title/summary ${s.dim('(required)')}`,
     `    ${s.brand('--description')}=${s.dim('TEXT')}  Ticket description`,
+    `    ${s.brand('--attach')}=${s.dim('PATHS')}    Comma-separated local file paths to attach, uploaded after creation`,
+    `                    ${s.dim('(optional)')}. Not supported on GitHub — no attachment upload API exists there.`,
     `    ${s.brand('--profile')}=${s.dim('NAME')}     Connection profile to use ${s.dim('(optional)')}`,
     `    ${s.brand('-h')}, ${s.brand('--help')}       Show this help`,
     '',
@@ -868,6 +874,7 @@ export function printCreateHelp({ stream = process.stdout } = {}) {
     '',
     `    ${s.dim('$')} ticketlens create --project=PROD --type="Task" --summary="Fix login on mobile"`,
     `    ${s.dim('$')} ticketlens create --project=ENG --summary="New Linear issue" --profile=linear-team`,
+    `    ${s.dim('$')} ticketlens create --project=PROD --type="Bug" --summary="Broken layout" --attach=./screenshot.png`,
     '',
   ];
   stream.write(lines.join('\n') + '\n');

package/skills/jtb/scripts/lib/jira-attachment-client.mjs

@@ -0,0 +1,80 @@
+/**
+ * Uploads a file to a Jira issue's attachments. Multipart/form-data, not
+ * JSON — the one write in this codebase with a genuinely different request
+ * shape from every other Jira write (comment/transition/assign/link/update/
+ * create all send `Content-Type: application/json`). Reuses the same
+ * guardedFetch/validateBaseUrl/buildAuthHeader SSRF/auth guards as every
+ * other call in jira-client.mjs, imported rather than duplicated.
+ */
+
+import { guardedFetch, validateBaseUrl, buildAuthHeader, defaultLookupFor, validateResolvedHost } from './jira-client.mjs';
+
+/**
+ * @param {string} ticketKey
+ * @param {{ filename: string, buffer: Buffer, mimeType: string }} file - from attachment-uploader.mjs's readAttachmentFile
+ * @param {object} opts
+ * @returns {Promise<{ id: string, filename: string, size: number, url: string|null }>}
+ */
+export async function uploadAttachment(ticketKey, file, opts = {}) {
+  const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), apiVersion = 2, timeoutMs = 30_000, allowPrivateIp = false } = opts;
+  validateBaseUrl(env.JIRA_BASE_URL, allowPrivateIp);
+  const baseUrl = env.JIRA_BASE_URL.replace(/\/$/, '');
+  const url = `${baseUrl}/rest/api/${apiVersion}/issue/${encodeURIComponent(ticketKey)}/attachments`;
+
+  const form = new FormData();
+  form.append('file', new Blob([file.buffer], { type: file.mimeType }), file.filename);
+
+  // No Content-Type header here — FormData sets its own multipart boundary.
+  // Every other write in jira-client.mjs sets 'Content-Type': 'application/json';
+  // copying that here would silently break the upload.
+  const fetchOpts = {
+    method: 'POST',
+    headers: { ...buildAuthHeader(env), 'X-Atlassian-Token': 'no-check' },
+    body: form,
+  };
+  if (timeoutMs) fetchOpts.signal = AbortSignal.timeout(timeoutMs);
+
+  const response = await guardedFetch(url, fetchOpts, { fetcher, lookup, allowPrivateIp });
+  if (!response.ok) {
+    const err = new Error(`Jira API error ${response.status} attaching ${file.filename} to ${ticketKey}`);
+    err.status = response.status;
+    throw err;
+  }
+  const raw = await response.json();
+  const uploaded = (Array.isArray(raw) ? raw[0] : raw) ?? {};
+  return {
+    id: uploaded.id,
+    filename: uploaded.filename ?? file.filename,
+    size: uploaded.size ?? file.buffer.length,
+    url: uploaded.content ?? null,
+  };
+}
+
+/**
+ * Resolves the Media Services UUID for an already-uploaded attachment —
+ * a completely different ID space from the classic attachment id above,
+ * and required to embed the attachment as real inline media in an ADF
+ * comment (see adf-converter.mjs's buildMediaNode). The only documented
+ * way to get it: a manual-redirect GET on the attachment's content URL,
+ * whose Location header points to
+ * `https://api.media.atlassian.com/file/{UUID}/binary?token=...` — the
+ * UUID is parsed out of that path without ever following the redirect
+ * (no need to actually download the file just to discard it).
+ *
+ * Real-instance-verified against a live Jira Cloud site: the resulting
+ * media node renders as a genuine inline thumbnail — see buildMediaNode's
+ * doc comment for what was confirmed about the `collection` attribute.
+ */
+export async function resolveMediaId(contentUrl, opts = {}) {
+  const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), allowPrivateIp = false } = opts;
+  await validateResolvedHost(new URL(contentUrl).hostname, lookup, allowPrivateIp);
+  const response = await fetcher(contentUrl, { headers: buildAuthHeader(env), redirect: 'manual' });
+  if (response.status < 300 || response.status >= 400) {
+    throw new Error(`Expected a redirect resolving the media id for ${contentUrl}, got ${response.status}`);
+  }
+  const location = response.headers.get('location');
+  if (!location) throw new Error(`Media content redirect for ${contentUrl} had no Location header`);
+  const match = new URL(location).pathname.match(/\/file\/([^/]+)\/binary/);
+  if (!match) throw new Error(`Could not parse a media uuid from redirect target for ${contentUrl}`);
+  return match[1];
+}

package/skills/jtb/scripts/lib/jira-client.mjs

@@ -4,7 +4,7 @@
  * Supports v2 (Server/DC) and v3 (Cloud) API versions.
  */
 
-import { adfToText, textToAdf } from './adf-converter.mjs';
+import { adfToText, textToAdf, appendNodesToAdf } from './adf-converter.mjs';
 import { lookup as dnsLookup } from 'node:dns/promises';
 
 function toText(value) {
@@ -420,14 +420,21 @@ export async function fetchRemoteLinks(ticketKey, opts = {}) {
  * Adds a comment to an issue. Cloud (v3) rejects a plain string body
  * outright and requires ADF; Server/DC (v2) accepts plain text directly —
  * same apiVersion branch point every other write/read here already uses.
+ *
+ * `extraAdfNodes` (Cloud only — a v2 string body has no ADF structure to
+ * append to) lets a caller embed real inline media (e.g. an uploaded
+ * attachment's mediaSingle node from adf-converter.mjs's buildMediaNode)
+ * after the text content, in the same atomic comment write.
  */
 export async function postComment(ticketKey, body, opts = {}) {
-  const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), apiVersion = 2, timeoutMs = 10_000, allowPrivateIp = false } = opts;
+  const { env = process.env, fetcher = globalThis.fetch, lookup = defaultLookupFor(fetcher), apiVersion = 2, timeoutMs = 10_000, allowPrivateIp = false, extraAdfNodes = [] } = opts;
   validateBaseUrl(env.JIRA_BASE_URL, allowPrivateIp);
   const baseUrl = env.JIRA_BASE_URL.replace(/\/$/, '');
   const url = `${baseUrl}/rest/api/${apiVersion}/issue/${encodeURIComponent(ticketKey)}/comment`;
 
-  const payload = { body: apiVersion === 3 ? textToAdf(body) : body };
+  let payloadBody = apiVersion === 3 ? textToAdf(body) : body;
+  if (apiVersion === 3 && extraAdfNodes.length) payloadBody = appendNodesToAdf(payloadBody, extraAdfNodes);
+  const payload = { body: payloadBody };
   const fetchOpts = {
     method: 'POST',
     headers: { ...buildAuthHeader(env), 'Content-Type': 'application/json' },

package/skills/jtb/scripts/lib/mcp-server.mjs

@@ -61,6 +61,7 @@ const TOOLS = [
       properties: {
         ticket: { type: 'string', description: 'Ticket key, e.g. PROJ-123.' },
         body: { type: 'string', description: 'Comment body.' },
+        attachments: { type: 'array', items: { type: 'string' }, description: 'Local file paths to attach — images render as a real inline thumbnail in the posted comment on both Jira (Cloud and Server/Data Center) and Linear. Not supported on GitHub — no PAT-compatible upload API exists there.' },
       },
       required: ['ticket', 'body'],
     },
@@ -142,6 +143,7 @@ const TOOLS = [
         type: { type: 'string', description: 'Jira issue type, e.g. "Task" or "Bug". Required for Jira only; ignored on GitHub/Linear.' },
         summary: { type: 'string', description: 'Ticket title/summary.' },
         description: { type: 'string', description: 'Ticket description. Omit for none.' },
+        attachments: { type: 'array', items: { type: 'string' }, description: 'Local file paths to attach, uploaded after the ticket is created. On Linear the image is automatically linked into the description. On Jira it becomes a real, visible attachment on the issue, but is not embedded inline in the initial description (use ticket_comment afterward for an inline thumbnail). Not supported on GitHub.' },
       },
       required: ['summary'],
     },
@@ -222,8 +224,10 @@ async function callTicketComment(args, { configDir, runTicketCommentFn }) {
   if (!args.body) {
     return { isError: true, content: [{ type: 'text', text: 'Missing required argument: body' }] };
   }
+  const cmdArgs = [args.ticket, `--body=${args.body}`];
+  if (args.attachments?.length) cmdArgs.push(`--attach=${args.attachments.join(',')}`);
   const capture = capturingStream();
-  const { ok } = await runTicketCommentFn([args.ticket, `--body=${args.body}`], { configDir, stream: capture });
+  const { ok } = await runTicketCommentFn(cmdArgs, { configDir, stream: capture });
   const content = [{ type: 'text', text: capture.text }];
   return ok ? { content } : { isError: true, content };
 }
@@ -350,6 +354,7 @@ function buildTicketCreateArgs(args) {
   if (args.type !== undefined) cmdArgs.push(`--type=${args.type}`);
   cmdArgs.push(`--summary=${args.summary}`);
   if (args.description !== undefined) cmdArgs.push(`--description=${args.description}`);
+  if (args.attachments?.length) cmdArgs.push(`--attach=${args.attachments.join(',')}`);
   return cmdArgs;
 }
 

package/skills/jtb/scripts/lib/ticket-command.mjs

@@ -20,11 +20,39 @@ import { readMetadataCache, writeMetadataCache } from './ticket-metadata-cache.m
 import { detectProjectOrTypeError, enrichCreateFailure } from './ticket-create-enrichment.mjs';
 import { TICKET_KEY_PATTERN } from './cli.mjs';
 import { scoreCandidates } from './duplicate-scorer.mjs';
+import { MAX_ATTACHMENTS } from './attachment-uploader.mjs';
 
 function parseFlag(cmdArgs, name) {
   return cmdArgs.find(a => a.startsWith(`--${name}=`))?.slice(name.length + 3);
 }
 
+function parseAttachPaths(cmdArgs) {
+  const raw = parseFlag(cmdArgs, 'attach');
+  return raw ? raw.split(',').map(p => p.trim()).filter(Boolean) : [];
+}
+
+/**
+ * GitHub has no PAT-compatible public API for uploading issue/comment
+ * assets (confirmed via research — the only upload endpoint requires a
+ * browser session, not a token). Refused before the adapter is ever
+ * called, same pattern already used for GitHub's --priority refusal in
+ * ticket_update, rather than silently no-op-ing.
+ */
+function refuseGithubAttachments(adapter, attachPaths, stream) {
+  if (!attachPaths.length || adapter.type !== 'github') return false;
+  stream.write('  Note: GitHub does not support file attachments via the API — no supported way to upload issue/comment assets exists. Continuing without --attach.\n');
+  return true;
+}
+
+function formatAttachSummary(attachResult) {
+  if (!attachResult) return '';
+  const lines = [];
+  for (const u of attachResult.uploaded) lines.push(`  Attached ${u.filename}${u.url ? ` (${u.url})` : ''}\n`);
+  for (const e of attachResult.errors) lines.push(`  Failed to attach ${e.path}: ${e.message}\n`);
+  if (attachResult.droppedCount > 0) lines.push(`  ${attachResult.droppedCount} attachment(s) dropped — exceeds the ${MAX_ATTACHMENTS}-file limit per call.\n`);
+  return lines.join('');
+}
+
 /**
  * Distinguishes retryable/terminal/rate-limited write failures so CLI and
  * MCP callers get the same actionable signal instead of a generic catch —
@@ -205,7 +233,7 @@ export async function runTicketComment(cmdArgs, {
   logActionFn = logAction,
   actor = os.userInfo().username,
 } = {}) {
-  const usage = 'Usage: ticketlens comment TICKET-KEY --body="..."\n';
+  const usage = 'Usage: ticketlens comment TICKET-KEY --body="..." [--attach=path1,path2]\n';
   if (!requireLicense(isLicensedFn, configDir, 'ticketlens comment', stream)) return { ok: false };
 
   const ticketKey = requireTicketKey(cmdArgs, usage, stream);
@@ -216,6 +244,7 @@ export async function runTicketComment(cmdArgs, {
     stream.write(usage);
     return { ok: false };
   }
+  const attachPaths = parseAttachPaths(cmdArgs);
 
   const cooldown = checkCooldownFn(ticketKey, 'comment', { configDir });
   if (cooldown.active) {
@@ -226,14 +255,32 @@ export async function runTicketComment(cmdArgs, {
   const adapter = resolveTicketAdapter(ticketKey, cmdArgs, { configDir, resolveConnectionFn, resolveAdapterFn, stream });
   if (!adapter) return { ok: false };
 
+  // Uploaded BEFORE the comment write so a tracker capable of inline
+  // rendering (Jira Server/DC via wiki markup, Jira Cloud via a real ADF
+  // media node, Linear via Markdown) can fold it into the same atomic
+  // comment post rather than needing a second edit call.
+  let attachResult = null;
+  if (attachPaths.length && !refuseGithubAttachments(adapter, attachPaths, stream)) {
+    attachResult = await adapter.attachFiles(ticketKey, attachPaths);
+  }
+  const inlineSnippets = (attachResult?.uploaded ?? []).filter(a => a.inlineMarkup).map(a => a.inlineMarkup).join('\n\n');
+  const finalBody = inlineSnippets ? `${body}\n\n${inlineSnippets}` : body;
+  const extraAdfNodes = (attachResult?.uploaded ?? []).filter(a => a.adfMediaNode).map(a => a.adfMediaNode);
+
   try {
-    const result = await adapter.addComment(ticketKey, body);
+    const result = await adapter.addComment(ticketKey, finalBody, extraAdfNodes.length ? { extraAdfNodes } : {});
     recordActionFn(ticketKey, 'comment', { configDir });
-    logActionFn({ ticketKey, action: 'comment', actor, tracker: adapter.type, detail: { id: result.id } }, { configDir });
-    stream.write(`  Comment posted to ${ticketKey}${result.url ? ` (${result.url})` : ''}\n`);
+    // attachPaths (every path attempted, raw) plus attachedFilenames (what
+    // actually landed) — a partial attach failure is reconstructable from
+    // the difference between the two, not just silently absent from audit.
+    logActionFn({ ticketKey, action: 'comment', actor, tracker: adapter.type, detail: { id: result.id, attachPaths, attachedFilenames: (attachResult?.uploaded ?? []).map(a => a.filename) } }, { configDir });
+    stream.write(`  Comment posted to ${ticketKey}${result.url ? ` (${result.url})` : ''}\n` + formatAttachSummary(attachResult));
     return { ok: true };
   } catch (err) {
-    stream.write(formatWriteFailure(ticketKey, err));
+    // Attachments (if any) genuinely landed on the tracker before this
+    // write was attempted — formatAttachSummary is still shown here so a
+    // caller retrying the whole command doesn't blindly re-upload them.
+    stream.write(formatWriteFailure(ticketKey, err) + formatAttachSummary(attachResult));
     return { ok: false };
   }
 }
@@ -705,9 +752,11 @@ export async function runTicketCreate(cmdArgs, {
   const project = parseFlag(cmdArgs, 'project');
   const type = parseFlag(cmdArgs, 'type');
   const description = parseFlag(cmdArgs, 'description');
+  const attachPaths = parseAttachPaths(cmdArgs);
 
   const adapter = resolveTicketAdapter(undefined, cmdArgs, { configDir, resolveConnectionFn, resolveAdapterFn, stream });
   if (!adapter) return { ok: false };
+  const attachRefused = refuseGithubAttachments(adapter, attachPaths, stream);
 
   if (adapter.type !== 'github' && !project) {
     stream.write(`  --project is required for ${adapter.type === 'jira' ? 'Jira (project key)' : 'Linear (team key)'}.\n`);
@@ -758,6 +807,44 @@ export async function runTicketCreate(cmdArgs, {
   } catch (bookkeepingErr) {
     stream.write(`  Warning: ${result.key} was created but could not be logged: ${bookkeepingErr.message}\n`);
   }
-  stream.write(`  Created ${result.key}${result.url ? ` (${result.url})` : ''}\n`);
+
+  // Attachments upload AFTER creation — Jira/Linear both need a real issue
+  // key to attach to (Jira strictly; Linear's fileUpload doesn't, but the
+  // same ordering is kept uniform across trackers for simplicity). The
+  // ticket has already landed, so nothing in this block may ever cause
+  // runTicketCreate to report the create itself as failed — wrapped in its
+  // own try/catch, mirroring the bookkeeping block above.
+  let attachResult = null;
+  if (attachPaths.length && !attachRefused) {
+    try {
+      attachResult = await adapter.attachFiles(result.key, attachPaths);
+
+      // Linear has no separate attachment list on an issue — unlike Jira's
+      // classic attachment (real regardless of description text), an
+      // uploaded Linear asset is only ever associated with the issue by
+      // referencing its URL in a text field. Without this follow-up edit,
+      // the file would be uploaded to Linear's storage but completely
+      // orphaned from the ticket. Best-effort: if this edit fails, the
+      // asset is still genuinely uploaded, just not linked — reported as
+      // an error entry, not a lost/misreported create.
+      const inlineSnippets = attachResult.uploaded.filter(a => a.inlineMarkup).map(a => a.inlineMarkup).join('\n\n');
+      if (inlineSnippets && adapter.type === 'linear') {
+        try {
+          await adapter.updateFields(result.key, { description: description ? `${description}\n\n${inlineSnippets}` : inlineSnippets });
+        } catch (linkErr) {
+          attachResult = { ...attachResult, errors: [...attachResult.errors, { path: '(description update)', message: `uploaded but failed to link into the ticket description: ${linkErr.message}` }] };
+        }
+      }
+
+      try {
+        logActionFn({ ticketKey: result.key, action: 'create', actor, tracker: adapter.type, detail: { attachPaths, attachedFilenames: attachResult.uploaded.map(a => a.filename) } }, { configDir });
+      } catch { /* best-effort, same as the primary bookkeeping above */ }
+    } catch (attachErr) {
+      stream.write(`  Warning: ${result.key} was created but attaching files failed: ${attachErr.message}\n`);
+      attachResult = null;
+    }
+  }
+
+  stream.write(`  Created ${result.key}${result.url ? ` (${result.url})` : ''}\n` + formatAttachSummary(attachResult));
   return { ok: true, key: result.key };
 }