icopilot 2.2.0

package/dist/commands/clipboard-cmd.js

@@ -0,0 +1,217 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFile, spawn, spawnSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { config } from '../config.js';
+const CLIPBOARD_DIR = '.icopilot-clipboard';
+const IMAGE_MARKER = '__ICLI_IMAGE__';
+const MAX_BUFFER = 20 * 1024 * 1024;
+export async function readClipboard() {
+    switch (process.platform) {
+        case 'win32':
+            return readClipboardWindows();
+        case 'darwin':
+            return readClipboardMacOS();
+        default:
+            return readClipboardLinux();
+    }
+}
+export async function pasteToChat() {
+    const clipboard = await readClipboard();
+    return clipboard.type === 'image' ? `"${clipboard.content}"` : clipboard.content;
+}
+export async function copyContextToClipboard(messages) {
+    await copyTextToClipboard(formatMessagesAsMarkdown(messages));
+}
+export async function copyTextToClipboard(text) {
+    if (process.platform === 'win32') {
+        try {
+            await writeClipboardText('clip.exe', [], text);
+            return;
+        }
+        catch {
+            await writeClipboardText('powershell.exe', ['-NoProfile', '-Command', 'Set-Clipboard -Value ([Console]::In.ReadToEnd())'], text);
+            return;
+        }
+    }
+    if (process.platform === 'darwin') {
+        await writeClipboardText('pbcopy', [], text);
+        return;
+    }
+    if (commandExists('xclip')) {
+        await writeClipboardText('xclip', ['-selection', 'clipboard'], text);
+        return;
+    }
+    if (commandExists('xsel')) {
+        await writeClipboardText('xsel', ['--clipboard', '--input'], text);
+        return;
+    }
+    throw new Error('No clipboard utility found (expected xclip or xsel).');
+}
+export function formatMessagesAsMarkdown(messages) {
+    const lines = [];
+    for (const message of messages) {
+        const role = capitalize(typeof message.role === 'string' ? message.role : 'message');
+        lines.push(`## ${role}`, '', contentToText(message.content).trim() || '_[no content]_', '', '---', '');
+    }
+    return lines.join('\n').trimEnd() + '\n';
+}
+async function readClipboardWindows() {
+    const imagePath = createClipboardArtifactPath('.png');
+    const script = [
+        'Add-Type -AssemblyName System.Windows.Forms',
+        'Add-Type -AssemblyName System.Drawing',
+        '$target = $args[0]',
+        'if ([System.Windows.Forms.Clipboard]::ContainsImage()) {',
+        '  $image = [System.Windows.Forms.Clipboard]::GetImage()',
+        '  if ($null -ne $image) {',
+        '    $image.Save($target, [System.Drawing.Imaging.ImageFormat]::Png)',
+        `    Write-Output "${IMAGE_MARKER}$target"`,
+        '    exit 0',
+        '  }',
+        '}',
+        'if ([System.Windows.Forms.Clipboard]::ContainsText()) {',
+        '  [Console]::OutputEncoding = [System.Text.Encoding]::UTF8',
+        '  Get-Clipboard -Raw',
+        '  exit 0',
+        '}',
+        'exit 2',
+    ].join('; ');
+    const { stdout } = await runExecFile('powershell.exe', ['-NoProfile', '-STA', '-Command', script, imagePath], { encoding: 'utf8' });
+    return parseClipboardOutput(String(stdout));
+}
+async function readClipboardMacOS() {
+    if (commandExists('pngpaste')) {
+        const imagePath = createClipboardArtifactPath('.png');
+        try {
+            await runExecFile('pngpaste', [imagePath], { encoding: 'buffer' });
+            if (fs.existsSync(imagePath) && fs.statSync(imagePath).size > 0) {
+                return { type: 'image', content: imagePath };
+            }
+        }
+        catch {
+            cleanupFile(imagePath);
+        }
+    }
+    const { stdout } = await runExecFile('pbpaste', [], { encoding: 'utf8' });
+    return { type: 'text', content: trimTrailingNewline(String(stdout)) };
+}
+async function readClipboardLinux() {
+    if (commandExists('xclip')) {
+        const imagePath = createClipboardArtifactPath('.png');
+        try {
+            const { stdout } = await runExecFile('xclip', ['-selection', 'clipboard', '-t', 'image/png', '-o'], { encoding: 'buffer' });
+            const buffer = asBuffer(stdout);
+            if (buffer.length > 0) {
+                fs.writeFileSync(imagePath, buffer);
+                return { type: 'image', content: imagePath };
+            }
+        }
+        catch {
+            cleanupFile(imagePath);
+        }
+    }
+    if (commandExists('xclip')) {
+        const { stdout } = await runExecFile('xclip', ['-selection', 'clipboard', '-o'], {
+            encoding: 'utf8',
+        });
+        return { type: 'text', content: trimTrailingNewline(String(stdout)) };
+    }
+    if (commandExists('xsel')) {
+        const { stdout } = await runExecFile('xsel', ['--clipboard', '--output'], { encoding: 'utf8' });
+        return { type: 'text', content: trimTrailingNewline(String(stdout)) };
+    }
+    throw new Error('No clipboard utility found (expected xclip or xsel).');
+}
+function parseClipboardOutput(stdout) {
+    const trimmed = trimTrailingNewline(stdout);
+    if (trimmed.startsWith(IMAGE_MARKER)) {
+        return { type: 'image', content: trimmed.slice(IMAGE_MARKER.length).trim() };
+    }
+    return { type: 'text', content: trimmed };
+}
+function createClipboardArtifactPath(extension) {
+    const dir = path.join(config.cwd || process.cwd(), CLIPBOARD_DIR);
+    fs.mkdirSync(dir, { recursive: true });
+    return path.join(dir, `clipboard-${Date.now()}-${randomUUID()}${extension}`);
+}
+function trimTrailingNewline(value) {
+    return value.replace(/\r?\n$/, '');
+}
+function cleanupFile(filePath) {
+    try {
+        fs.rmSync(filePath, { force: true });
+    }
+    catch {
+        /* ignore cleanup errors */
+    }
+}
+function commandExists(command) {
+    const checker = process.platform === 'win32' ? 'where.exe' : 'which';
+    return spawnSync(checker, [command], { stdio: 'ignore' }).status === 0;
+}
+function writeClipboardText(command, args, text) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            stdio: ['pipe', 'ignore', 'pipe'],
+            windowsHide: true,
+        });
+        let stderr = '';
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(stderr.trim() || `clipboard command exited with code ${code}`));
+            }
+        });
+        child.stdin.end(text);
+    });
+}
+function runExecFile(command, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        execFile(command, args, {
+            windowsHide: true,
+            maxBuffer: MAX_BUFFER,
+            ...options,
+        }, (error, stdout, stderr) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve({
+                stdout: stdout,
+                stderr: stderr,
+            });
+        });
+    });
+}
+function asBuffer(value) {
+    return Buffer.isBuffer(value) ? value : Buffer.from(value);
+}
+function contentToText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => {
+            if (typeof part?.text === 'string')
+                return part.text;
+            if (typeof part?.type === 'string')
+                return JSON.stringify(part);
+            return '';
+        })
+            .filter(Boolean)
+            .join('\n');
+    }
+    if (content == null)
+        return '';
+    return JSON.stringify(content, null, 2);
+}
+function capitalize(value) {
+    return value ? value[0].toUpperCase() + value.slice(1) : value;
+}

