logwork-cli 0.0.0-stage → 1.0.0

package/commands/auth.mjs

@@ -0,0 +1,227 @@
+import {
+  getStoredAuthStatus,
+  loginResourceOptimiser,
+  logoutResourceOptimiser
+} from '../lib/auth.mjs';
+import { authenticateWithApiSession } from '../lib/api-auth.mjs';
+import { createAuthDiagnosticsRecorder } from '../lib/auth-diagnostics.mjs';
+import { credentialStoreLabel } from '../lib/credential-store.mjs';
+import {
+  getStoredJiraStatus,
+  loginJira,
+  logoutJira,
+  safeJiraAuthError
+} from '../lib/jira-auth.mjs';
+
+// `logwork login|logout|status [ro|jira]`. Resource Optimiser is the default
+// target. Secrets are only ever typed in this terminal and stored in the OS
+// credential store; they are never accepted as arguments.
+
+export async function runLogin(argv = []) {
+  const { target, args } = splitTarget(argv);
+  if (wantsHelp(args)) {
+    console.log(formatAuthHelp());
+    return 0;
+  }
+  if (target === 'jira') {
+    const result = await runJiraLoginCommand(parseJiraLoginArgs(args));
+    return result.ok ? 0 : 1;
+  }
+  parseLoginArgs(args);
+  const result = await runLoginCommand();
+  return result.ok ? 0 : 1;
+}
+
+export async function runLogout(argv = []) {
+  const { target, args } = splitTarget(argv);
+  if (wantsHelp(args)) {
+    console.log(formatAuthHelp());
+    return 0;
+  }
+  assertNoArgs(args, 'logout');
+  const result = target === 'jira' ? await logoutJira() : await logoutResourceOptimiser();
+  console.log(result.summary);
+  return 0;
+}
+
+export async function runStatus(argv = []) {
+  if (wantsHelp(argv)) {
+    console.log(formatAuthHelp());
+    return 0;
+  }
+  const { target, args } = splitTarget(argv);
+  assertNoArgs(args, 'status');
+  const targets = argv.length ? [target] : ['ro', 'jira'];
+  let authenticated = true;
+  for (const item of targets) {
+    const result = item === 'jira' ? await getStoredJiraStatus() : await getStoredAuthStatus();
+    console.log(`${item === 'jira' ? 'Jira' : 'Resource Optimiser'}: ${result.summary}`);
+    if (item === 'ro' && !result.authenticated) {
+      authenticated = false;
+    }
+  }
+  return authenticated ? 0 : 1;
+}
+
+export function formatAuthHelp() {
+  const storeLabel = credentialStoreLabel();
+  return `Usage:
+  logwork login [ro|jira] [--base-url <url>]
+  logwork logout [ro|jira]
+  logwork status [ro|jira]
+
+Targets:
+  ro    Resource Optimiser (default). Email, password and 2FA are asked in this terminal.
+  jira  Jira Personal Access Token, pasted in this terminal.
+
+Sessions are stored in ${storeLabel}, never in files or command arguments.
+
+Options:
+  --base-url <url>  Jira base URL for \`login jira\`. Defaults to https://jira-vnv.vinova.sg`;
+}
+
+function splitTarget(argv = []) {
+  const [first, ...rest] = argv;
+  if (first === 'ro' || first === 'jira') {
+    return { target: first, args: rest };
+  }
+  return { target: 'ro', args: argv };
+}
+
+function wantsHelp(args) {
+  return args.includes('--help') || args.includes('-h');
+}
+
+function assertNoArgs(args, command) {
+  if (args.length) {
+    throw new Error(`Unknown ${command} option: ${args[0]}`);
+  }
+}
+
+export async function runLoginCommand({
+  login = loginResourceOptimiser,
+  createRecorder = createAuthDiagnosticsRecorder,
+  stdout = console.log,
+  stderr = console.error
+} = {}) {
+  stdout('Starting Resource Optimiser API auth. Secrets are requested in this terminal and are not stored.');
+  const diagnosticsRecorder = createRecorder();
+
+  try {
+    const result = await login({
+      authenticator: (options) => authenticateWithApiSession({
+        ...options,
+        diagnosticsRecorder
+      })
+    });
+    stdout(result.summary);
+    return {
+      ok: true,
+      result
+    };
+  } catch (error) {
+    stderr(error.message);
+    try {
+      const written = await diagnosticsRecorder.writeFailure(error);
+      stderr(`Auth failed. Sanitized diagnostics saved to ${written.path}. Attempt: ${written.attemptId}`);
+    } catch (writeError) {
+      stderr(`Auth failed. Unable to write sanitized diagnostics: ${writeError.message}`);
+    }
+    return {
+      ok: false,
+      error
+    };
+  }
+}
+
+export function parseLoginArgs(args = []) {
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (arg === '--api-mode') {
+      continue;
+    }
+
+    if (arg === '--browser' || arg.startsWith('--browser=')) {
+      throw new Error('Browser auth has been removed. Run `logwork login` for API-only auth.');
+    }
+
+    if (arg === '--browser-mode') {
+      throw new Error('Browser auth has been removed. Run `logwork login` for API-only auth.');
+    }
+
+    if (arg === 'record') {
+      throw new Error('Auth recording has been removed because auth is API-only.');
+    }
+
+    if (arg === '--help' || arg === '-h') {
+      continue;
+    }
+
+    throw new Error(`Unknown auth login option: ${arg}`);
+  }
+
+  return { mode: 'api' };
+}
+
+export async function runJiraLoginCommand({
+  baseUrl,
+  login = loginJira,
+  stdout = console.log,
+  stderr = console.error
+} = {}) {
+  stdout('Starting Jira PAT auth. Paste the token in this terminal; it is stored only in the OS credential store.');
+
+  try {
+    const result = await login({
+      ...(baseUrl ? { baseUrl } : {})
+    });
+    stdout(result.summary);
+    return {
+      ok: true,
+      result
+    };
+  } catch (error) {
+    const safeError = safeJiraAuthError(error);
+    stderr(safeError.message);
+    return {
+      ok: false,
+      error: safeError
+    };
+  }
+}
+
+export function parseJiraLoginArgs(args = []) {
+  const options = {};
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (arg === '--help' || arg === '-h') {
+      continue;
+    }
+
+    if (arg === '--base-url') {
+      const value = args[index + 1];
+      if (!value || value.startsWith('--')) {
+        throw new Error('--base-url requires a value.');
+      }
+      options.baseUrl = value;
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--base-url=')) {
+      const value = arg.slice('--base-url='.length);
+      if (!value) {
+        throw new Error('--base-url requires a value.');
+      }
+      options.baseUrl = value;
+      continue;
+    }
+
+    throw new Error(`Unknown jira login option: ${arg}`);
+  }
+
+  return options;
+}

