negotium 0.1.7 → 0.1.8

package/dist/runtime/src/mcp/task-server.ts

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+import "./stdio-protect";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { errMsg } from "#platform/error";
+import {
+  createTasks,
+  deleteTasks,
+  readTasks,
+  renderTaskList,
+  TASK_STATUS_VALUES,
+  taskScopeKey,
+  updateTasks,
+  writeTasks,
+} from "#storage/tasks";
+import { connectStdio, mcpError, mcpOk, parseUserIdArg } from "./mcp-helpers";
+
+const args = process.argv.slice(2);
+const userId = parseUserIdArg(args);
+const topic = args.find((arg) => arg.startsWith("--topic="))?.slice("--topic=".length) || "";
+const topicId =
+  args.find((arg) => arg.startsWith("--topic-id="))?.slice("--topic-id=".length) || undefined;
+const scopeKey = topic ? taskScopeKey({ topicId, session: topic }) : "";
+
+const server = new McpServer({ name: "task", version: "1.0.0" });
+
+function requireContext(): ReturnType<typeof mcpError> | null {
+  if (!userId || !scopeKey) {
+    return mcpError("Error: missing userId/topic context.");
+  }
+  return null;
+}
+
+const STATUS_ENUM = z.enum(TASK_STATUS_VALUES);
+
+server.tool(
+  "task_create",
+  "Add one or more tasks to this topic's shared Otium task list. Use this instead of provider-native todo/task tools.",
+  {
+    tasks: z
+      .array(
+        z.object({
+          subject: z.string().min(1).describe("Short imperative task description"),
+          active_form: z
+            .string()
+            .optional()
+            .describe("Label to show while the task is in progress"),
+          blocked_by: z.array(z.string()).optional().describe("Task ids blocking this task"),
+          owner: z.string().optional().describe("Owner/agent label for multi-agent work"),
+        }),
+      )
+      .min(1),
+  },
+  async ({ tasks: inputs }) => {
+    const guard = requireContext();
+    if (guard) return guard;
+    try {
+      const current = readTasks(userId, scopeKey);
+      const { tasks, created } = createTasks(
+        current,
+        inputs.map((task) => ({
+          subject: task.subject,
+          activeForm: task.active_form,
+          blockedBy: task.blocked_by,
+          owner: task.owner,
+        })),
+      );
+      writeTasks(userId, scopeKey, tasks);
+      const ids = created.map((task) => `#${task.id}`).join(", ");
+      return mcpOk(`${created.length} task(s) created (${ids})\n\n${renderTaskList(tasks)}`);
+    } catch (e) {
+      return mcpError(`task_create failed: ${errMsg(e)}`);
+    }
+  },
+);
+
+server.tool(
+  "task_update",
+  "Update task status/content in this topic's shared Otium task list. Batch related status changes in one call.",
+  {
+    updates: z
+      .array(
+        z.object({
+          id: z.string().describe("Target task id"),
+          status: STATUS_ENUM.optional().describe("New status"),
+          subject: z.string().min(1).optional().describe("Replacement task description"),
+          active_form: z
+            .string()
+            .optional()
+            .describe("Replacement in-progress label; empty string clears it"),
+          blocked_by: z.array(z.string()).optional().describe("Replacement blocker id list"),
+          owner: z.string().optional().describe("Replacement owner; empty string clears it"),
+        }),
+      )
+      .min(1),
+  },
+  async ({ updates }) => {
+    const guard = requireContext();
+    if (guard) return guard;
+    try {
+      const current = readTasks(userId, scopeKey);
+      const { tasks, missing } = updateTasks(
+        current,
+        updates.map((update) => ({
+          id: update.id,
+          status: update.status,
+          subject: update.subject,
+          activeForm: update.active_form,
+          blockedBy: update.blocked_by,
+          owner: update.owner,
+        })),
+      );
+      writeTasks(userId, scopeKey, tasks);
+      const warn = missing.length > 0 ? `\nMissing ids ignored: ${missing.join(", ")}` : "";
+      return mcpOk(`${renderTaskList(tasks)}${warn}`);
+    } catch (e) {
+      return mcpError(`task_update failed: ${errMsg(e)}`);
+    }
+  },
+);
+
+server.tool("task_list", "Read this topic's shared Otium task list.", {}, async () => {
+  const guard = requireContext();
+  if (guard) return guard;
+  try {
+    return mcpOk(renderTaskList(readTasks(userId, scopeKey)));
+  } catch (e) {
+    return mcpError(`task_list failed: ${errMsg(e)}`);
+  }
+});
+
+server.tool(
+  "task_get",
+  "Read one task from this topic's shared Otium task list as JSON.",
+  { id: z.string().describe("Task id") },
+  async ({ id }) => {
+    const guard = requireContext();
+    if (guard) return guard;
+    try {
+      const task = readTasks(userId, scopeKey).find((entry) => entry.id === id);
+      if (!task) return mcpError(`Task #${id} not found.`);
+      return mcpOk(JSON.stringify(task, null, 2));
+    } catch (e) {
+      return mcpError(`task_get failed: ${errMsg(e)}`);
+    }
+  },
+);
+
+server.tool(
+  "task_delete",
+  "Delete tasks from this topic's shared Otium task list. Use all=true only when starting a new plan.",
+  {
+    ids: z.array(z.string()).optional().describe("Task ids to delete"),
+    all: z.boolean().optional().describe("Delete the whole list"),
+  },
+  async ({ ids, all }) => {
+    const guard = requireContext();
+    if (guard) return guard;
+    if (!all && (!ids || ids.length === 0)) {
+      return mcpError("Provide ids or all=true.");
+    }
+    try {
+      const current = readTasks(userId, scopeKey);
+      const { tasks, removed } = deleteTasks(current, { ids, all });
+      writeTasks(userId, scopeKey, tasks);
+      return mcpOk(`${removed} task(s) deleted\n\n${renderTaskList(tasks)}`);
+    } catch (e) {
+      return mcpError(`task_delete failed: ${errMsg(e)}`);
+    }
+  },
+);
+
+await connectStdio(server);

