Build a production Microsoft Teams assistant with the Agents SDK

{
  "name": "production-teams-assistant",
  "version": "1.0.0",
  "private": true,
  "type": "module",
  "engines": {
    "node": "22.22.2"
  },
  "scripts": {
    "start": "node src/teams.mjs",
    "worker": "node src/teams.mjs --worker",
    "check": "node --check src/teams.mjs && node --check test/teams.test.mjs",
    "test": "node --test test/teams.test.mjs"
  },
  "dependencies": {
    "@microsoft/agents-hosting": "1.7.1",
    "express": "5.1.0",
    "helmet": "8.1.0",
    "openai": "7.1.0",
    "pg": "8.16.3",
    "pino": "9.7.0"
  }
}

PORT=3978
NODE_ENV=production
# Microsoft 365 Agents SDK reads these exact names.
tenantId=11111111-1111-1111-1111-111111111111
clientId=22222222-2222-2222-2222-222222222222
# For local development only; omit in Azure production and use the matching
# user-assigned managed identity or federated identity credential.
clientSecret=resolve-from-local-secret-store
ALLOWED_TENANT_IDS=11111111-1111-1111-1111-111111111111
IDENTITY_HMAC_SECRET=resolve-from-secret-store
DATABASE_URL=postgres://teams_runtime@db.internal/teams_assistant?sslmode=verify-full
OPENAI_API_KEY=resolve-from-secret-store
OPENAI_MODEL=gpt-5.4-nano
MAX_MESSAGE_CHARS=6000
MAX_OUTPUT_CHARS=8000
REQUESTS_PER_MINUTE=12
STATE_TTL_HOURS=24
APPROVAL_TTL_MINUTES=30
ACTION_DISPATCH_URL=https://dispatcher.example.internal/v1/teams-actions
ACTION_DISPATCH_TOKEN=resolve-from-separate-secret-store
OTEL_EXPORTER_OTLP_ENDPOINT=https://otel.example.internal/v1/traces

BEGIN;

CREATE TABLE IF NOT EXISTS bot_schema_revision (
  revision text PRIMARY KEY,
  applied_at timestamptz NOT NULL DEFAULT now()
);

INSERT INTO bot_schema_revision (revision)
VALUES ('teams-v1')
ON CONFLICT (revision) DO NOTHING;

CREATE TABLE IF NOT EXISTS teams_tenant_policy (
  tenant_id uuid PRIMARY KEY,
  display_name text NOT NULL,
  active boolean NOT NULL DEFAULT false,
  policy_revision text NOT NULL,
  created_at timestamptz NOT NULL DEFAULT now(),
  CHECK (char_length(policy_revision) BETWEEN 1 AND 80)
);

CREATE TABLE IF NOT EXISTS teams_events (
  tenant_id uuid NOT NULL REFERENCES teams_tenant_policy(tenant_id),
  event_id text NOT NULL,
  conversation_id text NOT NULL,
  actor_hash text NOT NULL,
  activity_type text NOT NULL,
  body_hash text NOT NULL,
  status text NOT NULL DEFAULT 'received'
    CHECK (status IN ('received', 'processing', 'completed', 'refused', 'failed')),
  response_activity_id text,
  created_at timestamptz NOT NULL DEFAULT now(),
  completed_at timestamptz,
  PRIMARY KEY (tenant_id, event_id),
  CHECK (char_length(event_id) BETWEEN 1 AND 240),
  CHECK (char_length(conversation_id) BETWEEN 1 AND 500)
);

CREATE TABLE IF NOT EXISTS teams_conversation_state (
  tenant_id uuid NOT NULL REFERENCES teams_tenant_policy(tenant_id),
  conversation_id text NOT NULL,
  state_json jsonb NOT NULL DEFAULT '{}'::jsonb,
  expires_at timestamptz NOT NULL,
  updated_at timestamptz NOT NULL DEFAULT now(),
  PRIMARY KEY (tenant_id, conversation_id),
  CHECK (jsonb_typeof(state_json) = 'object')
);

