gbos 1.0.0 → 1.1.0

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "gbos",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "GBOS - Command line interface for GBOS services",
   "main": "src/index.js",
   "bin": {
-    "gbos": "./src/cli.js"
+    "gbos": "src/cli.js"
   },
   "scripts": {
     "start": "node src/index.js",
@@ -19,7 +19,9 @@
     "cli",
     "tui",
     "cloud",
-    "devtools"
+    "devtools",
+    "development",
+    "ai-agent"
   ],
   "author": "Mystro Analytics",
   "license": "MIT",

package/src/cli.js

@@ -3,69 +3,134 @@
 const { Command } = require('commander');
 const program = new Command();
 
+const authCommand = require('./commands/auth');
+const connectCommand = require('./commands/connect');
+const logoutCommand = require('./commands/logout');
+const config = require('./lib/config');
+
+const VERSION = require('../package.json').version;
+
 program
   .name('gbos')
   .description('GBOS - Command line interface for GBOS services')
-  .version('1.0.0');
+  .version(VERSION);
 
 program
   .command('auth')
   .description('Authenticate with GBOS services')
-  .option('-t, --token <token>', 'Use a specific auth token')
-  .action((options) => {
-    console.log('Authenticating with GBOS services...');
-    if (options.token) {
-      console.log('Using provided token');
-    } else {
-      console.log('Opening browser for authentication...');
+  .option('-e, --email <email>', 'Email address for authentication')
+  .option('-f, --force', 'Force re-authentication even if already authenticated')
+  .action(authCommand);
+
+program
+  .command('connect')
+  .description('Connect to a GBOS development node')
+  .option('-d, --dir <directory>', 'Working directory (defaults to current directory)')
+  .option('-a, --agent <agent>', 'Agent CLI being used (default: claude-code)')
+  .option('-f, --force', 'Force reconnect even if already connected')
+  .action(connectCommand);
+
+program
+  .command('disconnect')
+  .description('Disconnect from the current GBOS node')
+  .action(async () => {
+    if (!config.isAuthenticated()) {
+      console.log('\nNot authenticated.\n');
+      return;
+    }
+
+    const connection = config.getConnection();
+    if (!connection) {
+      console.log('\nNot connected to any node.\n');
+      return;
+    }
+
+    try {
+      const api = require('./lib/api');
+      const result = await api.disconnect();
+
+      config.clearConnection();
+
+      console.log('\n✓ Disconnected from node.\n');
+
+      if (result.data) {
+        console.log(`  Tasks completed: ${result.data.tasks_completed || 0}`);
+        console.log(`  Tasks failed: ${result.data.tasks_failed || 0}`);
+        console.log(`  Total time: ${result.data.total_time_minutes || 0} minutes\n`);
+      }
+    } catch (error) {
+      config.clearConnection();
+      console.log('\n✓ Disconnected (local session cleared).\n');
     }
-    // TODO: Implement authentication logic
   });
 
 program
-  .command('connect')
-  .description('Connect to a GBOS service or resource')
-  .argument('[service]', 'Service name to connect to')
-  .option('-e, --env <environment>', 'Environment (dev, staging, prod)', 'dev')
-  .action((service, options) => {
-    console.log(`Connecting to GBOS...`);
-    if (service) {
-      console.log(`Service: ${service}`);
+  .command('status')
+  .description('Show current authentication and connection status')
+  .action(async () => {
+    const session = config.loadSession();
+
+    if (!session || !session.access_token) {
+      console.log('\nStatus: Not authenticated');
+      console.log('Run "gbos auth" to authenticate.\n');
+      return;
     }
-    console.log(`Environment: ${options.env}`);
-    // TODO: Implement connection logic
+
+    console.log('\n┌─────────────────────────────────────────────────────────────┐');
+    console.log('│                      GBOS Status                            │');
+    console.log('├─────────────────────────────────────────────────────────────┤');
+    console.log(`│  Authenticated: ✓                                          │`);
+    console.log(`│  User ID:       ${String(session.user_id).padEnd(42)}│`);
+    console.log(`│  Account ID:    ${String(session.account_id).padEnd(42)}│`);
+
+    const connection = session.connection;
+    if (connection) {
+      console.log('├─────────────────────────────────────────────────────────────┤');
+      console.log(`│  Connected:     ✓                                          │`);
+      console.log(`│  Node:          ${(connection.node?.name || 'Unknown').substring(0, 42).padEnd(42)}│`);
+      console.log(`│  Node ID:       ${String(connection.node?.id || '').padEnd(42)}│`);
+      console.log(`│  Connection:    ${(connection.connection_id || '').substring(0, 36).padEnd(42)}│`);
+    } else {
+      console.log('├─────────────────────────────────────────────────────────────┤');
+      console.log(`│  Connected:     ✗ (run "gbos connect")                     │`);
+    }
+
+    console.log('└─────────────────────────────────────────────────────────────┘\n');
+
+    // Show environment variables
+    console.log('Environment variables:');
+    const envVars = config.getSessionEnv();
+    Object.entries(envVars).forEach(([key, value]) => {
+      if (value) {
+        console.log(`  export ${key}="${value}"`);
+      }
+    });
+    console.log('');
   });
 
+program
+  .command('logout')
+  .description('Log out from GBOS services and clear credentials')
+  .option('-a, --all', 'Clear all stored data including machine ID')
+  .action(logoutCommand);
+
 program
   .command('help [command]')
   .description('Display help for a specific command')
   .action((command) => {
     if (command) {
-      const cmd = program.commands.find(c => c.name() === command);
+      const cmd = program.commands.find((c) => c.name() === command);
       if (cmd) {
         cmd.outputHelp();
       } else {
         console.log(`Unknown command: ${command}`);
-        console.log('Available commands: auth, connect, help, logout');
+        console.log('Available commands: auth, connect, disconnect, status, logout, help');
       }
     } else {
       program.outputHelp();
     }
   });
 
-program
-  .command('logout')
-  .description('Log out from GBOS services and clear credentials')
-  .option('-a, --all', 'Clear all stored credentials')
-  .action((options) => {
-    console.log('Logging out from GBOS services...');
-    if (options.all) {
-      console.log('Clearing all stored credentials...');
-    }
-    console.log('Successfully logged out.');
-    // TODO: Implement logout logic
-  });
-
 // Show help by default if no command is provided
 if (process.argv.length <= 2) {
   program.outputHelp();

package/src/commands/auth.js

@@ -0,0 +1,164 @@
+const api = require('../lib/api');
+const config = require('../lib/config');
+const readline = require('readline');
+
+// Simple prompt for email
+async function promptEmail() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question('Enter your email address: ', (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+// Sleep helper
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// Spinner frames
+const spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+async function authCommand(options) {
+  // Check if already authenticated
+  if (config.isAuthenticated() && !options.force) {
+    const session = config.loadSession();
+    console.log(`\nAlready authenticated as user ID: ${session.user_id}`);
+    console.log(`Account ID: ${session.account_id}`);
+    console.log(`\nUse --force to re-authenticate or 'gbos logout' first.\n`);
+    return;
+  }
+
+  try {
+    // Get email from user
+    const email = options.email || await promptEmail();
+
+    if (!email || !email.includes('@')) {
+      console.error('Invalid email address.');
+      process.exit(1);
+    }
+
+    console.log(`\nInitializing authentication for: ${email}`);
+
+    // Initialize device auth flow
+    const initResponse = await api.initAuth({ email });
+    const { device_code, verification_code, verification_url_complete, interval, expires_in } = initResponse.data;
+
+    console.log('\n┌─────────────────────────────────────────────────────────────┐');
+    console.log('│                    GBOS Authentication                       │');
+    console.log('├─────────────────────────────────────────────────────────────┤');
+    console.log(`│  Device Code: ${device_code}                              │`);
+    console.log('│                                                             │');
+    console.log('│  Please visit the following URL to authorize:              │');
+    console.log('└─────────────────────────────────────────────────────────────┘');
+    console.log(`\n${verification_url_complete}\n`);
+    console.log(`Code expires in ${Math.floor(expires_in / 60)} minutes.\n`);
+
+    // Try to open the URL in the default browser
+    const openCommand = process.platform === 'darwin' ? 'open' :
+                        process.platform === 'win32' ? 'start' : 'xdg-open';
+
+    try {
+      const { exec } = require('child_process');
+      exec(`${openCommand} "${verification_url_complete}"`);
+      console.log('Opening browser...\n');
+    } catch (e) {
+      console.log('Please open the URL above in your browser.\n');
+    }
+
+    // Poll for authorization
+    const pollInterval = (interval || 5) * 1000;
+    const maxAttempts = Math.ceil((expires_in || 900) / (interval || 5));
+    let attempts = 0;
+    let frameIndex = 0;
+
+    process.stdout.write('Waiting for authorization... ');
+
+    while (attempts < maxAttempts) {
+      attempts++;
+
+      // Show spinner
+      process.stdout.write(`\rWaiting for authorization... ${spinnerFrames[frameIndex]} `);
+      frameIndex = (frameIndex + 1) % spinnerFrames.length;
+
+      await sleep(pollInterval);
+
+      try {
+        const statusResponse = await api.checkAuthStatus(verification_code);
+
+        if (statusResponse.status === 'approved' && statusResponse.data) {
+          // Clear spinner line
+          process.stdout.write('\r' + ' '.repeat(50) + '\r');
+
+          const { access_token, refresh_token, expires_in: tokenExpires, user_id, account_id, session_id } = statusResponse.data;
+
+          // Calculate token expiration
+          const tokenExpiresAt = new Date(Date.now() + tokenExpires * 1000).toISOString();
+
+          // Save session
+          config.saveSession({
+            access_token,
+            refresh_token,
+            token_expires_at: tokenExpiresAt,
+            user_id,
+            account_id,
+            session_id,
+            authenticated_at: new Date().toISOString(),
+          });
+
+          console.log('\n✓ Authentication successful!\n');
+          console.log(`  User ID:    ${user_id}`);
+          console.log(`  Account ID: ${account_id}`);
+          console.log(`  Session:    ${session_id}\n`);
+          console.log('Run "gbos connect" to connect to a development node.\n');
+          return;
+        }
+
+        if (statusResponse.status === 'denied') {
+          process.stdout.write('\r' + ' '.repeat(50) + '\r');
+          console.log('\n✗ Authorization denied.\n');
+          process.exit(1);
+        }
+
+        if (statusResponse.status === 'expired') {
+          process.stdout.write('\r' + ' '.repeat(50) + '\r');
+          console.log('\n✗ Authorization request expired. Please try again.\n');
+          process.exit(1);
+        }
+
+        // Status is pending, continue polling
+      } catch (error) {
+        if (error.status === 410) {
+          process.stdout.write('\r' + ' '.repeat(50) + '\r');
+          console.log('\n✗ Authorization request expired. Please try again.\n');
+          process.exit(1);
+        }
+        if (error.status === 403) {
+          process.stdout.write('\r' + ' '.repeat(50) + '\r');
+          console.log('\n✗ Authorization denied.\n');
+          process.exit(1);
+        }
+        // For other errors, continue polling
+      }
+    }
+
+    process.stdout.write('\r' + ' '.repeat(50) + '\r');
+    console.log('\n✗ Authorization timed out. Please try again.\n');
+    process.exit(1);
+
+  } catch (error) {
+    console.error(`\nAuthentication failed: ${error.message}\n`);
+    if (process.env.DEBUG) {
+      console.error(error);
+    }
+    process.exit(1);
+  }
+}
+
+module.exports = authCommand;

package/src/commands/connect.js

@@ -0,0 +1,212 @@
+const api = require('../lib/api');
+const config = require('../lib/config');
+const readline = require('readline');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Simple selection prompt
+async function selectOption(message, options) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  console.log(`\n${message}\n`);
+
+  options.forEach((opt, index) => {
+    const status = opt.status ? ` [${opt.status}]` : '';
+    const connected = opt.is_connected ? ' (connected by another user)' : '';
+    console.log(`  ${index + 1}. ${opt.name}${status}${connected}`);
+    if (opt.description) {
+      console.log(`     ${opt.description}`);
+    }
+  });
+
+  console.log('');
+
+  return new Promise((resolve) => {
+    rl.question('Enter number (or q to quit): ', (answer) => {
+      rl.close();
+      if (answer.toLowerCase() === 'q') {
+        resolve(null);
+        return;
+      }
+      const index = parseInt(answer, 10) - 1;
+      if (index >= 0 && index < options.length) {
+        resolve(options[index]);
+      } else {
+        resolve(null);
+      }
+    });
+  });
+}
+
+// Get git info from current directory
+function getGitInfo() {
+  try {
+    const gitRepoUrl = execSync('git config --get remote.origin.url', { encoding: 'utf8' }).trim();
+    const gitBranch = execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf8' }).trim();
+    return { gitRepoUrl, gitBranch };
+  } catch (e) {
+    return { gitRepoUrl: null, gitBranch: null };
+  }
+}
+
+async function connectCommand(options) {
+  // Check authentication
+  if (!config.isAuthenticated()) {
+    console.log('\nNot authenticated. Please run "gbos auth" first.\n');
+    process.exit(1);
+  }
+
+  try {
+    // Check if already connected
+    const currentConnection = config.getConnection();
+    if (currentConnection && !options.force) {
+      console.log(`\nAlready connected to node: ${currentConnection.node?.name}`);
+      console.log(`Connection ID: ${currentConnection.connection_id}`);
+      console.log(`\nUse --force to reconnect or 'gbos disconnect' first.\n`);
+      return;
+    }
+
+    console.log('\nFetching available nodes...\n');
+
+    // Fetch available nodes
+    const nodesResponse = await api.listNodes();
+    const nodes = nodesResponse.data || [];
+
+    if (nodes.length === 0) {
+      console.log('No development nodes available.');
+      console.log('Please create a development node in the GBOS web interface.\n');
+      process.exit(1);
+    }
+
+    // Group nodes by application
+    const nodesByApp = {};
+    nodes.forEach((node) => {
+      const appId = node.application_id || 'unassigned';
+      if (!nodesByApp[appId]) {
+        nodesByApp[appId] = {
+          application: node.application,
+          nodes: [],
+        };
+      }
+      nodesByApp[appId].nodes.push(node);
+    });
+
+    // If multiple applications, let user select one first
+    let selectedApp = null;
+    const appIds = Object.keys(nodesByApp);
+
+    if (appIds.length > 1) {
+      const appOptions = appIds.map((appId) => ({
+        id: appId,
+        name: nodesByApp[appId].application?.name || `Application ${appId}`,
+        description: `${nodesByApp[appId].nodes.length} node(s) available`,
+      }));
+
+      selectedApp = await selectOption('Select an application:', appOptions);
+
+      if (!selectedApp) {
+        console.log('Connection cancelled.\n');
+        return;
+      }
+    } else {
+      selectedApp = { id: appIds[0] };
+    }
+
+    // Get nodes for selected application
+    const appNodes = nodesByApp[selectedApp.id].nodes;
+
+    // Let user select a node
+    const nodeOptions = appNodes.map((node) => ({
+      ...node,
+      name: node.name,
+      description: node.node_type || '',
+    }));
+
+    const selectedNode = await selectOption('Select a development node:', nodeOptions);
+
+    if (!selectedNode) {
+      console.log('Connection cancelled.\n');
+      return;
+    }
+
+    // Check if node is busy
+    if (selectedNode.is_connected && selectedNode.active_connection) {
+      console.log(`\nNode "${selectedNode.name}" is already connected by another user.`);
+      console.log('Please select a different node.\n');
+      return;
+    }
+
+    // Get connection info
+    const workingDirectory = options.dir || process.cwd();
+    const { gitRepoUrl, gitBranch } = getGitInfo();
+    const agentCli = options.agent || 'claude-code';
+
+    console.log(`\nConnecting to node: ${selectedNode.name}...`);
+
+    // Connect to node
+    const connectResponse = await api.connectToNode(selectedNode.id, {
+      working_directory: workingDirectory,
+      git_repo_url: gitRepoUrl,
+      git_branch: gitBranch,
+      agent_cli: agentCli,
+    });
+
+    const { connection_id, node } = connectResponse.data;
+
+    // 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: selectedNode.application_id,
+      },
+      connected_at: new Date().toISOString(),
+      working_directory: workingDirectory,
+      git_repo_url: gitRepoUrl,
+      git_branch: gitBranch,
+    });
+
+    console.log('\n┌─────────────────────────────────────────────────────────────┐');
+    console.log('│                    Connected to GBOS                        │');
+    console.log('├─────────────────────────────────────────────────────────────┤');
+    console.log(`│  Node:          ${node.name.padEnd(42)}│`);
+    console.log(`│  Connection ID: ${connection_id.substring(0, 36).padEnd(42)}│`);
+    console.log(`│  Working Dir:   ${workingDirectory.substring(0, 42).padEnd(42)}│`);
+    console.log('└─────────────────────────────────────────────────────────────┘');
+
+    console.log('\n✓ Successfully connected!\n');
+
+    // Show session info for other tools
+    console.log('Session data stored at: ~/.gbos/session.json');
+    console.log('\nEnvironment variables available:');
+    const envVars = config.getSessionEnv();
+    Object.entries(envVars).forEach(([key, value]) => {
+      if (value) {
+        console.log(`  ${key}=${value}`);
+      }
+    });
+
+    console.log('\nOther CLI tools can access this session by reading ~/.gbos/session.json');
+    console.log('or by using the GBOS MCP server.\n');
+
+  } catch (error) {
+    if (error.code === 'NODE_BUSY') {
+      console.error(`\nNode is already connected to another CLI session.\n`);
+    } else {
+      console.error(`\nConnection failed: ${error.message}\n`);
+    }
+    if (process.env.DEBUG) {
+      console.error(error);
+    }
+    process.exit(1);
+  }
+}
+
+module.exports = connectCommand;

package/src/commands/logout.js

@@ -0,0 +1,57 @@
+const api = require('../lib/api');
+const config = require('../lib/config');
+
+async function logoutCommand(options) {
+  // Check if authenticated
+  if (!config.isAuthenticated()) {
+    console.log('\nNot currently authenticated.\n');
+    return;
+  }
+
+  try {
+    const session = config.loadSession();
+
+    // Disconnect from node if connected
+    const connection = config.getConnection();
+    if (connection) {
+      console.log('Disconnecting from node...');
+      try {
+        await api.disconnect();
+      } catch (e) {
+        // Ignore disconnect errors during logout
+      }
+    }
+
+    // Call logout API
+    console.log('Logging out...');
+    try {
+      await api.logout();
+    } catch (e) {
+      // Ignore API errors - we'll clear local session anyway
+    }
+
+    // Clear local session
+    if (options.all) {
+      // Clear everything including machine ID
+      const fs = require('fs');
+      const path = require('path');
+      const configDir = config.getConfigDir();
+
+      if (fs.existsSync(configDir)) {
+        fs.rmSync(configDir, { recursive: true });
+        console.log('Cleared all GBOS data.\n');
+      }
+    } else {
+      config.clearSession();
+    }
+
+    console.log('\n✓ Successfully logged out.\n');
+
+  } catch (error) {
+    // Clear session anyway on error
+    config.clearSession();
+    console.log('\n✓ Logged out (session cleared locally).\n');
+  }
+}
+
+module.exports = logoutCommand;

package/src/lib/api.js

@@ -0,0 +1,158 @@
+const config = require('./config');
+
+const API_BASE_URL = 'https://gbos-api-579767694933.us-south1.run.app/api/v1';
+
+class GbosApiClient {
+  constructor() {
+    this.baseUrl = API_BASE_URL;
+  }
+
+  async request(endpoint, options = {}) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const headers = {
+      'Content-Type': 'application/json',
+      ...options.headers,
+    };
+
+    // Add auth header if we have a token
+    const token = config.getAccessToken();
+    if (token && !options.skipAuth) {
+      headers['Authorization'] = `Bearer ${token}`;
+    }
+
+    const response = await fetch(url, {
+      ...options,
+      headers,
+      body: options.body ? JSON.stringify(options.body) : undefined,
+    });
+
+    const data = await response.json();
+
+    if (!response.ok) {
+      const error = new Error(data.error || data.message || 'API request failed');
+      error.status = response.status;
+      error.code = data.code;
+      error.data = data;
+      throw error;
+    }
+
+    return data;
+  }
+
+  // Auth endpoints
+  async initAuth(clientInfo) {
+    const machineInfo = config.getMachineInfo();
+    return this.request('/cli/auth/init', {
+      method: 'POST',
+      body: {
+        client_name: 'gbos-cli',
+        client_version: require('../../package.json').version,
+        ...machineInfo,
+        ...clientInfo,
+      },
+      skipAuth: true,
+    });
+  }
+
+  async checkAuthStatus(verificationCode) {
+    return this.request(`/cli/auth/status/${verificationCode}`, {
+      method: 'GET',
+      skipAuth: true,
+    });
+  }
+
+  async refreshToken(refreshToken) {
+    return this.request('/cli/auth/refresh', {
+      method: 'POST',
+      body: { refresh_token: refreshToken },
+      skipAuth: true,
+    });
+  }
+
+  async logout() {
+    return this.request('/cli/auth/logout', {
+      method: 'POST',
+    });
+  }
+
+  async getSession() {
+    return this.request('/cli/auth/session', {
+      method: 'GET',
+    });
+  }
+
+  // Node endpoints
+  async listNodes(applicationId = null) {
+    let endpoint = '/cli/nodes';
+    if (applicationId) {
+      endpoint += `?application_id=${applicationId}`;
+    }
+    return this.request(endpoint, { method: 'GET' });
+  }
+
+  async connectToNode(nodeId, connectionInfo = {}) {
+    return this.request(`/cli/connect/${nodeId}`, {
+      method: 'POST',
+      body: connectionInfo,
+    });
+  }
+
+  async disconnect() {
+    return this.request('/cli/disconnect', {
+      method: 'POST',
+    });
+  }
+
+  async getConnectionStatus() {
+    return this.request('/cli/connection', {
+      method: 'GET',
+    });
+  }
+
+  async sendHeartbeat(taskId = null, progress = null) {
+    return this.request('/cli/heartbeat', {
+      method: 'POST',
+      body: {
+        current_task_id: taskId,
+        progress,
+      },
+    });
+  }
+
+  // Task endpoints
+  async getNextTask() {
+    return this.request('/cli/tasks/next', {
+      method: 'GET',
+    });
+  }
+
+  async startTask(taskId) {
+    return this.request(`/cli/tasks/${taskId}/start`, {
+      method: 'POST',
+    });
+  }
+
+  async completeTask(taskId, data = {}) {
+    return this.request(`/cli/tasks/${taskId}/complete`, {
+      method: 'POST',
+      body: data,
+    });
+  }
+
+  async failTask(taskId, data = {}) {
+    return this.request(`/cli/tasks/${taskId}/fail`, {
+      method: 'POST',
+      body: data,
+    });
+  }
+
+  // Activity logging
+  async logActivity(activity) {
+    return this.request('/cli/activity', {
+      method: 'POST',
+      body: activity,
+    });
+  }
+}
+
+module.exports = new GbosApiClient();

package/src/lib/config.js

@@ -0,0 +1,156 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_DIR = path.join(os.homedir(), '.gbos');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const SESSION_FILE = path.join(CONFIG_DIR, 'session.json');
+
+// Ensure config directory exists
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  }
+}
+
+// Get machine info for device auth
+function getMachineInfo() {
+  return {
+    machine_id: getMachineId(),
+    machine_name: os.hostname(),
+    os_type: os.platform(),
+    os_version: os.release(),
+  };
+}
+
+// Generate a persistent machine ID
+function getMachineId() {
+  ensureConfigDir();
+  const machineIdFile = path.join(CONFIG_DIR, '.machine_id');
+
+  if (fs.existsSync(machineIdFile)) {
+    return fs.readFileSync(machineIdFile, 'utf8').trim();
+  }
+
+  const machineId = `${os.hostname()}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  fs.writeFileSync(machineIdFile, machineId, { mode: 0o600 });
+  return machineId;
+}
+
+// Save session data
+function saveSession(data) {
+  ensureConfigDir();
+  const session = {
+    ...data,
+    updated_at: new Date().toISOString(),
+  };
+  fs.writeFileSync(SESSION_FILE, JSON.stringify(session, null, 2), { mode: 0o600 });
+  return session;
+}
+
+// Load session data
+function loadSession() {
+  try {
+    if (fs.existsSync(SESSION_FILE)) {
+      const data = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf8'));
+      return data;
+    }
+  } catch (err) {
+    // Ignore parse errors
+  }
+  return null;
+}
+
+// Clear session data
+function clearSession() {
+  if (fs.existsSync(SESSION_FILE)) {
+    fs.unlinkSync(SESSION_FILE);
+  }
+}
+
+// Check if authenticated
+function isAuthenticated() {
+  const session = loadSession();
+  if (!session || !session.access_token) {
+    return false;
+  }
+
+  // Check if token is expired
+  if (session.token_expires_at) {
+    const expiresAt = new Date(session.token_expires_at);
+    if (expiresAt < new Date()) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+// Get access token
+function getAccessToken() {
+  const session = loadSession();
+  return session?.access_token || null;
+}
+
+// Get current connection info
+function getConnection() {
+  const session = loadSession();
+  return session?.connection || null;
+}
+
+// Save connection info
+function saveConnection(connection) {
+  const session = loadSession() || {};
+  session.connection = connection;
+  saveSession(session);
+}
+
+// Clear connection info
+function clearConnection() {
+  const session = loadSession();
+  if (session) {
+    delete session.connection;
+    saveSession(session);
+  }
+}
+
+// Export session as environment variables format
+function getSessionEnv() {
+  const session = loadSession();
+  if (!session) return {};
+
+  return {
+    GBOS_ACCESS_TOKEN: session.access_token,
+    GBOS_ACCOUNT_ID: session.account_id,
+    GBOS_USER_ID: session.user_id,
+    GBOS_SESSION_ID: session.session_id,
+    GBOS_NODE_ID: session.connection?.node?.id,
+    GBOS_NODE_UUID: session.connection?.node?.uuid,
+    GBOS_CONNECTION_ID: session.connection?.connection_id,
+    GBOS_APPLICATION_ID: session.connection?.node?.application_id,
+  };
+}
+
+// Get config directory path (for other tools to access)
+function getConfigDir() {
+  return CONFIG_DIR;
+}
+
+module.exports = {
+  CONFIG_DIR,
+  CONFIG_FILE,
+  SESSION_FILE,
+  ensureConfigDir,
+  getMachineInfo,
+  getMachineId,
+  saveSession,
+  loadSession,
+  clearSession,
+  isAuthenticated,
+  getAccessToken,
+  getConnection,
+  saveConnection,
+  clearConnection,
+  getSessionEnv,
+  getConfigDir,
+};