@goodandready/dsh-tts 0.3.22 → 0.4.0

package/lib/routes.js

@@ -0,0 +1,400 @@
+import { writeJson, readBody, isTrustedSettingsRequest } from './http-util.js'
+import { addStreamSubscriber, removeStreamSubscriber } from './stream-hub.js'
+import { pendingKeyWrites, stripSecretsFromConfig, needsApiKey } from './keys.js'
+import { PROVIDER_KEYS } from './providers.js'
+
+/**
+ * Register all /dsh-tts HTTP routes.
+ * @param {object} ctx cordis context
+ * @param {object} api live bindings from apply()
+ */
+export function registerHttpRoutes(ctx, api) {
+  const {
+    live,
+    modelManager,
+    stats,
+    speechCache,
+    cleanText,
+    synthesize,
+    credentialsView,
+    configResponse,
+    storeProviderKey,
+    clearProviderKey,
+    pending,
+  } = api
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-tts/status',
+    handler: async (req, res) => {
+      if (req.method !== 'GET') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } }); return }
+      const cfg = live()
+      writeJson(res, 200, {
+        ok: true,
+        speakReplies: cfg.speakReplies,
+        enableLocalEngines: cfg.enableLocalEngines,
+        kokoroEnabled: cfg.kokoroEnabled,
+        f5Enabled: cfg.f5Enabled,
+        streamingEnabled: cfg.streamingEnabled,
+        rate: cfg.rate,
+        chime: cfg.chime,
+        bargeIn: cfg.bargeIn,
+        language: cfg.language,
+        chain: cfg.chain,
+        roles: cfg.roles,
+        providers: PROVIDER_KEYS,
+      })
+    },
+  }), 'dsh-tts: /status route')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-tts/stream',
+    handler: async (req, res) => {
+      if (req.method !== 'GET') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } }); return }
+      try {
+        res.writeHead(200, {
+          'Content-Type': 'text/event-stream',
+          'Cache-Control': 'no-cache, no-transform',
+          'Connection': 'keep-alive',
+        })
+        res.write(': connected\n\n')
+        addStreamSubscriber(res)
+        req.on('close', () => removeStreamSubscriber(res))
+      } catch {
+        removeStreamSubscriber(res)
+      }
+    },
+  }), 'dsh-tts: /stream route')
+
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-tts/models/status',
+    handler: async (req, res) => {
+      if (req.method !== 'GET') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } }); return }
+      try {
+        const list = await modelManager.listStatus()
+        writeJson(res, 200, { ok: true, models: list })
+      } catch (err) {
+        writeJson(res, 500, { ok: false, error: String(err && err.message || err) })
+      }
+    },
+  }), 'dsh-tts: /models/status route')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-tts/models/install',
+    handler: async (req, res) => {
+      if (req.method !== 'POST') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } }); return }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      let body = {}
+      try {
+        const raw = await readBody(req, 16 * 1024)
+        body = JSON.parse(raw.toString('utf8') || '{}')
+      } catch (e) {
+        writeJson(res, 400, { ok: false, error: { code: 'body', message: e.message } })
+        return
+      }
+      const engine = String(body.engine || '').trim()
+      if (!engine) {
+        writeJson(res, 400, { ok: false, error: { code: 'param', message: 'missing engine parameter' } })
+        return
+      }
+      try {
+        // Fire installation in background or await initial start
+        modelManager.installModel(engine).catch(() => {})
+        const current = await modelManager.getStatus(engine)
+        writeJson(res, 200, { ok: true, model: current })
+      } catch (err) {
+        writeJson(res, 500, { ok: false, error: String(err && err.message || err) })
+      }
+    },
+  }), 'dsh-tts: /models/install route')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-tts/models/delete',
+    handler: async (req, res) => {
+      if (req.method !== 'DELETE' && req.method !== 'POST') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'DELETE or POST only' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      let body = {}
+      try {
+        const raw = await readBody(req, 16 * 1024)
+        body = JSON.parse(raw.toString('utf8') || '{}')
+      } catch { body = {} }
+      const engine = String(body.engine || '').trim()
+      if (!engine) {
+        writeJson(res, 400, { ok: false, error: { code: 'param', message: 'missing engine parameter' } })
+        return
+      }
+      try {
+        const result = await modelManager.deleteModel(engine)
+        writeJson(res, 200, { ok: true, model: result })
+      } catch (err) {
+        writeJson(res, 500, { ok: false, error: String(err && err.message || err) })
+      }
+    },
+  }), 'dsh-tts: /models/delete route')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-tts/integrations',
+    handler: async (req, res) => {
+      if (req.method !== 'GET') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } }); return }
+      let voiceInstalled = false
+      let messengerInstalled = false
+
+      try {
+        if (typeof ctx.webServer?.hasRoute === 'function') {
+          voiceInstalled = ctx.webServer.hasRoute('/dsh-voice/status')
+          messengerInstalled = ctx.webServer.hasRoute('/dsh-messenger-gateway/status')
+        }
+      } catch {}
+
+      // Runtime routes are the only reliable signal. Do not probe ../ siblings
+      // or node_modules layouts — they lie outside a normal npm install.
+
+      writeJson(res, 200, {
+        ok: true,
+        voice: {
+          installed: voiceInstalled,
+          package: '@goodandready/dsh-voice',
+          hint: 'dsh plugin --profile web add @goodandready/dsh-voice',
+        },
+        messenger: {
+          installed: messengerInstalled,
+          package: '@goodandready/dsh-messenger-gateway',
+          hint: 'dsh plugin --profile web add @goodandready/dsh-messenger-gateway',
+        },
+      })
+    },
+  }), 'dsh-tts: /integrations route')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-tts/cache',
+    handler: async (req, res) => {
+      if (req.method !== 'DELETE') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'DELETE only' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      const removed = await speechCache.clear()
+      writeJson(res, 200, { ok: true, removed })
+    },
+  }), 'dsh-tts: /cache route')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-tts/preview',
+    handler: async (req, res) => {
+      if (req.method !== 'POST') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      let body = {}
+      try {
+        const raw = await readBody(req, 64 * 1024)
+        body = JSON.parse(raw.toString('utf8') || '{}')
+      } catch (e) {
+        writeJson(res, 400, { ok: false, error: { code: 'body', message: e.message } })
+        return
+      }
+      const cfg = live()
+      const phrase = String(cfg.language || '').toLowerCase().startsWith('ru') ? 'Проверка голоса.' : 'Voice check.'
+      try {
+        const probe = Object.assign({}, cfg, {
+          chain: [{ provider: body.provider || '', model: body.model || '', voice: body.voice || '' }],
+        })
+        const out = await synthesize(String(body.text || phrase), probe, null, 'reply')
+        writeJson(res, 200, { ok: true, mime: out.mime, audioBase64: Buffer.from(out.audio).toString('base64') })
+      } catch (e) {
+        writeJson(res, 502, { ok: false, error: { code: 'tts', message: String(e && e.message || e) } })
+      }
+    },
+  }), 'dsh-tts: /preview route')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-tts/stats',
+    handler: async (req, res) => {
+      if (req.method === 'GET') {
+        writeJson(res, 200, { ok: true, total: stats.total, cacheHits: stats.cacheHits, errors: stats.errors, providers: stats.providers })
+        return
+      }
+      if (req.method !== 'DELETE') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET or DELETE' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      stats.total = 0
+      stats.cacheHits = 0
+      stats.errors = 0
+      stats.providers = {}
+      writeJson(res, 200, { ok: true })
+    },
+  }), 'dsh-tts: /stats route')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-tts/config',
+    handler: async (req, res) => {
+      if (req.method === 'GET') {
+        writeJson(res, 200, await configResponse())
+        return
+      }
+      if (req.method !== 'PUT' && req.method !== 'POST') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET or PUT' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'dsh-tts: settings writes are same-origin only' } })
+        return
+      }
+      if (!settingsApi) {
+        writeJson(res, 503, { ok: false, error: { code: 'settings', message: 'settings not ready' } })
+        return
+      }
+      let raw
+      try { raw = await readBody(req, 256 * 1024) } catch (e) {
+        writeJson(res, 400, { ok: false, error: { code: 'body', message: e.message } })
+        return
+      }
+      let payload
+      try { payload = JSON.parse(raw.toString('utf8') || '{}') } catch {
+        writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
+        return
+      }
+      if (payload && typeof payload.config === 'object') {
+        payload = { ...payload.config, keys: payload.keys }
+      }
+      const keys = pendingKeyWrites(payload && payload.keys)
+      const stripped = stripSecretsFromConfig(payload)
+      let parsed
+      try { parsed = Config(stripped) } catch (e) {
+        writeJson(res, 400, { ok: false, error: { code: 'schema', message: String(e && e.message || e) } })
+        return
+      }
+      try {
+        for (const item of keys) {
+          await storeProviderKey(item.provider, item.value)
+        }
+        await settingsApi.replace(parsed)
+        writeJson(res, 200, await configResponse())
+      } catch (e) {
+        writeJson(res, 500, { ok: false, error: { code: 'save', message: String(e && e.message || e) } })
+      }
+    },
+  }), 'dsh-tts: /config route')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-tts/credential',
+    handler: async (req, res) => {
+      if (req.method !== 'PUT' && req.method !== 'DELETE') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'PUT or DELETE only' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'dsh-tts: keys are same-origin only' } })
+        return
+      }
+      let payload = {}
+      if (req.method === 'PUT' || (req.headers['content-length'] && Number(req.headers['content-length']) > 0)) {
+        let raw
+        try { raw = await readBody(req, 16 * 1024) } catch (e) {
+          writeJson(res, 400, { ok: false, error: { code: 'body', message: e.message } })
+          return
+        }
+        try { payload = JSON.parse(raw.toString('utf8') || '{}') } catch {
+          writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
+          return
+        }
+      }
+      const provider = typeof payload.provider === 'string' ? payload.provider.trim() : ''
+      if (!needsApiKey(provider)) {
+        writeJson(res, 400, { ok: false, error: { code: 'provider', message: 'unknown cloud provider' } })
+        return
+      }
+      try {
+        if (req.method === 'DELETE') {
+          const ref = await clearProviderKey(provider)
+          writeJson(res, 200, { ok: true, ref, credentials: await credentialsView() })
+          return
+        }
+        const ref = await storeProviderKey(provider, payload.value)
+        writeJson(res, 200, { ok: true, ref, credentials: await credentialsView() })
+      } catch (e) {
+        writeJson(res, 400, { ok: false, error: { code: 'credential', message: String(e && e.message || e) } })
+      }
+    },
+  }), 'dsh-tts: /credential route')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-tts/pending',
+    handler: async (req, res) => {
+      if (req.method !== 'GET') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } }); return }
+      const url = new URL(req.url || '/', 'http://127.0.0.1')
+      const after = url.searchParams.get('after') || ''
+      let items = pending.slice()
+      if (after) {
+        const idx = items.findIndex((x) => x.id === after)
+        items = idx >= 0 ? items.slice(idx + 1) : items
+      }
+      writeJson(res, 200, { ok: true, items })
+    },
+  }), 'dsh-tts: /pending route')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-tts/speak',
+    handler: async (req, res) => {
+      if (req.method !== 'POST') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } }); return }
+      let raw
+      try { raw = await readBody(req, 256 * 1024) } catch (e) {
+        writeJson(res, 400, { ok: false, error: { code: 'body', message: e.message } }); return
+      }
+      let payload
+      try { payload = JSON.parse(raw.toString('utf8') || '{}') } catch { payload = {} }
+      const text = cleanText(payload.text, live())
+      if (!text) { writeJson(res, 400, { ok: false, error: { code: 'no-text', message: 'no text' } }); return }
+      const cfg = live()
+      const controller = new AbortController()
+      const timer = setTimeout(() => controller.abort(), cfg.timeoutMs)
+      try {
+        const out = await synthesize(text, cfg, controller.signal)
+        writeJson(res, 200, {
+          ok: true,
+          provider: out.provider,
+          mime: out.mime,
+          audioBase64: Buffer.from(out.audio).toString('base64'),
+          tookMs: out.tookMs,
+        })
+      } catch (e) {
+        writeJson(res, 502, { ok: false, error: { code: 'chain', message: String(e && e.message || e) } })
+      } finally {
+        clearTimeout(timer)
+      }
+    },
+  }), 'dsh-tts: /speak route')
+}