CREATE TABLE IF NOT EXISTS teams_operators (
  tenant_id uuid NOT NULL REFERENCES teams_tenant_policy(tenant_id),
  actor_hash text NOT NULL,
  role text NOT NULL CHECK (role IN ('approver', 'auditor')),
  enabled boolean NOT NULL DEFAULT true,
  created_at timestamptz NOT NULL DEFAULT now(),
  PRIMARY KEY (tenant_id, actor_hash, role)
);

CREATE TABLE IF NOT EXISTS teams_action_drafts (
  id uuid PRIMARY KEY,
  tenant_id uuid NOT NULL REFERENCES teams_tenant_policy(tenant_id),
  conversation_id text NOT NULL,
  requested_by_hash text NOT NULL,
  action_kind text NOT NULL CHECK (action_kind IN ('notify_operations')),
  exact_payload jsonb NOT NULL,
  payload_hash text NOT NULL,
  state text NOT NULL DEFAULT 'draft'
    CHECK (state IN ('draft', 'approved', 'dispatching', 'dispatched', 'cancelled', 'expired', 'ambiguous', 'failed')),
  approved_by_hash text,
  approved_at timestamptz,
  expires_at timestamptz NOT NULL,
  dispatched_at timestamptz,
  external_id text,
  created_at timestamptz NOT NULL DEFAULT now(),
  CHECK (jsonb_typeof(exact_payload) = 'object')
);

CREATE INDEX IF NOT EXISTS teams_action_dispatch_idx
  ON teams_action_drafts (state, created_at)
  WHERE state = 'approved';

CREATE TABLE IF NOT EXISTS teams_rate_buckets (
  tenant_id uuid NOT NULL REFERENCES teams_tenant_policy(tenant_id),
  scope_hash text NOT NULL,
  minute_bucket timestamptz NOT NULL,
  request_count integer NOT NULL DEFAULT 1 CHECK (request_count > 0),
  PRIMARY KEY (tenant_id, scope_hash, minute_bucket)
);

CREATE TABLE IF NOT EXISTS bot_audit (
  id bigserial PRIMARY KEY,
  tenant_id uuid,
  event_class text NOT NULL,
  subject_hash text,
  object_id text,
  detail jsonb NOT NULL DEFAULT '{}'::jsonb,
  created_at timestamptz NOT NULL DEFAULT now(),
  CHECK (jsonb_typeof(detail) = 'object')
);

COMMIT;

import { createHash, createHmac, randomUUID } from "node:crypto";
import { pathToFileURL } from "node:url";
import {
  AgentApplication,
  CloudAdapter,
  MemoryStorage,
  authorizeJWT,
  loadAuthConfigFromEnv
} from "@microsoft/agents-hosting";
import express from "express";
import helmet from "helmet";
import OpenAI from "openai";
import pg from "pg";
import pino from "pino";

const CARD_CONTENT_TYPE = "application/vnd.microsoft.card.adaptive";
const INVOKE_NAME = "adaptiveCard/action";

export function normalizeTenantId(value) {
  const tenantId = String(value || "").trim().toLowerCase();
  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(tenantId)) {
    throw new Error("invalid_tenant_id");
  }
  return tenantId;
}

export function stableHash(value, secret) {
  return createHmac("sha256", secret).update(String(value)).digest("hex");
}

export function boundedText(value, maximum) {
  const text = String(value || "").replace(/\u0000/g, "").trim();
  if (!text || text.length > maximum) throw new Error("message_out_of_bounds");
  return text;
}

export function exactPayloadHash(value) {
  return createHash("sha256").update(JSON.stringify(value)).digest("hex");
}

export function safeTeamsText(value, maximum = 8000) {
  return String(value || "")
    .replace(/<at>[\s\S]*?<\/at>/gi, "[mention removed]")
    .replace(/https?:\/\/[^\s)]+/gi, "[link removed]")
    .slice(0, maximum);
}

