icopilot 2.2.0

package/dist/cloud/routine-storage.js

@@ -0,0 +1,297 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+const ROUTINES_ENV = 'ICOPILOT_CLOUD_ROUTINES_PATH';
+const LOGS_ENV = 'ICOPILOT_CLOUD_ROUTINES_LOGS_PATH';
+function routinesPath() {
+    return process.env[ROUTINES_ENV] || path.join(os.homedir(), '.icopilot', 'cloud-routines.json');
+}
+function logsPath() {
+    return process.env[LOGS_ENV] || path.join(os.homedir(), '.icopilot', 'cloud-routines-logs.json');
+}
+export class CloudRoutineStore {
+    routines = new Map();
+    logs = [];
+    constructor() {
+        this.load();
+    }
+    load() {
+        this.loadRoutines();
+        this.loadLogs();
+    }
+    loadRoutines() {
+        const file = routinesPath();
+        if (!fs.existsSync(file)) {
+            this.routines = new Map();
+            return;
+        }
+        try {
+            const data = fs.readFileSync(file, 'utf8');
+            const parsed = JSON.parse(data);
+            if (Array.isArray(parsed)) {
+                this.routines.clear();
+                for (const item of parsed) {
+                    if (isCloudRoutine(item)) {
+                        this.routines.set(item.id, item);
+                    }
+                }
+            }
+        }
+        catch {
+            this.routines = new Map();
+        }
+    }
+    loadLogs() {
+        const file = logsPath();
+        if (!fs.existsSync(file)) {
+            this.logs = [];
+            return;
+        }
+        try {
+            const data = fs.readFileSync(file, 'utf8');
+            const parsed = JSON.parse(data);
+            if (Array.isArray(parsed)) {
+                this.logs = parsed.filter(isRoutineExecutionLog);
+            }
+        }
+        catch {
+            this.logs = [];
+        }
+    }
+    saveRoutines() {
+        const dir = path.dirname(routinesPath());
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        const data = Array.from(this.routines.values());
+        fs.writeFileSync(routinesPath(), JSON.stringify(data, null, 2), 'utf8');
+    }
+    saveLogs() {
+        const dir = path.dirname(logsPath());
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(logsPath(), JSON.stringify(this.logs, null, 2), 'utf8');
+    }
+    create(name, schedule, prompt, enabled = true) {
+        const trimmedName = name.trim();
+        if (!trimmedName) {
+            throw new Error('routine name is required');
+        }
+        if (!isValidSchedule(schedule)) {
+            throw new Error('invalid schedule configuration');
+        }
+        const trimmedPrompt = prompt.trim();
+        if (!trimmedPrompt) {
+            throw new Error('routine prompt is required');
+        }
+        const routine = {
+            id: randomUUID(),
+            name: trimmedName,
+            prompt: trimmedPrompt,
+            schedule,
+            enabled,
+            createdAt: new Date().toISOString(),
+            nextRun: calculateNextRun(schedule),
+        };
+        this.routines.set(routine.id, routine);
+        this.saveRoutines();
+        return routine;
+    }
+    list() {
+        return Array.from(this.routines.values()).sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+    }
+    get(id) {
+        return this.routines.get(id);
+    }
+    update(id, updates) {
+        const routine = this.routines.get(id);
+        if (!routine) {
+            throw new Error(`routine with id ${id} not found`);
+        }
+        if (updates.name !== undefined && !updates.name.trim()) {
+            throw new Error('routine name cannot be empty');
+        }
+        if (updates.prompt !== undefined && !updates.prompt.trim()) {
+            throw new Error('routine prompt cannot be empty');
+        }
+        if (updates.schedule !== undefined && !isValidSchedule(updates.schedule)) {
+            throw new Error('invalid schedule configuration');
+        }
+        const updated = {
+            ...routine,
+            ...updates,
+            id: routine.id,
+            createdAt: routine.createdAt,
+        };
+        if (updates.schedule) {
+            updated.nextRun = calculateNextRun(updates.schedule);
+        }
+        this.routines.set(id, updated);
+        this.saveRoutines();
+        return updated;
+    }
+    delete(id) {
+        if (!this.routines.has(id)) {
+            return false;
+        }
+        this.routines.delete(id);
+        this.saveRoutines();
+        return true;
+    }
+    updateLastRun(id, timestamp) {
+        const routine = this.routines.get(id);
+        if (routine) {
+            routine.lastRun = timestamp;
+            routine.nextRun = calculateNextRun(routine.schedule);
+            this.routines.set(id, routine);
+            this.saveRoutines();
+        }
+    }
+    getNextRun(id) {
+        const routine = this.routines.get(id);
+        return routine?.nextRun;
+    }
+    findDueRoutines() {
+        const now = new Date();
+        return this.list().filter((r) => {
+            if (!r.enabled || !r.nextRun)
+                return false;
+            return new Date(r.nextRun) <= now;
+        });
+    }
+    logExecution(routineId, status, output, error, duration = 0) {
+        const log = {
+            id: randomUUID(),
+            routineId,
+            timestamp: new Date().toISOString(),
+            status,
+            output,
+            error,
+            duration,
+        };
+        this.logs.push(log);
+        this.saveLogs();
+        return log;
+    }
+    getLogs(routineId, limit = 20) {
+        return this.logs
+            .filter((log) => log.routineId === routineId)
+            .slice(-limit)
+            .reverse();
+    }
+    getAllLogs(limit = 100) {
+        return this.logs.slice(-limit).reverse();
+    }
+}
+function isValidSchedule(schedule) {
+    if (!schedule || typeof schedule !== 'object')
+        return false;
+    const { type } = schedule;
+    if (!type || !['once', 'daily', 'weekly', 'monthly', 'custom'].includes(type)) {
+        return false;
+    }
+    if (type === 'daily' && !schedule.time)
+        return false;
+    if (type === 'weekly' && (schedule.dayOfWeek === undefined || !schedule.time))
+        return false;
+    if (type === 'monthly' && (schedule.dayOfMonth === undefined || !schedule.time))
+        return false;
+    if (type === 'custom' && !schedule.expression)
+        return false;
+    return true;
+}
+function calculateNextRun(schedule) {
+    const now = new Date();
+    switch (schedule.type) {
+        case 'once': {
+            return now.toISOString();
+        }
+        case 'daily': {
+            const time = schedule.time || '09:00';
+            const [hours, minutes] = parseTime(time);
+            const next = new Date(now);
+            next.setHours(hours, minutes, 0, 0);
+            if (next <= now) {
+                next.setDate(next.getDate() + 1);
+            }
+            return next.toISOString();
+        }
+        case 'weekly': {
+            const time = schedule.time || '09:00';
+            const dayOfWeek = schedule.dayOfWeek ?? 0;
+            const [hours, minutes] = parseTime(time);
+            const next = new Date(now);
+            next.setHours(hours, minutes, 0, 0);
+            const daysUntilTarget = (dayOfWeek - next.getDay() + 7) % 7;
+            if (daysUntilTarget === 0 && next <= now) {
+                next.setDate(next.getDate() + 7);
+            }
+            else if (daysUntilTarget > 0) {
+                next.setDate(next.getDate() + daysUntilTarget);
+            }
+            return next.toISOString();
+        }
+        case 'monthly': {
+            const time = schedule.time || '09:00';
+            const dayOfMonth = schedule.dayOfMonth ?? 1;
+            const [hours, minutes] = parseTime(time);
+            const next = new Date(now);
+            next.setHours(hours, minutes, 0, 0);
+            next.setDate(dayOfMonth);
+            if (next <= now) {
+                next.setMonth(next.getMonth() + 1);
+                next.setDate(dayOfMonth);
+            }
+            return next.toISOString();
+        }
+        case 'custom': {
+            return now.toISOString();
+        }
+        default: {
+            return now.toISOString();
+        }
+    }
+}
+function parseTime(timeStr) {
+    const trimmed = timeStr.trim();
+    const match = trimmed.match(/^(\d{1,2}):?(\d{2})?/);
+    if (!match) {
+        throw new Error(`invalid time format: ${timeStr}`);
+    }
+    const hours = parseInt(match[1], 10);
+    const minutes = match[2] ? parseInt(match[2], 10) : 0;
+    if (hours < 0 || hours > 23 || minutes < 0 || minutes > 59) {
+        throw new Error(`invalid time values: ${timeStr}`);
+    }
+    return [hours, minutes];
+}
+function isCloudRoutine(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const obj = value;
+    return (typeof obj.id === 'string' &&
+        typeof obj.name === 'string' &&
+        typeof obj.prompt === 'string' &&
+        isValidSchedule(obj.schedule) &&
+        typeof obj.enabled === 'boolean' &&
+        typeof obj.createdAt === 'string');
+}
+function isRoutineExecutionLog(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const obj = value;
+    return (typeof obj.id === 'string' &&
+        typeof obj.routineId === 'string' &&
+        typeof obj.timestamp === 'string' &&
+        (obj.status === 'success' || obj.status === 'error') &&
+        typeof obj.duration === 'number');
+}
+let storeInstance = null;
+export function getCloudRoutineStore() {
+    if (!storeInstance) {
+        storeInstance = new CloudRoutineStore();
+    }
+    return storeInstance;
+}

