@m8t-stack/cli 0.2.68 → 0.2.69

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.68";
+var CLI_VERSION = "0.2.69";
 
 // src/lib/render-error.ts
 init_errors();
@@ -29792,7 +29792,7 @@ function renderFounderRecord(block, inputs, now = (/* @__PURE__ */ new Date()).t
   const subscription = (inputs.subscriptionId ?? "").trim();
   const advisorRendered = advisorName || advisorEmail ? [advisorName, advisorEmail ? `<${advisorEmail}>` : ""].filter(Boolean).join(" ") : NOT_CAPTURED;
   const request = block.pending_requests?.[0];
-  const requestLines = request === void 0 ? [] : (() => {
+  const requestLines2 = request === void 0 ? [] : (() => {
     const modelLabel = request.model.trim() ? `\`${request.model.trim()}\`` : "(model not recorded)";
     const consentLabel = request.consent === "submit" ? "submit the request" : "prepare it only, don't submit";
     const addressLine = request.company_address === null ? "not provided \u2014 the founder skipped it" : [
@@ -29832,7 +29832,7 @@ function renderFounderRecord(block, inputs, now = (/* @__PURE__ */ new Date()).t
     `- **Microsoft Startup Advisor (SA):** ${advisorRendered}`,
     `- **Azure subscription:** ${subscription || NOT_CAPTURED}`,
     ...bullet("Team size", block.team_size),
-    ...requestLines,
+    ...requestLines2,
     ``
   ].join("\n");
   const idxAdvisor = advisorEmail || advisorName || "\u2014";
@@ -33165,7 +33165,7 @@ var TelemetryEnrollCommand = class extends M8tCommand {
 };
 
 // src/commands/companion/bridge.ts
-import { Command as Command61 } from "clipanion";
+import { Command as Command61, Option as Option58 } from "clipanion";
 
 // ../../packages/companion-bridge-contract/src/index.ts
 var COMPANION_MESSAGE_MAX_CODE_POINTS = 32768;
@@ -33719,7 +33719,7 @@ async function rosterCompanions(sink, deps = {}) {
   const { controller, timer } = createDeadline(deps);
   try {
     const { token, origin } = await acquireContext(deps);
-    const agents = await fetchAgents(
+    const agents = await (deps.fetchAgents ?? fetchAgents)(
       deps.fetch ?? fetch,
       origin,
       token,
@@ -33871,14 +33871,14 @@ async function dispatchConversation(request, sink, deps, consume, readDesktopMar
   try {
     const { token, origin } = await acquireContext(deps);
     const headers = authenticatedHeaders(token);
-    const agents = await fetchAgents(
+    const agents = await (deps.fetchAgents ?? fetchAgents)(
       fetchImpl,
       origin,
       token,
       controller.signal
     );
     const agentName = resolveAgentName(agents, request.personaKey);
-    const conversationId = await resolveConversationId(
+    const conversationId = await (deps.resolveConversationId ?? resolveConversationId)(
       fetchImpl,
       origin,
       headers,
@@ -33982,14 +33982,14 @@ async function historyCompanionMessages(request, sink, deps = {}) {
   try {
     const { token, origin } = await acquireContext(deps);
     const headers = authenticatedHeaders(token);
-    const agents = await fetchAgents(
+    const agents = await (deps.fetchAgents ?? fetchAgents)(
       fetchImpl,
       origin,
       token,
       controller.signal
     );
     const agentName = resolveAgentName(agents, request.personaKey);
-    const conversationId = await resolveConversationId(
+    const conversationId = await (deps.resolveConversationId ?? resolveConversationId)(
       fetchImpl,
       origin,
       headers,
@@ -34042,6 +34042,182 @@ function companionUpdateAvailable(update) {
   return update.available !== null && update.available !== update.installed;
 }
 
+// src/lib/companion-bridge-serve.ts
+var TOKEN_TTL_MS = 10 * 6e4;
+var CONTEXT_TTL_MS = 5 * 6e4;
+var STALE_CONTEXT_REASONS = /* @__PURE__ */ new Set([
+  "not-authorized",
+  "not-connected",
+  "mate-unavailable"
+]);
+var ServeContext = class {
+  constructor(now, base) {
+    this.now = now;
+    this.base = base;
+  }
+  now;
+  base;
+  token = null;
+  agents = /* @__PURE__ */ new Map();
+  conversations = /* @__PURE__ */ new Map();
+  cacheServed = false;
+  /** Starts a request (or a retry) with a clean served-from-cache slate. */
+  beginRequest() {
+    this.cacheServed = false;
+  }
+  /** Whether the request in flight consumed anything cached. */
+  servedFromCache() {
+    return this.cacheServed;
+  }
+  /** Drops every held value so the next resolution starts from nothing. */
+  invalidate() {
+    this.token = null;
+    this.agents.clear();
+    this.conversations.clear();
+  }
+  fresh(entry, ttl) {
+    return entry !== null && entry !== void 0 && this.now() - entry.at < ttl;
+  }
+  /** The chat dependencies with the caching wrappers layered in. */
+  chatDeps() {
+    return {
+      ...this.base,
+      getFoundryToken: async () => {
+        if (this.fresh(this.token, TOKEN_TTL_MS)) {
+          this.cacheServed = true;
+          return this.token.value;
+        }
+        const value = await (this.base.getFoundryToken ?? getFoundryToken)();
+        this.token = { value, at: this.now() };
+        return value;
+      },
+      fetchAgents: async (fetchImpl, origin, token, signal) => {
+        const held = this.agents.get(origin);
+        if (this.fresh(held, CONTEXT_TTL_MS)) {
+          this.cacheServed = true;
+          return held.value;
+        }
+        const value = await (this.base.fetchAgents ?? fetchAgents)(
+          fetchImpl,
+          origin,
+          token,
+          signal
+        );
+        this.agents.set(origin, { value, at: this.now() });
+        return value;
+      },
+      resolveConversationId: async (fetchImpl, origin, headers, agentName, signal) => {
+        const key2 = `${origin} ${agentName}`;
+        const held = this.conversations.get(key2);
+        if (this.fresh(held, CONTEXT_TTL_MS)) {
+          this.cacheServed = true;
+          return held.value;
+        }
+        const value = await (this.base.resolveConversationId ?? resolveConversationId)(
+          fetchImpl,
+          origin,
+          headers,
+          agentName,
+          signal
+        );
+        this.conversations.set(key2, { value, at: this.now() });
+        return value;
+      }
+    };
+  }
+};
+async function* requestLines(stdin) {
+  stdin.setEncoding("utf8");
+  let buffered = "";
+  for await (const chunk of stdin) {
+    buffered += String(chunk);
+    for (; ; ) {
+      const breakAt = buffered.indexOf("\n");
+      if (breakAt === -1) break;
+      const line2 = buffered.slice(0, breakAt).replace(/\r$/u, "");
+      buffered = buffered.slice(breakAt + 1);
+      yield line2;
+    }
+    if (buffered.length > COMPANION_BRIDGE_LINE_MAX_LENGTH + 1) {
+      throw new Error("request exceeds bridge bound");
+    }
+  }
+  if (buffered.length > 0) yield buffered.replace(/\r$/u, "");
+}
+async function dispatchRequest(request, sink, handlers) {
+  if (request.type === "roster") return handlers.roster(sink);
+  if (request.type === "update") {
+    const terminal = await handlers.update();
+    sink(terminal);
+    return terminal;
+  }
+  if (request.type === "history") return handlers.history(request, sink);
+  if (request.type === "converse") return handlers.converse(request, sink);
+  return handlers.send(request, sink);
+}
+async function handleWithContext(request, sink, handlers, context) {
+  context.beginRequest();
+  const held = { failure: null, streamed: false };
+  const firstAttempt = (event) => {
+    if (!held.streamed && held.failure === null && event.type === "failed" && STALE_CONTEXT_REASONS.has(event.reason) && context.servedFromCache()) {
+      held.failure = event;
+      return;
+    }
+    held.streamed = true;
+    if (held.failure !== null) {
+      sink(held.failure);
+      held.failure = null;
+    }
+    sink(event);
+  };
+  const terminal = await dispatchRequest(request, firstAttempt, handlers);
+  if (held.failure === null) {
+    if (terminal.type === "indeterminate" && context.servedFromCache()) {
+      context.invalidate();
+    }
+    return;
+  }
+  context.invalidate();
+  context.beginRequest();
+  await dispatchRequest(request, sink, handlers);
+}
+async function runCompanionBridgeServe(stdin, stdout, stderr, deps = {}) {
+  const context = new ServeContext(deps.now ?? Date.now, deps.chat ?? {});
+  const chat = context.chatDeps();
+  const handlers = {
+    roster: (sink2) => rosterCompanions(sink2, chat),
+    send: (request, sink2) => sendCompanionMessage(request, sink2, chat),
+    converse: (request, sink2) => converseCompanionMessage(request, sink2, chat),
+    history: (request, sink2) => historyCompanionMessages(request, sink2, chat),
+    update: deps.update ?? (() => checkCompanionUpdate(defaultLocalCompanionInstallOptions()))
+  };
+  const sink = (event) => {
+    stdout.write(`${serializeEvent(event)}
+`);
+  };
+  try {
+    for await (const raw of requestLines(stdin)) {
+      let request;
+      try {
+        request = parseRequestLine(raw);
+      } catch {
+        stderr.write("bridge request rejected\n");
+        return 2;
+      }
+      try {
+        await handleWithContext(request, sink, handlers, context);
+      } catch {
+        stderr.write("bridge request failed\n");
+        return 3;
+      }
+    }
+  } catch {
+    stderr.write("bridge request rejected\n");
+    return 2;
+  }
+  return 0;
+}
+
 // src/commands/companion/bridge.ts
 var defaultDeps3 = {
   roster: rosterCompanions,
@@ -34109,7 +34285,20 @@ async function runCompanionBridge(stdin, stdout, stderr, deps = defaultDeps3) {
 }
 var CompanionBridgeCommand = class extends Command61 {
   static paths = [["companion", "_bridge"]];
+  /**
+   * One process serving many requests instead of one per request, so the
+   * session keeps its authenticated context between them. A CLI predating the
+   * flag rejects it outright, which is how the app knows to fall back.
+   */
+  serve = Option58.Boolean("--serve", false);
   async execute() {
+    if (this.serve) {
+      return runCompanionBridgeServe(
+        this.context.stdin,
+        this.context.stdout,
+        this.context.stderr
+      );
+    }
     return runCompanionBridge(
       this.context.stdin,
       this.context.stdout,
@@ -34205,7 +34394,7 @@ var CompanionStatusCommand = class extends M8tCommand {
 };
 
 // src/commands/companion/repair.ts
-import { Command as Command63, Option as Option58 } from "clipanion";
+import { Command as Command63, Option as Option59 } from "clipanion";
 async function runCompanionRepairCommand(stdout, repair) {
   const state = await repair();
   if (state.state === "not-released") {
@@ -34227,7 +34416,7 @@ var CompanionRepairCommand = class extends M8tCommand {
   static usage = Command63.Usage({
     description: "Restore the desktop companions and start-at-login state."
   });
-  resourceGroup = Option58.String("--resource-group", {
+  resourceGroup = Option59.String("--resource-group", {
     description: "Which deployment to bind to, when the subscription holds more than one."
   });
   async executeCommand() {