@agentorg/cli 0.0.1 → 0.0.3

package/node_modules/hono/dist/middleware/language/language.js

@@ -1,198 +0,0 @@
-import { getCookie, setCookie } from "../../helper/cookie/index.js";
-import { parseAccept } from "../../utils/accept.js";
-//#region src/middleware/language/language.ts
-const DEFAULT_OPTIONS = {
-	order: [
-		"querystring",
-		"cookie",
-		"header"
-	],
-	lookupQueryString: "lang",
-	lookupCookie: "language",
-	lookupFromHeaderKey: "accept-language",
-	lookupFromPathIndex: 0,
-	caches: ["cookie"],
-	ignoreCase: true,
-	fallbackLanguage: "en",
-	supportedLanguages: ["en"],
-	cookieOptions: {
-		sameSite: "Strict",
-		secure: true,
-		maxAge: 31536e3,
-		httpOnly: true
-	},
-	debug: false
-};
-/**
-* Parse Accept-Language header values with quality scores
-* @param header Accept-Language header string
-* @returns Array of parsed languages with quality scores
-*/
-function parseAcceptLanguage(header) {
-	return parseAccept(header).map(({ type, q }) => ({
-		lang: type,
-		q
-	}));
-}
-/**
-* Validate and normalize language codes
-* @param lang Language code to normalize
-* @param options Detector options
-* @returns Normalized language code or undefined
-*/
-const normalizeLanguage = (lang, options) => {
-	if (!lang) return;
-	try {
-		let normalizedLang = lang.trim();
-		if (options.convertDetectedLanguage) normalizedLang = options.convertDetectedLanguage(normalizedLang);
-		const compLang = options.ignoreCase ? normalizedLang.toLowerCase() : normalizedLang;
-		const compSupported = options.supportedLanguages.map((l) => options.ignoreCase ? l.toLowerCase() : l);
-		const exactIndex = compSupported.indexOf(compLang);
-		if (exactIndex !== -1) return options.supportedLanguages[exactIndex];
-		let longestMatchIndex = -1;
-		let longestMatchLength = -1;
-		for (let i = 0; i < compSupported.length; i++) {
-			const candidate = compSupported[i];
-			if (candidate.length < compLang.length && candidate.length > longestMatchLength && compLang.startsWith(candidate) && compLang[candidate.length] === "-") {
-				longestMatchIndex = i;
-				longestMatchLength = candidate.length;
-			}
-		}
-		if (longestMatchIndex !== -1) return options.supportedLanguages[longestMatchIndex];
-		return;
-	} catch {
-		return;
-	}
-};
-/**
-* Detects language from query parameter
-*/
-const detectFromQuery = (c, options) => {
-	const query = c.req.query(options.lookupQueryString);
-	return normalizeLanguage(query, options);
-};
-/**
-* Detects language from cookie
-*/
-const detectFromCookie = (c, options) => {
-	const cookie = getCookie(c, options.lookupCookie);
-	return normalizeLanguage(cookie, options);
-};
-/**
-* Detects language from Accept-Language header
-*/
-function detectFromHeader(c, options) {
-	try {
-		const acceptLanguage = c.req.header(options.lookupFromHeaderKey);
-		if (!acceptLanguage) return;
-		const languages = parseAcceptLanguage(acceptLanguage);
-		for (const { lang, q } of languages) {
-			if (q === 0) continue;
-			const normalizedLang = normalizeLanguage(lang, options);
-			if (normalizedLang) return normalizedLang;
-		}
-		return;
-	} catch {
-		return;
-	}
-}
-/**
-* Detects language from URL path
-*/
-function detectFromPath(c, options) {
-	const langSegment = new URL(c.req.url).pathname.split("/").filter(Boolean)[options.lookupFromPathIndex];
-	return normalizeLanguage(langSegment, options);
-}
-/**
-* Collection of all language detection strategies
-*/
-const detectors = {
-	querystring: detectFromQuery,
-	cookie: detectFromCookie,
-	header: detectFromHeader,
-	path: detectFromPath
-};
-/**
-* Validate detector options
-* @param options Detector options to validate
-* @throws Error if options are invalid
-*/
-function validateOptions(options) {
-	if (!options.supportedLanguages.includes(options.fallbackLanguage)) throw new Error("Fallback language must be included in supported languages");
-	if (options.lookupFromPathIndex < 0) throw new Error("Path index must be non-negative");
-	if (!options.order.every((detector) => Object.keys(detectors).includes(detector))) throw new Error("Invalid detector type in order array");
-}
-/**
-* Cache detected language
-*/
-function cacheLanguage(c, language, options) {
-	if (!Array.isArray(options.caches) || !options.caches.includes("cookie")) return;
-	try {
-		setCookie(c, options.lookupCookie, language, options.cookieOptions);
-	} catch (error) {
-		if (options.debug) console.error("Failed to cache language:", error);
-	}
-}
-/**
-* Detect language from request
-*/
-const detectLanguage = (c, options) => {
-	let detectedLang;
-	for (const detectorName of options.order) {
-		const detector = detectors[detectorName];
-		try {
-			detectedLang = detector(c, options);
-			if (detectedLang) {
-				if (options.debug) console.log(`Language detected from ${detectorName}: ${detectedLang}`);
-				break;
-			}
-		} catch (error) {
-			if (options.debug) console.error(`Error in ${detectorName} detector:`, error);
-			continue;
-		}
-	}
-	const finalLang = detectedLang || options.fallbackLanguage;
-	if (detectedLang && options.caches) cacheLanguage(c, finalLang, options);
-	return finalLang;
-};
-/**
-* Language detector middleware factory
-* @param userOptions Configuration options for the language detector
-* @returns Hono middleware function
-*
-* @example
-* ```ts
-* type Variables = LanguageVariables
-* const app = new Hono<{ Variables: Variables }>()
-*
-* app.use(
-*   languageDetector({
-*     supportedLanguages: ['en', 'ja'], // Must include fallback
-*     fallbackLanguage: 'en', // Required
-*   })
-* )
-*
-* app.get('/', (c) => {
-*   const lang = c.get('language')
-*   return c.text(`Current language: ${lang}`)
-* })
-* ```
-*/
-const languageDetector = (userOptions) => {
-	const options = {
-		...DEFAULT_OPTIONS,
-		...userOptions,
-		cookieOptions: {
-			...DEFAULT_OPTIONS.cookieOptions,
-			...userOptions.cookieOptions
-		}
-	};
-	validateOptions(options);
-	return async function languageDetector(ctx, next) {
-		const lang = detectLanguage(ctx, options);
-		ctx.set("language", lang);
-		await next();
-	};
-};
-//#endregion
-export { DEFAULT_OPTIONS, detectFromCookie, detectFromHeader, detectFromPath, detectFromQuery, detectors, languageDetector, normalizeLanguage, parseAcceptLanguage, validateOptions };

