ccusage 11.0.2 → 12.0.0

package/dist/index.js

@@ -1,14 +1,15 @@
 #!/usr/bin/env node
-import { CostModes, SortOrders, __commonJSMin, __require, __toESM, dateSchema } from "./pricing-fetcher-DDs53oR8.js";
+import { CostModes, SortOrders, __commonJSMin, __require, __toESM, dateSchema } from "./pricing-fetcher-3m6_Ejp8.js";
 import { calculateTotals, createTotalsObject, getTotalTokens } from "./calculate-cost-D3IraeGW.js";
-import { DEFAULT_SESSION_DURATION_HOURS, calculateBurnRate, filterRecentBlocks, formatDateCompact, getDefaultClaudePath, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, projectBlockUsage } from "./data-loader-B2EwZ_7B.js";
-import { safeParse } from "./dist-DCvt9hEv.js";
-import { description, log, logger, name, version } from "./logger-DPEwxrOW.js";
-import { detectMismatches, printMismatchReport } from "./debug-D4Ka6IrY.js";
-import "./types-5-VF7WcO.js";
-import { createMcpServer } from "./mcp-CklIto13.js";
-import "./index-CISmcbXk-DpuCarFe.js";
+import { DEFAULT_SESSION_DURATION_HOURS, calculateBurnRate, filterRecentBlocks, formatDateCompact, getDefaultClaudePath, loadDailyUsageData, loadMonthlyUsageData, loadSessionBlockData, loadSessionData, projectBlockUsage } from "./data-loader-rsgRy-no.js";
+import { description, log, logger, name, version } from "./logger-CTFDCX5W.js";
+import { detectMismatches, printMismatchReport } from "./debug-BhnEVNbA.js";
+import { createMcpHttpApp, createMcpServer, startMcpServerStdio } from "./mcp-Cg5potQX.js";
 import process$1 from "node:process";
+import { createServer } from "http";
+import { Http2ServerRequest } from "http2";
+import { Readable } from "stream";
+import crypto from "crypto";
 /**
 * The default locale string, which format is BCP 47 language tag.
 */
