@a5c-ai/tasks-adapter 5.1.1-staging.52898ebfc24f

package/dist/client/auth-client.js

@@ -0,0 +1,309 @@
+import { ServerClient, ServerError } from "./server-client.js";
+// -- AuthClient ---------------------------------------------------------------
+/**
+ * Authenticated client that wraps ServerClient, automatically injecting
+ * Authorization headers and handling token refresh on 401 responses.
+ */
+export class AuthClient {
+    serverClient;
+    token;
+    refreshTokenValue;
+    tokenProvider;
+    onTokenRefresh;
+    constructor(options) {
+        this.serverClient = new ServerClient(options.serverUrl);
+        this.token = options.token ?? null;
+        this.refreshTokenValue = options.refreshToken ?? null;
+        this.tokenProvider = options.tokenProvider ?? null;
+        this.onTokenRefresh = options.onTokenRefresh ?? null;
+    }
+    // -- Auth state -------------------------------------------------------------
+    /**
+     * Returns true if a token or token provider is available.
+     */
+    isAuthenticated() {
+        return this.token !== null || this.tokenProvider !== null;
+    }
+    // -- Auth methods -----------------------------------------------------------
+    /**
+     * Fetch the authenticated user's profile.
+     */
+    async getUser() {
+        return this.authenticatedGet("/auth/me");
+    }
+    /**
+     * Exchange an OAuth authorization code for auth tokens.
+     */
+    async login(code, codeVerifier) {
+        const body = { code };
+        if (codeVerifier) {
+            body.codeVerifier = codeVerifier;
+        }
+        const result = await this.serverClient.post("/auth/login", body);
+        this.token = result.accessToken;
+        this.refreshTokenValue = result.refreshToken;
+        return result;
+    }
+    /**
+     * Log out, clearing local token state.
+     */
+    async logout() {
+        try {
+            await this.authenticatedPost("/auth/logout", {});
+        }
+        finally {
+            this.token = null;
+            this.refreshTokenValue = null;
+        }
+    }
+    // -- Delegated breakpoint methods -------------------------------------------
+    /**
+     * List breakpoints with optional filters, authenticated.
+     */
+    async listBreakpoints(filters) {
+        const qs = filters ? "?" + new URLSearchParams(filters).toString() : "";
+        return this.authenticatedGet(`/breakpoints${qs}`);
+    }
+    /**
+     * Get a single breakpoint by ID, authenticated.
+     */
+    async getBreakpoint(id) {
+        return this.authenticatedGet(`/breakpoints/${id}`);
+    }
+    /**
+     * Submit a new breakpoint, authenticated.
+     */
+    async submitBreakpoint(text, context, routing, options) {
+        return this.authenticatedPost("/breakpoints", {
+            text,
+            context,
+            routing,
+            projectId: options.projectId,
+            repoId: options.repoId,
+        });
+    }
+    /**
+     * Submit an answer to a breakpoint, authenticated.
+     */
+    async submitAnswer(breakpointId, answer) {
+        return this.authenticatedPost(`/breakpoints/${breakpointId}/answers`, answer);
+    }
+    async createBrowserSession(breakpointId, options) {
+        return this.authenticatedPost(`/breakpoints/${breakpointId}/browser-session`, {
+            mode: options?.mode ?? "same-user",
+            responderId: options?.responderId,
+            responderName: options?.responderName,
+        });
+    }
+    async getBreakpointSession(authToken) {
+        return this.serverClient.get(`/breakpoints/session/${authToken}`);
+    }
+    async submitSessionAnswer(authToken, answer) {
+        return this.serverClient.post(`/breakpoints/session/${authToken}/answer`, answer);
+    }
+    // -- SSH key methods --------------------------------------------------------
+    /**
+     * Generate a new SSH key pair on the server.
+     */
+    async generateKey() {
+        return this.authenticatedPost("/keys/generate", {});
+    }
+    /**
+     * List SSH keys associated with the authenticated user.
+     */
+    async listKeys() {
+        return this.authenticatedGet("/keys");
+    }
+    /**
+     * Push an SSH public key to a repository via pull request.
+     */
+    async pushKey(keyId, owner, repo) {
+        return this.authenticatedPost(`/keys/${keyId}/push`, { owner, repo });
+    }
+    // -- Projects ---------------------------------------------------------------
+    /**
+     * List all projects the authenticated user has access to.
+     */
+    async listProjects() {
+        return this.authenticatedGet("/projects");
+    }
+    async listTeams() {
+        return this.authenticatedGet("/teams");
+    }
+    async getTeam(id) {
+        return this.authenticatedGet(`/teams/${id}`);
+    }
+    async createTeam(name, description) {
+        return this.authenticatedPost("/teams", { name, description });
+    }
+    async listTeamProjects(teamId) {
+        return this.authenticatedGet(`/teams/${teamId}/projects`);
+    }
+    async inviteTeamMember(teamId, login) {
+        return this.authenticatedPost(`/teams/${teamId}/invitations`, { login });
+    }
+    async acceptTeamInvitation(token) {
+        return this.authenticatedPost(`/teams/invitations/${token}/accept`, {});
+    }
+    /**
+     * Find known users for project membership and sharing flows.
+     */
+    async searchUsers(query, limit) {
+        const params = new URLSearchParams();
+        if (query)
+            params.set("q", query);
+        if (typeof limit === "number")
+            params.set("limit", String(limit));
+        const qs = params.toString();
+        return this.authenticatedGet(`/auth/users${qs ? `?${qs}` : ""}`);
+    }
+    /**
+     * Get a single project by ID.
+     */
+    async getProject(id) {
+        return this.authenticatedGet(`/projects/${id}`);
+    }
+    /**
+     * Create a new project.
+     */
+    async createProject(name, description, options) {
+        return this.authenticatedPost("/projects", {
+            name,
+            description,
+            teamId: options?.teamId,
+        });
+    }
+    /**
+     * Update an existing project.
+     */
+    async updateProject(id, updates) {
+        return this.authenticatedPut(`/projects/${id}`, updates);
+    }
+    /**
+     * Delete a project by ID.
+     */
+    async deleteProject(id) {
+        return this.authenticatedDelete(`/projects/${id}`);
+    }
+    /**
+     * Add a GitHub repository to a project.
+     */
+    async addRepoToProject(projectId, repo) {
+        return this.authenticatedPost(`/projects/${projectId}/repos`, repo);
+    }
+    /**
+     * Remove a repository from a project.
+     */
+    async removeRepoFromProject(projectId, repoId) {
+        return this.authenticatedDelete(`/projects/${projectId}/repos/${repoId}`);
+    }
+    /**
+     * List breakpoints associated with a project.
+     */
+    async listProjectBreakpoints(projectId) {
+        return this.authenticatedGet(`/projects/${projectId}/breakpoints`);
+    }
+    /**
+     * List GitHub repositories available to the authenticated user.
+     */
+    async listGitHubRepos() {
+        return this.authenticatedGet("/auth/github/repos");
+    }
+    // -- Internal helpers -------------------------------------------------------
+    /**
+     * Build the Authorization header from the current token or provider.
+     */
+    async getAuthHeaders() {
+        let accessToken = this.token;
+        if (this.tokenProvider) {
+            accessToken = await this.tokenProvider();
+            this.token = accessToken;
+        }
+        if (!accessToken) {
+            return {};
+        }
+        return { Authorization: `Bearer ${accessToken}` };
+    }
+    /**
+     * Attempt to refresh the access token using the stored refresh token.
+     */
+    async refreshAccessToken() {
+        if (!this.refreshTokenValue) {
+            throw new ServerError(401, "Unauthorized", "No refresh token available");
+        }
+        const result = await this.serverClient.post("/auth/refresh", { refreshToken: this.refreshTokenValue });
+        this.token = result.accessToken;
+        this.refreshTokenValue = result.refreshToken;
+        if (this.onTokenRefresh) {
+            this.onTokenRefresh(result);
+        }
+    }
+    /**
+     * Perform an authenticated GET request with automatic 401 retry.
+     */
+    async authenticatedGet(path) {
+        const headers = await this.getAuthHeaders();
+        try {
+            return await this.serverClient.get(path, headers);
+        }
+        catch (err) {
+            if (err instanceof ServerError && err.status === 401 && this.refreshTokenValue) {
+                await this.refreshAccessToken();
+                const newHeaders = await this.getAuthHeaders();
+                return this.serverClient.get(path, newHeaders);
+            }
+            throw err;
+        }
+    }
+    /**
+     * Perform an authenticated POST request with automatic 401 retry.
+     */
+    async authenticatedPost(path, body) {
+        const headers = await this.getAuthHeaders();
+        try {
+            return await this.serverClient.post(path, body, headers);
+        }
+        catch (err) {
+            if (err instanceof ServerError && err.status === 401 && this.refreshTokenValue) {
+                await this.refreshAccessToken();
+                const newHeaders = await this.getAuthHeaders();
+                return this.serverClient.post(path, body, newHeaders);
+            }
+            throw err;
+        }
+    }
+    /**
+     * Perform an authenticated PUT request with automatic 401 retry.
+     */
+    async authenticatedPut(path, body) {
+        const headers = await this.getAuthHeaders();
+        try {
+            return await this.serverClient.put(path, body, headers);
+        }
+        catch (err) {
+            if (err instanceof ServerError && err.status === 401 && this.refreshTokenValue) {
+                await this.refreshAccessToken();
+                const newHeaders = await this.getAuthHeaders();
+                return this.serverClient.put(path, body, newHeaders);
+            }
+            throw err;
+        }
+    }
+    /**
+     * Perform an authenticated DELETE request with automatic 401 retry.
+     */
+    async authenticatedDelete(path) {
+        const headers = await this.getAuthHeaders();
+        try {
+            return await this.serverClient.delete(path, headers);
+        }
+        catch (err) {
+            if (err instanceof ServerError && err.status === 401 && this.refreshTokenValue) {
+                await this.refreshAccessToken();
+                const newHeaders = await this.getAuthHeaders();
+                return this.serverClient.delete(path, newHeaders);
+            }
+            throw err;
+        }
+    }
+}

