@hellolynk-ai/trae-work-mcp 0.0.0-stage → 0.4.94

package/integrations/trae-work/server/trae-neutral-production.mjs

@@ -0,0 +1,97 @@
+import path from "node:path";
+import { resolveClientAccountRoot } from "../../../runtime/core/hellolynk-client-account.mjs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+import { createHostProtectedStore } from "../../../runtime/core/hellolynk-host-protected-store.mjs";
+import { createNeutralHostInstallationStore, defaultNeutralHostStoreRoot } from "../../../runtime/core/hellolynk-neutral-host-installation-store.mjs";
+import { launchTraeWorkNeutralHost, verifyPinnedBootstrap } from "./host-lifecycle.mjs";
+
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+const RELEASE_ROOT = path.resolve(MODULE_DIR, "..", "..", "..");
+
+// This is intentionally TRAE-owned: it obtains the protected binding locally,
+// checks that it points at this fixed release, and starts no other client host.
+export async function createTraeWorkNeutralProduction(options = {}) {
+  const releaseRoot = path.resolve(options.releaseRoot || RELEASE_ROOT);
+  const { storeRoot, protectedStore } = traeStores(options);
+  const resolved = options.resolvedBinding || await protectedStore.resolveTraeWorkNeutralBinding();
+  assertReleaseBinding(resolved, releaseRoot);
+  const preverified = String(options.verifiedReleaseManifestSha256 || "");
+  if (preverified && preverified !== resolved.releaseManifestSha256) {
+    throw codeError("neutral_trae_work_runner_integrity_invalid");
+  }
+  const inspection = preverified
+    ? Object.freeze({ ok: true, preverified: true })
+    : await verifyPinnedBootstrap(resolved, { storeRoot });
+  let initialBinding = resolved;
+  let launchCandidate = null;
+  return Object.freeze({
+    inspection, releaseRoot, storeRoot, protectedStore,
+    capabilityProvider: async () => {
+      const binding = initialBinding || await protectedStore.resolveTraeWorkNeutralBinding();
+      initialBinding = null;
+      assertReleaseBinding(binding, releaseRoot);
+      launchCandidate = binding;
+      return binding;
+    },
+    hostLauncher: async (binding) => {
+      if (!launchCandidate) throw codeError("neutral_trae_work_capability_binding_mismatch");
+      assertSamePublicBinding(binding, launchCandidate);
+      launchCandidate = null;
+      return launchTraeWorkNeutralHost(binding, {
+        storeRoot,
+        ...(options.spawnRunner ? { spawnRunner: options.spawnRunner } : {}),
+        ...(options.wait ? { wait: options.wait } : {}),
+      });
+    },
+  });
+}
+
+// A background update can move the binding to a newer release while this MCP stays open.
+// Each connection uses the production of the release the binding names now; that module
+// checks the binding against its own location again.
+export async function createCurrentTraeWorkNeutralProduction(options = {}) {
+  const { protectedStore } = traeStores(options);
+  const resolved = await protectedStore.resolveTraeWorkNeutralBinding();
+  const ownRoot = path.resolve(options.releaseRoot || RELEASE_ROOT);
+  const boundRoot = path.resolve(String(resolved?.releaseRoot || ownRoot));
+  if (boundRoot === ownRoot) return createTraeWorkNeutralProduction({ ...options, protectedStore, resolvedBinding: resolved });
+  // Installed releases sit side by side; a binding that names any other place is not loaded.
+  if (path.dirname(boundRoot) !== path.dirname(ownRoot)) {
+    resolved?.capability?.secretBuffer?.fill(0);
+    throw codeError("neutral_trae_work_runner_integrity_invalid");
+  }
+  const { releaseRoot: _ownRoot, ...forwarded } = options;
+  const bound = await import(pathToFileURL(path.join(boundRoot, "integrations", "trae-work", "server", "trae-neutral-production.mjs")).href);
+  return bound.createTraeWorkNeutralProduction({ ...forwarded, resolvedBinding: resolved });
+}
+
+function traeStores(options) {
+  const env = options.env || process.env;
+  const storeRoot = resolveClientAccountRoot("trae-work", absolutePath(
+    options.storeRoot || env.HELLOLYNK_NEUTRAL_STORE_ROOT || defaultNeutralHostStoreRoot("win32", env),
+    "neutral_trae_work_binding_configuration_required",
+  ));
+  const installationStore = options.installationStore || createNeutralHostInstallationStore({ root: storeRoot });
+  return { storeRoot, protectedStore: options.protectedStore || createHostProtectedStore({ root: storeRoot, installationStore }) };
+}
+
+function assertReleaseBinding(binding, releaseRoot) {
+  if (!binding?.releaseRoot || path.resolve(binding.releaseRoot) !== releaseRoot
+    || !/^[a-f0-9]{64}$/.test(String(binding.releaseManifestSha256 || ""))
+    || binding.runnerRelativePath !== "runtime/neutral-host-bootstrap.mjs"
+    || !path.isAbsolute(String(binding.profileManifestPath || ""))) {
+    throw codeError("neutral_trae_work_runner_integrity_invalid");
+  }
+}
+function assertSamePublicBinding(expected, actual) {
+  for (const key of [
+    "region", "principalId", "delegateId", "hostInstallationId", "profileId", "adapterId", "version",
+    "runtimeRoot", "releaseRoot", "releaseManifestSha256", "runnerRelativePath", "profileManifestPath",
+  ]) {
+    if (expected?.[key] !== actual?.[key]) throw codeError("neutral_trae_work_capability_binding_mismatch");
+  }
+  if (JSON.stringify(expected.scopes) !== JSON.stringify(actual.scopes)) throw codeError("neutral_trae_work_capability_binding_mismatch");
+}
+function absolutePath(value, code) { const text = String(value || ""); if (!path.isAbsolute(text)) throw codeError(code); return path.resolve(text); }
+function codeError(code) { const error = new Error(code); error.code = code; return error; }

