@khester/create-dynamics-app 2.7.0 → 2.8.0

package/templates/teams-bot/_variants/bot.echo/src/bot/welcomeCard.ts

@@ -0,0 +1,134 @@
+import { CardFactory, Attachment } from 'botbuilder';
+
+export function createWelcomeCard(userName: string): Attachment {
+  const card = {
+    type: 'AdaptiveCard',
+    $schema: 'http://adaptivecards.io/schemas/adaptive-card.json',
+    version: '1.4',
+    body: [
+      {
+        type: 'TextBlock',
+        size: 'Large',
+        weight: 'Bolder',
+        text: `Welcome, ${userName}!`,
+        wrap: true,
+      },
+      {
+        type: 'TextBlock',
+        text: "I'm a Teams bot built with Bot Framework. Here's what I can do:",
+        wrap: true,
+        spacing: 'Medium',
+      },
+      {
+        type: 'FactSet',
+        facts: [
+          { title: 'Echo', value: 'I repeat what you say' },
+          { title: 'Help', value: 'Type "help" for commands' },
+          { title: 'About', value: 'Type "about" for info' },
+        ],
+      },
+      {
+        type: 'TextBlock',
+        text: 'Try sending me a message!',
+        wrap: true,
+        spacing: 'Medium',
+        color: 'Accent',
+      },
+    ],
+    actions: [
+      {
+        type: 'Action.Submit',
+        title: 'Say Hello',
+        data: { action: 'hello' },
+      },
+    ],
+  };
+
+  return CardFactory.adaptiveCard(card);
+}
+
+export function createHelpCard(): Attachment {
+  const card = {
+    type: 'AdaptiveCard',
+    $schema: 'http://adaptivecards.io/schemas/adaptive-card.json',
+    version: '1.4',
+    body: [
+      {
+        type: 'TextBlock',
+        size: 'Medium',
+        weight: 'Bolder',
+        text: 'Available Commands',
+        wrap: true,
+      },
+      {
+        type: 'Container',
+        items: [
+          {
+            type: 'TextBlock',
+            text: '**help** - Show this help message',
+            wrap: true,
+          },
+          {
+            type: 'TextBlock',
+            text: '**about** - Learn about this bot',
+            wrap: true,
+          },
+          {
+            type: 'TextBlock',
+            text: '**echo [message]** - Echo your message',
+            wrap: true,
+          },
+          {
+            type: 'TextBlock',
+            text: 'Or just type anything and I will echo it back!',
+            wrap: true,
+            spacing: 'Medium',
+            isSubtle: true,
+          },
+        ],
+      },
+    ],
+  };
+
+  return CardFactory.adaptiveCard(card);
+}
+
+export function createAboutCard(): Attachment {
+  const card = {
+    type: 'AdaptiveCard',
+    $schema: 'http://adaptivecards.io/schemas/adaptive-card.json',
+    version: '1.4',
+    body: [
+      {
+        type: 'TextBlock',
+        size: 'Medium',
+        weight: 'Bolder',
+        text: 'About This Bot',
+        wrap: true,
+      },
+      {
+        type: 'FactSet',
+        facts: [
+          { title: 'Name', value: '{{projectName}}' },
+          { title: 'Framework', value: 'Bot Framework SDK v4' },
+          { title: 'Scaffold', value: 'create-dynamics-app (teams-bot)' },
+        ],
+      },
+      {
+        type: 'TextBlock',
+        text: 'This bot demonstrates the fundamentals of building a Teams bot using the Bot Framework SDK.',
+        wrap: true,
+        spacing: 'Medium',
+      },
+    ],
+    actions: [
+      {
+        type: 'Action.OpenUrl',
+        title: 'View Documentation',
+        url: 'https://learn.microsoft.com/en-us/microsoftteams/platform/bots/what-are-bots',
+      },
+    ],
+  };
+
+  return CardFactory.adaptiveCard(card);
+}

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

@@ -0,0 +1,59 @@
+import express, { Request, Response } from 'express';
+import { config, validateConfig } from './config';
+import { createBotAdapter } from './adapters/botAdapter';
+import { TeamsBot } from './bot/TeamsBot';
+import { startInteractiveTest } from './mock/mockMode';
+
+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();
+  const bot = new TeamsBot();
+
+  // 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');
+    }
+  });
+
+  app.get('/', (_req: Request, res: Response) => {
+    res.json({
+      name: '{{projectName}}',
+      description: 'Microsoft Teams echo bot (Bot Framework SDK v4)',
+      endpoints: { messaging: '/api/messages', health: '/health' },
+      mockMode: config.mockMode,
+    });
+  });
+
+  app.listen(config.port, () => {
+    console.log(`\nBot 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`);
+
+    if (config.mockMode) {
+      console.log(`\nTip: run with --interactive for console testing:`);
+      console.log(`   npm run dev -- --interactive`);
+    }
+  });
+}

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"
+}