@adhdev/daemon-core 0.5.3

package/src/cli-adapters/provider-cli-adapter.ts

@@ -0,0 +1,448 @@
+/**
+ * ProviderCliAdapter — generic CLI Adapter based on provider.js
+ *
+ * Replaces individual adapters (gemini-cli.ts, claude-cli.ts, codex-cli.ts).
+ * Single engine driven by provider.js patterns, spawn, and cleanOutput.
+ *
+ * provider.js contract:
+ * type: string — 'gemini-cli', 'claude-cli', 'codex-cli', ...
+ * name: string — 'Gemini CLI', 'Claude Code', ...
+ * category: 'cli'
+ * binary: string — binary name
+ * spawn: { command, args, shell, env }
+ * patterns: { prompt, generating, approval, ready }
+ * timeouts?: { idleFinish, generatingIdle, maxResponse, approvalCooldown, ... }
+ * cleanOutput(raw, lastUserInput): string
+ */
+
+import * as os from 'os';
+import { execSync } from 'child_process';
+import type { CliAdapter } from '../cli-adapter-types.js';
+import { LOG } from '../logging/logger.js';
+
+let pty: any;
+try {
+    pty = require('node-pty');
+} catch {
+    LOG.error('CLI', '[ProviderCliAdapter] node-pty not found. Install: npm install node-pty@1.0.0');
+}
+
+export interface CliChatMessage {
+    role: 'user' | 'assistant';
+    content: string;
+    timestamp?: number;
+}
+
+export interface CliSessionStatus {
+    status: 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting';
+    messages: CliChatMessage[];
+    workingDir: string;
+    activeModal: { message: string; buttons: string[] } | null;
+}
+
+export interface CliProviderModule {
+    type: string;
+    name: string;
+    category: 'cli';
+    binary: string;
+    spawn: {
+        command: string;
+        args: string[];
+        shell: boolean;
+        env: Record<string, string>;
+    };
+    patterns: {
+        prompt: RegExp[];
+        generating: RegExp[];
+        approval: RegExp[];
+        ready: RegExp[];
+    };
+    timeouts?: {
+ /** PTY output batch transmit interval (default 50ms) */
+        ptyFlush?: number;
+ /** Wait for startup dialog auto-proceed (default 300ms) */
+        dialogAccept?: number;
+ /** Approval detect cooldown (default 2000ms) */
+        approvalCooldown?: number;
+ /** Check for completion on no-response during generating (default 6000ms) */
+        generatingIdle?: number;
+ /** Check for completion on no-response (default 5000ms) */
+        idleFinish?: number;
+ /** Max response wait (default 300000ms = 5min) */
+        maxResponse?: number;
+ /** shutdown after kill wait (default 1000ms) */
+        shutdownGrace?: number;
+    };
+    cleanOutput(raw: string, lastUserInput?: string): string;
+}
+
+function stripAnsi(str: string): string {
+ // eslint-disable-next-line no-control-regex
+    return str.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '')
+        .replace(/\x1B\][^\x07]*\x07/g, '')
+        .replace(/\x1B\][^\x1B]*\x1B\\/g, '');
+}
+
+function findBinary(name: string): string {
+    const isWin = os.platform() === 'win32';
+    try {
+        const cmd = isWin ? `where ${name}` : `which ${name}`;
+        return execSync(cmd, { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }).trim().split('\n')[0].trim();
+    } catch {
+        return isWin ? `${name}.cmd` : name;
+    }
+}
+
+export class ProviderCliAdapter implements CliAdapter {
+    readonly cliType: string;
+    readonly cliName: string;
+    public workingDir: string;
+
+    private provider: CliProviderModule;
+    private ptyProcess: any = null;
+    private messages: CliChatMessage[] = [];
+    private currentStatus: CliSessionStatus['status'] = 'starting';
+    private onStatusChange: (() => void) | null = null;
+
+    private responseBuffer = '';
+    private recentOutputBuffer = '';
+    private isWaitingForResponse = false;
+    private activeModal: { message: string; buttons: string[] } | null = null;
+    private responseTimeout: NodeJS.Timeout | null = null;
+    private idleTimeout: NodeJS.Timeout | null = null;
+    private ready = false;
+    private startupBuffer = '';
+
+ // PTY I/O
+    private onPtyDataCallback: ((data: string) => void) | null = null;
+    private ptyOutputBuffer = '';
+    private ptyOutputFlushTimer: NodeJS.Timeout | null = null;
+
+ // Server log forwarding
+    private serverConn: any = null;
+    private logBuffer: { message: string; level: string }[] = [];
+
+ // Approval cooldown
+    private lastApprovalResolvedAt: number = 0;
+
+ // Resolved timeouts (provider defaults + overrides)
+    private readonly timeouts: Required<NonNullable<CliProviderModule['timeouts']>>;
+
+    constructor(provider: CliProviderModule, workingDir: string, private extraArgs: string[] = []) {
+        this.provider = provider;
+        this.cliType = provider.type;
+        this.cliName = provider.name;
+        this.workingDir = workingDir.startsWith('~')
+            ? workingDir.replace(/^~/, os.homedir())
+            : workingDir;
+
+ // Apply timeout overrides from Provider
+        const t = provider.timeouts || {};
+        this.timeouts = {
+            ptyFlush: t.ptyFlush ?? 50,
+            dialogAccept: t.dialogAccept ?? 300,
+            approvalCooldown: t.approvalCooldown ?? 2000,
+            generatingIdle: t.generatingIdle ?? 6000,
+            idleFinish: t.idleFinish ?? 5000,
+            maxResponse: t.maxResponse ?? 300000,
+            shutdownGrace: t.shutdownGrace ?? 1000,
+        };
+    }
+
+ // ─── Lifecycle ─────────────────────────────────
+
+    setServerConn(serverConn: any): void {
+        this.serverConn = serverConn;
+        if (this.serverConn && this.logBuffer.length > 0) {
+            this.logBuffer.forEach(log => this.serverConn.sendMessage('log', log));
+            this.logBuffer = [];
+        }
+    }
+
+    setOnStatusChange(callback: () => void): void {
+        this.onStatusChange = callback;
+    }
+
+    setOnPtyData(callback: (data: string) => void): void {
+        this.onPtyDataCallback = callback;
+    }
+
+    async spawn(): Promise<void> {
+        if (this.ptyProcess) return;
+        if (!pty) throw new Error('node-pty is not installed');
+
+        const { spawn: spawnConfig } = this.provider;
+        const binaryPath = findBinary(spawnConfig.command);
+        const isWin = os.platform() === 'win32';
+        const allArgs = [...spawnConfig.args, ...this.extraArgs];
+
+        LOG.info('CLI', `[${this.cliType}] Spawning in ${this.workingDir}`);
+
+        let shellCmd: string;
+        let shellArgs: string[];
+
+        if (spawnConfig.shell) {
+ // Execute via shell (for gemini etc npm shim compat)
+            shellCmd = isWin ? 'cmd.exe' : (process.env.SHELL || '/bin/zsh');
+            const fullCmd = [binaryPath, ...allArgs].join(' ');
+            shellArgs = isWin ? ['/c', fullCmd] : ['-l', '-c', fullCmd];
+        } else {
+            shellCmd = binaryPath;
+            shellArgs = allArgs;
+        }
+
+        this.ptyProcess = pty.spawn(shellCmd, shellArgs, {
+            name: 'xterm-256color',
+            cols: 120,
+            rows: 40,
+            cwd: this.workingDir,
+            env: {
+                ...process.env,
+                ...spawnConfig.env,
+            } as Record<string, string>,
+        });
+
+        this.ptyProcess.onData((data: string) => {
+            this.handleOutput(data);
+ // PTY output batch transmit (50ms)
+            if (this.onPtyDataCallback) {
+                this.ptyOutputBuffer += data;
+                if (!this.ptyOutputFlushTimer) {
+                    this.ptyOutputFlushTimer = setTimeout(() => {
+                        if (this.ptyOutputBuffer && this.onPtyDataCallback) {
+                            this.onPtyDataCallback(this.ptyOutputBuffer);
+                        }
+                        this.ptyOutputBuffer = '';
+                        this.ptyOutputFlushTimer = null;
+                    }, this.timeouts.ptyFlush);
+                }
+            }
+        });
+
+        this.ptyProcess.onExit(({ exitCode }: { exitCode: number }) => {
+            LOG.info('CLI', `[${this.cliType}] Exit code ${exitCode}`);
+            this.ptyProcess = null;
+            this.currentStatus = 'stopped';
+            this.ready = false;
+            this.onStatusChange?.();
+        });
+
+        this.currentStatus = 'starting';
+        this.onStatusChange?.();
+    }
+
+ // ─── Output state machine ────────────────────────────
+
+    private handleOutput(rawData: string): void {
+        const cleanData = stripAnsi(rawData);
+        const { patterns } = this.provider;
+
+ // Server log forwarding
+        if (cleanData.trim()) {
+            if (this.serverConn) {
+                this.serverConn.sendMessage('log', { message: cleanData.trim(), level: 'info' });
+            } else {
+                this.logBuffer.push({ message: cleanData.trim(), level: 'info' });
+            }
+        }
+
+ // Rolling buffer (recent 1000 chars)
+        this.recentOutputBuffer = (this.recentOutputBuffer + cleanData).slice(-1000);
+
+ // ─── Phase 1: Startup — ready status wait
+        if (!this.ready) {
+            this.startupBuffer += cleanData;
+
+ // Startup dialog auto-proceed (Enter)
+            const dialogPatterns = [
+                /Do you want to connect/i,
+                /Do you trust the files/i,
+            ];
+            if (dialogPatterns.some(p => p.test(this.startupBuffer))) {
+                setTimeout(() => this.ptyProcess?.write('\r'), this.timeouts.dialogAccept);
+                this.startupBuffer = '';
+                return;
+            }
+
+ // Prompt → ready
+            if (patterns.prompt.some(p => p.test(this.startupBuffer))) {
+                this.ready = true;
+                this.currentStatus = 'idle';
+                LOG.info('CLI', `[${this.cliType}] ✓ Ready`);
+                this.onStatusChange?.();
+            }
+            return;
+        }
+
+ // ─── Phase 2: Approval detect
+        const hasApproval = patterns.approval.some(p => p.test(this.recentOutputBuffer));
+        if (hasApproval && this.currentStatus !== 'waiting_approval') {
+            if (this.lastApprovalResolvedAt && (Date.now() - this.lastApprovalResolvedAt) < this.timeouts.approvalCooldown) return;
+
+            this.isWaitingForResponse = true;
+            this.currentStatus = 'waiting_approval';
+            this.recentOutputBuffer = '';
+            const ctxLines = cleanData.split('\n').map(l => l.trim()).filter(l => l && !/^[─═╭╮╰╯│]+$/.test(l));
+            this.activeModal = {
+                message: ctxLines.slice(-5).join(' ').slice(0, 200) || 'Approval required',
+                buttons: ['Allow once', 'Always allow', 'Deny'],
+            };
+            if (this.idleTimeout) clearTimeout(this.idleTimeout);
+            this.onStatusChange?.();
+            return;
+        }
+
+ // ─── Phase 3: Approval release
+        if (this.currentStatus === 'waiting_approval') {
+            const genResume = patterns.generating.some(p => p.test(cleanData));
+            const promptResume = patterns.prompt.some(p => p.test(cleanData));
+            if (genResume) {
+                this.currentStatus = 'generating';
+                this.activeModal = null;
+                this.recentOutputBuffer = '';
+                this.lastApprovalResolvedAt = Date.now();
+                this.onStatusChange?.();
+            } else if (promptResume) {
+                this.activeModal = null;
+                this.recentOutputBuffer = '';
+                this.lastApprovalResolvedAt = Date.now();
+                this.finishResponse();
+            }
+            return;
+        }
+
+ // ─── Phase 4: autonomous generation detection (generating starts without sendMessage)
+        if (!this.isWaitingForResponse) {
+            if (patterns.generating.some(p => p.test(cleanData))) {
+                this.isWaitingForResponse = true;
+                this.responseBuffer = '';
+                this.currentStatus = 'generating';
+                this.onStatusChange?.();
+            }
+        }
+
+ // ─── Phase 5: response collect
+        if (this.isWaitingForResponse) {
+            this.responseBuffer += cleanData;
+            if (this.idleTimeout) clearTimeout(this.idleTimeout);
+
+            const stillGenerating = patterns.generating.some(p => p.test(cleanData));
+            if (stillGenerating) {
+                this.currentStatus = 'generating';
+                this.idleTimeout = setTimeout(() => {
+                    if (this.isWaitingForResponse) this.finishResponse();
+                }, this.timeouts.generatingIdle);
+                this.onStatusChange?.();
+                return;
+            }
+
+ // Prompt → response complete
+            if (patterns.prompt.some(p => p.test(this.responseBuffer))) {
+                this.finishResponse();
+            } else {
+                this.idleTimeout = setTimeout(() => {
+                    if (this.isWaitingForResponse && this.responseBuffer.trim()) {
+                        this.finishResponse();
+                    }
+                }, this.timeouts.idleFinish);
+            }
+            this.onStatusChange?.();
+        }
+    }
+
+    private finishResponse(): void {
+        if (this.responseTimeout) { clearTimeout(this.responseTimeout); this.responseTimeout = null; }
+        if (this.idleTimeout) { clearTimeout(this.idleTimeout); this.idleTimeout = null; }
+
+        const lastUserText = this.messages.filter(m => m.role === 'user').pop()?.content;
+        let response = this.provider.cleanOutput(this.responseBuffer, lastUserText);
+
+ // Remove user input echo
+        if (lastUserText && response) {
+            const userTrimmed = lastUserText.trim();
+            response = response.split('\n')
+                .filter(l => l.trim() !== userTrimmed)
+                .join('\n').trim();
+        }
+
+        if (response) {
+            this.messages.push({ role: 'assistant', content: response, timestamp: Date.now() });
+            if (this.messages.length > 200) this.messages = this.messages.slice(-200);
+            LOG.info('CLI', `[${this.cliType}] Response (${response.length} chars)`);
+        }
+
+        this.responseBuffer = '';
+        this.isWaitingForResponse = false;
+        this.activeModal = null;
+        this.currentStatus = 'idle';
+        this.onStatusChange?.();
+    }
+
+ // ─── Public API (CliAdapter interface) ──────────
+
+    getStatus(): CliSessionStatus {
+        return {
+            status: this.currentStatus,
+            messages: [...this.messages],
+            workingDir: this.workingDir,
+            activeModal: this.activeModal,
+        };
+    }
+
+    async sendMessage(text: string): Promise<void> {
+        if (!this.ptyProcess) throw new Error(`${this.cliName} is not running`);
+        if (!this.ready) throw new Error(`${this.cliName} not ready (status: ${this.currentStatus})`);
+        if (this.isWaitingForResponse) return;
+
+        this.messages.push({ role: 'user', content: text, timestamp: Date.now() });
+        this.isWaitingForResponse = true;
+        this.responseBuffer = '';
+        this.currentStatus = 'generating';
+        this.onStatusChange?.();
+
+        this.ptyProcess.write(text + '\r');
+
+        this.responseTimeout = setTimeout(() => {
+            if (this.isWaitingForResponse) this.finishResponse();
+        }, this.timeouts.maxResponse);
+    }
+
+    getPartialResponse(): string {
+        if (!this.isWaitingForResponse) return '';
+        const partial = this.provider.cleanOutput(this.responseBuffer);
+        return partial || (this.isWaitingForResponse ? '(generating...)' : '');
+    }
+
+    cancel(): void { this.shutdown(); }
+
+    shutdown(): void {
+        if (this.ptyProcess) {
+            this.ptyProcess.write('\x03');
+            setTimeout(() => {
+                try { this.ptyProcess?.kill(); } catch { }
+                this.ptyProcess = null;
+                this.currentStatus = 'stopped';
+                this.ready = false;
+                this.onStatusChange?.();
+            }, this.timeouts.shutdownGrace);
+        }
+    }
+
+    clearHistory(): void {
+        this.messages = [];
+        this.onStatusChange?.();
+    }
+
+    isProcessing(): boolean { return this.isWaitingForResponse; }
+    isReady(): boolean { return this.ready; }
+
+    writeRaw(data: string): void {
+        this.ptyProcess?.write(data);
+    }
+
+    resize(cols: number, rows: number): void {
+        if (this.ptyProcess) {
+            try { this.ptyProcess.resize(cols, rows); } catch { }
+        }
+    }
+}

