@hsafa/cli 0.0.1 → 0.0.3

package/README.md

@@ -29,17 +29,16 @@ hsafa auth status
 hsafa auth logout
 ```
 
-### Workspaces & Projects
+### Workspaces
 
 ```bash
 hsafa workspace list
-hsafa workspace projects <workspace-id>
 ```
 
 ### Agents
 
 ```bash
-hsafa agent list -p <project-id>
+hsafa agent list --workspace <workspace-id>
 hsafa agent chat <agent-id>
 ```
 
@@ -67,6 +66,6 @@ hsafa status
 ## Features
 
 - **Interactive Chat**: Real-time streaming conversation with agents.
-- **Project Navigation**: Easily list workspaces, projects, and agents.
+- **Workspace Navigation**: Easily list workspaces and agents.
 - **Secure Auth**: Stores session tokens locally.
 - **File Uploads**: Command-line file uploads to the server.

package/dist/commands/agent.js

@@ -157,29 +157,44 @@ export function registerAgentCommands(program) {
     agent
         .command('list')
         .description('List all available agents')
-        .option('-p, --project <id>', 'Project ID')
+        .option('-w, --workspace <id>', 'Workspace ID')
         .action(async (options) => {
         const globalOptions = program.opts();
         const spinner = !globalOptions.json ? ora('Fetching agents...').start() : null;
         try {
-            const projectId = options.project;
-            if (!projectId) {
-                if (spinner)
-                    spinner.fail('Project ID is required. Use -p <id>');
-                else
-                    console.error(JSON.stringify({ error: 'Project ID is required' }));
-                return;
+            let workspaceId = options.workspace;
+            if (!workspaceId) {
+                const wsResponse = await api.get('/api/workspaces');
+                const workspaces = wsResponse.data;
+                if (!Array.isArray(workspaces) || workspaces.length === 0) {
+                    if (spinner)
+                        spinner.fail('No workspaces found.');
+                    else
+                        console.error(JSON.stringify({ error: 'No workspaces found' }));
+                    return;
+                }
+                workspaceId = workspaces[0].id;
             }
-            const response = await api.get(`/api/projects/${projectId}/agents`);
-            const agents = response.data;
+            const query = `
+          query($workspaceId: ID!) {
+            agents(workspaceId: $workspaceId) {
+              id
+              name
+              description
+              status
+            }
+          }
+        `;
+            const data = await graphqlRequest(query, { workspaceId });
+            const agents = data.agents;
             if (spinner)
                 spinner.stop();
             if (globalOptions.json) {
                 console.log(JSON.stringify(agents, null, 2));
                 return;
             }
-            if (agents.length === 0) {
-                console.log(chalk.yellow('No agents found for this project.'));
+            if (!Array.isArray(agents) || agents.length === 0) {
+                console.log(chalk.yellow('No agents found for this workspace.'));
                 return;
             }
             const table = new Table({

package/dist/commands/auth.js

@@ -38,11 +38,38 @@ export function registerAuthCommands(program) {
             return;
         }
         const spinner = ora('Waiting for authentication...').start();
-        // Start local server to receive the token
+        // CSRF-ish state to prevent random localhost hits from completing login
+        const expectedState = Math.random().toString(36).slice(2);
+        // Start local server to receive the authorization code
         const server = http.createServer(async (req, res) => {
             const url = new URL(req.url, `http://${req.headers.host}`);
