gemkit-cli 0.2.3 → 0.3.0

package/dist/services/logger.js

@@ -0,0 +1,102 @@
+/**
+ * Logging service for GemKit CLI
+ */
+import { brand } from '../utils/colors.js';
+const LOG_LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+    silent: 4,
+};
+let config = {
+    level: 'info',
+    verbose: false,
+    json: false,
+};
+export function configureLogger(options) {
+    config = { ...config, ...options };
+}
+function shouldLog(level) {
+    return LOG_LEVELS[level] >= LOG_LEVELS[config.level];
+}
+export function debug(message, data) {
+    if (!shouldLog('debug'))
+        return;
+    if (config.json) {
+        console.log(JSON.stringify({ level: 'debug', message, data }));
+    }
+    else {
+        console.log(brand.dim(`[DEBUG] ${message}`));
+        if (data && config.verbose) {
+            console.log(brand.dim(JSON.stringify(data, null, 2)));
+        }
+    }
+}
+export function info(message, data) {
+    if (!shouldLog('info'))
+        return;
+    if (config.json) {
+        console.log(JSON.stringify({ level: 'info', message, data }));
+    }
+    else {
+        console.log(`${brand.info('ℹ')} ${message}`);
+        if (data && config.verbose) {
+            console.log(JSON.stringify(data, null, 2));
+        }
+    }
+}
+export function success(message, data) {
+    if (!shouldLog('info'))
+        return;
+    if (config.json) {
+        console.log(JSON.stringify({ level: 'success', message, data }));
+    }
+    else {
+        console.log(`${brand.success('✓')} ${message}`);
+    }
+}
+export function warn(message, data) {
+    if (!shouldLog('warn'))
+        return;
+    if (config.json) {
+        console.log(JSON.stringify({ level: 'warn', message, data }));
+    }
+    else {
+        console.log(`${brand.warn('⚠')} ${message}`);
+    }
+}
+export function error(message, data) {
+    if (!shouldLog('error'))
+        return;
+    if (config.json) {
+        console.error(JSON.stringify({ level: 'error', message, data }));
+    }
+    else {
+        console.error(`${brand.error('✗')} ${message}`);
+        if (data && config.verbose) {
+            console.error(JSON.stringify(data, null, 2));
+        }
+    }
+}
+export function table(data) {
+    if (config.json) {
+        console.log(JSON.stringify(data));
+    }
+    else {
+        console.table(data);
+    }
+}
+export function json(data) {
+    console.log(JSON.stringify(data, null, 2));
+}
+export const logger = {
+    debug,
+    info,
+    success,
+    warn,
+    error,
+    table,
+    json,
+    configure: configureLogger,
+};

package/dist/services/music.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Elevator Music Player - Cross-platform background audio for long-running processes
+ * Supports: Windows (PowerShell), Mac (afplay), Linux (aplay/paplay)
+ */
+export interface ElevatorMusicOptions {
+    audioFile?: string;
+    loop?: boolean;
+    volume?: number;
+}
+export declare class ElevatorMusic {
+    private audioFile;
+    private loop;
+    private volume;
+    private process;
+    private isPlaying;
+    private loopInterval;
+    private hasLock;
+    private lockRefreshInterval;
+    private triedFallback;
+    constructor(options?: ElevatorMusicOptions);
+    /**
+     * Try to acquire the global music lock
+     */
+    private tryAcquireLock;
+    /**
+     * Try to take over a potentially stale lock
+     */
+    private tryTakeStaleLock;
+    /**
+     * Refresh the lock timestamp
+     */
+    private refreshLock;
+    /**
+     * Release the global music lock
+     */
+    private releaseLock;
+    /**
+     * Get default audio file path
+     */
+    private getDefaultAudioFile;
+    /**
+     * Get platform-specific play command
+     */
+    private getPlayCommand;
+    /**
+     * Start playing music
+     */
+    start(options?: {
+        force?: boolean;
+    }): boolean;
+    /**
+     * Internal loop handler
+     */
+    private playLoop;
+    /**
+     * Stop playing music
+     */
+    stop(): void;
+    /**
+     * Check if currently playing
+     */
+    get playing(): boolean;
+    /**
+     * Static method to check if any instance is currently playing
+     */
+    static isAnyPlaying(): boolean;
+}

