codexuse-cli 3.6.5 → 3.6.6

package/dist/server/{open-Cm7F9p66.mjs → open-BM96ykXl.mjs}

@@ -551,4 +551,4 @@ defineLazyProperty(apps, "safari", () => detectPlatformBinary({ darwin: "Safari"
 //#endregion
 export { apps, open as default, openApp };
 
-//# sourceMappingURL=open-Cm7F9p66.mjs.map
+//# sourceMappingURL=open-BM96ykXl.mjs.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codexuse-cli",
-  "version": "3.6.5",
+  "version": "3.6.6",
   "description": "CodexUse CLI for profiles, Accounts Pool, daemon mode, licenses, and sync.",
   "author": {
     "name": "Hoang",

package/dist/server/Cache-Ctxz7HFI.mjs

@@ -1,567 +0,0 @@
-#!/usr/bin/env bun
-
-import { Ba as succeedNone, Eo as filterMap, Ga as updateServices, Ha as sync, Ia as servicesWith, Jo as PipeInspectableProto, Ka as void_, Mo as succeed$1, Na as onExit, Qo as withFiber, Ro as isNone, Ui as _await, Wi as doneUnsafe, Xo as exitSucceed, Yi as makeUnsafe, _n as set$1, ao as fromInputUnsafe, co as isZero, do as toMillis, fa as ClockRef, gn as remove, hn as make$1, io as merge, ko as failVoid, mn as get$1, oo as infinity, so as isFinite, vn as size, vs as dual, ya as asSome, za as succeed, zo as isSome } from "./SqlClient-DSf3-WP1.mjs";
-//#region ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect-smol+effect@8881a9b/node_modules/effect/dist/Cache.js
-/**
-* @since 4.0.0
-*/
-const TypeId = "~effect/Cache";
-/**
-* Creates a cache with dynamic time-to-live based on the result and key.
-*
-* The timeToLive function receives both the exit result and the key, allowing
-* for flexible TTL policies based on success/failure state and key characteristics.
-*
-* @example
-* ```ts
-* import { Cache, Effect, Exit } from "effect"
-*
-* // Cache with different TTL for success vs failure
-* const program = Effect.gen(function*() {
-*   const cache = yield* Cache.makeWith<string, number, string>({
-*     capacity: 100,
-*     lookup: (key) =>
-*       key === "fail"
-*         ? Effect.fail("error")
-*         : Effect.succeed(key.length),
-*     timeToLive: (exit, key) => {
-*       if (Exit.isFailure(exit)) return "1 minute" // Short TTL for errors
-*       return key.startsWith("temp") ? "5 minutes" : "1 hour"
-*     }
-*   })
-*
-*   // Get values with different TTL policies
-*   const result1 = yield* Cache.get(cache, "hello")
-*   const result2 = yield* Cache.get(cache, "temp_data")
-*   console.log({ result1, result2 }) // { result1: 5, result2: 9 }
-* })
-* ```
-*
-* @example
-* ```ts
-* import { Cache, Effect, Exit } from "effect"
-*
-* // Cache with TTL based on computed value
-* const userCache = Effect.gen(function*() {
-*   const cache = yield* Cache.makeWith<
-*     number,
-*     { id: number; active: boolean },
-*     never
-*   >({
-*     capacity: 1000,
-*     lookup: (id) => Effect.succeed({ id, active: id % 2 === 0 }),
-*     timeToLive: (exit) => {
-*       if (Exit.isSuccess(exit)) {
-*         const user = exit.value
-*         return user.active ? "1 hour" : "5 minutes"
-*       }
-*       return "30 seconds"
-*     }
-*   })
-*
-*   return cache
-* })
-* ```
-*
-* @since 4.0.0
-* @category Constructors
-*/
-const makeWith = (options) => servicesWith((services) => {
-	const self = Object.create(Proto);
-	self.lookup = (key) => updateServices(options.lookup(key), (input) => merge(services, input));
-	self.map = make$1();
-	self.capacity = options.capacity;
-	self.timeToLive = options.timeToLive ? (exit, key) => fromInputUnsafe(options.timeToLive(exit, key)) : defaultTimeToLive;
-	return succeed(self);
-});
-/**
-* Creates a cache with a fixed time-to-live for all entries.
-*
-* This is the basic cache constructor where all entries share the same TTL.
-* The lookup function will be called when a key is not found or has expired.
-*
-* @example
-* ```ts
-* import { Cache, Effect } from "effect"
-*
-* // Basic cache with string keys
-* const program = Effect.gen(function*() {
-*   const cache = yield* Cache.make<string, number>({
-*     capacity: 100,
-*     lookup: (key) => Effect.succeed(key.length)
-*   })
-*
-*   const result1 = yield* Cache.get(cache, "hello")
-*   const result2 = yield* Cache.get(cache, "world")
-*   console.log({ result1, result2 }) // { result1: 5, result2: 5 }
-* })
-* ```
-*
-* @example
-* ```ts
-* import { Cache, Effect } from "effect"
-*
-* // Cache with TTL and async lookup
-* const fetchUserCache = Effect.gen(function*() {
-*   const cache = yield* Cache.make<
-*     number,
-*     { name: string; email: string },
-*     string
-*   >({
-*     capacity: 500,
-*     lookup: (userId) =>
-*       Effect.tryPromise({
-*         try: () => fetch(`/api/users/${userId}`).then((r) => r.json()),
-*         catch: () => "Failed to fetch user"
-*       }),
-*     timeToLive: "15 minutes"
-*   })
-*
-*   // First call fetches from API, second call returns cached result
-*   const user1 = yield* Cache.get(cache, 123)
-*   const user2 = yield* Cache.get(cache, 123) // From cache
-*   return { user1, user2 }
-* })
-* ```
-*
-* @since 4.0.0
-* @category Constructors
-*/
-const make = (options) => makeWith({
-	...options,
-	timeToLive: options.timeToLive ? () => options.timeToLive : defaultTimeToLive
-});
-const Proto = {
-	...PipeInspectableProto,
-	[TypeId]: TypeId,
-	toJSON() {
-		return {
-			_id: "Cache",
-			capacity: this.capacity,
-			map: this.map
-		};
-	}
-};
-const defaultTimeToLive = (_, _key) => infinity;
-/**
-* Retrieves the value associated with the specified key from the cache.
-*
-* If the key is not present or has expired, it will invoke the lookup function
-* to construct the value, store it in the cache, and return it.
-*
-* @example
-* ```ts
-* import { Cache, Effect } from "effect"
-*
-* const program = Effect.gen(function*() {
-*   const cache = yield* Cache.make({
-*     capacity: 10,
-*     lookup: (key: string) => Effect.succeed(key.length)
-*   })
-*
-*   // Cache miss - triggers lookup function
-*   const result1 = yield* Cache.get(cache, "hello")
-*   console.log(result1) // 5
-*
-*   // Cache hit - returns cached value without lookup
-*   const result2 = yield* Cache.get(cache, "hello")
-*   console.log(result2) // 5 (from cache)
-*
-*   return { result1, result2 }
-* })
-* ```
-*
-* @example
-* ```ts
-* import { Cache, Effect } from "effect"
-*
-* // Error handling when lookup fails
-* const program = Effect.gen(function*() {
-*   const cache = yield* Cache.make<string, number, string>({
-*     capacity: 10,
-*     lookup: (key: string) =>
-*       key === "error"
-*         ? Effect.fail("Lookup failed")
-*         : Effect.succeed(key.length)
-*   })
-*
-*   // Successful lookup
-*   const success = yield* Cache.get(cache, "hello")
-*   console.log(success) // 5
-*
-*   // Failed lookup - returns error
-*   const failure = yield* Effect.exit(Cache.get(cache, "error"))
-*   console.log(failure) // Exit.fail("Lookup failed")
-* })
-* ```
-*
-* @example
-* ```ts
-* import { Cache, Effect } from "effect"
-*
-* // Concurrent access - multiple gets of same key only invoke lookup once
-* const program = Effect.gen(function*() {
-*   let lookupCount = 0
-*   const cache = yield* Cache.make({
-*     capacity: 10,
-*     lookup: (key: string) =>
-*       Effect.sync(() => {
-*         lookupCount++
-*         return key.length
-*       })
-*   })
-*
-*   // Multiple concurrent gets
-*   const results = yield* Effect.all([
-*     Cache.get(cache, "hello"),
-*     Cache.get(cache, "hello"),
-*     Cache.get(cache, "hello")
-*   ], { concurrency: "unbounded" })
-*
-*   console.log(results) // [5, 5, 5]
-*   console.log(lookupCount) // 1 (lookup called only once)
-* })
-* ```
-*
-* @since 4.0.0
-* @category Combinators
-*/
-const get = /* @__PURE__ */ dual(2, (self, key) => withFiber((fiber) => {
-	const oentry = get$1(self.map, key);
-	if (isSome(oentry) && !hasExpired(oentry.value, fiber)) {
-		remove(self.map, key);
-		set$1(self.map, key, oentry.value);
-		return _await(oentry.value.deferred);
-	}
-	const deferred = makeUnsafe();
-	const entry = {
-		expiresAt: void 0,
-		deferred
-	};
-	set$1(self.map, key, entry);
-	if (Number.isFinite(self.capacity)) checkCapacity(self);
-	return onExit(self.lookup(key), (exit) => {
-		doneUnsafe(deferred, exit);
-		const ttl = self.timeToLive(exit, key);
-		if (isFinite(ttl)) entry.expiresAt = fiber.getRef(ClockRef).currentTimeMillisUnsafe() + toMillis(ttl);
-		else if (isZero(ttl)) remove(self.map, key);
-		return void_;
-	});
-}));
-const hasExpired = (entry, fiber) => {
-	if (entry.expiresAt === void 0) return false;
-	return fiber.getRef(ClockRef).currentTimeMillisUnsafe() >= entry.expiresAt;
-};
-const checkCapacity = (self) => {
-	let diff = size(self.map) - self.capacity;
-	if (diff <= 0) return;
-	for (const [key] of self.map) {
-		remove(self.map, key);
-		diff--;
-		if (diff === 0) return;
-	}
-};
-/**
-* Retrieves the value associated with the specified key from the cache,
-* returning an `Option` that is `Some` if the key exists and has not expired,
-* or `None` if the key does not exist or has expired.
-*
-* Unlike `get`, this function will not invoke the lookup function if the key
-* is missing or expired.
-*
-* @example
-* ```ts
-* import { Cache, Effect } from "effect"
-*
-* const program = Effect.gen(function*() {
-*   const cache = yield* Cache.make({
-*     capacity: 10,
-*     lookup: (key: string) => Effect.succeed(key.length)
-*   })
-*
-*   // No value in cache yet - returns None without lookup
-*   const empty = yield* Cache.getOption(cache, "hello")
-*   console.log(empty) // Option.none()
-*
-*   // Populate cache using get
-*   yield* Cache.get(cache, "hello")
-*
-*   // Now getOption returns the cached value
-*   const cached = yield* Cache.getOption(cache, "hello")
-*   console.log(cached) // Option.some(5)
-*
-*   return { empty, cached }
-* })
-* ```
-*
-* @example
-* ```ts
-* import { Cache, Effect } from "effect"
-* import { TestClock } from "effect/testing"
-*
-* // Expired entries return None
-* const program = Effect.gen(function*() {
-*   const cache = yield* Cache.make({
-*     capacity: 10,
-*     lookup: (key: string) => Effect.succeed(key.length),
-*     timeToLive: "1 hour"
-*   })
-*
-*   // Add value to cache
-*   yield* Cache.get(cache, "hello")
-*
-*   // Value exists before expiration
-*   const beforeExpiry = yield* Cache.getOption(cache, "hello")
-*   console.log(beforeExpiry) // Option.some(5)
-*
-*   // Simulate time passing
-*   yield* TestClock.adjust("2 hours")
-*
-*   // Value expired - returns None
-*   const afterExpiry = yield* Cache.getOption(cache, "hello")
-*   console.log(afterExpiry) // Option.none()
-* })
-* ```
-*
-* @example
-* ```ts
-* import { Cache, Deferred, Effect, Fiber } from "effect"
-*
-* // Waits for ongoing computation to complete
-* const program = Effect.gen(function*() {
-*   const deferred = yield* Deferred.make<void>()
-*   const cache = yield* Cache.make({
-*     capacity: 10,
-*     lookup: (_key: string) => Deferred.await(deferred).pipe(Effect.as(42))
-*   })
-*
-*   // Start lookup in background
-*   const getFiber = yield* Effect.forkChild(Cache.get(cache, "key"))
-*
-*   // getOption waits for ongoing computation
-*   const optionFiber = yield* Effect.forkChild(Cache.getOption(cache, "key"))
-*
-*   // Complete the computation
-*   yield* Deferred.succeed(deferred, void 0)
-*
-*   const result = yield* Fiber.join(optionFiber)
-*   console.log(result) // Option.some(42)
-* })
-* ```
-*
-* @since 4.0.0
-* @category Combinators
-*/
-const getOption = /* @__PURE__ */ dual(2, (self, key) => withFiber((fiber) => {
-	const entry = getImpl(self, key, fiber);
-	return entry ? asSome(_await(entry.deferred)) : succeedNone;
-}));
-const getImpl = (self, key, fiber, isRead = true) => {
-	const oentry = get$1(self.map, key);
-	if (isNone(oentry)) return;
-	else if (hasExpired(oentry.value, fiber)) {
-		remove(self.map, key);
-		return;
-	} else if (isRead) {
-		remove(self.map, key);
-		set$1(self.map, key, oentry.value);
-	}
-	return oentry.value;
-};
-/**
-* Sets the value associated with the specified key in the cache. This will
-* overwrite any existing value for that key, skipping the lookup function.
-*
-* @example
-* ```ts
-* import { Cache, Effect } from "effect"
-*
-* const program = Effect.gen(function*() {
-*   const cache = yield* Cache.make({
-*     capacity: 100,
-*     lookup: (key: string) => Effect.succeed(key.length)
-*   })
-*
-*   // Set a value directly without invoking lookup
-*   yield* Cache.set(cache, "hello", 42)
-*   const result = yield* Cache.get(cache, "hello")
-*   console.log(result) // 42 (not 5 from lookup)
-* })
-* ```
-*
-* @example
-* ```ts
-* import { Cache, Effect } from "effect"
-*
-* // Overwriting existing cached values
-* const program = Effect.gen(function*() {
-*   const cache = yield* Cache.make({
-*     capacity: 100,
-*     lookup: (key: string) => Effect.succeed(key.length)
-*   })
-*
-*   // First get populates via lookup
-*   const original = yield* Cache.get(cache, "test") // 4
-*
-*   // Set overwrites the cached value
-*   yield* Cache.set(cache, "test", 999)
-*   const updated = yield* Cache.get(cache, "test") // 999
-*
-*   console.log({ original, updated })
-* })
-* ```
-*
-* @example
-* ```ts
-* import { Cache, Effect } from "effect"
-* import { TestClock } from "effect/testing"
-*
-* // TTL behavior with set operations
-* const program = Effect.gen(function*() {
-*   const cache = yield* Cache.make({
-*     capacity: 100,
-*     lookup: (key: string) => Effect.succeed(key.length),
-*     timeToLive: "1 hour"
-*   })
-*
-*   // Set value with TTL applied
-*   yield* Cache.set(cache, "temporary", 123)
-*   console.log(yield* Cache.has(cache, "temporary")) // true
-*
-*   // Advance time past TTL
-*   yield* TestClock.adjust("2 hours")
-*   console.log(yield* Cache.has(cache, "temporary")) // false
-* })
-* ```
-*
-* @example
-* ```ts
-* import { Cache, Effect } from "effect"
-*
-* // Capacity enforcement with set operations
-* const program = Effect.gen(function*() {
-*   const cache = yield* Cache.make({
-*     capacity: 2,
-*     lookup: (key: string) => Effect.succeed(key.length)
-*   })
-*
-*   // Fill cache to capacity
-*   yield* Cache.set(cache, "a", 1)
-*   yield* Cache.set(cache, "b", 2)
-*   console.log(yield* Cache.size(cache)) // 2
-*
-*   // Adding another entry evicts oldest
-*   yield* Cache.set(cache, "c", 3)
-*   console.log(yield* Cache.size(cache)) // 2
-*   console.log(yield* Cache.has(cache, "a")) // false (evicted)
-*   console.log(yield* Cache.has(cache, "c")) // true
-* })
-* ```
-*
-* @since 4.0.0
-* @category Combinators
-*/
-const set = /* @__PURE__ */ dual(3, (self, key, value) => withFiber((fiber) => {
-	const exit = exitSucceed(value);
-	const deferred = makeUnsafe();
-	doneUnsafe(deferred, exit);
-	const ttl = self.timeToLive(exit, key);
-	if (isZero(ttl)) {
-		remove(self.map, key);
-		return void_;
-	}
-	set$1(self.map, key, {
-		deferred,
-		expiresAt: isFinite(ttl) ? fiber.getRef(ClockRef).currentTimeMillisUnsafe() + toMillis(ttl) : void 0
-	});
-	checkCapacity(self);
-	return void_;
-}));
-/**
-* Invalidates the entry associated with the specified key in the cache.
-*
-* @example
-* ```ts
-* import { Cache, Effect } from "effect"
-*
-* const program = Effect.gen(function*() {
-*   const cache = yield* Cache.make({
-*     capacity: 10,
-*     lookup: (key: string) => Effect.succeed(key.length)
-*   })
-*
-*   // Add a value to the cache
-*   yield* Cache.get(cache, "hello")
-*   console.log(yield* Cache.has(cache, "hello")) // true
-*
-*   // Invalidate the entry
-*   yield* Cache.invalidate(cache, "hello")
-*   console.log(yield* Cache.has(cache, "hello")) // false
-*
-*   // Invalidating non-existent keys doesn't error
-*   yield* Cache.invalidate(cache, "nonexistent")
-*
-*   // Get after invalidation will invoke lookup again
-*   let lookupCount = 0
-*   const cache2 = yield* Cache.make({
-*     capacity: 10,
-*     lookup: (key: string) =>
-*       Effect.sync(() => {
-*         lookupCount++
-*         return key.length
-*       })
-*   })
-*
-*   yield* Cache.get(cache2, "test") // lookupCount = 1
-*   yield* Cache.invalidate(cache2, "test")
-*   yield* Cache.get(cache2, "test") // lookupCount = 2 (lookup called again)
-* })
-* ```
-*
-* @since 4.0.0
-* @category Combinators
-*/
-const invalidate = /* @__PURE__ */ dual(2, (self, key) => sync(() => {
-	remove(self.map, key);
-}));
-/**
-* Retrieves all active keys from the cache, automatically filtering out expired entries.
-*
-* @example
-* ```ts
-* import { Cache, Effect } from "effect"
-*
-* // Basic key enumeration
-* const program = Effect.gen(function*() {
-*   const cache = yield* Cache.make({
-*     capacity: 10,
-*     lookup: (key: string) => Effect.succeed(key.length)
-*   })
-*
-*   // Add some entries to the cache
-*   yield* Cache.get(cache, "hello")
-*   yield* Cache.get(cache, "world")
-*   yield* Cache.get(cache, "cache")
-*
-*   // Retrieve all active keys
-*   const keys = yield* Cache.keys(cache)
-*
-*   console.log(Array.from(keys)) // ["hello", "world", "cache"]
-* })
-* ```
-*
-* @since 4.0.0
-* @category Combinators
-*/
-const keys = (self) => withFiber((fiber) => {
-	const now = fiber.getRef(ClockRef).currentTimeMillisUnsafe();
-	return succeed(filterMap(self.map, ([key, entry]) => {
-		if (entry.expiresAt === void 0 || entry.expiresAt > now) return succeed$1(key);
-		remove(self.map, key);
-		return failVoid;
-	}));
-});
-//#endregion
-export { make as a, keys as i, getOption as n, makeWith as o, invalidate as r, set as s, get as t };
-
-//# sourceMappingURL=Cache-Ctxz7HFI.mjs.map