@kingcrab/pi-imessage 0.0.43 → 1.1.0

package/dist/agent/scheduling.js

@@ -0,0 +1,291 @@
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { configure, defineDoc, defineExtension, defineTask, } from "@earendil-works/pi-durable";
+import { ScheduledOutbox, validateSchedules } from "../extensions/schedules.js";
+import { compactChats } from "./compaction.js";
+import { dailyTime, localDate, nextDaily } from "./time.js";
+export { ScheduledOutbox };
+const SIX_HOURS = 6 * 3600000;
+export const EXECUTION_KIND = "imessage.scheduled-execution";
+export const Schedules = defineDoc({
+    kind: "imessage.schedules",
+    version: 1,
+    scope: "session",
+    initial: () => ({ items: [] }),
+    checkpointWhen: () => false,
+});
+export const RunRequests = defineDoc({
+    kind: "imessage.schedule-requests",
+    version: 1,
+    scope: "session",
+    initial: () => ({ items: [] }),
+    checkpointWhen: () => false,
+});
+function nextAt(schedule, previous, now) {
+    if (schedule.time !== undefined)
+        return nextDaily(schedule.time, now);
+    const interval = schedule.intervalMs ?? SIX_HOURS;
+    return previous + (Math.max(0, Math.floor((now - previous) / interval)) + 1) * interval;
+}
+/** Durable owns cadence and execution receipts; extensions own business tasks and documents. */
+export function schedulingExtension(harness, defaults) {
+    let admissionReady = true;
+    const Execution = defineTask({
+        name: EXECUTION_KIND,
+        version: 2,
+        initial: () => ({ phase: "start" }),
+        phases: {
+            async start(task, runtime, context) {
+                const schedule = (await runtime.snapshot(Schedules, context))?.items.find((item) => item.id === task.input.jobId);
+                if (!schedule)
+                    throw new Error("Scheduled job is missing");
+                if (schedule.id === "compact-chats") {
+                    let admissionFailures = 0;
+                    const tasks = await compactChats(harness, () => admissionFailures++);
+                    await runtime.commit(() => ({ status: "running", checkpoint: { phase: "compact", tasks, admissionFailures } }), context);
+                    return;
+                }
+                const definition = schedule.execution && runtime.registry.task(schedule.execution);
+                if (!definition)
+                    throw new Error(`Missing scheduled task definition: ${schedule.execution}`);
+                await runtime.commit(async (tx) => {
+                    const execution = await tx.createTask(definition, { ...task.input, config: schedule.input ?? null, chatGuid: schedule.chatGuid ?? null }, { ownership: { kind: "task", taskId: task.id } });
+                    return {
+                        status: "waiting",
+                        checkpoint: { phase: "execute", execution },
+                        on: [execution],
+                        policy: "allSettled",
+                    };
+                }, context);
+            },
+            async execute(task, runtime, context) {
+                const receipt = await runtime.waitForTask(task.state.checkpoint.execution, context);
+                await runtime.commit(() => ({ status: "terminal", outcome: receipt.state.outcome }), context);
+            },
+            async compact(task, runtime, context) {
+                const receipts = await Promise.all(task.state.checkpoint.tasks.map((id) => runtime.waitForTask(id, context)));
+                const failed = task.state.checkpoint.admissionFailures +
+                    receipts.filter((receipt) => receipt.state.outcome.status !== "completed").length;
+                await runtime.commit(() => ({
+                    status: "terminal",
+                    outcome: failed
+                        ? { status: "failed", error: { message: `${failed} scheduled compaction(s) failed` } }
+                        : {
+                            status: "completed",
+                            result: {
+                                summary: `${receipts.length} native compaction(s) completed; includes no-ops`,
+                                finishedAt: runtime.now(),
+                            },
+                        },
+                }), context);
+            },
+        },
+        async abort(_task, runtime, context) {
+            await runtime.commit(() => ({ status: "terminal", outcome: { status: "aborted" } }), context);
+        },
+    });
+    const Scheduler = defineTask({
+        name: "imessage.schedule",
+        version: 2,
+        migrate(input, checkpoint) {
+            return { input: input, checkpoint: checkpoint };
+        },
+        initial: (input) => ({ phase: "sleep", at: input.firstAt }),
+        phases: {
+            async sleep(task, runtime, context) {
+                const { at } = task.state.checkpoint;
+                // A sleeping task resumes this phase at the same checkpoint once it is due.
+                if (runtime.now() < at)
+                    return runtime.sleepUntil(at, task.state.checkpoint, context);
+                // Due-now work must not start between the configuration commit and registry publication.
+                if (!admissionReady)
+                    return runtime.sleepUntil(runtime.now() + 100, task.state.checkpoint, context);
+                await runtime.commit(async (tx) => {
+                    const schedule = (await tx.doc(Schedules)).items.find((item) => item.id === task.input.jobId);
+                    if (!schedule)
+                        throw new Error("Scheduled job is missing");
+                    if (task.input.requestId &&
+                        !(await tx.doc(RunRequests)).items.find((item) => item.id === task.input.requestId)?.enabled)
+                        return { status: "terminal", outcome: { status: "completed", result: null } };
+                    const now = runtime.now();
+                    const beforeToday = schedule.time !== undefined && now < dailyTime(schedule.time, now);
+                    if (!schedule.enabled)
+                        return task.input.requestId
+                            ? { status: "terminal", outcome: { status: "completed", result: null } }
+                            : { status: "running", checkpoint: { phase: "sleep", at: nextAt(schedule, at, now) } };
+                    if (!task.input.requestId && beforeToday)
+                        return { status: "running", checkpoint: { phase: "sleep", at: nextAt(schedule, at, now) } };
+                    // All triggers of a job share its non-overlap boundary.
+                    for (const status of ["pending", "running", "waiting", "sleeping", "completing"]) {
+                        const existing = (await tx.scanTasks({ conversationId: schedule.conversationId, kind: EXECUTION_KIND, status }, 1)).items[0];
+                        if (existing)
+                            return {
+                                status: "waiting",
+                                checkpoint: {
+                                    phase: task.input.requestId ? "retry" : "advance",
+                                    at,
+                                    execution: existing.id,
+                                },
+                                on: [existing.id],
+                                policy: "allSettled",
+                            };
+                    }
+                    const execution = await tx.createTask(Execution, {
+                        jobId: schedule.id,
+                        dueAt: at,
+                        startedAt: now,
+                        date: localDate(now),
+                        ...(task.input.requestId ? { requestId: task.input.requestId } : {}),
+                    }, { ownership: { kind: "task", taskId: task.id } });
+                    return {
+                        status: "waiting",
+                        checkpoint: { phase: "advance", at, execution },
+                        on: [execution],
+                        policy: "allSettled",
+                    };
+                }, context);
+            },
+            async retry(task, runtime, context) {
+                await runtime.commit(() => ({ status: "running", checkpoint: { phase: "sleep", at: task.state.checkpoint.at } }), context);
+            },
+            async advance(task, runtime, context) {
+                if (task.input.requestId) {
+                    await runtime.commit(() => ({ status: "terminal", outcome: { status: "completed", result: null } }), context);
+                    return;
+                }
+                await runtime.commit(async (tx) => {
+                    const schedule = (await tx.doc(Schedules)).items.find((item) => item.id === task.input.jobId);
+                    if (!schedule)
+                        throw new Error("Scheduled job is missing");
+                    const execution = await tx.task(task.state.checkpoint.execution);
+                    const outcome = execution?.state.outcome;
+                    const result = outcome?.status === "completed" ? outcome.result : undefined;
+                    const finishedAt = result &&
+                        typeof result === "object" &&
+                        !Array.isArray(result) &&
+                        typeof result.finishedAt === "number"
+                        ? result.finishedAt
+                        : runtime.now();
+                    return {
+                        status: "running",
+                        checkpoint: { phase: "sleep", at: nextAt(schedule, task.state.checkpoint.at, finishedAt) },
+                    };
+                }, context);
+            },
+        },
+        async abort(_task, runtime, context) {
+            await runtime.commit(() => ({ status: "terminal", outcome: { status: "aborted" } }), context);
+        },
+    });
+    return {
+        extension: defineExtension({ name: "scheduling", tasks: [Scheduler, Execution] }),
+        /** May join a host reload commit. Existing task IDs and absolute deadlines are never reset. */
+        async initialize(extensions, transaction, publish) {
+            validateSchedules(extensions);
+            const timezone = new Intl.DateTimeFormat().resolvedOptions().timeZone;
+            const initialize = async (tx) => {
+                const state = await tx.doc(Schedules);
+                const definitions = [
+                    {
+                        id: "compact-chats",
+                        name: "Chat compaction",
+                        kind: "compaction",
+                        enabled: true,
+                        intervalMs: SIX_HOURS,
+                        timezone,
+                        extension: "scheduling",
+                    },
+                    ...extensions.flatMap((extension) => (extension.schedules ?? []).map(({ task, initialize, ...schedule }) => ({
+                        ...schedule,
+                        kind: schedule.kind ?? "custom",
+                        extension: extension.name,
+                        execution: task,
+                        timezone,
+                        initialize,
+                    }))),
+                ];
+                for (const { initialize: initializeBusiness, ...definition } of definitions) {
+                    const found = state.items.find((item) => item.id === definition.id);
+                    if (found) {
+                        // Clear old cadence when an extension switches between daily and interval scheduling.
+                        delete found.time;
+                        delete found.intervalMs;
+                        delete found.input;
+                        delete found.chatGuid;
+                        Object.assign(found, definition);
+                        await initializeBusiness?.(tx, found.conversationId);
+                        continue;
+                    }
+                    const conversation = await tx.createConversation({ ownership: { kind: "ownerless" } });
+                    await configure(tx, conversation.id, { ...defaults, extensions: [], tools: [] });
+                    await initializeBusiness?.(tx, conversation.id);
+                    const firstAt = definition.time !== undefined
+                        ? nextDaily(definition.time, Date.now())
+                        : Date.now() + (definition.intervalMs ?? SIX_HOURS);
+                    const taskId = await tx.createTask(Scheduler, { jobId: definition.id, firstAt }, { conversationId: conversation.id, ownership: { kind: "conversation" }, background: true });
+                    state.items.push({ ...definition, conversationId: conversation.id, taskId });
+                }
+                const ids = new Set(definitions.map((definition) => definition.id));
+                for (const item of state.items)
+                    if (!ids.has(item.id))
+                        item.enabled = false;
+                const requests = await tx.doc(RunRequests);
+                for (const extension of extensions)
+                    for (const request of extension.runRequests ?? []) {
+                        const existing = requests.items.find((item) => item.id === request.id);
+                        if (existing) {
+                            if (existing.jobId !== request.scheduleId || existing.requestedAt !== request.at)
+                                throw new Error(`Run request ID already used with different configuration: ${request.id}`);
+                            existing.enabled = true;
+                            continue;
+                        }
+                        const schedule = state.items.find((item) => item.id === request.scheduleId);
+                        if (!schedule?.enabled)
+                            throw new Error("Run request target is unavailable");
+                        if (schedule.manualRuns?.[request.id])
+                            throw new Error("Run request ID belongs to a historical operator run");
+                        const at = request.at === "now" ? Date.now() : request.at;
+                        const taskId = await tx.createTask(Scheduler, { jobId: schedule.id, firstAt: at, requestId: request.id }, {
+                            conversationId: schedule.conversationId,
+                            ownership: { kind: "conversation" },
+                            background: true,
+                        });
+                        requests.items.push({
+                            id: request.id,
+                            jobId: schedule.id,
+                            requestedAt: request.at,
+                            at,
+                            taskId,
+                            enabled: true,
+                        });
+                    }
+                const declaredRequests = new Set(extensions.flatMap((extension) => (extension.runRequests ?? []).map((request) => request.id)));
+                for (const request of requests.items)
+                    if (!declaredRequests.has(request.id))
+                        request.enabled = false;
+            };
+            admissionReady = false;
+            try {
+                if (transaction)
+                    await initialize(transaction);
+                else
+                    await harness.commit(initialize, BACKGROUND_CONTEXT);
+                publish?.();
+            }
+            finally {
+                admissionReady = true;
+            }
+        },
+    };
+}
+/** Reuse at-most-once direct-send receipts; never retry unknown external effects. */
+export async function deliverScheduled(harness, send, enabled) {
+    for (const item of (await harness.snapshot(ScheduledOutbox, BACKGROUND_CONTEXT))?.items ?? []) {
+        if (!enabled(item.chatGuid))
+            continue;
+        await send(item);
+        await harness.commit(async (tx) => {
+            const outbox = await tx.doc(ScheduledOutbox);
+            outbox.items = outbox.items.filter((queued) => queued.requestId !== item.requestId);
+        }, BACKGROUND_CONTEXT);
+    }
+}

