icopilot 2.2.0

package/dist/session/bookmarks.js

@@ -0,0 +1,72 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { config } from '../config.js';
+const NAME_PATTERN = /^[a-z0-9][a-z0-9_-]{0,32}$/i;
+export function bookmarksPath() {
+    fs.mkdirSync(config.sessionDir, { recursive: true });
+    return path.join(config.sessionDir, 'bookmarks.json');
+}
+export function listBookmarks(sessionId) {
+    const bookmarks = readBookmarks();
+    return sessionId ? bookmarks.filter((bookmark) => bookmark.sessionId === sessionId) : bookmarks;
+}
+export function addBookmark(sessionId, name, index, preview) {
+    if (!NAME_PATTERN.test(name)) {
+        throw new Error('Bookmark name must match /^[a-z0-9][a-z0-9_-]{0,32}$/i.');
+    }
+    const bookmarks = readBookmarks();
+    const bookmark = {
+        sessionId,
+        name,
+        index,
+        createdAt: new Date().toISOString(),
+        preview,
+    };
+    const existing = bookmarks.findIndex((item) => item.sessionId === sessionId && item.name === name);
+    if (existing === -1) {
+        bookmarks.push(bookmark);
+    }
+    else {
+        bookmarks[existing] = bookmark;
+    }
+    writeBookmarks(bookmarks);
+    return bookmark;
+}
+export function getBookmark(sessionId, name) {
+    return (readBookmarks().find((bookmark) => bookmark.sessionId === sessionId && bookmark.name === name) ?? null);
+}
+export function deleteBookmark(sessionId, name) {
+    const bookmarks = readBookmarks();
+    const remaining = bookmarks.filter((bookmark) => bookmark.sessionId !== sessionId || bookmark.name !== name);
+    if (remaining.length === bookmarks.length)
+        return false;
+    writeBookmarks(remaining);
+    return true;
+}
+function readBookmarks() {
+    const file = bookmarksPath();
+    try {
+        if (!fs.existsSync(file))
+            return [];
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter(isBookmark);
+    }
+    catch {
+        return [];
+    }
+}
+function writeBookmarks(bookmarks) {
+    fs.writeFileSync(bookmarksPath(), JSON.stringify(bookmarks, null, 2), 'utf8');
+}
+function isBookmark(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const bookmark = value;
+    return (typeof bookmark.sessionId === 'string' &&
+        typeof bookmark.name === 'string' &&
+        typeof bookmark.index === 'number' &&
+        typeof bookmark.createdAt === 'string' &&
+        typeof bookmark.preview === 'string');
+}

package/dist/session/cloud-session.js

