@ptkl/toolkit 0.3.0 → 0.4.0

package/dist/bin/toolkit.js

@@ -3,12 +3,12 @@ import { Command } from "commander";
 import { commands } from "../commands/index.js";
 const program = new Command();
 commands.forEach(c => program.addCommand(c));
-program.parseAsync(process.argv).catch((err) => {
+program.parseAsync(process.argv);
+process.on('uncaughtException', (err) => {
     const { response } = err;
     if (response && response.data) {
         console.error(response.data.message);
-        console.log(response);
         return;
     }
-    console.error(err.message);
+    process.exit(1);
 });

package/dist/commands/apiUsers.js

@@ -1,6 +1,6 @@
 import { Command } from "commander";
 import util from "../lib/util.js";
-import Api from "protokol-sdk";
+import Api from "@ptkl/sdk";
 import OutputFormatCommand from "./outputCommand.js";
 class ApiUsersCommand {
     register() {
@@ -17,13 +17,10 @@ class ApiUsersCommand {
             .description("Retrieve an auth token for an API user")
             .requiredOption("-u, --user <user>", "Username or name of the API user")
             .requiredOption("-p, --password <password>", "Password or secret for the API user")).action(this.getAuthToken))
-            // .addCommand(  new OutputFormatCommand(
-            //   new Command("edit")
-            //     .description("edit API user")
-            //     .requiredOption("-u, --uuid <uuid>", "UUID of the API user")
-            //     .requiredOption("-r, --roles <roles...>", "list of role uuids")
-            //     ).action(this.edit)
-            // )
+            .addCommand(new OutputFormatCommand(new Command("edit")
+            .description("edit API user")
+            .requiredOption("-u, --uuid <uuid>", "UUID of the API user")
+            .requiredOption("-r, --roles <roles...>", "list of role uuids")).action(this.edit))
             .addCommand(new OutputFormatCommand(new Command("list").description("list all API user's")).action(this.list))
             .addCommand(new OutputFormatCommand(new Command("get")
             .description("Retrieve an API user by UUID")
@@ -32,41 +29,41 @@ class ApiUsersCommand {
     async newSecret(opts) {
         const { uuid } = opts;
         const profile = util.getCurrentProfile();
-        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).apiUser();
+        const client = new Api({ token: profile.token, host: profile.host }).apiUser();
         const secret = await client.newSecret(uuid);
         return secret;
     }
     async revokeSecret(opts) {
         const { uuid } = opts;
         const profile = util.getCurrentProfile();
-        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).apiUser();
+        const client = new Api({ token: profile.token, host: profile.host }).apiUser();
         const status = await client.revokeSecret(uuid);
         return status;
     }
     async getAuthToken(opts) {
         const { user, password } = opts;
         const profile = util.getCurrentProfile();
-        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).apiUser();
-        const auth = await client.apiAuth(user, password);
+        const client = new Api({ token: profile.token, host: profile.host }).apiUser();
+        const auth = await client.auth(user, password);
         return auth.data.Token;
     }
     async edit(opts) {
         const { uuid, roles } = opts;
         const profile = util.getCurrentProfile();
-        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).apiUser();
+        const client = new Api({ token: profile.token, host: profile.host }).apiUser();
         const updatedUser = await client.edit(uuid, roles);
         return updatedUser;
     }
     async list() {
         const profile = util.getCurrentProfile();
-        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).apiUser();
+        const client = new Api({ token: profile.token, host: profile.host }).apiUser();
         const users = await client.list();
         return users;
     }
     async get(opts) {
         const { uuid } = opts;
         const profile = util.getCurrentProfile();
-        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).apiUser();
+        const client = new Api({ token: profile.token, host: profile.host }).apiUser();
         const user = await client.get(uuid);
         return user;
     }

package/dist/commands/apps.js

@@ -1,6 +1,6 @@
 import { Command, Option } from "commander";
 import util from "../lib/util.js";
-import Api from "protokol-sdk";
+import Api from "@ptkl/sdk";
 import { build, createServer } from 'vite';
 import { c } from 'tar';
 import { Writable } from "stream";
@@ -8,6 +8,9 @@ import { writeFileSync } from "fs";
 import Util from "../lib/util.js";
 import Playground from "../playground.js";
 import { join } from 'path';
