weifuwu 0.25.2 → 0.27.0

package/dist/user/client.d.ts

@@ -1,30 +0,0 @@
-import type { UserOptions, UserData, UserModule } from './types.ts';
-declare module '../types.ts' {
-    interface Context {
-        user: UserData;
-    }
-}
-/**
- * User authentication module — local register/login, JWT verification, OAuth2 server, social login.
- * Supports DB-less auth via tokens/verify/proxy options.
- *
- * ```ts
- * // Full auth with DB
- * import { user, postgres } from 'weifuwu'
- * const pg = postgres({ connection: DATABASE_URL })
- * const auth = user({ pg, jwtSecret: process.env.JWT_SECRET })
- *
- * await auth.migrate()
- * app.use(auth.middleware())   // inject ctx.user
- * app.use('/', auth)           // /register, /login
- *
- * // DB-less token auth
- * const auth = user({ tokens: ['sk-123', 'sk-456'] })
- * app.use(auth.middleware())   // injects ctx.user for valid tokens
- *
- * // DB-less custom verify
- * const auth = user({ verify: async (token) => validateToken(token) })
- * app.use(auth.middleware())
- * ```
- */
-export declare function user(options: UserOptions): UserModule;

package/dist/user/index.d.ts

@@ -1,2 +0,0 @@
-export { user } from './client.ts';
-export type { UserOptions, UserData, UserModule, AuthResult, OAuth2Client, OAuthProviderConfig, UserInjected, } from './types.ts';

package/dist/user/oauth-login.d.ts

@@ -1,21 +0,0 @@
-import type { SqlClient } from '../vendor.ts';
-import type { Router } from '../router.ts';
-import type { OAuthProviderConfig } from './types.ts';
-interface OAuthLoginDeps {
-    sql: SqlClient;
-    jwtSecret: string;
-    expiresIn: string | number;
-    usersTable: string;
-    /** Table for provider-user link, derived from usersTable. */
-    providerTable: string;
-    redirectUrl: string;
-    signToken: (user: Record<string, unknown>) => string;
-    /** Create a placeholder user for OAuth login (no password). */
-    createPlaceholderUser: (email: string, name: string) => Promise<Record<string, unknown>>;
-    /** Find user by internal ID. */
-    findUserById: (id: number) => Promise<Record<string, unknown> | undefined>;
-    /** Find user by email. */
-    findUserByEmail: (email: string) => Promise<Record<string, unknown> | undefined>;
-}
-export declare function registerOAuthLoginRoutes(router: Router, deps: OAuthLoginDeps, providers: Record<string, OAuthProviderConfig>): void;
-export {};

package/dist/user/oauth2.d.ts

@@ -1,31 +0,0 @@
-import type { Context } from '../types.ts';
-import type { OAuth2Client } from './types.ts';
-import type { BoundTable } from '../postgres/schema/index.ts';
-interface OAuth2Deps {
-    pg: any;
-    users: BoundTable<any>;
-    jwtSecret: string;
-    expiresIn: string | number;
-}
-/**
- * Create an OAuth2 authorization code server.
- *
- * Registers routes:
- * - `GET /oauth/authorize` — authorization page (user consent)
- * - `POST /oauth/consent` — user grants/denies access
- * - `POST /oauth/token` — exchange code for access token
- *
- * Used internally by the user module when `oauth2: { server: true }` is set.
- */
-export declare function createOAuth2Server(deps: OAuth2Deps): {
-    authorizeHandler: (req: Request, _ctx: Context) => Promise<Response>;
-    consentHandler: (req: Request) => Promise<Response>;
-    tokenHandler: (req: Request) => Promise<Response>;
-    registerClient: (data: {
-        name: string;
-        redirectUris: string[];
-    }) => Promise<OAuth2Client>;
-    getClient: (clientId: string) => Promise<OAuth2Client | null>;
-    revokeClient: (clientId: string) => Promise<void>;
-};
-export {};

package/dist/user/types.d.ts

