@khester/create-dynamics-app 2.6.6 → 2.8.0

package/templates/teams-bot/_variants/bot.echo/src/mock/mockMode.ts

@@ -0,0 +1,104 @@
+import { TestAdapter, Activity, ConversationReference, TurnContext } from 'botbuilder';
+import { TeamsBot } from '../bot/TeamsBot';
+
+// Create a test adapter for mock mode testing
+export function createMockAdapter(): TestAdapter {
+  const adapter = new TestAdapter(async (context: TurnContext) => {
+    const bot = new TeamsBot();
+    await bot.run(context);
+  });
+
+  return adapter;
+}
+
+// Simulate a Teams conversation for testing
+export async function runMockConversation(
+  userMessage: string,
+  callback?: (response: Partial<Activity>[]) => void
+): Promise<Partial<Activity>[]> {
+  const adapter = createMockAdapter();
+  const responses: Partial<Activity>[] = [];
+
+  await adapter.send(userMessage).assertReply((activity) => {
+    responses.push(activity);
+    callback?.([activity]);
+  });
+
+  return responses;
+}
+
+// Create a mock conversation reference for proactive messaging tests
+export function createMockConversationReference(
+  userId: string = 'user-1'
+): Partial<ConversationReference> {
+  return {
+    activityId: 'mock-activity-id',
+    user: {
+      id: userId,
+      name: 'Mock User',
+    },
+    bot: {
+      id: 'mock-bot-id',
+      name: 'Mock Bot',
+    },
+    conversation: {
+      id: 'mock-conversation-id',
+      isGroup: false,
+      conversationType: 'personal',
+      tenantId: 'mock-tenant-id',
+      name: '',
+    },
+    channelId: 'msteams',
+    serviceUrl: 'https://smba.trafficmanager.net/teams/',
+  };
+}
+
+// Interactive console testing
+export async function startInteractiveTest(): Promise<void> {
+  const readline = await import('readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  console.log('\n=== Bot Mock Mode Interactive Test ===');
+  console.log('Type messages to test the bot. Type "exit" to quit.\n');
+
+  const adapter = createMockAdapter();
+
+  const askQuestion = (): void => {
+    rl.question('You: ', async (input) => {
+      if (input.toLowerCase() === 'exit') {
+        console.log('Goodbye!');
+        rl.close();
+        process.exit(0);
+        return;
+      }
+
+      try {
+        await adapter.send(input).assertReply((activity) => {
+          if (activity.text) {
+            console.log(`Bot: ${activity.text}`);
+          }
+          if (activity.attachments && activity.attachments.length > 0) {
+            console.log('Bot: [Adaptive Card]');
+            const card = activity.attachments[0].content;
+            if (card.body) {
+              for (const block of card.body) {
+                if (block.type === 'TextBlock' && block.text) {
+                  console.log(`      ${block.text}`);
+                }
+              }
+            }
+          }
+        });
+      } catch {
+        console.log('Bot: [No response]');
+      }
+
+      askQuestion();
+    });
+  };
+
+  askQuestion();
+}

package/templates/teams-bot/_variants/bot.notification/appPackage/manifest.template.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://developer.microsoft.com/en-us/json-schemas/teams/v1.19/MicrosoftTeams.schema.json",
+  "manifestVersion": "1.19",
+  "id": "{{TEAMS_APP_ID}}",
+  "version": "1.0.0",
+  "developer": {
+    "name": "Contoso",
+    "websiteUrl": "https://example.com",
+    "privacyUrl": "https://example.com/privacy",
+    "termsOfUseUrl": "https://example.com/terms"
+  },
+  "name": { "short": "{{projectName}}", "full": "{{projectName}}" },
+  "description": { "short": "{{projectName}} notifications", "full": "{{projectName}} — a Microsoft Teams bot that delivers proactive notifications; message it 'subscribe' to opt in" },
+  "icons": { "color": "color.png", "outline": "outline.png" },
+  "accentColor": "#6264A7",
+  "bots": [
+    {
+      "botId": "{{BOT_ID}}",
+      "scopes": ["personal", "team", "groupChat"],
+      "supportsFiles": false,
+      "isNotificationOnly": false
+    }
+  ],
+  "permissions": ["identity"]
+}

