opencode-probleemwijken 1.0.0

package/README.md

@@ -0,0 +1,69 @@
+# opencode-probleemwijken
+
+OpenCode plugin dat een willekeurig geluid afspeelt van de legendarische [Probleemwijken/Derkolk soundboard](https://www.derkolk.nl/probleemwijken/) wanneer een sessie klaar is.
+
+## Installatie
+
+### Optie 1: Lokale plugin (aanbevolen)
+
+1. Kopieer `plugin.ts` naar je OpenCode plugins directory:
+
+```bash
+cp plugin.ts ~/.config/opencode/plugins/probleemwijken.ts
+```
+
+2. Kopieer de sounds naar je config directory:
+
+```bash
+mkdir -p ~/.config/opencode/sounds/random-soundboard
+cp sounds/*.mp3 ~/.config/opencode/sounds/random-soundboard/
+```
+
+3. Zorg dat je `@opencode-ai/plugin` hebt in `~/.config/opencode/package.json`:
+
+```json
+{
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.0.0"
+  }
+}
+```
+
+4. Herstart OpenCode
+
+### Optie 2: Eigen geluiden toevoegen
+
+Je kunt ook je eigen MP3/WAV/OGG/M4A bestanden toevoegen aan de `~/.config/opencode/sounds/random-soundboard/` directory.
+
+## Wat doet het?
+
+Elke keer als OpenCode klaar is met een taak (session.idle) of een error krijgt (session.error), speelt de plugin een willekeurig geluid af uit de collectie.
+
+## Geluiden
+
+De plugin bevat 36 klassieke Derkolk soundboard fragmenten:
+
+- "VLIEG!"
+- "Half elf"
+- "Boertje!?"
+- "Geert is inmiddels dronken"
+- "Broodje"
+- "Koffie"
+- "Pitbull"
+- "Tetete"
+- ... en nog veel meer!
+
+## Platform ondersteuning
+
+- **macOS**: Gebruikt `afplay` (ingebouwd)
+- **Linux**: Gebruikt `mpv` of `ffplay`
+- **Windows**: Gebruikt Windows Media Player via PowerShell
+
+## Credits
+
+- Geluiden van [derkolk.nl/probleemwijken](https://www.derkolk.nl/probleemwijken/)
+- Gebaseerd op [opencode-notifier](https://github.com/mohak34/opencode-notifier) door mohak34
+
+## Licentie
+
+MIT

package/dist/index.js

@@ -0,0 +1,223 @@
+// src/config.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var DEFAULT_CONFIG = {
+  enabled: true,
+  soundsDir: null,
+  events: {
+    complete: true,
+    subagent_complete: false,
+    error: true,
+    permission: false
+  }
+};
+function loadConfig() {
+  const configPath = join(homedir(), ".config", "opencode", "random-soundboard.json");
+  if (!existsSync(configPath)) {
+    return DEFAULT_CONFIG;
+  }
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    const userConfig = JSON.parse(content);
+    return {
+      enabled: userConfig.enabled ?? DEFAULT_CONFIG.enabled,
+      soundsDir: userConfig.soundsDir ?? DEFAULT_CONFIG.soundsDir,
+      events: {
+        complete: userConfig.events?.complete ?? DEFAULT_CONFIG.events.complete,
+        subagent_complete: userConfig.events?.subagent_complete ?? DEFAULT_CONFIG.events.subagent_complete,
+        error: userConfig.events?.error ?? DEFAULT_CONFIG.events.error,
+        permission: userConfig.events?.permission ?? DEFAULT_CONFIG.events.permission
+      }
+    };
+  } catch {
+    return DEFAULT_CONFIG;
+  }
+}
+function isEventEnabled(config, event) {
+  if (!config.enabled)
+    return false;
+  return config.events[event] ?? false;
+}
+
+// src/sound.ts
+import { platform } from "os";
+import { join as join2, dirname, extname } from "path";
+import { fileURLToPath } from "url";
+import { existsSync as existsSync2, readdirSync } from "fs";
+import { spawn } from "child_process";
+var __dirname2 = dirname(fileURLToPath(import.meta.url));
+var SUPPORTED_EXTENSIONS = [".mp3", ".wav", ".ogg", ".m4a", ".aac", ".flac"];
+function getBundledSoundsDir() {
+  const possiblePaths = [
+    join2(__dirname2, "..", "sounds"),
+    join2(__dirname2, "sounds")
+  ];
+  for (const path of possiblePaths) {
+    if (existsSync2(path)) {
+      return path;
+    }
+  }
+  return join2(__dirname2, "..", "sounds");
+}
+function getSoundsDirectory(config) {
+  if (config.soundsDir && existsSync2(config.soundsDir)) {
+    return config.soundsDir;
+  }
+  return getBundledSoundsDir();
+}
+function getSoundFiles(directory) {
+  if (!existsSync2(directory)) {
+    return [];
+  }
+  try {
+    const files = readdirSync(directory);
+    return files.filter((file) => {
+      const ext = extname(file).toLowerCase();
+      return SUPPORTED_EXTENSIONS.includes(ext);
+    }).map((file) => join2(directory, file));
+  } catch {
+    return [];
+  }
+}
+function getRandomSound(sounds) {
+  if (sounds.length === 0)
+    return null;
+  const index = Math.floor(Math.random() * sounds.length);
+  return sounds[index];
+}
+async function runCommand(command, args) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(command, args, {
+      stdio: "ignore",
+      detached: false
+    });
+    proc.on("error", (err) => {
+      reject(err);
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Command exited with code ${code}`));
+      }
+    });
+  });
+}
+async function playOnLinux(soundPath) {
+  const players = [
+    { command: "mpv", args: ["--no-video", "--no-terminal", soundPath] },
+    { command: "ffplay", args: ["-nodisp", "-autoexit", "-loglevel", "quiet", soundPath] },
+    { command: "paplay", args: [soundPath] },
+    { command: "aplay", args: [soundPath] }
+  ];
+  for (const player of players) {
+    try {
+      await runCommand(player.command, player.args);
+      return;
+    } catch {
+      continue;
+    }
+  }
+}
+async function playOnMac(soundPath) {
+  await runCommand("afplay", [soundPath]);
+}
+async function playOnWindows(soundPath) {
+  const ext = extname(soundPath).toLowerCase();
+  if (ext === ".wav") {
+    const script = `& { (New-Object Media.SoundPlayer $args[0]).PlaySync() }`;
+    await runCommand("powershell", ["-c", script, soundPath]);
+  } else {
+    const script = `
+      $player = New-Object -ComObject WMPlayer.OCX
+      $player.URL = $args[0]
+      $player.controls.play()
+      Start-Sleep -Milliseconds 500
+      while ($player.playState -eq 3) { Start-Sleep -Milliseconds 100 }
+      $player.close()
+    `;
+    await runCommand("powershell", ["-c", script, soundPath]);
+  }
+}
+async function playRandomSound(config) {
+  const soundsDir = getSoundsDirectory(config);
+  const sounds = getSoundFiles(soundsDir);
+  if (sounds.length === 0) {
+    return;
+  }
+  const soundPath = getRandomSound(sounds);
+  if (!soundPath) {
+    return;
+  }
+  const os = platform();
+  try {
+    switch (os) {
+      case "darwin":
+        await playOnMac(soundPath);
+        break;
+      case "linux":
+        await playOnLinux(soundPath);
+        break;
+      case "win32":
+        await playOnWindows(soundPath);
+        break;
+      default:
+        break;
+    }
+  } catch {}
+}
+
+// src/index.ts
+function getSessionIDFromEvent(event) {
+  const sessionID = event?.properties?.sessionID;
+  if (typeof sessionID === "string" && sessionID.length > 0) {
+    return sessionID;
+  }
+  return null;
+}
+async function isChildSession(client, sessionID) {
+  try {
+    const response = await client.session.get({ path: { id: sessionID } });
+    const parentID = response.data?.parentID;
+    return !!parentID;
+  } catch {
+    return false;
+  }
+}
+var RandomSoundboardPlugin = async ({ client }) => {
+  const config = loadConfig();
+  return {
+    event: async ({ event }) => {
+      if (event.type === "permission.updated" || event.type === "permission.asked") {
+        if (isEventEnabled(config, "permission")) {
+          await playRandomSound(config);
+        }
+      }
+      if (event.type === "session.idle") {
+        const sessionID = getSessionIDFromEvent(event);
+        if (sessionID) {
+          const isChild = await isChildSession(client, sessionID);
+          const eventType = isChild ? "subagent_complete" : "complete";
+          if (isEventEnabled(config, eventType)) {
+            await playRandomSound(config);
+          }
+        } else {
+          if (isEventEnabled(config, "complete")) {
+            await playRandomSound(config);
+          }
+        }
+      }
+      if (event.type === "session.error") {
+        if (isEventEnabled(config, "error")) {
+          await playRandomSound(config);
+        }
+      }
+    }
+  };
+};
+var src_default = RandomSoundboardPlugin;
+export {
+  src_default as default,
+  RandomSoundboardPlugin
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "opencode-probleemwijken",
+  "version": "1.0.0",
+  "description": "OpenCode plugin that plays a random Probleemwijken/Derkolk soundboard sound when a session completes",
+  "author": "Daan-Friday",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Daan-Friday/opencode-probleemwijken.git"
+  },
+  "homepage": "https://github.com/Daan-Friday/opencode-probleemwijken#readme",
+  "bugs": {
+    "url": "https://github.com/Daan-Friday/opencode-probleemwijken/issues"
+  },
+  "files": [
+    "dist",
+    "sounds"
+  ],
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --target node",
+    "prepublishOnly": "bun run build",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "soundboard",
+    "random",
+    "sound",
+    "notifications",
+    "probleemwijken",
+    "derkolk"
+  ],
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.0.224",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=1.0.0"
+  }
+}

package/sounds/.gitkeep

@@ -0,0 +1,2 @@
+# Add your MP3/WAV/OGG sound files to this directory!
+# The plugin will randomly pick one when OpenCode finishes a task.