package/integrations/trae-work/server/trae-ui-launch.mjs

@@ -0,0 +1,182 @@
+import { createWorkbenchAccountOpener, createWorkbenchConnection, workbenchConnectionError, isWorkbenchConnectionRequired } from "../../../runtime/core/hellolynk-workbench-connection.mjs";
+import path from "node:path";
+import { lstat } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+
+let active = null;
+const PACKAGED_WORKBENCH = new URL("../../../runtime/workbench/candidate-bootstrap.mjs", import.meta.url);
+const SOURCE_WORKBENCH = new URL("../../../runtime/workbench/candidate-bootstrap.mjs", import.meta.url);
+const ACTION_GRANT = /^[A-Za-z0-9._~-]{32,512}$/;
+
+// TRAE SOLO CN rejects user VSIX extensions in its current Solo-Lite runtime,
+// but its official Browser plugin can open loopback pages inside the client.
+// This launcher returns only a clean 127.0.0.1 URL. Each explicit open request
+// arms one top-level browser navigation, which becomes a short HttpOnly local
+// session without putting a reusable secret in MCP, the URL, or the clipboard.
+export async function openTraeWorkInbox(options = {}) {
+  const adapter = options.adapter;
+  requireReadAdapter(adapter);
+  if (typeof adapter.start === "function") await adapter.start().catch((error) => { if (!isWorkbenchConnectionRequired(error)) throw error; });
+  if (active && active.adapter === adapter) {
+    active.candidate.surface.armNavigation();
+    return active.result;
+  }
+  if (active) await closeTraeWorkInbox();
+  const sharedWorkbench = options.bootstrapWorkbenchCandidate
+    ? injectedSharedWorkbench(options)
+    : await loadSharedWorkbench();
+  const workbenchAdapter = createTraeWorkbenchAdapterFacade(adapter, sharedWorkbench.contract);
+  const bootstrapWorkbenchCandidate = sharedWorkbench.bootstrapWorkbenchCandidate;
+  const candidate = await bootstrapWorkbenchCandidate("trae-work", {
+    openAccount: options.openAccount || createWorkbenchAccountOpener(),
+    connectAccount: options.connectAccount || createWorkbenchConnection({ client: "trae-work", releaseRoot: path.resolve(fileURLToPath(new URL("../../../", import.meta.url))) }),
+    adapter: workbenchAdapter,
+    ...(options.port == null ? {} : { port: options.port }),
+    pagePath: "/inbox",
+  });
+  const result = Object.freeze({
+    launched: true,
+    cleanUrl: candidate.cleanUrl,
+    status: "ready_for_browser_navigation",
+  });
+  active = { adapter, candidate, result };
+  return result;
+}
+
+export async function closeTraeWorkInbox() {
+  if (!active) return;
+  const current = active; active = null;
+  await current.candidate.close();
+}
+
+export function createTraeWorkbenchAdapterFacade(adapter, contract) {
+  requireReadAdapter(adapter);
+  const facade = {
+    readSnapshot: (input) => Promise.resolve().then(() => adapter.readWorkbenchSnapshot(input)).catch((error) => { throw workbenchConnectionError(error); }),
+  };
+  if (typeof adapter.readWorkbenchChanges === "function") {
+    facade.readChanges = (input) => adapter.readWorkbenchChanges(input);
+  }
+  if (supportsF3Contract(contract) && hasHostActionGrantPair(adapter)) {
+    const issueWorkbenchActionGrant = adapter.issueWorkbenchActionGrant.bind(adapter);
+    const executeWorkbenchCommand = adapter.executeWorkbenchCommand.bind(adapter);
+    facade.issueActionGrant = async (command) => requireIssuedActionGrant(
+      await issueWorkbenchActionGrant(contract.validateWorkbenchCommand(command)),
+      "trae_workbench_action_grant_invalid",
+    );
+    facade.executeCommand = async (command, context) => {
+      const validated = contract.validateWorkbenchCommand(command);
+      const normalizedContext = validated.command === "message.send-status"
+        ? requireEmptyContext(context, "trae_workbench_action_grant_invalid")
+        : requireActionGrantContext(context, "trae_workbench_action_grant_required");
+      return contract.validateWorkbenchCommandResult(
+        await executeWorkbenchCommand(validated, normalizedContext),
+        validated.command,
+      );
+    };
+  }
+  return Object.freeze(facade);
+}
+
+async function loadSharedWorkbench() {
+  const moduleUrl = await selectWorkbenchModule();
+  let loaded;
+  let contract;
+  try {
+    [loaded, contract] = await Promise.all([
+      import(moduleUrl.href),
+      import(new URL("./contract.mjs", moduleUrl).href),
+    ]);
+  } catch {
+    throw codeError("trae_shared_workbench_unavailable");
+  }
+  if (typeof loaded.bootstrapWorkbenchCandidate !== "function") {
+    throw codeError("trae_shared_workbench_unavailable");
+  }
+  return Object.freeze({ bootstrapWorkbenchCandidate: loaded.bootstrapWorkbenchCandidate, contract });
+}
+
+function injectedSharedWorkbench(options) {
+  if (typeof options.bootstrapWorkbenchCandidate !== "function") {
+    throw codeError("trae_shared_workbench_unavailable");
+  }
+  return Object.freeze({
+    bootstrapWorkbenchCandidate: options.bootstrapWorkbenchCandidate,
+    contract: options.workbenchContract || null,
+  });
+}
+
+async function selectWorkbenchModule() {
+  const packaged = await regularFile(PACKAGED_WORKBENCH);
+  if (packaged) return PACKAGED_WORKBENCH;
+  if (await regularFile(SOURCE_WORKBENCH)) return SOURCE_WORKBENCH;
+  throw codeError("trae_shared_workbench_unavailable");
+}
+
+async function regularFile(url) {
+  try {
+    const metadata = await lstat(fileURLToPath(url));
+    if (metadata.isSymbolicLink() || !metadata.isFile()) {
+      throw codeError("trae_shared_workbench_unavailable");
+    }
+    return true;
+  } catch (error) {
+    if (error?.code === "ENOENT") return false;
+    throw error;
+  }
+}
+
+function requireReadAdapter(adapter) {
+  if (!adapter || typeof adapter.readWorkbenchSnapshot !== "function") {
+    throw codeError("trae_shared_workbench_adapter_required");
+  }
+}
+
+function supportsF3Contract(value) {
+  return Boolean(value)
+    && value.HELLOLYNK_WORKBENCH_SNAPSHOT_CONTRACT === "hellolynk-workbench-snapshot-v12"
+    && value.HELLOLYNK_WORKBENCH_SNAPSHOT_SCHEMA_VERSION === 12
+    && value.HELLOLYNK_WORKBENCH_COMMAND_CONTRACT === "hellolynk-workbench-command-v6"
+    && value.HELLOLYNK_WORKBENCH_RESULT_CONTRACT === "hellolynk-workbench-command-result-v6"
+    && value.HELLOLYNK_WORKBENCH_SCHEMA_VERSION === 6
+    && typeof value.validateWorkbenchCommand === "function"
+    && typeof value.validateWorkbenchCommandResult === "function";
+}
+
+function hasHostActionGrantPair(adapter) {
+  return typeof adapter.issueWorkbenchActionGrant === "function"
+    && adapter.issueWorkbenchActionGrant.length >= 1
+    && typeof adapter.executeWorkbenchCommand === "function"
+    && adapter.executeWorkbenchCommand.length >= 2;
+}
+
+function requireActionGrantContext(value, errorCode) {
+  if (!value || typeof value !== "object" || Array.isArray(value)
+    || ![Object.prototype, null].includes(Object.getPrototypeOf(value))
+    || Object.keys(value).length !== 1 || !Object.hasOwn(value, "actionGrant")
+    || typeof value.actionGrant !== "string" || !ACTION_GRANT.test(value.actionGrant)) {
+    throw codeError(errorCode);
+  }
+  return value;
+}
+
+function requireEmptyContext(value, errorCode) {
+  if (!value || typeof value !== "object" || Array.isArray(value)
+    || ![Object.prototype, null].includes(Object.getPrototypeOf(value))
+    || Object.keys(value).length !== 0) {
+    throw codeError(errorCode);
+  }
+  return value;
+}
+
+function requireIssuedActionGrant(value, errorCode) {
+  if (!value || typeof value !== "object" || Array.isArray(value)
+    || ![Object.prototype, null].includes(Object.getPrototypeOf(value))
+    || Object.keys(value).length !== 1 || !Object.hasOwn(value, "actionGrant")
+    || typeof value.actionGrant !== "string" || !ACTION_GRANT.test(value.actionGrant)) {
+    throw codeError(errorCode);
+  }
+  return value;
+}
+
+function codeError(code) { const error = new Error(code); error.code = code; return error; }

