dsh-tg-bridge 1.3.4 → 1.4.0

package/README.md

@@ -23,9 +23,28 @@ blocks.
 ## Requirements
 
 - Node.js ≥ 20
+- DeepSeek Harness `0.2.1-rc.2` or newer in the `0.2.x` line (`>=0.2.1-rc.2 <0.3.0`)
 - DeepSeek Harness installed (`~/.dsh/profiles/headless`)
 - A Telegram bot token from [@BotFather](https://t.me/BotFather)
 
+The supported harness range is declared twice: `engines.dsh` in `package.json`
+(what npm and the market read) and `dsh.compatibility.dsh` (what DSH itself
+reads before mounting the bundle). A future `0.3.0` needs an explicit bump:
+the bridge relies on the `0.2.x` CLI flags and profile layout.
+
+## Ecosystem
+
+The Chinese DSH community maintains the largest plugin catalogs and the
+in-app markets that read them; this bridge follows their packaging rules so it
+can be listed next to them:
+
+- [awesome-dsh-plugin](https://awesome-dsh-plugin.com) — bilingual (English /
+  中文) plugin list and the `dsh-plugin-catalog` npm package
+- [dsh-market](https://github.com/dsh-market/dsh-market) — the Chinese-built
+  in-app market with one-click install and themes
+- [dsh-find-plugin](https://github.com/awesome-dsh-plugin/dsh-find-plugin) —
+  finds a plugin from chat instead of browsing a catalog
+
 ## Languages
 
 - Menus (`/` in chat): three sets, `ru` by default, plus `en` and `zh`.
@@ -39,26 +58,26 @@ blocks.
 
 One command: your bot token and your numeric id. Nothing to edit by hand.
 
-**Windows (PowerShell)**
+**Any platform with Node.js ≥ 20**
 
-```powershell
+```bash
 npx dsh-tg-bridge@latest init --token 123456789:AA... --user 123456789
 npx dsh-tg-bridge@latest setup
 ```
 
-**macOS / Linux**
+`init` writes the token, your id and the working directory; `setup` registers
+autostart and starts the bridge.
+
+**As a DSH plugin** (the package carries a `dsh.bundle`; the catalog entry is
+pending review):
 
 ```bash
-DSH_TG_TOKEN=123456789:AA... DSH_TG_USER=123456789 \
-  bash -c "$(curl -fsSL https://raw.githubusercontent.com/aleksvega/dsh-tg-bridge/main/install.sh)"
+dsh plugin --profile desktop add dsh-tg-bridge
 ```
 
-**Windows, one line** (same thing, installs and starts):
-
-```powershell
-$env:DSH_TG_TOKEN='123456789:AA...'; $env:DSH_TG_USER='123456789'
-irm https://raw.githubusercontent.com/aleksvega/dsh-tg-bridge/main/install.ps1 | iex
-```
+The plugin starts one bridge when DSH boots and stops it on shutdown; if a
+bridge is already running (for example from the scheduled task), it leaves it
+alone. Run `npx dsh-tg-bridge@latest init ...` first so a config exists.
 
 What `init` does:
 
@@ -90,17 +109,17 @@ in Russian, English and Chinese at once. The full settings table, permissions, c
 common errors are in [docs/TELEGRAM-SETUP.md](docs/TELEGRAM-SETUP.md).
 
 **Autostart** is installed by the setup: `launchd` on macOS, `systemd --user` on
-Linux. On Windows `setup` registers the `DSH-TG-Bridge` task and a one-minute watchdog
-`DSH-Bridge-Kick` that brings the bridge back after a crash.
+Linux. On Windows `setup` registers the `DSH-TG-Bridge` task, which runs the
+guarded supervisor (the same launcher on logon and every five minutes) so a
+crashed bridge comes back without a second poller.
 
 **Manual install** (if you want full control):
 
 ```bash
-git clone https://github.com/aleksvega/dsh-tg-bridge.git ~/.dsh/tg-bridge
-cd ~/.dsh/tg-bridge
-node cli.mjs init --token 123456789:AA... --user 123456789
-node cli.mjs check     # report only, changes nothing
-node cli.mjs setup     # stop the old bridge and start the new one
+npm install -g dsh-tg-bridge
+dsh-tg init --token 123456789:AA... --user 123456789
+dsh-tg check     # report only, changes nothing
+dsh-tg setup     # stop the old bridge and start the new one
 ```
 
 If the bridge is already installed, `setup` restarts it on the new code and reinstalls

package/bridge-kick.mjs

@@ -8,7 +8,7 @@
 //
 // Exit codes: 0 = nothing to do or started, 2 = start failed.
 
-import { spawnSync } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { appendFileSync, existsSync, readFileSync, openSync, closeSync, unlinkSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
@@ -21,25 +21,48 @@ const KICK_LOG = join(DIR, 'kick.log');
 
 // Shared with setup.mjs: a restart holds this lock, so a tick that lands in the
 // middle of one must not start a second poller.
+//
+// A live holder used to disable supervision forever: the old code started the
+// bridge with spawnSync(), which blocks until the child EXITS — for a long-lived
+// bridge the tick never returned, kept this lock for hours, and every later tick
+// logged "restart in progress" and skipped (2026-10-24: supervisor dead from
+// 18:57 while the bridge lived). Two fixes: spawn() + unref() below, and
+// LOCK_MAX_AGE_MS here so even a genuinely wedged holder cannot wedge the guard.
 const LOCK = join(DIR, 'restart.lock');
+const LOCK_MAX_AGE_MS = 180_000;
+
 function acquireLock(owner) {
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
       const fd = openSync(LOCK, 'wx');
       writeFileSync(fd, JSON.stringify({ pid: process.pid, owner, ts: Date.now() }));
       closeSync(fd);
-      const release = () => { try { unlinkSync(LOCK); } catch {} };
+      // Remove only our own lock: after a stale-lock takeover the file belongs
+      // to the new holder, and a late exit must not steal it.
+      const release = () => {
+        try {
+          if (Number(JSON.parse(readFileSync(LOCK, 'utf8')).pid) === process.pid) unlinkSync(LOCK);
+        } catch {}
+      };
       process.on('exit', release);
       return release;
     } catch (error) {
       if (error.code !== 'EEXIST') return null;
       let held = 0;
-      try { held = Number(JSON.parse(readFileSync(LOCK, 'utf8')).pid) || 0; } catch {}
+      let heldTs = 0;
+      try {
+        const info = JSON.parse(readFileSync(LOCK, 'utf8'));
+        held = Number(info.pid) || 0;
+        heldTs = Number(info.ts) || 0;
+      } catch {}
+      const age = heldTs ? Date.now() - heldTs : Number.POSITIVE_INFINITY;
       let alive = false;
       if (held) {
         try { process.kill(held, 0); alive = true; } catch (e) { alive = e.code === 'EPERM'; }
       }
-      if (alive) return null;
+      // Age wins over liveness: a holder that has not finished a restart in
+      // LOCK_MAX_AGE_MS is wedged, not busy.
+      if (alive && age < LOCK_MAX_AGE_MS) return null;
       try { unlinkSync(LOCK); } catch {}
     }
   }
@@ -93,25 +116,37 @@ function main() {
   const restartPending = existsSync(marker);
 
   const filePid = pidFromFile();
+  // Cheap path first: a live pid file is authoritative for a healthy bridge, so
+  // the minute tick costs one kill(0) instead of a PowerShell process scan.
+  if (filePid && alive(filePid)) {
+    if (restartPending) log(`marker present but pid ${filePid} alive`);
+    return 0;
+  }
+  // Only when the pid file is stale or missing: scan for a bridge that started
+  // without writing one.
   const live = bridgePids();
-  if (live.length > 0 || (filePid && alive(filePid))) {
-    if (restartPending && live.length === 0) log(`marker present but pid ${filePid} alive`);
+  if (live.length > 0) {
+    log(`pid file stale (${filePid || 'missing'}), bridge ${live.join(',')} alive — not starting`);
     return 0;
   }
 
   log(restartPending ? 'marker present and no bridge: starting' : 'no bridge: starting');
-  const child = spawnSync(process.execPath, ['--dns-result-order=ipv4first', BRIDGE], {
-    cwd: DIR,
-    detached: true,
-    stdio: 'ignore',
-    windowsHide: true,
-  });
-  if (child.error) {
-    log(`start failed: ${child.error.message}`);
+  // spawn(), NOT spawnSync(): spawnSync waits for the child to exit, and this
+  // child is meant to outlive the tick.
+  let child;
+  try {
+    child = spawn(process.execPath, ['--dns-result-order=ipv4first', BRIDGE], {
+      cwd: DIR,
+      detached: true,
+      stdio: 'ignore',
+      windowsHide: true,
+    });
+  } catch (error) {
+    log(`start failed: ${error.message}`);
     return 2;
   }
-  try { readFileSync; } catch {}
-  log('start issued');
+  child.unref();
+  log(`start issued pid=${child.pid ?? '?'}`);
   return 0;
 }
 

package/cordis.patch.yml

@@ -0,0 +1,6 @@
+# DSH bundle: load the Telegram bridge with the harness. The plugin starts one
+# bridge process (skipped when a bridge is already running) and stops it on
+# shutdown. Install with: dsh plugin --profile desktop add dsh-tg-bridge
+- insert:
+    - id: tg-bridge
+      name: dsh-tg-bridge

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "dsh-tg-bridge",
-  "version": "1.3.4",
+  "version": "1.4.0",
   "description": "Telegram bridge for DeepSeek Harness: text, voice, photos and project-per-topic sessions without opening the desktop app",
   "type": "module",
-  "main": "bridge.mjs",
+  "main": "plugin-bridge.mjs",
   "bin": {
     "dsh-tg": "./cli.mjs"
   },
@@ -16,7 +16,25 @@
     "test": "node --test"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=20",
+    "dsh": ">=0.2.1-rc.2 <0.3.0"
+  },
+  "dsh": {
+    "manifestVersion": 1,
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "compatibility": {
+      "dsh": ">=0.2.1-rc.2 <0.3.0",
+      "profiles": [
+        "desktop",
+        "web"
+      ]
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aleksvega/dsh-tg-bridge.git"
   },
   "keywords": [
     "deepseek-harness",
@@ -31,6 +49,8 @@
   "dependencies": {},
   "files": [
     "bridge.mjs",
+    "plugin-bridge.mjs",
+    "cordis.patch.yml",
     "control.mjs",
     "i18n.mjs",
     "prices.mjs",

package/plugin-bridge.mjs

@@ -0,0 +1,83 @@
+// DSH plugin entry: run the Telegram bridge alongside the harness.
+//
+// The bridge is a separate long-polling process, not a tool inside the agent,
+// so the plugin starts it once when the host boots and stops it on shutdown.
+// It never starts a second copy: a live `bridge.pid` wins. That keeps the
+// scheduled-task install and this plugin from polling the same bot twice.
+import { spawn } from 'node:child_process';
+import { closeSync, existsSync, openSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const name = 'tg-bridge';
+export const inject = [];
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const DSH_HOME = process.env.DSH_HOME || join(homedir(), '.dsh');
+const DIR = join(DSH_HOME, 'tg-bridge');
+
+function alive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === 'EPERM';
+  }
+}
+
+function runningPid() {
+  try {
+    const pid = Number(readFileSync(join(DIR, 'bridge.pid'), 'utf8').trim());
+    return pid > 0 && alive(pid) ? pid : 0;
+  } catch {
+    return 0;
+  }
+}
+
+export function apply(ctx, config = {}) {
+  if (config.autoStart === false) return;
+  // Nothing to start until `dsh-tg init` wrote a token and a working directory.
+  if (!existsSync(join(DIR, 'config.json'))) return;
+  if (runningPid()) return;
+
+  // Two profiles loading at once must not both start a poller.
+  const lock = join(DIR, 'plugin-start.lock');
+  try {
+    const fd = openSync(lock, 'wx');
+    writeFileSync(fd, String(process.pid));
+    closeSync(fd);
+  } catch {
+    return;
+  }
+
+  let child = null;
+  try {
+    child = spawn(process.execPath, [join(HERE, 'bridge.mjs')], {
+      cwd: DIR,
+      detached: true,
+      stdio: 'ignore',
+      windowsHide: true,
+      env: {
+        ...process.env,
+        // Inside DSH desktop, process.execPath is Electron; this makes it run
+        // as Node without opening a window.
+        ...(process.versions.electron ? { ELECTRON_RUN_AS_NODE: '1' } : {}),
+      },
+    });
+    child.unref();
+  } catch {
+    child = null;
+  } finally {
+    try {
+      unlinkSync(lock);
+    } catch {}
+  }
+
+  if (!child?.pid || typeof ctx.on !== 'function') return;
+  ctx.on('dispose', () => {
+    try {
+      if (alive(child.pid)) process.kill(child.pid);
+    } catch {}
+  });
+}

package/setup.mjs

@@ -286,11 +286,30 @@ async function main() {
   if (recentConflict) fail('a stale poller still owns getUpdates (409 in the last 90s) — kill it, then re-run setup');
   else ok('no 409 conflicts in the last 90s');
 
+  // 4. Scheduled task: point it at the GUARDED HIDDEN launcher (wscript + bridge-kick).
+  //    Two reasons it must be the guarded supervisor and not a direct node.exe start:
+  //    (a) a console action on an Interactive-logon task pops a window at every logon
+  //        and repetition — wscript with window style 0 never shows one;
+  //    (b) starting bridge.mjs directly here races the one-minute tick: both see "no
+  //        bridge" and both start a poller (409 getUpdates Conflict). Going through
+  //        bridge-kick.mjs means every start happens under restart.lock after a check.
+  const vbsPath = join(BRIDGE_DIR, 'bridge-kick-hidden.vbs');
+  writeFileSync(
+    vbsPath,
+    [
+      "' hidden launcher: DSH bridge supervisor tick (no console window)",
+      'Set sh = CreateObject("WScript.Shell")',
+      `sh.CurrentDirectory = "${BRIDGE_DIR}"`,
+      `rc = sh.Run("""${NODE}"" ""${join(BRIDGE_DIR, 'bridge-kick.mjs')}""", 0, True)`,
+      'WScript.Quit rc',
+      '',
+    ].join('\r\n'),
+  );
   const task = run('powershell', [
     '-NoProfile', '-NonInteractive', '-Command',
-    `$a = New-ScheduledTaskAction -Execute '${NODE}' -Argument '"--dns-result-order=ipv4first" "${BRIDGE}"' -WorkingDirectory '${BRIDGE_DIR}'; Set-ScheduledTask -TaskName 'DSH-TG-Bridge' -Action $a | Out-Null; 'ok'`,
+    `$a = New-ScheduledTaskAction -Execute 'C:\\Windows\\System32\\wscript.exe' -Argument '//B //Nologo "${vbsPath}"'; Set-ScheduledTask -TaskName 'DSH-TG-Bridge' -Action $a | Out-Null; 'ok'`,
   ]);
-  if ((task.stdout || '').includes('ok')) ok('scheduled task DSH-TG-Bridge now uses the same flags');
+  if ((task.stdout || '').includes('ok')) ok('scheduled task DSH-TG-Bridge now runs the guarded hidden supervisor');
   else warn(`scheduled task not updated: ${(task.stderr || '').trim().slice(0, 160)}`);
 
   // 5. Bot menu.