gbos 1.4.16 → 1.4.18

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "gbos",
-  "version": "1.4.16",
-  "description": "GBOS - Command line interface for GBOS services",
+  "version": "1.4.18",
+  "description": "CLI and orchestrator for the Generative Business Operating System (GBOS) — connect AI coding agents (Claude, Gemini, Codex) to managed development workflows with task automation, GitLab sync, and NDJSON event streaming for thin client integration",
   "main": "src/index.js",
   "bin": {
     "gbos": "src/cli.js"
@@ -17,11 +17,18 @@
   "keywords": [
     "gbos",
     "cli",
-    "tui",
-    "cloud",
+    "orchestrator",
+    "ai-agent",
+    "ai-coding",
+    "claude",
+    "gemini",
+    "codex",
+    "task-automation",
     "devtools",
-    "development",
-    "ai-agent"
+    "gitlab",
+    "mcp",
+    "ndjson",
+    "thin-client"
   ],
   "author": "Mystro Analytics",
   "license": "MIT",

package/src/cli.js

@@ -4,6 +4,7 @@ const { Command } = require('commander');
 const program = new Command();
 
 const authCommand = require('./commands/auth');
+const authTokenCommand = require('./commands/auth-token');
 const connectCommand = require('./commands/connect');
 const logoutCommand = require('./commands/logout');
 const { tasksCommand, nextTaskCommand, continueCommand, fallbackCommand, addTaskCommand, completedCommand } = require('./commands/tasks');
@@ -27,6 +28,16 @@ program
   .option('-f, --force', 'Force re-authentication even if already authenticated')
   .action(authCommand);
 
+program
+  .command('auth-token')
+  .description('Authenticate with a pre-obtained access token (for thin clients and programmatic use)')
+  .requiredOption('-t, --token <token>', 'GBOS access token obtained from UI authentication')
+  .option('--node-id <nodeId>', 'Auto-connect to a specific node after authentication')
+  .option('-d, --dir <directory>', 'Working directory (defaults to current directory)')
+  .option('-a, --agent <agent>', 'Agent CLI being used (default: claude-code)')
+  .option('--json', 'Output result as JSON (for programmatic consumption)')
+  .action(authTokenCommand);
+
 program
   .command('connect')
   .description('Connect to a GBOS development node')
@@ -313,7 +324,7 @@ program
         cmd.outputHelp();
       } else {
         console.log(`Unknown command: ${command}`);
-        console.log('Available commands: auth, connect, disconnect, status, tasks, next, continue, completed, fallback, add_task, start, resume, stop, runs, auto, logout, gitlab, registry, help');
+        console.log('Available commands: auth, auth-token, connect, disconnect, status, tasks, next, continue, completed, fallback, add_task, start, resume, stop, runs, auto, logout, gitlab, registry, help');
       }
     } else {
       program.outputHelp();

package/src/commands/auth-token.js

@@ -0,0 +1,216 @@
+/**
+ * auth-token command
+ * Programmatic authentication for thin clients.
+ * Accepts an access token directly (obtained from UI-based login),
+ * validates it against the GBOS API, saves the session,
+ * and optionally auto-connects to a specific node.
+ *
+ * Usage:
+ *   gbos auth-token --token <access_token>
+ *   gbos auth-token --token <access_token> --node-id <id>
+ *   gbos auth-token --token <access_token> --node-id <id> --dir /path/to/project
+ */
+
+const api = require('../lib/api');
+const config = require('../lib/config');
+const { registerMCPServer } = require('../lib/skills');
+const { setupProjectSkills } = require('../lib/skills');
+
+async function authTokenCommand(options) {
+  const token = options.token;
+
+  if (!token) {
+    const result = { success: false, error: 'Missing --token flag. Provide an access token.' };
+    if (options.json) {
+      process.stdout.write(JSON.stringify(result) + '\n');
+    } else {
+      console.error('\nError: --token is required.\n');
+      console.error('Usage: gbos auth-token --token <access_token> [--node-id <id>] [--dir <path>]\n');
+    }
+    process.exit(1);
+  }
+
+  try {
+    // Step 1: Temporarily save the token so the API client can use it
+    config.saveSession({ access_token: token });
+
+    // Step 2: Validate the token by calling the session endpoint
+    let sessionInfo;
+    try {
+      sessionInfo = await api.getSession();
+    } catch (err) {
+      // Token is invalid — clear and fail
+      config.clearSession();
+      const result = { success: false, error: 'Invalid or expired token', details: err.message };
+      if (options.json) {
+        process.stdout.write(JSON.stringify(result) + '\n');
+      } else {
+        console.error('\nError: Token validation failed —', err.message, '\n');
+      }
+      process.exit(1);
+    }
+
+    const userData = sessionInfo.data || sessionInfo;
+    const user = userData.user || userData;
+    const account = userData.account || {};
+
+    // Step 3: Build and save the full session
+    const userId = user.id || user.user_id;
+    const userName = user.first_name && user.last_name
+      ? `${user.first_name} ${user.last_name}`
+      : user.name || user.user_name || `User ${userId}`;
+    const accountId = account.id || user.account_id;
+    const accountName = account.name || `Account ${accountId}`;
+
+    // Calculate token expiration — default 24 hours
+    const expiresInSeconds = userData.expires_in && userData.expires_in > 60
+      ? userData.expires_in : 86400;
+    const tokenExpiresAt = new Date(Date.now() + expiresInSeconds * 1000).toISOString();
+
+    const session = {
+      access_token: token,
+      refresh_token: userData.refresh_token || null,
+      token_expires_at: tokenExpiresAt,
+      user_id: userId,
+      user_name: userName,
+      user_first_name: user.first_name || null,
+      user_last_name: user.last_name || null,
+      user_email: user.email || null,
+      account_id: accountId,
+      account_name: accountName,
+      session_id: userData.session_id || null,
+      authenticated_at: new Date().toISOString(),
+      auth_method: 'token',
+    };
+
+    config.saveSession(session);
+
+    // Register MCP server
+    try {
+      registerMCPServer();
+    } catch (e) {
+      // Non-fatal
+    }
+
+    // Step 4: Optionally auto-connect to a node
+    let connectionResult = null;
+
+    if (options.nodeId) {
+      try {
+        const workingDirectory = options.dir || process.cwd();
+
+        // Get git info
+        let gitRepoUrl = null;
+        let gitBranch = null;
+        try {
+          const { execSync } = require('child_process');
+          gitRepoUrl = execSync('git config --get remote.origin.url', { encoding: 'utf8' }).trim();
+          gitBranch = execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf8' }).trim();
+        } catch (e) {
+          // Not a git repo — fine
+        }
+
+        const agentCli = options.agent || 'claude-code';
+
+        const connectResponse = await api.connectToNode(options.nodeId, {
+          working_directory: workingDirectory,
+          git_repo_url: gitRepoUrl,
+          git_branch: gitBranch,
+          agent_cli: agentCli,
+        });
+
+        const { connection_id, node } = connectResponse.data;
+        const applicationName = node.application?.name || 'N/A';
+
+        // Save connection to session
+        config.saveConnection({
+          connection_id,
+          node: {
+            id: node.id,
+            uuid: node.uuid,
+            name: node.name,
+            node_type: node.node_type,
+            system_prompt: node.system_prompt,
+            application_id: node.application_id,
+          },
+          application: {
+            id: node.application?.id || node.application_id,
+            name: applicationName,
+          },
+          connected_at: new Date().toISOString(),
+          working_directory: workingDirectory,
+          git_repo_url: gitRepoUrl,
+          git_branch: gitBranch,
+        });
+
+        // Setup project skills
+        try {
+          setupProjectSkills(workingDirectory);
+        } catch (e) {
+          // Non-fatal
+        }
+
+        connectionResult = {
+          connection_id,
+          node_id: node.id,
+          node_name: node.name,
+          application_id: node.application?.id || node.application_id,
+          application_name: applicationName,
+        };
+      } catch (err) {
+        // Auth succeeded but connect failed
+        connectionResult = { error: err.message };
+      }
+    }
+
+    // Step 5: Output result
+    const result = {
+      success: true,
+      user: {
+        id: userId,
+        name: userName,
+        email: user.email || null,
+      },
+      account: {
+        id: accountId,
+        name: accountName,
+      },
+      authenticated_at: session.authenticated_at,
+      token_expires_at: tokenExpiresAt,
+    };
+
+    if (connectionResult) {
+      result.connection = connectionResult;
+    }
+
+    if (options.json) {
+      process.stdout.write(JSON.stringify(result) + '\n');
+    } else {
+      console.log('\n  ✓ Authentication successful!\n');
+      console.log(`    User:    ${userName}`);
+      console.log(`    Account: ${accountName}`);
+      console.log(`    Expires: ${new Date(tokenExpiresAt).toLocaleString()}\n`);
+
+      if (connectionResult && !connectionResult.error) {
+        console.log('  ✓ Connected to node!\n');
+        console.log(`    Node:        ${connectionResult.node_name}`);
+        console.log(`    Application: ${connectionResult.application_name}`);
+        console.log(`    Session:     ${connectionResult.connection_id}\n`);
+      } else if (connectionResult && connectionResult.error) {
+        console.log(`  ✗ Connection failed: ${connectionResult.error}\n`);
+      }
+
+      console.log('  You can now run "gbos connect", "gbos tasks", or "gbos auto".\n');
+    }
+  } catch (error) {
+    const result = { success: false, error: error.message };
+    if (options.json) {
+      process.stdout.write(JSON.stringify(result) + '\n');
+    } else {
+      console.error(`\nError: ${error.message}\n`);
+    }
+    process.exit(1);
+  }
+}
+
+module.exports = authTokenCommand;