@permute/sdk 0.7.0 → 0.8.1

package/dist/auth/store.js

@@ -0,0 +1,106 @@
+import { z } from 'zod';
+import { createHash, randomUUID } from 'node:crypto';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { setTimeout } from 'node:timers/promises';
+export const TOKEN_REFRESH_BUFFER_MS = 60_000;
+const LoginCredentialsSchema = z.object({
+    issuer: z.string().url(),
+    apiUrl: z.string().url(),
+    workspaceId: z.string().min(1).optional(),
+    organizationId: z.string().min(1).optional(),
+    sessionId: z.string().min(1),
+    access: z.string().min(1),
+    refresh: z.string().min(1),
+    expiresAt: z.number().finite(),
+});
+/** Credentials are cached in memory only; disk holds a lock and a non-secret change marker. */
+export class SystemCredentialStore {
+    issuer;
+    onAccess;
+    account;
+    directory = join(homedir(), '.config', 'permute', 'auth');
+    revisionPath;
+    cached;
+    announced = false;
+    constructor(issuer, onAccess) {
+        this.issuer = issuer;
+        this.onAccess = onAccess;
+        this.account = createHash('sha256').update(issuer).digest('hex');
+        this.revisionPath = join(this.directory, `${this.account}.revision`);
+    }
+    async entry() {
+        const { AsyncEntry } = await import('@napi-rs/keyring');
+        if (!this.announced) {
+            this.onAccess?.(this.issuer);
+            this.announced = true;
+        }
+        return new AsyncEntry('permute-cli', this.account, { linux: { store: 'secret-service' } });
+    }
+    async read() {
+        const revision = await readFile(this.revisionPath, 'utf8').catch((error) => {
+            if (error.code === 'ENOENT')
+                return null;
+            throw error;
+        });
+        if (this.cached?.revision === revision && this.cached.value.expiresAt > Date.now() + TOKEN_REFRESH_BUFFER_MS)
+            return { ...this.cached.value };
+        this.cached = undefined;
+        const value = await (await this.entry()).getPassword();
+        if (!value)
+            return null;
+        const credentials = this.validate(JSON.parse(value));
+        this.cached = { revision, value: credentials };
+        return { ...credentials };
+    }
+    validate(value) {
+        const parsed = LoginCredentialsSchema.safeParse(value);
+        if (!parsed.success || parsed.data.issuer !== this.issuer)
+            throw new Error('Stored login is invalid. Run permute auth login again.');
+        return parsed.data;
+    }
+    async write(value) {
+        const credentials = this.validate(value);
+        this.cached = undefined;
+        await (await this.entry()).setPassword(JSON.stringify(credentials));
+        const revision = await this.markChanged();
+        this.cached = { revision, value: credentials };
+    }
+    async remove() {
+        this.cached = undefined;
+        const entry = await this.entry();
+        if (await entry.getPassword())
+            await entry.deletePassword();
+        await this.markChanged();
+    }
+    async markChanged() {
+        await mkdir(this.directory, { recursive: true, mode: 0o700 });
+        const revision = randomUUID();
+        await writeFile(this.revisionPath, revision, { mode: 0o600 });
+        return revision;
+    }
+    async exclusive(run) {
+        await mkdir(this.directory, { recursive: true, mode: 0o700 });
+        const lock = join(this.directory, `${this.account}.lock`);
+        const deadline = Date.now() + 30_000;
+        while (true) {
+            const acquired = await mkdir(lock, { mode: 0o700 }).then(() => true, (error) => {
+                if (error.code !== 'EEXIST')
+                    throw error;
+                return false;
+            });
+            if (acquired)
+                break;
+            if (Date.now() >= deadline)
+                throw new Error(`Another process is updating this login. Retry after it finishes. If a process crashed, stop other Permute CLI processes before removing ${lock}.`);
+            await setTimeout(100);
+        }
+        try {
+            return await run();
+        }
+        finally {
+            await rm(lock, { recursive: true, force: true });
+        }
+    }
+}

package/dist/auth.d.ts

@@ -0,0 +1 @@
+export * from './auth/oauth.js';

package/dist/auth.js

@@ -0,0 +1 @@
+export * from './auth/oauth.js';

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function runCli(args?: string[]): Promise<void>;

