@bardioc/app-sdk 1.0.2 → 1.0.3

package/dist/transports/os-transport.d.ts

@@ -0,0 +1,190 @@
+import type { Application, Configuration, CreateMemberInput, CreateUnitInput, FileEntry, InstanceList, OrgMember, OrgStructure, OrgUnit, OsRequestOptions, SdkTransportPayload, UpdateMemberInput, UpdateUnitInput, UserProfile } from '../types.js';
+export declare function parseOsError(error: any, operation: string, context?: Record<string, unknown>): Error;
+/** OS transport class providing OS/system operations */
+export declare class OsTransport {
+    private readonly _request;
+    constructor(_request: <T = unknown>(payload: SdkTransportPayload) => Promise<T>);
+    /**
+     * User profile operations
+     */
+    profile: {
+        /**
+         * Get current user profile
+         *
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        get: () => Promise<UserProfile>;
+        /**
+         * Get user avatar image
+         *
+         * @throws {EntityNotFoundError} if avatar doesn't exist
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        getAvatar: () => Promise<Blob>;
+        /**
+         * Upload user avatar
+         *
+         * @throws {ValidationError} if image format is invalid
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        setAvatar: (image: Blob) => Promise<void>;
+        /**
+         * Get accessible instances
+         *
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        getInstances: () => Promise<InstanceList>;
+    };
+    /**
+     * Organization structure operations
+     */
+    organization: {
+        /**
+         * Get full organization hierarchy
+         *
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        getStructure: () => Promise<OrgStructure>;
+        /**
+         * Create organizational unit
+         *
+         * @throws {ValidationError} if data is invalid or missing required fields
+         * @throws {PermissionError} if user lacks permission to create units
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        createUnit: (data: CreateUnitInput) => Promise<OrgUnit>;
+        /**
+         * Update organizational unit
+         *
+         * @throws {EntityNotFoundError} if unit doesn't exist
+         * @throws {ValidationError} if data is invalid
+         * @throws {PermissionError} if user lacks permission to update unit
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        updateUnit: (id: string, data: UpdateUnitInput) => Promise<OrgUnit>;
+        /**
+         * Create organization member
+         *
+         * @throws {ValidationError} if data is invalid or missing required fields
+         * @throws {PermissionError} if user lacks permission to create members
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        createMember: (data: CreateMemberInput) => Promise<OrgMember>;
+        /**
+         * Update organization member
+         *
+         * @throws {EntityNotFoundError} if member doesn't exist
+         * @throws {ValidationError} if data is invalid
+         * @throws {PermissionError} if user lacks permission to update member
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        updateMember: (id: string, data: UpdateMemberInput) => Promise<OrgMember>;
+        /**
+         * Delete organization member
+         *
+         * @throws {EntityNotFoundError} if member doesn't exist
+         * @throws {PermissionError} if user lacks permission to delete member
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        deleteMember: (id: string) => Promise<void>;
+        /**
+         * Send invitation email to member
+         *
+         * @throws {EntityNotFoundError} if member doesn't exist
+         * @throws {ValidationError} if member email is invalid
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        inviteMember: (id: string) => Promise<void>;
+    };
+    /**
+     * Application management
+     */
+    applications: {
+        /**
+         * List all applications
+         *
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        list: () => Promise<Application[]>;
+        /**
+         * Get application details
+         *
+         * @throws {EntityNotFoundError} if application doesn't exist
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        get: (appId: string) => Promise<Application>;
+        /**
+         * Upload application package (zip)
+         *
+         * @throws {EntityNotFoundError} if application doesn't exist
+         * @throws {ValidationError} if file format is invalid
+         * @throws {PermissionError} if user lacks permission to upload
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        upload: (appId: string, zipFile: Blob) => Promise<void>;
+        /**
+         * Download application package
+         *
+         * @throws {EntityNotFoundError} if application doesn't exist
+         * @throws {PermissionError} if user lacks permission to download
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        download: (appId: string) => Promise<Blob>;
+        /**
+         * List application files
+         *
+         * @throws {EntityNotFoundError} if application doesn't exist
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        getFiles: (appId: string) => Promise<FileEntry[]>;
+        /**
+         * Get specific application file
+         *
+         * @throws {EntityNotFoundError} if application or file doesn't exist
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        getFile: (appId: string, filePath: string) => Promise<string>;
+        /**
+         * List application configurations
+         *
+         * @throws {EntityNotFoundError} if application doesn't exist
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        getConfigurations: (appId: string) => Promise<Configuration[]>;
+    };
+    /**
+     * Generic HTTP request for custom OS endpoints
+     *
+     * @example
+     * const data = await os.request<CustomResponse>({
+     *   path: '/custom/endpoint',
+     *   method: 'POST',
+     *   body: { foo: 'bar' }
+     * });
+     *
+     * @throws {EntityNotFoundError} on 404 errors
+     * @throws {ValidationError} on 400 errors
+     * @throws {PermissionError} on 403 errors
+     * @throws {NetworkError} on HTTP errors
+     * @throws {TimeoutError} on request timeout
+     */
+    request<T = unknown>(options: OsRequestOptions): Promise<T>;
+}

package/dist/transports/os-transport.js

@@ -0,0 +1,444 @@
+import { EntityNotFoundError, NetworkError, PermissionError, SdkError, TimeoutError, ValidationError, } from '../errors.js';
+const OS_BASE = '/os';
+// Maps backend errors to typed SDK errors
+export function parseOsError(error, operation, context) {
+    let statusCode;
+    let errorMessage = error.message || 'Unknown error';
+    if (error.responsePayload && typeof error.responsePayload === 'object') {
+        statusCode = error.responsePayload.status || error.responsePayload.statusCode;
+        if (error.responsePayload.message) {
+            errorMessage = error.responsePayload.message;
+        }
+    }
+    if (errorMessage.includes('timed out') || errorMessage.includes('timeout')) {
+        return new TimeoutError(operation, 10000);
+    }
+    if (statusCode) {
+        const fullContext = {
+            ...context,
+            operation,
+            timestamp: Date.now(),
+            statusCode,
+        };
+        switch (statusCode) {
+            case 404:
+                return new EntityNotFoundError(context?.id || context?.appId || 'unknown');
+            case 400:
+                return new ValidationError(errorMessage, context?.field);
+            case 403:
+                return new PermissionError(errorMessage);
+            case 408:
+                return new TimeoutError(operation, 10000);
+            case 500:
+            case 502:
+            case 503:
+                return new NetworkError(errorMessage, statusCode);
+            default:
+                if (statusCode >= 400) {
+                    return new NetworkError(errorMessage, statusCode);
+                }
+        }
+    }
+    return new SdkError(errorMessage, 'UNKNOWN_ERROR', statusCode, {
+        ...context,
+        operation,
+        timestamp: Date.now(),
+    });
+}
+/** OS transport class providing OS/system operations */
+export class OsTransport {
+    _request;
+    constructor(_request) {
+        this._request = _request;
+    }
+    /**
+     * User profile operations
+     */
+    profile = {
+        /**
+         * Get current user profile
+         *
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        get: async () => {
+            try {
+                return await this._request({
+                    path: `${OS_BASE}/me/profile`,
+                    method: 'GET',
+                });
+            }
+            catch (error) {
+                throw parseOsError(error, 'os.profile.get');
+            }
+        },
+        /**
+         * Get user avatar image
+         *
+         * @throws {EntityNotFoundError} if avatar doesn't exist
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        getAvatar: async () => {
+            try {
+                return await this._request({
+                    path: `${OS_BASE}/me/avatar`,
+                    method: 'GET',
+                });
+            }
+            catch (error) {
+                throw parseOsError(error, 'os.profile.getAvatar');
+            }
+        },
+        /**
+         * Upload user avatar
+         *
+         * @throws {ValidationError} if image format is invalid
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        setAvatar: async (image) => {
+            try {
+                await this._request({
+                    path: `${OS_BASE}/me/avatar`,
+                    method: 'POST',
+                    body: image,
+                    contentType: 'application/octet-stream',
+                });
+            }
+            catch (error) {
+                throw parseOsError(error, 'os.profile.setAvatar');
+            }
+        },
+        /**
+         * Get accessible instances
+         *
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        getInstances: async () => {
+            try {
+                return await this._request({
+                    path: `${OS_BASE}/me/instances`,
+                    method: 'GET',
+                });
+            }
+            catch (error) {
+                throw parseOsError(error, 'os.profile.getInstances');
+            }
+        },
+    };
+    /**
+     * Organization structure operations
+     */
+    organization = {
+        /**
+         * Get full organization hierarchy
+         *
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        getStructure: async () => {
+            try {
+                return await this._request({
+                    path: `${OS_BASE}/organization/structure`,
+                    method: 'GET',
+                });
+            }
+            catch (error) {
+                throw parseOsError(error, 'os.organization.getStructure');
+            }
+        },
+        /**
+         * Create organizational unit
+         *
+         * @throws {ValidationError} if data is invalid or missing required fields
+         * @throws {PermissionError} if user lacks permission to create units
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        createUnit: async (data) => {
+            try {
+                return await this._request({
+                    path: `${OS_BASE}/organization/units`,
+                    method: 'POST',
+                    body: data,
+                    contentType: 'application/json',
+                });
+            }
+            catch (error) {
+                throw parseOsError(error, 'os.organization.createUnit', { name: data.name });
+            }
+        },
+        /**
+         * Update organizational unit
+         *
+         * @throws {EntityNotFoundError} if unit doesn't exist
+         * @throws {ValidationError} if data is invalid
+         * @throws {PermissionError} if user lacks permission to update unit
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        updateUnit: async (id, data) => {
+            try {
+                return await this._request({
+                    path: `${OS_BASE}/organization/units/${encodeURIComponent(id)}`,
+                    method: 'PATCH',
+                    body: data,
+                    contentType: 'application/json',
+                });
+            }
+            catch (error) {
+                throw parseOsError(error, 'os.organization.updateUnit', { id });
+            }
+        },
+        /**
+         * Create organization member
+         *
+         * @throws {ValidationError} if data is invalid or missing required fields
+         * @throws {PermissionError} if user lacks permission to create members
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        createMember: async (data) => {
+            try {
+                return await this._request({
+                    path: `${OS_BASE}/organization/members`,
+                    method: 'POST',
+                    body: data,
+                    contentType: 'application/json',
+                });
+            }
+            catch (error) {
+                throw parseOsError(error, 'os.organization.createMember', { email: data.mailAddress });
+            }
+        },
+        /**
+         * Update organization member
+         *
+         * @throws {EntityNotFoundError} if member doesn't exist
+         * @throws {ValidationError} if data is invalid
+         * @throws {PermissionError} if user lacks permission to update member
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        updateMember: async (id, data) => {
+            try {
+                return await this._request({
+                    path: `${OS_BASE}/organization/members/${encodeURIComponent(id)}`,
+                    method: 'PATCH',
+                    body: data,
+                    contentType: 'application/json',
+                });
+            }
+            catch (error) {
+                throw parseOsError(error, 'os.organization.updateMember', { id });
+            }
+        },
+        /**
+         * Delete organization member
+         *
+         * @throws {EntityNotFoundError} if member doesn't exist
+         * @throws {PermissionError} if user lacks permission to delete member
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        deleteMember: async (id) => {
+            try {
+                await this._request({
+                    path: `${OS_BASE}/organization/members/${encodeURIComponent(id)}`,
+                    method: 'DELETE',
+                });
+            }
+            catch (error) {
+                throw parseOsError(error, 'os.organization.deleteMember', { id });
+            }
+        },
+        /**
+         * Send invitation email to member
+         *
+         * @throws {EntityNotFoundError} if member doesn't exist
+         * @throws {ValidationError} if member email is invalid
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        inviteMember: async (id) => {
+            try {
+                await this._request({
+                    path: `${OS_BASE}/organization/members/${encodeURIComponent(id)}/invite`,
+                    method: 'POST',
+                    contentType: 'application/json',
+                });
+            }
+            catch (error) {
+                throw parseOsError(error, 'os.organization.inviteMember', { id });
+            }
+        },
+    };
+    /**
+     * Application management
+     */
+    applications = {
+        /**
+         * List all applications
+         *
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        list: async () => {
+            try {
+                return await this._request({
+                    path: `${OS_BASE}/applications`,
+                    method: 'GET',
+                });
+            }
+            catch (error) {
+                throw parseOsError(error, 'os.applications.list');
+            }
+        },
+        /**
+         * Get application details
+         *
+         * @throws {EntityNotFoundError} if application doesn't exist
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        get: async (appId) => {
+            try {
+                return await this._request({
+                    path: `${OS_BASE}/applications/${encodeURIComponent(appId)}`,
+                    method: 'GET',
+                });
+            }
+            catch (error) {
+                throw parseOsError(error, 'os.applications.get', { appId });
+            }
+        },
+        /**
+         * Upload application package (zip)
+         *
+         * @throws {EntityNotFoundError} if application doesn't exist
+         * @throws {ValidationError} if file format is invalid
+         * @throws {PermissionError} if user lacks permission to upload
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        upload: async (appId, zipFile) => {
+            try {
+                await this._request({
+                    path: `${OS_BASE}/applications/${encodeURIComponent(appId)}/upload`,
+                    method: 'POST',
+                    body: zipFile,
+                    contentType: 'application/zip',
+                });
+            }
+            catch (error) {
+                throw parseOsError(error, 'os.applications.upload', { appId });
+            }
+        },
+        /**
+         * Download application package
+         *
+         * @throws {EntityNotFoundError} if application doesn't exist
+         * @throws {PermissionError} if user lacks permission to download
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        download: async (appId) => {
+            try {
+                return await this._request({
+                    path: `${OS_BASE}/applications/${encodeURIComponent(appId)}/download`,
+                    method: 'GET',
+                });
+            }
+            catch (error) {
+                throw parseOsError(error, 'os.applications.download', { appId });
+            }
+        },
+        /**
+         * List application files
+         *
+         * @throws {EntityNotFoundError} if application doesn't exist
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        getFiles: async (appId) => {
+            try {
+                return await this._request({
+                    path: `${OS_BASE}/applications/${encodeURIComponent(appId)}/files`,
+                    method: 'GET',
+                });
+            }
+            catch (error) {
+                throw parseOsError(error, 'os.applications.getFiles', { appId });
+            }
+        },
+        /**
+         * Get specific application file
+         *
+         * @throws {EntityNotFoundError} if application or file doesn't exist
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        getFile: async (appId, filePath) => {
+            try {
+                return await this._request({
+                    path: `${OS_BASE}/applications/${encodeURIComponent(appId)}/files/${encodeURIComponent(filePath)}`,
+                    method: 'GET',
+                });
+            }
+            catch (error) {
+                throw parseOsError(error, 'os.applications.getFile', { appId, filePath });
+            }
+        },
+        /**
+         * List application configurations
+         *
+         * @throws {EntityNotFoundError} if application doesn't exist
+         * @throws {NetworkError} on HTTP errors
+         * @throws {TimeoutError} on request timeout
+         */
+        getConfigurations: async (appId) => {
+            try {
+                return await this._request({
+                    path: `${OS_BASE}/applications/${encodeURIComponent(appId)}/configurations`,
+                    method: 'GET',
+                });
+            }
+            catch (error) {
+                throw parseOsError(error, 'os.applications.getConfigurations', { appId });
+            }
+        },
+    };
+    /**
+     * Generic HTTP request for custom OS endpoints
+     *
+     * @example
+     * const data = await os.request<CustomResponse>({
+     *   path: '/custom/endpoint',
+     *   method: 'POST',
+     *   body: { foo: 'bar' }
+     * });
+     *
+     * @throws {EntityNotFoundError} on 404 errors
+     * @throws {ValidationError} on 400 errors
+     * @throws {PermissionError} on 403 errors
+     * @throws {NetworkError} on HTTP errors
+     * @throws {TimeoutError} on request timeout
+     */
+    async request(options) {
+        try {
+            return await this._request({
+                path: `${OS_BASE}${options.path}`,
+                method: options.method || 'GET',
+                body: options.body,
+                contentType: options.contentType,
+                scopeId: options.scopeId,
+                scopePolicy: options.scopePolicy,
+            });
+        }
+        catch (error) {
+            throw parseOsError(error, 'os.request', { path: options.path, method: options.method });
+        }
+    }
+}

package/dist/vite.js

@@ -3,7 +3,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { resolveDevAuthEnv } from './dev-auth-env.js';
-import { createDevAuthProxyHandler } from './dev-proxy.js';
+import { createDevAuthProxyHandler, sendJson } from './dev-proxy.js';
 import { MANIFEST_FILENAME, validateManifest } from './manifest.js';
 function devProxy(opts) {
     const { port } = opts;
@@ -26,7 +26,13 @@ function devProxy(opts) {
                     return;
                 }
                 console.log(`[bardioc] Dev server ready: http://localhost:${port}`);
-                console.log(`[bardioc] For standalone dev auth, set DEV_SECRET and API_BASE_URL in .env.`);
+                const env = resolveDevAuthEnv({
+                    envDir: server.config.envDir ?? server.config.root,
+                    mode: server.config.mode,
+                });
+                if (!env.devSecret || !env.apiBaseUrl) {
+                    console.log(`[bardioc] For standalone dev auth, set DEV_SECRET and API_BASE_URL in .env.`);
+                }
                 console.log(`[bardioc]   App Name: ${opts.appName || manifest.id}`);
                 console.log(`[bardioc]   URL: http://localhost:${port}`);
             });
@@ -136,20 +142,23 @@ export function bardiocDevAuth(options) {
                     envDir: server.config.envDir ?? server.config.root,
                     mode: server.config.mode,
                 });
-                if (!env.devSecret || !env.apiBaseUrl) {
-                    server.config.logger.warn(`[bardioc-dev-auth] DEV_SECRET and API_BASE_URL are required for dev auth — disabled for appName="${options.appName}".`);
-                    return;
+                if (env.devSecret && env.apiBaseUrl) {
+                    proxyOptions = {
+                        apiBaseUrl: env.apiBaseUrl,
+                        devSecret: env.devSecret,
+                    };
                 }
-                proxyOptions = {
-                    apiBaseUrl: env.apiBaseUrl,
-                    devSecret: env.devSecret,
-                };
             }
-            const handler = createDevAuthProxyHandler(proxyOptions);
+            const handler = proxyOptions ? createDevAuthProxyHandler(proxyOptions) : null;
             const basePath = server.config.base.endsWith('/')
                 ? server.config.base.slice(0, -1)
                 : server.config.base;
-            server.config.logger.info(`[bardioc-dev-auth] proxying /rest/* → ${proxyOptions.apiBaseUrl} for appName="${options.appName}"`);
+            if (proxyOptions) {
+                server.config.logger.info(`[bardioc-dev-auth] proxying /rest/* → ${proxyOptions.apiBaseUrl} for appName="${options.appName}"`);
+            }
+            else {
+                server.config.logger.warn(`[bardioc-dev-auth] DEV_SECRET and API_BASE_URL are required for dev auth — disabled for appName="${options.appName}".`);
+            }
             server.middlewares.use(async (req, res, next) => {
                 const originalUrl = req.url ?? '';
                 const parsed = new URL(originalUrl, 'http://localhost');
@@ -161,6 +170,11 @@ export function bardiocDevAuth(options) {
                     next();
                     return;
                 }
+                // Answer instead of falling through: Vite's SPA fallback would serve index.html as a 200.
+                if (!handler) {
+                    sendJson(res, 503, { error: 'dev_auth_disabled' });
+                    return;
+                }
                 try {
                     req.url = `${routePath}${parsed.search}`;
                     await handler(req, res);