@muskanmeet/invoicing-design-system 0.1.0

package/.local/skills/artifacts/artifacts/automation/files/src/mastra/index.ts

@@ -0,0 +1,212 @@
+import { Mastra } from "@mastra/core";
+import { MastraError } from "@mastra/core/error";
+import { PinoLogger } from "@mastra/loggers";
+import { LogLevel, MastraLogger } from "@mastra/core/logger";
+import pino from "pino";
+import { NonRetriableError } from "inngest";
+import { z } from "zod";
+
+import { sharedPostgresStorage } from "./storage";
+import { inngest, inngestServe } from "./inngest";
+
+// ======================================================================
+// Option 1: FOR TIME-BASED (CRON) TRIGGERS
+// ======================================================================
+// Call registerCronTrigger() BEFORE the Mastra initialization below.
+//
+// Example:
+//   import { registerCronTrigger } from "../triggers/cronTriggers";
+//   import { myWorkflow } from "./workflows/myWorkflow";
+//
+//   registerCronTrigger({
+//     cronExpression: "0 8 * * *", // Daily at 8 AM
+//     workflow: myWorkflow
+//   });
+//
+// See src/triggers/cronTriggers.ts for details
+// ======================================================================
+// Option 2: FOR WEBHOOK-BASED TRIGGERS
+// ======================================================================
+// Spread trigger registration functions into this apiRoutes array.
+//
+// Pattern:
+//   import { registerYourTrigger } from "../triggers/yourTriggers";
+//   import { myWorkflow } from "./workflows/myWorkflow";
+//   import { inngest } from "./inngest";
+//
+//   ...registerYourTrigger({
+//     triggerType: "your/event.type",
+//     handler: async (mastra, triggerInfo, runId) => {
+//       // Extract what you need from the payload
+//       ...
+//
+//       // Create a run of the workflow unless one was provided
+//       if (!runId) {
+//         runId = (await myWorkflow.createRun()).runId;
+//       }
+//       // Start the workflow
+//       return await inngest.send({
+//         name: `workflow.${myWorkflow.id}`,
+//         data: {
+//           runId,
+//           inputData: {
+//             // Your input data here
+//           },
+//         },
+//       });
+//     }
+//   })
+//
+// Available: src/triggers/slackTriggers.ts, telegramTriggers.ts, exampleConnectorTrigger.ts
+// ======================================================================
+
+// ======================================================================
+// IMPORT YOUR AGENTS AND WORKFLOWS
+// ======================================================================
+// Import your custom agents and workflows here.
+// See src/examples/ directory for complete examples:
+// - src/examples/agent.ts
+// - src/examples/workflow.ts
+// - src/examples/exampleTool.ts
+//
+// Example imports:
+// import { myAgent } from "./agents/myAgent";
+// import { myWorkflow } from "./workflows/myWorkflow";
+// ======================================================================
+
+class ProductionPinoLogger extends MastraLogger {
+  protected logger: pino.Logger;
+
+  constructor(
+    options: {
+      name?: string;
+      level?: LogLevel;
+    } = {},
+  ) {
+    super(options);
+
+    this.logger = pino({
+      name: options.name || "app",
+      level: options.level || LogLevel.INFO,
+      base: {},
+      formatters: {
+        level: (label: string, _number: number) => ({
+          level: label,
+        }),
+      },
+      timestamp: () => `,"time":"${new Date(Date.now()).toISOString()}"`,
+    });
+  }
+
+  debug(message: string, args: Record<string, any> = {}): void {
+    this.logger.debug(args, message);
+  }
+
+  info(message: string, args: Record<string, any> = {}): void {
+    this.logger.info(args, message);
+  }
+
+  warn(message: string, args: Record<string, any> = {}): void {
+    this.logger.warn(args, message);
+  }
+
+  error(message: string, args: Record<string, any> = {}): void {
+    this.logger.error(args, message);
+  }
+}
+
+const serverPort = Number(process.env.PORT ?? "5000");
+
+export const mastra = new Mastra({
+  storage: sharedPostgresStorage,
+  // Register your workflows here
+  workflows: {},
+  // Register your agents here
+  agents: {},
+  bundler: {
+    // A few dependencies are not properly picked up by
+    // the bundler if they are not added directly to the
+    // entrypoint.
+    externals: [
+      "@slack/web-api",
+      "inngest",
+      "inngest/hono",
+      "hono",
+      "hono/streaming",
+    ],
+    // sourcemaps are good for debugging.
+    sourcemap: true,
+  },
+  server: {
+    host: "0.0.0.0",
+    port: serverPort,
+    middleware: [
+      async (c, next) => {
+        const mastra = c.get("mastra");
+        const logger = mastra?.getLogger();
+        logger?.debug("[Request]", { method: c.req.method, url: c.req.url });
+        try {
+          await next();
+        } catch (error) {
+          logger?.error("[Response]", {
+            method: c.req.method,
+            url: c.req.url,
+            error,
+          });
+          if (error instanceof MastraError) {
+            if (error.id === "AGENT_MEMORY_MISSING_RESOURCE_ID") {
+              // This is typically a non-retirable error. It means that the request was not
+              // setup correctly to pass in the necessary parameters.
+              throw new NonRetriableError(error.message, { cause: error });
+            }
+          } else if (error instanceof z.ZodError) {
+            // Validation errors are never retriable.
+            throw new NonRetriableError(error.message, { cause: error });
+          }
+
+          throw error;
+        }
+      },
+    ],
+    apiRoutes: [
+      // ======================================================================
+      // Inngest Integration Endpoint
+      // ======================================================================
+      // Integrates Mastra workflows with Inngest for event-driven execution via inngest functions.
+      {
+        path: "/api/inngest",
+        method: "ALL",
+        createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
+      },
+
+      // Add webhook triggers here (see Option 2 above)
+      // Example: ...registerSlackTrigger({ ... })
+    ],
+  },
+  logger:
+    process.env.NODE_ENV === "production"
+      ? new ProductionPinoLogger({
+          name: "Mastra",
+          level: "info",
+        })
+      : new PinoLogger({
+          name: "Mastra",
+          level: "info",
+        }),
+});
+
+/*  Sanity check 1: Throw an error if there are more than 1 workflows.  */
+// !!!!!! Do not remove this check. !!!!!!
+if (Object.keys(mastra.listWorkflows()).length > 1) {
+  throw new Error(
+    "More than 1 workflows found. Currently, more than 1 workflows are not supported in the UI, since doing so will cause app state to be inconsistent.",
+  );
+}
+
+/*  Sanity check 2: Throw an error if there are more than 1 agents.  */
+// !!!!!! Do not remove this check. !!!!!!
+if (Object.keys(mastra.listAgents()).length > 1) {
+  throw new Error(
+    "More than 1 agents found. Currently, more than 1 agents are not supported in the UI, since doing so will cause app state to be inconsistent.",
+  );
+}

