@hraness/ghostget 0.17.6 → 0.18.2

package/dist/imessage-direct-install-2gm3kge7.js

@@ -0,0 +1,324 @@
+// @bun
+import {
+  ensureImsgNativeResources,
+  verifyImsgNativeResources
+} from "./index-en5hycxp.js";
+import {
+  ensurePrivateStateDirectory,
+  ghostgetStateHome
+} from "./index-yq6maz71.js";
+import"./index-gwk7rbyj.js";
+import"./index-z1w83f81.js";
+
+// src/providers/imessage-direct-install.ts
+import { createHash, randomBytes } from "crypto";
+import { constants, createReadStream } from "fs";
+import {
+  chmod,
+  link,
+  lstat,
+  open,
+  realpath,
+  unlink
+} from "fs/promises";
+import { isAbsolute, join } from "path";
+
+// src/providers/imessage-direct.ts
+var IMSG_UPSTREAM_VERSION = "0.14.1";
+var IMSG_UPSTREAM_COMMIT = "25beb76c902b0acf2dd7ae392f1b0792f6813240";
+var IMSG_PRIVATE_TRANSPORT_PATCH_COMMIT = "292db82d89293867ef847a2875667fea0fdd5dc1";
+var IMSG_PRIVATE_TRANSPORT_PATCH_SHA256 = "99cf18953470e85a62a226f207e6a5c0452d3997675c99eabf4d5cb73c6411fd";
+var IMSG_EXACT_CHAT_PATCH_COMMIT = "c5994f00d17969fd7772fd2772e7b3591089513a";
+var IMSG_EXACT_CHAT_PATCH_SHA256 = "b05aa92a078930f96fda611c674436638843f7b148d7bfa3b65ed1ccb0885c13";
+var IMSG_NO_FETCH_RICH_CARDS_PATCH_COMMIT = "520b82ab025c1d4d57333b552aa65c9ae3fdb5fd";
+var IMSG_NO_FETCH_RICH_CARDS_PATCH_SHA256 = "c2346afca4dd0f9721c235db4f692d6a2d6dece36481e074d94b5ce78f2e019b";
+var IMSG_REVIEWED_PATCH_COMMIT = IMSG_NO_FETCH_RICH_CARDS_PATCH_COMMIT;
+var IMSG_REVIEWED_PATCHES = Object.freeze([
+  Object.freeze({
+    commit: IMSG_PRIVATE_TRANSPORT_PATCH_COMMIT,
+    sha256: IMSG_PRIVATE_TRANSPORT_PATCH_SHA256
+  }),
+  Object.freeze({
+    commit: IMSG_EXACT_CHAT_PATCH_COMMIT,
+    sha256: IMSG_EXACT_CHAT_PATCH_SHA256
+  }),
+  Object.freeze({
+    commit: IMSG_NO_FETCH_RICH_CARDS_PATCH_COMMIT,
+    sha256: IMSG_NO_FETCH_RICH_CARDS_PATCH_SHA256
+  })
+]);
+var IMSG_REVIEWED_VERSION = "0.14.1+private-transport.3";
+var IMSG_DARWIN_ARM64_EXECUTABLE_SHA256 = "46c4c73c81c7db2d516c2d467c66aff03c73de196996d646bc8afce0ea85cff6";
+var IMSG_TOOL_PIN = Object.freeze({
+  id: "imsg-private-transport",
+  implementation: "github.com/openclaw/imsg+reviewed-patch",
+  version: IMSG_REVIEWED_VERSION,
+  upstreamVersion: IMSG_UPSTREAM_VERSION,
+  upstreamCommit: IMSG_UPSTREAM_COMMIT,
+  reviewedPatchCommit: IMSG_REVIEWED_PATCH_COMMIT,
+  reviewedPatches: IMSG_REVIEWED_PATCHES,
+  sourceUrl: `https://github.com/openclaw/imsg/tree/${IMSG_UPSTREAM_COMMIT}`,
+  artifacts: Object.freeze([Object.freeze({
+    platform: "darwin",
+    arch: "arm64",
+    executableSha256: IMSG_DARWIN_ARM64_EXECUTABLE_SHA256
+  })])
+});
+var IMSG_DIRECT_OPERATION_NAMES = Object.freeze([
+  "messaging.list",
+  "conversations.read",
+  "messaging.read",
+  "messaging.send",
+  "messaging.delivery.read"
+]);
+var IMSG_DIRECT_OPERATIONS = Object.freeze({
+  "messaging.list": Object.freeze({
+    effect: "read",
+    risk: "R1",
+    reason: "list a bounded current local Messages conversation window"
+  }),
+  "conversations.read": Object.freeze({
+    effect: "read",
+    risk: "R1",
+    reason: "resolve one exact live iMessage chat GUID, service, and database row"
+  }),
+  "messaging.read": Object.freeze({
+    effect: "read",
+    risk: "R1",
+    reason: "read bounded current context from one exact live iMessage chat"
+  }),
+  "messaging.send": Object.freeze({
+    effect: "write",
+    risk: "R3",
+    reason: "submit one confirmed text bubble through explicit AppleScript iMessage transport with SMS fallback disabled"
+  }),
+  "messaging.delivery.read": Object.freeze({
+    effect: "read",
+    risk: "R1",
+    reason: "read the local Messages status row for one exact observed outgoing GUID"
+  })
+});
+
+// src/providers/imessage-direct-install.ts
+var MAX_IMSG_BINARY_BYTES = 256 * 1024 * 1024;
+
+class ImsgInstallFailure extends Error {
+}
+function installFailure(message) {
+  return new ImsgInstallFailure(message);
+}
+function filesystemErrorCode(error) {
+  if (typeof error !== "object" || error === null || !("code" in error) || typeof error.code !== "string")
+    return null;
+  return error.code;
+}
+function sourceOpenFailure(error) {
+  const code = filesystemErrorCode(error);
+  if (code === "ENOENT") {
+    return installFailure("imsg install source file does not exist");
+  }
+  if (code === "EACCES" || code === "EPERM") {
+    return installFailure("imsg install source file is unreadable");
+  }
+  if (code === "ELOOP") {
+    return installFailure("imsg install source is not a trusted executable file");
+  }
+  return installFailure("imsg install source file could not be opened safely");
+}
+function imsgArtifactForCurrentRuntime() {
+  const artifact = IMSG_TOOL_PIN.artifacts.find((candidate) => candidate.platform === process.platform && candidate.arch === process.arch);
+  if (artifact === undefined) {
+    throw new Error(`reviewed imsg transport has no artifact for ${process.platform}/${process.arch}`);
+  }
+  return artifact;
+}
+async function sha256File(path) {
+  return await new Promise((resolve, reject) => {
+    const hash = createHash("sha256");
+    const stream = createReadStream(path);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("error", reject);
+    stream.on("end", () => resolve(hash.digest("hex")));
+  });
+}
+async function pinnedBinaryCandidate(path, executableSha256) {
+  try {
+    const canonical = await realpath(path);
+    if (canonical !== path)
+      return null;
+    const stats = await lstat(canonical);
+    if (!stats.isFile() || stats.isSymbolicLink() || stats.size < 1 || stats.size > MAX_IMSG_BINARY_BYTES || (stats.mode & 18) !== 0 || (stats.mode & 73) === 0 || stats.uid !== process.getuid?.() && stats.uid !== 0)
+      return null;
+    return await sha256File(canonical) === executableSha256 ? canonical : null;
+  } catch {
+    return null;
+  }
+}
+function imsgInstalledBinaryPath(environment = process.env) {
+  return join(ghostgetStateHome(environment), "tools", "imsg", IMSG_REVIEWED_VERSION, "imsg");
+}
+async function resolvePinnedImsgBinary(environment = process.env) {
+  const artifact = imsgArtifactForCurrentRuntime();
+  let candidate;
+  try {
+    candidate = imsgInstalledBinaryPath(environment);
+  } catch {
+    throw installFailure(`reviewed imsg transport ${IMSG_REVIEWED_VERSION} is unavailable or failed integrity verification`);
+  }
+  const resolved = await pinnedBinaryCandidate(candidate, artifact.executableSha256);
+  if (resolved === null) {
+    throw new Error(`reviewed imsg transport ${IMSG_REVIEWED_VERSION} is unavailable or failed integrity verification`);
+  }
+  try {
+    await verifyImsgNativeResources(join(ghostgetStateHome(environment), "tools", "imsg", IMSG_REVIEWED_VERSION));
+  } catch {
+    throw installFailure("reviewed imsg resources are unavailable or failed integrity verification");
+  }
+  return resolved;
+}
+async function validateInstallDirectory(path) {
+  try {
+    const canonical = await realpath(path);
+    const stats = await lstat(path);
+    if (canonical !== path || !stats.isDirectory() || stats.isSymbolicLink() || stats.uid !== process.getuid?.() || (stats.mode & 63) !== 0) {
+      throw installFailure("imsg install directory must be an owned physical private directory");
+    }
+  } catch (error) {
+    if (error instanceof ImsgInstallFailure)
+      throw error;
+    throw installFailure("imsg install state directory is unavailable or unsafe");
+  }
+}
+async function copyPinnedBinary(sourcePath, destinationPath, expectedSha256) {
+  let source;
+  try {
+    source = await open(sourcePath, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+  } catch (error) {
+    throw sourceOpenFailure(error);
+  }
+  let destination;
+  try {
+    const before = await source.stat();
+    if (!before.isFile() || before.size < 1 || before.size > MAX_IMSG_BINARY_BYTES || (before.mode & 18) !== 0 || (before.mode & 73) === 0 || before.uid !== process.getuid?.() && before.uid !== 0)
+      throw installFailure("imsg install source is not a trusted executable file");
+    destination = await open(destinationPath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 320);
+    const hash = createHash("sha256");
+    const buffer = Buffer.allocUnsafe(1024 * 1024);
+    let offset = 0;
+    while (offset < before.size) {
+      const read = await source.read(buffer, 0, Math.min(buffer.byteLength, before.size - offset), offset);
+      if (read.bytesRead < 1) {
+        throw installFailure("imsg install source changed while copied");
+      }
+      const chunk = buffer.subarray(0, read.bytesRead);
+      hash.update(chunk);
+      let written = 0;
+      while (written < chunk.byteLength) {
+        const result = await destination.write(chunk, written, chunk.byteLength - written, offset + written);
+        if (result.bytesWritten < 1) {
+          throw installFailure("imsg install copy failed");
+        }
+        written += result.bytesWritten;
+      }
+      offset += read.bytesRead;
+    }
+    const extra = await source.read(Buffer.allocUnsafe(1), 0, 1, offset);
+    const after = await source.stat();
+    if (extra.bytesRead !== 0 || before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs || hash.digest("hex") !== expectedSha256) {
+      throw installFailure("imsg install source changed or did not match the reviewed digest");
+    }
+    await destination.sync();
+  } finally {
+    await destination?.close();
+    await source.close();
+  }
+  await chmod(destinationPath, 320);
+  if (await sha256File(destinationPath) !== expectedSha256) {
+    throw installFailure("installed imsg transport failed its reviewed digest");
+  }
+}
+async function installReviewedImsgBinary(sourcePath, environment = process.env) {
+  if (!isAbsolute(sourcePath)) {
+    throw installFailure("imsg install source must be an absolute path");
+  }
+  const artifact = imsgArtifactForCurrentRuntime();
+  let stateHome;
+  try {
+    stateHome = ghostgetStateHome(environment);
+  } catch {
+    throw installFailure("imsg install state directory is unavailable or unsafe");
+  }
+  const installDirectory = join(stateHome, "tools", "imsg", IMSG_REVIEWED_VERSION);
+  const destinationPath = join(installDirectory, "imsg");
+  try {
+    ensurePrivateStateDirectory(installDirectory, environment);
+    await validateInstallDirectory(installDirectory);
+    await ensureImsgNativeResources(installDirectory, environment);
+  } catch (error) {
+    if (error instanceof ImsgInstallFailure)
+      throw error;
+    throw installFailure("imsg install state directory is unavailable or unsafe");
+  }
+  const existing = await pinnedBinaryCandidate(destinationPath, artifact.executableSha256);
+  if (existing !== null) {
+    return Object.freeze({
+      path: existing,
+      executableSha256: artifact.executableSha256,
+      version: IMSG_REVIEWED_VERSION,
+      alreadyPresent: true
+    });
+  }
+  try {
+    await lstat(destinationPath);
+    throw installFailure("existing imsg install does not match the reviewed artifact");
+  } catch (error) {
+    if (error instanceof ImsgInstallFailure)
+      throw error;
+    if (filesystemErrorCode(error) !== "ENOENT") {
+      throw installFailure("existing imsg install could not be inspected safely");
+    }
+  }
+  const temporaryPath = join(installDirectory, `.imsg-install-${randomBytes(16).toString("hex")}`);
+  try {
+    try {
+      await copyPinnedBinary(sourcePath, temporaryPath, artifact.executableSha256);
+    } catch (error) {
+      if (error instanceof ImsgInstallFailure)
+        throw error;
+      throw installFailure("imsg install I/O failed safely");
+    }
+    try {
+      await link(temporaryPath, destinationPath);
+    } catch (error) {
+      if (filesystemErrorCode(error) !== "EEXIST") {
+        throw installFailure("imsg install I/O failed safely");
+      }
+      if (await pinnedBinaryCandidate(destinationPath, artifact.executableSha256) === null)
+        throw installFailure("concurrent imsg install produced unreviewed bytes");
+    }
+  } finally {
+    try {
+      await unlink(temporaryPath);
+    } catch (error) {
+      if (filesystemErrorCode(error) !== "ENOENT") {
+        throw installFailure("imsg install I/O cleanup failed safely");
+      }
+    }
+  }
+  const installed = await pinnedBinaryCandidate(destinationPath, artifact.executableSha256);
+  if (installed === null) {
+    throw installFailure("imsg install could not be verified");
+  }
+  return Object.freeze({
+    path: installed,
+    executableSha256: artifact.executableSha256,
+    version: IMSG_REVIEWED_VERSION,
+    alreadyPresent: false
+  });
+}
+export {
+  resolvePinnedImsgBinary,
+  installReviewedImsgBinary,
+  imsgInstalledBinaryPath,
+  imsgArtifactForCurrentRuntime
+};

package/dist/index-01eeae9e.js

@@ -0,0 +1,5 @@
+// @bun
+// src/messaging-automation-types.ts
+var MESSAGING_AUTOMATION_PROTOCOL = "ghostget.messaging-automation/1";
+
+export { MESSAGING_AUTOMATION_PROTOCOL };

package/dist/index-2ymnp8xv.js

@@ -0,0 +1,145 @@
+// @bun
+// src/messaging-automation-validation.ts
+import { types } from "util";
+var AUTOMATION_ACTION_KINDS = Object.freeze(["text", "attachment", "reaction", "sticker", "link", "poll", "app-clip", "experience"]);
+function automationRecord(value, keys) {
+  if (types.isProxy(value) || typeof value !== "object" || value === null || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value)))
+    throw new Error("Messaging automation value must be a plain object.");
+  const fields = Object.getOwnPropertyDescriptors(value);
+  if (Reflect.ownKeys(fields).length !== keys.length || keys.some((key) => !Object.hasOwn(fields, key)) || Reflect.ownKeys(fields).some((key) => typeof key !== "string" || !keys.includes(key) || !fields[key]?.enumerable || !("value" in fields[key]))) {
+    throw new Error("Messaging automation value has unsupported fields.");
+  }
+  return value;
+}
+function automationText(value, maximum = 256, empty = false) {
+  if (typeof value !== "string" || !empty && value.length === 0 || Buffer.byteLength(value) > maximum || /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/u.test(value) || Buffer.from(value, "utf8").toString("utf8") !== value)
+    throw new Error("Messaging automation text is invalid or exceeds its bound.");
+  return value;
+}
+function automationId(value) {
+  const id = automationText(value, 256);
+  if (!/^[A-Za-z0-9._:-]+$/u.test(id))
+    throw new Error("Messaging automation identifier is invalid.");
+  return id;
+}
+function automationDigest(value) {
+  if (typeof value !== "string" || !/^[a-f0-9]{64}$/u.test(value))
+    throw new Error("Messaging automation digest is invalid.");
+  return value;
+}
+function automationInteger(value, minimum, maximum) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < minimum || value > maximum)
+    throw new Error("Messaging automation integer is outside its bound.");
+  return value;
+}
+function automationArray(value, maximum) {
+  if (types.isProxy(value) || !Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype || value.length > maximum || Reflect.ownKeys(value).length !== value.length + 1)
+    throw new Error("Messaging automation list is invalid or exceeds its bound.");
+  for (let i = 0;i < value.length; i++) {
+    const field = Object.getOwnPropertyDescriptor(value, String(i));
+    if (field === undefined || !field.enumerable || !("value" in field))
+      throw new Error("Messaging automation list must be dense data.");
+  }
+  return value;
+}
+function automationDate(value) {
+  const text = automationText(value, 32);
+  if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u.test(text) || !Number.isFinite(Date.parse(text)) || new Date(text).toISOString() !== text)
+    throw new Error("Messaging automation time must be canonical UTC.");
+  return text;
+}
+function parseAutomationCoordinate(value) {
+  if (typeof value !== "object" || value === null || types.isProxy(value))
+    throw new Error("Messaging coordinate is invalid.");
+  const provider = Object.getOwnPropertyDescriptor(value, "provider")?.value;
+  if (provider === "imessage") {
+    const r2 = automationRecord(value, ["provider", "chatGuid", "service", "observedChatRowId"]);
+    const chatGuid = automationText(r2.chatGuid, 1024);
+    if (!chatGuid.startsWith("iMessage;") || r2.service !== "iMessage")
+      throw new Error("Only exact iMessage conversations are supported.");
+    return Object.freeze({ provider, chatGuid, service: "iMessage", observedChatRowId: automationInteger(r2.observedChatRowId, 1, Number.MAX_SAFE_INTEGER) });
+  }
+  const r = automationRecord(value, ["provider", "conversationJid"]);
+  if (provider !== "whatsapp" || typeof r.conversationJid !== "string" || !/^(?:[1-9][0-9]{4,14}@s\.whatsapp\.net|[1-9][0-9]{4,19}@lid)$/u.test(r.conversationJid))
+    throw new Error("Only exact individual WhatsApp conversations are supported.");
+  return Object.freeze({ provider, conversationJid: r.conversationJid });
+}
+function parseAutomationIdentity(value) {
+  const r = automationRecord(value, ["provider", "authId", "accountIdentity", "accountSubject", "implementationIdentity", "sourceGeneration"]);
+  if (r.provider !== "imessage" && r.provider !== "whatsapp")
+    throw new Error("Messaging provider is invalid.");
+  return Object.freeze({ provider: r.provider, authId: automationId(r.authId), accountIdentity: automationDigest(r.accountIdentity), accountSubject: automationText(r.accountSubject, 512), implementationIdentity: automationDigest(r.implementationIdentity), sourceGeneration: automationText(r.sourceGeneration, 256) });
+}
+function parseAutomationActionKind(value) {
+  if (!AUTOMATION_ACTION_KINDS.includes(value))
+    throw new Error("Messaging action is unsupported.");
+  return value;
+}
+function https(value) {
+  const url = automationText(value, 4096);
+  const parsed = new URL(url);
+  if (parsed.protocol !== "https:" || parsed.username || parsed.password)
+    throw new Error("Messaging links require credential-free HTTPS.");
+  return url;
+}
+function parseAutomationAction(value) {
+  if (typeof value !== "object" || value === null || types.isProxy(value))
+    throw new Error("Messaging action is invalid.");
+  const kind = parseAutomationActionKind(Object.getOwnPropertyDescriptor(value, "kind")?.value);
+  if (kind === "text") {
+    const r2 = automationRecord(value, ["kind", "text"]);
+    return Object.freeze({ kind, text: automationText(r2.text, 65536) });
+  }
+  if (kind === "link" || kind === "app-clip") {
+    const r2 = automationRecord(value, ["kind", "url"]);
+    return Object.freeze({ kind, url: https(r2.url) });
+  }
+  if (kind === "attachment") {
+    const r2 = automationRecord(value, ["kind", "assetId", "name", "mimeType"]);
+    const name = automationText(r2.name, 255);
+    const mimeType = automationText(r2.mimeType, 128);
+    if (/[\\/\r\n]/u.test(name) || !/^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+$/u.test(mimeType))
+      throw new Error("Messaging attachment metadata is invalid.");
+    return Object.freeze({ kind, assetId: automationId(r2.assetId), name, mimeType });
+  }
+  if (kind === "reaction") {
+    const r2 = automationRecord(value, ["kind", "messageId", "emoji", "remove"]);
+    const emoji = automationText(r2.emoji, 64, true);
+    if (typeof r2.remove !== "boolean" || !r2.remove && (emoji.length === 0 || [...new Intl.Segmenter(undefined, { granularity: "grapheme" }).segment(emoji)].length !== 1))
+      throw new Error("Messaging reaction is invalid.");
+    return Object.freeze({ kind, messageId: automationId(r2.messageId), emoji, remove: r2.remove });
+  }
+  if (kind === "sticker") {
+    const r2 = automationRecord(value, ["kind", "assetId", "messageId"]);
+    return Object.freeze({ kind, assetId: automationId(r2.assetId), messageId: r2.messageId === null ? null : automationId(r2.messageId) });
+  }
+  if (kind === "poll") {
+    const r2 = automationRecord(value, ["kind", "question", "options", "maximumSelections"]);
+    const options = automationArray(r2.options, 12).map((option) => automationText(option, 256));
+    if (options.length < 2 || new Set(options).size !== options.length)
+      throw new Error("Messaging poll needs distinct options.");
+    return Object.freeze({ kind, question: automationText(r2.question, 1024), options: Object.freeze(options), maximumSelections: r2.maximumSelections === null ? null : automationInteger(r2.maximumSelections, 1, options.length) });
+  }
+  const r = automationRecord(value, ["kind", "experienceId", "parameters"]);
+  if (typeof r.parameters !== "object" || r.parameters === null || types.isProxy(r.parameters))
+    throw new Error("Messaging experience parameters are invalid.");
+  const keys = Object.keys(r.parameters);
+  if (keys.length > 16)
+    throw new Error("Messaging experience parameters exceed their bound.");
+  const parameters = automationRecord(r.parameters, keys);
+  return Object.freeze({ kind, experienceId: automationId(r.experienceId), parameters: Object.freeze(Object.fromEntries(keys.map((key) => [automationId(key), automationText(parameters[key], 4096, true)]))) });
+}
+function parseAutomationMessage(value) {
+  const r = automationRecord(value, ["id", "coordinate", "direction", "occurredAt", "text", "kind", "relatedMessageId", "attachments"]);
+  if (r.direction !== "incoming" && r.direction !== "outgoing" && r.direction !== "unknown")
+    throw new Error("Messaging authorship is invalid.");
+  if (r.kind !== "message" && r.kind !== "reaction" && r.kind !== "edit" && r.kind !== "delete")
+    throw new Error("Messaging event kind is invalid.");
+  const attachments = automationArray(r.attachments, 20).map((value2) => {
+    const a = automationRecord(value2, ["name", "mimeType", "sizeBytes"]);
+    return Object.freeze({ name: a.name === null ? null : automationText(a.name, 512), mimeType: a.mimeType === null ? null : automationText(a.mimeType, 256), sizeBytes: a.sizeBytes === null ? null : automationInteger(a.sizeBytes, 0, 1024 * 1024 * 1024) });
+  });
+  return Object.freeze({ id: automationId(r.id), coordinate: parseAutomationCoordinate(r.coordinate), direction: r.direction, occurredAt: automationDate(r.occurredAt), text: r.text === null ? null : automationText(r.text, 65536, true), kind: r.kind, relatedMessageId: r.relatedMessageId === null ? null : automationId(r.relatedMessageId), attachments: Object.freeze(attachments) });
+}
+
+export { AUTOMATION_ACTION_KINDS, automationRecord, automationText, automationId, automationDigest, automationInteger, automationArray, automationDate, parseAutomationCoordinate, parseAutomationIdentity, parseAutomationActionKind, parseAutomationAction, parseAutomationMessage };

