negotium 0.1.7 → 0.1.9

package/dist/runtime/src/mcp/session-comm/topic-config.ts

@@ -0,0 +1,131 @@
+/**
+ * Mutations and reads scoped to the *current* topic (the one this MCP server
+ * was spawned for). Splitting these out from `topics.ts` keeps read-only,
+ * cross-topic queries separate from writes that only make sense for
+ * `currentTopic`.
+ */
+import { existsSync } from "node:fs";
+import { OPTIONAL_FORUM_MCP_SERVERS, REQUIRED_FORUM_MCP_SERVERS } from "#platform/mcp-config";
+import { getApiTopicConfig, setApiTopicConfig } from "#storage/api-topic-config";
+import { getTopic, getTopicByNameForUser } from "#storage/api-topics";
+import {
+  currentTopic,
+  currentTopicId,
+  parseJsonField,
+  SESSIONS_DB,
+  userId,
+  withDb,
+} from "./runtime";
+
+export function currentApiTopicId(): string | null {
+  if (!userId) return null;
+  if (currentTopicId) {
+    try {
+      const topic = getTopic(currentTopicId);
+      if (!topic) {
+        process.stderr.write(`warn: session-comm: api topic id not found: ${currentTopicId}\n`);
+        return null;
+      }
+      if (!topic.participants.some((p) => p.userId === userId)) {
+        process.stderr.write(
+          `warn: session-comm: user ${userId} is not a participant of topic id ${currentTopicId}\n`,
+        );
+        return null;
+      }
+      return topic.id;
+    } catch (e) {
+      process.stderr.write(`warn: session-comm: api topic id lookup failed: ${e}\n`);
+      return null;
+    }
+  }
+  if (!currentTopic) return null;
+  try {
+    return getTopicByNameForUser(currentTopic, userId)?.id ?? null;
+  } catch (e) {
+    process.stderr.write(`warn: session-comm: api topic lookup failed: ${e}\n`);
+    return null;
+  }
+}
+
+function normalizeMcpEnabled(enabled: string[] | null): string[] | undefined {
+  if (enabled === null) return undefined;
+  const requested = [...new Set(enabled.map((n) => n.trim()).filter(Boolean))];
+  const invalid = requested.filter(
+    (n) => !OPTIONAL_FORUM_MCP_SERVERS.includes(n) && !REQUIRED_FORUM_MCP_SERVERS.includes(n),
+  );
+  if (invalid.length > 0) {
+    throw new Error(
+      `Unknown MCP server(s): ${invalid.join(", ")}. Optional servers are: ${OPTIONAL_FORUM_MCP_SERVERS.join(", ")}.`,
+    );
+  }
+  return requested.filter((n) => OPTIONAL_FORUM_MCP_SERVERS.includes(n));
+}
+
+export function getMcpConfig(): { enabled: string[] | null; extra: Record<string, unknown> } {
+  const apiTopicId = currentApiTopicId();
+  if (apiTopicId) {
+    return { enabled: getApiTopicConfig(apiTopicId)?.mcp ?? [], extra: {} };
+  }
+
+  if (!existsSync(SESSIONS_DB)) return { enabled: null, extra: {} };
+  try {
+    return withDb((db) => {
+      const row = db
+        .query<{ mcp_enabled: string | null; mcp_extra: string | null }, [string, string]>(
+          "SELECT mcp_enabled, mcp_extra FROM topics WHERE user_id = ? AND name = ?",
+        )
+        .get(userId, currentTopic);
+      const enabled =
+        parseJsonField<string[] | null>(
+          row?.mcp_enabled,
+          `mcp_enabled for topic "${currentTopic}"`,
+        ) ?? null;
+      const extra =
+        parseJsonField<Record<string, unknown>>(
+          row?.mcp_extra,
+          `mcp_extra for topic "${currentTopic}"`,
+        ) ?? {};
+      return { enabled, extra };
+    });
+  } catch (e) {
+    process.stderr.write(`warn: session-comm: getMcpConfig DB query failed: ${e}\n`);
+    return { enabled: null, extra: {} };
+  }
+}
+
+export function setCurrentTopicDescription(description: string) {
+  withDb(
+    (db) => {
+      db.query("UPDATE topics SET description = ? WHERE user_id = ? AND name = ?").run(
+        description,
+        userId,
+        currentTopic,
+      );
+    },
+    { write: true },
+  );
+}
+
+export function setMcpConfig(enabled?: string[] | null) {
+  const apiTopicId = currentApiTopicId();
+  if (apiTopicId) {
+    if (enabled !== undefined) {
+      const existing = getApiTopicConfig(apiTopicId) ?? {};
+      setApiTopicConfig(apiTopicId, { ...existing, mcp: normalizeMcpEnabled(enabled) });
+    }
+    return;
+  }
+
+  withDb(
+    (db) => {
+      if (enabled !== undefined) {
+        db.query("UPDATE topics SET mcp_enabled = ? WHERE user_id = ? AND name = ?").run(
+          enabled !== null ? JSON.stringify(enabled) : null,
+          userId,
+          currentTopic,
+        );
+      }
+    },
+    { write: true },
+  );
+}