package/dist/cli.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+import { createServer } from 'node:http';
+import { spawn } from 'node:child_process';
+import { parseArgs } from 'node:util';
+import { pathToFileURL } from 'node:url';
+import { realpathSync } from 'node:fs';
+import { OAuthLogin } from './auth.js';
+function openBrowser(url) {
+    const command = process.platform === 'darwin' ? 'open' : process.platform === 'linux' ? 'xdg-open' : undefined;
+    if (!command)
+        return;
+    const child = spawn(command, [url], { stdio: 'ignore' });
+    child.on('error', () => {
+        /* The printed link also works when no local browser is available. */
+    });
+    child.unref();
+}
+async function browserLogin(login, open) {
+    let destination;
+    let resolveCallback;
+    let rejectCallback;
+    const callback = new Promise((resolve, reject) => {
+        resolveCallback = resolve;
+        rejectCallback = reject;
+    });
+    const server = createServer((request, response) => {
+        if (!destination ||
+            request.method !== 'GET' ||
+            request.headers.host !== new URL(destination.redirectURI).host ||
+            !request.url?.startsWith('/callback?')) {
+            response.writeHead(400).end('This callback does not match the login request.');
+            return;
+        }
+        const url = new URL(request.url, destination.redirectURI);
+        if (url.searchParams.get('state') !== destination.state) {
+            response.writeHead(400).end('This callback does not match the login request.');
+            return;
+        }
+        response
+            .writeHead(200, {
+            'Content-Type': 'text/plain',
+            'Cache-Control': 'no-store',
+            'Content-Security-Policy': "default-src 'none'",
+        })
+            .end('Return to your terminal to finish connecting. You can close this tab.');
+        resolveCallback(url);
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', resolve);
+    });
+    const address = server.address();
+    if (!address || typeof address === 'string')
+        throw new Error('Could not open a loopback callback');
+    destination = login.beginBrowser(`http://127.0.0.1:${address.port}/callback`);
+    const timeout = setTimeout(() => rejectCallback(new Error('Login timed out. Start login again.')), 600_000);
+    const cancel = () => rejectCallback(new Error('Login canceled.'));
+    process.once('SIGINT', cancel);
+    try {
+        console.log(`Open this link to connect Permute CLI:\n${destination.url}`);
+        if (open)
+            openBrowser(destination.url);
+        return await login.finishBrowser(destination, await callback);
+    }
+    finally {
+        clearTimeout(timeout);
+        process.off('SIGINT', cancel);
+        server.closeAllConnections();
+        server.close();
+    }
+}
+export async function runCli(args = process.argv.slice(2)) {
+    const { values, positionals } = parseArgs({
+        args,
+        allowPositionals: true,
+        options: {
+            issuer: { type: 'string' },
+            'api-url': { type: 'string' },
+            'device-code': { type: 'boolean' },
+            'no-browser': { type: 'boolean' },
+            help: { type: 'boolean' },
+        },
+    });
+    const [area, command] = positionals;
+    if (values.help || area !== 'auth' || !['login', 'logout', 'status'].includes(command ?? '')) {
+        console.log('permute auth login [--device-code] [--no-browser]\npermute auth status\npermute auth logout\n\nUse --issuer and --api-url together for a development environment.');
+        if (!values.help)
+            process.exitCode = 1;
+        return;
+    }
+    if (!!values.issuer !== !!values['api-url'])
+        throw new Error('Provide both --issuer and --api-url for another environment.');
+    const login = new OAuthLogin({
+        issuer: values.issuer,
+        apiUrl: values['api-url'],
+        onCredentialStoreAccess: (issuer) => {
+            const store = process.platform === 'darwin' ? 'macOS Keychain' : 'your OS credential store';
+            console.error(`Permute CLI is accessing ${store} for ${issuer} (entry: permute-cli).`);
+        },
+    });
+    if (command === 'logout') {
+        await login.logout();
+        console.log('CLI login revoked and removed from this device.');
+        return;
+    }
+    if (command === 'status') {
+        const credentials = await login.credentials();
+        console.log(`Connected to ${credentials.apiUrl}\nOrganization: ${credentials.organizationId ?? 'Not specified'}\nWorkspace: ${credentials.workspaceId ?? 'All accessible workspaces in this organization'}`);
+        return;
+    }
+    const controller = new AbortController();
+    const cancel = () => controller.abort();
+    process.once('SIGINT', cancel);
+    try {
+        if (values['device-code']) {
+            const request = await login.beginDevice();
+            console.log(`Open this link on any device:\n${request.url}\n\nConfirm this code: ${request.userCode}\nWaiting for your approval…`);
+            if (!values['no-browser'])
+                openBrowser(request.url);
+            await login.finishDevice(request, controller.signal);
+        }
+        else
+            await browserLogin(login, !values['no-browser']);
+        console.log('Connected. Credentials are saved in your operating system’s credential store.');
+    }
+    finally {
+        process.off('SIGINT', cancel);
+    }
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href)
+    runCli().catch(() => {
+        console.error('Could not complete authentication. Ensure your OS credential store is available, then retry. Use --device-code --no-browser to approve from another device.');
+        process.exitCode = 1;
+    });