package/commands/delete.mjs

@@ -0,0 +1,69 @@
+import { confirm, isCancel } from '@clack/prompts';
+import { parseRoDeleteArgs } from '../lib/ro-delete-args.mjs';
+import {
+  applyRoLogworkDelete,
+  previewRoLogworkDelete
+} from '../lib/ro-delete-workflow.mjs';
+
+export async function runRoDeleteCommand(args = [], {
+  preview = previewRoLogworkDelete,
+  apply = applyRoLogworkDelete,
+  promptConfirm = defaultConfirm,
+  isTTY = Boolean(process.stdin.isTTY && process.stdout.isTTY),
+  print = console.log
+} = {}) {
+  const options = parseRoDeleteArgs(args);
+  if (options.help) {
+    print(formatRoDeleteHelp());
+    return null;
+  }
+
+  if (options.json && !options.yes) {
+    throw new Error('--json requires --yes so stdout remains valid JSON.');
+  }
+
+  const deletePreview = await preview({ logworkId: options.logworkId });
+  if (!options.json) {
+    print(deletePreview.summary);
+  }
+
+  let approved = options.yes;
+  if (!approved) {
+    if (!isTTY) {
+      throw new Error('Interactive confirmation is unavailable. Re-run with --yes.');
+    }
+    approved = await promptConfirm(`Delete RO logwork entry ${deletePreview.logworkId}?`);
+  }
+  if (!approved) {
+    print('RO logwork delete cancelled.');
+    return null;
+  }
+
+  const result = await apply({
+    preview: deletePreview,
+    confirm: true
+  });
+  print(options.json ? JSON.stringify(result, null, 2) : result.summary);
+  return result;
+}
+
+export function formatRoDeleteHelp() {
+  return `Usage:
+  logwork delete <logwork-id> [--yes] [--json]
+
+Soft-deletes one Resource Optimiser logwork entry (submitted or approved only).
+The command previews the entry, checks for concurrent changes, then calls DELETE /logwork/entries/:id.
+
+Options:
+  -y, --yes             Delete without interactive confirmation
+  --json                Print structured JSON; requires --yes
+  -h, --help            Show this help`;
+}
+
+async function defaultConfirm(message) {
+  const result = await confirm({
+    message,
+    initialValue: false
+  });
+  return !isCancel(result) && result === true;
+}