package/node_modules/hono/dist/middleware/logger/index.js

@@ -1,50 +0,0 @@
-import { getColorEnabledAsync } from "../../utils/color.js";
-//#region src/middleware/logger/index.ts
-const humanize = (times) => {
-	const [delimiter, separator] = [",", "."];
-	return times.map((v) => v.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1" + delimiter)).join(separator);
-};
-const time = (start) => {
-	const delta = Date.now() - start;
-	return humanize([delta < 1e3 ? delta + "ms" : Math.round(delta / 1e3) + "s"]);
-};
-const colorStatus = async (status) => {
-	if (await getColorEnabledAsync()) switch (status / 100 | 0) {
-		case 5: return `\x1b[31m${status}\x1b[0m`;
-		case 4: return `\x1b[33m${status}\x1b[0m`;
-		case 3: return `\x1b[36m${status}\x1b[0m`;
-		case 2: return `\x1b[32m${status}\x1b[0m`;
-	}
-	return `${status}`;
-};
-async function log(fn, prefix, method, path, status = 0, elapsed) {
-	fn(prefix === "<--" ? `${prefix} ${method} ${path}` : `${prefix} ${method} ${path} ${await colorStatus(status)} ${elapsed}`);
-}
-/**
-* Logger Middleware for Hono.
-*
-* @see {@link https://hono.dev/docs/middleware/builtin/logger}
-*
-* @param {PrintFunc} [fn=console.log] - Optional function for customized logging behavior.
-* @returns {MiddlewareHandler} The middleware handler function.
-*
-* @example
-* ```ts
-* const app = new Hono()
-*
-* app.use(logger())
-* app.get('/', (c) => c.text('Hello Hono!'))
-* ```
-*/
-const logger = (fn = console.log) => {
-	return async function logger(c, next) {
-		const { method, url } = c.req;
-		const path = url.slice(url.indexOf("/", 8));
-		await log(fn, "<--", method, path);
-		const start = Date.now();
-		await next();
-		await log(fn, "-->", method, path, c.res.status, time(start));
-	};
-};
-//#endregion
-export { logger };

package/node_modules/hono/dist/middleware/method-not-allowed/index.js

@@ -1,83 +0,0 @@
-import "../../router.js";
-import { TrieRouter } from "../../router/trie-router/router.js";
-import "../../router/trie-router/index.js";
-import { basePath, matchedRoutes } from "../../helper/route/index.js";
-//#region src/middleware/method-not-allowed/index.ts
-/**
-* Method Not Allowed Middleware for Hono.
-*
-* Returns a `405 Method Not Allowed` response with an `Allow` header when the request path
-* matches a registered route but the request method is not supported.
-*
-* @param {MethodNotAllowedOptions} options - The options for the middleware.
-* @param {Hono} options.app - The Hono instance used by the application.
-* @param {MethodNotAllowedHandler} [options.onMethodNotAllowed] - Generates the response, including its `Allow` header.
-* @returns {MiddlewareHandler} The middleware handler function.
-*
-* @example
-* ```ts
-* const app = new Hono()
-*
-* app.use(methodNotAllowed({ app }))
-*
-* app.get('/hello', (c) => c.text('Hello!'))
-* app.post('/hello', (c) => c.text('Posted!'))
-*
-* // PUT /hello -> 405 Method Not Allowed
-* // Allow: GET, HEAD, POST
-* ```
-*
-* @example
-* ```ts
-* app.use(
-*   methodNotAllowed({
-*     app,
-*     onMethodNotAllowed: (c, methods) =>
-*       c.json({ error: 'Method Not Allowed' }, 405, { Allow: methods.join(', ') }),
-*   })
-* )
-* ```
-*/
-const methodNotAllowed = (options) => {
-	let methodRouter;
-	return async function methodNotAllowed(c, next) {
-		const routeIndex = c.req.routeIndex;
-		await next();
-		if (c.res.status !== 404) return;
-		if (c.error) return;
-		if (!methodRouter) {
-			const methodsByPath = /* @__PURE__ */ new Map();
-			for (const route of options.app.routes) {
-				if (route.method === "ALL" || route.method === "HEAD") continue;
-				const methods = methodsByPath.get(route.path) ?? /* @__PURE__ */ new Set();
-				methods.add(route.method);
-				if (route.method === "GET") methods.add("HEAD");
-				methodsByPath.set(route.path, methods);
-			}
-			methodRouter = new TrieRouter();
-			for (const [path, methods] of methodsByPath) methodRouter.add("ALL", path, [...methods]);
-		}
-		let requestPath = c.req.path;
-		const currentRoute = matchedRoutes(c)[routeIndex];
-		const sourceRoute = options.app.routes.find((route) => route.handler === methodNotAllowed);
-		if (currentRoute && sourceRoute) {
-			const currentBasePathParts = basePath(c, routeIndex).split("/").filter(Boolean);
-			const sourceBasePathLength = sourceRoute.basePath.split("/").filter(Boolean).length;
-			const mountBasePathParts = currentBasePathParts.slice(0, currentBasePathParts.length - sourceBasePathLength);
-			if (mountBasePathParts.length > 0) {
-				const mountBasePath = `/${mountBasePathParts.join("/")}`;
-				requestPath = c.req.path.slice(mountBasePath.length) || "/";
-			}
-		}
-		const allowedMethods = /* @__PURE__ */ new Set();
-		for (const [methods] of methodRouter.match("ALL", requestPath)[0]) for (const method of methods) allowedMethods.add(method);
-		if (allowedMethods.size === 0 || allowedMethods.has(c.req.method)) return;
-		c.res.headers.delete("Allow");
-		c.res.headers.delete("Content-Length");
-		const methods = [...allowedMethods];
-		const allow = methods.join(", ");
-		c.res = options.onMethodNotAllowed ? await options.onMethodNotAllowed(c, methods) : c.text("Method Not Allowed", 405, { Allow: allow });
-	};
-};
-//#endregion
-export { methodNotAllowed };

package/node_modules/hono/dist/middleware/method-override/index.js

@@ -1,104 +0,0 @@
-import { parseBody } from "../../utils/body.js";
-//#region src/middleware/method-override/index.ts
-const DEFAULT_METHOD_FORM_NAME = "_method";
-/**
-* Method Override Middleware for Hono.
-*
-* @see {@link https://hono.dev/docs/middleware/builtin/method-override}
-*
-* @param {MethodOverrideOptions} options - The options for the method override middleware.
-* @param {Hono} options.app - The instance of Hono is used in your application.
-* @param {string} [options.form=_method] - Form key with a value containing the method name.
-* @param {string} [options.header] - Header name with a value containing the method name.
-* @param {string} [options.query] - Query parameter key with a value containing the method name.
-* @returns {MiddlewareHandler} The middleware handler function.
-*
-* @example
-* ```ts
-* const app = new Hono()
-*
-* // If no options are specified, the value of `_method` in the form,
-* // e.g. DELETE, is used as the method.
-* app.use('/posts', methodOverride({ app }))
-*
-* app.delete('/posts', (c) => {
-*   // ....
-* })
-* ```
-*/
-const methodOverride = (options) => async function methodOverride(c, next) {
-	if (c.req.method === "GET") return await next();
-	const app = options.app;
-	if (!(options.header || options.query)) {
-		const contentType = c.req.header("content-type");
-		const methodFormName = options.form || DEFAULT_METHOD_FORM_NAME;
-		const clonedRequest = c.req.raw.clone();
-		const newRequest = clonedRequest.clone();
-		if (contentType?.startsWith("multipart/form-data")) {
-			const method = (await clonedRequest.formData()).get(methodFormName);
-			if (method) {
-				const newForm = await newRequest.formData();
-				newForm.delete(methodFormName);
-				const newHeaders = new Headers(clonedRequest.headers);
-				newHeaders.delete("content-type");
-				newHeaders.delete("content-length");
-				const request = new Request(c.req.url, {
-					body: newForm,
-					headers: newHeaders,
-					method
-				});
-				return app.fetch(request, c.env, getExecutionCtx(c));
-			}
-		}
-		if (contentType?.startsWith("application/x-www-form-urlencoded")) {
-			const params = await parseBody(clonedRequest);
-			const method = params[methodFormName];
-			if (method) {
-				delete params[methodFormName];
-				const newParams = new URLSearchParams(params);
-				const request = new Request(newRequest, {
-					body: newParams,
-					method
-				});
-				return app.fetch(request, c.env, getExecutionCtx(c));
-			}
-		}
-	} else if (options.header) {
-		const headerName = options.header;
-		const method = c.req.header(headerName);
-		if (method) {
-			const newHeaders = new Headers(c.req.raw.headers);
-			newHeaders.delete(headerName);
-			const request = new Request(c.req.raw, {
-				headers: newHeaders,
-				method
-			});
-			return app.fetch(request, c.env, getExecutionCtx(c));
-		}
-	} else if (options.query) {
-		const queryName = options.query;
-		const method = c.req.query(queryName);
-		if (method) {
-			const url = new URL(c.req.url);
-			url.searchParams.delete(queryName);
-			const requestInit = {
-				body: c.req.raw.body,
-				headers: c.req.raw.headers,
-				method,
-				duplex: c.req.raw.body ? "half" : void 0
-			};
-			const request = new Request(url.toString(), requestInit);
-			return app.fetch(request, c.env, getExecutionCtx(c));
-		}
-	}
-	await next();
-};
-const getExecutionCtx = (c) => {
-	let executionCtx;
-	try {
-		executionCtx = c.executionCtx;
-	} catch {}
-	return executionCtx;
-};
-//#endregion
-export { methodOverride };

package/node_modules/hono/dist/middleware/mount/index.js

@@ -1,70 +0,0 @@
-import { routePath } from "../../helper/route/index.js";
-//#region src/middleware/mount/index.ts
-const defaultReplaceRequest = (c) => {
-	const pathPrefix = routePath(c).replace(/\/\*$/, "");
-	const url = new URL(c.req.raw.url);
-	url.pathname = c.req.path.slice(pathPrefix.length) || "/";
-	return new Request(url, c.req.raw);
-};
-const defaultGetOptions = (c) => {
-	let executionContext = void 0;
-	try {
-		executionContext = c.executionCtx;
-	} catch {}
-	return [c.env, executionContext];
-};
-/**
-* `mount()` allows you to mount applications built with other frameworks into your Hono application.
-*
-* @see {@link https://hono.dev/docs/api/hono#mount}
-*
-* @param {Function} applicationHandler - other Request Handler
-* @param {MountOptions} [options] - options of `mount()`
-* @returns {MiddlewareHandler} handler to register with `app.all()`
-*
-* @example
-* ```ts
-* import { Router as IttyRouter } from 'itty-router'
-* import { Hono } from 'hono'
-* import { mount } from 'hono/mount'
-* // Create itty-router application
-* const ittyRouter = IttyRouter()
-* // GET /itty-router/hello
-* ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
-*
-* const app = new Hono()
-* app.all('/itty-router/*', mount(ittyRouter.handle))
-* ```
-*
-* @example
-* ```ts
-* const app = new Hono()
-* // Send the request to another application without modification.
-* app.all('/app/*', mount(anotherApp, {
-*   replaceRequest: (req) => req,
-* }))
-* ```
-*/
-const mount = (applicationHandler, options) => {
-	let replaceRequest;
-	let optionHandler;
-	if (options) {
-		if (typeof options === "function") optionHandler = options;
-		else {
-			optionHandler = options.optionHandler;
-			if (options.replaceRequest === false) replaceRequest = (request) => request;
-			else replaceRequest = options.replaceRequest;
-		}
-	}
-	const getOptions = optionHandler ? (c) => {
-		const options = optionHandler(c);
-		return Array.isArray(options) ? options : [options];
-	} : defaultGetOptions;
-	return async (c, next) => {
-		const res = await applicationHandler(replaceRequest ? replaceRequest(c.req.raw) : defaultReplaceRequest(c), ...getOptions(c));
-		if (res) return res;
-		await next();
-	};
-};
-//#endregion
-export { mount };

package/node_modules/hono/dist/middleware/powered-by/index.js

@@ -1,24 +0,0 @@
-//#region src/middleware/powered-by/index.ts
-/**
-* Powered By Middleware for Hono.
-*
-* @param options - The options for the Powered By Middleware.
-* @returns {MiddlewareHandler} The middleware handler function.
-*
-* @example
-* ```ts
-* import { poweredBy } from 'hono/powered-by'
-*
-* const app = new Hono()
-*
-* app.use(poweredBy()) // With options: poweredBy({ serverName: "My Server" })
-* ```
-*/
-const poweredBy = (options) => {
-	return async function poweredBy(c, next) {
-		await next();
-		c.res.headers.set("X-Powered-By", options?.serverName ?? "Hono");
-	};
-};
-//#endregion
-export { poweredBy };

package/node_modules/hono/dist/middleware/pretty-json/index.js

@@ -1,40 +0,0 @@
-//#region src/middleware/pretty-json/index.ts
-const jsonContentTypeRegex = /^application\/(?:[a-z0-9._-]+\+)?json(?=$|[;\s])/i;
-/**
-* Pretty JSON Middleware for Hono.
-*
-* @see {@link https://hono.dev/docs/middleware/builtin/pretty-json}
-*
-* @param options - The options for the pretty JSON middleware.
-* @returns {MiddlewareHandler} The middleware handler function.
-*
-* @example
-* ```ts
-* const app = new Hono()
-*
-* app.use(prettyJSON()) // With options: prettyJSON({ space: 4 })
-* app.get('/', (c) => {
-*   return c.json({ message: 'Hono!' })
-* })
-* ```
-*/
-const prettyJSON = (options) => {
-	const targetQuery = options?.query ?? "pretty";
-	return async function prettyJSON(c, next) {
-		const pretty = options?.force || c.req.query(targetQuery) || c.req.query(targetQuery) === "";
-		await next();
-		const contentType = c.res.headers.get("Content-Type");
-		if (pretty && contentType && jsonContentTypeRegex.test(contentType)) {
-			let obj;
-			try {
-				obj = await c.res.clone().json();
-			} catch {
-				return;
-			}
-			c.res = new Response(JSON.stringify(obj, null, options?.space ?? 2), c.res);
-			c.res.headers.delete("Content-Length");
-		}
-	};
-};
-//#endregion
-export { prettyJSON };

package/node_modules/hono/dist/middleware/request-id/index.js

@@ -1,2 +0,0 @@
-import { requestId } from "./request-id.js";
-export { requestId };

package/node_modules/hono/dist/middleware/request-id/request-id.js

@@ -1,34 +0,0 @@
-//#region src/middleware/request-id/request-id.ts
-/**
-* Request ID Middleware for Hono.
-*
-* @param {object} options - Options for Request ID middleware.
-* @param {number} [options.limitLength=255] - The maximum length of request id.
-* @param {string} [options.headerName=X-Request-Id] - The header name used in request id.
-* @param {generator} [options.generator=() => crypto.randomUUID()] - The request id generation function.
-*
-* @returns {MiddlewareHandler} The middleware handler function.
-*
-* @example
-* ```ts
-* type Variables = RequestIdVariables
-* const app = new Hono<{Variables: Variables}>()
-*
-* app.use(requestId())
-* app.get('/', (c) => {
-*   console.log(c.get('requestId')) // Debug
-*   return c.text('Hello World!')
-* })
-* ```
-*/
-const requestId = ({ limitLength = 255, headerName = "X-Request-Id", generator = () => crypto.randomUUID() } = {}) => {
-	return async function requestId(c, next) {
-		let reqId = headerName ? c.req.header(headerName) : void 0;
-		if (!reqId || reqId.length > limitLength || /[^\w\-=]/.test(reqId)) reqId = generator(c);
-		c.set("requestId", reqId);
-		if (headerName) c.header(headerName, reqId);
-		await next();
-	};
-};
-//#endregion
-export { requestId };

package/node_modules/hono/dist/middleware/secure-headers/index.js

@@ -1,2 +0,0 @@
-import { NONCE, secureHeaders } from "./secure-headers.js";
-export { NONCE, secureHeaders };

package/node_modules/hono/dist/middleware/secure-headers/permissions-policy.js

@@ -1 +0,0 @@
-export {};