+/**
+ * Deprecation notice: Apps as such will be deprecated in favor for Protokol Forge and this will be removed in the future.
+ */
 class AppsCommand {
     register() {
         return new Command("apps")
@@ -67,26 +70,26 @@ class AppsCommand {
     async download(options) {
         const { apptype, version, ref, output } = options;
         const profile = util.getCurrentProfile();
-        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).app(apptype);
+        const client = new Api({ token: profile.token, host: profile.host }).app(apptype);
         return await client.download(version, ref, output);
     }
     async upload(options) {
         const { apptype, directory, build } = options;
         const profile = util.getCurrentProfile();
-        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).app(apptype);
+        const client = new Api({ token: profile.token, host: profile.host }).app(apptype);
         return await client.upload(directory, build);
     }
     async deploy(options) {
         const { apptype, dev_version, public_version, ref } = options;
         const profile = util.getCurrentProfile();
-        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).app(apptype);
+        const client = new Api({ token: profile.token, host: profile.host }).app(apptype);
         return await client.updateSettings({ dev_version, public_version }, ref);
     }
     async playground(options) {
         let { path, port, sdk_version, engine, apptype } = options;
         port = port ? Number(port) : 11400;
         const profile = util.getCurrentProfile();
-        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).app();
+        const client = new Api({ token: profile.token, host: profile.host }).app();
         let playgroundWatcher = new Playground(apptype, path, Number(sdk_version), engine, port, profile);
         await playgroundWatcher.init();
         playgroundWatcher.start();

package/dist/commands/component.js

@@ -0,0 +1,88 @@
+import { Command } from "commander";
+import Builder from "../builder/index.js";
+import { WebSocketServer } from "ws";
+import { resolve } from "path";
+import { rollup } from "rollup";
+import util from "../lib/util.js";
+import Api from "@ptkl/sdk";
+class ComponentCommand {
+    register() {
+        return new Command("component")
+            .description("Manage components")
+            .version("0.1.0")
+            .addCommand(new Command("builder")
+            .description("Run builder for component templates")
+            .requiredOption("-v, --version <version>", "SDK version to be used for build", "6")
+            .requiredOption("-e, --engine <engine>", "SDK engine to be used for build", "react")
+            .action(this.builder))
+            .addCommand(new Command("build")
+            .description("Build templates for component")
+            .requiredOption("-p, --path <path>", "Path to the source files", "./")
+            .action(this.build));
+    }
+    async builder(options) {
+        const { version, engine } = options;
+        console.log(`Running builder for SDK version ${version} with engine ${engine}`);
+        const ws = new WebSocketServer({ port: 11400 });
+        ws.on('connection', (socket) => {
+            socket.on('message', async (message) => {
+                console.log("Building component templates...");
+                const nodes = JSON.parse(message.toString());
+                try {
+                    let dist = null;
+                    if (version === '5') {
+                        const builder = new Builder(5, "vue2");
+                        const compiledFiles = await builder.buildFromNodes(nodes);
+                        dist = Object.assign({}, compiledFiles);
+                    }
+                    socket.send(JSON.stringify({ dist }));
+                    console.log('Component templates built successfully');
+                    // Do something with the parsed JSON
+                }
+                catch (error) { // Bad Request
+                    socket.send(JSON.stringify({ error: error.message }));
+                    console.error(error.message);
+                }
+            });
+        });
+    }
+    async build(options) {
+        try {
+            const { path } = options;
+            const configPath = resolve(path, 'ptkl.config.js');
+            console.log(`Loading config from ${configPath}`);
+            const { default: config } = await import(configPath);
+            const { name, version, input, engine, rollupOptions } = config;
+            const inputPath = resolve(path, input);
+            const outputOptions = {
+                format: 'esm',
+                name,
+            };
+            process.chdir(path);
+            const bundle = await rollup({
+                input: inputPath,
+                ...rollupOptions,
+                output: outputOptions,
+            });
+            const { output } = await bundle.generate(outputOptions);
+            console.log(`Bundle generated with size ${output[0].code.length} bytes`);
+            const profile = util.getCurrentProfile();
+            const client = new Api({ token: profile.token, host: profile.host }).component(name);
+            const d = output.reduce((curr, next) => {
+                if (next.isEntry) {
+                    return {
+                        ...curr,
+                        [next.fileName]: next.code
+                    };
+                }
+            }, {});
+            await client.saveTemplatesDist(version, 6, engine, d);
+            console.log(`Component templates saved successfully`);
+        }
+        catch (error) {
+            console.error(error);
+            return;
+        }
+    }
+}
+export default new ComponentCommand();

package/dist/commands/forge.js

@@ -15,15 +15,23 @@ class ForgeCommand {
             .requiredOption("-p, --path <path>", "Path is directory where app is located.")
             .option("-u, --upload", "Upload bundle")
             .action(this.bundle))