export function approvalCard({ draftId, summary, expiresAt, state = "draft" }) {
  const actions = state === "draft"
    ? [
        {
          type: "Action.Execute",
          title: "Approve exact request",
          verb: "approveDraft",
          data: { draftId }
        },
        {
          type: "Action.Execute",
          title: "Cancel",
          verb: "cancelDraft",
          data: { draftId }
        }
      ]
    : [];
  return {
    type: "AdaptiveCard",
    version: "1.5",
    body: [
      { type: "TextBlock", weight: "Bolder", text: "Human approval required" },
      { type: "TextBlock", wrap: true, text: safeTeamsText(summary, 600) },
      {
        type: "FactSet",
        facts: [
          { title: "State", value: state },
          { title: "Expires", value: new Date(expiresAt).toISOString() },
          { title: "Draft", value: draftId }
        ]
      }
    ],
    actions
  };
}

export function invokeResponse(card, statusCode = 200) {
  return {
    type: "invokeResponse",
    value: {
      status: statusCode,
      body: {
        statusCode,
        type: CARD_CONTENT_TYPE,
        value: card
      }
    }
  };
}

function asCardAttachment(card) {
  return { contentType: CARD_CONTENT_TYPE, content: card };
}

function parseAllowlist(value) {
  const tenants = String(value || "")
    .split(",")
    .map((item) => item.trim())
    .filter(Boolean)
    .map(normalizeTenantId);
  if (!tenants.length) throw new Error("missing_allowed_tenant_ids");
  return new Set(tenants);
}

function required(env, name) {
  const value = env[name];
  if (!value) throw new Error("missing_" + name.toLowerCase());
  return value;
}

function readActivityScope(activity, identitySecret) {
  if (activity.channelId !== "msteams") throw new Error("wrong_channel");
  const tenantId = normalizeTenantId(activity.channelData?.tenant?.id);
  const conversationId = String(activity.conversation?.id || "");
  const actorId = String(activity.from?.aadObjectId || activity.from?.id || "");
  const eventId = String(activity.id || "");
  if (!conversationId || !actorId || !eventId) throw new Error("missing_activity_scope");
  return {
    tenantId,
    conversationId,
    eventId,
    actorHash: stableHash(tenantId + ":" + actorId, identitySecret)
  };
}