@@ -1,178 +0,0 @@
-import type { Middleware, Context, Closeable } from '../types.ts';
-import type { Router } from '../router.ts';
-import type { PostgresClient } from '../postgres/types.ts';
-/** A user record from the database. */
-export interface UserData {
-    id: number;
-    email: string;
-    name: string;
-    role: string;
-    created_at: Date;
-    updated_at: Date;
-}
-/** Result of a successful register or login. */
-export interface AuthResult {
-    /** User data (excluding password hash). */
-    user: Omit<UserData, 'password'>;
-    /** Signed JWT token. */
-    token: string;
-}
-/** An OAuth2 client application registered with the server. */
-export interface OAuth2Client {
-    id: number;
-    name: string;
-    clientId: string;
-    clientSecret: string;
-    redirectUris: string[];
-    scopes: string;
-}
-/** Enable OAuth2 server mode (authorization code flow). */
-export interface OAuth2ServerOptions {
-    server: true;
-}
-/** Configuration for an OAuth login provider (e.g. GitHub, Google). */
-export interface OAuthProviderConfig {
-    /** OAuth app client ID. */
-    clientId: string;
-    /** OAuth app client secret. */
-    clientSecret: string;
-    /** Scopes to request (default: `'openid profile email'`). */
-    scope?: string;
-    /** Custom auth URL (overrides built-in provider default). */
-    authUrl?: string;
-    /** Custom token URL (overrides built-in provider default). */
-    tokenUrl?: string;
-    /** Custom user info URL (overrides built-in provider default). */
-    userUrl?: string;
-    /**
-     * Custom user parser.
-     * Required when any of `authUrl`/`tokenUrl`/`userUrl` is custom.
-     * Receives the raw response from `userUrl` + the access token.
-     */
-    parseUser?: (data: any, accessToken: string) => {
-        id: string;
-        email: string;
-        name: string;
-        avatarUrl?: string;
-    };
-}
-/** Options for {@link user}. */
-export interface UserOptions {
-    /** PostgreSQL client for user storage. Omit for DB-less token/verify/proxy auth. */
-    pg?: PostgresClient;
-    /** Secret key for JWT signing. Required for JWT auth and login/register routes. */
-    jwtSecret?: string;
-    /** Custom table name for users (default: `'users'`). */
-    table?: string;
-    /** JWT expiration time (default: `'7d'`). */
-    expiresIn?: string | number;
-    /** Static token(s) for simple bearer auth. No DB or JWT needed. */
-    tokens?: string[];
-    /** Custom verify function. Receives the token and request, returns user data or null. */
-    verify?: (token: string, req: Request) => unknown | Promise<unknown>;
-    /** Proxy auth — forward request to an external auth service for validation. */
-    proxy?: string | URL;
-    /** Custom header name for token extraction (default: `'Authorization'`). */
-    header?: string;
-    /**
-     * Function to load user data from a user ID stored in the session.
-     * Called when `ctx.session.userId` is present. Only used when `pg` is not provided.
-     * Return a falsy value to reject (e.g. if the user was deleted).
-     * If not provided and no pg, `ctx.user` is set to `{ id: userId }`.
-     */
-    resolveUser?: (userId: unknown) => unknown | Promise<unknown>;
-    /** Enable API key management (per-user keys with scopes). */
-    apiKeys?: boolean;
-    /** Enable OAuth2 server mode (authorization code flow). */
-    oauth2?: OAuth2ServerOptions;
-    /**
-     * OAuth login providers (login with GitHub/Google).
-     * Registers `GET /auth/:provider` and `GET /auth/:provider/callback` routes.
-     */
-    oauthLogin?: {
-        /** Map of provider name to config (e.g. `{ github: {...}, google: {...} }`). */
-        providers: Record<string, OAuthProviderConfig>;
-        /** Redirect URL after successful login (default: `'/'`). */
-        redirectUrl?: string;
-    };
-}
-/** The shape of `ctx.user` when the user middleware is active. */
-export interface UserInjected {
-    user: UserData;
-}
-/**
- * User module returned by {@link user}. Provides auth routes, middleware, and programmatic API.
- *
- * ```ts
- * const auth = user({ pg, jwtSecret: process.env.JWT_SECRET })
- * app.use(auth.middleware())   // injects ctx.user on every request
- * app.use('/', auth)           // mounts routes: /register, /login
- * ```
- */
-export interface UserModule extends Router, Closeable {
-    /**
-     * Strict auth middleware. Reads JWT from `Authorization: Bearer` header.
-     * Returns 401 if no valid token is found.
-     * Use for routes that require authentication.
-     */
-    middleware: () => Middleware<Context, Context & UserInjected>;
-    /**
-     * Optional auth middleware. Reads JWT from `Authorization` header or `token` cookie.
-     * Sets `ctx.user` if a valid token is present, but does **not** block unauthenticated requests.
-     * Use as a global middleware when some routes are public and some are protected.
-     *
-     * ```ts
-     * app.use(auth.middlewareOptional({ cookie: 'token' }))
-     * app.get('/profile', auth.middleware(), handler)  // protected
-     * app.get('/', handler)                              // public
-     * ```
-     */
-    middlewareOptional: (opts?: {
-        cookie?: string;
-    }) => Middleware;
-    /** Create the users table. */
-    migrate: () => Promise<void>;
-    /** Register a new user. Returns user data + JWT. */
-    register: (data: {
-        email: string;
-        password: string;
-        name: string;
-    }) => Promise<AuthResult>;
-    /** Authenticate by email + password. Returns user data + JWT. */
-    login: (data: {
-        email: string;
-        password: string;
-    }) => Promise<AuthResult>;
-    /** Verify a JWT and return the user data (or null if invalid). */
-    verify: (token: string) => Promise<Omit<UserData, 'password'> | null>;
-    /** Register a new OAuth2 client application. */
-    registerClient: (data: {
-        name: string;
-        redirectUris: string[];
-    }) => Promise<OAuth2Client>;
-    /** Look up an OAuth2 client by clientId. */
-    getClient: (clientId: string) => Promise<OAuth2Client | null>;
-    /** Revoke an OAuth2 client. */
-    revokeClient: (clientId: string) => Promise<void>;
-    /** Create a new API key for a user. Returns the full key (only shown once). */
-    createApiKey: (userId: number, name: string, scopes?: string[]) => Promise<{
-        id: number;
-        key: string;
-    }>;
-    /** List user\'s API keys (masked — only prefix + last 4 chars visible). */
-    listApiKeys: (userId: number) => Promise<ApiKeyInfo[]>;
-    /** Revoke an API key by ID. */
-    revokeApiKey: (userId: number, keyId: number) => Promise<void>;
-    /** Close the underlying DB connection. */
-    close: () => Promise<void>;
-}
-/** An API key record (as returned by listApiKeys — masked). */
-export interface ApiKeyInfo {
-    id: number;
-    name: string;
-    prefix: string;
-    scopes: string[];
-    last_used_at: string | null;
-    created_at: string;
-    revoked: boolean;
-}

