mppx 0.8.15 → 0.8.18

package/src/Store.ts

@@ -1,329 +0,0 @@
-/**
- * Async key-value store interface.
- *
- * Modeled after Cloudflare KV's API (`get`/`put`/`delete`).
- * Implementations handle serialization internally.
- *
- * ## Type architecture
- *
- * Uses a two-slot generic pattern inspired by Viem's `Client` type:
- *
- * - `itemMap` — constrains keys and their value types
- * - `extended` — accumulates additional capabilities (e.g., atomic `update`)
- *
- * `AtomicStore` is a type alias that fills the `extended` slot with
- * `AtomicActions`, just like Viem's `PublicClient = Client<..., PublicActions>`.
- */
-import { Json } from 'ox'
-
-export type StoreItemMap = Record<string, unknown>
-
-/**
- * Describes the outcome of an atomic {@link Update} callback.
- *
- * - `noop` — leave the stored value unchanged.
- * - `set`  — write `value` for the key.
- * - `delete` — remove the key.
- *
- * Every variant carries a `result` that is forwarded to the caller.
- */
-export type Change<value, result> =
-  | { op: 'noop'; result: result }
-  | { op: 'set'; value: value; result: result }
-  | { op: 'delete'; result: result }
-
-/**
- * Atomic read-modify-write for a single key.
- *
- * `fn` receives the current value (or `null`) and returns a {@link Change}
- * describing the write to perform. Implementations may retry `fn`, so it
- * must be synchronous and free of side effects.
- */
-export type Update<itemMap extends StoreItemMap = StoreItemMap> = <
-  key extends keyof itemMap & string,
-  result,
->(
-  key: key,
-  fn: (current: itemMap[key] | null) => Change<itemMap[key], result>,
-) => Promise<result>
-
-/** Base key-value actions available on every {@link Store}. */
-export type StoreActions<itemMap extends StoreItemMap = StoreItemMap> = {
-  get: <key extends keyof itemMap & string>(key: key) => Promise<itemMap[key] | null>
-  put: <key extends keyof itemMap & string>(key: key, value: itemMap[key]) => Promise<void>
-  delete: <key extends keyof itemMap & string>(key: key) => Promise<void>
-}
-
-/** Atomic actions that can be provided via the `extended` slot. */
-export type AtomicActions<itemMap extends StoreItemMap = StoreItemMap> = {
-  update: Update<itemMap>
-}
-
-/**
- * Async key-value store.
- *
- * The second generic `extended` accumulates additional capabilities
- * (like {@link AtomicActions}) without structural patching.
- */
-export type Store<
-  itemMap extends StoreItemMap = StoreItemMap,
-  extended extends Record<string, unknown> | undefined = undefined,
-> = StoreActions<itemMap> & (extended extends Record<string, unknown> ? extended : unknown)
-
-/**
- * A {@link Store} whose atomic {@link Update} method is guaranteed to exist.
- *
- * Use this when atomicity is required (e.g., replay protection, channel
- * deductions). Factory functions return `AtomicStore` when the backing
- * adapter provides an `update` implementation.
- *
- * Equivalent to `Store<itemMap, AtomicActions<itemMap>>`.
- */
-export type AtomicStore<itemMap extends StoreItemMap = StoreItemMap> = Store<
-  itemMap,
-  AtomicActions<itemMap>
->
-
-/** Options shared by store constructors. */
-export type Options = {
-  /** Prefix prepended to every backing store key. */
-  keyPrefix?: string | undefined
-}
-
-const keyPrefixCache = new WeakMap<Store, Map<string, Store | AtomicStore>>()
-
-/** Creates a {@link Store} from an existing implementation. */
-export function from<store extends AtomicStore<any>>(store: store, options?: Options): store
-export function from<store extends Store<any>>(store: store, options?: Options): store
-export function from(store: Store | AtomicStore, options?: Options) {
-  return withKeyPrefix(store, options?.keyPrefix)
-}
-
-function withKeyPrefix(store: Store | AtomicStore, keyPrefix = ''): Store | AtomicStore {
-  if (!keyPrefix) return store
-
-  const cached = keyPrefixCache.get(store)?.get(keyPrefix)
-  if (cached) return cached
-
-  const backing = store as Store
-  const prefixedKey = (key: string) => `${keyPrefix}${key}`
-  const prefixed = from({
-    async get(key: string) {
-      return backing.get(prefixedKey(key)) as Promise<unknown>
-    },
-    async put(key: string, value: unknown) {
-      await backing.put(prefixedKey(key), value)
-    },
-    async delete(key: string) {
-      await backing.delete(prefixedKey(key))
-    },
-    ...('update' in store
-      ? {
-          async update<result>(
-            key: string,
-            fn: (current: unknown | null) => Change<unknown, result>,
-          ) {
-            return (store as AtomicStore).update(prefixedKey(key), fn as never)
-          },
-        }
-      : {}),
-  } satisfies Store | AtomicStore)
-
-  const cachedByPrefix = keyPrefixCache.get(store) ?? new Map<string, Store | AtomicStore>()
-  cachedByPrefix.set(keyPrefix, prefixed)
-  keyPrefixCache.set(store, cachedByPrefix)
-  return prefixed
-}
-
-function wrapJsonUpdate(
-  update:
-    | (<result>(
-        key: string,
-        fn: (current: string | null) => Change<string, result>,
-      ) => Promise<result>)
-    | undefined,
-): AtomicActions | {} {
-  if (!update) return {}
-  return {
-    async update(key, fn) {
-      return update(key, (current) => {
-        const parsed = current == null ? null : (Json.parse(current) as never)
-        const change = fn(parsed)
-        if (change.op !== 'set') return change
-        return { ...change, value: Json.stringify(change.value) }
-      })
-    },
-  } satisfies AtomicActions
-}
-
-/** Wraps a Cloudflare KV namespace. */
-export function cloudflare(
-  kv: cloudflare.AtomicParameters,
-  options?: cloudflare.Options,
-): AtomicStore
-export function cloudflare(kv: cloudflare.Parameters, options?: cloudflare.Options): Store
-export function cloudflare(kv: cloudflare.Parameters, options?: cloudflare.Options): Store {
-  return from(
-    {
-      async get(key: string) {
-        const raw = await kv.get(key)
-        if (raw == null) return null as any
-        return Json.parse(raw as string)
-      },
-      async put(key: string, value: unknown) {
-        await kv.put(key, Json.stringify(value))
-      },
-      async delete(key: string) {
-        await kv.delete(key)
-      },
-      ...wrapJsonUpdate(kv.update),
-    },
-    options,
-  )
-}
-
-export declare namespace cloudflare {
-  export type Options = {
-    /** Prefix prepended to every backing store key. */
-    keyPrefix?: string | undefined
-  }
-
-  export type Parameters = {
-    get: (key: string) => Promise<unknown>
-    put: (key: string, value: string) => Promise<void>
-    delete: (key: string) => Promise<void>
-    update?: <result>(
-      key: string,
-      fn: (current: string | null) => Change<string, result>,
-    ) => Promise<result>
-  }
-
-  export type AtomicParameters = Omit<Parameters, 'update'> & {
-    update: NonNullable<Parameters['update']>
-  }
-}
-
-/** In-memory store backed by a `Map`. JSON-roundtrips values to match production behavior. */
-export function memory(options?: memory.Options): AtomicStore {
-  const store = new Map<string, string>()
-  return from(
-    {
-      async get(key: string) {
-        const raw = store.get(key)
-        if (raw === undefined) return null as any
-        return Json.parse(raw)
-      },
-      async put(key: string, value: unknown) {
-        store.set(key, Json.stringify(value))
-      },
-      async delete(key: string) {
-        store.delete(key)
-      },
-      async update<result>(key: string, fn: (current: unknown | null) => Change<unknown, result>) {
-        const current = store.has(key) ? (Json.parse(store.get(key)!) as never) : null
-        const change = fn(current)
-        if (change.op === 'set') store.set(key, Json.stringify(change.value))
-        if (change.op === 'delete') store.delete(key)
-        return change.result
-      },
-    },
-    options,
-  )
-}
-
-export declare namespace memory {
-  export type Options = {
-    /** Prefix prepended to every backing store key. */
-    keyPrefix?: string | undefined
-  }
-}
-
-/** Wraps a standard Redis client (ioredis, node-redis, Valkey). */
-export function redis(client: redis.AtomicParameters, options?: redis.Options): AtomicStore
-export function redis(client: redis.Parameters, options?: redis.Options): Store
-export function redis(client: redis.Parameters, options?: redis.Options): Store {
-  return from(
-    {
-      async get(key: string) {
-        const raw = await client.get(key)
-        if (raw == null) return null as any
-        return Json.parse(raw)
-      },
-      async put(key: string, value: unknown) {
-        await client.set(key, Json.stringify(value))
-      },
-      async delete(key: string) {
-        await client.del(key)
-      },
-      ...wrapJsonUpdate(client.update),
-    },
-    options,
-  )
-}
-
-export declare namespace redis {
-  export type Options = {
-    /** Prefix prepended to every backing store key. */
-    keyPrefix?: string | undefined
-  }
-
-  export type Parameters = {
-    get: (key: string) => Promise<string | null>
-    set: (key: string, value: string) => Promise<unknown>
-    del: (key: string) => Promise<unknown>
-    update?: <result>(
-      key: string,
-      fn: (current: string | null) => Change<string, result>,
-    ) => Promise<result>
-  }
-
-  export type AtomicParameters = Omit<Parameters, 'update'> & {
-    update: NonNullable<Parameters['update']>
-  }
-}
-
-/** Wraps an Upstash Redis instance (e.g. Vercel KV). */
-export function upstash(redis: upstash.AtomicParameters, options?: upstash.Options): AtomicStore
-export function upstash(redis: upstash.Parameters, options?: upstash.Options): Store
-export function upstash(redis: upstash.Parameters, options?: upstash.Options): Store {
-  return from(
-    {
-      async get(key: string) {
-        return (await redis.get(key)) as any
-      },
-      async put(key: string, value: unknown) {
-        await redis.set(key, value)
-      },
-      async delete(key: string) {
-        await redis.del(key)
-      },
-      ...(redis.update
-        ? {
-            update: redis.update as Update,
-          }
-        : {}),
-    },
-    options,
-  )
-}
-
-export declare namespace upstash {
-  export type Options = {
-    /** Prefix prepended to every backing store key. */
-    keyPrefix?: string | undefined
-  }
-
-  export type Parameters = {
-    get: (key: string) => Promise<unknown>
-    set: (key: string, value: unknown) => Promise<unknown>
-    del: (key: string) => Promise<unknown>
-    update?: <result>(
-      key: string,
-      fn: (current: unknown | null) => Change<unknown, result>,
-    ) => Promise<result>
-  }
-
-  export type AtomicParameters = Omit<Parameters, 'update'> & {
-    update: NonNullable<Parameters['update']>
-  }
-}