export function createTeamsRuntime(env = process.env) {
  const identitySecret = required(env, "IDENTITY_HMAC_SECRET");
  const allowedTenants = parseAllowlist(required(env, "ALLOWED_TENANT_IDS"));
  const maximumMessage = Number(env.MAX_MESSAGE_CHARS || 6000);
  const maximumOutput = Number(env.MAX_OUTPUT_CHARS || 8000);
  const requestsPerMinute = Number(env.REQUESTS_PER_MINUTE || 12);
  const approvalTtl = Number(env.APPROVAL_TTL_MINUTES || 30);
  const stateTtl = Number(env.STATE_TTL_HOURS || 24);
  if (
    identitySecret.length < 32 ||
    !Number.isInteger(maximumMessage) ||
    maximumMessage < 256 ||
    maximumMessage > 16000 ||
    !Number.isInteger(maximumOutput) ||
    maximumOutput < 512 ||
    maximumOutput > 16000 ||
    !Number.isInteger(requestsPerMinute) ||
    requestsPerMinute < 1 ||
    requestsPerMinute > 120 ||
    !Number.isInteger(approvalTtl) ||
    approvalTtl < 5 ||
    approvalTtl > 120 ||
    !Number.isInteger(stateTtl) ||
    stateTtl < 1 ||
    stateTtl > 168
  ) {
    throw new Error("invalid_runtime_limits");
  }

  const pool = new pg.Pool({
    connectionString: required(env, "DATABASE_URL"),
    max: 12,
    statement_timeout: 12_000
  });
  const openai = new OpenAI({
    apiKey: required(env, "OPENAI_API_KEY"),
    timeout: 30_000,
    maxRetries: 1
  });
  const logger = pino({
    redact: {
      paths: [
        "req.headers.authorization",
        "*.text",
        "*.body",
        "*.content",
        "*.clientSecret",
        "*.ACTION_DISPATCH_TOKEN"
      ],
      censor: "[redacted]"
    }
  });

  async function requireTenant(client, tenantId) {
    if (!allowedTenants.has(tenantId)) throw new Error("tenant_not_allowlisted");
    const result = await client.query(
      "SELECT policy_revision FROM teams_tenant_policy WHERE tenant_id=$1 AND active=true",
      [tenantId]
    );
    if (!result.rowCount) throw new Error("tenant_not_active");
    return result.rows[0].policy_revision;
  }

  async function consumeRate(client, tenantId, actorHash) {
    const result = await client.query(
      "INSERT INTO teams_rate_buckets (tenant_id,scope_hash,minute_bucket,request_count) " +
        "VALUES ($1,$2,date_trunc('minute',now()),1) " +
        "ON CONFLICT (tenant_id,scope_hash,minute_bucket) DO UPDATE " +
        "SET request_count=teams_rate_buckets.request_count+1 " +
        "WHERE teams_rate_buckets.request_count < $3 RETURNING request_count",
      [tenantId, actorHash, requestsPerMinute]
    );
    if (!result.rowCount) throw new Error("rate_limited");
  }

  async function claimEvent(client, scope, activity, bodyText) {
    const inserted = await client.query(
      "INSERT INTO teams_events " +
        "(tenant_id,event_id,conversation_id,actor_hash,activity_type,body_hash) " +
        "VALUES ($1,$2,$3,$4,$5,$6) ON CONFLICT DO NOTHING RETURNING event_id",
      [
        scope.tenantId,
        scope.eventId,
        scope.conversationId,
        scope.actorHash,
        String(activity.type || "unknown").slice(0, 40),
        exactPayloadHash(bodyText)
      ]
    );
    return inserted.rowCount === 1;
  }

  async function audit(client, scope, eventClass, objectId, detail = {}) {
    await client.query(
      "INSERT INTO bot_audit (tenant_id,event_class,subject_hash,object_id,detail) " +
        "VALUES ($1,$2,$3,$4,$5::jsonb)",
      [
        scope.tenantId,
        eventClass,
        scope.actorHash,
        objectId || null,
        JSON.stringify(detail)
      ]
    );
  }

  async function recordConversationState(client, scope, state) {
    await client.query(
      "INSERT INTO teams_conversation_state " +
        "(tenant_id,conversation_id,state_json,expires_at) " +
        "VALUES ($1,$2,$3::jsonb,now()+($4||' hours')::interval) " +
        "ON CONFLICT (tenant_id,conversation_id) DO UPDATE SET " +
        "state_json=excluded.state_json,expires_at=excluded.expires_at,updated_at=now()",
      [
        scope.tenantId,
        scope.conversationId,
        JSON.stringify(state),
        String(stateTtl)
      ]
    );
  }

  async function createDraft(client, scope, summary) {
    const id = randomUUID();
    const exactPayload = {
      kind: "notify_operations",
      tenantId: scope.tenantId,
      conversationId: scope.conversationId,
      summary: safeTeamsText(summary, 600)
    };
    const payloadHash = exactPayloadHash(exactPayload);
    const inserted = await client.query(
      "INSERT INTO teams_action_drafts " +
        "(id,tenant_id,conversation_id,requested_by_hash,action_kind,exact_payload,payload_hash,expires_at) " +
        "VALUES ($1,$2,$3,$4,'notify_operations',$5::jsonb,$6,now()+($7||' minutes')::interval) " +
        "RETURNING id,exact_payload,payload_hash,state,expires_at",
      [
        id,
        scope.tenantId,
        scope.conversationId,
        scope.actorHash,
        JSON.stringify(exactPayload),
        payloadHash,
        String(approvalTtl)
      ]
    );
    await audit(client, scope, "action_draft_created", id, {
      actionKind: "notify_operations",
      payloadHash
    });
    return inserted.rows[0];
  }

  async function approveOrCancel(client, scope, verb, draftId) {
    await client.query("BEGIN");
    try {
      await requireTenant(client, scope.tenantId);
      const operator = await client.query(
        "SELECT 1 FROM teams_operators " +
          "WHERE tenant_id=$1 AND actor_hash=$2 AND role='approver' AND enabled=true",
        [scope.tenantId, scope.actorHash]
      );
      if (!operator.rowCount) throw new Error("approver_required");
      const result = await client.query(
        "SELECT * FROM teams_action_drafts " +
          "WHERE id=$1 AND tenant_id=$2 AND conversation_id=$3 FOR UPDATE",
        [draftId, scope.tenantId, scope.conversationId]
      );
      if (!result.rowCount) throw new Error("draft_not_found");
      const draft = result.rows[0];
      if (draft.state !== "draft") throw new Error("draft_not_pending");
      if (Date.parse(draft.expires_at) <= Date.now()) {
        await client.query(
          "UPDATE teams_action_drafts SET state='expired' WHERE id=$1",
          [draftId]
        );
        throw new Error("draft_expired");
      }
      if (exactPayloadHash(draft.exact_payload) !== draft.payload_hash) {
        throw new Error("draft_payload_changed");
      }
      const next = verb === "approveDraft" ? "approved" : "cancelled";
      await client.query(
        "UPDATE teams_action_drafts SET state=$2,approved_by_hash=$3," +
          "approved_at=CASE WHEN $2='approved' THEN now() ELSE NULL END WHERE id=$1",
        [draftId, next, scope.actorHash]
      );
      await audit(client, scope, "action_draft_" + next, draftId, {
        payloadHash: draft.payload_hash
      });
      await client.query("COMMIT");
      return { ...draft, state: next };
    } catch (error) {
      await client.query("ROLLBACK");
      throw error;
    }
  }

  async function moderateText(text) {
    const result = await openai.moderations.create({
      model: "omni-moderation-latest",
      input: text
    });
    return !result.results.some((item) => item.flagged);
  }

  async function answerQuestion(text) {
    if (!(await moderateText(text))) return "I cannot help with that request.";
    const result = await openai.responses.create({
      model: env.OPENAI_MODEL || "gpt-5.4-nano",
      input: [
        {
          role: "developer",
          content:
            "Answer as a concise Teams assistant. Do not claim to perform actions. " +
            "Do not emit mentions, executable instructions, secrets, or external links. " +
            "Route consequential work to a human-approved draft."
        },
        { role: "user", content: text }
      ],
      max_output_tokens: 900,
      store: false
    });
    const output = safeTeamsText(result.output_text, maximumOutput);
    if (!output || !(await moderateText(output))) {
      return "I could not produce a safe response.";
    }
    return output;
  }

  async function withScope(context, operation) {
    const scope = readActivityScope(context.activity, identitySecret);
    const client = await pool.connect();
    try {
      await requireTenant(client, scope.tenantId);
      return await operation(client, scope);
    } finally {
      client.release();
    }
  }

  const application = new AgentApplication({ storage: new MemoryStorage() });

  application.onConversationUpdate("membersAdded", async (context) => {
    await withScope(context, async (client, scope) => {
      const isNew = await claimEvent(client, scope, context.activity, "membersAdded");
      if (!isNew) return;
      await context.sendActivity(
        "OneLiners Teams assistant is ready. Use /help, /ask <question>, or " +
          "/request <exact operations notification>. Requests never execute without approval."
      );
      await client.query(
        "UPDATE teams_events SET status='completed',completed_at=now() " +
          "WHERE tenant_id=$1 AND event_id=$2",
        [scope.tenantId, scope.eventId]
      );
    });
  });

  application.onActivity("message", async (context) => {
    await withScope(context, async (client, scope) => {
      await consumeRate(client, scope.tenantId, scope.actorHash);
      const body = boundedText(context.activity.text, maximumMessage);
      const isNew = await claimEvent(client, scope, context.activity, body);
      if (!isNew) return;
      if (context.activity.attachments?.length) {
        await context.sendActivity(
          "Attachments are disabled in this baseline. Paste bounded, non-sensitive text instead."
        );
        await client.query(
          "UPDATE teams_events SET status='refused',completed_at=now() " +
            "WHERE tenant_id=$1 AND event_id=$2",
          [scope.tenantId, scope.eventId]
        );
        return;
      }

      let responseActivity;
      if (body === "/help") {
        responseActivity = await context.sendActivity(
          "Use /ask <question> for a read-only answer. Use /request <exact summary> " +
            "to create an immutable draft that a configured tenant approver must review."
        );
      } else if (body.startsWith("/request ")) {
        const summary = boundedText(body.slice(9), 600);
        const draft = await createDraft(client, scope, summary);
        responseActivity = await context.sendActivity({
          attachments: [
            asCardAttachment(
              approvalCard({
                draftId: draft.id,
                summary: draft.exact_payload.summary,
                expiresAt: draft.expires_at
              })
            )
          ]
        });
      } else if (body.startsWith("/ask ")) {
        const question = boundedText(body.slice(5), maximumMessage);
        await context.sendActivity({ type: "typing" });
        responseActivity = await context.sendActivity(await answerQuestion(question));
        await recordConversationState(client, scope, {
          lastCommand: "ask",
          responseClass: "read_only",
          updatedAt: new Date().toISOString()
        });
      } else {
        responseActivity = await context.sendActivity(
          "Unsupported command. Use /help, /ask <question>, or /request <exact summary>."
        );
      }
      await client.query(
        "UPDATE teams_events SET status='completed',response_activity_id=$3,completed_at=now() " +
          "WHERE tenant_id=$1 AND event_id=$2",
        [scope.tenantId, scope.eventId, String(responseActivity?.id || "")]
      );
    });
  });

  application.onActivity("invoke", async (context) => {
    await withScope(context, async (client, scope) => {
      if (context.activity.name !== INVOKE_NAME) throw new Error("unsupported_invoke");
      await consumeRate(client, scope.tenantId, scope.actorHash);
      const isNew = await claimEvent(
        client,
        scope,
        context.activity,
        JSON.stringify(context.activity.value || {})
      );
      if (!isNew) {
        await context.sendActivity(
          invokeResponse({
            type: "AdaptiveCard",
            version: "1.5",
            body: [
              {
                type: "TextBlock",
                weight: "Bolder",
                text: "This action was already processed."
              },
              {
                type: "TextBlock",
                wrap: true,
                text: "Refresh the conversation before taking another action."
              }
            ],
            actions: []
          })
        );
        return;
      }
      const action = context.activity.value?.action;
      const verb = String(action?.verb || "");
      const draftId = String(action?.data?.draftId || "");
      if (!["approveDraft", "cancelDraft"].includes(verb)) {
        throw new Error("unsupported_action_verb");
      }
      if (!/^[0-9a-f-]{36}$/i.test(draftId)) throw new Error("invalid_draft_id");
      const draft = await approveOrCancel(client, scope, verb, draftId);
      await context.sendActivity(
        invokeResponse(
          approvalCard({
            draftId,
            summary: draft.exact_payload.summary,
            expiresAt: draft.expires_at,
            state: draft.state
          })
        )
      );
      await client.query(
        "UPDATE teams_events SET status='completed',completed_at=now() " +
          "WHERE tenant_id=$1 AND event_id=$2",
        [scope.tenantId, scope.eventId]
      );
    });
  });

  async function dispatchOne() {
    const client = await pool.connect();
    try {
      await client.query("BEGIN");
      const result = await client.query(
        "SELECT * FROM teams_action_drafts WHERE state='approved' " +
          "AND expires_at>now() ORDER BY created_at FOR UPDATE SKIP LOCKED LIMIT 1"
      );
      if (!result.rowCount) {
        await client.query("ROLLBACK");
        return false;
      }
      const draft = result.rows[0];
      if (exactPayloadHash(draft.exact_payload) !== draft.payload_hash) {
        throw new Error("approved_payload_changed");
      }
      await client.query(
        "UPDATE teams_action_drafts SET state='dispatching' WHERE id=$1",
        [draft.id]
      );
      await client.query("COMMIT");

      let response;
      try {
        response = await fetch(required(env, "ACTION_DISPATCH_URL"), {
          method: "POST",
          redirect: "error",
          headers: {
            authorization: "Bearer " + required(env, "ACTION_DISPATCH_TOKEN"),
            "content-type": "application/json",
            "idempotency-key": draft.id
          },
          body: JSON.stringify({
            draftId: draft.id,
            payloadHash: draft.payload_hash,
            action: draft.exact_payload
          }),
          signal: AbortSignal.timeout(10_000)
        });
      } catch {
        await pool.query(
          "UPDATE teams_action_drafts SET state='ambiguous' WHERE id=$1 AND state='dispatching'",
          [draft.id]
        );
        return true;
      }
      if (!response.ok) {
        const state = response.status >= 500 ? "ambiguous" : "failed";
        await pool.query(
          "UPDATE teams_action_drafts SET state=$2 WHERE id=$1 AND state='dispatching'",
          [draft.id, state]
        );
        return true;
      }
      const externalId = response.headers.get("x-operation-id");
      await pool.query(
        "UPDATE teams_action_drafts SET state='dispatched',external_id=$2,dispatched_at=now() " +
          "WHERE id=$1 AND state='dispatching'",
        [draft.id, externalId]
      );
      return true;
    } catch (error) {
      await client.query("ROLLBACK").catch(() => {});
      throw error;
    } finally {
      client.release();
    }
  }

  return { application, dispatchOne, logger, pool };
}