package/dist/client/breakpoint-router.d.ts

@@ -0,0 +1,45 @@
+import type { Breakpoint, BreakpointContext, BreakpointRouting, BreakpointStrategy } from "../types.js";
+import type { BreakpointBackend } from "../backend.js";
+/**
+ * Options for creating and submitting a breakpoint.
+ */
+export interface SubmitBreakpointOptions {
+    text: string;
+    context: BreakpointContext;
+    routing: BreakpointRouting;
+    projectId?: string;
+    repoId?: string;
+}
+/**
+ * Options for routing a breakpoint to responders.
+ */
+export interface RouteToRespondersOptions {
+    strategy: BreakpointStrategy;
+    timeoutMs: number;
+    presentToUser?: boolean;
+}
+/**
+ * Orchestrates breakpoint creation and routing through a backend.
+ */
+export declare class BreakpointRouter {
+    private readonly backend;
+    constructor(backend: BreakpointBackend);
+    /**
+     * Create and submit a new breakpoint to the backend.
+     * Returns the created Breakpoint with its backend-assigned ID.
+     */
+    submitBreakpoint(text: string, context: BreakpointContext, routing: BreakpointRouting, projectId?: string, repoId?: string): Promise<Breakpoint>;
+    /**
+     * Set up routing for a breakpoint, targeting specific responders.
+     *
+     * This is a convenience method that submits a breakpoint with
+     * the given responders pre-filled in the routing configuration.
+     */
+    routeToResponders(breakpointText: string, context: BreakpointContext, responderIds: string[], options: RouteToRespondersOptions, projectId?: string, repoId?: string): Promise<Breakpoint>;
+    /**
+     * Generate a new unique breakpoint ID (client-side).
+     * Useful for pre-generating IDs before submission.
+     */
+    generateBreakpointId(): string;
+}
+//# sourceMappingURL=breakpoint-router.d.ts.map