@@ -1190,9 +1191,9 @@ var require_picocolors = __commonJSMin((exports, module) => {
 * @throws TypeError if date format is invalid
 */
 function parseDateArg(value) {
-	const result = safeParse(dateSchema, value);
-	if (!result.success) throw new TypeError(result.issues[0].message);
-	return result.output;
+	const result = dateSchema.safeParse(value);
+	if (!result.success) throw new TypeError(result.error.issues[0]?.message ?? "Invalid date format");
+	return result.data;
 }
 /**
 * Shared command line arguments used across multiple CLI commands
@@ -3253,7 +3254,7 @@ const blocksCommand = define({
 					id: block.id,
 					startTime: block.startTime.toISOString(),
 					endTime: block.endTime.toISOString(),
-					actualEndTime: block.actualEndTime != null ? block.actualEndTime.toISOString() : null,
+					actualEndTime: block.actualEndTime?.toISOString() ?? null,
 					isActive: block.isActive,
 					isGap: block.isGap ?? false,
 					entries: block.entries.length,
@@ -3522,9 +3523,378 @@ const dailyCommand = define({
 		}
 	}
 });
+var RequestError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "RequestError";
+	}
+};
+var toRequestError = (e) => {
+	if (e instanceof RequestError) return e;
+	return new RequestError(e.message, { cause: e });
+};
+var GlobalRequest = global.Request;
+var Request = class extends GlobalRequest {
+	constructor(input, options) {
+		if (typeof input === "object" && getRequestCache in input) input = input[getRequestCache]();
+		if (typeof options?.body?.getReader !== "undefined") options.duplex ??= "half";
+		super(input, options);
+	}
+};
+var newRequestFromIncoming = (method, url, incoming, abortController) => {
+	const headerRecord = [];
+	const rawHeaders = incoming.rawHeaders;
+	for (let i = 0; i < rawHeaders.length; i += 2) {
+		const { [i]: key, [i + 1]: value } = rawHeaders;
+		if (key.charCodeAt(0) !== 58) headerRecord.push([key, value]);
+	}
+	const init$1 = {
+		method,
+		headers: headerRecord,
+		signal: abortController.signal
+	};
+	if (method === "TRACE") {
+		init$1.method = "GET";
+		const req = new Request(url, init$1);
+		Object.defineProperty(req, "method", { get() {
+			return "TRACE";
+		} });
+		return req;
+	}
+	if (!(method === "GET" || method === "HEAD")) if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) init$1.body = new ReadableStream({ start(controller) {
+		controller.enqueue(incoming.rawBody);
+		controller.close();
+	} });
+	else init$1.body = Readable.toWeb(incoming);
+	return new Request(url, init$1);
+};
+var getRequestCache = Symbol("getRequestCache");
+var requestCache = Symbol("requestCache");
+var incomingKey = Symbol("incomingKey");
+var urlKey = Symbol("urlKey");
+var abortControllerKey = Symbol("abortControllerKey");
+var getAbortController = Symbol("getAbortController");
+var requestPrototype = {
+	get method() {
+		return this[incomingKey].method || "GET";
+	},
+	get url() {
+		return this[urlKey];
+	},
+	[getAbortController]() {
+		this[getRequestCache]();
+		return this[abortControllerKey];
+	},
+	[getRequestCache]() {
+		this[abortControllerKey] ||= new AbortController();
+		return this[requestCache] ||= newRequestFromIncoming(this.method, this[urlKey], this[incomingKey], this[abortControllerKey]);
+	}
+};
+[
+	"body",
+	"bodyUsed",
+	"cache",
+	"credentials",
+	"destination",
+	"headers",
+	"integrity",
+	"mode",
+	"redirect",
+	"referrer",
+	"referrerPolicy",
+	"signal",
+	"keepalive"
+].forEach((k) => {
+	Object.defineProperty(requestPrototype, k, { get() {
+		return this[getRequestCache]()[k];
+	} });
+});
+[
+	"arrayBuffer",
+	"blob",
+	"clone",
+	"formData",
+	"json",
+	"text"
+].forEach((k) => {
+	Object.defineProperty(requestPrototype, k, { value: function() {
+		return this[getRequestCache]()[k]();
+	} });
+});
+Object.setPrototypeOf(requestPrototype, Request.prototype);
+var newRequest = (incoming, defaultHostname) => {
+	const req = Object.create(requestPrototype);
+	req[incomingKey] = incoming;
+	const incomingUrl = incoming.url || "";
+	if (incomingUrl[0] !== "/" && (incomingUrl.startsWith("http://") || incomingUrl.startsWith("https://"))) {
+		if (incoming instanceof Http2ServerRequest) throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
+		try {
+			const url2 = new URL(incomingUrl);
+			req[urlKey] = url2.href;
+		} catch (e) {
+			throw new RequestError("Invalid absolute URL", { cause: e });
+		}
+		return req;
+	}
+	const host = (incoming instanceof Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
+	if (!host) throw new RequestError("Missing host header");
+	let scheme;
+	if (incoming instanceof Http2ServerRequest) {
+		scheme = incoming.scheme;
+		if (!(scheme === "http" || scheme === "https")) throw new RequestError("Unsupported scheme");
+	} else scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
+	const url = new URL(`${scheme}://${host}${incomingUrl}`);
+	if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) throw new RequestError("Invalid host header");
+	req[urlKey] = url.href;
+	return req;
+};
+var responseCache = Symbol("responseCache");
+var getResponseCache = Symbol("getResponseCache");
+var cacheKey = Symbol("cache");
+var GlobalResponse = global.Response;
+var Response2 = class _Response {
+	#body;
+	#init;
+	[getResponseCache]() {
+		delete this[cacheKey];
+		return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
+	}
+	constructor(body, init$1) {
+		let headers;
+		this.#body = body;
+		if (init$1 instanceof _Response) {
+			const cachedGlobalResponse = init$1[responseCache];
+			if (cachedGlobalResponse) {
+				this.#init = cachedGlobalResponse;
+				this[getResponseCache]();
+				return;
+			} else {
+				this.#init = init$1.#init;
+				headers = new Headers(init$1.#init.headers);
+			}
+		} else this.#init = init$1;
+		if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) {
+			headers ||= init$1?.headers || { "content-type": "text/plain; charset=UTF-8" };
+			this[cacheKey] = [
+				init$1?.status || 200,
+				body,
+				headers
+			];
+		}
+	}
+	get headers() {
+		const cache = this[cacheKey];
+		if (cache) {
+			if (!(cache[2] instanceof Headers)) cache[2] = new Headers(cache[2]);
+			return cache[2];
+		}
+		return this[getResponseCache]().headers;
+	}
+	get status() {
+		return this[cacheKey]?.[0] ?? this[getResponseCache]().status;
+	}
+	get ok() {
+		const status = this.status;
+		return status >= 200 && status < 300;
+	}
+};
+[
+	"body",
+	"bodyUsed",
+	"redirected",
+	"statusText",
+	"trailers",
+	"type",
+	"url"
+].forEach((k) => {
+	Object.defineProperty(Response2.prototype, k, { get() {
+		return this[getResponseCache]()[k];
+	} });
+});
+[
+	"arrayBuffer",
+	"blob",
+	"clone",
+	"formData",
+	"json",
+	"text"
+].forEach((k) => {
+	Object.defineProperty(Response2.prototype, k, { value: function() {
+		return this[getResponseCache]()[k]();
+	} });
+});
+Object.setPrototypeOf(Response2, GlobalResponse);
+Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
+function writeFromReadableStream(stream, writable) {
+	if (stream.locked) throw new TypeError("ReadableStream is locked.");
+	else if (writable.destroyed) {
+		stream.cancel();
+		return;
+	}
+	const reader = stream.getReader();
+	writable.on("close", cancel);
+	writable.on("error", cancel);
+	reader.read().then(flow, cancel);
+	return reader.closed.finally(() => {
+		writable.off("close", cancel);
+		writable.off("error", cancel);
+	});
+	function cancel(error) {
+		reader.cancel(error).catch(() => {});
+		if (error) writable.destroy(error);
+	}
+	function onDrain() {
+		reader.read().then(flow, cancel);
+	}
+	function flow({ done, value }) {
+		try {
+			if (done) writable.end();
+			else if (!writable.write(value)) writable.once("drain", onDrain);
+			else return reader.read().then(flow, cancel);
+		} catch (e) {
+			cancel(e);
+		}
+	}
+}
+var buildOutgoingHttpHeaders = (headers) => {
+	const res = {};
+	if (!(headers instanceof Headers)) headers = new Headers(headers ?? void 0);
+	const cookies = [];
+	for (const [k, v] of headers) if (k === "set-cookie") cookies.push(v);
+	else res[k] = v;
+	if (cookies.length > 0) res["set-cookie"] = cookies;
+	res["content-type"] ??= "text/plain; charset=UTF-8";
+	return res;
+};
+var X_ALREADY_SENT = "x-hono-already-sent";
+var webFetch = global.fetch;
+if (typeof global.crypto === "undefined") global.crypto = crypto;
+global.fetch = (info$1, init$1) => {
+	init$1 = {
+		compress: false,
+		...init$1
+	};
+	return webFetch(info$1, init$1);
+};
+var regBuffer = /^no$/i;
+var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
+var handleRequestError = () => new Response(null, { status: 400 });
+var handleFetchError = (e) => new Response(null, { status: e instanceof Error && (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") ? 504 : 500 });
+var handleResponseError = (e, outgoing) => {
+	const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
+	if (err.code === "ERR_STREAM_PREMATURE_CLOSE") console.info("The user aborted a request.");
+	else {
+		console.error(e);
+		if (!outgoing.headersSent) outgoing.writeHead(500, { "Content-Type": "text/plain" });
+		outgoing.end(`Error: ${err.message}`);
+		outgoing.destroy(err);
+	}
+};
+var flushHeaders = (outgoing) => {
+	if ("flushHeaders" in outgoing && outgoing.writable) outgoing.flushHeaders();
+};
+var responseViaCache = async (res, outgoing) => {
+	let [status, body, header] = res[cacheKey];
+	if (header instanceof Headers) header = buildOutgoingHttpHeaders(header);
+	if (typeof body === "string") header["Content-Length"] = Buffer.byteLength(body);
+	else if (body instanceof Uint8Array) header["Content-Length"] = body.byteLength;
+	else if (body instanceof Blob) header["Content-Length"] = body.size;
+	outgoing.writeHead(status, header);
+	if (typeof body === "string" || body instanceof Uint8Array) outgoing.end(body);
+	else if (body instanceof Blob) outgoing.end(new Uint8Array(await body.arrayBuffer()));
+	else {
+		flushHeaders(outgoing);
+		return writeFromReadableStream(body, outgoing)?.catch((e) => handleResponseError(e, outgoing));
+	}
+};
+var responseViaResponseObject = async (res, outgoing, options = {}) => {
+	if (res instanceof Promise) if (options.errorHandler) try {
+		res = await res;
+	} catch (err) {
+		const errRes = await options.errorHandler(err);
+		if (!errRes) return;
+		res = errRes;
+	}
+	else res = await res.catch(handleFetchError);
+	if (cacheKey in res) return responseViaCache(res, outgoing);
+	const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
+	if (res.body) {
+		const { "transfer-encoding": transferEncoding, "content-encoding": contentEncoding, "content-length": contentLength, "x-accel-buffering": accelBuffering, "content-type": contentType } = resHeaderRecord;
+		if (transferEncoding || contentEncoding || contentLength || accelBuffering && regBuffer.test(accelBuffering) || !regContentType.test(contentType)) {
+			outgoing.writeHead(res.status, resHeaderRecord);
+			flushHeaders(outgoing);
+			await writeFromReadableStream(res.body, outgoing);
+		} else {
+			const buffer = await res.arrayBuffer();
+			resHeaderRecord["content-length"] = buffer.byteLength;
+			outgoing.writeHead(res.status, resHeaderRecord);
+			outgoing.end(new Uint8Array(buffer));
+		}
+	} else if (resHeaderRecord[X_ALREADY_SENT]) {} else {
+		outgoing.writeHead(res.status, resHeaderRecord);
+		outgoing.end();
+	}
+};
+var getRequestListener = (fetchCallback, options = {}) => {
+	if (options.overrideGlobalObjects !== false && global.Request !== Request) {
+		Object.defineProperty(global, "Request", { value: Request });
+		Object.defineProperty(global, "Response", { value: Response2 });
+	}
+	return async (incoming, outgoing) => {
+		let res, req;
+		try {
+			req = newRequest(incoming, options.hostname);
+			outgoing.on("close", () => {
+				const abortController = req[abortControllerKey];
+				if (!abortController) return;
+				if (incoming.errored) req[abortControllerKey].abort(incoming.errored.toString());
+				else if (!outgoing.writableFinished) req[abortControllerKey].abort("Client connection prematurely closed.");
+			});
+			res = fetchCallback(req, {
+				incoming,
+				outgoing
+			});
+			if (cacheKey in res) return responseViaCache(res, outgoing);
+		} catch (e) {
+			if (!res) if (options.errorHandler) {
+				res = await options.errorHandler(req ? e : toRequestError(e));
+				if (!res) return;
+			} else if (!req) res = handleRequestError();
+			else res = handleFetchError(e);
+			else return handleResponseError(e, outgoing);
+		}
+		try {
+			return await responseViaResponseObject(res, outgoing, options);
+		} catch (e) {
+			return handleResponseError(e, outgoing);
+		}
+	};
+};
+var createAdaptorServer = (options) => {
+	const fetchCallback = options.fetch;
+	const requestListener = getRequestListener(fetchCallback, {
+		hostname: options.hostname,
+		overrideGlobalObjects: options.overrideGlobalObjects
+	});
+	const createServer$1 = options.createServer || createServer;
+	const server = createServer$1(options.serverOptions || {}, requestListener);
+	return server;
+};
+var serve = (options, listeningListener) => {
+	const server = createAdaptorServer(options);
+	server.listen(options?.port ?? 3e3, options.hostname, () => {
+		const serverInfo = server.address();
+		listeningListener && listeningListener(serverInfo);
+	});
+	return server;
+};
+/**
+* MCP server command that supports both stdio and HTTP transports.
+* Allows starting an MCP server for external integrations with usage reporting tools.
+*/
 const mcpCommand = define({
 	name: "mcp",
-	description: "Show usage report for MCP",
+	description: "Start MCP server with usage reporting tools",
 	args: {
 		mode: sharedArgs.mode,
 		type: {
@@ -3543,14 +3913,21 @@ const mcpCommand = define({
 	async run(ctx) {
 		const { type, mode, port } = ctx.values;
 		if (type === "stdio") logger.level = 0;
-		const server = createMcpServer({
+		const options = {
 			claudePath: getDefaultClaudePath(),
 			mode
-		});
-		await server.start(ctx.values.type === "http" ? {
-			transportType: "httpStream",
-			httpStream: { port }
-		} : { transportType: "stdio" });
+		};
+		if (type === "stdio") {
+			const server = createMcpServer(options);
+			await startMcpServerStdio(server);
+		} else {
+			const app = createMcpHttpApp(options);
+			serve({
+				fetch: app.fetch,
+				port
+			});
+			logger.info(`MCP server is running on http://localhost:${port}`);
+		}
 	}
 });
 var import_picocolors$1 = __toESM(require_picocolors(), 1);

package/dist/{logger-DPEwxrOW.js → logger-CTFDCX5W.js}

@@ -938,7 +938,7 @@ function createConsola$1(options = {}) {
 		defaults: { level },
 		stdout: process.stdout,
 		stderr: process.stderr,
-		prompt: (...args) => import("./prompt-CUbwSrjo.js").then((m) => m.prompt(...args)),
+		prompt: (...args) => import("./prompt-E8j7mEMw.js").then((m) => m.prompt(...args)),
 		reporters: options.reporters || [options.fancy ?? !(T || R) ? new FancyReporter() : new BasicReporter()],
 		...options
 	});
@@ -951,7 +951,7 @@ function _getDefaultLogLevel() {
 }
 const consola = createConsola$1();
 var name = "ccusage";
-var version = "11.0.2";
+var version = "12.0.0";
 var description = "Usage analysis tool for Claude Code";
 /**
 * Application logger instance with package name tag

package/dist/logger.js

@@ -1,2 +1,2 @@
-import { log, logger } from "./logger-DPEwxrOW.js";
+import { log, logger } from "./logger-CTFDCX5W.js";
 export { log, logger };