package/dist/client.d.ts

@@ -1,6 +1,7 @@
+import type { EmailSender, EmailSendRequest, EmailReceipt, PermissionGrant, PermissionGrantInput, PermissionGrantUpdate, PermissionGrantQuery, PermissionGrantList, PermissionGrantRevoked, PermissionInspectionInput, PermissionInspection, AccessRequest, AccessRequestInput, AccessRequestQuery, AccessRequestList, AccessRequestDecision } from './types.js';
 export { PermuteApiError } from './errors.js';
-import type { BusinessAction, BusinessActionList, ActionCreateRequest, ActionDefinition, ActionDefinitionSaveRequest, ActionDefinitionSaved, ActionRequest, ActionReceipt } from './types.js';
-import type { ConnectorSession, ConnectorSessionCreated, ConnectorSessionCreateRequest, Database, AppDraft, AppAccess, AppAddressSettings, AppAddressSetRequest, AppAccessSetRequest, AppDraftList, AppCreateRequest, AppUpdateRequest, AppDeleted, AppUploadsRequest, AppUploads, AppSiteSaveRequest, AppSourceFileQuery, AppSourceFileContent, AppGrants, AppGrantSetRequest, AppUploadFile, DatabaseList, DatabaseCreateRequest, DatabaseDefinition, DatabaseDefinitionSaveRequest, DatabaseDefinitionSaved, DatabaseTables, DatabaseTableCreateRequest, DatabaseTableCreated, DatabaseRecords, DatabaseRecordsQuery, DatabaseTransactionRequest, DatabaseTransactionReceipt, WriteSync, WriteSyncCreateRequest, WriteSyncUpdateRequest, WriteSyncDetail, WriteSyncList, WriteSyncDeleted, WriteSyncDestinations, WriteSyncRun, WriteSyncRunList, WriteSyncRunQuery, WriteSyncExecution, ResourceVersionState, ResourceRevisionList, ResourceRevision, ResourceVersionRequest, ResourcePublishRequest, Fact, FactList, FactWriteRequest, SkillList, SkillContent, SkillWriteRequest, KnowledgeWriteResponse, OperationRunGroup, OperationRunQuery, Operation, OperationList, OperationListQuery, OperationSource, OperationSourceUpdateRequest, OperationUpdateRequest, OperationRunRequest, OperationRunStarted, OperationRunList, OperationRunOutput, DataFlow, DataFlowCreateRequest, DataFlowCommandRequest, DataFlowCommandResponse, Workspace, WorkspaceCreateRequest, WorkspaceDeleteResponse, WorkspaceList, WorkspaceUpdateRequest, AnswerRequest, AnswerResponse, PermuteClientOptions, PermuteRequestOptions, QueryRequest, SearchRequest, SourceDetail, CatalogTable, SourceList, CustomDatasetCreateRequest, DatasetDeleteResponse, DatasetResponse, FileDatasetCreateRequest, FileDatasetMetadataCreateRequest, FileDatasetResponse, DatasetRows, CustomDatasetResponse, DashboardSource, DashboardSourceUpdateRequest } from './types.js';
+import type { BusinessAction, BusinessActionDetail, BusinessActionList, ActionCreateRequest, ActionDefinition, ActionDefinitionSaveRequest, ActionDefinitionSaved, ActionRequest, ActionReceipt, ActionPublicationRequest, ActionPublicationRequestInput, ActionPublicationRequestList, ActionPublicationDecision } from './types.js';
+import type { ConnectorSession, ConnectorSessionCreated, ConnectorSessionCreateRequest, Database, AppPublicationRequest, AppPublicationRequestInput, AppPublicationRequestList, AppPublicationDecision, AppDraft, AppAccess, AppAddressSettings, AppAddressSetRequest, AppAccessSetRequest, AppDraftList, AppCreateRequest, AppUpdateRequest, AppDeleted, AppUploadsRequest, AppUploads, AppSiteSaveRequest, AppSourceFileQuery, AppSourceFileContent, AppGrants, AppGrantSetRequest, AppUploadFile, DatabaseList, DatabaseCreateRequest, DatabaseDefinition, DatabaseDefinitionSaveRequest, DatabaseDefinitionSaved, DatabaseTables, DatabaseTableCreateRequest, DatabaseTableCreated, DatabaseRecords, DatabaseRecordsQuery, DatabaseTransactionRequest, DatabaseTransactionReceipt, WriteSync, WriteSyncCreateRequest, WriteSyncUpdateRequest, WriteSyncDetail, WriteSyncList, WriteSyncDeleted, WriteSyncDestinations, WriteSyncRun, WriteSyncRunList, WriteSyncRunQuery, WriteSyncExecution, ResourceVersionState, ResourceRevisionList, ResourceRevision, ResourceVersionRequest, ResourcePublishRequest, Fact, FactList, FactWriteRequest, SkillList, SkillContent, SkillWriteRequest, KnowledgeWriteResponse, OperationRunGroup, OperationRunQuery, Operation, OperationList, OperationListQuery, OperationSource, OperationSourceUpdateRequest, OperationUpdateRequest, OperationRunRequest, OperationRunStarted, OperationRunList, OperationRunOutput, DataFlow, DataFlowCreateRequest, DataFlowCommandRequest, DataFlowCommandResponse, Workspace, WorkspaceCreateRequest, WorkspaceDeleteResponse, WorkspaceList, WorkspaceUpdateRequest, AnswerRequest, AnswerResponse, PermuteClientOptions, PermuteRequestOptions, QueryRequest, SearchRequest, SourceDetail, CatalogTable, SourceList, CustomDatasetCreateRequest, DatasetDeleteResponse, DatasetResponse, FileDatasetCreateRequest, FileDatasetMetadataCreateRequest, FileDatasetResponse, DatasetRows, CustomDatasetResponse, DashboardSource, DashboardSourceUpdateRequest } from './types.js';
 type DatasetWriteInput = {
     tables: Record<string, DatasetRows>;
     mode: 'replace';
@@ -19,7 +20,7 @@ type DatasetReader = (id: string, options?: PermuteRequestOptions) => Promise<Da
 export declare class PermuteDataset {
     private readonly writeTables;
     private readonly readDataset;
-    readonly type: "custom";
+    readonly type: 'custom';
     private snapshot;
     constructor(snapshot: CustomDatasetResponse, writeTables: DatasetWriter, readDataset: DatasetReader);
     get data(): CustomDatasetResponse;
@@ -39,7 +40,7 @@ export declare class PermuteDataset {
 }
 export declare class PermuteFileDataset {
     private readonly readDataset;
-    readonly type: "file";
+    readonly type: 'file';
     private snapshot;
     constructor(snapshot: FileDatasetResponse, readDataset: DatasetReader);
     get data(): FileDatasetResponse;
@@ -56,6 +57,19 @@ export interface SkillsClient {
     delete(path: string, options?: PermuteRequestOptions): Promise<KnowledgeWriteResponse>;
 }
 export declare class PermuteClient {
+    readonly permissions: {
+        update(permissionId: string, body: PermissionGrantUpdate, options?: PermuteRequestOptions): Promise<PermissionGrant>;
+        list(query?: PermissionGrantQuery, options?: PermuteRequestOptions): Promise<PermissionGrantList>;
+        create(body: PermissionGrantInput, options?: PermuteRequestOptions): Promise<PermissionGrant>;
+        delete(permissionId: string, options?: PermuteRequestOptions): Promise<PermissionGrantRevoked>;
+        inspect(body: PermissionInspectionInput, options?: PermuteRequestOptions): Promise<PermissionInspection>;
+    };
+    readonly accessRequests: {
+        create(body: AccessRequestInput, options?: PermuteRequestOptions): Promise<AccessRequest>;
+        list(query?: AccessRequestQuery, options?: PermuteRequestOptions): Promise<AccessRequestList>;
+        get(requestId: string, options?: PermuteRequestOptions): Promise<AccessRequest>;
+        decide(requestId: string, body: AccessRequestDecision, options?: PermuteRequestOptions): Promise<AccessRequest>;
+    };
     readonly revisions: {
         list(resourceId: string, options?: PermuteRequestOptions): Promise<ResourceRevisionList>;
         get(resourceId: string, revisionId: string, options?: PermuteRequestOptions): Promise<ResourceRevision>;
@@ -72,14 +86,22 @@ export declare class PermuteClient {
     readonly skills: SkillsClient;
     readonly organizationSkills: SkillsClient;
     readonly actions: {
+        requestPublication(actionId: string, body: ActionPublicationRequestInput, options?: PermuteRequestOptions): Promise<ActionPublicationRequest>;
+        publicationRequests(actionId: string, options?: PermuteRequestOptions): Promise<ActionPublicationRequestList>;
+        decidePublication(actionId: string, requestId: string, body: ActionPublicationDecision, options?: PermuteRequestOptions): Promise<ActionPublicationRequest>;
         list(options?: PermuteRequestOptions): Promise<BusinessActionList>;
         create(body: ActionCreateRequest, options?: PermuteRequestOptions): Promise<BusinessAction>;
-        get(actionId: string, options?: PermuteRequestOptions): Promise<BusinessAction>;
+        get(actionId: string, options?: PermuteRequestOptions): Promise<BusinessActionDetail>;
         delete(actionId: string, options?: PermuteRequestOptions): Promise<BusinessAction>;
         definition(actionId: string, options?: PermuteRequestOptions): Promise<ActionDefinition>;
         saveDefinition(actionId: string, body: ActionDefinitionSaveRequest, options?: PermuteRequestOptions): Promise<ActionDefinitionSaved>;
         invoke(actionId: string, body: ActionRequest, options?: PermuteRequestOptions): Promise<ActionReceipt>;
     };
+    readonly emails: {
+        get(options?: PermuteRequestOptions): Promise<EmailSender>;
+        /** Only callable from Business Actions through platform.withStep(stepId). */
+        send(body: EmailSendRequest, options?: PermuteRequestOptions): Promise<EmailReceipt>;
+    };
     readonly databases: {
         list(options?: PermuteRequestOptions): Promise<DatabaseList>;
         create(body: DatabaseCreateRequest, options?: PermuteRequestOptions): Promise<Database>;
@@ -93,6 +115,9 @@ export declare class PermuteClient {
         transact(databaseId: string, body: DatabaseTransactionRequest, options?: PermuteRequestOptions): Promise<DatabaseTransactionReceipt>;
     };
     readonly apps: {
+        requestPublication(applicationId: string, body: AppPublicationRequestInput, options?: PermuteRequestOptions): Promise<AppPublicationRequest>;
+        publicationRequests(applicationId: string, options?: PermuteRequestOptions): Promise<AppPublicationRequestList>;
+        decidePublication(applicationId: string, requestId: string, body: AppPublicationDecision, options?: PermuteRequestOptions): Promise<AppPublicationRequest>;
         address(applicationId: string, options?: PermuteRequestOptions): Promise<AppAddressSettings>;
         setAddress(applicationId: string, body: AppAddressSetRequest, options?: PermuteRequestOptions): Promise<AppAddressSettings>;
         access(applicationId: string, options?: PermuteRequestOptions): Promise<AppAccess>;
@@ -172,7 +197,8 @@ export declare class PermuteClient {
         download: (datasetId: string, options?: PermuteRequestOptions) => Promise<string>;
         delete: (datasetId: string, options?: PermuteRequestOptions) => Promise<DatasetDeleteResponse>;
     };
-    private readonly apiKey;
+    private readonly apiKey?;
+    private readonly accessToken?;
     private readonly baseUrl;
     /** Workspace selected for workspace-scoped API operations. */
     readonly workspaceId?: string;
@@ -191,12 +217,12 @@ export declare class PermuteClient {
             score?: number;
             sourceId?: string;
             title?: string;
-            type: "record" | "document" | "table" | "text_block" | "unknown";
+            type: 'record' | 'document' | 'table' | 'text_block' | 'unknown';
         }[];
         meta: {
             candidateCount?: number;
             reranked: boolean;
-            strategy: "semantic";
+            strategy: 'semantic';
             totalMs?: number;
         };
     }>;
@@ -222,18 +248,18 @@ export declare class PermuteClient {
                 ref?: string;
                 sourceId?: string;
                 title?: string;
-                type: "text" | "table" | "web" | "fact";
+                type: 'text' | 'table' | 'web' | 'fact';
                 url?: string;
             }[];
             confidence?: {
-                queryComplexity: "high" | "medium" | "low";
+                queryComplexity: 'high' | 'medium' | 'low';
                 reason: string;
                 score: number;
             };
             followUps?: string[];
         };
         startedAt?: string | null;
-        status: "queued" | "running" | "completed" | "failed" | "cancelled";
+        status: 'queued' | 'running' | 'completed' | 'failed' | 'cancelled';
         updatedAt?: string;
     }>;
     getAnswerJob: (answerJobId: string, options?: PermuteRequestOptions) => Promise<{
@@ -257,18 +283,18 @@ export declare class PermuteClient {
                 ref?: string;
                 sourceId?: string;
                 title?: string;
-                type: "text" | "table" | "web" | "fact";
+                type: 'text' | 'table' | 'web' | 'fact';
                 url?: string;
             }[];
             confidence?: {
-                queryComplexity: "high" | "medium" | "low";
+                queryComplexity: 'high' | 'medium' | 'low';
                 reason: string;
                 score: number;
             };
             followUps?: string[];
         };
         startedAt?: string | null;
-        status: "queued" | "running" | "completed" | "failed" | "cancelled";
+        status: 'queued' | 'running' | 'completed' | 'failed' | 'cancelled';
         updatedAt?: string;
     }>;
     withWorkspace(workspaceId: string): PermuteClient;

package/dist/client.js

@@ -251,11 +251,14 @@ export class PermuteFileDataset {
     }
 }
 export class PermuteClient {
+    permissions;
+    accessRequests;
     revisions;
     facts;
     skills;
     organizationSkills;
     actions;
+    emails;
     databases;
     apps;
     connectorSessions;
@@ -267,17 +270,18 @@ export class PermuteClient {
     dashboards;
     datasets;
     apiKey;
+    accessToken;
     baseUrl;
     /** Workspace selected for workspace-scoped API operations. */
     workspaceId;
     defaultHeaders;
     fetchImpl;
     constructor(options) {
-        if (!options.apiKey) {
+        if ((!options.apiKey && !options.accessToken) || (options.apiKey && options.accessToken)) {
             throw new PermuteApiError({
                 status: 0,
                 code: 'missing_api_key',
-                message: 'apiKey is required',
+                message: 'Provide apiKey or accessToken',
             });
         }
         const fetchImpl = options.fetch ?? globalThis.fetch;
@@ -289,10 +293,24 @@ export class PermuteClient {
             });
         }
         this.apiKey = options.apiKey;
+        this.accessToken = options.accessToken;
         this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
         this.workspaceId = options.workspaceId;
         this.defaultHeaders = options.headers ?? {};
         this.fetchImpl = fetchImpl.bind(globalThis);
+        this.permissions = {
+            update: this.bindMethod('permissionsUpdate', (request) => (permissionId, body, options) => request({ pathParams: { permissionId }, body }, options)),
+            list: this.bindMethod('permissionsList', (request) => (query, options) => request({ query }, options)),
+            create: this.bindMethod('permissionsCreate', (request) => (body, options) => request({ body }, options)),
+            delete: this.bindMethod('permissionsDelete', (request) => (permissionId, options) => request({ pathParams: { permissionId } }, options)),
+            inspect: this.bindMethod('permissionsInspect', (request) => (body, options) => request({ body }, options)),
+        };
+        this.accessRequests = {
+            create: this.bindMethod('accessRequestsCreate', (request) => (body, options) => request({ body }, options)),
+            list: this.bindMethod('accessRequestsList', (request) => (query, options) => request({ query }, options)),
+            get: this.bindMethod('accessRequestsGet', (request) => (requestId, options) => request({ pathParams: { requestId } }, options)),
+            decide: this.bindMethod('accessRequestsDecide', (request) => (requestId, body, options) => request({ pathParams: { requestId }, body }, options)),
+        };
         this.revisions = {
             list: this.bindMethod('resourceRevisionsList', (apiRequest) => (resourceId, options) => apiRequest({ pathParams: { resourceId } }, options)),
             get: this.bindMethod('resourceRevisionsGet', (apiRequest) => (resourceId, revisionId, options) => apiRequest({ pathParams: { resourceId, revisionId } }, options)),
@@ -315,6 +333,9 @@ export class PermuteClient {
         this.skills = skillsClient('skills');
         this.organizationSkills = skillsClient('organizationSkills');
         this.actions = {
+            requestPublication: this.bindMethod('actionsPublicationRequestsCreate', (apiRequest) => (actionId, body, options) => apiRequest({ pathParams: { actionId }, body }, options)),
+            publicationRequests: this.bindMethod('actionsPublicationRequestsList', (apiRequest) => (actionId, options) => apiRequest({ pathParams: { actionId } }, options)),
+            decidePublication: this.bindMethod('actionsPublicationRequestsDecide', (apiRequest) => (actionId, requestId, body, options) => apiRequest({ pathParams: { actionId, requestId }, body }, options)),
             list: this.bindMethod('actionsList', (apiRequest) => (options) => apiRequest({}, options)),
             create: this.bindMethod('actionsCreate', (apiRequest) => (body, options) => apiRequest({ body }, options)),
             get: this.bindMethod('actionsGet', (apiRequest) => (actionId, options) => apiRequest({ pathParams: { actionId } }, options)),
@@ -323,6 +344,10 @@ export class PermuteClient {
             saveDefinition: this.bindMethod('actionDefinitionSave', (apiRequest) => (actionId, body, options) => apiRequest({ pathParams: { actionId }, body }, options)),
             invoke: this.bindMethod('actionsInvoke', (apiRequest) => (actionId, body, options) => apiRequest({ pathParams: { actionId }, body }, options)),
         };
+        this.emails = {
+            get: this.bindMethod('emailsGet', (request) => (options) => request({}, options)),
+            send: this.bindMethod('emailsSend', (request) => (body, options) => request({ body }, options)),
+        };
         this.databases = {
             list: this.bindMethod('databasesList', (apiRequest) => (options) => apiRequest({}, options)),
             create: this.bindMethod('databasesCreate', (apiRequest) => (body, options) => apiRequest({ body }, options)),
@@ -336,6 +361,9 @@ export class PermuteClient {
             transact: this.bindMethod('databaseTransactionsCreate', (apiRequest) => (databaseId, body, options) => apiRequest({ pathParams: { databaseId }, body }, options)),
         };
         this.apps = {
+            requestPublication: this.bindMethod('appsPublicationRequestsCreate', (apiRequest) => (applicationId, body, options) => apiRequest({ pathParams: { applicationId }, body }, options)),
+            publicationRequests: this.bindMethod('appsPublicationRequestsList', (apiRequest) => (applicationId, options) => apiRequest({ pathParams: { applicationId } }, options)),
+            decidePublication: this.bindMethod('appsPublicationRequestsDecide', (apiRequest) => (applicationId, requestId, body, options) => apiRequest({ pathParams: { applicationId, requestId }, body }, options)),
             sourceFile: this.bindMethod('appsSourceFileGet', (apiRequest) => (applicationId, query, options) => apiRequest({ pathParams: { applicationId }, query }, options)),
             address: this.bindMethod('appsAddressGet', (apiRequest) => (applicationId, options) => apiRequest({ pathParams: { applicationId } }, options)),
             setAddress: this.bindMethod('appsAddressSet', (apiRequest) => (applicationId, body, options) => apiRequest({ pathParams: { applicationId }, body }, options)),
@@ -613,6 +641,7 @@ export class PermuteClient {
         }
         return new PermuteClient({
             apiKey: this.apiKey,
+            accessToken: this.accessToken,
             baseUrl: this.baseUrl,
             workspaceId,
             fetch: this.fetchImpl,
@@ -628,7 +657,7 @@ export class PermuteClient {
         const body = this.validateRequestBody(route, operationId, input.body);
         const query = this.validateRequestQuery(route, operationId, input.query);
         const headers = {
-            Authorization: `Bearer ${this.apiKey}`,
+            Authorization: `Bearer ${this.accessToken ? await this.accessToken() : this.apiKey}`,
             ...this.defaultHeaders,
             ...options?.headers,
         };

package/dist/deploy.d.ts

@@ -28,7 +28,7 @@ export declare function saveAppSource(client: PermuteClient, options: {
     deployment: {
         error: string | null;
         revisionId: string;
-        status: "deploying" | "live" | "deleting" | "failed" | "deleted";
+        status: 'deploying' | 'live' | 'deleting' | 'failed' | 'deleted';
         url: string;
     } | null;
     description: string;