package/dist/client/breakpoint-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"breakpoint-router.d.ts","sourceRoot":"","sources":["../../src/client/breakpoint-router.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,UAAU,EACV,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEvD;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,iBAAiB,CAAC;IAC3B,OAAO,EAAE,iBAAiB,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;GAEG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;gBAEhC,OAAO,EAAE,iBAAiB;IAItC;;;OAGG;IACG,gBAAgB,CACpB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,iBAAiB,EAC1B,SAAS,CAAC,EAAE,MAAM,EAClB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,UAAU,CAAC;IAItB;;;;;OAKG;IACG,iBAAiB,CACrB,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,iBAAiB,EAC1B,YAAY,EAAE,MAAM,EAAE,EACtB,OAAO,EAAE,wBAAwB,EACjC,SAAS,CAAC,EAAE,MAAM,EAClB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,UAAU,CAAC;IAiBtB;;;OAGG;IACH,oBAAoB,IAAI,MAAM;CAG/B"}

package/dist/client/breakpoint-router.js

@@ -0,0 +1,45 @@
+import { generateBreakpointId } from "../types.js";
+/**
+ * Orchestrates breakpoint creation and routing through a backend.
+ */
+export class BreakpointRouter {
+    backend;
+    constructor(backend) {
+        this.backend = backend;
+    }
+    /**
+     * Create and submit a new breakpoint to the backend.
+     * Returns the created Breakpoint with its backend-assigned ID.
+     */
+    async submitBreakpoint(text, context, routing, projectId, repoId) {
+        return this.backend.submitBreakpoint({ text, context, routing, projectId, repoId });
+    }
+    /**
+     * Set up routing for a breakpoint, targeting specific responders.
+     *
+     * This is a convenience method that submits a breakpoint with
+     * the given responders pre-filled in the routing configuration.
+     */
+    async routeToResponders(breakpointText, context, responderIds, options, projectId, repoId) {
+        const routing = {
+            strategy: options.strategy,
+            targetResponders: responderIds,
+            timeoutMs: options.timeoutMs,
+            presentToUser: options.presentToUser ?? false,
+        };
+        return this.backend.submitBreakpoint({
+            text: breakpointText,
+            context,
+            routing,
+            projectId,
+            repoId,
+        });
+    }
+    /**
+     * Generate a new unique breakpoint ID (client-side).
+     * Useful for pre-generating IDs before submission.
+     */
+    generateBreakpointId() {
+        return generateBreakpointId();
+    }
+}