package/commands/doctor.mjs

@@ -0,0 +1,24 @@
+import { generateDiagnosticsReport } from '../lib/diagnostics.mjs';
+
+export async function run(args = []) {
+  if (args.includes('--help') || args.includes('-h')) {
+    printHelp();
+    return;
+  }
+  if (args.length) {
+    throw new Error(`Unknown doctor option: ${args[0]}`);
+  }
+
+  const result = await generateDiagnosticsReport();
+  console.log(result.summary);
+  console.log('Send this sanitized file to the developer. Do not send raw curl logs, cookies, passwords, OTPs, or tokens.');
+}
+
+function printHelp() {
+  console.log(`Usage:
+  logwork doctor
+
+Checks your setup and writes a sanitized support report under ~/.logwork-cli/diagnostics.
+The report redacts tokens, cookies, passwords, OTPs, auth codes, and raw HTML.
+`);
+}

package/commands/edit.mjs

@@ -0,0 +1,88 @@
+import { confirm, isCancel } from '@clack/prompts';
+import { parseRoEditArgs } from '../lib/ro-edit-args.mjs';
+import {
+  applyRoLogworkEdit,
+  previewRoLogworkEdit
+} from '../lib/ro-edit-workflow.mjs';
+
+export async function runRoEditCommand(args = [], {
+  preview = previewRoLogworkEdit,
+  apply = applyRoLogworkEdit,
+  promptConfirm = defaultConfirm,
+  isTTY = Boolean(process.stdin.isTTY && process.stdout.isTTY),
+  print = console.log
+} = {}) {
+  const options = parseRoEditArgs(args);
+  if (options.help) {
+    print(formatRoEditHelp());
+    return null;
+  }
+
+  if (options.json && !options.yes) {
+    throw new Error('--json requires --yes so stdout remains valid JSON.');
+  }
+
+  const editPreview = await preview({
+    logworkId: options.logworkId,
+    hours: options.hours,
+    taskName: options.taskName,
+    description: options.description,
+    typeOfWork: options.typeOfWork
+  });
+  if (!options.json) {
+    print(editPreview.summary);
+  }
+
+  let approved = options.yes;
+  if (!approved) {
+    if (!isTTY) {
+      throw new Error('Interactive confirmation is unavailable. Re-run with --yes.');
+    }
+    approved = await promptConfirm(`Apply RO logwork edit ${editPreview.previewId}?`);
+  }
+  if (!approved) {
+    print('RO logwork edit cancelled.');
+    return null;
+  }
+
+  const result = await apply({
+    preview: editPreview,
+    confirm: true
+  });
+  print(options.json ? JSON.stringify(result, null, 2) : result.summary);
+  return result;
+}
+
+export function formatRoEditHelp() {
+  return `Usage:
+  logwork edit <id> [--hours <h>] [--task <task>] [--desc <text>] [--type <type>] [--yes] [--json]
+
+Changes one Resource Optimiser entry. Project and date are preserved. Get the id
+from \`logwork query\`.
+
+RO has no staff edit API, so apply replaces the entry: it creates the corrected
+entry, then deletes the original (the new entry gets a new id and is approved
+immediately). If the delete fails, the new entry is rolled back. Only submitted
+or approved entries can be edited; rejected entries are fixed with resubmit.
+
+Options:
+  --hours <h>      New hours (alias: --logtimes)
+  --task <task>    New worklog task from the project catalog, or #<id> (alias: --task-name)
+  --desc <text>    New description: what you did (alias: --description)
+  --type <type>    New type of work: create, correct, improve, other
+                   (follows the new task's catalog type when the task changes)
+  -y, --yes        Apply without the confirmation prompt
+  --json           Print the result as JSON (requires --yes)
+  -h, --help       Show this help
+
+Example:
+  logwork edit 304032 --task "Bug Fix" --desc "Fix date picker timezone (SAP-42)"`;
+}
+
+async function defaultConfirm(message) {
+  const result = await confirm({
+    message,
+    initialValue: false
+  });
+  return !isCancel(result) && result === true;
+}

