mcp-for-i 0.1.6 → 0.1.7

package/dist/config/store.js

@@ -17,7 +17,10 @@ const defaultSettings = {
     objectFilters: [],
     ifsShortcuts: [],
     debugPort: 8005,
-    debugSepPort: 8008
+    debugSepPort: 8008,
+    sessionIdleMinutes: 30,
+    sessionPingSeconds: 15,
+    sessionReconnectAttempts: 2
 };
 export class ConfigStore {
     configDir;

package/dist/controlplane/connectionService.js

@@ -35,7 +35,7 @@ export class ConnectionService {
             port: input.port ?? existing.port,
             username: input.username ?? existing.username,
             privateKeyPath: input.privateKeyPath ?? existing.privateKeyPath,
-            settings: input.settings ?? existing.settings,
+            settings: input.settings ? { ...(existing.settings || {}), ...input.settings } : existing.settings,
             policy: input.policy ?? existing.policy
         };
         await this.store.upsertConnection(next);

package/dist/controlplane/server.js

@@ -1,9 +1,10 @@
 import http from "http";
 import fs from "fs";
+import fsp from "fs/promises";
 import path from "path";
 import { URL } from "url";
 import { fileURLToPath } from "url";
-import { ConfigStore } from "../config/store.js";
+import { ConfigStore, getConfigDir } from "../config/store.js";
 import { isKeychainAvailable } from "../security/credentialStore.js";
 import { ConnectionService } from "./connectionService.js";
 import { RuntimeService } from "./runtimeService.js";
@@ -17,7 +18,7 @@ export async function startControlPlaneServer(opts) {
     const runtime = new RuntimeService(rootDir);
     const server = http.createServer(async (req, res) => {
         try {
-            await routeRequest(req, res, { connections, runtime });
+            await routeRequest(req, res, { store, connections, runtime });
         }
         catch (err) {
             sendJson(res, 500, { error: err?.message || String(err) });
@@ -48,6 +49,42 @@ async function routeRequest(req, res, services) {
         sendJson(res, 200, { ok: true, keychainAvailable: await isKeychainAvailable() });
         return;
     }
+    if (method === "GET" && pathname === "/api/settings") {
+        const settings = await services.store.getSettings();
+        sendJson(res, 200, { settings });
+        return;
+    }
+    if (method === "PUT" && pathname === "/api/settings") {
+        const body = await readJson(req);
+        const update = {};
+        try {
+            if (typeof body.sessionIdleMinutes !== "undefined") {
+                update.sessionIdleMinutes = parseNumberSetting(body.sessionIdleMinutes, 1, 24 * 60, "sessionIdleMinutes");
+            }
+            if (typeof body.sessionPingSeconds !== "undefined") {
+                update.sessionPingSeconds = parseNumberSetting(body.sessionPingSeconds, 5, 300, "sessionPingSeconds");
+            }
+            if (typeof body.sessionReconnectAttempts !== "undefined") {
+                update.sessionReconnectAttempts = parseNumberSetting(body.sessionReconnectAttempts, 1, 5, "sessionReconnectAttempts");
+            }
+        }
+        catch (err) {
+            sendJson(res, 400, { error: err?.message || String(err) });
+            return;
+        }
+        if (Object.keys(update).length === 0) {
+            sendJson(res, 400, { error: "No supported settings provided" });
+            return;
+        }
+        await services.store.updateSettings(update);
+        const settings = await services.store.getSettings();
+        sendJson(res, 200, { settings });
+        return;
+    }
+    if (method === "GET" && pathname === "/api/sessions") {
+        sendJson(res, 200, { snapshot: await readSessionSnapshot() });
+        return;
+    }
     if (method === "GET" && pathname === "/api/runtime/status") {
         sendJson(res, 200, { jobs: services.runtime.getStatus() });
         return;
@@ -197,3 +234,27 @@ function getDefaultRootDir() {
     }
     return process.cwd();
 }
+function parseNumberSetting(input, min, max, key) {
+    const value = Number(input);
+    if (!Number.isFinite(value)) {
+        throw new Error(`${key} must be a number`);
+    }
+    const normalized = Math.floor(value);
+    if (normalized < min || normalized > max) {
+        throw new Error(`${key} must be between ${min} and ${max}`);
+    }
+    return normalized;
+}
+async function readSessionSnapshot() {
+    const snapshotPath = path.join(getConfigDir(), "session-state.json");
+    try {
+        const raw = await fsp.readFile(snapshotPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object")
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}