@indianic/dialout 1.12.0 → 1.13.0

package/node_modules/@indianic/dialout-shared/dist/session-announce.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Whether a tmux session the agent just reported is news.
+ *
+ * The bug this exists to kill: the daemon's close handler used to set
+ * `ended_at` on every session, so a reconnect made the registry's UPDATE miss,
+ * take the INSERT branch, and push "New terminal" for every terminal that was
+ * already open. Task 2 stops writing `ended_at` there; this is the second
+ * line of defence, for a session the vanish-pass legitimately ended and that
+ * then came back.
+ */
+export interface PriorSession {
+    /** Null while the session is live. */
+    endedAt: string | null;
+    /** When tmux created the session, as the agent reported it. */
+    createdLocal: string | null;
+    /** When a push for this row went out, or null if none ever did. */
+    notifiedAt: string | null;
+}
+export declare function shouldAnnounceSession(prior: PriorSession | null, createdLocal: string | null): boolean;
+//# sourceMappingURL=session-announce.d.ts.map

package/node_modules/@indianic/dialout-shared/dist/session-announce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-announce.d.ts","sourceRoot":"","sources":["../src/session-announce.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,MAAM,WAAW,YAAY;IAC3B,sCAAsC;IACtC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,+DAA+D;IAC/D,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,mEAAmE;IACnE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,YAAY,GAAG,IAAI,EAC1B,YAAY,EAAE,MAAM,GAAG,IAAI,GAC1B,OAAO,CAeT"}

package/node_modules/@indianic/dialout-shared/dist/session-announce.js

@@ -0,0 +1,20 @@
+"use strict";
+// packages/devdash-shared/src/session-announce.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldAnnounceSession = shouldAnnounceSession;
+function shouldAnnounceSession(prior, createdLocal) {
+    // Never seen on this machine under this name: unambiguously new.
+    if (!prior)
+        return true;
+    // Both creation times known and different: tmux really did make a new
+    // session that happens to reuse the name.
+    if (prior.createdLocal && createdLocal && prior.createdLocal !== createdLocal)
+        return true;
+    // Everything else is the same session returning — including the case where
+    // either creation time is missing. The original push spec said a missed
+    // notification is worse than an extra one; for this trigger that is
+    // backwards, because the failure being fixed is a burst. The cost is that an
+    // agent too old to report a creation time cannot announce a genuinely new
+    // session that reuses an old name.
+    return false;
+}

package/node_modules/@indianic/dialout-shared/dist/session-announce.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=session-announce.test.d.ts.map

package/node_modules/@indianic/dialout-shared/dist/session-announce.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-announce.test.d.ts","sourceRoot":"","sources":["../src/session-announce.test.ts"],"names":[],"mappings":""}