package/dist/commands/acp-cmd.js

@@ -0,0 +1,143 @@
+import { getGlobalAPIServer } from '../server/api-server.js';
+import { theme } from '../ui/theme.js';
+export async function acpCommand(options) {
+    const subcommand = (options.subcommand || 'status').toLowerCase();
+    switch (subcommand) {
+        case 'status':
+            return formatAcpStatus();
+        case 'enable':
+            return await enableAcp(options.args);
+        case 'disable':
+            return await disableAcp();
+        case 'test':
+            return await testAcpMethod(options.args);
+        case 'help':
+            return formatAcpHelp();
+        default:
+            return `${theme.error('Unknown ACP subcommand:')} ${subcommand}\n\n${formatAcpHelp()}`;
+    }
+}
+function formatAcpStatus() {
+    const server = getGlobalAPIServer();
+    const isRunning = server.isRunning();
+    const port = server.getPort();
+    if (!isRunning) {
+        return theme.info('ACP Server is currently disabled.');
+    }
+    return `${theme.success('ACP Server is running')}
+  ${theme.muted('Protocol:')} Agent Client Protocol (ACP)
+  ${theme.muted('Endpoint:')} http://localhost:${port}/acp
+  ${theme.muted('Methods:')}
+    • tools/list - list available tools
+    • tool/call - execute a tool
+    • capabilities/get - get server capabilities
+
+  ${theme.muted('Test request:')}
+    curl -X POST http://localhost:${port}/acp \\
+      -H 'Content-Type: application/json' \\
+      -d '{"jsonrpc":"2.0","method":"capabilities/get","id":1}'
+`;
+}
+async function enableAcp(args) {
+    const portStr = args?.[0];
+    const port = portStr ? parseInt(portStr, 10) : 5173;
+    if (isNaN(port) || port < 1024 || port > 65535) {
+        return theme.error(`Invalid port: ${portStr || 'default'}`);
+    }
+    try {
+        const server = getGlobalAPIServer();
+        const actualPort = await server.start(port);
+        return `${theme.success('ACP Server enabled')}
+  ${theme.muted('Port:')} ${actualPort}
+  ${theme.muted('Endpoint:')} http://localhost:${actualPort}/acp
+
+${theme.info('Test with:')}
+  curl -X POST http://localhost:${actualPort}/acp \\
+    -H 'Content-Type: application/json' \\
+    -d '{"jsonrpc":"2.0","method":"capabilities/get","id":1}'
+`;
+    }
+    catch (error) {
+        return theme.error(`Failed to start ACP server: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function disableAcp() {
+    try {
+        const server = getGlobalAPIServer();
+        if (!server.isRunning()) {
+            return theme.info('ACP Server is already disabled.');
+        }
+        await server.stop();
+        return theme.success('ACP Server disabled');
+    }
+    catch (error) {
+        return theme.error(`Failed to stop ACP server: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function testAcpMethod(args) {
+    const method = args?.[0];
+    if (!method) {
+        return theme.error('Usage: /acp test <method> [params]');
+    }
+    const server = getGlobalAPIServer();
+    if (!server.isRunning()) {
+        return theme.error('ACP Server is not running. Use /acp enable [port] first.');
+    }
+    const port = server.getPort();
+    if (!port) {
+        return theme.error('Could not determine ACP server port.');
+    }
+    const paramsStr = args?.slice(1).join(' ') || '';
+    let params = undefined;
+    if (paramsStr) {
+        try {
+            params = JSON.parse(paramsStr);
+        }
+        catch {
+            return theme.error(`Invalid JSON params: ${paramsStr}`);
+        }
+    }
+    const request = {
+        jsonrpc: '2.0',
+        method,
+        params,
+        id: Math.floor(Math.random() * 1000000),
+    };
+    return `${theme.info('Test request:')}
+${JSON.stringify(request, null, 2)}
+
+${theme.info('Execute with:')}
+  curl -X POST http://localhost:${port}/acp \\
+    -H 'Content-Type: application/json' \\
+    -d '${JSON.stringify(request)}'
+
+${theme.muted('Expected responses:')}
+  • tools/list → array of available tools
+  • tool/call → requires toolName and args in params
+  • capabilities/get → server capabilities and version
+`;
+}
+function formatAcpHelp() {
+    return `${theme.brand('ACP (Agent Client Protocol) Commands')}
+
+${theme.muted('Usage:')} /acp [command] [options]
+
+${theme.muted('Commands:')}
+  status              show ACP server status and configuration
+  enable [port]       start ACP server on specified port (default 5173)
+  disable             stop the ACP server
+  test <method>       test an ACP method with sample request
+  help                show this help message
+
+${theme.muted('Examples:')}
+  /acp status
+  /acp enable 5173
+  /acp test tools/list
+  /acp test capabilities/get
+
+${theme.muted('ACP allows external agents to:')}
+  • List available iCopilot tools
+  • Execute iCopilot tools with parameters
+  • Query server capabilities and version
+`;
+}