datagrok-tools 6.1.10 → 6.1.12

package/bin/commands/report.js

@@ -12,19 +12,73 @@ var color = _interopRequireWildcard(require("../utils/color-utils"));
 var _testUtils = require("../utils/test-utils");
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 const fetch = require('node-fetch');
+const AdmZip = require('adm-zip');
 async function report(args) {
   const subcommand = args._[1];
   switch (subcommand) {
     case 'fetch':
       return await handleFetch(args);
+    case 'read':
+      return await handleRead(args);
     case 'resolve':
       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;
   }
 }
+async function fetchReportMeta(url, token, number) {
+  const resp = await fetch(`${url}/reports?text=number%3D${encodeURIComponent(number)}`, {
+    headers: {
+      Authorization: token
+    }
+  });
+  if (!resp.ok) return null;
+  const arr = await resp.json();
+  if (!Array.isArray(arr) || arr.length === 0) return null;
+  return arr[0];
+}
+async function fetchReportBundle(instance, number) {
+  const {
+    url,
+    key
+  } = (0, _testUtils.getDevKey)(instance);
+  const token = await (0, _testUtils.getToken)(url, key);
+  const byNumberResp = await fetch(`${url}/reports/by-number/${encodeURIComponent(number)}/zip`, {
+    headers: {
+      Authorization: token
+    }
+  });
+  if (byNumberResp.ok) {
+    const zipBuffer = await byNumberResp.buffer();
+    const metaJson = await fetchReportMeta(url, token, number);
+    return {
+      zipBuffer,
+      metaJson
+    };
+  }
+  if (byNumberResp.status !== 404 && byNumberResp.status !== 405) throw new Error(`HTTP ${byNumberResp.status} from /reports/by-number/${number}/zip`);
+  const metaJson = await fetchReportMeta(url, token, number);
+  if (metaJson == null) throw new Error(`Report #${number} not found`);
+  const reportId = metaJson.id || metaJson.Id;
+  if (!reportId) throw new Error('Report found but has no id field');
+  const downloadResp = await fetch(`${url}/reports/${reportId}/zip`, {
+    headers: {
+      Authorization: token
+    }
+  });
+  if (!downloadResp.ok) throw new Error(`Report download failed (HTTP ${downloadResp.status})`);
+  const zipBuffer = await downloadResp.buffer();
+  return {
+    zipBuffer,
+    metaJson
+  };
+}
 async function handleFetch(args) {
   const instance = args._[2];
   const number = args._[3];
@@ -33,49 +87,207 @@ async function handleFetch(args) {
     return false;
   }
   try {
+    console.log(`Fetching report #${number}...`);
     const {
-      url,
-      key
-    } = (0, _testUtils.getDevKey)(instance);
-    const token = await (0, _testUtils.getToken)(url, key);
-    console.log(`Searching for report #${number}...`);
-    const searchResp = await fetch(`${url}/reports?text=number%3D${encodeURIComponent(number)}`, {
-      headers: {
-        Authorization: token
-      }
-    });
-    if (!searchResp.ok) {
-      color.error(`Report search failed (HTTP ${searchResp.status})`);
-      return false;
+      zipBuffer,
+      metaJson
+    } = await fetchReportBundle(instance, number);
+    const outputPath = _path.default.join(_os.default.tmpdir(), `report_${instance}_${number}.zip`);
+    _fs.default.writeFileSync(outputPath, zipBuffer);
+    if (metaJson != null) {
+      const metaPath = outputPath.replace('.zip', '_meta.json');
+      _fs.default.writeFileSync(metaPath, JSON.stringify(metaJson, null, 2));
     }
-    const results = await searchResp.json();
-    if (!Array.isArray(results) || results.length === 0) {
-      color.error(`Report #${number} not found`);
+    color.success(`Report saved to: ${outputPath}`);
+    console.log(outputPath);
+    return true;
+  } catch (err) {
+    color.error(`Error: ${err.message}`);
+    return false;
+  }
+}
+function looksLikePath(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;
     }
-    const reportData = results[0];
-    const reportId = reportData.id || reportData.Id;
-    if (!reportId) {
-      color.error('Report found but has no id field');
+  }
+  return false;
+}
+function loadFromZip(z) {
+  const entries = z.getEntries();
+  const reportEntry = entries.find(e => e.entryName.toLowerCase().endsWith('report.json'));
+  if (reportEntry == null) {
+    const names = entries.map(e => e.entryName).join(', ');
+    throw new Error(`report.json not found in zip. Contents: ${names}`);
+  }
+  const data = JSON.parse(reportEntry.getData().toString('utf-8'));
+  const d42Names = entries.map(e => e.entryName).filter(n => n.toLowerCase().endsWith('.d42'));
+  return {
+    data,
+    zip: z,
+    d42Names
+  };
+}
+function loadFromBuffer(buf) {
+  try {
+    const z = new AdmZip(buf);
+    return loadFromZip(z);
+  } catch {
+    const text = buf.toString('utf-8');
+    return {
+      data: JSON.parse(text),
+      zip: null,
+      d42Names: []
+    };
+  }
+}
+function loadFromPath(p) {
+  if (p.toLowerCase().endsWith('.json')) {
+    const text = _fs.default.readFileSync(p, 'utf-8');
+    return {
+      data: JSON.parse(text),
+      zip: null,
+      d42Names: []
+    };
+  }
+  return loadFromBuffer(_fs.default.readFileSync(p));
+}
+function unwrapEnvelope(data) {
+  if (data && typeof data === 'object' && '#type' in data && 'data' in data && typeof data.data === 'object' && data.data != null) {
+    const meta = {};
+    if (data.id != null) meta.id = data.id;
+    if (data.createdOn != null) meta.createdOn = data.createdOn;
+    if (data['#type'] != null) meta['#type'] = data['#type'];
+    return {
+      meta,
+      body: data.data
+    };
+  }
+  return {
+    meta: {},
+    body: data
+  };
+}
+function loadSidecar(inputPath) {
+  const stem = inputPath.replace(/\.[^./\\]+$/, '');
+  const sidecar = `${stem}_meta.json`;
+  if (sidecar !== inputPath && _fs.default.existsSync(sidecar)) return JSON.parse(_fs.default.readFileSync(sidecar, 'utf-8'));
+  return null;
+}
+function ensureParentDir(p) {
+  const dir = _path.default.dirname(p);
+  if (dir && dir !== '.' && !_fs.default.existsSync(dir)) _fs.default.mkdirSync(dir, {
+    recursive: true
+  });
+}
+function extractScreenshot(zip, body, outPath) {
+  if (zip != null) {
+    const entries = zip.getEntries();
+    const e = entries.find(x => x.entryName.toLowerCase().endsWith('screenshot.png'));
+    if (e != null) {
+      ensureParentDir(outPath);
+      _fs.default.writeFileSync(outPath, e.getData());
+      return true;
+    }
+  }
+  const b64 = body && body.screenshot;
+  if (typeof b64 === 'string' && b64.length > 0) {
+    const stripped = b64.includes(',') ? b64.slice(b64.indexOf(',') + 1) : b64;
+    try {
+      const buf = Buffer.from(stripped, 'base64');
+      ensureParentDir(outPath);
+      _fs.default.writeFileSync(outPath, buf);
+      return true;
+    } catch {
       return false;
     }
-    console.log(`Downloading report ${reportId}...`);
-    const downloadResp = await fetch(`${url}/reports/${reportId}/zip`, {
-      headers: {
-        Authorization: token
+  }
+  return false;
+}
+function extractD42(zip, names, outDir) {
+  if (zip == null || names.length === 0) return [];
+  _fs.default.mkdirSync(outDir, {
+    recursive: true
+  });
+  const written = [];
+  for (const name of names) {
+    const entry = zip.getEntry(name);
+    if (entry == null) continue;
+    const out = _path.default.join(outDir, _path.default.basename(name));
+    _fs.default.writeFileSync(out, entry.getData());
+    written.push(out);
+  }
+  return written;
+}
+async function handleRead(args) {
+  const positional = args._.slice(2);
+  if (positional.length === 0) {
+    color.error('Usage: grok report read <path> | <instance> <number>');
+    return false;
+  }
+  const screenshotOut = args['extract-screenshot'];
+  const d42Dir = args['extract-d42'];
+  const extractActions = args['extract-actions'] === true;
+  try {
+    let loaded;
+    let sidecarMeta = null;
+    let inputPath = null;
+    let networkBase = null;
+    if (positional.length >= 2 && !looksLikePath(positional[0])) {
+      const [instance, number] = positional;
+      const bundle = await fetchReportBundle(instance, number);
+      loaded = loadFromBuffer(bundle.zipBuffer);
+      sidecarMeta = bundle.metaJson;
+      networkBase = _path.default.join(_os.default.tmpdir(), `report_${instance}_${number}`);
+    } else {
+      inputPath = _path.default.resolve(positional[0]);
+      if (!_fs.default.existsSync(inputPath)) {
+        color.error(`File not found: ${inputPath}`);
+        return false;
       }
-    });
-    if (!downloadResp.ok) {
-      color.error(`Report download failed (HTTP ${downloadResp.status})`);
-      return false;
+      loaded = loadFromPath(inputPath);
+      sidecarMeta = loadSidecar(inputPath);
     }
-    const buffer = await downloadResp.buffer();
-    const outputPath = _path.default.join(_os.default.tmpdir(), `report_${instance}_${number}.zip`);
-    _fs.default.writeFileSync(outputPath, buffer);
-    const metaPath = outputPath.replace('.zip', '_meta.json');
-    _fs.default.writeFileSync(metaPath, JSON.stringify(reportData, null, 2));
-    color.success(`Report saved to: ${outputPath}`);
-    console.log(outputPath);
+    const {
+      meta: envelopeMeta,
+      body
+    } = unwrapEnvelope(loaded.data);
+    const meta = Object.assign({}, envelopeMeta, sidecarMeta || {});
+    const output = {
+      meta,
+      ...body
+    };
+    const files = {};
+    if (screenshotOut) {
+      if (extractScreenshot(loaded.zip, body, screenshotOut)) {
+        files.screenshot = screenshotOut;
+        output.screenshot = screenshotOut;
+      }
+    }
+    if (d42Dir) {
+      const written = extractD42(loaded.zip, loaded.d42Names, d42Dir);
+      if (written.length > 0) files.d42 = written;
+    }
+    if (extractActions && Array.isArray(body && body.actions)) {
+      const stem = inputPath != null ? inputPath.replace(/\.[^./\\]+$/, '') : networkBase;
+      if (stem != null) {
+        const actionsPath = `${stem}_actions.json`;
+        _fs.default.writeFileSync(actionsPath, JSON.stringify(body.actions, null, 2));
+        files.actions = actionsPath;
+      }
+    }
+    if (Object.keys(files).length > 0) output.files = files;
+    process.stdout.write(JSON.stringify(output));
+    process.stdout.write('\n');
     return true;
   } catch (err) {
     color.error(`Error: ${err.message}`);
@@ -181,4 +393,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;
+  }
 }