gbos 1.2.0 → 1.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gbos",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "GBOS - Command line interface for GBOS services",
   "main": "src/index.js",
   "bin": {

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

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

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;
@@ -177,30 +261,90 @@ function imageToPixels(imagePath, targetWidth = 24, targetHeight = 5) {
   }
 }
 
+function applyAlphaThreshold(png, alphaThreshold) {
+  if (!alphaThreshold) return png;
+  for (let i = 0; i < png.data.length; i += 4) {
+    if (png.data[i + 3] < alphaThreshold) {
+      png.data[i + 3] = 0;
+    }
+  }
+  return png;
+}
+
+function preparePngForRender(imagePath, options = {}) {
+  const { alphaThreshold, crop, cropAlphaThreshold } = options;
+  const data = fs.readFileSync(imagePath);
+  let png = PNG.sync.read(data);
+  if (alphaThreshold) {
+    png = applyAlphaThreshold(png, alphaThreshold);
+  }
+  if (crop) {
+    png = cropPng(png, cropAlphaThreshold ?? alphaThreshold ?? 1);
+  }
+  return PNG.sync.write(png);
+}
+
 async function displayImage(imagePath, options = {}) {
-  const fallbackWidth = options.fallbackWidth || 40;
-  const fallbackHeight = options.fallbackHeight || 12;
+  const fallbackWidth = options.fallbackWidth === undefined ? 40 : options.fallbackWidth;
+  const fallbackHeight = options.fallbackHeight === undefined ? 12 : options.fallbackHeight;
+  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 useProcessedBuffer = crop || sharp;
   const renderOptions = { ...options };
   delete renderOptions.fallbackWidth;
   delete renderOptions.fallbackHeight;
+  delete renderOptions.sharp;
+  delete renderOptions.alphaThreshold;
+  delete renderOptions.crop;
+  delete renderOptions.cropAlphaThreshold;
+  delete renderOptions.backgroundLuminance;
 
   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;
+    let supportsGraphics = false;
+    try {
+      const supportsTerminalGraphics = await import('supports-terminal-graphics');
+      const graphics = supportsTerminalGraphics.default || supportsTerminalGraphics;
+      supportsGraphics = Boolean(
+        graphics?.stdout?.kitty || graphics?.stdout?.iterm2 || graphics?.stdout?.sixel,
+      );
+    } catch {
+      supportsGraphics = false;
     }
-    console.log('');
-    fallbackLines.forEach((line) => console.log(line));
-    console.log('');
-    return false;
+
+    if (supportsGraphics) {
+      const terminalImage = await import('terminal-image');
+      const renderer = terminalImage.default || terminalImage;
+      const buffer = useProcessedBuffer
+        ? preparePngForRender(imagePath, { alphaThreshold, crop, cropAlphaThreshold })
+        : null;
+      const output = buffer
+        ? await renderer.buffer(buffer, renderOptions)
+        : await renderer.file(imagePath, renderOptions);
+      process.stdout.write(output);
+      if (!output.endsWith('\n')) process.stdout.write('\n');
+      return true;
+    }
+  } catch (error) {
+    // Fall through to ANSI fallback
   }
+
+  const fallbackLines = imageToPixels(imagePath, fallbackWidth, fallbackHeight, {
+    sampleMode: sharp ? 'nearest' : 'coverage',
+    alphaThreshold,
+    backgroundLuminance,
+    crop,
+    cropAlphaThreshold: cropAlphaThreshold ?? alphaThreshold,
+  });
+  if (!fallbackLines) {
+    throw new Error('Unable to render image.');
+  }
+  console.log('');
+  fallbackLines.forEach((line) => console.log(line));
+  console.log('');
+  return false;
 }