@@ -0,0 +1,291 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+const CLOUD_STORE_VERSION = 1;
+const CLOUD_SESSIONS_PATH_ENV = 'ICOPILOT_CLOUD_SESSIONS_PATH';
+class SimulatedCloudHttpClient {
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    async create(config, opts) {
+        return this.mutate((store) => {
+            const now = new Date().toISOString();
+            const record = {
+                id: randomUUID(),
+                name: opts?.name?.trim() || `cloud-${new Date(now).toISOString().slice(0, 19)}`,
+                endpoint: config.endpoint,
+                status: 'connected',
+                createdAt: now,
+                updatedAt: now,
+                messageCount: 0,
+                messages: [],
+            };
+            store.currentSessionId = record.id;
+            for (const session of store.sessions)
+                session.status = 'idle';
+            store.sessions.unshift(record);
+            return cloneRecord(record);
+        });
+    }
+    async connect(sessionId) {
+        return this.mutate((store) => {
+            const session = store.sessions.find((entry) => entry.id === sessionId);
+            if (!session)
+                throw new Error(`Cloud session not found: ${sessionId}`);
+            const now = new Date().toISOString();
+            store.currentSessionId = sessionId;
+            for (const entry of store.sessions)
+                entry.status = entry.id === sessionId ? 'connected' : 'idle';
+            session.updatedAt = now;
+            return cloneRecord(session);
+        });
+    }
+    async disconnect() {
+        await this.mutate((store) => {
+            store.currentSessionId = undefined;
+            for (const session of store.sessions)
+                session.status = 'idle';
+            return undefined;
+        });
+    }
+    async send(sessionId, message) {
+        return this.mutate((store) => {
+            const session = store.sessions.find((entry) => entry.id === sessionId);
+            if (!session)
+                throw new Error(`Cloud session not found: ${sessionId}`);
+            const now = new Date().toISOString();
+            const reply = `[simulated-cloud] received: ${message}`;
+            const outgoing = [
+                { id: randomUUID(), role: 'user', content: message, createdAt: now },
+                { id: randomUUID(), role: 'assistant', content: reply, createdAt: now },
+            ];
+            session.messages.push(...outgoing);
+            if (session.snapshot) {
+                session.snapshot.messages.push({ role: 'user', content: message }, { role: 'assistant', content: reply });
+            }
+            session.messageCount = session.messages.length;
+            session.lastMessage = reply;
+            session.updatedAt = now;
+            return {
+                sessionId: session.id,
+                response: reply,
+                messageCount: session.messageCount,
+            };
+        });
+    }
+    async list() {
+        const store = this.read();
+        return store.sessions
+            .map((session) => cloneRecord(session))
+            .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    }
+    async destroy(sessionId) {
+        return this.mutate((store) => {
+            const before = store.sessions.length;
+            store.sessions = store.sessions.filter((entry) => entry.id !== sessionId);
+            if (store.currentSessionId === sessionId)
+                store.currentSessionId = undefined;
+            return store.sessions.length !== before;
+        });
+    }
+    async getStatus(sessionId) {
+        const store = this.read();
+        const session = store.sessions.find((entry) => entry.id === sessionId);
+        if (!session) {
+            return { id: sessionId, exists: false, status: 'missing', messageCount: 0 };
+        }
+        return {
+            id: session.id,
+            exists: true,
+            status: session.status,
+            updatedAt: session.updatedAt,
+            lastSyncedAt: session.lastSyncedAt,
+            messageCount: session.messageCount,
+        };
+    }
+    async sync(sessionId, localSession) {
+        return this.mutate((store) => {
+            const session = store.sessions.find((entry) => entry.id === sessionId);
+            if (!session)
+                throw new Error(`Cloud session not found: ${sessionId}`);
+            const now = new Date().toISOString();
+            session.snapshot = cloneState(localSession.state);
+            session.messages = localSession.state.messages.map(toCloudMessage);
+            session.messageCount = session.messages.length;
+            session.lastMessage = session.messages.at(-1)?.content;
+            session.lastSyncedAt = now;
+            session.updatedAt = now;
+            session.status = store.currentSessionId === sessionId ? 'connected' : session.status;
+            return cloneRecord(session);
+        });
+    }
+    currentSessionId() {
+        return this.read().currentSessionId;
+    }
+    mutate(operation) {
+        const store = this.read();
+        const result = operation(store);
+        this.write(store);
+        return result;
+    }
+    read() {
+        ensureParentDirectory(this.filePath);
+        if (!fs.existsSync(this.filePath)) {
+            return { version: CLOUD_STORE_VERSION, sessions: [] };
+        }
+        try {
+            const parsed = JSON.parse(fs.readFileSync(this.filePath, 'utf8'));
+            if (!parsed || typeof parsed !== 'object')
+                return { version: CLOUD_STORE_VERSION, sessions: [] };
+            return {
+                version: CLOUD_STORE_VERSION,
+                currentSessionId: typeof parsed.currentSessionId === 'string' ? parsed.currentSessionId : undefined,
+                sessions: Array.isArray(parsed.sessions)
+                    ? parsed.sessions.map(normalizeRecord).filter(isPresent)
+                    : [],
+            };
+        }
+        catch {
+            return { version: CLOUD_STORE_VERSION, sessions: [] };
+        }
+    }
+    write(store) {
+        ensureParentDirectory(this.filePath);
+        fs.writeFileSync(this.filePath, JSON.stringify(store, null, 2), 'utf8');
+    }
+}
+export class CloudSession {
+    config;
+    client;
+    currentId;
+    constructor(config) {
+        this.config = config;
+        this.currentId = config.sessionId;
+        this.client = new SimulatedCloudHttpClient(resolveCloudSessionsPath());
+    }
+    async create(opts) {
+        const session = await this.client.create(this.config, opts);
+        this.currentId = session.id;
+        return session;
+    }
+    async connect(sessionId) {
+        const session = await this.client.connect(sessionId);
+        this.currentId = session.id;
+        return session;
+    }
+    async disconnect() {
+        await this.client.disconnect();
+        this.currentId = undefined;
+    }
+    async send(message) {
+        const sessionId = this.getConnectedSessionId();
+        if (!sessionId)
+            throw new Error('No cloud session connected.');
+        return this.client.send(sessionId, message);
+    }
+    async list() {
+        return this.client.list();
+    }
+    async destroy(sessionId) {
+        const destroyed = await this.client.destroy(sessionId);
+        if (destroyed && this.currentId === sessionId)
+            this.currentId = undefined;
+        return destroyed;
+    }
+    async getStatus(sessionId) {
+        return this.client.getStatus(sessionId);
+    }
+    async sync(sessionId, localSession) {
+        const synced = await this.client.sync(sessionId, localSession);
+        if (!this.currentId)
+            this.currentId = sessionId;
+        return synced;
+    }
+    getConnectedSessionId() {
+        return this.currentId || this.client.currentSessionId();
+    }
+}
+function resolveCloudSessionsPath() {
+    return (process.env[CLOUD_SESSIONS_PATH_ENV] ||
+        path.join(os.homedir(), '.icopilot', 'cloud-sessions.json'));
+}
+function ensureParentDirectory(filePath) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+function normalizeRecord(record) {
+    if (!record || typeof record !== 'object')
+        return null;
+    const candidate = record;
+    if (typeof candidate.id !== 'string')
+        return null;
+    return {
+        id: candidate.id,
+        name: typeof candidate.name === 'string' && candidate.name.trim() ? candidate.name : candidate.id,
+        endpoint: typeof candidate.endpoint === 'string' ? candidate.endpoint : '',
+        status: candidate.status === 'connected' ? 'connected' : 'idle',
+        createdAt: typeof candidate.createdAt === 'string' ? candidate.createdAt : new Date().toISOString(),
+        updatedAt: typeof candidate.updatedAt === 'string' ? candidate.updatedAt : new Date().toISOString(),
+        lastSyncedAt: typeof candidate.lastSyncedAt === 'string' ? candidate.lastSyncedAt : undefined,
+        messageCount: typeof candidate.messageCount === 'number' ? candidate.messageCount : 0,
+        lastMessage: typeof candidate.lastMessage === 'string' ? candidate.lastMessage : undefined,
+        messages: Array.isArray(candidate.messages)
+            ? candidate.messages.map(normalizeMessage).filter(isPresent)
+            : [],
+        snapshot: candidate.snapshot ? cloneState(candidate.snapshot) : undefined,
+    };
+}
+function normalizeMessage(message) {
+    if (!message || typeof message !== 'object')
+        return null;
+    const candidate = message;
+    if (typeof candidate.id !== 'string' || typeof candidate.content !== 'string')
+        return null;
+    return {
+        id: candidate.id,
+        role: typeof candidate.role === 'string' ? candidate.role : 'message',
+        content: candidate.content,
+        createdAt: typeof candidate.createdAt === 'string' ? candidate.createdAt : new Date().toISOString(),
+    };
+}
+function toCloudMessage(message) {
+    return {
+        id: randomUUID(),
+        role: typeof message.role === 'string' ? message.role : 'message',
+        content: contentToText(message.content),
+        createdAt: new Date().toISOString(),
+    };
+}
+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 cloneRecord(record) {
+    return {
+        ...record,
+        messages: record.messages.map((message) => ({ ...message })),
+        snapshot: record.snapshot ? cloneState(record.snapshot) : undefined,
+    };
+}
+function cloneState(state) {
+    return JSON.parse(JSON.stringify(state));
+}
+function isPresent(value) {
+    return value !== null;
+}