@hachej/boring-ask-user 0.1.13

package/dist/server/index.d.ts

@@ -0,0 +1,205 @@
+import { UiBridge, WorkspaceServerPlugin } from '@hachej/boring-workspace/server';
+import { A as AskUserQuestion, a as AskUserAnswer, b as AskUserTranscriptEvent, c as AskUserToolResult, d as AskUserCancelReason, e as AskUserRequest, Q as QuestionsCommand, f as AskUserField, g as AskUserAnswerValue } from '../types-CF72YmK-.js';
+export { h as ASK_USER_PLUGIN_ID } from '../types-CF72YmK-.js';
+import { FastifyRequest, FastifyInstance } from 'fastify';
+
+declare class AskUserStoreError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+type AskUserStoreChange = {
+    sessionId: string;
+    questionId?: string;
+    reason: "create" | "answer" | "cancel" | "abandon" | "clear" | "transcript";
+};
+type AskUserStoreListener = (change: AskUserStoreChange) => void;
+interface AskUserStore {
+    getPending(sessionId: string): Promise<AskUserQuestion | null>;
+    getByQuestionId(questionId: string): Promise<AskUserQuestion | null>;
+    createPending(question: AskUserQuestion): Promise<void>;
+    answer(questionId: string, answer: AskUserAnswer): Promise<void>;
+    cancel(questionId: string): Promise<void>;
+    markAbandoned(questionId: string): Promise<void>;
+    clearPending(sessionId: string): Promise<void>;
+    appendTranscriptEvent(event: AskUserTranscriptEvent): Promise<void>;
+    listTranscriptEvents(sessionId: string): Promise<AskUserTranscriptEvent[]>;
+    getTranscriptEventsForQuestion(questionId: string): Promise<AskUserTranscriptEvent[]>;
+    subscribe(listener: AskUserStoreListener): () => void;
+}
+declare class FileAskUserStore implements AskUserStore {
+    private readonly filePath;
+    private state;
+    private writeChain;
+    private readonly listeners;
+    constructor(filePath: string);
+    getPending(sessionId: string): Promise<AskUserQuestion | null>;
+    getByQuestionId(questionId: string): Promise<AskUserQuestion | null>;
+    createPending(question: AskUserQuestion): Promise<void>;
+    answer(questionId: string, answer: AskUserAnswer): Promise<void>;
+    cancel(questionId: string): Promise<void>;
+    markAbandoned(questionId: string): Promise<void>;
+    clearPending(sessionId: string): Promise<void>;
+    appendTranscriptEvent(event: AskUserTranscriptEvent): Promise<void>;
+    listTranscriptEvents(sessionId: string): Promise<AskUserTranscriptEvent[]>;
+    getTranscriptEventsForQuestion(questionId: string): Promise<AskUserTranscriptEvent[]>;
+    subscribe(listener: AskUserStoreListener): () => void;
+    private mutate;
+    private load;
+    private save;
+    private emit;
+}
+
+declare class AskUserRuntimeError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+interface AskUserCoordinator {
+    registerWaiter(questionId: string, sessionId: string, signal?: AbortSignal): Promise<AskUserToolResult>;
+    hasWaiter(questionId: string): boolean;
+    resolveAnswered(questionId: string, answer: AskUserAnswer): boolean;
+    resolveCancelled(questionId: string, reason: AskUserCancelReason): boolean;
+}
+declare class InProcessAskUserCoordinator implements AskUserCoordinator {
+    private readonly waiters;
+    registerWaiter(questionId: string, sessionId: string, signal?: AbortSignal): Promise<AskUserToolResult>;
+    hasWaiter(questionId: string): boolean;
+    resolveAnswered(questionId: string, answer: AskUserAnswer): boolean;
+    resolveCancelled(questionId: string, reason: AskUserCancelReason): boolean;
+    private resolve;
+}
+type AskUserRuntimeOptions = {
+    store: AskUserStore;
+    coordinator?: AskUserCoordinator;
+    ownerPrincipalId?: string;
+    now?: () => Date;
+    limits?: {
+        perSessionPerMinute?: number;
+        perPrincipalPerHour?: number;
+    };
+    uiBridge?: UiBridge;
+};
+declare class AskUserRuntime {
+    readonly coordinator: AskUserCoordinator;
+    private readonly store;
+    private readonly ownerPrincipalId;
+    private readonly now;
+    private readonly perSessionPerMinute;
+    private readonly perPrincipalPerHour;
+    private readonly uiBridge?;
+    private readonly sessionBuckets;
+    private readonly principalBuckets;
+    constructor(options: AskUserRuntimeOptions);
+    abandonOrphanedPending(sessionIds: string[]): Promise<void>;
+    ask(request: AskUserRequest, signal?: AbortSignal): Promise<AskUserToolResult>;
+    submitAnswer(questionId: string, sessionId: string, values: AskUserAnswer["values"]): Promise<"answered" | "abandoned">;
+    cancelQuestion(questionId: string, sessionId: string, reason?: AskUserCancelReason): Promise<void>;
+    private waitForAnswerWithOpen;
+    private openQuestionSurface;
+    private waitForAnswer;
+    private abandon;
+    private createQuestion;
+    private assertAllowed;
+    private consume;
+    private isoNow;
+}
+declare function requireAskUserRuntime(runtime: AskUserRuntime | null | undefined): AskUserRuntime;
+
+declare class QuestionsBridgeError extends Error {
+    readonly code: string;
+    readonly statusCode: number;
+    constructor(code: string, message: string, statusCode?: number);
+}
+type QuestionsAuthContext = {
+    sessionId: string;
+    principalId: string;
+};
+type QuestionsBridgeOptions = {
+    store: AskUserStore;
+    runtime: AskUserRuntime;
+    getAuthContext?: () => QuestionsAuthContext | Promise<QuestionsAuthContext>;
+};
+declare class QuestionsBridge {
+    private readonly options;
+    constructor(options: QuestionsBridgeOptions);
+    handle(command: QuestionsCommand): Promise<{
+        ok: true;
+        status: string;
+    }>;
+    private resolveAuth;
+    private requireQuestion;
+    private assertSession;
+    private assertToken;
+}
+declare function constantTimeEqual(expected: string, actual: string): boolean;
+declare function validateAnswerValues(fields: AskUserField[], values: Record<string, AskUserAnswerValue>): void;
+
+type QuestionsRoutesOptions = {
+    store: AskUserStore;
+    runtime: AskUserRuntime;
+    getAuthContext?: (request: FastifyRequest) => QuestionsAuthContext | Promise<QuestionsAuthContext>;
+    allowedOrigins?: string[];
+    csrfHeaderName?: string;
+    csrfToken?: string | ((request: FastifyRequest) => string | undefined | Promise<string | undefined>);
+};
+declare function questionsRoutes(app: FastifyInstance, opts: QuestionsRoutesOptions, done: (err?: Error) => void): void;
+
+type AskUserServerPluginOptions = {
+    workspaceRoot?: string;
+    bridge?: UiBridge;
+    runtime?: AskUserRuntime;
+    store?: AskUserStore;
+    sessionId?: string | (() => string);
+    routes?: Omit<QuestionsRoutesOptions, "runtime" | "store">;
+    onClose?: () => void;
+};
+declare function createAskUserServerPlugin(options: AskUserServerPluginOptions): WorkspaceServerPlugin;
+
+type AskUserToolResultPayload = {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    details?: unknown;
+    isError?: boolean;
+};
+type AskUserToolDefinition = {
+    name: "ask_user";
+    label: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    promptSnippet?: string;
+    execute(toolCallId: string, params: Record<string, unknown>, signal?: AbortSignal, sessionId?: string): Promise<AskUserToolResultPayload>;
+};
+type AskUserToolOptions = {
+    runtime: AskUserRuntime;
+    sessionId: string | (() => string);
+};
+declare function createAskUserTool(options: AskUserToolOptions): AskUserToolDefinition;
+
+type AskUserPendingState = {
+    question: AskUserQuestion | null;
+};
+declare class AskUserStatePublisher {
+    private readonly store;
+    private readonly bridge;
+    private unsubscribe?;
+    constructor(store: AskUserStore, bridge: UiBridge);
+    start(): () => void;
+    stop(): void;
+    publishSession(sessionId: string): Promise<void>;
+}
+
+/**
+ * Default export — adapter for the standard `defaultPluginPackages`
+ * load process. The workspace's `pluginEntryResolver` calls a
+ * dir-source plugin's default-exported factory with `(options, ctx)`
+ * where `ctx = { workspaceRoot, bridge }`. This adapter forwards
+ * runtime context into `createAskUserServerPlugin`, which is the
+ * existing rich factory consumers use directly when wiring by hand.
+ */
+declare function defaultAskUserServerPlugin(options: Partial<AskUserServerPluginOptions> | undefined, ctx: {
+    workspaceRoot: string;
+    bridge: AskUserServerPluginOptions["bridge"];
+}): WorkspaceServerPlugin;
+
+export { type AskUserCoordinator, type AskUserPendingState, AskUserRuntime, AskUserRuntimeError, type AskUserRuntimeOptions, type AskUserServerPluginOptions, AskUserStatePublisher, type AskUserStore, type AskUserStoreChange, AskUserStoreError, type AskUserStoreListener, type AskUserToolDefinition, type AskUserToolOptions, type AskUserToolResultPayload, FileAskUserStore, InProcessAskUserCoordinator, type QuestionsAuthContext, QuestionsBridge, QuestionsBridgeError, type QuestionsBridgeOptions, type QuestionsRoutesOptions, constantTimeEqual, createAskUserServerPlugin, createAskUserTool, defaultAskUserServerPlugin as default, questionsRoutes, requireAskUserRuntime, validateAnswerValues };