package/dist/client/index.d.ts

@@ -0,0 +1,17 @@
+export { ServerClient, ServerError, DEFAULT_BMUX_SERVER_URL } from "./server-client.js";
+export type { SSEStream, ServerClientOptions } from "./server-client.js";
+export { AnswerPoller } from "./answer-poller.js";
+export type { PollerWaitForAnswerOptions } from "./answer-poller.js";
+export { ResponderMatcher } from "./responder-matcher.js";
+export type { ScoredResponder, ResponderMatcherOptions } from "./responder-matcher.js";
+export { BreakpointRouter } from "./breakpoint-router.js";
+export type { SubmitBreakpointOptions, RouteToRespondersOptions } from "./breakpoint-router.js";
+export { ResponderClient } from "./responder-client.js";
+export type { BreakpointCallback } from "./responder-client.js";
+export { AuthClient } from "./auth-client.js";
+export type { AuthClientOptions, SSHKeyInfo } from "./auth-client.js";
+export { TimeoutManager } from "./timeout-manager.js";
+export type { TimeoutStatus, TimeoutCallback } from "./timeout-manager.js";
+export { validateProfile, validateProfileFile, validateAllProfiles, } from "./profile-validator.js";
+export type { ProfileValidationResult, DirectoryValidationResult, } from "./profile-validator.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AACxF,YAAY,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAGzE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,YAAY,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AAGrE,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,YAAY,EAAE,eAAe,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAGvF,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,YAAY,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAGhG,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,YAAY,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAGhE,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,YAAY,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAGtE,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG3E,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,mBAAmB,GACpB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EACV,uBAAuB,EACvB,yBAAyB,GAC1B,MAAM,wBAAwB,CAAC"}

