@amenophis1er/foreman 0.1.5 → 0.1.7

package/src/notify/commands.ts

@@ -3,8 +3,8 @@
  *
  * The parser is pure and small on purpose: the phone is the least forgiving
  * place to discover a command's shape, so every command has one shape, a
- * `/help` lists them, and anything that is not a command is treated as talk
- * for the planner of the project last spoken to.
+ * `/help` lists them, and anything that is not a command is talk: for the
+ * planner of the project last spoken to, else for the fleet planner.
  */
 import os from 'node:os';
 import path from 'node:path';
@@ -16,7 +16,8 @@ export type Command =
   | { cmd: 'new'; name: string }
   | { cmd: 'plan'; project: string; text: string }
   | { cmd: 'run'; project: string; text: string }
-  | { cmd: 'stop'; project?: string };
+  | { cmd: 'stop'; project?: string }
+  | { cmd: 'fleet'; text: string };
 
 /** `/plan@ForemanBot test-4 add a footer` → { cmd: 'plan', project: 'test-4', text: 'add a footer' }. */
 export function parseCommand(text: string): Command | null {
@@ -36,6 +37,7 @@ export function parseCommand(text: string): Command | null {
     case 'plan': { const [project, t] = split(); return project && t ? { cmd: 'plan', project, text: t } : null; }
     case 'run': { const [project, t] = split(); return project && t ? { cmd: 'run', project, text: t } : null; }
     case 'stop': return { cmd: 'stop', ...(rest ? { project: rest } : {}) };
+    case 'fleet': case 'f': return { cmd: 'fleet', text: rest };
     default: return null;
   }
 }
@@ -68,6 +70,7 @@ export const HELP_TEXT = [
   '/plan <project> <what you want> — talk to that project\'s planner',
   '/run <project> <brief> — skip the talk: start a mission at the project\'s default cap',
   '/stop [project] — stop the planner reply in flight',
+  '/fleet [anything] — the front desk: ask how things are going, or say what you want started where',
   '',
-  'Anything else you type answers the open question, or continues the last planning conversation.',
+  'Anything else you type answers the open question, continues the planning conversation you were just in, or goes to the front desk.',
 ].join('\n');

package/src/notify/telegram.ts

@@ -69,6 +69,16 @@ export function telegramTransport(token: string, chatId: string, apiBase = TELEG
         ...(opts?.buttons ? keyboard(opts.buttons) : { reply_markup: { inline_keyboard: [] } }),
       });
     },
+    busy() {
+      // Telegram's typing bubble lasts about five seconds per call and there
+      // is no "stop" — it simply lapses. So: send now, repeat every four
+      // seconds, and stopping means letting it lapse.
+      const ping = () => void call(apiBase, token, 'sendChatAction', { chat_id: chatId, action: 'typing' }, 5_000);
+      ping();
+      const timer = setInterval(ping, 4_000);
+      timer.unref?.();
+      return () => clearInterval(timer);
+    },
   };
 }
 
@@ -88,6 +98,7 @@ export const BOT_COMMANDS: Array<{ command: string; description: string }> = [
   { command: 'plan', description: 'Talk to a planner: /plan <project> <what you want>' },
   { command: 'run', description: 'Skip the talk: /run <project> <brief>' },
   { command: 'stop', description: 'Stop the planner reply in flight' },
+  { command: 'fleet', description: 'The front desk: /fleet how is everything going?' },
   { command: 'help', description: 'What you can say here' },
 ];
 

package/src/notify.ts

@@ -35,6 +35,8 @@ export interface Transport {
   send(text: string, opts?: { buttons?: Button[][] }): Promise<string | null>;
   /** Replaces the text and drops any buttons unless new ones are given. */
   edit(id: string, text: string, opts?: { buttons?: Button[][] }): Promise<void>;
+  /** Shows "working" for as long as the returned stop function is not called, where the channel has such a thing. */
+  busy?(): () => void;
 }
 
 /** The same envelope the SSE clients get, plus the event name. */
@@ -309,6 +311,15 @@ export class NotifyHub {
   constructor(private ctx: () => NotifyContext) {}
 
   attach(t: Transport): void { this.transports.push(t); }
+  /**
+   * The channel's "working" indicator, for the whole of a planner turn. A
+   * phone that shows nothing for thirty seconds and then a paragraph reads
+   * as a bot that ignored you; the typing bubble is the difference.
+   */
+  busy(): () => void {
+    const stops = this.transports.map((t) => t.busy?.()).filter((f): f is () => void => typeof f === 'function');
+    return () => { for (const s of stops) s(); };
+  }
   detach(name: string): void { this.transports = this.transports.filter((t) => t.name !== name); }
   get active(): string[] { return this.transports.map((t) => t.name); }
 

package/src/planner.ts

@@ -202,7 +202,7 @@ export function pickKnownModel(
 }
 
 /** The section appended to the charter so the planner can recommend real models. */
-function modelsSection(models: PlannerModel[] | undefined): string {
+export function modelsSection(models: PlannerModel[] | undefined): string {
   if (!models?.length) return '';
   const lines = models.map((m) =>
     `  - ${m.id} — ${m.providerLabel} · ${m.costBasis}${m.note ? ` · ${m.note}` : ''}`);

package/src/preflight.ts

@@ -19,7 +19,7 @@ import { access, mkdir, readFile } from 'node:fs/promises';
 import { constants } from 'node:fs';
 import { defaultInstance, describeInstance, effectiveConfigDir } from './instance.js';
 import { discoverOllama, ollamaHost } from './ollama.js';
-import { tailnetUrl, type Tailnet } from './tailscale.js';
+import { serveHint, tailnetUrl, type Tailnet } from './tailscale.js';
 import { codexHome, codexModels, readCodexAuth } from './codex.js';
 import { createRequire } from 'node:module';
 import { fileURLToPath } from 'node:url';
@@ -286,7 +286,9 @@ async function checkBrowser(): Promise<Check> {
 /** Where the phone can reach this. Says so plainly either way — the answer decides which links work. */
 function checkTailnet(t: Tailnet | null, port: number): Check {
   return t
-    ? { name: 'Tailscale', status: 'ok', detail: `${tailnetUrl(t, port)} — listening there too; phone links use it` }
+    ? (t.httpsPort
+        ? { name: 'Tailscale', status: 'ok', detail: `${tailnetUrl(t, port)} — HTTPS via tailscale serve; phone links use it` }
+        : { name: 'Tailscale', status: 'ok', detail: `${tailnetUrl(t, port)} — listening there too; phone links use it. For HTTPS: ${serveHint(port, t.httpsInUse)}` })
     : { name: 'Tailscale', status: 'ok', detail: 'not running — localhost only; phone links need a public URL in Settings → Notifications' };
 }