negotium 0.1.7 → 0.1.9

package/dist/runtime/src/storage/token-stats.ts

@@ -0,0 +1,144 @@
+import { createHash } from "node:crypto";
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { LOG_DIR } from "#platform/config";
+import { appendJsonlEntry, readJsonlLines } from "#platform/jsonl";
+import { logger } from "#platform/logger";
+
+mkdirSync(LOG_DIR, { recursive: true });
+
+export interface QueryRecord {
+  timestamp: string; // ISO 8601 UTC
+  session: string; // topic name
+  inputTokens: number;
+  outputTokens: number;
+  cacheCreationInputTokens: number;
+  cacheReadInputTokens: number;
+}
+
+export interface Bucket {
+  inputTokens: number;
+  outputTokens: number;
+  cacheCreationInputTokens: number;
+  cacheReadInputTokens: number;
+  queries: number;
+}
+
+function emptyBucket(): Bucket {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheCreationInputTokens: 0,
+    cacheReadInputTokens: 0,
+    queries: 0,
+  };
+}
+
+function queriesPath(userId: number | string): string {
+  const rawUserId = String(userId);
+  // Preserve existing filenames for ordinary IDs, but never let an external
+  // identity introduce path separators or unbounded filename length.
+  const fileId = /^[A-Za-z0-9][A-Za-z0-9_.@-]{0,255}$/.test(rawUserId)
+    ? rawUserId
+    : `sha256-${createHash("sha256").update(rawUserId).digest("hex")}`;
+  return join(LOG_DIR, `token-queries-${fileId}.jsonl`);
+}
+
+function loadRecords(userId: number | string): QueryRecord[] {
+  try {
+    return readJsonlLines(queriesPath(userId)).flatMap((line) => {
+      try {
+        return [JSON.parse(line) as QueryRecord];
+      } catch {
+        return [];
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+
+export function calcCost(
+  b: Pick<
+    Bucket,
+    "inputTokens" | "outputTokens" | "cacheCreationInputTokens" | "cacheReadInputTokens"
+  >,
+): number {
+  return (
+    (b.inputTokens / 1_000_000) * 3.0 +
+    (b.outputTokens / 1_000_000) * 15.0 +
+    (b.cacheCreationInputTokens / 1_000_000) * 3.75 +
+    (b.cacheReadInputTokens / 1_000_000) * 0.3
+  );
+}
+
+/** 쿼리 완료 시 호출 — JSONL에 한 줄 추가 */
+export function recordUsage(
+  userId: number | string,
+  session: string,
+  usage: {
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreationInputTokens?: number;
+    cacheReadInputTokens?: number;
+  },
+) {
+  const record: QueryRecord = {
+    timestamp: new Date().toISOString(),
+    session,
+    inputTokens: usage.inputTokens,
+    outputTokens: usage.outputTokens,
+    cacheCreationInputTokens: usage.cacheCreationInputTokens ?? 0,
+    cacheReadInputTokens: usage.cacheReadInputTokens ?? 0,
+  };
+  try {
+    appendJsonlEntry(queriesPath(userId), record);
+  } catch (e) {
+    logger.warn({ err: e, userId }, "token-stats: Failed to record");
+  }
+}
+
+export function getStats(
+  userId: number | string,
+  from?: string,
+  to?: string,
+): {
+  total: Bucket;
+  byHour: Record<string, Bucket>;
+  bySession: Record<string, Bucket>;
+  estimatedCostUsd: number;
+} {
+  const records = loadRecords(userId);
+
+  const fromTs = from ? new Date(from).getTime() : 0;
+  const toTs = to ? new Date(to).getTime() : Infinity;
+
+  if ((from && Number.isNaN(fromTs)) || (to && Number.isNaN(toTs))) {
+    logger.warn({ from, to }, "token-stats: Invalid date range, returning empty");
+    return { total: emptyBucket(), byHour: {}, bySession: {}, estimatedCostUsd: 0 };
+  }
+
+  const total = emptyBucket();
+  const byHour: Record<string, Bucket> = {};
+  const bySession: Record<string, Bucket> = {};
+
+  for (const r of records) {
+    const ts = new Date(r.timestamp).getTime();
+    if (ts < fromTs || ts > toTs) continue;
+
+    const hourKey = r.timestamp.slice(0, 13); // "2026-03-28T14"
+
+    if (!byHour[hourKey]) byHour[hourKey] = emptyBucket();
+    if (!bySession[r.session]) bySession[r.session] = emptyBucket();
+
+    for (const bucket of [total, byHour[hourKey], bySession[r.session]]) {
+      bucket.inputTokens += r.inputTokens;
+      bucket.outputTokens += r.outputTokens;
+      bucket.cacheCreationInputTokens += r.cacheCreationInputTokens;
+      bucket.cacheReadInputTokens += r.cacheReadInputTokens;
+      bucket.queries += 1;
+    }
+  }
+
+  return { total, byHour, bySession, estimatedCostUsd: calcCost(total) };
+}

package/dist/runtime/src/storage/topic-archive-state.ts

@@ -0,0 +1,59 @@
+import { db } from "#storage/forum-db";
+
+db.exec(`
+  CREATE TABLE IF NOT EXISTS api_topic_archive_state (
+    topic_id TEXT PRIMARY KEY,
+    last_archived_rowid INTEGER NOT NULL DEFAULT 0,
+    last_archive_path TEXT,
+    updated_at TEXT NOT NULL
+  )
+`);
+
+export interface TopicArchiveState {
+  topicId: string;
+  lastArchivedRowid: number;
+  lastArchivePath?: string;
+  updatedAt: string;
+}
+
+interface TopicArchiveStateRow {
+  topic_id: string;
+  last_archived_rowid: number;
+  last_archive_path: string | null;
+  updated_at: string;
+}
+
+export function getTopicArchiveState(topicId: string): TopicArchiveState | null {
+  const row = db.query("SELECT * FROM api_topic_archive_state WHERE topic_id = ?").get(topicId) as
+    | TopicArchiveStateRow
+    | undefined;
+  if (!row) return null;
+  return {
+    topicId: row.topic_id,
+    lastArchivedRowid: row.last_archived_rowid,
+    lastArchivePath: row.last_archive_path ?? undefined,
+    updatedAt: row.updated_at,
+  };
+}
+
+export function setTopicArchiveState(
+  topicId: string,
+  lastArchivedRowid: number,
+  lastArchivePath?: string,
+): void {
+  db.query(
+    `INSERT INTO api_topic_archive_state (topic_id, last_archived_rowid, last_archive_path, updated_at)
+     VALUES (?, ?, ?, ?)
+     ON CONFLICT(topic_id) DO UPDATE SET
+       last_archived_rowid = excluded.last_archived_rowid,
+       last_archive_path = excluded.last_archive_path,
+       updated_at = excluded.updated_at`,
+  ).run(topicId, lastArchivedRowid, lastArchivePath ?? null, new Date().toISOString());
+}
+
+/** Remove the idle-archive cursor for a topic that no longer exists. */
+export function deleteTopicArchiveState(topicId: string): boolean {
+  return (
+    db.query("DELETE FROM api_topic_archive_state WHERE topic_id = ?").run(topicId).changes > 0
+  );
+}

package/dist/runtime/src/storage/topic-archive.ts

@@ -0,0 +1,74 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { logger } from "#platform/logger";
+import { sanitizeTopicName } from "#security/sanitize";
+import { getAllMessagesForTopic, getMessagesForTopicAfterRowid } from "#storage/api-messages";
+import { formatTopicArchiveTranscriptRecord } from "#storage/topic-transcript";
+import { getSharedWikiDir } from "#storage/wiki";
+
+export interface TopicArchiveResult {
+  path: string;
+  messageCount: number;
+  lastRowid: number;
+}
+
+export interface TopicArchiveOptions {
+  afterRowid?: number;
+  reason?: "delete" | "idle";
+}
+
+/**
+ * Forensic-archive a topic's SQLite-backed messages into the shared
+ * `wiki/archive/` as JSONL transcript records.
+ *
+ * Otium keeps conversations in the `api_messages` table (SQLite), not in the
+ * `PROJECT_ROOT/logs` activity-log files that Otium's `archiveSessionLogs`
+ * scans — so this is Otium's native equivalent. Each JSONL record keeps the raw
+ * DB message under `message`, plus a human-readable `line`/`role`/`speaker` for
+ * the background wiki-archiver turn.
+ *
+ * Output lands in the **shared** wiki root (see `getSharedWikiDir`) because
+ * that is the root the wiki MCP serves in topic-id mode; writing it elsewhere
+ * would make the archive invisible to later `wiki_query` calls.
+ *
+ * Returns `null` when the selected range has no messages.
+ */
+export function archiveTopicMessages(
+  topicId: string,
+  topicTitle: string,
+  options: TopicArchiveOptions = {},
+): TopicArchiveResult | null {
+  const rows =
+    options.afterRowid !== undefined
+      ? getMessagesForTopicAfterRowid(topicId, options.afterRowid)
+      : getAllMessagesForTopic(topicId);
+  if (rows.length === 0) return null;
+
+  const safeTopic = sanitizeTopicName(topicTitle, true);
+  const archiveDir = join(getSharedWikiDir(), "archive");
+  mkdirSync(archiveDir, { recursive: true });
+
+  // Collision-proof file name: a topic deleted twice on the same day (e.g.
+  // recreated then deleted again) must not clobber the earlier archive.
+  const date = new Date().toISOString().slice(0, 10);
+  const reasonSuffix = options.reason === "idle" ? "_idle" : "";
+  let filename = `${safeTopic}_${date}${reasonSuffix}.jsonl`;
+  let counter = 1;
+  while (existsSync(join(archiveDir, filename))) {
+    counter++;
+    filename = `${safeTopic}_${date}${reasonSuffix}_${counter}.jsonl`;
+  }
+  const path = join(archiveDir, filename);
+  const lastRowid = rows.reduce((max, row) => Math.max(max, row.rowid ?? 0), 0);
+
+  const body = `${rows
+    .map((r, index) => JSON.stringify(formatTopicArchiveTranscriptRecord(r, topicTitle, index + 1)))
+    .join("\n")}\n`;
+  writeFileSync(path, body);
+
+  logger.info(
+    { topicId, topicTitle, archive: path, messageCount: rows.length, lastRowid },
+    "archiveTopicMessages: archived topic messages",
+  );
+  return { path, messageCount: rows.length, lastRowid };
+}

package/dist/runtime/src/storage/topic-settings.ts

@@ -0,0 +1,67 @@
+import { db } from "#storage/forum-db";
+import { type AgentKind, isAgentKind } from "#types";
+
+export interface TopicAgentSwitchState {
+  name: string;
+  agent: AgentKind;
+}
+
+function toTopicAgentSwitchState(row: {
+  name: string;
+  agent: string | null;
+}): TopicAgentSwitchState {
+  if (!isAgentKind(row.agent)) throw new Error(`Invalid agent in DB: ${row.agent}`);
+  return {
+    name: row.name,
+    agent: row.agent,
+  };
+}
+
+export function getTopicAgentSwitchState(
+  userId: number,
+  topicName: string,
+): TopicAgentSwitchState | null {
+  const row = db
+    .query<{ name: string; agent: string | null }, [string, string]>(
+      "SELECT name, agent FROM topics WHERE user_id = ? AND name = ?",
+    )
+    .get(String(userId), topicName);
+  return row ? toTopicAgentSwitchState(row) : null;
+}
+
+export interface SetTopicAgentAndSessionOptions {
+  userId: number;
+  topicName: string;
+  agent: AgentKind;
+  sessionId: string;
+}
+
+export function setTopicAgentAndSession(opts: SetTopicAgentAndSessionOptions): void {
+  const { userId, topicName, agent, sessionId } = opts;
+  db.transaction(() => {
+    const r = db
+      .query("UPDATE topics SET agent = ?, session_id = ? WHERE user_id = ? AND name = ?")
+      .run(agent, sessionId, String(userId), topicName);
+    if (r.changes === 0) {
+      throw new Error(`setTopicAgentAndSession: row missing for ${userId}/${topicName}`);
+    }
+  })();
+}
+
+export interface SetTopicAgentAndClearSessionOptions {
+  userId: number;
+  topicName: string;
+  agent: AgentKind;
+}
+
+export function setTopicAgentAndClearSession(opts: SetTopicAgentAndClearSessionOptions): boolean {
+  const { userId, topicName, agent } = opts;
+  let changed = false;
+  db.transaction(() => {
+    const r = db
+      .query("UPDATE topics SET agent = ?, session_id = NULL WHERE user_id = ? AND name = ?")
+      .run(agent, String(userId), topicName);
+    changed = r.changes > 0;
+  })();
+  return changed;
+}

package/dist/runtime/src/storage/topic-transcript.ts

@@ -0,0 +1,98 @@
+export interface TopicArchiveMessageRow {
+  id: string;
+  topic_id: string;
+  parent_id: string | null;
+  author_id: string;
+  text: string;
+  query_id: string | null;
+  agent_type: string | null;
+  model: string | null;
+  attachments: string | null;
+  usage: string | null;
+  deleted: number;
+  created_at: string;
+  rowid?: number;
+}
+
+export type TopicArchiveRole = "user" | "assistant" | "system";
+
+export interface TopicArchiveTranscriptRecord {
+  type: "message";
+  index: number;
+  topicId: string;
+  topicTitle: string;
+  id: string;
+  createdAt: string;
+  rowid?: number;
+  role: TopicArchiveRole;
+  speaker: string;
+  line: string;
+  text: string;
+  authorId: string;
+  parentId?: string;
+  queryId?: string;
+  agentType?: string;
+  model?: string;
+  attachments?: unknown;
+  usage?: unknown;
+  message: TopicArchiveMessageRow;
+}
+
+function parseJsonField(value: string | null): unknown | undefined {
+  if (!value) return undefined;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+function transcriptRole(row: TopicArchiveMessageRow): TopicArchiveRole {
+  if (row.author_id === "system") return "system";
+  if (row.author_id === "ai" || row.agent_type) return "assistant";
+  return "user";
+}
+
+function transcriptSpeaker(row: TopicArchiveMessageRow, role: TopicArchiveRole): string {
+  if (role === "assistant") return row.agent_type ? `assistant:${row.agent_type}` : "assistant";
+  if (role === "system") return "system";
+  return `user:${row.author_id}`;
+}
+
+function oneLine(text: string): string {
+  const compact = text.replace(/\s+/g, " ").trim();
+  return compact.length > 2000 ? `${compact.slice(0, 2000)}...` : compact;
+}
+
+export function formatTopicArchiveTranscriptRecord(
+  row: TopicArchiveMessageRow,
+  topicTitle: string,
+  index: number,
+): TopicArchiveTranscriptRecord {
+  const role = transcriptRole(row);
+  const speaker = transcriptSpeaker(row, role);
+  const attachments = parseJsonField(row.attachments);
+  const usage = parseJsonField(row.usage);
+
+  return {
+    type: "message",
+    index,
+    topicId: row.topic_id,
+    topicTitle,
+    id: row.id,
+    createdAt: row.created_at,
+    ...(row.rowid !== undefined ? { rowid: row.rowid } : {}),
+    role,
+    speaker,
+    line: `[${row.created_at}] ${speaker}: ${oneLine(row.text)}`,
+    text: row.text,
+    authorId: row.author_id,
+    ...(row.parent_id ? { parentId: row.parent_id } : {}),
+    ...(row.query_id ? { queryId: row.query_id } : {}),
+    ...(row.agent_type ? { agentType: row.agent_type } : {}),
+    ...(row.model ? { model: row.model } : {}),
+    ...(attachments !== undefined ? { attachments } : {}),
+    ...(usage !== undefined ? { usage } : {}),
+    message: row,
+  };
+}

package/dist/runtime/src/storage/vault-crypto.ts

@@ -0,0 +1,65 @@
+import { createCipheriv, createDecipheriv, createHash, randomBytes } from "node:crypto";
+import { VAULT_MASTER_KEY } from "#platform/config";
+
+const ENVELOPE_PREFIX = "otium-vault:v1:";
+const IV_BYTES = 12;
+const KEY_BYTES = 32;
+
+function encryptionKey(): Buffer {
+  return createHash("sha256")
+    .update("otium-vault-value-v1\0", "utf8")
+    .update(VAULT_MASTER_KEY, "utf8")
+    .digest()
+    .subarray(0, KEY_BYTES);
+}
+
+function aad(userId: string, key: string): Buffer {
+  return Buffer.from(`${userId}\0${key.toUpperCase()}`, "utf8");
+}
+
+export function isEncryptedVaultValue(value: string): boolean {
+  return value.startsWith(ENVELOPE_PREFIX);
+}
+
+/** Encrypt one vault row. The user/key binding prevents ciphertext row swapping. */
+export function encryptVaultValue(userId: string, key: string, value: string): string {
+  const iv = randomBytes(IV_BYTES);
+  const cipher = createCipheriv("aes-256-gcm", encryptionKey(), iv);
+  cipher.setAAD(aad(userId, key));
+  const ciphertext = Buffer.concat([cipher.update(value, "utf8"), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return `${ENVELOPE_PREFIX}${iv.toString("base64url")}.${ciphertext.toString("base64url")}.${tag.toString("base64url")}`;
+}
+
+/**
+ * Decrypt a stored value. Plaintext rows are accepted for rolling upgrades and
+ * are re-encrypted by the storage layer immediately after a successful read.
+ */
+export function decryptVaultValue(
+  userId: string,
+  key: string,
+  storedValue: string,
+): { value: string; legacyPlaintext: boolean } {
+  if (!isEncryptedVaultValue(storedValue)) {
+    return { value: storedValue, legacyPlaintext: true };
+  }
+
+  const encoded = storedValue.slice(ENVELOPE_PREFIX.length);
+  const [ivPart, ciphertextPart, tagPart, ...extra] = encoded.split(".");
+  if (!ivPart || ciphertextPart === undefined || !tagPart || extra.length > 0) {
+    throw new Error("Invalid encrypted vault value");
+  }
+
+  const iv = Buffer.from(ivPart, "base64url");
+  const ciphertext = Buffer.from(ciphertextPart, "base64url");
+  const tag = Buffer.from(tagPart, "base64url");
+  if (iv.length !== IV_BYTES || tag.length !== 16) {
+    throw new Error("Invalid encrypted vault value");
+  }
+
+  const decipher = createDecipheriv("aes-256-gcm", encryptionKey(), iv);
+  decipher.setAAD(aad(userId, key));
+  decipher.setAuthTag(tag);
+  const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+  return { value: plaintext.toString("utf8"), legacyPlaintext: false };
+}