@mesh-tech/mesh-cli 0.1.1 → 0.12.1

package/templates/temporal-api-worker/README.md.hbs

@@ -1,133 +0,0 @@
-# {{titleCase name}}
-
-Temporal workflow application for {{tenant}}.
-
-## Overview
-
-This app demonstrates Temporal workflow orchestration with:
-- **Worker**: Executes workflows and activities
-- **API**: HTTP endpoints to trigger workflows
-
-## Prerequisites
-
-- MeshPlatform deployed with `temporal: { ... }` enabled
-- AWS credentials with apps-deployer role
-
-## Development
-
-### 1. Start Dev Server
-
-```bash
-pnpm mesh dev
-# Auto-starts unified tunnel (Temporal gRPC:7233, Web UI:8080, DB:5432)
-```
-
-### 2. Start Worker Manually
-
-Workers don't auto-start because they need the Temporal namespace to exist first.
-After `sst dev` is ready:
-1. Open SST dev UI
-2. Find the worker service
-3. Click to start it
-
-### 4. Test Workflows
-
-```bash
-# Trigger greeting workflow
-curl -X POST http://localhost:3000/greet \
-  -H "Content-Type: application/json" \
-  -d '{"name": "World"}'
-
-# Trigger task workflow
-curl -X POST http://localhost:3000/task \
-  -H "Content-Type: application/json" \
-  -d '{"taskId": "TASK-123", "userId": "user-456"}'
-
-# Check workflow status
-curl http://localhost:3000/workflow/task-TASK-123
-```
-
-### 5. View in Web UI
-
-Open http://localhost:8080 and navigate to your namespace.
-
-## Deployment
-
-```bash
-pnpm deploy --stage dev
-```
-
-## Project Structure
-
-```
-{{name}}/
-├── sst.config.ts      # SST config with AppEnvironment + TemporalWorker
-├── worker/
-│   ├── src/
-│   │   ├── worker.ts      # Worker entry point
-│   │   ├── workflows.ts   # Workflow definitions
-│   │   ├── activities.ts  # Activity implementations
-│   │   └── encryption-codec.ts  # Payload encryption
-│   ├── Dockerfile
-│   └── package.json
-├── api/
-│   ├── src/
-│   │   ├── index.ts       # Express API
-│   │   └── encryption-codec.ts  # Payload encryption
-│   ├── Dockerfile
-│   └── package.json
-└── README.md
-```
-
-## Customization
-
-### Adding Workflows
-
-1. Define workflow in `worker/src/workflows.ts`
-2. Add activities in `worker/src/activities.ts`
-3. Add API endpoint in `api/src/index.ts`
-
-### Workflow Patterns
-
-```typescript
-// Simple workflow
-export async function myWorkflow(input: string): Promise<string> {
-  const result = await myActivity(input);
-  return result;
-}
-
-// Workflow with timer
-export async function timedWorkflow(): Promise<void> {
-  await doSomething();
-  await sleep("1 hour");  // Durable timer
-  await doSomethingElse();
-}
-
-// Workflow with error handling
-export async function safeWorkflow(): Promise<string> {
-  try {
-    return await riskyActivity();
-  } catch (err) {
-    return await fallbackActivity();
-  }
-}
-```
-
-## Troubleshooting
-
-### Worker Can't Connect
-
-1. Ensure tunnel is running in SST dev (check "tunnel" pane)
-2. Check `TEMPORAL_ADDRESS` in worker logs
-3. Or start tunnel manually: `pnpm mesh tunnel dev`
-
-### Encrypted Payloads in Web UI
-
-Configure codec server in Web UI settings:
-- Dev: `http://localhost:8083`
-- Deploy: Check `codecServerUrl` output
-
-### Workflow Not Found
-
-1. Ensure worker is running
-2. Check task queue name matches between API and worker

package/templates/temporal-api-worker/api/src/index.ts.hbs

