@bastani/atomic 0.8.31-alpha.5 → 0.9.0-alpha.1

package/dist/builtin/intercom/subagent-relay.ts

@@ -0,0 +1,137 @@
+import type { ExtensionAPI, ExtensionContext } from "@bastani/atomic";
+import { randomUUID } from "crypto";
+import type { IntercomClient } from "./broker/client.ts";
+import type { SessionInfo, Message } from "./types.ts";
+import {
+  SUBAGENT_CONTROL_INTERCOM_EVENT,
+  SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT,
+  SUBAGENT_RESULT_INTERCOM_EVENT,
+  getErrorMessage,
+  parseSubagentIntercomPayload,
+} from "./intercom-utils.js";
+
+interface SubagentRelayDeps {
+  runtimeGeneration(): number;
+  runtimeStarted(): boolean;
+  runtimeContext(): ExtensionContext | null;
+  getLiveContext(ctx?: ExtensionContext | null, generation?: number): ExtensionContext | null;
+  currentSessionTargetMatches(to: string, resolvedTo?: string | null, activeClient?: IntercomClient): boolean;
+  sendIncomingMessage(entry: { from: SessionInfo; message: Message; bodyText: string }, delivery: "trigger" | "followUp", generation?: number): void;
+  ensureConnected(reason: "background"): Promise<IntercomClient>;
+  resolveSessionTarget(activeClient: IntercomClient, nameOrId: string): Promise<string | null>;
+}
+
+export function registerSubagentRelay(pi: ExtensionAPI, deps: SubagentRelayDeps): void {
+  const { getLiveContext, currentSessionTargetMatches, sendIncomingMessage, ensureConnected, resolveSessionTarget } = deps;
+  function deliverLocalSubagentRelayMessage(sender: "subagent-control" | "subagent-result", status: string, messageText: string): void {
+    const now = Date.now();
+    sendIncomingMessage({
+      from: {
+        id: sender,
+        name: sender,
+        cwd: deps.runtimeContext()?.cwd ?? process.cwd(),
+        model: sender,
+        pid: process.pid,
+        startedAt: now,
+        lastActivity: now,
+        status,
+      },
+      message: {
+        id: randomUUID(),
+        timestamp: now,
+        content: { text: messageText },
+      },
+      bodyText: messageText,
+    }, "trigger");
+  }
+  function recordSubagentDeliveryError(entryType: string, to: string, message: string, error: unknown): void {
+    pi.appendEntry(entryType, {
+      to,
+      message,
+      error: getErrorMessage(error),
+      timestamp: Date.now(),
+    });
+  }
+  function emitResultDelivery(requestId: string | undefined, delivered: boolean, error?: unknown): void {
+    if (!requestId) return;
+    pi.events.emit(SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT, {
+      requestId,
+      delivered,
+      ...(error ? { error: getErrorMessage(error) } : {}),
+    });
+  }
+  function relaySubagentIntercomPayload(payload: unknown, options: {
+    sender: "subagent-control" | "subagent-result";
+    status: string;
+    errorEntryType: string;
+    acknowledge?: boolean;
+  }): void {
+    const parsed = parseSubagentIntercomPayload(payload);
+    if (!parsed) return;
+
+    const relayGeneration = deps.runtimeGeneration();
+    void (async () => {
+      const relayStillLive = () => !deps.runtimeStarted() || Boolean(getLiveContext(deps.runtimeContext(), relayGeneration));
+      if (!relayStillLive()) {
+        return;
+      }
+      if (currentSessionTargetMatches(parsed.to)) {
+        deliverLocalSubagentRelayMessage(options.sender, options.status, parsed.message);
+        if (options.acknowledge) emitResultDelivery(parsed.requestId, true);
+        return;
+      }
+
+      let activeClient: IntercomClient;
+      let target: string;
+      try {
+        activeClient = await ensureConnected("background");
+        target = await resolveSessionTarget(activeClient, parsed.to) ?? parsed.to;
+      } catch (error) {
+        if (!relayStillLive()) return;
+        recordSubagentDeliveryError(options.errorEntryType, parsed.to, parsed.message, error);
+        if (options.acknowledge) emitResultDelivery(parsed.requestId, false, error);
+        return;
+      }
+
+      if (!relayStillLive()) {
+        return;
+      }
+      if (currentSessionTargetMatches(parsed.to, target, activeClient)) {
+        deliverLocalSubagentRelayMessage(options.sender, options.status, parsed.message);
+        if (options.acknowledge) emitResultDelivery(parsed.requestId, true);
+        return;
+      }
+
+      try {
+        const result = await activeClient.send(target, { text: parsed.message });
+        if (!relayStillLive()) return;
+        if (!result.delivered) {
+          const error = new Error(result.reason ?? "Session may not exist or has disconnected.");
+          recordSubagentDeliveryError(options.errorEntryType, parsed.to, parsed.message, error);
+          if (options.acknowledge) emitResultDelivery(parsed.requestId, false, error);
+          return;
+        }
+        if (options.acknowledge) emitResultDelivery(parsed.requestId, true);
+      } catch (error) {
+        if (!relayStillLive()) return;
+        recordSubagentDeliveryError(options.errorEntryType, parsed.to, parsed.message, error);
+        if (options.acknowledge) emitResultDelivery(parsed.requestId, false, error);
+      }
+    })();
+  }
+  pi.events.on(SUBAGENT_CONTROL_INTERCOM_EVENT, (payload) => {
+    relaySubagentIntercomPayload(payload, {
+      sender: "subagent-control",
+      status: "needs_attention",
+      errorEntryType: "intercom_control_error",
+    });
+  });
+  pi.events.on(SUBAGENT_RESULT_INTERCOM_EVENT, (payload) => {
+    relaySubagentIntercomPayload(payload, {
+      sender: "subagent-result",
+      status: "result",
+      errorEntryType: "intercom_result_error",
+      acknowledge: true,
+    });
+  });
+}

