datagrok-tools 6.1.11 → 6.1.13

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Datagrok-tools changelog
 
+## 6.1.13 (2026-04-30)
+
+* Reports: `grok report ticket` now uses direct JIRA REST honoring `$JIRA_PROJECT`, replacing the Datlas-mediated path that hardcoded GROK.
+
 ## 6.1.11 (2026-04-27)
 
 * `grok report read <path | instance number>` — normalize a report zip/json into one JSON object on stdout (envelope unwrap, `_meta.json` merge, optional `--extract-screenshot` / `--extract-d42` / `--extract-actions`)

package/bin/commands/report.js

@@ -24,6 +24,10 @@ async function report(args) {
       return await handleResolve(args);
     case 'ticket':
       return await handleTicket(args);
+    case 'comment':
+      return await handleComment(args);
+    case 'label':
+      return await handleLabel(args);
     default:
       return false;
   }
@@ -103,7 +107,20 @@ async function handleFetch(args) {
   }
 }
 function looksLikePath(s) {
-  return s.includes('/') || s.includes('\\') || /\.(zip|json)$/i.test(s) || _fs.default.existsSync(s);
+  if (s.includes('/') || s.includes('\\')) return true;
+  if (/\.(zip|json)$/i.test(s)) return true;
+  // Only treat a bare name as a path if it's an actual file. A *directory*
+  // collision (e.g. running `grok report read public 2147` from a checkout
+  // that has a `public/` submodule next to it) must not flip into the
+  // single-arg path branch — that would EISDIR on `readFileSync(p)`.
+  if (_fs.default.existsSync(s)) {
+    try {
+      return _fs.default.statSync(s).isFile();
+    } catch {
+      return false;
+    }
+  }
+  return false;
 }
 function loadFromZip(z) {
   const entries = z.getEntries();
@@ -202,7 +219,7 @@ function extractD42(zip, names, outDir) {
     recursive: true
   });
   const written = [];