package/dist/runtime/src/mcp/token-stats-server.ts

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { connectStdio, parseUserIdArg } from "#mcp/mcp-helpers";
+import { calcCost, getStats } from "#storage/token-stats";
+
+const args = process.argv.slice(2);
+const userId = parseUserIdArg(args);
+if (!userId) {
+  process.stderr.write("token-stats-server: --user-id is required (decimal integer)\n");
+  process.exit(1);
+}
+
+const server = new McpServer({ name: "token-stats", version: "1.0.0" });
+
+server.tool(
+  "get_usage_stats",
+  [
+    "Claude 사용량 통계를 조회합니다. 완료된 쿼리마다 세션/시간 정보가 기록됩니다. 현재 실행 중인 turn은 완료 후 집계됩니다.",
+    "",
+    "from/to 생략 시 전체 기간. 자연어 시간 표현을 ISO 형식으로 변환해서 넘겨주세요.",
+    "  예: '지난 3시간' → from = 현재 -3h",
+    "  예: '오늘 오전' → from = 오늘 00:00Z, to = 오늘 12:00Z",
+    "  예: '어제' → from = 어제 00:00Z, to = 어제 23:59Z",
+    "",
+    "groupBy: 'session'으로 설정하면 세션별 토큰 사용량 랭킹을 반환합니다.",
+  ].join("\n"),
+  {
+    from: z.string().optional().describe("시작 시각 ISO 8601. 예: '2026-03-28T09:00:00Z'"),
+    to: z.string().optional().describe("종료 시각 ISO 8601. 생략 시 현재"),
+    groupBy: z.enum(["hour", "session"]).optional().describe("집계 기준. 기본값: hour"),
+  },
+  async ({ from, to, groupBy = "hour" }) => {
+    const { total, byHour, bySession, estimatedCostUsd } = getStats(userId, from, to);
+
+    const lines: string[] = [
+      "📊 Claude 사용량",
+      from || to ? `기간: ${from ?? "전체"} ~ ${to ?? "현재"}` : "기간: 전체",
+      "",
+      `쿼리 횟수: ${total.queries.toLocaleString()}회`,
+      `입력 토큰: ${total.inputTokens.toLocaleString()}`,
+      `출력 토큰: ${total.outputTokens.toLocaleString()}`,
+      `캐시 쓰기: ${total.cacheCreationInputTokens.toLocaleString()}`,
+      `캐시 읽기: ${total.cacheReadInputTokens.toLocaleString()}`,
+      `예상 비용: $${estimatedCostUsd.toFixed(4)} USD`,
+    ];
+
+    if (groupBy === "session") {
+      const sorted = Object.entries(bySession)
+        .map(([name, b]) => ({ name, ...b, cost: calcCost(b) }))
+        .sort((a, b) => b.cost - a.cost);
+
+      lines.push("", `🗂 세션별 사용량 (${sorted.length}개)`);
+      for (const s of sorted) {
+        lines.push(
+          `  ${s.name}  쿼리 ${s.queries}회  입력 ${s.inputTokens.toLocaleString()} / 출력 ${s.outputTokens.toLocaleString()}  $${s.cost.toFixed(4)}`,
+        );
+      }
+    } else {
+      const hours = Object.keys(byHour).sort();
+      if (hours.length > 0 && hours.length <= 72) {
+        lines.push("", "📅 시간별 현황");
+        for (const h of hours) {
+          const b = byHour[h];
+          if (b.queries === 0) continue;
+          lines.push(
+            `  ${h}  쿼리 ${b.queries}회  입력 ${b.inputTokens.toLocaleString()} / 출력 ${b.outputTokens.toLocaleString()}  $${calcCost(b).toFixed(4)}`,
+          );
+        }
+      } else if (hours.length > 72) {
+        const byDate: Record<
+          string,
+          { queries: number; inputTokens: number; outputTokens: number; cost: number }
+        > = {};
+        for (const h of hours) {
+          const date = h.slice(0, 10);
+          if (!byDate[date])
+            byDate[date] = { queries: 0, inputTokens: 0, outputTokens: 0, cost: 0 };
+          const b = byHour[h];
+          byDate[date].queries += b.queries;
+          byDate[date].inputTokens += b.inputTokens;
+          byDate[date].outputTokens += b.outputTokens;
+          byDate[date].cost += calcCost(b);
+        }
+        lines.push("", `📅 일별 현황 (${Object.keys(byDate).length}일)`);
+        for (const [date, d] of Object.entries(byDate).sort()) {
+          lines.push(
+            `  ${date}  쿼리 ${d.queries}회  입력 ${d.inputTokens.toLocaleString()} / 출력 ${d.outputTokens.toLocaleString()}  $${d.cost.toFixed(4)}`,
+          );
+        }
+      }
+    }
+
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  },
+);
+
+await connectStdio(server);