package/commands/history.mjs

@@ -0,0 +1,62 @@
+import { queryApplyLedger } from '../lib/apply-ledger.mjs';
+
+export function parseHistoryArgs(args = []) {
+  const options = {
+    target: undefined,
+    limit: 20,
+    json: false
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === '--target') {
+      options.target = args[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === '--limit') {
+      options.limit = Number(args[index + 1]);
+      index += 1;
+      continue;
+    }
+    if (arg === '--json') {
+      options.json = true;
+      continue;
+    }
+    if (arg === '--help' || arg === '-h') {
+      return { help: true };
+    }
+    throw new Error(`Unknown history option: ${arg}`);
+  }
+
+  return options;
+}
+
+export async function runHistoryCommand(args = [], {
+  query = queryApplyLedger,
+  print = console.log
+} = {}) {
+  const options = parseHistoryArgs(args);
+  if (options.help) {
+    printHistoryHelp(print);
+    return null;
+  }
+
+  const result = await query({
+    target: options.target,
+    limit: options.limit
+  });
+  print(options.json ? JSON.stringify(result, null, 2) : result.summary);
+  return result;
+}
+
+function printHistoryHelp(print = console.log) {
+  print(`Usage:
+  logwork history [--target ro|jira|both] [--limit <count>] [--json]
+
+Shows the local apply result ledger. Target both means entries applied from a combined Both flow.`);
+}
+
+async function main() {
+  await runHistoryCommand(process.argv.slice(2));
+}

package/commands/query.mjs

@@ -0,0 +1,52 @@
+import { queryLogwork } from '../lib/query-workflow.mjs';
+import { normalizeReconciliationPeriod } from '../lib/reconciliation-workflow.mjs';
+
+// `logwork query [period] [--json]`: booked vs logged Resource Optimiser hours,
+// with each entry's id, worklog task, description and status.
+export function parseQueryArgs(args = []) {
+  const options = { period: 'today', json: false, help: false };
+  const positional = [];
+  for (const arg of args) {
+    if (arg === '--json') {
+      options.json = true;
+      continue;
+    }
+    if (arg === '--help' || arg === '-h') {
+      options.help = true;
+      continue;
+    }
+    if (arg.startsWith('-')) {
+      throw new Error(`Unknown query option: ${arg}`);
+    }
+    positional.push(arg);
+  }
+  if (positional.length > 1) {
+    throw new Error('Query accepts exactly one preset period.');
+  }
+  if (positional[0]) {
+    options.period = normalizeReconciliationPeriod(positional[0]);
+  }
+  return options;
+}
+
+export async function run(args = [], {
+  query = queryLogwork,
+  print = console.log
+} = {}) {
+  const options = parseQueryArgs(args);
+  if (options.help) {
+    print(formatQueryHelp());
+    return 0;
+  }
+  const result = await query({ period: options.period, includeEntries: true });
+  print(options.json ? JSON.stringify(result, null, 2) : result.summary);
+  return 0;
+}
+
+export function formatQueryHelp() {
+  return `Usage:
+  logwork query [today|yesterday|this-week|last-week|this-month|last-month] [--json]
+
+Shows booked vs logged Resource Optimiser hours per day and project, with each
+entry's id (use it with \`logwork edit\` / \`logwork delete\`). Defaults to today.`;
+}

package/commands/quick.mjs

