@hsafa/cli 0.0.1

package/dist/commands/kb.js

@@ -0,0 +1,155 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import api from '../utils/api.js';
+import { graphqlRequest } from '../utils/graphql.js';
+import ora from 'ora';
+export function registerKbCommands(program) {
+    const kb = program.command('kb').description('Knowledge Base management');
+    kb
+        .command('list')
+        .description('List your knowledge bases')
+        .action(async () => {
+        const spinner = ora('Fetching knowledge bases...').start();
+        try {
+            const query = `
+          query {
+            myKnowledgeBases {
+              id
+              name
+              description
+              createdAt
+            }
+          }
+        `;
+            const data = await graphqlRequest(query);
+            const kbs = data.myKnowledgeBases;
+            spinner.stop();
+            if (kbs.length === 0) {
+                console.log(chalk.yellow('No knowledge bases found.'));
+                return;
+            }
+            const table = new Table({
+                head: [chalk.cyan('ID'), chalk.cyan('Name'), chalk.cyan('Description'), chalk.cyan('Created')],
+                colWidths: [36, 20, 30, 25]
+            });
+            kbs.forEach((k) => {
+                table.push([k.id, k.name, k.description || 'N/A', k.createdAt]);
+            });
+            console.log(table.toString());
+        }
+        catch (error) {
+            spinner.fail(`Failed to fetch KB: ${error.message}`);
+        }
+    });
+    kb
+        .command('docs <id>')
+        .description('List documents in a knowledge base')
+        .action(async (id) => {
+        const spinner = ora('Fetching documents...').start();
+        try {
+            const query = `
+          query($id: ID!) {
+            knowledgeBaseDocuments(knowledgeBaseId: $id) {
+              id
+              fileName
+              fileType
+              status
+              uploadedAt
+            }
+          }
+        `;
+            const data = await graphqlRequest(query, { id });
+            const docs = data.knowledgeBaseDocuments;
+            spinner.stop();
+            if (docs.length === 0) {
+                console.log(chalk.yellow('No documents found in this KB.'));
+                return;
+            }
+            const table = new Table({
+                head: [chalk.cyan('ID'), chalk.cyan('File Name'), chalk.cyan('Status'), chalk.cyan('Uploaded')],
+                colWidths: [36, 30, 15, 25]
+            });
+            docs.forEach((d) => {
+                table.push([d.id, d.fileName, d.status, d.uploadedAt]);
+            });
+            console.log(table.toString());
+        }
+        catch (error) {
+            spinner.fail(`Failed to fetch documents: ${error.message}`);
+        }
+    });
+    kb
+        .command('create <name>')
+        .description('Create a new knowledge base')
+        .option('-d, --description <desc>', 'KB description')
+        .action(async (name, options) => {
+        const spinner = ora('Creating knowledge base...').start();
+        try {
+            const mutation = `
+          mutation($input: CreateKnowledgeBaseInput!) {
+            createKnowledgeBase(input: $input) {
+              id
+              name
+            }
+          }
+        `;
+            const data = await graphqlRequest(mutation, {
+                input: {
+                    name,
+                    description: options.description || '',
+                }
+            });
+            spinner.succeed(chalk.green(`Knowledge base "${data.createKnowledgeBase.name}" created with ID: ${data.createKnowledgeBase.id}`));
+        }
+        catch (error) {
+            spinner.fail(`Failed to create KB: ${error.message}`);
+        }
+    });
+    kb
+        .command('doc-add <kbId> <file>')
+        .description('Upload and add a document to a knowledge base')
+        .action(async (kbId, file) => {
+        const fs = await import('fs');
+        const path = await import('path');
+        const FormData = (await import('form-data')).default;
+        const filePath = path.resolve(file);
+        if (!fs.existsSync(filePath)) {
+            console.error(chalk.red(`File not found: ${file}`));
+            return;
+        }
+        const spinner = ora('Uploading and adding document...').start();
+        try {
+            // 1. Upload file
+            const formData = new FormData();
+            formData.append('file', fs.createReadStream(filePath));
+            const uploadResponse = await api.post('/api/uploads', formData, {
+                headers: {
+                    ...formData.getHeaders(),
+                },
+            });
+            const uploadData = uploadResponse.data;
+            spinner.text = 'Adding document to KB...';
+            // 2. Add to KB via GraphQL
+            const mutation = `
+          mutation($kbId: ID!, $docs: [CreateKnowledgeDocumentInput!]!) {
+            addKnowledgeDocuments(knowledgeBaseId: $kbId, documents: $docs) {
+              id
+              fileName
+            }
+          }
+        `;
+            await graphqlRequest(mutation, {
+                kbId,
+                docs: [{
+                        fileName: uploadData.name,
+                        fileType: uploadData.mimeType,
+                        storagePath: uploadData.url, // Using URL as storagePath as it's what the server returns
+                    }]
+            });
+            spinner.succeed(chalk.green(`Document "${uploadData.name}" added to KB ${kbId}`));
+        }
+        catch (error) {
+            spinner.fail(`Failed: ${error.message}`);
+        }
+    });
+}