+            .addCommand(new Command("remove-version")
+            .description("Remove version of app")
+            .requiredOption("-r, --ref <ref>", "App reference (e.g., uuid or name)")
+            .requiredOption("-v, --version <version>", "Version of the app to remove")
+            .action(this.removeVersion))
             .addCommand(new Command("dev")
             .description("Run dev app")
             .requiredOption("-p, --path <path>", "Path is directory where app is located.")
-            .action(this.runDev));
+            .action(this.runDev))
+            .addCommand(new Command("list")
+            .description("List all available apps")
+            .action(this.listApps));
     }
     async bundle(options) {
         const { path, upload } = options;
         const module = await import(`${path}/ptkl.config.js`);
-        const { views, name, version, distPath, icon, label, permissions, } = module.default ?? {};
+        const { views, name, version, distPath, icon, type, label, permissions, } = module.default ?? {};
         // build manifest file
         const manifest = {
             name,
@@ -32,12 +40,12 @@ class ForgeCommand {
             label,
             icon,
             permissions,
+            type: type || 'platform', // default to 'platform' if not specified
         };
-        const profile = Util.getCurrentProfile();
         const client = Util.getClientForProfile();
         // get base url of the platform client
         const baseUrl = client.getPlatformBaseURL();
-        const base = `${baseUrl}/v3/system/gateway/app-service/forge/static/bundle/${profile.project}/${name}/${version}`;
+        const base = `${baseUrl}/luma/appservice/v1/forge/static/bundle/${name}/${version}`;
         manifest.icon = `${base}/${icon}`;
         const buildViews = Object.keys(views).map((view) => {
             manifest.views[view] = `${view}.bundle.js`;
@@ -48,16 +56,17 @@ class ForgeCommand {
                     rollupOptions: {
                         input: views[view],
                         output: {
-                            format: 'umd',
+                            format: 'esm',
                             entryFileNames: `${view}.bundle.js`,
+                            assetFileNames: (assetInfo) => {
+                                return '[name].[ext]'; // Example: Customize the output file name format
+                            },
                         }
-                    }
+                    },
                 }
             });
         });
-        await Promise.allSettled(buildViews).catch(err => {
-            console.error('Error building:', err);
-        });
+        await Promise.allSettled(buildViews);
         console.log("Packaging app...");
         // // write manifest file
         const manifestPath = `${distPath}/manifest.json`;
@@ -73,13 +82,7 @@ class ForgeCommand {
             c({ gzip: true, cwd: distPath }, ['.']).pipe(bufferStream).on('finish', () => {
                 client.forge().bundleUpload(buffer).then(() => {
                     console.log('Bundle uploaded successfully');
-                })
-                    .catch((error) => {
-                    console.error('Bundle error:', error);
                 });
-            })
-                .on('error', (error) => {
-                console.error('Error creating the archive:', error.message);
             });
         }
         else {
@@ -88,17 +91,39 @@ class ForgeCommand {
                 console.log('Bundle created successfully');
             }
             catch (error) {
-                console.error('Error creating the archive:', error.message);
+                throw error;
             }
         }
     }
     async runDev(options) {
         const { path } = options;
+        const host = Util.getCurrentProfile().host;
         const server = await createServer({
             root: path, // Set your project root
+            define: {
+                __ENV_VARIABLES__: JSON.stringify({
+                    API_HOST: host,
+                    INTEGRATION_API: `${host}/luma/integrations`,
+                    PROJECT_API_TOKEN: Util.getCurrentProfile().token,
+                })
+            }
         });
         await server.listen();
+        console.log('Current profile:', Util.getCurrentProfile().name);
         console.log('Dev server running at:', server?.resolvedUrls?.local[0]);
     }
+    async removeVersion(options) {
+        const { ref, version } = options;
+        const client = Util.getClientForProfile();
+        const forge = client.forge();
+        await forge.removeVersion(ref, version);
+        console.log(`Version ${version} of app ${ref} removed successfully.`);
+    }
+    async listApps() {
+        const client = Util.getClientForProfile();
+        const forge = client.forge();
+        const { data } = await forge.list();
+        console.log(data);
+    }
 }
 export default new ForgeCommand();

package/dist/commands/functions.js

@@ -1,6 +1,6 @@
 import { Command } from "commander";
 import util from "../lib/util.js";
-import Api from "protokol-sdk";
+import Api from "@ptkl/sdk";
 import OutputFormatCommand from "./outputCommand.js";
 class FunctionsCommand {
     register() {
@@ -15,12 +15,12 @@ class FunctionsCommand {
     }
     async list() {
         const profile = util.getCurrentProfile();
-        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).function();
+        const client = new Api({ token: profile.token, host: profile.host }).function();
         return await client.list();
     }
     async get(reference) {
         const profile = util.getCurrentProfile();
-        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).function();
+        const client = new Api({ token: profile.token, host: profile.host }).function();
         return await client.get(reference);
     }
 }

