@twinsearth/w2m-dsh-plugin 1.9.12 → 1.9.15

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "twinsearth-w2m-dsh",
-  "version": "1.9.12",
+  "version": "1.9.15",
   "description": "Run one project across your own Windows and macOS machines from a single DeepSeek account, through 12 w2m_* tools. Four coordination modes (replicate, split, broadcast, pipeline) and six aggregate verdicts (consistent, divergent, divergent-platform, failed, partial, unverifiable). P2P hole punching by default, with a bundled relay, STUN responder and ledger fallback, so the fleet needs no third-party service. Joining needs a pairing code plus autoStartAgent: true; installing alone does not join.",
   "license": "MIT",
   "keywords": [

package/src/plugin/npm-update.mjs

@@ -8,6 +8,10 @@
  * package in the profile, and takes a backup. Keeping the check pure is what makes "NPM 对比" testable
  * without a network or a profile.
  */
+import { createHash } from 'node:crypto';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
 import { compareVersions } from './update-source.mjs';
 
 /** The package this plugin is. */
@@ -83,3 +87,61 @@ export async function checkNpmUpdate(input) {
   return decideNpmUpdate({ latest: last, currentVersion: input?.currentVersion ?? null });
 }
 
+
+
+/** Registry package documents to try, in order (mirror first, then npmjs). */
+export const NPM_PACKAGE_DOC_URLS = [
+  `https://registry.npmmirror.com/${encodeURIComponent(PLUGIN_PACKAGE_NAME)}`,
+  `https://registry.npmjs.org/${encodeURIComponent(PLUGIN_PACKAGE_NAME)}`,
+];
+
+/**
+ * Download an exact npm version and verify it against the registry's own integrity field before it
+ * can be installed. This is the fallback for "immediately update failed: fetch failed": GitHub
+ * release downloads are blocked on some networks while the npm registry is reachable.
+ */
+export async function fetchNpmTarball(input) {
+  const fetchImpl = input?.fetchImpl ?? globalThis.fetch;
+  const version = typeof input?.version === 'string' ? input.version.trim() : '';
+  if (version === '') return { ok: false, error: 'version is required' };
+  const destDir = input?.destDir;
+  if (typeof destDir !== 'string' || destDir === '') return { ok: false, error: 'destDir is required' };
+  const timeoutMs = Number.isInteger(input?.timeoutMs) ? input.timeoutMs : NPM_CHECK_TIMEOUT_MS;
+  const urls = Array.isArray(input?.urls) ? input.urls : NPM_PACKAGE_DOC_URLS;
+  const signalOf = () => (typeof AbortSignal !== 'undefined' && typeof AbortSignal.timeout === 'function' ? AbortSignal.timeout(timeoutMs) : undefined);
+  let meta = null;
+  let lastError = 'npm package document could not be read';
+  for (const url of urls) {
+    try {
+      const response = await fetchImpl(url, { headers: { accept: 'application/json' }, signal: signalOf() });
+      if (response?.ok !== true) { lastError = `npm registry answered HTTP ${response?.status ?? '?'}`; continue; }
+      const doc = await response.json();
+      const candidate = doc?.versions?.[version];
+      if (candidate?.dist?.tarball === undefined) { lastError = `npm has no version ${version} with a tarball`; continue; }
+      meta = candidate;
+      break;
+    } catch (error) { lastError = error instanceof Error ? error.message : String(error); }
+  }
+  if (meta === null) return { ok: false, error: lastError };
+  try {
+    const response = await fetchImpl(meta.dist.tarball, { signal: signalOf() });
+    if (response?.ok !== true) return { ok: false, error: `npm tarball answered HTTP ${response?.status ?? '?'}` };
+    const bytes = Buffer.from(await response.arrayBuffer());
+    const integrity = typeof meta.dist.integrity === 'string' ? meta.dist.integrity : null;
+    if (integrity !== null && /^sha512-/.test(integrity)) {
+      const actual = createHash('sha512').update(bytes).digest('base64');
+      if (actual !== integrity.slice('sha512-'.length)) return { ok: false, error: 'NPM_INTEGRITY_MISMATCH' };
+    } else if (typeof meta.dist.shasum === 'string') {
+      const actual = createHash('sha1').update(bytes).digest('hex');
+      if (actual !== meta.dist.shasum) return { ok: false, error: 'NPM_SHASUM_MISMATCH' };
+    } else {
+      return { ok: false, error: 'NPM_NO_INTEGRITY' };
+    }
+    mkdirSync(destDir, { recursive: true });
+    const path = join(destDir, `w2m-dsh-plugin-${version}.tgz`);
+    writeFileSync(path, bytes);
+    return { ok: true, path, bytes: bytes.length, sha256: createHash('sha256').update(bytes).digest('hex'), version, tarball: meta.dist.tarball, integrityVerified: true };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}

package/src/plugin/operator-token.mjs

@@ -0,0 +1,83 @@
+/**
+ * Secure storage for the relay operator token (v2 G0-1).
+ *
+ * The token must not travel through chat, argv, logs or environment dumps. This module stores it in
+ * a single 0600 file under the per-user W2M directory (or W2M_OPERATOR_TOKEN_FILE), and every read
+ * returns metadata plus at most a short fingerprint — never the value in logs.
+ *
+ * Resolution order used by the plugin: profile config (legacy) → this file → W2M_OPERATOR_TOKEN
+ * (legacy compatibility; discouraged). The file is the recommended source: it is not visible in the
+ * process environment and not echoed by any status output.
+ */
+import { createHash } from 'node:crypto';
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+const MIN_LENGTH = 16;
+const MAX_LENGTH = 4096;
+
+/** Where the token file lives. */
+export function operatorTokenPath(env = process.env) {
+  const explicit = typeof env.W2M_OPERATOR_TOKEN_FILE === 'string' ? env.W2M_OPERATOR_TOKEN_FILE.trim() : '';
+  if (explicit !== '') return explicit;
+  return join(homedir(), '.w2m', 'operator-token');
+}
+
+/** A stable, non-reversible fingerprint for display ("configured, id 3f2a1c..."). */
+export function fingerprintOf(token) {
+  if (typeof token !== 'string' || token === '') return null;
+  return createHash('sha256').update(token, 'utf8').digest('hex').slice(0, 12);
+}
+
+export function validateOperatorToken(token) {
+  if (typeof token !== 'string') return { ok: false, code: 'OPERATOR_TOKEN_INVALID' };
+  const value = token.trim();
+  if (value.length < MIN_LENGTH) return { ok: false, code: 'OPERATOR_TOKEN_TOO_SHORT', detail: { min: MIN_LENGTH } };
+  if (value.length > MAX_LENGTH) return { ok: false, code: 'OPERATOR_TOKEN_TOO_LONG', detail: { max: MAX_LENGTH } };
+  if (/[\r\n]/.test(value)) return { ok: false, code: 'OPERATOR_TOKEN_INVALID', detail: 'token must be a single line' };
+  return { ok: true, token: value };
+}
+
+/**
+ * Read the token file.
+ *
+ * @returns {{configured: false, path: string}
+ *   | {configured: true, token: string, path: string, fingerprint: string, mode: number|null}}
+ */
+export function readOperatorToken(options = {}) {
+  const env = options.env ?? process.env;
+  const path = options.path ?? operatorTokenPath(env);
+  if (!existsSync(path)) return { configured: false, path };
+  let raw;
+  try { raw = readFileSync(path, 'utf8'); } catch (error) {
+    return { configured: false, path, error: error instanceof Error ? error.message : String(error) };
+  }
+  const checked = validateOperatorToken(raw);
+  if (checked.ok !== true) return { configured: false, path, error: checked.code };
+  return { configured: true, token: checked.token, path, fingerprint: fingerprintOf(checked.token) };
+}
+
+export function writeOperatorToken(token, options = {}) {
+  const checked = validateOperatorToken(token);
+  if (checked.ok !== true) return checked;
+  const env = options.env ?? process.env;
+  const path = options.path ?? operatorTokenPath(env);
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, checked.token + '\n', { encoding: 'utf8', mode: 0o600 });
+    try { chmodSync(path, 0o600); } catch { /* Windows: the file ACL carries the protection */ }
+  } catch (error) {
+    return { ok: false, code: 'OPERATOR_TOKEN_WRITE_FAILED', detail: error instanceof Error ? error.message : String(error) };
+  }
+  return { ok: true, path, fingerprint: fingerprintOf(checked.token) };
+}
+
+export function clearOperatorToken(options = {}) {
+  const env = options.env ?? process.env;
+  const path = options.path ?? operatorTokenPath(env);
+  try { rmSync(path, { force: true }); } catch (error) {
+    return { ok: false, code: 'OPERATOR_TOKEN_CLEAR_FAILED', detail: error instanceof Error ? error.message : String(error) };
+  }
+  return { ok: true, path };
+}

