sql-preview 0.6.4 → 0.6.7

package/out/server/standalone.js

@@ -22581,7 +22581,7 @@ var require_view = __commonJS({
     var debug = require_src()("express:view");
     var path8 = require("node:path");
     var fs11 = require("node:fs");
-    var dirname2 = path8.dirname;
+    var dirname3 = path8.dirname;
     var basename = path8.basename;
     var extname = path8.extname;
     var join7 = path8.join;
@@ -22620,7 +22620,7 @@ var require_view = __commonJS({
       for (var i = 0; i < roots.length && !path9; i++) {
         var root = roots[i];
         var loc = resolve2(root, name);
-        var dir = dirname2(loc);
+        var dir = dirname3(loc);
         var file = basename(loc);
         path9 = this.resolve(dir, file);
       }
@@ -76257,18 +76257,103 @@ var init_errors = __esm({
   }
 });
 
+// src/common/tabProjection.ts
+function beginTabRun(options) {
+  return {
+    status: "loading",
+    columns: [],
+    rows: [],
+    wasTruncated: false,
+    maxRows: options?.maxRows,
+    remoteTabId: void 0,
+    supportsPagination: void 0,
+    error: void 0,
+    errorDetails: void 0,
+    executionTimeMs: void 0,
+    executedAt: void 0
+  };
+}
+function applyQueryPage(run, page) {
+  if (page.columns && page.columns.length > 0) {
+    run.columns = page.columns;
+  }
+  if (page.remoteTabId) {
+    run.remoteTabId = page.remoteTabId;
+  }
+  if (page.supportsPagination !== void 0) {
+    run.supportsPagination = page.supportsPagination;
+  }
+  if (page.data && page.data.length > 0) {
+    for (const row of page.data) {
+      if (row !== void 0) {
+        run.rows.push(row);
+      }
+    }
+  }
+  if (run.maxRows !== void 0 && run.rows.length >= run.maxRows) {
+    run.wasTruncated = true;
+  }
+  return run;
+}
+function completeTabRun(run, timing) {
+  run.status = "success";
+  if (timing?.startedAt !== void 0) {
+    run.executionTimeMs = Date.now() - timing.startedAt;
+  }
+  run.executedAt = (/* @__PURE__ */ new Date()).toISOString();
+  return run;
+}
+function failTabRun(run, error2, options) {
+  run.status = "error";
+  if (options?.aborted) {
+    run.error = "Query cancelled by user";
+    run.errorDetails = void 0;
+  } else {
+    run.error = error2 instanceof Error ? error2.message : String(error2);
+    run.errorDetails = serializeErrorDetails(error2);
+  }
+  run.executedAt = (/* @__PURE__ */ new Date()).toISOString();
+  return run;
+}
+var init_tabProjection = __esm({
+  "src/common/tabProjection.ts"() {
+    "use strict";
+    init_errors();
+  }
+});
+
 // src/server/query/QueryOperationRunner.ts
-var QueryOperationRunner;
+var _QueryOperationRunner, QueryOperationRunner;
 var init_QueryOperationRunner = __esm({
   "src/server/query/QueryOperationRunner.ts"() {
     "use strict";
-    init_errors();
+    init_tabProjection();
     init_ConsoleLogger();
-    QueryOperationRunner = class {
+    _QueryOperationRunner = class {
       constructor(sessionManager, queryExecutor) {
         this.sessionManager = sessionManager;
         this.queryExecutor = queryExecutor;
       }
+      /** Updates the row cap live; delegates to the underlying executor. */
+      setMaxRows(value) {
+        this.queryExecutor.setMaxRows(value);
+      }
+      /**
+       * Re-runs `query` outside of tab/session bookkeeping, uncapped by the display row limit, for
+       * CSV export. Mirrors the VS Code extension's ExportService: exports re-execute rather than
+       * reusing the (possibly truncated) rows already stored on the tab.
+       */
+      exportQuery(query, sessionId, abortSignal) {
+        return this.queryExecutor.execute(
+          query,
+          sessionId,
+          void 0,
+          abortSignal,
+          void 0,
+          void 0,
+          _QueryOperationRunner.EXPORT_MAX_ROWS
+        );
+      }
       async run(request) {
         const prepared = this.prepareQueryOperation(request);
         const waitForResult = request.waitForResult ?? true;
@@ -76502,6 +76587,9 @@ var init_QueryOperationRunner = __esm({
         if (!tab) {
           return;
         }
+        const startedAt = Date.now();
+        const run = beginTabRun({ maxRows: this.queryExecutor.maxRows });
+        tab.rows = run.rows;
         try {
           const generator = this.queryExecutor.execute(
             sql,
@@ -76511,51 +76599,55 @@ var init_QueryOperationRunner = __esm({
             connectionProfile,
             authHeader
           );
-          let columns = [];
           for await (const page of generator) {
             if (controller.signal.aborted) {
               throw new Error("Query cancelled by user");
             }
-            if (page.columns) {
-              columns = page.columns;
-              tab.columns = columns;
+            applyQueryPage(run, page);
+            tab.columns = run.columns;
+            if (run.supportsPagination !== void 0) {
+              tab.supportsPagination = run.supportsPagination;
             }
             if (page.data && page.data.length > 0) {
-              for (const row of page.data) {
-                tab.rows.push(row);
-              }
               this.sessionManager.updateTab(sessionId, tabId, {
-                columns: page.columns ?? tab.columns,
-                rows: tab.rows,
+                columns: run.columns,
+                rows: run.rows,
                 status: "loading"
               });
             }
-            if (page.supportsPagination !== void 0) {
-              tab.supportsPagination = page.supportsPagination;
-            }
           }
           if (controller.signal.aborted) {
             throw new Error("Query cancelled by user");
           }
+          completeTabRun(run, { startedAt });
+          Object.assign(tab, {
+            executionTimeMs: run.executionTimeMs,
+            wasTruncated: run.wasTruncated,
+            executedAt: run.executedAt
+          });
           this.sessionManager.updateTab(sessionId, tabId, {
             status: "success",
-            totalRowsInFirstBatch: tab.rows.length
+            totalRowsInFirstBatch: run.rows.length,
+            executionTimeMs: run.executionTimeMs,
+            wasTruncated: run.wasTruncated,
+            executedAt: run.executedAt
           });
         } catch (err) {
           if (session.abortControllers.get(tabId) !== controller) {
             return;
           }
-          const error2 = controller.signal.aborted ? "Query cancelled by user" : err instanceof Error ? err.message : String(err);
-          const errorDetails = controller.signal.aborted ? void 0 : serializeErrorDetails(err);
+          failTabRun(run, err, { aborted: controller.signal.aborted });
           Object.assign(tab, {
             status: "error",
-            error: error2,
-            errorDetails
+            error: run.error,
+            errorDetails: run.errorDetails,
+            executedAt: run.executedAt
           });
           this.sessionManager.updateTab(sessionId, tabId, {
             status: "error",
-            error: error2,
-            errorDetails
+            error: run.error,
+            errorDetails: run.errorDetails,
+            executedAt: run.executedAt
           });
         }
       }
@@ -76587,6 +76679,9 @@ var init_QueryOperationRunner = __esm({
           columns: tab.columns || [],
           rows: tab.rows || [],
           rowCount,
+          ...tab.wasTruncated !== void 0 ? { wasTruncated: tab.wasTruncated } : {},
+          ...tab.executionTimeMs !== void 0 ? { executionTimeMs: tab.executionTimeMs } : {},
+          ...tab.executedAt !== void 0 ? { executedAt: tab.executedAt } : {},
           ...tab.supportsPagination !== void 0 ? { supportsPagination: tab.supportsPagination } : {}
         };
       }
@@ -76611,6 +76706,8 @@ var init_QueryOperationRunner = __esm({
         return () => abortSignal?.removeEventListener("abort", abortFromCaller);
       }
     };
+    QueryOperationRunner = _QueryOperationRunner;
+    QueryOperationRunner.EXPORT_MAX_ROWS = 5e6;
   }
 });
 
@@ -76772,7 +76869,319 @@ var init_querySplitter = __esm({
   }
 });
 
+// src/common/toolProfiles.ts
+function isToolProfileName(value) {
+  return value === "vscode" || value === "headless" || value === "readonly";
+}
+var ALL_TOOLS, READ_ONLY_TOOLS, TOOL_PROFILES, WEB_PROXIED_TOOLS;
+var init_toolProfiles = __esm({
+  "src/common/toolProfiles.ts"() {
+    "use strict";
+    ALL_TOOLS = [
+      "list_connectors",
+      "run_query",
+      "get_tab_info",
+      "list_sessions",
+      "list_connections",
+      "save_connection",
+      "request_connection_credentials",
+      "test_connection",
+      "delete_connection",
+      "list_schemas",
+      "list_tables",
+      "describe_table",
+      "cancel_query",
+      "close_tab"
+    ];
+    READ_ONLY_TOOLS = [
+      "list_connectors",
+      "run_query",
+      "get_tab_info",
+      "list_sessions",
+      "list_connections",
+      "test_connection",
+      "list_schemas",
+      "list_tables",
+      "describe_table",
+      "cancel_query",
+      "close_tab"
+    ];
+    TOOL_PROFILES = {
+      // Human-in-the-loop VS Code surface: full toolset, safe mode from settings.
+      vscode: { name: "vscode", tools: ALL_TOOLS, forceSafeMode: false },
+      // Autonomous agents: starts as the full current toolset (RFC-062); will
+      // diverge toward synchronous/structured tools without breaking clients.
+      headless: { name: "headless", tools: ALL_TOOLS, forceSafeMode: false },
+      // Safe exploration: no profile/credential mutation, SQL gating always on.
+      readonly: { name: "readonly", tools: READ_ONLY_TOOLS, forceSafeMode: true }
+    };
+    WEB_PROXIED_TOOLS = [
+      "list_connectors",
+      "list_connections",
+      "save_connection",
+      "test_connection",
+      "delete_connection"
+    ];
+  }
+});
+
+// src/server/tools/toolDefinitions.ts
+var TOOL_DEFINITIONS;
+var init_toolDefinitions = __esm({
+  "src/server/tools/toolDefinitions.ts"() {
+    "use strict";
+    TOOL_DEFINITIONS = [
+      {
+        name: "list_connectors",
+        description: "List all supported database connector types and their configuration JSON schemas. Use this to dynamically generate connection setup forms in the UI.",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      },
+      {
+        name: "run_query",
+        description: "Execute a SQL query for a specific session. Waits for the query to complete and returns the full results including rows and column definitions. The tool result contains structured data (rows + columns) that will be rendered in the SQL Preview data grid UI. If the session does not exist, it will be auto-registered.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            sql: { type: "string", description: "The SQL query to execute" },
+            session: {
+              type: "string",
+              description: "The Session ID to run this query in. Use list_sessions to discover existing sessions, or provide a new ID to auto-create a session."
+            },
+            displayName: {
+              type: "string",
+              description: 'Display name for a new session (only used when auto-registering). Defaults to "MCP Client".'
+            },
+            connectionId: {
+              type: "string",
+              description: "Optional Connection ID to use a specific stored connection. Use list_connections to find available IDs."
+            },
+            connectionProfile: {
+              type: "object",
+              description: "Optional ad-hoc connection profile (including credentials) to use for this query."
+            },
+            authHeader: {
+              type: "string",
+              description: "Optional authorization header for the selected connection."
+            },
+            tabId: {
+              type: "string",
+              description: "Optional Tab ID to use for the result. If provided, the daemon will use this ID instead of generating a new one."
+            },
+            newTab: {
+              type: "boolean",
+              description: "When false, reuse the active tab if one exists. Defaults to true."
+            },
+            waitForResult: {
+              type: "boolean",
+              description: "When false, start the query and return immediately with structured started status. Defaults to true."
+            }
+          },
+          required: ["sql", "session"]
+        },
+        _meta: {
+          ui: {
+            resourceUri: "ui://sql-preview/results-grid"
+          }
+        }
+      },
+      {
+        name: "get_tab_info",
+        description: 'Get information about a result tab in a session. Defaults to a "preview" mode with metadata and a small sample. Use mode="page" to retrieve full pages of rows.',
+        inputSchema: {
+          type: "object",
+          properties: {
+            session: {
+              type: "string",
+              description: "The Session ID. Use list_sessions to discover available sessions."
+            },
+            tabId: {
+              type: "string",
+              description: "The Tab ID to retrieve (optional, defaults to the most recently active tab in the session)"
+            },
+            mode: {
+              type: "string",
+              enum: ["preview", "page"],
+              description: 'Retrieval mode. "preview" (default) returns stats + 10 rows. "page" returns specific rows defined by offset/limit.'
+            },
+            offset: {
+              type: "number",
+              description: 'Row offset for "page" mode (default: 0)'
+            },
+            limit: {
+              type: "number",
+              description: 'Number of rows to return. Default: 100 for "page" mode, 10 for "preview" mode.'
+            }
+          },
+          required: ["session"]
+        }
+      },
+      {
+        name: "list_sessions",
+        description: "List all active sessions managed by the daemon. Use this first to discover existing session IDs before running queries or checking results.",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      },
+      {
+        name: "list_connections",
+        description: "List available database connections managed by the daemon. Returns connection IDs and metadata (excluding passwords).",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      },
+      {
+        name: "save_connection",
+        description: "Save or update a connection profile.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            connectionProfile: {
+              type: "object",
+              description: 'The connection profile to save (must include "id", "name", "type").'
+            }
+          },
+          required: ["connectionProfile"]
+        }
+      },
+      {
+        name: "request_connection_credentials",
+        description: "Create a short-lived local browser form where the user can enter credentials for a saved connection without exposing the secret in the MCP transcript. Share only the returned URL with the user; never ask them to paste credentials into chat.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            connectionId: {
+              type: "string",
+              description: "Connection ID that should receive the safely submitted password."
+            }
+          },
+          required: ["connectionId"]
+        }
+      },
+      {
+        name: "test_connection",
+        description: "Test connectivity for a specific connection profile.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            connectionId: {
+              type: "string",
+              description: "Optional Connection ID to test."
+            },
+            type: {
+              type: "string",
+              description: "Connector type (e.g., trino) when testing unsaved profile."
+            },
+            connectionProfile: {
+              type: "object",
+              description: "The configuration object when testing unsaved profile."
+            },
+            authHeader: {
+              type: "string",
+              description: "Optional auth header."
+            }
+          }
+        }
+      },
+      {
+        name: "delete_connection",
+        description: "Delete a connection profile.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            connectionId: {
+              type: "string",
+              description: "The Connection ID to delete."
+            }
+          },
+          required: ["connectionId"]
+        }
+      },
+      {
+        name: "list_schemas",
+        description: "List database schemas (namespaces) available in a stored connection.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            connectionId: { type: "string", description: "Connection ID to inspect." },
+            catalog: { type: "string", description: "Optional catalog filter (e.g. for Trino)." }
+          },
+          required: ["connectionId"]
+        }
+      },
+      {
+        name: "list_tables",
+        description: "List tables and views in a specific schema for a stored connection.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            connectionId: { type: "string", description: "Connection ID to inspect." },
+            schema: { type: "string", description: "Schema name to list tables from." },
+            catalog: { type: "string", description: "Optional catalog (e.g. for Trino/BigQuery)." }
+          },
+          required: ["connectionId", "schema"]
+        }
+      },
+      {
+        name: "describe_table",
+        description: "Return column definitions and metadata for a specific table.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            connectionId: { type: "string", description: "Connection ID to inspect." },
+            table: { type: "string", description: "Table name." },
+            schema: { type: "string", description: "Schema containing the table." },
+            catalog: { type: "string", description: "Optional catalog (e.g. for Trino/BigQuery)." }
+          },
+          required: ["connectionId", "table", "schema"]
+        }
+      },
+      {
+        name: "cancel_query",
+        description: 'Cancel a running query. Use get_tab_info first to check if a query is still in "loading" state before cancelling.',
+        inputSchema: {
+          type: "object",
+          properties: {
+            session: { type: "string", description: "The Session ID" },
+            tabId: { type: "string", description: "The Tab ID to cancel" }
+          },
+          required: ["session", "tabId"]
+        }
+      },
+      {
+        name: "close_tab",
+        description: "Close a tab and remove it from the session.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            session: { type: "string", description: "The Session ID" },
+            tabId: { type: "string", description: "The Tab ID to close" }
+          },
+          required: ["session", "tabId"]
+        }
+      }
+    ];
+  }
+});
+
 // src/server/DaemonMcpToolManager.ts
