Domo: a calendar agent you text

$ claude   # sign in, then /quit
$ claude auth status --json
{ "loggedIn": true, ... }

{
  "token": "<the Bearer token from activation redeem>",
  "chat_uid": "<the chat uid, cht_...>"
}

// plow-channel.ts — the bridge between Plow Chat and the Claude session.
// In:  Plow WebSocket -> channel notification into the session.
// Out: the `reply` tool -> one POST to Plow. Nothing else can text anyone.
// Also serves the web dashboard on 127.0.0.1:8848 while Domo runs.
import { appendFileSync } from "fs";
const DIR = import.meta.dir; // the domo folder
const st = JSON.parse(await Bun.file(`${DIR}/plow.json`).text()); // written by activation
const BASE = "https://api.plow.co";
const AUTH = { "Authorization": `Bearer ${st.token}`, "Content-Type": "application/json" };
const TZ = Intl.DateTimeFormat().resolvedOptions().timeZone;
const seen = new Set(); // dedup for this process. TODO(hardening): persist + backfill offline texts.
 
// Half-open WebSocket guard: Plow sends a server ping ~every 20s. If NO frame of
// any kind (data OR control ping) arrives within this window, the link is dead —
// force-close so the reconnect loop below fires. See onmessage/ping touches.
const WS_IDLE_LIMIT_MS = 60_000; // silence past this => force-close
const WS_WATCHDOG_MS   = 10_000; // how often the watchdog checks
 
function send(obj) { process.stdout.write(JSON.stringify(obj) + "\n"); }
 
function log(event) { // operational events only — never message bodies, senders, or tokens
  appendFileSync(`${DIR}/bridge.log`, `${new Date().toISOString()}  ${event}\n`);
}
 
// ==========================================================================
// THE CHANNEL: texts in, replies out.
// notify() delivers an event into the session; reply() is the only way back.
// ==========================================================================
function notify(content, meta = {}) { // a channel event: how a text "arrives" in the session
  const today = new Date().toLocaleString("en-US", { timeZone: TZ, dateStyle: "full" });
  const today_iso = new Date().toLocaleDateString("en-CA", { timeZone: TZ }); // YYYY-MM-DD, the refresh skill's date anchor
  send({
    jsonrpc: "2.0",
    method: "notifications/claude/channel",
    params: { content, meta: { chat_id: st.chat_uid, today, today_iso, ...meta } },
  });
}
 
async function reply(text) { // any 2xx from Plow is success; a thrown fetch is a failed send
  try {
    const r = await fetch(`${BASE}/v1/chats/${st.chat_uid}/messages`, {
      method: "POST",
      headers: AUTH,
      body: JSON.stringify({ body: String(text) }),
    });
    log(r.ok ? "reply sent" : `reply send failed (${r.status})`);
    return r.ok;
  } catch { log("reply send failed (network)"); return false; }
}
 
async function listen() { // mint a ticket, hold the WebSocket, deliver inbound texts
  while (true) {
    try {
      const t = await fetch(`${BASE}/v1/ws/ticket`, {
        method: "POST",
        headers: AUTH,
        body: JSON.stringify({ chat_id: st.chat_uid }),
      });
      const { ticket } = await t.json();
      const ws = new WebSocket(`wss://api.plow.co/v1/ws?ticket=${ticket}`);
      await new Promise((done) => {
        let lastRx = Date.now();                 // last time ANY frame arrived
        const touch = () => { lastRx = Date.now(); };
        const watchdog = setInterval(() => {     // half-open guard: silence => force-close => reconnect
          if (Date.now() - lastRx > WS_IDLE_LIMIT_MS) {
            log("websocket idle — force closing (half-open)");
            try { ws.close(); } catch {}
          }
        }, WS_WATCHDOG_MS);
        ws.onopen = () => { touch(); log("websocket connected"); };
        ws.addEventListener("ping", touch);      // Plow's ~20s server keepalive; NOT delivered to onmessage
        ws.addEventListener("pong", touch);
        ws.onmessage = (ev) => {
          touch();
          let f; try { f = JSON.parse(String(ev.data)); } catch { return; }
          if (f.type !== "message_received") return;  // messages sit INSIDE typed frames
          const m = f.message || {};
          if (m.direction === "outbound" || !m.uid || !m.body || seen.has(m.uid)) return;
          seen.add(m.uid);
          log("inbound message received");
          notify(m.body, { message_id: m.uid, user: m.sender?.display_name || "You" });
        };
        ws.onclose = () => { clearInterval(watchdog); done(); };
        ws.onerror = () => { try { ws.close(); } catch {} };
      });
    } catch {}
    log("websocket reconnecting in 5s");
    await new Promise((r) => setTimeout(r, 5000)); // TODO(hardening): backoff + TCP keepalive + offline-backfill (persist seen-set, refetch texts from the dead window)
  }
}
 
