logwork-cli 0.0.0-stage → 1.1.0

package/lib/jira-api.mjs

@@ -0,0 +1,258 @@
+import { CONFIG } from './config.mjs';
+import { ApiError } from './api.mjs';
+import { fetchWithPolicy, redactedExcerpt } from './http.mjs';
+import { safeJsonParse } from './util.mjs';
+
+export async function jiraApiFetch(token, path, {
+  baseUrl = CONFIG.jiraBaseUrl,
+  fetchImpl = fetch,
+  timeoutMs = CONFIG.httpTimeoutMs,
+  retries = CONFIG.httpReadRetries,
+  retryDelayMs = CONFIG.httpRetryDelayMs,
+  method = 'GET',
+  body,
+  headers = {}
+} = {}) {
+  assertJiraToken(token);
+  const url = buildJiraUrl(baseUrl, path);
+  const response = await fetchWithPolicy(url.toString(), {
+    fetchImpl,
+    timeoutMs,
+    retries,
+    retryDelayMs,
+    idempotent: isIdempotentMethod(method),
+    method,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+      ...headers
+    },
+    body: body === undefined ? undefined : JSON.stringify(body)
+  });
+  const text = await response.text();
+  const data = text ? safeJsonParse(text, text) : null;
+  const safeBody = redactedExcerpt(text);
+
+  if (response.status === 401) {
+    throw new ApiError('Jira request returned 401 Unauthorized. Run `logwork login jira` with a valid PAT.', {
+      status: response.status,
+      path,
+      body: safeBody
+    });
+  }
+
+  if (!response.ok) {
+    throw new ApiError(`Jira request failed: ${response.status} ${response.statusText} for ${path}. Body: ${safeBody}`, {
+      status: response.status,
+      path,
+      body: safeBody
+    });
+  }
+
+  return data;
+}
+
+export async function getJiraMyself(token, options = {}) {
+  return normalizeJiraUser(await jiraApiFetch(token, '/rest/api/2/myself', options));
+}
+
+export async function getJiraIssue(token, issueKey, options = {}) {
+  assertIssueKey(issueKey);
+  return normalizeJiraIssue(await jiraApiFetch(token, `/rest/api/2/issue/${encodeURIComponent(issueKey)}`, options));
+}
+
+export async function getJiraIssueWorklogs(token, issueKey, options = {}) {
+  assertIssueKey(issueKey);
+  const { pageSize = 100, ...fetchOptions } = options;
+  const worklogs = [];
+  let startAt = 0;
+
+  while (true) {
+    const qs = new URLSearchParams({
+      maxResults: String(pageSize),
+      startAt: String(startAt)
+    });
+    const data = await jiraApiFetch(token, `/rest/api/2/issue/${encodeURIComponent(issueKey)}/worklog?${qs}`, fetchOptions);
+    const page = Array.isArray(data?.worklogs) ? data.worklogs : [];
+    worklogs.push(...page.map(normalizeJiraWorklog));
+
+    startAt += page.length;
+    const total = Number(data?.total);
+    if (!page.length || !Number.isFinite(total) || startAt >= total) {
+      break;
+    }
+  }
+
+  return worklogs;
+}
+
+export async function searchJiraIssues(token, {
+  jql,
+  fields = ['key', 'summary'],
+  pageSize = 100
+} = {}, options = {}) {
+  if (!String(jql || '').trim()) {
+    throw new Error('Jira search requires JQL.');
+  }
+  const issues = [];
+  let startAt = 0;
+
+  while (true) {
+    const qs = new URLSearchParams({
+      jql: String(jql),
+      fields: fields.join(','),
+      maxResults: String(pageSize),
+      startAt: String(startAt)
+    });
+    const data = await jiraApiFetch(token, `/rest/api/2/search?${qs}`, options);
+    const page = Array.isArray(data?.issues) ? data.issues : [];
+    issues.push(...page.map(normalizeJiraIssue));
+
+    startAt += page.length;
+    const total = Number(data?.total);
+    if (!page.length || !Number.isFinite(total) || startAt >= total) {
+      break;
+    }
+  }
+
+  return issues;
+}
+
+export async function addJiraIssueWorklog(token, issueKey, worklog, options = {}) {
+  assertIssueKey(issueKey);
+  const qs = new URLSearchParams({ adjustEstimate: 'leave' });
+  const path = `/rest/api/2/issue/${encodeURIComponent(issueKey)}/worklog?${qs}`;
+  return normalizeJiraWorklog(await jiraApiFetch(token, path, {
+    ...options,
+    method: 'POST',
+    retries: 0,
+    body: worklog
+  }));
+}
+
+export function normalizeJiraIssue(issue = {}) {
+  const fields = issue.fields || {};
+  return {
+    id: issue.id ? String(issue.id) : undefined,
+    key: issue.key ? String(issue.key) : undefined,
+    summary: fields.summary ? String(fields.summary) : '',
+    status: fields.status?.name ? String(fields.status.name) : '',
+    issueType: fields.issuetype?.name ? String(fields.issuetype.name) : '',
+    project: fields.project?.key || fields.project?.name
+      ? {
+        key: fields.project?.key ? String(fields.project.key) : undefined,
+        name: fields.project?.name ? String(fields.project.name) : undefined
+      }
+      : null,
+    assignee: fields.assignee ? normalizeJiraUser(fields.assignee) : null
+  };
+}
+
+export function normalizeJiraUser(user = {}) {
+  return {
+    name: user.name ? String(user.name) : undefined,
+    key: user.key ? String(user.key) : undefined,
+    displayName: user.displayName ? String(user.displayName) : undefined,
+    emailAddress: user.emailAddress ? String(user.emailAddress) : undefined,
+    active: user.active === undefined ? undefined : Boolean(user.active)
+  };
+}
+
+export function normalizeJiraWorklog(worklog = {}) {
+  return {
+    id: worklog.id ? String(worklog.id) : undefined,
+    issueId: worklog.issueId ? String(worklog.issueId) : undefined,
+    started: worklog.started ? String(worklog.started) : '',
+    timeSpent: worklog.timeSpent ? String(worklog.timeSpent) : '',
+    timeSpentSeconds: Number.isFinite(Number(worklog.timeSpentSeconds)) ? Number(worklog.timeSpentSeconds) : 0,
+    comment: normalizeWorklogComment(worklog.comment),
+    author: worklog.author ? normalizeJiraUser(worklog.author) : null
+  };
+}
+
+export function buildJiraUrl(baseUrl, path) {
+  const base = assertJiraBaseUrl(baseUrl);
+  const basePath = base.pathname.endsWith('/') ? base.pathname : `${base.pathname}/`;
+  const relativePath = String(path || '').replace(/^\/+/, '');
+  return new URL(relativePath, `${base.origin}${basePath}`);
+}
+
+export function assertJiraBaseUrl(rawUrl = CONFIG.jiraBaseUrl) {
+  let url;
+  try {
+    url = new URL(rawUrl);
+  } catch {
+    throw new Error('Jira base URL must be a valid http(s) URL.');
+  }
+
+  if (!['http:', 'https:'].includes(url.protocol)) {
+    throw new Error('Jira base URL must use HTTP or HTTPS.');
+  }
+
+  if (url.protocol === 'http:' && !isLocalHttpHost(url.hostname)) {
+    throw new Error('Jira base URL must use HTTPS unless it points to localhost or loopback.');
+  }
+
+  return url;
+}
+
+function assertJiraToken(token) {
+  if (!String(token || '').trim()) {
+    throw new Error('Jira PAT token is required.');
+  }
+}
+
+function assertIssueKey(issueKey) {
+  if (!/^[A-Z][A-Z0-9]+-\d+$/.test(String(issueKey || ''))) {
+    throw new Error('Jira issueKey must look like ABC-123.');
+  }
+}
+
+function normalizeWorklogComment(comment) {
+  if (typeof comment === 'string') {
+    return comment;
+  }
+  if (comment === undefined || comment === null) {
+    return '';
+  }
+  const text = extractJiraText(comment).trim();
+  if (text) {
+    return text;
+  }
+  try {
+    return JSON.stringify(comment);
+  } catch {
+    return String(comment);
+  }
+}
+
+function extractJiraText(value) {
+  if (typeof value === 'string') {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(extractJiraText).filter(Boolean).join(' ');
+  }
+  if (value && typeof value === 'object') {
+    if (typeof value.text === 'string') {
+      return value.text;
+    }
+    if (Array.isArray(value.content)) {
+      return extractJiraText(value.content);
+    }
+  }
+  return '';
+}
+
+function isIdempotentMethod(method) {
+  return ['GET', 'HEAD', 'OPTIONS'].includes(String(method || 'GET').toUpperCase());
+}
+
+function isLocalHttpHost(hostname) {
+  const host = String(hostname || '').replace(/^\[|\]$/g, '').toLowerCase();
+  return host === 'localhost' ||
+    host === '127.0.0.1' ||
+    host === '::1' ||
+    host.startsWith('127.');
+}