-            const token = url.searchParams.get('token');
-            if (token) {
+            const code = url.searchParams.get('code');
+            const returnedState = url.searchParams.get('state');
+            if (!returnedState || returnedState !== expectedState) {
+                res.writeHead(400, { 'Content-Type': 'text/plain' });
+                res.end('Invalid state.');
+                spinner.fail(chalk.red('Login failed: Invalid state.'));
+                server.close();
+                process.exit(1);
+            }
+            if (!code) {
+                res.writeHead(400, { 'Content-Type': 'text/plain' });
+                res.end('No code provided.');
+                spinner.fail(chalk.red('Login failed: No code received.'));
+                server.close();
+                process.exit(1);
+            }
+            // Exchange code for token
+            try {
+                const response = await axios.post(`${serverUrl}/api/cli-auth/exchange`, { code }, { headers: { 'Content-Type': 'application/json' } });
+                const token = response?.data?.token;
+                if (!token || typeof token !== 'string') {
+                    res.writeHead(400, { 'Content-Type': 'text/plain' });
+                    res.end('Invalid exchange response.');
+                    spinner.fail(chalk.red('Login failed: Invalid token response.'));
+                    server.close();
+                    process.exit(1);
+                }
                 // Save token
                 saveToken(token);
                 // Respond to browser
@@ -58,12 +85,13 @@ export function registerAuthCommands(program) {
         `);
                 spinner.succeed(chalk.green('Login successful!'));
                 server.close();
-                process.exit(0); // Exit successfully
+                process.exit(0);
             }
-            else {
+            catch (error) {
+                const errorMsg = error.response?.data?.error || error.message;
                 res.writeHead(400, { 'Content-Type': 'text/plain' });
-                res.end('No token provided.');
-                spinner.fail(chalk.red('Login failed: No token received.'));
+                res.end(`Login failed: ${errorMsg}`);
+                spinner.fail(chalk.red(`Login failed: ${errorMsg}`));
                 server.close();
                 process.exit(1);
             }
@@ -73,66 +101,20 @@ export function registerAuthCommands(program) {
             const address = server.address();
             const port = address.port;
             const callbackUrl = `http://localhost:${port}`;
-            // Open the browser
-            // Point to the client-side CLI login page (where NextAuth is configured)
-            // The client page logic:
-            // 1. Check if user is logged in (session).
-            // 2. If not, redirect to /api/auth/signin?callbackUrl=/cli-login?callback=callbackUrl
-            // 3. If logged in, get session token.
-            // 4. Redirect to callbackUrl?token=sessionToken
-            const loginUrl = `${serverUrl}/cli-login?callback=${encodeURIComponent(callbackUrl)}`;
+            const loginUrl = new URL('/cli-auth', serverUrl);
+            loginUrl.searchParams.set('callback', callbackUrl);
+            loginUrl.searchParams.set('state', expectedState);
             try {
-                await open(loginUrl);
+                await open(loginUrl.toString());
             }
             catch (err) {
                 spinner.fail(chalk.red('Failed to open browser. Please open this URL manually:'));
-                console.log(loginUrl);
+                console.log(loginUrl.toString());
             }
         });
     }
     async function loginManual() {
-        const answers = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'email',
-                message: 'Enter your email:',
-            },
-            {
-                type: 'password',
-                name: 'password',
-                message: 'Enter your password:',
-            },
-        ]);
-        const spinner = ora('Logging in...').start();
-        try {
-            const serverUrl = config.get('serverUrl');
-            const response = await axios.post(`${serverUrl}/api/auth/signin`, {
-                email: answers.email,
-                password: answers.password,
-            }, {
-                withCredentials: true,
-            });
-            // Extract cookie
-            const setCookie = response.headers['set-cookie'];
-            if (setCookie) {
-                const sessionTokenMatch = setCookie.find(c => c.includes('next-auth.session-token'));
-                if (sessionTokenMatch) {
-                    const token = sessionTokenMatch.split(';')[0].split('=')[1];
-                    saveToken(token);
-                    spinner.succeed(chalk.green('Login successful!'));
-                }
-                else {
-                    spinner.fail(chalk.red('Login failed: Could not find session token in response.'));
-                }
-            }
-            else {
-                spinner.fail(chalk.red('Login failed: No cookies returned from server.'));
-            }
-        }
-        catch (error) {
-            const errorMsg = error.response?.data?.error || error.message;
-            spinner.fail(chalk.red(`Login failed: ${errorMsg}`));
-        }
+        console.log(chalk.yellow('Manual login is not supported. Please run `hsafa auth login` to authenticate via the browser.'));
     }
     function saveToken(token) {
         config.set('token', token);
@@ -151,6 +133,14 @@ export function registerAuthCommands(program) {
         .description('Logout from HSAFA')
         .action(() => {
         config.delete('token');
+        const currentProfile = config.get('currentProfile');
+        if (currentProfile) {
+            const profiles = config.get('profiles') || {};
+            if (profiles[currentProfile]) {
+                profiles[currentProfile].token = '';
+                config.set('profiles', profiles);
+            }
+        }
         console.log(chalk.green('Logged out successfully.'));
     });
     auth

package/dist/commands/workspace.js

@@ -39,39 +39,4 @@ export function registerWorkspaceCommands(program) {
                 console.error(JSON.stringify({ error: error.message }));
         }
     });
