@whitewall/blip-sdk 0.0.136 → 0.0.138

package/src/namespaces/portal.ts

@@ -0,0 +1,402 @@
+import type { BlipClient } from '../client.ts'
+import { BlipError } from '../sender/bliperror.ts'
+import { PluginSender } from '../sender/plugin/pluginsender.ts'
+import type { Tenant } from '../types/account.ts'
+import { type Identity, Node, type PossiblyNode } from '../types/node.ts'
+import type { Application, ApplicationUserInfo, TenantSubscription, TenantUserInfo } from '../types/portal.ts'
+import { uri } from '../utils/uri.ts'
+import { type ConsumeOptions, Namespace, type SendCommandOptions } from './namespace.ts'
+
+export class PortalNamespace extends Namespace {
+    constructor(blipClient: BlipClient, defaultOptions?: SendCommandOptions) {
+        super(blipClient, 'portal', { ...defaultOptions, domain: 'blip.ai' })
+    }
+
+    public async getInstalledPlugins(opts?: ConsumeOptions) {
+        const configurations = await this.blipClient.account.getConfigurations({
+            ...opts,
+            ownerIdentity: this.identity,
+        })
+        if ('Plugins' in configurations) {
+            const plugins = JSON.parse(configurations.Plugins) as Record<string, { name: string; url: string }>
+            return Object.entries(plugins).map(([key, value]) => ({
+                id: key,
+                name: value.name,
+                url: value.url,
+            }))
+        }
+
+        return []
+    }
+
+    public async deletePlugin(id: string, opts?: ConsumeOptions): Promise<void>
+    public async deletePlugin(url: string | RegExp, opts?: ConsumeOptions): Promise<void>
+    public async deletePlugin(idOrUrl: string | RegExp, opts?: ConsumeOptions): Promise<void> {
+        const configurations = await this.blipClient.account.getConfigurations({
+            ...opts,
+            ownerIdentity: this.identity,
+        })
+
+        if ('Plugins' in configurations) {
+            const plugins = JSON.parse(configurations.Plugins) as Record<string, { name: string; url: string }>
+            for (const id in plugins) {
+                if (
+                    (idOrUrl instanceof RegExp && idOrUrl.test(plugins[id].url)) ||
+                    (typeof idOrUrl === 'string' && (idOrUrl === id || plugins[id].url === idOrUrl))
+                ) {
+                    delete plugins[id]
+                }
+            }
+
+            return await this.blipClient.account.setConfigurations(
+                { Plugins: JSON.stringify(plugins) },
+                { ...opts, ownerIdentity: this.identity },
+            )
+        }
+    }
+
+    public async addPlugin(
+        id: string,
+        settings: {
+            name: string
+            url: string
+        },
+        opts?: ConsumeOptions,
+    ): Promise<void> {
+        const configurations = await this.blipClient.account.getConfigurations({
+            ...opts,
+            ownerIdentity: this.identity,
+        })
+
+        const plugins = 'Plugins' in configurations ? JSON.parse(configurations.Plugins) : {}
+        plugins[id] = settings
+
+        return await this.blipClient.account.setConfigurations(
+            { Plugins: JSON.stringify(plugins) },
+            { ...opts, ownerIdentity: this.identity },
+        )
+    }
+
+    public async updatePlugin(
+        id: string,
+        settings: Partial<{
+            name: string
+            url: string
+        }>,
+        opts?: ConsumeOptions,
+    ): Promise<void> {
+        const configurations = await this.blipClient.account.getConfigurations({
+            ...opts,
+            ownerIdentity: this.identity,
+        })
+
+        if ('Plugins' in configurations) {
+            const plugins = JSON.parse(configurations.Plugins) as Record<string, { name: string; url: string }>
+            if (id in plugins) {
+                plugins[id] = { ...plugins[id], ...settings }
+                return await this.blipClient.account.setConfigurations(
+                    { Plugins: JSON.stringify(plugins) },
+                    { ...opts, ownerIdentity: this.identity },
+                )
+            } else {
+                throw new Error(`Plugin with id "${id}" not found`)
+            }
+        } else {
+            throw new Error('No plugins found')
+        }
+    }
+
+    public getApplication(bot?: PossiblyNode, opts?: ConsumeOptions): Promise<Application & { accessKey: string }> {
+        if (bot) {
+            return this.sendCommand(
+                {
+                    method: 'get',
+                    uri: uri`/applications/${Node.from(bot, 'msging.net')}`,
+                },
+                opts,
+            )
+        } else {
+            if (!this.blipClient.context.isOnPortal()) {
+                throw new Error('This command is only allowed for portal senders')
+            }
+
+            const sender = PluginSender.check(this.blipClient)
+            return sender.channel.post('getApplication', null)
+        }
+    }
+
+    public getApplications(tenantId: string, opts?: ConsumeOptions): Promise<Array<Application>> {
+        return this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/applications?${{ tenantId }}`,
+            },
+            {
+                collection: true,
+                // This route doesn't handle pagination correctly, it will always fetch all
+                fetchall: false,
+                ...opts,
+            },
+        )
+    }
+
+    /** @returns all applications where the current user is an admin */
+    public getAdminApplications(tenantId?: string, opts?: ConsumeOptions): Promise<Array<Identity>> {
+        return this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/applications-admin?${{ tenantId }}`,
+            },
+            {
+                collection: true,
+                // This route doesn't handle pagination correctly, it will always fetch all
+                fetchall: false,
+                ...opts,
+            },
+        )
+    }
+
+    public async getParentApplications(): Promise<Array<Application>> {
+        const current = await this.getApplication()
+        const applications = await this.getApplications(current.tenantId)
+
+        const parentApps = await Promise.all(
+            applications.map(async (app) => {
+                const client = this.blipClient.as(app.shortName)
+                const template = await client.account.getTemplateType()
+                if (template === 'master') {
+                    const children = await client.account.getChildren()
+                    if (children.some((child) => child.identifier === current.shortName)) {
+                        return app
+                    }
+                }
+
+                // Return undefined if the app is not a parent
+                return undefined
+            }),
+        )
+
+        return parentApps.filter((app) => app !== undefined)
+    }
+
+    public async getTenant(tenantId: string): Promise<Tenant> {
+        return await this.sendCommand({
+            method: 'get',
+            uri: uri`/tenants/${tenantId}`,
+        })
+    }
+
+    public async tenantExists(tenantId: string): Promise<boolean> {
+        try {
+            await this.sendCommand({
+                method: 'get',
+                uri: uri`/tenants/${tenantId}`,
+            })
+            return true
+        } catch (err) {
+            if (err instanceof BlipError) {
+                if (err.code === 67) {
+                    return false
+                } else if (err.code === 35) {
+                    return true
+                }
+            }
+
+            throw err
+        }
+    }
+
+    public async getTenants(opts?: ConsumeOptions): Promise<Array<Tenant>> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/tenants-mine`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+    }
+
+    public async getTenantUsers(
+        tenantId: string,
+        opts?: ConsumeOptions,
+    ): Promise<Array<Omit<TenantUserInfo, 'creationDate' | 'updateDate'>>> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/tenants/${tenantId}/users`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+    }
+
+    public async getTenantUser(tenantId: string, user: Identity, opts?: ConsumeOptions): Promise<TenantUserInfo> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/tenants/${tenantId}/users/${user}`,
+            },
+            opts,
+        )
+    }
+
+    public async getTenantSubscription(tenantId: string, opts?: ConsumeOptions): Promise<TenantSubscription> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/tenants/${tenantId}/subscription`,
+            },
+            opts,
+        )
+    }
+
+    public async deleteTenantUser(tenantId: string, user: Identity, opts?: ConsumeOptions): Promise<void> {
+        return await this.sendCommand(
+            {
+                method: 'delete',
+                uri: uri`/tenants/${tenantId}/users/${user}`,
+            },
+            opts,
+        )
+    }
+
+    public async setTenantUser(
+        tenantId: string,
+        user: Identity,
+        roleId: TenantUserInfo['roleId'],
+        opts?: ConsumeOptions,
+    ): Promise<void> {
+        return await this.sendCommand(
+            {
+                method: 'set',
+                uri: uri`/tenants/${tenantId}/users`,
+                type: 'application/vnd.lime.collection+json',
+                resource: {
+                    items: [
+                        {
+                            tenantId,
+                            userIdentity: user,
+                            roleId,
+                        },
+                    ],
+                    itemType: 'application/vnd.iris.portal.tenant-user+json',
+                },
+            },
+            opts,
+        )
+    }
+
+    public async getApplicationUsers(bot: PossiblyNode, opts?: ConsumeOptions): Promise<Array<ApplicationUserInfo>> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/applications/${Node.from(bot, 'msging.net')}/users`,
+            },
+            opts,
+        )
+    }
+
+    public async getApplicationUser(
+        bot: PossiblyNode,
+        user: Identity,
+        opts?: ConsumeOptions,
+    ): Promise<ApplicationUserInfo> {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/applications/${Node.from(bot, 'msging.net')}/users/${user}`,
+            },
+            opts,
+        )
+    }
+
+    public async deleteApplicationUser(bot: PossiblyNode, user: Identity, opts?: ConsumeOptions): Promise<void> {
+        return await this.sendCommand(
+            {
+                method: 'delete',
+                uri: uri`/applications/${Node.from(bot, 'msging.net')}/users/${user}`,
+            },
+            opts,
+        )
+    }
+
+    public async setApplicationUser(
+        bot: PossiblyNode,
+        user: Identity,
+        roleId: TenantUserInfo['roleId'],
+        tenantId: string,
+        opts?: ConsumeOptions,
+    ): Promise<void> {
+        await this.sendCommand(
+            {
+                method: 'set',
+                uri: uri`/applications/${Node.from(bot, 'msging.net')}/users?${{ tenantId }}`,
+                type: 'application/vnd.lime.identity',
+                resource: user,
+            },
+            opts,
+        )
+
+        await this.updateApplicationUserPermissions(bot, user, roleId, opts)
+    }
+
+    public async updateApplicationUserPermissions(
+        bot: PossiblyNode,
+        user: Identity,
+        roleId: TenantUserInfo['roleId'],
+        opts?: ConsumeOptions,
+    ): Promise<void> {
+        const actions: Array<'read' | 'write'> = ['read']
+        const otherPermissions: Array<{
+            permissionId: string
+            actions: typeof actions
+            userIdentity: typeof user
+        }> = []
+
+        if (roleId !== 'guest') {
+            actions.push('write')
+        }
+        if (roleId === 'admin') {
+            otherPermissions.push({
+                permissionId: 'team',
+                actions,
+                userIdentity: user,
+            })
+        }
+
+        return await this.sendCommand(
+            {
+                method: 'set',
+                uri: uri`/applications/${Node.from(bot, 'msging.net')}/permissions`,
+                type: 'application/vnd.lime.collection+json',
+                resource: {
+                    itemType: 'application/vnd.iris.portal.user-permission+json',
+                    items: [
+                        ...otherPermissions,
+                        { permissionId: 'payments', actions, userIdentity: user },
+                        { permissionId: 'ai-providers', actions, userIdentity: user },
+                        { permissionId: 'ai-model', actions, userIdentity: user },
+                        { permissionId: 'ai-enhancement', actions, userIdentity: user },
+                        { permissionId: 'ai-answers', actions, userIdentity: user },
+                        { permissionId: 'channels', actions, userIdentity: user },
+                        { permissionId: 'desk', actions, userIdentity: user },
+                        { permissionId: 'users', actions, userIdentity: user },
+                        { permissionId: 'scheduler', actions, userIdentity: user },
+                        { permissionId: 'config-basicConfigurations', actions, userIdentity: user },
+                        { permissionId: 'config-connectionInformation', actions, userIdentity: user },
+                        { permissionId: 'resources', actions, userIdentity: user },
+                        { permissionId: 'logMessages', actions, userIdentity: user },
+                        { permissionId: 'builder', actions, userIdentity: user },
+                        { permissionId: 'analysis', actions, userIdentity: user },
+                    ],
+                },
+            },
+            opts,
+        )
+    }
+}