package/dist/commands/cloud-routine-cmd.js

@@ -0,0 +1,265 @@
+import { getCloudRoutineStore } from '../cloud/routine-storage.js';
+import { theme } from '../ui/theme.js';
+export async function cloudRoutineCommand(arg) {
+    const store = getCloudRoutineStore();
+    const parts = arg.trim().split(/\s+/);
+    const subcommand = parts[0]?.toLowerCase();
+    switch (subcommand) {
+        case 'create':
+            return handleCreate(parts.slice(1), store);
+        case 'list':
+            return handleList(parts.slice(1), store);
+        case 'show':
+            return handleShow(parts.slice(1), store);
+        case 'update':
+            return handleUpdate(parts.slice(1), store);
+        case 'delete':
+            return handleDelete(parts.slice(1), store);
+        case 'run':
+            return handleRun(parts.slice(1), store);
+        case 'logs':
+            return handleLogs(parts.slice(1), store);
+        default:
+            return theme.err('Unknown cloud-routine subcommand. Use: create, list, show, update, delete, run, logs');
+    }
+}
+function handleCreate(args, store) {
+    if (args.length < 3) {
+        return theme.err('Usage: /cloud-routine create <name> <schedule> <prompt>\n' +
+            'Examples:\n' +
+            '  /cloud-routine create "daily-standup" "daily 09:00" "generate standup"\n' +
+            '  /cloud-routine create "weekly-review" "weekly 1 18:00" "code review checklist"');
+    }
+    const name = args[0].replace(/^["']|["']$/g, '');
+    const scheduleStr = args[1].replace(/^["']|["']$/g, '');
+    const prompt = args
+        .slice(2)
+        .join(' ')
+        .replace(/^["']|["']$/g, '');
+    try {
+        const schedule = parseSchedule(scheduleStr);
+        const routine = store.create(name, schedule, prompt);
+        return theme.ok(`✔ Routine "${routine.name}" created (ID: ${routine.id})\n` +
+            `  Next run: ${formatDate(routine.nextRun)}`);
+    }
+    catch (err) {
+        return theme.err(`✘ Failed to create routine: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function handleList(args, store) {
+    const detail = args.includes('--detail');
+    const routines = store.list();
+    if (routines.length === 0) {
+        return theme.dim('No cloud routines configured.');
+    }
+    let output = `${theme.brand('Cloud Routines')}\n`;
+    if (detail) {
+        for (const routine of routines) {
+            output += `\n${theme.bold(routine.name)} (${routine.id})\n`;
+            output += `  Enabled: ${routine.enabled ? '✓' : '✗'}\n`;
+            output += `  Schedule: ${formatSchedule(routine.schedule)}\n`;
+            output += `  Next Run: ${formatDate(routine.nextRun)}\n`;
+            if (routine.lastRun) {
+                output += `  Last Run: ${formatDate(routine.lastRun)}\n`;
+            }
+            output += `  Prompt: ${routine.prompt.substring(0, 60)}${routine.prompt.length > 60 ? '...' : ''}\n`;
+        }
+    }
+    else {
+        output += `${theme.dim('Name'.padEnd(30) + 'Status'.padEnd(10) + 'Next Run')}\n`;
+        for (const routine of routines) {
+            const status = routine.enabled ? '✓ active' : '✗ disabled';
+            output += `${routine.name.padEnd(30)}${status.padEnd(10)}${formatDate(routine.nextRun)}\n`;
+        }
+    }
+    return output;
+}
+function handleShow(args, store) {
+    const id = args[0];
+    if (!id) {
+        return theme.err('Usage: /cloud-routine show <id>');
+    }
+    const routine = store.get(id);
+    if (!routine) {
+        return theme.err(`Routine with ID "${id}" not found.`);
+    }
+    let output = `${theme.bold(routine.name)}\n`;
+    output += `  ID: ${routine.id}\n`;
+    output += `  Enabled: ${routine.enabled ? '✓' : '✗'}\n`;
+    output += `  Schedule: ${formatSchedule(routine.schedule)}\n`;
+    output += `  Next Run: ${formatDate(routine.nextRun)}\n`;
+    output += `  Created: ${formatDate(routine.createdAt)}\n`;
+    if (routine.lastRun) {
+        output += `  Last Run: ${formatDate(routine.lastRun)}\n`;
+    }
+    output += `\n${theme.dim('Prompt:')}\n${routine.prompt}\n`;
+    const logs = store.getLogs(routine.id, 5);
+    if (logs.length > 0) {
+        output += `\n${theme.dim('Recent Executions:')}\n`;
+        for (const log of logs) {
+            const status = log.status === 'success' ? '✓' : '✘';
+            output += `  ${status} ${formatDate(log.timestamp)} (${log.duration}ms)\n`;
+        }
+    }
+    return output;
+}
+function handleUpdate(args, store) {
+    const id = args[0];
+    if (!id) {
+        return theme.err('Usage: /cloud-routine update <id> [--schedule <sched>] [--prompt <prompt>] [--enabled <true|false>]');
+    }
+    const routine = store.get(id);
+    if (!routine) {
+        return theme.err(`Routine with ID "${id}" not found.`);
+    }
+    const updates = {};
+    for (let i = 1; i < args.length; i += 2) {
+        const flag = args[i];
+        const value = args[i + 1];
+        if (!flag || !value)
+            continue;
+        if (flag === '--schedule') {
+            try {
+                updates.schedule = parseSchedule(value);
+            }
+            catch (err) {
+                return theme.err(`Invalid schedule: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        else if (flag === '--prompt') {
+            updates.prompt = value.replace(/^["']|["']$/g, '');
+        }
+        else if (flag === '--enabled') {
+            updates.enabled = value.toLowerCase() === 'true';
+        }
+    }
+    if (Object.keys(updates).length === 0) {
+        return theme.err('No updates specified.');
+    }
+    try {
+        const updated = store.update(id, updates);
+        return theme.ok(`✔ Routine "${updated.name}" updated.`);
+    }
+    catch (err) {
+        return theme.err(`✘ Failed to update routine: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function handleDelete(args, store) {
+    const id = args[0];
+    if (!id) {
+        return theme.err('Usage: /cloud-routine delete <id>');
+    }
+    const routine = store.get(id);
+    if (!routine) {
+        return theme.err(`Routine with ID "${id}" not found.`);
+    }
+    if (store.delete(id)) {
+        return theme.ok(`✔ Routine "${routine.name}" deleted.`);
+    }
+    return theme.err('Failed to delete routine.');
+}
+function handleRun(args, store) {
+    const id = args[0];
+    if (!id) {
+        return theme.err('Usage: /cloud-routine run <id>');
+    }
+    const routine = store.get(id);
+    if (!routine) {
+        return theme.err(`Routine with ID "${id}" not found.`);
+    }
+    return theme.ok(`✔ Routine "${routine.name}" queued for immediate execution. (manual trigger)`);
+}
+function handleLogs(args, store) {
+    const id = args[0];
+    if (!id) {
+        return theme.err('Usage: /cloud-routine logs <id> [--last N]');
+    }
+    const routine = store.get(id);
+    if (!routine) {
+        return theme.err(`Routine with ID "${id}" not found.`);
+    }
+    let limit = 20;
+    const lastIdx = args.indexOf('--last');
+    if (lastIdx !== -1 && args[lastIdx + 1]) {
+        limit = parseInt(args[lastIdx + 1], 10) || 20;
+    }
+    const logs = store.getLogs(id, limit);
+    if (logs.length === 0) {
+        return theme.dim(`No execution logs for "${routine.name}".`);
+    }
+    let output = `${theme.bold(`Execution Logs: ${routine.name}`)}\n`;
+    for (const log of logs) {
+        const status = log.status === 'success' ? theme.ok('✓') : theme.err('✘');
+        output += `${status} ${formatDate(log.timestamp)} (${log.duration}ms)`;
+        if (log.error) {
+            output += ` - ${log.error}`;
+        }
+        output += '\n';
+    }
+    return output;
+}
+function parseSchedule(scheduleStr) {
+    const parts = scheduleStr.trim().toLowerCase().split(/\s+/);
+    const type = parts[0];
+    switch (type) {
+        case 'once': {
+            return { type: 'once' };
+        }
+        case 'daily': {
+            const time = parts[1] || '09:00';
+            return { type: 'daily', time };
+        }
+        case 'weekly': {
+            const dayOfWeek = parseInt(parts[1], 10);
+            const time = parts[2] || '09:00';
+            if (isNaN(dayOfWeek) || dayOfWeek < 0 || dayOfWeek > 6) {
+                throw new Error('day of week must be 0-6 (0=Sunday, 6=Saturday)');
+            }
+            return { type: 'weekly', dayOfWeek, time };
+        }
+        case 'monthly': {
+            const dayOfMonth = parseInt(parts[1], 10);
+            const time = parts[2] || '09:00';
+            if (isNaN(dayOfMonth) || dayOfMonth < 1 || dayOfMonth > 31) {
+                throw new Error('day of month must be 1-31');
+            }
+            return { type: 'monthly', dayOfMonth, time };
+        }
+        case 'custom': {
+            const expression = parts.slice(1).join(' ');
+            if (!expression)
+                throw new Error('custom schedule requires an expression');
+            return { type: 'custom', expression };
+        }
+        default:
+            throw new Error(`unknown schedule type: ${type}`);
+    }
+}
+function formatSchedule(schedule) {
+    switch (schedule.type) {
+        case 'once':
+            return 'once';
+        case 'daily':
+            return `daily at ${schedule.time || '09:00'}`;
+        case 'weekly': {
+            const days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+            return `weekly on ${days[schedule.dayOfWeek || 0]} at ${schedule.time || '09:00'}`;
+        }
+        case 'monthly':
+            return `monthly on day ${schedule.dayOfMonth || 1} at ${schedule.time || '09:00'}`;
+        case 'custom':
+            return `custom: ${schedule.expression || ''}`;
+        default:
+            return 'unknown';
+    }
+}
+function formatDate(date) {
+    if (!date)
+        return 'never';
+    try {
+        return new Date(date).toLocaleString();
+    }
+    catch {
+        return date;
+    }
+}