export async function startTeamsServer(env = process.env) {
  const authConfig = loadAuthConfigFromEnv();
  const adapter = new CloudAdapter(authConfig);
  const runtime = createTeamsRuntime(env);
  const server = express();
  server.disable("x-powered-by");
  server.use(helmet({ contentSecurityPolicy: false }));
  server.get("/healthz", (_request, response) => response.status(200).send("ok"));
  server.post(
    "/api/messages",
    authorizeJWT(authConfig),
    express.json({ limit: "96kb", strict: true, type: "application/json" }),
    async (request, response, next) => {
      try {
        await adapter.process(request, response, async (context) => {
          await runtime.application.run(context);
        });
      } catch (error) {
        next(error);
      }
    }
  );
  server.use((error, _request, response, _next) => {
    runtime.logger.warn({ errorClass: String(error?.message || "teams_error") }, "teams_request_failed");
    if (!response.headersSent) response.status(400).json({ error: "request_failed" });
  });
  server.listen(Number(env.PORT || 3978), "0.0.0.0");
}

export async function startTeamsDispatcher(env = process.env) {
  const runtime = createTeamsRuntime(env);
  for (;;) {
    const claimed = await runtime.dispatchOne();
    await new Promise((resolve) => setTimeout(resolve, claimed ? 100 : 1000));
  }
}

