@insforge/mcp 1.2.5-dev.0 → 1.2.6-dev.0

package/dist/chunk-EXDCZC7E.js

@@ -1,1836 +0,0 @@
-#!/usr/bin/env node
-
-// src/shared/tools.ts
-import { z as z19 } from "zod";
-import fetch2 from "node-fetch";
-import { promises as fs } from "fs";
-import { exec } from "child_process";
-import { promisify } from "util";
-
-// src/shared/response-handler.ts
-async function handleApiResponse(response) {
-  const responseData = await response.json();
-  if (!response.ok) {
-    const errorData = responseData;
-    let fullMessage = errorData.message || errorData.error || "Unknown error";
-    if (errorData.nextAction) {
-      fullMessage += `. ${errorData.nextAction}`;
-    }
-    throw new Error(fullMessage);
-  }
-  return responseData;
-}
-function formatSuccessMessage(operation, data) {
-  if (data && typeof data === "object" && "message" in data) {
-    return `${data.message}
-${JSON.stringify(data, null, 2)}`;
-  }
-  return `${operation} completed successfully:
-${JSON.stringify(data, null, 2)}`;
-}
-
-// src/shared/usage-tracker.ts
-import fetch from "node-fetch";
-var UsageTracker = class {
-  apiBaseUrl;
-  apiKey;
-  constructor(apiBaseUrl, apiKey) {
-    this.apiBaseUrl = apiBaseUrl;
-    this.apiKey = apiKey;
-  }
-  async trackUsage(toolName, success = true) {
-    if (!this.apiKey) {
-      return;
-    }
-    try {
-      const payload = {
-        tool_name: toolName,
-        success,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      await fetch(`${this.apiBaseUrl}/api/usage/mcp`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "x-api-key": this.apiKey
-        },
-        body: JSON.stringify(payload)
-      });
-    } catch (error) {
-      console.error("Failed to track usage:", error);
-    }
-  }
-};
-
-// node_modules/@insforge/shared-schemas/dist/database.schema.js
-import { z } from "zod";
-var ColumnType;
-(function(ColumnType2) {
-  ColumnType2["STRING"] = "string";
-  ColumnType2["DATE"] = "date";
-  ColumnType2["DATETIME"] = "datetime";
-  ColumnType2["INTEGER"] = "integer";
-  ColumnType2["FLOAT"] = "float";
-  ColumnType2["BOOLEAN"] = "boolean";
-  ColumnType2["UUID"] = "uuid";
-  ColumnType2["JSON"] = "json";
-})(ColumnType || (ColumnType = {}));
-var onUpdateActionSchema = z.enum(["CASCADE", "RESTRICT", "NO ACTION"]);
-var onDeleteActionSchema = z.enum([
-  "CASCADE",
-  "SET NULL",
-  "SET DEFAULT",
-  "RESTRICT",
-  "NO ACTION"
-]);
-var columnTypeSchema = z.enum([
-  ColumnType.STRING,
-  ColumnType.DATE,
-  ColumnType.DATETIME,
-  ColumnType.INTEGER,
-  ColumnType.FLOAT,
-  ColumnType.BOOLEAN,
-  ColumnType.UUID,
-  ColumnType.JSON
-]);
-var foreignKeySchema = z.object({
-  referenceTable: z.string().min(1, "Target table cannot be empty"),
-  referenceColumn: z.string().min(1, "Target column cannot be empty"),
-  onDelete: onDeleteActionSchema,
-  onUpdate: onUpdateActionSchema
-});
-var columnSchema = z.object({
-  columnName: z.string().min(1, "Column name cannot be empty").max(64, "Column name must be less than 64 characters"),
-  type: z.union([columnTypeSchema, z.string()]),
-  defaultValue: z.string().optional(),
-  isPrimaryKey: z.boolean().optional(),
-  isNullable: z.boolean(),
-  isUnique: z.boolean(),
-  foreignKey: foreignKeySchema.optional()
-});
-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().optional(),
-  createdAt: z.string().optional(),
-  updatedAt: z.string().optional()
-});
-var databaseFunctionSchema = z.object({
-  functionName: z.string(),
-  functionDef: z.string(),
-  kind: z.string()
-});
-var databaseIndexSchema = z.object({
-  tableName: z.string(),
-  indexName: z.string(),
-  indexDef: z.string(),
-  isUnique: z.boolean().nullable(),
-  isPrimary: z.boolean().nullable()
-});
-var databasePolicySchema = z.object({
-  tableName: z.string(),
-  policyName: z.string(),
-  cmd: z.string(),
-  roles: z.array(z.string()),
-  qual: z.string().nullable(),
-  withCheck: z.string().nullable()
-});
-var databaseTriggerSchema = z.object({
-  tableName: z.string(),
-  triggerName: z.string(),
-  actionTiming: z.string(),
-  eventManipulation: z.string(),
-  actionOrientation: z.string(),
-  actionCondition: z.string().nullable(),
-  actionStatement: z.string()
-});
-
-// node_modules/@insforge/shared-schemas/dist/database-api.schema.js
-import { z as z2 } from "zod";
-var createTableRequestSchema = tableSchema.pick({
-  tableName: true,
-  columns: true
-}).extend({
-  rlsEnabled: z2.boolean().default(true)
-});
-var createTableResponseSchema = tableSchema.pick({
-  tableName: true,
-  columns: true
-}).extend({
-  message: z2.string(),
-  autoFields: z2.array(z2.string()),
-  nextActions: z2.string()
-});
-var updateTableSchemaRequestSchema = z2.object({
-  addColumns: z2.array(columnSchema.omit({
-    foreignKey: true
-  })).optional(),
-  dropColumns: z2.array(z2.string()).optional(),
-  updateColumns: z2.array(z2.object({
-    columnName: z2.string(),
-    defaultValue: z2.string().optional(),
-    newColumnName: z2.string().min(1, "New column name cannot be empty").max(64, "New column name must be less than 64 characters").optional()
-  })).optional(),
-  addForeignKeys: z2.array(z2.object({
-    columnName: z2.string().min(1, "Column name is required for adding foreign key"),
-    foreignKey: foreignKeySchema
-  })).optional(),
-  dropForeignKeys: z2.array(z2.string()).optional(),
-  renameTable: z2.object({
-    newTableName: z2.string().min(1, "New table name cannot be empty").max(64, "New table name must be less than 64 characters")
-  }).optional()
-});
-var updateTableSchemaResponse = z2.object({
-  message: z2.string(),
-  tableName: z2.string(),
-  operations: z2.array(z2.string())
-});
-var deleteTableResponse = z2.object({
-  message: z2.string(),
-  tableName: z2.string(),
-  nextActions: z2.string()
-});
-var rawSQLRequestSchema = z2.object({
-  query: z2.string().min(1, "Query is required"),
-  params: z2.array(z2.unknown()).optional()
-});
-var rawSQLResponseSchema = z2.object({
-  rows: z2.array(z2.record(z2.string(), z2.unknown())),
-  rowCount: z2.number().nullable(),
-  fields: z2.array(z2.object({
-    name: z2.string(),
-    dataTypeID: z2.number()
-  })).optional()
-});
-var exportRequestSchema = z2.object({
-  tables: z2.array(z2.string()).optional(),
-  format: z2.enum(["sql", "json"]).default("sql"),
-  includeData: z2.boolean().default(true),
-  includeFunctions: z2.boolean().default(false),
-  includeSequences: z2.boolean().default(false),
-  includeViews: z2.boolean().default(false),
-  rowLimit: z2.number().int().positive().max(1e4).default(1e3)
-});
-var exportJsonDataSchema = z2.object({
-  timestamp: z2.string(),
-  tables: z2.record(z2.string(), z2.object({
-    schema: z2.array(z2.object({
-      columnName: z2.string(),
-      dataType: z2.string(),
-      characterMaximumLength: z2.number().nullable(),
-      isNullable: z2.string(),
-      columnDefault: z2.string().nullable()
-    })),
-    indexes: z2.array(z2.object({
-      indexname: z2.string(),
-      indexdef: z2.string(),
-      isUnique: z2.boolean().nullable(),
-      isPrimary: z2.boolean().nullable()
-    })),
-    foreignKeys: z2.array(z2.object({
-      constraintName: z2.string(),
-      columnName: z2.string(),
-      foreignTableName: z2.string(),
-      foreignColumnName: z2.string(),
-      deleteRule: z2.string().nullable(),
-      updateRule: z2.string().nullable()
-    })),
-    rlsEnabled: z2.boolean().optional(),
-    policies: z2.array(z2.object({
-      policyname: z2.string(),
-      cmd: z2.string(),
-      roles: z2.array(z2.string()),
-      qual: z2.string().nullable(),
-      withCheck: z2.string().nullable()
-    })),
-    triggers: z2.array(z2.object({
-      triggerName: z2.string(),
-      actionTiming: z2.string(),
-      eventManipulation: z2.string(),
-      actionOrientation: z2.string(),
-      actionCondition: z2.string().nullable(),
-      actionStatement: z2.string(),
-      newTable: z2.string().nullable(),
-      oldTable: z2.string().nullable()
-    })),
-    rows: z2.array(z2.record(z2.string(), z2.unknown())).optional(),
-    recordCount: z2.number().optional()
-  })),
-  functions: z2.array(z2.object({
-    functionName: z2.string(),
-    functionDef: z2.string(),
-    kind: z2.string()
-  })),
-  sequences: z2.array(z2.object({
-    sequenceName: z2.string(),
-    startValue: z2.string(),
-    increment: z2.string(),
-    minValue: z2.string().nullable(),
-    maxValue: z2.string().nullable(),
-    cycle: z2.string()
-  })),
-  views: z2.array(z2.object({
-    viewName: z2.string(),
-    definition: z2.string()
-  }))
-});
-var exportResponseSchema = z2.object({
-  format: z2.enum(["sql", "json"]),
-  data: z2.union([z2.string(), exportJsonDataSchema]),
-  timestamp: z2.string()
-});
-var importRequestSchema = z2.object({
-  truncate: z2.union([
-    z2.boolean(),
-    z2.string().transform((val) => {
-      if (val === "true")
-        return true;
-      if (val === "false")
-        return false;
-      throw new Error("Invalid boolean string");
-    })
-  ]).default(false)
-});
-var importResponseSchema = z2.object({
-  success: z2.boolean(),
-  message: z2.string(),
-  filename: z2.string(),
-  tables: z2.array(z2.string()),
-  rowsImported: z2.number(),
-  fileSize: z2.number()
-});
-var bulkUpsertRequestSchema = z2.object({
-  table: z2.string().min(1, "Table name is required"),
-  upsertKey: z2.string().optional()
-  // Note: File handling is done at the API layer via multipart/form-data
-});
-var bulkUpsertResponseSchema = z2.object({
-  success: z2.boolean(),
-  message: z2.string(),
-  table: z2.string(),
-  rowsAffected: z2.number(),
-  totalRecords: z2.number(),
-  filename: z2.string()
-});
-var databaseFunctionsResponseSchema = z2.object({
-  functions: z2.array(databaseFunctionSchema)
-});
-var databaseIndexesResponseSchema = z2.object({
-  indexes: z2.array(databaseIndexSchema)
-});
-var databasePoliciesResponseSchema = z2.object({
-  policies: z2.array(databasePolicySchema)
-});
-var databaseTriggersResponseSchema = z2.object({
-  triggers: z2.array(databaseTriggerSchema)
-});
-
-// node_modules/@insforge/shared-schemas/dist/storage.schema.js
-import { z as z3 } from "zod";
-var storageFileSchema = z3.object({
-  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()
-});
-
-// node_modules/@insforge/shared-schemas/dist/storage-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 uploadStrategyResponseSchema = z4.object({
-  method: z4.enum(["presigned", "direct"]),
-  uploadUrl: z4.string(),
-  fields: z4.record(z4.string()).optional(),
-  key: z4.string(),
-  confirmRequired: z4.boolean(),
-  confirmUrl: z4.string().optional(),
-  expiresAt: z4.date().optional()
-});
-var downloadStrategyRequestSchema = z4.object({
-  expiresIn: z4.number().optional().default(3600)
-});
-var downloadStrategyResponseSchema = z4.object({
-  method: z4.enum(["presigned", "direct"]),
-  url: z4.string(),
-  expiresAt: z4.date().optional(),
-  headers: z4.record(z4.string()).optional()
-});
-var confirmUploadRequestSchema = z4.object({
-  size: z4.number(),
-  contentType: z4.string().optional(),
-  etag: z4.string().optional()
-});
-
-// node_modules/@insforge/shared-schemas/dist/auth.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 profileSchema = z5.object({
-  name: z5.string().optional(),
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  avatar_url: z5.string().url().optional()
-}).passthrough();
-var userSchema = z5.object({
-  id: userIdSchema,
-  email: emailSchema,
-  emailVerified: z5.boolean(),
-  providers: z5.array(z5.string()).optional(),
-  createdAt: z5.string(),
-  // PostgreSQL timestamp
-  updatedAt: z5.string(),
-  // PostgreSQL timestamp
-  profile: profileSchema.nullable(),
-  // User profile data (name, avatar_url, bio, etc.)
-  metadata: z5.record(z5.unknown()).nullable()
-  // System metadata (device ID, login IP, etc.)
-});
-var oAuthProvidersSchema = z5.enum([
-  "google",
-  "github",
-  "discord",
-  "linkedin",
-  "facebook",
-  "instagram",
-  "tiktok",
-  "apple",
-  "x",
-  "spotify",
-  "microsoft"
-]);
-var oAuthStateSchema = z5.object({
-  provider: oAuthProvidersSchema,
-  redirectUri: z5.string().url().optional()
-});
-var oAuthConfigSchema = z5.object({
-  id: z5.string().uuid(),
-  provider: oAuthProvidersSchema,
-  clientId: z5.string().optional(),
-  scopes: z5.array(z5.string()).optional(),
-  redirectUri: z5.string().optional(),
-  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,
-  // Subject (user ID)
-  email: emailSchema,
-  role: roleSchema,
-  iat: z5.number().optional(),
-  // Issued at
-  exp: z5.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()
-});
-var createUserRequestSchema = z6.object({
-  email: emailSchema,
-  password: passwordSchema,
-  name: nameSchema.optional()
-});
-var createSessionRequestSchema = z6.object({
-  email: emailSchema,
-  password: passwordSchema
-});
-var exchangeAdminSessionRequestSchema = z6.object({
-  code: z6.string()
-});
-var listUsersRequestSchema = paginationSchema.extend({
-  search: z6.string().optional()
-}).optional();
-var deleteUsersRequestSchema = z6.object({
-  userIds: z6.array(userIdSchema).min(1, "At least one user ID is required")
-});
-var updateProfileRequestSchema = z6.object({
-  profile: z6.record(z6.unknown())
-});
-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(),
-  csrfToken: z6.string().nullable().optional()
-});
-var createSessionResponseSchema = z6.object({
-  user: userSchema,
-  accessToken: z6.string(),
-  redirectTo: z6.string().url().optional(),
-  csrfToken: z6.string().nullable().optional()
-});
-var verifyEmailResponseSchema = z6.object({
-  user: userSchema,
-  accessToken: z6.string(),
-  redirectTo: z6.string().url().optional(),
-  csrfToken: z6.string().nullable().optional()
-});
-var refreshSessionResponseSchema = z6.object({
-  accessToken: z6.string(),
-  user: userSchema,
-  csrfToken: z6.string()
-});
-var exchangeResetPasswordTokenResponseSchema = z6.object({
-  token: z6.string(),
-  expiresAt: z6.string().datetime()
-});
-var resetPasswordResponseSchema = z6.object({
-  message: z6.string()
-});
-var getCurrentSessionResponseSchema = z6.object({
-  user: userSchema
-});
-var getProfileResponseSchema = z6.object({
-  id: userIdSchema,
-  profile: profileSchema.nullable()
-});
-var listUsersResponseSchema = z6.object({
-  data: z6.array(userSchema),
-  pagination: z6.object({
-    offset: z6.number(),
-    limit: z6.number(),
-    total: z6.number()
-  })
-});
-var deleteUsersResponseSchema = z6.object({
-  message: z6.string(),
-  deletedCount: z6.number().int().nonnegative()
-});
-var getOauthUrlResponseSchema = z6.object({
-  authUrl: z6.string().url()
-});
-var createOAuthConfigRequestSchema = oAuthConfigSchema.omit({
-  id: true,
-  createdAt: true,
-  updatedAt: true
-}).extend({
-  clientSecret: z6.string().optional()
-});
-var updateOAuthConfigRequestSchema = oAuthConfigSchema.omit({
-  id: true,
-  provider: true,
-  createdAt: true,
-  updatedAt: true
-}).extend({
-  clientSecret: z6.string().optional()
-}).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(),
-  statusCode: z6.number().int(),
-  nextActions: z6.string().optional()
-});
-
-// 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 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 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)
-  })
-});
-
-// 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()
-  })),
-  totalSizeInGB: z9.number(),
-  hint: z9.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()
-  }))
-});
-var realtimeMetadataSchema = z9.object({
-  channels: z9.array(realtimeChannelSchema),
-  permissions: realtimePermissionsResponseSchema
-});
-var appMetaDataSchema = z9.object({
-  auth: authMetadataSchema,
-  database: databaseMetadataSchema,
-  storage: storageMetadataSchema,
-  aiIntegration: aiMetadataSchema.optional(),
-  functions: z9.array(edgeFunctionMetadataSchema),
-  realtime: realtimeMetadataSchema.optional(),
-  version: z9.string().optional()
-});
-
-// node_modules/@insforge/shared-schemas/dist/ai.schema.js
-import { z as z10 } from "zod";
-var modalitySchema = z10.enum(["text", "image"]);
-var aiConfigurationInputSchema = z10.object({
-  inputModality: z10.array(modalitySchema).min(1),
-  outputModality: z10.array(modalitySchema).min(1),
-  provider: z10.string(),
-  modelId: z10.string(),
-  systemPrompt: z10.string().optional()
-});
-var aiConfigurationSchema = aiConfigurationInputSchema.extend({
-  id: z10.string().uuid()
-});
-var aiConfigurationWithUsageSchema = aiConfigurationSchema.extend({
-  usageStats: z10.object({
-    totalInputTokens: z10.number(),
-    totalOutputTokens: z10.number(),
-    totalTokens: z10.number(),
-    totalImageCount: z10.number(),
-    totalRequests: z10.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 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()
-});
-
-// 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()
-});
-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 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 = z11.object({
-  model: z11.string(),
-  prompt: z11.string(),
-  images: z11.array(z11.object({
-    url: z11.string()
-  })).optional()
-});
-var imageGenerationResponseSchema = z11.object({
-  text: z11.string().optional(),
-  images: z11.array(z11.object({
-    type: z11.literal("imageUrl"),
-    imageUrl: 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 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 = z11.object({
-  systemPrompt: z11.string().nullable()
-});
-var listAIUsageResponseSchema = z11.object({
-  records: z11.array(aiUsageRecordSchema),
-  total: z11.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 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 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 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 = z13.object({
-  days: z13.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 clearAuditLogsRequestSchema = z13.object({
-  daysToKeep: z13.number().default(90)
-});
-var clearAuditLogsResponseSchema = z13.object({
-  message: z13.string(),
-  deleted: z13.number()
-});
-var getLogsResponseSchema = z13.object({
-  logs: z13.array(logSchema),
-  total: z13.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()
-});
-
-// 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()
-});
-
-// 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",
-  "auth-sdk",
-  "db-sdk",
-  "storage-sdk",
-  "functions-sdk",
-  "ai-integration-sdk",
-  "auth-components-react",
-  "auth-components-nextjs",
-  "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),
-      "auth-components-nextjs" (authentication components for Next.js applications),
-      "ai-integration-sdk" (AI features),
-      "real-time" (real-time pub/sub through WebSockets)
-    `);
-
-// node_modules/@insforge/shared-schemas/dist/email-api.schema.js
-import { z as z18 } from "zod";
-var emailOrEmails = z18.union([
-  emailSchema,
-  z18.array(emailSchema).min(1, "At least one email is required").max(50, "Maximum 50 recipients allowed")
-]);
-var sendRawEmailRequestSchema = z18.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"),
-  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()
-});
-var sendEmailResponseSchema = z18.object({});
-
-// src/shared/tools.ts
-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"
-};
-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;
-    }
-    return 0;
-  }
-  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"}`);
-    }
-  }
-  async function trackToolUsage(toolName, success = true) {
-    if (GLOBAL_API_KEY) {
-      await usageTracker.trackUsage(toolName, success);
-    }
-  }
-  function withUsageTracking(toolName, handler) {
-    return async (...args) => {
-      try {
-        const result = await handler(...args);
-        await trackToolUsage(toolName, true);
-        return result;
-      } catch (error) {
-        await trackToolUsage(toolName, false);
-        throw error;
-      }
-    };
-  }
-  const getApiKey = (_toolApiKey) => {
-    if (!GLOBAL_API_KEY) {
-      throw new Error("API key is required. Pass --api_key when starting the MCP server.");
-    }
-    return GLOBAL_API_KEY;
-  };
-  const fetchDocumentation = async (docType) => {
-    try {
-      const response = await fetch2(`${API_BASE_URL}/api/docs/${docType}`, {
-        method: "GET",
-        headers: {
-          "Content-Type": "application/json"
-        }
-      });
-      if (response.status === 404) {
-        throw new Error("Documentation not found. This feature may not be supported in your project version. Please contact the Insforge team for assistance.");
-      }
-      const result = await handleApiResponse(response);
-      if (result && typeof result === "object" && "content" in result) {
-        let content = result.content;
-        content = content.replace(/http:\/\/localhost:7130/g, API_BASE_URL);
-        content = content.replace(/https:\/\/your-app\.region\.insforge\.app/g, API_BASE_URL);
-        return content;
-      }
-      throw new Error("Invalid response format from documentation endpoint");
-    } catch (error) {
-      const errMsg = error instanceof Error ? error.message : "Unknown error occurred";
-      throw new Error(`Unable to retrieve ${docType} documentation: ${errMsg}`);
-    }
-  };
-  const fetchInsforgeInstructionsContext = async () => {
-    try {
-      return await fetchDocumentation("instructions");
-    } catch (error) {
-      console.error("Failed to fetch insforge-instructions.md:", error);
-      return null;
-    }
-  };
-  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: `
-
----
-\u{1F527} INSFORGE DEVELOPMENT RULES (Auto-loaded):
-${context}`
-          });
-        }
-      }
-    } catch {
-      console.warn("Could not determine backend version, skipping background context");
-    }
-    return response;
-  };
-  server.tool(
-    "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: docTypeSchema
-    },
-    withUsageTracking("fetch-docs", async ({ docType }) => {
-      try {
-        const content = await fetchDocumentation(docType);
-        return await addBackgroundContext({
-          content: [
-            {
-              type: "text",
-              text: content
-            }
-          ]
-        });
-      } catch (error) {
-        const errMsg = error instanceof Error ? error.message : "Unknown error occurred";
-        if (errMsg.includes("404") || errMsg.toLowerCase().includes("not found")) {
-          return {
-            content: [{
-              type: "text",
-              text: `Documentation for "${docType}" is not available. This is likely because your backend version is too old and doesn't support this documentation endpoint yet. This won't affect the functionality of the tools - they will still work correctly.`
-            }]
-          };
-        }
-        return {
-          content: [{ type: "text", text: `Error fetching ${docType} documentation: ${errMsg}` }]
-        };
-      }
-    })
-  );
-  server.tool(
-    "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)")
-    },
-    withUsageTracking("get-anon-key", async ({ apiKey }) => {
-      try {
-        const actualApiKey = getApiKey(apiKey);
-        const response = await fetch2(`${API_BASE_URL}/api/auth/tokens/anon`, {
-          method: "POST",
-          headers: {
-            "x-api-key": actualApiKey,
-            "Content-Type": "application/json"
-          }
-        });
-        const result = await handleApiResponse(response);
-        return await addBackgroundContext({
-          content: [
-            {
-              type: "text",
-              text: formatSuccessMessage("Anonymous token generated", result)
-            }
-          ]
-        });
-      } catch (error) {
-        const errMsg = error instanceof Error ? error.message : "Unknown error occurred";
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error generating anonymous token: ${errMsg}`
-            }
-          ],
-          isError: true
-        };
-      }
-    })
-  );
-  server.tool(
-    "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")
-    },
-    withUsageTracking("get-table-schema", async ({ apiKey, tableName }) => {
-      try {
-        const actualApiKey = getApiKey(apiKey);
-        const response = await fetch2(`${API_BASE_URL}/api/metadata/${tableName}`, {
-          method: "GET",
-          headers: {
-            "x-api-key": actualApiKey
-          }
-        });
-        const result = await handleApiResponse(response);
-        return await addBackgroundContext({
-          content: [
-            {
-              type: "text",
-              text: formatSuccessMessage("Schema retrieved", result)
-            }
-          ]
-        });
-      } catch (error) {
-        const errMsg = error instanceof Error ? error.message : "Unknown error occurred";
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error getting table schema: ${errMsg}`
-            }
-          ],
-          isError: true
-        };
-      }
-    })
-  );
-  server.tool(
-    "get-backend-metadata",
-    "Index all backend metadata",
-    {
-      apiKey: z19.string().optional().describe("API key for authentication (optional if provided via --api_key)")
-    },
-    withUsageTracking("get-backend-metadata", async ({ apiKey }) => {
-      try {
-        const actualApiKey = getApiKey(apiKey);
-        const response = await fetch2(`${API_BASE_URL}/api/metadata?mcp=true`, {
-          method: "GET",
-          headers: {
-            "x-api-key": actualApiKey
-          }
-        });
-        const metadata = await handleApiResponse(response);
-        return await addBackgroundContext({
-          content: [
-            {
-              type: "text",
-              text: `Backend metadata:
-
-${JSON.stringify(metadata, null, 2)}`
-            }
-          ]
-        });
-      } catch (error) {
-        const errMsg = error instanceof Error ? error.message : "Unknown error occurred";
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error retrieving backend metadata: ${errMsg}`
-            }
-          ],
-          isError: true
-        };
-      }
-    })
-  );
-  server.tool(
-    "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)"),
-      ...rawSQLRequestSchema.shape
-    },
-    withUsageTracking("run-raw-sql", async ({ apiKey, query, params }) => {
-      try {
-        const actualApiKey = getApiKey(apiKey);
-        const requestBody = {
-          query,
-          params: params || []
-        };
-        const response = await fetch2(`${API_BASE_URL}/api/database/advance/rawsql`, {
-          method: "POST",
-          headers: {
-            "x-api-key": actualApiKey,
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify(requestBody)
-        });
-        const result = await handleApiResponse(response);
-        return await addBackgroundContext({
-          content: [
-            {
-              type: "text",
-              text: formatSuccessMessage("SQL query executed", result)
-            }
-          ]
-        });
-      } catch (error) {
-        const errMsg = error instanceof Error ? error.message : "Unknown error occurred";
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error executing SQL query: ${errMsg}`
-            }
-          ],
-          isError: true
-        };
-      }
-    })
-  );
-  server.tool(
-    "create-bucket",
-    "Create new storage bucket",
-    {
-      apiKey: z19.string().optional().describe("API key for authentication (optional if provided via --api_key)"),
-      ...createBucketRequestSchema.shape
-    },
-    withUsageTracking("create-bucket", async ({ apiKey, bucketName, isPublic }) => {
-      try {
-        const actualApiKey = getApiKey(apiKey);
-        const response = await fetch2(`${API_BASE_URL}/api/storage/buckets`, {
-          method: "POST",
-          headers: {
-            "x-api-key": actualApiKey,
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({ bucketName, isPublic })
-        });
-        const result = await handleApiResponse(response);
-        return await addBackgroundContext({
-          content: [
-            {
-              type: "text",
-              text: formatSuccessMessage("Bucket created", result)
-            }
-          ]
-        });
-      } catch (error) {
-        const errMsg = error instanceof Error ? error.message : "Unknown error occurred";
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error creating bucket: ${errMsg}`
-            }
-          ],
-          isError: true
-        };
-      }
-    })
-  );
-  server.tool(
-    "list-buckets",
-    "Lists all storage buckets",
-    {},
-    withUsageTracking("list-buckets", async () => {
-      try {
-        const response = await fetch2(`${API_BASE_URL}/api/storage/buckets`, {
-          method: "GET",
-          headers: {
-            "x-api-key": getApiKey()
-          }
-        });
-        const result = await handleApiResponse(response);
-        return await addBackgroundContext({
-          content: [
-            {
-              type: "text",
-              text: formatSuccessMessage("Buckets retrieved", result)
-            }
-          ]
-        });
-      } catch (error) {
-        const errMsg = error instanceof Error ? error.message : "Unknown error occurred";
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error listing buckets: ${errMsg}`
-            }
-          ],
-          isError: true
-        };
-      }
-    })
-  );
-  server.tool(
-    "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")
-    },
-    withUsageTracking("delete-bucket", async ({ apiKey, bucketName }) => {
-      try {
-        const actualApiKey = getApiKey(apiKey);
-        const response = await fetch2(`${API_BASE_URL}/api/storage/buckets/${bucketName}`, {
-          method: "DELETE",
-          headers: {
-            "x-api-key": actualApiKey
-          }
-        });
-        const result = await handleApiResponse(response);
-        return await addBackgroundContext({
-          content: [
-            {
-              type: "text",
-              text: formatSuccessMessage("Bucket deleted", result)
-            }
-          ]
-        });
-      } catch (error) {
-        const errMsg = error instanceof Error ? error.message : "Unknown error occurred";
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error deleting bucket: ${errMsg}`
-            }
-          ],
-          isError: true
-        };
-      }
-    })
-  );
-  server.tool(
-    "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(
-        "Path to JavaScript file containing the function code. Must export: module.exports = async function(request) { return new Response(...) }"
-      )
-    },
-    withUsageTracking("create-function", async (args) => {
-      try {
-        let code;
-        try {
-          code = await fs.readFile(args.codeFile, "utf-8");
-        } catch (fileError) {
-          throw new Error(
-            `Failed to read code file '${args.codeFile}': ${fileError instanceof Error ? fileError.message : "Unknown error"}`
-          );
-        }
-        const response = await fetch2(`${API_BASE_URL}/api/functions`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            "x-api-key": getApiKey()
-          },
-          body: JSON.stringify({
-            slug: args.slug,
-            name: args.name,
-            code,
-            description: args.description,
-            status: args.status
-          })
-        });
-        const result = await handleApiResponse(response);
-        return await addBackgroundContext({
-          content: [
-            {
-              type: "text",
-              text: formatSuccessMessage(
-                `Edge function '${args.slug}' created successfully from ${args.codeFile}`,
-                result
-              )
-            }
-          ]
-        });
-      } catch (error) {
-        const errMsg = error instanceof Error ? error.message : "Unknown error occurred";
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error creating function: ${errMsg}`
-            }
-          ],
-          isError: true
-        };
-      }
-    })
-  );
-  server.tool(
-    "get-function",
-    "Get details of a specific edge function including its code",
-    {
-      slug: z19.string().describe("The slug identifier of the function")
-    },
-    withUsageTracking("get-function", async (args) => {
-      try {
-        const response = await fetch2(`${API_BASE_URL}/api/functions/${args.slug}`, {
-          method: "GET",
-          headers: {
-            "x-api-key": getApiKey()
-          }
-        });
-        const result = await handleApiResponse(response);
-        return await addBackgroundContext({
-          content: [
-            {
-              type: "text",
-              text: formatSuccessMessage(`Edge function '${args.slug}' details`, result)
-            }
-          ]
-        });
-      } catch (error) {
-        const errMsg = error instanceof Error ? error.message : "Unknown error occurred";
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error getting function: ${errMsg}`
-            }
-          ],
-          isError: true
-        };
-      }
-    })
-  );
-  server.tool(
-    "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(
-        "Path to JavaScript file containing the new function code. Must export: module.exports = async function(request) { return new Response(...) }"
-      )
-    },
-    withUsageTracking("update-function", async (args) => {
-      try {
-        const updateData = {};
-        if (args.name) {
-          updateData.name = args.name;
-        }
-        if (args.codeFile) {
-          try {
-            updateData.code = await fs.readFile(args.codeFile, "utf-8");
-          } catch (fileError) {
-            throw new Error(
-              `Failed to read code file '${args.codeFile}': ${fileError instanceof Error ? fileError.message : "Unknown error"}`
-            );
-          }
-        }
-        if (args.description !== void 0) {
-          updateData.description = args.description;
-        }
-        if (args.status) {
-          updateData.status = args.status;
-        }
-        const response = await fetch2(`${API_BASE_URL}/api/functions/${args.slug}`, {
-          method: "PUT",
-          headers: {
-            "Content-Type": "application/json",
-            "x-api-key": getApiKey()
-          },
-          body: JSON.stringify(updateData)
-        });
-        const result = await handleApiResponse(response);
-        const fileInfo = args.codeFile ? ` from ${args.codeFile}` : "";
-        return await addBackgroundContext({
-          content: [
-            {
-              type: "text",
-              text: formatSuccessMessage(
-                `Edge function '${args.slug}' updated successfully${fileInfo}`,
-                result
-              )
-            }
-          ]
-        });
-      } catch (error) {
-        const errMsg = error instanceof Error ? error.message : "Unknown error occurred";
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error updating function: ${errMsg}`
-            }
-          ],
-          isError: true
-        };
-      }
-    })
-  );
-  server.tool(
-    "delete-function",
-    "Delete an edge function permanently",
-    {
-      slug: z19.string().describe("The slug identifier of the function to delete")
-    },
-    withUsageTracking("delete-function", async (args) => {
-      try {
-        const response = await fetch2(`${API_BASE_URL}/api/functions/${args.slug}`, {
-          method: "DELETE",
-          headers: {
-            "x-api-key": getApiKey()
-          }
-        });
-        const result = await handleApiResponse(response);
-        return await addBackgroundContext({
-          content: [
-            {
-              type: "text",
-              text: formatSuccessMessage(`Edge function '${args.slug}' deleted successfully`, result)
-            }
-          ]
-        });
-      } catch (error) {
-        const errMsg = error instanceof Error ? error.message : "Unknown error occurred";
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error deleting function: ${errMsg}`
-            }
-          ],
-          isError: true
-        };
-      }
-    })
-  );
-  server.tool(
-    "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)")
-    },
-    withUsageTracking("get-container-logs", async ({ apiKey, source, limit }) => {
-      try {
-        const actualApiKey = getApiKey(apiKey);
-        const queryParams = new URLSearchParams();
-        if (limit) queryParams.append("limit", limit.toString());
-        let response = await fetch2(`${API_BASE_URL}/api/logs/${source}?${queryParams}`, {
-          method: "GET",
-          headers: {
-            "x-api-key": actualApiKey
-          }
-        });
-        if (response.status === 404) {
-          response = await fetch2(`${API_BASE_URL}/api/logs/analytics/${source}?${queryParams}`, {
-            method: "GET",
-            headers: {
-              "x-api-key": actualApiKey
-            }
-          });
-        }
-        const result = await handleApiResponse(response);
-        return await addBackgroundContext({
-          content: [
-            {
-              type: "text",
-              text: formatSuccessMessage(`Latest logs from ${source}`, result)
-            }
-          ]
-        });
-      } catch (error) {
-        const errMsg = error instanceof Error ? error.message : "Unknown error occurred";
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error retrieving container logs: ${errMsg}`
-            }
-          ],
-          isError: true
-        };
-      }
-    })
-  );
-  return {
-    apiKey: GLOBAL_API_KEY,
-    apiBaseUrl: API_BASE_URL,
-    toolCount: 15
-  };
-}
-
-export {
-  registerInsforgeTools
-};