@kingcrab/pi-imessage 0.0.43 → 1.1.0

package/dist/agent/compaction.js

@@ -0,0 +1,51 @@
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { CompactionEntry, LiveDoc, ResetEntry } from "@earendil-works/pi-durable";
+import { Chats } from "./chats.js";
+// Native compact() uses reason "manual" for both a command and a maintenance tick.
+// Record exact timer task IDs, not conversation IDs, so concurrent manual work stays visible.
+const scheduled = new WeakMap();
+/** Resolve admission before classifying: the commit may be observed before compact() returns its ID. */
+export async function takeScheduledCompaction(harness, taskId) {
+    const state = scheduled.get(harness);
+    if (!state)
+        return false;
+    await Promise.allSettled([...state.admissions]);
+    return state.tasks.delete(taskId);
+}
+/** Admit native compactions, not another summarization loop; Durable decides whether a cut is needed. */
+export async function compactChats(harness, admissionFailed) {
+    const tasks = [];
+    const chats = await harness.snapshot(Chats, BACKGROUND_CONTEXT);
+    for (const chat of chats?.items ?? []) {
+        try {
+            if ((await harness.snapshot(LiveDoc, chat.conversationId, BACKGROUND_CONTEXT))?.compactions?.length)
+                continue;
+            const conversation = await harness.conversation(chat.conversationId, BACKGROUND_CONTEXT);
+            const newest = (await conversation?.entries({}, 1, undefined, BACKGROUND_CONTEXT))?.items[0];
+            if (!conversation || !newest || CompactionEntry.is(newest) || ResetEntry.is(newest))
+                continue;
+            let state = scheduled.get(harness);
+            if (!state) {
+                state = { admissions: new Set(), tasks: new Set() };
+                scheduled.set(harness, state);
+            }
+            const quiet = state;
+            const admission = conversation.compact(undefined, BACKGROUND_CONTEXT).then((taskId) => {
+                quiet.tasks.add(taskId);
+                return taskId;
+            });
+            quiet.admissions.add(admission);
+            try {
+                tasks.push(await admission);
+            }
+            finally {
+                quiet.admissions.delete(admission);
+            }
+        }
+        catch (error) {
+            admissionFailed?.();
+            console.warn("Scheduled compaction admission failed", chat.chatGuid, error);
+        }
+    }
+    return tasks;
+}

package/dist/agent/deliver.js