if (import.meta.url === pathToFileURL(process.argv[1]).href) {
  if (process.argv.includes("--worker")) await startTeamsDispatcher();
  else await startTeamsServer();
}

import assert from "node:assert/strict";
import test from "node:test";
import {
  approvalCard,
  boundedText,
  exactPayloadHash,
  invokeResponse,
  normalizeTenantId,
  safeTeamsText,
  stableHash
} from "../src/teams.mjs";

test("tenant identifiers are normalized and bounded", () => {
  assert.equal(
    normalizeTenantId("11111111-1111-4111-8111-111111111111"),
    "11111111-1111-4111-8111-111111111111"
  );
  assert.throws(() => normalizeTenantId("common"), /invalid_tenant_id/);
  assert.throws(() => boundedText("x".repeat(601), 600), /message_out_of_bounds/);
});

test("identity hashes remain tenant-scoped", () => {
  const secret = "test-secret-with-at-least-thirty-two-bytes";
  const first = stableHash("tenant-a:actor-1", secret);
  const second = stableHash("tenant-b:actor-1", secret);
  assert.equal(first.length, 64);
  assert.notEqual(first, second);
});

test("Teams text removes mentions and links", () => {
  assert.equal(
    safeTeamsText("<at>Admin</at> see https://example.com/runbook"),
    "[mention removed] see [link removed]"
  );
});