package/dist/commands/key.js

@@ -0,0 +1,87 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { graphqlRequest } from '../utils/graphql.js';
+import ora from 'ora';
+export function registerKeyCommands(program) {
+    const key = program.command('key').description('API Key management');
+    key
+        .command('list')
+        .description('List your API keys')
+        .action(async () => {
+        const spinner = ora('Fetching API keys...').start();
+        try {
+            const query = `
+          query {
+            apiKeys {
+              id
+              name
+              provider
+              keyValue
+              isActive
+              lastUsedAt
+            }
+          }
+        `;
+            const data = await graphqlRequest(query);
+            const keys = data.apiKeys;
+            spinner.stop();
+            if (keys.length === 0) {
+                console.log(chalk.yellow('No API keys found.'));
+                return;
+            }
+            const table = new Table({
+                head: [chalk.cyan('ID'), chalk.cyan('Name'), chalk.cyan('Provider'), chalk.cyan('Status'), chalk.cyan('Last Used')],
+                colWidths: [36, 20, 15, 10, 25]
+            });
+            keys.forEach((k) => {
+                const status = k.isActive ? chalk.green('Active') : chalk.red('Inactive');
+                table.push([k.id, k.name, k.provider, status, k.lastUsedAt || 'Never']);
+            });
+            console.log(table.toString());
+        }
+        catch (error) {
+            spinner.fail(`Failed to fetch keys: ${error.message}`);
+        }
+    });
+    key
+        .command('add <name> <provider> <value>')
+        .description('Add a new API key (Providers: openai, anthropic, google, groq, perplexity, xai, openrouter)')
+        .action(async (name, provider, value) => {
+        const spinner = ora('Adding API key...').start();
+        try {
+            const mutation = `
+          mutation($input: CreateApiKeyInput!) {
+            createApiKey(input: $input) {
+              id
+              name
+            }
+          }
+        `;
+            const data = await graphqlRequest(mutation, {
+                input: { name, provider, keyValue: value }
+            });
+            spinner.succeed(chalk.green(`API key "${data.createApiKey.name}" added successfully.`));
+        }
+        catch (error) {
+            spinner.fail(`Failed to add key: ${error.message}`);
+        }
+    });
+    key
+        .command('delete <id>')
+        .description('Delete an API key')
+        .action(async (id) => {
+        const spinner = ora('Deleting API key...').start();
+        try {
+            const mutation = `
+          mutation($id: ID!) {
+            deleteApiKey(id: $id)
+          }
+        `;
+            await graphqlRequest(mutation, { id });
+            spinner.succeed(chalk.green('API key deleted.'));
+        }
+        catch (error) {
+            spinner.fail(`Failed to delete key: ${error.message}`);
+        }
+    });
+}

package/dist/commands/mcp.js