@@ -0,0 +1,163 @@
+import { intro } from '@clack/prompts';
+import { CONFIG } from '../lib/config.mjs';
+import { getFreshToken, getUserIdFromJwt } from '../lib/auth.mjs';
+import {
+  addLogtime,
+  ApiError,
+  fetchWorklogTasksForProject,
+  getTodayTimesheetProjects
+} from '../lib/api.mjs';
+import * as ui from '../lib/ui.mjs';
+import { todayLocalDateISO } from '../lib/util.mjs';
+
+// `logwork quick [-m "what you did"]`: log one Resource Optimiser entry for
+// today with guided prompts (project -> worklog task -> description -> hours).
+export async function run(argv = []) {
+  const { message, help } = parseQuickArgs(argv);
+  if (help) {
+    console.log(formatQuickHelp());
+    return 0;
+  }
+
+  try {
+    intro('Logwork quick');
+    const result = await runQuickLog({ message });
+    ui.showSuccess(result.dryRun
+      ? 'DRY RUN: payload generated; no API write performed.'
+      : 'Logwork submitted.');
+    return 0;
+  } catch (error) {
+    ui.showError(error);
+    return 1;
+  }
+}
+
+export async function runQuickLog({ message = '' } = {}) {
+  const localDateISO = todayLocalDateISO();
+  let session = await openSession();
+
+  let projects;
+  try {
+    projects = await loadBookedProjects(session, localDateISO);
+  } catch (error) {
+    if (!isUnauthorized(error)) {
+      throw error;
+    }
+    session = await openSession({ forceLogin: true });
+    projects = await loadBookedProjects(session, localDateISO);
+  }
+
+  const daySummaries = projects.map((project) => ({
+    projectId: project.projectId,
+    totalHours: project.loggedHours,
+    ok: true
+  }));
+  const project = await ui.chooseProject(projects, daySummaries);
+  const tasks = (await fetchWorklogTasksForProject(session.token, project.projectId)).map((task) => ({
+    taskId: task.id,
+    name: task.name,
+    typeOfWork: task.typeOfWork || 'other',
+    description: task.description,
+    needsProjectId: task.projectId === null || task.projectId === undefined
+  }));
+  if (!tasks.length) {
+    throw new Error(`No worklog tasks are available for ${project.projectName}.`);
+  }
+  const task = await ui.chooseTask(tasks);
+  const description = await ui.chooseMessageSource(message);
+  const hours = await ui.askHours(CONFIG.defaultHours);
+
+  await ui.confirmSubmit({
+    projectName: project.projectName,
+    hours,
+    taskName: task.name,
+    description,
+    localDateISO
+  });
+
+  const entry = {
+    projectId: project.projectId,
+    projectMemberId: project.projectMemberId,
+    logtimes: hours,
+    taskName: task.name,
+    localDateISO,
+    worklogTaskId: task.taskId,
+    typeOfWork: task.typeOfWork,
+    description,
+    worklogNeedsProjectId: task.needsProjectId
+  };
+
+  try {
+    return await addLogtime(session.token, entry);
+  } catch (error) {
+    if (!isUnauthorized(error)) {
+      throw error;
+    }
+    session = await openSession({ forceLogin: true });
+    return addLogtime(session.token, entry);
+  }
+}
+
+export function parseQuickArgs(argv = []) {
+  let message = '';
+  let help = false;
+  const positional = [];
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--help' || arg === '-h') {
+      help = true;
+      continue;
+    }
+    if (arg === '--message' || arg === '-m') {
+      const value = argv[index + 1];
+      if (!value) {
+        throw new Error(`${arg} requires a value.`);
+      }
+      message = value;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith('--message=')) {
+      message = arg.slice('--message='.length);
+      continue;
+    }
+    positional.push(arg);
+  }
+
+  if (!message && positional.length) {
+    message = positional.join(' ');
+  }
+  return { message, help };
+}
+
+export function formatQuickHelp() {
+  return `Usage:
+  logwork quick
+  logwork quick -m "Fix login bug (SCB-12)"
+  logwork quick "Fix login bug (SCB-12)"
+
+Logs one Resource Optimiser entry for today. You pick a booked project, a worklog
+task and the hours; the message becomes the entry description.
+
+Options:
+  -m, --message <text>  Description to prefill
+  -h, --help            Show this help`;
+}
+
+async function openSession({ forceLogin = false } = {}) {
+  const token = await getFreshToken({ forceLogin });
+  return { token, userId: getUserIdFromJwt(token) };
+}
+
+async function loadBookedProjects(session, localDateISO) {
+  const projects = await getTodayTimesheetProjects(session.token, session.userId, localDateISO);
+  if (!projects.length) {
+    throw new Error(`You have no booked project on ${localDateISO}.`);
+  }
+  return projects;
+}
+
+function isUnauthorized(error) {
+  return error instanceof ApiError && error.status === 401;
+}