import { spawn } from "node:child_process";

import {

createMessageReceiptFromOutboundResults,

type MessageReceipt,

},

) => Promise<{ path: string; contentType?: string }>;

createClient?: (params: { cliPath: string; dbPath?: string }) => Promise<IMessageRpcClient>;

runCliJson?: (args: readonly string[]) => Promise<Record<string, unknown>>;

};

export type IMessageSendResult = {

return `${params.accountId}:imessage:${params.target.to}`;

}

function buildIMessageCliJsonArgs(args: readonly string[], dbPath?: string): string[] {

const trimmedDbPath = dbPath?.trim();

return [...args, ...(trimmedDbPath ? ["--db", trimmedDbPath] : []), "--json"];

}

async function runIMessageCliJson(

cliPath: string,

dbPath: string | undefined,

args: readonly string[],

timeoutMs?: number,

): Promise<Record<string, unknown>> {

return await new Promise((resolve, reject) => {

const child = spawn(cliPath, buildIMessageCliJsonArgs(args, dbPath), {

stdio: ["ignore", "pipe", "pipe"],

});

let stdout = "";

let stderr = "";

let killEscalation: ReturnType<typeof setTimeout> | null = null;

const timer =

timeoutMs && timeoutMs > 0

? setTimeout(() => {

child.kill("SIGTERM");

killEscalation = setTimeout(() => {

try {

child.kill("SIGKILL");

} catch {

// best-effort

}

}, 2000);

reject(new Error(`iMessage action timed out after ${timeoutMs}ms`));

}, timeoutMs)

: null;

child.stdout.setEncoding("utf8");

child.stderr.setEncoding("utf8");

child.stdout.on("data", (chunk) => {

stdout += chunk;

});

child.stderr.on("data", (chunk) => {

stderr += chunk;

});

child.on("error", (error) => {

if (timer) {

clearTimeout(timer);

}

if (killEscalation) {

clearTimeout(killEscalation);

}

reject(error);

});

child.on("close", (code) => {

if (timer) {

clearTimeout(timer);

}

if (killEscalation) {

clearTimeout(killEscalation);

}

const lines = stdout

.split(/\r?\n/u)

.map((line) => line.trim())

.filter(Boolean);

const last = lines.at(-1);

let parsed: Record<string, unknown> | null = null;

if (last) {

try {

const json = JSON.parse(last) as unknown;

if (json && typeof json === "object" && !Array.isArray(json)) {

parsed = json as Record<string, unknown>;

}

} catch {

// handled below

}

}

if (code === 0 && parsed) {

resolve(parsed);

return;

}

if (parsed && typeof parsed.error === "string" && parsed.error.trim()) {

reject(new Error(parsed.error.trim()));

return;

}

const detail = stderr.trim() || stdout.trim() || `imsg exited with code ${code}`;

reject(new Error(detail));

});

});

}

function stringValue(value: unknown): string | undefined {

return typeof value === "string" && value.trim() ? value.trim() : undefined;

}

async function resolveAttachmentChatGuid(params: {

target: ReturnType<typeof parseIMessageTarget>;

runCliJson: (args: readonly string[]) => Promise<Record<string, unknown>>;

}): Promise<string | null> {

if (params.target.kind === "chat_guid") {

return params.target.chatGuid;

}

if (params.target.kind !== "chat_id") {

return null;

}

const result = await params.runCliJson(["group", "--chat-id", String(params.target.chatId)]);

return stringValue(result.guid) ?? stringValue(result.chat_guid) ?? null;

}

export async function sendMessageIMessage(

to: string,

text: string,

}

const echoText = resolveOutboundEchoText(message, filePath ? mediaContentType : undefined);

const resolvedReplyToId = sanitizeReplyToId(opts.replyToId);

const runCliJson =

opts.runCliJson ??

((args: readonly string[]) => runIMessageCliJson(cliPath, dbPath, args, opts.timeoutMs));

if (filePath && !message.trim() && !resolvedReplyToId) {

const attachmentChatGuid = await resolveAttachmentChatGuid({ target, runCliJson });

if (attachmentChatGuid) {

const result = await runCliJson([

"send-attachment",

"--chat",

attachmentChatGuid,

"--file",

filePath,

"--transport",

"auto",

]);

const resolvedId = resolveMessageId(result);

const approvalBindingMessageId = resolveOutboundMessageGuid(result);

const messageId = resolvedId ?? (result?.ok || result?.success ? "ok" : "unknown");

const echoScope = resolveOutboundEchoScope({ accountId: account.accountId, target });

if (echoScope) {

rememberPersistedIMessageEcho({

scope: echoScope,

text: echoText,

messageId: resolvedId ?? undefined,

});

}

if (resolvedId) {

rememberIMessageReplyCache({

accountId: account.accountId,

messageId: resolvedId,

chatGuid: target.kind === "chat_guid" ? target.chatGuid : attachmentChatGuid,

chatId: target.kind === "chat_id" ? target.chatId : undefined,

timestamp: Date.now(),

isFromMe: true,

});

}

return {

messageId,

...(approvalBindingMessageId ? { guid: approvalBindingMessageId } : {}),

sentText: message,

...(echoText ? { echoText } : {}),

receipt: createIMessageSendReceipt({

messageId,

target,

kind: "media",

}),

};

}

}

const params: Record<string, unknown> = {

text: message,

service: service || "auto",