package/integrations/trae-work/server/ui-action-gate.mjs

@@ -0,0 +1,122 @@
+import crypto from "node:crypto";
+import { validateDynamicUiEnvelope } from "./dynamic-ui-contract.mjs";
+
+export const TRAE_PRIVATE_UI_CONTRACT = "hellolynk-trae-private-ui-v1";
+export const TRAE_UI_ACTION_GATE_CONTRACT = "hellolynk-trae-ui-action-gate-v1";
+export const TRAE_UI_ACTION_TOKEN_TTL_MS = 5 * 60 * 1000;
+export const TRAE_UI_ACTION_TOKEN_MAX_ENTRIES = 2_048;
+
+const TOKEN = /^hellolynkui_[A-Za-z0-9_-]{43}$/;
+const TOOL = /^hellolynk_[a-z0-9_]{3,100}$/;
+const ID = /^[A-Za-z0-9][A-Za-z0-9_.:-]{2,198}$/;
+const MODES = new Set(["exact", "subset", "new-contact", "send-form", "no-target"]);
+
+export function createTraeUiActionGate(options = {}) {
+  const now = typeof options.now === "function" ? options.now : Date.now;
+  const randomBytes = typeof options.randomBytes === "function" ? options.randomBytes : crypto.randomBytes;
+  const ttlMs = integer(options.ttlMs, TRAE_UI_ACTION_TOKEN_TTL_MS, 1_000, 15 * 60 * 1000);
+  const maxEntries = integer(options.maxEntries, TRAE_UI_ACTION_TOKEN_MAX_ENTRIES, 1, 10_000);
+  const entries = new Map();
+
+  function issue(policy = {}) {
+    cleanup();
+    if (entries.size >= maxEntries) throw codeError("trae_ui_action_gate_full");
+    const toolName = safeTool(policy.toolName);
+    const mode = String(policy.mode || "");
+    if (!MODES.has(mode)) throw codeError("trae_ui_action_policy_invalid");
+    const allowedIds = canonicalIds(policy.allowedIds || []);
+    if ((mode === "exact" && allowedIds.length !== 1)
+      || (mode === "subset" && allowedIds.length < 1)
+      || ((mode === "new-contact" || mode === "send-form" || mode === "no-target") && allowedIds.length > 500)) {
+      throw codeError("trae_ui_action_policy_invalid");
+    }
+    let token;
+    do { token = `hellolynkui_${randomBytes(32).toString("base64url")}`; } while (entries.has(digest(token)));
+    const issuedAtMs = now();
+    const expiresAtMs = issuedAtMs + ttlMs;
+    entries.set(digest(token), Object.freeze({ toolName, mode, allowedIds, issuedAtMs, expiresAtMs }));
+    return Object.freeze({
+      contract: TRAE_UI_ACTION_GATE_CONTRACT,
+      token,
+      toolName,
+      mode,
+      expiresAtMs,
+    });
+  }
+
+  function consume(tokenValue, intent = {}) {
+    cleanup();
+    const token = String(tokenValue || "");
+    if (!TOKEN.test(token)) throw codeError("trae_ui_action_authorization_required");
+    const key = digest(token);
+    const entry = entries.get(key);
+    if (!entry) throw codeError("trae_ui_action_authorization_invalid");
+    entries.delete(key);
+    if (entry.expiresAtMs <= now()) throw codeError("trae_ui_action_authorization_expired");
+    if (entry.toolName !== safeTool(intent.toolName)) throw codeError("trae_ui_action_scope_mismatch");
+    const targetIds = canonicalIds(intent.targetIds || []);
+    const allowed = new Set(entry.allowedIds);
+    if (entry.mode === "exact" && (targetIds.length !== 1 || targetIds[0] !== entry.allowedIds[0])) {
+      throw codeError("trae_ui_action_scope_mismatch");
+    }
+    if (entry.mode === "subset" && (!targetIds.length || targetIds.some((id) => !allowed.has(id)))) {
+      throw codeError("trae_ui_action_scope_mismatch");
+    }
+    if (entry.mode === "new-contact" && targetIds.length !== 0) throw codeError("trae_ui_action_scope_mismatch");
+    if (entry.mode === "no-target" && targetIds.length !== 0) throw codeError("trae_ui_action_scope_mismatch");
+    if (entry.mode === "send-form") {
+      const recipientKind = String(intent.recipientKind || "");
+      if (recipientKind === "contact") {
+        if (targetIds.length !== 1 || !allowed.has(targetIds[0])) throw codeError("trae_ui_action_scope_mismatch");
+      } else if (recipientKind === "typed") {
+        if (targetIds.length !== 0) throw codeError("trae_ui_action_scope_mismatch");
+      } else throw codeError("trae_ui_action_scope_mismatch");
+    }
+    return Object.freeze({ ok: true, consumed: true, toolName: entry.toolName, mode: entry.mode });
+  }
+
+  function cleanup() {
+    const current = now();
+    for (const [key, entry] of entries) if (entry.expiresAtMs <= current) entries.delete(key);
+  }
+
+  return Object.freeze({ issue, consume, get size() { cleanup(); return entries.size; } });
+}
+
+export function createPrivateUiMeta(widgetEnvelope, actionGrants = []) {
+  try { validateDynamicUiEnvelope(widgetEnvelope); }
+  catch { throw codeError("trae_private_ui_envelope_invalid"); }
+  if (!Array.isArray(actionGrants) || actionGrants.length > 16) throw codeError("trae_private_ui_grants_invalid");
+  return Object.freeze({
+    hellolynkTraePrivateUi: Object.freeze({
+      contract: TRAE_PRIVATE_UI_CONTRACT,
+      modelVisibility: "none",
+      widgetEnvelope,
+      actionGrants: Object.freeze(actionGrants.map(validateGrant)),
+    }),
+  });
+}
+
+function validateGrant(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)
+    || value.contract !== TRAE_UI_ACTION_GATE_CONTRACT || !TOKEN.test(String(value.token || ""))
+    || !TOOL.test(String(value.toolName || "")) || !MODES.has(String(value.mode || ""))
+    || !Number.isSafeInteger(value.expiresAtMs) || value.expiresAtMs < 0) {
+    throw codeError("trae_private_ui_grants_invalid");
+  }
+  return Object.freeze({
+    contract: value.contract, token: value.token, toolName: value.toolName,
+    mode: value.mode, expiresAtMs: value.expiresAtMs,
+  });
+}
+
+function canonicalIds(value) {
+  if (!Array.isArray(value) || value.length > 500) throw codeError("trae_ui_action_policy_invalid");
+  const ids = value.map((item) => { const id = String(item || ""); if (!ID.test(id)) throw codeError("trae_ui_action_policy_invalid"); return id; }).sort();
+  if (new Set(ids).size !== ids.length) throw codeError("trae_ui_action_policy_invalid");
+  return Object.freeze(ids);
+}
+function safeTool(value) { const text = String(value || ""); if (!TOOL.test(text)) throw codeError("trae_ui_action_policy_invalid"); return text; }
+function digest(token) { return crypto.createHash("sha256").update(token).digest("hex"); }
+function integer(value, fallback, minimum, maximum) { const number = Number(value ?? fallback); if (!Number.isSafeInteger(number) || number < minimum || number > maximum) throw codeError("trae_ui_action_gate_limit_invalid"); return number; }
+function codeError(code) { const error = new Error(code); error.code = code; return error; }