@@ -1,145 +0,0 @@
-/**
- * {{titleCase name}} API
- *
- * HTTP API for triggering Temporal workflows.
- *
- * Environment variables:
- * - PORT: Server port (default: 3000)
- * - TEMPORAL_ADDRESS: Temporal server address (default: localhost:7233)
- * - TEMPORAL_NAMESPACE: Temporal namespace (required)
- * - TEMPORAL_TASK_QUEUE: Task queue name (required)
- * - TEMPORAL_ENCODING_KEY: Encoding key for payload encryption (optional)
- */
-
-import express, { Request, Response } from "express";
-import { Client, Connection } from "@temporalio/client";
-import { createEncryptionCodec } from "./encryption-codec.js";
-
-const PORT = parseInt(process.env.PORT ?? "3000", 10);
-const TEMPORAL_ADDRESS = process.env.TEMPORAL_ADDRESS ?? "localhost:7233";
-
-function requireEnv(name: string): string {
-  const value = process.env[name];
-  if (!value) {
-    throw new Error(`${name} environment variable is required`);
-  }
-  return value;
-}
-
-const TEMPORAL_NAMESPACE = requireEnv("TEMPORAL_NAMESPACE");
-const TEMPORAL_TASK_QUEUE = requireEnv("TEMPORAL_TASK_QUEUE");
-
-const app = express();
-app.use(express.json());
-
-let client: Client;
-
-// Initialize Temporal client
-async function initClient(): Promise<void> {
-  console.log(`[API] Connecting to Temporal at ${TEMPORAL_ADDRESS}...`);
-
-  const connection = await Connection.connect({
-    address: TEMPORAL_ADDRESS,
-  });
-
-  // Set up payload encryption if encoding key is available
-  const encryptionCodec = await createEncryptionCodec();
-  const dataConverter = encryptionCodec
-    ? { payloadCodecs: [encryptionCodec] }
-    : undefined;
-
-  client = new Client({
-    connection,
-    namespace: TEMPORAL_NAMESPACE,
-    dataConverter,
-  });
-
-  console.log(`[API] Connected. Namespace: ${TEMPORAL_NAMESPACE}`);
-}
-
-// Health check
-app.get("/health", (_req: Request, res: Response) => {
-  res.json({ status: "ok" });
-});
-
-// Trigger greeting workflow
-app.post("/greet", async (req: Request, res: Response) => {
-  try {
-    const { name } = req.body as { name: string };
-    if (!name) {
-      res.status(400).json({ error: "name is required" });
-      return;
-    }
-
-    const handle = await client.workflow.start("greetingWorkflow", {
-      taskQueue: TEMPORAL_TASK_QUEUE,
-      workflowId: `greeting-${Date.now()}`,
-      args: [name],
-    });
-
-    // Wait for result (greeting is quick)
-    const result = await handle.result();
-    res.json({ workflowId: handle.workflowId, result });
-  } catch (error) {
-    console.error("[API] Error starting workflow:", error);
-    res.status(500).json({ error: "Failed to start workflow" });
-  }
-});
-
-// Trigger task workflow
-app.post("/task", async (req: Request, res: Response) => {
-  try {
-    const { taskId, userId } = req.body as { taskId: string; userId: string };
-    if (!taskId || !userId) {
-      res.status(400).json({ error: "taskId and userId are required" });
-      return;
-    }
-
-    const handle = await client.workflow.start("taskWorkflow", {
-      taskQueue: TEMPORAL_TASK_QUEUE,
-      workflowId: `task-${taskId}`,
-      args: [taskId, userId],
-    });
-
-    // Don't wait for result - return workflow ID immediately
-    res.json({
-      workflowId: handle.workflowId,
-      status: "started",
-      message: "Workflow started. Check Temporal Web UI for progress.",
-    });
-  } catch (error) {
-    console.error("[API] Error starting workflow:", error);
-    res.status(500).json({ error: "Failed to start workflow" });
-  }
-});
-
-// Get workflow status
-app.get("/workflow/:workflowId", async (req: Request, res: Response) => {
-  try {
-    const { workflowId } = req.params;
-    const handle = client.workflow.getHandle(workflowId);
-    const describe = await handle.describe();
-
-    res.json({
-      workflowId,
-      status: describe.status.name,
-      startTime: describe.startTime,
-      closeTime: describe.closeTime,
-    });
-  } catch (error) {
-    console.error("[API] Error getting workflow:", error);
-    res.status(500).json({ error: "Failed to get workflow status" });
-  }
-});
-
-// Start server
-initClient()
-  .then(() => {
-    app.listen(PORT, "0.0.0.0", () => {
-      console.log(`[API] {{titleCase name}} API listening on port ${PORT}`);
-    });
-  })
-  .catch((err) => {
-    console.error("[API] Failed to initialize:", err);
-    process.exit(1);
-  });

