sanook-cli 0.5.1 → 0.5.2

package/dist/context-compression.js

@@ -0,0 +1,191 @@
+const DEFAULT_TARGET_CHARS = 6_000;
+const DEFAULT_MIN_CHARS = 8_000;
+const DEFAULT_MAX_LINE_CHARS = 800;
+const IMPORTANT_RE = /\b(error|exception|fail(?:ed|ure)?|warning|warn|timeout|denied|unauthorized|traceback|panic|regression|todo|fixme)\b/i;
+const CODE_RE = /^\s*(?:import|export|function|class|interface|type|const|let|var|async|await|return|if|for|while|switch|case)\b/;
+const DIFF_RE = /^\s*(?:diff --git|@@|\+\+\+|---|\+|-)/;
+const PATH_RE = /(?:^|\s)[\w@./-]+\.(?:ts|tsx|js|jsx|mjs|cjs|json|md|py|rs|go|java|css|scss|html|yml|yaml|toml)(?::\d+)?\b/;
+const STRUCTURE_RE = /^\s*(?:#{1,6}\s|\*|-|\d+\.|["'][^"']+["']\s*:)/;
+const TOKEN_RE = /[\p{L}\p{N}_./:-]{2,}/gu;
+function clampPositive(value, fallback) {
+    return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+function tokens(line) {
+    return [...line.toLowerCase().matchAll(TOKEN_RE)].map((match) => match[0]);
+}
+function queryTokens(query) {
+    const out = new Set();
+    for (const token of tokens(query ?? '')) {
+        if (token.length >= 3)
+            out.add(token);
+        const leaf = token.split(/[/:\\]/).pop();
+        if (leaf && leaf.length >= 3)
+            out.add(leaf);
+    }
+    return out;
+}
+function shrinkLine(line, maxChars) {
+    if (line.length <= maxChars)
+        return line;
+    const head = Math.max(80, Math.floor(maxChars * 0.55));
+    const tail = Math.max(60, maxChars - head - 48);
+    return `${line.slice(0, head)} ... [line pruned ${line.length - head - tail} chars] ... ${line.slice(-tail)}`;
+}
+function addAnchors(lines, budget, fromEnd = false) {
+    const selected = new Set();
+    let chars = 0;
+    for (let step = 0; step < lines.length; step++) {
+        const index = fromEnd ? lines.length - 1 - step : step;
+        if (index < 0 || index >= lines.length)
+            break;
+        if (chars >= budget)
+            break;
+        selected.add(index);
+        chars += lines[index].length + 1;
+    }
+    return selected;
+}
+function selectedChars(lines, selected, maxLineChars) {
+    let chars = 0;
+    for (const index of selected)
+        chars += Math.min(lines[index].length, maxLineChars) + 1;
+    return chars;
+}
+function lineScores(lines, selected, query) {
+    const candidates = lines
+        .map((line, index) => ({ line, index }))
+        .filter(({ line, index }) => !selected.has(index) && line.trim());
+    const df = new Map();
+    for (const { line } of candidates) {
+        for (const token of new Set(tokens(line)))
+            df.set(token, (df.get(token) ?? 0) + 1);
+    }
+    const total = Math.max(1, candidates.length);
+    const seenLines = new Map();
+    const scores = new Map();
+    for (const { line, index } of candidates) {
+        const clean = line.trim();
+        const lineTokens = tokens(clean);
+        let score = 0;
+        for (const token of lineTokens)
+            score += Math.log((total + 1) / ((df.get(token) ?? 0) + 1));
+        score = score / Math.sqrt(Math.max(1, lineTokens.length));
+        if (query.size) {
+            let overlap = 0;
+            for (const token of new Set(lineTokens)) {
+                const leaf = token.split(/[/:\\]/).pop() ?? token;
+                if (query.has(token) || query.has(leaf))
+                    overlap += 1;
+            }
+            if (overlap)
+                score += Math.min(40, overlap * 18);
+        }
+        if (IMPORTANT_RE.test(clean))
+            score += 8;
+        if (PATH_RE.test(clean))
+            score += 5;
+        if (DIFF_RE.test(clean))
+            score += 4;
+        if (CODE_RE.test(clean))
+            score += 3;
+        if (STRUCTURE_RE.test(clean))
+            score += 2;
+        if (/https?:\/\//i.test(clean))
+            score += 2;
+        if (/^\s*[}\])],?\s*$/.test(clean))
+            score -= 1;
+        if (clean.length > 500 && !/\s/.test(clean))
+            score -= 5;
+        const repeated = seenLines.get(clean) ?? 0;
+        if (repeated)
+            score -= Math.min(8, repeated * 2);
+        seenLines.set(clean, repeated + 1);
+        scores.set(index, score);
+    }
+    return scores;
+}
+function renderSelected(lines, selected, maxLineChars) {
+    const out = [];
+    let omittedLines = 0;
+    let omittedChars = 0;
+    let gapLines = 0;
+    let gapChars = 0;
+    const flushGap = () => {
+        if (!gapLines)
+            return;
+        out.push(`... [selective context compression: omitted ${gapLines} line(s), ${gapChars} chars] ...`);
+        omittedLines += gapLines;
+        omittedChars += gapChars;
+        gapLines = 0;
+        gapChars = 0;
+    };
+    for (let index = 0; index < lines.length; index++) {
+        if (selected.has(index)) {
+            flushGap();
+            out.push(shrinkLine(lines[index], maxLineChars));
+        }
+        else {
+            gapLines += 1;
+            gapChars += lines[index].length + 1;
+        }
+    }
+    flushGap();
+    return { text: out.join('\n'), omittedLines, omittedChars };
+}
+/**
+ * Zero-LLM selective context compression inspired by Selective Context / Headroom:
+ * keep anchors plus high-information lines (errors, paths, code structure, rare terms),
+ * then preserve original order with omission markers.
+ */
+export function selectiveCompressText(input, options = {}) {
+    const originalChars = input.length;
+    const targetChars = clampPositive(options.targetChars, DEFAULT_TARGET_CHARS);
+    const minChars = clampPositive(options.minChars, DEFAULT_MIN_CHARS);
+    const maxLineChars = clampPositive(options.maxLineChars, DEFAULT_MAX_LINE_CHARS);
+    if (originalChars <= minChars || originalChars <= targetChars) {
+        return { text: input, changed: false, originalChars, compressedChars: originalChars, omittedLines: 0, omittedChars: 0 };
+    }
+    const lines = input.split(/\r?\n/);
+    if (lines.length <= 4) {
+        const text = shrinkLine(input, targetChars);
+        return {
+            text,
+            changed: text !== input,
+            originalChars,
+            compressedChars: text.length,
+            omittedLines: text === input ? 0 : 1,
+            omittedChars: Math.max(0, originalChars - text.length),
+        };
+    }
+    const headBudget = Math.min(clampPositive(options.headChars, Math.floor(targetChars * 0.18)), Math.floor(targetChars * 0.35));
+    const tailBudget = Math.min(clampPositive(options.tailChars, Math.floor(targetChars * 0.25)), Math.floor(targetChars * 0.45));
+    const selected = new Set([
+        ...addAnchors(lines, headBudget),
+        ...addAnchors(lines, tailBudget, true),
+    ]);
+    const scores = lineScores(lines, selected, queryTokens(options.query));
+    const ranked = [...scores.entries()].sort((a, b) => b[1] - a[1]);
+    let used = selectedChars(lines, selected, maxLineChars);
+    const softBudget = Math.max(400, targetChars - 600);
+    for (const [index] of ranked) {
+        const nextCost = Math.min(lines[index].length, maxLineChars) + 1;
+        if (used + nextCost > softBudget && selected.size > 0)
+            continue;
+        selected.add(index);
+        used += nextCost;
+        if (used >= softBudget)
+            break;
+    }
+    const rendered = renderSelected(lines, selected, maxLineChars);
+    if (rendered.text.length >= originalChars) {
+        return { text: input, changed: false, originalChars, compressedChars: originalChars, omittedLines: 0, omittedChars: 0 };
+    }
+    return {
+        text: rendered.text,
+        changed: true,
+        originalChars,
+        compressedChars: rendered.text.length,
+        omittedLines: rendered.omittedLines,
+        omittedChars: rendered.omittedChars,
+    };
+}

