@restregular/dsh-powerup 0.0.0-stage → 0.2.1

package/cordis.patch.yml

@@ -0,0 +1,7 @@
+# dsh-powerup bundle patch: inserts the Host row. The Client half is resolved
+# from the same package through `dsh.client` in package.json; `name` must be
+# byte-for-byte the package name because the client module graph locates the
+# package by the Loader row name.
+- insert:
+    - id: dsh-powerup
+      name: '@restregular/dsh-powerup'

package/icon.svg

@@ -0,0 +1,22 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="256" height="256" viewBox="0 0 256 256" fill="none">
+  <defs>
+    <linearGradient id="dsh-powerup-bg" x1="32" y1="24" x2="224" y2="232" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#8B5CF6"/>
+      <stop offset="0.55" stop-color="#6D3BE0"/>
+      <stop offset="1" stop-color="#4C1D95"/>
+    </linearGradient>
+    <radialGradient id="dsh-powerup-glow" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(80 56) rotate(45) scale(190)">
+      <stop stop-color="#FFFFFF" stop-opacity="0.26"/>
+      <stop offset="1" stop-color="#FFFFFF" stop-opacity="0"/>
+    </radialGradient>
+    <linearGradient id="dsh-powerup-chevron" x1="78" y1="56" x2="178" y2="178" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#FFFFFF"/>
+      <stop offset="1" stop-color="#D8FFF4"/>
+    </linearGradient>
+  </defs>
+  <rect x="16" y="16" width="224" height="224" rx="56" fill="url(#dsh-powerup-bg)"/>
+  <rect x="16" y="16" width="224" height="224" rx="56" fill="url(#dsh-powerup-glow)"/>
+  <path d="M78 102 128 56l50 46" stroke="url(#dsh-powerup-chevron)" stroke-width="22" stroke-linecap="round" stroke-linejoin="round"/>
+  <path d="M78 178 128 132l50 46" stroke="#9DF2DB" stroke-width="22" stroke-linecap="round" stroke-linejoin="round"/>
+  <path d="M96 212h64" stroke="#FFC94D" stroke-width="10" stroke-linecap="round"/>
+</svg>

package/index.js