package/dist/agent/time.js

@@ -0,0 +1,18 @@
+/** Calendar dates follow the service process timezone, including an explicit TZ override. */
+export function localDate(timestamp) {
+    const date = new Date(timestamp);
+    return [date.getFullYear(), date.getMonth() + 1, date.getDate()]
+        .map((value, index) => String(value).padStart(index === 0 ? 4 : 2, "0"))
+        .join("-");
+}
+/** Date applies local daylight-saving rules: shift gaps forward and choose the first repeated time. */
+export function dailyTime(time, timestamp, dayOffset = 0) {
+    const date = new Date(timestamp);
+    const [hours, minutes] = time.split(":").map(Number);
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate() + dayOffset, hours, minutes).getTime();
+}
+/** Advance by a calendar day, which need not be 24 elapsed hours. */
+export function nextDaily(time, after) {
+    const today = dailyTime(time, after);
+    return today > after ? today : dailyTime(time, after, 1);
+}

package/dist/cli.js

@@ -1,199 +1,96 @@
-#!/usr/bin/env node
-/**
- * CLI entry point — handles launchd service management and foreground run.
- *
- * Usage:
- *   pi-imessage              Run in foreground
- *   pi-imessage install      Install + start launchd service (auto-starts on boot)
- *   pi-imessage uninstall    Stop + remove launchd service
- *   pi-imessage start        Start the service
- *   pi-imessage stop         Stop the service
- *   pi-imessage restart      Restart the service
- *   pi-imessage logs         Tail service logs
- */
-import { execSync, fork } from "node:child_process";
-import { existsSync, mkdirSync, unlinkSync, writeFileSync } from "node:fs";
-import { createRequire } from "node:module";
+#!/usr/bin/env -S node --use-env-proxy --experimental-strip-types
+import { realpathSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { join } from "node:path";
-const { version } = createRequire(import.meta.url)("../package.json");
-const LABEL = "com.kingcrab.pi-imessage";
-const PLIST_PATH = join(homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
-const WORKING_DIR = process.env.WORKING_DIR || join(homedir(), ".pi", "imessage");
-const WEB_HOST = process.env.WEB_HOST || "localhost";
-const WEB_PORT = process.env.WEB_PORT || "7750";
-const WEB_ENABLED = process.env.WEB_ENABLED || "true";
-const LOG_DIR = join(WORKING_DIR, "logs");
-const MAIN_JS = join(import.meta.dirname, "main.js");
-function getNodePath() {
-    try {
-        return execSync("which node", { encoding: "utf-8" }).trim();
-    }
-    catch {
-        return "/usr/local/bin/node";
+import { join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { parseEnv } from "node:util";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { startApplication } from "./main.js";
+import { createMessageSender } from "./transport/send.js";
+export async function main(args = process.argv.slice(2)) {
+    if (args.includes("--help") || args[0] === "help") {
+        console.log("pi-imessage [serve]\npi-imessage install (write launchd job only)\nSee ops/README.md for operator-only installation, deployment and restart.");
+        return;
     }
-}
-function buildPlist() {
-    const nodePath = getNodePath();
-    const stdoutLog = join(LOG_DIR, "stdout.log");
-    const stderrLog = join(LOG_DIR, "stderr.log");
-    return `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>Label</key>
-	<string>${LABEL}</string>
-	<key>ProgramArguments</key>
-	<array>
-		<string>${nodePath}</string>
-		<string>${MAIN_JS}</string>
-	</array>
-	<key>RunAtLoad</key>
-	<true/>
-	<key>KeepAlive</key>
-	<true/>
-	<key>StandardOutPath</key>
-	<string>${stdoutLog}</string>
-	<key>StandardErrorPath</key>
-	<string>${stderrLog}</string>
-	<key>EnvironmentVariables</key>
-	<dict>
-		<key>PATH</key>
-		<string>/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin</string>
-		<key>WORKING_DIR</key>
-		<string>${WORKING_DIR}</string>
-		<key>WEB_HOST</key>
-		<string>${WEB_HOST}</string>
-		<key>WEB_PORT</key>
-		<string>${WEB_PORT}</string>
-		<key>WEB_ENABLED</key>
-		<string>${WEB_ENABLED}</string>
-	</dict>
-</dict>
-</plist>`;
-}
-function isLoaded() {
     try {
-        execSync(`launchctl list ${LABEL}`, { stdio: "pipe" });
-        return true;
+        // Like the old dotenv entry point: cwd .env, with existing environment values taking priority.
+        for (const [name, value] of Object.entries(parseEnv(await readFile(process.env.DOTENV_CONFIG_PATH ?? ".env", "utf8"))))
+            if (process.env[name] === undefined && value !== undefined)
+                process.env[name] = value;
     }
-    catch {
-        return false;
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw new Error("Unable to load environment configuration", { cause: error });
     }
-}
-function install() {
-    mkdirSync(LOG_DIR, { recursive: true });
-    writeFileSync(PLIST_PATH, buildPlist(), "utf-8");
-    console.log(`[pi-imessage] Wrote ${PLIST_PATH}`);
-    if (isLoaded()) {
-        execSync(`launchctl unload ${PLIST_PATH}`, { stdio: "inherit" });
-    }
-    execSync(`launchctl load ${PLIST_PATH}`, { stdio: "inherit" });
-    console.log("[pi-imessage] Service installed and started (auto-starts on boot)");
-}
-function uninstall() {
-    if (isLoaded()) {
-        execSync(`launchctl unload ${PLIST_PATH}`, { stdio: "inherit" });
-        console.log("[pi-imessage] Service stopped");
-    }
-    if (existsSync(PLIST_PATH)) {
-        unlinkSync(PLIST_PATH);
-        console.log(`[pi-imessage] Removed ${PLIST_PATH}`);
-    }
-    console.log("[pi-imessage] Service uninstalled");
-}
-function start() {
-    if (!existsSync(PLIST_PATH)) {
-        console.error("[pi-imessage] Service not installed. Run 'pi-imessage install' first.");
-        process.exit(1);
-    }
-    if (!isLoaded()) {
-        execSync(`launchctl load ${PLIST_PATH}`, { stdio: "inherit" });
-    }
-    execSync(`launchctl start ${LABEL}`, { stdio: "inherit" });
-    console.log("[pi-imessage] Service started");
-}
-function stop() {
-    if (!isLoaded()) {
-        console.log("[pi-imessage] Service is not running");
+    const workingDir = resolve(process.env.WORKING_DIR ?? join(homedir(), ".pi", "imessage"));
+    const agentDir = resolve(getAgentDir());
+    if (args[0] === "install") {
+        const directory = join(homedir(), "Library", "LaunchAgents");
+        await mkdir(directory, { recursive: true });
+        await mkdir(workingDir, { recursive: true, mode: 0o700 });
+        const xml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+        const path = join(directory, "org.pi-imessage.service.plist");
+        const environment = [
+            "WEB_HOST",
+            "WEB_PORT",
+            "WEB_ENABLED",
+            "MESSAGES_DB_PATH",
+            "BRAVE_API_KEY",
+            "BRAVE_SEARCH_API_KEY",
+            "HTTP_PROXY",
+            "HTTPS_PROXY",
+            "NO_PROXY",
+            "http_proxy",
+            "https_proxy",
+            "no_proxy",
+            "NODE_OPTIONS",
+            "TZ",
+            "DOTENV_CONFIG_PATH",
+        ]
+            .filter((key) => process.env[key] !== undefined)
+            .map((key) => `<key>${key}</key><string>${xml(process.env[key] ?? "")}</string>`)
+            .join("");
+        await writeFile(path, `<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"><plist version="1.0"><dict><key>Label</key><string>org.pi-imessage.service</string><key>ProgramArguments</key><array><string>${xml(process.execPath)}</string><string>--use-env-proxy</string><string>--experimental-strip-types</string><string>${xml(fileURLToPath(import.meta.url))}</string><string>serve</string></array><key>WorkingDirectory</key><string>${xml(process.cwd())}</string><key>EnvironmentVariables</key><dict><key>PI_CODING_AGENT_DIR</key><string>${xml(agentDir)}</string><key>WORKING_DIR</key><string>${xml(workingDir)}</string><key>PATH</key><string>${xml(process.env.PATH ?? "/usr/bin:/bin")}</string>${environment}</dict><key>RunAtLoad</key><true/><key>KeepAlive</key><true/><key>StandardOutPath</key><string>${xml(join(workingDir, "service.log"))}</string><key>StandardErrorPath</key><string>${xml(join(workingDir, "service.log"))}</string></dict></plist>`, { flag: "wx", mode: 0o600 });
+        console.log(`Wrote ${path}. Not loaded. Follow ops/README.md for controller handover; never run two services.`);
         return;
     }
-    execSync(`launchctl stop ${LABEL}`, { stdio: "inherit" });
-    console.log("[pi-imessage] Service stopped");
-}
-function restart() {
-    if (isLoaded()) {
-        execSync(`launchctl unload ${PLIST_PATH}`, { stdio: "inherit" });
-        console.log("[pi-imessage] Service stopped");
-    }
-    mkdirSync(LOG_DIR, { recursive: true });
-    writeFileSync(PLIST_PATH, buildPlist(), "utf-8");
-    console.log("[pi-imessage] Regenerated plist with current env vars");
-    execSync(`launchctl load ${PLIST_PATH}`, { stdio: "inherit" });
-    console.log("[pi-imessage] Service restarted");
-}
-function logs() {
-    const stdoutLog = join(LOG_DIR, "stdout.log");
-    const stderrLog = join(LOG_DIR, "stderr.log");
-    if (!existsSync(stdoutLog) && !existsSync(stderrLog)) {
-        console.error("[pi-imessage] No logs found. Is the service installed?");
-        process.exit(1);
-    }
-    console.log("[pi-imessage] Tailing logs (Ctrl+C to stop)…\n");
-    const files = [stdoutLog, stderrLog].filter((f) => existsSync(f));
-    execSync(`tail -f ${files.join(" ")}`, { stdio: "inherit" });
-}
-function runForeground() {
-    // Fork main.js as a child so cli.ts doesn't need to import the full bot.
-    const child = fork(MAIN_JS, { stdio: "inherit" });
-    child.on("exit", (code) => process.exit(code ?? 0));
-}
-function help() {
-    console.log(`pi-imessage v${version}
-
-Usage: pi-imessage [command]
-
-Commands:
-  (none)       Run in foreground
-  install      Install + start launchd service (auto-starts on boot)
-  uninstall    Stop + remove launchd service
-  start        Start the service
-  stop         Stop the service
-  restart      Restart the service
-  logs         Tail service logs
-  help         Show this help message`);
-}
-const command = process.argv[2];
-switch (command) {
-    case "install":
-        install();
-        break;
-    case "uninstall":
-        uninstall();
-        break;
-    case "start":
-        start();
-        break;
-    case "stop":
-        stop();
-        break;
-    case "restart":
-        restart();
-        break;
-    case "logs":
-        logs();
-        break;
-    case "help":
-    case "--help":
-    case "-h":
-        help();
-        break;
-    case undefined:
-        runForeground();
-        break;
-    default:
-        console.error(`Unknown command: ${command}\n`);
-        help();
-        process.exit(1);
+    if (args.length && args[0] !== "serve")
+        throw new Error("Unknown command; see --help");
+    if (args.length > 1)
+        throw new Error("Unknown serve arguments; use workspace configuration and reload_extensions");
+    const dbPath = process.env.MESSAGES_DB_PATH ?? join(homedir(), "Library", "Messages", "chat.db");
+    // Incoming archives stay in the workspace; outgoing staging uses Messages' readable root.
+    const sender = createMessageSender({ dbPath });
+    const app = await startApplication({
+        workingDir,
+        agentDir,
+        dbPath,
+        send: sender.sendMessage,
+        sendAttachment: sender.sendAttachment,
+        onError: (error) => console.error(new Date().toISOString(), "Messaging poll failed", error),
+        web: process.env.WEB_ENABLED === "false"
+            ? false
+            : { host: process.env.WEB_HOST ?? "localhost", port: Number(process.env.WEB_PORT ?? 7750) },
+    });
+    let closing = false;
+    const stop = (signal) => {
+        if (closing)
+            return;
+        closing = true;
+        console.log(new Date().toISOString(), "Shutdown requested", { signal });
+        void app.close().then(() => {
+            console.log(new Date().toISOString(), "pi-imessage stopped");
+        }, (error) => {
+            console.error(new Date().toISOString(), "Shutdown failed", error);
+            process.exitCode = 1;
+        });
+    };
+    process.once("SIGINT", () => stop("SIGINT"));
+    process.once("SIGTERM", () => stop("SIGTERM"));
 }
-//# sourceMappingURL=cli.js.map
+if (process.argv[1] && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href)
+    void main().catch((error) => {
+        console.error(new Date().toISOString(), "Command failed", error instanceof Error ? error.message : error);
+        process.exitCode = 1;
+    });