@lorekit/cli 1.4.1 → 1.6.0

package/bin/lorekit.mjs

@@ -10,6 +10,7 @@ import { hook } from '../src/hook.mjs';
 import { migrate } from '../src/migrate.mjs';
 import { mcpServer } from '../src/mcp-server.mjs';
 import { traceCommand } from '../src/telemetry.mjs';
+import { loadDotEnv } from '../src/dotenv.mjs';
 
 // Read the version from package.json so it always matches the published
 // package — release-please bumps package.json, and this tracks it for free.
@@ -76,6 +77,9 @@ ${c.bold('Environment')}
   LOREKIT_TELEMETRY / DO_NOT_TRACK     set to 0/off (or DO_NOT_TRACK=1) to opt
                                        out of anonymous command-usage telemetry
 
+A ${c.cyan('.env')} file in the current directory is loaded automatically. Real
+environment variables take precedence, so the file is a fallback.
+
 ${c.bold('Examples')}
   npx @lorekit/cli install --endpoint https://ref.supabase.co/functions/v1/mcp --token lk_rw_xxx
   npx @lorekit/cli install --global    # set up memory for every project (~/.claude)
@@ -214,6 +218,12 @@ const KNOWN_FLAGS = [
 const HUMAN_COMMANDS = new Set(['install', 'uninstall', 'doctor', 'migrate']);
 
 async function main() {
+  // Load a `.env` from the current directory (if any) before anything reads the
+  // environment — so telemetry config, tokens, and endpoints can come from a
+  // file. Best-effort and non-overriding: real env vars still win, a missing
+  // file is a silent no-op, and it never prints (safe for hook/mcp stdout).
+  loadDotEnv();
+
   const argv = process.argv.slice(2);
   const args = parseArgs(argv, {
     aliases: { d: 'dir', e: 'endpoint', t: 'token', y: 'yes', h: 'help', v: 'version' },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lorekit/cli",
-  "version": "1.4.1",
+  "version": "1.6.0",
   "description": "Install the LoreKit shared-memory skill and run health checks for the LoreKit MCP server.",
   "license": "MIT",
   "repository": {

package/src/dotenv.mjs

@@ -0,0 +1,106 @@
+// LoreKit CLI — zero-dependency `.env` loader.
+//
+// The CLI is strictly zero-dependency (see package.json), and `engines.node`
+// is `>=18`, so we can rely on neither the `dotenv` package nor Node's built-in
+// `process.loadEnvFile()` (added in 20.6). This hand-rolled loader fills the gap
+// with a small, faithful parser and a best-effort file read.
+//
+// Semantics (chosen to match the dominant `dotenv` mental model, NOT Node's
+// `--env-file`):
+//   • A `.env` in the current working directory is loaded automatically if it
+//     exists. A missing file is a silent no-op — the default for real users.
+//   • Existing real environment variables WIN. A value already present in
+//     `process.env` (an explicit `export`, a CI var, an inline `FOO=bar cmd`)
+//     is never overwritten by the file. So a committed `.env` is a fallback,
+//     and a shell opt-out like `LOREKIT_TELEMETRY=0` can't be silently undone.
+//   • Loading never throws — a malformed line is skipped, an unreadable file is
+//     ignored. Nothing is printed, so machine-facing `hook` / `mcp` stdout is
+//     never touched.
+
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+
+const KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+/**
+ * Parse the contents of a `.env` file into a flat key→value object. Pure and
+ * unit-tested. Supports: blank lines, `#` comments, an optional `export `
+ * prefix, single/double-quoted values (double quotes unescape \n \r \t \\ \"),
+ * and trailing inline comments after unquoted values. Invalid keys are skipped.
+ */
+export function parseDotEnv(text) {
+  const out = {};
+  if (!text) return out;
+  for (const rawLine of String(text).split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) continue;
+
+    // Strip an optional `export ` prefix (a common shell-sourceable convention).
+    const withoutExport = line.startsWith('export ') ? line.slice(7).trimStart() : line;
+
+    const eq = withoutExport.indexOf('=');
+    if (eq <= 0) continue; // no key, or `=value` with empty key → skip
+
+    const key = withoutExport.slice(0, eq).trim();
+    if (!KEY_RE.test(key)) continue;
+
+    out[key] = parseValue(withoutExport.slice(eq + 1).trim());
+  }
+  return out;
+}
+
+/**
+ * Resolve one raw right-hand-side into its final string value: unwrap matching
+ * quotes (unescaping only inside double quotes), or, for a bare value, drop a
+ * trailing ` # comment`.
+ */
+function parseValue(raw) {
+  if (!raw) return '';
+  const q = raw[0];
+  if ((q === '"' || q === "'") && raw.length >= 2 && raw[raw.length - 1] === q) {
+    const inner = raw.slice(1, -1);
+    return q === '"'
+      ? inner.replace(/\\([nrt"\\])/g, (_, ch) =>
+          ch === 'n' ? '\n' : ch === 'r' ? '\r' : ch === 't' ? '\t' : ch,
+        )
+      : inner;
+  }
+  // Unquoted: a whitespace-preceded `#` starts an inline comment.
+  const hash = raw.search(/\s#/);
+  return (hash === -1 ? raw : raw.slice(0, hash)).trim();
+}
+
+/**
+ * Load a `.env` from `cwd` into `env`, without overriding keys already set.
+ * Best-effort: returns the list of keys it applied (empty if the file is absent
+ * or unreadable). Never throws, never prints.
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.cwd]  directory to look for `.env` in (default cwd)
+ * @param {object} [opts.env]  target env object to mutate (default process.env)
+ * @returns {string[]} keys newly set from the file
+ */
+export function loadDotEnv({ cwd = process.cwd(), env = process.env } = {}) {
+  let text;
+  try {
+    text = readFileSync(path.join(cwd, '.env'), 'utf8');
+  } catch {
+    return []; // no file (ENOENT) or unreadable → nothing to do
+  }
+
+  const applied = [];
+  try {
+    const parsed = parseDotEnv(text);
+    for (const [key, value] of Object.entries(parsed)) {
+      // Real env wins: only fill keys that aren't already set.
+      if (env[key] === undefined) {
+        env[key] = value;
+        applied.push(key);
+      }
+    }
+  } catch {
+    // A malformed file must never break the CLI — leave whatever was applied.
+  }
+  return applied;
+}

package/src/mcp-server.mjs

@@ -10,6 +10,12 @@
 //   remote → pass tool calls through to the hosted HTTP endpoint
 //   off    → advertise no tools; a call reports "disabled"
 //
+// org.* tools are always advertised regardless of memory mode. They proxy to
+// the remote endpoint because org management requires a server-side session
+// (JWT auth, SECURITY DEFINER RPCs). In local/off mode a transient RemoteStore
+// is built from the configured endpoint + token. If no remote is configured,
+// a clear error is returned.
+//
 // 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.
@@ -19,6 +25,7 @@ import process from 'node:process';
 import { resolveProjectRoot } from './config.mjs';
 import { loadControl } from './control.mjs';
 import { createStore } from './store/index.mjs';
+import { createRemoteStore } from './store/remote.mjs';
 
 const PROTOCOL_VERSION = '2024-11-05';
 const SERVER_INFO = { name: 'lorekit-local', version: '1.0.0' };
@@ -26,7 +33,7 @@ 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 = [
+export const MEMORY_TOOL_DEFS = [
   {
     name: 'memory.write',
     description: 'Store or update a lesson',
@@ -86,9 +93,62 @@ export const TOOL_DEFS = [
   },
 ];
 
+// Org tools — always advertised regardless of memory mode. They always route
+// through the remote MCP endpoint because org management requires JWT auth
+// (SECURITY DEFINER RPCs resolve actor via auth.uid(), never a passed user_id).
+export const ORG_TOOL_DEFS = [
+  {
+    name: 'org.create',
+    description:
+      'Create a new organization. You become its owner automatically. ' +
+      'The slug must be globally unique and lowercase (letters, digits, hyphens).',
+    inputSchema: {
+      type: 'object',
+      required: ['slug', 'name'],
+      properties: {
+        slug: { type: 'string', description: 'Unique lowercase identifier, e.g. "my-team"' },
+        name: { type: 'string', description: 'Human-readable display name' },
+      },
+    },
+  },
+  {
+    name: 'org.list',
+    description: 'List all organizations you are a member of, with your role in each.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'org.rename',
+    description: 'Rename an organization\'s display name. Requires admin or owner role.',
+    inputSchema: {
+      type: 'object',
+      required: ['slug', 'name'],
+      properties: {
+        slug: { type: 'string', description: 'The org slug to update' },
+        name: { type: 'string', description: 'New display name' },
+      },
+    },
+  },
+  {
+    name: 'org.delete',
+    description:
+      'Permanently delete an organization. Requires owner role. ' +
+      'All org-owned memories and memberships are cascade-deleted. Unrecoverable.',
+    inputSchema: {
+      type: 'object',
+      required: ['slug'],
+      properties: {
+        slug: { type: 'string', description: 'The org slug to delete' },
+      },
+    },
+  },
+];
+
+// Legacy alias kept so existing code that imports TOOL_DEFS still compiles.
+export const TOOL_DEFS = [...MEMORY_TOOL_DEFS, ...ORG_TOOL_DEFS];
+
 // tool name → (store, args) → store result. The store destructures the args it
 // needs, so the raw `arguments` object is passed straight through.
-const DISPATCH = {
+const MEMORY_DISPATCH = {
   'memory.write': (store, a) => store.write(a),
   'memory.read': (store, a) => store.read(a),
   'memory.list': (store, a) => store.list(a),
@@ -97,6 +157,14 @@ const DISPATCH = {
   'memory.archive': (store, a) => store.archive(a),
 };
 
+// org.* dispatch — always routed to the remote store.
+const ORG_DISPATCH = {
+  'org.create': (remote, a) => remote.orgCreate(a),
+  'org.list': (remote) => remote.orgList(),
+  'org.rename': (remote, a) => remote.orgRename(a),
+  'org.delete': (remote, a) => remote.orgDelete(a),
+};
+
 function reply(id, result) {
   return { jsonrpc: '2.0', id, result };
 }
@@ -117,10 +185,22 @@ function toolResult(id, payload) {
 }
 
 // Build the per-message handler over a resolved control model. `store` is null
-// when mode is `off`, in which case no tools are advertised.
+// when mode is `off`. Org tools are always advertised regardless of mode.
 export function createHandler(control) {
   const store = createStore(control);
-  const tools = store ? TOOL_DEFS : [];
+  const memoryTools = store ? MEMORY_TOOL_DEFS : [];
+
+  // For org.* calls: prefer the active remote store (already built if mode is
+  // remote); fall back to building one from control.connection so org management
+  // works even in local/off modes as long as a remote endpoint is configured.
+  function getOrgRemote() {
+    if (store && store.mode === 'remote') return store;
+    const conn = (control && control.connection) || {};
+    if (conn.endpoint && conn.token) {
+      return createRemoteStore({ endpoint: conn.endpoint, token: conn.token });
+    }
+    return null;
+  }
 
   // Returns a JSON-RPC response object, or null for a notification (no reply).
   return async function handle(msg) {
@@ -142,7 +222,7 @@ export function createHandler(control) {
     }
 
     if (method === 'tools/list') {
-      return reply(id, { tools });
+      return reply(id, { tools: [...memoryTools, ...ORG_TOOL_DEFS] });
     }
 
     if (method === 'tools/call') {
@@ -150,11 +230,29 @@ export function createHandler(control) {
       const name = params.name;
       const args = params.arguments || {};
 
+      // org.* tools — always proxy to remote.
+      if (name && name.startsWith('org.')) {
+        const fn = ORG_DISPATCH[name];
+        if (!fn) return errorReply(id, -32601, `Unknown tool: ${name}`);
+        const remote = getOrgRemote();
+        if (!remote) {
+          return toolResult(id, {
+            ok: false,
+            error:
+              'org.* tools require a remote LoreKit endpoint configured with a read-write token. ' +
+              'Set LOREKIT_MCP_URL and LOREKIT_TOKEN (lk_rw_*), or run `lorekit install --endpoint <url> --token <lk_rw_*>`.',
+          });
+        }
+        const result = await fn(remote, args);
+        return toolResult(id, result);
+      }
+
+      // memory.* tools
       if (!store) {
         return toolResult(id, { ok: false, error: `memory is disabled (mode: ${control.mode})` });
       }
 
-      const fn = DISPATCH[name];
+      const fn = MEMORY_DISPATCH[name];
       if (!fn) return errorReply(id, -32601, `Unknown tool: ${name}`);
 
       const result = await fn(store, args);

package/src/store/remote.mjs

@@ -82,6 +82,36 @@ class RemoteStore {
     return { ok: res.ok, error: res.error, networkError: res.networkError };
   }
 
+  // ── Org management ─────────────────────────────────────────────────────────
+  // These proxy to the hosted MCP endpoint's org.* tools. Auth is resolved
+  // server-side from the Bearer token; no user-id is passed by the caller.
+
+  async orgCreate({ slug, name } = {}) {
+    const res = await this._call('org.create', clean({ slug, name }));
+    if (!res.ok) return { ok: false, error: res.error, networkError: res.networkError };
+    const payload = unwrap(res.result);
+    return { ok: true, org: payload };
+  }
+
+  async orgList() {
+    const res = await this._call('org.list', {});
+    return this._entries(res);
+  }
+
+  async orgRename({ slug, name } = {}) {
+    const res = await this._call('org.rename', clean({ slug, name }));
+    if (!res.ok) return { ok: false, error: res.error, networkError: res.networkError };
+    const payload = unwrap(res.result);
+    return { ok: true, ...payload };
+  }
+
+  async orgDelete({ slug } = {}) {
+    const res = await this._call('org.delete', clean({ slug }));
+    if (!res.ok) return { ok: false, error: res.error, networkError: res.networkError };
+    const payload = unwrap(res.result);
+    return { ok: true, ...payload };
+  }
+
   // Connectivity probe for doctor — a transport check, not a memory op.
   async ping() {
     if (!this.usable()) return { ok: false, unusable: true };

package/src/telemetry-token.mjs

@@ -14,4 +14,4 @@
 // At runtime this is only the lowest-priority source: an explicit
 // LOREKIT_TELEMETRY_TOKEN env var or OTEL_EXPORTER_OTLP_HEADERS still win (see
 // resolveTelemetryConfig in telemetry.mjs).
-export const TELEMETRY_TOKEN = '';
+export const TELEMETRY_TOKEN = "auth_XFLXatTBqqgvhZ12Tn9sfttClUkBPodp";

package/src/telemetry.mjs

@@ -28,7 +28,7 @@ import { TELEMETRY_TOKEN } from './telemetry-token.mjs';
 // ── Baked-in defaults (public by design) ──────────────────────────────────────
 // The endpoint is a committed default; the token is injected at publish time
 // (empty in the source tree, so default export stays off until built/injected).
-const DEFAULT_ENDPOINT = 'https://ingress.us-east-1.aws.dash0.com';
+const DEFAULT_ENDPOINT = 'https://ingress.europe-west4.gcp.dash0-dev.com';
 const DEFAULT_TOKEN = TELEMETRY_TOKEN; // injected from LOREKIT_TELEMETRY_TOKEN at publish
 const DEFAULT_DATASET = 'lorekit-cli';