package/dist/services/music.js

@@ -0,0 +1,290 @@
+/**
+ * Elevator Music Player - Cross-platform background audio for long-running processes
+ * Supports: Windows (PowerShell), Mac (afplay), Linux (aplay/paplay)
+ */
+import { spawn, exec } from 'child_process';
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { tmpdir, platform } from 'os';
+// Global lock file path for cross-process coordination
+const LOCK_FILE = join(tmpdir(), 'elevator-music.lock');
+const LOCK_STALE_MS = 30000; // Consider lock stale after 30 seconds
+export class ElevatorMusic {
+    audioFile;
+    loop;
+    volume;
+    process = null;
+    isPlaying = false;
+    loopInterval = null;
+    hasLock = false;
+    lockRefreshInterval = null;
+    triedFallback = false;
+    constructor(options = {}) {
+        this.audioFile = options.audioFile || this.getDefaultAudioFile();
+        this.loop = options.loop !== false; // Default to looping
+        this.volume = options.volume || 0.5; // 0.0 to 1.0
+    }
+    /**
+     * Try to acquire the global music lock
+     */
+    tryAcquireLock() {
+        const lockData = {
+            pid: process.pid,
+            timestamp: Date.now()
+        };
+        try {
+            writeFileSync(LOCK_FILE, JSON.stringify(lockData), { flag: 'wx' });
+            this.hasLock = true;
+            this.lockRefreshInterval = setInterval(() => {
+                this.refreshLock();
+            }, LOCK_STALE_MS / 3);
+            return true;
+        }
+        catch (err) {
+            if (err.code === 'EEXIST') {
+                return this.tryTakeStaleLock(lockData);
+            }
+            return false;
+        }
+    }
+    /**
+     * Try to take over a potentially stale lock
+     */
+    tryTakeStaleLock(newLockData) {
+        try {
+            const existingLock = JSON.parse(readFileSync(LOCK_FILE, 'utf8'));
+            const lockAge = Date.now() - existingLock.timestamp;
+            if (lockAge < LOCK_STALE_MS && existingLock.pid !== process.pid) {
+                try {
+                    process.kill(existingLock.pid, 0);
+                    return false;
+                }
+                catch {
+                    // Process doesn't exist, lock is stale
+                }
+            }
+            unlinkSync(LOCK_FILE);
+            try {
+                writeFileSync(LOCK_FILE, JSON.stringify(newLockData), { flag: 'wx' });
+                this.hasLock = true;
+                this.lockRefreshInterval = setInterval(() => {
+                    this.refreshLock();
+                }, LOCK_STALE_MS / 3);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Refresh the lock timestamp
+     */
+    refreshLock() {
+        if (!this.hasLock)
+            return;
+        try {
+            const lockData = {
+                pid: process.pid,
+                timestamp: Date.now()
+            };
+            writeFileSync(LOCK_FILE, JSON.stringify(lockData), { flag: 'w' });
+        }
+        catch {
+            // Ignore refresh errors
+        }
+    }
+    /**
+     * Release the global music lock
+     */
+    releaseLock() {
+        if (this.lockRefreshInterval) {
+            clearInterval(this.lockRefreshInterval);
+            this.lockRefreshInterval = null;
+        }
+        if (!this.hasLock)
+            return;
+        try {
+            if (existsSync(LOCK_FILE)) {
+                const lockData = JSON.parse(readFileSync(LOCK_FILE, 'utf8'));
+                if (lockData.pid === process.pid) {
+                    unlinkSync(LOCK_FILE);
+                }
+            }
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+        this.hasLock = false;
+    }
+    /**
+     * Get default audio file path
+     */
+    getDefaultAudioFile() {
+        // Check common locations for audio file
+        const searchPaths = [
+            join(process.cwd(), '.gemini', 'extensions', 'spawn-agent', 'assets', 'golden-coast-melody.wav'),
+            join(process.cwd(), '.gemini', 'assets', 'elevator_music.wav'),
+            join(process.cwd(), 'assets', 'elevator_music.wav'),
+        ];
+        for (const p of searchPaths) {
+            if (existsSync(p)) {
+                return p;
+            }
+        }
+        return null;
+    }
+    /**
+     * Get platform-specific play command
+     */
+    getPlayCommand() {
+        if (!this.audioFile)
+            return null;
+        const plat = platform();
+        switch (plat) {
+            case 'win32':
+                return {
+                    command: 'powershell',
+                    args: [
+                        '-NoProfile',
+                        '-Command',
+                        `$player = New-Object System.Media.SoundPlayer '${this.audioFile}'; $player.PlaySync()`
+                    ],
+                    shell: false
+                };
+            case 'darwin':
+                return {
+                    command: 'afplay',
+                    args: ['-v', String(this.volume), this.audioFile],
+                    shell: false
+                };
+            case 'linux':
+                return {
+                    command: 'paplay',
+                    args: ['--volume', String(Math.round(this.volume * 65536)), this.audioFile],
+                    shell: false,
+                    fallback: {
+                        command: 'aplay',
+                        args: ['-q', this.audioFile],
+                        shell: false
+                    }
+                };
+            default:
+                return null;
+        }
+    }
+    /**
+     * Start playing music
+     */
+    start(options = {}) {
+        if (!this.audioFile) {
+            return false;
+        }
+        if (!existsSync(this.audioFile)) {
+            return false;
+        }
+        if (this.isPlaying) {
+            return true;
+        }
+        if (!options.force && !this.tryAcquireLock()) {
+            return false;
+        }
+        const playConfig = this.getPlayCommand();
+        if (!playConfig) {
+            this.releaseLock();
+            return false;
+        }
+        this.isPlaying = true;
+        this.playLoop(playConfig);
+        return true;
+    }
+    /**
+     * Internal loop handler
+     */
+    playLoop(playConfig) {
+        if (!this.isPlaying)
+            return;
+        const startPlay = (config) => {
+            this.process = spawn(config.command, config.args, {
+                stdio: ['ignore', 'ignore', 'pipe'],
+                windowsHide: true,
+                shell: config.shell
+            });
+            this.process.stderr?.on('data', () => {
+                if (config.fallback && !this.triedFallback) {
+                    this.triedFallback = true;
+                    this.process?.kill();
+                    startPlay(config.fallback);
+                }
+            });
+            this.process.on('close', () => {
+                if (this.isPlaying && this.loop) {
+                    this.loopInterval = setTimeout(() => {
+                        this.playLoop(playConfig);
+                    }, 100);
+                }
+            });
+            this.process.on('error', () => {
+                if (config.fallback && !this.triedFallback) {
+                    this.triedFallback = true;
+                    startPlay(config.fallback);
+                }
+            });
+        };
+        startPlay(playConfig);
+    }
+    /**
+     * Stop playing music
+     */
+    stop() {
+        this.isPlaying = false;
+        if (this.loopInterval) {
+            clearTimeout(this.loopInterval);
+            this.loopInterval = null;
+        }
+        if (this.process) {
+            if (platform() === 'win32') {
+                exec(`taskkill /pid ${this.process.pid} /T /F`, { windowsHide: true });
+            }
+            else {
+                this.process.kill('SIGTERM');
+            }
+            this.process = null;
+        }
+        this.releaseLock();
+    }
+    /**
+     * Check if currently playing
+     */
+    get playing() {
+        return this.isPlaying;
+    }
+    /**
+     * Static method to check if any instance is currently playing
+     */
+    static isAnyPlaying() {
+        try {
+            if (!existsSync(LOCK_FILE)) {
+                return false;
+            }
+            const lockData = JSON.parse(readFileSync(LOCK_FILE, 'utf8'));
+            const lockAge = Date.now() - lockData.timestamp;
+            if (lockAge >= LOCK_STALE_MS) {
+                return false;
+            }
+            try {
+                process.kill(lockData.pid, 0);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/services/npm.d.ts

@@ -0,0 +1,22 @@
+/**
+ * NPM Registry service - Check package versions
+ */
+export interface NpmPackageInfo {
+    name: string;
+    version: string;
+    description?: string;
+    publishedAt?: string;
+}
+/**
+ * Get latest version of a package from npm registry
+ */
+export declare function getLatestNpmVersion(packageName: string): Promise<NpmPackageInfo | null>;
+/**
+ * Compare two semver versions
+ * Returns: 1 if a > b, -1 if a < b, 0 if equal
+ */
+export declare function compareVersions(a: string, b: string): number;
+/**
+ * Check if update is available
+ */
+export declare function isUpdateAvailable(current: string, latest: string): boolean;

package/dist/services/npm.js

@@ -0,0 +1,65 @@
+/**
+ * NPM Registry service - Check package versions
+ */
+import { getCache, setCache } from '../domains/cache/manager.js';
+const NPM_REGISTRY = 'https://registry.npmjs.org';
+const CACHE_KEY = 'npm-version';
+const CACHE_TTL = 3600; // 1 hour
+/**
+ * Get latest version of a package from npm registry
+ */
+export async function getLatestNpmVersion(packageName) {
+    const cacheKey = `${CACHE_KEY}-${packageName}`;
+    // Check cache first
+    const cached = getCache(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    try {
+        const response = await fetch(`${NPM_REGISTRY}/${packageName}/latest`, {
+            headers: {
+                'Accept': 'application/json',
+                'User-Agent': 'gemkit-cli',
+            },
+        });
+        if (!response.ok) {
+            return null;
+        }
+        const data = await response.json();
+        const info = {
+            name: data.name,
+            version: data.version,
+            description: data.description,
+            publishedAt: data.time?.[data.version],
+        };
+        // Cache result
+        setCache(cacheKey, info, CACHE_TTL);
+        return info;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Compare two semver versions
+ * Returns: 1 if a > b, -1 if a < b, 0 if equal
+ */
+export function compareVersions(a, b) {
+    const partsA = a.replace(/^v/, '').split('.').map(Number);
+    const partsB = b.replace(/^v/, '').split('.').map(Number);
+    for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+        const numA = partsA[i] || 0;
+        const numB = partsB[i] || 0;
+        if (numA > numB)
+            return 1;
+        if (numA < numB)
+            return -1;
+    }
+    return 0;
+}
+/**
+ * Check if update is available
+ */
+export function isUpdateAvailable(current, latest) {
+    return compareVersions(latest, current) > 0;
+}

package/dist/services/pty-client.d.ts

@@ -0,0 +1,66 @@
+/**
+ * PTY Client - Sends commands to the PTY server
+ * Ported from claude-pty-wrapper/client.js
+ */
+import type { PtyExchange, PtyServerStatus, PtySendResponse, PtyCompleteResponse, PtyPendingResponse } from '../domains/agent/pty-types.js';
+export declare class PtyClient {
+    private port;
+    private host;
+    constructor(port?: number, host?: string);
+    /**
+     * Send command to server and get response
+     */
+    sendCommand(command: string): Promise<string>;
+    /**
+     * Check if server is running
+     */
+    isServerRunning(): Promise<boolean>;
+    /**
+     * Get server status
+     */
+    status(): Promise<PtyServerStatus>;
+    /**
+     * Send prompt to session
+     */
+    send(prompt: string): Promise<PtySendResponse>;
+    /**
+     * Wait for completion
+     */
+    waitForCompletion(timeout?: number): Promise<boolean>;
+    /**
+     * Check if response is complete
+     */
+    complete(): Promise<PtyCompleteResponse>;
+    /**
+     * Get structured exchange output
+     */
+    exchange(): Promise<PtyExchange>;
+    /**
+     * Check for pending tool confirmations
+     */
+    pending(): Promise<PtyPendingResponse>;
+    /**
+     * Read raw output
+     */
+    read(lines?: number): Promise<string>;
+    /**
+     * Get exchange history
+     */
+    history(): Promise<{
+        provider: string;
+        count: number;
+        exchanges: PtyExchange[];
+    }>;
+    /**
+     * Clear exchange history
+     */
+    clearHistory(): Promise<void>;
+    /**
+     * Stop the server
+     */
+    stop(): Promise<void>;
+    /**
+     * Sleep helper
+     */
+    private sleep;
+}