// ==========================================================================
// THE SCHEDULER: the first sync at startup, then Domo's two daily rhythms.
// ==========================================================================
const REFRESH = "Housekeeping — do NOT reply to the household: run the agenda-sync " +
  "skill to refresh the wall screen.";
const RUNDOWN = "Housekeeping: text the household its morning rundown — one short summary " +
  "of today's calendar, via the reply tool.";
let rundownDay = "";
function rhythms() { // channel events on a clock; nothing here waits for a text
  setTimeout(() => notify(REFRESH), 15_000);         // the first sync fires itself, once the session settles
  setInterval(() => notify(REFRESH), 30 * 60_000);   // keep the screen fresh
  setInterval(() => {                                // the morning rundown, once at 7
    const day = new Date().toLocaleDateString("en-CA", { timeZone: TZ });
    const hour = new Date().toLocaleString("en-US", { timeZone: TZ, hour: "numeric", hour12: false });
    if (Number(hour) === 7 && day !== rundownDay) { rundownDay = day; notify(RUNDOWN); }
  }, 60_000);
}
 
// ==========================================================================
// THE DASHBOARD HOST: one Bun server, loopback only (the wall screen, Step 7).
// ==========================================================================
Bun.serve({ // the wall screen: ui/index.html, plus the state files Domo keeps fresh
  hostname: "127.0.0.1", // loopback only; no login
  port: 8848,
  async fetch(req) {
    const path = new URL(req.url).pathname;
    const file = Bun.file(path === "/" ? `${DIR}/ui/index.html` : `${DIR}/state${path}`);
    if (await file.exists()) return new Response(file);
    return new Response("{}", { status: 404 });
  },
});
log("dashboard listening on 127.0.0.1:8848");
 
// ==========================================================================
// THE MCP WIRING: what makes all of the above one Claude Code channel.
// ==========================================================================
async function handle(msg) { // the MCP protocol, smallest useful subset
  const { id, method, params } = msg;
 
  if (method === "initialize") {
    send({
      jsonrpc: "2.0", id,
      result: {
        protocolVersion: params?.protocolVersion || "2025-06-18",
        capabilities: { tools: {}, experimental: { "claude/channel": {} } }, // what makes this a channel
        serverInfo: { name: "domo", version: "1.0.0" },
        instructions: "Anything the household should see MUST go through the reply tool.",
      },
    });
    log("mcp initialized");
    return;
  }
 
  if (method === "notifications/initialized") { // the session is up: start Domo's life
    listen();
    rhythms();
    return;
  }
 
  if (method === "tools/list") {
    send({
      jsonrpc: "2.0", id,
      result: {
        tools: [{
          name: "reply",
          description: "Send a text message to the household chat.",
          inputSchema: {
            type: "object",
            properties: { text: { type: "string" } },
            required: ["text"],
          },
        }],
      },
    });
    return;
  }
 
  if (method === "tools/call" && params?.name === "reply") {
    const ok = await reply(params.arguments?.text);
    send({
      jsonrpc: "2.0", id,
      result: {
        content: [{ type: "text", text: ok ? "sent" : "send failed" }],
        isError: !ok,
      },
    });
    return;
  }
 
  if (id !== undefined) send({ jsonrpc: "2.0", id, result: {} }); // politely ack anything else
}
 
for await (const line of console) {  // MCP over stdio: one JSON-RPC message per line
  if (line.trim()) { try { handle(JSON.parse(line)); } catch {} }
}

$ claude mcp add domo --scope local -- bun "$PWD/plow-channel.ts"

$ bun plow-channel.ts &   # run it in the background (or use a second terminal)
$ tail bridge.log         # "dashboard listening on 127.0.0.1:8848" = alive
$ kill %1                 # stop the manual run; Step 6 starts it for real

# Domo
You are Domo, a warm household calendar assistant, reached by text message.
 
- Anything the household should see goes through the domo `reply` tool, as
  short plain text. Ordinary assistant text reaches no one.
- The calendar is the Google Calendar connector's tools. Read it before answering;
  create and change events when asked.
- Check every calendar you have access to: on any calendar question, include events
  from all calendars unless the user names a specific one — "what's going on
  tomorrow?" means every calendar, not just one.