package/dist/commands/index.js

@@ -5,17 +5,17 @@ import Util from "../lib/util.js";
 import users from "./apiUsers.js";
 import functions from "./functions.js";
 import apps from "./apps.js";
-import pull from "./pull.js";
 import role from "./role.js";
 import forge from "./forge.js";
+import component from "./component.js";
 export const commands = [
     profile.register(),
     users.register(),
     functions.register(),
     apps.register(),
-    pull.register(),
     role.register(),
     forge.register(),
+    component.register(),
     new Command('init')
         .description("Init protokol toolkit")
         .action(Util.init)

package/dist/commands/profile.js

@@ -1,7 +1,7 @@
 import { Command } from "commander";
 import util from "../lib/util.js";
 import cli from "../lib/cli.js";
-import Api from "protokol-sdk";
+import { APIUser } from "@ptkl/sdk";
 class ProfileCommand {
     register() {
         return new Command('profile')
@@ -18,10 +18,8 @@ class ProfileCommand {
             .action(this.new))
             .addCommand(new Command('auth')
             .description('Profile auth')
-            .option("-n, --name <name>")
-            .option("-u, --username <username>")
             .option("-p, --password <password>")
-            .option("-P, --project <project>")
+            .option("-t, --token <token>")
             .action(this.auth))
             .addCommand(new Command('list')
             .description('List all available profiles')
@@ -52,13 +50,14 @@ class ProfileCommand {
         if (profile) {
             throw new Error(`Profile with ${name} already exist`);
         }
-        const user = new Api({ host, project }).apiUser();
+        const user = new APIUser({
+            host,
+        });
         // authenticate to protokol
-        const { data } = await user.apiAuth(username, password);
+        const { data } = await user.auth(username, password, project);
         profiles.push({
             name,
             username,
-            project,
             token: data.Token,
             host
         });
@@ -66,18 +65,20 @@ class ProfileCommand {
     }
     async auth(options) {
         // try to find profile with the name
-        const { name, username, password, project, host } = options;
-        const profiles = util.getProfiles() ?? [];
-        // try to find that the profile with the name already exist
-        const profile = profiles.find((p) => p.name == name);
-        if (!profile) {
-            throw new Error(`Profile with ${name} doesn't exist`);
+        const { password, token } = options;
+        const profile = util.getCurrentProfile();
+        if (!token) {
+            const user = new APIUser({
+                host: profile.host,
+            });
+            // authenticate to protokol
+            const { data } = await user.auth(profile.username, password, profile.project);
+            profile.token = data.Token;
         }
-        const user = new Api({ host, project }).apiUser();
-        // authenticate to protokol
-        const { data } = await user.apiAuth(username, password);
-        profile.token = data.Token;
-        util.updateProfiles(profiles);
+        else {
+            profile.token = token;
+        }
+        util.updateProfile(profile);
     }
     list() {
         const profiles = util.getProfiles() ?? [];

package/dist/commands/role.js

@@ -1,6 +1,6 @@
 import { Command } from "commander";
 import util from "../lib/util.js";
-import Api from "protokol-sdk";
+import Api from "@ptkl/sdk";
 import OutputFormatCommand from "./outputCommand.js";
 class RoleCommand {
     register() {
@@ -34,29 +34,29 @@ class RoleCommand {
         let { name, permissions, workspaces, level } = options;
         level = level ? Number(level) : 0;
         const profile = util.getCurrentProfile();
-        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).role();
+        const client = new Api({ token: profile.token, host: profile.host }).role();
         return await client.create({ name, workspaces, permissions, level });
     }
     async delete(opts) {
         const { uuid } = opts;
         const profile = util.getCurrentProfile();
-        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).role();
+        const client = new Api({ token: profile.token, host: profile.host }).role();
         return await client.delete(uuid);
     }
     async list() {
         const profile = util.getCurrentProfile();
-        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).role();
+        const client = new Api({ token: profile.token, host: profile.host }).role();
         return await client.list();
     }
     async listPermissions() {
         const profile = util.getCurrentProfile();
-        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).role();
+        const client = new Api({ token: profile.token, host: profile.host }).role();
         return await client.list();
     }
     async edit(opts) {
         let { uuid, permissions, workspaces, level } = opts;
         const profile = util.getCurrentProfile();
-        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).role();
+        const client = new Api({ token: profile.token, host: profile.host }).role();
         return await client.edit(permissions, workspaces, Number(level), uuid);
     }
 }

package/dist/commands/users.js

@@ -1,46 +1,34 @@
 import { Command } from "commander";
 import util from "../lib/util.js";
-import Api from "protokol-sdk";
+import Api from "@ptkl/sdk";
 class ApiUsersCommand {
     register() {
         return new Command("users")
             .description("Manage users")
             .version("0.1.0")
             .addCommand(new Command("invite")
-            .description("invite a new  user")
+            .description("Invite a new  user")
             .requiredOption("-e, --email <email>", "user email ")
-            .requiredOption("-r, --roles <roles...>", "uuids of role seprated by space")
+            .requiredOption("-r, --roles <roles...>", "uuids of role separated by space")
             .action(this.invite))
             .addCommand(new Command("delete")
-            .description("delete an existing user")
+            .description("Remove user from project")
             .requiredOption("-u, --uuid <uuid>", "UUID of the existing user")
-            .action(this.delete))
-            .addCommand(new Command("get-auth-token")
-            .description("Retrieve an auth token for an API user")
-            .requiredOption("-u, --user <user>", "Username or name of the API user")
-            .requiredOption("-p, --password <password>", "Password or secret for the API user")
-            .action(this.getAuthToken));
+            .action(this.delete));
     }
     async invite(opts) {
         const { email, roles } = opts;
         const profile = util.getCurrentProfile();
-        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).user();
+        const client = new Api({ token: profile.token, host: profile.host }).user();
         const secret = await client.invite(email, roles);
         console.table([secret]);
     }
     async delete(opts) {
         const { uuid } = opts;
         const profile = util.getCurrentProfile();
-        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).user();
+        const client = new Api({ token: profile.token, host: profile.host }).user();
         const status = await client.delete(uuid);
         console.table([status]);
     }
-    async getAuthToken(opts) {
-        const { user, password } = opts;
-        const profile = util.getCurrentProfile();
-        const client = new Api({ project: profile.project, token: profile.token, host: profile.host }).apiUser();
-        const auth = await client.apiAuth(user, password);
-        console.log(auth.data.Token);
-    }
 }
 export default new ApiUsersCommand();