@@ -0,0 +1,119 @@
+/**
+ * Host half of dsh-powerup.
+ *
+ * The plugin is primarily a Client UI upgrade. This Host entry exists for one
+ * operation the browser cannot perform itself: restarting the whole DSH
+ * desktop application after a plugin update. It exposes a small loopback-only
+ * route under `/dsh-powerup/api`:
+ *
+ *   GET  /dsh-powerup/api/restart   → { ok, supported, reason? }
+ *   POST /dsh-powerup/api/restart   → schedules the restart, then answers
+ *
+ * The Client half drives plugin installation through the built-in
+ * `pluginManager` Remote; only the process restart needs Host code.
+ */
+
+import { describeRestart, requestRestart } from './lib/restart.js';
+
+/** Prefix owned by this plugin. */
+const ROUTE = '/dsh-powerup/api';
+
+/**
+ * @param {import('node:http').ServerResponse} res
+ * @param {unknown} payload
+ * @param {number} status
+ */
+function sendJson(res, payload, status = 200) {
+  if (res.headersSent) return;
+  const body = JSON.stringify(payload);
+  res.writeHead(status, {
+    'content-type': 'application/json; charset=utf-8',
+    'cache-control': 'no-store',
+    'content-length': String(Buffer.byteLength(body)),
+  });
+  res.end(body);
+}
+
+/**
+ * The request came from this machine.
+ * @param {import('node:http').IncomingMessage} req
+ * @returns {boolean}
+ */
+function isLoopback(req) {
+  const address = req.socket?.remoteAddress ?? '';
+  return address === '127.0.0.1'
+    || address === '::1'
+    || address.startsWith('::ffff:127.')
+    || address === '';
+}
+
+/**
+ * A browser request carries an Origin matching Host. The desktop document
+ * proxy strips both headers, which is accepted here — a browser cannot produce
+ * that shape, and a loopback peer without an Origin is the desktop shell.
+ * @param {import('node:http').IncomingMessage} req
+ * @returns {boolean}
+ */
+function sameOrigin(req) {
+  const origin = req.headers.origin;
+  if (typeof origin !== 'string' || origin === '') return true;
+  try {
+    return new URL(origin).host === req.headers.host;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * @param {import('node:http').IncomingMessage} req
+ * @param {import('node:http').ServerResponse} res
+ */
+async function handle(req, res) {
+  if (!isLoopback(req) || !sameOrigin(req)) {
+    sendJson(res, { ok: false, error: 'forbidden' }, 403);
+    return;
+  }
+
+  const url = new URL(req.url ?? ROUTE, 'http://localhost');
+  const op = url.pathname.slice(ROUTE.length).replace(/^\/+/u, '') || url.searchParams.get('op') || '';
+  if (op !== '' && op !== 'restart') {
+    sendJson(res, { ok: false, error: 'not-found' }, 404);
+    return;
+  }
+
+  if (req.method === 'GET') {
+    sendJson(res, { ok: true, action: 'restart', ...describeRestart() });
+    return;
+  }
+
+  if (req.method === 'POST') {
+    try {
+      const scheduled = requestRestart();
+      sendJson(res, { ok: true, restarting: true, ...scheduled });
+    } catch (error) {
+      sendJson(res, { ok: false, code: error?.code, error: String(error?.message ?? error) }, 409);
+    }
+    return;
+  }
+
+  sendJson(res, { ok: false, error: 'method-not-allowed' }, 405);
+}
+
+/**
+ * Mount the restart route once the Web server exists.
+ * @param {import('@deepseek-ai/cordis').Context} ctx
+ */
+export function apply(ctx) {
+  if (ctx === undefined || typeof ctx.inject !== 'function') return;
+  ctx.inject(['webServer'], (scope) => {
+    const webServer = scope.get('webServer');
+    if (webServer === undefined || typeof webServer.register !== 'function') return;
+    scope.effect(
+      () => webServer.register({ kind: 'prefix', path: ROUTE, handler: handle }),
+      'dsh-powerup: restart route',
+    );
+  });
+}
+
+/** Exported for tests only; the Host never reads this. */
+export const __test = { handle, isLoopback, sameOrigin, ROUTE };

package/lib/restart-helper.cjs

@@ -0,0 +1,196 @@
+/**
+ * dsh-powerup — detached restart helper (runs in Electron's Node mode).
+ *
+ * Started by `lib/restart.js` with `detached: true`. It waits for the UI
+ * notice and the HTTP response to settle, ends the Electron main process, waits
+ * for the old Host to exit, then relaunches the same executable.
+ *
+ * Arguments:
+ *   1. exe        desktop executable (`process.execPath`)
+ *   2. mainPid    Electron main process pid (the Host's parent)
+ *   3. hostPid    this Host process pid
+ *   4. appDir     application directory, used as the new process cwd
+ *   5. argsJson   optional JSON array of launch arguments (normally empty)
+ *   6. mode       `restart` (default); `shutdown` is reserved for future use
+ *   7. delayMs    grace period before acting (default 1500 ms)
+ *
+ * Environment:
+ *   DSH_POWERUP_RESTART_LOG  optional path for a one-line run log.
+ *
+ * Adapted from dsh-pocket's restart helper.
+ *
+ * @module dsh-powerup/restart-helper
+ */
+
+'use strict';
+
+const { spawn } = require('node:child_process');
+const fs = require('node:fs');
+
+/** Wait for the UI notice and the HTTP response before ending the main process. */
+const RESPONSE_GRACE_MS = 1500;
+/** Upper bound for the old Host's graceful shutdown. */
+const HOST_EXIT_TIMEOUT_MS = 15000;
+/** Let the OS release the single-instance lock and file handles. */
+const RELAUNCH_DELAY_MS = 1200;
+
+const sleep = (ms) => new Promise((resolve) => {
+  setTimeout(resolve, ms);
+});
+
+/**
+ * Whether a process is alive; an access-denied answer counts as alive.
+ * @param {number} pid
+ * @returns {boolean}
+ */
+function alive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error !== null && typeof error === 'object' && error.code === 'EPERM';
+  }
+}
+
+/**
+ * Poll until the process exits or the deadline passes.
+ * @param {number} pid
+ * @param {number} timeout
+ * @returns {Promise<boolean>}
+ */
+async function waitGone(pid, timeout) {
+  const deadline = Date.now() + timeout;
+  while (Date.now() < deadline) {
+    if (!alive(pid)) return true;
+    await sleep(120);
+  }
+  return !alive(pid);
+}
+
+/**
+ * Terminate a process; failures are logged, not thrown.
+ * @param {number} pid
+ * @param {(message: string) => void} log
+ */
+function terminate(pid, log) {
+  if (!alive(pid)) return;
+  try {
+    process.kill(pid);
+    log(`terminated pid=${String(pid)}`);
+  } catch (error) {
+    log(`terminate pid=${String(pid)} failed: ${String(error && error.message ? error.message : error)}`);
+  }
+}
+
+/**
+ * Parse the optional launch arguments.
+ * @param {string | undefined} raw
+ * @returns {string[]}
+ */
+function parseArgs(raw) {
+  if (typeof raw !== 'string' || raw.length === 0) return [];
+  try {
+    const value = JSON.parse(raw);
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Parse the grace period, clamped to 0–10 seconds.
+ * @param {string | undefined} raw
+ * @returns {number}
+ */
+function parseDelay(raw) {
+  if (typeof raw !== 'string' || raw.length === 0) return RESPONSE_GRACE_MS;
+  const value = Number(raw);
+  if (!Number.isFinite(value) || value < 0) return RESPONSE_GRACE_MS;
+  return Math.min(value, 10000);
+}
+
+async function main() {
+  const [exe, mainPidRaw, hostPidRaw, appDir, argsRaw, modeRaw, delayRaw] = process.argv.slice(2);
+  const mode = modeRaw === 'shutdown' ? 'shutdown' : 'restart';
+  const delayMs = parseDelay(delayRaw);
+  const mainPid = Number(mainPidRaw);
+  const hostPid = Number(hostPidRaw);
+  const logPath = process.env.DSH_POWERUP_RESTART_LOG;
+  /** @param {string} message */
+  const log = (message) => {
+    if (typeof logPath !== 'string' || logPath.length === 0) return;
+    try {
+      fs.appendFileSync(logPath, `${new Date().toISOString()} ${message}\n`);
+    } catch {
+      /* A missing log never blocks the action. */
+    }
+  };
+
+  if (typeof exe !== 'string' || exe.length === 0) {
+    log('missing executable');
+    process.exit(2);
+  }
+
+  log(`scheduled mode=${mode} exe=${exe} main=${String(mainPid)} host=${String(hostPid)} delay=${String(delayMs)}`);
+  await sleep(delayMs);
+
+  // The Host exits on its own when the main process goes away; only the main
+  // process is terminated outright.
+  terminate(mainPid, log);
+  if (!(await waitGone(mainPid, 5000))) {
+    log('main still alive; retrying');
+    terminate(mainPid, log);
+    if (!(await waitGone(mainPid, 3000))) {
+      log('main did not exit; aborting');
+      process.exit(1);
+    }
+  }
+  if (!(await waitGone(hostPid, HOST_EXIT_TIMEOUT_MS))) {
+    log('host did not exit in time; terminating it');
+    terminate(hostPid, log);
+    await waitGone(hostPid, 3000);
+  }
+
+  if (mode === 'shutdown') {
+    log('shutdown complete; not relaunching');
+    process.exit(0);
+  }
+
+  await sleep(RELAUNCH_DELAY_MS);
+
+  const env = { ...process.env };
+  // These keep a new process in Node mode; the relaunched app must not inherit them.
+  delete env.ELECTRON_RUN_AS_NODE;
+  delete env.ELECTRON_NO_ATTACH_CONSOLE;
+  delete env.ELECTRON_ENABLE_LOGGING;
+  delete env.DSH_DESKTOP_NODE_EXECUTABLE;
+  delete env.DSH_POWERUP_RESTART_LOG;
+
+  const child = spawn(exe, parseArgs(argsRaw), {
+    cwd: typeof appDir === 'string' && appDir.length > 0 ? appDir : undefined,
+    env,
+    detached: true,
+    windowsHide: false,
+    stdio: 'ignore',
+  });
+  child.on('error', (error) => {
+    log(`spawn failed: ${String(error && error.message ? error.message : error)}`);
+    process.exit(1);
+  });
+  child.unref();
+  log(`launched pid=${String(child.pid)}`);
+
+  // Give spawn a moment to report a pid or an error, then exit.
+  await sleep(400);
+  process.exit(0);
+}
+
+main().catch((error) => {
+  try {
+    console.error(error);
+  } catch {
+    /* ignore */
+  }
+  process.exit(1);
+});

package/lib/restart.js

@@ -0,0 +1,136 @@
+/**
+ * dsh-powerup — restart the whole DSH desktop app.
+ *
+ * The Host half runs inside the `dsh-desktop-host` child process, whose parent
+ * is the Electron main process. The desktop shell exposes shutdown and update
+ * controls over IPC but no "restart application" request, so this module
+ * starts a detached helper (`restart-helper.cjs`), lets the HTTP response
+ * settle, then ends the Electron main process. The helper waits for this Host
+ * to exit and relaunches the same executable.
+ *
+ * Only the Electron desktop build supports this. A plain `dsh web` process
+ * reports the reason instead, and the UI hides the action.
+ *
+ * The mechanism is adapted from dsh-pocket's restart module (same profile,
+ * verified on this machine).
+ *
+ * @module dsh-powerup/restart
+ */
+
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+/** Helper shipped beside this module. */
+const HELPER_PATH = fileURLToPath(new URL('./restart-helper.cjs', import.meta.url));
+
+/** Let the UI paint its "restarting" state and the HTTP response settle. */
+const ACTION_DELAY_MS = 1500;
+
+/** One helper per process, even if the button is clicked twice. */
+let scheduled = false;
+
+/**
+ * The DSH home directory, matching the launcher's `DSH_HOME` handling.
+ * @returns {string}
+ */
+function dshHome() {
+  const configured = process.env.DSH_HOME;
+  if (typeof configured === 'string' && configured.trim().length > 0) return configured.trim();
+  return join(homedir(), '.dsh');
+}
+
+/**
+ * Whether this runtime can restart the whole application.
+ * @returns {{ supported: boolean, reason?: string }}
+ */
+export function describeRestart() {
+  if (process.versions.electron === undefined) {
+    return {
+      supported: false,
+      reason: 'DSH is running as a command-line web process (dsh web); restart it from the terminal.',
+    };
+  }
+  if (typeof process.execPath !== 'string' || process.execPath.length === 0 || !existsSync(process.execPath)) {
+    return { supported: false, reason: 'The DSH executable could not be located.' };
+  }
+  const mainPid = process.ppid;
+  if (!Number.isInteger(mainPid) || mainPid <= 1) {
+    return { supported: false, reason: 'The DSH main process could not be located.' };
+  }
+  return { supported: true };
+}
+
+/**
+ * Schedule a full application restart. The caller must finish its HTTP
+ * response; the helper waits {@link ACTION_DELAY_MS} before acting.
+ *
+ * @returns {{ supported: true, action: 'restart', pid: number | undefined, pending: boolean }}
+ * @throws {Error} with `code = 'restart-unsupported'` outside the desktop app.
+ */
+export function requestRestart() {
+  const capability = describeRestart();
+  if (!capability.supported) {
+    const error = new Error(capability.reason ?? 'This runtime cannot restart DSH.');
+    error.code = 'restart-unsupported';
+    throw error;
+  }
+  if (scheduled) return { supported: true, action: 'restart', pid: undefined, pending: true };
+  scheduled = true;
+
+  const executable = process.execPath;
+  const logPath = join(dshHome(), 'powerup', 'restart.log');
+  try {
+    mkdirSync(dirname(logPath), { recursive: true });
+  } catch {
+    /* The log directory is optional; the helper tolerates a missing path. */
+  }
+
+  let child;
+  try {
+    child = spawn(process.execPath, [
+      HELPER_PATH,
+      executable,
+      String(process.ppid),
+      String(process.pid),
+      dirname(executable),
+      '[]',
+      'restart',
+      String(ACTION_DELAY_MS),
+    ], {
+      cwd: dirname(executable),
+      detached: true,
+      windowsHide: true,
+      stdio: 'ignore',
+      env: {
+        ...process.env,
+        ELECTRON_RUN_AS_NODE: '1',
+        DSH_POWERUP_RESTART_LOG: logPath,
+      },
+    });
+  } catch (error) {
+    scheduled = false;
+    throw error;
+  }
+  if (child.pid === undefined) {
+    scheduled = false;
+    const error = new Error('The restart helper could not be started.');
+    error.code = 'restart-helper-failed';
+    throw error;
+  }
+  child.unref();
+  child.on('error', () => {
+    scheduled = false;
+  });
+  return { supported: true, action: 'restart', pid: child.pid, pending: false };
+}
+
+/**
+ * Reset the one-shot latch; exported for tests only.
+ * @internal
+ */
+export function __resetScheduled() {
+  scheduled = false;
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Power-Up",
+    "description": "Adds a right-click action menu to the Trajectory ledger: copy a record, copy a Markdown quote, quote it into the composer, open the record inspector, fork the session at that record, export the trajectory snapshot, and copy the session ID. The Plugins page gains an update control on every third-party installed plugin: choose a version from the registry, uninstall the old copy, reinstall through the Add plugin path, then enable and optionally restart DSH."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Power-Up",
+    "description": "在轨迹页面为记录增加右键操作菜单：复制内容、复制 Markdown 引用、引用到输入框、查看记录详情、从该记录 Fork 会话、导出轨迹快照、复制会话 ID。插件页为每个第三方已安装插件增加更新按钮：从安装源选择版本，先卸载旧版再按「添加插件」流程安装，完成后可立即启用并选择是否重启 DSH。"
+  }
+}

package/package.json

@@ -1,6 +1,72 @@
 {
   "name": "@restregular/dsh-powerup",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.1",
+  "description": "Power-Up — small, opt-in upgrades for DeepSeek Harness. Adds a right-click action menu to the Trajectory ledger and an update control for third-party plugins installed from the Plugins page, with version lookup, uninstall-and-reinstall through the Add plugin path, and an optional DSH restart. · 为 DeepSeek Harness 提供小型增强：在轨迹页面右键记录即可复制、引用、查看详情或从该记录 Fork；并在插件页为第三方已安装插件提供带版本查询的更新按钮，沿用「添加插件」的安装流程，并可重启 DSH 使更改生效。",
+  "icon": "./icon.svg",
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "cordis.patch.yml",
+    "lib/restart.js",
+    "lib/restart-helper.cjs",
+    "locale/*.json",
+    "icon.svg",
+    "README.md",
+    "LICENSE"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-layout",
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-session",
+        "@deepseek-ai/dsh-api-session-controller",
+        "@deepseek-ai/dsh-client-ui-workspace"
+      ]
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RestRegular/dsh-powerup.git"
+  },
+  "homepage": "https://github.com/RestRegular/dsh-powerup#readme",
+  "bugs": {
+    "url": "https://github.com/RestRegular/dsh-powerup/issues"
+  },
+  "keywords": [
+    "dsh-plugin",
+    "deepseek-harness",
+    "deepseek",
+    "trajectory",
+    "context-menu",
+    "power-up"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "scripts": {
+    "test": "node test/smoke.mjs"
+  },
+  "license": "MIT",
+  "author": "RestRegular"
+}