test("approval card binds Action.Execute to one immutable draft", () => {
  const card = approvalCard({
    draftId: "11111111-1111-4111-8111-111111111111",
    summary: "Notify operations about the reviewed incident.",
    expiresAt: "2026-07-29T12:30:00.000Z"
  });
  assert.equal(card.version, "1.5");
  assert.equal(card.actions[0].type, "Action.Execute");
  assert.equal(card.actions[0].verb, "approveDraft");
  assert.equal(
    card.actions[0].data.draftId,
    "11111111-1111-4111-8111-111111111111"
  );
  assert.equal(card.actions[1].verb, "cancelDraft");
});

test("invoke response replaces the card without executing client data", () => {
  const card = approvalCard({
    draftId: "11111111-1111-4111-8111-111111111111",
    summary: "Reviewed",
    expiresAt: "2026-07-29T12:30:00.000Z",
    state: "approved"
  });
  const response = invokeResponse(card);
  assert.equal(response.type, "invokeResponse");
  assert.equal(response.value.status, 200);
  assert.equal(response.value.body.type, "application/vnd.microsoft.card.adaptive");
  assert.equal(response.value.body.value.actions.length, 0);
});

test("exact payload hashes change with exact approved content", () => {
  const first = exactPayloadHash({ kind: "notify_operations", summary: "A" });
  const second = exactPayloadHash({ kind: "notify_operations", summary: "B" });
  assert.equal(first.length, 64);
  assert.notEqual(first, second);
});