package/templates/teams-bot/_variants/bot.notification/src/bot/NotificationBot.ts

@@ -0,0 +1,54 @@
+import { TeamsActivityHandler, TurnContext, MessageFactory, CardFactory, Attachment } from 'botbuilder';
+import { IConversationStore } from '../storage/conversationStore';
+
+export class NotificationBot extends TeamsActivityHandler {
+  constructor(private conversationStore: IConversationStore) {
+    super();
+
+    // Capture the conversation reference whenever we hear from a user — this is
+    // what proactive messaging replays later via continueConversationAsync.
+    this.onConversationUpdate(async (context: TurnContext, next: () => Promise<void>) => {
+      await this.saveConversationReference(context);
+      await next();
+    });
+
+    this.onMessage(async (context: TurnContext, next: () => Promise<void>) => {
+      await this.saveConversationReference(context);
+      const text = context.activity.text?.toLowerCase().trim() || '';
+
+      if (text === 'subscribe') {
+        await context.sendActivity(MessageFactory.text('You are subscribed to notifications!'));
+      } else if (text === 'unsubscribe') {
+        const userId = context.activity.from.id;
+        await this.conversationStore.delete(userId);
+        await context.sendActivity(MessageFactory.text('You have been unsubscribed.'));
+      } else {
+        await context.sendActivity(
+          MessageFactory.text('Commands: **subscribe**, **unsubscribe**. Notifications arrive via POST /api/notify.')
+        );
+      }
+      await next();
+    });
+  }
+
+  private async saveConversationReference(context: TurnContext): Promise<void> {
+    const reference = TurnContext.getConversationReference(context.activity);
+    const userId = context.activity.from?.id;
+    if (userId) {
+      await this.conversationStore.save(userId, reference);
+    }
+  }
+
+  static createNotificationCard(title: string, message: string): Attachment {
+    return CardFactory.adaptiveCard({
+      type: 'AdaptiveCard',
+      $schema: 'http://adaptivecards.io/schemas/adaptive-card.json',
+      version: '1.4',
+      body: [
+        { type: 'TextBlock', text: title, weight: 'Bolder', size: 'Medium', wrap: true },
+        { type: 'TextBlock', text: message, wrap: true },
+        { type: 'TextBlock', text: new Date().toLocaleString(), size: 'Small', isSubtle: true },
+      ],
+    });
+  }
+}

package/templates/teams-bot/_variants/bot.notification/src/index.ts