package/lib/jira-auth.mjs

@@ -0,0 +1,203 @@
+import { isCancel, password } from '@clack/prompts';
+import { CONFIG } from './config.mjs';
+import { createCredentialJiraStorage } from './credential-store.mjs';
+import { getJiraMyself, assertJiraBaseUrl } from './jira-api.mjs';
+import { redactText } from './auth-redaction.mjs';
+import { safeJsonParse } from './util.mjs';
+
+export function createJiraAuthRequiredError(message = jiraAuthRequiredSummary()) {
+  const error = new Error(message);
+  error.code = 'JIRA_AUTH_REQUIRED';
+  return error;
+}
+
+export function isJiraAuthRequiredError(error) {
+  return error?.code === 'JIRA_AUTH_REQUIRED';
+}
+
+export function jiraAuthRequiredPayload(error) {
+  return {
+    status: 'jira_auth_required',
+    authRequired: true,
+    command: 'logwork login jira',
+    summary: error?.message || jiraAuthRequiredSummary()
+  };
+}
+
+export async function loginJira({
+  baseUrl = CONFIG.jiraBaseUrl,
+  tokenProvider = createTerminalJiraTokenProvider(),
+  storage = createCredentialJiraStorage(),
+  validateToken = getJiraMyself
+} = {}) {
+  const normalizedBaseUrl = normalizeJiraBaseUrl(baseUrl);
+  const token = String(await tokenProvider.requestToken({ baseUrl: normalizedBaseUrl }) || '').trim();
+  if (!token) {
+    throw new Error('Jira PAT token is required.');
+  }
+
+  const user = await validateToken(token, {
+    baseUrl: normalizedBaseUrl
+  });
+  const session = normalizeJiraSession({
+    baseUrl: normalizedBaseUrl,
+    token,
+    user
+  });
+  await storage.set(serializeJiraSession(session));
+
+  return {
+    ...session,
+    summary: `Authenticated to Jira ${session.baseUrl} as ${formatJiraUser(session.user)}.`
+  };
+}
+
+export async function getStoredJiraStatus({
+  storage = createCredentialJiraStorage()
+} = {}) {
+  const session = normalizeStoredJiraSession(await storage.get());
+  if (!session?.token) {
+    return {
+      authenticated: false,
+      summary: 'Not authenticated to Jira. Run `logwork login jira`.'
+    };
+  }
+
+  return {
+    authenticated: true,
+    baseUrl: session.baseUrl,
+    user: session.user,
+    summary: `Authenticated to Jira ${session.baseUrl} as ${formatJiraUser(session.user)}.`
+  };
+}
+
+export async function logoutJira({
+  storage = createCredentialJiraStorage()
+} = {}) {
+  const deleted = await storage.delete();
+  return {
+    deleted,
+    summary: deleted ? 'Deleted stored Jira PAT.' : 'No stored Jira PAT found.'
+  };
+}
+
+export async function getStoredJiraSession({
+  storage = createCredentialJiraStorage()
+} = {}) {
+  const session = normalizeStoredJiraSession(await storage.get());
+  if (!session?.token) {
+    throw createJiraAuthRequiredError();
+  }
+  return session;
+}
+
+export function createTerminalJiraTokenProvider({
+  stdin = process.stdin,
+  stdout = process.stdout
+} = {}) {
+  return {
+    async requestToken({ baseUrl }) {
+      ensureInteractive(stdin, stdout);
+      return handleCancel(await password({
+        message: `Jira PAT for ${baseUrl}:`,
+        validate(value) {
+          if (!String(value || '').trim()) {
+            return 'Jira PAT token is required.';
+          }
+          return undefined;
+        }
+      }));
+    }
+  };
+}
+
+export function normalizeStoredJiraSession(rawValue) {
+  if (!rawValue) {
+    return null;
+  }
+
+  const parsed = safeJsonParse(String(rawValue), null);
+  if (!parsed || typeof parsed !== 'object') {
+    return null;
+  }
+
+  try {
+    return normalizeJiraSession(parsed);
+  } catch {
+    return null;
+  }
+}
+
+export function normalizeJiraSession(session = {}) {
+  const baseUrl = normalizeJiraBaseUrl(session.baseUrl || CONFIG.jiraBaseUrl);
+  const token = String(session.token || '').trim();
+  if (!token) {
+    throw new Error('Jira session token is required.');
+  }
+
+  return {
+    baseUrl,
+    token,
+    user: session.user && typeof session.user === 'object' ? sanitizeJiraUser(session.user) : null
+  };
+}
+
+export function serializeJiraSession(session) {
+  const normalized = normalizeJiraSession(session);
+  return JSON.stringify({
+    baseUrl: normalized.baseUrl,
+    token: normalized.token,
+    user: normalized.user
+  });
+}
+
+export function formatJiraUser(user) {
+  if (!user) {
+    return 'unknown user';
+  }
+  return user.displayName || user.name || user.key || user.emailAddress || 'unknown user';
+}
+
+function sanitizeJiraUser(user) {
+  return {
+    name: textOrUndefined(user.name),
+    key: textOrUndefined(user.key),
+    displayName: textOrUndefined(user.displayName),
+    emailAddress: textOrUndefined(user.emailAddress),
+    active: user.active === undefined ? undefined : Boolean(user.active)
+  };
+}
+
+function textOrUndefined(value) {
+  if (value === undefined || value === null || String(value).trim() === '') {
+    return undefined;
+  }
+  return String(value);
+}
+
+function ensureInteractive(stdin, stdout) {
+  if (!stdin?.isTTY || !stdout?.isTTY) {
+    throw createJiraAuthRequiredError();
+  }
+}
+
+function handleCancel(value) {
+  if (isCancel(value)) {
+    throw new Error('User cancelled Jira authentication.');
+  }
+  return value;
+}
+
+function normalizeJiraBaseUrl(value) {
+  const url = assertJiraBaseUrl(value);
+  const pathname = url.pathname === '/' ? '' : url.pathname.replace(/\/+$/, '');
+  return `${url.origin}${pathname}`;
+}
+
+function jiraAuthRequiredSummary() {
+  return 'Jira authentication required. Run `logwork login jira` in a terminal, paste a Jira Personal Access Token there, then retry this MCP tool.';
+}
+
+export function safeJiraAuthError(error) {
+  return new Error(redactText(error?.message || String(error || 'Jira authentication failed.')));
+}