package/dist/lib/util.js

@@ -1,5 +1,5 @@
 import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import Api from 'protokol-sdk';
+import Api from '@ptkl/sdk';
 export default class Util {
     static profilePath = `${process.env.HOME}/.ptkl`;
     static fileName = "profiles.json";
@@ -22,6 +22,21 @@ export default class Util {
             throw new Error("There was a problem with updating profiles. Did you run 'init'?");
         }
     }
+    static updateProfile(profile) {
+        try {
+            const profiles = Util.getProfiles() ?? [];
+            const index = profiles?.findIndex(p => p.name == profile.name);
+            if (index === undefined || index < 0) {
+                throw new Error("There was a problem with updating profile. Did you run 'init'?");
+            }
+            profiles[index] = profile;
+            Util.updateProfiles(profiles);
+            return profile;
+        }
+        catch (err) {
+            throw new Error("There was a problem with updating profile. Did you run 'init'?");
+        }
+    }
     static init() {
         try {
             mkdirSync(Util.profilePath, { recursive: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ptkl/toolkit",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "build": "npx tsc",
@@ -10,18 +10,27 @@
   "author": "",
   "license": "MIT",
   "description": "",
+  "type": "module",
   "dependencies": {
+    "@babel/standalone": "^7.26.10",
+    "@ptkl/sdk": "^0.4.0",
     "@types/axios": "^0.14.0",
     "@types/commander": "^2.12.2",
     "@types/js-yaml": "^4.0.9",
+    "@vue/compiler-sfc": "^3.5.13",
     "axios": "^1.7.4",
     "chalk": "^4.1.2",
     "chokidar": "^4.0.1",
     "circular-json": "^0.5.9",
     "commander": "^12.1.0",
     "js-yaml": "^4.1.0",
-    "protokol-sdk": "file:../protokol-sdk",
+    "less": "^4.1.1",
+    "lodash": "^4.17.21",
+    "open": "^10.1.2",
+    "rollup": "^4.34.6",
     "tar": "^7.4.3",
+    "vite": "^6.0.6",
+    "vue-template-compiler": "^2.7.16",
     "ws": "^8.18.0",
     "yaml": "^2.5.0"
   },
@@ -34,6 +43,6 @@
     "dist"
   ],
   "bin": {
-    "pkit": "dist/bin/toolkit"
+    "ptkl": "dist/bin/toolkit.js"
   }
 }