package/integrations/trae-work/skills/hellolynk-inbox/SKILL.md

@@ -0,0 +1,9 @@
+---
+name: hellolynk-inbox
+description: 在 TRAE Work 中打开和使用 HelloLynk 通讯；不用于邮件。
+---
+# HelloLynk 通讯
+HelloLynk 是本人授权的 AI 通讯。接着已有来往用 hellolynk_reply_authorized_message，沿用来信的 localMessageId 和 conversationKey；发起新通信用 hellolynk_send_authorized_message，contact 填对方名字。每条新消息用新的 clientMessageId；发送失败或结果未知时保留编号并停止，不重发；参数无效时改正后重新调用。收到本聊天的 HelloLynk 自动提醒时，用 hellolynk_claim_message 按 batchId 读一次。没有本聊天的提醒或本人查信要求时，不主动查信。用户要看全部来信时，打开本客户端的 HelloLynk 界面供本人查看。
+## 打开
+1. 调用 hellolynk_open_inbox（空参数）一次。
+2. 用 OpenPreview 打开返回的地址。

package/package.json

@@ -1,6 +1,63 @@
 {
   "name": "@hellolynk-ai/trae-work-mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.4.94",
+  "description": "HelloLynk Messaging for TRAE Work: open conversations and let your AI message other people's AI assistants.",
+  "homepage": "https://hellolynk.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/haoyun18881-beep/HelloLynk.git",
+    "directory": "clients/trae-work"
+  },
+  "bugs": {
+    "url": "https://github.com/haoyun18881-beep/HelloLynk/issues"
+  },
+  "keywords": [
+    "hellolynk-ai",
+    "HelloLynk",
+    "agent-communication",
+    "trae-work"
+  ],
+  "license": "SEE LICENSE IN LICENSE",
+  "type": "module",
+  "os": [
+    "win32"
+  ],
+  "engines": {
+    "node": ">=22.16.0"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "bin/",
+    "tools/",
+    "integrations/trae-work/",
+    "runtime/",
+    "hellolynk-client-pack-manifest.json",
+    "hellolynk-client-pack-pin.json"
+  ],
+  "bin": {
+    "hellolynk-trae-work": "./bin/hellolynk-client-setup.mjs"
+  },
+  "scripts": {
+    "connect": "node ./bin/hellolynk-client-setup.mjs connect",
+    "init": "node ./bin/hellolynk-client-setup.mjs init",
+    "activate": "node ./bin/hellolynk-client-setup.mjs activate --binding-key-from-stdin",
+    "doctor": "node ./bin/hellolynk-client-setup.mjs doctor",
+    "setup": "node ./bin/hellolynk-client-setup.mjs setup"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "hellolynkClient": {
+    "client": "trae-work",
+    "activationTool": "tools/hellolynk-activate-neutral-host-clients.mjs",
+    "coreRoot": "runtime/core",
+    "profileId": "hellolynk-host-trae-work-v2",
+    "releaseRoot": ".",
+    "serviceBaseUrl": "https://hellolynk.com",
+    "configurator": "runtime/core/hellolynk-agent-configurator.mjs",
+    "entry": "runtime/trae-work-bootstrap.mjs",
+    "skillTarget": "trae"
+  }
+}

