@guildai/cli 0.11.0 → 0.12.0

package/dist/lib/auth.js

@@ -1,284 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-import { AsyncEntry } from '@napi-rs/keyring';
-import axios, { AxiosError } from 'axios';
-import chalk from 'chalk';
-import cliBoxes from 'cli-boxes';
-import inquirer from 'inquirer';
-import { handleAxiosError } from './errors.js';
-import { createSpinner } from './progress.js';
-import { getGuildcoreUrl } from './config.js';
-import { getIapHeaders } from './iap.js';
-import { brand, warn } from './colors.js';
-import { isInteractive } from './stdin.js';
-const SERVICE_NAME = 'guild-cli';
-/**
- * Get account name for keyring, keyed by host to support multiple backends
- */
-function getAccountName() {
-    const url = getGuildcoreUrl();
-    try {
-        const host = new URL(url).host;
-        return `auth-token:${host}`;
-    }
-    catch {
-        return 'auth-token';
-    }
-}
-/**
- * Display verification code in a styled box
- */
-function displayVerificationCode(code, authUrl) {
-    const box = cliBoxes.round;
-    const maxWidth = 95; // Increased to fit UUID-based device flow URLs
-    const lines = [
-        '',
-        `  ${chalk.bold('Verification code:')} ${brand.bold(code)}`,
-        '',
-        `  ${chalk.dim('Open:')} ${brand(authUrl)}`,
-        '',
-    ];
-    // Calculate box width based on longest line (accounting for ANSI codes)
-    const strippedLines = lines.map((line) => line.replace(/\x1b\[[0-9;]*m/g, ''));
-    const contentWidth = Math.max(...strippedLines.map((line) => line.length));
-    const boxWidth = Math.min(contentWidth + 4, maxWidth);
-    // Build the box
-    const horizontalLine = box.top.repeat(boxWidth - 2);
-    const topBorder = box.topLeft + horizontalLine + box.topRight;
-    const bottomBorder = box.bottomLeft + box.bottom.repeat(boxWidth - 2) + box.bottomRight;
-    console.log('\n' + chalk.dim(topBorder));
-    lines.forEach((line) => {
-        const strippedLine = line.replace(/\x1b\[[0-9;]*m/g, '');
-        const padding = ' '.repeat(Math.max(0, boxWidth - strippedLine.length - 2));
-        console.log(chalk.dim(box.left) + line + padding + chalk.dim(box.right));
-    });
-    console.log(chalk.dim(bottomBorder) + '\n');
-}
-/**
- * Save authentication token to system keyring
- */
-export async function saveAuthToken(token) {
-    const entry = new AsyncEntry(SERVICE_NAME, getAccountName());
-    await entry.setPassword(token);
-}
-/**
- * Get authentication token from system keyring or state file
- * Returns null if no token is stored
- *
- * In test environments, checks GUILD_STATE_DIR/auth-state.json ONLY (no fallback)
- * In production, checks system keyring
- */
-export async function getAuthToken() {
-    // Check for token in state directory (used by E2E tests)
-    const stateDir = process.env.GUILD_STATE_DIR;
-    if (stateDir) {
-        try {
-            const fs = await import('fs/promises');
-            const path = await import('path');
-            const authStatePath = path.join(stateDir, 'auth-state.json');
-            const authStateContent = await fs.readFile(authStatePath, 'utf-8');
-            const authState = JSON.parse(authStateContent);
-            if (authState.token && authState.authenticated) {
-                return authState.token;
-            }
-        }
-        catch {
-            // In test mode (GUILD_STATE_DIR set), do NOT fall back to keyring
-            // This ensures test isolation - tests must explicitly authenticate
-            return null;
-        }
-        return null;
-    }
-    // Check system keyring (production use)
-    try {
-        const entry = new AsyncEntry(SERVICE_NAME, getAccountName());
-        const token = await entry.getPassword();
-        return token || null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Clear authentication token from system keyring
- */
-export async function clearAuthToken() {
-    try {
-        const entry = new AsyncEntry(SERVICE_NAME, getAccountName());
-        await entry.deletePassword();
-    }
-    catch {
-        // Ignore if token doesn't exist
-    }
-}
-/**
- * Start OAuth device flow
- * @param authUrl - Base URL of the OAuth provider (guildcore)
- * @param returnUrl - Optional custom URL to redirect to after authentication
- * @param returnLabel - Optional friendly label for return button (e.g., "VSCode")
- * @returns Device code response with verification URL and code
- */
-export async function startDeviceFlow(authUrl = getGuildcoreUrl(), returnUrl, returnLabel) {
-    const requestBody = {};
-    if (returnUrl) {
-        requestBody.return_url = returnUrl;
-    }
-    if (returnLabel) {
-        requestBody.return_label = returnLabel;
-    }
-    // Get IAP headers for IAP-protected hosts
-    const iapHeaders = await getIapHeaders(authUrl);
-    const response = await axios.post(`${authUrl}/oauth/device/initiate`, requestBody, { headers: iapHeaders });
-    return response.data;
-}
-/**
- * Poll for OAuth token
- * @param authUrl - Base URL of the OAuth provider (guildcore)
- * @param code - Device code from startDeviceFlow
- * @returns Access token if successful, null if failed/expired
- */
-export async function pollForToken(authUrl, code, interval) {
-    const isTTY = process.stderr.isTTY || false;
-    const spinner = createSpinner('Waiting for authorization...');
-    spinner.start();
-    const maxAttempts = 90; // 3 minutes (90 * 2 seconds)
-    let attempts = 0;
-    // Get IAP headers for IAP-protected hosts (fetch once, reuse for all polls)
-    const iapHeaders = await getIapHeaders(authUrl);
-    while (attempts < maxAttempts) {
-        attempts++;
-        await new Promise((resolve) => setTimeout(resolve, interval * 1000));
-        try {
-            const response = await axios.post(`${authUrl}/oauth/device/token`, {
-                grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
-                device_code: code,
-            }, { headers: iapHeaders });
-            if (response.data.access_token) {
-                spinner.succeed('Authorization successful!');
-                return response.data.access_token;
-            }
-            else {
-                spinner.fail('Missing access token');
-                return null;
-            }
-        }
-        catch (error) {
-            if (error instanceof AxiosError && error.status === 400) {
-                if (error.response?.data?.error === 'slow_down') {
-                    interval += 5;
-                }
-                if (error.response?.data?.error === 'authorization_pending' ||
-                    error.response?.data?.error === 'slow_down') {
-                    if (isTTY) {
-                        spinner.text = `Waiting for authorization... (${attempts}/${maxAttempts})`;
-                    }
-                    continue;
-                }
-            }
-            spinner.fail('Authorization polling failed');
-            const formattedError = handleAxiosError(error);
-            console.error(chalk.red('\nError:'), formattedError.error);
-            console.error(warn(formattedError.details));
-            throw error;
-        }
-    }
-    spinner.fail('Authorization timed out');
-    return null;
-}
-/**
- * Perform complete login flow
- * @param returnUrl - Optional custom URL to redirect to after authentication
- * @param returnLabel - Optional friendly label for return button (e.g., "VSCode")
- * @returns true if successful, false otherwise
- */
-export async function login(returnUrl, returnLabel) {
-    const authUrl = getGuildcoreUrl();
-    try {
-        console.log(chalk.bold('\nGuild.ai Authentication'));
-        const deviceCode = await startDeviceFlow(authUrl, returnUrl, returnLabel);
-        const skipBrowser = !isInteractive();
-        if (skipBrowser) {
-            console.log(`\nVerification code: ${deviceCode.user_code}`);
-            console.log(`Open to authenticate: ${deviceCode.verification_uri_complete}\n`);
-        }
-        else {
-            displayVerificationCode(deviceCode.user_code, deviceCode.verification_uri_complete);
-            // Wait for user to press Enter before opening browser
-            // This gives them time to see and copy the code before browser opens
-            // Critical for VSCode integration where browser may open full screen
-            const { openBrowser } = await inquirer.prompt([
-                {
-                    type: 'confirm',
-                    name: 'openBrowser',
-                    message: 'Press Enter to open browser in your default web browser...',
-                    default: true,
-                },
-            ]);
-            if (!openBrowser) {
-                console.error(chalk.red('✗ Authentication cancelled by user'));
-                return false;
-            }
-            // Open URL in default browser after user confirmation
-            try {
-                const open = (await import('open')).default;
-                await open(deviceCode.verification_uri_complete);
-            }
-            catch {
-                // Fallback if open fails - user can manually open URL
-                console.log(chalk.red('✗ Could not open browser automatically. Please visit the URL manually.\n'));
-            }
-        }
-        const token = await pollForToken(authUrl, deviceCode.device_code, deviceCode.interval);
-        if (token) {
-            await saveAuthToken(token);
-            return true;
-        }
-        return false;
-    }
-    catch (error) {
-        console.log(''); // Blank line for spacing
-        const formattedError = handleAxiosError(error);
-        console.error(chalk.red('✗ Authentication failed'));
-        console.error(warn(`\nError: ${formattedError.error}`));
-        console.error(chalk.dim(formattedError.details));
-        if (formattedError.code) {
-            console.error(chalk.dim(`\nError code: ${formattedError.code}`));
-        }
-        return false;
-    }
-}
-/**
- * Perform logout
- */
-export async function logout() {
-    await clearAuthToken();
-    console.log(chalk.green('\n✓ Logged out successfully\n'));
-}
-/**
- * Get current authentication status
- * @returns Object with authenticated flag and optional token
- */
-export async function getAuthStatus() {
-    const token = await getAuthToken();
-    return {
-        authenticated: !!token,
-        token: token || undefined,
-    };
-}
-/**
- * Create an authenticated URL by embedding the auth token.
- * Used for operations requiring x-access-token authentication.
- * @param targetUrl - The URL to authenticate
- * @returns URL with x-access-token credentials embedded, or null if not authenticated
- */
-export async function getAuthenticatedUrl(targetUrl) {
-    const token = await getAuthToken();
-    if (!token) {
-        return null;
-    }
-    const url = new URL(targetUrl);
-    url.username = 'x-access-token';
-    url.password = token;
-    return url.toString();
-}
-//# sourceMappingURL=auth.js.map

package/dist/lib/braille-canvas.js

@@ -1,321 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Braille Canvas - A tiny pixel canvas using Unicode braille characters
- *
- * Each braille character represents a 2x4 pixel grid (8 dots total).
- * Multiple characters side-by-side create a wider canvas.
- *
- * Braille dot positions:
- *   1 4
- *   2 5
- *   3 6
- *   7 8
- *
- * Unicode encoding: U+2800 + bit pattern
- *   dot1=0x01, dot2=0x02, dot3=0x04, dot4=0x08
- *   dot5=0x10, dot6=0x20, dot7=0x40, dot8=0x80
- */
-import chalk from 'chalk';
-// Braille base character (blank)
-const BRAILLE_BASE = 0x2800;
-// Dot bit positions indexed by (x, y) where x is 0-1, y is 0-3
-const DOT_BITS = [
-    [0x01, 0x08], // y=0: dot1, dot4
-    [0x02, 0x10], // y=1: dot2, dot5
-    [0x04, 0x20], // y=2: dot3, dot6
-    [0x40, 0x80], // y=3: dot7, dot8
-];
-/**
- * A braille-based pixel canvas
- *
- * Canvas dimensions are in "pixels" (dots), internally stored as braille chars.
- * Width should be even (each braille char is 2 pixels wide).
- * Height should be multiple of 4 (each braille char is 4 pixels tall).
- */
-export class BrailleCanvas {
-    width; // Width in pixels (dots)
-    height; // Height in pixels (dots)
-    charWidth; // Width in braille characters
-    charHeight; // Height in braille characters
-    pixels; // 2D array of pixel states
-    colors; // Color per braille character cell
-    constructor(width, height) {
-        // Round up to braille character boundaries
-        this.charWidth = Math.ceil(width / 2);
-        this.charHeight = Math.ceil(height / 4);
-        this.width = this.charWidth * 2;
-        this.height = this.charHeight * 4;
-        // Initialize pixel array (all off)
-        this.pixels = Array(this.height)
-            .fill(null)
-            .map(() => Array(this.width).fill(false));
-        // Initialize colors (default: no color override)
-        this.colors = Array(this.charHeight)
-            .fill(null)
-            .map(() => Array(this.charWidth)
-            .fill(null)
-            .map(() => ({})));
-    }
-    /**
-     * Clear the canvas
-     */
-    clear() {
-        for (let y = 0; y < this.height; y++) {
-            for (let x = 0; x < this.width; x++) {
-                this.pixels[y][x] = false;
-            }
-        }
-        for (let cy = 0; cy < this.charHeight; cy++) {
-            for (let cx = 0; cx < this.charWidth; cx++) {
-                this.colors[cy][cx] = {};
-            }
-        }
-    }
-    /**
-     * Set a single pixel
-     */
-    setPixel(x, y, on = true) {
-        if (x >= 0 && x < this.width && y >= 0 && y < this.height) {
-            this.pixels[y][x] = on;
-        }
-    }
-    /**
-     * Get a pixel value
-     */
-    getPixel(x, y) {
-        if (x >= 0 && x < this.width && y >= 0 && y < this.height) {
-            return this.pixels[y][x];
-        }
-        return false;
-    }
-    /**
-     * Set color for a braille character cell
-     * @param cx - Character x position (0 to charWidth-1)
-     * @param cy - Character y position (0 to charHeight-1)
-     * @param color - Color specification
-     */
-    setCellColor(cx, cy, color) {
-        if (cx >= 0 && cx < this.charWidth && cy >= 0 && cy < this.charHeight) {
-            this.colors[cy][cx] = color;
-        }
-    }
-    /**
-     * Set color for a pixel (affects the containing braille cell)
-     */
-    setPixelColor(x, y, color) {
-        const cx = Math.floor(x / 2);
-        const cy = Math.floor(y / 4);
-        this.setCellColor(cx, cy, color);
-    }
-    /**
-     * Draw a line using Bresenham's algorithm
-     */
-    drawLine(x0, y0, x1, y1) {
-        const dx = Math.abs(x1 - x0);
-        const dy = Math.abs(y1 - y0);
-        const sx = x0 < x1 ? 1 : -1;
-        const sy = y0 < y1 ? 1 : -1;
-        let err = dx - dy;
-        let x = x0;
-        let y = y0;
-        while (true) {
-            this.setPixel(x, y, true);
-            if (x === x1 && y === y1)
-                break;
-            const e2 = 2 * err;
-            if (e2 > -dy) {
-                err -= dy;
-                x += sx;
-            }
-            if (e2 < dx) {
-                err += dx;
-                y += sy;
-            }
-        }
-    }
-    /**
-     * Draw a filled rectangle
-     */
-    fillRect(x, y, w, h) {
-        for (let py = y; py < y + h; py++) {
-            for (let px = x; px < x + w; px++) {
-                this.setPixel(px, py, true);
-            }
-        }
-    }
-    /**
-     * Draw a circle outline
-     */
-    drawCircle(cx, cy, r) {
-        let x = r;
-        let y = 0;
-        let err = 0;
-        while (x >= y) {
-            this.setPixel(cx + x, cy + y, true);
-            this.setPixel(cx + y, cy + x, true);
-            this.setPixel(cx - y, cy + x, true);
-            this.setPixel(cx - x, cy + y, true);
-            this.setPixel(cx - x, cy - y, true);
-            this.setPixel(cx - y, cy - x, true);
-            this.setPixel(cx + y, cy - x, true);
-            this.setPixel(cx + x, cy - y, true);
-            y += 1;
-            err += 1 + 2 * y;
-            if (2 * (err - x) + 1 > 0) {
-                x -= 1;
-                err += 1 - 2 * x;
-            }
-        }
-    }
-    /**
-     * Convert canvas to a single row of braille characters with colors
-     * Returns an array of cells, one per braille character
-     */
-    toCells() {
-        const result = [];
-        for (let cy = 0; cy < this.charHeight; cy++) {
-            const row = [];
-            for (let cx = 0; cx < this.charWidth; cx++) {
-                // Calculate braille character for this 2x4 cell
-                let bits = 0;
-                const px = cx * 2;
-                const py = cy * 4;
-                for (let dy = 0; dy < 4; dy++) {
-                    for (let dx = 0; dx < 2; dx++) {
-                        if (this.getPixel(px + dx, py + dy)) {
-                            bits |= DOT_BITS[dy][dx];
-                        }
-                    }
-                }
-                row.push({
-                    char: String.fromCharCode(BRAILLE_BASE + bits),
-                    color: this.colors[cy][cx],
-                });
-            }
-            result.push(row);
-        }
-        return result;
-    }
-    /**
-     * Render canvas to a string with ANSI colors
-     */
-    render() {
-        const cells = this.toCells();
-        const lines = [];
-        for (const row of cells) {
-            let line = '';
-            for (const cell of row) {
-                let colored = cell.char;
-                if (cell.color.fg || cell.color.bg) {
-                    let colorFn = chalk;
-                    if (cell.color.fg) {
-                        if (cell.color.fg.startsWith('#')) {
-                            colorFn = colorFn.hex(cell.color.fg);
-                        }
-                        else {
-                            // Try to use named color
-                            const colorName = cell.color.fg;
-                            if (typeof chalk[colorName] === 'function') {
-                                colorFn = chalk[colorName];
-                            }
-                        }
-                    }
-                    if (cell.color.bg) {
-                        if (cell.color.bg.startsWith('#')) {
-                            colorFn = colorFn.bgHex(cell.color.bg);
-                        }
-                        else {
-                            // Try to use named background color
-                            const bgName = `bg${cell.color.bg.charAt(0).toUpperCase()}${cell.color.bg.slice(1)}`;
-                            if (typeof chalk[bgName] === 'function') {
-                                colorFn = chalk[bgName];
-                            }
-                        }
-                    }
-                    colored = colorFn(cell.char);
-                }
-                line += colored;
-            }
-            lines.push(line);
-        }
-        return lines.join('\n');
-    }
-    /**
-     * Render to a single line (for single-row canvases)
-     */
-    renderLine() {
-        const cells = this.toCells();
-        if (cells.length === 0)
-            return '';
-        let line = '';
-        for (const cell of cells[0]) {
-            let colored = cell.char;
-            if (cell.color.fg || cell.color.bg) {
-                let colorFn = chalk;
-                if (cell.color.fg) {
-                    if (cell.color.fg.startsWith('#')) {
-                        colorFn = colorFn.hex(cell.color.fg);
-                    }
-                    else {
-                        const colorName = cell.color.fg;
-                        if (typeof chalk[colorName] === 'function') {
-                            colorFn = chalk[colorName];
-                        }
-                    }
-                }
-                if (cell.color.bg) {
-                    if (cell.color.bg.startsWith('#')) {
-                        colorFn = colorFn.bgHex(cell.color.bg);
-                    }
-                    else {
-                        const bgName = `bg${cell.color.bg.charAt(0).toUpperCase()}${cell.color.bg.slice(1)}`;
-                        if (typeof chalk[bgName] === 'function') {
-                            colorFn = chalk[bgName];
-                        }
-                    }
-                }
-                colored = colorFn(cell.char);
-            }
-            line += colored;
-        }
-        return line;
-    }
-    /**
-     * Get canvas dimensions
-     */
-    getWidth() {
-        return this.width;
-    }
-    getHeight() {
-        return this.height;
-    }
-    getCharWidth() {
-        return this.charWidth;
-    }
-    getCharHeight() {
-        return this.charHeight;
-    }
-}
-/**
- * Create a simple braille character from an 8-bit pattern
- */
-export function brailleFromBits(bits) {
-    return String.fromCharCode(BRAILLE_BASE + (bits & 0xff));
-}
-/**
- * Create a braille character from a 2x4 boolean array
- * array[y][x] where y is 0-3, x is 0-1
- */
-export function brailleFromArray(dots) {
-    let bits = 0;
-    for (let y = 0; y < 4 && y < dots.length; y++) {
-        for (let x = 0; x < 2 && x < (dots[y]?.length || 0); x++) {
-            if (dots[y][x]) {
-                bits |= DOT_BITS[y][x];
-            }
-        }
-    }
-    return String.fromCharCode(BRAILLE_BASE + bits);
-}
-//# sourceMappingURL=braille-canvas.js.map

package/dist/lib/colors.js

@@ -1,46 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Guild brand colors for CLI output
- */
-import chalk from 'chalk';
-/**
- * Brand accent color - muted cyan (complement of rust orange)
- * rgb(62, 166, 196) - visible on dark terminals while staying on-brand
- */
-// export const BRAND_COLOR = '#3ea6c4';
-export const BRAND_COLOR = '#c6541e';
-/**
- * Chalk instance for brand-colored text
- */
-export const brand = chalk.hex(BRAND_COLOR);
-/**
- * Warning/highlight color - readable on both light and dark terminals.
- * Replaces chalk.yellow which is invisible on light backgrounds.
- */
-export const warn = chalk.hex('#b8860b');
-/**
- * Inline code color - readable on both light and dark terminals.
- * Replaces chalk.yellow for code highlighting.
- */
-export const code = chalk.hex('#b8860b');
-/**
- * Wrap text in an OSC8 terminal hyperlink.
- *
- * In supported terminals (iTerm2, VS Code, Windows Terminal, etc.),
- * the text becomes clickable. Falls back to plain text when:
- * - Output is piped (non-TTY)
- * - FORCE_HYPERLINK=0
- *
- * Set FORCE_HYPERLINK=1 to force hyperlinks even in non-TTY.
- */
-export function hyperlink(text, url) {
-    const force = process.env.FORCE_HYPERLINK;
-    if (force === '0')
-        return text;
-    const supported = force === '1' || process.stderr.isTTY;
-    if (!supported)
-        return text;
-    return `\x1b]8;;${url}\x1b\\${text}\x1b]8;;\x1b\\`;
-}
-//# sourceMappingURL=colors.js.map

package/dist/lib/config-cache.js

@@ -1,45 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Synchronous config cache for early-init flags (debug, json, quiet).
- *
- * isDebugMode(), getOutputMode(), and isQuietMode() are sync functions
- * called before any async init can run. This module reads
- * ~/.guild/config.json synchronously and caches the result.
- *
- * Path logic is duplicated from guild-config.ts to avoid circular
- * imports (guild-config.ts → errors.ts → config-cache.ts → guild-config.ts).
- */
-import { readFileSync, existsSync } from 'fs';
-import path from 'path';
-import os from 'os';
-let cached = null;
-function loadSync() {
-    if (cached !== null)
-        return cached;
-    const configPath = path.join(os.homedir(), '.guild', 'config.json');
-    if (!existsSync(configPath)) {
-        cached = {};
-        return cached;
-    }
-    try {
-        const content = readFileSync(configPath, 'utf-8');
-        const parsed = JSON.parse(content);
-        cached = {
-            debug: parsed.debug === true,
-            json: parsed.json === true,
-            quiet: parsed.quiet === true,
-        };
-    }
-    catch {
-        cached = {};
-    }
-    return cached;
-}
-/**
- * Get a boolean config flag from ~/.guild/config.json (sync, cached).
- */
-export function getConfigFlag(key) {
-    return loadSync()[key] === true;
-}
-//# sourceMappingURL=config-cache.js.map