@parall/sdk 1.12.0

package/dist/client.js

@@ -0,0 +1,718 @@
+import { ENDPOINTS } from './constants.js';
+export class ParallClient {
+    baseUrl;
+    token;
+    onTokenExpired;
+    getRefreshToken;
+    setTokens;
+    refreshPromise = null;
+    swimlaneName;
+    /** Auth endpoints excluded from automatic 401 refresh to prevent recursion. */
+    static AUTH_PATHS = new Set([
+        '/auth/login', '/auth/register', '/auth/refresh', '/auth/logout',
+        '/auth/verify-email', '/auth/resend-code', '/auth/check-email',
+    ]);
+    /** Proactive refresh when token expires within this window (seconds). */
+    static REFRESH_THRESHOLD_S = 5 * 60;
+    /** Build headers common to all requests (auth, swimlane). */
+    buildHeaders(extra) {
+        const headers = {
+            'Content-Type': 'application/json',
+            ...extra,
+        };
+        if (this.token) {
+            headers['Authorization'] = `Bearer ${this.token}`;
+        }
+        if (this.swimlaneName) {
+            headers['X-Prll-Swimlane'] = this.swimlaneName;
+        }
+        return headers;
+    }
+    constructor(options = {}) {
+        this.baseUrl = options.baseUrl ?? '';
+        this.token = options.token ?? null;
+        this.onTokenExpired = options.onTokenExpired;
+        this.getRefreshToken = options.getRefreshToken;
+        this.setTokens = options.setTokens;
+        this.swimlaneName = options.swimlaneName;
+    }
+    setToken(token) {
+        this.token = token;
+    }
+    getToken() {
+        return this.token;
+    }
+    /** Decode the `exp` claim from a JWT without verifying the signature. */
+    static decodeJwtExp(token) {
+        try {
+            const parts = token.split('.');
+            if (parts.length !== 3)
+                return null;
+            // base64url → standard base64
+            const b64 = parts[1].replace(/-/g, '+').replace(/_/g, '/');
+            const padded = b64.padEnd(b64.length + ((4 - (b64.length % 4)) % 4), '=');
+            const payload = JSON.parse(atob(padded));
+            return typeof payload.exp === 'number' ? payload.exp : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Proactive refresh: if the current access token expires within
+     * REFRESH_THRESHOLD_S, refresh it **before** sending the request.
+     * No-op when the token is still fresh, missing, or un-parseable.
+     */
+    async ensureFreshToken(path) {
+        if (!this.token || !this.getRefreshToken)
+            return;
+        const pathSuffix = path.replace(/^\/api\/v1/, '');
+        if (ParallClient.AUTH_PATHS.has(pathSuffix))
+            return;
+        const exp = ParallClient.decodeJwtExp(this.token);
+        if (exp === null)
+            return;
+        if (exp - Date.now() / 1000 > ParallClient.REFRESH_THRESHOLD_S)
+            return;
+        await this.tryRefresh();
+    }
+    /**
+     * Single-flight token refresh. Multiple concurrent 401s share one promise
+     * so only one refresh request is made.
+     */
+    async tryRefresh() {
+        const rt = this.getRefreshToken?.();
+        if (!rt)
+            return false;
+        if (!this.refreshPromise) {
+            this.refreshPromise = this.refreshToken(rt);
+        }
+        try {
+            const tokens = await this.refreshPromise;
+            this.setToken(tokens.access_token);
+            this.setTokens?.(tokens);
+            return true;
+        }
+        catch {
+            return false;
+        }
+        finally {
+            this.refreshPromise = null;
+        }
+    }
+    async request(method, path, body, query, retried = false) {
+        // Proactive refresh: block until token is fresh (no-op if still valid)
+        if (!retried) {
+            await this.ensureFreshToken(path);
+        }
+        let url = `${this.baseUrl}${path}`;
+        if (query) {
+            const params = new URLSearchParams();
+            for (const [key, value] of Object.entries(query)) {
+                if (value !== undefined) {
+                    params.set(key, String(value));
+                }
+            }
+            const qs = params.toString();
+            if (qs)
+                url += `?${qs}`;
+        }
+        const headers = this.buildHeaders();
+        let res;
+        try {
+            res = await fetch(url, {
+                method,
+                headers,
+                body: body ? JSON.stringify(body) : undefined,
+                signal: AbortSignal.timeout(15_000),
+            });
+        }
+        catch (err) {
+            if (err instanceof DOMException && err.name === 'TimeoutError') {
+                throw new ApiError(0, 'Request timed out', 'REQUEST_TIMEOUT');
+            }
+            throw err;
+        }
+        if (res.status === 401) {
+            const pathSuffix = path.replace(/^\/api\/v1/, '');
+            const isAuthPath = ParallClient.AUTH_PATHS.has(pathSuffix);
+            if (!retried && !isAuthPath && this.getRefreshToken) {
+                const refreshed = await this.tryRefresh();
+                if (refreshed) {
+                    // Retry once with the new token
+                    return this.request(method, path, body, query, true);
+                }
+            }
+            // Only fire for non-auth paths — auth endpoints (e.g. /auth/refresh)
+            // just throw; the original caller's path handles the notification.
+            if (this.onTokenExpired && !isAuthPath) {
+                this.onTokenExpired();
+            }
+        }
+        if (!res.ok) {
+            const errorBody = await res.json().catch(() => ({}));
+            const errorObj = errorBody?.error && typeof errorBody.error === 'object' ? errorBody.error : undefined;
+            const errMsg = errorObj?.message ?? (typeof errorBody?.error === 'string' ? errorBody.error : undefined);
+            const errCode = errorObj?.code ?? (typeof errorBody?.code === 'string' ? errorBody.code : undefined);
+            throw new ApiError(res.status, errMsg ?? res.statusText, errCode);
+        }
+        if (res.status === 204)
+            return undefined;
+        // 202 Accepted may have an empty body (e.g., async restart) or a JSON body.
+        if (res.status === 202) {
+            const text = await res.text();
+            if (!text)
+                return undefined;
+            return JSON.parse(text);
+        }
+        return res.json();
+    }
+    // ---- Auth ----
+    async register(req) {
+        return this.request('POST', ENDPOINTS.AUTH_REGISTER, req);
+    }
+    async login(req) {
+        return this.request('POST', ENDPOINTS.AUTH_LOGIN, req);
+    }
+    async refreshToken(refreshToken) {
+        return this.request('POST', ENDPOINTS.AUTH_REFRESH, { refresh_token: refreshToken });
+    }
+    async logout() {
+        return this.request('POST', ENDPOINTS.AUTH_LOGOUT);
+    }
+    async checkEmail(email) {
+        return this.request('POST', ENDPOINTS.AUTH_CHECK_EMAIL, { email });
+    }
+    async verifyEmail(email, code) {
+        return this.request('POST', ENDPOINTS.AUTH_VERIFY_EMAIL, { email, code });
+    }
+    async resendCode(email) {
+        return this.request('POST', ENDPOINTS.AUTH_RESEND_CODE, { email });
+    }
+    // ---- WebSocket ----
+    async getWsTicket() {
+        return this.request('POST', ENDPOINTS.WS_TICKET);
+    }
+    // ---- Users ----
+    async getMe() {
+        return this.request('GET', ENDPOINTS.USERS_ME);
+    }
+    async updateMe(data) {
+        return this.request('PATCH', ENDPOINTS.USERS_ME, data);
+    }
+    async getUser(id) {
+        return this.request('GET', ENDPOINTS.USER(id));
+    }
+    // ---- Organizations ----
+    async createOrg(data) {
+        return this.request('POST', ENDPOINTS.ORGS, data);
+    }
+    async getOrgs() {
+        const res = await this.request('GET', ENDPOINTS.ORGS);
+        return res.data;
+    }
+    async getOrg(orgId) {
+        return this.request('GET', ENDPOINTS.ORG(orgId));
+    }
+    async updateOrg(orgId, data) {
+        return this.request('PATCH', ENDPOINTS.ORG(orgId), data);
+    }
+    async deleteOrg(orgId) {
+        return this.request('DELETE', ENDPOINTS.ORG(orgId));
+    }
+    async getOrgMembers(orgId) {
+        const res = await this.request('GET', ENDPOINTS.ORG_MEMBERS(orgId));
+        return res.data;
+    }
+    async getOnlineMembers(orgId) {
+        const res = await this.request('GET', ENDPOINTS.ORG_MEMBERS_ONLINE(orgId));
+        return res.user_ids ?? [];
+    }
+    async removeOrgMember(orgId, userId) {
+        return this.request('DELETE', ENDPOINTS.ORG_MEMBER(orgId, userId));
+    }
+    async updateOrgMember(orgId, userId, role) {
+        return this.request('PATCH', ENDPOINTS.ORG_MEMBER(orgId, userId), { role });
+    }
+    // ---- Invitations ----
+    async createInvitation(orgId, email, role) {
+        return this.request('POST', ENDPOINTS.ORG_INVITATIONS(orgId), { email, role });
+    }
+    async getOrgInvitations(orgId) {
+        const res = await this.request('GET', ENDPOINTS.ORG_INVITATIONS(orgId));
+        return res.data;
+    }
+    async revokeInvitation(orgId, invId) {
+        return this.request('DELETE', ENDPOINTS.ORG_INVITATION(orgId, invId));
+    }
+    async resendInvitation(orgId, invId) {
+        return this.request('POST', ENDPOINTS.ORG_INVITATION_RESEND(orgId, invId));
+    }
+    async getMyInvitations() {
+        const res = await this.request('GET', ENDPOINTS.MY_INVITATIONS);
+        return res.data;
+    }
+    async acceptInvitation(id) {
+        return this.request('POST', ENDPOINTS.INVITATION_ACCEPT(id));
+    }
+    async declineInvitation(id) {
+        return this.request('POST', ENDPOINTS.INVITATION_DECLINE(id));
+    }
+    async getInvitationByToken(token) {
+        return this.request('GET', ENDPOINTS.INVITATION_BY_TOKEN(token));
+    }
+    // ---- Direct Messages (org-scoped) ----
+    async sendDirectMessage(orgId, req) {
+        return this.request('POST', ENDPOINTS.DM(orgId), req);
+    }
+    // ---- Chats (org-scoped) ----
+    async createChat(orgId, req) {
+        return this.request('POST', ENDPOINTS.CHATS(orgId), req);
+    }
+    async getChats(orgId, params) {
+        return this.request('GET', ENDPOINTS.CHATS(orgId), undefined, params);
+    }
+    async getChat(orgId, chatId) {
+        return this.request('GET', ENDPOINTS.CHAT(orgId, chatId));
+    }
+    async updateChat(orgId, chatId, data) {
+        return this.request('PATCH', ENDPOINTS.CHAT(orgId, chatId), data);
+    }
+    async deleteChat(orgId, chatId) {
+        return this.request('DELETE', ENDPOINTS.CHAT(orgId, chatId));
+    }
+    // ---- Chat Members ----
+    async getChatMembers(orgId, chatId) {
+        const res = await this.request('GET', ENDPOINTS.CHAT_MEMBERS(orgId, chatId));
+        return res.data;
+    }
+    async addChatMember(orgId, chatId, userId, role) {
+        return this.request('POST', ENDPOINTS.CHAT_MEMBERS(orgId, chatId), { user_id: userId, role });
+    }
+    async removeChatMember(orgId, chatId, userId) {
+        return this.request('DELETE', ENDPOINTS.CHAT_MEMBER(orgId, chatId, userId));
+    }
+    async updateChatMemberRole(orgId, chatId, userId, role) {
+        return this.request('PATCH', ENDPOINTS.CHAT_MEMBER(orgId, chatId, userId), { role });
+    }
+    // ---- Messages ----
+    async sendMessage(orgId, chatId, req) {
+        return this.request('POST', ENDPOINTS.CHAT_MESSAGES(orgId, chatId), req);
+    }
+    async getMessages(orgId, chatId, params) {
+        return this.request('GET', ENDPOINTS.CHAT_MESSAGES(orgId, chatId), undefined, params);
+    }
+    async getMessage(id) {
+        return this.request('GET', ENDPOINTS.MESSAGE(id));
+    }
+    async editMessage(id, content) {
+        return this.request('PATCH', ENDPOINTS.MESSAGE(id), { content });
+    }
+    async deleteMessage(id) {
+        return this.request('DELETE', ENDPOINTS.MESSAGE(id));
+    }
+    async patchMessage(id, req) {
+        return this.request('POST', ENDPOINTS.MESSAGE_PATCHES(id), req);
+    }
+    async getMessageReplies(id, params) {
+        return this.request('GET', ENDPOINTS.MESSAGE_REPLIES(id), undefined, params);
+    }
+    // ---- File Upload ----
+    async getUploadPresignUrl(orgId, req) {
+        return this.request('POST', ENDPOINTS.UPLOAD_PRESIGN(orgId), req);
+    }
+    async completeUpload(orgId, attachmentId) {
+        return this.request('POST', ENDPOINTS.UPLOAD_COMPLETE(orgId), { attachment_id: attachmentId });
+    }
+    async getFileUrl(id) {
+        return this.request('GET', ENDPOINTS.FILE(id));
+    }
+    // ---- Approvals ----
+    async decideApproval(id, decision) {
+        return this.request('POST', ENDPOINTS.APPROVAL_DECIDE(id), { decision });
+    }
+    async getPendingApprovals() {
+        const res = await this.request('GET', ENDPOINTS.APPROVALS_PENDING);
+        return res.data;
+    }
+    // ---- Agents (org-scoped) ----
+    async createAgent(orgId, req) {
+        return this.request('POST', ENDPOINTS.AGENTS(orgId), req);
+    }
+    async getAgents(orgId) {
+        const res = await this.request('GET', ENDPOINTS.AGENTS(orgId));
+        return res.data;
+    }
+    async updateAgent(orgId, agentId, data) {
+        return this.request('PATCH', ENDPOINTS.AGENT(orgId, agentId), data);
+    }
+    async deleteAgent(orgId, agentId) {
+        return this.request('DELETE', ENDPOINTS.AGENT(orgId, agentId));
+    }
+    async createAgentApiKey(orgId, agentId) {
+        return this.request('POST', ENDPOINTS.AGENT_API_KEYS(orgId, agentId));
+    }
+    async revokeAgentApiKey(orgId, agentId, key) {
+        return this.request('DELETE', ENDPOINTS.AGENT_API_KEY(orgId, agentId, key));
+    }
+    async getAgentActivity(orgId, agentId, params) {
+        const res = await this.request('GET', ENDPOINTS.AGENT_ACTIVITY(orgId, agentId), undefined, params);
+        return res.data;
+    }
+    async getAgentMonitor(orgId, agentId) {
+        const res = await this.request('GET', ENDPOINTS.AGENT_MONITOR(orgId, agentId));
+        return res.data;
+    }
+    // ---- Agent Bootstrap (self) ----
+    async getAgentMe(orgId) {
+        return this.request('GET', ENDPOINTS.AGENT_ME(orgId));
+    }
+    // ---- Agent Sessions (org-scoped) ----
+    async createAgentSession(orgId, agentId, req) {
+        return this.request('POST', ENDPOINTS.AGENT_SESSIONS(orgId, agentId), req);
+    }
+    /**
+     * List agent sessions.
+     * @param params.status - Comma-separated status filter (e.g., `'active,idle'`).
+     */
+    async getAgentSessions(orgId, agentId, params) {
+        const res = await this.request('GET', ENDPOINTS.AGENT_SESSIONS(orgId, agentId), undefined, params);
+        return res.data;
+    }
+    async getAgentSession(orgId, agentId, sessionId) {
+        return this.request('GET', ENDPOINTS.AGENT_SESSION(orgId, agentId, sessionId));
+    }
+    async updateAgentSession(orgId, agentId, sessionId, req) {
+        return this.request('PATCH', ENDPOINTS.AGENT_SESSION(orgId, agentId, sessionId), req);
+    }
+    async createAgentStep(orgId, agentId, sessionId, req) {
+        return this.request('POST', ENDPOINTS.AGENT_SESSION_STEPS(orgId, agentId, sessionId), req);
+    }
+    async getAgentSessionSteps(orgId, agentId, sessionId, params) {
+        const res = await this.request('GET', ENDPOINTS.AGENT_SESSION_STEPS(orgId, agentId, sessionId), undefined, params);
+        return res.data;
+    }
+    /** Fetch all pending tasks (todo/in_progress) assigned to an agent. Pages automatically. */
+    async getAgentTasks(orgId, agentId) {
+        const all = [];
+        let cursor;
+        do {
+            const params = { limit: '100' };
+            if (cursor)
+                params.cursor = cursor;
+            const res = await this.request('GET', ENDPOINTS.AGENT_TASKS(orgId, agentId), undefined, params);
+            all.push(...res.data);
+            cursor = res.has_more ? res.next_cursor : undefined;
+        } while (cursor);
+        return all;
+    }
+    // ---- Machines (org-scoped) ----
+    async getMachines(orgId) {
+        const res = await this.request('GET', ENDPOINTS.MACHINES(orgId));
+        return res.data;
+    }
+    async getMachine(orgId, machineId) {
+        return this.request('GET', ENDPOINTS.MACHINE(orgId, machineId));
+    }
+    async deleteMachine(orgId, machineId) {
+        return this.request('DELETE', ENDPOINTS.MACHINE(orgId, machineId));
+    }
+    async startMachine(orgId, machineId) {
+        return this.request('POST', ENDPOINTS.MACHINE_START(orgId, machineId));
+    }
+    async stopMachine(orgId, machineId) {
+        return this.request('POST', ENDPOINTS.MACHINE_STOP(orgId, machineId));
+    }
+    async getMachineStatus(orgId, machineId) {
+        return this.request('GET', ENDPOINTS.MACHINE_STATUS(orgId, machineId));
+    }
+    async getMachineLogs(orgId, machineId, lines = 100) {
+        return this.request('GET', ENDPOINTS.MACHINE_LOGS(orgId, machineId), undefined, { lines });
+    }
+    async restartMachine(orgId, machineId) {
+        return this.request('POST', ENDPOINTS.MACHINE_RESTART(orgId, machineId));
+    }
+    async restartAllMachines(orgId) {
+        return this.request('POST', ENDPOINTS.MACHINE_RESTART_ALL(orgId));
+    }
+    async updateMachineWorkspace(orgId, machineId, files) {
+        return this.request('PUT', ENDPOINTS.MACHINE_WORKSPACE(orgId, machineId), files);
+    }
+    // Wiki mount/token methods removed — wiki-service handles all wiki endpoints.
+    // ---- Unread ----
+    async getUnreadCounts() {
+        const res = await this.request('GET', ENDPOINTS.UNREAD);
+        return res.data;
+    }
+    async markRead(orgId, chatId, messageId) {
+        return this.request('POST', ENDPOINTS.CHAT_READ(orgId, chatId), { message_id: messageId });
+    }
+    // ---- Inbox ----
+    async getInbox(orgId, params) {
+        return this.request('GET', ENDPOINTS.INBOX(orgId), undefined, params);
+    }
+    async getInboxUnreadCount(orgId) {
+        return this.request('GET', ENDPOINTS.INBOX_UNREAD_COUNT(orgId));
+    }
+    async markInboxRead(orgId, id) {
+        return this.request('PATCH', ENDPOINTS.INBOX_ITEM_READ(orgId, id));
+    }
+    async archiveInboxItem(orgId, id) {
+        return this.request('PATCH', ENDPOINTS.INBOX_ITEM_ARCHIVE(orgId, id));
+    }
+    // snoozeInboxItem / unsnoozeInboxItem deferred until un-snooze cron worker is implemented
+    async markAllInboxRead(orgId) {
+        return this.request('POST', ENDPOINTS.INBOX_MARK_ALL_READ(orgId));
+    }
+    async archiveAllInbox(orgId) {
+        return this.request('POST', ENDPOINTS.INBOX_ARCHIVE_ALL(orgId));
+    }
+    /** Mark an inbox item as read by its source (source_type + source_id) rather than inbox item ID. */
+    async ackInbox(orgId, source) {
+        return this.request('POST', ENDPOINTS.INBOX_ACK(orgId), source);
+    }
+    async deleteInboxItem(orgId, id) {
+        return this.request('DELETE', ENDPOINTS.INBOX_ITEM(orgId, id));
+    }
+    // ---- Dispatch (agent event delivery) ----
+    async getDispatch(orgId, params) {
+        return this.request('GET', ENDPOINTS.DISPATCH(orgId), undefined, params);
+    }
+    async getDispatchPendingCount(orgId) {
+        return this.request('GET', ENDPOINTS.DISPATCH_PENDING_COUNT(orgId));
+    }
+    async ackDispatch(orgId, source) {
+        return this.request('POST', ENDPOINTS.DISPATCH_ACK(orgId), source);
+    }
+    async ackDispatchByID(orgId, id) {
+        return this.request('POST', ENDPOINTS.DISPATCH_ACK_BY_ID(orgId, id));
+    }
+    // ---- Platform Config ----
+    /**
+     * Fetch platform config for the authenticated agent.
+     * Pass currentVersion to enable conditional fetch (If-None-Match / 304).
+     * Returns null when the server responds with 304 (config unchanged).
+     */
+    async getPlatformConfig(currentVersion) {
+        const url = `${this.baseUrl}${ENDPOINTS.PLATFORM_CONFIG}`;
+        const extra = {};
+        if (currentVersion !== undefined) {
+            extra['If-None-Match'] = currentVersion;
+        }
+        const headers = this.buildHeaders(extra);
+        const res = await fetch(url, {
+            method: 'GET',
+            headers,
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (res.status === 304)
+            return null;
+        if (!res.ok) {
+            const errorBody = await res.json().catch(() => ({}));
+            const errorObj = errorBody?.error && typeof errorBody.error === 'object' ? errorBody.error : undefined;
+            const errMsg = errorObj?.message ?? (typeof errorBody?.error === 'string' ? errorBody.error : undefined);
+            const errCode = errorObj?.code ?? (typeof errorBody?.code === 'string' ? errorBody.code : undefined);
+            throw new ApiError(res.status, errMsg ?? res.statusText, errCode);
+        }
+        return res.json();
+    }
+    // ---- Tasks (org-scoped) ----
+    async createTask(orgId, data) {
+        return this.request('POST', ENDPOINTS.TASKS(orgId), data);
+    }
+    async getTasks(orgId, params) {
+        return this.request('GET', ENDPOINTS.TASKS(orgId), undefined, params);
+    }
+    async getTask(orgId, taskId) {
+        return this.request('GET', ENDPOINTS.TASK(orgId, taskId));
+    }
+    async updateTask(orgId, taskId, data) {
+        return this.request('PATCH', ENDPOINTS.TASK(orgId, taskId), data);
+    }
+    async deleteTask(orgId, taskId) {
+        return this.request('DELETE', ENDPOINTS.TASK(orgId, taskId));
+    }
+    async getSubtasks(orgId, taskId) {
+        const res = await this.request('GET', ENDPOINTS.TASK_SUBTASKS(orgId, taskId));
+        return res.data;
+    }
+    async createTaskRelation(orgId, taskId, data) {
+        return this.request('POST', ENDPOINTS.TASK_RELATIONS(orgId, taskId), data);
+    }
+    async getTaskRelations(orgId, taskId) {
+        const res = await this.request('GET', ENDPOINTS.TASK_RELATIONS(orgId, taskId));
+        return res.data;
+    }
+    async deleteTaskRelation(orgId, taskId, relationId) {
+        return this.request('DELETE', ENDPOINTS.TASK_RELATION(orgId, taskId, relationId));
+    }
+    // ---- Task Comments ----
+    async getTaskComments(orgId, taskId, params) {
+        return this.request('GET', ENDPOINTS.TASK_COMMENTS(orgId, taskId), undefined, params);
+    }
+    async getTaskComment(orgId, taskId, commentId) {
+        return this.request('GET', ENDPOINTS.TASK_COMMENT(orgId, taskId, commentId));
+    }
+    async createTaskComment(orgId, taskId, data) {
+        return this.request('POST', ENDPOINTS.TASK_COMMENTS(orgId, taskId), data);
+    }
+    async updateTaskComment(orgId, taskId, commentId, data) {
+        return this.request('PATCH', ENDPOINTS.TASK_COMMENT(orgId, taskId, commentId), data);
+    }
+    async deleteTaskComment(orgId, taskId, commentId) {
+        return this.request('DELETE', ENDPOINTS.TASK_COMMENT(orgId, taskId, commentId));
+    }
+    // ---- Task Activities ----
+    async getTaskActivities(orgId, taskId, params) {
+        return this.request('GET', ENDPOINTS.TASK_ACTIVITIES(orgId, taskId), undefined, params);
+    }
+    // ---- Projects (org-scoped) ----
+    async createProject(orgId, data) {
+        return this.request('POST', ENDPOINTS.PROJECTS(orgId), data);
+    }
+    async getProjects(orgId) {
+        const res = await this.request('GET', ENDPOINTS.PROJECTS(orgId));
+        return res.data;
+    }
+    async getProject(orgId, projectId) {
+        return this.request('GET', ENDPOINTS.PROJECT(orgId, projectId));
+    }
+    async updateProject(orgId, projectId, data) {
+        return this.request('PATCH', ENDPOINTS.PROJECT(orgId, projectId), data);
+    }
+    async deleteProject(orgId, projectId) {
+        return this.request('DELETE', ENDPOINTS.PROJECT(orgId, projectId));
+    }
+    // ---- Wikis (org-scoped) ----
+    async createWiki(orgId, data) {
+        return this.request('POST', ENDPOINTS.WIKIS(orgId), data);
+    }
+    async getWikis(orgId) {
+        const res = await this.request('GET', ENDPOINTS.WIKIS(orgId));
+        return res.data;
+    }
+    async getWiki(orgId, wikiId) {
+        return this.request('GET', ENDPOINTS.WIKI(orgId, wikiId));
+    }
+    async getWikiTree(orgId, wikiId, params) {
+        return this.request('GET', ENDPOINTS.WIKI_TREE(orgId, wikiId), undefined, params);
+    }
+    async getWikiBlob(orgId, wikiId, params) {
+        return this.request('GET', ENDPOINTS.WIKI_BLOB(orgId, wikiId), undefined, params);
+    }
+    async getWikiNodeSections(orgId, wikiId, params) {
+        return this.request('GET', ENDPOINTS.WIKI_NODE_SECTIONS(orgId, wikiId), undefined, params);
+    }
+    async searchWiki(orgId, wikiId, params) {
+        return this.request('GET', ENDPOINTS.WIKI_SEARCH(orgId, wikiId), undefined, params);
+    }
+    async getWikiPageIndex(orgId, wikiId, params) {
+        return this.request('GET', ENDPOINTS.WIKI_PAGE_INDEX(orgId, wikiId), undefined, params);
+    }
+    async getWikiRefs(orgId, wikiId, params) {
+        return this.request('GET', ENDPOINTS.WIKI_REFS(orgId, wikiId), undefined, params);
+    }
+    async checkWikiRefs(orgId, wikiId, params) {
+        return this.request('GET', ENDPOINTS.WIKI_REFS_CHECK(orgId, wikiId), undefined, params);
+    }
+    async createWikiChangeset(orgId, wikiId, data) {
+        return normalizeWikiChangeset(await this.request('POST', ENDPOINTS.WIKI_CHANGESETS(orgId, wikiId), data));
+    }
+    async getWikiChangesets(orgId, wikiId) {
+        const res = await this.request('GET', ENDPOINTS.WIKI_CHANGESETS(orgId, wikiId));
+        return res.data.map(normalizeWikiChangeset);
+    }
+    async getWikiChangeset(orgId, wikiId, changesetId) {
+        return normalizeWikiChangeset(await this.request('GET', ENDPOINTS.WIKI_CHANGESET(orgId, wikiId, changesetId)));
+    }
+    async updateWikiChangeset(orgId, wikiId, changesetId, data) {
+        return normalizeWikiChangeset(await this.request('PATCH', ENDPOINTS.WIKI_CHANGESET(orgId, wikiId, changesetId), data));
+    }
+    async getWikiChangesetDiff(orgId, wikiId, changesetId) {
+        return this.request('GET', ENDPOINTS.WIKI_CHANGESET_DIFF(orgId, wikiId, changesetId));
+    }
+    async mergeWikiChangeset(orgId, wikiId, changesetId) {
+        return normalizeWikiChangeset(await this.request('POST', ENDPOINTS.WIKI_CHANGESET_MERGE(orgId, wikiId, changesetId)));
+    }
+    async closeWikiChangeset(orgId, wikiId, changesetId) {
+        return normalizeWikiChangeset(await this.request('POST', ENDPOINTS.WIKI_CHANGESET_CLOSE(orgId, wikiId, changesetId)));
+    }
+    // ---- Wiki Path Scopes (AFCS ACL) ----
+    async getWikiPathScopes(orgId, wikiId) {
+        const res = await this.request('GET', ENDPOINTS.WIKI_PATH_SCOPES(orgId, wikiId));
+        return res.data;
+    }
+    async createWikiPathScope(orgId, wikiId, data) {
+        return this.request('POST', ENDPOINTS.WIKI_PATH_SCOPES(orgId, wikiId), data);
+    }
+    async deleteWikiPathScope(orgId, wikiId, scopeId) {
+        await this.request('DELETE', ENDPOINTS.WIKI_PATH_SCOPE(orgId, wikiId, scopeId));
+    }
+    async getWikiAccessStatus(orgId, wikiId, path) {
+        return this.request('GET', ENDPOINTS.WIKI_ACCESS_STATUS(orgId, wikiId), undefined, path ? { path } : undefined);
+    }
+    async createWikiAccessRequest(orgId, wikiId, data) {
+        await this.request('POST', ENDPOINTS.WIKI_ACCESS_REQUESTS(orgId, wikiId), data);
+    }
+    // ---- Wiki History (commits, file commits, blame) ----
+    async getWikiCommits(orgId, wikiId, params) {
+        return this.request('GET', ENDPOINTS.WIKI_COMMITS(orgId, wikiId), undefined, params);
+    }
+    async getWikiFileCommits(orgId, wikiId, path, params) {
+        return this.request('GET', ENDPOINTS.WIKI_FILE_COMMITS(orgId, wikiId), undefined, { path, ...params });
+    }
+    async getWikiBlame(orgId, wikiId, path, ref) {
+        return this.request('GET', ENDPOINTS.WIKI_BLAME(orgId, wikiId), undefined, { path, ref });
+    }
+    // ---- Wiki Operations (audit log) ----
+    async getWikiOperations(orgId, wikiId, params) {
+        return this.request('GET', ENDPOINTS.WIKI_OPERATIONS(orgId, wikiId), undefined, params);
+    }
+    async revertWikiOperation(orgId, wikiId, opId) {
+        return this.request('POST', ENDPOINTS.WIKI_OPERATION_REVERT(orgId, wikiId, opId));
+    }
+    // ---- References ----
+    async resolveRefs(orgId, refs) {
+        return this.request('POST', ENDPOINTS.REFS_RESOLVE(orgId), { refs });
+    }
+    async getBacklinks(orgId, params) {
+        return this.request('GET', ENDPOINTS.REFS_BACKLINKS(orgId), undefined, params);
+    }
+    async checkBrokenRefs(orgId) {
+        return this.request('GET', ENDPOINTS.REFS_CHECK(orgId));
+    }
+    // ---- Push Notifications ----
+    async subscribePush(body) {
+        return this.request('POST', ENDPOINTS.PUSH_SUBSCRIBE, body);
+    }
+    async unsubscribePush(token) {
+        return this.request('DELETE', ENDPOINTS.PUSH_UNSUBSCRIBE, { token });
+    }
+    async getVapidKey() {
+        return this.request('GET', ENDPOINTS.PUSH_VAPID_KEY);
+    }
+    // ---- Notification Preferences ----
+    async getNotificationPreferences() {
+        return this.request('GET', ENDPOINTS.NOTIFICATION_PREFERENCES);
+    }
+    async updateNotificationPreferences(prefs) {
+        return this.request('PATCH', ENDPOINTS.NOTIFICATION_PREFERENCES, { prefs });
+    }
+}
+function normalizeWikiChangeset(changeset) {
+    return {
+        ...changeset,
+        changed_paths: changeset.changed_paths ?? [],
+        file_changes: changeset.file_changes ?? [],
+    };
+}
+export class ApiError extends Error {
+    status;
+    code;
+    constructor(status, message, code) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = 'ApiError';
+    }
+}