@mindstudio-ai/local-model-tunnel 0.5.45 → 0.5.47

package/dist/{chunk-ZKXKUFNA.js → chunk-UT7QCCAJ.js}

@@ -890,11 +890,11 @@ async function ensureWorker(projectRoot) {
     stdio: ["ignore", "pipe", "pipe", "ipc"],
     env: { ...process.env }
   });
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     const onMessage = (msg) => {
       if (msg?.type === "ready") {
         child.off("message", onMessage);
-        resolve2();
+        resolve3();
       }
     };
     child.on("message", onMessage);
@@ -958,16 +958,16 @@ async function executeMethodInWorker(opts) {
   const w = await ensureWorker(opts.projectRoot);
   const id = randomBytes(8).toString("hex");
   log.debug("executor", "Sending method to execution process", { id, methodExport: opts.methodExport });
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const timer = setTimeout(() => {
       pending.delete(id);
       log.warn("executor", "Method execution timed out", { id, methodExport: opts.methodExport });
-      resolve2({
+      resolve3({
         success: false,
         error: { message: "Method execution timed out after 30m" }
       });
     }, EXECUTION_TIMEOUT_MS);
-    pending.set(id, { resolve: resolve2, timer });
+    pending.set(id, { resolve: resolve3, timer });
     if (opts.sessionId) {
       requestMeta.set(id, { sessionId: opts.sessionId, method: opts.methodExport, input: opts.input });
     }
@@ -1167,8 +1167,6 @@ async function disconnectHeartbeat() {
 }
 
 // src/dev/execution/runner.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { join as join6 } from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 
 // src/dev/execution/format-error.ts
@@ -1195,9 +1193,205 @@ function formatErrorForDisplay(error) {
   return parts.join("\n");
 }
 
-// src/dev/execution/agent-config.ts
+// src/dev/interfaces/agent-config.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join6, dirname as dirname3 } from "path";
+
+// src/dev/interfaces/schema/extract.ts
+import ts3 from "typescript";
+import { readFileSync as readFileSync3 } from "fs";
+
+// src/dev/interfaces/schema/type-map.ts
+import ts from "typescript";
 import { readFileSync as readFileSync2 } from "fs";
-import { join as join5, dirname as dirname2 } from "path";
+import { dirname as dirname2 } from "path";
+
+// src/dev/interfaces/schema/resolve-import.ts
+import { existsSync as existsSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+var EXTENSIONS = [".ts", ".tsx", "/index.ts", "/index.tsx"];
+function resolveImportPath(specifier, fromDir) {
+  if (!specifier.startsWith("./") && !specifier.startsWith("../")) {
+    return null;
+  }
+  const base = resolve2(fromDir, specifier);
+  if (existsSync2(base) && !base.endsWith("/")) return base;
+  for (const ext of EXTENSIONS) {
+    const candidate = base + ext;
+    if (existsSync2(candidate)) return candidate;
+  }
+  return null;
+}
+
+// src/dev/interfaces/schema/type-map.ts
+function collectTypeMap(filePath) {
+  const typeMap = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  const source = readFileSync2(filePath, "utf-8");
+  const sourceFile = ts.createSourceFile(
+    filePath,
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TS
+  );
+  collectFromFile(sourceFile, filePath, typeMap, visited);
+  return { typeMap, sourceFile };
+}
+function collectFromFile(sourceFile, filePath, typeMap, visited) {
+  if (visited.has(filePath)) return;
+  visited.add(filePath);
+  const dir = dirname2(filePath);
+  for (const stmt of sourceFile.statements) {
+    if (ts.isTypeAliasDeclaration(stmt)) {
+      typeMap.set(stmt.name.text, stmt.type);
+    }
+    if (ts.isInterfaceDeclaration(stmt)) {
+      const typeLiteral = ts.factory.createTypeLiteralNode(
+        stmt.members.filter(ts.isPropertySignature)
+      );
+      typeMap.set(stmt.name.text, typeLiteral);
+    }
+    if (ts.isImportDeclaration(stmt) && stmt.moduleSpecifier && ts.isStringLiteral(stmt.moduleSpecifier)) {
+      const specifier = stmt.moduleSpecifier.text;
+      const resolved = resolveImportPath(specifier, dir);
+      if (!resolved) continue;
+      try {
+        const importSource = readFileSync2(resolved, "utf-8");
+        const importFile = ts.createSourceFile(
+          resolved,
+          importSource,
+          ts.ScriptTarget.Latest,
+          true,
+          ts.ScriptKind.TS
+        );
+        collectFromFile(importFile, resolved, typeMap, visited);
+      } catch {
+      }
+    }
+  }
+}
+
+// src/dev/interfaces/schema/convert.ts
+import ts2 from "typescript";
+var STRING_FALLBACK = { type: "string" };
+function convertTypeNode(node, typeMap, sourceFile) {
+  if (ts2.isTypeLiteralNode(node)) {
+    return convertTypeLiteral(node, typeMap, sourceFile);
+  }
+  if (node.kind === ts2.SyntaxKind.StringKeyword) return { type: "string" };
+  if (node.kind === ts2.SyntaxKind.NumberKeyword) return { type: "number" };
+  if (node.kind === ts2.SyntaxKind.BooleanKeyword) return { type: "boolean" };
+  if (node.kind === ts2.SyntaxKind.AnyKeyword) return { type: "object" };
+  if (node.kind === ts2.SyntaxKind.UnknownKeyword) return { type: "object" };
+  if (ts2.isArrayTypeNode(node)) {
+    const items = convertTypeNode(node.elementType, typeMap, sourceFile);
+    return { type: "array", items };
+  }
+  if (ts2.isTypeReferenceNode(node) && ts2.isIdentifier(node.typeName) && node.typeName.text === "Array" && node.typeArguments?.length === 1) {
+    const items = convertTypeNode(node.typeArguments[0], typeMap, sourceFile);
+    return { type: "array", items };
+  }
+  if (ts2.isTypeReferenceNode(node) && ts2.isIdentifier(node.typeName) && node.typeName.text === "Record" && node.typeArguments?.length === 2) {
+    const valueSchema = convertTypeNode(node.typeArguments[1], typeMap, sourceFile);
+    return { type: "object", additionalProperties: valueSchema };
+  }
+  if (ts2.isUnionTypeNode(node)) {
+    const allStringLiterals = node.types.every(
+      (t) => ts2.isLiteralTypeNode(t) && ts2.isStringLiteral(t.literal)
+    );
+    if (allStringLiterals) {
+      const enumValues = node.types.map(
+        (t) => t.literal.text
+      );
+      return { type: "string", enum: enumValues };
+    }
+    return STRING_FALLBACK;
+  }
+  if (ts2.isParenthesizedTypeNode(node)) {
+    return convertTypeNode(node.type, typeMap, sourceFile);
+  }
+  if (ts2.isIntersectionTypeNode(node)) {
+    const merged = { type: "object", properties: {}, required: [] };
+    for (const member of node.types) {
+      const sub = convertTypeNode(member, typeMap, sourceFile);
+      if (sub.properties) {
+        Object.assign(merged.properties, sub.properties);
+        if (sub.required) merged.required.push(...sub.required);
+      }
+    }
+    if (merged.required.length === 0) delete merged.required;
+    if (Object.keys(merged.properties).length === 0) delete merged.properties;
+    return merged;
+  }
+  if (ts2.isTypeReferenceNode(node) && ts2.isIdentifier(node.typeName)) {
+    const resolved = typeMap.get(node.typeName.text);
+    if (resolved) return convertTypeNode(resolved, typeMap, sourceFile);
+  }
+  return STRING_FALLBACK;
+}
+function convertTypeLiteral(node, typeMap, sourceFile) {
+  const properties = {};
+  const required = [];
+  for (const member of node.members) {
+    if (!ts2.isPropertySignature(member) || !member.name) continue;
+    const name = member.name.getText(sourceFile);
+    const optional = !!member.questionToken;
+    if (member.type) {
+      properties[name] = convertTypeNode(member.type, typeMap, sourceFile);
+      if (!optional) required.push(name);
+    }
+  }
+  const schema = { type: "object", properties };
+  if (required.length > 0) schema.required = required;
+  return schema;
+}
+
+// src/dev/interfaces/schema/types.ts
+var EMPTY_OBJECT_SCHEMA = { type: "object", properties: {} };
+
+// src/dev/interfaces/schema/extract.ts
+function extractInputSchema(filePath, exportName) {
+  let source;
+  try {
+    source = readFileSync3(filePath, "utf-8");
+  } catch {
+    return EMPTY_OBJECT_SCHEMA;
+  }
+  const { typeMap, sourceFile } = collectTypeMap(filePath);
+  const fn = findExportedFunction(sourceFile, exportName);
+  if (!fn || fn.parameters.length === 0) return EMPTY_OBJECT_SCHEMA;
+  const param = fn.parameters[0];
+  if (!param.type) return EMPTY_OBJECT_SCHEMA;
+  return convertTypeNode(param.type, typeMap, sourceFile);
+}
+function findExportedFunction(sourceFile, name) {
+  for (const stmt of sourceFile.statements) {
+    if (ts3.isFunctionDeclaration(stmt) && stmt.name?.text === name && hasExportModifier(stmt)) {
+      return stmt;
+    }
+    if (ts3.isVariableStatement(stmt) && hasExportModifier(stmt)) {
+      for (const decl of stmt.declarationList.declarations) {
+        if (ts3.isIdentifier(decl.name) && decl.name.text === name && decl.initializer) {
+          if (ts3.isArrowFunction(decl.initializer)) {
+            return decl.initializer;
+          }
+          if (ts3.isFunctionExpression(decl.initializer)) {
+            return decl.initializer;
+          }
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function hasExportModifier(node) {
+  return ts3.canHaveModifiers(node) && (ts3.getModifiers(node) ?? []).some(
+    (m) => m.kind === ts3.SyntaxKind.ExportKeyword
+  );
+}
+
+// src/dev/interfaces/agent-config.ts
 function readAgentConfig(projectRoot, appConfig) {
   const agentInterface = appConfig.interfaces.find(
     (i) => i.type === "agent" && i.enabled !== false
@@ -1205,10 +1399,10 @@ function readAgentConfig(projectRoot, appConfig) {
   if (!agentInterface) {
     throw new Error("No agent interface configured in mindstudio.json");
   }
-  const configPath = join5(projectRoot, agentInterface.path);
+  const configPath = join6(projectRoot, agentInterface.path);
   let raw;
   try {
-    raw = readFileSync2(configPath, "utf-8");
+    raw = readFileSync4(configPath, "utf-8");
   } catch {
     throw new Error(
       `Agent config not found at ${agentInterface.path} \u2014 run your build command`
@@ -1216,11 +1410,11 @@ function readAgentConfig(projectRoot, appConfig) {
   }
   const parsed = JSON.parse(raw);
   const config2 = parsed.agent ?? parsed;
-  const agentDir = dirname2(configPath);
-  const systemPromptPath = join5(agentDir, config2.systemPrompt);
+  const agentDir = dirname3(configPath);
+  const systemPromptPath = join6(agentDir, config2.systemPrompt);
   let systemPrompt;
   try {
-    systemPrompt = readFileSync2(systemPromptPath, "utf-8");
+    systemPrompt = readFileSync4(systemPromptPath, "utf-8");
   } catch {
     throw new Error(
       `Agent system prompt not found at ${config2.systemPrompt} \u2014 run your build command`
@@ -1228,21 +1422,23 @@ function readAgentConfig(projectRoot, appConfig) {
   }
   const tools = (config2.tools ?? []).map(
     (tool) => {
-      const descPath = join5(agentDir, tool.description);
+      const descPath = join6(agentDir, tool.description);
       let description;
       try {
-        description = readFileSync2(descPath, "utf-8");
+        description = readFileSync4(descPath, "utf-8");
       } catch {
         throw new Error(
           `Agent tool description not found at ${tool.description} for method "${tool.method}" \u2014 run your build command`
         );
       }
-      const entry = {
-        name: tool.method,
-        description
-      };
-      if (tool.inputSchema) entry.inputSchema = tool.inputSchema;
-      return entry;
+      let inputSchema;
+      if (tool.inputSchema) {
+        inputSchema = tool.inputSchema;
+      } else {
+        const method = appConfig.methods.find((m) => m.id === tool.method);
+        inputSchema = method ? extractInputSchema(join6(projectRoot, method.path), method.export) : EMPTY_OBJECT_SCHEMA;
+      }
+      return { name: tool.method, description, inputSchema };
     }
   );
   return {
@@ -1254,6 +1450,51 @@ function readAgentConfig(projectRoot, appConfig) {
   };
 }
 
+// src/dev/interfaces/api-config.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join7 } from "path";
+function readApiConfig(projectRoot, appConfig) {
+  const apiInterface = appConfig.interfaces.find(
+    (i) => i.type === "api" && i.enabled !== false
+  );
+  if (!apiInterface) {
+    throw new Error("No API interface config found");
+  }
+  const apiJsonPath = join7(projectRoot, apiInterface.path);
+  const raw = readFileSync5(apiJsonPath, "utf-8");
+  const parsed = JSON.parse(raw);
+  if (!parsed.api) {
+    throw new Error("No API interface config found");
+  }
+  return parsed.api;
+}
+
+// src/dev/interfaces/read-config.ts
+function readConfig(projectRoot, appConfig) {
+  let agent = null;
+  try {
+    agent = readAgentConfig(projectRoot, appConfig);
+  } catch (err) {
+    log.debug("config", "Agent config not available", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+  let api = null;
+  try {
+    api = readApiConfig(projectRoot, appConfig);
+  } catch (err) {
+    log.debug("config", "API config not available", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+  return {
+    name: appConfig.name,
+    auth: appConfig.auth ?? null,
+    agent,
+    api
+  };
+}
+
 // src/dev/execution/runner.ts
 var DevRunner = class {
   constructor(appId, projectRoot, startOpts = {}) {
@@ -1363,13 +1604,12 @@ var DevRunner = class {
     try {
       const authorizationToken = await fetchCallbackToken(this.appId, this.session.sessionId);
       const transpiledPath = await this.transpiler.transpile(opts.methodPath);
-      const auth = this.roleOverride ? {
-        userId: this.session.auth.userId,
-        roleAssignments: this.roleOverride.map((roleName) => ({
-          userId: this.session.auth.userId,
-          roleName
-        }))
-      } : this.session.auth;
+      const userId = opts.userId ?? this.session.auth.userId;
+      const roles = opts.roles ?? this.roleOverride;
+      const auth = roles ? {
+        userId,
+        roleAssignments: roles.map((roleName) => ({ userId, roleName }))
+      } : { ...this.session.auth, userId };
       const result = await executeMethod({
         transpiledPath,
         methodExport: opts.methodExport,
@@ -1549,16 +1789,8 @@ var DevRunner = class {
     }
   }
   async handleRequest(request) {
-    if (request.type === "get-agent-config") {
-      await this.handleGetAgentConfig(request);
-      return;
-    }
-    if (request.type === "get-auth-config") {
-      await this.handleGetAuthConfig(request);
-      return;
-    }
-    if (request.type === "get-api-config") {
-      await this.handleGetApiConfig(request);
+    if (request.type === "get-config") {
+      await this.handleGetConfig(request);
       return;
     }
     const startTime = Date.now();
@@ -1699,122 +1931,40 @@ var DevRunner = class {
       });
     }
   }
-  async handleGetAgentConfig(request) {
-    const startTime = Date.now();
-    log.info("runner", "Agent config requested", { requestId: request.requestId, sessionId: this.session.sessionId });
-    try {
-      if (!this.appConfig) {
-        throw new Error("App config not available");
-      }
-      const bundle = readAgentConfig(this.projectRoot, this.appConfig);
-      await submitDevResult(
-        this.appId,
-        this.session.sessionId,
-        request.requestId,
-        {
-          type: "get-agent-config",
-          success: true,
-          output: bundle
-        }
-      );
-      log.info("runner", "Agent config sent", { requestId: request.requestId, duration: Date.now() - startTime });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : "Unknown error";
-      log.error("runner", "Agent config failed", { requestId: request.requestId, error: message });
-      try {
-        await submitDevResult(
-          this.appId,
-          this.session.sessionId,
-          request.requestId,
-          {
-            type: "get-agent-config",
-            success: false,
-            error: { message }
-          }
-        );
-      } catch (submitErr) {
-        log.error("runner", "Failed to report agent config error to platform", { error: submitErr instanceof Error ? submitErr.message : String(submitErr) });
-      }
-    }
-  }
-  async handleGetAuthConfig(request) {
-    log.info("runner", "Auth config requested", { requestId: request.requestId, sessionId: this.session.sessionId });
+  async handleGetConfig(request) {
+    log.info("runner", "Config requested", { requestId: request.requestId, sessionId: this.session.sessionId });
     try {
       if (!this.appConfig) {
         throw new Error("App config not available");
       }
+      const config2 = readConfig(this.projectRoot, this.appConfig);
       await submitDevResult(
         this.appId,
         this.session.sessionId,
         request.requestId,
         {
-          type: "get-auth-config",
-          success: true,
-          output: { auth: this.appConfig.auth ?? null, name: this.appConfig.name }
-        }
-      );
-      log.info("runner", "Auth config sent", { requestId: request.requestId });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : "Unknown error";
-      log.error("runner", "Auth config failed", { requestId: request.requestId, error: message });
-      try {
-        await submitDevResult(
-          this.appId,
-          this.session.sessionId,
-          request.requestId,
-          {
-            type: "get-auth-config",
-            success: false,
-            error: { message }
-          }
-        );
-      } catch (submitErr) {
-        log.error("runner", "Failed to report auth config error to platform", { error: submitErr instanceof Error ? submitErr.message : String(submitErr) });
-      }
-    }
-  }
-  async handleGetApiConfig(request) {
-    log.info("runner", "API config requested", { requestId: request.requestId, sessionId: this.session.sessionId });
-    try {
-      const apiInterface = this.appConfig?.interfaces.find(
-        (i) => i.type === "api" && i.enabled !== false
-      );
-      if (!apiInterface) {
-        throw new Error("No API interface config found");
-      }
-      const apiJsonPath = join6(this.projectRoot, apiInterface.path);
-      const raw = readFileSync3(apiJsonPath, "utf-8");
-      const parsed = JSON.parse(raw);
-      if (!parsed.api) {
-        throw new Error("No API interface config found");
-      }
-      await submitDevResult(
-        this.appId,
-        this.session.sessionId,
-        request.requestId,
-        {
-          type: "get-api-config",
+          type: "get-config",
           success: true,
-          output: parsed.api
+          output: config2
         }
       );
-      log.info("runner", "API config sent", { requestId: request.requestId });
+      log.info("runner", "Config sent", { requestId: request.requestId });
     } catch (err) {
       const message = err instanceof Error ? err.message : "Unknown error";
-      log.error("runner", "API config failed", { requestId: request.requestId, error: message });
+      log.error("runner", "Config failed", { requestId: request.requestId, error: message });
       try {
         await submitDevResult(
           this.appId,
           this.session.sessionId,
           request.requestId,
           {
-            type: "get-api-config",
+            type: "get-config",
             success: false,
             error: { message }
           }
         );
       } catch (submitErr) {
-        log.error("runner", "Failed to report API config error to platform", { error: submitErr instanceof Error ? submitErr.message : String(submitErr) });
+        log.error("runner", "Failed to report config error to platform", { error: submitErr instanceof Error ? submitErr.message : String(submitErr) });
       }
     }
   }
@@ -1863,7 +2013,7 @@ var DevRunner = class {
     }
   }
   sleep(ms) {
-    return new Promise((resolve2) => setTimeout(resolve2, ms));
+    return new Promise((resolve3) => setTimeout(resolve3, ms));
   }
 };
 
@@ -2057,12 +2207,12 @@ var DevProxy = class _DevProxy {
       );
     }
     const id = randomBytes4(4).toString("hex");
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       this.commandQueue.push({
         id,
         steps,
         timeoutMs,
-        resolve: resolve2,
+        resolve: resolve3,
         reject,
         queuedAt: Date.now()
       });
@@ -2082,7 +2232,7 @@ var DevProxy = class _DevProxy {
       const target = this.clients.getCommandTarget();
       if (!target) break;
       const queued = this.commandQueue.shift();
-      const { id, steps, timeoutMs, resolve: resolve2, reject } = queued;
+      const { id, steps, timeoutMs, resolve: resolve3, reject } = queued;
       log.info("proxy", "Browser command sent", {
         id,
         clientId: target.id,
@@ -2102,7 +2252,7 @@ var DevProxy = class _DevProxy {
         reject(new Error("Browser command timed out"));
         this.drainCommandQueue();
       }, timeoutMs);
-      this.pendingResults.set(id, { resolve: resolve2, timeout, clientId: target.id });
+      this.pendingResults.set(id, { resolve: resolve3, timeout, clientId: target.id });
       target.activeCommandId = id;
       try {
         target.ws.send(JSON.stringify({ type: "command", id, steps }));
@@ -2170,7 +2320,7 @@ var DevProxy = class _DevProxy {
     throw new Error("Failed to start proxy server");
   }
   listenOnPort(server, port) {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const onError = (err) => {
         server.removeListener("error", onError);
         reject(err);
@@ -2183,7 +2333,7 @@ var DevProxy = class _DevProxy {
           reject(new Error("Failed to get proxy server address"));
           return;
         }
-        resolve2(addr.port);
+        resolve3(addr.port);
       });
     });
   }
@@ -2836,7 +2986,7 @@ var DevProxy = class _DevProxy {
     if (releaseId) url.searchParams.set("releaseId", releaseId);
     const isHttps = url.protocol === "https:";
     const httpModule = isHttps ? https : http;
-    return new Promise((resolve2) => {
+    return new Promise((resolve3) => {
       const req = httpModule.request(
         {
           hostname: url.hostname,
@@ -2855,24 +3005,24 @@ var DevProxy = class _DevProxy {
             try {
               const body = JSON.parse(Buffer.concat(chunks).toString("utf-8"));
               if (body.user && body.token) {
-                resolve2({
+                resolve3({
                   user: body.user,
                   token: body.token,
                   methods: body.methods ?? {}
                 });
               } else {
-                resolve2(null);
+                resolve3(null);
               }
             } catch {
-              resolve2(null);
+              resolve3(null);
             }
           });
         }
       );
-      req.on("error", () => resolve2(null));
+      req.on("error", () => resolve3(null));
       req.setTimeout(3e3, () => {
         req.destroy();
-        resolve2(null);
+        resolve3(null);
       });
       req.end();
     });
@@ -2935,13 +3085,13 @@ ${agentScript}`;
 };
 
 // src/dev/config/app-config.ts
-import { readFileSync as readFileSync4, existsSync as existsSync2 } from "fs";
-import { join as join7, dirname as dirname3 } from "path";
+import { readFileSync as readFileSync6, existsSync as existsSync3 } from "fs";
+import { join as join8, dirname as dirname4 } from "path";
 function detectAppConfig(cwd = process.cwd()) {
-  const appJsonPath = join7(cwd, "mindstudio.json");
-  if (!existsSync2(appJsonPath)) return null;
+  const appJsonPath = join8(cwd, "mindstudio.json");
+  if (!existsSync3(appJsonPath)) return null;
   try {
-    const raw = readFileSync4(appJsonPath, "utf-8");
+    const raw = readFileSync6(appJsonPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed.name || !Array.isArray(parsed.methods)) {
       return null;
@@ -2978,12 +3128,12 @@ function getWebInterfaceConfig(appConfig, cwd = process.cwd()) {
   if (!webInterface) {
     return null;
   }
-  const configPath = join7(cwd, webInterface.path);
-  if (!existsSync2(configPath)) {
+  const configPath = join8(cwd, webInterface.path);
+  if (!existsSync3(configPath)) {
     return null;
   }
   try {
-    const raw = readFileSync4(configPath, "utf-8");
+    const raw = readFileSync6(configPath, "utf-8");
     const parsed = JSON.parse(raw);
     const web = parsed.web;
     if (!web || typeof web !== "object") {
@@ -3004,18 +3154,18 @@ function getWebProjectDir(appConfig, cwd = process.cwd()) {
   if (!webInterface) {
     return null;
   }
-  return dirname3(join7(cwd, webInterface.path));
+  return dirname4(join8(cwd, webInterface.path));
 }
 function readTableSources(appConfig, cwd = process.cwd()) {
   const results = [];
   for (const table of appConfig.tables) {
-    const filePath = join7(cwd, table.path);
-    if (!existsSync2(filePath)) {
+    const filePath = join8(cwd, table.path);
+    if (!existsSync3(filePath)) {
       log.warn("config", "Table source file not found", { table: table.export, path: table.path });
       continue;
     }
     try {
-      const source = readFileSync4(filePath, "utf-8");
+      const source = readFileSync6(filePath, "utf-8");
       const name = table.export;
       results.push({ name, source });
     } catch (err) {
@@ -3033,9 +3183,9 @@ function findDirsNeedingInstall(appConfig, cwd = process.cwd()) {
     const firstMethodPath = appConfig.methods[0].path;
     const parts = firstMethodPath.split("/");
     for (let i = parts.length - 1; i >= 1; i--) {
-      const candidate = join7(cwd, ...parts.slice(0, i));
-      if (existsSync2(join7(candidate, "package.json"))) {
-        if (!existsSync2(join7(candidate, "node_modules"))) {
+      const candidate = join8(cwd, ...parts.slice(0, i));
+      if (existsSync3(join8(candidate, "package.json"))) {
+        if (!existsSync3(join8(candidate, "node_modules"))) {
           dirs.push(candidate);
         }
         break;
@@ -3043,8 +3193,8 @@ function findDirsNeedingInstall(appConfig, cwd = process.cwd()) {
     }
   }
   const webProjectDir = getWebProjectDir(appConfig, cwd);
-  if (webProjectDir && existsSync2(join7(webProjectDir, "package.json"))) {
-    if (!existsSync2(join7(webProjectDir, "node_modules"))) {
+  if (webProjectDir && existsSync3(join8(webProjectDir, "package.json"))) {
+    if (!existsSync3(join8(webProjectDir, "node_modules"))) {
       dirs.push(webProjectDir);
     }
   }
@@ -3073,11 +3223,11 @@ function detectGitBranch() {
 
 // src/dev/config/table-watcher.ts
 import { watch } from "chokidar";
-import { join as join8, dirname as dirname4, basename as basename2 } from "path";
+import { join as join9, dirname as dirname5, basename as basename2 } from "path";
 function watchTableFiles(tables, cwd, onChanged) {
   if (tables.length === 0) return () => {
   };
-  const filePaths = tables.map((t) => join8(cwd, t.path));
+  const filePaths = tables.map((t) => join9(cwd, t.path));
   let syncTimer;
   const watcher = watch(filePaths, {
     ignoreInitial: true,
@@ -3090,8 +3240,8 @@ function watchTableFiles(tables, cwd, onChanged) {
   });
   const dirToFiles = /* @__PURE__ */ new Map();
   for (const table of tables) {
-    const absPath = join8(cwd, table.path);
-    const dir = dirname4(absPath);
+    const absPath = join9(cwd, table.path);
+    const dir = dirname5(absPath);
     const file = basename2(absPath);
     if (!dirToFiles.has(dir)) dirToFiles.set(dir, /* @__PURE__ */ new Set());
     dirToFiles.get(dir).add(file);
@@ -3108,9 +3258,9 @@ function watchTableFiles(tables, cwd, onChanged) {
 
 // src/dev/config/config-watcher.ts
 import { watch as watch2 } from "chokidar";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 function watchConfigFile(cwd, onChanged) {
-  const configPath = join9(cwd, "mindstudio.json");
+  const configPath = join10(cwd, "mindstudio.json");
   let debounceTimer;
   const watcher = watch2(configPath, {
     ignoreInitial: true,
@@ -3179,4 +3329,4 @@ export {
   watchTableFiles,
   watchConfigFile
 };
-//# sourceMappingURL=chunk-ZKXKUFNA.js.map
+//# sourceMappingURL=chunk-UT7QCCAJ.js.map