@@ -0,0 +1,139 @@
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { AssistantEntry, } from "@earendil-works/pi-durable";
+import { finalReplyText } from "../extensions/final-text.js";
+import { Chats } from "./chats.js";
+import { DirectSends } from "./direct-send.js";
+import { Deliveries } from "./replies.js";
+import { RUN_RECORD, Runs, runRecord } from "./run.js";
+async function targets(harness) {
+    const chats = (await harness.snapshot(Chats, BACKGROUND_CONTEXT))?.items ?? [];
+    const runs = (await harness.snapshot(Runs, BACKGROUND_CONTEXT))?.items ?? [];
+    return [
+        ...chats,
+        ...runs.map((run) => ({
+            conversationId: run.conversationId,
+            chatGuid: run.chatGuid,
+            chat: run.chat,
+            label: "/run reply",
+        })),
+    ];
+}
+export async function recoverSending(harness) {
+    const directUnknown = await harness.commit(async (tx) => {
+        const sends = await tx.doc(DirectSends);
+        const changed = [];
+        for (const receipt of sends.requests) {
+            for (const part of ["textStatus", "fileStatus"]) {
+                if (receipt[part] !== "sending")
+                    continue;
+                receipt[part] = "unknown";
+                changed.push({ chatGuid: receipt.chatGuid, requestId: receipt.requestId, part });
+            }
+        }
+        return changed;
+    }, BACKGROUND_CONTEXT);
+    for (const { chatGuid, requestId, part } of directUnknown)
+        console.warn("Direct delivery unknown", chatGuid, requestId, part);
+    for (const { conversationId } of await targets(harness)) {
+        const unknown = await harness.commit(async (tx) => {
+            const deliveries = await tx.doc(Deliveries, conversationId);
+            const changed = [];
+            for (const [answerId, status] of Object.entries(deliveries.answers)) {
+                if (status === "sending") {
+                    deliveries.answers[answerId] = "unknown";
+                    changed.push(answerId);
+                }
+            }
+            return changed;
+        }, BACKGROUND_CONTEXT);
+        for (const answerId of unknown)
+            console.warn("Reply delivery unknown", conversationId, answerId);
+    }
+}
+/** Returns false when the answer must wait for an earlier in-flight send. */
+async function deliverAnswer(harness, storage, target, answerId, send) {
+    const { conversationId } = target;
+    const claim = await harness.commit(async (tx) => {
+        const entry = await tx.entry(AssistantEntry, answerId);
+        const text = finalReplyText(entry?.model?.[0]);
+        const deliveries = await tx.doc(Deliveries, conversationId);
+        const key = String(answerId);
+        const decided = () => {
+            if (deliveries.scanned === undefined || deliveries.scanned < answerId)
+                deliveries.scanned = answerId;
+            return true;
+        };
+        if (!text || deliveries.answers[key] || deliveries.drafts?.[key])
+            return { decided: decided() };
+        // The owning Session serializes admission with this claim. Read committed native submissions,
+        // not arbitrary user entries: passive logs and /run continuation text are not new human input.
+        let intervening = false;
+        let cursor;
+        do {
+            const page = await storage.scanSubmissions({ conversationId }, 100, cursor, BACKGROUND_CONTEXT);
+            intervening = page.items.some((input) => input.type === "input" &&
+                (input.status === "queued" || (input.entry !== undefined && input.entry > answerId)));
+            cursor = page.next;
+        } while (cursor && !intervening);
+        if (intervening) {
+            deliveries.drafts ??= {};
+            deliveries.drafts[key] = { status: "held", reason: "newer_input" };
+            return { decided: decided() };
+        }
+        // Do not overtake an earlier in-flight send in this chat.
+        if (Object.values(deliveries.answers).includes("sending"))
+            return { decided: false };
+        // Finals are claimed in order, so the only earlier unsent ones are held drafts; this answer replaces them.
+        const drafts = deliveries.drafts ?? {};
+        for (const [previous, draft] of Object.entries(drafts))
+            if (draft.status === "held" && Number(previous) < answerId)
+                drafts[previous] = { status: "superseded", replacement: answerId };
+        deliveries.answers[key] = "sending";
+        return { decided: decided(), text };
+    }, BACKGROUND_CONTEXT);
+    if (!claim.text)
+        return claim.decided;
+    let status = "sent";
+    try {
+        await send(target.chatGuid, claim.text);
+    }
+    catch {
+        // A throwing transport may already have sent. Never retry it automatically.
+        status = "unknown";
+    }
+    await harness.commit(async (tx) => {
+        (await tx.doc(Deliveries, conversationId)).answers[String(answerId)] = status;
+    }, BACKGROUND_CONTEXT);
+    if (status === "unknown")
+        console.warn("Reply delivery unknown", conversationId, String(answerId));
+    if (target.chat !== undefined) {
+        // A queued write never splits a turn that is running in the chat conversation.
+        const chat = await harness.conversation(target.chat, BACKGROUND_CONTEXT);
+        await chat?.submit({
+            type: "write",
+            requestId: `${RUN_RECORD}:${answerId}`,
+            entry: runRecord(`[${target.label}, ${status}]\n${claim.text}`, Date.now()),
+        }, BACKGROUND_CONTEXT);
+    }
+    return true;
+}
+/** Sends committed final answers in order, including those a /run writes between continuations. */
+export async function deliverReplies(harness, storage, send, enabled) {
+    for (const target of await targets(harness)) {
+        if (!enabled(target.chatGuid))
+            continue;
+        const scanned = (await harness.snapshot(Deliveries, target.conversationId, BACKGROUND_CONTEXT))?.scanned;
+        const answers = [];
+        let cursor;
+        do {
+            const page = await storage.scanEntries({ conversationId: target.conversationId, ...(scanned === undefined ? {} : { minEntryId: scanned }) }, 100, cursor, BACKGROUND_CONTEXT);
+            for (const entry of page.items)
+                if (AssistantEntry.is(entry) && finalReplyText(entry.model?.[0]))
+                    answers.push(entry.id);
+            cursor = page.next;
+        } while (cursor);
+        for (const answerId of answers.reverse())
+            if (!(await deliverAnswer(harness, storage, target, answerId, send)))
+                break;
+    }
+}

