@detergent-software/conductor 1.0.0-dev.6 → 1.0.0-dev.8

package/mod/hooks/model.ts

@@ -2,7 +2,7 @@
 // the status line, band and pane show, and what each event asks the mod to do. register.tsx does
 // the engine's part (only its top-level functions may take `$`); vitest tests this file in CI
 // (apps/conductor/mod/tests/model.spec.ts).
-import type { ConductorInboxItem, ConductorSnapshot, ConductorWorker } from '../types';
+import type { ConductorInboxItem, ConductorNotify, ConductorSnapshot, ConductorWorker } from '../types';
 
 // A daemon API answer: its status and parsed JSON body.
 export type ApiAnswer = { body: unknown; status: number };
@@ -19,6 +19,33 @@ export type Reaction =
   | { kind: 'refresh'; toast: string | null }
   | { kind: 'send'; text: string; to: string };
 
+// What a Remote Control push came to: reached the phone (ok); not, as Remote Control is off
+// (inactive) or pushes are off in Claude Code's config (disabled); not sent to the phone on
+// purpose (skipped: Jason is at the terminal, or the answer says nothing about the phone); or the
+// call failed (failed: it threw, was denied, or answered an error).
+export type PushOutcome = { detail: string; state: 'disabled' | 'failed' | 'inactive' | 'ok' | 'skipped' };
+
+// Said once in the console when pushes stop reaching the phone (ATK-255), by why.
+export function pushWarning(outcome: PushOutcome): null | string {
+  switch (outcome.state) {
+    case 'disabled':
+      return "conductor: mobile pushes are off in Claude Code's config, so pushes reach this terminal only. Turn them on, or /notify away for Pushover.";
+    case 'failed':
+      return `conductor: a Remote Control push failed (${outcome.detail}). /notify away sends by Pushover instead.`;
+    case 'inactive':
+      return 'conductor: Remote Control is off, so pushes reach this terminal only. Connect Remote Control, or /notify away for Pushover.';
+    case 'ok':
+    case 'skipped':
+      return null;
+  }
+}
+
+// The state the daemon records for a push's outcome (POST /notify/report).
+export function reportedState(outcome: PushOutcome): 'failing' | 'inactive' | 'ok' | 'skipped' {
+  if (outcome.state === 'disabled') return 'inactive';
+  return outcome.state === 'failed' ? 'failing' : outcome.state;
+}
+
 // A band entry and the act its press does.
 export type BandEntry = { act: 'approve' | 'copy' | 'pane'; hotkey: string; id: number; label: string; text: string };
 
@@ -121,6 +148,15 @@ export function age(iso: string, now: number): string {
   return `${Math.floor(minutes / (24 * 60))}d`;
 }
 