package/templates/temporal-api-worker/package.json.hbs

@@ -1,29 +0,0 @@
-{
-  "name": "{{name}}",
-  "version": "0.0.1",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "typecheck": "tsc --noEmit",
-    "sst:patch": "patch-sst-pulumi .",
-    "dev": "pnpm run sst:patch && sst dev",
-    "deploy": "pnpm run sst:patch && sst deploy",
-    "deploy:dev": "pnpm run sst:patch && sst deploy --stage dev",
-    "deploy:prod": "pnpm run sst:patch && sst deploy --stage prod",
-    "remove": "sst remove"
-  },
-  "dependencies": {
-    "@mesh-tech/infra-components": "workspace:*",
-    "@pulumi/aws": "6.66.2",
-    "@pulumi/docker-build": "^0.0.15",
-    "@pulumi/eks": "4.2.0",
-    "@pulumi/kubernetes": "4.24.1",
-    "@pulumi/pulumi": "3.214.1",
-    "@pulumi/random": "4.18.2",
-    "sst": "^3.3.61"
-  },
-  "devDependencies": {
-    "@aws-sdk/credential-providers": "^3.964.0",
-    "typescript": "^5.7.2"
-  }
-}

package/templates/temporal-api-worker/sst.config.ts.hbs

@@ -1,161 +0,0 @@
-/// <reference path="./.sst/platform/config.d.ts" />
-
-/**
- * {{titleCase name}} - Temporal Workflow Application
- *
- * This app demonstrates Temporal workflow orchestration with:
- * - AppEnvironment with temporal: true (namespace provisioning, encoding key)
- * - TemporalWorker component (auto-configured env vars, no Service/Ingress)
- * - API Service for triggering workflows
- *
- * Dev mode:
- *   1. Run: pnpm mesh dev (auto-starts tunnel to Temporal + DB)
- *   2. Start worker manually in SST dev UI
- *
- * Deploy:
- *   pnpm deploy --stage dev
- */
-
-export default $config({
-  app(input) {
-    return {
-      name: "{{name}}",
-      removal: input?.stage === "prod" ? "retain" : "remove",
-      protect: ["prod"].includes(input?.stage ?? ""),
-      home: "aws",
-      providers: {
-        aws: {
-          region: "us-east-2",
-        },
-      },
-    };
-  },
-  async run() {
-    // Dynamic imports (SST requirement for non-SST packages)
-    const { mesh } = await import("@mesh-tech/infra-components");
-    const { config, getPlatform } = await import("../config.js");
-
-    const stage = $app.stage;
-    const tenant = config.tenant;
-    const platform = getPlatform(stage);
-
-    // =========================================================================
-    // AppEnvironment with Temporal enabled
-    // =========================================================================
-    // This creates:
-    // - Kubernetes namespace (deploy mode)
-    // - Temporal namespace (via TemporalNamespaceProvisioner Lambda)
-    // - Encoding key K8s Secret for payload encryption
-    // - Codec server deployment (for Web UI decryption)
-    // - Unified dev tunnel (mesh tunnel dev) for Temporal + DB access
-
-    const env = new mesh.apps.AppEnvironment("env", {
-      tenant,
-      platform,
-      stage,
-      appName: "{{name}}",
-      dev: $dev,
-      namespace: !$dev,
-
-      // Enable Temporal support
-      temporal: true,
-      DevCommand: sst.x.DevCommand,
-    });
-
-    // =========================================================================
-    // Temporal Worker
-    // =========================================================================
-    // TemporalWorker automatically handles:
-    // - Temporal environment variables (ADDRESS, NAMESPACE, TASK_QUEUE)
-    // - Encoding key secret mounting for payload encryption
-    // - No Service/Ingress (workers don't serve HTTP)
-    // - Dev mode: doesn't autostart (waits for namespace provisioning)
-
-    const worker = new mesh.apps.TemporalWorker(
-      "worker",
-      {
-        env,
-        rootDir: $cli.paths.root,
-        src: "./worker",
-        devCommand: ["pnpm", "dev"],
-
-        // Task queue defaults to worker name ("worker")
-        taskQueue: "{{name}}",
-
-        environment: {
-          NODE_ENV: $dev ? "development" : "production",
-        },
-
-        replicas: 1,
-        resources: {
-          cpu: "100m",
-          memory: "256Mi",
-        },
-      },
-      {
-        providers: env.providers,
-        parent: env,
-      },
-    );
-
-    // =========================================================================
-    // API Service (triggers workflows)
-    // =========================================================================
-    const api = new mesh.apps.Service(
-      "api",
-      {
-        dev: $dev,
-        tenant,
-        stage,
-        appName: "{{name}}",
-        namespace: env.namespace!,
-        rootDir: $cli.paths.root,
-        src: "./api",
-        port: 3000,
-        devCommand: ["pnpm", "dev"],
-
-        environment: {
-          NODE_ENV: $dev ? "development" : "production",
-          TEMPORAL_ADDRESS: env.temporal!.endpoint.apply((e) =>
-            $dev ? "localhost:7233" : `${e}:7233`,
-          ),
-          TEMPORAL_NAMESPACE: env.temporal!.namespace,
-          TEMPORAL_TASK_QUEUE: "{{name}}",
-          // Dev mode: inject encoding key directly
-          ...($dev && env.temporal!.devEncodingKey
-            ? { TEMPORAL_ENCODING_KEY: env.temporal!.devEncodingKey }
-            : {}),
-        },
-
-        // Deploy mode: inject encoding key from K8s secret
-        envFromSecrets: $dev ? [] : [env.temporal!.encodingKeySecretName],
-
-        ingress: env.buildIngress({
-          subdomain: "{{name}}-api",
-          healthCheckPath: "/health",
-        }),
-
-        replicas: 1,
-        resources: {
-          cpu: "100m",
-          memory: "128Mi",
-        },
-      },
-      {
-        providers: env.providers,
-        parent: env,
-        dependsOn: [worker],
-      },
-    );
-
-    return {
-      namespace: env.namespace,
-      temporalNamespace: env.temporal?.namespace,
-      temporalEndpoint: env.temporal?.endpoint,
-      encodingKeySecret: env.temporal?.encodingKeySecretName,
-      codecServerUrl: env.temporal?.codecServerUrl,
-      workerTaskQueue: worker.taskQueue,
-      apiUrl: api.url,
-    };
-  },
-});