package/dist/runtime/src/mcp/session-comm/topics.ts

@@ -0,0 +1,229 @@
+/**
+ * Topic-level data access for the session-comm MCP server.
+ *
+ * All read-only DB queries that return topic entities live here. Mutations
+ * against the *current* topic belong in `topic-config.ts`; runtime/CLI
+ * concerns belong in `runtime.ts`.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { sessionInboxPath } from "#query/session-inbox-path";
+import { sanitizeTopicName } from "#security/sanitize";
+// NOTE: see `runtime.ts` — import these from `@/types` directly to keep
+// `maestro-agent-sdk` (whose `bootstrapHostPath()` prints to stdout) out of
+// this stdio MCP server's import graph.
+import { type AgentKind, isAgentKind, type QueryState } from "#types";
+import {
+  currentTopic,
+  currentTopicId,
+  PLAYWRIGHT_PORTS_DIR,
+  parseJsonField,
+  SESSIONS_DB,
+  userId,
+  withDb,
+} from "./runtime";
+
+export type { QueryState };
+
+// --- Topic entry types ---
+
+export interface TopicEntry {
+  sessionId: string;
+  messageThreadId: number;
+  name: string;
+  description?: string;
+  /** api_topics id (UUID) — delivery target for tell/ask. */
+  topicId?: string;
+  /** REST topics can be human-only. ask_session/tell_session require an AI target. */
+  agent?: AgentKind;
+}
+
+export interface McpTopicEntry {
+  sessionId: string;
+  messageThreadId: number;
+  name: string;
+  createdAt: string;
+  description?: string;
+  agent: AgentKind;
+  mcpEnabled?: string[] | null;
+  mcpExtra?: Record<string, unknown>;
+}
+
+export interface McpUserConfig {
+  dmSessionId?: string;
+  topics: { [name: string]: McpTopicEntry };
+}
+
+export type ValidateTargetResult =
+  | { ok: true; target: TopicEntry }
+  | { ok: false; error: { content: Array<{ type: "text"; text: string }>; isError: true } };
+
+// --- Queries ---
+
+export function validateTarget(to: string): ValidateTargetResult {
+  const topics = getTopicsForUser();
+  const target = topics[to];
+  if (!target) {
+    const available = Object.entries(topics)
+      .filter(([name, topic]) => name !== currentTopic && Boolean(topic.agent))
+      .map(([name]) => name);
+    return {
+      ok: false,
+      error: {
+        content: [
+          {
+            type: "text" as const,
+            text: `Error: Session "${to}" not found.\nAvailable: ${available.join(", ") || "none"}`,
+          },
+        ],
+        isError: true,
+      },
+    };
+  }
+  // Topics without an active session (sessionId === "") are still valid
+  // targets — ask_session / tell_session deliveries will wake them with a
+  // fresh session via the session-inbox worker. See `session-inbox.ts`.
+  return { ok: true, target };
+}
+
+export function getTopicsForUser(): { [name: string]: TopicEntry } {
+  if (!existsSync(SESSIONS_DB)) return {};
+  try {
+    return withDb((db) => {
+      // Otium topics live in `api_topics`; membership is normalized in
+      // `topic_members`. Expose the current user's rooms keyed by title.
+      const rows = db
+        .query<
+          {
+            id: string;
+            title: string;
+            kind: string | null;
+            agent: string | null;
+            session_id: string | null;
+            description: string | null;
+          },
+          string
+        >(
+          `SELECT t.id, t.title, t.kind, t.agent, t.session_id, t.description
+           FROM api_topics t
+           INNER JOIN topic_members m ON m.topic_id = t.id
+           WHERE m.user_id = ?`,
+        )
+        .all(userId);
+      const entries: Array<{ key: string; entry: TopicEntry }> = [];
+      const titleCounts = new Map<string, number>();
+      for (const row of rows) {
+        if (row.kind === "manager") continue;
+        if (currentTopicId && row.id === currentTopicId) continue;
+        if (row.title === currentTopic) continue;
+        const agent = isAgentKind(row.agent) ? row.agent : undefined;
+        const kind = row.kind === "agent" ? "agent" : "channel";
+        const entry = {
+          sessionId: row.session_id ?? "",
+          messageThreadId: 0,
+          name: row.title,
+          topicId: row.id,
+          ...(agent && { agent }),
+          ...(row.description && { description: row.description }),
+        };
+        entries.push({ key: `${kind}:${row.title}`, entry });
+        titleCounts.set(row.title, (titleCounts.get(row.title) ?? 0) + 1);
+      }
+
+      const result: { [name: string]: TopicEntry } = {};
+      for (const { key, entry } of entries) {
+        result[key] = entry;
+        if ((titleCounts.get(entry.name) ?? 0) === 1) result[entry.name] = entry;
+      }
+      return result;
+    });
+  } catch (e) {
+    process.stderr.write(`warn: session-comm: failed to load topics from DB: ${e}\n`);
+    return {};
+  }
+}
+
+export function getMcpUserConfig(): McpUserConfig | null {
+  if (!existsSync(SESSIONS_DB)) return null;
+  try {
+    return withDb((db) => {
+      const user = db
+        .query<{ dm_session_id: string | null }, string>(
+          "SELECT dm_session_id FROM users WHERE id = ?",
+        )
+        .get(userId);
+      if (!user) return null;
+      const dmSessionId = user.dm_session_id;
+
+      const topicRows = db
+        .query<
+          {
+            name: string;
+            message_thread_id: number;
+            session_id: string | null;
+            created_at: string;
+            description: string | null;
+            agent: string | null;
+            mcp_enabled: string | null;
+            mcp_extra: string | null;
+          },
+          string
+        >(
+          "SELECT name, message_thread_id, session_id, created_at, description, agent, mcp_enabled, mcp_extra FROM topics WHERE user_id = ?",
+        )
+        .all(userId);
+
+      const topics: { [name: string]: McpTopicEntry } = {};
+      for (const row of topicRows) {
+        const mcpEnabled = parseJsonField<string[] | null>(
+          row.mcp_enabled,
+          `mcp_enabled for "${row.name}"`,
+        );
+        const mcpExtra = parseJsonField<Record<string, unknown>>(
+          row.mcp_extra,
+          `mcp_extra for "${row.name}"`,
+        );
+        if (!isAgentKind(row.agent)) throw new Error(`Invalid agent in DB: ${row.agent}`);
+        const agent: AgentKind = row.agent;
+        topics[row.name] = {
+          name: row.name,
+          messageThreadId: row.message_thread_id,
+          sessionId: row.session_id ?? "",
+          createdAt: row.created_at,
+          agent,
+          ...(row.description && { description: row.description }),
+          ...(mcpEnabled !== undefined && { mcpEnabled }),
+          ...(mcpExtra !== undefined && { mcpExtra }),
+        };
+      }
+
+      return {
+        ...(dmSessionId && { dmSessionId }),
+        topics,
+      };
+    });
+  } catch (e) {
+    process.stderr.write(`warn: session-comm: getMcpUserConfig failed: ${e}\n`);
+    return null;
+  }
+}
+
+/**
+ * Build the session-inbox jsonl path.
+ */
+export function buildInboxPath(targetTopicId: string): string {
+  return sessionInboxPath(userId, targetTopicId);
+}
+
+/** Look up the playwright SSE port for the target topic from the port file */
+export function getPlaywrightPort(topic: string): number | null {
+  if (!userId || !topic) return null;
+  const safeTopicName = sanitizeTopicName(topic);
+  const portFile = join(PLAYWRIGHT_PORTS_DIR, `${userId}_${safeTopicName}`);
+  try {
+    const port = parseInt(readFileSync(portFile, "utf-8").trim(), 10);
+    return Number.isNaN(port) ? null : port;
+  } catch {
+    return null;
+  }
+}