package/runtime/bootstrap/core/hellolynk-client-account.mjs

@@ -0,0 +1,180 @@
+import { randomBytes } from "node:crypto";
+import { lstatSync, readFileSync } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { applyCurrentUserAcl, defaultNeutralHostStoreRoot, withNeutralHostStoreLock } from "./hellolynk-neutral-host-installation-store.mjs";
+
+export const ACCOUNT_CLIENTS = Object.freeze(["codex", "openclaw", "trae-work", "workbuddy", "dsh", "claude-code"]);
+const GENERATION = /^[a-f0-9]{32}$/;
+const INITIAL = "initial";
+
+// Packages and account data have separate lifetimes. Existing installations
+// keep their shared account until the user disconnects one particular client.
+export function clientAccountBaseRoot(root = defaultNeutralHostStoreRoot()) {
+  if (!path.isAbsolute(root)) throw failure("workbench_account_path_invalid");
+  root = path.resolve(root);
+  const generation = path.dirname(root), client = path.dirname(generation), accounts = path.dirname(client);
+  if (path.basename(root) === "host" && GENERATION.test(path.basename(generation))
+    && ACCOUNT_CLIENTS.includes(path.basename(client)) && path.basename(accounts) === "account-data") {
+    return path.join(path.dirname(accounts), "host");
+  }
+  return root;
+}
+
+function statePath(client, baseRoot) {
+  if (!ACCOUNT_CLIENTS.includes(client)) throw failure("workbench_account_client_invalid");
+  return path.join(baseRoot, `client-account-${client}.json`);
+}
+
+export function readClientAccount(client, root = defaultNeutralHostStoreRoot()) {
+  const baseRoot = clientAccountBaseRoot(root);
+  const file = statePath(client, baseRoot);
+  let record;
+  try {
+    assertPath(file);
+    const stat = lstatSync(file);
+    if (!stat.isFile() || stat.nlink !== 1 || stat.size > 1024) throw failure("workbench_account_state_invalid");
+    record = JSON.parse(readFileSync(file, "utf8"));
+  } catch (error) {
+    if (error.code !== "ENOENT") throw failure("workbench_account_state_invalid");
+    return Object.freeze({ client, baseRoot, root: baseRoot, revision: INITIAL, phase: "ready", previousRevision: null });
+  }
+  if (record?.version !== 1 || !GENERATION.test(record.revision)
+    || !["disconnecting", "ready"].includes(record.phase)
+    || (record.previousRevision !== INITIAL && !GENERATION.test(record.previousRevision))
+    || Object.keys(record).sort().join(",") !== "phase,previousRevision,revision,version") {
+    throw failure("workbench_account_state_invalid");
+  }
+  return Object.freeze({ client, baseRoot, root: generationRoot(client, baseRoot, record.revision), ...record });
+}
+
+export function resolveClientAccountRoot(client, root) {
+  const account = readClientAccount(client, root);
+  if (account.phase !== "ready") throw failure("workbench_account_disconnect_incomplete");
+  return account.root;
+}
+
+export function assertClientAccountCurrent(client, root) {
+  if (!ACCOUNT_CLIENTS.includes(client)) return;
+  const account = readClientAccount(client, root);
+  if (account.phase !== "ready" || !samePath(root, account.root)) throw failure("workbench_account_changed");
+}
+
+export function withClientAccountLock(client, root, operation) {
+  const baseRoot = clientAccountBaseRoot(root);
+  statePath(client, baseRoot);
+  return withNeutralHostStoreLock(baseRoot, `client-account-${client}`, operation);
+}
+
+export function createClientAccountActions(options) {
+  const client = options?.client;
+  const root = options?.storeRoot || defaultNeutralHostStoreRoot("win32", options?.env || process.env);
+  statePath(client, clientAccountBaseRoot(root));
+  const readAccountState = () => {
+    const state = readClientAccount(client, root);
+    return { revision: state.revision, disconnecting: state.phase === "disconnecting", canDisconnect: true };
+  };
+  const assertRevision = (revision) => {
+    const state = readClientAccount(client, root);
+    if (state.revision !== revision) throw failure("workbench_account_changed");
+    if (state.phase !== "ready") throw failure("workbench_account_disconnect_incomplete");
+    return state.root;
+  };
+  return Object.freeze({
+    readAccountState, assertRevision,
+    runForAccount(revision, operation) {
+      return withClientAccountLock(client, root, () => operation(assertRevision(revision)));
+    },
+    async runSafetyVerificationForAccount(revision, operation) {
+      // Only native safety verification may wait outside the account lock.
+      // The Host fences its eventual write with the original attachment and
+      // exact device identity; the account revision also fences its UI result.
+      const pending = await withClientAccountLock(client, root, () => ({
+        completion: Promise.resolve(operation(assertRevision(revision))).then(
+          (value) => ({ value }), (error) => ({ error }),
+        ),
+      }));
+      const outcome = await pending.completion;
+      return withClientAccountLock(client, root, () => {
+        assertRevision(revision);
+        if (Object.hasOwn(outcome, "error")) throw outcome.error;
+        return outcome.value;
+      });
+    },
+    async disconnectAccount(input) {
+      if (!input || Object.keys(input).join(",") !== "revision"
+        || typeof input.revision !== "string" || !/^(?:initial|[a-f0-9]{32})$/.test(input.revision)) {
+        throw failure("workbench_disconnect_input_invalid");
+      }
+      return disconnectClientAccount({ client, root, revision: input.revision }, async (previousRoot) => {
+        const { createHostProtectedStore } = await import("./hellolynk-host-protected-store.mjs");
+        await createHostProtectedStore({ root: previousRoot, followClientAccount: false,
+          ...(options.helperPath ? { helperPath: options.helperPath } : {}),
+        }).disconnectLocalClient(client);
+      });
+    },
+  });
+}
+
+// The pending record is a durable fence: a crash while revoking the old local
+// capability must never make it usable again. Retrying resumes that same fence.
+export async function disconnectClientAccount({ client, root, revision }, revokePrevious) {
+  return withClientAccountLock(client, root, async () => {
+    let account = readClientAccount(client, root);
+    if (account.phase === "ready" && account.previousRevision === revision) {
+      return { disconnected: true, revision: account.revision };
+    }
+    if (revision !== account.revision && !(account.phase === "disconnecting" && revision === account.previousRevision)) {
+      throw failure("workbench_account_changed");
+    }
+    if (account.phase === "ready") {
+      await save(client, account.baseRoot, {
+        version: 1, revision: randomBytes(16).toString("hex"), previousRevision: account.revision, phase: "disconnecting",
+      });
+      account = readClientAccount(client, root);
+    }
+    const previousRoot = generationRoot(client, account.baseRoot, account.previousRevision);
+    await revokePrevious(previousRoot);
+    await save(client, account.baseRoot, {
+      version: 1, revision: account.revision, previousRevision: account.previousRevision, phase: "ready",
+    });
+    return { disconnected: true, revision: account.revision };
+  });
+}
+
+function generationRoot(client, baseRoot, revision) {
+  return revision === INITIAL ? baseRoot : path.join(path.dirname(baseRoot), "account-data", client, revision, "host");
+}
+
+async function save(client, root, record) {
+  const file = statePath(client, root);
+  assertPath(root);
+  const temporary = `${file}.${process.pid}.${randomBytes(6).toString("hex")}`;
+  let handle;
+  try {
+    handle = await fs.open(temporary, "wx", 0o600);
+    await handle.writeFile(`${JSON.stringify(record)}\n`);
+    await handle.sync();
+    await handle.close(); handle = null;
+    await fs.chmod(temporary, 0o600);
+    await applyCurrentUserAcl(temporary, false);
+    await fs.rename(temporary, file);
+  } finally {
+    await handle?.close();
+    await fs.unlink(temporary).catch((error) => { if (error.code !== "ENOENT") throw error; });
+  }
+}
+
+function assertPath(file) {
+  let cursor = path.resolve(file);
+  while (cursor !== path.dirname(cursor)) {
+    try { if (lstatSync(cursor).isSymbolicLink()) throw failure("workbench_account_path_invalid"); }
+    catch (error) { if (error.code !== "ENOENT") throw error; }
+    cursor = path.dirname(cursor);
+  }
+}
+function samePath(a, b) {
+  const normalize = (v) => process.platform === "win32" ? path.resolve(v).toLowerCase() : path.resolve(v);
+  return normalize(a) === normalize(b);
+}
+function failure(code) { return Object.assign(new Error(code), { code, status: 409 }); }