@insforge/mcp 1.2.9 → 1.2.10-dev.1

package/dist/{chunk-YH7HSQYJ.js → chunk-MQZLKWM4.js}

@@ -567,6 +567,28 @@ var authConfigSchema = z7.object({
   updatedAt: z7.string()
   // PostgreSQL timestamp
 });
+var smtpConfigSchema = z7.object({
+  id: z7.string().uuid(),
+  enabled: z7.boolean(),
+  host: z7.string(),
+  port: z7.number().int(),
+  username: z7.string(),
+  hasPassword: z7.boolean(),
+  // Never expose actual password
+  senderEmail: z7.string(),
+  senderName: z7.string(),
+  minIntervalSeconds: z7.number().int().min(0),
+  createdAt: z7.string(),
+  updatedAt: z7.string()
+});
+var emailTemplateSchema = z7.object({
+  id: z7.string().uuid(),
+  templateType: z7.string(),
+  subject: z7.string(),
+  bodyHtml: z7.string(),
+  createdAt: z7.string(),
+  updatedAt: z7.string()
+});
 var tokenPayloadSchema = z7.object({
   sub: userIdSchema,
   // Subject (user ID)
@@ -598,7 +620,8 @@ var createUserRequestSchema = z8.object({
   email: emailSchema,
   password: passwordSchema,
   name: nameSchema.optional(),
-  redirectTo: z8.string().url().optional()
+  redirectTo: z8.string().url().optional(),
+  autoConfirm: z8.boolean().optional()
 });
 var createSessionRequestSchema = z8.object({
   email: emailSchema,
@@ -744,6 +767,25 @@ var getPublicAuthConfigResponseSchema = z8.object({
     allowedRedirectUrls: true
   }).shape
 });
+var upsertSmtpConfigRequestSchema = z8.object({
+  enabled: z8.boolean(),
+  host: z8.string().min(1, "SMTP host is required"),
+  port: z8.union([z8.literal(25), z8.literal(465), z8.literal(587), z8.literal(2525)], {
+    errorMap: () => ({ message: "Port must be one of: 25, 465, 587, 2525" })
+  }),
+  username: z8.string().min(1, "SMTP username is required"),
+  password: z8.string().min(1, "SMTP password is required").optional(),
+  senderEmail: z8.string().email("Invalid sender email"),
+  senderName: z8.string().min(1, "Sender name is required"),
+  minIntervalSeconds: z8.number().int().min(0).default(60)
+});
+var updateEmailTemplateRequestSchema = z8.object({
+  subject: z8.string().min(1, "Subject is required"),
+  bodyHtml: z8.string().min(1, "Template body is required")
+});
+var listEmailTemplatesResponseSchema = z8.object({
+  data: z8.array(emailTemplateSchema)
+});
 var authErrorResponseSchema = z8.object({
   error: z8.string(),
   message: z8.string(),
@@ -1574,9 +1616,9 @@ var sendEmailResponseSchema = z20.object({});
 import { z as z21 } from "zod";
 var deploymentStatusSchema = z21.enum([
   "WAITING",
-  // Record created, waiting for client to upload zip to S3
+  // Record created, waiting for source zip upload or direct file registration/content
   "UPLOADING",
-  // Server is downloading from S3 and uploading to Vercel
+  // File uploads or Vercel deployment creation are in progress
   "QUEUED",
   // Vercel: deployment queued
   "BUILDING",
@@ -1613,11 +1655,47 @@ var envVarSchema = z22.object({
   key: z22.string(),
   value: z22.string()
 });
+var deploymentFilePathSchema = z22.string().min(1, "path is required").max(2048, "path is too long").refine((value) => !value.includes("\0"), "path cannot contain null bytes").refine((value) => !value.includes("\\"), "path must use forward slashes").refine((value) => !value.startsWith("/"), "path must be relative").refine((value) => value.split("/").every((part) => part !== "" && part !== "." && part !== ".."), "path cannot contain empty, current, or parent directory segments");
+var deploymentManifestFileEntrySchema = z22.object({
+  path: deploymentFilePathSchema,
+  sha: z22.string().regex(/^[a-f0-9]{40}$/i, "sha must be a SHA-1 hex digest"),
+  size: z22.number().int().nonnegative()
+});
+var deploymentManifestFileSchema = deploymentManifestFileEntrySchema.extend({
+  fileId: z22.string().uuid(),
+  uploadedAt: z22.string().datetime().nullable()
+});
 var createDeploymentResponseSchema = z22.object({
   id: z22.string().uuid(),
   uploadUrl: z22.string().url(),
   uploadFields: z22.record(z22.string())
-  // Required for S3 presigned POST (policy, signature, key, etc.)
+});
+var createDirectDeploymentResponseSchema = z22.object({
+  id: z22.string().uuid(),
+  status: deploymentSchema.shape.status
+});
+var createDeploymentManifestRequestSchema = z22.object({
+  files: z22.array(deploymentManifestFileEntrySchema).min(1)
+}).superRefine(({ files }, ctx) => {
+  const firstSeenByPath = /* @__PURE__ */ new Map();
+  files.forEach((file, index) => {
+    const existingIndex = firstSeenByPath.get(file.path);
+    if (existingIndex !== void 0) {
+      ctx.addIssue({
+        code: z22.ZodIssueCode.custom,
+        message: "duplicate file path",
+        path: ["files", index, "path"]
+      });
+      return;
+    }
+    firstSeenByPath.set(file.path, index);
+  });
+});
+var createDeploymentManifestResponseSchema = z22.object({
+  files: z22.array(deploymentManifestFileSchema)
+});
+var uploadDeploymentFileResponseSchema = deploymentManifestFileSchema.extend({
+  uploadedAt: z22.string().datetime()
 });
 var startDeploymentRequestSchema = z22.object({
   projectSettings: projectSettingsSchema.optional(),
@@ -2562,23 +2640,320 @@ function registerFunctionTools(ctx) {
 // src/shared/tools/deployment.ts
 import { z as z29 } from "zod";
 import fetch6 from "node-fetch";
+import { createHash } from "crypto";
 import { promises as fs3, createWriteStream, createReadStream } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join2 } from "path";
+import { join as join2, relative, sep } from "path";
 import archiver from "archiver";
 import FormData2 from "form-data";
-function isCreateDeploymentResponse(obj) {
-  if (typeof obj !== "object" || obj === null) {
-    return false;
+var DIRECT_DEPLOYMENT_MIN_VERSION = "2.0.4";
+var EXCLUDED_DEPLOYMENT_SEGMENTS = /* @__PURE__ */ new Set(["node_modules", ".git", ".next", "dist", "build", ".insforge"]);
+var DirectDeploymentUnsupportedError = class extends Error {
+  constructor() {
+    super("Direct deployment endpoints are not available on this backend");
+    this.name = "DirectDeploymentUnsupportedError";
   }
-  const value = obj;
-  const idOk = "id" in value && (typeof value.id === "string" || typeof value.id === "number");
-  const urlOk = "uploadUrl" in value && typeof value.uploadUrl === "string" && value.uploadUrl.length > 0;
-  const fieldsOk = "uploadFields" in value && typeof value.uploadFields === "object" && value.uploadFields !== null;
-  return idOk && urlOk && fieldsOk;
+};
+function isAbsoluteSourcePath(sourceDirectory) {
+  return sourceDirectory.startsWith("/") || /^[a-zA-Z]:[/\\]/.test(sourceDirectory);
+}
+function supportsDirectDeploymentVersion(backendVersion) {
+  const cleanVersion = backendVersion.replace(/^v/, "").split("-")[0];
+  const [major = 0, minor = 0, patch = 0] = cleanVersion.split(".").map(Number);
+  const [minMajor, minMinor, minPatch] = DIRECT_DEPLOYMENT_MIN_VERSION.split(".").map(Number);
+  if (major !== minMajor) return major > minMajor;
+  if (minor !== minMinor) return minor > minMinor;
+  return patch >= minPatch;
+}
+function shouldExcludeDeploymentPath(normalizedName) {
+  const segments = normalizedName.split("/");
+  if (segments.some((segment) => segment === ".env" || segment.startsWith(".env."))) {
+    return true;
+  }
+  if (segments.some((segment) => EXCLUDED_DEPLOYMENT_SEGMENTS.has(segment))) {
+    return true;
+  }
+  return normalizedName === ".DS_Store" || normalizedName.endsWith("/.DS_Store") || normalizedName.endsWith(".log");
+}
+function normalizeRelativePath(rootDirectory, absolutePath) {
+  return relative(rootDirectory, absolutePath).split(sep).join("/").replace(/\\/g, "/");
+}
+async function hashFile(filePath) {
+  const hash = createHash("sha1");
+  let size = 0;
+  for await (const chunk of createReadStream(filePath)) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    size += buffer.length;
+    hash.update(buffer);
+  }
+  return { sha: hash.digest("hex"), size };
+}
+function parseCreateDeploymentResponse(obj) {
+  const result = createDeploymentResponseSchema.safeParse(obj);
+  if (!result.success) {
+    throw new Error("Unexpected response format from deployments endpoint");
+  }
+  return result.data;
+}
+function parseCreateDirectDeploymentResponse(obj) {
+  const result = createDirectDeploymentResponseSchema.safeParse(obj);
+  if (!result.success) {
+    throw new Error("Unexpected response format from direct deployments endpoint");
+  }
+  return result.data;
+}
+function parseCreateDeploymentManifestResponse(obj) {
+  const result = createDeploymentManifestResponseSchema.safeParse(obj);
+  if (!result.success) {
+    throw new Error("Unexpected response format from deployment manifest endpoint");
+  }
+  return result.data;
+}
+async function collectDeploymentFiles(sourceDirectory) {
+  const files = [];
+  async function walk(currentDirectory) {
+    const entries = await fs3.readdir(currentDirectory, { withFileTypes: true });
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      const absolutePath = join2(currentDirectory, entry.name);
+      const normalizedPath = normalizeRelativePath(sourceDirectory, absolutePath);
+      if (!normalizedPath || shouldExcludeDeploymentPath(normalizedPath)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        await walk(absolutePath);
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      const { sha, size } = await hashFile(absolutePath);
+      files.push({
+        absolutePath,
+        path: normalizedPath,
+        sha,
+        size
+      });
+    }
+  }
+  await walk(sourceDirectory);
+  return files;
+}
+function buildStartBody(input) {
+  const startBody = {};
+  if (input.projectSettings) startBody.projectSettings = input.projectSettings;
+  if (input.envVars) startBody.envVars = input.envVars;
+  if (input.meta) startBody.meta = input.meta;
+  return startBody;
+}
+async function createDirectDeploymentSession(API_BASE_URL, apiKey) {
+  const response = await fetch6(`${API_BASE_URL}/api/deployments/direct`, {
+    method: "POST",
+    headers: {
+      "x-api-key": apiKey,
+      "Content-Type": "application/json"
+    }
+  });
+  if (response.status === 404) {
+    throw new DirectDeploymentUnsupportedError();
+  }
+  const result = await handleApiResponse(response);
+  return parseCreateDirectDeploymentResponse(result);
+}
+async function createDeploymentManifest(API_BASE_URL, apiKey, deploymentId, files) {
+  const response = await fetch6(`${API_BASE_URL}/api/deployments/${encodeURIComponent(deploymentId)}/manifest`, {
+    method: "POST",
+    headers: {
+      "x-api-key": apiKey,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ files })
+  });
+  if (response.status === 404) {
+    throw new DirectDeploymentUnsupportedError();
+  }
+  const result = await handleApiResponse(response);
+  return parseCreateDeploymentManifestResponse(result);
+}
+async function uploadDeploymentFileContent(API_BASE_URL, apiKey, deploymentId, file, localFile) {
+  const response = await fetch6(
+    `${API_BASE_URL}/api/deployments/${encodeURIComponent(deploymentId)}/files/${encodeURIComponent(file.fileId)}/content`,
+    {
+      method: "PUT",
+      headers: {
+        "x-api-key": apiKey,
+        "Content-Type": "application/octet-stream",
+        "Content-Length": String(localFile.size)
+      },
+      body: createReadStream(localFile.absolutePath)
+    }
+  );
+  if (response.status === 404) {
+    throw new DirectDeploymentUnsupportedError();
+  }
+  await handleApiResponse(response);
+}
+async function startDeployment(API_BASE_URL, apiKey, deploymentId, startBody) {
+  const response = await fetch6(`${API_BASE_URL}/api/deployments/${encodeURIComponent(deploymentId)}/start`, {
+    method: "POST",
+    headers: {
+      "x-api-key": apiKey,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(startBody)
+  });
+  return handleApiResponse(response);
+}
+async function deployDirect(API_BASE_URL, apiKey, sourceDirectory, startBody) {
+  const files = await collectDeploymentFiles(sourceDirectory);
+  if (files.length === 0) {
+    throw new Error("No deployable files found in source directory after applying exclusions.");
+  }
+  const createResult = await createDirectDeploymentSession(API_BASE_URL, apiKey);
+  const deploymentId = String(createResult.id);
+  const manifest = await createDeploymentManifest(
+    API_BASE_URL,
+    apiKey,
+    deploymentId,
+    files.map(({ path, sha, size }) => ({ path, sha, size }))
+  );
+  const localFilesByPath = new Map(files.map((file) => [file.path, file]));
+  for (const manifestFile of manifest.files) {
+    const localFile = localFilesByPath.get(manifestFile.path);
+    if (!localFile) {
+      throw new Error(`Manifest response included unknown file path: ${manifestFile.path}`);
+    }
+    await uploadDeploymentFileContent(API_BASE_URL, apiKey, deploymentId, manifestFile, localFile);
+  }
+  const startResult = await startDeployment(API_BASE_URL, apiKey, deploymentId, startBody);
+  return { deploymentId, fileCount: files.length, startResult };
+}
+function buildRemoteDirectUploadInstructions(API_BASE_URL, sourceDirectory, deploymentId) {
+  const escapedDir = shellEsc(sourceDirectory);
+  const apiBaseUrlJson = JSON.stringify(API_BASE_URL);
+  const deploymentIdJson = JSON.stringify(deploymentId);
+  return `Deployment prepared successfully using direct upload. Deployment ID: ${deploymentId}
+
+Please execute the following command locally from a shell that has INSFORGE_API_KEY set, then call the \`start-deployment\` tool with the deployment ID printed by the script.
+
+\`\`\`bash
+cd ${escapedDir}
+INSFORGE_API_KEY="\${INSFORGE_API_KEY:?Set INSFORGE_API_KEY to your InsForge API key}" node --input-type=module <<'NODE'
+const { createHash } = await import('node:crypto');
+const { createReadStream } = await import('node:fs');
+const fs = await import('node:fs/promises');
+const path = await import('node:path');
+
+const API_BASE_URL = ${apiBaseUrlJson};
+const API_KEY = process.env.INSFORGE_API_KEY;
+const deploymentId = ${deploymentIdJson};
+const EXCLUDED_SEGMENTS = new Set(['node_modules', '.git', '.next', 'dist', 'build', '.insforge']);
+
+function shouldExcludeDeploymentPath(normalizedName) {
+  const segments = normalizedName.split('/');
+  if (segments.some((segment) => segment === '.env' || segment.startsWith('.env.'))) return true;
+  if (segments.some((segment) => EXCLUDED_SEGMENTS.has(segment))) return true;
+  return normalizedName === '.DS_Store' || normalizedName.endsWith('/.DS_Store') || normalizedName.endsWith('.log');
+}
+
+async function readJsonResponse(response) {
+  const text = await response.text();
+  const data = text ? JSON.parse(text) : null;
+  if (!response.ok) {
+    throw new Error(data?.message || data?.error || \`Request failed with status \${response.status}\`);
+  }
+  return data;
+}
+
+async function api(pathname, init = {}) {
+  const headers = {
+    'x-api-key': API_KEY,
+    ...(init.headers || {}),
+  };
+  const response = await fetch(\`\${API_BASE_URL}\${pathname}\`, { ...init, headers });
+  return readJsonResponse(response);
+}
+
+async function hashFile(filePath) {
+  const hash = createHash('sha1');
+  let size = 0;
+  for await (const chunk of createReadStream(filePath)) {
+    size += chunk.length;
+    hash.update(chunk);
+  }
+  return { sha: hash.digest('hex'), size };
+}
+
+async function collectFiles(rootDirectory) {
+  const files = [];
+
+  async function walk(currentDirectory) {
+    const entries = await fs.readdir(currentDirectory, { withFileTypes: true });
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+
+    for (const entry of entries) {
+      const absolutePath = path.join(currentDirectory, entry.name);
+      const normalizedPath = path.relative(rootDirectory, absolutePath).split(path.sep).join('/').replace(/\\\\/g, '/');
+
+      if (!normalizedPath || shouldExcludeDeploymentPath(normalizedPath)) continue;
+      if (entry.isDirectory()) {
+        await walk(absolutePath);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+
+      const { sha, size } = await hashFile(absolutePath);
+      files.push({ absolutePath, path: normalizedPath, sha, size });
+    }
+  }
+
+  await walk(rootDirectory);
+  return files;
+}
+
+const rootDirectory = process.cwd();
+const localFiles = await collectFiles(rootDirectory);
+if (localFiles.length === 0) throw new Error('No deployable files found after applying exclusions.');
+
+const manifest = await api(\`/api/deployments/\${encodeURIComponent(deploymentId)}/manifest\`, {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({
+    files: localFiles.map(({ path, sha, size }) => ({ path, sha, size })),
+  }),
+});
+
+const localFilesByPath = new Map(localFiles.map((file) => [file.path, file]));
+for (const remoteFile of manifest.files) {
+  const localFile = localFilesByPath.get(remoteFile.path);
+  if (!localFile) throw new Error(\`Manifest response included unknown path: \${remoteFile.path}\`);
+
+  const uploadResponse = await fetch(
+    \`\${API_BASE_URL}/api/deployments/\${encodeURIComponent(deploymentId)}/files/\${encodeURIComponent(remoteFile.fileId)}/content\`,
+    {
+      method: 'PUT',
+      headers: {
+        'x-api-key': API_KEY,
+        'Content-Type': 'application/octet-stream',
+        'Content-Length': String(localFile.size),
+      },
+      body: createReadStream(localFile.absolutePath),
+      duplex: 'half',
+    }
+  );
+  await readJsonResponse(uploadResponse);
+}
+
+console.log(\`Deployment files uploaded. Deployment ID: \${deploymentId}\`);
+console.log(\`Uploaded \${localFiles.length} files through the direct deployment proxy.\`);
+NODE
+\`\`\`
+
+After the script succeeds, call the \`start-deployment\` tool with the printed deployment ID.`;
 }
 function registerDeploymentTools(ctx) {
-  const { API_BASE_URL, isRemote, registerTool, withUsageTracking, getApiKey, addBackgroundContext } = ctx;
+  const { API_BASE_URL, backendVersion, isRemote, registerTool, withUsageTracking, getApiKey, addBackgroundContext } = ctx;
+  const supportsDirectDeployment = supportsDirectDeploymentVersion(backendVersion);
   registerTool(
     "get-container-logs",
     "Get latest logs from a specific container/service. Use this to help debug problems with your app.",
@@ -2618,14 +2993,13 @@ function registerDeploymentTools(ctx) {
   if (isRemote) {
     registerTool(
       "create-deployment",
-      "Prepare a deployment by creating a presigned upload URL. Returns shell commands for the agent to execute locally: zip the source directory and upload to cloud storage. After uploading, call the start-deployment tool to trigger the build.",
+      "Prepare a deployment upload. For backends v2.0.5 and newer, returns direct file upload commands. Older backends use the legacy zip upload flow. After uploading, call the start-deployment tool to trigger the build.",
       {
         sourceDirectory: z29.string().describe('Absolute path to the source directory containing files to deploy (e.g., /Users/name/project). Do not use relative paths like "."')
       },
       withUsageTracking("create-deployment", async ({ sourceDirectory }) => {
         try {
-          const isAbsolutePath = sourceDirectory.startsWith("/") || /^[a-zA-Z]:[/\\]/.test(sourceDirectory);
-          if (!isAbsolutePath) {
+          if (!isAbsoluteSourcePath(sourceDirectory)) {
             return {
               content: [{
                 type: "text",
@@ -2634,6 +3008,21 @@ function registerDeploymentTools(ctx) {
               isError: true
             };
           }
+          if (supportsDirectDeployment) {
+            try {
+              const createResult2 = await createDirectDeploymentSession(API_BASE_URL, getApiKey());
+              return {
+                content: [{
+                  type: "text",
+                  text: buildRemoteDirectUploadInstructions(API_BASE_URL, sourceDirectory, String(createResult2.id))
+                }]
+              };
+            } catch (error) {
+              if (!(error instanceof DirectDeploymentUnsupportedError)) {
+                throw error;
+              }
+            }
+          }
           const createResponse = await fetch6(`${API_BASE_URL}/api/deployments`, {
             method: "POST",
             headers: {
@@ -2641,10 +3030,7 @@ function registerDeploymentTools(ctx) {
               "Content-Type": "application/json"
             }
           });
-          const createResult = await handleApiResponse(createResponse);
-          if (!isCreateDeploymentResponse(createResult)) {
-            throw new Error("Unexpected response format from deployments endpoint");
-          }
+          const createResult = parseCreateDeploymentResponse(await handleApiResponse(createResponse));
           const { id: deploymentId, uploadUrl, uploadFields } = createResult;
           const esc = shellEsc;
           const curlFields = Object.entries(uploadFields).map(([key, value]) => `-F ${esc(`${key}=${value}`)}`).join(" \\\n  ");
@@ -2656,7 +3042,7 @@ Please execute the following commands locally, then call the \`start-deployment\
 
 ## Step 1: Zip the source directory
 \`\`\`bash
-cd ${escapedDir} && zip -r ${tmpZip} .   -x "node_modules/*" ".git/*" ".next/*" ".env" ".env.local" "dist/*" "build/*" ".DS_Store" "*.log"
+cd ${escapedDir} && zip -r ${tmpZip} .   -x "node_modules/*" ".git/*" ".next/*" ".env*" "dist/*" "build/*" ".insforge/*" ".DS_Store" "*.log"
 \`\`\`
 
 ## Step 2: Upload the zip file
@@ -2725,15 +3111,14 @@ Run each step in order. If any step fails, do not proceed to the next step.`;
   } else {
     registerTool(
       "create-deployment",
-      "Deploy source code from a directory. This tool zips files, uploads to cloud storage, and triggers deployment with optional environment variables and project settings.",
+      "Deploy source code from a directory. Uses direct file upload for backends v2.0.5 and newer, with legacy zip upload fallback for older projects.",
       {
         sourceDirectory: z29.string().describe('Absolute path to the source directory containing files to deploy (e.g., /Users/name/project or C:\\Users\\name\\project). Do not use relative paths like "."'),
         ...startDeploymentRequestSchema.shape
       },
       withUsageTracking("create-deployment", async ({ sourceDirectory, projectSettings, envVars, meta }) => {
         try {
-          const isAbsolutePath = sourceDirectory.startsWith("/") || /^[a-zA-Z]:[/\\]/.test(sourceDirectory);
-          if (!isAbsolutePath) {
+          if (!isAbsoluteSourcePath(sourceDirectory)) {
             return {
               content: [{
                 type: "text",
@@ -2763,6 +3148,26 @@ Run each step in order. If any step fails, do not proceed to the next step.`;
             };
           }
           const resolvedSourceDir = sourceDirectory;
+          const startBody = buildStartBody({ projectSettings, envVars, meta });
+          if (supportsDirectDeployment) {
+            try {
+              const { fileCount, startResult: startResult2 } = await deployDirect(API_BASE_URL, getApiKey(), resolvedSourceDir, startBody);
+              return await addBackgroundContext({
+                content: [{
+                  type: "text",
+                  text: formatSuccessMessage("Deployment started", startResult2) + `
+
+Uploaded ${fileCount} files through the direct deployment proxy.
+
+Note: You can check deployment status by querying the system.deployments table.`
+                }]
+              });
+            } catch (error) {
+              if (!(error instanceof DirectDeploymentUnsupportedError)) {
+                throw error;
+              }
+            }
+          }
           const createResponse = await fetch6(`${API_BASE_URL}/api/deployments`, {
             method: "POST",
             headers: {
@@ -2770,10 +3175,7 @@ Run each step in order. If any step fails, do not proceed to the next step.`;
               "Content-Type": "application/json"
             }
           });
-          const createResult = await handleApiResponse(createResponse);
-          if (!isCreateDeploymentResponse(createResult)) {
-            throw new Error("Unexpected response format from deployments endpoint");
-          }
+          const createResult = parseCreateDeploymentResponse(await handleApiResponse(createResponse));
           const { id: deploymentId, uploadUrl, uploadFields } = createResult;
           const tmpZipPath = join2(tmpdir2(), `insforge-deploy-${deploymentId}.zip`);
           try {
@@ -2783,15 +3185,9 @@ Run each step in order. If any step fails, do not proceed to the next step.`;
               output.on("close", resolve);
               output.on("error", reject);
               archive.on("error", reject);
-              const excludePatterns = ["node_modules", ".git", ".next", ".env", ".env.local", "dist", "build", ".DS_Store"];
               archive.directory(resolvedSourceDir, false, (entry) => {
                 const normalizedName = entry.name.replace(/\\/g, "/");
-                for (const pattern of excludePatterns) {
-                  if (normalizedName.startsWith(pattern + "/") || normalizedName === pattern || normalizedName.endsWith("/" + pattern) || normalizedName.includes("/" + pattern + "/")) {
-                    return false;
-                  }
-                }
-                if (normalizedName.endsWith(".log")) return false;
+                if (shouldExcludeDeploymentPath(normalizedName)) return false;
                 return entry;
               });
               archive.pipe(output);
@@ -2819,19 +3215,7 @@ Run each step in order. If any step fails, do not proceed to the next step.`;
           } finally {
             await fs3.rm(tmpZipPath, { force: true }).catch(() => void 0);
           }
-          const startBody = {};
-          if (projectSettings) startBody.projectSettings = projectSettings;
-          if (envVars) startBody.envVars = envVars;
-          if (meta) startBody.meta = meta;
-          const startResponse = await fetch6(`${API_BASE_URL}/api/deployments/${encodeURIComponent(deploymentId)}/start`, {
-            method: "POST",
-            headers: {
-              "x-api-key": getApiKey(),
-              "Content-Type": "application/json"
-            },
-            body: JSON.stringify(startBody)
-          });
-          const startResult = await handleApiResponse(startResponse);
+          const startResult = await startDeployment(API_BASE_URL, getApiKey(), deploymentId, startBody);
           return await addBackgroundContext({
             content: [{
               type: "text",
@@ -3004,6 +3388,7 @@ ${result.content}`
   };
   const ctx = {
     API_BASE_URL,
+    backendVersion,
     isRemote,
     registerTool,
     withUsageTracking,

package/dist/http-server.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   registerInsforgeTools
-} from "./chunk-YH7HSQYJ.js";
+} from "./chunk-MQZLKWM4.js";
 
 // src/http/server.ts
 import "dotenv/config";

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   registerInsforgeTools
-} from "./chunk-YH7HSQYJ.js";
+} from "./chunk-MQZLKWM4.js";
 
 // src/stdio/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@insforge/mcp",
-  "version": "1.2.9",
+  "version": "1.2.10-dev.1",
   "description": "MCP (Model Context Protocol) server for Insforge backend-as-a-service",
   "mcpName": "io.github.InsForge/insforge-mcp",
   "type": "module",
@@ -45,7 +45,7 @@
     "server.json"
   ],
   "dependencies": {
-    "@insforge/shared-schemas": "1.1.47",
+    "@insforge/shared-schemas": "1.1.48",
     "@modelcontextprotocol/sdk": "^1.27.1",
     "archiver": "^7.0.1",
     "commander": "^14.0.0",
@@ -61,6 +61,9 @@
     "brace-expansion": "^5.0.5",
     "glob": "^10.5.0",
     "minimatch": "^9.0.7",
+    "@hono/node-server": "^1.19.13",
+    "hono": "^4.12.12",
+    "lodash": "^4.18.0",
     "rollup": "^4.59.0"
   },
   "devDependencies": {
@@ -78,7 +81,7 @@
     "tsx": "^4.7.0",
     "typescript": "^5.3.3",
     "typescript-eslint": "^8.57.1",
-    "vite": "^8.0.3",
+    "vite": "^8.0.5",
     "vitest": "^4.1.0"
   }
 }