package/dist/runtime/src/mcp/stdio-protect.ts

@@ -0,0 +1,84 @@
+/**
+ * Side-effect module: protect the MCP JSON-RPC stdio channel from rogue
+ * stdout writes by transitively-imported dependencies.
+ *
+ * Problem
+ * -------
+ * MCP servers in stdio mode use `process.stdout` as a JSON-RPC framing
+ * channel — every line must parse as JSON. If any imported module logs to
+ * stdout (e.g. via `console.log`) during module evaluation or at any later
+ * point, the receiving client's MCP parser sees a non-JSON line and aborts:
+ *
+ *   ERROR rmcp::transport::async_rw: Error reading from stream:
+ *     serde error expected value at line 1 column 2
+ *
+ * The host then drops every tool exposed by that server.
+ *
+ * Status (maestro-agent-sdk ≥ 0.1.14)
+ * -----------------------------------
+ * The original motivating offender — `bootstrapHostPath()` in
+ * `maestro-agent-sdk` — is fixed at the source as of v0.1.13: its default
+ * console logger now routes every level to stderr, and v0.1.14 ships a
+ * `MAESTRO_SDK_SILENT_BOOTSTRAP=1` env to suppress the line entirely.
+ * This module sets that env defensively (before any SDK import resolves)
+ * and keeps the broad `console.*` redirect in place as a safety net for
+ * any *other* transitive dep that might log to stdout in the future. The
+ * cost is essentially zero and the failure mode is silent tool loss, so
+ * the belt-and-suspenders posture stays.
+ *
+ * Fix
+ * ---
+ * Re-route `console.log` / `console.info` (and `process.stdout.write` for
+ * a final belt-and-suspenders catch) to stderr. The real MCP transport
+ * still uses `process.stdout.write` directly via the @modelcontextprotocol
+ * SDK, so JSON-RPC frames are unaffected — only stray writes are diverted.
+ *
+ * Wait — doesn't redirecting `process.stdout.write` break the transport?
+ * No: the @modelcontextprotocol/sdk stdio transport holds a bound
+ * reference to the *original* `stdout.write` captured when the
+ * StdioServerTransport is instantiated. We override the property *before*
+ * any of those imports run, but the transport binds its own ref at
+ * construction time — which happens via `connectStdio()` *after* this
+ * module has applied the redirect. To guarantee transport writes still
+ * land on stdout, we expose `realStdoutWrite` so any code that needs a
+ * raw stdout channel can use it explicitly. The default transport works
+ * because we only redirect `console.*`, not `process.stdout.write`.
+ *
+ * Usage
+ * -----
+ * Import this **as the very first import** in every stdio MCP server's
+ * entry-point file:
+ *
+ *   #!/usr/bin/env node
+ *   import "./stdio-protect";
+ *   // … rest of the imports
+ *
+ * Being first matters: ES modules evaluate dependencies in DFS post-order,
+ * so a side-effect module placed at the top of the import list runs before
+ * any sibling `import` that might transitively pull in a stdout-noisy dep.
+ */
+
+// Suppress maestro-agent-sdk's bootstrap log line at source (v0.1.14+).
+// Must run before any `import` of the SDK resolves — placing this in the
+// module body of stdio-protect (always the first import) achieves that
+// because ES module evaluation is DFS post-order: side-effect statements
+// at the top of this file run before sibling imports finish hydrating.
+process.env.MAESTRO_SDK_SILENT_BOOTSTRAP ??= "1";
+
+const origLog = console.log.bind(console);
+const origInfo = console.info.bind(console);
+
+console.log = (...args: unknown[]) => {
+  // Route to stderr; preserve the original signature so callers that pass
+  // format strings + interpolation args still work.
+  console.error(...args);
+};
+console.info = (...args: unknown[]) => {
+  console.error(...args);
+};
+
+// Expose originals for tests / explicit re-entry, even though we don't
+// currently rely on them. Marked `void` so unused-import lints don't fire
+// when this file is imported only for its side-effect.
+export const __origConsoleLog: (...args: unknown[]) => void = origLog;
+export const __origConsoleInfo: (...args: unknown[]) => void = origInfo;

