gbos 1.2.0 → 1.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gbos",
-  "version": "1.2.0",
+  "version": "1.2.6",
   "description": "GBOS - Command line interface for GBOS services",
   "main": "src/index.js",
   "bin": {
@@ -39,7 +39,6 @@
   ],
   "dependencies": {
     "commander": "^12.1.0",
-    "pngjs": "^7.0.0",
-    "terminal-image": "^4.2.0"
+    "pngjs": "^7.0.0"
   }
 }

package/src/commands/connect.js

@@ -151,42 +151,75 @@ async function connectCommand(options) {
 
     console.log('\nFetching available applications...\n');
 
-    // Fetch available nodes
-    const nodesResponse = await api.listNodes();
-    const nodes = nodesResponse.data || [];
+    // Try to fetch applications directly first
+    let appOptions = [];
+    let nodesByApp = {};
+
+    try {
+      // Try the applications endpoint first
+      const appsResponse = await api.listApplications();
+      const applications = appsResponse.data || [];
+
+      if (applications.length > 0) {
+        appOptions = applications.map((app) => ({
+          id: app.id,
+          name: app.name || `Application ${app.id}`,
+          description: app.description,
+          nodeCount: app.nodes_count || app.nodesCount || '?',
+          application: app,
+        }));
+      }
+    } catch (err) {
+      // Applications endpoint not available, fall back to deriving from nodes
+      if (process.env.DEBUG) {
+        console.log('Note: /cli/applications endpoint not available, falling back to nodes');
+      }
+    }
 
-    if (nodes.length === 0) {
+    // If no applications from direct endpoint, derive from nodes
+    if (appOptions.length === 0) {
+      const nodesResponse = await api.listNodes();
+      const nodes = nodesResponse.data || [];
+
+      if (nodes.length === 0) {
+        displayMessageBox(
+          'No Nodes Available',
+          'No development nodes available. Please create a development node in the GBOS web interface.',
+          'warning'
+        );
+        process.exit(1);
+      }
+
+      // Group nodes by application
+      nodes.forEach((node) => {
+        const appId = node.application_id || 'unassigned';
+        if (nodesByApp[appId] === undefined) {
+          nodesByApp[appId] = {
+            application: node.application,
+            nodes: [],
+          };
+        }
+        nodesByApp[appId].nodes.push(node);
+      });
+
+      const appIds = Object.keys(nodesByApp);
+      appOptions = appIds.map((appId) => ({
+        id: appId,
+        name: nodesByApp[appId].application?.name || `Application ${appId}`,
+        nodeCount: nodesByApp[appId].nodes.length,
+        application: nodesByApp[appId].application,
+      }));
+    }
+
+    if (appOptions.length === 0) {
       displayMessageBox(
-        'No Nodes Available',
-        'No development nodes available. Please create a development node in the GBOS web interface.',
+        'No Applications Available',
+        'No applications found. Please create an application in the GBOS web interface.',
         'warning'
       );
       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);
-    });
-
-    const appIds = Object.keys(nodesByApp);
-
-    // Build application options
-    const appOptions = appIds.map((appId) => ({
-      id: appId,
-      name: nodesByApp[appId].application?.name || `Application ${appId}`,
-      nodeCount: nodesByApp[appId].nodes.length,
-      application: nodesByApp[appId].application,
-    }));
-
     // Always show application selection (even if only one)
     const selectedApp = await selectWithArrows(
       'Select an application:',
@@ -200,8 +233,28 @@ async function connectCommand(options) {
     }
 
     // Get nodes for selected application
-    const appNodes = nodesByApp[selectedApp.id].nodes;
-    const selectedApplication = nodesByApp[selectedApp.id].application;
+    let appNodes;
+    let selectedApplication = selectedApp.application;
+
+    if (nodesByApp[selectedApp.id]) {
+      // We already have nodes from the fallback path
+      appNodes = nodesByApp[selectedApp.id].nodes;
+      selectedApplication = nodesByApp[selectedApp.id].application || selectedApp.application;
+    } else {
+      // Fetch nodes for the selected application
+      console.log(`\nFetching nodes for ${selectedApp.name}...\n`);
+      const nodesResponse = await api.listNodes(selectedApp.id);
+      appNodes = nodesResponse.data || [];
+
+      if (appNodes.length === 0) {
+        displayMessageBox(
+          'No Nodes Available',
+          `No development nodes found for "${selectedApp.name}". Please create a development node in the GBOS web interface.`,
+          'warning'
+        );
+        return;
+      }
+    }
 
     // Build node options
     const nodeOptions = appNodes.map((node) => ({

package/src/commands/logo.js

@@ -2,14 +2,18 @@ const path = require('path');
 const { displayImage, getTerminalWidth } = require('../lib/display');
 
 async function logoCommand() {
-  const logoPath = path.join(__dirname, '../../images/logo-2.png');
+  const logoPath = path.join(__dirname, '../../images/logo.png');
   const terminalWidth = getTerminalWidth();
-  const targetWidth = Math.min(60, Math.max(30, terminalWidth - 10));
+  const targetWidth = Math.max(16, Math.floor(terminalWidth * 0.2));
 
   await displayImage(logoPath, {
     width: targetWidth,
-    fallbackWidth: 40,
-    fallbackHeight: 12,
+    fallbackWidth: targetWidth,
+    fallbackHeight: 7,
+    sharp: false,
+    crop: true,
+    alphaThreshold: 200,
+    cropAlphaThreshold: 200,
   });
 }
 

package/src/lib/api.js

@@ -81,6 +81,11 @@ class GbosApiClient {
     });
   }
 
+  // Application endpoints
+  async listApplications() {
+    return this.request('/cli/applications', { method: 'GET' });
+  }
+
   // Node endpoints
   async listNodes(applicationId = null) {
     let endpoint = '/cli/nodes';

package/src/lib/display.js

@@ -57,15 +57,18 @@ function samplePixel(png, x, y) {
 }
 
 // Check if pixel is transparent or white (background)
-function isBackground(pixel) {
-  return pixel.a < 50 || (pixel.r > 240 && pixel.g > 240 && pixel.b > 240);
+function isBackground(pixel, options = {}) {
+  const alphaThreshold = options.alphaThreshold ?? 50;
+  const backgroundLuminance = options.backgroundLuminance ?? 240;
+  return pixel.a < alphaThreshold ||
+    (pixel.r > backgroundLuminance && pixel.g > backgroundLuminance && pixel.b > backgroundLuminance);
 }
 
 // Shading characters for smooth edges (from light to full)
 const SHADE_CHARS = [' ', '░', '▒', '▓', '█'];
 
 // Get average alpha/coverage for a region (for anti-aliasing)
-function getRegionCoverage(png, startX, startY, width, height) {
+function getRegionCoverage(png, startX, startY, width, height, backgroundOptions = {}) {
   let totalAlpha = 0;
   let totalR = 0, totalG = 0, totalB = 0;
   let samples = 0;
@@ -73,7 +76,7 @@ function getRegionCoverage(png, startX, startY, width, height) {
   for (let y = startY; y < startY + height; y++) {
     for (let x = startX; x < startX + width; x++) {
       const pixel = samplePixel(png, x, y);
-      if (!isBackground(pixel)) {
+      if (!isBackground(pixel, backgroundOptions)) {
         totalAlpha += pixel.a;
         totalR += pixel.r;
         totalG += pixel.g;
@@ -94,30 +97,111 @@ function getRegionCoverage(png, startX, startY, width, height) {
   };
 }
 
-// Convert PNG to true-color pixel art with smooth edges
-// Uses shading characters for anti-aliasing on edges
-function imageToPixels(imagePath, targetWidth = 24, targetHeight = 5) {
+function cropPng(png, alphaThreshold = 1) {
+  let minX = png.width;
+  let minY = png.height;
+  let maxX = -1;
+  let maxY = -1;
+
+  for (let y = 0; y < png.height; y++) {
+    for (let x = 0; x < png.width; x++) {
+      const idx = (png.width * y + x) << 2;
+      if (png.data[idx + 3] >= alphaThreshold) {
+        minX = Math.min(minX, x);
+        minY = Math.min(minY, y);
+        maxX = Math.max(maxX, x);
+        maxY = Math.max(maxY, y);
+      }
+    }
+  }
+
+  if (maxX < minX || maxY < minY) return png;
+
+  const width = maxX - minX + 1;
+  const height = maxY - minY + 1;
+  const cropped = new PNG({ width, height });
+
+  for (let y = 0; y < height; y++) {
+    const srcStart = ((minY + y) * png.width + minX) << 2;
+    const srcEnd = srcStart + (width << 2);
+    const destStart = (width * y) << 2;
+    png.data.copy(cropped.data, destStart, srcStart, srcEnd);
+  }
+
+  return cropped;
+}
+
+// Convert PNG to true-color pixel art
+// Uses shading characters for anti-aliasing on edges when sampling coverage
+function imageToPixels(imagePath, targetWidth = 24, targetHeight = 5, options = {}) {
+  const {
+    alphaThreshold = 50,
+    backgroundLuminance = 240,
+    sampleMode = 'coverage',
+    crop = false,
+    cropAlphaThreshold = 1,
+  } = options;
+
   try {
     const data = fs.readFileSync(imagePath);
-    const png = PNG.sync.read(data);
+    let png = PNG.sync.read(data);
+    if (crop) {
+      png = cropPng(png, cropAlphaThreshold);
+    }
+
+    const resolvedWidth = Math.max(1, Math.round(targetWidth));
+    const resolvedHeight = targetHeight == null
+      ? Math.max(1, Math.round((resolvedWidth * png.height) / (png.width * 2)))
+      : Math.max(1, Math.round(targetHeight));
 
     // Each row of output = 2 rows of pixels (using half-blocks)
-    const pixelRows = targetHeight * 2;
-    const cellWidth = png.width / targetWidth;
+    const pixelRows = resolvedHeight * 2;
+    const cellWidth = png.width / resolvedWidth;
     const cellHeight = png.height / pixelRows;
+    const backgroundOptions = { alphaThreshold, backgroundLuminance };
 
     const lines = [];
 
-    for (let row = 0; row < targetHeight; row++) {
+    for (let row = 0; row < resolvedHeight; row++) {
       let line = '';
-      for (let col = 0; col < targetWidth; col++) {
+      for (let col = 0; col < resolvedWidth; col++) {
+        if (sampleMode === 'nearest') {
+          const topStartY = row * 2 * cellHeight;
+          const bottomStartY = (row * 2 + 1) * cellHeight;
+          const startX = col * cellWidth;
+
+          const topPixel = samplePixel(png, startX + cellWidth * 0.5, topStartY + cellHeight * 0.5);
+          const bottomPixel = samplePixel(png, startX + cellWidth * 0.5, bottomStartY + cellHeight * 0.5);
+          const topBg = isBackground(topPixel, backgroundOptions);
+          const bottomBg = isBackground(bottomPixel, backgroundOptions);
+
+          if (topBg && bottomBg) {
+            line += ' ';
+            continue;
+          }
+
+          if (!topBg && !bottomBg) {
+            line += fg(topPixel.r, topPixel.g, topPixel.b) +
+              bg(bottomPixel.r, bottomPixel.g, bottomPixel.b) +
+              UPPER_HALF + RESET;
+            continue;
+          }
+
+          if (!topBg) {
+            line += fg(topPixel.r, topPixel.g, topPixel.b) + UPPER_HALF + RESET;
+          } else {
+            line += fg(bottomPixel.r, bottomPixel.g, bottomPixel.b) + LOWER_HALF + RESET;
+          }
+          continue;
+        }
+
         // Get coverage for top and bottom halves of this cell
         const topStartY = row * 2 * cellHeight;
         const bottomStartY = (row * 2 + 1) * cellHeight;
         const startX = col * cellWidth;
 
-        const topRegion = getRegionCoverage(png, startX, topStartY, cellWidth, cellHeight);
-        const bottomRegion = getRegionCoverage(png, startX, bottomStartY, cellWidth, cellHeight);
+        const topRegion = getRegionCoverage(png, startX, topStartY, cellWidth, cellHeight, backgroundOptions);
+        const bottomRegion = getRegionCoverage(png, startX, bottomStartY, cellWidth, cellHeight, backgroundOptions);
 
         const topCov = topRegion.coverage;
         const bottomCov = bottomRegion.coverage;
@@ -178,29 +262,27 @@ function imageToPixels(imagePath, targetWidth = 24, targetHeight = 5) {
 }
 
 async function displayImage(imagePath, options = {}) {
-  const fallbackWidth = options.fallbackWidth || 40;
-  const fallbackHeight = options.fallbackHeight || 12;
-  const renderOptions = { ...options };
-  delete renderOptions.fallbackWidth;
-  delete renderOptions.fallbackHeight;
-
-  try {
-    const terminalImage = await import('terminal-image');
-    const renderer = terminalImage.default || terminalImage;
-    const output = await renderer.file(imagePath, renderOptions);
-    process.stdout.write(output);
-    if (!output.endsWith('\n')) process.stdout.write('\n');
-    return true;
-  } catch (error) {
-    const fallbackLines = imageToPixels(imagePath, fallbackWidth, fallbackHeight);
-    if (!fallbackLines) {
-      throw error;
-    }
-    console.log('');
-    fallbackLines.forEach((line) => console.log(line));
-    console.log('');
-    return false;
+  const width = options.fallbackWidth ?? options.width ?? 40;
+  const height = options.fallbackHeight ?? options.height ?? 12;
+  const sharp = options.sharp ?? false;
+  const alphaThreshold = options.alphaThreshold ?? 50;
+  const crop = options.crop ?? false;
+  const cropAlphaThreshold = options.cropAlphaThreshold;
+  const backgroundLuminance = options.backgroundLuminance ?? 240;
+
+  const lines = imageToPixels(imagePath, width, height, {
+    sampleMode: sharp ? 'nearest' : 'coverage',
+    alphaThreshold,
+    backgroundLuminance,
+    crop,
+    cropAlphaThreshold: cropAlphaThreshold ?? alphaThreshold,
+  });
+  if (!lines) {
+    throw new Error('Unable to render image.');
   }
+  console.log('');
+  lines.forEach((line) => console.log(line));
+  console.log('');
 }
 
 
@@ -213,20 +295,25 @@ const COMPACT_LOGO = [
 
 // Display logo with connection details (Claude Code style - clean, minimal)
 function displayLogoWithDetails(details = null) {
-  const logoPath = path.join(__dirname, '../../images/logo-2.png');
+  const logoPath = path.join(__dirname, '../../images/logo.png');
   const version = require('../../package.json').version;
 
-  // Render logo at ~20 chars wide, 5 rows tall (smooth edges)
-  let logoLines = imageToPixels(logoPath, 20, 5);
+  // Render logo at ~16 chars wide, 7 rows tall with smooth edges
+  let logoLines = imageToPixels(logoPath, 16, 7, {
+    alphaThreshold: 200,
+    crop: true,
+    cropAlphaThreshold: 200,
+    sampleMode: 'coverage',
+  });
   if (!logoLines) logoLines = COMPACT_LOGO;
 
-  const logoWidth = 28; // Account for escape codes
+  const logoWidth = 22; // Account for escape codes
 
   // Build right side - Claude Code style (clean lines, no boxes)
   const rightLines = [];
 
   if (details) {
-    rightLines.push(`${BOLD}${colors.purple5}GBOS${RESET} ${DIM}v${version}${RESET}`);
+    rightLines.push(`${BOLD}${colors.purple5}gbos.io${RESET} ${DIM}v${version}${RESET}`);
     rightLines.push(`${colors.white}${details.accountName || 'N/A'}${RESET} ${DIM}·${RESET} ${colors.purple5}${details.applicationName || 'N/A'}${RESET}`);
     rightLines.push(`${DIM}${details.nodeName || 'N/A'}${RESET}`);
   }
@@ -252,16 +339,21 @@ function displayLogo() {
 }
 
 function displayAuthSuccess(data) {
-  const logoPath = path.join(__dirname, '../../images/logo-2.png');
+  const logoPath = path.join(__dirname, '../../images/logo.png');
   const version = require('../../package.json').version;
 
-  let logoLines = imageToPixels(logoPath, 20, 5);
+  let logoLines = imageToPixels(logoPath, 16, 7, {
+    alphaThreshold: 200,
+    crop: true,
+    cropAlphaThreshold: 200,
+    sampleMode: 'coverage',
+  });
   if (!logoLines) logoLines = COMPACT_LOGO;
 
-  const logoWidth = 28;
+  const logoWidth = 22;
 
   const rightLines = [];
-  rightLines.push(`${BOLD}${colors.purple5}GBOS${RESET} ${DIM}v${version}${RESET}`);
+  rightLines.push(`${BOLD}${colors.purple5}gbos.io${RESET} ${DIM}v${version}${RESET}`);
   rightLines.push(`${colors.purple5}✓${RESET} ${colors.white}Authenticated${RESET}`);
   rightLines.push(`${colors.white}${data.userName || 'N/A'}${RESET} ${DIM}·${RESET} ${colors.purple5}${data.accountName || 'N/A'}${RESET}`);
   rightLines.push('');