@nordbyte/nordrelay 0.2.1

package/dist/voice.js

@@ -0,0 +1,373 @@
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+const PARAKEET_SPECIFIER = "parakeet-coreml";
+const FFMPEG_INSTALL_MESSAGE = "ffmpeg not found. Install it with: sudo apt-get install ffmpeg or brew install ffmpeg";
+const NO_BACKEND_ERROR = `Voice messages require a transcription backend.
+
+Option 1: Install faster-whisper for local Linux transcription:
+  python3 -m venv .venv
+  .venv/bin/python -m pip install faster-whisper
+  Add FASTER_WHISPER_PYTHON=.venv/bin/python to your .env file
+
+Option 2: Install Parakeet for local macOS Apple Silicon transcription (free, private, ~1.5GB download):
+  npm install parakeet-coreml
+Also requires ffmpeg: sudo apt-get install ffmpeg or brew install ffmpeg
+
+Option 3: Set OPENAI_API_KEY for cloud transcription (~$0.006/min):
+  Add OPENAI_API_KEY=sk-... to your .env file`;
+const FASTER_WHISPER_CHECK_SCRIPT = "import faster_whisper";
+const FASTER_WHISPER_TRANSCRIBE_SCRIPT = `
+import json
+import os
+import sys
+from faster_whisper import WhisperModel
+
+audio_path = sys.argv[1]
+model_name = os.environ.get("FASTER_WHISPER_MODEL", "base")
+device = os.environ.get("FASTER_WHISPER_DEVICE", "cpu")
+compute_type = os.environ.get("FASTER_WHISPER_COMPUTE_TYPE", "int8")
+language = os.environ.get("FASTER_WHISPER_LANGUAGE") or None
+
+model = WhisperModel(model_name, device=device, compute_type=compute_type)
+segments, info = model.transcribe(audio_path, language=language, vad_filter=True)
+text = " ".join(segment.text.strip() for segment in segments).strip()
+print(json.dumps({
+    "text": text,
+    "language": getattr(info, "language", None),
+    "duration": getattr(info, "duration", None),
+}))
+`;
+const _require = createRequire(import.meta.url);
+let _importModule = async (specifier) => _require(specifier);
+let _decodeAudio = decodeAudioToSamples;
+let _runCommand = runCommand;
+let _engine = null;
+let _fasterWhisperAvailable;
+export function _setImportHook(hook) {
+    _importModule = hook;
+}
+export function _setDecodeHook(hook) {
+    _decodeAudio = hook;
+}
+export function _setCommandHook(hook) {
+    _runCommand = hook;
+    _fasterWhisperAvailable = undefined;
+}
+export function _resetImportHook() {
+    _importModule = async (specifier) => _require(specifier);
+    _decodeAudio = decodeAudioToSamples;
+    _runCommand = runCommand;
+    _engine = null;
+    _fasterWhisperAvailable = undefined;
+}
+export async function transcribeAudio(filePath, options = {}) {
+    for (const backend of backendOrder(options.preferredBackend)) {
+        try {
+            if (backend === "parakeet") {
+                const parakeetMod = await _importModule(PARAKEET_SPECIFIER);
+                return await transcribeWithParakeet(filePath, parakeetMod);
+            }
+            if (backend === "faster-whisper" && await hasFasterWhisper()) {
+                return await transcribeWithFasterWhisper(filePath, options);
+            }
+            if (backend === "openai" && hasOpenAIApiKey()) {
+                return await transcribeWithOpenAI(filePath, options);
+            }
+        }
+        catch (error) {
+            if (backend === "parakeet" && isModuleNotFoundError(error, PARAKEET_SPECIFIER)) {
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw new Error(NO_BACKEND_ERROR);
+}
+export async function getAvailableBackends() {
+    const backends = [];
+    try {
+        await _importModule(PARAKEET_SPECIFIER);
+        backends.push("parakeet");
+    }
+    catch {
+        // Treat import failures as unavailable so /start can still work.
+    }
+    if (await hasFasterWhisper()) {
+        backends.push("faster-whisper");
+    }
+    if (hasOpenAIApiKey()) {
+        backends.push("openai");
+    }
+    return backends;
+}
+async function transcribeWithParakeet(filePath, parakeetMod) {
+    const startedAt = Date.now();
+    const samples = await _decodeAudio(filePath);
+    if (!_engine) {
+        const mod = parakeetMod;
+        const ParakeetAsrEngine = mod?.ParakeetAsrEngine ??
+            mod?.default?.ParakeetAsrEngine;
+        if (typeof ParakeetAsrEngine !== "function") {
+            throw new Error("parakeet-coreml was loaded but does not expose a ParakeetAsrEngine class");
+        }
+        const engine = new ParakeetAsrEngine();
+        if (typeof engine.initialize !== "function") {
+            throw new Error("parakeet-coreml was loaded but the engine does not expose initialize()");
+        }
+        if (typeof engine.transcribe !== "function") {
+            throw new Error("parakeet-coreml was loaded but the engine does not expose transcribe(samples)");
+        }
+        await engine.initialize();
+        _engine = engine;
+    }
+    const result = await _engine.transcribe(samples);
+    const text = extractTranscribedText(result);
+    if (text === undefined) {
+        throw new Error("parakeet-coreml returned an unsupported transcription result");
+    }
+    const durationMs = typeof result === "object" && result !== null && typeof result.durationMs === "number"
+        ? result.durationMs
+        : Date.now() - startedAt;
+    return {
+        text,
+        backend: "parakeet",
+        durationMs,
+    };
+}
+async function transcribeWithFasterWhisper(filePath, options = {}) {
+    const startedAt = Date.now();
+    const env = {
+        ...process.env,
+        ...(options.language ? { FASTER_WHISPER_LANGUAGE: options.language } : {}),
+        ...(options.fasterWhisperModel ? { FASTER_WHISPER_MODEL: options.fasterWhisperModel } : {}),
+    };
+    const result = await _runCommand(resolveFasterWhisperPython(), ["-c", FASTER_WHISPER_TRANSCRIBE_SCRIPT, filePath], {
+        env,
+        timeoutMs: parsePositiveInteger(process.env.FASTER_WHISPER_TIMEOUT_MS, 10 * 60 * 1000),
+    });
+    if (result.code !== 0) {
+        const detail = (result.stderr || result.stdout || "unknown error").trim();
+        throw new Error(`faster-whisper transcription failed (${result.code ?? result.signal ?? "unknown"}): ${detail}`);
+    }
+    const payload = parseJsonLine(result.stdout);
+    if (!payload || typeof payload.text !== "string") {
+        throw new Error("faster-whisper transcription response did not include a text field");
+    }
+    return {
+        text: payload.text,
+        backend: "faster-whisper",
+        durationMs: typeof payload.duration === "number" ? Math.round(payload.duration * 1000) : Date.now() - startedAt,
+    };
+}
+async function transcribeWithOpenAI(filePath, options = {}) {
+    const apiKey = process.env.OPENAI_API_KEY?.trim();
+    if (!apiKey) {
+        throw new Error(NO_BACKEND_ERROR);
+    }
+    const startedAt = Date.now();
+    const audioBuffer = await readFile(filePath);
+    const ext = (path.extname(filePath) || ".ogg").slice(1).toLowerCase();
+    const mimeTypes = {
+        ogg: "audio/ogg", oga: "audio/ogg", mp3: "audio/mpeg",
+        m4a: "audio/mp4", aac: "audio/aac", wav: "audio/wav",
+        webm: "audio/webm", flac: "audio/flac",
+    };
+    const mimeType = mimeTypes[ext] ?? "audio/ogg";
+    const form = new FormData();
+    form.append("file", new Blob([audioBuffer], { type: mimeType }), path.basename(filePath) || "audio.ogg");
+    form.append("model", "whisper-1");
+    if (options.language) {
+        form.append("language", options.language);
+    }
+    const response = await fetch("https://api.openai.com/v1/audio/transcriptions", {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+        },
+        body: form,
+    });
+    if (!response.ok) {
+        const errorText = (await response.text().catch(() => "")).trim();
+        throw new Error(`OpenAI transcription failed (${response.status}): ${errorText || response.statusText || "Unknown error"}`);
+    }
+    const payload = (await response.json());
+    if (typeof payload.text !== "string") {
+        throw new Error("OpenAI transcription response did not include a text field");
+    }
+    return {
+        text: payload.text,
+        backend: "openai",
+        durationMs: Date.now() - startedAt,
+    };
+}
+function decodeAudioToSamples(filePath) {
+    return new Promise((resolve, reject) => {
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        let settled = false;
+        const ffmpeg = spawn("ffmpeg", ["-i", filePath, "-ar", "16000", "-ac", "1", "-f", "f32le", "pipe:1"], {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const finish = (callback) => {
+            if (settled)
+                return;
+            settled = true;
+            callback();
+        };
+        ffmpeg.stdout.on("data", (chunk) => {
+            stdoutChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        });
+        ffmpeg.stderr.on("data", (chunk) => {
+            stderrChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        });
+        ffmpeg.once("error", (error) => {
+            finish(() => {
+                if (error.code === "ENOENT") {
+                    reject(new Error(FFMPEG_INSTALL_MESSAGE));
+                    return;
+                }
+                reject(error);
+            });
+        });
+        ffmpeg.once("close", (code, signal) => {
+            finish(() => {
+                if (code !== 0) {
+                    const stderr = Buffer.concat(stderrChunks).toString("utf8").trim();
+                    const reason = stderr || (signal ? `signal ${signal}` : `exit code ${code ?? "unknown"}`);
+                    reject(new Error(`ffmpeg failed to decode audio: ${reason}`));
+                    return;
+                }
+                const buffer = Buffer.concat(stdoutChunks);
+                if (buffer.byteLength % Float32Array.BYTES_PER_ELEMENT !== 0) {
+                    reject(new Error("ffmpeg returned invalid float32 PCM output"));
+                    return;
+                }
+                const samples = new Float32Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / Float32Array.BYTES_PER_ELEMENT).slice();
+                resolve(samples);
+            });
+        });
+    });
+}
+async function hasFasterWhisper() {
+    if (_fasterWhisperAvailable !== undefined) {
+        return _fasterWhisperAvailable;
+    }
+    const result = await _runCommand(resolveFasterWhisperPython(), ["-c", FASTER_WHISPER_CHECK_SCRIPT], {
+        env: process.env,
+        timeoutMs: 10_000,
+    }).catch(() => null);
+    _fasterWhisperAvailable = result?.code === 0;
+    return _fasterWhisperAvailable;
+}
+function resolveFasterWhisperPython() {
+    return process.env.FASTER_WHISPER_PYTHON?.trim() || process.env.WHISPER_PYTHON?.trim() || "python3";
+}
+function hasOpenAIApiKey() {
+    return Boolean(process.env.OPENAI_API_KEY?.trim());
+}
+function extractTranscribedText(result) {
+    if (typeof result === "string") {
+        return result;
+    }
+    if (typeof result === "object" && result !== null && typeof result.text === "string") {
+        return result.text;
+    }
+    return undefined;
+}
+function parseJsonLine(stdout) {
+    const lines = stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const lastLine = lines.at(-1);
+    if (!lastLine) {
+        return null;
+    }
+    try {
+        return JSON.parse(lastLine);
+    }
+    catch {
+        return null;
+    }
+}
+function runCommand(command, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        let settled = false;
+        const child = spawn(command, args, {
+            env: options.env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const timer = options.timeoutMs
+            ? setTimeout(() => {
+                if (settled)
+                    return;
+                child.kill("SIGTERM");
+                settled = true;
+                resolve({
+                    code: null,
+                    signal: "SIGTERM",
+                    stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+                    stderr: `Command timed out after ${options.timeoutMs}ms`,
+                });
+            }, options.timeoutMs)
+            : undefined;
+        timer?.unref?.();
+        const finish = (callback) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            callback();
+        };
+        child.stdout.on("data", (chunk) => {
+            stdoutChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        });
+        child.stderr.on("data", (chunk) => {
+            stderrChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        });
+        child.once("error", (error) => {
+            finish(() => {
+                reject(error);
+            });
+        });
+        child.once("close", (code, signal) => {
+            finish(() => {
+                resolve({
+                    code,
+                    signal,
+                    stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+                    stderr: Buffer.concat(stderrChunks).toString("utf8"),
+                });
+            });
+        });
+    });
+}
+function parsePositiveInteger(raw, fallback) {
+    const parsed = Number.parseInt(raw ?? "", 10);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+function backendOrder(preferred) {
+    const all = ["parakeet", "faster-whisper", "openai"];
+    if (!preferred || preferred === "auto") {
+        return all;
+    }
+    return [preferred, ...all.filter((backend) => backend !== preferred)];
+}
+function isModuleNotFoundError(error, specifier) {
+    const code = typeof error === "object" && error !== null ? error.code : undefined;
+    if (code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND") {
+        const message = error instanceof Error ? error.message : String(error);
+        // Only treat as "not installed" if the message references the specific package.
+        // A broken transitive dependency (e.g. missing native addon) should surface as a real error.
+        return !message || message.includes(specifier);
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return (message.includes(`Cannot find package '${specifier}'`) ||
+        message.includes(`Cannot find module '${specifier}'`) ||
+        message.includes(`Cannot resolve module '${specifier}'`));
+}

package/dist/workspace-policy.js

@@ -0,0 +1,41 @@
+import path from "node:path";
+const BROAD_WORKSPACE_NAMES = new Set(["/", "home", "Users", "projects", "src", "code", "workspace"]);
+export function evaluateWorkspacePolicy(workspace, config) {
+    const resolved = path.resolve(workspace);
+    const allowedRoots = config.workspaceAllowedRoots.map((root) => path.resolve(root));
+    if (allowedRoots.length > 0 && !allowedRoots.some((root) => isPathInside(resolved, root))) {
+        return {
+            allowed: false,
+            warning: `Workspace is outside allowed roots: ${resolved}`,
+        };
+    }
+    const warnRoots = config.workspaceWarnRoots.map((root) => path.resolve(root));
+    const explicitWarningRoot = warnRoots.find((root) => resolved === root);
+    if (explicitWarningRoot) {
+        return {
+            allowed: true,
+            warning: `Workspace is a broad configured root: ${explicitWarningRoot}`,
+        };
+    }
+    const basename = path.basename(resolved) || resolved;
+    if (BROAD_WORKSPACE_NAMES.has(basename) && resolved.split(path.sep).filter(Boolean).length <= 3) {
+        return {
+            allowed: true,
+            warning: `Workspace looks broad; prefer a project-specific directory: ${resolved}`,
+        };
+    }
+    return { allowed: true };
+}
+export function filterAllowedWorkspaces(workspaces, config) {
+    return workspaces.filter((workspace) => evaluateWorkspacePolicy(workspace, config).allowed);
+}
+export function renderWorkspacePolicyLine(workspace, config) {
+    const result = evaluateWorkspacePolicy(workspace, config);
+    if (!result.allowed) {
+        return `Blocked: ${result.warning}`;
+    }
+    return result.warning ? `Warning: ${result.warning}` : undefined;
+}
+function isPathInside(candidate, root) {
+    return candidate === root || candidate.startsWith(`${root}${path.sep}`);
+}

package/docker-compose.yml

@@ -0,0 +1,17 @@
+services:
+  nordrelay:
+    build: .
+    env_file: .env
+    volumes:
+      - ${HOME}/.codex:/home/nordrelay/.codex:rw
+      - ./workspace:/workspace:rw
+    cap_drop:
+      - ALL
+    security_opt:
+      - no-new-privileges:true
+    deploy:
+      resources:
+        limits:
+          memory: 2G
+          cpus: "2.0"
+    restart: unless-stopped

package/launchd/start.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+set -euo pipefail
+
+export PATH="${PATH:-/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin}"
+: "${HOME:?Set HOME before starting nordrelay}"
+
+cd "${NORDRELAY_SOURCE_ROOT:-$HOME/projects/nordrelay}"
+exec node dist/index.js

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@nordbyte/nordrelay",
+  "version": "0.2.1",
+  "description": "Remote control plane for coding agents across messaging channels.",
+  "type": "module",
+  "author": "Ricardo",
+  "homepage": "https://github.com/nordbyte",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nordbyte/nordrelay.git"
+  },
+  "bugs": {
+    "url": "https://github.com/nordbyte/nordrelay/issues"
+  },
+  "keywords": [
+    "coding-agents",
+    "messaging",
+    "remote-control",
+    "codex",
+    "pi",
+    "telegram",
+    "bot",
+    "automation"
+  ],
+  "main": "./dist/index.js",
+  "bin": {
+    "nordrelay": "plugins/nordrelay/scripts/nordrelay.mjs"
+  },
+  "files": [
+    "dist/",
+    "plugins/",
+    "launchd/",
+    ".env.example",
+    "Dockerfile",
+    "docker-compose.yml"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "check": "node --check plugins/nordrelay/scripts/nordrelay.mjs && tsc --noEmit",
+    "dev": "tsx src/index.ts",
+    "foreground": "node plugins/nordrelay/scripts/nordrelay.mjs foreground",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run check && npm test && npm run build",
+    "status": "node plugins/nordrelay/scripts/nordrelay.mjs status",
+    "start": "node plugins/nordrelay/scripts/nordrelay.mjs start",
+    "stop": "node plugins/nordrelay/scripts/nordrelay.mjs stop",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@grammyjs/auto-retry": "^2.0.2",
+    "@openai/codex-sdk": "^0.130.0",
+    "grammy": "^1.41.1"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.0",
+    "@types/node": "^25.5.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
+  },
+  "optionalDependencies": {
+    "better-sqlite3": "^11.0.0",
+    "parakeet-coreml": "^2.2.0"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "license": "MIT"
+}

package/plugins/nordrelay/.codex-plugin/plugin.json

@@ -0,0 +1,48 @@
+{
+  "name": "nordrelay",
+  "version": "0.2.1",
+  "description": "Run a remote-control bridge for coding agents. The current adapter connects Codex sessions to Telegram with streaming replies, multi-session controls, attachments, voice input, model selection, thread browsing, and handback.",
+  "author": {
+    "name": "Ricardo",
+    "url": "https://github.com/nordbyte"
+  },
+  "homepage": "https://github.com/nordbyte",
+  "repository": "https://github.com/nordbyte/nordrelay",
+  "license": "MIT",
+  "keywords": [
+    "coding-agents",
+    "messaging",
+    "remote-control",
+    "codex",
+    "telegram",
+    "bot",
+    "app-server"
+  ],
+  "skills": "./skills/",
+  "interface": {
+    "displayName": "NordRelay",
+    "shortDescription": "Remote-control bridge for coding agents",
+    "longDescription": "Starts NordRelay, a messaging bridge for coding agents. The current runtime connects Codex and Pi sessions to Telegram: messages become agent turns, replies and tool activity stream back to Telegram, each chat or forum topic has its own session, and commands provide thread browsing, model and reasoning controls, launch profiles, attachments, voice transcription, artifacts, login, abort, retry, and CLI handback.",
+    "developerName": "Ricardo",
+    "category": "Productivity",
+    "capabilities": [
+      "Interactive",
+      "Read",
+      "Write"
+    ],
+    "websiteURL": "https://github.com/nordbyte",
+    "privacyPolicyURL": "https://github.com/nordbyte/nordrelay",
+    "termsOfServiceURL": "https://github.com/nordbyte/nordrelay",
+    "defaultPrompt": [
+      "Start NordRelay remote control",
+      "Show NordRelay status",
+      "Stop NordRelay",
+      "Show Telegram session browser",
+      "Select Codex model"
+    ],
+    "brandColor": "#229ED9",
+    "composerIcon": "./assets/nordrelay.svg",
+    "logo": "./assets/nordrelay.svg",
+    "screenshots": []
+  }
+}

package/plugins/nordrelay/assets/nordrelay.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="256" height="256" viewBox="0 0 256 256" role="img" aria-label="NordRelay">
+  <rect width="256" height="256" rx="48" fill="#229ED9"/>
+  <path d="M202.4 59.9 38.9 123.1c-11.2 4.5-11.1 10.8-2 13.6l41.9 13.1 16 49.1c2 5.6 1 7.8 6.9 7.8 4.5 0 6.5-2.1 9-4.5l21.7-21.1 45.2 33.4c8.3 4.6 14.3 2.2 16.4-7.7l29.7-140.1c3-12.1-4.6-17.6-21.3-6.8Z" fill="#fff"/>
+  <path d="m86.3 145.9 96.7-61c4.6-2.8 8.8-1.3 5.3 1.8l-82.8 74.8-3.2 34.1-16-49.7Z" fill="#D2F0FF"/>
+</svg>

package/plugins/nordrelay/commands/remote.md

@@ -0,0 +1,33 @@
+---
+description: Start, stop, or inspect the NordRelay bot process.
+---
+
+# /nordrelay:remote
+
+Start the NordRelay bot process.
+
+This command is now only a process-manager shortcut. The Telegram bot itself provides the full remote controls: `/start`, `/new`, `/session`, `/sessions`, `/sync`, `/pinned`, `/pin`, `/unpin`, `/attach`, `/handback`, `/model`, `/reasoning`, `/fast`, `/launch_profiles`, `/retry`, `/queue`, `/cancel`, `/clearqueue`, `/artifacts`, `/abort`, `/stop`, `/tasks`, `/progress`, `/status`, `/health`, `/version`, `/logs`, `/diagnostics`, `/restart`, `/update`, voice messages, photos, documents, media groups, artifacts, and login.
+
+Codex plugin commands are namespaced by the plugin id in current plugin-aware command surfaces. The unnamespaced `/remote` command is not available in current Codex TUI builds.
+
+## Arguments
+
+- empty: start the connector in the background
+- `status`: show connector status
+- `stop`: stop the connector
+- `restart`: restart the connector
+- `foreground`: run the connector in the foreground for debugging
+
+## Workflow
+
+1. Locate the plugin root containing `.codex-plugin/plugin.json` with `"name": "nordrelay"`. In a source checkout this is usually `<repo>/plugins/nordrelay`.
+2. Check whether `TELEGRAM_BOT_TOKEN` and either `TELEGRAM_ALLOWED_USER_IDS`, `TELEGRAM_ALLOWED_CHAT_IDS`, or `TELEGRAM_ALLOW_ANY_CHAT=1` are available from the environment or from `.env`.
+3. Run the connector command from the plugin root:
+
+```bash
+node scripts/nordrelay.mjs ${ARGUMENTS:-start}
+```
+
+4. If `${ARGUMENTS}` is empty, use `start`.
+5. After `start` or `restart`, run `node scripts/nordrelay.mjs status` and report the PID, selected Codex thread id, and log file.
+6. If startup fails because dependencies are missing, run `npm install` and `npm run build` in the repository root.