@@ -0,0 +1,136 @@
+import express, { Request, Response } from 'express';
+import { timingSafeEqual } from 'node:crypto';
+import { config, validateConfig } from './config';
+import { createBotAdapter } from './adapters/botAdapter';
+import { NotificationBot } from './bot/NotificationBot';
+import { FileConversationStore, MemoryConversationStore } from './storage/conversationStore';
+import { startInteractiveTest } from './mock/mockMode';
+
+// Length-checked constant-time compare (timingSafeEqual throws on length mismatch) so the
+// shared X-Notify-Key can't be recovered a byte at a time via response-timing analysis.
+function timingSafeEqualStr(a: string, b: string): boolean {
+  const ab = Buffer.from(a);
+  const bb = Buffer.from(b);
+  return ab.length === bb.length && timingSafeEqual(ab, bb);
+}
+
+validateConfig();
+
+// Interactive mock mode: console chat loop, no server / no Azure.
+if (process.argv.includes('--interactive')) {
+  startInteractiveTest();
+} else {
+  const app = express();
+  app.use(express.json());
+
+  const adapter = createBotAdapter();
+  // File store by default so subscriptions survive restarts; memory store in mock mode.
+  const conversationStore = config.mockMode
+    ? new MemoryConversationStore()
+    : new FileConversationStore(config.conversationStorePath);
+  const bot = new NotificationBot(conversationStore);
+
+  // Health check endpoint (the deploy pipeline gates on this)
+  app.get('/health', (_req: Request, res: Response) => {
+    res.json({
+      status: 'healthy',
+      timestamp: new Date().toISOString(),
+      mockMode: config.mockMode,
+    });
+  });
+
+  // Bot messaging endpoint
+  app.post('/api/messages', async (req: Request, res: Response) => {
+    try {
+      await adapter.process(req, res, (context) => bot.run(context));
+    } catch (error) {
+      console.error('Error processing message:', error);
+      res.status(500).send('Internal Server Error');
+    }
+  });
+
+  // Proactive notification endpoint. Fail-closed: without a configured key the
+  // endpoint stays off (this is a public URL — an open POST would be a spam relay).
+  app.post('/api/notify', async (req: Request, res: Response) => {
+    if (!config.notifyApiKey) {
+      res.status(503).json({ error: 'NOTIFY_API_KEY is not configured; endpoint disabled.' });
+      return;
+    }
+    const providedKey = req.get('X-Notify-Key');
+    if (!providedKey || !timingSafeEqualStr(providedKey, config.notifyApiKey)) {
+      res.status(401).json({ error: 'Missing or invalid X-Notify-Key header.' });
+      return;
+    }
+
+    const { title, message, userId } = req.body as {
+      title?: string;
+      message?: string;
+      userId?: string;
+    };
+    if (!title || !message) {
+      res.status(400).json({ error: 'Both "title" and "message" are required.' });
+      return;
+    }
+
+    const sendTo = async (reference: Parameters<typeof adapter.continueConversationAsync>[1]) => {
+      await adapter.continueConversationAsync(config.botId, reference, async (context) => {
+        await context.sendActivity({
+          attachments: [NotificationBot.createNotificationCard(title, message)],
+        });
+      });
+    };
+
+    try {
+      if (userId) {
+        const reference = await conversationStore.get(userId);
+        if (!reference) {
+          res.status(404).json({ error: `No conversation reference for user "${userId}".` });
+          return;
+        }
+        await sendTo(reference);
+        res.json({ success: true, sent: 1 });
+      } else {
+        // Broadcast to every stored reference; tolerate stale ones.
+        const refs = await conversationStore.getAll();
+        let sent = 0;
+        let failed = 0;
+        for (const [id, reference] of refs) {
+          try {
+            await sendTo(reference);
+            sent++;
+          } catch (err) {
+            failed++;
+            console.warn(`Failed to notify ${id}:`, err);
+          }
+        }
+        res.json({ success: true, sent, failed });
+      }
+    } catch (error) {
+      console.error('Error sending notification:', error);
+      res.status(500).json({ error: 'Failed to send notification.' });
+    }
+  });
+
+  app.get('/', (_req: Request, res: Response) => {
+    res.json({
+      name: '{{projectName}}',
+      description: 'Microsoft Teams notification bot (Bot Framework SDK v4, proactive messaging)',
+      endpoints: { messaging: '/api/messages', notify: '/api/notify', health: '/health' },
+      mockMode: config.mockMode,
+    });
+  });
+
+  app.listen(config.port, () => {
+    console.log(`\nNotification bot server is running!`);
+    console.log(`   Local:  http://localhost:${config.port}`);
+    console.log(`   Health: http://localhost:${config.port}/health`);
+    console.log(`   Mode:   ${config.mockMode ? 'Mock (development)' : 'Production'}`);
+    console.log(`\n   Messaging endpoint: /api/messages`);
+    console.log(`   Notify endpoint:    /api/notify (X-Notify-Key required)`);
+
+    if (config.mockMode) {
+      console.log(`\nTip: run with --interactive for console testing:`);
+      console.log(`   npm run dev -- --interactive`);
+    }
+  });
+}

package/templates/teams-bot/_variants/bot.notification/src/mock/mockMode.ts