package/dist/validate.d.ts

@@ -1,32 +0,0 @@
-import type { ZodSchema } from 'zod';
-import type { Middleware } from './types.ts';
-declare module './types.ts' {
-    interface Context {
-        parsed: Record<string, unknown>;
-    }
-}
-/** Validation middleware — a {@link Middleware} that injects `ctx.parsed` with validated data. */
-export type ValidateModule = Middleware;
-export interface ValidationSchemas {
-    body?: ZodSchema;
-    query?: ZodSchema;
-    params?: ZodSchema;
-    headers?: ZodSchema;
-}
-/**
- * Request validation middleware using Zod schemas.
- *
- * Validates `params`, `query`, `body`, and/or `headers` against schemas.
- * Returns 422 with error details on mismatch.
- * Injects `ctx.parsed` with validated-and-transformed values.
- *
- * ```ts
- * import { z } from 'zod'
- *
- * app.get('/users/:id', validate({
- *   params: z.object({ id: z.string() }),
- *   query: z.object({ include: z.string().optional() }),
- * }), handler)
- * ```
- */
-export declare function validate(schemas?: ValidationSchemas): Middleware;

package/dist/vendor.d.ts

@@ -1,7 +0,0 @@
-import type postgres from 'postgres';
-/** Untyped postgres.js SQL client. Use typed `Sql<{ table: { col: type } }>` for schemas. */
-export type SqlClient = postgres.Sql<Record<string, unknown>>;
-/** Re-export for downstream usage. */
-export type { Sql } from 'postgres';
-export type { WebSocket } from 'ws';
-export type { Redis, RedisOptions } from 'ioredis';

