negotium 0.1.7 → 0.1.8

package/dist/runtime/src/storage/session-asks.ts

@@ -0,0 +1,347 @@
+import {
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { SESSION_ASKS_DIR } from "#platform/config";
+
+export const PENDING_ASK_TTL_MS = 15 * 60 * 1000;
+
+export type PendingAskState =
+  | "requested"
+  | "reply_ready"
+  | "queued_for_caller"
+  | "injecting_to_caller";
+
+export type PendingAskUserId = number | string;
+
+export interface PendingAskRecord {
+  userId: PendingAskUserId;
+  from: string;
+  to: string;
+  requestId: string;
+  contextId?: string;
+  state: PendingAskState;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface AskReplySource {
+  from?: string;
+  requestId?: string;
+  contextId?: string;
+}
+
+interface AskKey {
+  userId: PendingAskUserId;
+  from: string;
+  to: string;
+}
+
+interface AskIdentity extends AskKey {
+  requestId?: string;
+}
+
+function pendingAskDir(userId: PendingAskUserId): string {
+  return join(SESSION_ASKS_DIR, String(userId));
+}
+
+const ASK_FILENAME_PREFIX = "v2-";
+
+function encodeAskKey(key: Pick<AskKey, "from" | "to">): string {
+  return Buffer.from(JSON.stringify([key.from, key.to]), "utf8").toString("base64url");
+}
+
+function pendingAskPath(key: AskKey): string {
+  return join(pendingAskDir(key.userId), `${ASK_FILENAME_PREFIX}${encodeAskKey(key)}.pending`);
+}
+
+function legacyPendingAskPath(key: AskKey): string | null {
+  if (key.from.includes("___") || /[\\/]/.test(key.from) || /[\\/]/.test(key.to)) return null;
+  return join(pendingAskDir(key.userId), `${key.from}___${key.to}.pending`);
+}
+
+function resolvePendingAskPath(key: AskKey): string {
+  const current = pendingAskPath(key);
+  if (existsSync(current)) return current;
+  const legacy = legacyPendingAskPath(key);
+  if (!legacy || !existsSync(legacy)) return current;
+
+  // Keep one durable identity across the filename transition. renameSync is
+  // atomic within this directory, so concurrent creators observe either the
+  // legacy request or its v2 name, never a copied half-state.
+  try {
+    renameSync(legacy, current);
+    return current;
+  } catch {
+    return existsSync(current) ? current : legacy;
+  }
+}
+
+function parsePendingAskFilename(fileName: string): { from: string; to: string } | null {
+  if (!fileName.endsWith(".pending")) return null;
+  const raw = fileName.slice(0, -".pending".length);
+  if (raw.startsWith(ASK_FILENAME_PREFIX)) {
+    try {
+      const decoded = JSON.parse(
+        Buffer.from(raw.slice(ASK_FILENAME_PREFIX.length), "base64url").toString("utf8"),
+      ) as unknown;
+      if (
+        Array.isArray(decoded) &&
+        decoded.length === 2 &&
+        decoded.every((part) => typeof part === "string")
+      ) {
+        return { from: decoded[0], to: decoded[1] };
+      }
+    } catch {
+      return null;
+    }
+    return null;
+  }
+
+  // Read files created before the opaque v2 key was introduced.
+  const sep = raw.indexOf("___");
+  if (sep < 0) return null;
+  return { from: raw.slice(0, sep), to: raw.slice(sep + 3) };
+}
+
+function readPendingAskFile(path: string, fallback: AskKey): PendingAskRecord | null {
+  try {
+    const raw = readFileSync(path, "utf8").trim();
+    if (!raw) return null;
+    if (!raw.startsWith("{")) {
+      const ts = new Date(statSync(path).mtimeMs).toISOString();
+      return {
+        userId: fallback.userId,
+        from: fallback.from,
+        to: fallback.to,
+        requestId: raw,
+        state: "requested",
+        createdAt: ts,
+        updatedAt: ts,
+      };
+    }
+    const parsed = JSON.parse(raw) as Partial<PendingAskRecord>;
+    if (!parsed.requestId || !parsed.from || !parsed.to) return null;
+    const now = new Date().toISOString();
+    return {
+      userId: parsed.userId ?? fallback.userId,
+      from: parsed.from,
+      to: parsed.to,
+      requestId: parsed.requestId,
+      contextId: parsed.contextId,
+      state: parsed.state ?? "requested",
+      createdAt: parsed.createdAt ?? now,
+      updatedAt: parsed.updatedAt ?? parsed.createdAt ?? now,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function isStale(record: PendingAskRecord | null, path: string): boolean {
+  const ts = record ? Date.parse(record.updatedAt || record.createdAt) : Number.NaN;
+  if (Number.isFinite(ts)) return Date.now() - ts > PENDING_ASK_TTL_MS;
+  try {
+    return Date.now() - statSync(path).mtimeMs > PENDING_ASK_TTL_MS;
+  } catch {
+    return false;
+  }
+}
+
+function writePendingAsk(record: PendingAskRecord, path = pendingAskPath(record)): void {
+  mkdirSync(pendingAskDir(record.userId), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(record)}\n`);
+}
+
+export function createPendingAsk(args: {
+  userId: PendingAskUserId;
+  from: string;
+  to: string;
+  requestId: string;
+  contextId?: string;
+}):
+  | { ok: true; record: PendingAskRecord }
+  | { ok: false; existing: PendingAskRecord | null; stale: boolean } {
+  const path = resolvePendingAskPath(args);
+  const now = new Date().toISOString();
+  const record: PendingAskRecord = {
+    userId: args.userId,
+    from: args.from,
+    to: args.to,
+    requestId: args.requestId,
+    contextId: args.contextId,
+    state: "requested",
+    createdAt: now,
+    updatedAt: now,
+  };
+
+  mkdirSync(pendingAskDir(args.userId), { recursive: true });
+  for (let attempt = 0; attempt < 2; attempt++) {
+    let fd: number | null = null;
+    try {
+      fd = openSync(path, "wx");
+      writeFileSync(fd, `${JSON.stringify(record)}\n`);
+      return { ok: true, record };
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code !== "EEXIST") throw err;
+      const existing = readPendingAskFile(path, args);
+      if (!isStale(existing, path)) return { ok: false, existing, stale: false };
+      try {
+        unlinkSync(path);
+      } catch {
+        return { ok: false, existing, stale: true };
+      }
+    } finally {
+      if (fd !== null) closeSync(fd);
+    }
+  }
+
+  return { ok: false, existing: readPendingAskFile(path, args), stale: true };
+}
+
+export function markPendingAskState(
+  args: AskIdentity & { state: PendingAskState },
+): PendingAskRecord | null {
+  const path = resolvePendingAskPath(args);
+  const record = readPendingAskFile(path, args);
+  if (!record) return null;
+  if (args.requestId && record.requestId !== args.requestId) return record;
+  const next = {
+    ...record,
+    state: args.state,
+    updatedAt: new Date().toISOString(),
+  };
+  writePendingAsk(next, path);
+  return next;
+}
+
+export function clearPendingAsk(args: AskIdentity): boolean {
+  const path = resolvePendingAskPath(args);
+  const record = readPendingAskFile(path, args);
+  if (args.requestId && record && record.requestId !== args.requestId) return false;
+  try {
+    unlinkSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function markPendingAskSources(args: {
+  userId: PendingAskUserId;
+  callerTopic: string;
+  sources?: AskReplySource[];
+  state: PendingAskState;
+}): void {
+  for (const source of args.sources ?? []) {
+    if (!source.from) continue;
+    markPendingAskState({
+      userId: args.userId,
+      from: args.callerTopic,
+      to: source.from,
+      requestId: source.requestId,
+      state: args.state,
+    });
+  }
+}
+
+export function clearPendingAskSources(args: {
+  userId: PendingAskUserId;
+  callerTopic: string;
+  sources?: AskReplySource[];
+}): void {
+  for (const source of args.sources ?? []) {
+    if (!source.from) continue;
+    clearPendingAsk({
+      userId: args.userId,
+      from: args.callerTopic,
+      to: source.from,
+      requestId: source.requestId,
+    });
+  }
+}
+
+export function listPendingAsksForCaller(args: {
+  userId: PendingAskUserId;
+  from: string;
+}): PendingAskRecord[] {
+  const dir = pendingAskDir(args.userId);
+  let files: string[];
+  try {
+    files = readdirSync(dir);
+  } catch {
+    return [];
+  }
+
+  const records: PendingAskRecord[] = [];
+  for (const fileName of files) {
+    const parsed = parsePendingAskFilename(fileName);
+    if (!parsed || parsed.from !== args.from) continue;
+    const path = join(dir, fileName);
+    const record = readPendingAskFile(path, {
+      userId: args.userId,
+      from: parsed.from,
+      to: parsed.to,
+    });
+    if (!record) continue;
+    if (isStale(record, path)) {
+      try {
+        unlinkSync(path);
+      } catch {
+        // Best-effort stale cleanup only.
+      }
+      continue;
+    }
+    records.push(record);
+  }
+  return records;
+}
+
+/** Remove durable ask edges to or from a topic that no longer exists. */
+export function deletePendingAsksForTopic(args: {
+  userId: PendingAskUserId;
+  topicName: string;
+}): number {
+  const dir = pendingAskDir(args.userId);
+  let files: string[];
+  try {
+    files = readdirSync(dir);
+  } catch {
+    return 0;
+  }
+
+  let deleted = 0;
+  for (const fileName of files) {
+    const parsed = parsePendingAskFilename(fileName);
+    if (!parsed || (parsed.from !== args.topicName && parsed.to !== args.topicName)) continue;
+    try {
+      unlinkSync(join(dir, fileName));
+      deleted++;
+    } catch {
+      // Best-effort teardown; stale cleanup will retry any file that survives.
+    }
+  }
+  return deleted;
+}
+
+export function describePendingAskState(state: PendingAskState): string {
+  switch (state) {
+    case "requested":
+      return "대상 세션 처리 중";
+    case "reply_ready":
+      return "응답 생성 완료, 이 세션 주입 준비 중";
+    case "queued_for_caller":
+      return "응답 생성 완료, 이 세션 실행 종료 후 주입 대기 중";
+    case "injecting_to_caller":
+      return "응답을 이 세션에 주입 중";
+  }
+}

package/dist/runtime/src/storage/sqlite.ts

@@ -0,0 +1,129 @@
+// Runtime-adaptive SQLite façade.
+//
+// Why this exists: Otium normally runs on bun and uses `bun:sqlite` (native,
+// fast, zero-build). But the `codex` agent's MCP servers must run on pure node
+// — codex 0.135's rmcp stdio client can't handshake with bun-spawned servers
+// (see serverLaunch in platform/mcp-config.ts). `bun:sqlite` doesn't exist
+// under node, so any MCP server that touches the DB would crash on import.
+//
+// This module picks the backend at runtime and re-exports it as `Database`:
+//   - under bun  → the real `bun:sqlite` Database (unchanged behavior)
+//   - under node → a thin shim over node:sqlite's DatabaseSync exposing the
+//     exact subset Otium uses: new Database(path, {readonly?,create?}),
+//     .query()/.prepare() → statement, .exec(), .run(), .transaction(fn),
+//     .close(); statements support positional `?` params via .run()/.get()/
+//     .all(). (No named-object params / .values()/.iterate()/.as() are used in
+//     this codebase, so the shim intentionally omits them.)
+//
+// The TYPE of the exported `Database` is bun:sqlite's own class type (imported
+// type-only, so it's erased at runtime and never resolved under node). That
+// keeps every existing call site — including generic `.query<Row, Params>()`
+// usages — type-checking exactly as before with zero changes.
+//
+// The bun branch uses a dynamic import so node never resolves the `bun:sqlite`
+// specifier (dead code under node), and the node branch's `node:sqlite` import
+// never runs under bun.
+
+import type { Database as BunDatabase } from "bun:sqlite";
+
+// `mock.module()` can replace the Bun global while a test graph is being
+// evaluated. The runtime version flag is stable and is also the documented
+// cross-runtime discriminator.
+const isBun = typeof process.versions.bun === "string";
+
+type DatabaseCtor = typeof BunDatabase;
+
+let Database: DatabaseCtor;
+
+if (isBun) {
+  ({ Database } = await import("bun:sqlite"));
+} else {
+  // node:sqlite has no type declarations under our tsconfig (`types: bun-types`
+  // only), and `bun-types` doesn't ship them — so type the dynamic import
+  // locally and use a `string` specifier to keep tsc from trying to resolve it.
+  type NodeStatement = {
+    run(...params: unknown[]): unknown;
+    get(...params: unknown[]): unknown;
+    all(...params: unknown[]): unknown[];
+  };
+  type NodeDatabaseSync = {
+    prepare(sql: string): NodeStatement;
+    exec(sql: string): void;
+    close(): void;
+  };
+  type NodeSqliteModule = {
+    DatabaseSync: new (path: string, options?: { readOnly?: boolean }) => NodeDatabaseSync;
+  };
+  // Keep Bun's resolver from eagerly resolving the Node-only builtin even
+  // though this branch is dead there (notably under `bun test` + mock.module).
+  const nodeSqliteSpecifier = ["node", "sqlite"].join(":");
+  const { DatabaseSync } = (await import(nodeSqliteSpecifier)) as NodeSqliteModule;
+
+  type DbOptions = { readonly?: boolean; create?: boolean };
+
+  class NodeDatabase {
+    #db: NodeDatabaseSync;
+
+    constructor(path: string, options: DbOptions = {}) {
+      // node:sqlite opens read-write and creates-if-missing by default, which
+      // matches bun's `{create:true}`. For readonly we must not create.
+      this.#db = options.readonly
+        ? new DatabaseSync(path, { readOnly: true })
+        : new DatabaseSync(path);
+    }
+
+    query(sql: string) {
+      return this.#db.prepare(sql);
+    }
+
+    prepare(sql: string) {
+      return this.#db.prepare(sql);
+    }
+
+    exec(sql: string): void {
+      this.#db.exec(sql);
+    }
+
+    run(sql: string, ...params: unknown[]) {
+      return this.#db.prepare(sql).run(...params);
+    }
+
+    transaction<Args extends unknown[], R>(fn: (...args: Args) => R): (...args: Args) => R {
+      // bun's db.transaction(fn) returns a function that runs fn inside a
+      // transaction when called. node:sqlite has no helper, so emulate with
+      // BEGIN/COMMIT/ROLLBACK. It also exposes deferred/immediate/exclusive
+      // variants; mirror those so Node-launched MCP servers can share call
+      // sites with Bun.
+      const run =
+        (begin: "BEGIN" | "BEGIN DEFERRED" | "BEGIN IMMEDIATE" | "BEGIN EXCLUSIVE") =>
+        (...args: Args): R => {
+          this.#db.exec(begin);
+          try {
+            const result = fn(...args);
+            this.#db.exec("COMMIT");
+            return result;
+          } catch (err) {
+            this.#db.exec("ROLLBACK");
+            throw err;
+          }
+        };
+      const tx = run("BEGIN") as ((...args: Args) => R) & {
+        deferred: (...args: Args) => R;
+        immediate: (...args: Args) => R;
+        exclusive: (...args: Args) => R;
+      };
+      tx.deferred = run("BEGIN DEFERRED");
+      tx.immediate = run("BEGIN IMMEDIATE");
+      tx.exclusive = run("BEGIN EXCLUSIVE");
+      return tx;
+    }
+
+    close(): void {
+      this.#db.close();
+    }
+  }
+
+  Database = NodeDatabase as unknown as DatabaseCtor;
+}
+
+export { Database };

package/dist/runtime/src/storage/tasks.ts

@@ -0,0 +1,179 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { DATA_DIR } from "#platform/config";
+import { logger } from "#platform/logger";
+import { sanitizeFileName } from "#security/sanitize";
+import type { TaskSnapshot } from "#types";
+
+/**
+ * Otium-owned task store, shared by every agent backend.
+ *
+ * Provider-native task/todo stores are not authoritative because they live
+ * inside one SDK session. This store is keyed by Otium topic context so task
+ * state survives agent switches and feeds the same live task panel for
+ * claude/codex/maestro.
+ */
+export type StoredTask = TaskSnapshot;
+
+export const TASK_STATUS_VALUES = ["pending", "in_progress", "completed"] as const;
+
+interface TaskFileShape {
+  version: 1;
+  tasks: StoredTask[];
+}
+
+function safeUserIdComponent(userId: number | string): string {
+  const str = String(userId);
+  if (!str || /[/\\]|\.\./.test(str)) {
+    throw new Error(`tasks: refusing unsafe userId path component: ${str}`);
+  }
+  return str;
+}
+
+function safeTaskScopeKey(scopeKey: string): string {
+  const safe = sanitizeFileName(scopeKey);
+  if (!safe || safe === "." || safe === "..") {
+    throw new Error(`tasks: refusing unsafe scope key: ${scopeKey}`);
+  }
+  return safe;
+}
+
+export function taskScopeKey(opts: { topicId?: string; session: string }): string {
+  return opts.topicId?.trim() || opts.session || "default";
+}
+
+export function getTaskFilePath(userId: number | string, scopeKey: string): string {
+  return join(DATA_DIR, "tasks", safeUserIdComponent(userId), `${safeTaskScopeKey(scopeKey)}.json`);
+}
+
+export function readTasks(userId: number | string, scopeKey: string): StoredTask[] {
+  const path = getTaskFilePath(userId, scopeKey);
+  if (!existsSync(path)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8")) as TaskFileShape;
+    return Array.isArray(parsed?.tasks) ? parsed.tasks : [];
+  } catch (e) {
+    logger.warn({ err: e, path }, "tasks: failed to read task store");
+    return [];
+  }
+}
+
+export function writeTasks(userId: number | string, scopeKey: string, tasks: StoredTask[]): void {
+  const path = getTaskFilePath(userId, scopeKey);
+  mkdirSync(dirname(path), { recursive: true });
+  const payload: TaskFileShape = { version: 1, tasks };
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(payload, null, 2), "utf-8");
+  renameSync(tmp, path);
+}
+
+export function taskFileMtimeNs(userId: number | string, scopeKey: string): bigint | null {
+  try {
+    return statSync(getTaskFilePath(userId, scopeKey), { bigint: true }).mtimeNs;
+  } catch {
+    return null;
+  }
+}
+
+export interface TaskCreateInput {
+  subject: string;
+  activeForm?: string;
+  blockedBy?: string[];
+  owner?: string;
+}
+
+export interface TaskUpdateInput {
+  id: string;
+  status?: StoredTask["status"];
+  subject?: string;
+  activeForm?: string;
+  blockedBy?: string[];
+  owner?: string;
+}
+
+function nextTaskId(tasks: StoredTask[]): number {
+  let max = 0;
+  for (const task of tasks) {
+    const n = Number(task.id);
+    if (Number.isInteger(n) && n > max) max = n;
+  }
+  return max + 1;
+}
+
+export function createTasks(
+  tasks: StoredTask[],
+  inputs: TaskCreateInput[],
+): { tasks: StoredTask[]; created: StoredTask[] } {
+  const out = [...tasks];
+  const created: StoredTask[] = [];
+  let id = nextTaskId(out);
+  for (const input of inputs) {
+    const task: StoredTask = {
+      id: String(id++),
+      subject: input.subject,
+      status: "pending",
+      ...(input.blockedBy && input.blockedBy.length > 0 ? { blockedBy: input.blockedBy } : {}),
+      ...(input.activeForm ? { activeForm: input.activeForm } : {}),
+      ...(input.owner ? { owner: input.owner } : {}),
+    };
+    out.push(task);
+    created.push(task);
+  }
+  return { tasks: out, created };
+}
+
+export function updateTasks(
+  tasks: StoredTask[],
+  updates: TaskUpdateInput[],
+): { tasks: StoredTask[]; missing: string[] } {
+  const out = tasks.map((task) => ({ ...task }));
+  const byId = new Map(out.map((task) => [task.id, task]));
+  const missing: string[] = [];
+  for (const update of updates) {
+    const task = byId.get(update.id);
+    if (!task) {
+      missing.push(update.id);
+      continue;
+    }
+    if (update.status !== undefined) task.status = update.status;
+    if (update.subject !== undefined) task.subject = update.subject;
+    if (update.activeForm !== undefined) {
+      if (update.activeForm) task.activeForm = update.activeForm;
+      else delete task.activeForm;
+    }
+    if (update.owner !== undefined) {
+      if (update.owner) task.owner = update.owner;
+      else delete task.owner;
+    }
+    if (update.blockedBy !== undefined) {
+      if (update.blockedBy.length > 0) task.blockedBy = update.blockedBy;
+      else delete task.blockedBy;
+    }
+  }
+  return { tasks: out, missing };
+}
+
+export function deleteTasks(
+  tasks: StoredTask[],
+  opts: { ids?: string[]; all?: boolean },
+): { tasks: StoredTask[]; removed: number } {
+  if (opts.all) return { tasks: [], removed: tasks.length };
+  const ids = new Set(opts.ids ?? []);
+  const kept = tasks.filter((task) => !ids.has(task.id));
+  return { tasks: kept, removed: tasks.length - kept.length };
+}
+
+export function renderTaskList(tasks: StoredTask[]): string {
+  if (tasks.length === 0) return "작업 목록이 비어 있습니다.";
+  const mark = { pending: "[ ]", in_progress: "[->]", completed: "[x]" } as const;
+  const lines = tasks.map((task) => {
+    const deps =
+      task.blockedBy && task.blockedBy.length > 0
+        ? ` (blocked by #${task.blockedBy.join(", #")})`
+        : "";
+    const owner = task.owner ? ` @${task.owner}` : "";
+    return `${mark[task.status]} #${task.id} ${task.subject}${deps}${owner}`;
+  });
+  const done = tasks.filter((task) => task.status === "completed").length;
+  return [`Tasks (${done}/${tasks.length} 완료)`, ...lines].join("\n");
+}