@insforge/mcp 1.2.1 → 1.2.2-dev.2

package/README.md

@@ -14,6 +14,10 @@
 
 Model Context Protocol server for [Insforge](https://github.com/InsForge/insforge).
 
+<a href="https://glama.ai/mcp/servers/@InsForge/insforge-mcp">
+  <img width="380" height="200" src="https://glama.ai/mcp/servers/@InsForge/insforge-mcp/badge" alt="Insforge Server MCP server" />
+</a>
+
 ## 📖 Documentation
 
 Please visit the [main Insforge repository](https://github.com/InsForge/insforge) for:

package/dist/{chunk-MRGODXOM.js → chunk-FCDI74JO.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/shared/tools.ts
-import { z as z14 } from "zod";
+import { z as z18 } from "zod";
 import fetch2 from "node-fetch";
 import { promises as fs } from "fs";
 import { exec } from "child_process";
@@ -112,7 +112,7 @@ var columnSchema = z.object({
 var tableSchema = z.object({
   tableName: z.string().min(1, "Table name cannot be empty").max(64, "Table name must be less than 64 characters"),
   columns: z.array(columnSchema).min(1, "At least one column is required"),
-  recordCount: z.number().default(0),
+  recordCount: z.number().optional(),
   createdAt: z.string().optional(),
   updatedAt: z.string().optional()
 });
@@ -165,7 +165,6 @@ var deleteTableResponse = z2.object({
 var rawSQLRequestSchema = z2.object({
   query: z2.string().min(1, "Query is required"),
   params: z2.array(z2.unknown()).optional()
-  // z.unknown() generates JSON Schema with items: {}
 });
 var rawSQLResponseSchema = z2.object({
   rows: z2.array(z2.record(z2.string(), z2.unknown())),
@@ -352,9 +351,10 @@ var confirmUploadRequestSchema = z4.object({
 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().min(6, "Password must be at least 6 characters").max(32, "Password must be less than 32 characters");
+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(["authenticated", "project_admin"]);
+var roleSchema = z5.enum(["anon", "authenticated", "project_admin"]);
+var verificationMethodSchema = z5.enum(["code", "link"]);
 var userSchema = z5.object({
   id: userIdSchema,
   email: emailSchema,
@@ -387,11 +387,32 @@ var oAuthStateSchema = z5.object({
   redirectUri: z5.string().url().optional()
 });
 var oAuthConfigSchema = z5.object({
-  provider: z5.string(),
+  id: z5.string().uuid(),
+  provider: oAuthProvidersSchema,
   clientId: z5.string().optional(),
   scopes: z5.array(z5.string()).optional(),
   redirectUri: z5.string().optional(),
-  useSharedKey: z5.boolean()
+  useSharedKey: z5.boolean(),
+  createdAt: z5.string(),
+  // PostgreSQL timestamp
+  updatedAt: z5.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(),
+  verifyEmailMethod: verificationMethodSchema,
+  resetPasswordMethod: verificationMethodSchema,
+  signInRedirectTo: z5.union([z5.string().url(), z5.literal(""), z5.null()]).optional().transform((val) => val === "" ? null : val),
+  createdAt: z5.string(),
+  // PostgreSQL timestamp
+  updatedAt: z5.string()
+  // PostgreSQL timestamp
 });
 var tokenPayloadSchema = z5.object({
   sub: userIdSchema,
@@ -428,9 +449,48 @@ var listUsersRequestSchema = paginationSchema.extend({
 var deleteUsersRequestSchema = z6.object({
   userIds: z6.array(userIdSchema).min(1, "At least one user ID is required")
 });
+var sendVerificationEmailRequestSchema = z6.object({
+  email: emailSchema
+});
+var verifyEmailRequestSchema = z6.object({
+  email: emailSchema.optional(),
+  otp: z6.string().min(1)
+}).refine((data) => data.email || data.otp, {
+  message: "Either email or otp must be provided"
+});
+var sendResetPasswordEmailRequestSchema = z6.object({
+  email: emailSchema
+});
+var exchangeResetPasswordTokenRequestSchema = z6.object({
+  email: emailSchema,
+  code: z6.string().min(1)
+});
+var resetPasswordRequestSchema = z6.object({
+  newPassword: passwordSchema,
+  otp: z6.string().min(1, "OTP/token is required")
+});
 var createUserResponseSchema = z6.object({
+  user: userSchema.optional(),
+  accessToken: z6.string().nullable(),
+  requireEmailVerification: z6.boolean().optional(),
+  redirectTo: z6.string().url().optional()
+});
+var createSessionResponseSchema = z6.object({
+  user: userSchema,
+  accessToken: z6.string(),
+  redirectTo: z6.string().url().optional()
+});
+var verifyEmailResponseSchema = z6.object({
   user: userSchema,
-  accessToken: z6.string()
+  accessToken: z6.string(),
+  redirectTo: z6.string().url().optional()
+});
+var exchangeResetPasswordTokenResponseSchema = z6.object({
+  token: z6.string(),
+  expiresAt: z6.string().datetime()
+});
+var resetPasswordResponseSchema = z6.object({
+  message: z6.string()
 });
 var getCurrentSessionResponseSchema = z6.object({
   user: z6.object({
@@ -454,18 +514,39 @@ var deleteUsersResponseSchema = z6.object({
 var getOauthUrlResponseSchema = z6.object({
   authUrl: z6.string().url()
 });
-var createOAuthConfigRequestSchema = oAuthConfigSchema.extend({
+var createOAuthConfigRequestSchema = oAuthConfigSchema.omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true
+}).extend({
   clientSecret: z6.string().optional()
 });
-var updateOAuthConfigRequestSchema = oAuthConfigSchema.extend({
+var updateOAuthConfigRequestSchema = oAuthConfigSchema.omit({
+  id: true,
+  provider: true,
+  createdAt: true,
+  updatedAt: true
+}).extend({
   clientSecret: z6.string().optional()
-}).omit({
-  provider: true
-});
+}).partial();
 var listOAuthConfigsResponseSchema = z6.object({
   data: z6.array(oAuthConfigSchema),
   count: z6.number()
 });
+var updateAuthConfigRequestSchema = authConfigSchema.omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true
+}).partial();
+var getPublicAuthConfigResponseSchema = z6.object({
+  oAuthProviders: z6.array(oAuthProvidersSchema),
+  ...authConfigSchema.omit({
+    id: true,
+    updatedAt: true,
+    createdAt: true,
+    signInRedirectTo: true
+  }).shape
+});
 var authErrorResponseSchema = z6.object({
   error: z6.string(),
   message: z6.string(),
@@ -474,268 +555,488 @@ var authErrorResponseSchema = z6.object({
 });
 
 // node_modules/@insforge/shared-schemas/dist/metadata.schema.js
+import { z as z9 } from "zod";
+
+// node_modules/@insforge/shared-schemas/dist/realtime.schema.js
 import { z as z7 } from "zod";
-var authMetadataSchema = z7.object({
-  oauths: z7.array(oAuthConfigSchema)
-});
-var databaseMetadataSchema = z7.object({
-  tables: z7.array(z7.object({
-    schema: z7.string(),
-    tableName: z7.string(),
-    recordCount: z7.number()
-  })),
-  totalSizeInGB: z7.number(),
-  hint: z7.string().optional()
+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()),
+  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)
+  // The resolved channel instance, e.g., "order:123"
+});
+var unsubscribeChannelPayloadSchema = z7.object({
+  channel: z7.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 subscribeResponseSchema = z7.discriminatedUnion("ok", [
+  z7.object({
+    ok: z7.literal(true),
+    channel: z7.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)
+    })
+  })
+]);
+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(),
+  // Present for room broadcasts
+  messageId: z7.string().uuid(),
+  senderType: senderTypeSchema,
+  senderId: z7.string().uuid().optional(),
+  timestamp: z7.string().datetime()
+});
+var socketMessageSchema = z7.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)
+  }))
 });
-var bucketMetadataSchema = storageBucketSchema.extend({
-  objectCount: z7.number().optional()
+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)
+  }),
+  publish: z8.object({
+    policies: z8.array(rlsPolicySchema)
+  })
 });
-var storageMetadataSchema = z7.object({
-  buckets: z7.array(bucketMetadataSchema),
-  totalSizeInGB: z7.number()
+
+// node_modules/@insforge/shared-schemas/dist/metadata.schema.js
+var authMetadataSchema = z9.object({
+  oauths: z9.array(oAuthConfigSchema)
 });
-var edgeFunctionMetadataSchema = z7.object({
-  slug: z7.string(),
-  name: z7.string(),
-  description: z7.string().nullable(),
-  status: z7.string()
+var databaseMetadataSchema = z9.object({
+  tables: z9.array(z9.object({
+    tableName: z9.string(),
+    recordCount: z9.number()
+  })),
+  totalSizeInGB: z9.number(),
+  hint: z9.string().optional()
 });
-var aiMetadataSchema = z7.object({
-  models: z7.array(z7.object({
-    inputModality: z7.array(z7.string()),
-    outputModality: z7.array(z7.string()),
-    modelId: z7.string()
+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()
   }))
 });
-var appMetaDataSchema = z7.object({
+var realtimeMetadataSchema = z9.object({
+  channels: z9.array(realtimeChannelSchema),
+  permissions: realtimePermissionsResponseSchema
+});
+var appMetaDataSchema = z9.object({
   auth: authMetadataSchema,
   database: databaseMetadataSchema,
   storage: storageMetadataSchema,
   aiIntegration: aiMetadataSchema.optional(),
-  functions: z7.array(edgeFunctionMetadataSchema),
-  version: z7.string().optional()
+  functions: z9.array(edgeFunctionMetadataSchema),
+  realtime: realtimeMetadataSchema.optional(),
+  version: z9.string().optional()
 });
 
 // node_modules/@insforge/shared-schemas/dist/ai.schema.js
-import { z as z8 } from "zod";
-var modalitySchema = z8.enum(["text", "image"]);
-var aiConfigurationSchema = z8.object({
-  id: z8.string().uuid(),
-  inputModality: z8.array(modalitySchema).min(1),
-  outputModality: z8.array(modalitySchema).min(1),
-  provider: z8.string(),
-  modelId: z8.string(),
-  systemPrompt: z8.string().optional()
+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()
 });
 var aiConfigurationWithUsageSchema = aiConfigurationSchema.extend({
-  usageStats: z8.object({
-    totalInputTokens: z8.number(),
-    totalOutputTokens: z8.number(),
-    totalTokens: z8.number(),
-    totalImageCount: z8.number(),
-    totalRequests: z8.number()
+  usageStats: z10.object({
+    totalInputTokens: z10.number(),
+    totalOutputTokens: z10.number(),
+    totalTokens: z10.number(),
+    totalImageCount: z10.number(),
+    totalRequests: z10.number()
   }).optional()
 });
-var aiUsageDataSchema = z8.object({
-  configId: z8.string().uuid(),
-  inputTokens: z8.number().int().optional(),
-  outputTokens: z8.number().int().optional(),
-  imageCount: z8.number().int().optional(),
-  imageResolution: z8.string().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 aiUsageRecordSchema = aiUsageDataSchema.extend({
-  id: z8.string().uuid(),
-  createdAt: z8.date()
-});
-var aiUsageSummarySchema = z8.object({
-  totalInputTokens: z8.number(),
-  totalOutputTokens: z8.number(),
-  totalTokens: z8.number(),
-  totalImageCount: z8.number(),
-  totalRequests: z8.number()
+  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()
 });
 
 // node_modules/@insforge/shared-schemas/dist/ai-api.schema.js
-import { z as z9 } from "zod";
-var chatMessageSchema = z9.object({
-  role: z9.enum(["user", "assistant", "system"]),
-  content: z9.string(),
-  images: z9.array(z9.object({
-    url: z9.string()
-  })).optional()
+import { z as z11 } from "zod";
+var textContentSchema = z11.object({
+  type: z11.literal("text"),
+  text: z11.string()
+});
+var imageContentSchema = z11.object({
+  type: z11.literal("image_url"),
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  image_url: z11.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()
+  })
 });
-var chatCompletionRequestSchema = z9.object({
-  model: z9.string(),
-  messages: z9.array(chatMessageSchema),
-  temperature: z9.number().min(0).max(2).optional(),
-  maxTokens: z9.number().positive().optional(),
-  topP: z9.number().min(0).max(1).optional(),
-  stream: z9.boolean().optional()
-});
-var chatCompletionResponseSchema = z9.object({
-  text: z9.string(),
-  metadata: z9.object({
-    model: z9.string(),
-    usage: z9.object({
-      promptTokens: z9.number().optional(),
-      completionTokens: z9.number().optional(),
-      totalTokens: z9.number().optional()
+var contentSchema = z11.union([textContentSchema, imageContentSchema]);
+var chatMessageSchema = z11.object({
+  role: z11.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)]),
+  // 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()
     }).optional()
   }).optional()
 });
-var imageGenerationRequestSchema = z9.object({
-  model: z9.string(),
-  prompt: z9.string(),
-  images: z9.array(z9.object({
-    url: z9.string()
+var imageGenerationRequestSchema = z11.object({
+  model: z11.string(),
+  prompt: z11.string(),
+  images: z11.array(z11.object({
+    url: z11.string()
   })).optional()
 });
-var imageGenerationResponseSchema = z9.object({
-  text: z9.string().optional(),
-  images: z9.array(z9.object({
-    type: z9.literal("imageUrl"),
-    imageUrl: z9.string()
+var imageGenerationResponseSchema = z11.object({
+  text: z11.string().optional(),
+  images: z11.array(z11.object({
+    type: z11.literal("imageUrl"),
+    imageUrl: z11.string()
   })),
-  metadata: z9.object({
-    model: z9.string(),
-    usage: z9.object({
-      promptTokens: z9.number().optional(),
-      completionTokens: z9.number().optional(),
-      totalTokens: z9.number().optional()
+  metadata: z11.object({
+    model: z11.string(),
+    usage: z11.object({
+      promptTokens: z11.number().optional(),
+      completionTokens: z11.number().optional(),
+      totalTokens: z11.number().optional()
     }).optional()
   }).optional()
 });
-var aiModelSchema = z9.object({
-  id: z9.string(),
-  inputModality: z9.array(modalitySchema).min(1),
-  outputModality: z9.array(modalitySchema).min(1),
-  provider: z9.string(),
-  modelId: z9.string(),
-  priceLevel: z9.number().min(0).max(3).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 createAIConfigurationRequestSchema = aiConfigurationSchema.omit({
   id: true
 });
-var updateAIConfigurationRequestSchema = z9.object({
-  systemPrompt: z9.string().nullable()
+var updateAIConfigurationRequestSchema = z11.object({
+  systemPrompt: z11.string().nullable()
 });
-var listAIUsageResponseSchema = z9.object({
-  records: z9.array(aiUsageRecordSchema),
-  total: z9.number()
+var listAIUsageResponseSchema = z11.object({
+  records: z11.array(aiUsageRecordSchema),
+  total: z11.number()
 });
-var getAIUsageRequestSchema = z9.object({
-  startDate: z9.string().datetime().optional(),
-  endDate: z9.string().datetime().optional(),
-  limit: z9.string().regex(/^\d+$/).default("50"),
-  offset: z9.string().regex(/^\d+$/).default("0")
+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 getAIUsageSummaryRequestSchema = z9.object({
-  configId: z9.string().uuid().optional(),
-  startDate: z9.string().datetime().optional(),
-  endDate: z9.string().datetime().optional()
+var getAIUsageSummaryRequestSchema = z11.object({
+  configId: z11.string().uuid().optional(),
+  startDate: z11.string().datetime().optional(),
+  endDate: z11.string().datetime().optional()
 });
 
 // node_modules/@insforge/shared-schemas/dist/logs.schema.js
-import { z as z10 } from "zod";
-var auditLogSchema = z10.object({
-  id: z10.string(),
-  actor: z10.string(),
-  action: z10.string(),
-  module: z10.string(),
-  details: z10.record(z10.unknown()).nullable(),
-  ipAddress: z10.string().nullable(),
-  createdAt: z10.string(),
-  updatedAt: z10.string()
-});
-var logSourceSchema = z10.object({
-  id: z10.string(),
-  name: z10.string(),
-  token: z10.string()
-});
-var logSchema = z10.object({
-  id: z10.string(),
-  eventMessage: z10.string(),
-  timestamp: z10.string(),
-  body: z10.record(z10.string(), z10.unknown()),
-  source: z10.string().optional()
-});
-var logStatsSchema = z10.object({
-  source: z10.string(),
-  count: z10.number(),
-  lastActivity: z10.string()
+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()
 });
 
 // node_modules/@insforge/shared-schemas/dist/logs-api.schema.js
-import { z as z11 } from "zod";
-var getAuditLogsRequestSchema = z11.object({
-  limit: z11.number().default(100),
-  offset: z11.number().default(0),
-  actor: z11.string().optional(),
-  action: z11.string().optional(),
-  module: z11.string().optional(),
-  startDate: z11.string().optional(),
-  endDate: z11.string().optional()
-});
-var getAuditLogsResponseSchema = z11.object({
-  data: z11.array(auditLogSchema),
-  pagination: z11.object({
-    limit: z11.number(),
-    offset: z11.number(),
-    total: z11.number()
+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()
   })
 });
-var getAuditLogStatsRequestSchema = z11.object({
-  days: z11.number().default(7)
+var getAuditLogStatsRequestSchema = z13.object({
+  days: z13.number().default(7)
 });
-var getAuditLogStatsResponseSchema = z11.object({
-  totalLogs: z11.number(),
-  uniqueActors: z11.number(),
-  uniqueModules: z11.number(),
-  actionsByModule: z11.record(z11.number()),
-  recentActivity: z11.array(auditLogSchema)
+var getAuditLogStatsResponseSchema = z13.object({
+  totalLogs: z13.number(),
+  uniqueActors: z13.number(),
+  uniqueModules: z13.number(),
+  actionsByModule: z13.record(z13.number()),
+  recentActivity: z13.array(auditLogSchema)
 });
-var clearAuditLogsRequestSchema = z11.object({
-  daysToKeep: z11.number().default(90)
+var clearAuditLogsRequestSchema = z13.object({
+  daysToKeep: z13.number().default(90)
 });
-var clearAuditLogsResponseSchema = z11.object({
-  message: z11.string(),
-  deleted: z11.number()
+var clearAuditLogsResponseSchema = z13.object({
+  message: z13.string(),
+  deleted: z13.number()
 });
-var getLogsResponseSchema = z11.object({
-  logs: z11.array(logSchema),
-  total: z11.number()
+var getLogsResponseSchema = z13.object({
+  logs: z13.array(logSchema),
+  total: z13.number()
 });
 
 // node_modules/@insforge/shared-schemas/dist/functions.schema.js
-import { z as z12 } from "zod";
-var functionSchema = z12.object({
-  id: z12.string(),
-  slug: z12.string(),
-  name: z12.string(),
-  description: z12.string().nullable(),
-  code: z12.string(),
-  status: z12.enum(["draft", "active"]),
-  createdAt: z12.string(),
-  updatedAt: z12.string(),
-  deployedAt: z12.string().nullable()
+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()
 });
 
 // node_modules/@insforge/shared-schemas/dist/functions-api.schema.js
-import { z as z13 } from "zod";
-var functionUploadRequestSchema = z13.object({
-  name: z13.string().min(1, "Name is required"),
-  slug: z13.string().regex(/^[a-zA-Z0-9_-]+$/, "Invalid slug format - must be alphanumeric with hyphens or underscores only").optional(),
-  code: z13.string().min(1),
-  description: z13.string().optional(),
-  status: z13.enum(["draft", "active"]).optional().default("active")
-});
-var functionUpdateRequestSchema = z13.object({
-  name: z13.string().optional(),
-  code: z13.string().optional(),
-  description: z13.string().optional(),
-  status: z13.enum(["draft", "active"]).optional()
+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()
 });
 
+// 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()
+});
+var authSuccessEventSchema = z16.object({
+  type: z16.literal("AUTH_SUCCESS")
+});
+var authErrorEventSchema = z16.object({
+  type: z16.literal("AUTH_ERROR"),
+  message: z16.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 showOnboardingOverlayEventSchema = z16.object({
+  type: z16.literal("SHOW_ONBOARDING_OVERLAY")
+});
+var showSettingsOverlayEventSchema = z16.object({
+  type: z16.literal("SHOW_SETTINGS_OVERLAY")
+});
+var onboardingSuccessSchema = z16.object({
+  type: z16.literal("ONBOARDING_SUCCESS")
+});
+var navigateToUsageSchema = z16.object({
+  type: z16.literal("NAVIGATE_TO_USAGE")
+});
+var cloudEventSchema = z16.discriminatedUnion("type", [
+  appRouteChangeEventSchema,
+  authSuccessEventSchema,
+  authErrorEventSchema,
+  mcpConnectionStatusEventSchema,
+  showOnboardingOverlayEventSchema,
+  showSettingsOverlayEventSchema,
+  onboardingSuccessSchema,
+  navigateToUsageSchema
+]);
+
+// node_modules/@insforge/shared-schemas/dist/docs.schema.js
+import { z as z17 } from "zod";
+var docTypeSchema = z17.enum([
+  "instructions",
+  "db-sdk",
+  "storage-sdk",
+  "functions-sdk",
+  "ai-integration-sdk",
+  "auth-components-react",
+  "real-time"
+]).describe(`
+    Documentation type: 
+      "instructions" (essential backend setup - use FIRST),
+      "db-sdk" (database operations),
+      "storage-sdk" (file storage),
+      "functions-sdk" (edge functions),
+      "auth-components-react" (authentication components for React+Vite applications),
+      "ai-integration-sdk" (AI features),
+      "real-time" (real-time pub/sub through WebSockets)
+    `);
+
 // src/shared/tools.ts
 import FormData from "form-data";
 var execAsync = promisify(exec);
@@ -890,9 +1191,7 @@ ${context}`
     "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.',
     {
-      docType: z14.enum(["instructions", "db-sdk", "storage-sdk", "functions-sdk", "ai-integration-sdk", "auth-components-react"]).describe(
-        'Documentation type: "instructions" (essential backend setup - use FIRST), "db-sdk" (database operations), "storage-sdk" (file storage), "functions-sdk" (edge functions), "ai-integration-sdk" (AI features), "auth-components-react" (authentication components for React+Vite applications).'
-      )
+      docType: docTypeSchema
     },
     withUsageTracking("fetch-docs", async ({ docType }) => {
       try {
@@ -925,7 +1224,7 @@ ${context}`
     "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: z14.string().optional().describe("API key for authentication (optional if provided via --api_key)")
+      apiKey: z18.string().optional().describe("API key for authentication (optional if provided via --api_key)")
     },
     withUsageTracking("get-anon-key", async ({ apiKey }) => {
       try {
@@ -964,8 +1263,8 @@ ${context}`
     "get-table-schema",
     "Returns the detailed schema(including RLS, indexes, constraints, etc.) of a specific table",
     {
-      apiKey: z14.string().optional().describe("API key for authentication (optional if provided via --api_key)"),
-      tableName: z14.string().describe("Name of the table")
+      apiKey: z18.string().optional().describe("API key for authentication (optional if provided via --api_key)"),
+      tableName: z18.string().describe("Name of the table")
     },
     withUsageTracking("get-table-schema", async ({ apiKey, tableName }) => {
       try {
@@ -1003,7 +1302,7 @@ ${context}`
     "get-backend-metadata",
     "Index all backend metadata",
     {
-      apiKey: z14.string().optional().describe("API key for authentication (optional if provided via --api_key)")
+      apiKey: z18.string().optional().describe("API key for authentication (optional if provided via --api_key)")
     },
     withUsageTracking("get-backend-metadata", async ({ apiKey }) => {
       try {
@@ -1043,7 +1342,7 @@ ${JSON.stringify(metadata, null, 2)}`
     "run-raw-sql",
     "Execute raw SQL query with optional parameters. Admin access required. Use with caution as it can modify data directly.",
     {
-      apiKey: z14.string().optional().describe("API key for authentication (optional if provided via --api_key)"),
+      apiKey: z18.string().optional().describe("API key for authentication (optional if provided via --api_key)"),
       ...rawSQLRequestSchema.shape
     },
     withUsageTracking("run-raw-sql", async ({ apiKey, query, params }) => {
@@ -1088,8 +1387,8 @@ ${JSON.stringify(metadata, null, 2)}`
     "download-template",
     "CRITICAL: MANDATORY FIRST STEP for all new InsForge projects. Download pre-configured starter template (React) to a temporary directory. After download, you MUST copy files to current directory using the provided command.",
     {
-      frame: z14.enum(["react"]).describe("Framework to use for the template (currently only React is supported)"),
-      projectName: z14.string().optional().describe('Name for the project directory (optional, defaults to "insforge-react")')
+      frame: z18.enum(["react"]).describe("Framework to use for the template (currently only React is supported)"),
+      projectName: z18.string().optional().describe('Name for the project directory (optional, defaults to "insforge-react")')
     },
     withUsageTracking("download-template", async ({ frame, projectName }) => {
       try {
@@ -1164,9 +1463,9 @@ To: Your current project directory
     "bulk-upsert",
     "Bulk insert or update data from CSV or JSON file. Supports upsert operations with a unique key.",
     {
-      apiKey: z14.string().optional().describe("API key for authentication (optional if provided via --api_key)"),
+      apiKey: z18.string().optional().describe("API key for authentication (optional if provided via --api_key)"),
       ...bulkUpsertRequestSchema.shape,
-      filePath: z14.string().describe("Path to CSV or JSON file containing data to import")
+      filePath: z18.string().describe("Path to CSV or JSON file containing data to import")
     },
     withUsageTracking("bulk-upsert", async ({ apiKey, table, filePath, upsertKey }) => {
       try {
@@ -1221,7 +1520,7 @@ To: Your current project directory
     "create-bucket",
     "Create new storage bucket",
     {
-      apiKey: z14.string().optional().describe("API key for authentication (optional if provided via --api_key)"),
+      apiKey: z18.string().optional().describe("API key for authentication (optional if provided via --api_key)"),
       ...createBucketRequestSchema.shape
     },
     withUsageTracking("create-bucket", async ({ apiKey, bucketName, isPublic }) => {
@@ -1297,8 +1596,8 @@ To: Your current project directory
     "delete-bucket",
     "Deletes a storage bucket",
     {
-      apiKey: z14.string().optional().describe("API key for authentication (optional if provided via --api_key)"),
-      bucketName: z14.string().describe("Name of the bucket to delete")
+      apiKey: z18.string().optional().describe("API key for authentication (optional if provided via --api_key)"),
+      bucketName: z18.string().describe("Name of the bucket to delete")
     },
     withUsageTracking("delete-bucket", async ({ apiKey, bucketName }) => {
       try {
@@ -1337,7 +1636,7 @@ To: Your current project directory
     "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: z14.string().describe(
+      codeFile: z18.string().describe(
         "Path to JavaScript file containing the function code. Must export: module.exports = async function(request) { return new Response(...) }"
       )
     },
@@ -1395,7 +1694,7 @@ To: Your current project directory
     "get-function",
     "Get details of a specific edge function including its code",
     {
-      slug: z14.string().describe("The slug identifier of the function")
+      slug: z18.string().describe("The slug identifier of the function")
     },
     withUsageTracking("get-function", async (args) => {
       try {
@@ -1432,9 +1731,9 @@ To: Your current project directory
     "update-function",
     "Update an existing edge function code or metadata",
     {
-      slug: z14.string().describe("The slug identifier of the function to update"),
+      slug: z18.string().describe("The slug identifier of the function to update"),
       ...functionUpdateRequestSchema.omit({ code: true }).shape,
-      codeFile: z14.string().optional().describe(
+      codeFile: z18.string().optional().describe(
         "Path to JavaScript file containing the new function code. Must export: module.exports = async function(request) { return new Response(...) }"
       )
     },
@@ -1498,7 +1797,7 @@ To: Your current project directory
     "delete-function",
     "Delete an edge function permanently",
     {
-      slug: z14.string().describe("The slug identifier of the function to delete")
+      slug: z18.string().describe("The slug identifier of the function to delete")
     },
     withUsageTracking("delete-function", async (args) => {
       try {
@@ -1535,9 +1834,9 @@ To: Your current project directory
     "get-container-logs",
     "Get latest logs from a specific container/service. Use this to help debug problems with your app.",
     {
-      apiKey: z14.string().optional().describe("API key for authentication (optional if provided via --api_key)"),
-      source: z14.enum(["insforge.logs", "postgREST.logs", "postgres.logs", "function.logs"]).describe("Log source to retrieve"),
-      limit: z14.number().optional().default(20).describe("Number of logs to return (default: 20)")
+      apiKey: z18.string().optional().describe("API key for authentication (optional if provided via --api_key)"),
+      source: z18.enum(["insforge.logs", "postgREST.logs", "postgres.logs", "function.logs"]).describe("Log source to retrieve"),
+      limit: z18.number().optional().default(20).describe("Number of logs to return (default: 20)")
     },
     withUsageTracking("get-container-logs", async ({ apiKey, source, limit }) => {
       try {

package/dist/http-server.js

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

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   registerInsforgeTools
-} from "./chunk-MRGODXOM.js";
+} from "./chunk-FCDI74JO.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.1",
+  "version": "1.2.2-dev.2",
   "description": "MCP (Model Context Protocol) server for Insforge backend-as-a-service",
   "mcpName": "io.github.InsForge/insforge-mcp",
   "type": "module",
@@ -36,7 +36,7 @@
     "server.json"
   ],
   "dependencies": {
-    "@insforge/shared-schemas": "^1.1.7",
+    "@insforge/shared-schemas": "^1.1.28",
     "@modelcontextprotocol/sdk": "^1.15.1",
     "@types/express": "^5.0.3",
     "commander": "^14.0.0",

package/LICENSE.md

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Support. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2024 Insforge
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.