package/src/namespaces/scheduler.ts

@@ -0,0 +1,88 @@
+import type { BlipClient } from '../client.ts'
+import { BlipError } from '../sender/bliperror.ts'
+import type { UnknownMessage } from '../types/index.ts'
+import { uri } from '../utils/uri.ts'
+import { type ConsumeOptions, Namespace, type SendCommandOptions } from './namespace.ts'
+
+export class SchedulerNamespace extends Namespace {
+    constructor(blipClient: BlipClient, defaultOptions?: SendCommandOptions) {
+        super(blipClient, 'scheduler', defaultOptions)
+    }
+
+    public async scheduleMessage(
+        schedule: {
+            name?: string
+            message: UnknownMessage
+            when: string
+        },
+        opts?: ConsumeOptions,
+    ) {
+        return await this.sendCommand(
+            {
+                method: 'set',
+                uri: uri`/schedules`,
+                type: 'application/vnd.iris.schedule+json',
+                resource: schedule,
+            },
+            opts,
+        )
+    }
+
+    public async getSchedule(
+        id: string,
+        opts?: ConsumeOptions,
+    ): Promise<
+        | {
+              when: string
+              message: UnknownMessage
+              status: 'scheduled' | 'executed' | 'canceled'
+          }
+        | undefined
+    > {
+        try {
+            return await this.sendCommand(
+                {
+                    method: 'get',
+                    uri: uri`/schedules/${id}`,
+                },
+                opts,
+            )
+        } catch (err) {
+            if (err instanceof BlipError && err.code === 67) {
+                return undefined
+            }
+
+            throw err
+        }
+    }
+
+    public async getSchedules(opts?: ConsumeOptions): Promise<
+        Array<{
+            id: string
+            when: string
+            message: UnknownMessage
+            status: 'scheduled' | 'executed' | 'canceled'
+        }>
+    > {
+        return await this.sendCommand(
+            {
+                method: 'get',
+                uri: uri`/schedules`,
+            },
+            {
+                collection: true,
+                ...opts,
+            },
+        )
+    }
+
+    public async cancelSchedule(id: string, opts?: ConsumeOptions) {
+        return await this.sendCommand(
+            {
+                method: 'delete',
+                uri: uri`/schedules/${id}`,
+            },
+            opts,
+        )
+    }
+}