@@ -0,0 +1,56 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { graphqlRequest } from '../utils/graphql.js';
+import ora from 'ora';
+export function registerMcpCommands(program) {
+    const mcp = program.command('mcp').description('Model Context Protocol (MCP) management');
+    mcp
+        .command('agent <agentId>')
+        .description('List MCP servers configured for an agent')
+        .action(async (agentId) => {
+        const globalOptions = program.opts();
+        const spinner = !globalOptions.json ? ora('Checking MCP status...').start() : null;
+        try {
+            const query = `
+          query($id: ID!) {
+            agentWithFlow(id: $id) {
+              flowNodes {
+                nodeId
+                nodeType
+                data
+              }
+            }
+          }
+        `;
+            const data = await graphqlRequest(query, { id: agentId });
+            const mcpNodes = data.agentWithFlow.flowNodes.filter((n) => n.nodeType === 'custom_mcp');
+            if (spinner)
+                spinner.stop();
+            if (globalOptions.json) {
+                console.log(JSON.stringify(mcpNodes, null, 2));
+                return;
+            }
+            if (mcpNodes.length === 0) {
+                console.log(chalk.yellow('No MCP nodes found for this agent.'));
+                return;
+            }
+            const table = new Table({
+                head: [chalk.cyan('Node ID'), chalk.cyan('Type'), chalk.cyan('Preset/Label'), chalk.cyan('Status')],
+                colWidths: [36, 20, 20, 15]
+            });
+            mcpNodes.forEach((n) => {
+                const nodeData = n.data || {};
+                const status = nodeData.connectionStatus || 'unknown';
+                const label = nodeData.title || n.nodeType;
+                table.push([n.nodeId, n.nodeType, label, status === 'connected' ? chalk.green(status) : chalk.red(status)]);
+            });
+            console.log(table.toString());
+        }
+        catch (error) {
+            if (spinner)
+                spinner.fail(`Failed: ${error.message}`);
+            else
+                console.error(JSON.stringify({ error: error.message }));
+        }
+    });
+}

package/dist/commands/member.js

@@ -0,0 +1,103 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { graphqlRequest } from '../utils/graphql.js';
+import ora from 'ora';
+export function registerMemberCommands(program) {
+    const member = program.command('member').description('Member management');
+    member
+        .command('list <workspaceId>')
+        .description('List all members of a workspace')
+        .action(async (workspaceId) => {
+        const globalOptions = program.opts();
+        const spinner = !globalOptions.json ? ora('Fetching members...').start() : null;
+        try {
+            const query = `
+          query($workspaceId: ID!) {
+            workspaceMembers(workspaceId: $workspaceId) {
+              id
+              role
+              joinedAt
+              user {
+                id
+                name
+                email
+              }
+            }
+          }
+        `;
+            const data = await graphqlRequest(query, { workspaceId });
+            const members = data.workspaceMembers;
+            if (spinner)
+                spinner.stop();
+            if (globalOptions.json) {
+                console.log(JSON.stringify(members, null, 2));
+                return;
+            }
+            if (members.length === 0) {
+                console.log(chalk.yellow('No members found.'));
+                return;
+            }
+            const table = new Table({
+                head: [chalk.cyan('Member ID'), chalk.cyan('Name'), chalk.cyan('Email'), chalk.cyan('Role'), chalk.cyan('Joined')],
+                colWidths: [36, 20, 30, 10, 25]
+            });
+            members.forEach((m) => {
+                table.push([m.user.id, m.user.name || 'N/A', m.user.email, m.role, m.joinedAt]);
+            });
+            console.log(table.toString());
+        }
+        catch (error) {
+            if (spinner)
+                spinner.fail(`Failed to fetch members: ${error.message}`);
+            else
+                console.error(JSON.stringify({ error: error.message }));
+        }
+    });
+    member
+        .command('update <workspaceId> <memberId>')
+        .description('Update a member role (OWNER, EDITOR, VIEWER)')
+        .option('-r, --role <role>', 'New role')
+        .action(async (workspaceId, memberId, options) => {
+        if (!options.role) {
+            console.error(chalk.red('Role is required. Use -r <role>'));
+            return;
+        }
+        const spinner = ora('Updating member role...').start();
+        try {
+            const mutation = `
+          mutation($memberId: ID!, $input: UpdateWorkspaceMemberRoleInput!) {
+            updateWorkspaceMemberRole(memberId: $memberId, input: $input) {
+              id
+              role
+            }
+          }
+        `;
+            await graphqlRequest(mutation, {
+                memberId,
+                input: { role: options.role.toUpperCase() }
+            });
+            spinner.succeed(chalk.green(`Member role updated to ${options.role.toUpperCase()}.`));
+        }
+        catch (error) {
+            spinner.fail(`Failed to update member: ${error.message}`);
+        }
+    });
+    member
+        .command('remove <workspaceId> <memberId>')
+        .description('Remove a member from a workspace')
+        .action(async (workspaceId, memberId) => {
+        const spinner = ora('Removing member...').start();
+        try {
+            const mutation = `
+          mutation($memberId: ID!) {
+            removeWorkspaceMember(memberId: $memberId)
+          }
+        `;
+            await graphqlRequest(mutation, { memberId });
+            spinner.succeed(chalk.green('Member removed from workspace.'));
+        }
+        catch (error) {
+            spinner.fail(`Failed to remove member: ${error.message}`);
+        }
+    });
+}