package/dist/webhook.d.ts

@@ -1,79 +0,0 @@
-import type { Context } from './types.ts';
-import { Router } from './router.ts';
-/** A parsed webhook event delivered to handlers. */
-export interface WebhookEvent {
-    /** Raw event name from the provider (e.g. 'checkout.session.completed'). */
-    event: string;
-    /** Parsed event payload (body after verification). */
-    payload: unknown;
-    /** Provider name (e.g. 'stripe', 'github'). */
-    provider: string;
-    /** Unique event ID for replay protection. */
-    id?: string;
-}
-/** Handler function for a webhook event. */
-export interface WebhookHandler {
-    (event: WebhookEvent, ctx: Context): void | Promise<void>;
-}
-/** Configuration for a built-in platform webhook verifier (Stripe, GitHub, Slack). */
-export interface PlatformConfig {
-    /** HMAC-SHA256 signing secret. */
-    secret: string;
-    /** Optional event prefix (default: platform name, e.g. 'stripe'). */
-    prefix?: string;
-}
-/** Configuration for a custom webhook verifier. */
-export interface CustomVerifierConfig {
-    /** Name for this verifier. */
-    name: string;
-    /** Verify function. Return true if signature is valid. */
-    verify: (body: string, headers: Record<string, string>) => boolean | Promise<boolean>;
-    /** Extract event name from body and headers */
-    event: (body: unknown, headers: Record<string, string>) => string;
-}
-/** Options for {@link webhook}. */
-export interface WebhookOptions {
-    /** Stripe webhook config (enables Stripe signature verification). */
-    stripe?: PlatformConfig;
-    /** GitHub webhook config. */
-    github?: PlatformConfig;
-    /** Slack webhook config. */
-    slack?: PlatformConfig;
-    /** Custom verifiers. */
-    custom?: CustomVerifierConfig[];
-    /** Global prefix for all event types (default: none). */
-    prefix?: string;
-    /** Path to mount the webhook receiver. Default: `'/'`. */
-    path?: string;
-    /** Enable replay protection (requires provider to send unique event IDs). Default: true. */
-    replayProtection?: boolean;
-    /** Idempotency key TTL in ms. Default: 3600000 (1 hour). */
-    idempotencyTTL?: number;
-}
-/** Webhook module instance returned by {@link webhook}. */
-export interface WebhookModule extends Router {
-    /** Register an event handler. */
-    on(event: string, handler: WebhookHandler): this;
-    /** Remove an event handler. */
-    off(event: string, handler: WebhookHandler): this;
-}
-/**
- * Webhook receiver module. Validates signatures and dispatches events.
- *
- * Supports built-in verifiers for Stripe, GitHub, and Slack, plus custom verifiers.
- *
- * ```ts
- * import { webhook } from 'weifuwu'
- *
- * const wh = webhook({
- *   stripe: { secret: process.env.STRIPE_WEBHOOK_SECRET },
- * })
- *
- * wh.on('checkout.session.completed', async (event, ctx) => {
- *   // event.payload contains the parsed Stripe event
- * })
- *
- * app.use('/', wh)
- * ```
- */
-export declare function webhook(options?: WebhookOptions): WebhookModule;

package/opencode/ui/app/globals.css

@@ -1 +0,0 @@
-@import 'tailwindcss';

package/opencode/ui/app/layout.tsx

@@ -1,13 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-export default function RootLayout({ children }: { children: any }) {
-  return (
-    <html lang="en">
-      <head>
-        <meta charSet="utf-8" />
-        <meta name="viewport" content="width=device-width, initial-scale=1" />
-        <title>Opencode Chat</title>
-      </head>
-      <body>{children}</body>
-    </html>
-  )
-}