package/lib/stream-hub.js

@@ -0,0 +1,31 @@
+// SSE subscriber hub for /dsh-tts/stream.
+
+const subscribers = new Set()
+
+export function addStreamSubscriber(res) {
+  subscribers.add(res)
+}
+
+export function removeStreamSubscriber(res) {
+  subscribers.delete(res)
+}
+
+export function broadcastStream(type, item) {
+  const payload = `event: ${type}\ndata: ${JSON.stringify(item)}\n\n`
+  for (const res of subscribers) {
+    try {
+      res.write(payload)
+    } catch {
+      subscribers.delete(res)
+    }
+  }
+}
+
+export function clearStreamSubscribers() {
+  for (const res of subscribers) {
+    try {
+      res.end()
+    } catch { /* already closed */ }
+  }
+  subscribers.clear()
+}

package/lib/text.js

@@ -11,8 +11,8 @@ export function blocksToText(content) {
   return parts.join('\n')
 }
 
-// Короткие пометки вместо выброшенной разметки. Формулировки выбираются по
-// языку озвучки из настроек; подстановки {n} заполняются числом строк.
+// Short spoken notices replace dropped markup. Wording follows
+// the configured speech language; {n} is filled with a line/row count.
 export const SPEECH_PHRASES = {
   en: { codeBlock: 'code block, {n} lines', table: 'table, {n} rows', summaryIntro: 'Summary of the reply.' },
   ru: { codeBlock: 'блок кода, {n} строк', table: 'таблица, {n} строк', summaryIntro: 'Пересказ ответа.' },
@@ -23,8 +23,8 @@ export function speechPhrases(language) {
   return lang.startsWith('ru') ? SPEECH_PHRASES.ru : SPEECH_PHRASES.en
 }
 
-// Фильтры наррации: вырезания поверх общей чистки, до словаря произношения.
-// Порядок: своя регулярка -> блоки *действий* -> режим «только цитаты».
+// Narration filters run on top of general scrubbing, before pronunciation.
+// Order: custom regex -> *action* blocks -> quotes-only mode.
 export function applyNarrationFilters(text, cfg) {
   let out = String(text || '')
   if (cfg && cfg.removeRegex) {
@@ -40,7 +40,7 @@ export function applyNarrationFilters(text, cfg) {
   return out
 }
 
-// Грубая эвристика языка куска: где букв больше, тот язык и подсказываем.
+// Rough language heuristic: whichever script has more letters wins.
 export function detectLang(text) {
   const s = String(text || '')
   const cyr = (s.match(/[\u0400-\u04FF]/g) || []).length
@@ -48,10 +48,10 @@ export function detectLang(text) {
   return cyr > lat ? 'ru' : 'en'
 }
 
-// Словарь произношения: правила применяются сверху вниз, каждое по одному
-// разу ко всему тексту. Левая часть — обычный текст; запись вида /…/флаги
-// трактуется как регулярное выражение для тех, кто умеет. whole=true требует
-// совпадения целого слова (границы по буквам/цифрам Unicode).
+// Pronunciation rules apply top-down, once each over the whole text.
+// Left side is plain text; /…/flags form is treated as a regular expression.
+// whole=true requires a full word match (Unicode letter/digit boundaries).
+
 function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }
@@ -114,8 +114,8 @@ export function stripForSpeech(raw, maxChars, opts) {
   const skipCode = options.skipCode !== false
   const phrases = options.phrases || SPEECH_PHRASES.en
   let text = String(raw || '')
-  // Чистка обязана идти до нарезки на предложения, иначе половина блока
-  // уедет в первый кусок и будет озвучена.
+    // Scrubbing must run before sentence splitting or half a fenced block ends
+    // up in the first chunk and is spoken.
   if (skipCode) {
     text = text.replace(/```[\s\S]*?```/g, (block) => {
       const inner = block.replace(/^```[^\n]*\n?/, '').replace(/\n?```\s*$/, '')
@@ -124,8 +124,8 @@ export function stripForSpeech(raw, maxChars, opts) {
     })
     text = text.replace(/`[^`\n]+`/g, ' ')
   }
-  // Таблицы Markdown: подряд идущие строки, начинающиеся с |; разделительная
-  // шапка |---| в счёт строк не идёт.
+    // Markdown tables: consecutive lines starting with |; the |---| separator
+    // row is not counted as a data row.
   text = text.replace(/(?:^[ \t]*\|.*\|[ \t]*$\n?)+/gm, (run) => {
     const rows = run.trim().split('\n')
       .filter((line) => !/^\s*\|[\s:|-]+\|\s*$/.test(line)).length
@@ -136,7 +136,7 @@ export function stripForSpeech(raw, maxChars, opts) {
   text = text.replace(/[#*_>]+/g, ' ')
   text = text.replace(/MEDIA:[^\s]+/g, ' ')
   text = text.replace(/\s+/g, ' ').trim()
-  // maxChars === 0 отключает обрезку; не задан — дефолтные 4000.
+  // maxChars === 0 disables truncation; unset means the 4000 default.
   const requested = Number(maxChars)
   if (requested > 0 && text.length > requested) text = text.slice(0, requested)
   return text
@@ -147,6 +147,32 @@ export function assistantText(message) {
   return blocksToText(message.content)
 }
 
+// Protect common abbreviations from false sentence splits
+const PROTECTED_ABBREVIATIONS = [
+  // Russian abbreviations
+  'т.е.', 'т.д.', 'т.п.', 'т.к.', 'руб.', 'коп.', 'ул.', 'пер.', 'пр.', 'просп.',
+  'д.', 'корп.', 'стр.', 'кв.', 'г.', 'гг.', 'в.', 'вв.', 'см.', 'ср.', 'напр.',
+  'рис.', 'табл.', 'им.', 'акад.', 'проф.', 'доц.', 'млн.', 'млрд.', 'тыс.',
+  // English abbreviations
+  'e.g.', 'i.e.', 'vs.', 'etc.', 'dr.', 'mr.', 'mrs.', 'ms.', 'prof.',
+  'approx.', 'dept.', 'est.', 'min.', 'max.', 'no.', 'vol.', 'p.m.', 'a.m.'
+]
+
+export function protectAbbreviations(text) {
+  let res = String(text || '')
+  for (const abbr of PROTECTED_ABBREVIATIONS) {
+    const escaped = abbr.replace(/\./g, '\\.')
+    const rx = new RegExp('(?<=^|[\\s"«(])' + escaped + '(?=[\\s"»)\\]]|$)', 'gi')
+    res = res.replace(rx, (m) => m.replace(/\./g, '\u2024'))
+  }
+  res = res.replace(/(?<=[vV]?\d+)\.(?=\d+)/g, '\u2024')
+  return res
+}
+
+export function restoreAbbreviations(text) {
+  return String(text || '').replace(/\u2024/g, '.')
+}
+
 /**
  * Режет текст на куски по границам предложений.
  *
@@ -161,18 +187,19 @@ export function assistantText(message) {
 export function splitSentences(text, maxChars) {
   const limit = Number(maxChars) > 0 ? Number(maxChars) : 320
   const min = Math.min(60, Math.floor(limit / 3))
-  const source = String(text || '').trim()
-  if (!source) return []
+  const raw = String(text || '').trim()
+  if (!raw) return []
 
+  const source = protectAbbreviations(raw)
   const pieces = []
   let current = ''
-  // Границей считаем точку, вопрос, восклицание, многоточие и перевод строки.
+  // Boundaries are period, question, exclamation, ellipsis, and newline.
   for (const part of source.split(/(?<=[.!?…])\s+|\n+/)) {
     const chunk = String(part || '').trim()
     if (!chunk) continue
     if (!current) { current = chunk } else if (current.length < min) { current += ' ' + chunk }
     else { pieces.push(current); current = chunk }
-    // Кусок длиннее предела режем по словам: провайдеры не любят простыни.
+    // Oversized pieces are split on words: providers choke on walls of text.
     while (current.length > limit) {
       let cut = current.lastIndexOf(' ', limit)
       if (cut < min) cut = limit
@@ -181,5 +208,5 @@ export function splitSentences(text, maxChars) {
     }
   }
   if (current) pieces.push(current)
-  return pieces.filter(Boolean)
+  return pieces.filter(Boolean).map(restoreAbbreviations)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-tts",
-  "version": "0.3.22",
+  "version": "0.4.0",
   "description": "Text-to-speech for DeepSeek Harness: speak agent replies in the Web UI with a provider fallback chain (OpenAI, ElevenLabs, Google, Azure, Groq, Deepgram, OpenRouter, Edge, Piper, eSpeak).",
   "license": "MIT",
   "type": "module",
@@ -13,9 +13,12 @@
   },
   "files": [
     "lib/",
+    "scripts/",
     "cordis.patch.yml",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "README.ru.md",
+    "README.zh.md"
   ],
   "keywords": [
     "dsh",
@@ -63,4 +66,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/scripts/f5_daemon.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+"""F5-TTS control stub.
+
+Honest status only: ping answers when this script can run. It does not
+synthesize audio. Real F5 inference is out of scope for this package until a
+supported external runtime is documented and wired.
+"""
+import sys
+import json
+
+
+def main():
+    if len(sys.argv) > 1 and sys.argv[1] == '--ping':
+        print(json.dumps({"ok": True, "status": "ready", "synthesize": False}))
+        sys.exit(0)
+
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            req = json.loads(line)
+            cmd = req.get("cmd")
+            if cmd == "ping":
+                print(json.dumps({"ok": True, "status": "pong", "synthesize": False}))
+            elif cmd == "synthesize":
+                print(json.dumps({
+                    "ok": False,
+                    "error": "F5 synthesis is not bundled; use Edge/Piper/eSpeak offline providers",
+                }))
+            else:
+                print(json.dumps({"ok": False, "error": f"unknown cmd: {cmd}"}))
+            sys.stdout.flush()
+        except Exception as e:
+            print(json.dumps({"ok": False, "error": str(e)}))
+            sys.stdout.flush()
+
+
+if __name__ == "__main__":
+    main()