- The wall screen's agenda is not yours to write — the agenda-sync skill owns it.
  Run that skill after you create, change, or delete events, and whenever a
  housekeeping event or a person asks for a refresh. Never write state/agenda.json.
- The screen also reads state/countdown.json {"date","label"} and state/location.json
  {"lat","lon","label"}, in this folder. The weather and countdown cards start blank:
  write state/location.json when someone texts a place ("set my weather to Oakland") and
  state/countdown.json when they name an event worth counting down to — and offer to set
  them if they haven't.
- "Housekeeping" channel events come from the scheduler, not the household: do what
  they say, and text no one unless they say to.

---
name: agenda-sync
description: Use when a housekeeping channel event asks for an agenda refresh, after
  creating, changing, or deleting calendar events, or when someone asks for the screen
  to be refreshed. Spawns the calendar-fetch subagent to rebuild the wall screen's
  agenda. Silent - never reply to the household, with one exception, a calendar auth
  failure sends a single re-login text, once per outage.
---
 
# agenda-sync
 
Refresh the wall screen's agenda. The whole job is one subagent spawn and one line of
handling — fewest possible tool calls, no narration.
 
1. Spawn the calendar-fetch subagent (Task tool, subagent type "calendar-fetch") with
   a one-line prompt, passing the date from the channel event's today_iso meta:
 
   window_start: <today_iso>
 
   Don't call the calendar tools yourself, and don't add anything else to the prompt.
   The subagent dumps the raw events and runs ./agenda-publish.sh itself, then
   returns exactly one line.
 
2. Handle that line:
   - "OK <n>" — the screen is already updated. Done.
   - "FAILED <reason>" — leave the screen alone: the last-good agenda stays up, never
     blank or rewrite state/agenda.json. Done.
   - "AUTH <reason>" — the calendar connector needs a re-login. The housekeeping
     event's "do NOT reply" describes the normal path; this alert is its single
     deliberate exception. Was the household already told? Run via Bash:
       [ -e .auth-alerted ] && echo QUIET || echo ALERT
     ALERT: send exactly one reply — "I can't see the calendar right now — it needs
     a re-login. On the machine I run on: run ./run.sh from the domo folder to
     attach, type /mcp and reconnect Google Calendar, then Ctrl-b d to detach. Text
     me if you want a hand." Only if the reply tool returned "sent", mark the outage
     announced — run via Bash: date > .auth-alerted. On "send failed", leave the
     marker absent so the next half-hour cycle retries the alert. QUIET: send
     nothing; this outage was already announced. Either way the last-good agenda
     stays on the screen. (agenda-publish.sh deletes .auth-alerted on the next good
     refresh, so each outage texts once.)
 
3. Beyond that one AUTH text, don't use the reply tool and write no summary — this is
   housekeeping, and nobody reads the transcript.

---
name: calendar-fetch
description: Fetch every Google calendar's raw events and publish the wall screen's
  agenda. Spawned by the agenda-sync skill. Runs on the cheapest model with a
  restricted tool set - it dumps raw tool results and runs one deterministic script,
  it never interprets calendar content.
tools: Read, Write, Bash, mcp__claude_ai_Google_Calendar__list_calendars, mcp__claude_ai_Google_Calendar__list_events
model: haiku
---
 
You fetch calendar events and publish the wall screen's agenda. You do NOT filter,
interpret, summarize, or reformat calendar content — the jq program inside the script
you run at the end does the normalizing. Follow these steps exactly, then return
exactly ONE line.
 
Your prompt gives you the window start date as `window_start: YYYY-MM-DD`. Use it
verbatim — do not compute dates yourself.
 
1. Call list_calendars and keep every calendar it returns.
 
