@lorekit/cli 1.0.0

package/src/mcp-server.mjs

@@ -0,0 +1,233 @@
+// `lorekit mcp` — a zero-dependency local MCP stdio server.
+//
+// Speaks JSON-RPC 2.0 over newline-delimited stdin/stdout (the MCP stdio
+// transport) and serves LoreKit's memory.* tools from the store the control
+// model resolves. This makes `lorekit mcp` a uniform local entrypoint for
+// every mode, so an agent's `.mcp.json` can point at the local CLI instead of
+// `mcp-remote <url>`:
+//
+//   local  → serve the `.lorekit/` file store directly (offline, no network)
+//   remote → pass tool calls through to the hosted HTTP endpoint
+//   off    → advertise no tools; a call reports "disabled"
+//
+// Machine-facing: ONLY JSON-RPC frames go to stdout — any diagnostics go to
+// stderr. The server never throws on malformed or partial input; a bad frame
+// yields a JSON-RPC parse error and the loop keeps serving.
+//
+// The transport is hand-rolled (no MCP SDK) to keep the CLI dependency-free.
+import process from 'node:process';
+import { resolveProjectRoot } from './config.mjs';
+import { loadControl } from './control.mjs';
+import { createStore } from './store/index.mjs';
+
+const PROTOCOL_VERSION = '2024-11-05';
+const SERVER_INFO = { name: 'lorekit-local', version: '1.0.0' };
+
+// Tool advertisements — names + input schemas mirror the production MCP server
+// (supabase/functions/mcp/mcp-handler.ts) so a client sees the same contract
+// whether it points at the hosted endpoint or this local server.
+export const TOOL_DEFS = [
+  {
+    name: 'memory.write',
+    description: 'Store or update a lesson',
+    inputSchema: { type: 'object', required: ['scope', 'key', 'value'] },
+  },
+  {
+    name: 'memory.read',
+    description: 'Read a lesson by scope and key',
+    inputSchema: { type: 'object', required: ['scope', 'key'] },
+  },
+  {
+    name: 'memory.list',
+    description: 'List lessons for a scope',
+    inputSchema: { type: 'object', required: ['scope'] },
+  },
+  {
+    name: 'memory.search',
+    description: 'Keyword search across lessons',
+    inputSchema: { type: 'object', required: ['q'] },
+  },
+  {
+    name: 'memory.delete',
+    description:
+      'Soft-archive a lesson (default) or hard-delete it (force: true). ' +
+      'Archived lessons are hidden from reads but can be restored.',
+    inputSchema: {
+      type: 'object',
+      required: ['scope', 'key'],
+      properties: {
+        scope: { type: 'string' },
+        key: { type: 'string' },
+        force: { type: 'boolean' },
+      },
+    },
+  },
+  {
+    name: 'memory.archive',
+    description: 'Soft-archive a lesson. Hidden from reads but restorable.',
+    inputSchema: { type: 'object', required: ['scope', 'key'] },
+  },
+];
+
+// tool name → (store, args) → store result. The store destructures the args it
+// needs, so the raw `arguments` object is passed straight through.
+const DISPATCH = {
+  'memory.write': (store, a) => store.write(a),
+  'memory.read': (store, a) => store.read(a),
+  'memory.list': (store, a) => store.list(a),
+  'memory.search': (store, a) => store.search(a),
+  'memory.delete': (store, a) => store.delete(a),
+  'memory.archive': (store, a) => store.archive(a),
+};
+
+function reply(id, result) {
+  return { jsonrpc: '2.0', id, result };
+}
+
+function errorReply(id, code, message) {
+  return { jsonrpc: '2.0', id, error: { code, message } };
+}
+
+// Wrap a store result in the MCP tools/call result shape. `ok: false` from the
+// store surfaces as a tool-level error (isError) rather than a protocol error,
+// so the model sees the failure payload instead of a broken transport.
+function toolResult(id, payload) {
+  const isError = payload && payload.ok === false;
+  return reply(id, {
+    content: [{ type: 'text', text: JSON.stringify(payload) }],
+    ...(isError ? { isError: true } : {}),
+  });
+}
+
+// Build the per-message handler over a resolved control model. `store` is null
+// when mode is `off`, in which case no tools are advertised.
+export function createHandler(control) {
+  const store = createStore(control);
+  const tools = store ? TOOL_DEFS : [];
+
+  // Returns a JSON-RPC response object, or null for a notification (no reply).
+  return async function handle(msg) {
+    const id = msg && Object.prototype.hasOwnProperty.call(msg, 'id') ? msg.id : null;
+    const isNotification = id === null || id === undefined;
+    const method = msg && msg.method;
+
+    if (method === 'initialize') {
+      return reply(id, {
+        protocolVersion: PROTOCOL_VERSION,
+        capabilities: { tools: {} },
+        serverInfo: SERVER_INFO,
+      });
+    }
+
+    // Notifications (initialized, cancelled, …) never get a response.
+    if (typeof method === 'string' && method.startsWith('notifications/')) {
+      return null;
+    }
+
+    if (method === 'tools/list') {
+      return reply(id, { tools });
+    }
+
+    if (method === 'tools/call') {
+      const params = (msg && msg.params) || {};
+      const name = params.name;
+      const args = params.arguments || {};
+
+      if (!store) {
+        return toolResult(id, { ok: false, error: `memory is disabled (mode: ${control.mode})` });
+      }
+
+      const fn = DISPATCH[name];
+      if (!fn) return errorReply(id, -32601, `Unknown tool: ${name}`);
+
+      const result = await fn(store, args);
+      return toolResult(id, result);
+    }
+
+    // Unknown or missing method. A notification gets silence; a request gets
+    // a proper JSON-RPC "method not found".
+    if (isNotification) return null;
+    return errorReply(id, -32601, `Method not found: ${method}`);
+  };
+}
+
+// The stdio read/write loop. Split out from the process streams so it can be
+// driven by any duplex-ish pair in tests. Frames are newline-delimited JSON;
+// responses are serialized single-line + '\n' and written in arrival order.
+export function runStdio(handle, input, output) {
+  return new Promise((resolve) => {
+    let buffer = '';
+    let chain = Promise.resolve();
+
+    const writeMsg = (obj) => {
+      if (obj != null) output.write(`${JSON.stringify(obj)}\n`);
+    };
+
+    const handleOne = (m) =>
+      Promise.resolve()
+        .then(() => handle(m))
+        .then(writeMsg)
+        .catch((e) => {
+          // A handler fault must not take the server down; report it and go on.
+          const id = m && Object.prototype.hasOwnProperty.call(m, 'id') ? m.id : null;
+          writeMsg(errorReply(id ?? null, -32603, String(e && e.message ? e.message : e)));
+        });
+
+    const processLine = (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) return;
+      let msg;
+      try {
+        msg = JSON.parse(trimmed);
+      } catch {
+        // Malformed frame: we cannot know the id, so reply with null id and
+        // keep serving. This is the "never crash on bad input" guarantee.
+        writeMsg(errorReply(null, -32700, 'Parse error'));
+        return;
+      }
+      // Serialize so responses are written in the order frames arrived. A batch
+      // (JSON-RPC array) is handled element-wise rather than crashing.
+      chain = chain.then(() =>
+        Array.isArray(msg) ? Promise.all(msg.map(handleOne)) : handleOne(msg),
+      );
+    };
+
+    input.setEncoding('utf8');
+    input.on('data', (chunk) => {
+      buffer += chunk;
+      let idx;
+      while ((idx = buffer.indexOf('\n')) !== -1) {
+        const line = buffer.slice(0, idx);
+        buffer = buffer.slice(idx + 1);
+        processLine(line);
+      }
+    });
+    input.on('end', () => {
+      if (buffer) processLine(buffer);
+      buffer = '';
+      chain.then(resolve, resolve);
+    });
+    input.on('error', () => {
+      chain.then(resolve, resolve);
+    });
+  });
+}
+
+function withOverrides(args, env) {
+  const out = { ...env };
+  if (args.store) out.LOREKIT_STORE = args.store;
+  if (args.mode) out.LOREKIT_MODE = args.mode;
+  if (args.endpoint) out.LOREKIT_MCP_URL = args.endpoint;
+  if (args.token) out.LOREKIT_TOKEN = args.token;
+  return out;
+}
+
+// Entrypoint for `lorekit mcp`. Resolves the store once, then serves stdio
+// until the client closes stdin. Always resolves to exit code 0.
+export async function mcpServer(args = {}, { env = process.env, input = process.stdin, output = process.stdout } = {}) {
+  const root = resolveProjectRoot(args.dir);
+  const control = loadControl(root, { env: withOverrides(args, env) });
+  const handle = createHandler(control);
+  await runStdio(handle, input, output);
+  return 0;
+}

