jfet97

Personal Teams MCP setup

Set up a personal Microsoft Teams MCP for this colleague, using their own Microsoft account and the existing Entra registration. Docker is optional.

1. Identify their OS and AI client. Use local stdio unless they want a persistent Docker/HTTP service.

2. Use https://github.com/ssasuoirafen/teams-mcp-server. Read its README and project instructions; pin a verified commit. Our tested base was b0d7ba4f59319fe99e596de2e0e52151c5a8710f. Install uv and a compatible Python version (project minimum: 3.12).

3. Configure these environment variables:

jfet97

function mergeSort(array, start, end) {
    if (array.length <= 1) return array;
  
    let slices = []
    let nextSlices = []
    let nextSlicesTemp = []
    let unit = 2 // then 4 then 8 and so on

    const mid = Math.floor((start + end) / 2);
    if(mid + 1 <= end) {

jfet97

// https://hackage.haskell.org/package/justified-containers-0.3.0.0/docs/src/Data-Map-Justified.html
// TODO: not all operations have been translated into TS
// TODO: is it possible to avoid continuations? Don't think so, TS doesn't support existentials

export type JMap<PH, K, V> = { readonly carrier: ReadonlyMap<K, V>, readonly proof: PH, readonly brand: unique symbol }

export type JKey<PH, K> = { readonly carrier: K, readonly proof: PH, readonly brand: unique symbol }

// internals

jfet97

{

    function flatten_it(a) {
        let res = [...a]

        while (res.some(el => Array.isArray(el))) {
            for (let i = 0; i < res.length; i++) {
                if (Array.isArray(res[i])) {
                    res.splice(i, 1, ...res[i])
                }

jfet97

function invert(tree, toInvR = [], path = [], res = null) {
  // tree == nodo corrente
  // path[path.length - 1] == nodo padre

  if (!tree) {
    return null;
  }

  const parent = path[path.length - 1]; // is undefined iif res === null
  const newNode = Node(tree.value);

jfet97

type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y
  ? 1
  : 2
  ? true
  : false;

interface StringCostrainType {
  readonly _N: number;
  readonly _E: unknown;
  readonly _type: "exact" | "atleast" | "atmost";

jfet97

export type Extends<A, B, Y = unknown, N = never> =
    [A] extends [never] // <- ottimizzo evitando la distribution, altrimenti nello step dopo farei tot A extends B identici
    ? N
    : A extends B
      ? Y
      : N
      
// type IsNever<A> = A extends never ? true : false risulta in never se A = never
// (entra in gioco la distribution, ma non c'è nulla da distribuire!)
//

jfet97

type AllKeys<T> = T extends unknown ? keyof T : never;
type Lookup<T, K extends PropertyKey> = T extends any ? T[K & keyof T] : never;
type MergeAsUnion<T> = { [K in AllKeys<T>]: Lookup<T, K> };

type IfEquals<T, U, Y = unknown, N = never> = (<V>() => V extends T
  ? 1
  : 2) extends <V>() => V extends U ? 1 : 2
  ? Y
  : N;

jfet97

// 6 any perché l'ultimo "viene inferito" come la stringa vuota "", gli altri 5 acchiappano un carattere ciascuno
type String5<T extends string> = T extends `${any}${any}${any}${any}${any}${any}` ? T : "The string must be at least 5 characters long" // oppure never

type testmeno1 = String5<string> // nope
type test0 = String5<""> // nope
type test1 = String5<"a"> // nope
type test2 = String5<"ab"> // nope
type test3 = String5<"abc"> // nope
type test4 = String5<"abcd"> // nope
type test5 = String5<"abcde"> // "abcde"

jfet97

type IndexesKeysOfTuple<T extends any[]> = Exclude<
  keyof T & string,
  keyof any[]
>;

type NumberToString<N extends number | bigint> = `${N}`;

type ValidIndex<T extends any[], I extends number> = any[] extends T
  ? number // T is an array but not a tuple type
  : NumberToString<I> extends IndexesKeysOfTuple<T>