2. For EACH calendar, call list_events for the window from window_start 00:00 through
   7 days later, in the household timezone (run.sh's TZ — your session inherits it).
   Fetch every event in the window (follow pagination if the tool indicates more
   results).
 
3. Assemble one JSON document — the raw tool results verbatim, nothing dropped,
   nothing reworded:
   {"calendars": [{"name": "<calendar name>", "events": [<raw events as returned>]}]}
   and Write it to raw-events.json in this folder.
 
4. Run via Bash: ./agenda-publish.sh
   It normalizes the dump into state/agenda.json and prints an event count; exit 0
   means the screen was updated.
 
5. Return exactly one line, nothing else:
   - OK <n> — agenda-publish.sh exited 0; <n> is the total raw events you dumped.
   - AUTH <short reason> — ANY calendar tool call failed with an authorization error
     ("requires re-authorization", "token expired", or similar). Do NOT write the
     dump and do NOT run agenda-publish.sh — the last-good screen must stay up.
     Return immediately.
   - FAILED <short reason> — any other failure, including any calendar's fetch
     failing. The whole cycle is FAILED — never publish a partial calendar set (it
     would silently erase that calendar's events from the screen).
 
The reason after AUTH or FAILED must be short and non-personal — tool or script error
wording only, never event titles, locations, or any calendar content.

# agenda-normalize.jq — the calendar-fetch subagent's raw dump -> the {"events": [...]}
# shape the wall screen reads. Deterministic on purpose: the subagent only dumps raw
# tool results and ./agenda-publish.sh runs this transform, so no model ever retypes
# an event on its way to the screen. Drops cancelled events and events the household
# declined. Private events show as "Busy" with no location. All-day events keep
# date-only start/end, with the end pulled back one day: Google's all-day end is
# exclusive (a one-day event arrives as end = the next day), the screen's is not.
def declined:
  ([.attendees[]? | select(.self == true and .responseStatus == "declined")] | length) > 0;
def inclusive_end:
  if . then strptime("%Y-%m-%d") | mktime - 86400 | strftime("%Y-%m-%d") else null end;
 
{ events:
  [ .calendars[] as $cal
    | $cal.events[]
    | select(.status != "cancelled")
    | select(declined | not)
    | ((.visibility // "default") == "private") as $private
    | { start: (.start.dateTime // .start.date),
        end: (.end.dateTime // (.end.date | inclusive_end)),
        title: (if $private then "Busy" else (.summary // "(untitled)") end),
        location: (if $private then null else (.location // null) end),
        calendar: $cal.name }
  ] | sort_by([.start, .title])
}

#!/usr/bin/env bash
# agenda-publish.sh: the screen's one writer. Normalizes the calendar-fetch
# subagent's raw dump (agenda-normalize.jq) into state/agenda.json, atomically.
# The dump holds real event data, so it is chmod 600 while it exists and always
# deleted on exit. Fixed filenames only; nothing here interpolates a path.
cd "$(dirname "$0")" || exit 1
umask 077
chmod 600 raw-events.json 2>/dev/null || true
trap 'rm -f raw-events.json state/agenda.json.tmp' EXIT
mkdir -p state
jq -f agenda-normalize.jq raw-events.json > state/agenda.json.tmp \
  || { echo "normalize failed" >&2; exit 2; }
mv state/agenda.json.tmp state/agenda.json \
  || { echo "publish failed" >&2; exit 3; }
rm -f .auth-alerted   # a good refresh ends the auth outage: next failure texts once
echo "agenda updated ($(jq '.events | length' state/agenda.json) events)"

{
  "permissions": {
    "allow": ["Bash(./agenda-publish.sh:*)"],
    "deny": ["Edit(state/agenda.json)"]
  }
}

#!/usr/bin/env bash
# run.sh — start Domo, or attach to it if it's already running.
# One tmux session, two windows: 0 "claude" is Domo itself, 1 "bridge" tails
# the bridge's log. First run: creates the session and attaches you, so you
# can approve Claude's prompts. Every later run just attaches. Detach: Ctrl-b, then d.
cd "$(dirname "$0")" || exit 1
 
TZ="America/Los_Angeles"  # Domo's timezone. Defaults to Pacific — change it here.
 
DOMO="TZ=$TZ claude --permission-mode auto --dangerously-load-development-channels server:domo"
 
if ! tmux has-session -t domo 2>/dev/null; then
  tmux new-session -d -s domo -n claude "$DOMO; tmux kill-session -t domo"
  tmux new-window -d -t domo -n bridge "exec tail -n 100 -F '$PWD/bridge.log'"
  tmux select-window -t domo:claude
fi
tmux attach -t domo

$ chmod +x run.sh agenda-publish.sh && ./run.sh

what's on the calendar tomorrow?
Tomorrow: dentist at 9, school pickup at 3. Want a countdown for anything?

$ jq '.events | length' state/agenda.json   # a number within ~a minute of starting = the crew ran
7

$ cd ~/domo && curl -sS -X DELETE "https://api.plow.co/v1/chats/$(jq -r .chat_uid plow.json)" \
     -H "authorization: Bearer $(jq -r .token plow.json)"
# 204 No Content → deleted.   404 → already gone or not yours.

$ tmux kill-session -t domo 2>/dev/null || true   # stops Domo, if it's running
$ claude mcp remove domo
$ rm -rf ~/domo   # or wherever your domo folder lives
$ rm -f ~/.plow-token   # leftover token file from activation, if still present