@trops/dash-core 0.1.287 → 0.1.289

package/dist/electron/index.js

@@ -31578,6 +31578,77 @@ var schedulerController_1 = schedulerController$2;
 	    } catch (error) {
 	      console.error("[WidgetRegistry] Error loading registry:", error);
 	    }
+
+	    // Reconcile: re-register orphaned widget packages found on disk
+	    this.reconcileWithDisk();
+	  }
+
+	  /**
+	   * Scan the widgets directory for packages that exist on disk but are
+	   * missing from the registry (e.g. because registry.json was manually edited).
+	   * Re-registers them so they can be properly managed (listed, uninstalled).
+	   */
+	  reconcileWithDisk() {
+	    try {
+	      if (!WIDGETS_CACHE_DIR || !fs.existsSync(WIDGETS_CACHE_DIR)) return;
+
+	      const registeredPaths = new Set(
+	        Array.from(this.widgets.values()).map((w) => w.path),
+	      );
+	      let reconciled = false;
+
+	      const entries = fs.readdirSync(WIDGETS_CACHE_DIR, {
+	        withFileTypes: true,
+	      });
+	      for (const entry of entries) {
+	        if (!entry.isDirectory()) continue;
+
+	        if (entry.name.startsWith("@")) {
+	          // Scoped packages: @scope/name
+	          const scopeDir = path.join(WIDGETS_CACHE_DIR, entry.name);
+	          const pkgs = fs.readdirSync(scopeDir, { withFileTypes: true });
+	          for (const pkg of pkgs) {
+	            if (!pkg.isDirectory()) continue;
+	            const pkgPath = path.join(scopeDir, pkg.name);
+	            const pkgId = `${entry.name}/${pkg.name}`;
+	            if (!registeredPaths.has(pkgPath) && !this.widgets.has(pkgId)) {
+	              this._reregisterOrphan(pkgId, pkgPath);
+	              reconciled = true;
+	            }
+	          }
+	        } else if (entry.name !== "registry.json") {
+	          // Bare-name packages
+	          const pkgPath = path.join(WIDGETS_CACHE_DIR, entry.name);
+	          if (!registeredPaths.has(pkgPath) && !this.widgets.has(entry.name)) {
+	            this._reregisterOrphan(entry.name, pkgPath);
+	            reconciled = true;
+	          }
+	        }
+	      }
+
+	      if (reconciled) {
+	        this.saveRegistry();
+	        console.log("[WidgetRegistry] Disk reconciliation complete");
+	      }
+	    } catch (err) {
+	      console.warn("[WidgetRegistry] Reconciliation error:", err.message);
+	    }
+	  }
+
+	  /**
+	   * Re-register an orphaned widget package found on disk.
+	   */
+	  _reregisterOrphan(pkgId, pkgPath) {
+	    console.log(`[WidgetRegistry] Re-registering orphaned widget: ${pkgId}`);
+	    const { scope } = parsePackageId(pkgId);
+	    this.widgets.set(pkgId, {
+	      name: pkgId,
+	      packageId: pkgId,
+	      scope: scope || null,
+	      path: pkgPath,
+	      version: null,
+	      orphaned: true,
+	    });
 	  }
 
 	  /**
@@ -32171,10 +32242,23 @@ var schedulerController_1 = schedulerController$2;
 	   * @param {string} widgetName - Name of the widget to remove
 	   */
 	  uninstallWidget(widgetName) {
-	    const widget = this.widgets.get(widgetName);
+	    let widget = this.widgets.get(widgetName);
+
+	    // Fallback: widget not in registry but might exist on disk
 	    if (!widget) {
-	      console.warn(`[WidgetRegistry] Widget not found: ${widgetName}`);
-	      return false;
+	      const candidatePath = path.join(
+	        WIDGETS_CACHE_DIR,
+	        ...widgetName.split("/"),
+	      );
+	      if (fs.existsSync(candidatePath)) {
+	        widget = { path: candidatePath };
+	        console.log(
+	          `[WidgetRegistry] Widget ${widgetName} not in registry, removing from disk`,
+	        );
+	      } else {
+	        console.warn(`[WidgetRegistry] Widget not found: ${widgetName}`);
+	        return false;
+	      }
 	    }
 
 	    try {
@@ -32347,7 +32431,13 @@ var schedulerController_1 = schedulerController$2;
 	  ipcMain.handle("widget:uninstall", (event, widgetName) => {
 	    const schedulerController = schedulerController_1;
 	    schedulerController.cleanupWidget(widgetName);
-	    return getWidgetRegistry().uninstallWidget(widgetName);
+	    const success = getWidgetRegistry().uninstallWidget(widgetName);
+	    if (success) {
+	      BrowserWindow.getAllWindows().forEach((win) => {
+	        win.webContents.send("widget:uninstalled", { widgetName });
+	      });
+	    }
+	    return success;
 	  });
 
 	  ipcMain.handle("widget:cache-path", () => getWidgetRegistry().getCachePath());
@@ -67484,7 +67574,7 @@ const registeredPrompts = [];
  * Register a tool to be exposed via the MCP server.
  * Call this before starting the server (or restart after registering).
  */
-function registerTool$5(toolDef) {
+function registerTool$6(toolDef) {
   registeredTools.push(toolDef);
 }
 
@@ -67847,7 +67937,7 @@ const mcpDashServerController$4 = {
   },
 
   // Expose registration functions for other controllers
-  registerTool: registerTool$5,
+  registerTool: registerTool$6,
   registerResource: registerResource$1,
   registerPrompt: registerPrompt$1,
   getServerContext,
@@ -68929,6 +69019,23 @@ const widgetApi$2 = {
     });
   },
 
+  /**
+   * Listen for widget uninstallation events
+   * Useful for cleaning up ComponentManager entries and refreshing UI
+   *
+   * @param {Function} callback - Function called when a widget is uninstalled
+   *
+   * @example
+   * mainApi.widgets.onUninstalled(({ widgetName }) => {
+   *   console.log(`Widget ${widgetName} was uninstalled!`);
+   * });
+   */
+  onUninstalled: (callback) => {
+    ipcRenderer$k.on("widget:uninstalled", (event, data) => {
+      callback(data);
+    });
+  },
+
   /**
    * Listen for batch widget loading events
    * Useful for updating UI when multiple widgets are loaded at once
@@ -68956,6 +69063,15 @@ const widgetApi$2 = {
     ipcRenderer$k.removeListener("widget:installed", callback);
   },
 
+  /**
+   * Remove listener for widget uninstallation events
+   *
+   * @param {Function} callback - The callback to remove
+   */
+  removeUninstalledListener: (callback) => {
+    ipcRenderer$k.removeListener("widget:uninstalled", callback);
+  },
+
   /**
    * Remove listener for batch widget loading events
    *
@@ -70437,7 +70553,7 @@ const dashboardTools$1 = [
   {
     name: "create_dashboard",
     description:
-      "Create a new empty dashboard with the given name. Returns the dashboard ID. After creating, use search_widgets or list_widgets to find widgets, then add_widget to populate the dashboard.",
+      "Create a new dashboard with the given name. Optionally provide a layout to create a grid dashboard. Returns the dashboard ID. After creating, use search_widgets or list_widgets to find widgets, then add_widget to populate the dashboard.",
     inputSchema: {
       type: "object",
       properties: {
@@ -70445,6 +70561,32 @@ const dashboardTools$1 = [
           type: "string",
           description: "Display name for the new dashboard",
         },
+        layout: {
+          type: "object",
+          description:
+            "Optional grid layout configuration. When provided, creates a grid dashboard instead of a simple container.",
+          properties: {
+            rows: {
+              type: "number",
+              description: "Number of rows (1-10)",
+            },
+            cols: {
+              type: "number",
+              description: "Number of columns (1-10)",
+            },
+            gap: {
+              type: "string",
+              description:
+                "Tailwind gap class (e.g. 'gap-2', 'gap-4'). Defaults to 'gap-2'.",
+            },
+            colModes: {
+              type: "object",
+              description:
+                "Per-row column sizing. Keys are row numbers (as strings), values are mode strings: 'equal', '1/4', '1/3', '1/2', '2/3'.",
+            },
+          },
+          required: ["rows", "cols"],
+        },
       },
       required: ["name"],
     },
@@ -70480,7 +70622,7 @@ const widgetTools$1 = [
   {
     name: "add_widget",
     description:
-      "Add a widget to a dashboard by component name. Call list_widgets or search_widgets first to discover available widget names. Can be called multiple times to add multiple widgets. Returns the widget instance ID for use with configure_widget.",
+      "Add a widget to a dashboard by component name. Call list_widgets or search_widgets first to discover available widget names. Can be called multiple times to add multiple widgets. Returns the widget instance ID for use with configure_widget. If the dashboard has a grid layout, you can specify row/col for explicit placement, or omit them to auto-place in the next empty cell.",
     inputSchema: {
       type: "object",
       properties: {
@@ -70494,6 +70636,16 @@ const widgetTools$1 = [
           description:
             "Component name of the widget to add (e.g. 'Clock', 'WeatherWidget')",
         },
+        row: {
+          type: "number",
+          description:
+            "Grid row to place the widget in (1-indexed). Must be used together with col. Requires a grid layout on the dashboard.",
+        },
+        col: {
+          type: "number",
+          description:
+            "Grid column to place the widget in (1-indexed). Must be used together with row.",
+        },
       },
       required: ["widgetName"],
     },
@@ -70744,12 +70896,108 @@ const providerTools$1 = [
   },
 ];
 
+const layoutTools$1 = [
+  {
+    name: "set_layout",
+    description:
+      "Set or replace the grid layout on a dashboard. Creates a LayoutGridContainer with the specified dimensions. Existing widgets in cells that fit the new grid are preserved; widgets outside the new bounds are orphaned (kept but unassigned). Use this to add a grid to an existing dashboard or to resize the grid.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        dashboardId: {
+          type: "string",
+          description: "Dashboard ID. Omit to use the active dashboard.",
+        },
+        rows: {
+          type: "number",
+          description: "Number of rows (1-10)",
+        },
+        cols: {
+          type: "number",
+          description: "Number of columns (1-10)",
+        },
+        gap: {
+          type: "string",
+          description:
+            "Tailwind gap class (e.g. 'gap-2', 'gap-4'). Defaults to 'gap-2'.",
+        },
+        colModes: {
+          type: "object",
+          description:
+            "Per-row column sizing. Keys are row numbers (as strings), values are mode strings: 'equal', '1/4', '1/3', '1/2', '2/3'.",
+        },
+      },
+      required: ["rows", "cols"],
+    },
+  },
+  {
+    name: "update_layout",
+    description:
+      "Partially update the grid layout. Only specified properties change — omitted properties keep their current values. colModes is merged (not replaced). Widgets in removed rows/columns are orphaned. Dashboard must already have a grid layout.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        dashboardId: {
+          type: "string",
+          description: "Dashboard ID. Omit to use the active dashboard.",
+        },
+        rows: {
+          type: "number",
+          description: "New number of rows (1-10). Omit to keep current.",
+        },
+        cols: {
+          type: "number",
+          description: "New number of columns (1-10). Omit to keep current.",
+        },
+        gap: {
+          type: "string",
+          description: "Tailwind gap class. Omit to keep current.",
+        },
+        colModes: {
+          type: "object",
+          description:
+            "Column sizing modes to merge. Set a key to null to reset that row to default.",
+        },
+      },
+      required: [],
+    },
+  },
+  {
+    name: "move_widget",
+    description:
+      "Move a widget to a different grid cell. If the target cell is occupied, the two widgets are swapped. The widget must already be placed in a grid cell. Use get_dashboard to find widget IDs and current positions.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        dashboardId: {
+          type: "string",
+          description: "Dashboard ID. Omit to use the active dashboard.",
+        },
+        widgetId: {
+          type: "string",
+          description: "ID of the widget to move",
+        },
+        row: {
+          type: "number",
+          description: "Target row (1-indexed)",
+        },
+        col: {
+          type: "number",
+          description: "Target column (1-indexed)",
+        },
+      },
+      required: ["widgetId", "row", "col"],
+    },
+  },
+];
+
 var toolDefinitions = {
   dashboardTools: dashboardTools$1,
   widgetTools: widgetTools$1,
   themeTools: themeTools$1,
   providerTools: providerTools$1,
   guideTools: guideTools$1,
+  layoutTools: layoutTools$1,
 };
 
 /**
@@ -70905,7 +71153,7 @@ async function handleGetDashboard$1({ dashboardId }) {
 /**
  * create_dashboard — Creates a new workspace with the given name.
  */
-async function handleCreateDashboard$1({ name }) {
+async function handleCreateDashboard$1({ name, layout }) {
   if (!name || typeof name !== "string" || !name.trim()) {
     return {
       content: [
@@ -70920,8 +71168,86 @@ async function handleCreateDashboard$1({ name }) {
     };
   }
 
+  // Validate optional layout parameter
+  if (layout !== undefined && layout !== null) {
+    if (typeof layout !== "object" || Array.isArray(layout)) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: "layout must be an object with rows and cols",
+            }),
+          },
+        ],
+        isError: true,
+      };
+    }
+    const { rows, cols } = layout;
+    if (
+      rows === undefined ||
+      cols === undefined ||
+      typeof rows !== "number" ||
+      typeof cols !== "number"
+    ) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: "layout.rows and layout.cols are required numbers",
+            }),
+          },
+        ],
+        isError: true,
+      };
+    }
+    if (rows < 1 || rows > 10 || cols < 1 || cols > 10) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: "rows and cols must be between 1 and 10",
+            }),
+          },
+        ],
+        isError: true,
+      };
+    }
+  }
+
   const { win, appId } = requireContext$1();
 