package/dist/builtin/mcp/CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.0-alpha.1] - 2026-06-20
+
 ### Fixed
 
 - Hardened `unflattenToolArguments` against prototype pollution: a flattened key whose path walks through `__proto__`, `constructor`, or `prototype` (at any position, including the final segment and a literal plain key) is now dropped instead of being written, so a model-emitted key such as `__proto__.polluted` can no longer reach and mutate `Object.prototype`. The reconstruction logic (parse/assign/compact plus this guard) is now imported from a single canonical implementation in `@bastani/atomic` (`reconstructFlattenedKeys`) instead of being duplicated in `packages/mcp/utils.ts`, so the host-runtime and MCP `callTool` paths can no longer drift (the previous near-duplicate copies had already diverged on the security guard). Behavior for well-formed and ordinary flattened arguments is unchanged.
@@ -15,6 +17,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 
 - Aligned the MCP extension peer dependencies with upstream pi AI/TUI `^0.79.7` so MCP-backed sessions can use the host's latest provider catalog, model-search, theme/color-scheme, Warp image capability, and shared TUI compatibility fixes; no MCP extension code changes were made for this metadata sync ([#1413](https://github.com/bastani-inc/atomic/issues/1413)).
+- Changed contributor validation to include the monorepo-wide file-length gate for tracked TS/JS/Rust files in local `prek` hooks and PR CI, with only documented generated/vendored exclusions and no grandfathered baseline allowlist ([#1445](https://github.com/bastani-inc/atomic/issues/1445)).
 
 ## [0.8.30] - 2026-06-17
 

package/dist/builtin/mcp/config-write-utils.ts

@@ -0,0 +1,104 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import type { ServerEntry } from "./types.ts";
+
+export interface ConfigWritePreview {
+  path: string;
+  existed: boolean;
+  changed: boolean;
+  beforeText: string;
+  afterText: string;
+  diffText: string;
+}
+
+function serializeRawConfig(raw: Record<string, unknown>): string {
+  return `${JSON.stringify(raw, null, 2)}\n`;
+}
+
+function buildUnifiedDiff(beforeText: string, afterText: string): string {
+  if (beforeText === afterText) return "(no changes)";
+
+  const before = beforeText.split("\n");
+  const after = afterText.split("\n");
+  const rows = before.length;
+  const cols = after.length;
+  const lcs = Array.from({ length: rows + 1 }, () => Array<number>(cols + 1).fill(0));
+
+  for (let i = rows - 1; i >= 0; i--) {
+    for (let j = cols - 1; j >= 0; j--) {
+      lcs[i][j] = before[i] === after[j]
+        ? lcs[i + 1][j + 1] + 1
+        : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+    }
+  }
+
+  const lines: string[] = ["--- before", "+++ after"];
+  let i = 0;
+  let j = 0;
+  while (i < rows || j < cols) {
+    if (i < rows && j < cols && before[i] === after[j]) {
+      lines.push(`  ${before[i]}`);
+      i++;
+      j++;
+      continue;
+    }
+    if (j < cols && (i === rows || lcs[i][j + 1] >= lcs[i + 1][j])) {
+      lines.push(`+ ${after[j]}`);
+      j++;
+      continue;
+    }
+    if (i < rows) {
+      lines.push(`- ${before[i]}`);
+      i++;
+    }
+  }
+
+  return lines.join("\n");
+}
+
+export function buildConfigWritePreview(filePath: string, nextRaw: Record<string, unknown>): ConfigWritePreview {
+  const existed = existsSync(filePath);
+  const beforeRaw = readRawConfigObject(filePath);
+  const beforeText = existed ? serializeRawConfig(beforeRaw) : "";
+  const afterText = serializeRawConfig(nextRaw);
+  return {
+    path: filePath,
+    existed,
+    changed: beforeText !== afterText,
+    beforeText,
+    afterText,
+    diffText: buildUnifiedDiff(beforeText, afterText),
+  };
+}
+
+export function readRawConfigObject(filePath: string): Record<string, unknown> {
+  if (!existsSync(filePath)) return {};
+
+  try {
+    const raw = JSON.parse(readFileSync(filePath, "utf-8"));
+    return raw && typeof raw === "object" && !Array.isArray(raw) ? raw as Record<string, unknown> : {};
+  } catch {
+    return {};
+  }
+}
+
+export function writeRawConfigObject(filePath: string, raw: Record<string, unknown>): void {
+  mkdirSync(dirname(filePath), { recursive: true });
+  const tmpPath = `${filePath}.${process.pid}.tmp`;
+  writeFileSync(tmpPath, `${JSON.stringify(raw, null, 2)}\n`, "utf-8");
+  renameSync(tmpPath, filePath);
+}
+
+export function getServersObject(raw: Record<string, unknown>): Record<string, ServerEntry> {
+  const existing = raw.mcpServers ?? raw["mcp-servers"] ?? {};
+  if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
+    return {};
+  }
+  return existing as Record<string, ServerEntry>;
+}
+
+export function setServersObject(raw: Record<string, unknown>, servers: Record<string, ServerEntry>): void {
+  delete raw["mcp-servers"];
+  raw.mcpServers = servers;
+}
+