@insforge/mcp 1.2.4 → 1.2.5

package/dist/{chunk-452MLCIR.js → chunk-FUYK7JVW.js}

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 
 // src/shared/tools.ts
-import { z as z19 } from "zod";
+import { z as z23 } from "zod";
 import fetch2 from "node-fetch";
 import { promises as fs } from "fs";
 import { exec } from "child_process";
 import { promisify } from "util";
 import { tmpdir } from "os";
+import archiver from "archiver";
 
 // src/shared/response-handler.ts
 async function handleApiResponse(response) {
@@ -326,91 +327,136 @@ var databaseTriggersResponseSchema = z2.object({
   triggers: z2.array(databaseTriggerSchema)
 });
 
-// node_modules/@insforge/shared-schemas/dist/storage.schema.js
+// node_modules/@insforge/shared-schemas/dist/secrets.schema.js
 import { z as z3 } from "zod";
-var storageFileSchema = z3.object({
+var secretSchema = z3.object({
+  id: z3.string(),
   key: z3.string(),
-  bucket: z3.string(),
-  size: z3.number(),
-  mimeType: z3.string().optional(),
-  uploadedAt: z3.string(),
-  url: z3.string()
-});
-var storageBucketSchema = z3.object({
-  name: z3.string(),
-  public: z3.boolean(),
-  createdAt: z3.string()
+  isActive: z3.boolean(),
+  isReserved: z3.boolean(),
+  lastUsedAt: z3.string().nullable(),
+  expiresAt: z3.string().nullable(),
+  createdAt: z3.string(),
+  updatedAt: z3.string()
 });
 
-// node_modules/@insforge/shared-schemas/dist/storage-api.schema.js
+// node_modules/@insforge/shared-schemas/dist/secrets-api.schema.js
 import { z as z4 } from "zod";
-var createBucketRequestSchema = z4.object({
-  bucketName: z4.string().min(1, "Bucket name cannot be empty"),
-  isPublic: z4.boolean().default(true)
-});
-var updateBucketRequestSchema = z4.object({
-  isPublic: z4.boolean()
-});
-var listObjectsResponseSchema = z4.object({
-  objects: z4.array(storageFileSchema),
-  pagination: z4.object({
-    offset: z4.number(),
-    limit: z4.number(),
-    total: z4.number()
-  })
-});
-var uploadStrategyRequestSchema = z4.object({
-  filename: z4.string().min(1, "Filename cannot be empty"),
-  contentType: z4.string().optional(),
-  size: z4.number().optional()
+var listSecretsResponseSchema = z4.object({
+  secrets: z4.array(secretSchema)
 });
-var uploadStrategyResponseSchema = z4.object({
-  method: z4.enum(["presigned", "direct"]),
-  uploadUrl: z4.string(),
-  fields: z4.record(z4.string()).optional(),
+var getSecretValueResponseSchema = z4.object({
   key: z4.string(),
-  confirmRequired: z4.boolean(),
-  confirmUrl: z4.string().optional(),
-  expiresAt: z4.date().optional()
+  value: z4.string()
+});
+var createSecretRequestSchema = z4.object({
+  key: z4.string().regex(/^[A-Z0-9_]+$/, "Use uppercase letters, numbers, and underscores only"),
+  value: z4.string().min(1, "Value is required")
 });
-var downloadStrategyRequestSchema = z4.object({
-  expiresIn: z4.number().optional().default(3600)
+var createSecretResponseSchema = z4.object({
+  success: z4.literal(true),
+  message: z4.string(),
+  id: z4.string()
 });
-var downloadStrategyResponseSchema = z4.object({
-  method: z4.enum(["presigned", "direct"]),
-  url: z4.string(),
-  expiresAt: z4.date().optional(),
-  headers: z4.record(z4.string()).optional()
+var updateSecretResponseSchema = z4.object({
+  success: z4.literal(true),
+  message: z4.string()
 });
-var confirmUploadRequestSchema = z4.object({
-  size: z4.number(),
-  contentType: z4.string().optional(),
-  etag: z4.string().optional()
+var deleteSecretResponseSchema = z4.object({
+  success: z4.literal(true),
+  message: z4.string()
 });
 
-// node_modules/@insforge/shared-schemas/dist/auth.schema.js
+// node_modules/@insforge/shared-schemas/dist/storage.schema.js
 import { z as z5 } from "zod";
-var userIdSchema = z5.string().uuid("Invalid user ID format");
-var emailSchema = z5.string().email("Invalid email format").toLowerCase().trim();
-var passwordSchema = z5.string();
-var nameSchema = z5.string().min(1, "Name is required").max(100, "Name must be less than 100 characters").trim();
-var roleSchema = z5.enum(["anon", "authenticated", "project_admin"]);
-var verificationMethodSchema = z5.enum(["code", "link"]);
-var userSchema = z5.object({
+var storageFileSchema = z5.object({
+  key: z5.string(),
+  bucket: z5.string(),
+  size: z5.number(),
+  mimeType: z5.string().optional(),
+  uploadedAt: z5.string(),
+  url: z5.string()
+});
+var storageBucketSchema = z5.object({
+  name: z5.string(),
+  public: z5.boolean(),
+  createdAt: z5.string()
+});
+
+// node_modules/@insforge/shared-schemas/dist/storage-api.schema.js
+import { z as z6 } from "zod";
+var createBucketRequestSchema = z6.object({
+  bucketName: z6.string().min(1, "Bucket name cannot be empty"),
+  isPublic: z6.boolean().default(true)
+});
+var updateBucketRequestSchema = z6.object({
+  isPublic: z6.boolean()
+});
+var listObjectsResponseSchema = z6.object({
+  objects: z6.array(storageFileSchema),
+  pagination: z6.object({
+    offset: z6.number(),
+    limit: z6.number(),
+    total: z6.number()
+  })
+});
+var uploadStrategyRequestSchema = z6.object({
+  filename: z6.string().min(1, "Filename cannot be empty"),
+  contentType: z6.string().optional(),
+  size: z6.number().optional()
+});
+var uploadStrategyResponseSchema = z6.object({
+  method: z6.enum(["presigned", "direct"]),
+  uploadUrl: z6.string(),
+  fields: z6.record(z6.string()).optional(),
+  key: z6.string(),
+  confirmRequired: z6.boolean(),
+  confirmUrl: z6.string().optional(),
+  expiresAt: z6.date().optional()
+});
+var downloadStrategyRequestSchema = z6.object({
+  expiresIn: z6.number().optional().default(3600)
+});
+var downloadStrategyResponseSchema = z6.object({
+  method: z6.enum(["presigned", "direct"]),
+  url: z6.string(),
+  expiresAt: z6.date().optional(),
+  headers: z6.record(z6.string()).optional()
+});
+var confirmUploadRequestSchema = z6.object({
+  size: z6.number(),
+  contentType: z6.string().optional(),
+  etag: z6.string().optional()
+});
+
+// node_modules/@insforge/shared-schemas/dist/auth.schema.js
+import { z as z7 } from "zod";
+var userIdSchema = z7.string().uuid("Invalid user ID format");
+var emailSchema = z7.string().email("Invalid email format").toLowerCase().trim();
+var passwordSchema = z7.string();
+var nameSchema = z7.string().min(1, "Name is required").max(100, "Name must be less than 100 characters").trim();
+var roleSchema = z7.enum(["anon", "authenticated", "project_admin"]);
+var verificationMethodSchema = z7.enum(["code", "link"]);
+var profileSchema = z7.object({
+  name: z7.string().optional(),
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  avatar_url: z7.string().url().optional()
+}).passthrough();
+var userSchema = z7.object({
   id: userIdSchema,
   email: emailSchema,
-  name: nameSchema,
-  emailVerified: z5.boolean(),
-  identities: z5.array(z5.object({
-    provider: z5.string()
-  })).optional(),
-  providerType: z5.string().optional(),
-  createdAt: z5.string(),
+  emailVerified: z7.boolean(),
+  providers: z7.array(z7.string()).optional(),
+  createdAt: z7.string(),
   // PostgreSQL timestamp
-  updatedAt: z5.string()
+  updatedAt: z7.string(),
   // PostgreSQL timestamp
+  profile: profileSchema.nullable(),
+  // User profile data (name, avatar_url, bio, etc.)
+  metadata: z7.record(z7.unknown()).nullable()
+  // System metadata (device ID, login IP, etc.)
 });
-var oAuthProvidersSchema = z5.enum([
+var oAuthProvidersSchema = z7.enum([
   "google",
   "github",
   "discord",
@@ -423,144 +469,155 @@ var oAuthProvidersSchema = z5.enum([
   "spotify",
   "microsoft"
 ]);
-var oAuthStateSchema = z5.object({
+var oAuthStateSchema = z7.object({
   provider: oAuthProvidersSchema,
-  redirectUri: z5.string().url().optional()
+  redirectUri: z7.string().url().optional()
 });
-var oAuthConfigSchema = z5.object({
-  id: z5.string().uuid(),
+var oAuthConfigSchema = z7.object({
+  id: z7.string().uuid(),
   provider: oAuthProvidersSchema,
-  clientId: z5.string().optional(),
-  scopes: z5.array(z5.string()).optional(),
-  redirectUri: z5.string().optional(),
-  useSharedKey: z5.boolean(),
-  createdAt: z5.string(),
+  clientId: z7.string().optional(),
+  scopes: z7.array(z7.string()).optional(),
+  redirectUri: z7.string().optional(),
+  useSharedKey: z7.boolean(),
+  createdAt: z7.string(),
   // PostgreSQL timestamp
-  updatedAt: z5.string()
+  updatedAt: z7.string()
   // PostgreSQL timestamp
 });
-var authConfigSchema = z5.object({
-  id: z5.string().uuid(),
-  requireEmailVerification: z5.boolean(),
-  passwordMinLength: z5.number().min(4).max(128),
-  requireNumber: z5.boolean(),
-  requireLowercase: z5.boolean(),
-  requireUppercase: z5.boolean(),
-  requireSpecialChar: z5.boolean(),
+var authConfigSchema = z7.object({
+  id: z7.string().uuid(),
+  requireEmailVerification: z7.boolean(),
+  passwordMinLength: z7.number().min(4).max(128),
+  requireNumber: z7.boolean(),
+  requireLowercase: z7.boolean(),
+  requireUppercase: z7.boolean(),
+  requireSpecialChar: z7.boolean(),
   verifyEmailMethod: verificationMethodSchema,
   resetPasswordMethod: verificationMethodSchema,
-  signInRedirectTo: z5.union([z5.string().url(), z5.literal(""), z5.null()]).optional().transform((val) => val === "" ? null : val),
-  createdAt: z5.string(),
+  signInRedirectTo: z7.union([z7.string().url(), z7.literal(""), z7.null()]).optional().transform((val) => val === "" ? null : val),
+  createdAt: z7.string(),
   // PostgreSQL timestamp
-  updatedAt: z5.string()
+  updatedAt: z7.string()
   // PostgreSQL timestamp
 });
-var tokenPayloadSchema = z5.object({
+var tokenPayloadSchema = z7.object({
   sub: userIdSchema,
   // Subject (user ID)
   email: emailSchema,
   role: roleSchema,
-  iat: z5.number().optional(),
+  iat: z7.number().optional(),
   // Issued at
-  exp: z5.number().optional()
+  exp: z7.number().optional()
   // Expiration
 });
 
 // node_modules/@insforge/shared-schemas/dist/auth-api.schema.js
-import { z as z6 } from "zod";
-var paginationSchema = z6.object({
-  limit: z6.string().optional(),
-  offset: z6.string().optional()
+import { z as z8 } from "zod";
+var paginationSchema = z8.object({
+  limit: z8.string().optional(),
+  offset: z8.string().optional()
 });
-var createUserRequestSchema = z6.object({
+var createUserRequestSchema = z8.object({
   email: emailSchema,
   password: passwordSchema,
   name: nameSchema.optional()
 });
-var createSessionRequestSchema = z6.object({
+var createSessionRequestSchema = z8.object({
   email: emailSchema,
   password: passwordSchema
 });
-var exchangeAdminSessionRequestSchema = z6.object({
-  code: z6.string()
+var exchangeAdminSessionRequestSchema = z8.object({
+  code: z8.string()
 });
 var listUsersRequestSchema = paginationSchema.extend({
-  search: z6.string().optional()
+  search: z8.string().optional()
 }).optional();
-var deleteUsersRequestSchema = z6.object({
-  userIds: z6.array(userIdSchema).min(1, "At least one user ID is required")
+var deleteUsersRequestSchema = z8.object({
+  userIds: z8.array(userIdSchema).min(1, "At least one user ID is required")
+});
+var updateProfileRequestSchema = z8.object({
+  profile: z8.record(z8.unknown())
 });
-var sendVerificationEmailRequestSchema = z6.object({
+var sendVerificationEmailRequestSchema = z8.object({
   email: emailSchema
 });
-var verifyEmailRequestSchema = z6.object({
+var verifyEmailRequestSchema = z8.object({
   email: emailSchema.optional(),
-  otp: z6.string().min(1)
+  otp: z8.string().min(1)
 }).refine((data) => data.email || data.otp, {
   message: "Either email or otp must be provided"
 });
-var sendResetPasswordEmailRequestSchema = z6.object({
+var sendResetPasswordEmailRequestSchema = z8.object({
   email: emailSchema
 });
-var exchangeResetPasswordTokenRequestSchema = z6.object({
+var exchangeResetPasswordTokenRequestSchema = z8.object({
   email: emailSchema,
-  code: z6.string().min(1)
+  code: z8.string().min(1)
 });
-var resetPasswordRequestSchema = z6.object({
+var resetPasswordRequestSchema = z8.object({
   newPassword: passwordSchema,
-  otp: z6.string().min(1, "OTP/token is required")
+  otp: z8.string().min(1, "OTP/token is required")
 });
-var createUserResponseSchema = z6.object({
+var createUserResponseSchema = z8.object({
   user: userSchema.optional(),
-  accessToken: z6.string().nullable(),
-  requireEmailVerification: z6.boolean().optional(),
-  redirectTo: z6.string().url().optional()
+  accessToken: z8.string().nullable(),
+  requireEmailVerification: z8.boolean().optional(),
+  redirectTo: z8.string().url().optional(),
+  csrfToken: z8.string().nullable().optional()
 });
-var createSessionResponseSchema = z6.object({
+var createSessionResponseSchema = z8.object({
   user: userSchema,
-  accessToken: z6.string(),
-  redirectTo: z6.string().url().optional()
+  accessToken: z8.string(),
+  redirectTo: z8.string().url().optional(),
+  csrfToken: z8.string().nullable().optional()
 });
-var verifyEmailResponseSchema = z6.object({
+var verifyEmailResponseSchema = z8.object({
   user: userSchema,
-  accessToken: z6.string(),
-  redirectTo: z6.string().url().optional()
+  accessToken: z8.string(),
+  redirectTo: z8.string().url().optional(),
+  csrfToken: z8.string().nullable().optional()
 });
-var exchangeResetPasswordTokenResponseSchema = z6.object({
-  token: z6.string(),
-  expiresAt: z6.string().datetime()
+var refreshSessionResponseSchema = z8.object({
+  accessToken: z8.string(),
+  user: userSchema,
+  csrfToken: z8.string()
 });
-var resetPasswordResponseSchema = z6.object({
-  message: z6.string()
+var exchangeResetPasswordTokenResponseSchema = z8.object({
+  token: z8.string(),
+  expiresAt: z8.string().datetime()
 });
-var getCurrentSessionResponseSchema = z6.object({
-  user: z6.object({
-    id: userIdSchema,
-    email: emailSchema,
-    role: roleSchema
-  })
+var resetPasswordResponseSchema = z8.object({
+  message: z8.string()
 });
-var listUsersResponseSchema = z6.object({
-  data: z6.array(userSchema),
-  pagination: z6.object({
-    offset: z6.number(),
-    limit: z6.number(),
-    total: z6.number()
+var getCurrentSessionResponseSchema = z8.object({
+  user: userSchema
+});
+var getProfileResponseSchema = z8.object({
+  id: userIdSchema,
+  profile: profileSchema.nullable()
+});
+var listUsersResponseSchema = z8.object({
+  data: z8.array(userSchema),
+  pagination: z8.object({
+    offset: z8.number(),
+    limit: z8.number(),
+    total: z8.number()
   })
 });
-var deleteUsersResponseSchema = z6.object({
-  message: z6.string(),
-  deletedCount: z6.number().int().nonnegative()
+var deleteUsersResponseSchema = z8.object({
+  message: z8.string(),
+  deletedCount: z8.number().int().nonnegative()
 });
-var getOauthUrlResponseSchema = z6.object({
-  authUrl: z6.string().url()
+var getOauthUrlResponseSchema = z8.object({
+  authUrl: z8.string().url()
 });
 var createOAuthConfigRequestSchema = oAuthConfigSchema.omit({
   id: true,
   createdAt: true,
   updatedAt: true
 }).extend({
-  clientSecret: z6.string().optional()
+  clientSecret: z8.string().optional()
 });
 var updateOAuthConfigRequestSchema = oAuthConfigSchema.omit({
   id: true,
@@ -568,19 +625,19 @@ var updateOAuthConfigRequestSchema = oAuthConfigSchema.omit({
   createdAt: true,
   updatedAt: true
 }).extend({
-  clientSecret: z6.string().optional()
+  clientSecret: z8.string().optional()
 }).partial();
-var listOAuthConfigsResponseSchema = z6.object({
-  data: z6.array(oAuthConfigSchema),
-  count: z6.number()
+var listOAuthConfigsResponseSchema = z8.object({
+  data: z8.array(oAuthConfigSchema),
+  count: z8.number()
 });
 var updateAuthConfigRequestSchema = authConfigSchema.omit({
   id: true,
   createdAt: true,
   updatedAt: true
 }).partial();
-var getPublicAuthConfigResponseSchema = z6.object({
-  oAuthProviders: z6.array(oAuthProvidersSchema),
+var getPublicAuthConfigResponseSchema = z8.object({
+  oAuthProviders: z8.array(oAuthProvidersSchema),
   ...authConfigSchema.omit({
     id: true,
     updatedAt: true,
@@ -588,465 +645,503 @@ var getPublicAuthConfigResponseSchema = z6.object({
     signInRedirectTo: true
   }).shape
 });
-var authErrorResponseSchema = z6.object({
-  error: z6.string(),
-  message: z6.string(),
-  statusCode: z6.number().int(),
-  nextActions: z6.string().optional()
+var authErrorResponseSchema = z8.object({
+  error: z8.string(),
+  message: z8.string(),
+  statusCode: z8.number().int(),
+  nextActions: z8.string().optional()
 });
 
 // node_modules/@insforge/shared-schemas/dist/metadata.schema.js
-import { z as z9 } from "zod";
+import { z as z11 } from "zod";
 
 // node_modules/@insforge/shared-schemas/dist/realtime.schema.js
-import { z as z7 } from "zod";
-var senderTypeSchema = z7.enum(["system", "user"]);
-var realtimeChannelSchema = z7.object({
-  id: z7.string().uuid(),
-  pattern: z7.string().min(1),
-  description: z7.string().nullable(),
-  webhookUrls: z7.array(z7.string().url()).nullable(),
-  enabled: z7.boolean(),
-  createdAt: z7.string().datetime(),
-  updatedAt: z7.string().datetime()
-});
-var realtimeMessageSchema = z7.object({
-  id: z7.string().uuid(),
-  eventName: z7.string().min(1),
-  channelId: z7.string().uuid().nullable(),
-  channelName: z7.string().min(1),
-  payload: z7.record(z7.string(), z7.unknown()),
+import { z as z9 } from "zod";
+var senderTypeSchema = z9.enum(["system", "user"]);
+var realtimeChannelSchema = z9.object({
+  id: z9.string().uuid(),
+  pattern: z9.string().min(1),
+  description: z9.string().nullable(),
+  webhookUrls: z9.array(z9.string().url()).nullable(),
+  enabled: z9.boolean(),
+  createdAt: z9.string().datetime(),
+  updatedAt: z9.string().datetime()
+});
+var realtimeMessageSchema = z9.object({
+  id: z9.string().uuid(),
+  eventName: z9.string().min(1),
+  channelId: z9.string().uuid().nullable(),
+  channelName: z9.string().min(1),
+  payload: z9.record(z9.string(), z9.unknown()),
   senderType: senderTypeSchema,
-  senderId: z7.string().uuid().nullable(),
-  wsAudienceCount: z7.number().int().min(0),
-  whAudienceCount: z7.number().int().min(0),
-  whDeliveredCount: z7.number().int().min(0),
-  createdAt: z7.string().datetime()
-});
-var subscribeChannelPayloadSchema = z7.object({
-  channel: z7.string().min(1)
+  senderId: z9.string().uuid().nullable(),
+  wsAudienceCount: z9.number().int().min(0),
+  whAudienceCount: z9.number().int().min(0),
+  whDeliveredCount: z9.number().int().min(0),
+  createdAt: z9.string().datetime()
+});
+var subscribeChannelPayloadSchema = z9.object({
+  channel: z9.string().min(1)
   // The resolved channel instance, e.g., "order:123"
 });
-var unsubscribeChannelPayloadSchema = z7.object({
-  channel: z7.string().min(1)
+var unsubscribeChannelPayloadSchema = z9.object({
+  channel: z9.string().min(1)
   // The resolved channel instance, e.g., "order:123"
 });
-var publishEventPayloadSchema = z7.object({
-  channel: z7.string().min(1),
-  event: z7.string().min(1),
-  payload: z7.record(z7.string(), z7.unknown())
+var publishEventPayloadSchema = z9.object({
+  channel: z9.string().min(1),
+  event: z9.string().min(1),
+  payload: z9.record(z9.string(), z9.unknown())
 });
-var subscribeResponseSchema = z7.discriminatedUnion("ok", [
-  z7.object({
-    ok: z7.literal(true),
-    channel: z7.string().min(1)
+var subscribeResponseSchema = z9.discriminatedUnion("ok", [
+  z9.object({
+    ok: z9.literal(true),
+    channel: z9.string().min(1)
   }),
-  z7.object({
-    ok: z7.literal(false),
-    channel: z7.string().min(1),
-    error: z7.object({
-      code: z7.string().min(1),
-      message: z7.string().min(1)
+  z9.object({
+    ok: z9.literal(false),
+    channel: z9.string().min(1),
+    error: z9.object({
+      code: z9.string().min(1),
+      message: z9.string().min(1)
     })
   })
 ]);
-var realtimeErrorPayloadSchema = z7.object({
-  channel: z7.string().optional(),
-  code: z7.string().min(1),
-  message: z7.string().min(1)
-});
-var webhookMessageSchema = z7.object({
-  messageId: z7.string().uuid(),
-  channel: z7.string().min(1),
-  eventName: z7.string().min(1),
-  payload: z7.record(z7.string(), z7.unknown())
-});
-var socketMessageMetaSchema = z7.object({
-  channel: z7.string().optional(),
+var realtimeErrorPayloadSchema = z9.object({
+  channel: z9.string().optional(),
+  code: z9.string().min(1),
+  message: z9.string().min(1)
+});
+var webhookMessageSchema = z9.object({
+  messageId: z9.string().uuid(),
+  channel: z9.string().min(1),
+  eventName: z9.string().min(1),
+  payload: z9.record(z9.string(), z9.unknown())
+});
+var socketMessageMetaSchema = z9.object({
+  channel: z9.string().optional(),
   // Present for room broadcasts
-  messageId: z7.string().uuid(),
+  messageId: z9.string().uuid(),
   senderType: senderTypeSchema,
-  senderId: z7.string().uuid().optional(),
-  timestamp: z7.string().datetime()
+  senderId: z9.string().uuid().optional(),
+  timestamp: z9.string().datetime()
 });
-var socketMessageSchema = z7.object({
+var socketMessageSchema = z9.object({
   meta: socketMessageMetaSchema
 }).passthrough();
 
 // node_modules/@insforge/shared-schemas/dist/realtime-api.schema.js
-import { z as z8 } from "zod";
-var createChannelRequestSchema = z8.object({
-  pattern: z8.string().min(1, "Channel pattern is required"),
-  description: z8.string().optional(),
-  webhookUrls: z8.array(z8.string().url()).optional(),
-  enabled: z8.boolean().optional().default(true)
-});
-var updateChannelRequestSchema = z8.object({
-  pattern: z8.string().min(1).optional(),
-  description: z8.string().optional(),
-  webhookUrls: z8.array(z8.string().url()).optional(),
-  enabled: z8.boolean().optional()
-});
-var listChannelsResponseSchema = z8.array(realtimeChannelSchema);
-var deleteChannelResponseSchema = z8.object({
-  message: z8.string()
-});
-var listMessagesRequestSchema = z8.object({
-  channelId: z8.string().uuid().optional(),
-  eventName: z8.string().optional(),
-  limit: z8.coerce.number().int().min(1).max(1e3).optional().default(100),
-  offset: z8.coerce.number().int().min(0).optional().default(0)
-});
-var listMessagesResponseSchema = z8.array(realtimeMessageSchema);
-var messageStatsRequestSchema = z8.object({
-  channelId: z8.string().uuid().optional(),
-  since: z8.coerce.date().optional()
-});
-var messageStatsResponseSchema = z8.object({
-  totalMessages: z8.number().int().min(0),
-  whDeliveryRate: z8.number().min(0).max(1),
-  topEvents: z8.array(z8.object({
-    eventName: z8.string(),
-    count: z8.number().int().min(0)
+import { z as z10 } from "zod";
+var createChannelRequestSchema = z10.object({
+  pattern: z10.string().min(1, "Channel pattern is required"),
+  description: z10.string().optional(),
+  webhookUrls: z10.array(z10.string().url()).optional(),
+  enabled: z10.boolean().optional().default(true)
+});
+var updateChannelRequestSchema = z10.object({
+  pattern: z10.string().min(1).optional(),
+  description: z10.string().optional(),
+  webhookUrls: z10.array(z10.string().url()).optional(),
+  enabled: z10.boolean().optional()
+});
+var listChannelsResponseSchema = z10.array(realtimeChannelSchema);
+var deleteChannelResponseSchema = z10.object({
+  message: z10.string()
+});
+var listMessagesRequestSchema = z10.object({
+  channelId: z10.string().uuid().optional(),
+  eventName: z10.string().optional(),
+  limit: z10.coerce.number().int().min(1).max(1e3).optional().default(100),
+  offset: z10.coerce.number().int().min(0).optional().default(0)
+});
+var listMessagesResponseSchema = z10.array(realtimeMessageSchema);
+var messageStatsRequestSchema = z10.object({
+  channelId: z10.string().uuid().optional(),
+  since: z10.coerce.date().optional()
+});
+var messageStatsResponseSchema = z10.object({
+  totalMessages: z10.number().int().min(0),
+  whDeliveryRate: z10.number().min(0).max(1),
+  topEvents: z10.array(z10.object({
+    eventName: z10.string(),
+    count: z10.number().int().min(0)
   }))
 });
-var rlsPolicySchema = z8.object({
-  policyName: z8.string(),
-  tableName: z8.string(),
-  command: z8.string(),
-  roles: z8.array(z8.string()),
-  using: z8.string().nullable(),
-  withCheck: z8.string().nullable()
-});
-var realtimePermissionsResponseSchema = z8.object({
-  subscribe: z8.object({
-    policies: z8.array(rlsPolicySchema)
+var rlsPolicySchema = z10.object({
+  policyName: z10.string(),
+  tableName: z10.string(),
+  command: z10.string(),
+  roles: z10.array(z10.string()),
+  using: z10.string().nullable(),
+  withCheck: z10.string().nullable()
+});
+var realtimePermissionsResponseSchema = z10.object({
+  subscribe: z10.object({
+    policies: z10.array(rlsPolicySchema)
   }),
-  publish: z8.object({
-    policies: z8.array(rlsPolicySchema)
+  publish: z10.object({
+    policies: z10.array(rlsPolicySchema)
   })
 });
 
 // node_modules/@insforge/shared-schemas/dist/metadata.schema.js
-var authMetadataSchema = z9.object({
-  oauths: z9.array(oAuthConfigSchema)
-});
-var databaseMetadataSchema = z9.object({
-  tables: z9.array(z9.object({
-    tableName: z9.string(),
-    recordCount: z9.number()
+var authMetadataSchema = getPublicAuthConfigResponseSchema;
+var databaseMetadataSchema = z11.object({
+  tables: z11.array(z11.object({
+    tableName: z11.string(),
+    recordCount: z11.number()
   })),
-  totalSizeInGB: z9.number(),
-  hint: z9.string().optional()
+  totalSizeInGB: z11.number(),
+  hint: z11.string().optional()
 });
 var bucketMetadataSchema = storageBucketSchema.extend({
-  objectCount: z9.number().optional()
-});
-var storageMetadataSchema = z9.object({
-  buckets: z9.array(bucketMetadataSchema),
-  totalSizeInGB: z9.number()
-});
-var edgeFunctionMetadataSchema = z9.object({
-  slug: z9.string(),
-  name: z9.string(),
-  description: z9.string().nullable(),
-  status: z9.string()
-});
-var aiMetadataSchema = z9.object({
-  models: z9.array(z9.object({
-    inputModality: z9.array(z9.string()),
-    outputModality: z9.array(z9.string()),
-    modelId: z9.string()
+  objectCount: z11.number().optional()
+});
+var storageMetadataSchema = z11.object({
+  buckets: z11.array(bucketMetadataSchema),
+  totalSizeInGB: z11.number()
+});
+var edgeFunctionMetadataSchema = z11.object({
+  slug: z11.string(),
+  name: z11.string(),
+  description: z11.string().nullable(),
+  status: z11.string()
+});
+var aiMetadataSchema = z11.object({
+  models: z11.array(z11.object({
+    inputModality: z11.array(z11.string()),
+    outputModality: z11.array(z11.string()),
+    modelId: z11.string()
   }))
 });
-var realtimeMetadataSchema = z9.object({
-  channels: z9.array(realtimeChannelSchema),
+var realtimeMetadataSchema = z11.object({
+  channels: z11.array(realtimeChannelSchema),
   permissions: realtimePermissionsResponseSchema
 });
-var appMetaDataSchema = z9.object({
+var appMetaDataSchema = z11.object({
   auth: authMetadataSchema,
   database: databaseMetadataSchema,
   storage: storageMetadataSchema,
   aiIntegration: aiMetadataSchema.optional(),
-  functions: z9.array(edgeFunctionMetadataSchema),
+  functions: z11.array(edgeFunctionMetadataSchema),
   realtime: realtimeMetadataSchema.optional(),
-  version: z9.string().optional()
+  version: z11.string().optional()
+});
+var databaseConnectionParametersSchema = z11.object({
+  host: z11.string(),
+  port: z11.number(),
+  database: z11.string(),
+  user: z11.string(),
+  password: z11.string(),
+  sslmode: z11.string()
+});
+var databaseConnectionInfoSchema = z11.object({
+  connectionURL: z11.string(),
+  parameters: databaseConnectionParametersSchema
+});
+var databasePasswordInfoSchema = z11.object({
+  databasePassword: z11.string()
+});
+var apiKeyResponseSchema = z11.object({
+  apiKey: z11.string()
 });
 
 // node_modules/@insforge/shared-schemas/dist/ai.schema.js
-import { z as z10 } from "zod";
-var modalitySchema = z10.enum(["text", "image"]);
-var aiConfigurationSchema = z10.object({
-  id: z10.string().uuid(),
-  inputModality: z10.array(modalitySchema).min(1),
-  outputModality: z10.array(modalitySchema).min(1),
-  provider: z10.string(),
-  modelId: z10.string(),
-  systemPrompt: z10.string().optional()
+import { z as z12 } from "zod";
+var modalitySchema = z12.enum(["text", "image"]);
+var aiConfigurationInputSchema = z12.object({
+  inputModality: z12.array(modalitySchema).min(1),
+  outputModality: z12.array(modalitySchema).min(1),
+  provider: z12.string(),
+  modelId: z12.string(),
+  systemPrompt: z12.string().optional()
+});
+var aiConfigurationSchema = aiConfigurationInputSchema.extend({
+  id: z12.string().uuid()
 });
 var aiConfigurationWithUsageSchema = aiConfigurationSchema.extend({
-  usageStats: z10.object({
-    totalInputTokens: z10.number(),
-    totalOutputTokens: z10.number(),
-    totalTokens: z10.number(),
-    totalImageCount: z10.number(),
-    totalRequests: z10.number()
+  usageStats: z12.object({
+    totalInputTokens: z12.number(),
+    totalOutputTokens: z12.number(),
+    totalTokens: z12.number(),
+    totalImageCount: z12.number(),
+    totalRequests: z12.number()
   }).optional()
 });
-var aiUsageDataSchema = z10.object({
-  configId: z10.string().uuid(),
-  inputTokens: z10.number().int().optional(),
-  outputTokens: z10.number().int().optional(),
-  imageCount: z10.number().int().optional(),
-  imageResolution: z10.string().optional()
+var aiUsageDataSchema = z12.object({
+  configId: z12.string().uuid(),
+  inputTokens: z12.number().int().optional(),
+  outputTokens: z12.number().int().optional(),
+  imageCount: z12.number().int().optional(),
+  imageResolution: z12.string().optional()
 });
 var aiUsageRecordSchema = aiUsageDataSchema.extend({
-  id: z10.string().uuid(),
-  createdAt: z10.date(),
-  modelId: z10.string().nullable().optional(),
-  model: z10.string().nullable(),
-  provider: z10.string().nullable(),
-  inputModality: z10.array(modalitySchema).nullable(),
-  outputModality: z10.array(modalitySchema).nullable()
-});
-var aiUsageSummarySchema = z10.object({
-  totalInputTokens: z10.number(),
-  totalOutputTokens: z10.number(),
-  totalTokens: z10.number(),
-  totalImageCount: z10.number(),
-  totalRequests: z10.number()
+  id: z12.string().uuid(),
+  createdAt: z12.date(),
+  modelId: z12.string().nullable().optional(),
+  model: z12.string().nullable(),
+  provider: z12.string().nullable(),
+  inputModality: z12.array(modalitySchema).nullable(),
+  outputModality: z12.array(modalitySchema).nullable()
+});
+var aiUsageSummarySchema = z12.object({
+  totalInputTokens: z12.number(),
+  totalOutputTokens: z12.number(),
+  totalTokens: z12.number(),
+  totalImageCount: z12.number(),
+  totalRequests: z12.number()
 });
 
 // node_modules/@insforge/shared-schemas/dist/ai-api.schema.js
-import { z as z11 } from "zod";
-var textContentSchema = z11.object({
-  type: z11.literal("text"),
-  text: z11.string()
+import { z as z13 } from "zod";
+var textContentSchema = z13.object({
+  type: z13.literal("text"),
+  text: z13.string()
 });
-var imageContentSchema = z11.object({
-  type: z11.literal("image_url"),
+var imageContentSchema = z13.object({
+  type: z13.literal("image_url"),
   // eslint-disable-next-line @typescript-eslint/naming-convention
-  image_url: z11.object({
+  image_url: z13.object({
     // URL can be either a public URL or base64-encoded data URI
     // Examples:
     // - Public URL: "https://example.com/image.jpg"
     // - Base64: "data:image/jpeg;base64,/9j/4AAQ..."
-    url: z11.string(),
-    detail: z11.enum(["auto", "low", "high"]).optional()
+    url: z13.string(),
+    detail: z13.enum(["auto", "low", "high"]).optional()
   })
 });
-var contentSchema = z11.union([textContentSchema, imageContentSchema]);
-var chatMessageSchema = z11.object({
-  role: z11.enum(["user", "assistant", "system"]),
+var contentSchema = z13.union([textContentSchema, imageContentSchema]);
+var chatMessageSchema = z13.object({
+  role: z13.enum(["user", "assistant", "system"]),
   // New format: content can be string or array of content parts (OpenAI-compatible)
-  content: z11.union([z11.string(), z11.array(contentSchema)]),
+  content: z13.union([z13.string(), z13.array(contentSchema)]),
   // Legacy format: separate images field (deprecated but supported for backward compatibility)
-  images: z11.array(z11.object({ url: z11.string() })).optional()
-});
-var chatCompletionRequestSchema = z11.object({
-  model: z11.string(),
-  messages: z11.array(chatMessageSchema),
-  temperature: z11.number().min(0).max(2).optional(),
-  maxTokens: z11.number().positive().optional(),
-  topP: z11.number().min(0).max(1).optional(),
-  stream: z11.boolean().optional()
-});
-var chatCompletionResponseSchema = z11.object({
-  text: z11.string(),
-  metadata: z11.object({
-    model: z11.string(),
-    usage: z11.object({
-      promptTokens: z11.number().optional(),
-      completionTokens: z11.number().optional(),
-      totalTokens: z11.number().optional()
+  images: z13.array(z13.object({ url: z13.string() })).optional()
+});
+var chatCompletionRequestSchema = z13.object({
+  model: z13.string(),
+  messages: z13.array(chatMessageSchema),
+  temperature: z13.number().min(0).max(2).optional(),
+  maxTokens: z13.number().positive().optional(),
+  topP: z13.number().min(0).max(1).optional(),
+  stream: z13.boolean().optional()
+});
+var chatCompletionResponseSchema = z13.object({
+  text: z13.string(),
+  metadata: z13.object({
+    model: z13.string(),
+    usage: z13.object({
+      promptTokens: z13.number().optional(),
+      completionTokens: z13.number().optional(),
+      totalTokens: z13.number().optional()
     }).optional()
   }).optional()
 });
-var imageGenerationRequestSchema = z11.object({
-  model: z11.string(),
-  prompt: z11.string(),
-  images: z11.array(z11.object({
-    url: z11.string()
+var imageGenerationRequestSchema = z13.object({
+  model: z13.string(),
+  prompt: z13.string(),
+  images: z13.array(z13.object({
+    url: z13.string()
   })).optional()
 });
-var imageGenerationResponseSchema = z11.object({
-  text: z11.string().optional(),
-  images: z11.array(z11.object({
-    type: z11.literal("imageUrl"),
-    imageUrl: z11.string()
+var imageGenerationResponseSchema = z13.object({
+  text: z13.string().optional(),
+  images: z13.array(z13.object({
+    type: z13.literal("imageUrl"),
+    imageUrl: z13.string()
   })),
-  metadata: z11.object({
-    model: z11.string(),
-    usage: z11.object({
-      promptTokens: z11.number().optional(),
-      completionTokens: z11.number().optional(),
-      totalTokens: z11.number().optional()
+  metadata: z13.object({
+    model: z13.string(),
+    usage: z13.object({
+      promptTokens: z13.number().optional(),
+      completionTokens: z13.number().optional(),
+      totalTokens: z13.number().optional()
     }).optional()
   }).optional()
 });
-var aiModelSchema = z11.object({
-  id: z11.string(),
-  inputModality: z11.array(modalitySchema).min(1),
-  outputModality: z11.array(modalitySchema).min(1),
-  provider: z11.string(),
-  modelId: z11.string(),
-  priceLevel: z11.number().min(0).max(3).optional()
+var aiModelSchema = z13.object({
+  id: z13.string(),
+  inputModality: z13.array(modalitySchema).min(1),
+  outputModality: z13.array(modalitySchema).min(1),
+  provider: z13.string(),
+  modelId: z13.string(),
+  priceLevel: z13.number().min(0).max(3).optional()
 });
 var createAIConfigurationRequestSchema = aiConfigurationSchema.omit({
   id: true
 });
-var updateAIConfigurationRequestSchema = z11.object({
-  systemPrompt: z11.string().nullable()
+var updateAIConfigurationRequestSchema = z13.object({
+  systemPrompt: z13.string().nullable()
 });
-var listAIUsageResponseSchema = z11.object({
-  records: z11.array(aiUsageRecordSchema),
-  total: z11.number()
+var listAIUsageResponseSchema = z13.object({
+  records: z13.array(aiUsageRecordSchema),
+  total: z13.number()
 });
-var getAIUsageRequestSchema = z11.object({
-  startDate: z11.string().datetime().optional(),
-  endDate: z11.string().datetime().optional(),
-  limit: z11.string().regex(/^\d+$/).default("50"),
-  offset: z11.string().regex(/^\d+$/).default("0")
+var getAIUsageRequestSchema = z13.object({
+  startDate: z13.string().datetime().optional(),
+  endDate: z13.string().datetime().optional(),
+  limit: z13.string().regex(/^\d+$/).default("50"),
+  offset: z13.string().regex(/^\d+$/).default("0")
 });
-var getAIUsageSummaryRequestSchema = z11.object({
-  configId: z11.string().uuid().optional(),
-  startDate: z11.string().datetime().optional(),
-  endDate: z11.string().datetime().optional()
+var getAIUsageSummaryRequestSchema = z13.object({
+  configId: z13.string().uuid().optional(),
+  startDate: z13.string().datetime().optional(),
+  endDate: z13.string().datetime().optional()
 });
 
 // node_modules/@insforge/shared-schemas/dist/logs.schema.js
-import { z as z12 } from "zod";
-var auditLogSchema = z12.object({
-  id: z12.string(),
-  actor: z12.string(),
-  action: z12.string(),
-  module: z12.string(),
-  details: z12.record(z12.unknown()).nullable(),
-  ipAddress: z12.string().nullable(),
-  createdAt: z12.string(),
-  updatedAt: z12.string()
-});
-var logSourceSchema = z12.object({
-  id: z12.string(),
-  name: z12.string(),
-  token: z12.string()
-});
-var logSchema = z12.object({
-  id: z12.string(),
-  eventMessage: z12.string(),
-  timestamp: z12.string(),
-  body: z12.record(z12.string(), z12.unknown()),
-  source: z12.string().optional()
-});
-var logStatsSchema = z12.object({
-  source: z12.string(),
-  count: z12.number(),
-  lastActivity: z12.string()
+import { z as z14 } from "zod";
+var auditLogSchema = z14.object({
+  id: z14.string(),
+  actor: z14.string(),
+  action: z14.string(),
+  module: z14.string(),
+  details: z14.record(z14.unknown()).nullable(),
+  ipAddress: z14.string().nullable(),
+  createdAt: z14.string(),
+  updatedAt: z14.string()
+});
+var logSourceSchema = z14.object({
+  id: z14.string(),
+  name: z14.string(),
+  token: z14.string()
+});
+var logSchema = z14.object({
+  id: z14.string(),
+  eventMessage: z14.string(),
+  timestamp: z14.string(),
+  body: z14.record(z14.string(), z14.unknown()),
+  source: z14.string().optional()
+});
+var logStatsSchema = z14.object({
+  source: z14.string(),
+  count: z14.number(),
+  lastActivity: z14.string()
 });
 
 // node_modules/@insforge/shared-schemas/dist/logs-api.schema.js
-import { z as z13 } from "zod";
-var getAuditLogsRequestSchema = z13.object({
-  limit: z13.number().default(100),
-  offset: z13.number().default(0),
-  actor: z13.string().optional(),
-  action: z13.string().optional(),
-  module: z13.string().optional(),
-  startDate: z13.string().optional(),
-  endDate: z13.string().optional()
-});
-var getAuditLogsResponseSchema = z13.object({
-  data: z13.array(auditLogSchema),
-  pagination: z13.object({
-    limit: z13.number(),
-    offset: z13.number(),
-    total: z13.number()
+import { z as z15 } from "zod";
+var getAuditLogsRequestSchema = z15.object({
+  limit: z15.number().default(100),
+  offset: z15.number().default(0),
+  actor: z15.string().optional(),
+  action: z15.string().optional(),
+  module: z15.string().optional(),
+  startDate: z15.string().optional(),
+  endDate: z15.string().optional()
+});
+var getAuditLogsResponseSchema = z15.object({
+  data: z15.array(auditLogSchema),
+  pagination: z15.object({
+    limit: z15.number(),
+    offset: z15.number(),
+    total: z15.number()
   })
 });
-var getAuditLogStatsRequestSchema = z13.object({
-  days: z13.number().default(7)
+var getAuditLogStatsRequestSchema = z15.object({
+  days: z15.number().default(7)
 });
-var getAuditLogStatsResponseSchema = z13.object({
-  totalLogs: z13.number(),
-  uniqueActors: z13.number(),
-  uniqueModules: z13.number(),
-  actionsByModule: z13.record(z13.number()),
-  recentActivity: z13.array(auditLogSchema)
+var getAuditLogStatsResponseSchema = z15.object({
+  totalLogs: z15.number(),
+  uniqueActors: z15.number(),
+  uniqueModules: z15.number(),
+  actionsByModule: z15.record(z15.number()),
+  recentActivity: z15.array(auditLogSchema)
 });
-var clearAuditLogsRequestSchema = z13.object({
-  daysToKeep: z13.number().default(90)
+var clearAuditLogsRequestSchema = z15.object({
+  daysToKeep: z15.number().default(90)
 });
-var clearAuditLogsResponseSchema = z13.object({
-  message: z13.string(),
-  deleted: z13.number()
+var clearAuditLogsResponseSchema = z15.object({
+  message: z15.string(),
+  deleted: z15.number()
 });
-var getLogsResponseSchema = z13.object({
-  logs: z13.array(logSchema),
-  total: z13.number()
+var getLogsResponseSchema = z15.object({
+  logs: z15.array(logSchema),
+  total: z15.number()
 });
 
 // node_modules/@insforge/shared-schemas/dist/functions.schema.js
-import { z as z14 } from "zod";
-var functionSchema = z14.object({
-  id: z14.string(),
-  slug: z14.string(),
-  name: z14.string(),
-  description: z14.string().nullable(),
-  code: z14.string(),
-  status: z14.enum(["draft", "active"]),
-  createdAt: z14.string(),
-  updatedAt: z14.string(),
-  deployedAt: z14.string().nullable()
+import { z as z16 } from "zod";
+var functionSchema = z16.object({
+  id: z16.string(),
+  slug: z16.string(),
+  name: z16.string(),
+  description: z16.string().nullable(),
+  code: z16.string(),
+  status: z16.enum(["draft", "active", "error"]),
+  createdAt: z16.string(),
+  updatedAt: z16.string(),
+  deployedAt: z16.string().nullable()
 });
 
 // node_modules/@insforge/shared-schemas/dist/functions-api.schema.js
-import { z as z15 } from "zod";
-var functionUploadRequestSchema = z15.object({
-  name: z15.string().min(1, "Name is required"),
-  slug: z15.string().regex(/^[a-zA-Z0-9_-]+$/, "Invalid slug format - must be alphanumeric with hyphens or underscores only").optional(),
-  code: z15.string().min(1),
-  description: z15.string().optional(),
-  status: z15.enum(["draft", "active"]).optional().default("active")
-});
-var functionUpdateRequestSchema = z15.object({
-  name: z15.string().optional(),
-  code: z15.string().optional(),
-  description: z15.string().optional(),
-  status: z15.enum(["draft", "active"]).optional()
+import { z as z17 } from "zod";
+var uploadFunctionRequestSchema = z17.object({
+  name: z17.string().min(1, "Name is required"),
+  slug: z17.string().regex(/^[a-zA-Z0-9_-]+$/, "Invalid slug format - must be alphanumeric with hyphens or underscores only").optional(),
+  code: z17.string().min(1),
+  description: z17.string().optional(),
+  status: z17.enum(["draft", "active"]).optional().default("active")
+});
+var updateFunctionRequestSchema = z17.object({
+  name: z17.string().optional(),
+  code: z17.string().optional(),
+  description: z17.string().optional(),
+  status: z17.enum(["draft", "active"]).optional()
+});
+var listFunctionsResponseSchema = z17.object({
+  functions: z17.array(functionSchema),
+  runtime: z17.object({
+    status: z17.enum(["running", "unavailable"])
+  })
 });
 
 // node_modules/@insforge/shared-schemas/dist/cloud-events.schema.js
-import { z as z16 } from "zod";
-var appRouteChangeEventSchema = z16.object({
-  type: z16.literal("APP_ROUTE_CHANGE"),
-  path: z16.string()
+import { z as z18 } from "zod";
+var appRouteChangeEventSchema = z18.object({
+  type: z18.literal("APP_ROUTE_CHANGE"),
+  path: z18.string()
 });
-var authSuccessEventSchema = z16.object({
-  type: z16.literal("AUTH_SUCCESS")
+var authSuccessEventSchema = z18.object({
+  type: z18.literal("AUTH_SUCCESS")
 });
-var authErrorEventSchema = z16.object({
-  type: z16.literal("AUTH_ERROR"),
-  message: z16.string()
+var authErrorEventSchema = z18.object({
+  type: z18.literal("AUTH_ERROR"),
+  message: z18.string()
 });
-var mcpConnectionStatusEventSchema = z16.object({
-  type: z16.literal("MCP_CONNECTION_STATUS"),
-  connected: z16.boolean(),
-  toolName: z16.string(),
-  timestamp: z16.union([z16.number(), z16.string()])
+var mcpConnectionStatusEventSchema = z18.object({
+  type: z18.literal("MCP_CONNECTION_STATUS"),
+  connected: z18.boolean(),
+  toolName: z18.string(),
+  timestamp: z18.union([z18.number(), z18.string()])
 });
-var showOnboardingOverlayEventSchema = z16.object({
-  type: z16.literal("SHOW_ONBOARDING_OVERLAY")
+var showOnboardingOverlayEventSchema = z18.object({
+  type: z18.literal("SHOW_ONBOARDING_OVERLAY")
 });
-var showSettingsOverlayEventSchema = z16.object({
-  type: z16.literal("SHOW_SETTINGS_OVERLAY")
+var showSettingsOverlayEventSchema = z18.object({
+  type: z18.literal("SHOW_SETTINGS_OVERLAY")
 });
-var onboardingSuccessSchema = z16.object({
-  type: z16.literal("ONBOARDING_SUCCESS")
+var onboardingSuccessSchema = z18.object({
+  type: z18.literal("ONBOARDING_SUCCESS")
 });
-var navigateToUsageSchema = z16.object({
-  type: z16.literal("NAVIGATE_TO_USAGE")
+var navigateToUsageSchema = z18.object({
+  type: z18.literal("NAVIGATE_TO_USAGE")
 });
-var cloudEventSchema = z16.discriminatedUnion("type", [
+var showContactModalEventSchema = z18.object({
+  type: z18.literal("SHOW_CONTACT_MODAL")
+});
+var showConnectOverlayEventSchema = z18.object({
+  type: z18.literal("SHOW_CONNECT_OVERLAY")
+});
+var authorizationCodeEventSchema = z18.object({
+  type: z18.literal("AUTHORIZATION_CODE"),
+  code: z18.string()
+});
+var routeChangeEventSchema = z18.object({
+  type: z18.literal("ROUTE_CHANGE"),
+  path: z18.string()
+});
+var cloudEventSchema = z18.discriminatedUnion("type", [
   appRouteChangeEventSchema,
   authSuccessEventSchema,
   authErrorEventSchema,
@@ -1054,121 +1149,192 @@ var cloudEventSchema = z16.discriminatedUnion("type", [
   showOnboardingOverlayEventSchema,
   showSettingsOverlayEventSchema,
   onboardingSuccessSchema,
-  navigateToUsageSchema
+  navigateToUsageSchema,
+  showContactModalEventSchema,
+  showConnectOverlayEventSchema,
+  authorizationCodeEventSchema,
+  routeChangeEventSchema
 ]);
 
 // node_modules/@insforge/shared-schemas/dist/docs.schema.js
-import { z as z17 } from "zod";
-var docTypeSchema = z17.enum([
+import { z as z19 } from "zod";
+var docTypeSchema = z19.enum([
   "instructions",
+  "auth-sdk",
   "db-sdk",
   "storage-sdk",
   "functions-sdk",
   "ai-integration-sdk",
   "auth-components-react",
   "auth-components-nextjs",
-  "real-time"
+  "real-time",
+  "deployment"
 ]).describe(`
-    Documentation type: 
+    Documentation type:
       "instructions" (essential backend setup - use FIRST),
       "db-sdk" (database operations),
       "storage-sdk" (file storage),
       "functions-sdk" (edge functions),
+      "auth-sdk" (direct SDK methods for custom auth flows),
       "auth-components-react" (authentication components for React+Vite applications),
       "auth-components-nextjs" (authentication components for Next.js applications),
       "ai-integration-sdk" (AI features),
-      "real-time" (real-time pub/sub through WebSockets)
+      "real-time" (real-time pub/sub through WebSockets),
+      "deployment" (deploy frontend applications via MCP tool)
     `);
 
 // node_modules/@insforge/shared-schemas/dist/email-api.schema.js
-import { z as z18 } from "zod";
-var emailOrEmails = z18.union([
+import { z as z20 } from "zod";
+var emailOrEmails = z20.union([
   emailSchema,
-  z18.array(emailSchema).min(1, "At least one email is required").max(50, "Maximum 50 recipients allowed")
+  z20.array(emailSchema).min(1, "At least one email is required").max(50, "Maximum 50 recipients allowed")
 ]);
-var sendRawEmailRequestSchema = z18.object({
+var sendRawEmailRequestSchema = z20.object({
   to: emailOrEmails,
-  subject: z18.string().trim().min(1, "Subject is required").max(500, "Subject too long"),
-  html: z18.string().trim().min(1, "HTML content is required"),
+  subject: z20.string().trim().min(1, "Subject is required").max(500, "Subject too long"),
+  html: z20.string().trim().min(1, "HTML content is required"),
   cc: emailOrEmails.optional(),
   bcc: emailOrEmails.optional(),
-  from: z18.string().trim().max(100, "From name too long").optional(),
-  replyTo: z18.string().email("Reply-To must be a valid email").optional()
+  from: z20.string().trim().max(100, "From name too long").optional(),
+  replyTo: z20.string().email("Reply-To must be a valid email").optional()
+});
+var sendEmailResponseSchema = z20.object({});
+
+// node_modules/@insforge/shared-schemas/dist/deployments.schema.js
+import { z as z21 } from "zod";
+var deploymentStatusSchema = z21.enum([
+  "WAITING",
+  // Record created, waiting for client to upload zip to S3
+  "UPLOADING",
+  // Server is downloading from S3 and uploading to Vercel
+  "QUEUED",
+  // Vercel: deployment queued
+  "BUILDING",
+  // Vercel: deployment building
+  "READY",
+  // Vercel: deployment ready
+  "ERROR",
+  // Vercel: deployment failed
+  "CANCELED"
+  // Vercel: deployment canceled
+]);
+var deploymentSchema = z21.object({
+  id: z21.string().uuid(),
+  providerDeploymentId: z21.string().nullable(),
+  // Provider's deployment ID, null until deployment starts
+  provider: z21.string(),
+  status: deploymentStatusSchema,
+  url: z21.string().nullable(),
+  metadata: z21.record(z21.unknown()).nullable(),
+  createdAt: z21.string().datetime(),
+  updatedAt: z21.string().datetime()
+});
+
+// node_modules/@insforge/shared-schemas/dist/deployments-api.schema.js
+import { z as z22 } from "zod";
+var projectSettingsSchema = z22.object({
+  buildCommand: z22.string().nullable().optional(),
+  outputDirectory: z22.string().nullable().optional(),
+  installCommand: z22.string().nullable().optional(),
+  devCommand: z22.string().nullable().optional(),
+  rootDirectory: z22.string().nullable().optional()
+});
+var envVarSchema = z22.object({
+  key: z22.string(),
+  value: z22.string()
+});
+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 startDeploymentRequestSchema = z22.object({
+  projectSettings: projectSettingsSchema.optional(),
+  envVars: z22.array(envVarSchema).optional(),
+  meta: z22.record(z22.string()).optional()
+});
+var listDeploymentsResponseSchema = z22.object({
+  data: z22.array(deploymentSchema),
+  pagination: z22.object({
+    limit: z22.number(),
+    offset: z22.number(),
+    total: z22.number()
+  })
 });
 
 // src/shared/tools.ts
 import FormData from "form-data";
 var execAsync = promisify(exec);
 var TOOL_VERSION_REQUIREMENTS = {
-  "upsert-schedule": "1.1.1",
-  // 'get-schedules': '1.1.1',
-  // 'get-schedule-logs': '1.1.1',
-  "delete-schedule": "1.1.1"
+  // Schedule tools - require backend v1.1.1+
+  "upsert-schedule": { minVersion: "1.1.1" },
+  "delete-schedule": { minVersion: "1.1.1" },
+  // 'get-schedules': { minVersion: '1.1.1' },
+  // 'get-schedule-logs': { minVersion: '1.1.1' },
+  "create-deployment": { minVersion: "1.4.7" }
+  // Example of a deprecated tool (uncomment when needed):
+  // 'legacy-tool': { minVersion: '1.0.0', maxVersion: '1.5.0' },
 };
-function registerInsforgeTools(server, config = {}) {
-  const GLOBAL_API_KEY = config.apiKey || process.env.API_KEY || "";
-  const API_BASE_URL = config.apiBaseUrl || process.env.API_BASE_URL || "http://localhost:7130";
-  const usageTracker = new UsageTracker(API_BASE_URL, GLOBAL_API_KEY);
-  let versionCache = null;
-  const VERSION_CACHE_TTL = 5 * 60 * 1e3;
-  async function getBackendVersion() {
-    const now = Date.now();
-    if (versionCache && now - versionCache.timestamp < VERSION_CACHE_TTL) {
-      return versionCache.version;
-    }
-    try {
-      const response = await fetch2(`${API_BASE_URL}/api/health`, {
-        method: "GET",
-        headers: {
-          "Content-Type": "application/json"
-        }
-      });
-      if (!response.ok) {
-        throw new Error(`Health check failed with status ${response.status}`);
-      }
-      const health = await response.json();
-      versionCache = {
-        version: health.version,
-        timestamp: now
-      };
-      return health.version;
-    } catch (error) {
-      const errMsg = error instanceof Error ? error.message : "Unknown error";
-      throw new Error(`Failed to fetch backend version: ${errMsg}`);
-    }
+function compareVersions(v1, v2) {
+  const clean1 = v1.replace(/^v/, "").split("-")[0];
+  const clean2 = v2.replace(/^v/, "").split("-")[0];
+  const parts1 = clean1.split(".").map(Number);
+  const parts2 = clean2.split(".").map(Number);
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const part1 = parts1[i] || 0;
+    const part2 = parts2[i] || 0;
+    if (part1 > part2) return 1;
+    if (part1 < part2) return -1;
   }
-  function compareVersions(v1, v2) {
-    const clean1 = v1.replace(/^v/, "").split("-")[0];
-    const clean2 = v2.replace(/^v/, "").split("-")[0];
-    const parts1 = clean1.split(".").map(Number);
-    const parts2 = clean2.split(".").map(Number);
-    for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
-      const part1 = parts1[i] || 0;
-      const part2 = parts2[i] || 0;
-      if (part1 > part2) return 1;
-      if (part1 < part2) return -1;
-    }
-    return 0;
+  return 0;
+}
+function shouldRegisterTool(toolName, backendVersion) {
+  const requirement = TOOL_VERSION_REQUIREMENTS[toolName];
+  if (!requirement) {
+    return true;
   }
-  async function checkToolVersion(toolName) {
-    const requiredVersion = TOOL_VERSION_REQUIREMENTS[toolName];
-    if (!requiredVersion) {
-      return;
-    }
-    try {
-      const currentVersion = await getBackendVersion();
-      if (compareVersions(currentVersion, requiredVersion) < 0) {
-        throw new Error(
-          `Tool '${toolName}' requires backend version ${requiredVersion} or higher, but current version is ${currentVersion}. Please upgrade your Insforge backend server.`
-        );
-      }
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("requires backend version")) {
-        throw error;
-      }
-      console.warn(`Warning: Could not verify backend version for tool '${toolName}': ${error instanceof Error ? error.message : "Unknown error"}`);
+  const { minVersion, maxVersion } = requirement;
+  if (minVersion && compareVersions(backendVersion, minVersion) < 0) {
+    return false;
+  }
+  if (maxVersion && compareVersions(backendVersion, maxVersion) > 0) {
+    return false;
+  }
+  return true;
+}
+async function fetchBackendVersion(apiBaseUrl) {
+  const response = await fetch2(`${apiBaseUrl}/api/health`, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json"
     }
+  });
+  if (!response.ok) {
+    throw new Error(`Health check failed with status ${response.status}`);
   }
+  const health = await response.json();
+  return health.version;
+}
+async function registerInsforgeTools(server, config = {}) {
+  const GLOBAL_API_KEY = config.apiKey || process.env.API_KEY || "";
+  const API_BASE_URL = config.apiBaseUrl || process.env.API_BASE_URL || "http://localhost:7130";
+  const usageTracker = new UsageTracker(API_BASE_URL, GLOBAL_API_KEY);
+  const backendVersion = await fetchBackendVersion(API_BASE_URL);
+  console.error(`Backend version: ${backendVersion}`);
+  let toolCount = 0;
+  const registerTool = (toolName, ...args) => {
+    if (shouldRegisterTool(toolName, backendVersion)) {
+      server.tool(toolName, ...args);
+      toolCount++;
+      return true;
+    } else {
+      const req = TOOL_VERSION_REQUIREMENTS[toolName];
+      const reason = req?.minVersion && compareVersions(backendVersion, req.minVersion) < 0 ? `requires backend >= ${req.minVersion}` : `deprecated after backend ${req?.maxVersion}`;
+      console.error(`Skipping tool '${toolName}': ${reason} (current: ${backendVersion})`);
+      return false;
+    }
+  };
   async function trackToolUsage(toolName, success = true) {
     if (GLOBAL_API_KEY) {
       await usageTracker.trackUsage(toolName, success);
@@ -1225,28 +1391,23 @@ function registerInsforgeTools(server, config = {}) {
     }
   };
   const addBackgroundContext = async (response) => {
-    try {
-      const currentVersion = await getBackendVersion();
-      const isLegacyVersion = compareVersions(currentVersion, "1.1.7") < 0;
-      if (isLegacyVersion) {
-        const context = await fetchInsforgeInstructionsContext();
-        if (context && response.content && Array.isArray(response.content)) {
-          response.content.push({
-            type: "text",
-            text: `
+    const isLegacyVersion = compareVersions(backendVersion, "1.1.7") < 0;
+    if (isLegacyVersion) {
+      const context = await fetchInsforgeInstructionsContext();
+      if (context && response.content && Array.isArray(response.content)) {
+        response.content.push({
+          type: "text",
+          text: `
 
 ---
 \u{1F527} INSFORGE DEVELOPMENT RULES (Auto-loaded):
 ${context}`
-          });
-        }
+        });
       }
-    } catch {
-      console.warn("Could not determine backend version, skipping background context");
     }
     return response;
   };
-  server.tool(
+  registerTool(
     "fetch-docs",
     'Fetch Insforge documentation. Use "instructions" for essential backend setup (MANDATORY FIRST), or select specific SDK docs for database, auth, storage, functions, or AI integration.',
     {
@@ -1279,11 +1440,11 @@ ${context}`
       }
     })
   );
-  server.tool(
+  registerTool(
     "get-anon-key",
     "Generate an anonymous JWT token that never expires. Requires admin API key. Use this for client-side applications that need public access.",
     {
-      apiKey: z19.string().optional().describe("API key for authentication (optional if provided via --api_key)")
+      apiKey: z23.string().optional().describe("API key for authentication (optional if provided via --api_key)")
     },
     withUsageTracking("get-anon-key", async ({ apiKey }) => {
       try {
@@ -1318,12 +1479,12 @@ ${context}`
       }
     })
   );
-  server.tool(
+  registerTool(
     "get-table-schema",
     "Returns the detailed schema(including RLS, indexes, constraints, etc.) of a specific table",
     {
-      apiKey: z19.string().optional().describe("API key for authentication (optional if provided via --api_key)"),
-      tableName: z19.string().describe("Name of the table")
+      apiKey: z23.string().optional().describe("API key for authentication (optional if provided via --api_key)"),
+      tableName: z23.string().describe("Name of the table")
     },
     withUsageTracking("get-table-schema", async ({ apiKey, tableName }) => {
       try {
@@ -1357,11 +1518,11 @@ ${context}`
       }
     })
   );
-  server.tool(
+  registerTool(
     "get-backend-metadata",
     "Index all backend metadata",
     {
-      apiKey: z19.string().optional().describe("API key for authentication (optional if provided via --api_key)")
+      apiKey: z23.string().optional().describe("API key for authentication (optional if provided via --api_key)")
     },
     withUsageTracking("get-backend-metadata", async ({ apiKey }) => {
       try {
@@ -1397,11 +1558,11 @@ ${JSON.stringify(metadata, null, 2)}`
       }
     })
   );
-  server.tool(
+  registerTool(
     "run-raw-sql",
     "Execute raw SQL query with optional parameters. Admin access required. Use with caution as it can modify data directly.",
     {
-      apiKey: z19.string().optional().describe("API key for authentication (optional if provided via --api_key)"),
+      apiKey: z23.string().optional().describe("API key for authentication (optional if provided via --api_key)"),
       ...rawSQLRequestSchema.shape
     },
     withUsageTracking("run-raw-sql", async ({ apiKey, query, params }) => {
@@ -1442,12 +1603,12 @@ ${JSON.stringify(metadata, null, 2)}`
       }
     })
   );
-  server.tool(
+  registerTool(
     "download-template",
     "CRITICAL: MANDATORY FIRST STEP for all new InsForge projects. Download pre-configured starter template to a temporary directory. After download, you MUST copy files to current directory using the provided command.",
     {
-      frame: z19.enum(["react", "nextjs"]).describe("Framework to use for the template (support React and Next.js)"),
-      projectName: z19.string().optional().describe('Name for the project directory (optional, defaults to "insforge-react")')
+      frame: z23.enum(["react", "nextjs"]).describe("Framework to use for the template (support React and Next.js)"),
+      projectName: z23.string().optional().describe('Name for the project directory (optional, defaults to "insforge-react")')
     },
     withUsageTracking("download-template", async ({ frame, projectName }) => {
       try {
@@ -1518,13 +1679,13 @@ To: Your current project directory
       }
     })
   );
-  server.tool(
+  registerTool(
     "bulk-upsert",
     "Bulk insert or update data from CSV or JSON file. Supports upsert operations with a unique key.",
     {
-      apiKey: z19.string().optional().describe("API key for authentication (optional if provided via --api_key)"),
+      apiKey: z23.string().optional().describe("API key for authentication (optional if provided via --api_key)"),
       ...bulkUpsertRequestSchema.shape,
-      filePath: z19.string().describe("Path to CSV or JSON file containing data to import")
+      filePath: z23.string().describe("Path to CSV or JSON file containing data to import")
     },
     withUsageTracking("bulk-upsert", async ({ apiKey, table, filePath, upsertKey }) => {
       try {
@@ -1575,11 +1736,11 @@ To: Your current project directory
       }
     })
   );
-  server.tool(
+  registerTool(
     "create-bucket",
     "Create new storage bucket",
     {
-      apiKey: z19.string().optional().describe("API key for authentication (optional if provided via --api_key)"),
+      apiKey: z23.string().optional().describe("API key for authentication (optional if provided via --api_key)"),
       ...createBucketRequestSchema.shape
     },
     withUsageTracking("create-bucket", async ({ apiKey, bucketName, isPublic }) => {
@@ -1616,7 +1777,7 @@ To: Your current project directory
       }
     })
   );
-  server.tool(
+  registerTool(
     "list-buckets",
     "Lists all storage buckets",
     {},
@@ -1651,12 +1812,12 @@ To: Your current project directory
       }
     })
   );
-  server.tool(
+  registerTool(
     "delete-bucket",
     "Deletes a storage bucket",
     {
-      apiKey: z19.string().optional().describe("API key for authentication (optional if provided via --api_key)"),
-      bucketName: z19.string().describe("Name of the bucket to delete")
+      apiKey: z23.string().optional().describe("API key for authentication (optional if provided via --api_key)"),
+      bucketName: z23.string().describe("Name of the bucket to delete")
     },
     withUsageTracking("delete-bucket", async ({ apiKey, bucketName }) => {
       try {
@@ -1690,12 +1851,12 @@ To: Your current project directory
       }
     })
   );
-  server.tool(
+  registerTool(
     "create-function",
     "Create a new edge function that runs in Deno runtime. The code must be written to a file first for version control",
     {
-      ...functionUploadRequestSchema.omit({ code: true }).shape,
-      codeFile: z19.string().describe(
+      ...uploadFunctionRequestSchema.omit({ code: true }).shape,
+      codeFile: z23.string().describe(
         "Path to JavaScript file containing the function code. Must export: module.exports = async function(request) { return new Response(...) }"
       )
     },
@@ -1749,11 +1910,11 @@ To: Your current project directory
       }
     })
   );
-  server.tool(
+  registerTool(
     "get-function",
     "Get details of a specific edge function including its code",
     {
-      slug: z19.string().describe("The slug identifier of the function")
+      slug: z23.string().describe("The slug identifier of the function")
     },
     withUsageTracking("get-function", async (args) => {
       try {
@@ -1786,13 +1947,13 @@ To: Your current project directory
       }
     })
   );
-  server.tool(
+  registerTool(
     "update-function",
     "Update an existing edge function code or metadata",
     {
-      slug: z19.string().describe("The slug identifier of the function to update"),
-      ...functionUpdateRequestSchema.omit({ code: true }).shape,
-      codeFile: z19.string().optional().describe(
+      slug: z23.string().describe("The slug identifier of the function to update"),
+      ...updateFunctionRequestSchema.omit({ code: true }).shape,
+      codeFile: z23.string().optional().describe(
         "Path to JavaScript file containing the new function code. Must export: module.exports = async function(request) { return new Response(...) }"
       )
     },
@@ -1852,11 +2013,11 @@ To: Your current project directory
       }
     })
   );
-  server.tool(
+  registerTool(
     "delete-function",
     "Delete an edge function permanently",
     {
-      slug: z19.string().describe("The slug identifier of the function to delete")
+      slug: z23.string().describe("The slug identifier of the function to delete")
     },
     withUsageTracking("delete-function", async (args) => {
       try {
@@ -1889,13 +2050,13 @@ To: Your current project directory
       }
     })
   );
-  server.tool(
+  registerTool(
     "get-container-logs",
     "Get latest logs from a specific container/service. Use this to help debug problems with your app.",
     {
-      apiKey: z19.string().optional().describe("API key for authentication (optional if provided via --api_key)"),
-      source: z19.enum(["insforge.logs", "postgREST.logs", "postgres.logs", "function.logs"]).describe("Log source to retrieve"),
-      limit: z19.number().optional().default(20).describe("Number of logs to return (default: 20)")
+      apiKey: z23.string().optional().describe("API key for authentication (optional if provided via --api_key)"),
+      source: z23.enum(["insforge.logs", "postgREST.logs", "postgres.logs", "function.logs"]).describe("Log source to retrieve"),
+      limit: z23.number().optional().default(20).describe("Number of logs to return (default: 20)")
     },
     withUsageTracking("get-container-logs", async ({ apiKey, source, limit }) => {
       try {
@@ -1939,10 +2100,148 @@ To: Your current project directory
       }
     })
   );
+  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.",
+    {
+      sourceDirectory: z23.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) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: sourceDirectory must be an absolute path, not a relative path like "${sourceDirectory}". Please provide the full path to the source directory (e.g., /Users/name/project on macOS/Linux or C:\\Users\\name\\project on Windows).`
+              }
+            ],
+            isError: true
+          };
+        }
+        try {
+          const stats = await fs.stat(sourceDirectory);
+          if (!stats.isDirectory()) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Error: "${sourceDirectory}" is not a directory. Please provide a path to a directory containing the source code.`
+                }
+              ],
+              isError: true
+            };
+          }
+        } catch (statError) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: Directory "${sourceDirectory}" does not exist or is not accessible. Please verify the path is correct.`
+              }
+            ],
+            isError: true
+          };
+        }
+        const resolvedSourceDir = sourceDirectory;
+        const createResponse = await fetch2(`${API_BASE_URL}/api/deployments`, {
+          method: "POST",
+          headers: {
+            "x-api-key": getApiKey(),
+            "Content-Type": "application/json"
+          }
+        });
+        const createResult = await handleApiResponse(createResponse);
+        const { id: deploymentId, uploadUrl, uploadFields } = createResult;
+        const zipBuffer = await new Promise((resolve, reject) => {
+          const archive = archiver("zip", { zlib: { level: 9 } });
+          const chunks = [];
+          archive.on("data", (chunk) => chunks.push(chunk));
+          archive.on("end", () => resolve(Buffer.concat(chunks)));
+          archive.on("error", (err) => reject(err));
+          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;
+            }
+            return entry;
+          });
+          archive.finalize();
+        });
+        const uploadFormData = new FormData();
+        for (const [key, value] of Object.entries(uploadFields)) {
+          uploadFormData.append(key, value);
+        }
+        uploadFormData.append("file", zipBuffer, {
+          filename: "deployment.zip",
+          contentType: "application/zip"
+        });
+        const uploadResponse = await fetch2(uploadUrl, {
+          method: "POST",
+          body: uploadFormData,
+          headers: uploadFormData.getHeaders()
+        });
+        if (!uploadResponse.ok) {
+          const uploadError = await uploadResponse.text();
+          throw new Error(`Failed to upload zip file: ${uploadError}`);
+        }
+        const startBody = {};
+        if (projectSettings) startBody.projectSettings = projectSettings;
+        if (envVars) startBody.envVars = envVars;
+        if (meta) startBody.meta = meta;
+        const startResponse = await fetch2(`${API_BASE_URL}/api/deployments/${deploymentId}/start`, {
+          method: "POST",
+          headers: {
+            "x-api-key": getApiKey(),
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(startBody)
+        });
+        const startResult = await handleApiResponse(startResponse);
+        return await addBackgroundContext({
+          content: [
+            {
+              type: "text",
+              text: formatSuccessMessage("Deployment started", startResult) + "\n\nNote: You can check deployment status by querying the system.deployments table."
+            }
+          ]
+        });
+      } catch (error) {
+        const errMsg = error instanceof Error ? error.message : "Unknown error occurred";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error creating deployment: ${errMsg}`
+            }
+          ],
+          isError: true
+        };
+      }
+    })
+  );
   return {
     apiKey: GLOBAL_API_KEY,
     apiBaseUrl: API_BASE_URL,
-    toolCount: 15
+    toolCount,
+    backendVersion
   };
 }