@@ -0,0 +1,55 @@
+import { TestAdapter, TurnContext } from 'botbuilder';
+import { NotificationBot } from '../bot/NotificationBot';
+import { MemoryConversationStore } from '../storage/conversationStore';
+
+// Create a test adapter for mock mode testing (memory store — nothing persists)
+export function createMockAdapter(): TestAdapter {
+  const bot = new NotificationBot(new MemoryConversationStore());
+  const adapter = new TestAdapter(async (context: TurnContext) => {
+    await bot.run(context);
+  });
+
+  return adapter;
+}
+
+// Interactive console testing
+export async function startInteractiveTest(): Promise<void> {
+  const readline = await import('readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  console.log('\n=== Notification Bot Mock Mode ===');
+  console.log('Try "subscribe" / "unsubscribe". Type "exit" to quit.\n');
+
+  const adapter = createMockAdapter();
+
+  const askQuestion = (): void => {
+    rl.question('You: ', async (input) => {
+      if (input.toLowerCase() === 'exit') {
+        console.log('Goodbye!');
+        rl.close();
+        process.exit(0);
+        return;
+      }
+
+      try {
+        await adapter.send(input).assertReply((activity) => {
+          if (activity.text) {
+            console.log(`Bot: ${activity.text}`);
+          }
+          if (activity.attachments && activity.attachments.length > 0) {
+            console.log('Bot: [Adaptive Card]');
+          }
+        });
+      } catch {
+        console.log('Bot: [No response]');
+      }
+
+      askQuestion();
+    });
+  };
+
+  askQuestion();
+}

package/templates/teams-bot/_variants/bot.notification/src/storage/conversationStore.ts

@@ -0,0 +1,84 @@
+import { ConversationReference } from 'botbuilder';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+
+export interface IConversationStore {
+  save(userId: string, reference: Partial<ConversationReference>): Promise<void>;
+  get(userId: string): Promise<Partial<ConversationReference> | null>;
+  getAll(): Promise<Map<string, Partial<ConversationReference>>>;
+  delete(userId: string): Promise<void>;
+}
+
+export class MemoryConversationStore implements IConversationStore {
+  private store = new Map<string, Partial<ConversationReference>>();
+
+  async save(userId: string, reference: Partial<ConversationReference>): Promise<void> {
+    this.store.set(userId, reference);
+  }
+
+  async get(userId: string): Promise<Partial<ConversationReference> | null> {
+    return this.store.get(userId) || null;
+  }
+
+  async getAll(): Promise<Map<string, Partial<ConversationReference>>> {
+    return new Map(this.store);
+  }
+
+  async delete(userId: string): Promise<void> {
+    this.store.delete(userId);
+  }
+}
+
+/**
+ * Write-through JSON-file store so subscriptions survive process restarts.
+ * On Azure App Service point it at /home/data/conversations.json — /home is
+ * persistent storage that also survives redeploys (unlike wwwroot).
+ */
+export class FileConversationStore implements IConversationStore {
+  private store = new Map<string, Partial<ConversationReference>>();
+  private loaded = false;
+
+  constructor(private filePath: string) {}
+
+  private async load(): Promise<void> {
+    if (this.loaded) return;
+    this.loaded = true;
+    try {
+      const raw = await fs.readFile(this.filePath, 'utf8');
+      const entries = JSON.parse(raw) as [string, Partial<ConversationReference>][];
+      this.store = new Map(entries);
+      console.log(`Loaded ${this.store.size} conversation reference(s) from ${this.filePath}`);
+    } catch (err: unknown) {
+      if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {
+        console.warn(`Could not read conversation store at ${this.filePath}:`, err);
+      }
+    }
+  }
+
+  private async persist(): Promise<void> {
+    await fs.mkdir(path.dirname(this.filePath), { recursive: true });
+    await fs.writeFile(this.filePath, JSON.stringify([...this.store.entries()], null, 2), 'utf8');
+  }
+
+  async save(userId: string, reference: Partial<ConversationReference>): Promise<void> {
+    await this.load();
+    this.store.set(userId, reference);
+    await this.persist();
+  }
+
+  async get(userId: string): Promise<Partial<ConversationReference> | null> {
+    await this.load();
+    return this.store.get(userId) || null;
+  }
+
+  async getAll(): Promise<Map<string, Partial<ConversationReference>>> {
+    await this.load();
+    return new Map(this.store);
+  }
+
+  async delete(userId: string): Promise<void> {
+    await this.load();
+    this.store.delete(userId);
+    await this.persist();
+  }
+}

package/templates/teams-bot/gitignore

@@ -0,0 +1,8 @@
+node_modules/
+dist/
+build/
+.data/
+.env
+.env.local
+.teams/
+*.log

package/templates/teams-bot/nodemon.json

@@ -0,0 +1,6 @@
+{
+  "watch": ["src"],
+  "ext": "ts",
+  "ignore": ["src/**/*.spec.ts"],
+  "exec": "ts-node src/index.ts"
+}

package/templates/teams-bot/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "{{projectName}}",
+  "version": "1.0.0",
+  "private": true,
+  "description": "{{projectName}} — Microsoft Teams bot (Bot Framework SDK v4)",
+  "scripts": {
+    "dev": "nodemon src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "botbuilder": "^4.22.1",
+    "dotenv": "^16.4.1",
+    "express": "^4.18.2"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.11.0",
+    "nodemon": "^3.0.3",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3"
+  }
+}