+// The time left until `iso`: "12m", "3h", "2d"; "<1m" when it is (almost) up.
+export function remaining(iso: string, now: number): string {
+  const minutes = Math.floor((Date.parse(iso) - now) / 60_000);
+  if (!(minutes >= 1)) return '<1m';
+  if (minutes < 60) return `${minutes}m`;
+  if (minutes < 24 * 60) return `${Math.floor(minutes / 60)}h`;
+  return `${Math.floor(minutes / (24 * 60))}d`;
+}
+
 // 950, 42k, 6.1M.
 export function tokens(n: number): string {
   if (n < 1000) return String(n);
@@ -169,6 +205,11 @@ export function reaction(line: StreamLine): Reaction {
       const ask = text('text');
       return { kind: 'refresh', toast: ask === null ? null : `conductor: ${line.subject ? `${line.subject} · ` : ''}${ask}` };
     }
+    case 'notify.failed':
+    case 'notify.routed':
+    case 'notify.sent':
+      // Nothing the mod draws: only notify.profile and notify.channel change the pane.
+      return { kind: 'ignore' };
     case 'notify.requested': {
       const message = text('message');
       return line.data.channel === 'remote-control' && message !== null ? { kind: 'push', message } : { kind: 'ignore' };
@@ -264,13 +305,85 @@ export function endpointOf(portText: string, tokenText: string): { port: number;
   return Number.isInteger(port) && port > 0 && /^[0-9a-f]{64}$/.test(token) ? { port, token } : null;
 }
 
-// GET /fleet and GET /inbox as one snapshot; `error` set when the daemon didn't answer both.
-export function snapshotOf(fleet: ApiAnswer, inbox: ApiAnswer, readAt: number): ConductorSnapshot {
+// GET /fleet, GET /inbox and GET /notify as one snapshot; `error` set when the daemon didn't answer
+// the first two. A daemon older than the notifier answers /notify 404, which leaves `notify` null.
+export function snapshotOf(fleet: ApiAnswer, inbox: ApiAnswer, readAt: number, notify?: ApiAnswer): ConductorSnapshot {
   const workers = fleet.status === 200 ? parseFleet(fleet.body) : null;
-  if (workers === null) return { error: errorOf(fleet), inbox: [], readAt, workers: [] };
+  if (workers === null) return { error: errorOf(fleet), inbox: [], notify: null, readAt, workers: [] };
   const items = inbox.status === 200 ? parseInbox(inbox.body) : null;
-  if (items === null) return { error: errorOf(inbox), inbox: [], readAt, workers: [] };
-  return { error: null, inbox: items, readAt, workers };
+  if (items === null) return { error: errorOf(inbox), inbox: [], notify: null, readAt, workers: [] };
+  return { error: null, inbox: items, notify: notify?.status === 200 ? parseNotify(notify.body) : null, readAt, workers };
+}
+
+// GET /notify's body, kept to what the mod draws; null when it isn't one.
+export function parseNotify(body: unknown): ConductorNotify | null {
+  if (!isRecord(body) || typeof body.profile !== 'string') return null;
+  const channels = isRecord(body.channels) ? body.channels : {};
+  const remote = isRecord(channels['remote-control']) ? channels['remote-control'] : {};
+  return {
+    held: typeof body.held === 'number' ? body.held : 0,
+    profile: body.profile,
+    profiles: strings(body.profiles),
+    profileUntil: typeof body.profileUntil === 'string' ? body.profileUntil : null,
+    quietNow: body.quietNow === true,
+    remoteControl: typeof remote.state === 'string' ? remote.state : 'unknown',
+  };
+}
+
+// What `$.tool.call` of PushNotification answered: `{ result: { pushSent, disabledReason }, text }`.
+// Only a push that reached the phone is ok; Remote Control off (no_transport, or the text saying
+// so) is inactive; pushes turned off in the config are disabled; the rest say nothing of the phone.
+export function pushOutcome(answer: unknown): PushOutcome {
+  const call = isRecord(answer) ? answer : {};
+  if (typeof call.deny === 'string') return { detail: `refused: ${call.deny}`, state: 'failed' };
+  const result = isRecord(call.result) ? call.result : {};
+  const detail = typeof call.text === 'string' && call.text.trim() !== '' ? call.text.trim() : typeof result.message === 'string' ? result.message : '';
+  if (call.isError === true) return { detail: detail || 'PushNotification answered an error', state: 'failed' };
+  if (result.pushSent === true) return { detail, state: 'ok' };
+  if (result.disabledReason === 'config_off') return { detail: "Mobile push not sent (off in Claude Code's config)", state: 'disabled' };
+  if (result.disabledReason === 'no_transport' || /remote control inactive/i.test(detail)) {
+    return { detail: detail || 'Mobile push not sent (Remote Control inactive)', state: 'inactive' };
+  }
+  if (result.disabledReason === 'user_present') return { detail: 'Mobile push not sent: you were at the terminal (user_present)', state: 'skipped' };
+  return { detail: detail || 'PushNotification said nothing about the phone', state: 'skipped' };
+}
+
+// `/notify <profile> [--until <when>]`: --until is a local time (the next one), a date (local
+// midnight) or a date and time, as `conduct notify profile` reads it.
+export function notifyArgs(args: string, now: number): { error: string } | { name: string; until: null | string } {
+  const typed = /^(\S+)(?:\s+--until\s+(\S+))?$/.exec(args.trim());
+  if (!typed?.[1]) return { error: 'usage: /notify [<profile> [--until <when>]]' };
+  const when = typed[2];
+  if (when === undefined) return { name: typed[1], until: null };
+  const clock = /^([01]?\d|2[0-3]):([0-5]\d)$/.exec(when);
+  let at: Date;
+  if (clock) {
+    at = new Date(now);
+    at.setHours(Number(clock[1]), Number(clock[2]), 0, 0);
+    if (at.getTime() <= now) at.setDate(at.getDate() + 1);
+  } else {
+    at = new Date(/^\d{4}-\d{2}-\d{2}$/.test(when) ? `${when}T00:00` : when);
+  }
+  if (Number.isNaN(at.getTime())) return { error: `--until "${when}" is not a time: a local time such as 17:00, or a date and time such as 2026-10-12T09:00` };
+  return { name: typed[1], until: at.toISOString() };
+}
+
+// `/notify` with no profile: the profile, quiet hours, Remote Control.
+export function notifyText(notify: ConductorNotify | null, now: number): string {
+  if (notify === null) return 'the running conductor has no notifier: restart it on this build (conduct upgrade)';
+  const until = notify.profileUntil === null ? '' : ` for ${remaining(notify.profileUntil, now)} more`;
+  return [
+    `notify profile: ${notify.profile}${until} (profiles: ${notify.profiles.join(', ')}; /notify <profile> switches)`,
+    `Remote Control: ${notify.remoteControl}${notify.quietNow ? ` · quiet hours now, ${notify.held} held for the summary` : ''}`,
+  ].join('\n');
+}
+
+// POST /notify/profile's answer as the line to show.
+export function profileText(name: string, answer: ApiAnswer, now: number): string {
+  if (answer.status !== 200) return `notify profile not switched: ${errorOf(answer)}`;
+  const notify = parseNotify(answer.body);
+  const until = notify?.profileUntil ? ` for ${remaining(notify.profileUntil, now)}` : '';
+  return `notify profile: ${notify?.profile ?? name}${until}`;
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {

package/mod/hooks/register.tsx

@@ -15,9 +15,16 @@ import {
   glyph,
   homeOf,
   inboxText,
+  notifyArgs,
+  notifyText,
   parseLine,
+  profileText,
   projectGroups,
+  type PushOutcome,
+  pushOutcome,
+  pushWarning,
   reaction,
+  reportedState,
   snapshotOf,
   spendToday,
   statusText,
@@ -47,6 +54,8 @@ let isConsole = false;
 let isRefreshing = false;
 // The newest event id the stream showed, so a restarted `conduct events` picks up after it.
 let lastEventId: null | number = null;
+// Set once the console has said that pushes no longer reach the phone; a push that does clears it.
+let warnedInactive = false;
 
 type Endpoint = { port: number; token: string };
 
@@ -85,16 +94,20 @@ async function callApi($: EngineInterface, method: 'GET' | 'POST', path: string,
   return { body: parsed, status: answer.status };
 }
 
-// Reads /fleet and /inbox into the state the drawings read, and the status line.
+// Reads /fleet, /inbox and /notify into the state the drawings read, and the status line.
 async function refresh($: EngineInterface): Promise<ConductorSnapshot> {
   const readAt = await $.clock.now();
   let next: ConductorSnapshot;
   try {
     const at = await endpoint($);
-    const [fleet, inbox] = await Promise.all([callApi($, 'GET', '/fleet', undefined, at), callApi($, 'GET', '/inbox', undefined, at)]);
-    next = snapshotOf(fleet, inbox, readAt);
+    const [fleet, inbox, notify] = await Promise.all([
+      callApi($, 'GET', '/fleet', undefined, at),
+      callApi($, 'GET', '/inbox', undefined, at),
+      callApi($, 'GET', '/notify', undefined, at),
+    ]);
+    next = snapshotOf(fleet, inbox, readAt, notify);
   } catch (error) {
-    next = { error: error instanceof Error ? error.message : String(error), inbox: [], readAt, workers: [] };
+    next = { error: error instanceof Error ? error.message : String(error), inbox: [], notify: null, readAt, workers: [] };
   }
   await update($, snapshot, () => next);
   $.ui.status(statusText(next));
@@ -121,7 +134,7 @@ async function onLine($: EngineInterface, text: string): Promise<void> {
     switch (act.kind) {
       case 'disconnected': {
         const readAt = await $.clock.now();
-        await update($, snapshot, () => ({ error: NOT_RUNNING, inbox: [], readAt, workers: [] }));
+        await update($, snapshot, () => ({ error: NOT_RUNNING, inbox: [], notify: null, readAt, workers: [] }));
         $.ui.status(undefined);
         return;
       }
@@ -132,7 +145,7 @@ async function onLine($: EngineInterface, text: string): Promise<void> {
       case 'ignore':
         return;
       case 'push':
-        await $.tool.call({ message: act.message, status: 'proactive', tool: 'PushNotification' });
+        await push($, act.message);
         return;
       case 'refresh':
         if (act.toast !== null) $.ui.toast(act.toast);
@@ -147,6 +160,40 @@ async function onLine($: EngineInterface, text: string): Promise<void> {
   }
 }
 
+// Pushes to the phone through PushNotification, tells the daemon what came of it whatever it was
+// (`conduct notify` shows it), and says once in the console when pushes stop reaching the phone
+// (ATK-255): Remote Control off, pushes off in the config, or the call failing.
+async function push($: EngineInterface, message: string): Promise<void> {
+  let outcome: PushOutcome;
+  try {
+    outcome = pushOutcome(await $.tool.call({ message, status: 'proactive', tool: 'PushNotification' }));
+  } catch (error) {
+    outcome = { detail: error instanceof Error ? error.message : String(error), state: 'failed' };
+  }
+  const warning = pushWarning(outcome);
+  if (outcome.state === 'ok') warnedInactive = false;
+  if (warning !== null && !warnedInactive) {
+    warnedInactive = true;
+    $.ui.toast(warning);
+  }
+  try {
+    await callApi($, 'POST', '/notify/report', { channel: 'remote-control', result: outcome.detail, state: reportedState(outcome) });
+  } catch (error) {
+    $.ui.log(`conductor: notify report failed: ${error instanceof Error ? error.message : String(error)}`, { to: 'debug' });
+  }
+}
+
+// `/notify <profile> [--until <when>]` and the pane's picker: switch the notification profile.
+async function switchProfile($: EngineInterface, name: string, until: null | string = null): Promise<string> {
+  try {
+    const result = await callApi($, 'POST', '/notify/profile', until === null ? { name } : { name, until });
+    refreshSoon($);
+    return profileText(name, result, await $.clock.now());
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
+
 // `conduct events --follow` from this package's own build, so the mod and the CLI are one version
 // and no .cmd shim is in the way. It reconnects by itself; a child that ends is started again after
 // the last event it showed, so nothing in between is lost. One that keeps exiting at once (no
@@ -222,6 +269,7 @@ async function registerCommands($: EngineInterface): Promise<void> {
   await $.command.register({ argumentHint: '<item | #id>', description: "Approve an item's plan (posts approve as you)", name: 'approve' });
   await $.command.register({ argumentHint: '<item | #id> <what to change>', description: 'Ask for a revised plan (posts revise: … as you)', name: 'revise' });
   await $.command.register({ argumentHint: '<item | worker>', description: 'Wake a parked worker and open it in a tab', name: 'attach' });
+  await $.command.register({ argumentHint: '[<profile> [--until <when>]]', description: 'Show or switch the notification profile (default, away, focus …)', name: 'notify' });
 }
 
 export const register: Register = (on) => {
@@ -279,6 +327,15 @@ export const register: Register = (on) => {
     return { text: worker.found ? await attach($, worker.found.id, worker.found.name) : worker.error };
   });
 
+  on('command.run', { command: 'notify' }, async ($, e) => {
+    if (e.args.trim() !== '') {
+      const typed = notifyArgs(e.args, await $.clock.now());
+      return { text: 'error' in typed ? typed.error : await switchProfile($, typed.name, typed.until) };
+    }
+    const snap = await refresh($);
+    return { text: snap.error ?? notifyText(snap.notify, await $.clock.now()) };
+  });
+
   // The band above the prompt, in the console, while the inbox has items. A bare digit typed into
   // an empty prompt presses a band Button, so a plan's approve takes a second press (`y`).
   on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
@@ -331,9 +388,10 @@ export const register: Register = (on) => {
     );
   });
 
-  // The pane: the inbox first, then the fleet by project, then today's spend.
+  // The pane: the notification profile, the inbox, then the fleet by project, then today's spend.
   on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
-    const { Box, Button, Link, Text } = $.ui.resolve(e);
+    const ui = $.ui.resolve(e);
+    const { Box, Button, Link, Text } = ui;
     const snap = await read($, snapshot);
     const open = await read($, expanded);
     const now = await $.clock.now();
@@ -352,6 +410,32 @@ export const register: Register = (on) => {
         <Text bold>
           {TITLE} <Text dimColor>{statusText(snap)}</Text>
         </Text>
+        {snap.notify !== null && (
+          <Box columnGap={2} flexWrap="wrap">
+            {e.surface !== 'mobile' && 'Select' in ui ? (
+              <ui.Select
+                key="notify-profile"
+                label="notify "
+                onSelect={async (name) => $.ui.toast(await switchProfile($, name))}
+                options={snap.notify.profiles.map((p) => ({ value: p }))}
+                value={snap.notify.profile}
+              />
+            ) : (
+              snap.notify.profiles.map((p) => (
+                <Button
+                  key={`profile-${p}`}
+                  label={p === snap.notify?.profile ? `notify: ${p}` : p}
+                  onPress={async () => $.ui.toast(await switchProfile($, p))}
+                  variant={p === snap.notify?.profile ? 'primary' : undefined}
+                />
+              ))
+            )}
+            <Text dimColor>
+              Remote Control: {snap.notify.remoteControl}
+              {snap.notify.quietNow ? ` · quiet hours, ${snap.notify.held} held` : ''}
+            </Text>
+          </Box>
+        )}
         <Text dimColor wrap="truncate">
           {rule(`Inbox (${snap.inbox.length})`)}
         </Text>

package/mod/types/index.d.ts

@@ -24,10 +24,22 @@ export type ConductorInboxItem = {
   text: string;
 };
 
+// GET /notify as the mod draws it: the profile, the others to switch to, Remote Control's state.
+export type ConductorNotify = {
+  held: number;
+  profile: string;
+  profiles: string[];
+  profileUntil: string | null;
+  quietNow: boolean;
+  remoteControl: string;
+};
+
 // What the mod last read from the daemon; `error` set (and the lists empty) when none answered.
+// `notify` is null from a daemon older than the notifier.
 export type ConductorSnapshot = {
   error: string | null;
   inbox: ConductorInboxItem[];
+  notify: ConductorNotify | null;
   readAt: number;
   workers: ConductorWorker[];
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@detergent-software/conductor",
-	"version": "1.0.0-dev.6",
+	"version": "1.0.0-dev.8",
 	"description": "Conductor: the local daemon that runs conducted projects' work loops (conduct serve) and its conduct CLI.",
 	"type": "module",
 	"bin": {