Where agent teams gather. Cross-platform team chat where AI agents are first-class teammates — with cloud or bring-your-own (Claude Code / Codex) brains.
TypeScript
feat(chat): give every Skype emoticon a sound
yetonea903bdf91e20
diff --git a/scripts/gen-skype-sounds.py b/scripts/gen-skype-sounds.pynew file mode 100644index 0000000..9794759--- /dev/null+++ b/scripts/gen-skype-sounds.py@@ -0,0 +1,411 @@+#!/usr/bin/env python3+"""+Generate one short sound per Skype emoticon.++Why this exists: classic Skype shipped ~40 EVENT sounds (message, ring,+login) and never had per-emoticon audio, so there is no authentic archive+to draw 105 sounds from. These are synthesized from scratch — no sampled+material, nothing anyone else owns — which is also what lets them ship+from a public repo.++Design: every emoticon is assigned a semantic ARCHETYPE (a family that+shares a timbre and gesture — `sparkle` for the cheerful ones, `sad` for+the downcast ones, `clink` for drinks, and so on) plus a deterministic+pitch offset derived from its key. So the family reads instantly, no two+emoticons sound identical, and re-running this produces byte-identical+output.++The nine emoticons with a real Skype event-sound counterpart (skype, call,+phone, hi, sleepy, wait, talktothehand, mail, handshake) are skipped by+default — those keep the genuine article. Pass --all to synthesize them too.++Usage:+ python3 scripts/gen-skype-sounds.py --out /tmp/skype-sounds+ python3 scripts/gen-skype-sounds.py --out /tmp/skype-sounds --all++Requires: numpy, ffmpeg (for mp3 encode).+"""+from __future__ import annotations++import argparse+import hashlib+import math+import re+import subprocess+import sys+import wave+from pathlib import Path++import numpy as np++SR = 44100+REPO = Path(__file__).resolve().parent.parent+CATALOG = REPO / "src" / "lib" / "skypeEmojis.ts"++# Emoticons that keep their authentic Skype event sound.+AUTHENTIC = {"skype", "call", "phone", "hi", "sleepy", "wait",+ "talktothehand", "mail", "handshake"}++# Major pentatonic — any pitch offset lands on a consonant note, so the+# per-emoticon variation can never produce a sour interval.+PENT = [0, 2, 4, 7, 9]+++def semitone(n: float) -> float:+ """Frequency of a semitone offset from A4=440."""+ return 440.0 * (2.0 ** (n / 12.0))+++def env(n: int, attack: float, decay: float, sustain: float = 0.0,+ release: float = 0.25) -> np.ndarray:+ """ADSR-ish envelope. Zero at both ends so nothing clicks."""+ a = max(1, int(n * attack))+ d = max(1, int(n * decay))+ r = max(1, int(n * release))+ s = max(0, n - a - d - r)+ out = np.concatenate([+ np.linspace(0.0, 1.0, a) ** 0.6,+ np.linspace(1.0, sustain if s or r else 0.0, d),+ np.full(s, sustain),+ np.linspace(sustain if s else 0.0, 0.0, r) ** 1.4,+ ])+ return np.resize(out, n)+++def tone(freq: float, dur: float, kind: str = "sine", detune: float = 0.0,+ vibrato: float = 0.0) -> np.ndarray:+ n = int(SR * dur)+ t = np.arange(n) / SR+ f = freq * (1.0 + vibrato * np.sin(2 * np.pi * 5.5 * t))+ phase = 2 * np.pi * np.cumsum(f) / SR+ if kind == "sine":+ w = np.sin(phase)+ elif kind == "tri":+ w = 2.0 / np.pi * np.arcsin(np.sin(phase))+ elif kind == "saw":+ w = 2.0 * ((phase / (2 * np.pi)) % 1.0) - 1.0+ elif kind == "square":+ w = np.sign(np.sin(phase))+ elif kind == "fm": # bell-ish+ w = np.sin(phase + 2.5 * np.sin(phase * 2.01) * np.exp(-4 * t))+ else:+ raise ValueError(kind)+ if detune:+ w = 0.5 * w + 0.5 * tone(freq * (1 + detune), dur, kind)+ return w+++def sweep(f0: float, f1: float, dur: float, kind: str = "sine") -> np.ndarray:+ n = int(SR * dur)+ t = np.arange(n) / SR+ f = np.geomspace(max(f0, 1.0), max(f1, 1.0), n)+ phase = 2 * np.pi * np.cumsum(f) / SR+ return np.sin(phase) if kind == "sine" else 2.0 * ((phase / (2 * np.pi)) % 1.0) - 1.0+++def noise(dur: float, seed: int) -> np.ndarray:+ # abs(): callers seed from a pitch offset, which is negative below A4.+ rng = np.random.default_rng(abs(int(seed)) + 1)+ return rng.standard_normal(int(SR * dur))+++def lowpass(x: np.ndarray, cutoff: float) -> np.ndarray:+ """One-pole lowpass — enough to take the fizz off synthesized noise."""+ a = math.exp(-2.0 * math.pi * cutoff / SR)+ out = np.empty_like(x)+ acc = 0.0+ for i, v in enumerate(x):+ acc = (1 - a) * v + a * acc+ out[i] = acc+ return out+++def place(canvas: np.ndarray, part: np.ndarray, at: float, gain: float = 1.0) -> None:+ i = int(SR * at)+ j = min(len(canvas), i + len(part))+ if j > i:+ canvas[i:j] += part[: j - i] * gain+++def blank(dur: float) -> np.ndarray:+ return np.zeros(int(SR * dur))+++# ── archetypes ───────────────────────────────────────────────────────────+# Each returns a mono float array. `k` is the emoticon's pitch offset.++def a_sparkle(k: int) -> np.ndarray:+ out = blank(0.62)+ for i, step in enumerate([0, 4, 7, 12]):+ f = semitone(k + step + 12)+ d = 0.30+ place(out, tone(f, d, "tri") * env(int(SR * d), 0.01, 0.3), 0.055 * i, 0.55)+ return out+++def a_laugh(k: int) -> np.ndarray:+ out = blank(0.72)+ for i in range(4):+ f = semitone(k + 12 + (2 if i % 2 else 0))+ d = 0.13+ place(out, tone(f, d, "tri", vibrato=0.05) * env(int(SR * d), 0.02, 0.4),+ 0.13 * i, 0.62 - 0.09 * i)+ return out+++def a_warm(k: int) -> np.ndarray:+ out = blank(0.85)+ for step in (0, 4, 7):+ d = 0.8+ place(out, tone(semitone(k + step), d, "sine", detune=0.004, vibrato=0.02)+ * env(int(SR * d), 0.18, 0.35, 0.35, 0.4), 0.0, 0.4)+ return out+++def a_sad(k: int) -> np.ndarray:+ out = blank(0.8)+ for i, step in enumerate([3, 0, -2]):+ d = 0.42+ place(out, tone(semitone(k + step), d, "sine", detune=0.006)+ * env(int(SR * d), 0.05, 0.5), 0.14 * i, 0.55 - 0.1 * i)+ return out+++def a_harsh(k: int) -> np.ndarray:+ out = blank(0.55)+ d = 0.5+ base = tone(semitone(k - 12), d, "saw", detune=0.02)+ base = np.tanh(base * 3.2) # drive+ place(out, base * env(int(SR * d), 0.01, 0.35), 0.0, 0.5)+ place(out, lowpass(noise(0.18, k + 7), 1400) * env(int(SR * 0.18), 0.01, 0.5), 0.0, 0.25)+ return out+++def a_blip(k: int) -> np.ndarray:+ out = blank(0.4)+ d = 0.26+ place(out, sweep(semitone(k + 7), semitone(k + 16), d) * env(int(SR * d), 0.03, 0.4),+ 0.0, 0.6)+ return out+++def a_clink(k: int) -> np.ndarray:+ out = blank(0.7)+ for i, mult in enumerate([1.0, 2.76, 5.4]): # inharmonic → glassy+ d = 0.6 - 0.12 * i+ place(out, tone(semitone(k + 19) * mult / 2, d, "sine")+ * env(int(SR * d), 0.002, 0.6), 0.0, 0.34 / (i + 1))+ place(out, noise(0.03, k) * env(int(SR * 0.03), 0.001, 0.8), 0.0, 0.16)+ return out+++def a_ring(k: int) -> np.ndarray:+ out = blank(0.85)+ for i in range(2):+ for step in (0, 5):+ d = 0.26+ place(out, tone(semitone(k + 12 + step), d, "sine")+ * env(int(SR * d), 0.02, 0.35, 0.3, 0.3), 0.42 * i, 0.35)+ return out+++def a_mech(k: int) -> np.ndarray:+ out = blank(0.55)+ for i in range(3):+ place(out, lowpass(noise(0.035, k + i), 2600) * env(int(SR * 0.035), 0.001, 0.7),+ 0.085 * i, 0.5)+ d = 0.34+ place(out, tone(semitone(k - 5), d, "square") * env(int(SR * d), 0.02, 0.5), 0.1, 0.16)+ return out+++def a_animal(k: int) -> np.ndarray:+ out = blank(0.6)+ d = 0.42+ body = sweep(semitone(k + 10), semitone(k + 4), d)+ body = body * (1 + 0.35 * np.sin(2 * np.pi * 24 * np.arange(len(body)) / SR)) # bleat+ place(out, body * env(int(SR * d), 0.04, 0.4), 0.0, 0.5)+ return out+++def a_fanfare(k: int) -> np.ndarray:+ out = blank(0.9)+ for i, step in enumerate([0, 4, 7]):+ d = 0.5+ place(out, tone(semitone(k + step), d, "saw", detune=0.008)+ * env(int(SR * d), 0.02, 0.3, 0.28, 0.4), 0.075 * i, 0.3)+ d = 0.55+ place(out, tone(semitone(k + 12), d, "saw", detune=0.01)+ * env(int(SR * d), 0.03, 0.3, 0.25, 0.45), 0.22, 0.34)+ return out+++def a_zap(k: int) -> np.ndarray:+ out = blank(0.45)+ d = 0.3+ place(out, lowpass(noise(d, k), 5200) * np.geomspace(1.0, 0.02, int(SR * d))+ * env(int(SR * d), 0.005, 0.5), 0.0, 0.55)+ place(out, sweep(semitone(k + 26), semitone(k + 2), 0.26) * env(int(SR * 0.26), 0.005, 0.5),+ 0.0, 0.3)+ return out+++def a_wobble(k: int) -> np.ndarray:+ out = blank(0.75)+ d = 0.62+ n = int(SR * d)+ t = np.arange(n) / SR+ f = semitone(k + 8) * np.exp(-1.15 * t) # comic slide down+ phase = 2 * np.pi * np.cumsum(f) / SR+ w = np.sin(phase + 0.6 * np.sin(2 * np.pi * 7 * t))+ place(out, w * env(n, 0.02, 0.4, 0.2, 0.4), 0.0, 0.55)+ return out+++def a_beat(k: int) -> np.ndarray:+ out = blank(0.8)+ for i in range(4):+ thump = lowpass(noise(0.09, k + i), 220) + tone(semitone(k - 17), 0.09, "sine")+ place(out, thump * env(int(SR * 0.09), 0.002, 0.6), 0.165 * i, 0.5)+ if i % 2:+ place(out, lowpass(noise(0.04, k + 9 + i), 7000) * env(int(SR * 0.04), 0.001, 0.7),+ 0.165 * i, 0.2)+ return out+++def a_neutral(k: int) -> np.ndarray:+ out = blank(0.5)+ for i, step in enumerate([0, 5]):+ d = 0.3+ place(out, tone(semitone(k + 12 + step), d, "sine") * env(int(SR * d), 0.02, 0.4),+ 0.11 * i, 0.5)+ return out+++ARCHETYPES = {+ "sparkle": a_sparkle, "laugh": a_laugh, "warm": a_warm, "sad": a_sad,+ "harsh": a_harsh, "blip": a_blip, "clink": a_clink, "ring": a_ring,+ "mech": a_mech, "animal": a_animal, "fanfare": a_fanfare, "zap": a_zap,+ "wobble": a_wobble, "beat": a_beat, "neutral": a_neutral,+}++# Semantic assignment. Anything unlisted falls back to `neutral`.+ASSIGN = {+ "sparkle": ["smile", "happy", "star", "sunshine", "flower", "idea", "cool",+ "wink", "blushing", "cake", "fingerscrossed", "whew", "nerd"],+ "laugh": ["bigsmile", "giggle", "rofl", "tongueout", "smirk", "evilgrin", "lalala"],+ "warm": ["heart", "inlove", "kiss", "hug", "angel", "mmm"],+ "sad": ["sadsmile", "crying", "worried", "brokenheart", "emo", "dull", "envy",+ "waiting", "tumbleweed"],+ "harsh": ["angry", "devil", "swear", "punch", "wtf", "fubar", "mooning", "finger",+ "headbang"],+ "blip": ["thinking", "wondering", "speechless", "surprised", "lipssealed", "tmi",+ "no", "shake"],+ "clink": ["beer", "drink", "coffee", "pizza", "poolparty", "cash"],+ "ring": ["talking", "movie", "time"],+ "mech": ["bike", "bug", "wfh", "makeup", "smoking", "rain"],+ "animal": ["cat", "dog", "sheep", "heidy", "oliver", "toivo"],+ "fanfare": ["captain", "muscle", "highfive", "party", "clapping", "shielddeflect",+ "nickfury", "bucky", "blackwidow", "dancing", "music", "bartlett"],+ "zap": ["ninja", "bandit"],+ "wobble": ["doh", "facepalm", "drunk", "puking", "yawning", "sweating"],+ "beat": ["nod", "bow", "yes", "handshake"],+}+++def archetype_for(key: str) -> str:+ for name, keys in ASSIGN.items():+ if key in keys:+ return name+ return "neutral"+++def family_slots(all_keys: list[str]) -> dict[str, int]:+ """Position of each emoticon within its archetype family.++ Pitch is assigned from this position, NOT from a hash of the key: with+ only 15 usable pentatonic slots a hash collides constantly, and two+ emoticons in one family that draw the same slot render byte-identical+ audio. Walking the slots in order guarantees every member of a family+ sounds different from every other."""+ seen: dict[str, int] = {}+ slots: dict[str, int] = {}+ for key in all_keys:+ fam = archetype_for(key)+ slots[key] = seen.get(fam, 0)+ seen[fam] = slots[key] + 1+ return slots+++def pitch_for(slot: int) -> int:+ """Pentatonic degree + octave for a family slot. 15 distinct pitches+ before it wraps; the wrap adds an octave so it still doesn't repeat."""+ deg = PENT[slot % len(PENT)]+ octave = ((slot // len(PENT)) % 3) - 1+ return deg + 12 * octave + (12 if slot >= 15 else 0)+++def normalize(x: np.ndarray, peak_db: float = -3.0) -> np.ndarray:+ x = np.tanh(x * 1.05) # soft limit before scaling+ m = float(np.max(np.abs(x))) or 1.0+ return x * (10 ** (peak_db / 20.0)) / m+++def write_wav(path: Path, x: np.ndarray) -> None:+ pcm = np.clip(x, -1.0, 1.0)+ pcm = (pcm * 32767.0).astype("<i2")+ with wave.open(str(path), "wb") as w:+ w.setnchannels(1)+ w.setsampwidth(2)+ w.setframerate(SR)+ w.writeframes(pcm.tobytes())+++def load_keys() -> list[str]:+ src = CATALOG.read_text(encoding="utf-8")+ return re.findall(r"\{ key: '([a-z0-9]+)'", src)+++def main() -> int:+ ap = argparse.ArgumentParser()+ ap.add_argument("--out", required=True, help="output directory for .mp3 files")+ ap.add_argument("--all", action="store_true",+ help="also synthesize the emoticons that have authentic Skype audio")+ args = ap.parse_args()++ out_dir = Path(args.out)+ out_dir.mkdir(parents=True, exist_ok=True)+ tmp = out_dir / "_wav"+ tmp.mkdir(exist_ok=True)++ keys = load_keys()+ if not keys:+ print("no emoticons found in catalog", file=sys.stderr)+ return 1++ slots = family_slots(keys)+ made = 0+ for key in keys:+ if key in AUTHENTIC and not args.all:+ continue+ arch = archetype_for(key)+ audio = normalize(ARCHETYPES[arch](pitch_for(slots[key])))+ wav = tmp / f"{key}.wav"+ write_wav(wav, audio)+ subprocess.run(+ ["ffmpeg", "-y", "-loglevel", "error", "-i", str(wav),+ "-codec:a", "libmp3lame", "-b:a", "96k", "-ar", "44100", "-ac", "1",+ str(out_dir / f"{key}.mp3")],+ check=True,+ )+ wav.unlink()+ made += 1+ print(f"{key:16s} {arch}")++ tmp.rmdir()+ print(f"\n{made} sounds → {out_dir}")+ return 0+++if __name__ == "__main__":+ raise SystemExit(main())diff --git a/src/lib/skypeEmojis.ts b/src/lib/skypeEmojis.tsindex f83aad3..14a1815 100644--- a/src/lib/skypeEmojis.ts+++ b/src/lib/skypeEmojis.ts@@ -190,19 +190,25 @@ export function skypeEmojiUrl(key: string): string {return `/skype-emojis/anim/${key}.png`}-/** Sound file URL. The audio files are deliberately NOT in this repo- * (they're classic Skype event sounds — Microsoft IP we don't- * redistribute in source form); they're served out-of-band from the- * deployment's CDN. Self-hosters can point VITE_SKYPE_SOUNDS_BASE at- * their own copies, or leave the default and get Cumora's.+/** Sound file URL. Every emoticon in the catalog has one; the files are+ * served from the deployment's CDN rather than committed here, and a+ * self-hoster can point VITE_SKYPE_SOUNDS_BASE at their own copies.*- * Classic Skype only ever had EVENT sounds (message pop, ringtone,- * login…), never per-emoticon audio — so only the emoticons with a- * natural event counterpart have a file: skype→IM pop, call→ring-in,- * phone→ring-out, hi→login, sleepy→logout, wait→hold,- * talktothehand→busy, mail→sent, handshake→contact-added. Every other- * key 404s and `Audio.play()` rejects silently by design — the picker /- * message renderer never errors visibly. */+ * Two provenances behind that URL:+ * - Nine emoticons with a real Skype event-sound counterpart use the+ * genuine article (skype→IM pop, call→ring-in, phone→ring-out,+ * hi→login, sleepy→logout, wait→hold, talktothehand→busy, mail→sent,+ * handshake→contact-added). Microsoft IP, which is why they stay out+ * of the source tree.+ * - The rest are synthesized — classic Skype never had per-emoticon+ * audio, so there was nothing to source. `scripts/gen-skype-sounds.py`+ * regenerates them deterministically from the catalog: a semantic+ * archetype per emoticon (sparkle / sad / clink / zap …) plus a+ * per-emoticon pitch, so a family reads as a family and no two are+ * alike. Original work, safe to redistribute.+ *+ * A missing file still degrades quietly: `Audio.play()` rejects and the+ * picker / message renderer never errors visibly. */const SKYPE_SOUNDS_BASE: string =(import.meta.env?.VITE_SKYPE_SOUNDS_BASE as string | undefined)?.replace(/\/+$/, '')|| 'https://cdn.cumora.ai/skype-sounds'