package/templates/temporal-api-worker/worker/Dockerfile

@@ -1,11 +0,0 @@
-FROM node:20-slim
-
-WORKDIR /app
-
-COPY package*.json ./
-RUN npm ci --omit=dev
-
-COPY . .
-RUN npm run build
-
-CMD ["node", "dist/worker.js"]

package/templates/temporal-api-worker/worker/src/bundle-workflows.ts

@@ -1,38 +0,0 @@
-/**
- * Bundle Workflows for Production
- *
- * Pre-bundles workflows to avoid runtime bundling in production.
- * Run with: npm run bundle:workflows
- */
-
-import * as fs from "fs";
-import * as path from "path";
-import { fileURLToPath } from "url";
-import { bundleWorkflowCode } from "@temporalio/worker";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-async function bundle() {
-  console.log("[Bundle] Bundling workflows...");
-
-  const bundle = await bundleWorkflowCode({
-    workflowsPath: path.join(__dirname, "workflows.ts"),
-  });
-
-  const outPath = path.join(__dirname, "..", "dist", "workflows-bundle.js");
-
-  // Ensure dist directory exists
-  const distDir = path.dirname(outPath);
-  if (!fs.existsSync(distDir)) {
-    fs.mkdirSync(distDir, { recursive: true });
-  }
-
-  fs.writeFileSync(outPath, bundle.code);
-  console.log(`[Bundle] Wrote bundle to ${outPath}`);
-}
-
-bundle().catch((err) => {
-  console.error("[Bundle] Failed:", err);
-  process.exit(1);
-});