package/dist/runtime/src/mcp/system-health-server.ts

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+import { execFile } from "node:child_process";
+import { cpus, freemem, loadavg, totalmem } from "node:os";
+import { promisify } from "node:util";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { errMsg } from "#platform/error";
+import { connectStdio, mcpOk } from "./mcp-helpers";
+
+const execFileAsync = promisify(execFile);
+
+function fmtBytes(bytes: number): string {
+  const gb = bytes / 1024 ** 3;
+  return gb >= 1 ? `${gb.toFixed(1)}GB` : `${(bytes / 1024 ** 2).toFixed(0)}MB`;
+}
+
+async function shell(cmd: string, args: string[]): Promise<string> {
+  const { stdout } = await execFileAsync(cmd, args, { timeout: 5000 });
+  return stdout.trim();
+}
+
+async function getMemoryPressure(): Promise<string> {
+  try {
+    const level = await shell("sysctl", ["-n", "kern.memorystatus_vm_pressure_level"]);
+    return level === "4" ? "critical" : level === "2" ? "warning" : "normal";
+  } catch {
+    return "unknown";
+  }
+}
+
+async function getSwapUsage(): Promise<string> {
+  try {
+    const out = await shell("sysctl", ["vm.swapusage"]);
+    // vm.swapusage: total = 2048.00M  used = 606.00M  free = 1442.00M
+    const m = out.match(
+      /total\s*=\s*([\d.]+\w+)\s+used\s*=\s*([\d.]+\w+)\s+free\s*=\s*([\d.]+\w+)/,
+    );
+    return m ? `used ${m[2]} / total ${m[1]}  여유: ${m[3]}` : out;
+  } catch (e) {
+    return errMsg(e);
+  }
+}
+
+async function getThermal(): Promise<string> {
+  try {
+    const out = await shell("pmset", ["-g", "therm"]);
+    // Look for "System Thermal Level" or "CPU_Scheduler_Limit"
+    const cpuLimit = out.match(/CPU_Scheduler_Limit\s*=\s*(\d+)/)?.[1];
+    const cpuAvail = out.match(/CPU_Available_CPUs\s*=\s*(\d+)/)?.[1];
+    const thermalLevel = out.match(/System Thermal Level\s*=\s*(\d+)/)?.[1];
+    const parts: string[] = [];
+    if (thermalLevel !== undefined) parts.push(`level ${thermalLevel}`);
+    if (cpuLimit !== undefined) parts.push(`CPU scheduler limit ${cpuLimit}%`);
+    if (cpuAvail !== undefined) parts.push(`available CPUs ${cpuAvail}`);
+    return parts.length > 0 ? parts.join(", ") : "nominal";
+  } catch (e) {
+    return errMsg(e);
+  }
+}
+
+async function getProcessCount(): Promise<number> {
+  try {
+    const out = await shell("ps", ["-A", "-o", "pid="]);
+    return out.split("\n").filter(Boolean).length;
+  } catch {
+    return -1;
+  }
+}
+
+async function getDisk(): Promise<string> {
+  try {
+    const out = await shell("df", ["-k", "-P", "/"]);
+    const parts = out.split("\n")[1]?.split(/\s+/);
+    if (!parts || parts.length < 4) return "조회 실패";
+    const diskTotal = Number(parts[1]) * 1024;
+    const diskUsed = Number(parts[2]) * 1024;
+    const diskAvail = Number(parts[3]) * 1024;
+    const diskPct = ((diskUsed / diskTotal) * 100).toFixed(1);
+    return `${fmtBytes(diskUsed)} / ${fmtBytes(diskTotal)} (${diskPct}%)  여유: ${fmtBytes(diskAvail)}`;
+  } catch (e) {
+    return errMsg(e);
+  }
+}
+
+const server = new McpServer({ name: "system-health", version: "1.0.0" });
+
+server.tool(
+  "get_system_health",
+  [
+    "시스템 상태를 조회합니다.",
+    "- CPU 부하 (load average 1/5/15분)",
+    "- 메모리 사용량 + 압력 (normal/warning/critical)",
+    "- 스왑 사용량",
+    "- 디스크 사용률 (/)",
+    "- 열 상태 (thermal)",
+    "- 프로세스 수",
+  ].join("\n"),
+  {},
+  async () => {
+    const [memPressure, swap, thermal, disk, procCount] = await Promise.all([
+      getMemoryPressure(),
+      getSwapUsage(),
+      getThermal(),
+      getDisk(),
+      getProcessCount(),
+    ]);
+
+    const total = totalmem();
+    const free = freemem();
+    const used = total - free;
+    const memPct = ((used / total) * 100).toFixed(1);
+    const [l1, l5, l15] = loadavg();
+    const numCpus = cpus().length;
+
+    return mcpOk(
+      [
+        "시스템 상태",
+        "",
+        `CPU 부하:      ${l1.toFixed(2)} / ${l5.toFixed(2)} / ${l15.toFixed(2)}  (1/5/15분, 코어 ${numCpus}개)`,
+        `메모리:        ${fmtBytes(used)} / ${fmtBytes(total)} (${memPct}%)  여유: ${fmtBytes(free)}`,
+        `메모리 압력:   ${memPressure}`,
+        `스왑:          ${swap}`,
+        `디스크(/):     ${disk}`,
+        `열 상태:       ${thermal}`,
+        `프로세스 수:   ${procCount > 0 ? `${procCount}개` : "조회 실패"}`,
+      ].join("\n"),
+    );
+  },
+);
+
+await connectStdio(server);