+function resolveProfile(explicit) {
+  if (explicit) {
+    return TOOL_PROFILES[explicit];
+  }
+  const fromEnv = process.env["MCP_PROFILE"];
+  if (fromEnv !== void 0) {
+    if (isToolProfileName(fromEnv)) {
+      return TOOL_PROFILES[fromEnv];
+    }
+    logger.warn(`Ignoring unknown MCP_PROFILE '${fromEnv}'; using 'vscode'.`);
+  }
+  return TOOL_PROFILES.vscode;
+}
 function isSnowflakeBrowserSsoProfile(value) {
   if (!value || typeof value !== "object") {
     return false;
@@ -76869,6 +77278,8 @@ var init_DaemonMcpToolManager = __esm({
     init_QueryOperationRunner();
     init_QueryToolResultCodecs();
     init_querySplitter();
+    init_toolProfiles();
+    init_toolDefinitions();
     WRITE_KEYWORDS = /\b(ALTER|CALL|COPY|CREATE|DELETE|DROP|EXEC|EXECUTE|GRANT|INSERT|INSTALL|LOAD|MERGE|REPLACE|REVOKE|SET|TRUNCATE|UPDATE|VACUUM)\b/i;
     READ_ONLY_START_KEYWORDS = /* @__PURE__ */ new Set(["SELECT", "SHOW", "DESCRIBE", "EXPLAIN", "WITH"]);
     DaemonMcpToolManager = class {
@@ -76879,246 +77290,34 @@ var init_DaemonMcpToolManager = __esm({
         this.connectorRegistry = connectorRegistry;
         this.options = options;
         this.safeMode = options.safeMode ?? true;
+        this.profile = resolveProfile(options.profile);
+        this.profileTools = new Set(this.profile.tools);
         this.queryOperationRunner = queryOperationRunner ?? new QueryOperationRunner(sessionManager, queryExecutor);
       }
+      get profileName() {
+        return this.profile.name;
+      }
+      get isSafeMode() {
+        return this.profile.forceSafeMode || this.safeMode;
+      }
+      /** Updates the read-only enforcement for agent queries live (e.g. from a settings-panel save). */
+      setSafeMode(value) {
+        this.safeMode = value;
+      }
       getTools() {
-        return [
-          {
-            name: "list_connectors",
-            description: "List all supported database connector types and their configuration JSON schemas. Use this to dynamically generate connection setup forms in the UI.",
-            inputSchema: {
-              type: "object",
-              properties: {}
-            }
-          },
-          {
-            name: "run_query",
-            description: "Execute a SQL query for a specific session. Waits for the query to complete and returns the full results including rows and column definitions. The tool result contains structured data (rows + columns) that will be rendered in the SQL Preview data grid UI. If the session does not exist, it will be auto-registered.",
-            inputSchema: {
-              type: "object",
-              properties: {
-                sql: { type: "string", description: "The SQL query to execute" },
-                session: {
-                  type: "string",
-                  description: "The Session ID to run this query in. Use list_sessions to discover existing sessions, or provide a new ID to auto-create a session."
-                },
-                displayName: {
-                  type: "string",
-                  description: 'Display name for a new session (only used when auto-registering). Defaults to "MCP Client".'
-                },
-                connectionId: {
-                  type: "string",
-                  description: "Optional Connection ID to use a specific stored connection. Use list_connections to find available IDs."
-                },
-                connectionProfile: {
-                  type: "object",
-                  description: "Optional ad-hoc connection profile (including credentials) to use for this query."
-                },
-                authHeader: {
-                  type: "string",
-                  description: "Optional authorization header for the selected connection."
-                },
-                tabId: {
-                  type: "string",
-                  description: "Optional Tab ID to use for the result. If provided, the daemon will use this ID instead of generating a new one."
-                },
-                newTab: {
-                  type: "boolean",
-                  description: "When false, reuse the active tab if one exists. Defaults to true."
-                },
-                waitForResult: {
-                  type: "boolean",
-                  description: "When false, start the query and return immediately with structured started status. Defaults to true."
-                }
-              },
-              required: ["sql", "session"]
-            },
-            _meta: {
-              ui: {
-                resourceUri: "ui://sql-preview/results-grid"
-              }
-            }
-          },
-          {
-            name: "get_tab_info",
-            description: 'Get information about a result tab in a session. Defaults to a "preview" mode with metadata and a small sample. Use mode="page" to retrieve full pages of rows.',
-            inputSchema: {
-              type: "object",
-              properties: {
-                session: {
-                  type: "string",
-                  description: "The Session ID. Use list_sessions to discover available sessions."
-                },
-                tabId: {
-                  type: "string",
-                  description: "The Tab ID to retrieve (optional, defaults to the most recently active tab in the session)"
-                },
-                mode: {
-                  type: "string",
-                  enum: ["preview", "page"],
-                  description: 'Retrieval mode. "preview" (default) returns stats + 10 rows. "page" returns specific rows defined by offset/limit.'
-                },
-                offset: {
-                  type: "number",
-                  description: 'Row offset for "page" mode (default: 0)'
-                },
-                limit: {
-                  type: "number",
-                  description: 'Number of rows to return. Default: 100 for "page" mode, 10 for "preview" mode.'
-                }
-              },
-              required: ["session"]
-            }
-          },
-          {
-            name: "list_sessions",
-            description: "List all active sessions managed by the daemon. Use this first to discover existing session IDs before running queries or checking results.",
-            inputSchema: {
-              type: "object",
-              properties: {}
-            }
-          },
-          {
-            name: "list_connections",
-            description: "List available database connections managed by the daemon. Returns connection IDs and metadata (excluding passwords).",
-            inputSchema: {
-              type: "object",
-              properties: {}
-            }
-          },
-          {
-            name: "save_connection",
-            description: "Save or update a connection profile.",
-            inputSchema: {
-              type: "object",
-              properties: {
-                connectionProfile: {
-                  type: "object",
-                  description: 'The connection profile to save (must include "id", "name", "type").'
-                }
-              },
-              required: ["connectionProfile"]
-            }
-          },
-          {
-            name: "request_connection_credentials",
-            description: "Create a short-lived local browser form where the user can enter credentials for a saved connection without exposing the secret in the MCP transcript. Share only the returned URL with the user; never ask them to paste credentials into chat.",
-            inputSchema: {
-              type: "object",
-              properties: {
-                connectionId: {
-                  type: "string",
-                  description: "Connection ID that should receive the safely submitted password."
-                }
-              },
-              required: ["connectionId"]
-            }
-          },
-          {
-            name: "test_connection",
-            description: "Test connectivity for a specific connection profile.",
-            inputSchema: {
-              type: "object",
-              properties: {
-                connectionId: {
-                  type: "string",
-                  description: "Optional Connection ID to test."
-                },
-                type: {
-                  type: "string",
-                  description: "Connector type (e.g., trino) when testing unsaved profile."
-                },
-                connectionProfile: {
-                  type: "object",
-                  description: "The configuration object when testing unsaved profile."
-                },
-                authHeader: {
-                  type: "string",
-                  description: "Optional auth header."
-                }
-              }
-            }
-          },
-          {
-            name: "delete_connection",
-            description: "Delete a connection profile.",
-            inputSchema: {
-              type: "object",
-              properties: {
-                connectionId: {
-                  type: "string",
-                  description: "The Connection ID to delete."
-                }
-              },
-              required: ["connectionId"]
-            }
-          },
-          {
-            name: "list_schemas",
-            description: "List database schemas (namespaces) available in a stored connection.",
-            inputSchema: {
-              type: "object",
-              properties: {
-                connectionId: { type: "string", description: "Connection ID to inspect." },
-                catalog: { type: "string", description: "Optional catalog filter (e.g. for Trino)." }
-              },
-              required: ["connectionId"]
-            }
-          },
-          {
-            name: "list_tables",
-            description: "List tables and views in a specific schema for a stored connection.",
-            inputSchema: {
-              type: "object",
-              properties: {
-                connectionId: { type: "string", description: "Connection ID to inspect." },
-                schema: { type: "string", description: "Schema name to list tables from." },
-                catalog: { type: "string", description: "Optional catalog (e.g. for Trino/BigQuery)." }
-              },
-              required: ["connectionId", "schema"]
-            }
-          },
-          {
-            name: "describe_table",
-            description: "Return column definitions and metadata for a specific table.",
-            inputSchema: {
-              type: "object",
-              properties: {
-                connectionId: { type: "string", description: "Connection ID to inspect." },
-                table: { type: "string", description: "Table name." },
-                schema: { type: "string", description: "Schema containing the table." },
-                catalog: { type: "string", description: "Optional catalog (e.g. for Trino/BigQuery)." }
-              },
-              required: ["connectionId", "table", "schema"]
-            }
-          },
-          {
-            name: "cancel_query",
-            description: 'Cancel a running query. Use get_tab_info first to check if a query is still in "loading" state before cancelling.',
-            inputSchema: {
-              type: "object",
-              properties: {
-                session: { type: "string", description: "The Session ID" },
-                tabId: { type: "string", description: "The Tab ID to cancel" }
-              },
-              required: ["session", "tabId"]
-            }
-          },
-          {
-            name: "close_tab",
-            description: "Close a tab and remove it from the session.",
-            inputSchema: {
-              type: "object",
-              properties: {
-                session: { type: "string", description: "The Session ID" },
-                tabId: { type: "string", description: "The Tab ID to close" }
-              },
-              required: ["session", "tabId"]
-            }
-          }
-        ];
+        return TOOL_DEFINITIONS.filter((tool) => this.profileTools.has(tool.name)).map(
+          ({ name, description, inputSchema, _meta }) => ({
+            name,
+            description,
+            inputSchema,
+            ..._meta !== void 0 ? { _meta } : {}
+          })
+        );
       }
       async handleToolCall(name, args) {
+        if (!this.profileTools.has(name)) {
+          throw new Error("Unknown tool");
+        }
         switch (name) {
           case "run_query":
             return this.handleRunQuery(args);
@@ -77414,7 +77613,7 @@ This link expires at ${new Date(
           if (!sql) {
             throw new Error("SQL query is required");
           }
-          if (this.safeMode && !isReadOnlySql(sql)) {
+          if (this.isSafeMode && !isReadOnlySql(sql)) {
             const message = "MCP safe mode blocked a non-read-only query. Disable sqlPreview.mcpSafeMode to allow write statements.";
             return {
               isError: true,
@@ -77624,6 +77823,7 @@ var init_DaemonQueryExecutor = __esm({
     "use strict";
     init_routing();
     init_errors();
+    init_DaemonConfig();
     init_SubProcessConnectorClient();
     DaemonQueryExecutor = class {
       constructor(connectorRegistry, connectionManager, logger2, driverManager, queryConfig = {}) {
@@ -77632,10 +77832,18 @@ var init_DaemonQueryExecutor = __esm({
         this.logger = logger2;
         this.driverManager = driverManager;
         this.queryConfig = {
-          maxRows: queryConfig.maxRows ?? 1e4,
-          timeoutMs: queryConfig.timeoutMs ?? 5 * 60 * 1e3
+          maxRows: queryConfig.maxRows ?? DEFAULT_CONFIG.query.maxRows,
+          timeoutMs: queryConfig.timeoutMs ?? DEFAULT_CONFIG.query.timeoutMs
         };
       }
+      /** Row cap applied to every query; results at or above this length were truncated by the connector. */
+      get maxRows() {
+        return this.queryConfig.maxRows;
+      }
+      /** Updates the row cap live, effective for the next query (e.g. from a settings-panel save). */
+      setMaxRows(value) {
+        this.queryConfig.maxRows = value;
+      }
       async getConnectorForProfile(profile) {
         let executablePath;
         let connectorId = profile.type;
@@ -77715,7 +77923,7 @@ var init_DaemonQueryExecutor = __esm({
       /**
        * Orchestrates the query execution.
        */
-      async *execute(query, sessionId, connectionId, abortSignal, connectionOverride, authHeaderOverride) {
+      async *execute(query, sessionId, connectionId, abortSignal, connectionOverride, authHeaderOverride, maxRowsOverride) {
         this.logger.info(`Starting query execution for session ${sessionId}`, { query });
         let profile;
         let isAutoRoutedDuckDbFileQuery = false;
@@ -77807,7 +78015,7 @@ var init_DaemonQueryExecutor = __esm({
           this.logger.error("No valid connection profile found.");
           throw new Error("No valid connection profile found.");
         }
-        const maxRows = this.queryConfig.maxRows;
+        const maxRows = maxRowsOverride ?? this.queryConfig.maxRows;
         const connectorConfig = {
           ...profile,
           maxRows,
@@ -77952,9 +78160,9 @@ var init_CredentialRequestService = __esm({
     import_crypto3 = __toESM(require("crypto"));
     DEFAULT_TTL_MS = 10 * 60 * 1e3;
     CredentialRequestService = class {
-      constructor(connectionManager, baseUrl, ttlMs = DEFAULT_TTL_MS) {
+      constructor(connectionManager, getBaseUrl, ttlMs = DEFAULT_TTL_MS) {
         this.connectionManager = connectionManager;
-        this.baseUrl = baseUrl;
+        this.getBaseUrl = getBaseUrl;
         this.ttlMs = ttlMs;
         this.requests = /* @__PURE__ */ new Map();
       }
@@ -77972,7 +78180,7 @@ var init_CredentialRequestService = __esm({
           connectionId,
           connectionName: profile.name,
           expiresAt: Date.now() + this.ttlMs,
-          url: `${this.baseUrl}/credential-requests/${encodeURIComponent(id)}?token=${encodeURIComponent(
+          url: `${this.getBaseUrl()}/credential-requests/${encodeURIComponent(id)}?token=${encodeURIComponent(
             token
           )}`
         };
@@ -78182,8 +78390,57 @@ var init_httpAbort = __esm({
 });
 
 // src/server/surfaces/DaemonHttpRoutes.ts
+function isLoopbackOnly(context2) {
+  return ["127.0.0.1", "localhost", "::1"].includes(context2.resolvedConfig.config.server.host);
+}
+function readDaemonVersion() {
+  try {
+    const pkgPath = path4.join(findPackageRoot(__dirname), "package.json");
+    const pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf8"));
+    return pkg.version ?? null;
+  } catch {
+    return null;
+  }
+}
+function findPackageRoot(startDir) {
+  let dir = startDir;
+  for (let i = 0; i < 8; i++) {
+    if (fs6.existsSync(path4.join(dir, "package.json"))) {
+      return dir;
+    }
+    const parent = path4.dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return startDir;
+}
+function escapeCsvCell(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  let str;
+  if (typeof value === "object") {
+    try {
+      str = JSON.stringify(value);
+    } catch {
+      str = String(value);
+    }
+  } else {
+    str = String(value);
+  }
+  if (/^[=+\-@]/.test(str) && Number.isNaN(Number(str))) {
+    str = "'" + str;
+  }
+  if (/["\n\r,]/.test(str)) {
+    return `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
+}
 function registerDaemonHttpRoutes(context2, mcpHttpSurface) {
   const { app } = context2;
+  const daemonVersion = readDaemonVersion();
   app.use((_req, _res, next) => {
     context2.refreshActivity();
     next();
@@ -78193,6 +78450,7 @@ function registerDaemonHttpRoutes(context2, mcpHttpSurface) {
     res.send({
       status: "running",
       service: "sql-preview-daemon",
+      version: daemonVersion,
       readiness: {
         transport: "ready",
         connectors: "lazy",
@@ -78326,7 +78584,8 @@ data: ${Date.now()}
           query: t.query,
           sourceFileUri: t.sourceFileUri,
           wasTruncated: t.wasTruncated,
-          totalRowsInFirstBatch: t.totalRowsInFirstBatch
+          totalRowsInFirstBatch: t.totalRowsInFirstBatch,
+          executedAt: t.executedAt
         }))
       );
     } catch (err) {
@@ -78405,6 +78664,163 @@ data: ${Date.now()}
       res.status(500).json({ error: "Internal Server Error" });
     }
   });
+  app.get("/api/v1/sessions/:sid/tabs/:tid/export", async (req, res) => {
+    try {
+      const session = context2.sessionManager.getSession(req.params.sid);
+      if (!session) {
+        res.status(404).json({ error: "Session not found" });
+        return;
+      }
+      const tab = session.tabs.get(req.params.tid);
+      if (!tab) {
+        res.status(404).json({ error: "Tab not found" });
+        return;
+      }
+      if (!tab.query) {
+        res.status(400).json({ error: "Tab has no query to export" });
+        return;
+      }
+      const filename = `${(tab.title || "export").replace(/[^a-z0-9-_]+/gi, "_")}.csv`;
+      res.setHeader("Content-Type", "text/csv; charset=utf-8");
+      res.setHeader("Content-Disposition", `attachment; filename="${filename}"`);
+      const controller = new AbortController();
+      const cleanupDisconnectAbort = attachAbortOnHttpDisconnect(
+        req,
+        res,
+        controller,
+        () => logger.warn(
+          `[Daemon] Export for ${req.params.sid}/${req.params.tid} aborted; client disconnected`
+        )
+      );
+      try {
+        let wroteHeader = false;
+        for await (const page of context2.queryOperationRunner.exportQuery(
+          tab.query,
+          req.params.sid,
+          controller.signal
+        )) {
+          if (page.columns && !wroteHeader) {
+            res.write(page.columns.map((c) => escapeCsvCell(c.name)).join(",") + "\r\n");
+            wroteHeader = true;
+          }
+          for (const row of page.data) {
+            res.write(row.map(escapeCsvCell).join(",") + "\r\n");
+          }
+        }
+      } finally {
+        cleanupDisconnectAbort();
+      }
+      res.end();
+    } catch (err) {
+      logger.error("[Daemon] Error in GET /api/v1/sessions/:sid/tabs/:tid/export:", err);
+      if (!res.headersSent) {
+        res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+      } else {
+        res.end();
+      }
+    }
+  });
+  app.get("/api/v1/settings", (_req, res) => {
+    res.json({
+      maxRowsToDisplay: context2.resolvedConfig.config.query.maxRows,
+      mcpSafeMode: context2.resolvedConfig.config.mcp.safeMode
+    });
+  });
+  app.post("/api/v1/settings", import_express.default.json(), (req, res) => {
+    try {
+      const body = req.body;
+      const patch = {};
+      if (body.maxRowsToDisplay !== void 0) {
+        const maxRows = Number(body.maxRowsToDisplay);
+        if (!Number.isFinite(maxRows) || maxRows < 1) {
+          res.status(400).json({ error: "maxRowsToDisplay must be a positive number" });
+          return;
+        }
+        context2.resolvedConfig.config.query.maxRows = maxRows;
+        context2.queryOperationRunner.setMaxRows(maxRows);
+        patch.query = { maxRows };
+      }
+      if (body.mcpSafeMode !== void 0) {
+        const safeMode = Boolean(body.mcpSafeMode);
+        context2.resolvedConfig.config.mcp.safeMode = safeMode;
+        context2.toolManager.setSafeMode(safeMode);
+        patch.mcp = { safeMode };
+      }
+      if (patch.query || patch.mcp) {
+        persistConfigPatch(context2.resolvedConfig.configPath, patch);
+      }
+      res.json({
+        maxRowsToDisplay: context2.resolvedConfig.config.query.maxRows,
+        mcpSafeMode: context2.resolvedConfig.config.mcp.safeMode
+      });
+    } catch (err) {
+      logger.error("[Daemon] Error in POST /api/v1/settings:", err);
+      res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+    }
+  });
+  app.post("/api/v1/install-dependency", import_express.default.json(), async (req, res) => {
+    if (!isLoopbackOnly(context2)) {
+      res.status(403).json({
+        error: "Installing dependencies is disabled because this daemon is not bound to loopback (127.0.0.1). Restart it without a non-default --host/SQL_PREVIEW_HOST to enable this."
+      });
+      return;
+    }
+    const dependency = req.body?.dependency;
+    if (typeof dependency !== "string" || !SUPPORTED_OPTIONAL_DEPENDENCIES.has(dependency)) {
+      res.status(400).json({ error: `Unsupported optional dependency: ${String(dependency)}` });
+      return;
+    }
+    const packageRoot = findPackageRoot(__dirname);
+    const npmCommand = process.platform === "win32" ? "npm.cmd" : "npm";
+    let output = "";
+    try {
+      const exitCode = await new Promise((resolve2, reject) => {
+        const child = (0, import_child_process2.spawn)(npmCommand, ["install", dependency], {
+          cwd: packageRoot,
+          shell: false,
+          windowsHide: true
+        });
+        child.stdout?.on("data", (chunk) => {
+          output += chunk.toString();
+        });
+        child.stderr?.on("data", (chunk) => {
+          output += chunk.toString();
+        });
+        child.on("error", reject);
+        child.on("close", (code) => resolve2(code ?? 1));
+      });
+      if (exitCode !== 0) {
+        logger.error(`[Daemon] npm install ${dependency} exited with code ${exitCode}: ${output}`);
+        res.status(500).json({
+          error: `npm install ${dependency} exited with code ${exitCode}`,
+          output
+        });
+        return;
+      }
+      res.json({
+        status: "installed",
+        dependency,
+        message: `Installed ${dependency}. Restart the SQL Preview daemon to use the new driver.`
+      });
+    } catch (err) {
+      logger.error(`[Daemon] Failed to install ${dependency}:`, err);
+      res.status(500).json({ error: err instanceof Error ? err.message : String(err), output });
+    }
+  });
+  app.post("/api/v1/tools/:name", import_express.default.json(), async (req, res) => {
+    const { name } = req.params;
+    if (!webProxiedTools.has(name)) {
+      res.status(404).json({ error: `Tool '${name}' is not available on the web surface` });
+      return;
+    }
+    try {
+      const result = await context2.toolManager.handleToolCall(name, req.body?.args ?? {});
+      res.json(result);
+    } catch (err) {
+      logger.error(`[Daemon] Error in POST /api/v1/tools/${name}:`, err);
+      res.status(400).json({ error: err instanceof Error ? err.message : String(err) });
+    }
+  });
   app.post("/api/v1/query", import_express.default.json(), async (req, res) => {
     await handleQueryRoute(context2, req, res, {
       displayName: "Web Client",
@@ -78468,6 +78884,24 @@ async function handleQueryRoute(context2, req, res, options) {
     }
   }
 }
+function persistConfigPatch(configPath, patch) {
+  let onDisk = {};
+  if (fs6.existsSync(configPath)) {
+    try {
+      onDisk = JSON.parse(fs6.readFileSync(configPath, "utf8"));
+    } catch (err) {
+      logger.warn(`[Daemon] Could not parse existing config at ${configPath}, overwriting:`, err);
+      onDisk = {};
+    }
+  }
+  if (patch.query) {
+    onDisk["query"] = { ...onDisk["query"], ...patch.query };
+  }
+  if (patch.mcp) {
+    onDisk["mcp"] = { ...onDisk["mcp"], ...patch.mcp };
+  }
+  fs6.writeFileSync(configPath, JSON.stringify(onDisk, null, 2) + "\n");
+}
 function sendQueryResult(res, result) {
   if (res.headersSent || res.writableEnded) {
     return;
@@ -78478,7 +78912,10 @@ function sendQueryResult(res, result) {
       data: result.rows,
       rowCount: result.rowCount,
       sessionId: result.sessionId,
-      tabId: result.tabId
+      tabId: result.tabId,
+      ...result.wasTruncated !== void 0 ? { wasTruncated: result.wasTruncated } : {},
+      ...result.executionTimeMs !== void 0 ? { executionTimeMs: result.executionTimeMs } : {},
+      ...result.executedAt !== void 0 ? { executedAt: result.executedAt } : {}
     });
     return;
   }
@@ -78540,14 +78977,14 @@ function renderCredentialPage(input) {
   <style>
     :root { color-scheme: light dark; font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }
     body { margin: 0; min-height: 100vh; display: grid; place-items: center; background: Canvas; color: CanvasText; }
-    main { width: min(92vw, 32rem); padding: 2rem; border: 1px solid color-mix(in srgb, CanvasText 18%, transparent); border-radius: 12px; box-shadow: 0 12px 40px color-mix(in srgb, CanvasText 12%, transparent); }
+    main { width: min(92vw, 32rem); padding: 2rem; border: 1px solid color-mix(in srgb, CanvasText 18%, transparent); border-radius: 6px; box-shadow: 0 12px 40px color-mix(in srgb, CanvasText 12%, transparent); }
     h1 { margin-top: 0; font-size: 1.35rem; }
     label { display: block; margin-bottom: 0.4rem; font-weight: 600; }
-    input[type="password"] { box-sizing: border-box; width: 100%; padding: 0.75rem; border: 1px solid color-mix(in srgb, CanvasText 30%, transparent); border-radius: 8px; font: inherit; }
-    button { margin-top: 1rem; padding: 0.7rem 1rem; border: 0; border-radius: 8px; background: #2563eb; color: white; font: inherit; font-weight: 700; cursor: pointer; }
+    input[type="password"] { box-sizing: border-box; width: 100%; padding: 0.75rem; border: 1px solid color-mix(in srgb, CanvasText 30%, transparent); border-radius: 3px; font: inherit; }
+    button { margin-top: 1rem; padding: 0.7rem 1rem; border: 0; border-radius: 3px; background: #007acc; color: white; font: inherit; font-weight: 700; cursor: pointer; }
     .hint { color: color-mix(in srgb, CanvasText 72%, transparent); }
-    .success { color: #15803d; }
-    .error { color: #b91c1c; }
+    .success { color: light-dark(#107c10, #4ec9b0); }
+    .error { color: light-dark(#a1260d, #f48771); }
   </style>
 </head>
 <body>
@@ -78578,16 +79015,20 @@ function escapeHtml(value) {
     }
   });
 }
-var import_crypto4, import_express, fs6, path4;
+var import_crypto4, import_child_process2, import_express, fs6, path4, webProxiedTools, SUPPORTED_OPTIONAL_DEPENDENCIES;
 var init_DaemonHttpRoutes = __esm({
   "src/server/surfaces/DaemonHttpRoutes.ts"() {
     "use strict";
     import_crypto4 = __toESM(require("crypto"));
+    import_child_process2 = require("child_process");
     import_express = __toESM(require_express2());
     fs6 = __toESM(require("fs"));
     path4 = __toESM(require("path"));
     init_ConsoleLogger();
     init_httpAbort();
+    init_toolProfiles();
+    webProxiedTools = new Set(WEB_PROXIED_TOOLS);
+    SUPPORTED_OPTIONAL_DEPENDENCIES = /* @__PURE__ */ new Set(["@duckdb/node-api", "snowflake-sdk"]);
   }
 });
 
@@ -126743,7 +127184,7 @@ var init_telemetry = __esm({
 
 // src/common/guideHub.ts
 function getGuideHubLeadText(state) {
-  return "Run queries across all your files and databases and collaborate with your Agents";
+  return "Query your databases and local files right from the editor, and give your AI agents the same access.";
 }
 function getConnectionSummary(state) {
   if (state.connectionCount === 0) {
@@ -127040,7 +127481,17 @@ var init_DaemonMcpHttpSurface = __esm({
           logger.info(`[Daemon] Headers: ${JSON.stringify(redactHeadersForLog(req.headers))}`);
           logger.info(`[Daemon] Query: ${JSON.stringify(req.query)}`);
           try {
-            const sessionId = this.resolveSessionId(req);
+            let sessionId = this.resolveSessionId(req);
+            if (req.method === "POST" && !sessionId) {
+              logger.warn("[Daemon] Rejecting POST /mcp request without a sessionId");
+              if (!res.headersSent) {
+                res.status(400).json({ error: "Missing sessionId for POST request" });
+              }
+              return;
+            }
+            if (!sessionId) {
+              sessionId = `session-${import_crypto6.default.randomUUID()}`;
+            }
             const mcpSession = await this.getOrCreateSession(sessionId);
             mcpSession.lastActive = Date.now();
             const transportPromise = mcpSession.transport.handleRequest(req, res);
@@ -127096,7 +127547,7 @@ var init_DaemonMcpHttpSurface = __esm({
         if (typeof headerSessionId === "string" && headerSessionId.length > 0) {
           return headerSessionId;
         }
-        return `session-${import_crypto6.default.randomUUID()}`;
+        return void 0;
       }
       async getOrCreateSession(sessionId) {
         const existingSession = this.sessions.get(sessionId);
@@ -131459,7 +131910,8 @@ var init_DaemonSurfaceManager = __esm({
             resolvedConfig: this.options.resolvedConfig,
             sessionManager: this.options.sessionManager,
             getSurfaceStatus: () => this.getStatus(),
-            credentialRequestService: this.options.credentialRequestService
+            credentialRequestService: this.options.credentialRequestService,
+            toolManager: this.options.toolManager
           },
           this.mcpHttpSurface
         );
@@ -131502,7 +131954,7 @@ var init_DaemonSurfaceManager = __esm({
           http: {
             status: "ready",
             host: this.options.config.server.host,
-            port: this.options.httpPort
+            port: this.options.getHttpPort ? this.options.getHttpPort() : this.options.httpPort
           },
           mcpHttp: {
             path: "/mcp",
@@ -131565,6 +132017,7 @@ var init_Daemon = __esm({
       constructor(configOptions = {}) {
         this.httpServer = null;
         this.isStdioMode = false;
+        this.ownsPidAndSocket = false;
         this.lastActivityTime = Date.now();
         this.uncaughtExceptionHandler = null;
         this.unhandledRejectionHandler = null;
@@ -131597,7 +132050,7 @@ var init_Daemon = __esm({
         this.queryOperationRunner = new QueryOperationRunner(this.sessionManager, this.queryExecutor);
         this.credentialRequestService = new CredentialRequestService(
           this.connectionManager,
-          this.getHttpBaseUrl()
+          () => this.getHttpBaseUrl()
         );
         this.toolManager = new DaemonMcpToolManager(
           this.sessionManager,
@@ -131616,6 +132069,15 @@ var init_Daemon = __esm({
           configDir: this.CONFIG_DIR,
           connectorRegistry: this.connectorRegistry,
           httpPort: this.HTTP_PORT,
+          getHttpPort: () => {
+            if (this.httpServer) {
+              const addr = this.httpServer.address();
+              if (addr && typeof addr.port === "number") {
+                return addr.port;
+              }
+            }
+            return this.HTTP_PORT;
+          },
           queryOperationRunner: this.queryOperationRunner,
           refreshActivity: () => this.refreshActivity(),
           resolvedConfig: this.resolvedConfig,
@@ -131633,7 +132095,14 @@ var init_Daemon = __esm({
       }
       getHttpBaseUrl() {
         const host = ["0.0.0.0", "::", ""].includes(this.config.server.host) ? "127.0.0.1" : this.config.server.host;
-        return `http://${host}:${this.HTTP_PORT}`;
+        let port = this.HTTP_PORT;
+        if (this.httpServer) {
+          const addr = this.httpServer.address();
+          if (addr && typeof addr.port === "number") {
+            port = addr.port;
+          }
+        }
+        return `http://${host}:${port}`;
       }
       /**
        * Auto-provisions built-in connections that should always be available.
@@ -131796,6 +132265,7 @@ var init_Daemon = __esm({
             }
           }
           fs10.writeFileSync(pidPath, process.pid.toString());
+          this.ownsPidAndSocket = true;
         } catch (e) {
           logger.error("[Daemon] Startup error checking PID:", e);
           process.exit(1);
@@ -131824,6 +132294,19 @@ var init_Daemon = __esm({
       async startStdio() {
         this.isStdioMode = true;
         ConsoleLogger.getInstance().setUseStdErr(true);
+        await new Promise((resolve2, reject) => {
+          this.httpServer = this.app.listen(0, "127.0.0.1", () => {
+            const addr = this.httpServer?.address();
+            const bind2 = addr ? `port ${addr.port}` : "unknown port";
+            logger.info(`[Daemon] Stdio background HTTP listening on http://127.0.0.1:${bind2}`);
+            this.httpServer?.removeAllListeners("error");
+            this.httpServer?.on("error", (err) => {
+              logger.error("[Daemon] Background HTTP server error:", err);
+            });
+            resolve2();
+          });
+          this.httpServer.on("error", reject);
+        });
         await this.surfaceManager.startStdio();
       }
       stop() {
@@ -131859,17 +132342,19 @@ var init_Daemon = __esm({
           clearInterval(this.idleCheckInterval);
           this.idleCheckInterval = void 0;
         }
-        const pidPath = path7.join(this.CONFIG_DIR, `server-${this.HTTP_PORT}.pid`);
-        if (fs10.existsSync(pidPath)) {
-          try {
-            fs10.unlinkSync(pidPath);
-          } catch {
+        if (this.ownsPidAndSocket) {
+          const pidPath = path7.join(this.CONFIG_DIR, `server-${this.HTTP_PORT}.pid`);
+          if (fs10.existsSync(pidPath)) {
+            try {
+              fs10.unlinkSync(pidPath);
+            } catch {
+            }
           }
-        }
-        if (fs10.existsSync(this.SOCKET_PATH)) {
-          try {
-            fs10.unlinkSync(this.SOCKET_PATH);
-          } catch {
+          if (fs10.existsSync(this.SOCKET_PATH)) {
+            try {
+              fs10.unlinkSync(this.SOCKET_PATH);
+            } catch {
+            }
           }
         }
       }