+  // Build root layout node — grid or plain container
+  const rootNode =
+    layout && layout.rows && layout.cols
+      ? {
+          id: 1,
+          order: 1,
+          component: "LayoutGridContainer",
+          type: "grid",
+          parent: 0,
+          hasChildren: 1,
+          scrollable: false,
+          width: "w-full",
+          height: "h-full",
+          workspace: "layout",
+          grid: buildEmptyGrid(
+            layout.rows,
+            layout.cols,
+            layout.gap,
+            layout.colModes,
+          ),
+        }
+      : {
+          id: 1,
+          order: 1,
+          component: "Container",
+          parent: 0,
+          items: [],
+        };
+
   const newWorkspace = {
     id: Date.now(),
     name: name.trim(),
@@ -70929,15 +71255,7 @@ async function handleCreateDashboard$1({ name }) {
     type: "workspace",
     version: 1,
     menuId: 1,
-    layout: [
-      {
-        id: 1,
-        order: 1,
-        component: "Container",
-        parentId: 0,
-        items: [],
-      },
-    ],
+    layout: [rootNode],
   };
 
   const result = workspaceController$2.saveWorkspaceForApplication(
@@ -70958,15 +71276,16 @@ async function handleCreateDashboard$1({ name }) {
     };
   }
 
+  const response = { id: String(newWorkspace.id), name: newWorkspace.name };
+  if (layout && layout.rows && layout.cols) {
+    response.layout = { rows: layout.rows, cols: layout.cols };
+  }
+
   return {
     content: [
       {
         type: "text",
-        text: JSON.stringify(
-          { id: String(newWorkspace.id), name: newWorkspace.name },
-          null,
-          2,
-        ),
+        text: JSON.stringify(response, null, 2),
       },
     ],
   };
@@ -71157,10 +71476,65 @@ function nextLayoutId(layout) {
   return maxId + 1;
 }
 
+/**
+ * Helper: find the LayoutGridContainer node in a layout array.
+ */
+function findGridNode(layout) {
+  if (!Array.isArray(layout)) return null;
+  return (
+    layout.find(
+      (item) => item.component === "LayoutGridContainer" && item.grid,
+    ) || null
+  );
+}
+
+/**
+ * Helper: build an empty grid object with cell slots for all row.col positions.
+ */
+function buildEmptyGrid(rows, cols, gap, colModes) {
+  const grid = {
+    rows,
+    cols,
+    gap: gap || "gap-2",
+  };
+  if (colModes && Object.keys(colModes).length > 0) {
+    grid.colModes = colModes;
+  }
+  for (let r = 1; r <= rows; r++) {
+    for (let c = 1; c <= cols; c++) {
+      grid[`${r}.${c}`] = { component: null, hide: false };
+    }
+  }
+  return grid;
+}
+
+/**
+ * Helper: find the next empty cell scanning left-to-right, top-to-bottom.
+ */
+function findNextEmptyCell(grid) {
+  for (let r = 1; r <= grid.rows; r++) {
+    for (let c = 1; c <= grid.cols; c++) {
+      const key = `${r}.${c}`;
+      const cell = grid[key];
+      if (!cell || (cell.component === null && !cell.hide)) {
+        return { row: r, col: c };
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Helper: check if a row/col position is within grid bounds.
+ */
+function isValidCell(grid, row, col) {
+  return row >= 1 && row <= grid.rows && col >= 1 && col <= grid.cols;
+}
+
 /**
  * add_widget — Add a widget to a dashboard by component name.
  */
-async function handleAddWidget$1({ dashboardId, widgetName }) {
+async function handleAddWidget$1({ dashboardId, widgetName, row, col }) {
   if (!widgetName || typeof widgetName !== "string" || !widgetName.trim()) {
     return {
       content: [
@@ -71175,6 +71549,25 @@ async function handleAddWidget$1({ dashboardId, widgetName }) {
     };
   }
 
+  // Validate row/col pairing
+  if (
+    (row !== undefined && col === undefined) ||
+    (row === undefined && col !== undefined)
+  ) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error:
+              "Both row and col must be provided together, or both omitted",
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
   const { win, appId } = requireContext$1();
   const result = workspaceController$2.listWorkspacesForApplication(win, appId);
   if (result.error) {
@@ -71199,7 +71592,88 @@ async function handleAddWidget$1({ dashboardId, widgetName }) {
       item.component === "LayoutContainer" ||
       item.component === "LayoutGridContainer",
   );
-  const parentId = container ? container.id : 0;
+
+  const gridNode = findGridNode(layout);
+
+  // Determine grid placement
+  let targetRow = null;
+  let targetCol = null;
+
+  if (row !== undefined && col !== undefined) {
+    // Explicit placement requested
+    if (!gridNode) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error:
+                "Cannot specify row/col: dashboard has no grid layout. Use create_dashboard with layout or set_layout first.",
+            }),
+          },
+        ],
+        isError: true,
+      };
+    }
+    const r = Number(row);
+    const c = Number(col);
+    if (!isValidCell(gridNode.grid, r, c)) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: `Cell ${r}.${c} is out of bounds (grid is ${gridNode.grid.rows}x${gridNode.grid.cols})`,
+            }),
+          },
+        ],
+        isError: true,
+      };
+    }
+    const cellKey = `${r}.${c}`;
+    const cell = gridNode.grid[cellKey];
+    if (cell && cell.hide) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: `Cell ${r}.${c} is hidden`,
+            }),
+          },
+        ],
+        isError: true,
+      };
+    }
+    if (cell && cell.component !== null) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: `Cell ${r}.${c} is already occupied by widget ${cell.component}`,
+            }),
+          },
+        ],
+        isError: true,
+      };
+    }
+    targetRow = r;
+    targetCol = c;
+  } else if (gridNode) {
+    // No row/col specified but grid exists — auto-place in next empty cell
+    const empty = findNextEmptyCell(gridNode.grid);
+    if (empty) {
+      targetRow = empty.row;
+      targetCol = empty.col;
+    }
+  }
+
+  const parentContainerId = gridNode
+    ? gridNode.id
+    : container
+      ? container.id
+      : 0;
 
   const newId = nextLayoutId(layout);
   const maxOrder = layout.reduce(
@@ -71211,12 +71685,22 @@ async function handleAddWidget$1({ dashboardId, widgetName }) {
     id: newId,
     order: maxOrder + 1,
     component: widgetName.trim(),
-    parentId,
+    parent: parentContainerId,
     config: {},
   };
 
   workspace.layout = [...layout, newItem];
 
+  // If placing in grid, update the cell assignment
+  if (gridNode && targetRow !== null && targetCol !== null) {
+    const cellKey = `${targetRow}.${targetCol}`;
+    gridNode.grid[cellKey] = {
+      ...(gridNode.grid[cellKey] || {}),
+      component: newId,
+      hide: false,
+    };
+  }
+
   const saveResult = workspaceController$2.saveWorkspaceForApplication(
     win,
     appId,
@@ -71234,19 +71718,20 @@ async function handleAddWidget$1({ dashboardId, widgetName }) {
     };
   }
 
+  const response = {
+    widgetId: String(newId),
+    name: widgetName.trim(),
+    dashboardId: String(workspace.id),
+  };
+  if (targetRow !== null && targetCol !== null) {
+    response.cell = { row: targetRow, col: targetCol };
+  }
+
   return {
     content: [
       {
         type: "text",
-        text: JSON.stringify(
-          {
-            widgetId: String(newId),
-            name: widgetName.trim(),
-            dashboardId: String(workspace.id),
-          },
-          null,
-          2,
-        ),
+        text: JSON.stringify(response, null, 2),
       },
     ],
   };
@@ -71302,6 +71787,21 @@ async function handleRemoveWidget$1({ dashboardId, widgetId }) {
 
   workspace.layout = layout.filter((item) => String(item.id) !== widgetId);
 
+  // Clean up grid cell assignments that reference this widget
+  const numericId = Number(widgetId);
+  for (const item of workspace.layout) {
+    if (item.grid) {
+      for (const key of Object.keys(item.grid)) {
+        if (/^\d+\.\d+$/.test(key)) {
+          const cell = item.grid[key];
+          if (cell && cell.component === numericId) {
+            cell.component = null;
+          }
+        }
+      }
+    }
+  }
+
   const saveResult = workspaceController$2.saveWorkspaceForApplication(
     win,
     appId,
@@ -72463,6 +72963,492 @@ async function handleGetSetupGuide$1({ topic }) {
   };
 }
 
+// --- Layout Tool Handlers ---
+
+/**
+ * set_layout — Set or replace the grid layout on a dashboard.
+ */
+async function handleSetLayout$1({ dashboardId, rows, cols, gap, colModes }) {
+  if (
+    rows === undefined ||
+    cols === undefined ||
+    typeof rows !== "number" ||
+    typeof cols !== "number"
+  ) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: "rows and cols are required numbers",
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+  if (rows < 1 || rows > 10 || cols < 1 || cols > 10) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: "rows and cols must be between 1 and 10",
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  const { win, appId } = requireContext$1();
+  const result = workspaceController$2.listWorkspacesForApplication(win, appId);
+  if (result.error) {
+    return {
+      content: [
+        { type: "text", text: JSON.stringify({ error: result.message }) },
+      ],
+      isError: true,
+    };
+  }
+
+  const found = findWorkspace(result.workspaces || [], dashboardId);
+  if (found.error) return found.response;
+
+  const workspace = found.workspace;
+  const layout = workspace.layout || [];
+
+  const newGrid = buildEmptyGrid(rows, cols, gap, colModes);
+  const existingGridNode = findGridNode(layout);
+  const orphanedWidgetIds = [];
+
+  if (existingGridNode) {
+    // Preserve cell assignments that still fit in the new dimensions
+    const oldGrid = existingGridNode.grid;
+    for (const key of Object.keys(oldGrid)) {
+      if (
+        /^\d+\.\d+$/.test(key) &&
+        oldGrid[key] &&
+        oldGrid[key].component !== null
+      ) {
+        const parts = key.split(".");
+        const r = Number(parts[0]);
+        const c = Number(parts[1]);
+        if (r <= rows && c <= cols) {
+          newGrid[key] = { ...newGrid[key], component: oldGrid[key].component };
+        } else {
+          orphanedWidgetIds.push(oldGrid[key].component);
+        }
+      }
+    }
+    existingGridNode.grid = newGrid;
+  } else {
+    // Replace root Container with a LayoutGridContainer
+    const rootIdx = layout.findIndex(
+      (item) =>
+        item.parent === 0 &&
+        (item.component === "Container" ||
+          item.component === "LayoutContainer"),
+    );
+
+    const newGridNode = {
+      id: rootIdx >= 0 ? layout[rootIdx].id : nextLayoutId(layout),
+      order: 1,
+      component: "LayoutGridContainer",
+      type: "grid",
+      parent: 0,
+      hasChildren: 1,
+      scrollable: false,
+      width: "w-full",
+      height: "h-full",
+      workspace: "layout",
+      grid: newGrid,
+    };
+
+    if (rootIdx >= 0) {
+      // Reparent existing widgets to the new grid node
+      const oldRootId = layout[rootIdx].id;
+      for (const item of layout) {
+        if (item.parent === oldRootId && item.id !== oldRootId) {
+          item.parent = newGridNode.id;
+        }
+      }
+      workspace.layout[rootIdx] = newGridNode;
+    } else {
+      workspace.layout = [newGridNode, ...layout];
+    }
+  }
+
+  const saveResult = workspaceController$2.saveWorkspaceForApplication(
+    win,
+    appId,
+    workspace,
+  );
+  if (saveResult.error) {
+    return {
+      content: [
+        { type: "text", text: JSON.stringify({ error: saveResult.message }) },
+      ],
+      isError: true,
+    };
+  }
+
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          {
+            dashboardId: String(workspace.id),
+            grid: { rows, cols },
+            orphanedWidgets: orphanedWidgetIds.map(String),
+          },
+          null,
+          2,
+        ),
+      },
+    ],
+  };
+}
+
+/**
+ * update_layout — Partially update grid layout properties.
+ */
+async function handleUpdateLayout$1({ dashboardId, rows, cols, gap, colModes }) {
+  if (
+    rows === undefined &&
+    cols === undefined &&
+    gap === undefined &&
+    colModes === undefined
+  ) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error:
+              "At least one of rows, cols, gap, or colModes must be provided",
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  const { win, appId } = requireContext$1();
+  const result = workspaceController$2.listWorkspacesForApplication(win, appId);
+  if (result.error) {
+    return {
+      content: [
+        { type: "text", text: JSON.stringify({ error: result.message }) },
+      ],
+      isError: true,
+    };
+  }
+
+  const found = findWorkspace(result.workspaces || [], dashboardId);
+  if (found.error) return found.response;
+
+  const workspace = found.workspace;
+  const gridNode = findGridNode(workspace.layout || []);
+
+  if (!gridNode) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error:
+              "Dashboard has no grid layout. Use set_layout or create_dashboard with layout first.",
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  const grid = gridNode.grid;
+  const oldRows = grid.rows;
+  const oldCols = grid.cols;
+  const newRows = rows !== undefined ? rows : oldRows;
+  const newCols = cols !== undefined ? cols : oldCols;
+
+  if (newRows < 1 || newRows > 10 || newCols < 1 || newCols > 10) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: "rows and cols must be between 1 and 10",
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  // Update gap if specified
+  if (gap !== undefined) {
+    grid.gap = gap;
+  }
+
+  // Merge colModes if specified
+  if (colModes !== undefined) {
+    grid.colModes = { ...(grid.colModes || {}), ...colModes };
+    // Remove entries set to null
+    for (const k of Object.keys(grid.colModes)) {
+      if (grid.colModes[k] === null) {
+        delete grid.colModes[k];
+      }
+    }
+    if (Object.keys(grid.colModes).length === 0) {
+      delete grid.colModes;
+    }
+  }
+
+  // Handle dimension changes
+  const orphanedWidgetIds = [];
+  if (newRows !== oldRows || newCols !== oldCols) {
+    // Add new cells
+    for (let r = 1; r <= newRows; r++) {
+      for (let c = 1; c <= newCols; c++) {
+        const key = `${r}.${c}`;
+        if (!grid[key]) {
+          grid[key] = { component: null, hide: false };
+        }
+      }
+    }
+    // Collect orphaned widgets from removed cells
+    for (const key of Object.keys(grid)) {
+      if (/^\d+\.\d+$/.test(key)) {
+        const parts = key.split(".");
+        const r = Number(parts[0]);
+        const c = Number(parts[1]);
+        if (r > newRows || c > newCols) {
+          if (grid[key] && grid[key].component !== null) {
+            orphanedWidgetIds.push(grid[key].component);
+          }
+          delete grid[key];
+        }
+      }
+    }
+    grid.rows = newRows;
+    grid.cols = newCols;
+  }
+
+  const saveResult = workspaceController$2.saveWorkspaceForApplication(
+    win,
+    appId,
+    workspace,
+  );
+  if (saveResult.error) {
+    return {
+      content: [
+        { type: "text", text: JSON.stringify({ error: saveResult.message }) },
+      ],
+      isError: true,
+    };
+  }
+
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          {
+            dashboardId: String(workspace.id),
+            grid: { rows: newRows, cols: newCols, gap: grid.gap },
+            orphanedWidgets: orphanedWidgetIds.map(String),
+          },
+          null,
+          2,
+        ),
+      },
+    ],
+  };
+}
+
+/**
+ * move_widget — Move a widget to a different grid cell (swap if occupied).
+ */
+async function handleMoveWidget$1({ dashboardId, widgetId, row, col }) {
+  if (!widgetId || typeof widgetId !== "string") {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ error: "widgetId is required" }),
+        },
+      ],
+      isError: true,
+    };
+  }
+  if (row === undefined || col === undefined) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ error: "row and col are required" }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  const { win, appId } = requireContext$1();
+  const result = workspaceController$2.listWorkspacesForApplication(win, appId);
+  if (result.error) {
+    return {
+      content: [
+        { type: "text", text: JSON.stringify({ error: result.message }) },
+      ],
+      isError: true,
+    };
+  }
+
+  const found = findWorkspace(result.workspaces || [], dashboardId);
+  if (found.error) return found.response;
+
+  const workspace = found.workspace;
+  const gridNode = findGridNode(workspace.layout || []);
+
+  if (!gridNode) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: "Dashboard has no grid layout",
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  const r = Number(row);
+  const c = Number(col);
+  if (!isValidCell(gridNode.grid, r, c)) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: `Cell ${r}.${c} is out of bounds (grid is ${gridNode.grid.rows}x${gridNode.grid.cols})`,
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  const targetKey = `${r}.${c}`;
+  const targetCell = gridNode.grid[targetKey];
+  if (targetCell && targetCell.hide) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: `Cell ${r}.${c} is hidden`,
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  // Find the widget's current cell
+  const numericWidgetId = Number(widgetId);
+  let sourceKey = null;
+  for (const key of Object.keys(gridNode.grid)) {
+    if (
+      /^\d+\.\d+$/.test(key) &&
+      gridNode.grid[key] &&
+      gridNode.grid[key].component === numericWidgetId
+    ) {
+      sourceKey = key;
+      break;
+    }
+  }
+
+  if (!sourceKey) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: `Widget ${widgetId} not found in any grid cell`,
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  if (sourceKey === targetKey) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              widgetId,
+              cell: { row: r, col: c },
+              swapped: false,
+            },
+            null,
+            2,
+          ),
+        },
+      ],
+    };
+  }
+
+  // Perform the move (swap if target occupied)
+  const targetComponentId = targetCell ? targetCell.component : null;
+  gridNode.grid[targetKey] = {
+    ...(gridNode.grid[targetKey] || {}),
+    component: numericWidgetId,
+  };
+  gridNode.grid[sourceKey] = {
+    ...(gridNode.grid[sourceKey] || {}),
+    component: targetComponentId,
+  };
+
+  const saveResult = workspaceController$2.saveWorkspaceForApplication(
+    win,
+    appId,
+    workspace,
+  );
+  if (saveResult.error) {
+    return {
+      content: [
+        { type: "text", text: JSON.stringify({ error: saveResult.message }) },
+      ],
+      isError: true,
+    };
+  }
+
+  const response = {
+    widgetId,
+    cell: { row: r, col: c },
+    swapped: targetComponentId !== null,
+  };
+  if (targetComponentId !== null) {
+    response.swappedWidgetId = String(targetComponentId);
+  }
+
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(response, null, 2),
+      },
+    ],
+  };
+}
+
 var toolHandlers = {
   handleListDashboards: handleListDashboards$1,
   handleGetDashboard: handleGetDashboard$1,
@@ -72483,6 +73469,14 @@ var toolHandlers = {
   handleAddProvider: handleAddProvider$1,
   handleRemoveProvider: handleRemoveProvider$1,
   handleGetSetupGuide: handleGetSetupGuide$1,
+  handleSetLayout: handleSetLayout$1,
+  handleUpdateLayout: handleUpdateLayout$1,
+  handleMoveWidget: handleMoveWidget$1,
+  // Helpers (exported for testing)
+  findGridNode,
+  buildEmptyGrid,
+  findNextEmptyCell,
+  isValidCell,
 };
 
 /**
@@ -72492,7 +73486,7 @@ var toolHandlers = {
  * Call registerDashboardTools() during app startup (before or after server start).
  */
 
-const { registerTool: registerTool$4 } = mcpDashServerController_1;
+const { registerTool: registerTool$5 } = mcpDashServerController_1;
 const { dashboardTools } = toolDefinitions;
 const {
   handleListDashboards,
@@ -72503,7 +73497,7 @@ const {
 } = toolHandlers;
 
 // Map tool names to handler functions
-const handlerMap$6 = {
+const handlerMap$7 = {
   list_dashboards: handleListDashboards,
   get_dashboard: handleGetDashboard,
   create_dashboard: handleCreateDashboard,
@@ -72516,12 +73510,12 @@ const handlerMap$6 = {
  */
 function registerDashboardTools$1() {
   for (const tool of dashboardTools) {
-    const handler = handlerMap$6[tool.name];
+    const handler = handlerMap$7[tool.name];
     if (!handler) {
       console.warn(`[dashboardTools] No handler found for tool: ${tool.name}`);
       continue;
     }
-    registerTool$4({
+    registerTool$5({
       name: tool.name,
       description: tool.description,
       inputSchema: tool.inputSchema,
@@ -72542,7 +73536,7 @@ var dashboardTools_1 = { registerDashboardTools: registerDashboardTools$1 };
  * Call registerWidgetTools() during app startup (before or after server start).
  */
 
-const { registerTool: registerTool$3 } = mcpDashServerController_1;
+const { registerTool: registerTool$4 } = mcpDashServerController_1;
 const { widgetTools } = toolDefinitions;
 const {
   handleAddWidget,
@@ -72553,7 +73547,7 @@ const {
 } = toolHandlers;
 
 // Map tool names to handler functions
-const handlerMap$5 = {
+const handlerMap$6 = {
   add_widget: handleAddWidget,
   remove_widget: handleRemoveWidget,
   configure_widget: handleConfigureWidget,
@@ -72566,12 +73560,12 @@ const handlerMap$5 = {
  */
 function registerWidgetTools$1() {
   for (const tool of widgetTools) {
-    const handler = handlerMap$5[tool.name];
+    const handler = handlerMap$6[tool.name];
     if (!handler) {
       console.warn(`[widgetTools] No handler found for tool: ${tool.name}`);
       continue;
     }
-    registerTool$3({
+    registerTool$4({
       name: tool.name,
       description: tool.description,
       inputSchema: tool.inputSchema,
@@ -72590,7 +73584,7 @@ var widgetTools_1 = { registerWidgetTools: registerWidgetTools$1 };
  * Call registerThemeTools() during app startup (before or after server start).
  */
 
-const { registerTool: registerTool$2 } = mcpDashServerController_1;
+const { registerTool: registerTool$3 } = mcpDashServerController_1;
 const { themeTools } = toolDefinitions;
 const {
   handleListThemes,
@@ -72601,7 +73595,7 @@ const {
 } = toolHandlers;
 
 // Map tool names to handler functions
-const handlerMap$4 = {
+const handlerMap$5 = {
   list_themes: handleListThemes,
   get_theme: handleGetTheme,
   create_theme: handleCreateTheme,
@@ -72614,12 +73608,12 @@ const handlerMap$4 = {
  */
 function registerThemeTools$1() {
   for (const tool of themeTools) {
-    const handler = handlerMap$4[tool.name];
+    const handler = handlerMap$5[tool.name];
     if (!handler) {
       console.warn(`[themeTools] No handler found for tool: ${tool.name}`);
       continue;
     }
-    registerTool$2({
+    registerTool$3({
       name: tool.name,
       description: tool.description,
       inputSchema: tool.inputSchema,
@@ -72638,7 +73632,7 @@ var themeTools_1 = { registerThemeTools: registerThemeTools$1 };
  * Call registerProviderTools() during app startup (before or after server start).
  */
 
-const { registerTool: registerTool$1 } = mcpDashServerController_1;
+const { registerTool: registerTool$2 } = mcpDashServerController_1;
 const { providerTools } = toolDefinitions;
 const {
   handleListProviders,
@@ -72647,7 +73641,7 @@ const {
 } = toolHandlers;
 
 // Map tool names to handler functions
-const handlerMap$3 = {
+const handlerMap$4 = {
   list_providers: handleListProviders,
   add_provider: handleAddProvider,
   remove_provider: handleRemoveProvider,
@@ -72658,12 +73652,12 @@ const handlerMap$3 = {
  */
 function registerProviderTools$1() {
   for (const tool of providerTools) {
-    const handler = handlerMap$3[tool.name];
+    const handler = handlerMap$4[tool.name];
     if (!handler) {
       console.warn(`[providerTools] No handler found for tool: ${tool.name}`);
       continue;
     }
-    registerTool$1({
+    registerTool$2({
       name: tool.name,
       description: tool.description,
       inputSchema: tool.inputSchema,
@@ -72684,22 +73678,22 @@ var providerTools_1 = { registerProviderTools: registerProviderTools$1 };
  * Call registerGuideTools() during app startup.
  */
 
-const { registerTool } = mcpDashServerController_1;
+const { registerTool: registerTool$1 } = mcpDashServerController_1;
 const { guideTools } = toolDefinitions;
 const { handleGetSetupGuide } = toolHandlers;
 
-const handlerMap$2 = {
+const handlerMap$3 = {
   get_setup_guide: handleGetSetupGuide,
 };
 
 function registerGuideTools$1() {
   for (const tool of guideTools) {
-    const handler = handlerMap$2[tool.name];
+    const handler = handlerMap$3[tool.name];
     if (!handler) {
       console.warn(`[guideTools] No handler found for tool: ${tool.name}`);
       continue;
     }
-    registerTool({
+    registerTool$1({
       name: tool.name,
       description: tool.description,
       inputSchema: tool.inputSchema,
@@ -72711,6 +73705,49 @@ function registerGuideTools$1() {
 
 var guideTools_1 = { registerGuideTools: registerGuideTools$1 };
 
+/**
+ * layoutTools.js
+ *
+ * Registers layout/grid MCP tools with the MCP Dash server.
+ * Call registerLayoutTools() during app startup (before or after server start).
+ */
+
+const { registerTool } = mcpDashServerController_1;
+const { layoutTools } = toolDefinitions;
+const {
+  handleSetLayout,
+  handleUpdateLayout,
+  handleMoveWidget,
+} = toolHandlers;
+
+const handlerMap$2 = {
+  set_layout: handleSetLayout,
+  update_layout: handleUpdateLayout,
+  move_widget: handleMoveWidget,
+};
+
+/**
+ * Register all layout tools with the MCP server controller.
+ */
+function registerLayoutTools$1() {
+  for (const tool of layoutTools) {
+    const handler = handlerMap$2[tool.name];
+    if (!handler) {
+      console.warn(`[layoutTools] No handler found for tool: ${tool.name}`);
+      continue;
+    }
+    registerTool({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema,
+      handler,
+    });
+  }
+  console.log(`[layoutTools] Registered ${layoutTools.length} layout tools`);
+}
+
+var layoutTools_1 = { registerLayoutTools: registerLayoutTools$1 };
+
 /**
  * resourceDefinitions.js
  *
@@ -73679,6 +74716,7 @@ const { registerWidgetTools } = widgetTools_1;
 const { registerThemeTools } = themeTools_1;
 const { registerProviderTools } = providerTools_1;
 const { registerGuideTools } = guideTools_1;
+const { registerLayoutTools } = layoutTools_1;
 const { registerResources } = resources;
 const { registerPrompts } = promptRegistration;
 registerDashboardTools();
@@ -73686,6 +74724,7 @@ registerWidgetTools();
 registerThemeTools();
 registerProviderTools();
 registerGuideTools();
+registerLayoutTools();
 registerResources();
 registerPrompts();
 
@@ -73787,6 +74826,7 @@ var electron = {
   registerWidgetTools,
   registerThemeTools,
   registerProviderTools,
+  registerLayoutTools,
   registerResources,
 };