@go-labs-sg/bb 1.20.0 → 2.0.0

package/dist/api-client.js

@@ -1,7 +1,18 @@
-import { createTRPCProxyClient, httpBatchLink, loggerLink } from "@trpc/client";
+import { createTRPCProxyClient, httpBatchLink, loggerLink, } from "@trpc/client";
 import SuperJSON from "superjson";
 import { sanitizeValueForTrace, shouldLogCliActions } from "./cli-trace.js";
-const BASE_URL = "https://budget-builder.getout.events";
+export const DEFAULT_BUDGET_BUILDER_API_BASE_URL = "https://budget-builder.getout.events";
+const normalizeApiBaseUrl = (value) => {
+    const url = new URL(value);
+    const isLocalHttp = url.protocol === "http:" &&
+        (url.hostname === "localhost" || url.hostname === "127.0.0.1");
+    if (url.protocol !== "https:" && !isLocalHttp) {
+        throw new Error("Budget Builder API URL must use HTTPS, except for localhost development.");
+    }
+    url.pathname = url.pathname.replace(/\/$/, "");
+    return url.toString().replace(/\/$/, "");
+};
+export let BUDGET_BUILDER_API_BASE_URL = DEFAULT_BUDGET_BUILDER_API_BASE_URL;
 function getAuthHeader() {
     const key = process.env.BB_API_KEY;
     if (!key?.trim())
@@ -17,7 +28,7 @@ const containsRawApiKey = (value, seen = new WeakSet()) => {
     return Object.entries(value).some(([key, nestedValue]) => (key.toLowerCase() === "apikey" && typeof nestedValue === "string") ||
         containsRawApiKey(nestedValue, seen));
 };
-export const api = createTRPCProxyClient({
+export const createBudgetBuilderClient = (apiBaseUrl = BUDGET_BUILDER_API_BASE_URL) => createTRPCProxyClient({
     links: [
         loggerLink({
             enabled: (opts) => shouldLogCliActions() &&
@@ -31,7 +42,7 @@ export const api = createTRPCProxyClient({
             },
         }),
         httpBatchLink({
-            url: `${BASE_URL}/api/trpc`,
+            url: `${apiBaseUrl}/api/trpc`,
             transformer: SuperJSON,
             headers: () => {
                 const headers = {
@@ -45,13 +56,38 @@ export const api = createTRPCProxyClient({
         }),
     ],
 });
+let activeClient = createBudgetBuilderClient();
+export const configureBudgetBuilderApiBaseUrl = (value) => {
+    const normalized = normalizeApiBaseUrl(value);
+    BUDGET_BUILDER_API_BASE_URL = normalized;
+    activeClient = createBudgetBuilderClient(normalized);
+    return normalized;
+};
+/**
+ * Stable facade used by command handlers. Tests can replace the transport without
+ * teaching commands about tRPC or process-wide authentication.
+ */
+export const api = new Proxy({}, {
+    get: (_target, property, receiver) => Reflect.get(activeClient, property, receiver),
+});
+export const setBudgetBuilderClientForTesting = (client) => {
+    const previous = activeClient;
+    activeClient = client;
+    return () => {
+        activeClient = previous;
+    };
+};
+export class MissingApiKeyError extends Error {
+    code = "AUTHENTICATION";
+    constructor() {
+        super("BB_API_KEY is required. Set it in the environment.");
+        this.name = "MissingApiKeyError";
+    }
+}
 export function requireApiKey() {
     const key = process.env.BB_API_KEY?.trim();
     if (!key) {
-        console.error(JSON.stringify({
-            error: "BB_API_KEY is required. Set it in the environment.",
-        }));
-        process.exit(1);
+        throw new MissingApiKeyError();
     }
     return key;
 }

package/dist/cli-trace.js

@@ -29,8 +29,12 @@ const SENSITIVE_TRACE_FIELD = new Set([
     "paymentproofattachments",
     "paymentproofpath",
     "paymentreference",
+    "proof",
     "receipt",
 ]);
+const isPresignedUrl = (value) => typeof value === "string" &&
+    (/[?&]X-Amz-(?:Algorithm|Credential|Signature)=/i.test(value) ||
+        /[?&]X-Goog-(?:Algorithm|Credential|Signature)=/i.test(value));
 export const sanitizeValueForTrace = (value, seen = new WeakSet()) => {
     if (typeof value !== "object" || value === null)
         return value;
@@ -45,7 +49,8 @@ export const sanitizeValueForTrace = (value, seen = new WeakSet()) => {
         return value;
     return Object.fromEntries(Object.entries(value).map(([key, nestedValue]) => [
         key,
-        SENSITIVE_TRACE_FIELD.has(key.toLowerCase())
+        SENSITIVE_TRACE_FIELD.has(key.toLowerCase()) ||
+            isPresignedUrl(nestedValue)
             ? "[redacted]"
             : sanitizeValueForTrace(nestedValue, seen),
     ]));

package/dist/commands.js

@@ -6,9 +6,10 @@ import { contentType } from "mime-types";
 import { api } from "./api-client.js";
 import { BudgetRole, Deals, ExtendedApprovalStatus, ExtendedApprovalType, ExtendedBudgetStatus, TimeFrame, } from "./filter-enums.js";
 import { billStatusesForApi, } from "./parse-cli-enums.js";
-import { parseBudgetDiscountPayload, parseCompanyUpdatePayload, parseContactCreatePayload, parseContactUpdatePayload, parseCreateBillPayload, parseCreateBudgetPayload, parseCreateCustomerInvoicePayload, parseCreateQuotationPayload, parseItemCreatePayload, parseItemUpdatePayload, parseSendEstimateToContactPersonPayload, parseSupplierCreatePayload, parseSupplierUpdatePayload, parseUpdateBillPayload, parseUpdateBillPaymentEvidencePayload, parseUpdateBudgetCommissionPayload, parseUpdateBudgetPayload, parseUpdateProjectPayload, parseUpdateQuotationPayload, parseValidateBillSelectionPayload, } from "./parse-mutation-payload.js";
+import { parseBudgetDiscountPayload, parseCompanyUpdatePayload, parseContactCreatePayload, parseContactUpdatePayload, parseCreateBillPayload, parseCreateBudgetPayload, parseCreateCustomerInvoicePayload, parseCreateQuotationPayload, parseItemCreatePayload, parseItemUpdatePayload, parseSendCustomerInvoiceToContactPersonPayload, parseSendEstimateToContactPersonPayload, parseSupplierCreatePayload, parseSupplierUpdatePayload, parseUpdateBillPayload, parseUpdateBillPaymentEvidencePayload, parseUpdateBudgetCommissionPayload, parseUpdateBudgetPayload, parseUpdateProjectPayload, parseUpdateQuotationPayload, parseValidateBillSelectionPayload, } from "./parse-mutation-payload.js";
 import { BillStatus, BudgetStatus, ProjectStatus } from "./prisma-enums.js";
 import { createRichTextFromPlainText } from "./rich-text.js";
+import { confirmCurrentCommand, emitCommandResult, getActiveCliSession, } from "./runtime/index.js";
 const BUDGET = "BUDGET";
 const BILL = "BILL";
 const SUPPLIER = "SUPPLIER";
@@ -52,7 +53,7 @@ function isPendingRequest(n) {
     return n.notificationType === "request" && n.status === "PENDING_APPROVAL";
 }
 const out = (data) => {
-    console.log(JSON.stringify(data, null, 2));
+    emitCommandResult(data);
 };
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const stringField = (record, key) => {
@@ -263,7 +264,18 @@ const billAttachmentContentTypeForFileName = (fileName) => {
     return resolvedContentType;
 };
 const PAYMENT_PROOF_MAX_SIZE = 20 * 1024 * 1024;
+const CUSTOMER_INVOICE_PAYMENT_PROOF_MAX_SIZE = 20 * 1024 * 1024;
 const QUOTATION_ATTACHMENT_MAX_SIZE = 20 * 1024 * 1024;
+const customerInvoicePaymentProofContentTypeForFileName = (fileName) => {
+    const resolvedContentType = contentTypeHeaderForFileName(fileName);
+    if (resolvedContentType === "application/pdf" ||
+        resolvedContentType === "image/gif" ||
+        resolvedContentType === "image/jpeg" ||
+        resolvedContentType === "image/png") {
+        return resolvedContentType;
+    }
+    throw new Error(`Unsupported customer invoice payment-proof type: ${fileName}. Use PDF, GIF, JPEG, or PNG.`);
+};
 const quotationAttachmentContentTypeForFileName = (fileName) => {
     const resolvedContentType = contentTypeHeaderForFileName(fileName);
     if (resolvedContentType === "application/pdf" ||
@@ -290,18 +302,35 @@ const lockedBudgetStatusLabels = {
 const lockedBudgetStatusLabel = (status) => status in lockedBudgetStatusLabels
     ? lockedBudgetStatusLabels[status]
     : status;
-const assertSensitiveWorkflowConfirmed = async ({ action, entity, details, }) => {
+export const buildSensitiveWorkflowPreview = ({ action, entity, details, }) => {
+    const effects = details ?? "may change workflow state or send notifications";
+    return [
+        "Budget Builder workflow preview",
+        `Action: ${action}`,
+        `Target: ${entity}`,
+        `Effects: ${effects}`,
+    ].join("\n");
+};
+const assertSensitiveWorkflowConfirmed = async (input) => {
+    if (getActiveCliSession()?.invocation.legacy !== true) {
+        await confirmCurrentCommand({
+            action: input.action,
+            target: input.entity,
+            details: input.details,
+        });
+        return;
+    }
     const expected = "CONFIRM";
-    const detailText = details ? ` ${details}` : "";
+    const preview = buildSensitiveWorkflowPreview(input);
     if (!process.stdin.isTTY || !process.stderr.isTTY) {
-        throw new Error(`${action} on ${entity}${detailText} is a sensitive Budget Builder workflow change. Run this command in an interactive terminal after the user explicitly confirms the exact action, then type "${expected}" to continue.`);
+        throw new Error(`${preview}\nThis is a sensitive workflow change. Run it in an interactive terminal only after the user explicitly confirms this exact action, then type "${expected}" to continue.`);
     }
     const rl = createInterface({
         input: process.stdin,
         output: process.stderr,
     });
     try {
-        const answer = await rl.question(`${action} on ${entity}${detailText} may change workflow status, approvals, or send notification emails. Confirm the user explicitly approved this exact action, then type "${expected}" to continue: `);
+        const answer = await rl.question(`${preview}\nConfirm the user explicitly approved this exact action, then type "${expected}" to continue: `);
         if (answer.trim() !== expected) {
             throw new Error("Aborted.");
         }
@@ -315,6 +344,15 @@ const assertLockedBudgetChangeConfirmed = async ({ budget, action, }) => {
         return;
     }
     const statusLabel = lockedBudgetStatusLabel(budget.status);
+    if (getActiveCliSession()?.invocation.legacy !== true) {
+        await confirmCurrentCommand({
+            action,
+            target: `budget ${budget.id}`,
+            details: `Changes locked budget "${budget.name}" in status ${statusLabel}.`,
+            effects: ["state-change"],
+        });
+        return;
+    }
     if (!process.stdin.isTTY || !process.stderr.isTTY) {
         throw new Error(`${action} would change locked budget "${budget.name}" (${budget.id}) with status ${statusLabel}. Run this command in an interactive terminal and type "yes" to confirm.`);
     }
@@ -392,6 +430,9 @@ export async function updateBudgetStatus(budgetId, status, opts) {
         ...(opts?.projectStatusOnCommercialRejection !== undefined && {
             projectStatusOnCommercialRejection: opts.projectStatusOnCommercialRejection,
         }),
+        ...(opts?.projectInvoiceSettings !== undefined && {
+            projectInvoiceSettings: opts.projectInvoiceSettings,
+        }),
     });
     out(result);
 }
@@ -503,7 +544,9 @@ export async function approveBill(billId) {
     }
     let email;
     try {
-        await api.email.sendReplyBillApprovalEmail.mutate(result.updatedApproval);
+        await api.email.sendReplyBillApprovalEmail.mutate({
+            id: result.updatedApproval.id,
+        });
         email = { sent: true };
     }
     catch (error) {
@@ -709,8 +752,8 @@ export async function updateBillStatus(opts) {
     catch (error) {
         await rethrowAfterStagedPaymentProofCleanup(error, bill && paymentProof
             ? async () => {
-                // The cleanup endpoint checks Attachment rows and refuses to delete a key
-                // that an ambiguously successful status update already attached.
+                // The cleanup endpoint checks the staged-upload record and refuses to
+                // delete a key that an ambiguously successful update already consumed.
                 await deleteStagedPaymentProof(bill.projectId, paymentProof.key);
             }
             : undefined);
@@ -867,6 +910,8 @@ export async function uploadQuotationAttachmentFromPath(projectId, filePath) {
     const key = `quotations/${projectId}/${randomUUID()}.${ext || "pdf"}`;
     const uploadUrl = await api.attachment.getPresignedUrlToUpload.mutate({
         key,
+        size: buf.byteLength,
+        contentType: attachmentContentType,
     });
     const res = await fetch(uploadUrl, {
         method: "PUT",
@@ -958,6 +1003,9 @@ export async function uploadBudgetWinProofFromPath(budgetId, filePath, opts) {
         ...(opts?.markProjectWon !== undefined && {
             markProjectWon: opts.markProjectWon,
         }),
+        ...(opts?.projectInvoiceSettings !== undefined && {
+            projectInvoiceSettings: opts.projectInvoiceSettings,
+        }),
     });
     out(result);
 }
@@ -1278,19 +1326,31 @@ export const checkCustomerInvoiceReadiness = async (budgetId) => {
     out(result);
 };
 export const listCustomerInvoices = async (input) => {
-    const result = await api.customerInvoice.listByBudget.query(input);
+    const result = await api.customerInvoice.list.query(input);
+    out(result);
+};
+export const listEligibleCustomerInvoiceBudgets = async (projectId) => {
+    const result = await api.customerInvoice.getEligibleBudgets.query({
+        projectId,
+    });
     out(result);
 };
 export const getCustomerInvoice = async (batchId) => {
     const result = await api.customerInvoice.getInvoiceDetail.query({ batchId });
     out(result);
 };
+export const getCustomerInvoiceEmailContext = async (batchId) => {
+    const result = await api.customerInvoice.getInvoiceEmailContext.query({
+        batchId,
+    });
+    out(result);
+};
 export const createCustomerInvoice = async (raw) => {
     const input = parseCreateCustomerInvoicePayload(raw);
     await assertSensitiveWorkflowConfirmed({
         action: "Create customer invoice",
         entity: `budget ${input.budgetId}`,
-        details: "create the invoice in QuickBooks and either approve it as admin or send approval-request emails",
+        details: "creates one invoice in QuickBooks; admin-created invoices are approved immediately, while other invoices request approval; approved cumulative coverage of 100% closes the QuickBooks estimate",
     });
     const result = await api.customerInvoice.createInvoiceBatch.mutate(input);
     out(result);
@@ -1299,6 +1359,7 @@ export const discardCreatingCustomerInvoice = async (batchId) => {
     await assertSensitiveWorkflowConfirmed({
         action: "Discard unfinished customer invoice",
         entity: `invoice batch ${batchId}`,
+        details: "removes only a reserved CREATING batch that has no invoice created in QuickBooks",
     });
     const result = await api.customerInvoice.discardCreatingInvoiceBatch.mutate({
         batchId,
@@ -1309,7 +1370,7 @@ export const deleteCustomerInvoice = async (batchId) => {
     await assertSensitiveWorkflowConfirmed({
         action: "Delete customer invoice",
         entity: `invoice batch ${batchId}`,
-        details: "delete its invoices from QuickBooks and remove the local batch",
+        details: "deletes its invoices from QuickBooks and removes the local batch; paid invoices are blocked until their QBO payments are reversed; removing approved coverage may reopen the estimate",
     });
     const result = await api.customerInvoice.deleteInvoiceBatch.mutate({
         batchId,
@@ -1320,7 +1381,7 @@ export const voidCustomerInvoice = async (batchId) => {
     await assertSensitiveWorkflowConfirmed({
         action: "Void customer invoice",
         entity: `invoice batch ${batchId}`,
-        details: "void its invoices in QuickBooks",
+        details: "voids its invoices in QuickBooks and updates Budget Builder; paid invoices are blocked until their QBO payments are reversed; removing approved coverage may reopen the estimate",
     });
     const result = await api.customerInvoice.voidInvoiceBatch.mutate({ batchId });
     out(result);
@@ -1329,7 +1390,7 @@ export const approveCustomerInvoice = async (batchId) => {
     await assertSensitiveWorkflowConfirmed({
         action: "Approve customer invoice",
         entity: `invoice batch ${batchId}`,
-        details: "and notify its creator",
+        details: "approves the batch and notifies its creator; voided invoices cannot be approved; cumulative approved coverage of 100% closes the QuickBooks estimate",
     });
     const result = await api.customerInvoice.approveInvoiceBatch.mutate({
         batchId,
@@ -1340,7 +1401,7 @@ export const rejectCustomerInvoice = async (batchId, rejectionReason) => {
     await assertSensitiveWorkflowConfirmed({
         action: "Reject customer invoice",
         entity: `invoice batch ${batchId}`,
-        details: `with reason "${rejectionReason}", void it in QuickBooks, and notify its creator`,
+        details: `records the rejection reason, voids it in QuickBooks, notifies its creator, and reopens a prematurely closed estimate when applicable`,
     });
     const result = await api.customerInvoice.rejectInvoiceBatch.mutate({
         batchId,
@@ -1364,13 +1425,104 @@ export const syncCustomerInvoice = async (invoiceId) => {
     await assertSensitiveWorkflowConfirmed({
         action: "Sync customer invoice from QuickBooks",
         entity: `invoice ${invoiceId}`,
-        details: "and update its local status, QuickBooks metadata, balance, and history",
+        details: "refreshes local status, QuickBooks metadata, balance, and history; QBO Paid or a zero balance becomes PAID, a reversed payment restores the delivery or approval status, and a QBO void becomes VOIDED",
     });
     const result = await api.customerInvoice.syncInvoiceStatus.mutate({
         invoiceId,
     });
     out(result);
 };
+export const describeCustomerInvoiceEmailConfirmation = (input) => `emails the QBO invoice PDF to ${input.to}; requested CC ${input.cc.length > 0 ? input.cc.join(", ") : "none"}; reply-to ${input.replyTo}; subject "${input.subject}"; server-required admin, creator, business-development, and inside-sales CC recipients are added; success marks the invoice SENT; do not retry blindly after an ambiguous delivery failure`;
+export const sendCustomerInvoiceToContactPersonFromPayload = async (raw) => {
+    const input = parseSendCustomerInvoiceToContactPersonPayload(raw);
+    await assertSensitiveWorkflowConfirmed({
+        action: "Send customer invoice email",
+        entity: `invoice ${input.invoiceId}`,
+        details: describeCustomerInvoiceEmailConfirmation(input),
+    });
+    const result = await api.customerInvoice.sendInvoiceToContactPerson.mutate(input);
+    out(result);
+};
+export const describeCustomerInvoicePaymentConfirmation = ({ invoiceId, paymentDate, paymentReference, proofFileName, proofSize, }) => `for invoice ${invoiceId}, records payment date ${paymentDate}${paymentReference
+    ? " with a payment reference"
+    : " without a payment reference"}; uploads ${proofFileName} (${proofSize} bytes); creates a QuickBooks Payment for the live outstanding balance when non-zero, attaches the proof to QBO when possible, and records the payment in Budget Builder`;
+const assertPaymentDate = (paymentDate) => {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(paymentDate)) {
+        throw new Error("--paymentDate must use YYYY-MM-DD.");
+    }
+    const parsed = new Date(`${paymentDate}T00:00:00.000Z`);
+    if (Number.isNaN(parsed.getTime()) ||
+        parsed.toISOString().slice(0, 10) !== paymentDate) {
+        throw new Error("--paymentDate must be a valid calendar date.");
+    }
+    return paymentDate;
+};
+export const markCustomerInvoicePaidFromPath = async ({ invoiceId, paymentDate, paymentProofPath, paymentReference, }) => {
+    const normalizedPaymentDate = assertPaymentDate(paymentDate);
+    const proofContents = await readFile(paymentProofPath);
+    const proofFileName = basename(paymentProofPath);
+    if (proofContents.byteLength === 0) {
+        throw new Error("Customer invoice payment proof must not be empty.");
+    }
+    if (proofContents.byteLength > CUSTOMER_INVOICE_PAYMENT_PROOF_MAX_SIZE) {
+        throw new Error("Customer invoice payment proof must be 20MB or smaller.");
+    }
+    const proofContentType = customerInvoicePaymentProofContentTypeForFileName(proofFileName);
+    await assertSensitiveWorkflowConfirmed({
+        action: "Mark customer invoice paid",
+        entity: `invoice ${invoiceId}`,
+        details: describeCustomerInvoicePaymentConfirmation({
+            invoiceId,
+            paymentDate: normalizedPaymentDate,
+            paymentReference,
+            proofFileName,
+            proofSize: proofContents.byteLength,
+        }),
+    });
+    const proofUpload = await api.customerInvoice.requestPaymentProofUpload.mutate({
+        invoiceId,
+        fileName: proofFileName,
+        size: proofContents.byteLength,
+        contentType: proofContentType,
+    });
+    const uploadResponse = await fetch(proofUpload.uploadUrl, {
+        method: "PUT",
+        body: proofContents,
+        headers: { "Content-Type": proofUpload.contentType },
+    });
+    if (!uploadResponse.ok) {
+        throw new Error(`Payment-proof upload failed: HTTP ${uploadResponse.status} ${(await uploadResponse.text()).slice(0, 500)}`);
+    }
+    const result = await api.customerInvoice.markPaid.mutate({
+        invoiceId,
+        paymentDate: normalizedPaymentDate,
+        paymentReference,
+        proof: {
+            key: proofUpload.key,
+            name: proofUpload.name,
+            size: proofContents.byteLength,
+            contentType: proofUpload.contentType,
+        },
+    });
+    out(result);
+};
+export const downloadCustomerInvoicePaymentProof = async (invoiceId, outputPath) => {
+    const proof = await api.customerInvoice.getPaymentProofDownloadUrl.mutate({
+        invoiceId,
+    });
+    const response = await fetch(proof.url);
+    if (!response.ok) {
+        throw new Error(`Payment-proof download failed: HTTP ${response.status} ${(await response.text()).slice(0, 500)}`);
+    }
+    const contents = Buffer.from(await response.arrayBuffer());
+    const resolvedOutputPath = outputPath?.trim() || basename(proof.fileName);
+    await writeFile(resolvedOutputPath, contents);
+    out({
+        fileName: proof.fileName,
+        outputPath: resolvedOutputPath,
+        size: contents.byteLength,
+    });
+};
 export async function updateBillFromPayload(raw) {
     const input = parseUpdateBillPayload(raw);
     const result = await api.bill.update.mutate(input);
@@ -1539,7 +1691,9 @@ export async function approveBudget(budgetId) {
     });
     let email;
     try {
-        await api.email.sendReplyApprovalEmail.mutate(result.updatedApproval);
+        await api.email.sendReplyApprovalEmail.mutate({
+            id: result.updatedApproval.id,
+        });
         email = { sent: true };
     }
     catch (error) {
@@ -1576,7 +1730,9 @@ export async function rejectBudget(budgetId, reason) {
     });
     let email;
     try {
-        await api.email.sendReplyApprovalEmail.mutate(result.updatedApproval);
+        await api.email.sendReplyApprovalEmail.mutate({
+            id: result.updatedApproval.id,
+        });
         email = { sent: true };
     }
     catch (error) {
@@ -1673,8 +1829,7 @@ export async function approveSupplier(supplierId) {
     let email;
     try {
         await api.email.sendReplySupplierApprovalEmail.mutate({
-            ...result.updatedApproval,
-            rejectionReason: result.updatedApproval.rejectionReason ?? undefined,
+            id: result.updatedApproval.id,
         });
         email = { sent: true };
     }
@@ -1712,8 +1867,7 @@ export async function rejectSupplier(supplierId, reason) {
     let email;
     try {
         await api.email.sendReplySupplierApprovalEmail.mutate({
-            ...result.updatedApproval,
-            rejectionReason: result.updatedApproval.rejectionReason ?? undefined,
+            id: result.updatedApproval.id,
         });
         email = { sent: true };
     }
@@ -1754,7 +1908,9 @@ export async function rejectBill(billId, reason) {
     }
     let email;
     try {
-        await api.email.sendReplyBillApprovalEmail.mutate(result.updatedApproval);
+        await api.email.sendReplyBillApprovalEmail.mutate({
+            id: result.updatedApproval.id,
+        });
         email = { sent: true };
     }
     catch (error) {
@@ -1995,6 +2151,10 @@ export async function listUsers() {
     const users = await api.user.getAllUsers.query();
     out(users);
 }
+export async function whoAmI() {
+    const user = await api.user.getCurrentUser.query();
+    out(user);
+}
 export async function getUserPerformance(userId) {
     const result = await api.dashboard.getUserPerformance.query({ userId });
     out(result);