@ptkl/toolkit 0.6.1 → 0.7.0

package/README.md

@@ -0,0 +1,139 @@
+# Protokol Toolkit
+
+A command-line toolkit for managing Protokol platform applications, profiles, functions, and components.
+
+## Installation
+
+```bash
+npm install -g @ptkl/toolkit
+```
+
+## Getting Started
+
+### 1. Initialize the Toolkit
+
+Before using the toolkit, initialize it to create the configuration directory:
+
+```bash
+ptkl init
+```
+
+This creates a `~/.ptkl` directory where profiles and settings are stored.
+
+### 2. Create a Profile
+
+A profile stores your authentication credentials and connection settings for a Protokol instance.
+
+#### Secure Method (Recommended)
+
+Omit the password or use `--password` flag without a value to be prompted securely:
+
+```bash
+ptkl profile new \
+  -n production \
+  -u user@example.com \
+  -P my-project \
+  -h https://api.example.com \
+  --password
+```
+
+You'll be prompted to enter your password securely (hidden input).
+
+#### With Password in CLI (Not Recommended)
+
+```bash
+ptkl profile new \
+  -n production \
+  -u user@example.com \
+  -P my-project \
+  -h https://api.example.com \
+  --password "myPassword"
+```
+
+⚠️ **Security Warning**: This will show a warning as the password may be visible in shell history.
+
+#### Options
+
+- `-n, --name <name>` - Profile name (e.g., "production", "staging")
+- `-u, --username <username>` - Email or API username
+- `-P, --project <project>` - Project identifier
+- `-h, --host <host>` - API host URL
+- `-p, --password [password]` - Password (optional value for secure prompt)
+
+## Profile Management
+
+### List All Profiles
+
+```bash
+ptkl profile list
+```
+
+Shows all available profiles. The currently active profile is marked with `*`.
+
+### View Current Profile
+
+```bash
+ptkl profile
+```
+
+### Switch to a Different Profile
+
+```bash
+ptkl profile use staging
+```
+
+Sets `staging` as the active profile for all subsequent commands.
+
+### Inspect Profile Details
+
+```bash
+ptkl profile inspect production
+```
+
+### Re-authenticate a Profile
+
+If your token expires or you need to update credentials:
+
+```bash
+ptkl profile auth --password
+```
+
+Or for a specific profile:
+
+```bash
+ptkl profile auth --profile production --password
+```
+
+#### Options
+
+- `-p, --password [password]` - Password (omit value for secure prompt)
+- `-t, --token <token>` - Directly provide a token
+- `-P, --project <project>` - Update the project
+
+### Delete a Profile
+
+```bash
+ptkl profile delete staging
+```
+
+## Using the --profile Flag
+
+You can override the active profile for any command using the global `--profile` flag:
+
+```bash
+ptkl --profile production apps upload -a app -d ./my-app
+```
+
+## Version
+
+Current version: 0.7.0
+
+## License
+
+GNU General Public License v3.0 (GPL-3.0)
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+Any modifications or derivative works must also be licensed under GPL-3.0 and the source code must be made available.

package/dist/bin/toolkit.js

@@ -2,8 +2,27 @@
 import { Command } from "commander";
 import { commands } from "../commands/index.js";
 const program = new Command();
+// Add global --profile option
+program.option('--profile <profileName>', 'Use a specific profile for this command');
+// Add a preAction hook to handle the global --profile flag
+program.hook('preAction', (thisCommand, actionCommand) => {
+    const opts = thisCommand.opts();
+    if (opts.profile) {
+        // Store the profile name in a global variable or process.env so commands can access it
+        process.env.PTKL_ACTIVE_PROFILE = opts.profile;
+    }
+});
 commands.forEach(c => program.addCommand(c));