package/src/plugin/tools.mjs

@@ -191,6 +191,7 @@ import {
 import { registerChatRoutes } from './fleet-chat-route.mjs';
 import { registerExecCapabilityRoutes } from './exec-capability-route.mjs';
 import { registerPluginUpdateRoutes } from './update-route.mjs';
+import { fingerprintOf, readOperatorToken } from './operator-token.mjs';
 import { registerCaptureRoutes } from './capture-route.mjs';
 import { defaultExecCapabilityFile } from '../util/exec-capability.mjs';
 import { createFleetCouncil, fleetCouncilThread } from './council-fleet.mjs';
@@ -283,7 +284,7 @@ const MAX_STAGES = 16;
  * `package.json` during `scripts/pack.mjs` rather than hand-maintained, and `W2M_PLUGIN_VERSION`
  * overrides it at runtime for tests and packagers.
  */
-const PLUGIN_VERSION = '1.9.12';
+const PLUGIN_VERSION = '1.9.15';
 
 /** How long any single HTTP call may take before it is aborted, in milliseconds. */
 const DEFAULT_REQUEST_TIMEOUT_MS = 15_000;
@@ -687,6 +688,7 @@ async function loadDefineTool() {
  *            p2pMode: string, stunServers: string[]}}
  */
 function readConfig(config = {}) {
+  let operatorTokenSource = null;
   const cwd = process.cwd();
 
   /**
@@ -872,11 +874,23 @@ function readConfig(config = {}) {
         ? process.env.W2M_PAIRING_CODE.trim()
         : null),
     // §5: the operator credential. Only `w2m_run` uses it.
-    operatorToken: typeof config.operatorToken === 'string' && config.operatorToken.trim() !== ''
-      ? config.operatorToken.trim()
-      : (typeof process.env.W2M_OPERATOR_TOKEN === 'string' && process.env.W2M_OPERATOR_TOKEN.trim() !== ''
+    // v2 G0-1: the token file (0600) is the recommended source; profile config stays for legacy,
+    // env last. The value never reaches a status output - only the source and a fingerprint do.
+    operatorToken: (() => {
+      const fromConfig = typeof config.operatorToken === 'string' && config.operatorToken.trim() !== ''
+        ? config.operatorToken.trim()
+        : null;
+      if (fromConfig !== null) { operatorTokenSource = 'config'; return fromConfig; }
+      const secure = readOperatorToken();
+      if (secure.configured === true) { operatorTokenSource = 'file'; return secure.token; }
+      const fromEnv = typeof process.env.W2M_OPERATOR_TOKEN === 'string' && process.env.W2M_OPERATOR_TOKEN.trim() !== ''
         ? process.env.W2M_OPERATOR_TOKEN.trim()
-        : null),
+        : null;
+      if (fromEnv !== null) { operatorTokenSource = 'env'; return fromEnv; }
+      operatorTokenSource = null;
+      return null;
+    })(),
+    operatorTokenSource,
     // ---------------------------------------------------------------------------------------------
     // v0.2.3: daily self-update
     // ---------------------------------------------------------------------------------------------
@@ -4996,6 +5010,7 @@ const result = await request({
             // wrong one without spending a dispatch, and `required_by_relay` is what makes the two
             // halves of the mismatch (client has none / relay demands one) visible side by side.
             operatorToken_configured: cfg.operatorToken !== null,
+    operatorToken_fingerprint: cfg.operatorToken === null ? null : fingerprintOf(cfg.operatorToken),
             operatorToken_source: cfg.operatorToken !== null
               ? (typeof config?.operatorToken === 'string' && config.operatorToken.trim() !== ''
                 ? 'config'

package/src/plugin/update-route.mjs

@@ -86,6 +86,13 @@ export function registerPluginUpdateRoutes(ctx, deps) {
         const result = await updater.check('manual');
         const installedTo = typeof result?.to === 'string' && result.to !== '' ? result.to : null;
         const installed = result?.outcome === 'installed' || installedTo !== null && installedTo !== current;
+        // The GitHub release download is blocked on some networks ("fetch failed"), while the npm
+        // registry is reachable. Before reporting a failure, install the same version from the
+        // registry tarball, whose integrity field is verified before pnpm sees it.
+        if (installed !== true) {
+          const fallback = await installFromNpmFallback({ profileDir, current, version: checked.latest ?? current });
+          if (fallback !== null) return Response.json(fallback.body, { headers: NO_STORE });
+        }
         return Response.json({
           ok: result?.ok === true && installed === true,
           outcome: result?.outcome ?? 'unknown',
@@ -116,3 +123,27 @@ async function defaultUpdater({ profileDir, currentVersion }) {
     log: () => {},
   });
 }
+
+/** Install the same version from the npm registry when the GitHub release download fails. */
+async function installFromNpmFallback({ profileDir, current, version }) {
+  try {
+    const { fetchNpmTarball } = await import('./npm-update.mjs');
+    const { installUpdate } = await import('./update-install.mjs');
+    const { tmpdir } = await import('node:os');
+    const fetched = await fetchNpmTarball({ version, destDir: join(tmpdir(), 'w2m-npm-update-' + Date.now()) });
+    if (fetched.ok !== true) return null;
+    const result = await installUpdate({ profileDir, tarballPath: fetched.path, expectedSha256: fetched.sha256 });
+    if (result?.ok !== true) return null;
+    return {
+      body: {
+        ok: true,
+        outcome: 'installed',
+        installedVia: 'npm-tarball',
+        from: result.from ?? current,
+        to: result.to ?? version,
+        installed: true,
+        restart_required: true,
+      },
+    };
+  } catch { return null; }
+}

package/src/relay/repair-ledger.mjs

@@ -16,6 +16,7 @@
  */
 import {
   chmodSync,
+  chownSync,
   closeSync,
   copyFileSync,
   existsSync,
@@ -63,6 +64,7 @@ export function repairLedger(file, options = {}) {
   const before = statSync(file);
   if (!before.isFile()) return { ok: false, code: LEDGER_REPAIR_CODES.NOT_A_FILE, path: file };
 
+  const mode = before.mode & 0o777;
   const raw = readFileSync(file);
   const afterRead = statSync(file);
   if (afterRead.mtimeMs !== before.mtimeMs || afterRead.size !== before.size) {
@@ -116,7 +118,8 @@ export function repairLedger(file, options = {}) {
   const backup = `${file}.bak-${now}`;
   try {
     copyFileSync(file, backup);
-    chmodSync(backup, 0o600);
+    chmodSync(backup, mode);
+    try { chownSync(backup, before.uid, before.gid); } catch { /* unprivileged run keeps the caller's owner */ }
   } catch (error) {
     return { ...base, dry_run: false, written: false, ok: false, code: LEDGER_REPAIR_CODES.WRITE_FAILED, error: String(error) };
   }
@@ -132,7 +135,10 @@ export function repairLedger(file, options = {}) {
   const next = valid.length === 0 ? '' : valid.join('\n') + (hasFinalNewline ? '\n' : '');
   const tmp = `${file}.repair-${now}.tmp`;
   try {
-    writeDurable(tmp, Buffer.from(next, 'utf8'), 0o600);
+    writeDurable(tmp, Buffer.from(next, 'utf8'), mode);
+    // Keep the service account as the owner: a relay that runs as `w2m` must still be able to
+    // read the file after root repaired it (this exact break happened on Vultr).
+    try { chownSync(tmp, before.uid, before.gid); } catch { /* unprivileged */ }
     renameSync(tmp, file);
   } catch (error) {
     try { if (existsSync(tmp)) unlinkSync(tmp); } catch { /* best effort */ }