package/node_modules/@indianic/dialout-shared/dist/session-announce.test.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const session_announce_1 = require("./session-announce");
+(0, vitest_1.describe)('shouldAnnounceSession', () => {
+    (0, vitest_1.it)('announces a session with no prior row at all', () => {
+        (0, vitest_1.expect)((0, session_announce_1.shouldAnnounceSession)(null, '2026-10-29T09:00:00Z')).toBe(true);
+        (0, vitest_1.expect)((0, session_announce_1.shouldAnnounceSession)(null, null)).toBe(true);
+    });
+    // The reported bug. The agent reconnects, the row was marked ended, and the
+    // same tmux session is re-reported — it is not news.
+    (0, vitest_1.it)('stays quiet when the prior row is the same session by creation time', () => {
+        (0, vitest_1.expect)((0, session_announce_1.shouldAnnounceSession)({ endedAt: '2026-10-29T08:00:00Z', createdLocal: '2026-10-29T07:00:00Z', notifiedAt: null }, '2026-10-29T07:00:00Z')).toBe(false);
+    });
+    (0, vitest_1.it)('announces a genuinely new session that reuses a name', () => {
+        (0, vitest_1.expect)((0, session_announce_1.shouldAnnounceSession)({ endedAt: '2026-10-29T08:00:00Z', createdLocal: '2026-10-29T07:00:00Z', notifiedAt: '2026-10-29T07:00:01Z' }, '2026-10-29T09:30:00Z')).toBe(true);
+    });
+    // Durable suppression: lastNewNotifiedAt is in memory, so a ws-server
+    // restart must not replay an announcement the database already recorded.
+    (0, vitest_1.it)('stays quiet when the prior row was already announced and is still live', () => {
+        (0, vitest_1.expect)((0, session_announce_1.shouldAnnounceSession)({ endedAt: null, createdLocal: '2026-10-29T07:00:00Z', notifiedAt: '2026-10-29T07:00:01Z' }, '2026-10-29T07:00:00Z')).toBe(false);
+    });
+    // The documented reversal of the original push spec. Without a creation time
+    // there is no way to tell a revival from a new session, and the complaint is
+    // bursts, so silence is the right direction here.
+    (0, vitest_1.it)('treats a missing creation time on either side as the same session', () => {
+        (0, vitest_1.expect)((0, session_announce_1.shouldAnnounceSession)({ endedAt: '2026-10-29T08:00:00Z', createdLocal: null, notifiedAt: null }, '2026-10-29T09:00:00Z')).toBe(false);
+        (0, vitest_1.expect)((0, session_announce_1.shouldAnnounceSession)({ endedAt: '2026-10-29T08:00:00Z', createdLocal: '2026-10-29T07:00:00Z', notifiedAt: null }, null)).toBe(false);
+    });
+});

package/node_modules/@indianic/dialout-shared/src/index.ts

@@ -12,7 +12,19 @@ export { REPLAY_LIMIT } from './session';
 
 export type { CommandSource, AiCommand, McpServerInfo, AiCapabilities } from './capabilities';
 
-export { NOTIFY_COOLDOWN_MS, shouldNotifyAi, shouldNotifyPrompt } from './notify';
+export {
+  NOTIFY_COOLDOWN_MS,
+  shouldNotifyAi,
+  shouldNotifyPrompt,
+  shouldNotifyNewTerminal,
+  shouldNotifyNewAiSession,
+  type PushPrefs,
+} from './notify';
+
+export {
+  shouldAnnounceSession,
+  type PriorSession,
+} from './session-announce';
 
 export type { ToolItem, ChatBlock } from './chat-blocks';
 export { groupEvents, toolGroupStartsOpen } from './chat-blocks';
@@ -56,3 +68,27 @@ export {
   ATTACHMENT_DIR, ATTACHMENT_MAX_BYTES, ATTACHMENT_MAX_FILES,
   composeWithAttachments, isImageName, safeAttachmentName, splitAttachments,
 } from './attachments';
+
+export {
+  NOTIFICATION_TYPES,
+  ACTION_KINDS,
+  TEMPLATE_VARIABLES,
+  DEFAULT_TEMPLATES,
+  TITLE_MAX,
+  BODY_MAX,
+  MAX_ACTIONS,
+  categoryId,
+  renderNotification,
+  parseActions,
+  parseTemplatePatch,
+  isNotificationType,
+  shouldSendNotification,
+  folderLabel,
+  isSendable,
+  type NotificationType,
+  type ActionKind,
+  type NotificationAction,
+  type NotificationTemplate,
+  type TemplateVars,
+  type TemplatePatch,
+} from './notify-template';

package/node_modules/@indianic/dialout-shared/src/notify-template.test.ts