package/templates/temporal-api-worker/worker/src/worker.ts.hbs

@@ -1,93 +0,0 @@
-/**
- * {{titleCase name}} Temporal Worker
- *
- * Environment variables:
- * - TEMPORAL_ADDRESS: Temporal server address (default: localhost:7233)
- * - TEMPORAL_NAMESPACE: Temporal namespace (required)
- * - TEMPORAL_TASK_QUEUE: Task queue name (required)
- * - TEMPORAL_ENCODING_KEY: Encoding key for payload encryption (optional)
- */
-
-import * as fs from "fs";
-import * as path from "path";
-import { fileURLToPath } from "url";
-import { NativeConnection, Worker, WorkerOptions, bundleWorkflowCode } from "@temporalio/worker";
-import * as activities from "./activities.js";
-import { createEncryptionCodec } from "./encryption-codec.js";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-const TEMPORAL_ADDRESS = process.env.TEMPORAL_ADDRESS ?? "localhost:7233";
-
-function requireEnv(name: string): string {
-  const value = process.env[name];
-  if (!value) {
-    throw new Error(`${name} environment variable is required`);
-  }
-  return value;
-}
-
-const TEMPORAL_NAMESPACE = requireEnv("TEMPORAL_NAMESPACE");
-const TEMPORAL_TASK_QUEUE = requireEnv("TEMPORAL_TASK_QUEUE");
-
-/**
- * Load workflows - uses pre-bundled code in production, source files in dev
- */
-async function getWorkflowOptions(): Promise<
-  Pick<WorkerOptions, "workflowBundle" | "workflowsPath">
-> {
-  const bundlePath = path.join(__dirname, "workflows-bundle.js");
-
-  if (fs.existsSync(bundlePath)) {
-    console.log("[Worker] Loading pre-bundled workflows...");
-    return {
-      workflowBundle: { code: fs.readFileSync(bundlePath, "utf-8") },
-    };
-  }
-
-  console.log("[Worker] Bundling workflows from source...");
-  return {
-    workflowBundle: await bundleWorkflowCode({
-      workflowsPath: new URL("./workflows.js", import.meta.url).pathname,
-    }),
-  };
-}
-
-async function run() {
-  console.log(`[Worker] Connecting to Temporal at ${TEMPORAL_ADDRESS}...`);
-
-  const connection = await NativeConnection.connect({
-    address: TEMPORAL_ADDRESS,
-  });
-
-  console.log(`[Worker] Connected. Namespace: ${TEMPORAL_NAMESPACE}`);
-
-  const workflowOptions = await getWorkflowOptions();
-
-  // Set up payload encryption if encoding key is available
-  const encryptionCodec = await createEncryptionCodec();
-  const dataConverter = encryptionCodec
-    ? { payloadCodecs: [encryptionCodec] }
-    : undefined;
-
-  if (encryptionCodec) {
-    console.log("[Worker] Payload encryption enabled");
-  }
-
-  const worker = await Worker.create({
-    connection,
-    namespace: TEMPORAL_NAMESPACE,
-    taskQueue: TEMPORAL_TASK_QUEUE,
-    ...workflowOptions,
-    activities,
-    dataConverter,
-  });
-
-  console.log(`[Worker] Starting on task queue: ${TEMPORAL_TASK_QUEUE}`);
-  await worker.run();
-}
-
-run().catch((err) => {
-  console.error("[Worker] Fatal error:", err);
-  process.exit(1);
-});