package/dist/runtime/src/mcp/vault-http.ts

@@ -0,0 +1,219 @@
+import { logger } from "#platform/logger";
+import { redactVaultSecrets, vaultSubstituteDetailed } from "#storage/vault";
+
+const SAFE_RESPONSE_HEADERS = new Set([
+  "content-type",
+  "content-length",
+  "location",
+  "retry-after",
+  "x-ratelimit-limit",
+  "x-ratelimit-remaining",
+  "x-ratelimit-reset",
+]);
+
+const FORBIDDEN_REQUEST_HEADERS = new Set([
+  "connection",
+  "content-length",
+  "host",
+  "proxy-authorization",
+  "transfer-encoding",
+]);
+
+export interface VaultHttpRequest {
+  method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+  url: string;
+  headers?: Record<string, string>;
+  body?: string;
+  timeoutMs?: number;
+  maxResponseBytes?: number;
+}
+
+export interface VaultHttpResult {
+  ok: boolean;
+  status?: number;
+  statusText?: string;
+  headers?: Record<string, string>;
+  body?: string;
+  truncated?: boolean;
+  error?: string;
+}
+
+function substituteObject(
+  userId: string,
+  values: Record<string, string>,
+): { values: Record<string, string>; usedKeys: string[] } {
+  const used = new Set<string>();
+  const substituted: Record<string, string> = {};
+  for (const [key, value] of Object.entries(values)) {
+    if (FORBIDDEN_REQUEST_HEADERS.has(key.toLowerCase())) {
+      throw new Error(`Header "${key}" is not allowed`);
+    }
+    const result = vaultSubstituteDetailed(userId, value);
+    for (const usedKey of result.usedKeys) used.add(usedKey);
+    substituted[key] = result.text;
+  }
+  return { values: substituted, usedKeys: [...used] };
+}
+
+function safeResponseHeaders(userId: string, headers: Headers): Record<string, string> {
+  const output: Record<string, string> = {};
+  for (const [key, value] of headers.entries()) {
+    if (!SAFE_RESPONSE_HEADERS.has(key.toLowerCase())) continue;
+    output[key] = redactVaultSecrets(userId, value);
+  }
+  return output;
+}
+
+async function readBoundedBody(
+  response: Response,
+  maxBytes: number,
+): Promise<{ bytes: Uint8Array; truncated: boolean }> {
+  if (!response.body) return { bytes: new Uint8Array(), truncated: false };
+  const reader = response.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let keptBytes = 0;
+  let truncated = false;
+  try {
+    while (true) {
+      const next = await reader.read();
+      if (next.done) break;
+      const remaining = maxBytes - keptBytes;
+      if (remaining <= 0) {
+        truncated = true;
+        await reader.cancel();
+        break;
+      }
+      const visible = next.value.subarray(0, remaining);
+      chunks.push(visible);
+      keptBytes += visible.byteLength;
+      if (visible.byteLength < next.value.byteLength) {
+        truncated = true;
+        await reader.cancel();
+        break;
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+
+  const bytes = new Uint8Array(keptBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return { bytes, truncated };
+}
+
+/**
+ * Execute an HTTPS request inside the credential boundary. The caller supplies
+ * only {{KEY}} references; expanded headers/body never leave this function.
+ */
+export async function executeVaultHttpRequest(
+  userId: string,
+  request: VaultHttpRequest,
+  fetchImpl: typeof fetch = fetch,
+): Promise<VaultHttpResult> {
+  let parsedUrl: URL;
+  try {
+    parsedUrl = new URL(request.url);
+  } catch {
+    return { ok: false, error: "url must be an absolute HTTPS URL" };
+  }
+  if (parsedUrl.protocol !== "https:") {
+    return { ok: false, error: "Vault credentials may only be sent over HTTPS" };
+  }
+  if (parsedUrl.username || parsedUrl.password || /\{\{[^}]+\}\}/.test(request.url)) {
+    return {
+      ok: false,
+      error: "Keep Vault placeholders out of URLs; put credentials in headers or body",
+    };
+  }
+
+  let headers: Record<string, string>;
+  let headerKeys: string[];
+  try {
+    const substituted = substituteObject(userId, request.headers ?? {});
+    headers = substituted.values;
+    headerKeys = substituted.usedKeys;
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+  }
+
+  const bodyResult =
+    request.body === undefined
+      ? { text: undefined, usedKeys: [] as string[] }
+      : vaultSubstituteDetailed(userId, request.body);
+  const usedKeys = [...new Set([...headerKeys, ...bodyResult.usedKeys])].sort();
+  if (usedKeys.length === 0) {
+    return {
+      ok: false,
+      error: "No valid Vault placeholder was found in headers or body",
+    };
+  }
+  if (request.method === "GET" && request.body !== undefined) {
+    return { ok: false, error: "GET requests cannot include a credential-bearing body" };
+  }
+
+  const controller = new AbortController();
+  const timeoutMs = Math.min(Math.max(request.timeoutMs ?? 30_000, 1_000), 120_000);
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  const startedAt = Date.now();
+  try {
+    const response = await fetchImpl(parsedUrl, {
+      method: request.method,
+      headers,
+      body: request.method === "GET" ? undefined : bodyResult.text,
+      redirect: "manual",
+      signal: controller.signal,
+    });
+    const maxBytes = Math.min(Math.max(request.maxResponseBytes ?? 256 * 1024, 1_024), 1024 * 1024);
+    const { bytes, truncated } = await readBoundedBody(response, maxBytes);
+    const contentType = response.headers.get("content-type")?.toLowerCase() ?? "";
+    const textual =
+      contentType.startsWith("text/") ||
+      contentType.includes("json") ||
+      contentType.includes("xml") ||
+      contentType.includes("javascript") ||
+      contentType === "";
+    const body = textual
+      ? redactVaultSecrets(userId, new TextDecoder().decode(bytes))
+      : `[binary response omitted: ${bytes.byteLength} bytes, ${contentType || "unknown content type"}]`;
+
+    logger.info(
+      {
+        userId,
+        vaultKeys: usedKeys,
+        host: parsedUrl.hostname,
+        method: request.method,
+        status: response.status,
+        durationMs: Date.now() - startedAt,
+      },
+      "vault credential used",
+    );
+
+    return {
+      ok: response.ok,
+      status: response.status,
+      statusText: response.statusText,
+      headers: safeResponseHeaders(userId, response.headers),
+      body,
+      truncated,
+    };
+  } catch (error) {
+    const raw = error instanceof Error ? error.message : String(error);
+    logger.warn(
+      {
+        userId,
+        vaultKeys: usedKeys,
+        host: parsedUrl.hostname,
+        method: request.method,
+        durationMs: Date.now() - startedAt,
+      },
+      "vault credential request failed",
+    );
+    return { ok: false, error: redactVaultSecrets(userId, raw) };
+  } finally {
+    clearTimeout(timeout);
+  }
+}

package/dist/runtime/src/mcp/vault-run.ts

@@ -0,0 +1,153 @@
+import { spawn } from "node:child_process";
+import { logger } from "#platform/logger";
+import { redactVaultSecrets, vaultSubstituteDetailed } from "#storage/vault";
+
+export interface VaultRunRequest {
+  command: string;
+  timeoutMs?: number;
+  maxOutputBytes?: number;
+  cwd?: string;
+}
+
+export interface VaultRunResult {
+  ok: boolean;
+  exitCode: number | null;
+  signal: NodeJS.Signals | null;
+  stdout: string;
+  stderr: string;
+  truncated: boolean;
+  usedKeys: string[];
+  error?: string;
+}
+
+function appendBounded(
+  chunks: Buffer[],
+  chunk: Buffer,
+  state: { bytes: number; truncated: boolean },
+  maxBytes: number,
+): void {
+  if (state.bytes >= maxBytes) {
+    state.truncated = true;
+    return;
+  }
+  const remaining = maxBytes - state.bytes;
+  const visible = chunk.subarray(0, remaining);
+  chunks.push(visible);
+  state.bytes += visible.byteLength;
+  if (visible.byteLength < chunk.byteLength) state.truncated = true;
+}
+
+/** Execute a placeholder-bearing shell command without exposing expanded input/output to the SDK. */
+export async function executeVaultRun(
+  userId: string,
+  request: VaultRunRequest,
+): Promise<VaultRunResult> {
+  const substitution = vaultSubstituteDetailed(userId, request.command);
+  if (substitution.usedKeys.length === 0) {
+    return {
+      ok: false,
+      exitCode: null,
+      signal: null,
+      stdout: "",
+      stderr: "",
+      truncated: false,
+      usedKeys: [],
+      error: "No valid Vault placeholder was found in command",
+    };
+  }
+
+  const timeoutMs = Math.min(Math.max(request.timeoutMs ?? 120_000, 1_000), 600_000);
+  const maxOutputBytes = Math.min(
+    Math.max(request.maxOutputBytes ?? 512 * 1024, 1_024),
+    2 * 1024 * 1024,
+  );
+  const stdoutChunks: Buffer[] = [];
+  const stderrChunks: Buffer[] = [];
+  const stdoutState = { bytes: 0, truncated: false };
+  const stderrState = { bytes: 0, truncated: false };
+  const startedAt = Date.now();
+
+  return await new Promise<VaultRunResult>((resolve) => {
+    // Feed the expanded script over stdin so plaintext never appears in argv or
+    // the provider-visible tool input. zsh -s reads commands from standard input.
+    const child = spawn(process.env.SHELL || "/bin/sh", ["-s"], {
+      cwd: request.cwd,
+      detached: true,
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    let settled = false;
+    let timedOut = false;
+    const signalTree = (signal: NodeJS.Signals) => {
+      if (!child.pid) return;
+      try {
+        process.kill(-child.pid, signal);
+      } catch {
+        try {
+          child.kill(signal);
+        } catch {
+          // The process tree already exited.
+        }
+      }
+    };
+
+    const finish = (result: Omit<VaultRunResult, "usedKeys">) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      logger.info(
+        {
+          userId,
+          vaultKeys: substitution.usedKeys,
+          exitCode: result.exitCode,
+          signal: result.signal,
+          durationMs: Date.now() - startedAt,
+          timedOut,
+        },
+        "vault credential command used",
+      );
+      resolve({ ...result, usedKeys: substitution.usedKeys });
+    };
+
+    child.stdout.on("data", (chunk: Buffer) =>
+      appendBounded(stdoutChunks, chunk, stdoutState, maxOutputBytes),
+    );
+    child.stderr.on("data", (chunk: Buffer) =>
+      appendBounded(stderrChunks, chunk, stderrState, maxOutputBytes),
+    );
+    child.once("error", (error) => {
+      finish({
+        ok: false,
+        exitCode: null,
+        signal: null,
+        stdout: "",
+        stderr: "",
+        truncated: false,
+        error: redactVaultSecrets(userId, error.message),
+      });
+    });
+    child.once("close", (exitCode, signal) => {
+      // vault_run is deliberately foreground-only. Clean up descendants a
+      // command attempted to leave behind so secrets do not linger in argv/env.
+      signalTree("SIGTERM");
+      const stdout = redactVaultSecrets(userId, Buffer.concat(stdoutChunks).toString("utf8"));
+      const stderr = redactVaultSecrets(userId, Buffer.concat(stderrChunks).toString("utf8"));
+      finish({
+        ok: !timedOut && exitCode === 0,
+        exitCode,
+        signal,
+        stdout,
+        stderr,
+        truncated: stdoutState.truncated || stderrState.truncated,
+        ...(timedOut ? { error: `Command timed out after ${timeoutMs}ms` } : {}),
+      });
+    });
+
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      signalTree("SIGKILL");
+    }, timeoutMs);
+
+    child.stdin.end(substitution.text);
+  });
+}