package/dist/agent/direct-send.js

@@ -0,0 +1,69 @@
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { defineDoc } from "@earendil-works/pi-durable";
+/** Receipts only: no background worker or automatic retry of explicit sends. */
+export const DirectSends = defineDoc({
+    kind: "imessage.direct-sends",
+    version: 1,
+    scope: "session",
+    initial: () => ({ requests: [] }),
+    checkpointWhen: () => false,
+});
+export async function deliverDirect(harness, input, sender) {
+    const { chatGuid, requestId } = input;
+    const text = input.text || null;
+    const filePath = input.filePath || null;
+    if (!chatGuid.trim() || !requestId.trim() || (!text && !filePath))
+        throw new Error("Chat GUID, request ID and text or file path are required");
+    const accepted = await harness.commit(async (tx) => {
+        const sends = await tx.doc(DirectSends);
+        const existing = sends.requests.find((send) => send.chatGuid === chatGuid && send.requestId === requestId);
+        if (existing) {
+            if (existing.text !== text || existing.filePath !== filePath)
+                throw new Error("Send request ID was already used with different content");
+            return { claimed: false, receipt: { ...existing } };
+        }
+        const receipt = {
+            chatGuid,
+            requestId,
+            text,
+            filePath,
+            textStatus: text ? "not_attempted" : null,
+            fileStatus: filePath ? "not_attempted" : null,
+        };
+        sends.requests.push(receipt);
+        return { claimed: true, receipt: { ...receipt } };
+    }, BACKGROUND_CONTEXT);
+    if (!accepted.claimed)
+        return accepted.receipt;
+    let receipt = accepted.receipt;
+    async function setStatus(part, status) {
+        receipt = await harness.commit(async (tx) => {
+            const sends = await tx.doc(DirectSends);
+            const record = sends.requests.find((send) => send.chatGuid === chatGuid && send.requestId === requestId);
+            if (!record)
+                throw new Error("Direct send receipt is missing");
+            record[part] = status;
+            return { ...record };
+        }, BACKGROUND_CONTEXT);
+    }
+    async function attempt(part, send) {
+        await setStatus(part, "sending");
+        let status = "sent";
+        try {
+            await send();
+        }
+        catch {
+            status = "unknown";
+        }
+        await setStatus(part, status);
+        if (status === "unknown")
+            console.warn("Direct delivery unknown", chatGuid, requestId, part);
+        return status;
+    }
+    // Explicit sends are plain text, independent of automatic reply settings.
+    if (text && (await attempt("textStatus", () => sender.sendMessage(chatGuid, text))) !== "sent")
+        return receipt;
+    if (filePath)
+        await attempt("fileStatus", () => sender.sendAttachment(chatGuid, filePath));
+    return receipt;
+}

package/dist/agent/harness.js

