@codelia/storage 0.1.0

package/dist/index.cjs

@@ -0,0 +1,416 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  McpAuthStore: () => McpAuthStore,
+  RunEventStoreFactoryImpl: () => RunEventStoreFactoryImpl,
+  SessionStateStoreImpl: () => SessionStateStoreImpl,
+  SessionStoreWriterImpl: () => SessionStoreWriterImpl,
+  StoragePathServiceImpl: () => StoragePathServiceImpl,
+  ToolOutputCacheStoreImpl: () => ToolOutputCacheStoreImpl,
+  ensureStorageDirs: () => ensureStorageDirs,
+  resolveStoragePaths: () => resolveStoragePaths
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/mcp-auth-store.ts
+var import_node_fs = require("fs");
+
+// src/paths.ts
+var import_promises = require("fs/promises");
+var import_node_os = __toESM(require("os"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var DEFAULT_ROOT_DIR = ".codelia";
+var LAYOUT_ENV = "CODELIA_LAYOUT";
+var XDG_DIR_NAME = "codelia";
+var CONFIG_FILENAME = "config.json";
+var AUTH_FILENAME = "auth.json";
+var MCP_AUTH_FILENAME = "mcp-auth.json";
+var CACHE_DIRNAME = "cache";
+var TOOL_OUTPUT_CACHE_DIRNAME = "tool-output";
+var SESSIONS_DIRNAME = "sessions";
+var LOGS_DIRNAME = "logs";
+function resolveStoragePaths(options = {}) {
+  if (options.rootOverride) {
+    return buildHomeLayout(options.rootOverride);
+  }
+  const layoutValue = options.layout ?? process.env[LAYOUT_ENV];
+  const layout = normalizeLayout(layoutValue);
+  if (layout === "xdg") {
+    return buildXdgLayout();
+  }
+  return buildHomeLayout(defaultHomeRoot());
+}
+async function ensureStorageDirs(paths) {
+  await Promise.all([
+    (0, import_promises.mkdir)(paths.configDir, { recursive: true }),
+    (0, import_promises.mkdir)(paths.cacheDir, { recursive: true }),
+    (0, import_promises.mkdir)(paths.toolOutputCacheDir, { recursive: true }),
+    (0, import_promises.mkdir)(paths.sessionsDir, { recursive: true }),
+    (0, import_promises.mkdir)(paths.logsDir, { recursive: true })
+  ]);
+}
+function normalizeLayout(value) {
+  if (value && value.toLowerCase() === "xdg") return "xdg";
+  return "home";
+}
+function defaultHomeRoot() {
+  return import_node_path.default.join(import_node_os.default.homedir(), DEFAULT_ROOT_DIR);
+}
+function buildHomeLayout(root) {
+  const configDir = root;
+  return {
+    root,
+    configDir,
+    configFile: import_node_path.default.join(configDir, CONFIG_FILENAME),
+    authFile: import_node_path.default.join(configDir, AUTH_FILENAME),
+    mcpAuthFile: import_node_path.default.join(configDir, MCP_AUTH_FILENAME),
+    cacheDir: import_node_path.default.join(root, CACHE_DIRNAME),
+    toolOutputCacheDir: import_node_path.default.join(
+      root,
+      CACHE_DIRNAME,
+      TOOL_OUTPUT_CACHE_DIRNAME
+    ),
+    sessionsDir: import_node_path.default.join(root, SESSIONS_DIRNAME),
+    logsDir: import_node_path.default.join(root, LOGS_DIRNAME)
+  };
+}
+function buildXdgLayout() {
+  const home = import_node_os.default.homedir();
+  const configRoot = process.env.XDG_CONFIG_HOME ?? import_node_path.default.join(home, ".config");
+  const cacheRoot = process.env.XDG_CACHE_HOME ?? import_node_path.default.join(home, ".cache");
+  const stateRoot = process.env.XDG_STATE_HOME ?? import_node_path.default.join(home, ".local", "state");
+  const configDir = import_node_path.default.join(configRoot, XDG_DIR_NAME);
+  const cacheDir = import_node_path.default.join(cacheRoot, XDG_DIR_NAME);
+  const stateDir = import_node_path.default.join(stateRoot, XDG_DIR_NAME);
+  return {
+    root: stateDir,
+    configDir,
+    configFile: import_node_path.default.join(configDir, CONFIG_FILENAME),
+    authFile: import_node_path.default.join(configDir, AUTH_FILENAME),
+    mcpAuthFile: import_node_path.default.join(configDir, MCP_AUTH_FILENAME),
+    cacheDir,
+    toolOutputCacheDir: import_node_path.default.join(cacheDir, TOOL_OUTPUT_CACHE_DIRNAME),
+    sessionsDir: import_node_path.default.join(stateDir, SESSIONS_DIRNAME),
+    logsDir: import_node_path.default.join(stateDir, LOGS_DIRNAME)
+  };
+}
+
+// src/mcp-auth-store.ts
+var MCP_AUTH_VERSION = 1;
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var pickString = (value) => typeof value === "string" ? value : void 0;
+var pickNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+var normalizeTokens = (value) => {
+  if (!isRecord(value)) return null;
+  const accessToken = pickString(value.access_token);
+  if (!accessToken) return null;
+  return {
+    access_token: accessToken,
+    ...pickString(value.refresh_token) ? { refresh_token: pickString(value.refresh_token) } : {},
+    ...pickNumber(value.expires_at) ? { expires_at: pickNumber(value.expires_at) } : {},
+    ...pickString(value.token_type) ? { token_type: pickString(value.token_type) } : {},
+    ...pickString(value.scope) ? { scope: pickString(value.scope) } : {},
+    ...pickString(value.client_id) ? { client_id: pickString(value.client_id) } : {},
+    ...pickString(value.client_secret) ? { client_secret: pickString(value.client_secret) } : {}
+  };
+};
+var McpAuthStore = class {
+  paths;
+  constructor(paths) {
+    this.paths = paths ?? resolveStoragePaths();
+  }
+  async load() {
+    try {
+      const text = await import_node_fs.promises.readFile(this.paths.mcpAuthFile, "utf8");
+      const parsed = JSON.parse(text);
+      if (!isRecord(parsed) || parsed.version !== MCP_AUTH_VERSION) {
+        throw new Error("mcp-auth.json has unsupported version");
+      }
+      const serversRaw = isRecord(parsed.servers) ? parsed.servers : {};
+      const servers = {};
+      for (const [id, entry] of Object.entries(serversRaw)) {
+        const normalized = normalizeTokens(entry);
+        if (normalized) {
+          servers[id] = normalized;
+        }
+      }
+      return {
+        version: MCP_AUTH_VERSION,
+        servers
+      };
+    } catch (error) {
+      const err = error;
+      if (err?.code === "ENOENT") {
+        return { version: MCP_AUTH_VERSION, servers: {} };
+      }
+      throw error;
+    }
+  }
+  async save(auth) {
+    await ensureStorageDirs(this.paths);
+    const data = JSON.stringify(auth, null, 2);
+    await import_node_fs.promises.writeFile(this.paths.mcpAuthFile, data, { mode: 384 });
+    try {
+      await import_node_fs.promises.chmod(this.paths.mcpAuthFile, 384);
+    } catch {
+    }
+  }
+};
+
+// src/session-store.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = __toESM(require("path"), 1);
+var pad2 = (value) => String(value).padStart(2, "0");
+var resolveDateParts = (startedAt) => {
+  const parsed = new Date(startedAt);
+  const date = Number.isNaN(parsed.getTime()) ? /* @__PURE__ */ new Date() : parsed;
+  return {
+    year: String(date.getUTCFullYear()),
+    month: pad2(date.getUTCMonth() + 1),
+    day: pad2(date.getUTCDate())
+  };
+};
+var SessionStoreWriterImpl = class {
+  filePath;
+  ensureDir;
+  writeChain = Promise.resolve();
+  constructor(options) {
+    const paths = options.paths ?? resolveStoragePaths();
+    const parts = resolveDateParts(options.startedAt);
+    const baseDir = import_node_path2.default.join(
+      paths.sessionsDir,
+      parts.year,
+      parts.month,
+      parts.day
+    );
+    this.filePath = import_node_path2.default.join(baseDir, `${options.runId}.jsonl`);
+    this.ensureDir = import_node_fs2.promises.mkdir(baseDir, { recursive: true }).then(() => {
+    });
+  }
+  append(record) {
+    let line;
+    try {
+      line = `${JSON.stringify(record)}
+`;
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    const write = this.writeChain.then(async () => {
+      await this.ensureDir;
+      await import_node_fs2.promises.appendFile(this.filePath, line, "utf8");
+    });
+    this.writeChain = write.catch(() => {
+    });
+    return write;
+  }
+};
+
+// src/run-event-store.ts
+var RunEventStoreFactoryImpl = class {
+  create(init) {
+    return new SessionStoreWriterImpl({
+      runId: init.runId,
+      startedAt: init.startedAt
+    });
+  }
+};
+
+// src/service.ts
+var StoragePathServiceImpl = class {
+  resolvePaths(options = {}) {
+    return resolveStoragePaths(options);
+  }
+};
+
+// src/session-state.ts
+var import_node_fs3 = require("fs");
+var import_node_path3 = __toESM(require("path"), 1);
+var import_core = require("@codelia/core");
+var STATE_DIRNAME = "state";
+var resolveStateDir = (paths) => import_node_path3.default.join(paths.sessionsDir, STATE_DIRNAME);
+var extractLastUserMessage = (messages) => {
+  for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
+    const message = messages[idx];
+    if (!message || typeof message !== "object") continue;
+    if ("role" in message && message.role === "user" && "content" in message) {
+      return (0, import_core.stringifyContent)(message.content, {
+        mode: "display"
+      });
+    }
+  }
+  return void 0;
+};
+var toSummary = (state) => ({
+  session_id: state.session_id,
+  updated_at: state.updated_at,
+  run_id: state.run_id,
+  message_count: Array.isArray(state.messages) ? state.messages.length : void 0,
+  last_user_message: Array.isArray(state.messages) ? extractLastUserMessage(state.messages) : void 0
+});
+var SessionStateStoreImpl = class {
+  stateDir;
+  ensureDir;
+  onError;
+  constructor(options = {}) {
+    const paths = options.paths ?? resolveStoragePaths();
+    this.stateDir = resolveStateDir(paths);
+    this.ensureDir = import_node_fs3.promises.mkdir(this.stateDir, { recursive: true }).then(() => {
+    });
+    this.onError = options.onError;
+  }
+  resolvePath(sessionId) {
+    return import_node_path3.default.join(this.stateDir, `${sessionId}.json`);
+  }
+  async load(sessionId) {
+    try {
+      const file = await import_node_fs3.promises.readFile(this.resolvePath(sessionId), "utf8");
+      const parsed = JSON.parse(file);
+      if (!parsed || typeof parsed !== "object") return null;
+      return parsed;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return null;
+      }
+      this.onError?.(error, { action: "load", detail: sessionId });
+      throw error;
+    }
+  }
+  async save(state) {
+    await this.ensureDir;
+    const payload = `${JSON.stringify(state)}
+`;
+    await import_node_fs3.promises.writeFile(this.resolvePath(state.session_id), payload, "utf8");
+  }
+  async list() {
+    await this.ensureDir;
+    let entries;
+    try {
+      entries = await import_node_fs3.promises.readdir(this.stateDir, {
+        withFileTypes: true,
+        encoding: "utf8"
+      });
+    } catch (error) {
+      this.onError?.(error, { action: "list" });
+      throw error;
+    }
+    const summaries = [];
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      if (!entry.name.endsWith(".json")) continue;
+      const filePath = import_node_path3.default.join(this.stateDir, entry.name);
+      try {
+        const contents = await import_node_fs3.promises.readFile(filePath, "utf8");
+        const parsed = JSON.parse(contents);
+        if (!parsed || typeof parsed !== "object") continue;
+        if (!parsed.session_id || !parsed.updated_at) continue;
+        summaries.push(toSummary(parsed));
+      } catch (error) {
+        this.onError?.(error, { action: "parse", detail: filePath });
+      }
+    }
+    return summaries;
+  }
+};
+
+// src/tool-output-cache.ts
+var import_node_fs4 = require("fs");
+var import_node_path4 = __toESM(require("path"), 1);
+var DEFAULT_MAX_MATCHES = 50;
+var normalizeRefId = (refId) => refId.replace(/[^a-zA-Z0-9_-]/g, "_");
+var formatLineNumber = (lineNumber) => String(lineNumber).padStart(5, " ");
+var toLineNumbered = (lines, offset) => lines.map((line, index) => `${formatLineNumber(index + offset + 1)}  ${line}`).join("\n");
+var ToolOutputCacheStoreImpl = class {
+  baseDir;
+  constructor(options = {}) {
+    const paths = options.paths ?? resolveStoragePaths();
+    this.baseDir = paths.toolOutputCacheDir;
+  }
+  async save(record) {
+    const refId = normalizeRefId(record.tool_call_id);
+    const filePath = this.resolvePath(refId);
+    await import_node_fs4.promises.mkdir(this.baseDir, { recursive: true });
+    await import_node_fs4.promises.writeFile(filePath, record.content, "utf8");
+    const byteSize = Buffer.byteLength(record.content, "utf8");
+    const lineCount = record.content.split(/\r?\n/).length;
+    return { id: refId, byte_size: byteSize, line_count: lineCount };
+  }
+  async read(refId, options = {}) {
+    const filePath = this.resolvePath(refId);
+    const content = await import_node_fs4.promises.readFile(filePath, "utf8");
+    const lines = content.split(/\r?\n/);
+    const offset = options.offset ?? 0;
+    const limit = options.limit ?? lines.length;
+    if (offset >= lines.length) {
+      return "Offset exceeds output length.";
+    }
+    const slice = lines.slice(offset, offset + limit);
+    return toLineNumbered(slice, offset);
+  }
+  async grep(refId, options) {
+    const filePath = this.resolvePath(refId);
+    const content = await import_node_fs4.promises.readFile(filePath, "utf8");
+    const lines = content.split(/\r?\n/);
+    const regex = options.regex ? new RegExp(options.pattern) : new RegExp(options.pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+    const before = Math.max(0, options.before ?? 0);
+    const after = Math.max(0, options.after ?? 0);
+    const maxMatches = Math.max(1, options.max_matches ?? DEFAULT_MAX_MATCHES);
+    const results = [];
+    for (let i = 0; i < lines.length; i += 1) {
+      if (results.length >= maxMatches) break;
+      if (!regex.test(lines[i])) continue;
+      const start = Math.max(0, i - before);
+      const end = Math.min(lines.length, i + after + 1);
+      const snippet = toLineNumbered(lines.slice(start, end), start);
+      results.push(`ref:${normalizeRefId(refId)}
+${snippet}`);
+    }
+    if (!results.length) {
+      return `No matches for: ${options.pattern}`;
+    }
+    return results.length >= maxMatches ? `${results.join("\n\n")}
+... (truncated)` : results.join("\n\n");
+  }
+  resolvePath(refId) {
+    return import_node_path4.default.join(this.baseDir, `${normalizeRefId(refId)}.txt`);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  McpAuthStore,
+  RunEventStoreFactoryImpl,
+  SessionStateStoreImpl,
+  SessionStoreWriterImpl,
+  StoragePathServiceImpl,
+  ToolOutputCacheStoreImpl,
+  ensureStorageDirs,
+  resolveStoragePaths
+});

package/dist/index.d.cts

@@ -0,0 +1,76 @@
+import { StoragePaths, ResolveStorageOptions, RunEventStoreFactory, RunEventStoreInit, SessionStore, StoragePathService, SessionStateStore, SessionState, SessionStateSummary, SessionRecord, ToolOutputCacheStore, ToolOutputCacheRecord, ToolOutputRef, ToolOutputCacheReadOptions, ToolOutputCacheSearchOptions } from '@codelia/core';
+export { ResolveStorageOptions, StorageLayout, StoragePathService, StoragePaths } from '@codelia/core';
+
+type McpOAuthTokens = {
+    access_token: string;
+    refresh_token?: string;
+    expires_at?: number;
+    token_type?: string;
+    scope?: string;
+    client_id?: string;
+    client_secret?: string;
+};
+type McpAuthFile = {
+    version: 1;
+    servers: Record<string, McpOAuthTokens>;
+};
+declare class McpAuthStore {
+    private readonly paths;
+    constructor(paths?: StoragePaths);
+    load(): Promise<McpAuthFile>;
+    save(auth: McpAuthFile): Promise<void>;
+}
+
+declare function resolveStoragePaths(options?: ResolveStorageOptions): StoragePaths;
+declare function ensureStorageDirs(paths: StoragePaths): Promise<void>;
+
+declare class RunEventStoreFactoryImpl implements RunEventStoreFactory {
+    create(init: RunEventStoreInit): SessionStore;
+}
+
+declare class StoragePathServiceImpl implements StoragePathService {
+    resolvePaths(options?: ResolveStorageOptions): StoragePaths;
+}
+
+type SessionStateStoreOptions = {
+    paths?: StoragePaths;
+    onError?: (error: unknown, context: {
+        action: string;
+        detail?: string;
+    }) => void;
+};
+declare class SessionStateStoreImpl implements SessionStateStore {
+    private readonly stateDir;
+    private readonly ensureDir;
+    private readonly onError?;
+    constructor(options?: SessionStateStoreOptions);
+    private resolvePath;
+    load(sessionId: string): Promise<SessionState | null>;
+    save(state: SessionState): Promise<void>;
+    list(): Promise<SessionStateSummary[]>;
+}
+
+declare class SessionStoreWriterImpl implements SessionStore {
+    private readonly filePath;
+    private readonly ensureDir;
+    private writeChain;
+    constructor(options: {
+        runId: string;
+        startedAt: string;
+        paths?: StoragePaths;
+    });
+    append(record: SessionRecord): Promise<void>;
+}
+
+declare class ToolOutputCacheStoreImpl implements ToolOutputCacheStore {
+    private readonly baseDir;
+    constructor(options?: {
+        paths?: StoragePaths;
+    });
+    save(record: ToolOutputCacheRecord): Promise<ToolOutputRef>;
+    read(refId: string, options?: ToolOutputCacheReadOptions): Promise<string>;
+    grep(refId: string, options: ToolOutputCacheSearchOptions): Promise<string>;
+    private resolvePath;
+}
+
+export { type McpAuthFile, McpAuthStore, type McpOAuthTokens, RunEventStoreFactoryImpl, SessionStateStoreImpl, SessionStoreWriterImpl, StoragePathServiceImpl, ToolOutputCacheStoreImpl, ensureStorageDirs, resolveStoragePaths };

package/dist/index.d.ts

@@ -0,0 +1,76 @@
+import { StoragePaths, ResolveStorageOptions, RunEventStoreFactory, RunEventStoreInit, SessionStore, StoragePathService, SessionStateStore, SessionState, SessionStateSummary, SessionRecord, ToolOutputCacheStore, ToolOutputCacheRecord, ToolOutputRef, ToolOutputCacheReadOptions, ToolOutputCacheSearchOptions } from '@codelia/core';
+export { ResolveStorageOptions, StorageLayout, StoragePathService, StoragePaths } from '@codelia/core';
+
+type McpOAuthTokens = {
+    access_token: string;
+    refresh_token?: string;
+    expires_at?: number;
+    token_type?: string;
+    scope?: string;
+    client_id?: string;
+    client_secret?: string;
+};
+type McpAuthFile = {
+    version: 1;
+    servers: Record<string, McpOAuthTokens>;
+};
+declare class McpAuthStore {
+    private readonly paths;
+    constructor(paths?: StoragePaths);
+    load(): Promise<McpAuthFile>;
+    save(auth: McpAuthFile): Promise<void>;
+}
+
+declare function resolveStoragePaths(options?: ResolveStorageOptions): StoragePaths;
+declare function ensureStorageDirs(paths: StoragePaths): Promise<void>;
+
+declare class RunEventStoreFactoryImpl implements RunEventStoreFactory {
+    create(init: RunEventStoreInit): SessionStore;
+}
+
+declare class StoragePathServiceImpl implements StoragePathService {
+    resolvePaths(options?: ResolveStorageOptions): StoragePaths;
+}
+
+type SessionStateStoreOptions = {
+    paths?: StoragePaths;
+    onError?: (error: unknown, context: {
+        action: string;
+        detail?: string;
+    }) => void;
+};
+declare class SessionStateStoreImpl implements SessionStateStore {
+    private readonly stateDir;
+    private readonly ensureDir;
+    private readonly onError?;
+    constructor(options?: SessionStateStoreOptions);
+    private resolvePath;
+    load(sessionId: string): Promise<SessionState | null>;
+    save(state: SessionState): Promise<void>;
+    list(): Promise<SessionStateSummary[]>;
+}
+
+declare class SessionStoreWriterImpl implements SessionStore {
+    private readonly filePath;
+    private readonly ensureDir;
+    private writeChain;
+    constructor(options: {
+        runId: string;
+        startedAt: string;
+        paths?: StoragePaths;
+    });
+    append(record: SessionRecord): Promise<void>;
+}
+
+declare class ToolOutputCacheStoreImpl implements ToolOutputCacheStore {
+    private readonly baseDir;
+    constructor(options?: {
+        paths?: StoragePaths;
+    });
+    save(record: ToolOutputCacheRecord): Promise<ToolOutputRef>;
+    read(refId: string, options?: ToolOutputCacheReadOptions): Promise<string>;
+    grep(refId: string, options: ToolOutputCacheSearchOptions): Promise<string>;
+    private resolvePath;
+}
+
+export { type McpAuthFile, McpAuthStore, type McpOAuthTokens, RunEventStoreFactoryImpl, SessionStateStoreImpl, SessionStoreWriterImpl, StoragePathServiceImpl, ToolOutputCacheStoreImpl, ensureStorageDirs, resolveStoragePaths };

package/dist/index.js

@@ -0,0 +1,372 @@
+// src/mcp-auth-store.ts
+import { promises as fs } from "fs";
+
+// src/paths.ts
+import { mkdir } from "fs/promises";
+import os from "os";
+import path from "path";
+var DEFAULT_ROOT_DIR = ".codelia";
+var LAYOUT_ENV = "CODELIA_LAYOUT";
+var XDG_DIR_NAME = "codelia";
+var CONFIG_FILENAME = "config.json";
+var AUTH_FILENAME = "auth.json";
+var MCP_AUTH_FILENAME = "mcp-auth.json";
+var CACHE_DIRNAME = "cache";
+var TOOL_OUTPUT_CACHE_DIRNAME = "tool-output";
+var SESSIONS_DIRNAME = "sessions";
+var LOGS_DIRNAME = "logs";
+function resolveStoragePaths(options = {}) {
+  if (options.rootOverride) {
+    return buildHomeLayout(options.rootOverride);
+  }
+  const layoutValue = options.layout ?? process.env[LAYOUT_ENV];
+  const layout = normalizeLayout(layoutValue);
+  if (layout === "xdg") {
+    return buildXdgLayout();
+  }
+  return buildHomeLayout(defaultHomeRoot());
+}
+async function ensureStorageDirs(paths) {
+  await Promise.all([
+    mkdir(paths.configDir, { recursive: true }),
+    mkdir(paths.cacheDir, { recursive: true }),
+    mkdir(paths.toolOutputCacheDir, { recursive: true }),
+    mkdir(paths.sessionsDir, { recursive: true }),
+    mkdir(paths.logsDir, { recursive: true })
+  ]);
+}
+function normalizeLayout(value) {
+  if (value && value.toLowerCase() === "xdg") return "xdg";
+  return "home";
+}
+function defaultHomeRoot() {
+  return path.join(os.homedir(), DEFAULT_ROOT_DIR);
+}
+function buildHomeLayout(root) {
+  const configDir = root;
+  return {
+    root,
+    configDir,
+    configFile: path.join(configDir, CONFIG_FILENAME),
+    authFile: path.join(configDir, AUTH_FILENAME),
+    mcpAuthFile: path.join(configDir, MCP_AUTH_FILENAME),
+    cacheDir: path.join(root, CACHE_DIRNAME),
+    toolOutputCacheDir: path.join(
+      root,
+      CACHE_DIRNAME,
+      TOOL_OUTPUT_CACHE_DIRNAME
+    ),
+    sessionsDir: path.join(root, SESSIONS_DIRNAME),
+    logsDir: path.join(root, LOGS_DIRNAME)
+  };
+}
+function buildXdgLayout() {
+  const home = os.homedir();
+  const configRoot = process.env.XDG_CONFIG_HOME ?? path.join(home, ".config");
+  const cacheRoot = process.env.XDG_CACHE_HOME ?? path.join(home, ".cache");
+  const stateRoot = process.env.XDG_STATE_HOME ?? path.join(home, ".local", "state");
+  const configDir = path.join(configRoot, XDG_DIR_NAME);
+  const cacheDir = path.join(cacheRoot, XDG_DIR_NAME);
+  const stateDir = path.join(stateRoot, XDG_DIR_NAME);
+  return {
+    root: stateDir,
+    configDir,
+    configFile: path.join(configDir, CONFIG_FILENAME),
+    authFile: path.join(configDir, AUTH_FILENAME),
+    mcpAuthFile: path.join(configDir, MCP_AUTH_FILENAME),
+    cacheDir,
+    toolOutputCacheDir: path.join(cacheDir, TOOL_OUTPUT_CACHE_DIRNAME),
+    sessionsDir: path.join(stateDir, SESSIONS_DIRNAME),
+    logsDir: path.join(stateDir, LOGS_DIRNAME)
+  };
+}
+
+// src/mcp-auth-store.ts
+var MCP_AUTH_VERSION = 1;
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var pickString = (value) => typeof value === "string" ? value : void 0;
+var pickNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+var normalizeTokens = (value) => {
+  if (!isRecord(value)) return null;
+  const accessToken = pickString(value.access_token);
+  if (!accessToken) return null;
+  return {
+    access_token: accessToken,
+    ...pickString(value.refresh_token) ? { refresh_token: pickString(value.refresh_token) } : {},
+    ...pickNumber(value.expires_at) ? { expires_at: pickNumber(value.expires_at) } : {},
+    ...pickString(value.token_type) ? { token_type: pickString(value.token_type) } : {},
+    ...pickString(value.scope) ? { scope: pickString(value.scope) } : {},
+    ...pickString(value.client_id) ? { client_id: pickString(value.client_id) } : {},
+    ...pickString(value.client_secret) ? { client_secret: pickString(value.client_secret) } : {}
+  };
+};
+var McpAuthStore = class {
+  paths;
+  constructor(paths) {
+    this.paths = paths ?? resolveStoragePaths();
+  }
+  async load() {
+    try {
+      const text = await fs.readFile(this.paths.mcpAuthFile, "utf8");
+      const parsed = JSON.parse(text);
+      if (!isRecord(parsed) || parsed.version !== MCP_AUTH_VERSION) {
+        throw new Error("mcp-auth.json has unsupported version");
+      }
+      const serversRaw = isRecord(parsed.servers) ? parsed.servers : {};
+      const servers = {};
+      for (const [id, entry] of Object.entries(serversRaw)) {
+        const normalized = normalizeTokens(entry);
+        if (normalized) {
+          servers[id] = normalized;
+        }
+      }
+      return {
+        version: MCP_AUTH_VERSION,
+        servers
+      };
+    } catch (error) {
+      const err = error;
+      if (err?.code === "ENOENT") {
+        return { version: MCP_AUTH_VERSION, servers: {} };
+      }
+      throw error;
+    }
+  }
+  async save(auth) {
+    await ensureStorageDirs(this.paths);
+    const data = JSON.stringify(auth, null, 2);
+    await fs.writeFile(this.paths.mcpAuthFile, data, { mode: 384 });
+    try {
+      await fs.chmod(this.paths.mcpAuthFile, 384);
+    } catch {
+    }
+  }
+};
+
+// src/session-store.ts
+import { promises as fs2 } from "fs";
+import path2 from "path";
+var pad2 = (value) => String(value).padStart(2, "0");
+var resolveDateParts = (startedAt) => {
+  const parsed = new Date(startedAt);
+  const date = Number.isNaN(parsed.getTime()) ? /* @__PURE__ */ new Date() : parsed;
+  return {
+    year: String(date.getUTCFullYear()),
+    month: pad2(date.getUTCMonth() + 1),
+    day: pad2(date.getUTCDate())
+  };
+};
+var SessionStoreWriterImpl = class {
+  filePath;
+  ensureDir;
+  writeChain = Promise.resolve();
+  constructor(options) {
+    const paths = options.paths ?? resolveStoragePaths();
+    const parts = resolveDateParts(options.startedAt);
+    const baseDir = path2.join(
+      paths.sessionsDir,
+      parts.year,
+      parts.month,
+      parts.day
+    );
+    this.filePath = path2.join(baseDir, `${options.runId}.jsonl`);
+    this.ensureDir = fs2.mkdir(baseDir, { recursive: true }).then(() => {
+    });
+  }
+  append(record) {
+    let line;
+    try {
+      line = `${JSON.stringify(record)}
+`;
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    const write = this.writeChain.then(async () => {
+      await this.ensureDir;
+      await fs2.appendFile(this.filePath, line, "utf8");
+    });
+    this.writeChain = write.catch(() => {
+    });
+    return write;
+  }
+};
+
+// src/run-event-store.ts
+var RunEventStoreFactoryImpl = class {
+  create(init) {
+    return new SessionStoreWriterImpl({
+      runId: init.runId,
+      startedAt: init.startedAt
+    });
+  }
+};
+
+// src/service.ts
+var StoragePathServiceImpl = class {
+  resolvePaths(options = {}) {
+    return resolveStoragePaths(options);
+  }
+};
+
+// src/session-state.ts
+import { promises as fs3 } from "fs";
+import path3 from "path";
+import { stringifyContent } from "@codelia/core";
+var STATE_DIRNAME = "state";
+var resolveStateDir = (paths) => path3.join(paths.sessionsDir, STATE_DIRNAME);
+var extractLastUserMessage = (messages) => {
+  for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
+    const message = messages[idx];
+    if (!message || typeof message !== "object") continue;
+    if ("role" in message && message.role === "user" && "content" in message) {
+      return stringifyContent(message.content, {
+        mode: "display"
+      });
+    }
+  }
+  return void 0;
+};
+var toSummary = (state) => ({
+  session_id: state.session_id,
+  updated_at: state.updated_at,
+  run_id: state.run_id,
+  message_count: Array.isArray(state.messages) ? state.messages.length : void 0,
+  last_user_message: Array.isArray(state.messages) ? extractLastUserMessage(state.messages) : void 0
+});
+var SessionStateStoreImpl = class {
+  stateDir;
+  ensureDir;
+  onError;
+  constructor(options = {}) {
+    const paths = options.paths ?? resolveStoragePaths();
+    this.stateDir = resolveStateDir(paths);
+    this.ensureDir = fs3.mkdir(this.stateDir, { recursive: true }).then(() => {
+    });
+    this.onError = options.onError;
+  }
+  resolvePath(sessionId) {
+    return path3.join(this.stateDir, `${sessionId}.json`);
+  }
+  async load(sessionId) {
+    try {
+      const file = await fs3.readFile(this.resolvePath(sessionId), "utf8");
+      const parsed = JSON.parse(file);
+      if (!parsed || typeof parsed !== "object") return null;
+      return parsed;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return null;
+      }
+      this.onError?.(error, { action: "load", detail: sessionId });
+      throw error;
+    }
+  }
+  async save(state) {
+    await this.ensureDir;
+    const payload = `${JSON.stringify(state)}
+`;
+    await fs3.writeFile(this.resolvePath(state.session_id), payload, "utf8");
+  }
+  async list() {
+    await this.ensureDir;
+    let entries;
+    try {
+      entries = await fs3.readdir(this.stateDir, {
+        withFileTypes: true,
+        encoding: "utf8"
+      });
+    } catch (error) {
+      this.onError?.(error, { action: "list" });
+      throw error;
+    }
+    const summaries = [];
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      if (!entry.name.endsWith(".json")) continue;
+      const filePath = path3.join(this.stateDir, entry.name);
+      try {
+        const contents = await fs3.readFile(filePath, "utf8");
+        const parsed = JSON.parse(contents);
+        if (!parsed || typeof parsed !== "object") continue;
+        if (!parsed.session_id || !parsed.updated_at) continue;
+        summaries.push(toSummary(parsed));
+      } catch (error) {
+        this.onError?.(error, { action: "parse", detail: filePath });
+      }
+    }
+    return summaries;
+  }
+};
+
+// src/tool-output-cache.ts
+import { promises as fs4 } from "fs";
+import path4 from "path";
+var DEFAULT_MAX_MATCHES = 50;
+var normalizeRefId = (refId) => refId.replace(/[^a-zA-Z0-9_-]/g, "_");
+var formatLineNumber = (lineNumber) => String(lineNumber).padStart(5, " ");
+var toLineNumbered = (lines, offset) => lines.map((line, index) => `${formatLineNumber(index + offset + 1)}  ${line}`).join("\n");
+var ToolOutputCacheStoreImpl = class {
+  baseDir;
+  constructor(options = {}) {
+    const paths = options.paths ?? resolveStoragePaths();
+    this.baseDir = paths.toolOutputCacheDir;
+  }
+  async save(record) {
+    const refId = normalizeRefId(record.tool_call_id);
+    const filePath = this.resolvePath(refId);
+    await fs4.mkdir(this.baseDir, { recursive: true });
+    await fs4.writeFile(filePath, record.content, "utf8");
+    const byteSize = Buffer.byteLength(record.content, "utf8");
+    const lineCount = record.content.split(/\r?\n/).length;
+    return { id: refId, byte_size: byteSize, line_count: lineCount };
+  }
+  async read(refId, options = {}) {
+    const filePath = this.resolvePath(refId);
+    const content = await fs4.readFile(filePath, "utf8");
+    const lines = content.split(/\r?\n/);
+    const offset = options.offset ?? 0;
+    const limit = options.limit ?? lines.length;
+    if (offset >= lines.length) {
+      return "Offset exceeds output length.";
+    }
+    const slice = lines.slice(offset, offset + limit);
+    return toLineNumbered(slice, offset);
+  }
+  async grep(refId, options) {
+    const filePath = this.resolvePath(refId);
+    const content = await fs4.readFile(filePath, "utf8");
+    const lines = content.split(/\r?\n/);
+    const regex = options.regex ? new RegExp(options.pattern) : new RegExp(options.pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+    const before = Math.max(0, options.before ?? 0);
+    const after = Math.max(0, options.after ?? 0);
+    const maxMatches = Math.max(1, options.max_matches ?? DEFAULT_MAX_MATCHES);
+    const results = [];
+    for (let i = 0; i < lines.length; i += 1) {
+      if (results.length >= maxMatches) break;
+      if (!regex.test(lines[i])) continue;
+      const start = Math.max(0, i - before);
+      const end = Math.min(lines.length, i + after + 1);
+      const snippet = toLineNumbered(lines.slice(start, end), start);
+      results.push(`ref:${normalizeRefId(refId)}
+${snippet}`);
+    }
+    if (!results.length) {
+      return `No matches for: ${options.pattern}`;
+    }
+    return results.length >= maxMatches ? `${results.join("\n\n")}
+... (truncated)` : results.join("\n\n");
+  }
+  resolvePath(refId) {
+    return path4.join(this.baseDir, `${normalizeRefId(refId)}.txt`);
+  }
+};
+export {
+  McpAuthStore,
+  RunEventStoreFactoryImpl,
+  SessionStateStoreImpl,
+  SessionStoreWriterImpl,
+  StoragePathServiceImpl,
+  ToolOutputCacheStoreImpl,
+  ensureStorageDirs,
+  resolveStoragePaths
+};

package/package.json

@@ -0,0 +1,28 @@
+{
+	"name": "@codelia/storage",
+	"version": "0.1.0",
+	"type": "module",
+	"files": [
+		"dist"
+	],
+	"main": "./dist/index.cjs",
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"require": "./dist/index.cjs"
+		}
+	},
+	"scripts": {
+		"build": "tsup src/index.ts --format esm,cjs --dts --clean",
+		"typecheck": "tsc --noEmit"
+	},
+	"dependencies": {
+		"@codelia/core": "0.1.0"
+	},
+	"publishConfig": {
+		"access": "public"
+	}
+}