package/src/mcp.mjs

@@ -0,0 +1,89 @@
+// Minimal MCP-over-HTTP (JSON-RPC 2.0) client for the LoreKit endpoint.
+// Zero dependencies — uses the global fetch (Node 18+).
+
+// Split a configured server URL like ".../mcp?token=lk_rw_x" into
+// { endpoint: ".../mcp", token: "lk_rw_x" }.
+export function splitEndpoint(url) {
+  if (!url) return { endpoint: null, token: null };
+  try {
+    const u = new URL(url);
+    const token = u.searchParams.get('token');
+    u.searchParams.delete('token');
+    const endpoint = u.origin + u.pathname + (u.search || '');
+    return { endpoint, token: token || null };
+  } catch {
+    return { endpoint: url, token: null };
+  }
+}
+
+// Build the mcp-remote URL that goes into .mcp.json args.
+export function buildRemoteUrl(endpoint, token) {
+  if (!token) return endpoint;
+  const u = new URL(endpoint);
+  u.searchParams.set('token', token);
+  return u.toString();
+}
+
+let idCounter = 0;
+
+// Returns { ok, httpStatus, result, error, networkError }.
+export async function mcpCall(endpoint, token, method, params = {}, { timeoutMs = 10000 } = {}) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    // Inside the try so a malformed endpoint yields the documented
+    // { ok:false, networkError } shape instead of throwing at the call site.
+    const url = buildRemoteUrl(endpoint, token);
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        accept: 'application/json, text/event-stream',
+        ...(token ? { authorization: `Bearer ${token}` } : {}),
+      },
+      body: JSON.stringify({ jsonrpc: '2.0', id: ++idCounter, method, params }),
+      signal: controller.signal,
+    });
+
+    const text = await res.text();
+    const json = parseBody(text);
+
+    if (json && json.error) {
+      return { ok: false, httpStatus: res.status, error: json.error };
+    }
+    if (!res.ok) {
+      return {
+        ok: false,
+        httpStatus: res.status,
+        error: { code: res.status, message: text.slice(0, 200) || res.statusText },
+      };
+    }
+    return { ok: true, httpStatus: res.status, result: json ? json.result : undefined };
+  } catch (e) {
+    return { ok: false, networkError: String(e && e.message ? e.message : e) };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// The endpoint may answer as plain JSON or as an SSE frame ("data: {...}").
+function parseBody(text) {
+  if (!text) return null;
+  const trimmed = text.trim();
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    const line = trimmed
+      .split('\n')
+      .map((l) => l.trim())
+      .find((l) => l.startsWith('data:'));
+    if (line) {
+      try {
+        return JSON.parse(line.slice('data:'.length).trim());
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+}

package/src/migrate.mjs

@@ -0,0 +1,149 @@
+// `lorekit migrate --from <path> [--to home|project] [--yes|--apply]`
+//
+// Relocation / rename tool — NOT a persistent-memory importer. It reads a
+// LoreKit-format local store at <path> (e.g. an old `.lore/` directory, or a
+// store that was moved elsewhere) and re-writes its entries into the resolved
+// current-layout store(s), so lessons are never stranded by a rename or a move.
+//
+// Dry-run (preview) by default: it prints what would move, per scope, and
+// changes nothing. Only `--yes` (or `--apply`) mutates. Idempotent: entries are
+// upserted verbatim by scope+key, so a re-run is all NOOP.
+//
+// Out of scope: reading persistent-memory's `~/.agent-memory/<bucket>/INDEX.md`
+// + `entries/` format. This tool only understands LoreKit's own on-disk format.
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolveProjectRoot } from './config.mjs';
+import { localStoreDirs } from './control.mjs';
+import { createLocalStore, createTwoTierStore } from './store/index.mjs';
+import { parseEntry } from './store/format.mjs';
+import { log, heading, status, err, c } from './util.mjs';
+
+// Recursively collect every parseable LoreKit entry under a base dir. The
+// canonical scope comes from each file's frontmatter, so the source layout does
+// not have to match the destination layout.
+function collectEntries(base) {
+  const out = [];
+  const walk = (dir) => {
+    let names;
+    try {
+      names = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of names) {
+      const p = path.join(dir, e.name);
+      if (e.isDirectory()) {
+        walk(p);
+      } else if (e.name.endsWith('.md')) {
+        try {
+          const entry = parseEntry(fs.readFileSync(p, 'utf8'));
+          if (entry && entry.scope && entry.key) out.push(entry);
+        } catch {
+          // Skip an unreadable / non-entry file rather than abort the migration.
+        }
+      }
+    }
+  };
+  walk(base);
+  return out;
+}
+
+// Full-field equality (ignoring nothing) so a re-run after apply is NOOP.
+function sameEntry(a, b) {
+  if (!a || !b) return false;
+  const norm = (e) =>
+    JSON.stringify({
+      tags: [...(e.tags || [])].sort(),
+      source_agent: e.source_agent ?? null,
+      trigger: e.trigger ?? null,
+      created: e.created ?? null,
+      updated: e.updated ?? null,
+      archived_at: e.archived_at ?? null,
+      value: e.value == null ? '' : String(e.value),
+    });
+  return norm(a) === norm(b);
+}
+
+export async function migrate(args) {
+  const root = resolveProjectRoot(args.dir);
+
+  const from = typeof args.from === 'string' ? args.from : null;
+  if (!from) {
+    err(`${c.red('migrate:')} --from <path> is required (the store to migrate from)`);
+    return 1;
+  }
+  const src = path.isAbsolute(from) ? from : path.join(root, from);
+  if (!fs.existsSync(src)) {
+    err(`${c.red('migrate:')} source not found: ${src}`);
+    return 1;
+  }
+
+  const to = typeof args.to === 'string' ? args.to.toLowerCase() : null;
+  if (to && to !== 'home' && to !== 'project') {
+    err(`${c.red('migrate:')} --to must be "home" or "project"`);
+    return 1;
+  }
+  const apply = Boolean(args.apply || args.yes);
+
+  const dirs = localStoreDirs(root);
+
+  // Resolve where each entry goes. `--to` forces a single tier; the default
+  // routes each entry by scope through the two-tier store (global → home,
+  // repo/branch → project when opted-in, else home).
+  let targetFor;
+  let destLabel;
+  if (to === 'home') {
+    const store = createLocalStore(dirs.home);
+    targetFor = () => store;
+    destLabel = `home (${dirs.home})`;
+  } else if (to === 'project') {
+    if (apply) fs.mkdirSync(dirs.project, { recursive: true }); // opt-in on apply
+    const store = createLocalStore(dirs.project);
+    targetFor = () => store;
+    destLabel = `project (${dirs.project})`;
+  } else {
+    const two = createTwoTierStore(dirs);
+    targetFor = (scope) => two.tierFor(scope);
+    destLabel = 'resolved layout (global→home, repo/branch→project-if-opted-in)';
+  }
+
+  const entries = collectEntries(src);
+
+  heading('LoreKit migrate');
+  log(`  from: ${c.dim(src)}`);
+  log(`  to:   ${c.dim(destLabel)}`);
+  log(`  mode: ${apply ? c.bold('apply') : 'dry-run — pass --yes to apply'}`);
+  log(`  found: ${entries.length} entr${entries.length === 1 ? 'y' : 'ies'}\n`);
+
+  const totals = { add: 0, update: 0, noop: 0 };
+  const byScope = new Map();
+  for (const entry of entries) {
+    const store = targetFor(entry.scope);
+    const current = store.getEntry({ scope: entry.scope, key: entry.key });
+    let verdict;
+    if (!current) verdict = 'add';
+    else if (sameEntry(current, entry)) verdict = 'noop';
+    else verdict = 'update';
+
+    totals[verdict]++;
+    const s = byScope.get(entry.scope) || { add: 0, update: 0, noop: 0 };
+    s[verdict]++;
+    byScope.set(entry.scope, s);
+
+    if (apply && verdict !== 'noop') await store.putEntry(entry);
+  }
+
+  for (const [scope, s] of byScope) {
+    status('info', scope, `${s.add} add, ${s.update} update, ${s.noop} unchanged`);
+  }
+
+  const moved = totals.add + totals.update;
+  heading('Summary');
+  log(
+    `  ${apply ? 'migrated' : 'would migrate'} ${moved} entr${moved === 1 ? 'y' : 'ies'} ` +
+      `(${totals.add} new, ${totals.update} updated), ${totals.noop} unchanged.`,
+  );
+  if (!apply && moved > 0) log(`  ${c.dim('Re-run with --yes to apply.')}`);
+  return 0;
+}

package/src/scope.mjs

@@ -0,0 +1,59 @@
+// Derive LoreKit scope strings from the git working directory.
+import { execFileSync } from 'node:child_process';
+import path from 'node:path';
+
+function git(args, cwd) {
+  try {
+    return execFileSync('git', args, {
+      cwd,
+      stdio: ['ignore', 'pipe', 'ignore'],
+      encoding: 'utf8',
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+// git@github.com:Owner/Repo.git  →  owner/repo
+// https://github.com/Owner/Repo  →  owner/repo
+export function ownerRepoFromRemote(url) {
+  if (!url) return null;
+  let s = url.trim().replace(/\.git$/i, '');
+  s = s.replace(/^git@[^:]+:/, ''); // scp-style
+  s = s.replace(/^ssh:\/\/git@[^/]+\//, '');
+  s = s.replace(/^https?:\/\/[^/]+\//, '');
+  const parts = s.split('/').filter(Boolean);
+  if (parts.length < 2) return null;
+  const owner = parts[parts.length - 2];
+  const repo = parts[parts.length - 1];
+  return `${owner}/${repo}`.toLowerCase();
+}
+
+// Returns { ownerRepo, branch, repoScope, branchScope, projectScope, readOrder }.
+export function deriveScope(cwd = process.cwd()) {
+  const remote = git(['config', '--get', 'remote.origin.url'], cwd);
+  const ownerRepo = ownerRepoFromRemote(remote);
+  const branch = git(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
+  const root = git(['rev-parse', '--show-toplevel'], cwd) || cwd;
+  const projectName = path.basename(root).toLowerCase();
+
+  const repoScope = ownerRepo ? `repo::${ownerRepo}` : null;
+  const branchScope =
+    ownerRepo && branch && branch !== 'HEAD'
+      ? `branch::${ownerRepo}::${branch.toLowerCase()}`
+      : null;
+  const projectScope = `project::${projectName}`;
+
+  const readOrder = [branchScope, repoScope, 'global'].filter(Boolean);
+
+  return {
+    ownerRepo,
+    branch,
+    projectName,
+    repoScope,
+    branchScope,
+    projectScope,
+    readOrder,
+    hasRemote: Boolean(ownerRepo),
+  };
+}

package/src/store/format.mjs

@@ -0,0 +1,99 @@
+// On-disk entry format for the local file store.
+// Zero-dependency. An entry is a markdown file: a YAML frontmatter block whose
+// scalars are JSON-encoded (a strict subset of YAML, so the file stays valid
+// YAML and greppable) followed by the lesson body. This converges with the
+// persistent-memory entry format (frontmatter + body) so a `.lorekit/` directory
+// is interoperable — the frontmatter mirrors a LoreKit row's columns and the
+// body is the row's `value`.
+import path from 'node:path';
+
+// The frontmatter columns, in a stable order. `value` is the body, not a column.
+export const FIELDS = [
+  'scope',
+  'key',
+  'tags',
+  'source_agent',
+  'trigger',
+  'created',
+  'updated',
+  'archived_at',
+];
+
+// Serialize an entry ({ ...columns, value }) into file text.
+export function serializeEntry(entry) {
+  const fm = FIELDS.map((k) => `${k}: ${JSON.stringify(entry[k] ?? null)}`).join('\n');
+  const body = entry.value == null ? '' : String(entry.value);
+  return `---\n${fm}\n---\n${body}\n`;
+}
+
+// Parse file text back into an entry, or null when it has no frontmatter.
+// Values are JSON-decoded; a hand-edited non-JSON scalar falls back to raw text.
+export function parseEntry(text) {
+  const m = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/.exec(text);
+  if (!m) return null;
+  const meta = {};
+  for (const line of m[1].split('\n')) {
+    const idx = line.indexOf(':');
+    if (idx === -1) continue;
+    const key = line.slice(0, idx).trim();
+    if (!key) continue;
+    meta[key] = decode(line.slice(idx + 1).trim());
+  }
+  return { ...meta, value: m[2].replace(/\n$/, '') };
+}
+
+function decode(raw) {
+  if (raw === '') return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+
+// Filesystem-safe slug for a lesson key. The key stays authoritative in the
+// frontmatter, so the slug only needs to be safe and readable, not reversible.
+export function slugify(key) {
+  const s = String(key)
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 80);
+  return s || 'entry';
+}
+
+// Sanitize a single path segment (owner, repo, branch part).
+function safeSeg(s) {
+  const cleaned = String(s == null ? '' : s)
+    .replace(/[^a-zA-Z0-9._-]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  // Neutralize dot-only segments ('.', '..', …): the char class above keeps
+  // dots (so `my.repo` survives), but a bare `..` segment would let a crafted
+  // scope traverse out of the store dir via path.join. Collapse those to '_'.
+  if (/^\.+$/.test(cleaned)) return '_';
+  return cleaned || '_';
+}
+
+// Map a canonical scope string to its directory under the store base.
+//   global                          → <base>/global
+//   project::{name}                 → <base>/project/{name}
+//   repo::{owner}/{repo}            → <base>/repo/{owner}/{repo}
+//   branch::{owner}/{repo}::{branch} → <base>/branch/{owner}/{repo}/{branch...}
+export function scopeToDir(baseDir, scope) {
+  const parts = String(scope).split('::');
+  const type = parts[0];
+  if (type === 'global') return path.join(baseDir, 'global');
+  if (type === 'project') return path.join(baseDir, 'project', safeSeg(parts[1]));
+  if (type === 'repo') {
+    const [owner, repo] = String(parts[1] || '').split('/');
+    return path.join(baseDir, 'repo', safeSeg(owner), safeSeg(repo));
+  }
+  if (type === 'branch') {
+    const [owner, repo] = String(parts[1] || '').split('/');
+    const branch = String(parts[2] || '')
+      .split('/')
+      .map(safeSeg);
+    return path.join(baseDir, 'branch', safeSeg(owner), safeSeg(repo), ...branch);
+  }
+  return path.join(baseDir, '_other', safeSeg(String(scope).replace(/::/g, '-')));
+}

package/src/store/index.mjs

@@ -0,0 +1,18 @@
+// Store factory: build the store the resolved control model selects.
+// Returns null for `off` — callers short-circuit `off` before reaching here,
+// so a no-op store object is unnecessary.
+import { createLocalStore, createTwoTierStore } from './local.mjs';
+import { createRemoteStore } from './remote.mjs';
+
+export function createStore(control) {
+  if (!control || control.mode === 'off') return null;
+  // Local mode is two-tier: control.storeTarget is { home, project }.
+  if (control.mode === 'local') return createTwoTierStore(control.storeTarget);
+  if (control.mode === 'remote') {
+    const conn = control.connection || {};
+    return createRemoteStore({ endpoint: conn.endpoint, token: conn.token });
+  }
+  return null;
+}
+
+export { createLocalStore, createTwoTierStore, createRemoteStore };