package/.local/skills/artifacts/artifacts/automation/files/src/mastra/inngest/client.ts

@@ -0,0 +1,17 @@
+import { Inngest } from "inngest";
+import { realtimeMiddleware } from "@inngest/realtime/middleware";
+
+// Use development configuration when NODE_ENV is not "production"
+export const inngest = new Inngest(
+  process.env.NODE_ENV === "production"
+    ? {
+        id: "replit-agent-workflow",
+        name: "Replit Agent Workflow System",
+      }
+    : {
+        id: "mastra",
+        baseUrl: `http://localhost:${process.env.INNGEST_PORT ?? "3000"}`,
+        isDev: true,
+        middleware: [realtimeMiddleware()],
+      },
+);

package/.local/skills/artifacts/artifacts/automation/files/src/mastra/inngest/index.ts

@@ -0,0 +1,214 @@
+import { inngest } from "./client";
+import { init, serve as originalInngestServe } from "@mastra/inngest";
+import { registerApiRoute as originalRegisterApiRoute } from "@mastra/core/server";
+import { type Mastra } from "@mastra/core";
+import { type Inngest, InngestFunction, NonRetriableError } from "inngest";
+
+// Initialize Inngest with Mastra to get Inngest-compatible workflow helpers
+const {
+  createWorkflow: originalCreateWorkflow,
+  createStep,
+  cloneStep,
+} = init(inngest);
+
+export function createWorkflow(
+  params: Parameters<typeof originalCreateWorkflow>[0],
+): ReturnType<typeof originalCreateWorkflow> {
+  return originalCreateWorkflow({
+    ...params,
+    retryConfig: {
+      attempts: process.env.NODE_ENV === "production" ? 3 : 0,
+      ...(params.retryConfig ?? {}),
+    },
+  });
+}
+
+// Export the Inngest client and Inngest-compatible workflow helpers
+export { inngest, createStep, cloneStep };
+
+const inngestFunctions: InngestFunction.Any[] = [];
+const localMastraBaseUrl = `http://localhost:${process.env.PORT ?? "5000"}`;
+const basePath =
+  process.env.BASE_PATH && process.env.BASE_PATH !== "/"
+    ? process.env.BASE_PATH
+    : "";
+
+// Create a middleware for Inngest to be able to route triggers to Mastra directly.
+export function registerApiRoute<P extends string>(
+  ...args: Parameters<typeof originalRegisterApiRoute<P>>
+): ReturnType<typeof originalRegisterApiRoute<P>> {
+  const [path, options] = args;
+  if (typeof options !== "object") {
+    // This will throw an error.
+    return originalRegisterApiRoute(...args);
+  }
+
+  const pathWithoutSlash = path.replace(/^\/+/, "");
+  const pathWithoutApi = pathWithoutSlash.startsWith("api/")
+    ? pathWithoutSlash.substring(4)
+    : pathWithoutSlash;
+
+  // Determine function ID and event name based on path type:
+  // - Slack/Telegram use /webhooks/{provider}/action paths: use full path-based event name
+  // - Connectors use /{connector}/webhook paths: use standardized event pattern
+  let functionId: string;
+  let eventName: string;
+
+  if (pathWithoutApi.startsWith("webhooks/")) {
+    // Slack/Telegram: use full path-based event name for backwards compatibility
+    // e.g., /webhooks/slack/action → event/api.webhooks.slack.action
+    functionId = `api-${pathWithoutApi.replaceAll(/\/+/g, "-")}`;
+    eventName = `event/api.${pathWithoutApi.replaceAll(/\/+/g, ".")}`;
+  } else {
+    // Connector path: use the standardized event pattern
+    // e.g., /linear/webhook → event/api.webhooks.linear.action
+    const connectorName = pathWithoutApi.split("/")[0];
+    functionId = `api-${connectorName}`;
+    eventName = `event/api.webhooks.${connectorName}.action`;
+  }
+
+  inngestFunctions.push(
+    inngest.createFunction(
+      {
+        id: functionId,
+        name: path,
+      },
+      {
+        event: eventName,
+      },
+      async ({ event, step }) => {
+        await step.run("forward request to Mastra", async () => {
+          // It is hard to obtain an internal handle on the Hono server,
+          // so we just forward the request to the local Mastra server.
+          // Extract runId from event.data if provided and pass it as a header
+          const headers = { ...(event.data.headers ?? {}) };
+          if (event.data.runId) {
+            headers["x-mastra-run-id"] = event.data.runId;
+          }
+          const response = await fetch(`${localMastraBaseUrl}${path}`, {
+            method: event.data.method,
+            headers,
+            body: event.data.body,
+          });
+
+          if (!response.ok) {
+            if (
+              (response.status >= 500 && response.status < 600) ||
+              response.status == 429 ||
+              response.status == 408
+            ) {
+              // 5XX, 429 (Rate-Limit Exceeded), 408 (Request Timeout) are retriable.
+              throw new Error(
+                `Failed to forward request to Mastra: ${response.statusText}`,
+              );
+            } else {
+              // All other errors are non-retriable.
+              throw new NonRetriableError(
+                `Failed to forward request to Mastra: ${response.statusText}`,
+              );
+            }
+          }
+        });
+      },
+    ),
+  );
+
+  return originalRegisterApiRoute(...args);
+}
+
+// ======================================================================
+// TRIGGER FUNCTIONS - CHOOSE ONE BASED ON YOUR AUTOMATION TYPE
+// ======================================================================
+// An automation only has a single trigger type. Based on your trigger:
+//
+// FOR TIME-BASED AUTOMATIONS (cron/schedule):
+//   - Keep the registerCronWorkflow function below
+//   - Delete the registerApiRoute function above (entire function)
+//   - Used for: Daily reports, scheduled tasks, periodic checks
+//
+// FOR WEBHOOK-BASED AUTOMATIONS (Slack, Telegram, connectors):
+//   - Keep the registerApiRoute function above
+//   - Delete the registerCronWorkflow function below (entire function)
+//   - Used for: Slack bots, Telegram bots, GitHub webhooks, Linear webhooks, etc.
+// ======================================================================
+
+// Helper function for registering cron-based workflow triggers
+export function registerCronWorkflow(cronExpression: string, workflow: any) {
+  console.log("🕐 [registerCronWorkflow] Registering cron trigger", {
+    cronExpression,
+    workflowId: workflow?.id,
+  });
+
+  const cronFunction = inngest.createFunction(
+    { id: "cron-trigger" },
+    [{ event: "replit/cron.trigger" }, { cron: cronExpression }],
+    async ({ event, step }) => {
+      return await step.run("execute-cron-workflow", async () => {
+        console.log("🚀 [Cron Trigger] Starting scheduled workflow execution", {
+          workflowId: workflow?.id,
+          scheduledTime: new Date().toISOString(),
+          cronExpression,
+        });
+
+        try {
+          const run = await workflow.createRun();
+          console.log("📝 [Cron Trigger] Workflow run created", {
+            runId: run?.runId,
+          });
+
+          const result = await inngest.send({
+            name: `workflow.${workflow.id}`,
+            data: {
+              runId: run?.runId,
+              inputData: {},
+            },
+          });
+          console.log("✅ [Cron Trigger] Invoked Inngest function", {
+            workflowId: workflow?.id,
+            runId: run?.runId,
+          });
+
+          return result;
+        } catch (error) {
+          console.error("❌ [Cron Trigger] Workflow execution failed", {
+            workflowId: workflow?.id,
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : undefined,
+          });
+          throw error;
+        }
+      });
+    },
+  );
+
+  inngestFunctions.push(cronFunction);
+  console.log(
+    "✅ [registerCronWorkflow] Cron trigger registered successfully",
+    {
+      cronExpression,
+    },
+  );
+}
+
+export function inngestServe({
+  mastra,
+  inngest,
+}: {
+  mastra: Mastra;
+  inngest: Inngest;
+}): ReturnType<typeof originalInngestServe> {
+  let serveHost: string | undefined = undefined;
+  if (process.env.NODE_ENV === "production") {
+    if (process.env.REPLIT_DOMAINS) {
+      serveHost = `https://${process.env.REPLIT_DOMAINS.split(",")[0]}${basePath}`;
+    }
+  } else {
+    serveHost = localMastraBaseUrl;
+  }
+  return originalInngestServe({
+    mastra,
+    inngest,
+    functions: inngestFunctions,
+    registerOptions: { serveHost },
+  });
+}

