@m8t-stack/cli 0.2.65 → 0.2.67

package/dist/cli.js

@@ -1364,7 +1364,7 @@ var init_enable_hosted_brain = __esm({
 import { Builtins, Cli } from "clipanion";
 
 // src/lib/package-version.ts
-var CLI_VERSION = "0.2.65";
+var CLI_VERSION = "0.2.67";
 
 // src/lib/render-error.ts
 init_errors();
@@ -21295,6 +21295,7 @@ function resolveHeadlessContextFromEnv(env) {
 
 // src/lib/apply-request-store.ts
 import { TableClient as TableClient4 } from "@azure/data-tables";
+var MAX_LEASE_TAKEOVERS = 2;
 async function openApplyTable(opts) {
   const { tableEndpoint } = await discoverStampStorage(opts);
   return new TableClient4(tableEndpoint, "Metadata", opts.credential);
@@ -21314,12 +21315,37 @@ async function readApplyRequest(client) {
 async function claimApplyRequest(client, executionId, nowIso, leaseMs) {
   const cur = await readApplyRequest(client);
   if (!cur) return null;
-  const leaseExpired = cur.status === "claimed" && cur.leaseUntil !== null && Date.parse(cur.leaseUntil) < Date.parse(nowIso);
+  const leaseExpired = isInFlight(cur.status) && cur.leaseUntil !== null && Date.parse(cur.leaseUntil) < Date.parse(nowIso);
   const claimable = cur.status === "pending" || cur.status === "awaiting-engine-update" || leaseExpired;
   if (!claimable) return null;
   const nowMs = Date.parse(nowIso);
   const leaseUntil = new Date((Number.isNaN(nowMs) ? Date.now() : nowMs) + leaseMs).toISOString();
-  const claimed = { ...cur, status: "claimed", claimedBy: executionId, leaseUntil, updatedAt: nowIso };
+  if (leaseExpired && cur.attempt >= MAX_LEASE_TAKEOVERS) {
+    const held = {
+      ...cur,
+      status: "held",
+      breaker: "held",
+      result: {
+        appliedVersion: cur.result?.appliedVersion ?? null,
+        error: `the converge was abandoned mid-apply ${(cur.attempt + 1).toString()} times (last owner ${cur.claimedBy ?? "(unknown)"}, phase "${cur.phase ?? "(none)"}"); the updater stopped retrying to avoid re-rolling infra behind a converge that cannot finish`
+      },
+      updatedAt: nowIso
+    };
+    try {
+      await client.updateEntity({ ...applyRequestToEntity(held), etag: cur.etag }, "Merge", { etag: cur.etag });
+    } catch (e) {
+      if (!hasStatus(e, 412)) throw e;
+    }
+    return null;
+  }
+  const claimed = {
+    ...cur,
+    status: "claimed",
+    claimedBy: executionId,
+    leaseUntil,
+    ...leaseExpired ? { attempt: cur.attempt + 1 } : {},
+    updatedAt: nowIso
+  };
   try {
     await client.updateEntity({ ...applyRequestToEntity(claimed), etag: cur.etag }, "Merge", { etag: cur.etag });
     return claimed;
@@ -33147,6 +33173,10 @@ var COMPANION_REQUEST_ID_MAX_LENGTH = 128;
 var COMPANION_AGENT_NAME_MAX_LENGTH = 256;
 var COMPANION_DESKTOP_AFTER_MAX_LENGTH = 256;
 var COMPANION_BRIDGE_LINE_MAX_LENGTH = 14e4;
+var COMPANION_HISTORY_LIMIT_MAX = 40;
+var COMPANION_TURN_TEXT_MAX_CODE_POINTS = 32768;
+var COMPANION_REPLY_DELTA_MAX_CODE_POINTS = 4096;
+var COMPANION_TURN_ID_MAX_LENGTH = 256;
 var PERSONAS = /* @__PURE__ */ new Set([
   "startup-advisor",
   "azure-advisor"
@@ -33181,6 +33211,17 @@ function isBoundedPlainString(value, maxLength) {
 function isRequestId(value) {
   return isBoundedPlainString(value, COMPANION_REQUEST_ID_MAX_LENGTH);
 }
+var FORBIDDEN_TEXT_CHARACTERS = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/u;
+function isBoundedMessageText(value, maxCodePoints) {
+  return typeof value === "string" && value.length > 0 && !FORBIDDEN_TEXT_CHARACTERS.test(value) && [...value].length <= maxCodePoints;
+}
+var INSTANT_SHAPE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/;
+function isInstantOrNull(value) {
+  return value === null || typeof value === "string" && INSTANT_SHAPE.test(value) && Number.isFinite(Date.parse(value));
+}
+function isCompanionTurn(value) {
+  return isRecord2(value) && hasExactKeys(value, ["id", "role", "text", "at"]) && isBoundedPlainString(value.id, COMPANION_TURN_ID_MAX_LENGTH) && (value.role === "user" || value.role === "mate") && isBoundedMessageText(value.text, COMPANION_TURN_TEXT_MAX_CODE_POINTS) && isInstantOrNull(value.at);
+}
 function isCanonicalInstant(value) {
   if (typeof value !== "string") return false;
   const time = Date.parse(value);
@@ -33244,7 +33285,18 @@ function parseRequest(value) {
     if (!hasExactKeys(value, ["type"])) return requestError();
     return { type: "update" };
   }
-  if (value.type !== "send" || !hasExactKeys(value, [
+  if (value.type === "history") {
+    if (!hasExactKeys(value, ["type", "requestId", "personaKey", "limit"]) || !isRequestId(value.requestId) || !isPersonaKey(value.personaKey) || !Number.isSafeInteger(value.limit) || value.limit < 1 || value.limit > COMPANION_HISTORY_LIMIT_MAX) {
+      return requestError();
+    }
+    return {
+      type: "history",
+      requestId: value.requestId,
+      personaKey: value.personaKey,
+      limit: value.limit
+    };
+  }
+  if (value.type !== "send" && value.type !== "converse" || !hasExactKeys(value, [
     "type",
     "requestId",
     "personaKey",
@@ -33254,7 +33306,7 @@ function parseRequest(value) {
     return requestError();
   }
   return {
-    type: "send",
+    type: value.type,
     requestId: value.requestId,
     personaKey: value.personaKey,
     draftRevision: value.draftRevision,
@@ -33339,6 +33391,41 @@ function parseEvent(value) {
     }
     return { type: "completed", requestId: value.requestId };
   }
+  if (value.type === "turn") {
+    if (!hasExactKeys(value, ["type", "requestId", "turn"]) || !isRequestId(value.requestId) || !isCompanionTurn(value.turn)) {
+      return eventError();
+    }
+    return {
+      type: "turn",
+      requestId: value.requestId,
+      turn: {
+        id: value.turn.id,
+        role: value.turn.role,
+        text: value.turn.text,
+        at: value.turn.at
+      }
+    };
+  }
+  if (value.type === "history-end") {
+    if (!hasExactKeys(value, ["type", "requestId", "count"]) || !isRequestId(value.requestId) || !Number.isSafeInteger(value.count) || value.count < 0 || value.count > COMPANION_HISTORY_LIMIT_MAX) {
+      return eventError();
+    }
+    return {
+      type: "history-end",
+      requestId: value.requestId,
+      count: value.count
+    };
+  }
+  if (value.type === "reply-delta") {
+    if (!hasExactKeys(value, ["type", "requestId", "text"]) || !isRequestId(value.requestId) || !isBoundedMessageText(value.text, COMPANION_REPLY_DELTA_MAX_CODE_POINTS)) {
+      return eventError();
+    }
+    return {
+      type: "reply-delta",
+      requestId: value.requestId,
+      text: value.text
+    };
+  }
   if (value.type === "dispatching" || value.type === "accepted") {
     if (!hasExactKeys(value, [
       "type",
@@ -33496,6 +33583,77 @@ function decodeLastMessageId(data) {
   }
   return last.id;
 }
+async function resolveConversationId(fetchImpl, origin, headers, agentName, signal) {
+  let response;
+  try {
+    response = await fetchImpl(`${origin}/api/conversations`, {
+      method: "POST",
+      headers: { ...headers, "content-type": "application/json" },
+      body: JSON.stringify({ agentName }),
+      signal
+    });
+  } catch {
+    throw new PredispatchFailure("not-connected");
+  }
+  return decodeConversationId(await readJsonEnvelope(response));
+}
+async function fetchConversationMessages(fetchImpl, origin, headers, conversationId, signal) {
+  let response;
+  try {
+    response = await fetchImpl(
+      `${origin}/api/conversations/${encodeURIComponent(conversationId)}/messages`,
+      { headers, signal }
+    );
+  } catch {
+    throw new PredispatchFailure("not-connected");
+  }
+  return readJsonEnvelope(response);
+}
+var EPOCH_SECONDS_LIMIT = 1e11;
+function sanitizeMessageText(value) {
+  let out = "";
+  for (const character of value) {
+    const code = character.codePointAt(0) ?? 0;
+    const forbidden = code === 127 || code <= 31 && code !== 9 && code !== 10 && code !== 13;
+    if (!forbidden) out += character;
+  }
+  return out;
+}
+function boundCodePoints(value, maxCodePoints) {
+  let count = 0;
+  let out = "";
+  for (const character of value) {
+    if (count >= maxCodePoints) return out;
+    out += character;
+    count += 1;
+  }
+  return value;
+}
+function decodeTurns(data, limit2) {
+  if (!isRecord3(data) || !Array.isArray(data.messages)) {
+    throw new PredispatchFailure("not-connected");
+  }
+  const turns = [];
+  for (const entry of data.messages) {
+    if (!isRecord3(entry)) continue;
+    if (entry.role !== "user" && entry.role !== "assistant") continue;
+    if (typeof entry.id !== "string" || !OPAQUE_ID.test(entry.id)) continue;
+    if (typeof entry.content !== "string") continue;
+    const text = boundCodePoints(
+      sanitizeMessageText(entry.content),
+      COMPANION_TURN_TEXT_MAX_CODE_POINTS
+    );
+    if (text.length === 0) continue;
+    const at = typeof entry.createdAt === "number" && Number.isFinite(entry.createdAt) && entry.createdAt > 0 && entry.createdAt < EPOCH_SECONDS_LIMIT ? new Date(Math.round(entry.createdAt) * 1e3).toISOString() : null;
+    turns.push({
+      id: entry.id,
+      role: entry.role === "user" ? "user" : "mate",
+      text,
+      at
+    });
+  }
+  return turns.slice(-limit2);
+}
 function mateRoute(personaKey, desktopAfter) {
   const marker = desktopAfter === void 0 ? "" : `&desktopAfter=${desktopAfter}`;
   return `/mates/${personaKey}?desktopPending=1${marker}`;
@@ -33618,7 +33776,93 @@ async function drainAcceptedSse(response) {
   }
   if (!sawDone) throw new Error("stream ended without terminal marker");
 }
-async function sendCompanionMessage(request, sink, deps = {}) {
+var REPLY_FLUSH_MIN_LENGTH = 64;
+var REPLY_FLUSH_MS = 150;
+function emitBoundedText(text, emit) {
+  let slice = "";
+  let count = 0;
+  for (const character of text) {
+    slice += character;
+    count += 1;
+    if (count === COMPANION_REPLY_DELTA_MAX_CODE_POINTS) {
+      emit(slice);
+      slice = "";
+      count = 0;
+    }
+  }
+  if (slice.length > 0) emit(slice);
+}
+async function streamAcceptedSse(response, now, onText) {
+  if (!response.body) throw new Error("response body unavailable");
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let buffered = "";
+  let total = 0;
+  const terminal = { sawDone: false };
+  let pending = "";
+  let lastFlush = now();
+  const flush = () => {
+    const text = sanitizeMessageText(pending);
+    pending = "";
+    lastFlush = now();
+    if (text.length > 0) emitBoundedText(text, onText);
+  };
+  const handleFrame = (frame) => {
+    if (frame.trim().length === 0) return;
+    const dataLines = frame.split(/\r?\n/u).filter((line2) => line2.startsWith("data:")).map((line2) => line2.slice(5).trimStart());
+    if (dataLines.length === 0) return;
+    const data = dataLines.join("\n");
+    if (terminal.sawDone) throw new Error("data after terminal stream marker");
+    if (data === "[DONE]") {
+      terminal.sawDone = true;
+      return;
+    }
+    const parsed = JSON.parse(data);
+    if (!isRecord3(parsed) || typeof parsed.type !== "string" || parsed.type === "error") {
+      throw new Error("invalid stream event");
+    }
+    if (parsed.type === "text-delta" && typeof parsed.delta === "string" && parsed.delta.length > 0) {
+      pending += parsed.delta;
+      if (pending.length >= REPLY_FLUSH_MIN_LENGTH || now() - lastFlush >= REPLY_FLUSH_MS) {
+        flush();
+      }
+    }
+  };
+  const drainFrames = () => {
+    for (; ; ) {
+      const boundary = /\r?\n\r?\n/u.exec(buffered);
+      if (!boundary) return;
+      const frame = buffered.slice(0, boundary.index);
+      buffered = buffered.slice(boundary.index + boundary[0].length);
+      handleFrame(frame);
+    }
+  };
+  for (; ; ) {
+    const part = await reader.read();
+    if (part.done) break;
+    total += part.value.byteLength;
+    if (total > RESPONSE_MAX_BYTES) {
+      await reader.cancel().catch(() => void 0);
+      throw new Error("bounded response rejected");
+    }
+    buffered += decoder.decode(part.value, { stream: true });
+    drainFrames();
+    if (terminal.sawDone) {
+      await reader.cancel().catch(() => void 0);
+      break;
+    }
+  }
+  if (!terminal.sawDone) {
+    buffered += decoder.decode();
+    drainFrames();
+    if (buffered.trim().length > 0) handleFrame(buffered);
+  }
+  flush();
+  if (!terminal.sawDone) {
+    throw new Error("stream ended without terminal marker");
+  }
+}
+async function dispatchConversation(request, sink, deps, consume, readDesktopMarker) {
   const { controller, timer } = createDeadline(deps);
   const fetchImpl = deps.fetch ?? fetch;
   let route;
@@ -33634,32 +33878,22 @@ async function sendCompanionMessage(request, sink, deps = {}) {
       controller.signal
     );
     const agentName = resolveAgentName(agents, request.personaKey);
-    let conversationResponse;
-    try {
-      conversationResponse = await fetchImpl(`${origin}/api/conversations`, {
-        method: "POST",
-        headers: { ...headers, "content-type": "application/json" },
-        body: JSON.stringify({ agentName }),
-        signal: controller.signal
-      });
-    } catch {
-      throw new PredispatchFailure("not-connected");
-    }
-    const conversationId = decodeConversationId(
-      await readJsonEnvelope(conversationResponse)
-    );
-    let messagesResponse;
-    try {
-      messagesResponse = await fetchImpl(
-        `${origin}/api/conversations/${encodeURIComponent(conversationId)}/messages`,
-        { headers, signal: controller.signal }
-      );
-    } catch {
-      throw new PredispatchFailure("not-connected");
-    }
-    const desktopAfter = decodeLastMessageId(
-      await readJsonEnvelope(messagesResponse)
+    const conversationId = await resolveConversationId(
+      fetchImpl,
+      origin,
+      headers,
+      agentName,
+      controller.signal
     );
+    const desktopAfter = readDesktopMarker ? decodeLastMessageId(
+      await fetchConversationMessages(
+        fetchImpl,
+        origin,
+        headers,
+        conversationId,
+        controller.signal
+      )
+    ) : void 0;
     route = mateRoute(request.personaKey, desktopAfter);
     const dispatching = parseEvent({
       type: "dispatching",
@@ -33695,7 +33929,7 @@ async function sendCompanionMessage(request, sink, deps = {}) {
     });
     sink(acceptedEvent);
     accepted = true;
-    await drainAcceptedSse(chatResponse);
+    await consume(chatResponse);
     const completed = parseEvent({
       type: "completed",
       requestId: request.requestId
@@ -33722,6 +33956,76 @@ async function sendCompanionMessage(request, sink, deps = {}) {
     clearTimeout(timer);
   }
 }
+async function sendCompanionMessage(request, sink, deps = {}) {
+  return dispatchConversation(request, sink, deps, drainAcceptedSse, true);
+}
+async function converseCompanionMessage(request, sink, deps = {}) {
+  return dispatchConversation(
+    request,
+    sink,
+    deps,
+    (response) => streamAcceptedSse(response, deps.now ?? Date.now, (text) => {
+      sink(
+        parseEvent({
+          type: "reply-delta",
+          requestId: request.requestId,
+          text
+        })
+      );
+    }),
+    false
+  );
+}
+async function historyCompanionMessages(request, sink, deps = {}) {
+  const { controller, timer } = createDeadline(deps);
+  const fetchImpl = deps.fetch ?? fetch;
+  try {
+    const { token, origin } = await acquireContext(deps);
+    const headers = authenticatedHeaders(token);
+    const agents = await fetchAgents(
+      fetchImpl,
+      origin,
+      token,
+      controller.signal
+    );
+    const agentName = resolveAgentName(agents, request.personaKey);
+    const conversationId = await resolveConversationId(
+      fetchImpl,
+      origin,
+      headers,
+      agentName,
+      controller.signal
+    );
+    const turns = decodeTurns(
+      await fetchConversationMessages(
+        fetchImpl,
+        origin,
+        headers,
+        conversationId,
+        controller.signal
+      ),
+      request.limit
+    );
+    for (const turn of turns) {
+      sink(parseEvent({ type: "turn", requestId: request.requestId, turn }));
+    }
+    const end = parseEvent({
+      type: "history-end",
+      requestId: request.requestId,
+      count: turns.length
+    });
+    sink(end);
+    return end;
+  } catch (error) {
+    return emitFailure(
+      sink,
+      classifyUnknownPredispatch(error),
+      request.requestId
+    );
+  } finally {
+    clearTimeout(timer);
+  }
+}
 
 // src/lib/companion-update-check.ts
 async function checkCompanionUpdate(options, deps = {}) {
@@ -33742,6 +34046,8 @@ function companionUpdateAvailable(update) {
 var defaultDeps3 = {
   roster: rosterCompanions,
   send: sendCompanionMessage,
+  converse: converseCompanionMessage,
+  history: historyCompanionMessages,
   update: () => checkCompanionUpdate(defaultLocalCompanionInstallOptions())
 };
 async function readSingleRequest(stdin) {
@@ -33764,6 +34070,7 @@ async function readSingleRequest(stdin) {
 }
 function exitFor(terminal) {
   if (terminal.type === "roster" || terminal.type === "completed") return 0;
+  if (terminal.type === "history-end") return 0;
   if (terminal.type === "update") return 0;
   if (terminal.type === "indeterminate") return 4;
   if (terminal.type === "failed" && terminal.reason !== "bad-request") {
@@ -33789,6 +34096,10 @@ async function runCompanionBridge(stdin, stdout, stderr, deps = defaultDeps3) {
     else if (request.type === "update") {
       terminal = await deps.update();
       sink(terminal);
+    } else if (request.type === "history") {
+      terminal = await deps.history(request, sink);
+    } else if (request.type === "converse") {
+      terminal = await deps.converse(request, sink);
     } else terminal = await deps.send(request, sink);
     return exitFor(terminal);
   } catch {