weifuwu 0.24.0 → 0.24.2

package/dist/kb/types.d.ts

@@ -41,6 +41,14 @@ export interface KBListEntry {
     title: string;
     chunks: number;
 }
+export interface KBInjected {
+    search(query: string, searchOptions?: KBSearchOptions): Promise<KBSearchResult[]>;
+}
+declare module '../types.ts' {
+    interface Context {
+        kb?: KBInjected;
+    }
+}
 export interface KBModule {
     /**
      * Ingest a document: chunk → embed → store.

package/dist/live.d.ts

@@ -1,8 +1,7 @@
-import { Router } from './router.ts';
-import type { WebSocketHandler } from './router.ts';
+import { Router, type WebSocketHandler } from './router.ts';
 export declare function broadcastReload(): void;
 export declare function liveWs(): WebSocketHandler;
-export declare function liveRouter(dir: string): Router;
+export declare function liveRouter(_dir: string): Router;
 export declare function liveWatcher(dir: string): {
     close: () => void;
 };

package/dist/logdb/rest.d.ts

@@ -1,4 +1,4 @@
-import type { BoundTable } from '../postgres/schema/index.ts';
+import { type BoundTable } from '../postgres/schema/index.ts';
 import type { Context } from '../types.ts';
 export declare function createHandler(entries: BoundTable<any>): (req: Request, ctx: Context) => Promise<Response>;
 export declare function listHandler(entries: BoundTable<any>): (req: Request) => Promise<Response>;

package/dist/logdb/types.d.ts

@@ -1,5 +1,6 @@
 import type { PostgresClient } from '../postgres/types.ts';
 import type { Router } from '../router.ts';
+import type { Closeable } from '../types.ts';
 export interface LogdbOptions {
     pg: PostgresClient;
     table?: string;
@@ -18,7 +19,7 @@ export interface LogEntryInput {
     message: string;
     metadata?: Record<string, unknown>;
 }
-export interface LogdbModule extends Router {
+export interface LogdbModule extends Router, Closeable {
     log(input: LogEntryInput): Promise<LogEntry>;
     migrate(): Promise<void>;
     clean(retentionMonths: number): Promise<number>;

package/dist/mailer.d.ts

@@ -1,4 +1,5 @@
-import type { Transporter } from 'nodemailer';
+import { type Transporter } from 'nodemailer';
+import type { Closeable } from './types.ts';
 /** Options for sending an email. */
 export interface MailOptions {
     /** Recipient address(es). */
@@ -26,7 +27,7 @@ export interface MailerOptions {
     send?: (opts: MailOptions) => Promise<void>;
 }
 /** Mailer instance returned by {@link mailer}. */
-export interface Mailer {
+export interface Mailer extends Closeable {
     /** Send an email. */
     send: (opts: MailOptions) => Promise<void>;
     /** Close the nodemailer transport. */

package/dist/messager/agent.d.ts

@@ -1,4 +1,4 @@
-import type { Sql } from '../vendor.ts';
+import type { SqlClient } from '../vendor.ts';
 import type { AgentModule } from '../agent/types.ts';
 import type { Hub } from '../hub.ts';
 /**
@@ -6,6 +6,6 @@ import type { Hub } from '../hub.ts';
  * - Streaming: broadcasts SSE text tokens in real-time
  * - Multi-round: passes recent channel history as conversation context
  */
-export declare function runAgentRouting(sql: Sql<{}>, messages: {
+export declare function runAgentRouting(sql: SqlClient, messages: {
     insert: (data: any) => Promise<any>;
 }, agents: AgentModule | undefined, hub: Hub, channelId: number, content: string, stream?: boolean, contextMessages?: number): Promise<void>;

package/dist/messager/rest.d.ts

@@ -1,10 +1,10 @@
-import type { Sql } from '../vendor.ts';
+import type { SqlClient } from '../vendor.ts';
 import { Router } from '../router.ts';
 import type { AgentModule } from '../agent/types.ts';
 import type { Hub } from '../hub.ts';
-import type { BoundTable } from '../postgres/schema/index.ts';
+import { type BoundTable } from '../postgres/schema/index.ts';
 interface RestDeps {
-    sql: Sql<{}>;
+    sql: SqlClient;
     channels: BoundTable<any>;
     members: BoundTable<any>;
     messages: BoundTable<any>;

package/dist/messager/types.d.ts

@@ -2,6 +2,7 @@ import type { Router } from '../router.ts';
 import type { AgentModule } from '../agent/types.ts';
 import type { PostgresClient } from '../postgres/types.ts';
 import type { Redis } from '../vendor.ts';
+import type { Closeable } from '../types.ts';
 export interface MessagerOptions {
     pg: PostgresClient;
     agents?: AgentModule;
@@ -37,7 +38,7 @@ export interface Message {
     mime_type: string | null;
     created_at: string;
 }
-export interface MessagerModule extends Router {
+export interface MessagerModule extends Router, Closeable {
     migrate: () => Promise<void>;
     wsHandler: () => any;
     send: (channelId: number, content: string, opts?: {

package/dist/messager/ws.d.ts

@@ -1,8 +1,8 @@
-import type { Sql } from '../vendor.ts';
+import type { SqlClient } from '../vendor.ts';
 import type { AgentModule } from '../agent/types.ts';
-import type { Hub } from '../hub.ts';
+import { type Hub } from '../hub.ts';
 interface WSDeps {
-    sql: Sql<{}>;
+    sql: SqlClient;
     agents?: AgentModule;
     redis?: import('../vendor.ts').Redis;
 }

package/dist/opencode/index.d.ts

@@ -1,2 +1,2 @@
 export { opencode } from './client.ts';
-export type { OpencodeOptions, OpencodeModule, SkillDef, SkillRegistry, OpencodePermissions, Session } from './types.ts';
+export type { OpencodeOptions, OpencodeModule, SkillDef, SkillRegistry, OpencodePermissions, Session, } from './types.ts';

package/dist/opencode/permissions.d.ts

@@ -1,5 +1,5 @@
 import type { OpencodePermissions } from './types.ts';
 export declare function isCommandAllowed(command: string): boolean;
-export declare function isPathAllowed(resolvedPath: string, workspace: string, perms?: OpencodePermissions): boolean;
+export declare function isPathAllowed(resolvedPath: string, workspace: string, _perms?: OpencodePermissions): boolean;
 export declare function isToolEnabled(name: string, perms?: OpencodePermissions): boolean;
 export declare function isSkillAllowed(name: string, perms?: OpencodePermissions): boolean;

package/dist/opencode/run.d.ts

@@ -1,5 +1,5 @@
 import { type LanguageModel, type Tool } from 'ai';
-import type { SessionMessage } from './session.ts';
+import { type SessionMessage } from './session.ts';
 export interface ExecuteOptions {
     sessionId: string;
     input: string;

package/dist/opencode/session.d.ts

@@ -1,15 +1,15 @@
-import type { Sql } from '../vendor.ts';
+import type { SqlClient } from '../vendor.ts';
 import type { Session, Message } from './types.ts';
-export declare function createSession(sql: Sql<{}>, opts: {
+export declare function createSession(sql: SqlClient, opts: {
     userId?: number;
     title?: string;
     model?: string;
     systemPrompt?: string;
 }, cwd: string, mountPath: string): Promise<Session>;
-export declare function getSession(sql: Sql<{}>, id: string): Promise<Session | null>;
-export declare function listSessions(sql: Sql<{}>, userId?: number): Promise<Session[]>;
-export declare function deleteSession(sql: Sql<{}>, id: string): Promise<void>;
-export declare function getHistory(sql: Sql<{}>, sessionId: string, limit?: number): Promise<SessionMessage[]>;
+export declare function getSession(sql: SqlClient, id: string): Promise<Session | null>;
+export declare function listSessions(sql: SqlClient, userId?: number): Promise<Session[]>;
+export declare function deleteSession(sql: SqlClient, id: string): Promise<void>;
+export declare function getHistory(sql: SqlClient, sessionId: string, limit?: number): Promise<SessionMessage[]>;
 export interface SessionMessage {
     id: number;
     session_id: string;
@@ -21,6 +21,6 @@ export interface SessionMessage {
     tokens_out: number;
     created_at: string;
 }
-export declare function addTextMessage(sql: Sql<{}>, sessionId: string, role: 'user' | 'assistant', content: string, tokensIn?: number, tokensOut?: number): Promise<Message>;
-export declare function addToolMessages(sql: Sql<{}>, sessionId: string, toolCalls: unknown[], toolResults: unknown[]): Promise<Message>;
-export declare function updateSessionTitle(sql: Sql<{}>, id: string, title: string): Promise<void>;
+export declare function addTextMessage(sql: SqlClient, sessionId: string, role: 'user' | 'assistant', content: string, tokensIn?: number, tokensOut?: number): Promise<Message>;
+export declare function addToolMessages(sql: SqlClient, sessionId: string, toolCalls: unknown[], toolResults: unknown[]): Promise<Message>;
+export declare function updateSessionTitle(sql: SqlClient, id: string, title: string): Promise<void>;

package/dist/opencode/tools/web.d.ts

@@ -1,5 +1,5 @@
 import type { ToolContext } from './index.ts';
-export declare function createWebTool(ctx: ToolContext): import("ai").Tool<{
+export declare function createWebTool(_ctx: ToolContext): import("ai").Tool<{
     url: string;
 }, {
     content: string;

package/dist/opencode/types.d.ts

@@ -1,5 +1,6 @@
 import type { Router } from '../router.ts';
 import type { PostgresClient } from '../postgres/types.ts';
+import type { Closeable } from '../types.ts';
 export interface Session {
     id: string;
     tenant_id: string | null;
@@ -74,7 +75,7 @@ export interface OpencodeOptions {
     skills?: SkillDef[];
     permissions?: OpencodePermissions;
 }
-export interface OpencodeModule extends Router {
+export interface OpencodeModule extends Router, Closeable {
     migrate: () => Promise<void>;
     wsHandler: () => any;
     close: () => Promise<void>;

package/dist/opencode/ws.d.ts

@@ -1,8 +1,7 @@
 import type { WebSocket } from '../vendor.ts';
 import type { LanguageModel } from 'ai';
 import type { Context } from '../types.ts';
-import type { PendingQuestion, SkillDef, SkillRegistry } from './types.ts';
-import type { OpencodePermissions } from './types.ts';
+import type { PendingQuestion, SkillDef, SkillRegistry, OpencodePermissions } from './types.ts';
 interface WsDeps {
     sql: any;
     model: LanguageModel;

package/dist/permissions.d.ts

@@ -1,4 +1,4 @@
-import type { Sql } from './vendor.ts';
+import type { SqlClient } from './vendor.ts';
 import type { Middleware, Context, Handler } from './types.ts';
 declare module './types.ts' {
     interface Context {
@@ -11,7 +11,7 @@ declare module './types.ts' {
 export interface PermissionsOptions {
     /** PostgreSQL client. */
     pg: {
-        sql: Sql<{}>;
+        sql: SqlClient;
     };
     /** Table prefix (default: '' → _roles, _user_roles, _role_permissions). */
     prefix?: string;
@@ -39,12 +39,12 @@ export interface PermissionsModule extends Middleware {
      * Middleware that rejects the request if the user does not have any of the specified roles.
      * Must be placed after `permissions()` middleware (which injects ctx.permissions.roles).
      */
-    requireRole(...roles: string[]): Middleware;
+    requireRole(...roles: string[]): Middleware<Context, Context>;
     /**
      * Middleware that rejects the request if the user does not have all specified permissions.
      * Must be placed after `permissions()` middleware (which injects ctx.permissions.permissions).
      */
-    requirePermission(...permissions: string[]): Middleware;
+    requirePermission(...permissions: string[]): Middleware<Context, Context>;
     /** Create the underlying tables. Safe to call multiple times. */
     migrate(): Promise<void>;
 }

package/dist/postgres/module.d.ts

@@ -1,14 +1,15 @@
 import type { PostgresClient } from './types.ts';
-import type { Sql } from '../vendor.ts';
+import type { SqlClient } from '../vendor.ts';
 import type { ColumnBuilder, BoundTable, Table } from './schema/index.ts';
-export declare class PgModule {
-    protected sql: Sql<{}>;
+import type { Closeable } from '../types.ts';
+export declare class PgModule implements Closeable {
+    protected sql: SqlClient;
     protected pg: PostgresClient;
     constructor(pg: PostgresClient);
     table<R extends Record<string, unknown>>(tableOrSchema: string | Table<R>, builders?: {
         [K in keyof R]: ColumnBuilder<R[K]>;
     }): BoundTable<R>;
-    transaction<T>(fn: (sql: Sql<{}>) => Promise<T>, retryOpts?: {
+    transaction<T>(fn: (sql: SqlClient) => Promise<T>, retryOpts?: {
         maxRetries?: number;
     }): Promise<T>;
     migrate(): Promise<void>;

package/dist/postgres/schema/index.d.ts

@@ -3,4 +3,4 @@ export { ColumnBuilder, serial, uuid, text, integer, boolean as boolean, boolean
 export type { PartitionByDef } from './columns.ts';
 export { pgTable, Table, BoundTable } from './table.ts';
 export type { IndexOptions, FindOptions, CreateOptions } from './table.ts';
-export { eq, ne, gt, gte, lt, lte, isNull, isNotNull, like, contains, in_, and, or, not } from './where.ts';
+export { eq, ne, gt, gte, lt, lte, isNull, isNotNull, like, contains, in_, and, or, not, } from './where.ts';

package/dist/postgres/schema/table.d.ts

@@ -1,4 +1,4 @@
-import type { Sql } from '../../vendor.ts';
+import type { SqlClient } from '../../vendor.ts';
 import { ColumnBuilder, type PartitionByDef } from './columns.ts';
 import { SQL } from './sql.ts';
 /** Options for table index creation. */
@@ -64,39 +64,41 @@ export declare class Table<R extends Record<string, unknown>> {
      * Bind this table schema to a SQL connection, returning a `BoundTable`
      * that can run queries without passing `sql` to every call.
      */
-    bind(sql: Sql<{}>): BoundTable<R>;
+    bind(sql: SqlClient): BoundTable<R>;
     /** Returns the primary key column name (DB name), or 'id' as fallback. */
     private get pkColumn();
     /** Adds `deleted_at IS NULL` condition if the table has soft delete and not explicitly excluded. */
     private _softDeleteFilter;
-    create(sql: Sql<{}>, opts?: CreateOptions): Promise<void>;
-    drop(sql: Sql<{}>, opts?: {
+    create(sql: SqlClient, opts?: CreateOptions): Promise<void>;
+    drop(sql: SqlClient, opts?: {
         cascade?: boolean;
     }): Promise<void>;
-    createIndex(sql: Sql<{}>, columns: string | string[], opts?: IndexOptions): Promise<void>;
-    createUniqueIndex(sql: Sql<{}>, columns: string | string[]): Promise<void>;
+    createIndex(sql: SqlClient, columns: string | string[], opts?: IndexOptions): Promise<void>;
+    createUniqueIndex(sql: SqlClient, columns: string | string[]): Promise<void>;
     private _buildConditions;
     private _buildSET;
-    insert(sql: Sql<{}>, data: Partial<R>): Promise<R>;
-    insertMany(sql: Sql<{}>, data: Partial<R>[]): Promise<R[]>;
-    read(sql: Sql<{}>, id: string | number, opts?: Pick<FindOptions, 'select' | 'withDeleted'>): Promise<R | undefined>;
-    readMany(sql: Sql<{}>, where?: Partial<R> | SQL | SQL[], opts?: FindOptions): Promise<{
+    insert(sql: SqlClient, data: Partial<R>): Promise<R>;
+    insertMany(sql: SqlClient, data: Partial<R>[]): Promise<R[]>;
+    read(sql: SqlClient, id: string | number, opts?: Pick<FindOptions, 'select' | 'withDeleted'>): Promise<R | undefined>;
+    readMany(sql: SqlClient, where?: Partial<R> | SQL | SQL[], opts?: FindOptions): Promise<{
         count: number;
         data: R[];
     }>;
-    update(sql: Sql<{}>, id: string | number, data: Partial<R>): Promise<R | undefined>;
-    updateMany(sql: Sql<{}>, where: Partial<R> | SQL | SQL[], data: Partial<R>): Promise<number>;
-    delete(sql: Sql<{}>, id: string | number): Promise<R | undefined>;
-    hardDelete(sql: Sql<{}>, id: string | number): Promise<R | undefined>;
-    deleteMany(sql: Sql<{}>, where: Partial<R> | SQL | SQL[]): Promise<number>;
-    hardDeleteMany(sql: Sql<{}>, where: Partial<R> | SQL | SQL[]): Promise<number>;
-    upsert(sql: Sql<{}>, data: Partial<R>, conflict: string | string[]): Promise<R>;
-    count(sql: Sql<{}>, where?: Partial<R> | SQL | SQL[]): Promise<number>;
+    update(sql: SqlClient, id: string | number, data: Partial<R>): Promise<R | undefined>;
+    updateMany(sql: SqlClient, where: Partial<R> | SQL | SQL[], data: Partial<R>): Promise<number>;
+    delete(sql: SqlClient, id: string | number): Promise<R | undefined>;
+    hardDelete(sql: SqlClient, id: string | number): Promise<R | undefined>;
+    deleteMany(sql: SqlClient, where: Partial<R> | SQL | SQL[]): Promise<number>;
+    hardDeleteMany(sql: SqlClient, where: Partial<R> | SQL | SQL[]): Promise<number>;
+    upsert(sql: SqlClient, data: Partial<R>, conflict: string | string[]): Promise<R>;
+    count(sql: SqlClient, where?: Partial<R> | SQL | SQL[]): Promise<number>;
 }
 export declare class BoundTable<R extends Record<string, unknown>> {
     private inner;
     private sql;
-    constructor(sql: Sql<{}>, tableName: string, builders: Record<string, ColumnBuilder<unknown>>);
+    /** The underlying table name. */
+    get tableName(): string;
+    constructor(sql: SqlClient, tableName: string, builders: Record<string, ColumnBuilder<unknown>>);
     create(opts?: CreateOptions): Promise<void>;
     drop(opts?: {
         cascade?: boolean;
@@ -118,7 +120,7 @@ export declare class BoundTable<R extends Record<string, unknown>> {
     hardDeleteMany(where: Partial<R> | SQL | SQL[]): Promise<number>;
     upsert(data: Partial<R>, conflict: string | string[]): Promise<R>;
     count(where?: Partial<R> | SQL | SQL[]): Promise<number>;
-    withSql(sql: Sql<{}>): BoundTable<R>;
+    withSql(sql: SqlClient): BoundTable<R>;
 }
 /**
  * Define a type-safe table schema.

package/dist/postgres/types.d.ts

@@ -1,13 +1,13 @@
-import type { Sql } from '../vendor.ts';
-import type { Context, Middleware } from '../types.ts';
+import type { SqlClient } from '../vendor.ts';
+import type { Context, Middleware, Closeable } from '../types.ts';
 import type { ColumnBuilder, BoundTable, Table } from './schema/index.ts';
 declare module '../types.ts' {
     interface Context {
-        sql: Sql<{}>;
+        sql: SqlClient;
     }
 }
 export interface PostgresInjected {
-    sql: Sql<{}>;
+    sql: SqlClient;
 }
 export interface PostgresOptions {
     connection?: string | Record<string, unknown>;
@@ -22,8 +22,8 @@ export interface PostgresOptions {
     /** Called after every query completes. Receives query text, duration in ms, and row count. */
     onQuery?: (query: string, durationMs: number, rowCount: number) => void;
 }
-export interface PostgresClient extends Middleware<Context, Context & PostgresInjected> {
-    sql: Sql<{}>;
+export interface PostgresClient extends Middleware<Context, Context & PostgresInjected>, Closeable {
+    sql: SqlClient;
     /** Creates the migration tracking table (_weifuwu_migrations). Called once at startup. */
     migrate: () => Promise<void>;
     /** Record that a module's migration has been applied (idempotent). */

package/dist/queue/types.d.ts

@@ -1,5 +1,5 @@
 import type { Redis } from '../vendor.ts';
-import type { Context, Middleware } from '../types.ts';
+import type { Context, Middleware, Closeable } from '../types.ts';
 declare module '../types.ts' {
     interface Context {
         queue: Queue;
@@ -22,7 +22,7 @@ export interface QueueOptions {
     pollInterval?: number;
     /** PostgreSQL client (required when store: 'pg'). */
     pg?: {
-        sql: import('../vendor.ts').Sql<{}>;
+        sql: import('../vendor.ts').SqlClient;
     };
 }
 export interface QueueInjected {
@@ -32,7 +32,7 @@ export interface QueueJobWithError<T = unknown> extends QueueJob<T> {
     error: string;
     failedAt: number;
 }
-export interface Queue extends Middleware<Context, Context & QueueInjected> {
+export interface Queue extends Middleware<Context, Context & QueueInjected>, Closeable {
     /** Register a cron job. Uses queue's backend (memory/pg/redis) for execution. */
     cron(pattern: string, handler: () => void | Promise<void>): {
         stop: () => void;

package/dist/rate-limit.d.ts

@@ -34,7 +34,7 @@ export interface RateLimitOptions {
  * app.use(rateLimit({ store: 'redis', redis: new Redis(), max: 100 }))
  * ```
  */
-export declare function rateLimit(options?: RateLimitOptions): Middleware & {
+export declare function rateLimit(options?: RateLimitOptions): Middleware<Context, Context> & {
     close: () => void;
     stop?: () => void;
 };

package/dist/react.d.ts

@@ -11,4 +11,4 @@ export { useLocale } from './client-locale.ts';
 export { useTheme, applyTheme } from './client-theme.ts';
 export { useFlashMessage } from './use-flash-message.ts';
 export { useAgentStream } from './use-agent-stream.ts';
-export type { UseAgentStreamOptions, UseAgentStreamReturn, AgentStreamState } from './use-agent-stream.ts';
+export type { UseAgentStreamOptions, UseAgentStreamReturn, AgentStreamState, } from './use-agent-stream.ts';