@pheem49/mint 1.5.2 → 1.5.3

package/src/System/config_manager.js

@@ -39,6 +39,9 @@ const DEFAULT_CONFIG = {
     customBgStart: '#0f172a',
     customBgEnd: '#1e1b4b',
     customPanelBg: '#1e293b',
+    glassBlur: 'blur(16px)',
+    fontFamily: "'Outfit', sans-serif",
+    fontSize: '15px',
     apiKey: '',
     geminiModel: 'gemini-2.5-flash',
     language: 'th-TH',
@@ -187,4 +190,4 @@ function isPlaceholder(val) {
     return !val || val.startsWith('your_') || val.includes('key_here') || val.trim() === '';
 }
 
-module.exports = { readConfig, writeConfig, getAvailableProviders, isPlaceholder, CONFIG_PATH };
+module.exports = { readConfig, writeConfig, getAvailableProviders, isPlaceholder, CONFIG_PATH, CONFIG_DIR };

package/src/System/ipc_handlers.js

@@ -17,6 +17,8 @@ function registerIpcHandlers({
         getWeather,
         readConfig,
         writeConfig,
+        saveChatImages,
+        listSavedPictures,
         parseCommand,
         executeAction,
         getGoogleTtsUrls,
@@ -25,6 +27,10 @@ function registerIpcHandlers({
 
     ipcMain.handle('chat-message', async (event, message, base64Image = null, base64Audio = null) => {
         try {
+            if (base64Image && saveChatImages) {
+                saveChatImages(base64Image, { source: 'chat', message });
+            }
+
             const rawResponse = await handleChat(message, base64Image, base64Audio);
             const aiResponse = parseCommand(rawResponse);
 
@@ -79,6 +85,10 @@ function registerIpcHandlers({
 
     ipcMain.handle('get-chat-history', () => getChatTranscript());
 
+    ipcMain.handle('list-saved-pictures', () => {
+        return listSavedPictures ? listSavedPictures() : [];
+    });
+
     ipcMain.handle('open-settings', () => {
         windowManager.createSettingsWindow();
     });

package/src/System/picture_store.js

@@ -0,0 +1,109 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+const { pathToFileURL } = require('url');
+
+const PICTURES_DIR = path.join(os.homedir(), '.config', 'mint', 'Pictures');
+const INDEX_PATH = path.join(PICTURES_DIR, 'pictures.json');
+
+const EXTENSIONS = {
+    'image/png': 'png',
+    'image/jpeg': 'jpg',
+    'image/jpg': 'jpg',
+    'image/webp': 'webp',
+    'image/gif': 'gif'
+};
+
+function ensurePicturesDir() {
+    fs.mkdirSync(PICTURES_DIR, { recursive: true });
+}
+
+function readIndex() {
+    try {
+        if (!fs.existsSync(INDEX_PATH)) return [];
+        const parsed = JSON.parse(fs.readFileSync(INDEX_PATH, 'utf8'));
+        return Array.isArray(parsed) ? parsed : [];
+    } catch (error) {
+        console.error('[Pictures] Failed to read index:', error.message);
+        return [];
+    }
+}
+
+function writeIndex(entries) {
+    ensurePicturesDir();
+    fs.writeFileSync(INDEX_PATH, JSON.stringify(entries, null, 2), 'utf8');
+}
+
+function parseImageDataUri(dataUri) {
+    if (!dataUri || typeof dataUri !== 'string') return null;
+    const match = dataUri.match(/^data:(image\/[\w.+-]+);base64,([\s\S]+)$/);
+    if (!match) return null;
+
+    const mimeType = match[1].toLowerCase();
+    const extension = EXTENSIONS[mimeType] || 'png';
+    return {
+        mimeType,
+        extension,
+        buffer: Buffer.from(match[2], 'base64')
+    };
+}
+
+function createFilename(extension) {
+    const stamp = new Date().toISOString()
+        .replace(/[-:]/g, '')
+        .replace(/\..+$/, '')
+        .replace('T', '-');
+    const id = crypto.randomBytes(4).toString('hex');
+    return `mint-${stamp}-${id}.${extension}`;
+}
+
+function saveChatImages(base64Image, metadata = {}) {
+    const images = Array.isArray(base64Image) ? base64Image : (base64Image ? [base64Image] : []);
+    const saved = [];
+    if (images.length === 0) return saved;
+
+    ensurePicturesDir();
+    const index = readIndex();
+
+    for (const item of images) {
+        const parsed = parseImageDataUri(item);
+        if (!parsed || parsed.buffer.length === 0) continue;
+
+        const filename = createFilename(parsed.extension);
+        const filePath = path.join(PICTURES_DIR, filename);
+        fs.writeFileSync(filePath, parsed.buffer);
+
+        const entry = {
+            id: path.basename(filename, path.extname(filename)),
+            filename,
+            path: filePath,
+            mimeType: parsed.mimeType,
+            createdAt: new Date().toISOString(),
+            source: metadata.source || 'chat',
+            message: String(metadata.message || '').slice(0, 240)
+        };
+
+        index.unshift(entry);
+        saved.push(entry);
+    }
+
+    writeIndex(index);
+    return saved;
+}
+
+function listSavedPictures() {
+    ensurePicturesDir();
+    return readIndex()
+        .filter(entry => entry && entry.path && fs.existsSync(entry.path))
+        .map(entry => ({
+            ...entry,
+            url: pathToFileURL(entry.path).href
+        }));
+}
+
+module.exports = {
+    PICTURES_DIR,
+    saveChatImages,
+    listSavedPictures
+};

package/src/System/task_manager.js

@@ -57,6 +57,12 @@ function addTask(description) {
         createdAt: new Date().toISOString(),
         updatedAt: new Date().toISOString(),
         steps: [],
+        subtasks: [],
+        checkpoints: [],
+        artifacts: [],
+        retryCount: 0,
+        maxRetries: 1,
+        lastCheckpointAt: null,
         result: null
     };
     tasks.push(newTask);
@@ -80,6 +86,120 @@ function updateTask(id, updates) {
     return null;
 }
 
+function getTask(id) {
+    return readTasks().find(t => t.id === id) || null;
+}
+
+function normalizeTask(task) {
+    return {
+        ...task,
+        steps: Array.isArray(task.steps) ? task.steps : [],
+        subtasks: Array.isArray(task.subtasks) ? task.subtasks : [],
+        checkpoints: Array.isArray(task.checkpoints) ? task.checkpoints : [],
+        artifacts: Array.isArray(task.artifacts) ? task.artifacts : [],
+        retryCount: Number.isFinite(task.retryCount) ? task.retryCount : 0,
+        maxRetries: Number.isFinite(task.maxRetries) ? task.maxRetries : 1
+    };
+}
+
+function mutateTask(id, mutator) {
+    const tasks = readTasks();
+    const idx = tasks.findIndex(t => t.id === id);
+    if (idx === -1) return null;
+    const next = normalizeTask(tasks[idx]);
+    mutator(next);
+    next.updatedAt = new Date().toISOString();
+    tasks[idx] = next;
+    writeTasks(tasks);
+    return next;
+}
+
+function addSubtask(taskId, title, extra = {}) {
+    return mutateTask(taskId, task => {
+        task.subtasks.push({
+            id: `${taskId}-${task.subtasks.length + 1}`,
+            title,
+            status: extra.status || 'pending',
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            ...extra
+        });
+    });
+}
+
+function updateSubtask(taskId, subtaskId, updates = {}) {
+    return mutateTask(taskId, task => {
+        const subtask = task.subtasks.find(item => item.id === subtaskId);
+        if (!subtask) return;
+        Object.assign(subtask, updates, { updatedAt: new Date().toISOString() });
+    });
+}
+
+function addCheckpoint(taskId, checkpoint = {}) {
+    return mutateTask(taskId, task => {
+        const entry = {
+            id: `${taskId}-checkpoint-${task.checkpoints.length + 1}`,
+            time: new Date().toISOString(),
+            ...checkpoint
+        };
+        task.checkpoints.push(entry);
+        task.lastCheckpointAt = entry.time;
+        task.steps.push(entry);
+    });
+}
+
+function addArtifact(taskId, artifact = {}) {
+    return mutateTask(taskId, task => {
+        task.artifacts.push({
+            id: `${taskId}-artifact-${task.artifacts.length + 1}`,
+            time: new Date().toISOString(),
+            ...artifact
+        });
+    });
+}
+
+function failTaskWithRetry(id, errorMessage) {
+    return mutateTask(id, task => {
+        const retryCount = Number(task.retryCount) || 0;
+        const maxRetries = Number.isFinite(task.maxRetries) ? task.maxRetries : 1;
+        task.result = errorMessage;
+        task.retryCount = retryCount + 1;
+        task.status = task.retryCount <= maxRetries ? 'pending' : 'failed';
+        const checkpoint = {
+            id: `${id}-checkpoint-${task.checkpoints.length + 1}`,
+            time: new Date().toISOString(),
+            phase: task.status === 'pending' ? 'retry_scheduled' : 'failed',
+            message: errorMessage,
+            retryCount: task.retryCount,
+            maxRetries
+        };
+        task.checkpoints.push(checkpoint);
+        task.steps.push(checkpoint);
+    });
+}
+
+function resumeRunningTasks() {
+    const resumed = [];
+    const tasks = readTasks().map(task => {
+        if (task.status !== 'running') return task;
+        const normalized = normalizeTask(task);
+        normalized.status = 'pending';
+        const checkpoint = {
+            id: `${normalized.id}-checkpoint-${normalized.checkpoints.length + 1}`,
+            time: new Date().toISOString(),
+            phase: 'resume_after_restart',
+            message: 'Task was running during shutdown and has been re-queued.'
+        };
+        normalized.checkpoints.push(checkpoint);
+        normalized.steps.push(checkpoint);
+        normalized.updatedAt = new Date().toISOString();
+        resumed.push(normalized);
+        return normalized;
+    });
+    writeTasks(tasks);
+    return resumed;
+}
+
 function clearCompletedTasks() {
     const tasks = readTasks();
     const activeTasks = tasks.filter(t => t.status === 'pending' || t.status === 'running');
@@ -88,8 +208,15 @@ function clearCompletedTasks() {
 
 module.exports = {
     addTask,
+    addArtifact,
+    addCheckpoint,
+    addSubtask,
+    failTaskWithRetry,
+    getTask,
     getPendingTask,
+    resumeRunningTasks,
     updateTask,
+    updateSubtask,
     readTasks,
     clearCompletedTasks
 };

package/src/System/tool_registry.js

@@ -41,6 +41,19 @@ const TOOL_REGISTRY = Object.freeze({
         important: true,
         description: 'Run a non-destructive shell command after user approval.'
     },
+    verify: {
+        permission: 'approval',
+        required: [],
+        codeAgentOnly: true,
+        important: true,
+        description: 'Run test/build/lint verification commands after user approval.'
+    },
+    plan: {
+        permission: 'approval',
+        required: ['plan'],
+        codeAgentOnly: true,
+        description: 'Present a multi-file edit plan before changing files.'
+    },
     apply_patch: {
         permission: 'approval',
         required: ['patch'],

package/src/System/window_manager.js

@@ -9,12 +9,19 @@ function createWindowManager(projectRoot) {
     let tray = null;
 
     function createMainWindow() {
+        const iconPath = path.join(projectRoot, 'assets', 'icon.png');
+        const { width: screenWidth, height: screenHeight } = screen.getPrimaryDisplay().workAreaSize;
+        const windowWidth = Math.min(1360, Math.max(1180, screenWidth - 40));
+        const windowHeight = Math.min(920, Math.max(860, screenHeight - 40));
+
         mainWindow = new BrowserWindow({
-            width: 1180,
-            height: 860,
+            width: windowWidth,
+            height: windowHeight,
             minWidth: 900,
             minHeight: 680,
-            icon: path.join(projectRoot, 'assets', 'icon.png'),
+            x: Math.floor((screenWidth - windowWidth) / 2),
+            y: Math.floor((screenHeight - windowHeight) / 2),
+            icon: nativeImage.createFromPath(iconPath),
             webPreferences: {
                 preload: path.join(projectRoot, 'preload.js'),
                 nodeIntegration: false,
@@ -75,12 +82,13 @@ function createWindowManager(projectRoot) {
             return settingsWindow;
         }
 
+        const iconPath = path.join(projectRoot, 'assets', 'icon.png');
         settingsWindow = new BrowserWindow({
-            width: 720,
-            height: 620,
-            minWidth: 640,
-            minHeight: 560,
-            icon: path.join(projectRoot, 'assets', 'icon.png'),
+            width: 1020,
+            height: 720,
+            minWidth: 860,
+            minHeight: 620,
+            icon: nativeImage.createFromPath(iconPath),
             webPreferences: {
                 preload: path.join(projectRoot, 'preload-settings.js'),
                 nodeIntegration: false,

package/src/UI/live2d_manager.js

@@ -18,6 +18,9 @@ window.Live2DManager = {
         cat: { paramId: 'Param54', label: 'Cat Filter' }
     },
     pointerTrackingEnabled: true,
+    zoomMultiplier: 1,
+    interactionZoneOrigin: { x: 0.5, y: 0.58 },
+    fitModelToMount: null,
     pointerTrackingFrame: null,
     pointerTracking: {
         targetX: 0,
@@ -135,7 +138,7 @@ window.Live2DManager = {
                 const heightScale = mountHeight / Math.max(modelHeight, 1);
                 
                 // Reduced zoom to 2.0 as requested
-                const scale = Math.min(widthScale, heightScale) * 1.85;
+                const scale = Math.min(widthScale, heightScale) * 1.85 * this.zoomMultiplier;
 
                 this.model.scale.set(scale);
                 // Adjusted Y offset to 1.0 as requested
@@ -145,6 +148,7 @@ window.Live2DManager = {
                 };
                 this.applyModelFollowOffset();
             };
+            this.fitModelToMount = fitModel;
 
             requestAnimationFrame(() => {
                 fitModel();
@@ -214,9 +218,9 @@ window.Live2DManager = {
         try {
             const point = this.getPointerViewportPoint(event);
             if (!point) return null;
-            const { x, y } = point;
+            const { x, y } = this.toInteractionZonePoint(point);
 
-            if (this.isPointInZone(x, y, 0.38, 0.40, 0.24, 0.115)) {
+            if (this.isPointInZone(x, y, 0.36, 0.375, 0.28, 0.12)) {
                 return {
                     id: 'face',
                     label: 'Cat Ears',
@@ -225,7 +229,7 @@ window.Live2DManager = {
                 };
             }
 
-            if (this.isPointInZone(x, y, 0.34, 0.255, 0.32, 0.15)) {
+            if (this.isPointInZone(x, y, 0.34, 0.205, 0.32, 0.155)) {
                 return {
                     id: 'head',
                     label: 'Head Pat',
@@ -234,8 +238,8 @@ window.Live2DManager = {
                 };
             }
 
-            const isLeftHand = this.isPointInZone(x, y, 0.22, 0.68, 0.20, 0.16);
-            const isRightHand = this.isPointInZone(x, y, 0.61, 0.68, 0.19, 0.16);
+            const isLeftHand = this.isPointInZone(x, y, 0.14, 0.70, 0.22, 0.16);
+            const isRightHand = this.isPointInZone(x, y, 0.65, 0.69, 0.23, 0.17);
             if (isLeftHand || isRightHand) {
                 return {
                     id: isLeftHand ? 'left-hand' : 'right-hand',
@@ -245,7 +249,7 @@ window.Live2DManager = {
                 };
             }
 
-            if (this.isPointInZone(x, y, 0.38, 0.77, 0.30, 0.23)) {
+            if (this.isPointInZone(x, y, 0.34, 0.74, 0.30, 0.24)) {
                 return {
                     id: 'lower-body',
                     label: 'Careful',
@@ -254,7 +258,7 @@ window.Live2DManager = {
                 };
             }
 
-            if (this.isPointInZone(x, y, 0.37, 0.555, 0.29, 0.14)) {
+            if (this.isPointInZone(x, y, 0.36, 0.53, 0.29, 0.145)) {
                 return {
                     id: 'body',
                     label: 'Shoulder Tap',
@@ -293,6 +297,17 @@ window.Live2DManager = {
         return x >= left && x <= left + width && y >= top && y <= top + height;
     },
 
+    toInteractionZonePoint(point) {
+        const scale = this.zoomMultiplier || 1;
+        if (Math.abs(scale - 1) < 0.001) return point;
+
+        const origin = this.interactionZoneOrigin;
+        return {
+            x: origin.x + (point.x - origin.x) / scale,
+            y: origin.y + (point.y - origin.y) / scale
+        };
+    },
+
     cycleExpression() {
         if (!this.model) return;
         this.expIndex = (this.expIndex + 1) % this.expressionNames.length;
@@ -316,6 +331,25 @@ window.Live2DManager = {
         this.model.buttonMode = this.interactionEnabled;
     },
 
+    setPointerTrackingEnabled(isEnabled) {
+        this.pointerTrackingEnabled = Boolean(isEnabled);
+        if (this.pointerTrackingEnabled) return;
+
+        this.resetPointerTrackingTarget();
+        this.pointerTracking.currentX = 0;
+        this.pointerTracking.currentY = 0;
+        this.applyModelFollowOffset();
+    },
+
+    setZoomMultiplier(multiplier) {
+        const value = Number(multiplier);
+        this.zoomMultiplier = this.clamp(Number.isFinite(value) ? value : 1, 0.78, 1.28);
+        document.documentElement.style.setProperty('--model-zone-scale', String(this.zoomMultiplier));
+        if (typeof this.fitModelToMount === 'function') {
+            this.fitModelToMount();
+        }
+    },
+
     getSavedInteractionEnabled() {
         try {
             return localStorage.getItem(this.interactionStorageKey) !== 'false';