package/.local/skills/artifacts/artifacts/automation/files/src/mastra/storage/index.ts

@@ -0,0 +1,8 @@
+import { PostgresStore } from "@mastra/pg";
+
+// Create a single shared PostgreSQL storage instance
+export const sharedPostgresStorage = new PostgresStore({
+  id: "main-postgres-store",
+  connectionString:
+    process.env.DATABASE_URL || "postgresql://localhost:5432/mastra",
+});

package/.local/skills/artifacts/artifacts/automation/files/src/mastra/tools/exampleTool.ts

@@ -0,0 +1,71 @@
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+
+/**
+ * Example Mastra Tool
+ *
+ * MASTRA TOOL GUIDE:
+ * - Tools are reusable functions that can be used by agents and workflows
+ * - Use createTool() to define a tool with typed inputs/outputs
+ * - Tools should be focused on a single task
+ * - Always include clear descriptions for the tool and its parameters
+ */
+
+// Define the input and output schemas using Zod
+// This provides type safety and validation
+export const exampleTool = createTool({
+  id: "example-tool",
+
+  // Describe what your tool does - this helps agents understand when to use it
+  description:
+    "A simple example tool that demonstrates how to create Mastra tools",
+
+  // Define what inputs your tool expects
+  // Use .describe() to add helpful descriptions for each field
+  inputSchema: z.object({
+    message: z.string().describe("A message to process"),
+    count: z.number().optional().describe("Optional number parameter"),
+  }),
+
+  // Define what your tool will return
+  outputSchema: z.object({
+    processed: z.string(),
+    timestamp: z.string(),
+    metadata: z.object({
+      characterCount: z.number(),
+      wordCount: z.number(),
+    }),
+  }),
+
+  // The execute function contains your tool's logic
+  // Access mastra for logging and other utilities
+  execute: async (inputData, context) => {
+    const mastra = context?.mastra;
+    const logger = mastra?.getLogger();
+
+    // Use logger instead of console.log for proper observability
+    logger?.info("🔧 [exampleTool] Executing with:", context);
+
+    // In a real tool, you might:
+    // 1. Call external APIs
+    // 2. Process data
+    // 3. Interact with databases
+    // 4. Transform information
+
+    // For this example, we'll do some trivial data processing
+    const processedMessage = inputData.message.toUpperCase();
+    const words = inputData.message.split(" ").filter((w) => w.length > 0);
+
+    logger?.info("✅ [exampleTool] Processing complete");
+
+    // Return data matching the output schema
+    return {
+      processed: processedMessage,
+      timestamp: new Date().toISOString(),
+      metadata: {
+        characterCount: inputData.message.length,
+        wordCount: words.length,
+      },
+    };
+  },
+});