package/dist/commands/profile.js

@@ -0,0 +1,65 @@
+import chalk from 'chalk';
+import config from '../utils/config.js';
+import Table from 'cli-table3';
+export function registerProfileCommands(program) {
+    const profile = program.command('profile').description('Environment profiles management');
+    profile
+        .command('list')
+        .description('List all profiles')
+        .action(() => {
+        const profiles = config.get('profiles') || {};
+        const current = config.get('currentProfile');
+        if (Object.keys(profiles).length === 0) {
+            console.log(chalk.yellow('No profiles found. Use hsafa profile add <name> <url>'));
+            return;
+        }
+        const table = new Table({
+            head: [chalk.cyan('Active'), chalk.cyan('Name'), chalk.cyan('Server URL')],
+            colWidths: [10, 20, 40]
+        });
+        Object.entries(profiles).forEach(([name, data]) => {
+            table.push([name === current ? chalk.green('  *  ') : '', name, data.serverUrl]);
+        });
+        console.log(table.toString());
+    });
+    profile
+        .command('add <name> <url>')
+        .description('Add a new profile')
+        .action((name, url) => {
+        const profiles = config.get('profiles') || {};
+        profiles[name] = { serverUrl: url };
+        config.set('profiles', profiles);
+        console.log(chalk.green(`Profile "${name}" added.`));
+    });
+    profile
+        .command('use <name>')
+        .description('Switch to a profile')
+        .action((name) => {
+        const profiles = config.get('profiles') || {};
+        if (!profiles[name]) {
+            console.error(chalk.red(`Profile "${name}" not found.`));
+            return;
+        }
+        const current = profiles[name];
+        config.set('currentProfile', name);
+        config.set('serverUrl', current.serverUrl);
+        config.set('token', current.token || '');
+        console.log(chalk.green(`Switched to profile "${name}" (${current.serverUrl})`));
+    });
+    profile
+        .command('delete <name>')
+        .description('Delete a profile')
+        .action((name) => {
+        const profiles = config.get('profiles') || {};
+        if (!profiles[name]) {
+            console.error(chalk.red(`Profile "${name}" not found.`));
+            return;
+        }
+        delete profiles[name];
+        config.set('profiles', profiles);
+        if (config.get('currentProfile') === name) {
+            config.delete('currentProfile');
+        }
+        console.log(chalk.green(`Profile "${name}" deleted.`));
+    });
+}

package/dist/commands/project.js

