@ours.network/fleet 0.19.0-nightly.13 → 0.19.0-nightly.14

package/dist/rooms-tasks/markdown.d.ts

@@ -0,0 +1,49 @@
+import type { RoomOrchestrationState, TaskState } from './types.js';
+export declare const MARKDOWN_MAX_CODE_POINTS = 3500;
+export declare const MARKDOWN_MAX_BYTES = 12000;
+export interface StatusPresentation {
+    icon: string;
+    word: string;
+}
+export type MarkdownField = {
+    label: string;
+    value: unknown;
+    kind?: 'prose' | 'code' | 'markdown';
+    multiline?: boolean;
+};
+export type MarkdownSection = {
+    heading?: string;
+    items?: unknown[];
+    markdownItems?: string[];
+    prose?: unknown;
+};
+export declare function withinMarkdownBounds(value: string): boolean;
+/** Escaped single-line prose suitable for a field or list item. */
+export declare function markdownProse(value: unknown): string;
+/** Escaped heading text. Newlines and heading/list syntax cannot escape the heading. */
+export declare function markdownHeading(value: unknown): string;
+/** Escaped multiline prose. Intended line breaks remain line breaks. */
+export declare function markdownMultiline(value: unknown): string;
+/** CommonMark code span with a delimiter longer than every run in the value. */
+export declare function markdownCode(value: unknown): string;
+export declare function taskStatus(value: TaskState | string): string;
+export declare function roomStatus(value: RoomOrchestrationState | string): string;
+export declare function renderMarkdownResult(input: {
+    icon: string;
+    title: string;
+    fields?: MarkdownField[];
+    sections?: MarkdownSection[];
+}): string;
+export declare function renderMarkdownList(input: {
+    icon: string;
+    title: string;
+    empty: string;
+    records: string[];
+}): string;
+export type FailureKind = 'usage' | 'not_found' | 'conflict' | 'state' | 'pending' | 'unexpected';
+export declare function renderMarkdownFailure(input: {
+    kind: FailureKind;
+    subject: string;
+    detail?: unknown;
+    action: string;
+}): string;

package/dist/rooms-tasks/markdown.js