package/src/bin.ts

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-import cli from './cli/cli.js'
-
-await cli.serve()

package/src/cli/account.ts

@@ -1,269 +0,0 @@
-import * as child from 'node:child_process'
-import * as fs from 'node:fs'
-import * as os from 'node:os'
-import * as path from 'node:path'
-
-import { Errors } from 'incur'
-
-import { isTempoAccount } from './utils.js'
-
-const SERVICE_NAME = 'mppx'
-const defaultCommandTimeoutMs = 10_000
-
-function commandTimeoutMs() {
-  const value = Number.parseInt(process.env.MPPX_KEYCHAIN_COMMAND_TIMEOUT_MS ?? '', 10)
-  return Number.isFinite(value) && value > 0 ? value : defaultCommandTimeoutMs
-}
-
-function isMissingCommand(error: Error, command: string) {
-  return 'code' in error && error.code === 'ENOENT' && error.message.includes(command)
-}
-
-function keyringUnavailableError(cause: Error) {
-  return new Errors.IncurError({
-    code: 'KEYCHAIN_UNAVAILABLE',
-    message: 'Linux keyring requires secret-tool. Install libsecret-tools.',
-    hint: 'On Debian/Ubuntu, run: sudo apt install libsecret-tools gnome-keyring dbus-x11',
-    exitCode: 69,
-    cause,
-  })
-}
-
-function assertSecretToolAvailable(
-  error: Error | null | undefined,
-): asserts error is null | undefined {
-  if (error && isMissingCommand(error, 'secret-tool')) throw keyringUnavailableError(error)
-}
-
-export function execCommand(
-  command: string,
-  args: string[],
-): Promise<{ stdout: string; stderr: string; error: Error | null }> {
-  return new Promise((resolve) => {
-    child.execFile(command, args, { timeout: commandTimeoutMs() }, (error, stdout, stderr) => {
-      resolve({ stdout: stdout.trim(), stderr: stderr.trim(), error })
-    })
-  })
-}
-
-export function createDefaultStore() {
-  const configPath = path.join(
-    process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'),
-    'mppx',
-    'default',
-  )
-  return {
-    get(): string {
-      try {
-        return fs.readFileSync(configPath, 'utf-8').trim() || 'main'
-      } catch {
-        return 'main'
-      }
-    },
-    set(value: string): void {
-      fs.mkdirSync(path.dirname(configPath), { recursive: true })
-      fs.writeFileSync(configPath, value, 'utf-8')
-    },
-    clear(): void {
-      try {
-        fs.unlinkSync(configPath)
-      } catch {}
-    },
-  }
-}
-
-export function resolveAccountName(explicit?: string): string {
-  if (explicit) return explicit
-  if (process.env.MPPX_ACCOUNT?.trim()) return process.env.MPPX_ACCOUNT
-  return createDefaultStore().get()
-}
-
-// biome-ignore format: compact shell commands
-export function createKeychain(account = 'main') {
-  const service = SERVICE_NAME
-  return {
-    async list(): Promise<string[]> {
-      const platform = os.platform()
-      if (platform === 'darwin') {
-        const { stdout, error } = await execCommand('security', ['dump-keychain'])
-        if (error) return []
-        const accounts: string[] = []
-        const blocks = stdout.split('keychain:')
-        for (const block of blocks) {
-          const serviceMatch = block.match(/"svce"<blob>="([^"]*)"/)
-          const accountMatch = block.match(/"acct"<blob>="([^"]*)"/)
-          if (serviceMatch?.[1] === service && accountMatch?.[1]) accounts.push(accountMatch[1])
-        }
-        return accounts
-      }
-      if (platform === 'linux') {
-        const { stdout, stderr, error } = await execCommand('secret-tool', [
-          'search',
-          '--all',
-          '--unlock',
-          'service',
-          service,
-        ])
-        assertSecretToolAvailable(error)
-        if (error) return []
-        const combined = `${stdout}\n${stderr}`
-        const accounts: string[] = []
-        const matches = combined.matchAll(/\baccount = (.+)/g)
-        for (const match of matches) if (match[1]) accounts.push(match[1])
-        return accounts
-      }
-      throw new Error(`Unsupported platform: ${platform}`)
-    },
-    async get(): Promise<string | undefined> {
-      const platform = os.platform()
-      if (platform === 'darwin') {
-        const { stdout, error } = await execCommand('security', [
-          'find-generic-password',
-          '-s',
-          service,
-          '-a',
-          account,
-          '-w',
-        ])
-        return error ? undefined : stdout
-      }
-      if (platform === 'linux') {
-        const { stdout, error } = await execCommand('secret-tool', [
-          'lookup',
-          'service',
-          service,
-          'account',
-          account,
-        ])
-        assertSecretToolAvailable(error)
-        return error ? undefined : stdout || undefined
-      }
-      throw new Error(`Unsupported platform: ${platform}`)
-    },
-    async set(value: string): Promise<void> {
-      const platform = os.platform()
-      if (platform === 'darwin') {
-        await execCommand('security', ['delete-generic-password', '-s', service, '-a', account])
-        const { error } = await execCommand('security', [
-          'add-generic-password',
-          '-s',
-          service,
-          '-a',
-          account,
-          '-w',
-          value,
-        ])
-        if (error) throw error
-        return
-      }
-      if (platform === 'linux') {
-        const proc = child.execFile('secret-tool', [
-          'store',
-          '--label',
-          `${service} ${account}`,
-          'service',
-          service,
-          'account',
-          account,
-        ])
-        const timeout = setTimeout(() => proc.kill(), commandTimeoutMs())
-        proc.stdin?.write(value)
-        proc.stdin?.end()
-        return new Promise((resolve, reject) => {
-          proc.on('close', (code) => {
-            clearTimeout(timeout)
-            if (code === 0) resolve()
-            else reject(new Error(`secret-tool exited with code ${code}`))
-          })
-          proc.on('error', (error) => {
-            clearTimeout(timeout)
-            reject(isMissingCommand(error, 'secret-tool') ? keyringUnavailableError(error) : error)
-          })
-        })
-      }
-      throw new Error(`Unsupported platform: ${platform}`)
-    },
-    async delete(): Promise<void> {
-      const platform = os.platform()
-      if (platform === 'darwin') {
-        await execCommand('security', ['delete-generic-password', '-s', service, '-a', account])
-        return
-      }
-      if (platform === 'linux') {
-        const { error } = await execCommand('secret-tool', [
-          'clear',
-          'service',
-          service,
-          'account',
-          account,
-        ])
-        assertSecretToolAvailable(error)
-        return
-      }
-      throw new Error(`Unsupported platform: ${platform}`)
-    },
-  }
-}
-
-/** Resolves a local CLI signer together with its durable account reference. */
-export async function resolveLocalAccount(name?: string) {
-  const { privateKeyToAccount } = await import('viem/accounts')
-
-  const envKey = process.env.MPPX_PRIVATE_KEY?.trim()
-  if (envKey)
-    return {
-      account: privateKeyToAccount(envKey as `0x${string}`),
-      source: 'environment' as const,
-    }
-
-  const accountName = resolveAccountName(name)
-  const key = await createKeychain(accountName).get()
-  if (key)
-    return {
-      account: privateKeyToAccount(key as `0x${string}`),
-      accountName,
-      source: 'keychain' as const,
-    }
-
-  throw new Error(`Account "${accountName}" not found.`)
-}
-
-/** Resolves an account supported by persistent CLI sessions. */
-export async function resolvePersistentAccount(name?: string) {
-  const accountName = resolveAccountName(name)
-  if (!process.env.MPPX_PRIVATE_KEY?.trim() && isTempoAccount(accountName))
-    throw new Errors.IncurError({
-      code: 'UNSUPPORTED_ACCOUNT',
-      message: 'Persistent sessions require an mppx account or MPPX_PRIVATE_KEY.',
-      exitCode: 2,
-    })
-  return resolveLocalAccount(name).catch((cause: unknown) => {
-    throw new Errors.IncurError({
-      code: 'ACCOUNT_NOT_FOUND',
-      message: cause instanceof Error ? cause.message : 'No account found.',
-      exitCode: 69,
-      ...(cause instanceof Error && { cause }),
-    })
-  })
-}
-
-/**
- * Resolve a CLI account to a viem `LocalAccount`.
- *
- * Resolution order:
- * 1. `MPPX_PRIVATE_KEY` environment variable
- * 2. OS keychain lookup for the named account
- *
- * @example
- * ```ts
- * import { resolveAccount } from 'mppx/cli'
- * import { tempo } from 'mppx/client'
- *
- * export default defineConfig({
- *   methods: [tempo({ account: await resolveAccount() })],
- * })
- * ```
- */
-export async function resolveAccount(name?: string) {
-  return (await resolveLocalAccount(name)).account
-}