open-walnut 0.3.0

package/dist/session-server/index.js

@@ -0,0 +1,1382 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  ARCHIVE_DIR: () => ARCHIVE_DIR,
+  BUILTIN_COMMANDS_DIR: () => BUILTIN_COMMANDS_DIR,
+  BUILTIN_SKILLS_DIR: () => BUILTIN_SKILLS_DIR,
+  CHAT_HISTORY_FILE: () => CHAT_HISTORY_FILE,
+  CLAUDE_CREDENTIALS_FILE: () => CLAUDE_CREDENTIALS_FILE,
+  CLAUDE_HOME: () => CLAUDE_HOME,
+  CLAUDE_PLUGINS_DIR: () => CLAUDE_PLUGINS_DIR,
+  CLAUDE_SETTINGS_FILE: () => CLAUDE_SETTINGS_FILE,
+  CLAUDE_SKILLS_DIR: () => CLAUDE_SKILLS_DIR,
+  CLOUD_MODE: () => CLOUD_MODE,
+  COMMANDS_DIR: () => COMMANDS_DIR,
+  COMPACTION_DIR: () => COMPACTION_DIR,
+  CONFIG_FILE: () => CONFIG_FILE,
+  CONFIG_SHARE_DIR: () => CONFIG_SHARE_DIR,
+  CONVERSATIONS_DIR: () => CONVERSATIONS_DIR,
+  CRON_FILE: () => CRON_FILE,
+  DAEMON_BINARIES_DIR: () => DAEMON_BINARIES_DIR,
+  DAILY_DIR: () => DAILY_DIR,
+  DTACH_SOCKET_DIR: () => DTACH_SOCKET_DIR,
+  FREQUENT_DIRS_FILE: () => FREQUENT_DIRS_FILE,
+  GLOBAL_NOTES_FILE: () => GLOBAL_NOTES_FILE,
+  GLOBAL_SKILLS_DIR: () => GLOBAL_SKILLS_DIR,
+  HEARTBEAT_FILE: () => HEARTBEAT_FILE,
+  HISTORY_CACHE_DIR: () => HISTORY_CACHE_DIR,
+  HOOK_LOG_FILE: () => HOOK_LOG_FILE,
+  HOST_MODEL_CATALOG_FILE: () => HOST_MODEL_CATALOG_FILE,
+  IMAGES_DIR: () => IMAGES_DIR,
+  IS_EPHEMERAL: () => IS_EPHEMERAL,
+  LEGACY_MEMORY_FILE: () => LEGACY_MEMORY_FILE,
+  LOG_DIR: () => LOG_DIR,
+  LOG_PREFIX: () => LOG_PREFIX,
+  MEMORY_DIR: () => MEMORY_DIR,
+  MEMORY_FILE: () => MEMORY_FILE,
+  MEMORY_INDEX_FILE: () => MEMORY_INDEX_FILE,
+  MENTION_DIRS_FILE: () => MENTION_DIRS_FILE,
+  NOTES_AGENTS_FILE: () => NOTES_AGENTS_FILE,
+  NOTES_CLAUDE_FILE: () => NOTES_CLAUDE_FILE,
+  NOTES_DIR: () => NOTES_DIR,
+  PASTES_DIR: () => PASTES_DIR,
+  PLUGIN_STORES_DIR: () => PLUGIN_STORES_DIR,
+  PROJECTION_CACHE_DIR: () => PROJECTION_CACHE_DIR,
+  PROJECTS_DIR: () => PROJECTS_DIR,
+  PROJECTS_MEMORY_DIR: () => PROJECTS_MEMORY_DIR,
+  QUICK_START_MESSAGE_HARD_LIMIT: () => QUICK_START_MESSAGE_HARD_LIMIT,
+  QUICK_START_MESSAGE_SPILL_LIMIT: () => QUICK_START_MESSAGE_SPILL_LIMIT,
+  RECORDINGS_DIR: () => RECORDINGS_DIR,
+  REMOTE_IMAGES_DIR: () => REMOTE_IMAGES_DIR,
+  REPOSITORIES_DIR: () => REPOSITORIES_DIR,
+  REPOS_MEMORY_DIR: () => REPOS_MEMORY_DIR,
+  SESSIONS_DIR: () => SESSIONS_DIR,
+  SESSIONS_FILE: () => SESSIONS_FILE,
+  SESSION_QUEUE_FILE: () => SESSION_QUEUE_FILE,
+  SESSION_STREAMS_DIR: () => SESSION_STREAMS_DIR,
+  SKILL_SETTINGS_FILE: () => SKILL_SETTINGS_FILE,
+  STT_VOCAB_FILE: () => STT_VOCAB_FILE,
+  SYNC_DIR: () => SYNC_DIR,
+  TASKS_DIR: () => TASKS_DIR,
+  TASKS_FILE: () => TASKS_FILE,
+  TASK_QUEUE_DIR: () => TASK_QUEUE_DIR,
+  TIMELINE_DIR: () => TIMELINE_DIR,
+  TMP_DIR: () => TMP_DIR,
+  TOPICS_DIR: () => TOPICS_DIR,
+  TRANSCRIPT_CACHE_DIR: () => TRANSCRIPT_CACHE_DIR,
+  UI_PREFS_FILE: () => UI_PREFS_FILE,
+  USAGE_DB_FILE: () => USAGE_DB_FILE,
+  USER_FILE: () => USER_FILE,
+  WALNUT_HOME: () => WALNUT_HOME,
+  WALNUT_INSTALL_DIR: () => WALNUT_INSTALL_DIR,
+  WORKING_MEMORY_FILE: () => WORKING_MEMORY_FILE,
+  agentDailyDir: () => agentDailyDir,
+  agentMemoryDir: () => agentMemoryDir,
+  assertNotProductionPath: () => assertNotProductionPath,
+  chatHistoryFile: () => chatHistoryFile,
+  conversationDir: () => conversationDir,
+  conversationFile: () => conversationFile,
+  conversationIndexFile: () => conversationIndexFile,
+  isValidSessionUuid: () => isValidSessionUuid,
+  validateAgentId: () => validateAgentId,
+  validateConversationId: () => validateConversationId,
+  workingMemoryFile: () => workingMemoryFile
+});
+import path2 from "path";
+import fs2 from "fs";
+import os from "os";
+import { fileURLToPath } from "url";
+function resolveOpenWalnutHome() {
+  const envHome = process.env.OPEN_WALNUT_HOME;
+  const productionHome = path2.join(os.homedir(), ".open-walnut");
+  const isTestEnv = !!(process.env.VITEST || process.env.VITEST_WORKER_ID || process.env.NODE_ENV === "test");
+  if (isTestEnv) {
+    if (envHome && envHome !== productionHome && !envHome.startsWith(productionHome + path2.sep)) {
+      assertNotProductionPath(envHome);
+      return envHome;
+    }
+    const testHome = path2.join(os.tmpdir(), `open-walnut-test-${process.pid}`);
+    process.env.OPEN_WALNUT_HOME = testHome;
+    return testHome;
+  }
+  if (!envHome) return productionHome;
+  if (process.argv.includes("--_ephemeral-child")) return envHome;
+  if (isEphemeralTmpDir(envHome)) {
+    process.stderr.write(
+      `WARNING: OPEN_WALNUT_HOME=${envHome} looks like a leaked ephemeral temp dir.
+  Overriding to ${productionHome}. (Only --_ephemeral-child processes may use one.)
+`
+    );
+    process.env.OPEN_WALNUT_HOME = productionHome;
+    return productionHome;
+  }
+  return envHome;
+}
+function assertNotProductionPath(inputPath) {
+  const isTestEnv = !!(process.env.VITEST || process.env.VITEST_WORKER_ID || process.env.NODE_ENV === "test");
+  if (!isTestEnv) return;
+  const resolved = path2.resolve(inputPath);
+  const prodHome = path2.join(os.homedir(), ".open-walnut");
+  if (resolved === prodHome || resolved.startsWith(prodHome + path2.sep)) {
+    throw new Error(
+      `SAFETY: Test process attempted to use production path: ${resolved}
+  This would destroy real user data in ~/.open-walnut/.
+  Set OPEN_WALNUT_HOME to a temp directory or let constants.ts auto-assign one.`
+    );
+  }
+}
+function isEphemeralTmpDir(inputPath) {
+  if (!/[\\/]open-walnut-[^\\/]+$/.test(inputPath)) return false;
+  const tmpDirs = /* @__PURE__ */ new Set();
+  tmpDirs.add(os.tmpdir());
+  try {
+    tmpDirs.add(fs2.realpathSync(os.tmpdir()));
+  } catch {
+  }
+  try {
+    tmpDirs.add(fs2.realpathSync("/tmp"));
+  } catch {
+  }
+  const parent = path2.dirname(path2.resolve(inputPath));
+  if (tmpDirs.has(parent)) return true;
+  try {
+    return tmpDirs.has(fs2.realpathSync(parent));
+  } catch {
+    return false;
+  }
+}
+function validateAgentId(agentId) {
+  if (!/^[a-z0-9_-]{1,64}$/i.test(agentId)) {
+    throw new Error(`Invalid agentId: ${JSON.stringify(agentId)}`);
+  }
+  return agentId;
+}
+function chatHistoryFile(agentId) {
+  if (!agentId || agentId === "general") return CHAT_HISTORY_FILE;
+  return path2.join(WALNUT_HOME, `chat-history-${agentId}.json`);
+}
+function conversationDir(agentId) {
+  return path2.join(CONVERSATIONS_DIR, validateAgentId(agentId));
+}
+function conversationIndexFile(agentId) {
+  return path2.join(conversationDir(agentId), "_index.json");
+}
+function conversationFile(agentId, conversationId) {
+  return path2.join(conversationDir(agentId), `${conversationId}.json`);
+}
+function validateConversationId(id) {
+  if (!/^conv-[a-z0-9-]{1,64}$/i.test(id)) {
+    throw new Error(`Invalid conversationId: ${JSON.stringify(id)}`);
+  }
+  return id;
+}
+function isValidSessionUuid(id) {
+  return typeof id === "string" && SESSION_UUID_RE.test(id);
+}
+function agentMemoryDir(agentId) {
+  if (!agentId || agentId === "general") return WALNUT_HOME;
+  return path2.join(MEMORY_DIR, "agents", agentId);
+}
+function agentDailyDir(agentId) {
+  if (!agentId || agentId === "general") return DAILY_DIR;
+  return path2.join(MEMORY_DIR, "agents", agentId, "daily");
+}
+function workingMemoryFile(agentId, conversationId) {
+  return path2.join(conversationDir(agentId), `${validateConversationId(conversationId)}.working-memory.md`);
+}
+var WALNUT_HOME, IS_EPHEMERAL, CLOUD_MODE, TASKS_DIR, TASKS_FILE, ARCHIVE_DIR, MEMORY_DIR, SESSIONS_DIR, PROJECTS_DIR, CONFIG_FILE, SYNC_DIR, PLUGIN_STORES_DIR, SESSIONS_FILE, CLAUDE_HOME, HISTORY_CACHE_DIR, PROJECTION_CACHE_DIR, TRANSCRIPT_CACHE_DIR, TASK_QUEUE_DIR, HOST_MODEL_CATALOG_FILE, HOOK_LOG_FILE, DAILY_DIR, MEMORY_FILE, USER_FILE, LEGACY_MEMORY_FILE, PROJECTS_MEMORY_DIR, CHAT_HISTORY_FILE, CONVERSATIONS_DIR, SESSION_UUID_RE, GLOBAL_SKILLS_DIR, SKILL_SETTINGS_FILE, CLAUDE_SKILLS_DIR, CLAUDE_SETTINGS_FILE, CLAUDE_PLUGINS_DIR, CLAUDE_CREDENTIALS_FILE, CRON_FILE, USAGE_DB_FILE, LOG_DIR, SESSION_STREAMS_DIR, DTACH_SOCKET_DIR, SESSION_QUEUE_FILE, IMAGES_DIR, REMOTE_IMAGES_DIR, PASTES_DIR, HEARTBEAT_FILE, COMMANDS_DIR, BUILTIN_COMMANDS_DIR, BUILTIN_SKILLS_DIR, FREQUENT_DIRS_FILE, MENTION_DIRS_FILE, NOTES_DIR, GLOBAL_NOTES_FILE, NOTES_AGENTS_FILE, NOTES_CLAUDE_FILE, REPOSITORIES_DIR, REPOS_MEMORY_DIR, TOPICS_DIR, COMPACTION_DIR, MEMORY_INDEX_FILE, WORKING_MEMORY_FILE, TIMELINE_DIR, CONFIG_SHARE_DIR, UI_PREFS_FILE, STT_VOCAB_FILE, TMP_DIR, RECORDINGS_DIR, LOG_PREFIX, QUICK_START_MESSAGE_SPILL_LIMIT, QUICK_START_MESSAGE_HARD_LIMIT, DAEMON_BINARIES_DIR, WALNUT_INSTALL_DIR;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    "use strict";
+    WALNUT_HOME = resolveOpenWalnutHome();
+    IS_EPHEMERAL = process.argv.includes("--_ephemeral-child");
+    CLOUD_MODE = process.env.WALNUT_CLOUD_MODE === "1";
+    TASKS_DIR = path2.join(WALNUT_HOME, "tasks");
+    TASKS_FILE = path2.join(TASKS_DIR, "tasks.json");
+    ARCHIVE_DIR = path2.join(TASKS_DIR, "archive");
+    MEMORY_DIR = path2.join(WALNUT_HOME, "memory");
+    SESSIONS_DIR = path2.join(MEMORY_DIR, "sessions");
+    PROJECTS_DIR = path2.join(MEMORY_DIR, "projects");
+    CONFIG_FILE = path2.join(WALNUT_HOME, "config.yaml");
+    SYNC_DIR = path2.join(WALNUT_HOME, "sync");
+    PLUGIN_STORES_DIR = path2.join(WALNUT_HOME, "plugin-stores");
+    SESSIONS_FILE = path2.join(WALNUT_HOME, "sessions.json");
+    CLAUDE_HOME = path2.join(os.homedir(), ".claude");
+    HISTORY_CACHE_DIR = path2.join(WALNUT_HOME, "cache", "history");
+    PROJECTION_CACHE_DIR = path2.join(WALNUT_HOME, "cache", "projections");
+    TRANSCRIPT_CACHE_DIR = path2.join(WALNUT_HOME, "cache", "transcripts");
+    TASK_QUEUE_DIR = path2.join(WALNUT_HOME, "cache", "task-queue");
+    HOST_MODEL_CATALOG_FILE = path2.join(WALNUT_HOME, "cache", "host-model-catalogs.json");
+    HOOK_LOG_FILE = path2.join(WALNUT_HOME, "hook-errors.log");
+    DAILY_DIR = path2.join(MEMORY_DIR, "daily");
+    MEMORY_FILE = path2.join(MEMORY_DIR, "MEMORY.md");
+    USER_FILE = path2.join(MEMORY_DIR, "USER.md");
+    LEGACY_MEMORY_FILE = path2.join(WALNUT_HOME, "MEMORY.md");
+    PROJECTS_MEMORY_DIR = path2.join(MEMORY_DIR, "projects");
+    CHAT_HISTORY_FILE = path2.join(WALNUT_HOME, "chat-history.json");
+    CONVERSATIONS_DIR = path2.join(WALNUT_HOME, "conversations");
+    SESSION_UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+    GLOBAL_SKILLS_DIR = path2.join(WALNUT_HOME, "skills");
+    SKILL_SETTINGS_FILE = path2.join(WALNUT_HOME, "skill-settings.json");
+    CLAUDE_SKILLS_DIR = path2.join(CLAUDE_HOME, "skills");
+    CLAUDE_SETTINGS_FILE = path2.join(CLAUDE_HOME, "settings.json");
+    CLAUDE_PLUGINS_DIR = path2.join(CLAUDE_HOME, "plugins");
+    CLAUDE_CREDENTIALS_FILE = path2.join(CLAUDE_HOME, ".credentials.json");
+    CRON_FILE = path2.join(WALNUT_HOME, "cron-jobs.json");
+    USAGE_DB_FILE = path2.join(WALNUT_HOME, "usage.sqlite");
+    LOG_DIR = process.env.WALNUT_DAEMON_DIR || "/tmp/open-walnut";
+    SESSION_STREAMS_DIR = path2.join(LOG_DIR, "streams");
+    DTACH_SOCKET_DIR = path2.join(LOG_DIR, "term");
+    SESSION_QUEUE_FILE = path2.join(WALNUT_HOME, "session-message-queue.json");
+    IMAGES_DIR = path2.join(LOG_DIR, "images");
+    REMOTE_IMAGES_DIR = path2.join(IMAGES_DIR, "remote");
+    PASTES_DIR = path2.join(LOG_DIR, "pastes");
+    HEARTBEAT_FILE = path2.join(WALNUT_HOME, "HEARTBEAT.md");
+    COMMANDS_DIR = path2.join(WALNUT_HOME, "commands");
+    BUILTIN_COMMANDS_DIR = (() => {
+      let dir = path2.dirname(fileURLToPath(import.meta.url));
+      for (let i = 0; i < 5; i++) {
+        const candidate = path2.join(dir, "data", "slash-commands");
+        try {
+          if (fs2.statSync(candidate).isDirectory()) return candidate;
+        } catch {
+        }
+        dir = path2.dirname(dir);
+      }
+      return path2.join(path2.dirname(fileURLToPath(import.meta.url)), "..", "data", "slash-commands");
+    })();
+    BUILTIN_SKILLS_DIR = (() => {
+      let dir = path2.dirname(fileURLToPath(import.meta.url));
+      for (let i = 0; i < 5; i++) {
+        const candidate = path2.join(dir, "data", "skills");
+        try {
+          if (fs2.statSync(candidate).isDirectory()) return candidate;
+        } catch {
+        }
+        dir = path2.dirname(dir);
+      }
+      return path2.join(path2.dirname(fileURLToPath(import.meta.url)), "..", "data", "skills");
+    })();
+    FREQUENT_DIRS_FILE = path2.join(WALNUT_HOME, "frequent-directories.json");
+    MENTION_DIRS_FILE = path2.join(WALNUT_HOME, "mention-directories.json");
+    NOTES_DIR = path2.join(WALNUT_HOME, "notes");
+    GLOBAL_NOTES_FILE = path2.join(NOTES_DIR, "global-notes.md");
+    NOTES_AGENTS_FILE = path2.join(NOTES_DIR, "AGENTS.md");
+    NOTES_CLAUDE_FILE = path2.join(NOTES_DIR, "CLAUDE.md");
+    REPOSITORIES_DIR = path2.join(WALNUT_HOME, "repositories");
+    REPOS_MEMORY_DIR = path2.join(GLOBAL_SKILLS_DIR, "repos");
+    TOPICS_DIR = path2.join(MEMORY_DIR, "topics");
+    COMPACTION_DIR = path2.join(MEMORY_DIR, "compaction");
+    MEMORY_INDEX_FILE = path2.join(MEMORY_DIR, "index.md");
+    WORKING_MEMORY_FILE = path2.join(MEMORY_DIR, "working-memory.md");
+    TIMELINE_DIR = path2.join(WALNUT_HOME, "timeline");
+    CONFIG_SHARE_DIR = path2.join(WALNUT_HOME, "config", "share");
+    UI_PREFS_FILE = path2.join(CONFIG_SHARE_DIR, "ui-prefs.json");
+    STT_VOCAB_FILE = path2.join(CONFIG_SHARE_DIR, "stt-vocab.txt");
+    TMP_DIR = path2.join(WALNUT_HOME, "tmp");
+    RECORDINGS_DIR = path2.join(TMP_DIR, "recordings");
+    LOG_PREFIX = "open-walnut-";
+    QUICK_START_MESSAGE_SPILL_LIMIT = 25e3;
+    QUICK_START_MESSAGE_HARD_LIMIT = 2e6;
+    DAEMON_BINARIES_DIR = (() => {
+      let dir = path2.dirname(fileURLToPath(import.meta.url));
+      for (let i = 0; i < 5; i++) {
+        const candidate = path2.join(dir, "dist", "daemon-binaries");
+        try {
+          if (fs2.statSync(candidate).isDirectory()) return candidate;
+        } catch {
+        }
+        dir = path2.dirname(dir);
+      }
+      return path2.join(path2.dirname(fileURLToPath(import.meta.url)), "..", "dist", "daemon-binaries");
+    })();
+    WALNUT_INSTALL_DIR = (() => {
+      let dir = path2.dirname(fileURLToPath(import.meta.url));
+      for (let i = 0; i < 6; i++) {
+        try {
+          const pkg = JSON.parse(fs2.readFileSync(path2.join(dir, "package.json"), "utf8"));
+          if (pkg.name === "open-walnut" && fs2.statSync(path2.join(dir, ".git")).isDirectory()) return dir;
+        } catch {
+        }
+        const parent = path2.dirname(dir);
+        if (parent === dir) break;
+        dir = parent;
+      }
+      return null;
+    })();
+  }
+});
+
+// src/session-server/server.ts
+import { WebSocketServer, WebSocket } from "ws";
+import { createServer } from "http";
+
+// src/session-server/sdk-session.ts
+import crypto from "crypto";
+
+// src/core/usage/cost-watermark.ts
+function costIncrement(cumulativeTotal, watermark) {
+  if (cumulativeTotal === void 0 || !(cumulativeTotal > 0)) {
+    return { delta: 0, watermark };
+  }
+  const delta = cumulativeTotal - watermark;
+  if (delta <= 0) {
+    return { delta: 0, watermark };
+  }
+  return { delta, watermark: cumulativeTotal };
+}
+var CostWatermark = class {
+  watermark = 0;
+  /** Forget billed cost — call on every process spawn/resume (fresh total at 0). */
+  reset() {
+    this.watermark = 0;
+  }
+  /** Bill the increment since the last result; advances the watermark. */
+  bill(cumulativeTotal) {
+    const r = costIncrement(cumulativeTotal, this.watermark);
+    this.watermark = r.watermark;
+    return r.delta;
+  }
+};
+
+// src/session-server/sdk-session.ts
+var SDK_PERMISSION_MODE = {
+  bypass: "bypassPermissions",
+  accept: "acceptEdits",
+  plan: "plan",
+  dontAsk: "dontAsk",
+  default: "default"
+};
+function applySdkPermissionMode(options, mode) {
+  if (!mode) return;
+  const resolved = SDK_PERMISSION_MODE[mode];
+  if (!resolved) {
+    throw new Error(
+      `Permission mode "${mode}" is not supported by the SDK session server (supported: ${Object.keys(SDK_PERMISSION_MODE).join(", ")}). Use a CLI session for this mode.`
+    );
+  }
+  options.permissionMode = resolved;
+  if (mode === "bypass") options.allowDangerouslySkipPermissions = true;
+}
+function createMessageChannel() {
+  const queue = [];
+  let resolve = null;
+  let done = false;
+  const iterable = {
+    [Symbol.asyncIterator]() {
+      return {
+        next() {
+          if (queue.length > 0) {
+            return Promise.resolve({ value: queue.shift(), done: false });
+          }
+          if (done) {
+            return Promise.resolve({ value: void 0, done: true });
+          }
+          return new Promise((r) => {
+            resolve = r;
+          });
+        }
+      };
+    }
+  };
+  return {
+    push(msg) {
+      if (done) return;
+      if (resolve) {
+        const r = resolve;
+        resolve = null;
+        r({ value: msg, done: false });
+      } else {
+        queue.push(msg);
+      }
+    },
+    end() {
+      done = true;
+      if (resolve) {
+        const r = resolve;
+        resolve = null;
+        r({ value: void 0, done: true });
+      }
+    },
+    iterable
+  };
+}
+var SdkSession = class {
+  id;
+  queryHandle = null;
+  channel;
+  abortController = new AbortController();
+  emitEvent;
+  _status = "idle";
+  _cwd;
+  _mode;
+  _sessionId;
+  /** Converts the SDK's cumulative total_cost_usd into a billable per-result
+   *  increment. The total is a running total per query(); a resume starts a fresh
+   *  query() whose total restarts at 0, so we reset on every start()/resume().
+   *  Without this the whole running total was billed every turn (the 13×
+   *  session-cost inflation bug). See core/usage/cost-watermark.ts. */
+  _costWatermark = new CostWatermark();
+  /** Map of pending interactive requests (question/permission) by requestId */
+  pendingInteractions = /* @__PURE__ */ new Map();
+  constructor(id, emitEvent) {
+    this.id = id;
+    this.emitEvent = emitEvent;
+    this.channel = createMessageChannel();
+    this._mode = "default";
+  }
+  get status() {
+    return this._status;
+  }
+  get cwd() {
+    return this._cwd;
+  }
+  get mode() {
+    return this._mode;
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  /** Billable cost increment since the last result; advances the per-query
+   *  watermark. Returns 0 for replayed/stale results. See cost-watermark.ts. */
+  billableCostDelta(totalCostUsd) {
+    return this._costWatermark.bill(totalCostUsd);
+  }
+  /**
+   * Start a new query (or resume) and begin streaming events.
+   */
+  async start(params) {
+    const { query } = await import("@anthropic-ai/claude-agent-sdk");
+    this._cwd = params.cwd;
+    this._mode = params.mode ?? "default";
+    this._sessionId = params.sessionId;
+    this._status = "running";
+    this._costWatermark.reset();
+    const options = {
+      cwd: params.cwd,
+      includePartialMessages: true,
+      abortController: this.abortController
+    };
+    applySdkPermissionMode(options, params.mode);
+    if (params.systemPrompt) {
+      options.systemPrompt = {
+        type: "preset",
+        preset: "claude_code",
+        append: params.systemPrompt
+      };
+    }
+    if (params.sessionId) {
+      options.resume = params.sessionId;
+    }
+    options.canUseTool = this.createCanUseTool();
+    const initialMessage = {
+      type: "user",
+      message: { role: "user", content: params.message },
+      parent_tool_use_id: null,
+      session_id: this._sessionId ?? ""
+    };
+    this.channel = createMessageChannel();
+    this.queryHandle = query({
+      prompt: params.message,
+      options
+    });
+    this.processOutput().catch((err) => {
+      this.emitEvent("session:error", {
+        sessionId: this._sessionId ?? this.id,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      this._status = "error";
+    });
+    return this._sessionId ?? this.id;
+  }
+  /**
+   * Send a follow-up message to the running session.
+   *
+   * If the session is idle (previous turn completed), starts a new query
+   * with `resume: sessionId` — the SDK picks up the existing conversation.
+   * If still running mid-turn, uses `streamInput` to inject the message.
+   */
+  async send(message) {
+    if (this._status === "idle" && this._sessionId) {
+      await this.resume(message);
+      return;
+    }
+    if (!this.queryHandle) {
+      throw new Error("Session not started");
+    }
+    this._status = "running";
+    const msg = {
+      type: "user",
+      message: { role: "user", content: message },
+      parent_tool_use_id: null,
+      session_id: this._sessionId ?? ""
+    };
+    await this.queryHandle.streamInput((async function* () {
+      yield msg;
+    })());
+  }
+  /**
+   * Resume the session with a new query after the previous turn completed.
+   */
+  async resume(message) {
+    const { query } = await import("@anthropic-ai/claude-agent-sdk");
+    this._status = "running";
+    this._costWatermark.reset();
+    this.abortController = new AbortController();
+    const options = {
+      cwd: this._cwd,
+      includePartialMessages: true,
+      abortController: this.abortController,
+      resume: this._sessionId
+    };
+    applySdkPermissionMode(options, this._mode);
+    options.canUseTool = this.createCanUseTool();
+    this.queryHandle = query({
+      prompt: message,
+      options
+    });
+    this.processOutput().catch((err) => {
+      this.emitEvent("session:error", {
+        sessionId: this._sessionId ?? this.id,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      this._status = "error";
+    });
+  }
+  /**
+   * Interrupt the current turn.
+   */
+  async interrupt() {
+    if (this.queryHandle) {
+      await this.queryHandle.interrupt();
+    }
+    this._status = "idle";
+  }
+  /**
+   * Change permission mode.
+   */
+  async setMode(mode) {
+    this._mode = mode;
+    if (this.queryHandle) {
+      await this.queryHandle.setPermissionMode(mode);
+    }
+  }
+  /**
+   * Stop the session entirely.
+   */
+  stop() {
+    this.abortController.abort();
+    if (this.queryHandle) {
+      this.queryHandle.close();
+      this.queryHandle = null;
+    }
+    this.channel.end();
+    this._status = "idle";
+    for (const [, pending] of this.pendingInteractions) {
+      pending.reject(new Error("Session stopped"));
+    }
+    this.pendingInteractions.clear();
+  }
+  /**
+   * Resolve a pending AskUserQuestion interaction.
+   */
+  resolveQuestion(questionId, answers) {
+    const pending = this.pendingInteractions.get(questionId);
+    if (pending) {
+      this.pendingInteractions.delete(questionId);
+      pending.resolve(answers);
+    }
+  }
+  /**
+   * Resolve a pending permission request.
+   */
+  resolvePermission(requestId, allow, message) {
+    const pending = this.pendingInteractions.get(requestId);
+    if (pending) {
+      this.pendingInteractions.delete(requestId);
+      pending.resolve({ allow, message });
+    }
+  }
+  // ── Private ──
+  createCanUseTool() {
+    return async (toolName, input, options) => {
+      if (toolName === "AskUserQuestion") {
+        const questionId = `q-${crypto.randomBytes(4).toString("hex")}`;
+        const questions = input.questions;
+        this.emitEvent("session:ask-question", {
+          sessionId: this._sessionId ?? this.id,
+          questionId,
+          questions
+        });
+        const answers = await new Promise((resolve, reject) => {
+          this.pendingInteractions.set(questionId, { resolve, reject });
+        });
+        return {
+          behavior: "allow",
+          updatedInput: { ...input, answers }
+        };
+      }
+      if (toolName === "ExitPlanMode") {
+        const planContent = typeof input.plan === "string" ? input.plan : "";
+        this.emitEvent("session:plan-complete", {
+          sessionId: this._sessionId ?? this.id,
+          planContent
+        });
+        return { behavior: "allow" };
+      }
+      if (this._mode === "bypass") {
+        return { behavior: "allow" };
+      }
+      if (this._mode === "accept") {
+        const editTools = ["Write", "Edit", "NotebookEdit"];
+        if (editTools.includes(toolName)) {
+          return { behavior: "allow" };
+        }
+      }
+      if (this._mode === "dontAsk") {
+        return {
+          behavior: "deny",
+          message: `Denied by "Don't Ask" mode \u2014 ${toolName} is not pre-approved. Switch modes to allow it.`
+        };
+      }
+      const requestId = `perm-${crypto.randomBytes(4).toString("hex")}`;
+      this.emitEvent("session:permission-request", {
+        sessionId: this._sessionId ?? this.id,
+        requestId,
+        toolName,
+        input,
+        suggestions: options.suggestions
+      });
+      const result = await new Promise((resolve, reject) => {
+        this.pendingInteractions.set(requestId, {
+          resolve,
+          reject
+        });
+      });
+      if (result.allow) {
+        return { behavior: "allow" };
+      } else {
+        return { behavior: "deny", message: result.message ?? "Permission denied" };
+      }
+    };
+  }
+  /**
+   * Process the output stream from the SDK query.
+   * Maps SDK messages to session server events.
+   */
+  async processOutput() {
+    if (!this.queryHandle) return;
+    try {
+      for await (const msg of this.queryHandle) {
+        this.handleMessage(msg);
+      }
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        return;
+      }
+      throw err;
+    } finally {
+      this._status = "idle";
+    }
+  }
+  handleMessage(msg) {
+    const sessionId = this._sessionId ?? this.id;
+    switch (msg.type) {
+      case "system": {
+        const sys = msg;
+        if ("subtype" in sys) {
+          if (sys.subtype === "init") {
+            const init = sys;
+            this._sessionId = init.session_id;
+            this.emitEvent("session:init", {
+              sessionId: init.session_id,
+              model: init.model,
+              cwd: init.cwd,
+              tools: init.tools
+            });
+          } else if (sys.subtype === "compact_boundary") {
+            const compact = sys;
+            this.emitEvent("session:compact", {
+              sessionId,
+              trigger: compact.compact_metadata.trigger,
+              preTokens: compact.compact_metadata.pre_tokens
+            });
+          }
+        }
+        break;
+      }
+      case "assistant": {
+        const assistant = msg;
+        if (!assistant.message?.content) break;
+        for (const block of assistant.message.content) {
+          if (block.type === "text" && "text" in block) {
+            this.emitEvent("session:text-delta", {
+              sessionId,
+              delta: block.text
+            });
+          } else if (block.type === "tool_use") {
+            this.emitEvent("session:tool-use", {
+              sessionId,
+              toolUseId: block.id,
+              name: block.name,
+              input: block.input,
+              parentToolUseId: assistant.parent_tool_use_id ?? void 0
+            });
+          }
+        }
+        break;
+      }
+      case "user": {
+        const user = msg;
+        if ("isReplay" in user && user.isReplay) break;
+        if (user.message?.content && Array.isArray(user.message.content)) {
+          for (const block of user.message.content) {
+            if (typeof block === "object" && block !== null && "type" in block && block.type === "tool_result") {
+              const content = "content" in block ? typeof block.content === "string" ? block.content : JSON.stringify(block.content) : "";
+              this.emitEvent("session:tool-result", {
+                sessionId,
+                toolUseId: "tool_use_id" in block ? block.tool_use_id : "",
+                result: typeof content === "string" ? content.slice(0, 2e3) : ""
+              });
+            }
+          }
+        }
+        break;
+      }
+      case "stream_event": {
+        const partial = msg;
+        if (partial.event?.type === "content_block_delta") {
+          const delta = partial.event;
+          if (delta.delta?.type === "text_delta" && delta.delta.text) {
+            this.emitEvent("session:text-delta", {
+              sessionId,
+              delta: delta.delta.text
+            });
+          }
+        }
+        break;
+      }
+      case "result": {
+        const result = msg;
+        this._sessionId = result.session_id;
+        let subtype = "success";
+        let resultText = "";
+        if (result.subtype === "success") {
+          subtype = "success";
+          resultText = result.result ?? "";
+        } else {
+          const errorResult = result;
+          if (errorResult.subtype === "error_max_turns") {
+            subtype = "error_max_turns";
+          } else if (errorResult.subtype === "error_max_budget_usd") {
+            subtype = "error_max_budget";
+          } else {
+            subtype = "error";
+          }
+          resultText = errorResult.errors?.join("\n") ?? "";
+        }
+        this.emitEvent("session:result", {
+          sessionId: result.session_id,
+          result: resultText,
+          subtype,
+          cost: result.total_cost_usd,
+          costDelta: this.billableCostDelta(result.total_cost_usd),
+          duration: result.duration_ms,
+          usage: result.usage ? {
+            input_tokens: result.usage.input_tokens,
+            output_tokens: result.usage.output_tokens
+          } : void 0,
+          modelUsage: result.modelUsage
+        });
+        this._status = "idle";
+        break;
+      }
+    }
+  }
+};
+
+// src/session-server/state.ts
+import fs from "fs";
+import path from "path";
+var STATE_FILE = "session-server-state.json";
+var StateManager = class {
+  filePath;
+  sessions = /* @__PURE__ */ new Map();
+  constructor(dataDir) {
+    this.filePath = path.join(dataDir, STATE_FILE);
+    this.load();
+  }
+  /** Add or update a session. */
+  set(sessionId, data) {
+    this.sessions.set(sessionId, { sessionId, ...data });
+    this.save();
+  }
+  /** Remove a session. */
+  remove(sessionId) {
+    this.sessions.delete(sessionId);
+    this.save();
+  }
+  /** Get all persisted sessions. */
+  getAll() {
+    return Array.from(this.sessions.values());
+  }
+  /** Clear all sessions. */
+  clear() {
+    this.sessions.clear();
+    this.save();
+  }
+  load() {
+    try {
+      if (fs.existsSync(this.filePath)) {
+        const raw = fs.readFileSync(this.filePath, "utf-8");
+        const state = JSON.parse(raw);
+        for (const s of state.sessions) {
+          this.sessions.set(s.sessionId, s);
+        }
+      }
+    } catch {
+      this.sessions.clear();
+    }
+  }
+  save() {
+    try {
+      const dir = path.dirname(this.filePath);
+      fs.mkdirSync(dir, { recursive: true });
+      const state = {
+        sessions: Array.from(this.sessions.values())
+      };
+      fs.writeFileSync(this.filePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
+    } catch {
+    }
+  }
+};
+
+// src/session-server/server.ts
+var SessionServer = class {
+  constructor(options) {
+    this.options = options;
+    this.state = new StateManager(options.dataDir);
+  }
+  wss = null;
+  httpServer = null;
+  sessions = /* @__PURE__ */ new Map();
+  state;
+  clients = /* @__PURE__ */ new Set();
+  /** Start the WebSocket server. Returns the actual port. */
+  async start() {
+    const persisted = this.state.getAll();
+    for (const p of persisted) {
+      this.state.remove(p.sessionId);
+    }
+    return new Promise((resolve, reject) => {
+      this.httpServer = createServer();
+      this.wss = new WebSocketServer({ server: this.httpServer });
+      this.wss.on("connection", (ws) => {
+        this.clients.add(ws);
+        ws.on("close", () => this.clients.delete(ws));
+        ws.on("message", (raw) => {
+          try {
+            const frame = JSON.parse(raw.toString());
+            if (frame.type === "cmd") {
+              this.handleCommand(ws, frame);
+            }
+          } catch {
+          }
+        });
+      });
+      this.httpServer.listen(this.options.port, () => {
+        const addr = this.httpServer.address();
+        if (typeof addr === "object" && addr) {
+          resolve(addr.port);
+        } else {
+          reject(new Error("Failed to get server address"));
+        }
+      });
+      this.httpServer.on("error", reject);
+    });
+  }
+  /** Stop the server and clean up all sessions. */
+  async stop() {
+    for (const [, session] of this.sessions) {
+      session.stop();
+    }
+    this.sessions.clear();
+    for (const ws of this.clients) {
+      ws.close();
+    }
+    this.clients.clear();
+    return new Promise((resolve) => {
+      if (this.wss) {
+        this.wss.close(() => {
+          if (this.httpServer) {
+            this.httpServer.close(() => resolve());
+          } else {
+            resolve();
+          }
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+  async handleCommand(ws, cmd) {
+    try {
+      switch (cmd.method) {
+        case "session.start":
+          await this.handleSessionStart(ws, cmd);
+          break;
+        case "session.send":
+          await this.handleSessionSend(ws, cmd);
+          break;
+        case "session.interrupt":
+          await this.handleSessionInterrupt(ws, cmd);
+          break;
+        case "session.setMode":
+          await this.handleSessionSetMode(ws, cmd);
+          break;
+        case "session.stop":
+          await this.handleSessionStop(ws, cmd);
+          break;
+        case "session.respondToQuestion":
+          this.handleRespondToQuestion(ws, cmd);
+          break;
+        case "session.respondToPermission":
+          this.handleRespondToPermission(ws, cmd);
+          break;
+        case "session.list":
+          this.handleSessionList(ws, cmd);
+          break;
+        case "ping":
+          this.sendResponse(ws, cmd.id, true, { ok: true });
+          break;
+        default:
+          this.sendResponse(ws, cmd.id, false, void 0, `Unknown method: ${cmd.method}`);
+      }
+    } catch (err) {
+      this.sendResponse(ws, cmd.id, false, void 0, err instanceof Error ? err.message : String(err));
+    }
+  }
+  async handleSessionStart(ws, cmd) {
+    const params = cmd.params;
+    const sessionId = params.sessionId ?? `sdk-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const emitEvent = (name, data) => {
+      this.broadcastEvent(sessionId, name, data);
+    };
+    const session = new SdkSession(sessionId, emitEvent);
+    this.sessions.set(sessionId, session);
+    this.state.set(sessionId, {
+      cwd: params.cwd,
+      mode: params.mode,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    this.sendResponse(ws, cmd.id, true, { sessionId });
+    session.start({
+      message: params.message,
+      cwd: params.cwd,
+      mode: params.mode,
+      systemPrompt: params.systemPrompt,
+      sessionId: params.sessionId
+    }).catch((err) => {
+      this.broadcastEvent(sessionId, "session:error", {
+        sessionId,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    });
+  }
+  async handleSessionSend(ws, cmd) {
+    const params = cmd.params;
+    const session = this.sessions.get(params.sessionId);
+    if (!session) {
+      this.sendResponse(ws, cmd.id, false, void 0, `Session not found: ${params.sessionId}`);
+      return;
+    }
+    this.sendResponse(ws, cmd.id, true, { ok: true });
+    session.send(params.message).catch((err) => {
+      this.broadcastEvent(params.sessionId, "session:error", {
+        sessionId: params.sessionId,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    });
+  }
+  async handleSessionInterrupt(ws, cmd) {
+    const params = cmd.params;
+    const session = this.sessions.get(params.sessionId);
+    if (!session) {
+      this.sendResponse(ws, cmd.id, false, void 0, `Session not found: ${params.sessionId}`);
+      return;
+    }
+    await session.interrupt();
+    this.sendResponse(ws, cmd.id, true, { ok: true });
+  }
+  async handleSessionSetMode(ws, cmd) {
+    const params = cmd.params;
+    const session = this.sessions.get(params.sessionId);
+    if (!session) {
+      this.sendResponse(ws, cmd.id, false, void 0, `Session not found: ${params.sessionId}`);
+      return;
+    }
+    await session.setMode(params.mode);
+    this.sendResponse(ws, cmd.id, true, { ok: true });
+  }
+  async handleSessionStop(ws, cmd) {
+    const params = cmd.params;
+    const session = this.sessions.get(params.sessionId);
+    if (session) {
+      session.stop();
+      this.sessions.delete(params.sessionId);
+      this.state.remove(params.sessionId);
+    }
+    this.sendResponse(ws, cmd.id, true, { ok: true });
+  }
+  handleRespondToQuestion(ws, cmd) {
+    const params = cmd.params;
+    const session = this.sessions.get(params.sessionId);
+    if (session) {
+      session.resolveQuestion(params.questionId, params.answers);
+    }
+    this.sendResponse(ws, cmd.id, true, { ok: true });
+  }
+  handleRespondToPermission(ws, cmd) {
+    const params = cmd.params;
+    const session = this.sessions.get(params.sessionId);
+    if (session) {
+      session.resolvePermission(params.requestId, params.allow, params.message);
+    }
+    this.sendResponse(ws, cmd.id, true, { ok: true });
+  }
+  handleSessionList(ws, cmd) {
+    const sessions = [];
+    for (const [id, session] of this.sessions) {
+      sessions.push({
+        sessionId: session.sessionId ?? id,
+        status: session.status,
+        cwd: session.cwd,
+        mode: session.mode
+      });
+    }
+    this.sendResponse(ws, cmd.id, true, { sessions });
+  }
+  sendResponse(ws, id, ok, data, error) {
+    const frame = { type: "res", id, ok };
+    if (data !== void 0) frame.data = data;
+    if (error !== void 0) frame.error = error;
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify(frame));
+    }
+  }
+  broadcastEvent(sessionId, name, data) {
+    const frame = { type: "event", sessionId, name, data };
+    const payload = JSON.stringify(frame);
+    for (const ws of this.clients) {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(payload);
+      }
+    }
+  }
+};
+
+// src/logging/logger.ts
+init_constants();
+import fs3 from "fs";
+import fsp from "fs/promises";
+import path3 from "path";
+
+// src/logging/redact.ts
+var REDACTED = "[REDACTED]";
+var patterns = [
+  // PEM private key blocks (multiline)
+  {
+    re: /-----BEGIN\s[\w\s]*PRIVATE KEY-----[\s\S]*?-----END\s[\w\s]*PRIVATE KEY-----/g,
+    replacement: REDACTED
+  },
+  // Bearer tokens: Authorization: Bearer <token>
+  {
+    re: /(Bearer\s+)\S+/gi,
+    replacement: `$1${REDACTED}`
+  },
+  // OpenAI / Anthropic style keys: sk-... (at least 20 chars after prefix)
+  {
+    re: /\bsk-[A-Za-z0-9_-]{20,}\b/g,
+    replacement: REDACTED
+  },
+  // AWS access key IDs: AKIA...
+  {
+    re: /\bAKIA[A-Z0-9]{12,}\b/g,
+    replacement: REDACTED
+  },
+  // AWS secret access key in key=value form
+  {
+    re: /(aws_secret_access_key\s*[=:]\s*)\S+/gi,
+    replacement: `$1${REDACTED}`
+  },
+  // AWS session token in key=value form
+  {
+    re: /(aws_session_token\s*[=:]\s*)\S+/gi,
+    replacement: `$1${REDACTED}`
+  },
+  // Credentials in URL userinfo: https://user:secret@host/...
+  // Motivating shape: execSync embeds the whole command in error.message, so a
+  // failed `git remote add origin https://walnut:<device-token>@host/git/data`
+  // otherwise logs the cloud companion's long-lived credential verbatim.
+  {
+    re: /(https?:\/\/[^/\s:@]+:)[^@/\s]+@/gi,
+    replacement: `$1${REDACTED}@`
+  },
+  // Generic secrets: password=, secret=, token=, api_key=, apikey=
+  {
+    re: /((?:password|secret|token|api_key|apikey)\s*[=:]\s*)\S+/gi,
+    replacement: `$1${REDACTED}`
+  }
+];
+function redactSensitiveText(text) {
+  let result = text;
+  for (const { re, replacement } of patterns) {
+    result = result.replace(re, replacement);
+  }
+  return result;
+}
+
+// src/logging/logger.ts
+var dirEnsured = false;
+function ensureLogDir() {
+  if (dirEnsured) return;
+  try {
+    fs3.mkdirSync(LOG_DIR, { recursive: true });
+    dirEnsured = true;
+  } catch {
+  }
+}
+function todayFileName() {
+  const d = /* @__PURE__ */ new Date();
+  const yyyy = d.getFullYear();
+  const mm = String(d.getMonth() + 1).padStart(2, "0");
+  const dd = String(d.getDate()).padStart(2, "0");
+  return `${LOG_PREFIX}${yyyy}-${mm}-${dd}.log`;
+}
+function logFilePath() {
+  return path3.join(LOG_DIR, todayFileName());
+}
+var FLUSH_INTERVAL_MS = 2e3;
+var buffer = [];
+var flushTimer = null;
+var flushing = false;
+function startFlushTimer() {
+  if (flushTimer) return;
+  flushTimer = setInterval(() => {
+    void flushLogBuffer();
+  }, FLUSH_INTERVAL_MS);
+  if (flushTimer && typeof flushTimer === "object" && "unref" in flushTimer) {
+    flushTimer.unref();
+  }
+}
+async function flushLogBuffer() {
+  if (flushing || buffer.length === 0) return;
+  flushing = true;
+  const batch = buffer;
+  buffer = [];
+  try {
+    ensureLogDir();
+    await fsp.appendFile(logFilePath(), batch.join(""), "utf-8");
+  } catch {
+  } finally {
+    flushing = false;
+  }
+}
+function flushLogBufferSync() {
+  if (buffer.length === 0) return;
+  const batch = buffer;
+  buffer = [];
+  try {
+    ensureLogDir();
+    fs3.appendFileSync(logFilePath(), batch.join(""), "utf-8");
+  } catch {
+  }
+}
+process.on("beforeExit", flushLogBufferSync);
+process.on("exit", flushLogBufferSync);
+function writeLogEntry(entry) {
+  const line = redactSensitiveText(JSON.stringify(entry)) + "\n";
+  buffer.push(line);
+  startFlushTimer();
+}
+
+// src/logging/subsystem.ts
+import chalk from "chalk";
+
+// src/logging/levels.ts
+var LOG_LEVEL_ORDER = {
+  trace: 0,
+  debug: 1,
+  info: 2,
+  warn: 3,
+  error: 4,
+  fatal: 5
+};
+var DEFAULT_LEVEL = "info";
+function resolveConfiguredLevel() {
+  const raw = process.env.WALNUT_LOG_LEVEL?.toLowerCase().trim();
+  if (raw && raw in LOG_LEVEL_ORDER) return raw;
+  return DEFAULT_LEVEL;
+}
+var CONFIGURED_LOG_LEVEL = resolveConfiguredLevel();
+function shouldLog(messageLevel, configuredLevel = CONFIGURED_LOG_LEVEL) {
+  return LOG_LEVEL_ORDER[messageLevel] >= LOG_LEVEL_ORDER[configuredLevel];
+}
+
+// src/logging/subsystem.ts
+var levelColor = {
+  trace: chalk.gray,
+  debug: chalk.cyan,
+  info: chalk.green,
+  warn: chalk.yellow,
+  error: chalk.red,
+  fatal: chalk.bgRed.white
+};
+var levelLabel = {
+  trace: "TRC",
+  debug: "DBG",
+  info: "INF",
+  warn: "WRN",
+  error: "ERR",
+  fatal: "FTL"
+};
+function timeStamp(d) {
+  const hh = String(d.getHours()).padStart(2, "0");
+  const mm = String(d.getMinutes()).padStart(2, "0");
+  const ss = String(d.getSeconds()).padStart(2, "0");
+  return `${hh}:${mm}:${ss}`;
+}
+function formatMeta(meta) {
+  if (!meta || Object.keys(meta).length === 0) return "";
+  return " " + chalk.dim(JSON.stringify(meta));
+}
+var ERROR_SINK_KEY = /* @__PURE__ */ Symbol.for("open-walnut.errorNotificationSink");
+var inErrorSink = false;
+function forwardToErrorSink(subsystem, message, meta) {
+  const sink = globalThis[ERROR_SINK_KEY];
+  if (!sink || inErrorSink) return;
+  if (subsystem.startsWith("notif")) return;
+  inErrorSink = true;
+  try {
+    sink({ subsystem, message, meta });
+  } catch {
+  } finally {
+    inErrorSink = false;
+  }
+}
+function emit(level, subsystem, message, meta) {
+  if (!shouldLog(level)) return;
+  const now = /* @__PURE__ */ new Date();
+  writeLogEntry({
+    time: now.toISOString(),
+    level,
+    subsystem,
+    message,
+    ...meta && Object.keys(meta).length > 0 ? meta : {}
+  });
+  if (level === "error" || level === "fatal") {
+    forwardToErrorSink(subsystem, message, meta);
+  }
+  try {
+    const colorFn = levelColor[level];
+    const tag = chalk.bold(`[${subsystem}]`);
+    const lbl = colorFn(levelLabel[level]);
+    const ts = chalk.dim(timeStamp(now));
+    const metaStr = formatMeta(meta);
+    const line = redactSensitiveText(`${ts} ${lbl} ${tag} ${message}${metaStr}
+`);
+    process.stderr.write(line);
+  } catch {
+  }
+}
+function createSubsystemLogger(subsystem) {
+  const logger = {
+    trace: (msg, meta) => emit("trace", subsystem, msg, meta),
+    debug: (msg, meta) => emit("debug", subsystem, msg, meta),
+    info: (msg, meta) => emit("info", subsystem, msg, meta),
+    warn: (msg, meta) => emit("warn", subsystem, msg, meta),
+    error: (msg, meta) => emit("error", subsystem, msg, meta),
+    fatal: (msg, meta) => emit("fatal", subsystem, msg, meta),
+    child(subName) {
+      return createSubsystemLogger(`${subsystem}/${subName}`);
+    }
+  };
+  return logger;
+}
+
+// src/logging/index.ts
+var log = {
+  bus: createSubsystemLogger("bus"),
+  agent: createSubsystemLogger("agent"),
+  session: createSubsystemLogger("session"),
+  subagent: createSubsystemLogger("subagent"),
+  web: createSubsystemLogger("web"),
+  ws: createSubsystemLogger("ws"),
+  hook: createSubsystemLogger("hook"),
+  task: createSubsystemLogger("task"),
+  memory: createSubsystemLogger("memory"),
+  cron: createSubsystemLogger("cron"),
+  notif: createSubsystemLogger("notif"),
+  usage: createSubsystemLogger("usage"),
+  heartbeat: createSubsystemLogger("heartbeat"),
+  git: createSubsystemLogger("git"),
+  browser: createSubsystemLogger("browser"),
+  audio: createSubsystemLogger("audio"),
+  stt: createSubsystemLogger("stt"),
+  obs: createSubsystemLogger("obs"),
+  calendar: createSubsystemLogger("calendar")
+};
+
+// src/session-server/index.ts
+var DEFAULT_PORT = 7890;
+async function startSessionServer(options) {
+  delete process.env.CLAUDECODE;
+  const server = new SessionServer({
+    port: options.port,
+    dataDir: options.dataDir
+  });
+  const actualPort = await server.start();
+  return { port: actualPort, server };
+}
+async function runSessionServer(options) {
+  const { WALNUT_HOME: WALNUT_HOME2 } = await Promise.resolve().then(() => (init_constants(), constants_exports));
+  const port = parseInt(options.port ?? String(DEFAULT_PORT), 10);
+  const dataDir = options.dataDir ?? WALNUT_HOME2;
+  const { port: actualPort } = await startSessionServer({ port, dataDir });
+  console.log(JSON.stringify({ port: actualPort, pid: process.pid }));
+  const shutdown = () => {
+    log.session.info("shutting down session server");
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+var isMainModule = process.argv[1]?.endsWith("session-server/index.js") || process.argv[1]?.endsWith("session-server/index.mjs");
+if (isMainModule) {
+  const args = process.argv.slice(2);
+  const portIdx = args.indexOf("--port");
+  const dataDirIdx = args.indexOf("--data-dir");
+  const options = {};
+  if (portIdx !== -1 && args[portIdx + 1]) options.port = args[portIdx + 1];
+  if (dataDirIdx !== -1 && args[dataDirIdx + 1]) options.dataDir = args[dataDirIdx + 1];
+  runSessionServer(options).catch((err) => {
+    console.error("Fatal:", err);
+    log.session.fatal("fatal error in session server", { error: err instanceof Error ? err.message : String(err), stack: err instanceof Error ? err.stack : void 0 });
+    process.exit(1);
+  });
+}
+export {
+  runSessionServer,
+  startSessionServer
+};
+//# sourceMappingURL=index.js.map