package/dist/index-en5hycxp.js

@@ -0,0 +1,175 @@
+// @bun
+import {
+  ensurePrivateStateDirectory
+} from "./index-yq6maz71.js";
+import {
+  __require
+} from "./index-z1w83f81.js";
+
+// src/providers/messaging-native-install.ts
+import { createHash, randomBytes } from "crypto";
+import { constants } from "fs";
+import { chmod, link, lstat, mkdtemp, open, realpath, rmdir, unlink } from "fs/promises";
+import { tmpdir } from "os";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { gunzipSync } from "zlib";
+
+// src/providers/messaging-native-artifacts.ts
+var MESSAGING_NATIVE_ARTIFACTS = Object.freeze({
+  imessage: {
+    file: "imsg-darwin-arm64.gz",
+    sha256: "46c4c73c81c7db2d516c2d467c66aff03c73de196996d646bc8afce0ea85cff6",
+    bytes: 4525960,
+    compressedSha256: "12861bdb93779405f7cc4cb4a47fc1d6ea3bf2fc8cec5ed69f2197ce96804532",
+    compressedBytes: 1490956
+  },
+  whatsapp: {
+    file: "wacli-darwin-arm64.gz",
+    sha256: "9b77ffb810d028fde725ca02b1451f1725b5ff5312a46a54468a9a38533d4cea",
+    bytes: 21963810,
+    compressedSha256: "1c1650d6c79b74db7f8f335b4746398c802031260a90468312dcaac0374a5166",
+    compressedBytes: 7682949
+  },
+  phoneMetadata: {
+    file: "phone-number-metadata.json.gz",
+    sha256: "cbfe80ee5ee9901f46893a4d2c353d5eb513a21e62529ee5dfaa4e94b4460d83",
+    bytes: 365770,
+    compressedSha256: "27c5818bae151e945f0047fdc5a73f87a44ba678a4eb7343d1f56ef8a2b77e6f",
+    compressedBytes: 51131
+  },
+  phonePrivacy: {
+    file: "phone-number-privacy.plist.gz",
+    sha256: "561040f7a52952f75d02d4b6758382ff48c563d6f25c84a09f1a655f6dc60ff8",
+    bytes: 372,
+    compressedSha256: "83585010417bc61a2262f3c051eba0ab275987b02c824184c556f98412db4405",
+    compressedBytes: 240
+  },
+  phoneInfo: {
+    file: "phone-number-info.plist.gz",
+    sha256: "161f6c4a3ceaee9ab2ce30e33c80e605a11e196c53e9791f87341e01bf80d7e9",
+    bytes: 532,
+    compressedSha256: "6b41b44fe783ea873ef4a4a90bad1f554f474c0dc46735a95f41ff1f5bfb0729",
+    compressedBytes: 287
+  }
+});
+
+// src/providers/messaging-native-install.ts
+var sha = (bytes) => createHash("sha256").update(bytes).digest("hex");
+var resources = [
+  ["phoneMetadata", "Contents/Resources/PhoneNumberMetadata.json"],
+  ["phonePrivacy", "Contents/Resources/PrivacyInfo.xcprivacy"],
+  ["phoneInfo", "Contents/Info.plist"]
+];
+async function readBundledMessagingAsset(asset) {
+  const expected = MESSAGING_NATIVE_ARTIFACTS[asset];
+  const candidates = [new URL(`../assets/messaging-runtime/${expected.file}`, import.meta.url), new URL(`../src/assets/messaging-runtime/${expected.file}`, import.meta.url)];
+  for (const candidate of candidates) {
+    const path = fileURLToPath(candidate);
+    let handle;
+    try {
+      handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    } catch (error) {
+      if (error.code === "ENOENT")
+        continue;
+      throw new Error("Bundled messaging asset is unreadable");
+    }
+    try {
+      const before = await handle.stat();
+      if (!before.isFile() || before.size !== expected.compressedBytes || before.size > 32 * 1024 * 1024 || (before.mode & 18) !== 0 || ![0, process.getuid?.()].includes(before.uid) || await realpath(path) !== path)
+        throw new Error("Bundled messaging asset has unsafe metadata");
+      const compressed = await handle.readFile(), after = await handle.stat();
+      if (before.dev !== after.dev || before.ino !== after.ino || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs || compressed.length !== expected.compressedBytes || sha(compressed) !== expected.compressedSha256)
+        throw new Error("Bundled messaging asset changed or failed its digest");
+      const bytes = gunzipSync(compressed, { maxOutputLength: expected.bytes });
+      if (bytes.length !== expected.bytes || sha(bytes) !== expected.sha256)
+        throw new Error("Bundled messaging executable or resource failed its exact pin");
+      return bytes;
+    } finally {
+      await handle.close();
+    }
+  }
+  throw new Error("The installed package omitted its pinned messaging runtime");
+}
+async function verifyResource(path, asset) {
+  const expected = MESSAGING_NATIVE_ARTIFACTS[asset], handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+  try {
+    const info = await handle.stat();
+    if (!info.isFile() || info.nlink !== 1 || info.uid !== process.getuid?.() || (info.mode & 511) !== 384 || info.size !== expected.bytes || await realpath(path) !== path || sha(await handle.readFile()) !== expected.sha256)
+      throw new Error("Installed iMessage resource differs from its pin");
+  } finally {
+    await handle.close();
+  }
+}
+async function verifyImsgNativeResources(installDirectory) {
+  for (const [asset, relative] of resources)
+    await verifyResource(join(installDirectory, "PhoneNumberKit_PhoneNumberKit.bundle", relative), asset);
+}
+async function ensureImsgNativeResources(installDirectory, environment) {
+  for (const [asset, relative] of resources) {
+    const path = join(installDirectory, "PhoneNumberKit_PhoneNumberKit.bundle", relative), parent = dirname(path);
+    ensurePrivateStateDirectory(parent, environment);
+    try {
+      await lstat(path);
+      await verifyResource(path, asset);
+      continue;
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+    }
+    const bytes = await readBundledMessagingAsset(asset), temporary = join(parent, `.install-${randomBytes(16).toString("hex")}`);
+    const handle = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
+    try {
+      try {
+        await handle.writeFile(bytes);
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+      try {
+        await link(temporary, path);
+      } catch (error) {
+        if (error.code !== "EEXIST")
+          throw error;
+      }
+    } finally {
+      await unlink(temporary);
+    }
+    await verifyResource(path, asset);
+    const directory = await open(parent, constants.O_RDONLY);
+    try {
+      await directory.sync();
+    } finally {
+      await directory.close();
+    }
+  }
+}
+async function installBundledMessagingRuntime(provider, environment = process.env) {
+  if (process.platform !== "darwin" || process.arch !== "arm64")
+    throw new Error("Bundled messaging runtimes require Apple silicon macOS");
+  if (provider !== "imessage" && provider !== "whatsapp")
+    throw new Error("Unknown messaging runtime");
+  const bytes = await readBundledMessagingAsset(provider), directory = await mkdtemp(join(await realpath(tmpdir()), "wrench-messaging-install-"));
+  await chmod(directory, 448);
+  const path = join(directory, "runtime"), file = await open(path, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW, 320);
+  try {
+    try {
+      await file.writeFile(bytes);
+      await file.sync();
+    } finally {
+      await file.close();
+    }
+    if (provider === "imessage") {
+      const { installReviewedImsgBinary } = await import("./imessage-direct-install-2gm3kge7.js");
+      const result = await installReviewedImsgBinary(path, environment);
+      return { version: result.version, sha256: result.executableSha256, alreadyPresent: result.alreadyPresent };
+    }
+    const { installReviewedWhatsAppAutomationBinary } = await import("./whatsapp-automation-runtime-hgh1e9rm.js");
+    return await installReviewedWhatsAppAutomationBinary(path, environment);
+  } finally {
+    await unlink(path);
+    await rmdir(directory);
+  }
+}
+
+export { readBundledMessagingAsset, verifyImsgNativeResources, ensureImsgNativeResources, installBundledMessagingRuntime };

package/dist/{index-cytf8d9p.js → index-hfbygww8.js}

@@ -1,5 +1,5 @@
 // @bun
 // src/version.ts
-var GHOSTGET_VERSION = "0.17.6";
+var GHOSTGET_VERSION = "0.18.2";
 
 export { GHOSTGET_VERSION };