apiVersion: v1
kind: ServiceAccount
metadata:
  name: teams-assistant
  annotations:
    azure.workload.identity/client-id: "22222222-2222-2222-2222-222222222222"
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: teams-assistant-ingress
spec:
  replicas: 3
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 0
      maxSurge: 1
  selector:
    matchLabels:
      app: teams-assistant
      role: ingress
  template:
    metadata:
      labels:
        app: teams-assistant
        role: ingress
        azure.workload.identity/use: "true"
    spec:
      serviceAccountName: teams-assistant
      automountServiceAccountToken: false
      containers:
        - name: ingress
          image: registry.example/teams-assistant@sha256:replace-reviewed-digest
          args: ["node", "src/teams.mjs"]
          ports:
            - containerPort: 3978
          envFrom:
            - configMapRef:
                name: teams-assistant-policy
            - secretRef:
                name: teams-assistant-secrets
          readinessProbe:
            httpGet:
              path: /healthz
              port: 3978
            initialDelaySeconds: 3
            periodSeconds: 5
          livenessProbe:
            httpGet:
              path: /healthz
              port: 3978
            initialDelaySeconds: 15
            periodSeconds: 10
          resources:
            requests:
              cpu: 100m
              memory: 160Mi
            limits:
              cpu: "1"
              memory: 512Mi
          securityContext:
            allowPrivilegeEscalation: false
            readOnlyRootFilesystem: true
            runAsNonRoot: true
            capabilities:
              drop: ["ALL"]
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: teams-assistant-dispatcher
spec:
  replicas: 1
  strategy:
    type: Recreate
  selector:
    matchLabels:
      app: teams-assistant
      role: dispatcher
  template:
    metadata:
      labels:
        app: teams-assistant
        role: dispatcher
        azure.workload.identity/use: "true"
    spec:
      serviceAccountName: teams-assistant
      automountServiceAccountToken: false
      containers:
        - name: dispatcher
          image: registry.example/teams-assistant@sha256:replace-reviewed-digest
          args: ["node", "src/teams.mjs", "--worker"]
          envFrom:
            - configMapRef:
                name: teams-assistant-policy
            - secretRef:
                name: teams-dispatcher-secrets
          resources:
            requests:
              cpu: 50m
              memory: 128Mi
            limits:
              cpu: "0.5"
              memory: 384Mi
          securityContext:
            allowPrivilegeEscalation: false
            readOnlyRootFilesystem: true
            runAsNonRoot: true
            capabilities:
              drop: ["ALL"]
---
apiVersion: v1
kind: Service
metadata:
  name: teams-assistant
spec:
  selector:
    app: teams-assistant
    role: ingress
  ports:
    - name: https-upstream
      port: 80
      targetPort: 3978