@@ -0,0 +1,90 @@
+import chalk from 'chalk';
+import { graphqlRequest } from '../utils/graphql.js';
+import ora from 'ora';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export function registerProjectCommands(program) {
+    const project = program.command('project').description('Project management');
+    project
+        .command('init <name>')
+        .description('Initialize a new project with a template')
+        .option('-w, --workspace <id>', 'Workspace ID (if not provided, will use the first one)')
+        .option('-t, --template <name>', 'Template name (basic-assistant, researcher)', 'basic-assistant')
+        .action(async (name, options) => {
+        const spinner = ora('Initializing project...').start();
+        try {
+            // 1. Get Workspace ID
+            let workspaceId = options.workspace;
+            if (!workspaceId) {
+                const workspacesQuery = `query { workspaces { id name } }`;
+                const wsData = await graphqlRequest(workspacesQuery);
+                if (wsData.workspaces.length === 0) {
+                    spinner.fail('No workspaces found. Create a workspace first using the UI or GraphQL.');
+                    return;
+                }
+                workspaceId = wsData.workspaces[0].id;
+                spinner.info(`Using workspace: ${wsData.workspaces[0].name} (${workspaceId})`);
+                spinner.start('Creating project...');
+            }
+            // 2. Create Project
+            const createProjectMutation = `
+          mutation($input: CreateProjectInput!) {
+            createProject(input: $input) {
+              id
+              name
+            }
+          }
+        `;
+            // Note: The GraphQL schema for createProject might vary, let's assume it takes workspaceId
+            // Looking at current server code, projects are often created within a workspace scope.
+            // However, I'll use the createAgent mutation which we know works well.
+            // Let's create an agent directly in the workspace as per current hsafa server structure
+            const createAgentMutation = `
+          mutation($workspaceId: ID!, $input: CreateAgentInput!) {
+            createAgent(workspaceId: $workspaceId, input: $input) {
+              id
+              name
+            }
+          }
+        `;
+            const agentData = await graphqlRequest(createAgentMutation, {
+                workspaceId,
+                input: {
+                    name,
+                    description: `Project initialized from ${options.template} template`,
+                    type: 'AI Agent'
+                }
+            });
+            const agentId = agentData.createAgent.id;
+            spinner.text = `Applying template ${options.template}...`;
+            // 3. Load Template
+            const templatePath = path.join(__dirname, '..', 'templates', `${options.template}.json`);
+            if (!fs.existsSync(templatePath)) {
+                spinner.fail(`Template ${options.template} not found.`);
+                return;
+            }
+            const template = JSON.parse(fs.readFileSync(templatePath, 'utf8'));
+            // 4. Apply Template Flow
+            const saveFlowMutation = `
+          mutation($agentId: ID!, $input: SaveAgentFlowInput!) {
+            saveAgentFlow(agentId: $agentId, input: $input)
+          }
+        `;
+            await graphqlRequest(saveFlowMutation, {
+                agentId,
+                input: {
+                    nodes: template.nodes,
+                    edges: template.edges
+                }
+            });
+            spinner.succeed(chalk.green(`Project "${name}" initialized successfully!`));
+            console.log(`\nAgent ID: ${chalk.cyan(agentId)}`);
+            console.log(`Run chat: ${chalk.bold(`hsafa agent chat ${agentId}`)}`);
+        }
+        catch (error) {
+            spinner.fail(`Initialization failed: ${error.message}`);
+        }
+    });
+}

package/dist/commands/system.js

@@ -0,0 +1,27 @@
+import chalk from 'chalk';
+import api from '../utils/api.js';
+import ora from 'ora';
+import Table from 'cli-table3';
+export function registerSystemCommands(program) {
+    program
+        .command('status')
+        .description('Check HSAFA system status')
+        .action(async () => {
+        const spinner = ora('Checking system status...').start();
+        try {
+            const response = await api.get('/api/health');
+            const data = response.data;
+            spinner.stop();
+            console.log(chalk.bold('\nHSAFA System Status:'));
+            const table = new Table();
+            table.push({ 'Status': data.status === 'healthy' ? chalk.green(data.status) : chalk.red(data.status) }, { 'Timestamp': data.timestamp }, { 'Database': data.database === 'connected' ? chalk.green(data.database) : chalk.red(data.database) }, { 'Server': chalk.green(data.server) });
+            if (data.error) {
+                table.push({ 'Error': chalk.red(data.error) });
+            }
+            console.log(table.toString());
+        }
+        catch (error) {
+            spinner.fail(`Failed to check status: ${error.message}`);
+        }
+    });
+}

package/dist/commands/user.js

@@ -0,0 +1,48 @@
+import chalk from 'chalk';
+import { graphqlRequest } from '../utils/graphql.js';
+import ora from 'ora';
+import Table from 'cli-table3';
+export function registerUserCommands(program) {
+    program
+        .command('me')
+        .description('Show current user profile')
+        .action(async () => {
+        const globalOptions = program.opts();
+        const spinner = !globalOptions.json ? ora('Fetching profile...').start() : null;
+        try {
+            const query = `
+          query {
+            me {
+              id
+              email
+              name
+              avatarUrl
+              createdAt
+            }
+          }
+        `;
+            const data = await graphqlRequest(query);
+            const user = data.me;
+            if (spinner)
+                spinner.stop();
+            if (globalOptions.json) {
+                console.log(JSON.stringify(user, null, 2));
+                return;
+            }
+            if (!user) {
+                console.log(chalk.red('Not logged in or user not found.'));
+                return;
+            }
+            const table = new Table();
+            table.push({ 'ID': user.id }, { 'Name': user.name || 'N/A' }, { 'Email': user.email }, { 'Created At': user.createdAt });
+            console.log(chalk.bold('\nYour Profile:'));
+            console.log(table.toString());
+        }
+        catch (error) {
+            if (spinner)
+                spinner.fail(`Failed to fetch profile: ${error.message}`);
+            else
+                console.error(JSON.stringify({ error: error.message }));
+        }
+    });
+}