@@ -0,0 +1,206 @@
+import { Buffer } from 'node:buffer';
+export const MARKDOWN_MAX_CODE_POINTS = 3_500;
+export const MARKDOWN_MAX_BYTES = 12_000;
+const FIELD_MAX_CODE_POINTS = 900;
+const FIELD_MAX_BYTES = 3_000;
+const ID_MAX_CODE_POINTS = 160;
+const ID_MAX_BYTES = 640;
+const TRUNCATED = '_… output truncated._';
+const SPOOFING_CONTROLS = /[\u200b-\u200f\u202a-\u202e\u2060-\u206f\ufeff]/g;
+const SINGLE_LINE_CONTROLS = /[\u0000-\u001f\u007f-\u009f]/g;
+const MULTILINE_CONTROLS = /[\u0000-\u0009\u000b-\u001f\u007f-\u009f]/g;
+const PROSE_PUNCTUATION = /([\\`*_[\]<>])/g;
+const HEADING_PUNCTUATION = /([\\`*_[\]<>#])/g;
+const TASK_STATUS = {
+    backlog: { icon: '⏸️', word: 'Backlog' },
+    provisioning: { icon: '⏳', word: 'Provisioning' },
+    active: { icon: '🟢', word: 'Active' },
+    review: { icon: '🟡', word: 'Review' },
+    done: { icon: '✅', word: 'Done' },
+    cancelled: { icon: '🚫', word: 'Cancelled' },
+    failed: { icon: '❌', word: 'Failed' },
+};
+const ROOM_STATUS = {
+    provisioning: { icon: '⏳', word: 'Provisioning' },
+    active: { icon: '🟢', word: 'Active' },
+    closing: { icon: '⏳', word: 'Closing' },
+    closed: { icon: '🔒', word: 'Closed' },
+};
+const codePoints = (value) => Array.from(value).length;
+const bytes = (value) => Buffer.byteLength(value, 'utf8');
+export function withinMarkdownBounds(value) {
+    return codePoints(value) <= MARKDOWN_MAX_CODE_POINTS && bytes(value) <= MARKDOWN_MAX_BYTES;
+}
+function normalize(value, multiline) {
+    let text = String(value ?? '').replace(/\r\n?/g, '\n').replace(SPOOFING_CONTROLS, '�');
+    if (multiline)
+        text = text.replace(MULTILINE_CONTROLS, '�');
+    else
+        text = text.replace(SINGLE_LINE_CONTROLS, ' ').replace(/\n+/g, ' ');
+    return text;
+}
+function boundPlain(value, maxPoints, maxBytes) {
+    if (codePoints(value) <= maxPoints && bytes(value) <= maxBytes)
+        return value;
+    const suffix = '…';
+    let out = '';
+    for (const point of value) {
+        const next = out + point + suffix;
+        if (codePoints(next) > maxPoints || bytes(next) > maxBytes)
+            break;
+        out += point;
+    }
+    return out.replace(/\s+$/u, '') + suffix;
+}
+/** Escaped single-line prose suitable for a field or list item. */
+export function markdownProse(value) {
+    return boundPlain(normalize(value, false).trim(), FIELD_MAX_CODE_POINTS, FIELD_MAX_BYTES)
+        .replace(PROSE_PUNCTUATION, '\\$1');
+}
+/** Escaped heading text. Newlines and heading/list syntax cannot escape the heading. */
+export function markdownHeading(value) {
+    return boundPlain(normalize(value, false).trim(), 160, 640)
+        .replace(HEADING_PUNCTUATION, '\\$1');
+}
+/** Escaped multiline prose. Intended line breaks remain line breaks. */
+export function markdownMultiline(value) {
+    const bounded = boundPlain(normalize(value, true).trim(), FIELD_MAX_CODE_POINTS, FIELD_MAX_BYTES);
+    return bounded.split('\n').map(line => {
+        const escaped = line.replace(PROSE_PUNCTUATION, '\\$1');
+        // A multiline value is commonly nested inside a block quote. Escape every
+        // still-active line-leading block marker so user text cannot create nested
+        // headings, lists, quotes, thematic breaks, or tilde fences.
+        return escaped
+            .replace(/^([ \t]*)(#{1,6}|[-+>])(?=[ \t]|$)/u, '$1\\$2')
+            .replace(/^([ \t]*)(\d{1,9})([.)])(?=[ \t]|$)/u, '$1$2\\$3')
+            .replace(/^([ \t]*)(-{3,})(?=[ \t]*$)/u, '$1\\$2')
+            .replace(/^([ \t]*)(~{3,})/u, '$1\\$2');
+    }).join('\n');
+}
+/** CommonMark code span with a delimiter longer than every run in the value. */
+export function markdownCode(value) {
+    const normalized = normalize(value, false);
+    const text = boundPlain(normalized || '—', ID_MAX_CODE_POINTS, ID_MAX_BYTES);
+    const longest = Math.max(0, ...[...text.matchAll(/`+/g)].map(match => match[0].length));
+    const fence = '`'.repeat(longest + 1);
+    const pad = /^`|`$/.test(text) || (/^ | $/.test(text) && !/^ +$/.test(text));
+    return `${fence}${pad ? ' ' : ''}${text}${pad ? ' ' : ''}${fence}`;
+}
+export function taskStatus(value) {
+    const status = TASK_STATUS[value];
+    return status ? `${status.icon} ${status.word}` : `⚪ Unknown (${markdownProse(value)})`;
+}
+export function roomStatus(value) {
+    const status = ROOM_STATUS[value];
+    return status ? `${status.icon} ${status.word}` : `⚪ Unknown (${markdownProse(value)})`;
+}
+function addBlock(blocks, block) {
+    const candidate = [...blocks, block, TRUNCATED].join('\n\n');
+    if (!withinMarkdownBounds(candidate))
+        return false;
+    blocks.push(block);
+    return true;
+}
+function finalize(blocks, truncated) {
+    if (truncated)
+        blocks.push(TRUNCATED);
+    const output = blocks.join('\n\n');
+    if (!withinMarkdownBounds(output))
+        throw new Error('Markdown result exceeded its transport bounds');
+    return output;
+}
+export function renderMarkdownResult(input) {
+    const blocks = [`## ${input.icon} ${markdownHeading(input.title)}`];
+    let truncated = false;
+    for (const field of input.fields ?? []) {
+        const label = markdownHeading(field.label);
+        const value = field.kind === 'code' ? markdownCode(field.value)
+            : field.kind === 'markdown' ? String(field.value)
+                : field.multiline ? markdownMultiline(field.value) : markdownProse(field.value);
+        const rendered = field.multiline
+            ? `**${label}:**\n\n${value.split('\n').map(line => `> ${line}`).join('\n')}`
+            : `- **${label}:** ${value || '—'}`;
+        if (!addBlock(blocks, rendered)) {
+            truncated = true;
+            break;
+        }
+    }
+    if (!truncated)
+        for (const section of input.sections ?? []) {
+            const lines = [];
+            if (section.heading)
+                lines.push(`### ${markdownHeading(section.heading)}`);
+            if (section.prose !== undefined)
+                lines.push(markdownMultiline(section.prose));
+            const items = [
+                ...(section.items ?? []).map(markdownProse),
+                ...(section.markdownItems ?? []),
+            ];
+            let admitted = 0;
+            for (const item of items) {
+                const next = [...lines, `- ${item}`];
+                const remaining = items.length - admitted - 1;
+                const omission = remaining
+                    ? `- _${remaining} more ${remaining === 1 ? 'result' : 'results'} omitted\\._` : undefined;
+                const candidate = [...blocks, [...next, ...(omission ? [omission] : [])].join('\n'), TRUNCATED]
+                    .join('\n\n');
+                if (!withinMarkdownBounds(candidate))
+                    break;
+                lines.push(`- ${item}`);
+                admitted++;
+            }
+            if (admitted < items.length) {
+                const omitted = items.length - admitted;
+                lines.push(`- _${omitted} more ${omitted === 1 ? 'result' : 'results'} omitted\\._`);
+            }
+            if (!addBlock(blocks, lines.join('\n'))) {
+                truncated = true;
+                break;
+            }
+        }
+    return finalize(blocks, truncated);
+}
+export function renderMarkdownList(input) {
+    const blocks = [`## ${input.icon} ${markdownHeading(input.title)}`];
+    if (!input.records.length)
+        return finalize([...blocks, markdownProse(input.empty)], false);
+    let admitted = 0;
+    for (const record of input.records) {
+        const remaining = input.records.length - admitted - 1;
+        const rendered = `- ${record}`;
+        const omission = remaining
+            ? `- _${remaining} more ${remaining === 1 ? 'result' : 'results'} omitted\\._` : '';
+        const candidate = [...blocks, rendered, ...(omission ? [omission] : [])].join('\n\n');
+        if (!withinMarkdownBounds(candidate))
+            break;
+        blocks.push(rendered);
+        admitted++;
+    }
+    if (admitted < input.records.length) {
+        const omitted = input.records.length - admitted;
+        const notice = `- _${omitted} more ${omitted === 1 ? 'result' : 'results'} omitted\\._`;
+        if (!addBlock(blocks, notice))
+            return finalize(blocks, true);
+    }
+    return finalize(blocks, false);
+}
+export function renderMarkdownFailure(input) {
+    const titles = {
+        usage: 'Invalid command',
+        not_found: 'Not found',
+        conflict: 'Conflict',
+        state: 'Action not allowed',
+        pending: 'Action still pending',
+        unexpected: 'Command failed',
+    };
+    return renderMarkdownResult({
+        icon: input.kind === 'pending' ? '⏳' : '⚠️',
+        title: titles[input.kind],
+        fields: [
+            { label: 'Command', value: input.subject, kind: 'code' },
+            ...(input.detail !== undefined && input.kind !== 'unexpected'
+                ? [{ label: 'Reason', value: input.detail }] : []),
+        ],
+        sections: [{ heading: 'Next step', items: [input.action] }],
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "0.19.0-nightly.13",
+  "version": "0.19.0-nightly.14",
   "description": "Harness-agnostic fleet of persistent, identity-bound AI agents. Declarative fleet.yaml, tmux or ACP sessions, supervision, and ours.network messaging.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",