-program.parseAsync(process.argv);
+program.parseAsync(process.argv).catch((err) => {
+    const { response } = err;
+    if (response && response.data) {
+        console.error(response.data.message);
+    }
+    else {
+        console.error(err.message || err);
+    }
+    process.exit(1);
+});
 process.on('uncaughtException', (err) => {
     const { response } = err;
     if (response && response.data) {

package/dist/commands/apps.js

@@ -78,10 +78,10 @@ class AppsCommand {
         const profile = util.getCurrentProfile();
         const client = new Api({ token: profile.token, host: profile.host }).app(apptype);
         try {
-            let buffer = Buffer.alloc(0);
+            const chunks = [];
             const bufferStream = new Writable({
                 write(chunk, encoding, callback) {
-                    buffer = Buffer.concat([buffer, chunk]);
+                    chunks.push(Buffer.from(chunk));
                     callback();
                 },
             });
@@ -93,14 +93,35 @@ class AppsCommand {
                     .on('error', reject);
             });
             console.log('Archive created successfully');
-            // Create FormData with buffer
+            // Convert chunks to a single ArrayBuffer to avoid Node Buffer issues
+            const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+            const arrayBuffer = new ArrayBuffer(totalLength);
+            const uint8View = new Uint8Array(arrayBuffer);
+            let offset = 0;
+            for (const chunk of chunks) {
+                uint8View.set(new Uint8Array(chunk), offset);
+                offset += chunk.length;
+            }
+            console.log('ArrayBuffer size:', arrayBuffer.byteLength);
+            // Create FormData with ArrayBuffer
             const formData = new FormData();
-            const blob = new Blob([buffer], { type: 'application/gzip' });
+            const blob = new Blob([arrayBuffer], { type: 'application/gzip' });
+            console.log('Blob size:', blob.size);
             formData.append('app', blob, 'app.tar.gz');
             if (build) {
                 formData.append('build', 'true');
             }
-            return await client.upload(formData);
+            console.log('About to call client.upload...');
+            try {
+                const result = await client.upload(formData);
+                console.log('Upload successful');
+                return result;
+            }
+            catch (error) {
+                console.log('Upload failed with error:', error.message);
+                console.log('Error details:', error);
+                throw error;
+            }
         }
         catch (error) {
             throw error;
@@ -164,14 +185,15 @@ class AppsCommand {
         const manifestPath = `${distPath}/manifest.json`;
         writeFileSync(manifestPath, JSON.stringify(manifest, null, 4));
         if (upload) {
-            let buffer = Buffer.alloc(0);
+            const chunks = [];
             const bufferStream = new Writable({
                 write(chunk, encoding, callback) {
-                    buffer = Buffer.concat([buffer, chunk]);
+                    chunks.push(chunk);
                     callback();
                 },
             });
             c({ gzip: true, cwd: distPath }, ['.']).pipe(bufferStream).on('finish', () => {
+                const buffer = Buffer.concat(chunks);
                 client.app().bundleUpload(buffer).then(() => {
                     console.log('Bundle uploaded successfully');
                 })

package/dist/commands/profile.js

@@ -2,6 +2,7 @@ import { Command } from "commander";
 import util from "../lib/util.js";
 import cli from "../lib/cli.js";
 import { APIUser, User } from "@ptkl/sdk";
+import password from '@inquirer/password';
 class ProfileCommand {
     register() {
         return new Command('profile')
@@ -12,14 +13,15 @@ class ProfileCommand {
             .description('Create new profile')
             .option("-n, --name <name>")
             .option("-u, --username <username>")
-            .option("-p, --password <password>")
+            .option("-p, --password [password]", "Password (optional value - if omitted, you will be prompted securely)")
             .option("-P, --project <project>")
             .option("-h, --host <host>")
             .action(this.new))
             .addCommand(new Command('auth')
             .description('Profile auth')
-            .option("-p, --password <password>")
+            .option("-p, --password [password]", "Password (optional value - if omitted, you will be prompted securely)")
             .option("-t, --token <token>")
+            .option("-P, --project <project>")
             .action(this.auth))
             .addCommand(new Command('list')
             .description('List all available profiles')
@@ -43,23 +45,39 @@ class ProfileCommand {
     }
     async new(options) {
         // try to find profile with the name
-        const { name, username, password, project, host } = options;
+        const { name, username, project, host } = options;
+        let userPassword = options.password;
+        // Handle password input
+        if (typeof userPassword === 'string' && userPassword.length > 0) {
+            // Password was provided as CLI argument - show security warning
+            console.warn('⚠️  WARNING: Providing password via CLI argument is insecure and may be visible in shell history.');
+            console.warn('⚠️  Consider using --password flag without a value to be prompted securely.\n');
+        }
+        else {
+            // Prompt for password securely (either --password flag was used without value, or not provided at all)
+            userPassword = await password({
+                message: 'Enter password:',
+            });
+        }
         let token = "";
         // if username is email then login to platform as user
         if (username && username.includes('@')) {
             const user = new User({
-                username,
-                password,
                 host,
             });
-            const { data } = await user.auth(username, password, project);
-            token = "SESSION:" + data.token;
+            try {
+                const { data } = await user.auth(username, userPassword, project);
+                token = "SESSION:" + data.token;
+            }
+            catch (error) {
+                throw error;
+            }
         }
         else {
             const user = new APIUser({
                 host,
             });
-            const { data } = await user.auth(username, password, project);
+            const { data } = await user.auth(username, userPassword, project);
             token = data.Token;
         }
         const profiles = util.getProfiles() ?? [];
@@ -72,25 +90,51 @@ class ProfileCommand {
             name,
             username,
             token,
-            host
+            host,
+            project,
         });
         util.updateProfiles(profiles);
     }
     async auth(options) {
         // try to find profile with the name
-        const { password, token } = options;
+        let { token, project } = options;
+        let userPassword = options.password;
         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;
-        }
-        else {
-            profile.token = token;
+            // Handle password input
+            if (typeof userPassword === 'string' && userPassword.length > 0) {
+                // Password was provided as CLI argument - show security warning
+                console.warn('⚠️  WARNING: Providing password via CLI argument is insecure and may be visible in shell history.');
+                console.warn('⚠️  Consider using --password flag without a value to be prompted securely.\n');
+            }
+            else {
+                // Prompt for password securely
+                userPassword = await password({
+                    message: 'Enter password:',
+                });
+            }
+            if (profile.username && profile.username.includes('@')) {
+                const user = new User({
+                    host: profile.host,
+                });
+                try {
+                    const { data } = await user.auth(profile.username, userPassword, project ?? profile.project);
+                    token = "SESSION:" + data.token;
+                }
+                catch (error) {
+                    throw error;
+                }
+            }
+            else {
+                const user = new APIUser({
+                    host: profile.host,
+                });
+                const { data } = await user.auth(profile.username, userPassword, project ?? profile.project);
+                token = data.Token;
+            }
         }
+        profile.project = project ?? profile.project;
+        profile.token = token;
         util.updateProfile(profile);
     }
     list() {

package/dist/lib/util.js

@@ -48,9 +48,22 @@ export default class Util {
     }
     static getCurrentProfile() {
         const profiles = Util.getProfiles();
-        const profile = profiles?.find(p => p.current);
-        if (!profile) {
-            throw new Error("Current profile is not set. Run command `profile use {profile-name}`");
+        // Check if --profile flag was used globally
+        const profileNameFromFlag = process.env.PTKL_ACTIVE_PROFILE;
+        let profile;
+        if (profileNameFromFlag) {
+            // Use the profile specified via --profile flag
+            profile = profiles?.find(p => p.name === profileNameFromFlag);
+            if (!profile) {
+                throw new Error(`Profile '${profileNameFromFlag}' not found. Available profiles: ${profiles?.map(p => p.name).join(', ')}`);
+            }
+        }
+        else {
+            // Fall back to current profile
+            profile = profiles?.find(p => p.current);
+            if (!profile) {
+                throw new Error("Current profile is not set. Run command `profile use {profile-name}` or use --profile flag");
+            }
         }
         return profile;
     }

package/package.json

@@ -1,19 +1,36 @@
 {
   "name": "@ptkl/toolkit",
-  "version": "0.6.1",
+  "version": "0.7.0",
+  "description": "A command-line toolkit for managing Protokol platform applications, profiles, functions, and components",
+  "keywords": [
+    "protokol",
+    "cli",
+    "toolkit",
+    "deployment",
+    "serverless",
+    "functions"
+  ],
+  "author": "Protokol",
+  "license": "GPL-3.0",
+  "repository": {
+    "type": "git",
+    "url": "https://your-gitea-instance.com/your-org/protokol-toolkit.git"
+  },
+  "bugs": {
+    "url": "https://your-gitea-instance.com/your-org/protokol-toolkit/issues"
+  },
+  "homepage": "https://your-gitea-instance.com/your-org/protokol-toolkit#readme",
+  "type": "module",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "build": "npx tsc",
-    "toolkit": "tsc --build && node dist/bin/toolkit"
+    "toolkit": "tsc --build && node dist/bin/toolkit",
+    "prepublishOnly": "npm run build"
   },
-  "keywords": [],
-  "author": "",
-  "license": "MIT",
-  "description": "",
-  "type": "module",
   "dependencies": {
     "@babel/standalone": "^7.26.10",
-    "@ptkl/sdk": "file:../protokol-sdk",
+    "@inquirer/password": "^4.0.21",
+    "@ptkl/sdk": "^0.9.12",
     "@types/axios": "^0.14.0",
     "@types/commander": "^2.12.2",
     "@types/js-yaml": "^4.0.9",