package/dist/client/index.js

@@ -0,0 +1,16 @@
+// -- Server Client ------------------------------------------------------------
+export { ServerClient, ServerError, DEFAULT_BMUX_SERVER_URL } from "./server-client.js";
+// -- Answer Poller ------------------------------------------------------------
+export { AnswerPoller } from "./answer-poller.js";
+// -- Responder Matcher --------------------------------------------------------
+export { ResponderMatcher } from "./responder-matcher.js";
+// -- Breakpoint Router --------------------------------------------------------
+export { BreakpointRouter } from "./breakpoint-router.js";
+// -- Responder Client ---------------------------------------------------------
+export { ResponderClient } from "./responder-client.js";
+// -- Auth Client --------------------------------------------------------------
+export { AuthClient } from "./auth-client.js";
+// -- Timeout Manager ----------------------------------------------------------
+export { TimeoutManager } from "./timeout-manager.js";
+// -- Profile Validator --------------------------------------------------------
+export { validateProfile, validateProfileFile, validateAllProfiles, } from "./profile-validator.js";

package/dist/client/profile-validator.d.ts

@@ -0,0 +1,34 @@
+import type { ResponderProfile } from "../types.js";
+/**
+ * Result of validating a single profile.
+ */
+export interface ProfileValidationResult {
+    valid: boolean;
+    filePath?: string;
+    profile?: ResponderProfile;
+    errors: string[];
+}
+/**
+ * Result of validating all profiles in a directory.
+ */
+export interface DirectoryValidationResult {
+    valid: boolean;
+    results: ProfileValidationResult[];
+    totalProfiles: number;
+    validProfiles: number;
+    invalidProfiles: number;
+}
+/**
+ * Validate a profile object against the ResponderProfile Zod schema.
+ */
+export declare function validateProfile(profile: unknown): ProfileValidationResult;
+/**
+ * Read a JSON profile file from disk and validate it against the ResponderProfile schema.
+ */
+export declare function validateProfileFile(filePath: string): Promise<ProfileValidationResult>;
+/**
+ * Validate all JSON profile files in a directory.
+ * Non-JSON files are ignored.
+ */
+export declare function validateAllProfiles(dir: string): Promise<DirectoryValidationResult>;
+//# sourceMappingURL=profile-validator.d.ts.map

package/dist/client/profile-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile-validator.d.ts","sourceRoot":"","sources":["../../src/client/profile-validator.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,uBAAuB,EAAE,CAAC;IACnC,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,uBAAuB,CAazE;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,uBAAuB,CAAC,CAuBlC;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,yBAAyB,CAAC,CAyCpC"}

package/dist/client/profile-validator.js