@@ -0,0 +1,352 @@
+// packages/devdash-shared/src/notify-template.test.ts
+import { describe, it, expect } from 'vitest';
+import {
+  renderNotification, parseActions, categoryId, DEFAULT_TEMPLATES,
+  TEMPLATE_VARIABLES, NOTIFICATION_TYPES, parseTemplatePatch, shouldSendNotification,
+  folderLabel, isSendable,
+} from './notify-template';
+
+describe('renderNotification', () => {
+  // The old hardcoded title chose between these two; a single template string
+  // cannot, so {what} carries it. Guards against "finished" reading as blocked.
+  it('default ai_question title keeps "needs you" distinct from "finished"', () => {
+    const t = DEFAULT_TEMPLATES.ai_question;
+    expect(renderNotification(t, { agent: 'Claude', what: 'needs you' }, 'UTC').title).toBe('Claude needs you');
+    expect(renderNotification(t, { agent: 'Claude', what: 'finished' }, 'UTC').title).toBe('Claude finished');
+  });
+
+  // The old hardcoded body had a fallback for each missing half; the values
+  // now carry them (folder -> 'session'), so no case may render empty and a
+  // finished session must still name its CLI.
+  it('default ai_question body is never empty and always names the CLI', () => {
+    const t = DEFAULT_TEMPLATES.ai_question;
+    const body = (question: string, folder: string) =>
+      renderNotification(t, { agent: 'Claude', what: 'finished', kind: 'claude', question, folder }, 'UTC').body;
+    expect(body('Q', 'dialout')).toBe('Q · claude · dialout');
+    expect(body('Q', 'session')).toBe('Q · claude · session');
+    expect(body('', 'dialout')).toBe('claude · dialout');
+    expect(body('', 'session')).toBe('claude · session');
+  });
+
+  it('substitutes the variables it is given', () => {
+    expect(renderNotification(
+      { title: '{agent} needs you', body: '{question} · {folder}' },
+      { agent: 'Claude', question: 'Run the migration?', folder: 'dialout' },
+      'UTC',
+    )).toEqual({ title: 'Claude needs you', body: 'Run the migration? · dialout' });
+  });
+
+  // A notification showing its own template syntax on a lock screen is worse
+  // than one with a gap in it.
+  it('renders an unknown or missing variable as empty, never as its own name', () => {
+    const r = renderNotification({ title: 'Hi {nobody}', body: '{alsoNobody}' }, {}, 'UTC');
+    expect(r.title).toBe('Hi');
+    expect(r.body).toBe('');
+    expect(r.title).not.toContain('{');
+  });
+
+  it('treats a null or undefined value as missing', () => {
+    expect(renderNotification({ title: 'a{x}b', body: '' }, { x: null }, 'UTC').title).toBe('ab');
+    expect(renderNotification({ title: 'a{x}b', body: '' }, { x: undefined }, 'UTC').title).toBe('ab');
+  });
+
+  // Emptying a variable otherwise strands the separator that was joining it to
+  // the next thing, and "Run it? · " reads as truncation.
+  it('collapses a separator left stranded by an empty variable', () => {
+    expect(renderNotification(
+      { title: 'x', body: '{question} · {folder}' },
+      { question: 'Run it?' },
+      'UTC',
+    ).body).toBe('Run it?');
+    expect(renderNotification(
+      { title: 'x', body: '{a} · {b} · {c}' },
+      { b: 'middle' },
+      'UTC',
+    ).body).toBe('middle');
+  });
+
+  it('collapses runs of whitespace', () => {
+    expect(renderNotification({ title: 'a  {x}   b', body: '' }, {}, 'UTC').title).toBe('a b');
+  });
+
+  it('formats time and date in the given timezone', () => {
+    const vars = { at: '2026-10-29T18:30:00Z' };
+    const utc = renderNotification({ title: '{time}', body: '{date}' }, vars, 'UTC');
+    const ist = renderNotification({ title: '{time}', body: '{date}' }, vars, 'Asia/Kolkata');
+    expect(utc.title).not.toBe(ist.title);
+    expect(ist.title).toMatch(/\d/);
+  });
+
+  // An unknown zone throws inside Intl, and this runs on the notify path.
+  it('falls back to UTC rather than throwing on an unknown timezone', () => {
+    expect(() => renderNotification(
+      { title: '{time}', body: '' }, { at: '2026-10-29T18:30:00Z' }, 'Mars/Olympus',
+    )).not.toThrow();
+  });
+
+  it('caps the title at 80 and the body at 240', () => {
+    const r = renderNotification({ title: '{x}', body: '{x}' }, { x: 'y'.repeat(500) }, 'UTC');
+    expect(r.title).toHaveLength(80);
+    expect(r.body).toHaveLength(240);
+  });
+
+  it('never throws on a template that is not a string', () => {
+    expect(() => renderNotification(
+      { title: undefined as unknown as string, body: null as unknown as string }, {}, 'UTC',
+    )).not.toThrow();
+  });
+
+describe('renderNotification: names that were never supplied', () => {
+  it.each(['constructor', '__proto__', 'toString', 'hasOwnProperty'])(
+    'renders {%s} as nothing',
+    (name) => {
+      expect(renderNotification({ title: `a{${name}}b`, body: `{${name}}` }, {}, 'UTC'))
+        .toEqual({ title: 'ab', body: '' });
+    },
+  );
+
+  it('renders a supplied value that is not a string or number as nothing, without throwing', () => {
+    const vars = { x: { nested: 1 }, y: ['a'], z: true } as unknown as Record<string, string>;
+    expect(renderNotification({ title: 'a{x}b{y}c{z}d', body: '' }, vars, 'UTC').title).toBe('abcd');
+  });
+
+  it('still substitutes a supplied number', () => {
+    const vars = { n: 3 } as unknown as Record<string, string>;
+    expect(renderNotification({ title: 'n={n}', body: '' }, vars, 'UTC').title).toBe('n=3');
+  });
+});
+
+// These guard the marker indirection specifically (surviving placeholders are
+// swapped for private-use markers while the skeleton is tidied). They look
+// redundant next to the verbatim-value tests; do not delete them as such.
+describe('renderNotification: marker indirection', () => {
+  const E0 = '';
+  const E1 = '';
+
+  it('renders values when the template itself contains marker characters, and emits none', () => {
+    const r = renderNotification(
+      { title: `a${E0}{x}${E1}b${E0}0${E1}`, body: `${E0}{y}` }, { x: 'X', y: 'Y' }, 'UTC',
+    );
+    expect(r.title).toBe('aXb0');
+    expect(r.body).toBe('Y');
+    expect(r.title + r.body).not.toMatch(/[]/);
+  });
+
+  it('renders marker-shaped text inside a value literally, without re-scanning it', () => {
+    const lookalike = `${E0}1${E1}`;
+    const r = renderNotification({ title: '', body: '{a} {b}' }, { a: lookalike, b: 'B' }, 'UTC');
+    expect(r.body).toBe(`${lookalike} B`);
+  });
+
+  it('keeps twelve placeholders in their own slots, including adjacent ones', () => {
+    const names = 'abcdefghijkl'.split('');
+    const vars = Object.fromEntries(names.map((n, i) => [n, `v${i}`]));
+    const template = '{a}{b} {c} {d} {e} {f} {g} {h} {i} {j} {k} {l}';
+    const r = renderNotification({ title: '', body: template }, vars, 'UTC');
+    expect(r.body).toBe('v0v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11');
+  });
+
+  it('substitutes values verbatim, including surrounding whitespace and newlines', () => {
+    const r = renderNotification({ title: '', body: '[{x}]' }, { x: '  a\nb  ' }, 'UTC');
+    expect(r.body).toBe('[  a\nb  ]');
+  });
+});
+
+describe('renderNotification: vars that are not an object', () => {
+  it.each([null, undefined, 'str', 42, true, ['a']])('does not throw for vars = %j', (v) => {
+    const r = renderNotification({ title: 'a{question}b', body: '{time}' }, v as never, 'UTC');
+    expect(r.title).toBe('ab');
+    expect(r.body).toMatch(/^\d{2}:\d{2}$/);
+  });
+});
+
+describe('renderNotification: a value is never tidied', () => {
+  it.each([
+    'Should I run git push --force?',
+    'Use the --no-verify flag',
+    'Run cmd1 || cmd2 ?',
+    '-rf flag is set',
+    'ends with a dash -',
+    '  spaced   out  ',
+    'a · · b',
+  ])('keeps %j character for character', (q) => {
+    expect(renderNotification({ title: '', body: '{question}' }, { question: q }, 'UTC').body).toBe(q);
+  });
+
+  it('does not let a value inject a placeholder', () => {
+    expect(renderNotification({ title: '', body: '{a}' }, { a: '{b}', b: 'no' }, 'UTC').body).toBe('{b}');
+  });
+
+  it('still tidies the skeleton around a verbatim value', () => {
+    expect(renderNotification({ title: '', body: '{question} · {folder}' }, { question: 'git push --force?' }, 'UTC').body)
+      .toBe('git push --force?');
+    expect(renderNotification({ title: '', body: '{folder} · {question}' }, { question: '-rf' }, 'UTC').body)
+      .toBe('-rf');
+  });
+});
+});
+
+describe('DEFAULT_TEMPLATES', () => {
+  it('covers every type', () => {
+    for (const t of NOTIFICATION_TYPES) expect(DEFAULT_TEMPLATES[t]).toBeDefined();
+  });
+
+  // A template may only use variables its own type supplies, or it renders a
+  // gap on every send.
+  it('only uses variables its own type offers', () => {
+    for (const t of NOTIFICATION_TYPES) {
+      const used = `${DEFAULT_TEMPLATES[t].title} ${DEFAULT_TEMPLATES[t].body}`
+        .match(/\{(\w+)\}/g)?.map((m) => m.slice(1, -1)) ?? [];
+      for (const v of used) expect(TEMPLATE_VARIABLES[t], `${t} uses {${v}}`).toContain(v);
+    }
+  });
+});
+
+describe('categoryId', () => {
+  // SDK 57: a category identifier may contain no ':' or '-', and a hyphen
+  // silently costs the action buttons. ai_question must land on exactly the
+  // string AI_CATEGORY already holds, so notifications in flight during the
+  // deploy keep their Reply button.
+  it('strips underscores and hyphens', () => {
+    expect(categoryId('ai_question')).toBe('aiquestion');
+    expect(categoryId('new_terminal')).toBe('newterminal');
+    expect(categoryId('new_ai_session')).toBe('newaisession');
+    expect(categoryId('announcement')).toBe('announcement');
+  });
+
+  it('never produces an id with a character the SDK rejects', () => {
+    for (const t of NOTIFICATION_TYPES) {
+      expect(categoryId(t)).not.toMatch(/[:-]/);
+    }
+  });
+});
+
+describe('parseActions', () => {
+  it('keeps well-formed actions', () => {
+    expect(parseActions([{ id: 'reply', label: 'Reply', kind: 'reply' }]))
+      .toEqual([{ id: 'reply', label: 'Reply', kind: 'reply' }]);
+  });
+
+  it('parses a JSON string, which is what the jsonb column may hand back', () => {
+    expect(parseActions('[{"id":"open","label":"Open","kind":"open"}]'))
+      .toEqual([{ id: 'open', label: 'Open', kind: 'open' }]);
+  });
+
+  // kind is a closed set so a button cannot be configured to do something the
+  // app has no code for.
+  it('drops an action with an unknown kind', () => {
+    expect(parseActions([{ id: 'x', label: 'X', kind: 'launchMissiles' }])).toEqual([]);
+  });
+
+  it('drops an action missing an id or a label', () => {
+    expect(parseActions([{ label: 'X', kind: 'open' }, { id: 'y', kind: 'open' }])).toEqual([]);
+  });
+
+  it('returns an empty array for anything unusable', () => {
+    for (const bad of [null, undefined, 42, 'not json', {}]) {
+      expect(parseActions(bad)).toEqual([]);
+    }
+  });
+
+  it('caps the list at four, which is what iOS shows', () => {
+    const many = Array.from({ length: 9 }, (_, i) => ({ id: `a${i}`, label: 'A', kind: 'open' }));
+    expect(parseActions(many)).toHaveLength(4);
+  });
+
+  it('drops a duplicate id, which would collide in the response handler', () => {
+    expect(parseActions([
+      { id: 'open', label: 'Open', kind: 'open' },
+      { id: 'open', label: 'Again', kind: 'open' },
+    ])).toHaveLength(1);
+  });
+});
+
+describe('shouldSendNotification', () => {
+  // The feature's central rule, and the one most likely to be re-implemented
+  // wrongly at a third call site. The repo has no route tests — the convention
+  // is pure-logic tests in src/lib/__tests__ — so this is where the gate is
+  // pinned.
+  it('needs both gates to say yes', () => {
+    expect(shouldSendNotification(true, true)).toBe(true);
+  });
+
+  it('sends nothing when the admin has switched the type off', () => {
+    expect(shouldSendNotification(false, true)).toBe(false);
+  });
+
+  it('sends nothing to a device whose owner opted out', () => {
+    expect(shouldSendNotification(true, false)).toBe(false);
+  });
+
+  it('is false when neither says yes', () => {
+    expect(shouldSendNotification(false, false)).toBe(false);
+  });
+});
+
+describe('parseTemplatePatch', () => {
+  it('accepts a partial patch', () => {
+    const r = parseTemplatePatch({ enabled: false, title: ' Hi ' });
+    expect(r).toEqual({ ok: true, patch: { enabled: false, title: 'Hi' } });
+  });
+
+  it('rejects a body that is not an object', () => {
+    expect(parseTemplatePatch(null).ok).toBe(false);
+  });
+
+  it('caps title and body rather than rejecting them', () => {
+    const r = parseTemplatePatch({ title: 'x'.repeat(300), body: 'y'.repeat(900) });
+    expect(r.ok).toBe(true);
+    if (r.ok) {
+      expect(r.patch.title).toHaveLength(80);
+      expect(r.patch.body).toHaveLength(240);
+    }
+  });
+
+  it('normalises actions through parseActions', () => {
+    const r = parseTemplatePatch({ actions: [{ id: 'x', label: 'X', kind: 'nope' }] });
+    expect(r.ok).toBe(true);
+    if (r.ok) expect(r.patch.actions).toEqual([]);
+  });
+});
+
+// The push this wording replaced named a terminal by its folder and fell back
+// to the tmux name. For a browser session the tmux name is dd-<uuid>, so a
+// default built on {terminal} would turn "dialout" into an opaque id.
+describe('default wording for a new session', () => {
+  const tz = 'UTC';
+
+  it('new_terminal names the folder, not the tmux name', () => {
+    const r = renderNotification(DEFAULT_TEMPLATES.new_terminal, {
+      terminal: 'dd-7f3a9c2b4e', folder: 'dialout', machine: 'MacBook Pro',
+    }, tz);
+    expect(r.body).toBe('dialout on MacBook Pro');
+  });
+
+  it('new_ai_session never leaves a gap when the sender has no folder', () => {
+    const vars = { agent: 'dd-ai-x', machine: 'MacBook Pro', folder: folderLabel(null, 'session') };
+    expect(renderNotification(DEFAULT_TEMPLATES.new_ai_session, vars, tz).body)
+      .toBe('dd-ai-x in session on MacBook Pro');
+  });
+});
+
+describe('folderLabel', () => {
+  it('uses the folder when there is one', () => {
+    expect(folderLabel('dialout', 'dd-abc')).toBe('dialout');
+  });
+  it('falls back for null, undefined, empty and whitespace', () => {
+    for (const f of [null, undefined, '', '   ']) expect(folderLabel(f, 'dd-abc')).toBe('dd-abc');
+  });
+});
+
+// A cleared title or body is a deliberate choice, so the sender has to decide
+// what an empty one means rather than discovering it on a lock screen.
+describe('isSendable', () => {
+  it('sends a notification with only a body or only a title', () => {
+    expect(isSendable({ title: '', body: 'Run it?' })).toBe(true);
+    expect(isSendable({ title: 'Agent needs you', body: '' })).toBe(true);
+  });
+  it('does not send one with neither', () => {
+    expect(isSendable({ title: '', body: '' })).toBe(false);
+    expect(isSendable({ title: '  ', body: ' ' })).toBe(false);
+  });
+});