@@ -0,0 +1,79 @@
+import { mkdir, open, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { createRegistry, Harness } from "@earendil-works/pi-durable";
+import { NodeExecutionEnv } from "@earendil-works/pi-durable/env/node";
+import { openNodeJsonlStorage } from "@earendil-works/pi-durable/storage/jsonl/node";
+import { chatBehavior } from "./behavior.js";
+import { RunExtension } from "./run.js";
+export async function openHarness(workingDir, models, extensions, policy) {
+    const directory = join(workingDir, "durable");
+    await mkdir(directory, { recursive: true });
+    const lockPath = join(directory, "owner.lock");
+    // Never steal a lock: after an unclean exit the operator must confirm its owner is dead.
+    const lock = await open(lockPath, "wx");
+    try {
+        await lock.writeFile(`${process.pid}\n`);
+        const storage = await openNodeJsonlStorage(directory, BACKGROUND_CONTEXT, { fsync: true });
+        try {
+            const registry = createRegistry();
+            registry.install(chatBehavior(storage));
+            registry.install(RunExtension);
+            for (const extension of extensions) {
+                if (registry.snapshot().extension(extension.name))
+                    throw new Error(`Duplicate extension name: ${extension.name}`);
+                registry.install(extension);
+            }
+            const env = new NodeExecutionEnv({ cwd: workingDir });
+            const harness = await Harness.open(storage, 
+            // Large Codex contexts exceed WebSocket frame limits; force SSE.
+            {
+                models,
+                registry,
+                env: () => env,
+                // Consume all admitted corrections at the next native boundary, not one per turn.
+                settings: {
+                    get stream() {
+                        return { ...policy.stream, transport: "sse" };
+                    },
+                    get retry() {
+                        return policy.retry;
+                    },
+                    steeringMode: "all",
+                    // Only run conversations select the run extension; reread so reinstalls apply.
+                    get extensions() {
+                        return registry
+                            .snapshot()
+                            .installed()
+                            .filter((extension) => extension.name !== RunExtension.name);
+                    },
+                },
+            }, BACKGROUND_CONTEXT);
+            let closing;
+            return {
+                harness,
+                storage,
+                registry,
+                close(beforeUnlock) {
+                    closing ??= (async () => {
+                        await harness.close(BACKGROUND_CONTEXT);
+                        // External browser resources must be closed before another owner can resume this workspace.
+                        await beforeUnlock?.();
+                        await lock.close();
+                        await unlink(lockPath);
+                    })();
+                    return closing;
+                },
+            };
+        }
+        catch (error) {
+            await storage.close(BACKGROUND_CONTEXT);
+            throw error;
+        }
+    }
+    catch (error) {
+        await lock.close();
+        await unlink(lockPath);
+        throw error;
+    }
+}

package/dist/agent/health.js

@@ -0,0 +1,33 @@
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { configure, defineDoc } from "@earendil-works/pi-durable";
+/** Retained metadata for read-only inspection of historical isolated conversations. */
+export const Sessions = defineDoc({
+    kind: "imessage.sessions",
+    version: 1,
+    scope: "session",
+    initial: () => ({ items: [] }),
+    checkpointWhen: () => false,
+});
+/** Explicit health checks reuse one tool-less conversation and never deliver to a chat. */
+export async function submitHealth(harness, defaults) {
+    const key = JSON.stringify(["health", "model-health"]);
+    const id = await harness.commit(async (tx) => {
+        const sessions = await tx.doc(Sessions);
+        const found = sessions.items.find((item) => item.key === key);
+        const id = found?.conversationId ?? (await tx.createConversation({ ownership: { kind: "ownerless" } })).id;
+        await configure(tx, id, { ...defaults, tools: [], instructions: "Reply OK. Do not use tools." });
+        if (!found)
+            sessions.items.push({
+                key,
+                label: "model-health",
+                conversationId: id,
+                chatGuid: "health",
+                deliver: false,
+            });
+        return id;
+    }, BACKGROUND_CONTEXT);
+    const conversation = await harness.conversation(id, BACKGROUND_CONTEXT);
+    if (!conversation)
+        throw new Error("Model health conversation missing");
+    return conversation.submit({ type: "input", content: "Reply OK.", requestId: crypto.randomUUID(), whenBusy: "followUp" }, BACKGROUND_CONTEXT);
+}

package/dist/agent/models.js

@@ -0,0 +1,69 @@
+import { join } from "node:path";
+import { ModelRuntime, SettingsManager } from "@earendil-works/pi-coding-agent";
+export function openModels(agentDir) {
+    return ModelRuntime.create({
+        authPath: join(agentDir, "auth.json"),
+        modelsPath: join(agentDir, "models.json"),
+    });
+}
+/** Read defaults and use only an explicitly configured, available fallback. */
+export async function readDefaults(runtime, workingDir, agentDir, policy = {}) {
+    const settings = SettingsManager.create(workingDir, agentDir);
+    const provider = settings.getDefaultProvider();
+    const modelId = settings.getDefaultModel();
+    const thinkingLevel = settings.getDefaultThinkingLevel();
+    await runtime.refresh();
+    if (provider && modelId && runtime.getModel(provider, modelId) && runtime.hasConfiguredAuth(provider))
+        return { model: { provider, modelId }, thinkingLevel };
+    const fallback = policy.fallback;
+    if (!fallback ||
+        !runtime.getModel(fallback.provider, fallback.modelId) ||
+        !runtime.hasConfiguredAuth(fallback.provider))
+        throw new Error(`Default model ${provider}/${modelId} is unavailable; no available configured fallback`);
+    console.warn(`Default model ${provider}/${modelId} unavailable; using ${fallback.provider}/${fallback.modelId}`);
+    return { model: { ...fallback }, thinkingLevel };
+}
+/** Match Pi's experimental Durable request policy; execution and retries remain native. */
+export function requestSettings(settings) {
+    return {
+        get stream() {
+            const provider = settings.getProviderRetrySettings();
+            const idle = settings.getHttpIdleTimeoutMs();
+            return {
+                timeoutMs: provider.timeoutMs ?? (idle === 0 ? 2_147_483_647 : idle),
+                maxRetryDelayMs: provider.maxRetryDelayMs,
+                ...(provider.maxRetries === undefined ? {} : { maxRetries: provider.maxRetries }),
+            };
+        },
+        get retry() {
+            return settings.getRetrySettings();
+        },
+    };
+}
+/** A live configuration getter applies tier changes to subsequent requests only. */
+export function withModelPolicy(models, policy) {
+    return new Proxy(models, {
+        get(target, key) {
+            if (key === "streamSimple") {
+                const streamSimple = (model, context, options) => {
+                    const tier = policy().codexServiceTier;
+                    if (!tier || model.provider !== "openai-codex" || !/^gpt-/.test(model.id))
+                        return target.streamSimple(model, context, options);
+                    const configured = {
+                        ...options,
+                        async onPayload(payload, payloadModel) {
+                            const current = (await options?.onPayload?.(payload, payloadModel)) ?? payload;
+                            if (typeof current !== "object" || current === null || Array.isArray(current))
+                                return current;
+                            return { ...current, service_tier: tier };
+                        },
+                    };
+                    return target.streamSimple(model, context, configured);
+                };
+                return streamSimple;
+            }
+            const value = Reflect.get(target, key, target);
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+    });
+}

package/dist/agent/progress-format.js

@@ -0,0 +1,87 @@
+/** The plain-text adapter; apps can render the same fields without parsing this text. */
+export function formatProgress(event) {
+    const prefix = event.parents.length ? `${event.parents.join("/")}/` : "";
+    const header = `[${prefix}${event.type}]`;
+    if (event.phase === "response") {
+        return `${event.success ? "✓" : "×"} ${header} ${event.name} (${(event.elapsedMs / 1000).toFixed(1)}s)`;
+    }
+    const summary = event.type === "tool" ? (event.name === "bash" ? event.commandPreview : event.summary) : undefined;
+    return `→ ${header} ${event.name}${summary ? `: ${summary}` : ""}`;
+}
+/** Screen the whole command before showing a bounded, non-clickable preview. */
+export function commandPreview(command) {
+    if (typeof command !== "string")
+        return "[command hidden]";
+    // Match a complete shell word, including concatenated quotes and escaped spaces.
+    const word = String.raw `(?:"(?:\\[\s\S]|[^"\\])*(?:"|$)|'[^']*(?:'|$)|\$\([\s\S]*\)|\x60(?:\\[\s\S]|[^\x60\\])*\x60|\\[\s\S]|[^\s;|&<>"'\\\x60])+`;
+    const key = String.raw `[\w.-]*(?:secret|token|password|passwd|credential|authorization|api[._-]?key|private[._-]?key|bearer)[\w.-]*`;
+    let maskNext = false;
+    const screened = command
+        .replace(/\\\r?\n/g, "")
+        .replace(/-----BEGIN[^\r\n]*PRIVATE KEY-----[\s\S]*?(?:-----END[^\r\n]*PRIVATE KEY-----|$)/g, "***")
+        .replace(/\b(?:sk-[a-z0-9_-]+|gh[pousr]_[a-z0-9_]+|github_pat_[a-z0-9_]+)\b/gi, "***")
+        .replace(/(https?:\/\/)[^\s/<>]+@/gi, "$1***@")
+        .replace(new RegExp(word, "g"), (argument) => {
+        if (maskNext) {
+            maskNext = false;
+            return "***";
+        }
+        const option = argument.replace(/["']/g, "");
+        if (new RegExp(`^(?:--${key}|--user|-u|bearer)$`, "i").test(option)) {
+            maskNext = true;
+            return argument;
+        }
+        // Headers can concatenate quoted/unquoted fragments in one shell word.
+        if (/\b(?:proxy-)?authorization\s*:/i.test(argument)) {
+            const quote = /^["']/.test(argument) && argument.at(-1) === argument[0] ? argument[0] : "";
+            return argument.replace(/(\b(?:proxy-)?authorization\s*:\s*)[\s\S]*/i, "$1***") + quote;
+        }
+        // Escaped JSON is an opaque shell argument; don't expose partial values.
+        if (new RegExp(String.raw `\\["']${key}\\["']\s*:`, "i").test(argument))
+            return "***";
+        return argument
+            .replace(new RegExp(String.raw `(["']${key}["']\s*:\s*)("(?:\\[\s\S]|[^"\\])*"|'[^']*'|[^\s,}\]]+)`, "gi"), (_match, prefix, value) => `${prefix}${/^["']/.test(value) ? `${value[0]}***${value[0]}` : "***"}`)
+            .replace(new RegExp(String.raw `((?:\b${key}|--user)\s*[=:]\s*)[\s\S]*`, "gi"), "$1***")
+            .replace(/(\bbearer\s+)[\s\S]*/gi, "$1***");
+    })
+        .replace(/\s+/g, " ")
+        .trim()
+        .replace(/https?:\/\/[^\s"'`<>]+/gi, (url) => url.replaceAll(":", "：").replaceAll("/", "／").replaceAll(".", "．"))
+        .replace(/\b(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+(?:com|org|net|cn|io|dev|app|co|edu|gov|uk|us)\b/gi, (host) => host.replaceAll(".", "．"));
+    const characters = Array.from(screened);
+    return characters.length > 120 ? `${characters.slice(0, 119).join("")}…` : screened;
+}
+/** Argument previews for non-bash tools; bash requests show only `commandPreview`. */
+export function argumentSummary(arguments_) {
+    return Object.entries(arguments_)
+        .filter(([key]) => key !== "timeout")
+        .map(([key, value]) => {
+        if (/secret|token|password|credential|authorization|api.?key/i.test(key))
+            return `${key}=[redacted]`;
+        if (typeof value === "number" || typeof value === "boolean")
+            return `${key}=${value}`;
+        if (typeof value === "string") {
+            if (["path", "filePath", "cwd", "query"].includes(key)) {
+                if (/secret|token|password|credential|authorization|api.?key|sk-[a-z0-9]|gh[pousr]_|github_pat_|bearer\s|https?:\/\/\S+@/i.test(value))
+                    return `${key}=[redacted]`;
+                return `${key}=${value
+                    .replace(/https?:\/\/\S+/gi, "[link omitted]")
+                    .replace(/[\r\n\t]/g, " ")
+                    .slice(0, 160)}`;
+            }
+            if (key === "url") {
+                try {
+                    const url = new URL(value);
+                    return `${key}=${url.hostname.replaceAll(".", "．")}`;
+                }
+                catch {
+                    return `${key}=[${value.length} chars]`;
+                }
+            }
+            return `${key}=[${value.length} chars]`;
+        }
+        return `${key}=[${Array.isArray(value) ? `${value.length} items` : "object"}]`;
+    })
+        .join(", ")
+        .slice(0, 400);
+}