@hellolynk-ai/codex-plugin 0.2.101 → 0.2.102-macos.1

package/plugins/hellolynk-codex/runtime/bootstrap/platform/darwin/hellolynk-keychain-helper.swift

@@ -0,0 +1,149 @@
+// Rebuild in this directory: xcrun swiftc -O -target arm64-apple-macos13.0 -module-name HelloLynkKeychain hellolynk-keychain-helper.swift -o hellolynk-keychain-helper.bin
+import AppKit
+import CryptoKit
+import Foundation
+import Security
+
+func fail(_ code: String) -> Never {
+    FileHandle.standardError.write(Data((code + "\n").utf8))
+    exit(1)
+}
+
+func requireNoGrantACL(_ path: String) {
+    guard let acl = acl_get_file(path, ACL_TYPE_EXTENDED) else {
+        if errno == ENOENT { return } // A first write creates the file with mode 0600.
+        fail("macos_vault_acl_unavailable")
+    }
+    defer { acl_free(UnsafeMutableRawPointer(acl)) }
+    var entry: acl_entry_t?
+    var selector = ACL_FIRST_ENTRY
+    while acl_get_entry(acl, Int32(selector.rawValue), &entry) == 0 {
+        var tag = ACL_UNDEFINED_TAG
+        guard acl_get_tag_type(entry, &tag) == 0, tag == ACL_EXTENDED_DENY else {
+            fail("macos_vault_acl_invalid")
+        }
+        selector = ACL_NEXT_ENTRY
+    }
+}
+
+// The caller verifies the release path's ancestors and package hashes. Walk
+// with lstat so a symlink or hard link cannot redirect a permission change.
+func secureRelease(_ path: String, verifyOnly: Bool) {
+    var pending = [path]
+    while let entry = pending.popLast() {
+        var st = stat()
+        guard lstat(entry, &st) == 0, st.st_uid == getuid() else { fail("macos_vault_release_invalid") }
+        let type = st.st_mode & S_IFMT
+        guard type == S_IFDIR || (type == S_IFREG && st.st_nlink == 1) else { fail("macos_vault_release_invalid") }
+        let mode: mode_t = type == S_IFDIR || entry.hasSuffix(".bin") ? 0o700 : 0o600
+        if (st.st_mode & 0o7777) != mode {
+            guard !verifyOnly, chmod(entry, mode) == 0 else { fail("macos_vault_release_permissions_invalid") }
+        }
+        requireNoGrantACL(entry)
+        if type == S_IFDIR {
+            guard let names = try? FileManager.default.contentsOfDirectory(atPath: entry) else { fail("macos_vault_release_invalid") }
+            pending.append(contentsOf: names.map { entry + "/" + $0 })
+        }
+    }
+}
+
+func masterKey(_ root: String, create: Bool) -> Data {
+    let account = SHA256.hash(data: Data(root.utf8)).map { String(format: "%02x", $0) }.joined()
+    let base: [String: Any] = [
+        kSecClass as String: kSecClassGenericPassword,
+        kSecAttrService as String: "com.hellolynk.codex.macos-vault.v1",
+        kSecAttrAccount as String: account
+    ]
+    var lookup = base
+    lookup[kSecReturnData as String] = true
+    lookup[kSecMatchLimit as String] = kSecMatchLimitOne
+    var result: CFTypeRef?
+    let status = SecItemCopyMatching(lookup as CFDictionary, &result)
+    if status == errSecSuccess {
+        guard let key = result as? Data, key.count == 32 else { fail("macos_vault_key_invalid") }
+        return key
+    }
+    guard status == errSecItemNotFound else { fail("macos_keychain_access_\(abs(Int(status)))") }
+    guard create else { fail("macos_vault_key_missing") }
+    let key = SymmetricKey(size: .bits256).withUnsafeBytes { Data($0) }
+    var add = base
+    add[kSecValueData as String] = key
+    add[kSecAttrAccessible as String] = kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly
+    let inserted = SecItemAdd(add as CFDictionary, nil)
+    if inserted == errSecDuplicateItem { return masterKey(root, create: false) }
+    guard inserted == errSecSuccess else { fail("macos_keychain_access_\(abs(Int(inserted)))") }
+    return key
+}
+
+func nativeConfirmation() {
+    let raw = FileHandle.standardInput.readDataToEndOfFile()
+    guard raw.count <= 20480 * 6 + 8192,
+          var v = (try? JSONSerialization.jsonObject(with: raw)) as? [String: Any],
+          let body = v["displayText"] as? String, !body.isEmpty, body.utf8.count <= 20480,
+          let encoded = v["hmacKey"] as? String, encoded.count == 43,
+          let key = Data(base64Encoded: encoded.replacingOccurrences(of: "-", with: "+")
+              .replacingOccurrences(of: "_", with: "/") + "="), key.count == 32,
+          let recipient = v["recipientHelloLynkId"] as? String,
+          v["contract"] as? String == "hellolynk-native-human-confirmation-v1",
+          v["textDigest"] as? String == SHA256.hash(data: Data(body.utf8)).map({ String(format: "%02x", $0) }).joined()
+    else { fail("human_confirmation_request_invalid") }
+
+    var fields = ["contract", "actionId", "decision", "principalId", "delegateId", "hostInstallationId",
+                  "adapterId", "adapterInstanceId", "hostGeneration", "recipientHelloLynkId"]
+    var label = "收件人：" + recipient
+    if v["recipientDelegateId"] != nil || v["recipientInstanceDisplayName"] != nil {
+        guard let name = v["recipientInstanceDisplayName"] as? String, !name.isEmpty, name.utf8.count <= 512,
+              name.range(of: #"[\x00-\x1F\x7F-\x9F\u2028\u2029\u202A-\u202E\u2066-\u2069]"#, options: .regularExpression) == nil,
+              v["recipientDelegateId"] is String else { fail("human_confirmation_request_invalid") }
+        fields += ["recipientDelegateId", "recipientInstanceDisplayName"]
+        label += "\n目标 AI：" + name
+    }
+    fields += ["clientMessageId", "textDigest", "createdAtMs", "expiresAtMs", "challenge"]
+    var expected = Set(fields)
+    expected.remove("decision")
+    expected.formUnion(["displayText", "hmacKey"])
+    guard expected == Set(v.keys) else { fail("human_confirmation_request_invalid") }
+    let app = NSApplication.shared
+    app.setActivationPolicy(.accessory)
+    app.activate(ignoringOtherApps: true)
+    let dialog = NSAlert()
+    dialog.messageText = "是否允许 HelloLynk 发送以下文本？"
+    dialog.informativeText = label
+    dialog.addButton(withTitle: "取消")
+    dialog.addButton(withTitle: "批准发送")
+    let scroll = NSScrollView(frame: NSRect(x: 0, y: 0, width: 500, height: 230))
+    scroll.hasVerticalScroller = true
+    let view = NSTextView(frame: scroll.contentView.bounds)
+    view.isEditable = false
+    view.isRichText = false
+    view.isVerticallyResizable = true
+    view.autoresizingMask = [.width]
+    view.textContainer?.widthTracksTextView = true
+    view.string = body
+    scroll.documentView = view
+    dialog.accessoryView = scroll
+    v["decision"] = dialog.runModal() == .alertSecondButtonReturn ? "approve" : "cancel"
+    let message = fields.map { field -> String in
+        if let text = v[field] as? String { return text }
+        if ["createdAtMs","expiresAtMs"].contains(field), let n = v[field] as? NSNumber { return n.stringValue }
+        fail("human_confirmation_request_invalid")
+    }.joined(separator: "\n")
+    let proof = HMAC<SHA256>.authenticationCode(for: Data(message.utf8), using: SymmetricKey(data: key))
+    v["proof"] = proof.map { String(format: "%02x", $0) }.joined()
+    for field in ["hmacKey", "challenge", "displayText"] { v.removeValue(forKey: field) }
+    guard let output = try? JSONSerialization.data(withJSONObject: v) else { fail("human_confirmation_response_invalid") }
+    FileHandle.standardOutput.write(output)
+}
+
+let args = Array(CommandLine.arguments.dropFirst())
+if args == ["confirm"] { nativeConfirmation() }
+else if args.count == 3, args[0] == "key", args[1].hasPrefix("/"), ["load","create"].contains(args[2]) {
+    requireNoGrantACL(args[1])
+    requireNoGrantACL(args[1] + "/protected-v1.sqlite")
+    let key = masterKey(args[1], create: args[2] == "create")
+    FileHandle(fileDescriptor: 3, closeOnDealloc: false).write(key)
+} else if args.count == 2, ["verify-tree", "secure-tree"].contains(args[0]), args[1].hasPrefix("/") {
+    secureRelease(args[1], verifyOnly: args[0] == "verify-tree")
+} else if args.count == 2, args[0] == "verify-acl", args[1].hasPrefix("/") {
+    requireNoGrantACL(args[1])
+} else { fail("macos_vault_helper_arguments_invalid") }

package/plugins/hellolynk-codex/runtime/connect-activate.mjs

@@ -5,6 +5,7 @@ import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 
+import { verifyDarwinUnclaimedAuthorization } from "./core/hellolynk-darwin-host.mjs";
 import { readClientProfile } from "./core/hellolynk-client-profile.mjs";
 import { createNeutralHostInstallationStore } from "./core/hellolynk-neutral-host-installation-store.mjs";
 import { clientAccountBaseRoot } from "./core/hellolynk-client-account.mjs";
@@ -164,7 +165,7 @@ assert.equal(releaseVerification.verifiedFileCount >= 8, true);
 let transport = null;
 let bootstrapTransportRequired = false;
 let protectedStorePresent = true;
-try { await fs.lstat(path.join(root, "capabilities-v1.dpapi.clixml")); }
+try { await fs.lstat(path.join(root, process.platform === "darwin" ? "protected-v1.sqlite" : "capabilities-v1.dpapi.clixml")); }
 catch (error) {
   if (error?.code !== "ENOENT") throw error;
   protectedStorePresent = false;
@@ -173,6 +174,9 @@ if (!protectedStorePresent) {
   if (!(freshPreBind || recoveryPreBind)) await store.status();
   await verifyHostProtectedStorePath({ root, path: root, directory: true });
   bootstrapTransportRequired = true;
+} else if (process.platform === "darwin" && freshPreBind) {
+  await verifyDarwinUnclaimedAuthorization(root);
+  bootstrapTransportRequired = true;
 } else {
   assert.equal((await store.status()).protected, true);
   try { transport = preflightOnly ? await store.verifyTransport() : await store.resolveTransport(); }

package/plugins/hellolynk-codex/runtime/core/hellolynk-client-account.mjs

@@ -68,7 +68,7 @@ export function withClientAccountLock(client, root, operation) {
 
 export function createClientAccountActions(options) {
   const client = options?.client;
-  const root = options?.storeRoot || defaultNeutralHostStoreRoot("win32", options?.env || process.env);
+  const root = options?.storeRoot || defaultNeutralHostStoreRoot(process.platform, options?.env || process.env);
   statePath(client, clientAccountBaseRoot(root));
   const readAccountState = () => {
     const state = readClientAccount(client, root);

package/plugins/hellolynk-codex/runtime/core/hellolynk-client-profile.mjs

@@ -1,4 +1,5 @@
 import { lstat, mkdir, open, readFile, rename, rm, stat } from "node:fs/promises";
+import { readdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import { randomUUID } from "node:crypto";
@@ -19,12 +20,34 @@ const SAFE_SCOPE = /^[a-z][a-z0-9_.:-]{0,127}$/;
 const MAX_PROFILE_BYTES = 64 * 1024;
 
 export function defaultHelloLynkClientRoot(platform = process.platform, env = process.env) {
-  const home = resolve(String(env.HOME || env.USERPROFILE || homedir()));
-  if (platform === "win32") return resolve(String(env.LOCALAPPDATA || join(home, "AppData", "Local")), "HelloLynk");
+  const home = resolve(String((platform === "win32" ? env.USERPROFILE || env.HOME : env.HOME || env.USERPROFILE) || homedir()));
+  if (platform === "win32") {
+    const current = join(home, ".hellolynk", "hellolynk-v2");
+    // Once selected, another client's older installer must not move us back.
+    if (hasWindowsClientInstallation(current)) return current;
+    const existing = resolve(String(env.LOCALAPPDATA || join(home, "AppData", "Local")), "HelloLynk");
+    // AppData created from a packaged desktop app can be private to that app.
+    // Keep an existing installation; an empty failed setup is not an account.
+    if (hasWindowsClientInstallation(existing)) return existing;
+    return current;
+  }
   if (platform === "darwin") return join(home, "Library", "Application Support", "HelloLynk");
   return resolve(String(env.XDG_DATA_HOME || join(home, ".local", "share")), "hellolynk");
 }
 
+function hasWindowsClientInstallation(root) {
+  for (const directory of ["profiles", "releases", "host", "credentials", "e2ee-private-keys"]) {
+    try {
+      const entries = readdirSync(join(root, directory), { withFileTypes: true });
+      if (entries.some((entry) => directory !== "host" || entry.name !== "runtime")) return true;
+    } catch (error) {
+      // An unreadable existing location must not silently become a fresh account.
+      if (error.code !== "ENOENT") return true;
+    }
+  }
+  return false;
+}
+
 function safeId(value, code) {
   const normalized = String(value || "").trim();
   if (!SAFE_ID.test(normalized)) throw new Error(code);

package/plugins/hellolynk-codex/runtime/core/hellolynk-client-update-entry.mjs

@@ -2,6 +2,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { clientAccountBaseRoot } from "./hellolynk-client-account.mjs";
 import { startClientUpdateRuntime } from "./hellolynk-client-update-runtime.mjs";
+import { clientUpdateCatalogId, MAC_CODEX_VERSION } from "./hellolynk-client-update.mjs";
 
 const running = new Map();
 
@@ -9,7 +10,9 @@ const running = new Map();
 // to the Host. A checkout or an uninstalled test fixture never self-updates.
 export function startInstalledClientUpdate(options = {}) {
   const { client, packageRoot, storeRoot } = options;
-  if (process.platform !== "win32" || !path.isAbsolute(String(packageRoot || ""))) return Promise.resolve(null);
+  const catalogId = clientUpdateCatalogId(client, process.platform);
+  const mac = catalogId === "codex-macos";
+  if (!catalogId || (mac && process.arch !== "arm64") || !path.isAbsolute(String(packageRoot || ""))) return Promise.resolve(null);
   let baseRoot;
   try { baseRoot = clientAccountBaseRoot(storeRoot); } catch { return Promise.resolve(null); }
   const key = `${client}\0${path.resolve(packageRoot)}\0${baseRoot}`;
@@ -21,8 +24,9 @@ export function startInstalledClientUpdate(options = {}) {
     const metadata = await fs.lstat(packageFile);
     if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.nlink !== 1 || metadata.size > 64 * 1024) return null;
     const manifest = JSON.parse(await fs.readFile(packageFile, "utf8"));
-    if (manifest.hellolynkClient?.client !== client
-      || !/^\d+\.\d+\.\d+$/.test(manifest.version || "")) return null;
+    const version = mac ? MAC_CODEX_VERSION : /^\d+\.\d+\.\d+$/u;
+    if (manifest.hellolynkClient?.client !== client || !version.test(manifest.version || "")
+      || (mac && (manifest.os?.[0] !== "darwin" || manifest.cpu?.[0] !== "arm64"))) return null;
     return startClientUpdateRuntime({
       root: baseRoot, client, currentVersion: manifest.version,
       installContext: { ...options.installContext, packageRoot: path.resolve(packageRoot) },

package/plugins/hellolynk-codex/runtime/core/hellolynk-client-update-runtime.mjs

@@ -4,7 +4,8 @@ import os from "node:os";
 import path from "node:path";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { createClientUpdateManager, extractClientUpdateArchive, compareClientUpdateVersions, CLIENT_UPDATE_CLIENTS } from "./hellolynk-client-update.mjs";
+import { createClientUpdateManager, extractClientUpdateArchive, compareClientUpdateVersions, clientUpdateCatalogId,
+  CLIENT_UPDATE_CLIENTS, MAC_CODEX_VERSION } from "./hellolynk-client-update.mjs";
 import { withNeutralHostStoreLock } from "./hellolynk-neutral-host-installation-store.mjs";
 import { readClientAccount } from "./hellolynk-client-account.mjs";
 import runtimeSafety from "./hellolynk-runtime-safety.cjs";
@@ -26,7 +27,7 @@ const RETRY_AFTER_MS = 10 * 60_000;
 // waits only for DSH's lease, and a downloaded update is applied by a worker in
 // the background. Checking the network is always detached.
 export async function startClientUpdateRuntime(options = {}) {
-  if ((options.platform || process.platform) !== "win32") return disabled();
+  if (!clientUpdateCatalogId(options.client, options.platform || process.platform)) return disabled();
   let config;
   try { config = normalize(options); await verifyInstalledContext(config); }
   catch { return disabled(); }
@@ -95,7 +96,7 @@ function createRuntime(config, options) {
   const { root, client, currentVersion, installContext } = config;
   const directory = path.join(root, "client-updates", client);
   const statePath = path.join(directory, "runtime.json"), leasePath = path.join(directory, "leases.json"), installedPath = path.join(directory, "installed.json");
-  const manager = createClientUpdateManager({ ...options, root, client, currentVersion });
+  const manager = createClientUpdateManager({ ...options, root, client, currentVersion, platform: config.platform });
   const alive = options.isProcessAlive || processAlive;
   async function gate(operation) {
     await safeDirectory(directory);
@@ -409,7 +410,7 @@ async function prepareCandidate(config, record) {
     // extractedRoot or an executable path supplied by state.json.
     const sealed = path.join(temporaryRoot, record.filename);
     await fs.writeFile(sealed, archive, { flag: "wx", mode: 0o600 });
-    await extractClientUpdateArchive({ archivePath: sealed, destination: extractedRoot });
+    await extractClientUpdateArchive({ archivePath: sealed, destination: extractedRoot, platform: config.platform });
     let packageRoot;
     if (config.client === "dsh") {
       const descriptor = await readJson(path.join(extractedRoot, "trusted-release.json"));
@@ -421,7 +422,8 @@ async function prepareCandidate(config, record) {
       packageRoot = path.join(extractedRoot, "dist", "package", "runtime", "connect");
       await safeFile(path.join(extractedRoot, "scripts", "install.mjs"));
     } else {
-      const candidates = [extractedRoot, path.join(extractedRoot, "package"), path.join(extractedRoot, `hellolynk-${config.client}-${record.version}`, "package")];
+      const id = clientUpdateCatalogId(config.client, config.platform) || config.client;
+      const candidates = [extractedRoot, path.join(extractedRoot, "package"), path.join(extractedRoot, `hellolynk-${id}-${record.version}`, "package")];
       const matches = [];
       for (const candidate of candidates) if (await exists(path.join(candidate, "package.json"))) matches.push(candidate);
       if (matches.length !== 1) throw failure("package_identity_invalid");
@@ -438,11 +440,18 @@ async function verifyPackage(root, client, version) {
   const pin = await readJson(path.join(root, "hellolynk-client-pack-pin.json"));
   const manifest = JSON.parse(manifestBytes.toString("utf8"));
   if (pkg.version !== version || pkg.hellolynkClient?.client !== client || pkg.name !== NAMES[client]
+    || (MAC_CODEX_VERSION.test(version) && (client !== "codex" || pkg.os?.[0] !== "darwin" || pkg.cpu?.[0] !== "arm64"))
     || manifest.contract !== "hellolynk-client-npm-pack-manifest-v1" || manifest.client !== client
     || manifest.packageName !== pkg.name || manifest.version !== version
     || pin.contract !== "hellolynk-client-npm-pack-pin-v1" || pin.manifestSha256 !== sha(manifestBytes)) throw failure("package_identity_invalid");
   await verifyRecords(root, manifest.files, ["hellolynk-client-pack-manifest.json", "hellolynk-client-pack-pin.json"]);
   if (!manifest.files.some((file) => file.path === "bin/hellolynk-client-setup.mjs")) throw failure("package_pin_invalid");
+  if (process.platform !== "win32" && MAC_CODEX_VERSION.test(version)) {
+    for (const relative of ["platform/darwin", "bootstrap/platform/darwin"]) {
+      const helper = path.join(root, "plugins/hellolynk-codex/runtime", relative, "hellolynk-keychain-helper.bin");
+      if (!((await fs.lstat(helper)).mode & 0o100)) throw failure("package_pin_invalid");
+    }
+  }
 }
 async function verifyRecords(root, records, allowedExtra) {
   if (!Array.isArray(records) || records.length < 1 || records.length > 5000) throw failure("package_pin_invalid");
@@ -471,7 +480,9 @@ async function verifyInstalledContext(config) {
   await verifyPackage(context.packageRoot, config.client, config.currentVersion);
 }
 function normalize(value) {
+  const platform = value.platform || process.platform;
   if (!CLIENT_UPDATE_CLIENTS.includes(value.client) || typeof value.currentVersion !== "string" || !VERSION.test(value.currentVersion)
+    || (platform === "darwin" && (value.client !== "codex" || !MAC_CODEX_VERSION.test(value.currentVersion)))
     || !path.isAbsolute(String(value.root || "")) || !path.isAbsolute(String(value.installContext?.packageRoot || ""))) throw failure("configuration_invalid");
   const context = { packageRoot: path.resolve(value.installContext.packageRoot) };
   for (const name of ["nodePath", "dshProfile", "dshRoot"]) {
@@ -484,7 +495,7 @@ function normalize(value) {
     if (!HASH.test(value.installContext.expectedInstalledManifestSha256)) throw failure("configuration_invalid");
     context.expectedInstalledManifestSha256 = value.installContext.expectedInstalledManifestSha256;
   }
-  return { root: path.resolve(value.root), client: value.client, currentVersion: value.currentVersion, installContext: context };
+  return { root: path.resolve(value.root), client: value.client, currentVersion: value.currentVersion, platform, installContext: context };
 }
 async function launchWorker(config) {
   // A host may execute this module from an ephemeral captured import graph.
@@ -510,8 +521,9 @@ async function launchWorker(config) {
 async function runInstaller({ executable, args, cwd, root, timeoutMs }) {
   executable = await runtimeSafety.resolveHelloLynkStandaloneNode({ preferredExecutable: executable });
   const env = { ...runtimeSafety.standaloneHelloLynkNodeEnvironment(process.env), HELLOLYNK_NEUTRAL_STORE_ROOT: root };
+  const mac = process.platform === "darwin";
   return new Promise((resolve, reject) => {
-    const child = spawn(executable, args, { cwd, env, windowsHide: true, stdio: ["ignore", "pipe", "pipe"], shell: false });
+    const child = spawn(executable, args, { cwd, env, detached: mac, windowsHide: true, stdio: ["ignore", "pipe", "pipe"], shell: false });
     let stdout = "", stderr = "", finished = false, terminalError = null;
     const timer = setTimeout(() => terminate(failure("installer_timeout")), timeoutMs);
     function finish(error, value) { if (finished) return; finished = true; clearTimeout(timer); error ? reject(error) : resolve(value); }
@@ -529,6 +541,9 @@ async function runInstaller({ executable, args, cwd, root, timeoutMs }) {
           killer.on("error", () => { clearTimeout(killTimer); if (!finished) killChild(); });
           killer.once("close", () => { clearTimeout(killTimer); if (!finished) killChild(); });
         } catch { killChild(); }
+      } else if (mac && child.pid) {
+        // The installer owns this process group, including a synchronous Codex CLI.
+        try { process.kill(-child.pid, "SIGKILL"); } catch { killChild(); }
       } else killChild();
     }
     child.on("error", () => {
@@ -580,7 +595,8 @@ function damaged(error) { return error instanceof SyntaxError || error?.code ===
 // Windows paths compare case-insensitively and may differ by a link or short name.
 async function samePath(left, right) {
   if (typeof left !== "string" || typeof right !== "string" || !path.isAbsolute(left) || !path.isAbsolute(right)) return false;
-  const same = (a, b) => path.resolve(a).toLowerCase() === path.resolve(b).toLowerCase();
+  const canonical = (value) => process.platform === "win32" ? path.resolve(value).toLowerCase() : path.resolve(value);
+  const same = (a, b) => canonical(a) === canonical(b);
   if (same(left, right)) return true;
   try { return same(await fs.realpath(left), await fs.realpath(right)); } catch { return false; }
 }

package/plugins/hellolynk-codex/runtime/core/hellolynk-client-update.mjs

@@ -6,6 +6,7 @@ import { withNeutralHostStoreLock } from "./hellolynk-neutral-host-installation-
 
 const CATALOG = "https://hellolynk.com/downloads/clients.json";
 export const CLIENT_UPDATE_CLIENTS = Object.freeze(["codex", "openclaw", "trae-work", "workbuddy", "dsh", "claude-code"]);
+export const MAC_CODEX_VERSION = /^\d+\.\d+\.\d+-macos\.[1-9]\d*$/u;
 const HOUR = 3_600_000;
 const MAX_ARTIFACT = 64 * 1024 * 1024;
 const HASH = /^[a-f0-9]{64}$/;
@@ -13,11 +14,20 @@ const CONTRACT = "hellolynk-client-update-v1";
 // A failed integrity or path check keeps a downloaded package from installing. Every other failure is transient.
 const BLOCKING = /^client_update_(?:same_version_changed|version_rollback|artifact_integrity_invalid|archive_[a-z_]+|path_invalid|url_invalid|redirect_invalid)$/;
 
+export function clientUpdateCatalogId(client, platform) {
+  if (platform === "win32") return client;
+  if (platform === "darwin" && client === "codex") return "codex-macos";
+  return null;
+}
+
 // This component only stages verified files. Host lifecycle and client-native
 // installation remain the responsibility of the caller.
 export function createClientUpdateManager(options = {}) {
   const { client, currentVersion, platform = process.platform } = options;
   if (!CLIENT_UPDATE_CLIENTS.includes(client) || !semver(currentVersion) || !path.isAbsolute(String(options.root || ""))) fail("configuration_invalid");
+  const catalogId = clientUpdateCatalogId(client, platform);
+  const mac = catalogId === "codex-macos";
+  if (mac && !MAC_CODEX_VERSION.test(currentVersion)) fail("configuration_invalid");
   const root = path.join(path.resolve(options.root), "client-updates", client);
   const stateFile = path.join(root, "state.json");
   const fetcher = options.fetchImpl || globalThis.fetch;
@@ -80,12 +90,12 @@ export function createClientUpdateManager(options = {}) {
       let old = await readState();
       const now = clock();
       if (!force && old.checkedAt > 0 && now >= old.checkedAt && now - old.checkedAt < 23 * HOUR) return old;
-      if (platform !== "win32") return save({ ...old, stage: "unsupported", checkedAt: now });
+      if (!catalogId) return save({ ...old, stage: "unsupported", checkedAt: now });
       try {
         const metadata = await request(CATALOG, { limit: 256 * 1024, timeout: timeoutMs, kind: "catalog" });
         let catalog;
         try { catalog = JSON.parse(metadata.toString("utf8")); } catch { fail("catalog_invalid"); }
-        const artifact = validateCatalog(catalog, client);
+        const artifact = validateCatalog(catalog, catalogId, mac);
         // The catalog has no build for this client: there is nothing to install.
         if (!artifact) {
           // A downloaded package keeps its stage and any integrity block; only an empty cache is "current".
@@ -139,7 +149,7 @@ export function createClientUpdateManager(options = {}) {
         try {
           const archivePath = path.join(stage, artifact.filename);
           await fs.writeFile(archivePath, bytes, { flag: "wx", mode: 0o600 });
-          await extractClientUpdateArchive({ archivePath, destination: path.join(stage, "extracted") });
+          await extractClientUpdateArchive({ archivePath, destination: path.join(stage, "extracted"), platform });
           await fs.rename(stage, release).catch(async (error) => {
             if (!["EEXIST", "ENOTEMPTY", "EPERM"].includes(error.code)) throw error;
             try {
@@ -267,15 +277,16 @@ export function createClientUpdateManager(options = {}) {
   });
 }
 
-function validateCatalog(catalog, client) {
+function validateCatalog(catalog, client, mac) {
   if (!catalog || !Array.isArray(catalog.clients) || catalog.clients.length > 32) fail("catalog_invalid");
   const matches = catalog.clients.filter((item) => item?.client === client);
   if (matches.length === 0) return null;
   if (matches.length > 1) fail("catalog_invalid");
   const item = matches[0];
-  if (!semver(item.version) || !HASH.test(String(item.sha256 || "")) || !safeFilename(item.filename)
+  if (!semver(item.version) || (mac && !MAC_CODEX_VERSION.test(item.version))
+    || !HASH.test(String(item.sha256 || "")) || !safeFilename(item.filename)
     || !Number.isSafeInteger(item.bytes) || item.bytes < 4 || item.bytes > MAX_ARTIFACT
-    || !Array.isArray(item.platforms) || !item.platforms.includes("Windows")) fail("catalog_invalid");
+    || !Array.isArray(item.platforms) || !item.platforms.includes(mac ? "macOS" : "Windows")) fail("catalog_invalid");
   const official = new URL(String(item.url || ""), CATALOG);
   if (official.origin !== "https://hellolynk.com" || !official.pathname.startsWith("/downloads/")) fail("catalog_invalid");
   validateUrl(official, "artifact");
@@ -309,7 +320,7 @@ function validateUrl(url, kind, redirected = false, initial = url) {
   if (!direct && !githubCdn) fail("url_invalid");
 }
 
-export async function extractClientUpdateArchive({ archivePath, destination, maxTotalBytes = 128 * 1024 * 1024, maxFileBytes = 32 * 1024 * 1024, maxEntries = 4096 }) {
+export async function extractClientUpdateArchive({ archivePath, destination, platform = process.platform, maxTotalBytes = 128 * 1024 * 1024, maxFileBytes = 32 * 1024 * 1024, maxEntries = 4096 }) {
   if (!path.isAbsolute(archivePath) || !path.isAbsolute(destination)) fail("archive_path_invalid");
   await safeAncestors(archivePath, false);
   const stat = await fs.lstat(archivePath);
@@ -360,7 +371,7 @@ export async function extractClientUpdateArchive({ archivePath, destination, max
     total += size;
     if (total > maxTotalBytes) fail("archive_too_large");
     spans.push([local, start + packed]);
-    entries.push({ segments, directory, start, packed, size, method, crc });
+    entries.push({ segments, directory, start, packed, size, method, crc, mode });
     cursor += 46 + nameLength + extraLength + commentLength;
   }
   if (cursor !== eocd) fail("archive_invalid");
@@ -377,7 +388,10 @@ export async function extractClientUpdateArchive({ archivePath, destination, max
     try { body = entry.method === 0 ? compressed : inflateRawSync(compressed, { maxOutputLength: Math.max(1, entry.size) }); }
     catch { fail("archive_integrity_invalid"); }
     if (body.length !== entry.size || crc32(body) !== entry.crc) fail("archive_integrity_invalid");
-    await fs.writeFile(target, body, { flag: "wx", mode: 0o600 });
+    // A Mac update runs a bundled Keychain helper. Keep its execute bit without
+    // inheriting group/other access or special permission bits from the ZIP.
+    const ownerExecute = platform === "darwin" ? entry.mode & 0o100 : 0;
+    await fs.writeFile(target, body, { flag: "wx", mode: 0o600 | ownerExecute });
   }
   return Object.freeze({ files: entries.filter((item) => !item.directory).length, bytes: total });
 }