package/dist/cost.js

@@ -15,9 +15,6 @@ export const PRICING = {
     // Google Gemini (≤200k context tier)
     'google:gemini-2.5-pro': { input: 1.25, output: 10, cacheWrite: 1.25, cacheRead: 0.31 },
     'google:gemini-2.5-flash': { input: 0.3, output: 2.5, cacheWrite: 0.3, cacheRead: 0.075 },
-    // DeepSeek V4
-    'deepseek:deepseek-v4-flash': { input: 0.28, output: 0.42, cacheWrite: 0.28, cacheRead: 0.028 },
-    'deepseek:deepseek-v4-pro': { input: 0.55, output: 2.19, cacheWrite: 0.55, cacheRead: 0.055 },
     // xAI Grok
     'xai:grok-4.3': { input: 3, output: 15, cacheWrite: 3, cacheRead: 0.75 },
     // Mistral
@@ -30,6 +27,9 @@ export const PRICING = {
 export function hasPricingForKey(specKey) {
     return specKey in PRICING;
 }
+function isPricingKey(key) {
+    return /^[^:\s]+:\S+$/.test(key);
+}
 /**
  * merge pricing เพิ่ม/override (จาก config `pricing` หรือ env SANOOK_PRICING)
  * — ให้ budget cap ใช้ได้กับ provider ที่ยังไม่มีในตาราง โดยไม่ต้องแก้โค้ด
@@ -38,6 +38,8 @@ export function registerPricing(extra) {
     if (!extra)
         return;
     for (const [key, p] of Object.entries(extra)) {
+        if (!isPricingKey(key))
+            continue;
         if (p == null || typeof p !== 'object')
             continue;
         const base = PRICING[key] ?? { input: 0, output: 0, cacheWrite: 0, cacheRead: 0 };
@@ -54,17 +56,41 @@ export function registerPricing(extra) {
         PRICING[key] = next;
     }
 }
+function safeTokenCount(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0)
+        return 0;
+    return value;
+}
+export class SharedBudget {
+    budgetUsd;
+    spent = 0;
+    constructor(budgetUsd) {
+        this.budgetUsd = budgetUsd;
+    }
+    add(usd) {
+        if (Number.isFinite(usd) && usd > 0)
+            this.spent += usd;
+    }
+    get totalUsd() {
+        return this.spent;
+    }
+    get overBudget() {
+        return this.budgetUsd != null && this.spent >= this.budgetUsd;
+    }
+}
 export class CostMeter {
     specKey;
     budgetUsd;
+    sharedBudget;
     inTok = 0;
     outTok = 0;
     cacheReadTok = 0;
     cacheWriteTok = 0;
     spent = 0;
-    constructor(specKey, budgetUsd) {
+    constructor(specKey, budgetUsd, sharedBudget) {
         this.specKey = specKey;
         this.budgetUsd = budgetUsd;
+        this.sharedBudget = sharedBudget;
     }
     /**
      * บวก usage ของ 1 step. cacheWriteTokens ดึงจาก providerMetadata แยก (default 0)
@@ -72,21 +98,23 @@ export class CostMeter {
      * ไม่งั้น double-count cacheRead (cache hit จะกลายเป็นแพงกว่า no-cache)
      */
     add(usage, cacheWriteTokens = 0) {
-        const totalInput = usage.inputTokens ?? 0;
-        const output = usage.outputTokens ?? 0;
-        const cacheRead = usage.cachedInputTokens ?? 0;
-        const noCacheInput = Math.max(0, totalInput - cacheRead - cacheWriteTokens);
+        const totalInput = safeTokenCount(usage.inputTokens);
+        const output = safeTokenCount(usage.outputTokens);
+        const cacheRead = safeTokenCount(usage.cachedInputTokens);
+        const cacheWrite = safeTokenCount(cacheWriteTokens);
+        const noCacheInput = Math.max(0, totalInput - cacheRead - cacheWrite);
         this.inTok += noCacheInput;
         this.outTok += output;
         this.cacheReadTok += cacheRead;
-        this.cacheWriteTok += cacheWriteTokens;
+        this.cacheWriteTok += cacheWrite;
         const p = PRICING[this.specKey];
         if (p) {
-            this.spent +=
-                (noCacheInput / 1e6) * p.input +
-                    (output / 1e6) * p.output +
-                    (cacheRead / 1e6) * p.cacheRead +
-                    (cacheWriteTokens / 1e6) * p.cacheWrite;
+            const delta = (noCacheInput / 1e6) * p.input +
+                (output / 1e6) * p.output +
+                (cacheRead / 1e6) * p.cacheRead +
+                (cacheWrite / 1e6) * p.cacheWrite;
+            this.spent += delta;
+            this.sharedBudget?.add(delta);
         }
     }
     /** รวม token + cost จาก meter อีกตัว (เช่น primary model ก่อน fallback) — กัน usage หาย/budget reset */
@@ -96,6 +124,8 @@ export class CostMeter {
         this.cacheReadTok += other.cacheReadTok;
         this.cacheWriteTok += other.cacheWriteTok;
         this.spent += other.spent;
+        if (this.sharedBudget && this.sharedBudget !== other.sharedBudget)
+            this.sharedBudget.add(other.spent);
     }
     get totalUsd() {
         return this.spent;
@@ -105,7 +135,11 @@ export class CostMeter {
     }
     /** true เมื่อใช้เกิน budget (เช็คก่อนยิง request ถัดไป) — no-op ถ้าไม่มี pricing (เตือนที่ entry point) */
     get overBudget() {
-        return this.budgetUsd != null && this.hasPricing && this.spent >= this.budgetUsd;
+        if (this.sharedBudget?.overBudget)
+            return true;
+        if (!this.hasPricing)
+            return false;
+        return this.budgetUsd != null && this.spent >= this.budgetUsd;
     }
     summary() {
         const total = this.inTok + this.outTok + this.cacheReadTok + this.cacheWriteTok;

package/dist/first-run.js

@@ -0,0 +1,21 @@
+import { detectCodex } from './providers/codex.js';
+import { hasUsableEnvKey, parseSpec, PROVIDERS } from './providers/registry.js';
+/**
+ * First-run can skip the setup wizard only when the selected provider is genuinely
+ * ready to run: cloud providers need a policy-valid API key, local providers need
+ * no key, and delegate providers like Codex must have their official CLI auth ready.
+ */
+export async function providerCanSkipSetup(provider, detect = detectCodex) {
+    const cfg = PROVIDERS[provider];
+    if (!cfg)
+        return false;
+    if (cfg.kind === 'delegate') {
+        const s = await detect();
+        return s.installed && s.loggedIn;
+    }
+    return hasUsableEnvKey(provider);
+}
+export async function modelNeedsSetup(modelSpec, detect = detectCodex) {
+    const { provider } = parseSpec(modelSpec);
+    return !(await providerCanSkipSetup(provider, detect));
+}

package/dist/gateway/auth.js

@@ -4,19 +4,48 @@ import { randomBytes, timingSafeEqual } from 'node:crypto';
 import { appHomePath } from '../brand.js';
 const GATEWAY_DIR = appHomePath('gateway');
 const TOKEN_FILE = join(GATEWAY_DIR, 'token');
+const TOKEN_FILE_PATTERN = /^([a-f0-9]{64})(?:\r?\n)?$/;
+export async function ensureGatewayDir() {
+    await mkdir(GATEWAY_DIR, { recursive: true, mode: 0o700 });
+    await chmod(GATEWAY_DIR, 0o700).catch(() => { });
+}
 /** โหลด bearer token ของ gateway; ไม่มี → สร้าง 256-bit ใหม่ เก็บ chmod 600 */
 export async function loadOrCreateToken() {
+    for (;;) {
+        const existingToken = await readTokenIfPresent();
+        if (existingToken !== undefined)
+            return existingToken;
+        const token = randomBytes(32).toString('hex');
+        await ensureGatewayDir();
+        try {
+            await writeFile(TOKEN_FILE, `${token}\n`, { mode: 0o600, flag: 'wx' });
+        }
+        catch (e) {
+            if (e.code === 'EEXIST')
+                continue;
+            throw new Error(`ไม่สามารถเขียน gateway token ที่ ${TOKEN_FILE}: ${e.message}`);
+        }
+        await chmod(TOKEN_FILE, 0o600).catch(() => { });
+        return token;
+    }
+}
+async function readTokenIfPresent() {
+    let rawToken;
     try {
-        const t = (await readFile(TOKEN_FILE, 'utf8')).trim();
-        if (t)
-            return t;
+        rawToken = await readFile(TOKEN_FILE, 'utf8');
+    }
+    catch (e) {
+        if (e.code !== 'ENOENT') {
+            throw new Error(`ไม่สามารถอ่าน gateway token ที่ ${TOKEN_FILE}: ${e.message}`);
+        }
+        return undefined;
     }
-    catch {
-        /* ยังไม่มี → สร้างใหม่ */
+    const tokenMatch = TOKEN_FILE_PATTERN.exec(rawToken);
+    if (!tokenMatch) {
+        throw new Error(`gateway token ที่ ${TOKEN_FILE} ไม่ถูกต้อง: ต้องเป็น hex 64 ตัวอักษร`);
     }
-    const token = randomBytes(32).toString('hex');
-    await mkdir(GATEWAY_DIR, { recursive: true });
-    await writeFile(TOKEN_FILE, `${token}\n`, { mode: 0o600 });
+    const token = tokenMatch[1];
+    await chmod(GATEWAY_DIR, 0o700).catch(() => { });
     await chmod(TOKEN_FILE, 0o600).catch(() => { });
     return token;
 }

package/dist/gateway/bluebubbles.js

@@ -0,0 +1,205 @@
+import { randomUUID } from 'node:crypto';
+import { redactKey } from '../providers/keys.js';
+const BLUEBUBBLES_TEXT_LIMIT = 4_000;
+const GUID_CACHE_SIZE = 500;
+const chatGuidCache = new Map();
+function chatGuidCacheKey(config, target) {
+    return `${normalizeBlueBubblesServerUrl(config.serverUrl) ?? ''}|${target}`;
+}
+function rememberChatGuid(config, target, guid) {
+    chatGuidCache.set(chatGuidCacheKey(config, target), guid);
+    if (chatGuidCache.size <= GUID_CACHE_SIZE)
+        return;
+    const first = chatGuidCache.keys().next().value;
+    if (first)
+        chatGuidCache.delete(first);
+}
+function redactBlueBubblesDetail(raw, secrets) {
+    let safe = redactKey(raw);
+    for (const secret of secrets) {
+        const value = secret?.trim();
+        if (value)
+            safe = safe.split(value).join('<secret>');
+    }
+    return safe;
+}
+export function normalizeBlueBubblesServerUrl(raw) {
+    let value = raw?.trim();
+    if (!value)
+        return undefined;
+    if (!/^https?:\/\//i.test(value))
+        value = `http://${value}`;
+    try {
+        const url = new URL(value);
+        if (url.protocol !== 'http:' && url.protocol !== 'https:')
+            return undefined;
+        return url.toString().replace(/\/+$/, '');
+    }
+    catch {
+        return undefined;
+    }
+}
+export function normalizeBlueBubblesWebhookPath(raw) {
+    const value = raw?.trim() || '/bluebubbles-webhook';
+    return value.startsWith('/') ? value : `/${value}`;
+}
+export function blueBubblesApiUrl(config, path) {
+    const baseUrl = normalizeBlueBubblesServerUrl(config.serverUrl);
+    const password = config.password?.trim();
+    if (!baseUrl)
+        throw new Error('BlueBubbles server URL ต้องเป็น http:// หรือ https:// URL');
+    if (!password)
+        throw new Error('ยังไม่ได้ตั้ง BlueBubbles password');
+    const url = new URL(path, `${baseUrl}/`);
+    url.searchParams.set('password', password);
+    return url.toString();
+}
+export function parseBlueBubblesTarget(config, explicitTarget) {
+    const target = explicitTarget?.trim() || config.homeChannel?.trim();
+    if (!target)
+        throw new Error('ต้องระบุ BlueBubbles target หรือ home channel ใน gateway config');
+    const stripped = target.replace(/^(?:chat|guid)[:/]/i, '').trim();
+    if (!stripped || /\s/.test(stripped))
+        throw new Error('BlueBubbles target ต้องเป็น chat GUID, email, หรือเบอร์โทรที่ไม่มีช่องว่าง');
+    if (stripped.includes(';'))
+        return { value: stripped, chatGuid: stripped };
+    return { value: stripped };
+}
+export function formatBlueBubblesText(raw) {
+    return raw
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+        .replace(/^#{1,6}\s+/gm, '')
+        .replace(/`{1,3}([^`]+)`{1,3}/g, '$1')
+        .replace(/(\*\*|__)(.*?)\1/g, '$2')
+        .trim();
+}
+export function chunkBlueBubblesText(raw, limit = BLUEBUBBLES_TEXT_LIMIT) {
+    const text = formatBlueBubblesText(raw) || '(ไม่มีผลลัพธ์)';
+    const paragraphs = text.split(/\n\s*\n/).map((part) => part.trim()).filter(Boolean);
+    const chunks = [];
+    for (const paragraph of paragraphs.length ? paragraphs : [text]) {
+        if (paragraph.length <= limit) {
+            chunks.push(paragraph);
+            continue;
+        }
+        for (let index = 0; index < paragraph.length; index += limit) {
+            chunks.push(paragraph.slice(index, index + limit));
+        }
+    }
+    return chunks;
+}
+async function readBlueBubblesJsonOrThrow(response, label, secrets = []) {
+    const text = await response.text().catch(() => '');
+    if (!response.ok)
+        throw new Error(`${label} ${response.status}${text ? `: ${redactBlueBubblesDetail(text, secrets).slice(0, 240)}` : ''}`);
+    let json;
+    try {
+        json = (text ? JSON.parse(text) : {});
+    }
+    catch {
+        throw new Error(`${label} ${response.status}: response ไม่ใช่ JSON: ${redactBlueBubblesDetail(text, secrets).slice(0, 240)}`);
+    }
+    const status = typeof json.status === 'number' ? json.status : response.status;
+    if (status >= 400 || json.error) {
+        const detail = json.error?.error || json.error?.type || json.message || 'unknown error';
+        throw new Error(`${label} status ${status}: ${redactBlueBubblesDetail(detail, secrets).slice(0, 200)}`);
+    }
+    return json;
+}
+async function postBlueBubbles(config, path, body) {
+    const r = await fetch(blueBubblesApiUrl(config, path), {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    return readBlueBubblesJsonOrThrow(r, `BlueBubbles ${path}`, [config.password]);
+}
+async function getBlueBubbles(config, path) {
+    const r = await fetch(blueBubblesApiUrl(config, path));
+    return readBlueBubblesJsonOrThrow(r, `BlueBubbles ${path}`, [config.password]);
+}
+async function resolveBlueBubblesChatGuid(config, target) {
+    if (target.chatGuid)
+        return target.chatGuid;
+    const cached = chatGuidCache.get(chatGuidCacheKey(config, target.value));
+    if (cached)
+        return cached;
+    const res = await postBlueBubbles(config, '/api/v1/chat/query', {
+        limit: 100,
+        offset: 0,
+        with: ['participants'],
+    });
+    for (const chat of res.data ?? []) {
+        const guid = chat.guid || chat.chatGuid;
+        const identifier = chat.chatIdentifier || chat.identifier;
+        if (guid && identifier === target.value) {
+            rememberChatGuid(config, target.value, guid);
+            return guid;
+        }
+        for (const participant of chat.participants ?? []) {
+            if (guid && participant.address?.trim() === target.value) {
+                rememberChatGuid(config, target.value, guid);
+                return guid;
+            }
+        }
+    }
+    return undefined;
+}
+async function canCreateBlueBubblesChat(config) {
+    try {
+        const info = await getBlueBubbles(config, '/api/v1/server/info');
+        return Boolean(info.data?.private_api);
+    }
+    catch {
+        return false;
+    }
+}
+async function createBlueBubblesChat(config, target, message) {
+    const res = await postBlueBubbles(config, '/api/v1/chat/new', {
+        addresses: [target],
+        message,
+        text: message,
+        tempGuid: `temp-${randomUUID()}`,
+    });
+    const messageId = res.data?.guid || res.data?.messageGuid || 'ok';
+    return { target, messageIds: [messageId], messageCount: 1 };
+}
+function looksLikeBlueBubblesAddress(target) {
+    return target.includes('@') || /^\+\d{7,15}$/.test(target);
+}
+export async function sendBlueBubblesMessage(config, text, explicitTarget) {
+    if (!normalizeBlueBubblesServerUrl(config.serverUrl) || !config.password?.trim()) {
+        throw new Error('ยังไม่ได้ตั้ง BlueBubbles server URL/password');
+    }
+    const target = parseBlueBubblesTarget(config, explicitTarget);
+    const chunks = chunkBlueBubblesText(text);
+    const messageIds = [];
+    let chatGuid;
+    for (const chunk of chunks) {
+        chatGuid = await resolveBlueBubblesChatGuid(config, target);
+        if (!chatGuid) {
+            if (looksLikeBlueBubblesAddress(target.value) && (await canCreateBlueBubblesChat(config))) {
+                if (chunks.length > 1) {
+                    throw new Error('BlueBubbles new chat ยังไม่รองรับข้อความหลายส่วนแบบปลอดภัย — ส่งข้อความแรกให้สั้นลงหรือระบุ chat GUID ที่มีอยู่');
+                }
+                return createBlueBubblesChat(config, target.value, chunk);
+            }
+            throw new Error(`BlueBubbles chat not found for target: ${target.value}`);
+        }
+        const res = await postBlueBubbles(config, '/api/v1/message/text', {
+            chatGuid,
+            tempGuid: `temp-${randomUUID()}`,
+            message: chunk,
+            text: chunk,
+        });
+        const messageId = res.data?.guid || res.data?.messageGuid || 'ok';
+        if (messageId)
+            messageIds.push(String(messageId));
+    }
+    return {
+        target: target.value,
+        chatGuid,
+        messageIds,
+        messageCount: messageIds.length || chunks.length,
+    };
+}