package/src/commands/cdp-commands.ts

@@ -0,0 +1,208 @@
+/**
+ * CDP Commands — cdpEval, screenshot, cdpCommand, cdpBatch, cdpRemoteAction,
+ *                discoverAgents, file operations
+ */
+
+import type { CommandResult, CommandHelpers } from './handler.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+// ─── CDP direct commands ──────────────────────────
+
+export async function handleCdpEval(h: CommandHelpers, args: any): Promise<CommandResult> {
+    if (!h.getCdp()?.isConnected) return { success: false, error: 'CDP not connected' };
+    const expression = args?.expression || args?.script;
+    if (!expression) return { success: false, error: 'expression required' };
+    try {
+        const result = await h.getCdp()!.evaluate(expression, 50000);
+        return { success: true, result };
+    } catch (e: any) {
+        return { success: false, error: e.message };
+    }
+}
+
+export async function handleScreenshot(h: CommandHelpers, args: any): Promise<CommandResult> {
+    if (!h.getCdp()?.isConnected) return { success: false, error: 'CDP not connected' };
+    try {
+        const buf = await h.getCdp()!.captureScreenshot();
+        if (buf) {
+            const b64 = buf.toString('base64');
+            return { success: true, result: b64, base64: b64, screenshot: b64, format: 'webp' };
+        }
+        return { success: false, error: 'Screenshot failed' };
+    } catch (e: any) {
+        return { success: false, error: e.message };
+    }
+}
+
+export async function handleCdpCommand(h: CommandHelpers, args: any): Promise<CommandResult> {
+    if (!h.getCdp()?.isConnected) return { success: false, error: 'CDP not connected' };
+    const method = args?.method;
+    const params = args?.params || {};
+    if (!method) return { success: false, error: 'method required' };
+    try {
+        const result = await h.getCdp()!.sendCdpCommand(method, params);
+        return { success: true, result };
+    } catch (e: any) {
+        return { success: false, error: e.message };
+    }
+}
+
+export async function handleCdpBatch(h: CommandHelpers, args: any): Promise<CommandResult> {
+    if (!h.getCdp()?.isConnected) return { success: false, error: 'CDP not connected' };
+    const commands = args?.commands as any[];
+    const stopOnError = args?.stopOnError !== false;
+    if (!commands?.length) return { success: false, error: 'commands array required' };
+
+    const results: any[] = [];
+    for (const cmd of commands) {
+        try {
+            const result = await h.getCdp()!.sendCdpCommand(cmd.method, cmd.params || {});
+            results.push({ method: cmd.method, success: true, result });
+        } catch (e: any) {
+            results.push({ method: cmd.method, success: false, error: e.message });
+            if (stopOnError) break;
+        }
+    }
+    return { success: true, results };
+}
+
+export async function handleCdpRemoteAction(h: CommandHelpers, args: any): Promise<CommandResult> {
+    if (!h.getCdp()?.isConnected) return { success: false, error: 'CDP not connected' };
+    const action = args?.action;
+    const params = args?.params || args;
+
+    try {
+        switch (action) {
+            case 'input_key': {
+                const { key, modifiers } = params;
+                await h.getCdp()!.send('Input.dispatchKeyEvent', {
+                    type: 'keyDown', key,
+                    ...(modifiers?.ctrl ? { modifiers: 2 } : {}),
+                    ...(modifiers?.shift ? { modifiers: 8 } : {}),
+                });
+                await h.getCdp()!.send('Input.dispatchKeyEvent', { type: 'keyUp', key });
+                return { success: true };
+            }
+            case 'input_click': {
+                let { x, y, nx, ny, button: btn } = params;
+                if ((x === undefined || y === undefined) && nx !== undefined && ny !== undefined) {
+                    const viewport = await h.getCdp()!.evaluate(
+                        'JSON.stringify({ w: window.innerWidth, h: window.innerHeight })'
+                    ) as string;
+                    const { w, h: vh } = JSON.parse(viewport);
+                    x = Math.round(nx * w);
+                    y = Math.round(ny * vh);
+                }
+                if (x === undefined || y === undefined) {
+                    return { success: false, error: 'No coordinates provided (x,y or nx,ny required)' };
+                }
+                await h.getCdp()!.send('Input.dispatchMouseEvent', {
+                    type: 'mousePressed', x, y, button: btn || 'left', clickCount: 1,
+                });
+                await h.getCdp()!.send('Input.dispatchMouseEvent', {
+                    type: 'mouseReleased', x, y, button: btn || 'left', clickCount: 1,
+                });
+                return { success: true, x, y };
+            }
+            case 'input_type': {
+                const { text } = params;
+                for (const char of text || '') {
+                    await h.getCdp()!.send('Input.dispatchKeyEvent', {
+                        type: 'keyDown', text: char, key: char,
+                    });
+                    await h.getCdp()!.send('Input.dispatchKeyEvent', { type: 'keyUp', key: char });
+                }
+                return { success: true };
+            }
+            case 'page_screenshot': return handleScreenshot(h, args);
+            case 'page_eval': return handleCdpEval(h, params);
+            case 'dom_query': {
+                const html = await h.getCdp()!.querySelector(params?.selector);
+                return { success: true, html };
+            }
+            case 'input_wheel': {
+                let { x, y, nx, ny, deltaX, deltaY } = params;
+                if ((x === undefined || y === undefined) && nx !== undefined && ny !== undefined) {
+                    const viewport = await h.getCdp()!.evaluate(
+                        'JSON.stringify({ w: window.innerWidth, h: window.innerHeight })'
+                    ) as string;
+                    const { w, h: vh } = JSON.parse(viewport);
+                    x = Math.round(nx * w);
+                    y = Math.round(ny * vh);
+                }
+                await h.getCdp()!.send('Input.dispatchMouseEvent', {
+                    type: 'mouseWheel', x: x || 0, y: y || 0,
+                    deltaX: deltaX || 0, deltaY: deltaY || 0,
+                });
+                return { success: true };
+            }
+            default:
+                return { success: false, error: `Unknown remote action: ${action}` };
+        }
+    } catch (e: any) {
+        return { success: false, error: e.message };
+    }
+}
+
+export async function handleDiscoverAgents(h: CommandHelpers, args: any): Promise<CommandResult> {
+    if (!h.getCdp()?.isConnected) return { success: false, error: 'CDP not connected' };
+    const agents = await h.getCdp()!.discoverAgentWebviews();
+    return { success: true, agents };
+}
+
+// ─── File commands ─────────────────────────────
+
+function resolveSafePath(requestedPath: string): string {
+    const home = os.homedir();
+    let resolved: string;
+    if (requestedPath.startsWith('~')) {
+        resolved = path.join(home, requestedPath.slice(1));
+    } else if (path.isAbsolute(requestedPath)) {
+        resolved = requestedPath;
+    } else {
+        resolved = path.resolve(requestedPath);
+    }
+    return resolved;
+}
+
+export async function handleFileRead(h: CommandHelpers, args: any): Promise<CommandResult> {
+    try {
+        const filePath = resolveSafePath(args?.path);
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return { success: true, content, path: filePath };
+    } catch (e: any) {
+        return { success: false, error: e.message };
+    }
+}
+
+export async function handleFileWrite(h: CommandHelpers, args: any): Promise<CommandResult> {
+    try {
+        const filePath = resolveSafePath(args?.path);
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, args?.content || '', 'utf-8');
+        return { success: true, path: filePath };
+    } catch (e: any) {
+        return { success: false, error: e.message };
+    }
+}
+
+export async function handleFileList(h: CommandHelpers, args: any): Promise<CommandResult> {
+    try {
+        const dirPath = resolveSafePath(args?.path || '.');
+        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+        const files = entries.map(e => ({
+            name: e.name,
+            type: e.isDirectory() ? 'directory' : 'file',
+            size: e.isFile() ? fs.statSync(path.join(dirPath, e.name)).size : undefined,
+        }));
+        return { success: true, files, path: dirPath };
+    } catch (e: any) {
+        return { success: false, error: e.message };
+    }
+}
+
+export async function handleFileListBrowse(h: CommandHelpers, args: any): Promise<CommandResult> {
+    return handleFileList(h, args);
+}