@@ -0,0 +1,89 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join, extname } from "node:path";
+import { ResponderProfileSchema } from "../types.js";
+/**
+ * Validate a profile object against the ResponderProfile Zod schema.
+ */
+export function validateProfile(profile) {
+    const result = ResponderProfileSchema.safeParse(profile);
+    if (result.success) {
+        return {
+            valid: true,
+            profile: result.data,
+            errors: [],
+        };
+    }
+    return {
+        valid: false,
+        errors: result.error.message.split("; "),
+    };
+}
+/**
+ * Read a JSON profile file from disk and validate it against the ResponderProfile schema.
+ */
+export async function validateProfileFile(filePath) {
+    try {
+        const raw = await readFile(filePath, "utf-8");
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            return {
+                valid: false,
+                filePath,
+                errors: [`Failed to parse JSON in ${filePath}`],
+            };
+        }
+        const result = validateProfile(parsed);
+        result.filePath = filePath;
+        return result;
+    }
+    catch (err) {
+        return {
+            valid: false,
+            filePath,
+            errors: [`Failed to read file ${filePath}: ${err.message}`],
+        };
+    }
+}
+/**
+ * Validate all JSON profile files in a directory.
+ * Non-JSON files are ignored.
+ */
+export async function validateAllProfiles(dir) {
+    const results = [];
+    let entries;
+    try {
+        entries = await readdir(dir);
+    }
+    catch {
+        return {
+            valid: false,
+            results: [
+                {
+                    valid: false,
+                    errors: [`Directory not found or not readable: ${dir}`],
+                },
+            ],
+            totalProfiles: 0,
+            validProfiles: 0,
+            invalidProfiles: 0,
+        };
+    }
+    const jsonFiles = entries.filter((e) => extname(e).toLowerCase() === ".json" && e !== "schema.json");
+    for (const file of jsonFiles) {
+        const filePath = join(dir, file);
+        const result = await validateProfileFile(filePath);
+        results.push(result);
+    }
+    const validCount = results.filter((r) => r.valid).length;
+    const invalidCount = results.filter((r) => !r.valid).length;
+    return {
+        valid: invalidCount === 0 && results.length > 0,
+        results,
+        totalProfiles: results.length,
+        validProfiles: validCount,
+        invalidProfiles: invalidCount,
+    };
+}

package/dist/client/responder-client.d.ts

@@ -0,0 +1,39 @@
+import type { Breakpoint, BreakpointAnswer } from "../types.js";
+import { ServerClient } from "./server-client.js";
+/**
+ * Callback invoked when new pending breakpoints are found.
+ */
+export type BreakpointCallback = (breakpoints: Breakpoint[]) => void | Promise<void>;
+/**
+ * Client used by responders to receive, claim, and answer breakpoints.
+ */
+export declare class ResponderClient {
+    private readonly client;
+    readonly responderId: string;
+    private pollingTimer;
+    constructor(client: ServerClient, responderId: string);
+    /**
+     * Fetch all pending breakpoints routed to this responder.
+     */
+    fetchPendingBreakpoints(): Promise<Breakpoint[]>;
+    /**
+     * Claim a breakpoint so no other responder can answer it.
+     */
+    claimBreakpoint(breakpointId: string): Promise<Breakpoint>;
+    /**
+     * Submit an answer to a claimed breakpoint.
+     */
+    submitAnswer(breakpointId: string, text: string, confidence?: number, references?: string[]): Promise<BreakpointAnswer>;
+    /**
+     * Start a polling loop that periodically checks for new pending breakpoints
+     * and invokes the callback when breakpoints are found.
+     *
+     * Returns a function to stop the loop.
+     */
+    startPollingLoop(callback: BreakpointCallback, intervalMs?: number): () => void;
+    /**
+     * Stop the current polling loop if running.
+     */
+    stopPollingLoop(): void;
+}
+//# sourceMappingURL=responder-client.d.ts.map

package/dist/client/responder-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responder-client.d.ts","sourceRoot":"","sources":["../../src/client/responder-client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,WAAW,EAAE,UAAU,EAAE,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAErF;;GAEG;AACH,qBAAa,eAAe;IAIxB,OAAO,CAAC,QAAQ,CAAC,MAAM;aACP,WAAW,EAAE,MAAM;IAJrC,OAAO,CAAC,YAAY,CAA+C;gBAGhD,MAAM,EAAE,YAAY,EACrB,WAAW,EAAE,MAAM;IAGrC;;OAEG;IACG,uBAAuB,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;IAItD;;OAEG;IACG,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAIhE;;OAEG;IACG,YAAY,CAChB,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,MAAM,EACZ,UAAU,SAAK,EACf,UAAU,GAAE,MAAM,EAAO,GACxB,OAAO,CAAC,gBAAgB,CAAC;IAU5B;;;;;OAKG;IACH,gBAAgB,CACd,QAAQ,EAAE,kBAAkB,EAC5B,UAAU,GAAE,MAAiC,GAC5C,MAAM,IAAI;IAuBb;;OAEG;IACH,eAAe,IAAI,IAAI;CAMxB"}