-    workspace
-        .command('projects <id>')
-        .description('List projects in a workspace')
-        .action(async (id) => {
-        const globalOptions = program.opts();
-        const spinner = !globalOptions.json ? ora('Fetching projects...').start() : null;
-        try {
-            const response = await api.get(`/api/workspaces/${id}/projects`);
-            const projects = response.data;
-            if (spinner)
-                spinner.stop();
-            if (globalOptions.json) {
-                console.log(JSON.stringify(projects, null, 2));
-                return;
-            }
-            if (projects.length === 0) {
-                console.log(chalk.yellow('No projects found in this workspace.'));
-                return;
-            }
-            const table = new Table({
-                head: [chalk.cyan('ID'), chalk.cyan('Name'), chalk.cyan('Description')],
-                colWidths: [36, 20, 40]
-            });
-            projects.forEach((p) => {
-                table.push([p.id, p.name, p.description || 'N/A']);
-            });
-            console.log(table.toString());
-        }
-        catch (error) {
-            if (spinner)
-                spinner.fail(`Failed to fetch projects: ${error.message}`);
-            else
-                console.error(JSON.stringify({ error: error.message }));
-        }
-    });
 }

package/dist/index.js

@@ -8,7 +8,6 @@ import { registerDocCommands } from './commands/doc.js';
 import { registerKbCommands } from './commands/kb.js';
 import { registerKeyCommands } from './commands/key.js';
 import { registerProfileCommands } from './commands/profile.js';
-import { registerProjectCommands } from './commands/project.js';
 import { registerSystemCommands } from './commands/system.js';
 import { registerUserCommands } from './commands/user.js';
 import { registerMemberCommands } from './commands/member.js';
@@ -21,7 +20,7 @@ const program = new Command();
 program
     .name('hsafa')
     .description('CLI to control HSAFA without UI')
-    .version('0.0.1')
+    .version('0.0.3')
     .option('--json', 'Output results in JSON format');
 program
     .command('config')
@@ -46,7 +45,6 @@ registerDocCommands(program);
 registerKbCommands(program);
 registerKeyCommands(program);
 registerProfileCommands(program);
-registerProjectCommands(program);
 registerSystemCommands(program);
 registerUserCommands(program);
 registerMemberCommands(program);

package/dist/utils/api.js

@@ -6,7 +6,7 @@ const api = axios.create({
 api.interceptors.request.use((req) => {
     const token = config.get('token');
     if (token) {
-        req.headers.Cookie = `next-auth.session-token=${token}`;
+        req.headers.Authorization = `Bearer ${token}`;
     }
     return req;
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hsafa/cli",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "CLI to control HSAFA without UI",
   "main": "dist/index.js",
   "exports": {
@@ -17,7 +17,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsc && cp -r src/templates dist/",
+    "build": "rm -rf dist && tsc && cp -r src/templates dist/ && node -e \"const fs=require('fs');const p='dist/index.js';let s=fs.readFileSync(p,'utf8');if(!s.startsWith('#!/usr/bin/env node\\n')){fs.writeFileSync(p,'#!/usr/bin/env node\\n'+s,{encoding:'utf8'});}\" && chmod +x dist/index.js",
     "dev": "tsc --watch",
     "start": "node dist/index.js",
     "prepublishOnly": "pnpm run build"

package/dist/commands/project.js

@@ -1,90 +0,0 @@
-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}`);
-        }
-    });
-}