package/templates/teams-bot/src/adapters/botAdapter.ts

@@ -0,0 +1,45 @@
+import {
+  CloudAdapter,
+  ConfigurationBotFrameworkAuthentication,
+  ConfigurationBotFrameworkAuthenticationOptions,
+  TurnContext,
+} from 'botbuilder';
+import { config } from '../config';
+
+// Error handler for the adapter
+const onTurnErrorHandler = async (context: TurnContext, error: Error): Promise<void> => {
+  console.error(`\n [onTurnError] unhandled error: ${error}`);
+  console.error(error.stack);
+
+  await context.sendActivity('The bot encountered an error or bug.');
+
+  // Send a trace activity (visible in Bot Framework Emulator)
+  await context.sendTraceActivity(
+    'OnTurnError Trace',
+    `${error}`,
+    'https://www.botframework.com/schemas/error',
+    'TurnError'
+  );
+};
+
+export function createBotAdapter(): CloudAdapter {
+  // MicrosoftAppTenantId only applies to SingleTenant — a MultiTenant bot must
+  // authenticate against the common Bot Framework authority, so omit it there.
+  const authConfig: ConfigurationBotFrameworkAuthenticationOptions = config.mockMode
+    ? {} // Empty config for mock mode
+    : {
+        MicrosoftAppId: config.botId,
+        MicrosoftAppPassword: config.botPassword,
+        MicrosoftAppType: config.appType,
+        ...(config.appType === 'SingleTenant'
+          ? { MicrosoftAppTenantId: config.botTenantId }
+          : {}),
+      };
+
+  const botFrameworkAuth = new ConfigurationBotFrameworkAuthentication(authConfig);
+  const adapter = new CloudAdapter(botFrameworkAuth);
+
+  adapter.onTurnError = onTurnErrorHandler;
+
+  return adapter;
+}

package/templates/teams-bot/src/config.ts

@@ -0,0 +1,34 @@
+import dotenv from 'dotenv';
+
+// .env.local first (the teams-app-manager identity stage writes secrets there),
+// then .env — dotenv never overwrites a key that is already set.
+dotenv.config({ path: ['.env.local', '.env'] });
+
+export type AppType = 'SingleTenant' | 'MultiTenant';
+
+export const config = {
+  // Bot Framework credentials
+  botId: process.env.MICROSOFT_APP_ID || '',
+  botPassword: process.env.MICROSOFT_APP_PASSWORD || '',
+  botTenantId: process.env.MICROSOFT_APP_TENANT_ID || '',
+  // Must match the Azure Bot resource's app type; MultiTenant needs no tenant id.
+  appType: (process.env.MICROSOFT_APP_TYPE as AppType) || 'SingleTenant',
+
+  // Shared secret for POST /api/notify (notification bots). Empty = endpoint disabled.
+  notifyApiKey: process.env.NOTIFY_API_KEY || '',
+
+  // Conversation-reference persistence (notification bots).
+  conversationStorePath: process.env.CONVERSATION_STORE_PATH || './.data/conversations.json',
+
+  // Server configuration
+  port: parseInt(process.env.PORT || '3978', 10),
+
+  // Mock mode for development without an Azure registration
+  mockMode: process.env.MOCK_MODE === 'true',
+};
+
+export function validateConfig(): void {
+  if (!config.mockMode && !config.botId) {
+    console.warn('Warning: MICROSOFT_APP_ID not set. Set MOCK_MODE=true for local development.');
+  }
+}

package/templates/teams-bot/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}