-  for (var name of names) {
+  for (const name of names) {
     const entry = zip.getEntry(name);
     if (entry == null) continue;
     const out = _path.default.join(outDir, _path.default.basename(name));
@@ -325,46 +342,79 @@ async function handleTicket(args) {
   const instance = args._[2];
   const reportId = args._[3];
   if (!instance || !reportId) {
-    color.error('Usage: grok report ticket <instance> <report-id>');
+    color.error('Usage: grok report ticket <instance> <report-id> [--project <KEY>] [--type <Bug>] [--jira-url <url>]');
+    return false;
+  }
+  const projectKey = args['project'] || process.env.JIRA_PROJECT || '';
+  if (!projectKey) {
+    color.error('--project or $JIRA_PROJECT is required (no GROK default)');
     return false;
   }
+  const issueType = args['type'] || 'Bug';
+  const auth = jiraAuthHeader();
+  if (auth == null) {
+    color.error('JIRA_USER and JIRA_TOKEN env vars are required for `grok report ticket`.');
+    return false;
+  }
+  const jiraBase = resolveJiraBase(args);
   try {
     const {
       url,
       key
     } = (0, _testUtils.getDevKey)(instance);
     const token = await (0, _testUtils.getToken)(url, key);
-    console.log('Getting current user...');
-    const userResp = await fetch(`${url}/users/current`, {
+    console.log(`Fetching report ${reportId}...`);
+    const reportResp = await fetch(`${url}/reports/${encodeURIComponent(reportId)}`, {
       headers: {
         Authorization: token
       }
     });
-    if (!userResp.ok) {
-      color.error(`Failed to get current user (HTTP ${userResp.status})`);
-      return false;
-    }
-    const user = await userResp.json();
-    const userId = user.id || user.Id;
-    if (!userId) {
-      color.error('No user id in response');
+    if (!reportResp.ok) {
+      const body = await reportResp.text();
+      color.error(`Failed to fetch report (HTTP ${reportResp.status}): ${body.slice(0, 400)}`);
       return false;
     }
-    console.log(`Creating JIRA ticket for report ${reportId}...`);
-    const ticketResp = await fetch(`${url}/reports/${reportId}/jira?assigneeId=${userId}`, {
+    const body = await reportResp.json();
+    // The REST endpoint returns a flat UserReport: top-level `#type`,
+    // `number`, `errorMessage`, etc. The `data` field is a ref to the
+    // related data-table entity, not a body wrapper — do not unwrap.
+    const number = body && (body.number != null ? body.number : body.Number);
+    const errorMessage = (body && (body.errorMessage || body.ErrorMessage) || '').toString().trim();
+    let summary = number != null ? errorMessage ? `Report #${number}: ${errorMessage}` : `Report #${number}` : errorMessage || `Report ${reportId}`;
+    if (summary.length > 200) summary = summary.slice(0, 200);
+    // JIRA rejects newlines in summary.
+    summary = summary.replace(/[\r\n]+/g, ' ').trim();
+    const webRoot = url.replace(/\/api\/?$/, '');
+    const reportLink = number != null ? `${webRoot}/apps/usage/reports/${number}` : `${webRoot}/apps/usage/reports/`;
+    const description = `Auto-created from ${reportLink}`;
+    console.log(`Creating JIRA ticket in ${projectKey} (${issueType})...`);
+    const createResp = await fetch(`${jiraBase}/rest/api/2/issue/`, {
       method: 'POST',
       headers: {
-        Authorization: token,
-        'Content-Type': 'application/json'
-      }
+        Authorization: auth,
+        'Content-Type': 'application/json',
+        Accept: 'application/json'
+      },
+      body: JSON.stringify({
+        fields: {
+          project: {
+            key: projectKey
+          },
+          summary,
+          issuetype: {
+            name: issueType
+          },
+          description
+        }
+      })
     });
-    if (ticketResp.status !== 200 && ticketResp.status !== 201) {
-      const body = await ticketResp.text();
-      color.error(`JIRA ticket creation failed (HTTP ${ticketResp.status}): ${body}`);
+    if (createResp.status !== 200 && createResp.status !== 201) {
+      const errBody = await createResp.text();
+      color.error(`JIRA issue creation failed (HTTP ${createResp.status}): ${errBody}`);
       return false;
     }
-    const result = await ticketResp.json();
-    const ticketKey = result.key;
+    const result = await createResp.json();
+    const ticketKey = result && result.key;
     if (!ticketKey) {
       color.error(`No ticket key in response: ${JSON.stringify(result).slice(0, 200)}`);
       return false;
@@ -376,4 +426,132 @@ async function handleTicket(args) {
     color.error(`Error: ${err.message}`);
     return false;
   }
+}
+
+// ─── JIRA REST helpers (used by `grok report comment` / `grok report label`) ─
+//
+// These talk DIRECTLY to Atlassian Cloud REST v2 (not Datagrok). Auth is HTTP
+// Basic with `JIRA_USER` (Atlassian email) + `JIRA_TOKEN` (API token from
+// id.atlassian.com/manage-profile/security/api-tokens). Base URL defaults to
+// the Datagrok org instance; override via --jira-url or $JIRA_URL.
+//
+// Why v2 and not v3: v3 requires comment bodies in ADF (Atlassian Document
+// Format) JSON; v2 accepts plain text / wiki-markup. The handoff prompt emits
+// markdown, which JIRA's plain-text path renders acceptably.
+
+function resolveJiraBase(args) {
+  const cli = args['jira-url'] || '';
+  const env = process.env.JIRA_URL || '';
+  return (cli || env || 'https://reddata.atlassian.net').replace(/\/+$/, '');
+}
+function jiraAuthHeader() {
+  const user = process.env.JIRA_USER;
+  const token = process.env.JIRA_TOKEN;
+  if (!user || !token) return null;
+  return 'Basic ' + Buffer.from(`${user}:${token}`).toString('base64');
+}
+async function handleComment(args) {
+  const ticket = args._[2];
+  if (!ticket) {
+    color.error('Usage: grok report comment <ticket-key> [--body <text> | --body-file <path>] [--jira-url <url>]');
+    return false;
+  }
+  const auth = jiraAuthHeader();
+  if (auth == null) {
+    color.error('JIRA_USER and JIRA_TOKEN env vars are required for `grok report comment`.');
+    return false;
+  }
+  let body;
+  if (typeof args['body-file'] === 'string') {
+    const p = args['body-file'];
+    try {
+      body = _fs.default.readFileSync(p, 'utf-8');
+    } catch (e) {
+      color.error(`Failed to read --body-file ${p}: ${e.message}`);
+      return false;
+    }
+  } else if (typeof args['body'] === 'string') {
+    body = args['body'];
+  } else {
+    // Read from stdin if neither --body nor --body-file is provided.
+    body = _fs.default.readFileSync(0, 'utf-8');
+  }
+  if (!body || body.trim().length === 0) {
+    color.error('Comment body is empty (use --body, --body-file, or pipe to stdin).');
+    return false;
+  }
+  const base = resolveJiraBase(args);
+  const url = `${base}/rest/api/2/issue/${encodeURIComponent(ticket)}/comment`;
+  try {
+    const resp = await fetch(url, {
+      method: 'POST',
+      headers: {
+        Authorization: auth,
+        'Content-Type': 'application/json',
+        Accept: 'application/json'
+      },
+      body: JSON.stringify({
+        body
+      })
+    });
+    if (resp.status !== 200 && resp.status !== 201) {
+      const text = await resp.text();
+      color.error(`JIRA comment POST failed (HTTP ${resp.status}): ${text.slice(0, 400)}`);
+      return false;
+    }
+    const result = await resp.json();
+    const id = result && (result.id || result.Id);
+    if (!id) {
+      color.error(`JIRA returned no comment id: ${JSON.stringify(result).slice(0, 200)}`);
+      return false;
+    }
+    color.success(`Posted comment ${id} on ${ticket}`);
+    console.log(id);
+    return true;
+  } catch (err) {
+    color.error(`Error: ${err.message}`);
+    return false;
+  }
+}
+async function handleLabel(args) {
+  const ticket = args._[2];
+  const labels = args._.slice(3).filter(s => s.length > 0);
+  if (!ticket || labels.length === 0) {
+    color.error('Usage: grok report label <ticket-key> <label> [<label2> ...] [--jira-url <url>]');
+    return false;
+  }
+  const auth = jiraAuthHeader();
+  if (auth == null) {
+    color.error('JIRA_USER and JIRA_TOKEN env vars are required for `grok report label`.');
+    return false;
+  }
+  const base = resolveJiraBase(args);
+  const url = `${base}/rest/api/2/issue/${encodeURIComponent(ticket)}`;
+  const update = {
+    labels: labels.map(l => ({
+      add: l
+    }))
+  };
+  try {
+    const resp = await fetch(url, {
+      method: 'PUT',
+      headers: {
+        Authorization: auth,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        update
+      })
+    });
+    if (resp.status !== 204 && resp.status !== 200) {
+      const text = await resp.text();
+      color.error(`JIRA label PUT failed (HTTP ${resp.status}): ${text.slice(0, 400)}`);
+      return false;
+    }
+    color.success(`Applied labels to ${ticket}: ${labels.join(', ')}`);
+    return true;
+  } catch (err) {
+    color.error(`Error: ${err.message}`);
+    return false;
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "datagrok-tools",
-  "version": "6.1.11",
+  "version": "6.1.13",
   "description": "Utility to upload and publish packages to Datagrok",
   "homepage": "https://github.com/datagrok-ai/public/tree/master/tools#readme",
   "dependencies": {