@krimto-labs/krimto 0.2.21 → 0.2.22

package/bin/krimto.mjs

@@ -13,7 +13,9 @@ try {
   const cmd =
     rawCmd === "team" && typeof process.argv[3] === "string"
       ? `team ${process.argv[3]}`
-      : rawCmd;
+      : rawCmd === "set" && typeof process.argv[3] === "string"
+        ? `set ${process.argv[3]}`
+        : rawCmd;
 
   // Guard: `krimto team` alone (or with an unknown subverb) shouldn't fall through to the stdio
   // MCP server. Print usage and exit instead.
@@ -27,6 +29,16 @@ try {
     process.exit(2);
   }
 
+  // Same guard for `krimto set <subverb>`.
+  const knownSetCmds = ["set identity"];
+  if (rawCmd === "set" && !knownSetCmds.includes(cmd)) {
+    process.stderr.write(
+      "Usage: krimto set <identity> <value>\n" +
+        "  identity <email>   Change the identity used for new fact writes\n",
+    );
+    process.exit(2);
+  }
+
   if (cmd === "--help" || cmd === "-h" || cmd === "help") {
     // `krimto --help` — surface every subcommand so a user who didn't read the README can still
     // discover them. Version is read from the server module so it never drifts from KRIMTO_VERSION.
@@ -351,6 +363,36 @@ try {
     // doesn't have to chase the README. Honors KRIMTO_IDENTITY when set.
     const { formatConnect } = await tsImport("../src/cli/connect.ts", import.meta.url);
     process.stdout.write(formatConnect({ identity: process.env.KRIMTO_IDENTITY }));
+  } else if (cmd === "whoami") {
+    // `krimto whoami` — show the active KRIMTO_IDENTITY and every place it's currently set
+    // (each editor's MCP config + the always-running service unit). Surfaces drift between
+    // sources so users notice before notes start splitting across two scopes.
+    const { runWhoami } = await tsImport("../src/cli/whoami.ts", import.meta.url);
+    const result = await runWhoami();
+    process.stdout.write(result.message);
+    if (result.mismatch) process.exitCode = 1;
+  } else if (cmd === "set identity") {
+    // `krimto set identity <email>` — update KRIMTO_IDENTITY across every registered editor
+    // and the always-running service. Preserves other env keys (KRIMTO_EMBED_*). Existing
+    // notes do NOT move — that's an intentional separate step.
+    const newIdentity = process.argv[4];
+    const flags = process.argv.slice(5);
+    const yes = flags.includes("--yes");
+    if (!newIdentity) {
+      process.stderr.write(
+        "Usage: krimto set identity <email> [--yes]\n  e.g. krimto set identity alice@acme.com\n",
+      );
+      process.exit(2);
+    }
+    const { runSetIdentity } = await tsImport("../src/cli/setIdentity.ts", import.meta.url);
+    const { resolveDataDir } = await tsImport("../src/server/index.ts", import.meta.url);
+    const result = await runSetIdentity({
+      identity: newIdentity,
+      dataDir: resolveDataDir(),
+      yes,
+    });
+    process.stdout.write(result.message);
+    if (result.status === "error") process.exitCode = 1;
   } else {
     const mod = await tsImport("../src/server/index.ts", import.meta.url);
     await mod.main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krimto-labs/krimto",
-  "version": "0.2.21",
+  "version": "0.2.22",
   "description": "Open-source team memory layer for AI agents — markdown files in git, user/team/org hierarchy, cross-vendor MCP server.",
   "license": "Apache-2.0",
   "type": "module",

package/src/cli/help.ts

@@ -37,6 +37,10 @@ export function formatHelp(version: string): string {
     "    rm <id>            Delete a fact (file + index + git deletion commit)",
     "    reindex            Rebuild index.db from markdown (fixes manual-delete orphans)",
     "",
+    "  Identity:",
+    "    whoami             Show which email Krimto is using (and where it's set)",
+    "    set identity <e>   Change the identity used for new fact writes",
+    "",
     "  Diagnose:",
     "    verify-connection  Is my agent actually calling Krimto? (live status + last 5 calls)",
     "    setup-remote <url> Wire data dir to a git remote, verify the push works",

package/src/cli/setIdentity.ts

@@ -0,0 +1,232 @@
+// `krimto set identity <email>` — change KRIMTO_IDENTITY everywhere the wizard wrote it.
+//
+// Surfaces touched (in order):
+//   1. Each registered editor's MCP config — for JSON-method editors, mutate
+//      `env.KRIMTO_IDENTITY` in place (other env keys like KRIMTO_EMBED_* are preserved).
+//      For CLI-method editors (Claude Code), rebuild a fresh stdio entry via writeMcpConfig
+//      (extra env keys are lost — known limitation noted below).
+//   2. The always-running service (launchd/systemd/schtasks) — uninstall + reinstall with
+//      the new env. Same dataDir + port as before, mirroring serviceCmd.applyService.
+//
+// HTTP-transport MCP entries don't carry identity (it lives in the service env); they are
+// left untouched.
+//
+// Existing notes do NOT migrate. The folder for the old identity stays under
+// `~/.krimto/user/<old-email>/` — moving them is intentionally a separate step (would need
+// a git rename + reindex; out of scope for this command).
+
+import { confirm } from "@inquirer/prompts";
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+
+import { stdioMcpEntry, type KrimtoMcpEntry } from "../server/connect";
+import {
+  detectEditorEnvironments,
+  detectExistingSetup,
+  type EditorEnvironment,
+  type EditorKind,
+} from "./init";
+import { writeMcpConfig } from "./mcpConfig";
+import {
+  detectPlatform,
+  installService,
+  isServiceInstalled,
+  uninstallService,
+} from "./service";
+import { defaultIO, isExitPrompt, type WizardIO } from "./promptHelpers";
+import { runWhoami } from "./whoami";
+
+const EDITOR_LABEL: Record<EditorKind, string> = {
+  cursor: "Cursor",
+  "claude-code": "Claude Code",
+  codex: "Codex",
+  "gemini-cli": "Gemini CLI",
+};
+
+// Same permissive shape used by defaultIdentity() — accepts anything that looks like name@host.
+const EMAIL_REGEX = /^[^@\s]+@[^@\s]+$/;
+
+export interface SetIdentityOptions {
+  identity: string;
+  io?: WizardIO;
+  cwd?: string;
+  homeDir?: string;
+  dataDir?: string;
+  /** Skip the confirmation prompt (CI / scripted runs). */
+  yes?: boolean;
+  /** Forwarded to install/uninstallService for tests. */
+  dryRun?: boolean;
+}
+
+export interface SetIdentityResult {
+  status: "ok" | "no-change" | "error";
+  message: string;
+  updatedEditors: EditorKind[];
+  serviceUpdated: boolean;
+}
+
+export async function runSetIdentity(opts: SetIdentityOptions): Promise<SetIdentityResult> {
+  const io = opts.io ?? defaultIO;
+  const cwd = opts.cwd ?? process.cwd();
+
+  if (!EMAIL_REGEX.test(opts.identity)) {
+    return {
+      status: "error",
+      message:
+        `\n❌ Not a valid email: "${opts.identity}"\n` +
+        `   Expected something like name@example.com\n\n`,
+      updatedEditors: [],
+      serviceUpdated: false,
+    };
+  }
+
+  const current = await runWhoami({ cwd, homeDir: opts.homeDir });
+  const snapshot = await detectExistingSetup(cwd, opts.homeDir);
+
+  if (!snapshot.configured) {
+    return {
+      status: "error",
+      message: "\n❌ Krimto isn't set up here yet. Run `krimto init` first.\n\n",
+      updatedEditors: [],
+      serviceUpdated: false,
+    };
+  }
+
+  if (current.activeIdentity === opts.identity && !current.mismatch) {
+    return {
+      status: "no-change",
+      message: `\nNo change — identity is already ${opts.identity}.\n\n`,
+      updatedEditors: [],
+      serviceUpdated: false,
+    };
+  }
+
+  if (!opts.yes) {
+    io.out("\nKrimto — Set identity\n\n");
+    io.out(`  Current identity: ${current.activeIdentity}\n`);
+    io.out(`  New identity:     ${opts.identity}\n\n`);
+    io.out("  Will update:\n");
+    for (const e of snapshot.registeredEditors) {
+      io.out(`    • ${EDITOR_LABEL[e]} MCP config\n`);
+    }
+    if (snapshot.runMode === "always-running") {
+      io.out("    • Background service (launchd/systemd/schtasks)\n");
+    }
+    io.out("\n  ⚠️  Existing notes will NOT move — they stay under\n");
+    io.out(`     ~/.krimto/user/${current.activeIdentity}/\n`);
+    io.out(`     New facts will go to ~/.krimto/user/${opts.identity}/\n\n`);
+    try {
+      const ok = await confirm({ message: "Apply this change?", default: true });
+      if (!ok) {
+        return {
+          status: "no-change",
+          message: "\nAborted. No changes were made.\n\n",
+          updatedEditors: [],
+          serviceUpdated: false,
+        };
+      }
+    } catch (e) {
+      if (isExitPrompt(e)) {
+        return {
+          status: "no-change",
+          message: "\nAborted. No changes were made.\n\n",
+          updatedEditors: [],
+          serviceUpdated: false,
+        };
+      }
+      throw e;
+    }
+  }
+
+  const envs = await detectEditorEnvironments(cwd, opts.homeDir);
+  const updatedEditors: EditorKind[] = [];
+  for (const env of envs) {
+    if (!snapshot.registeredEditors.includes(env.editor)) continue;
+    const ok = await updateEditorIdentity(env, opts.identity);
+    if (ok) updatedEditors.push(env.editor);
+  }
+
+  let serviceUpdated = false;
+  const platform = detectPlatform();
+  const service = await isServiceInstalled(platform, opts.homeDir);
+  if (service.installed) {
+    const dataDir = opts.dataDir ?? path.join(opts.homeDir ?? "", ".krimto");
+    await uninstallService({ platform, homeDir: opts.homeDir, dryRun: opts.dryRun });
+    await installService(
+      {
+        binPath: process.execPath,
+        args: [process.argv[1] ?? "krimto", "serve"],
+        env: { KRIMTO_IDENTITY: opts.identity, KRIMTO_DATA: dataDir, KRIMTO_HTTP_PORT: "8080" },
+        homeDir: opts.homeDir,
+      },
+      { dryRun: opts.dryRun, platform },
+    );
+    serviceUpdated = true;
+  }
+
+  const lines: string[] = ["", `✅ Identity changed → ${opts.identity}`, ""];
+  for (const e of updatedEditors) {
+    lines.push(`   • Updated ${EDITOR_LABEL[e]} MCP config`);
+  }
+  if (serviceUpdated) lines.push("   • Restarted background service");
+  if (updatedEditors.length === 0 && !serviceUpdated) {
+    lines.push("   (Nothing to update — no editors registered + no service installed)");
+  }
+  lines.push("");
+  lines.push("Restart your editor(s) so they pick up the new identity.");
+  lines.push("");
+  lines.push(`New facts → ~/.krimto/user/${opts.identity}/`);
+  lines.push(`Old facts stay at ~/.krimto/user/${current.activeIdentity}/`);
+  lines.push("");
+
+  return {
+    status: "ok",
+    message: lines.join("\n"),
+    updatedEditors,
+    serviceUpdated,
+  };
+}
+
+/**
+ * Update KRIMTO_IDENTITY in this editor's MCP entry.
+ *  • JSON method: surgical mutation preserves any other env keys (KRIMTO_EMBED_*).
+ *  • CLI method (Claude Code): rebuild + re-add via writeMcpConfig. Extra env keys are lost.
+ *  • HTTP entry (url-based): no-op — identity lives in the service env.
+ *  • mcpWire === null: no automated wiring; skip silently.
+ */
+async function updateEditorIdentity(env: EditorEnvironment, identity: string): Promise<boolean> {
+  if (env.mcpWire === null) return false;
+  if (env.mcpWire.method === "json") {
+    return updateIdentityInJson(env.mcpWire.path, env.mcpWire.key, identity);
+  }
+  const entry: KrimtoMcpEntry = { transport: "stdio", ...stdioMcpEntry({ identity }) };
+  await writeMcpConfig(env, entry);
+  return true;
+}
+
+async function updateIdentityInJson(
+  filePath: string,
+  key: string,
+  identity: string,
+): Promise<boolean> {
+  let text: string;
+  try {
+    text = await fs.readFile(filePath, "utf8");
+  } catch {
+    return false;
+  }
+  let parsed: Record<string, unknown>;
+  try {
+    parsed = JSON.parse(text) as Record<string, unknown>;
+  } catch {
+    return false;
+  }
+  const servers = parsed[key] as Record<string, unknown> | undefined;
+  if (!servers || !("krimto" in servers)) return false;
+  const krimto = servers.krimto as { env?: Record<string, string>; url?: string };
+  if (krimto.url) return false;
+  const nextEnv = { ...(krimto.env ?? {}), KRIMTO_IDENTITY: identity };
+  (servers.krimto as { env: Record<string, string> }).env = nextEnv;
+  await fs.writeFile(filePath, JSON.stringify(parsed, null, 2) + "\n", "utf8");
+  return true;
+}

package/src/cli/whoami.ts

@@ -0,0 +1,172 @@
+// `krimto whoami` — show the active KRIMTO_IDENTITY and every place it's set.
+//
+// Motivation: the v0.2.21 "data-location surprise" bug class — users end up with two scopes
+// (`user/lpdthemes@gmail.com` and `user/user@localhost`) because different surfaces saw
+// different identities and they only noticed weeks later. `whoami` makes drift visible
+// before it leads to split notes.
+
+import { promises as fs } from "node:fs";
+
+import {
+  defaultIdentity,
+  detectEditorEnvironments,
+  type EditorEnvironment,
+  type EditorKind,
+} from "./init";
+import { detectPlatform, isServiceInstalled, type ServicePlatform } from "./service";
+
+const EDITOR_LABEL: Record<EditorKind, string> = {
+  cursor: "Cursor",
+  "claude-code": "Claude Code",
+  codex: "Codex",
+  "gemini-cli": "Gemini CLI",
+};
+
+export interface WhoamiOptions {
+  cwd?: string;
+  homeDir?: string;
+}
+
+export interface IdentitySource {
+  label: string;
+  /** The literal value found; `null` when nothing readable, `"(http)"` for HTTP entries with no inline identity. */
+  identity: string | null;
+  detail?: string;
+}
+
+export interface WhoamiResult {
+  /** The identity Krimto would use for a write right now (best inference). */
+  activeIdentity: string;
+  sources: IdentitySource[];
+  /** True when registered surfaces disagree on identity. */
+  mismatch: boolean;
+  message: string;
+}
+
+export async function runWhoami(opts: WhoamiOptions = {}): Promise<WhoamiResult> {
+  const cwd = opts.cwd ?? process.cwd();
+  const homeDir = opts.homeDir;
+  const envs = await detectEditorEnvironments(cwd, homeDir);
+
+  const sources: IdentitySource[] = [];
+  const distinctIdentities = new Set<string>();
+
+  for (const env of envs) {
+    const found = await readIdentityFromEditor(env);
+    if (found === null) continue;
+    sources.push(found);
+    if (found.identity && found.identity !== "(http)") distinctIdentities.add(found.identity);
+  }
+
+  const platform = detectPlatform();
+  const service = await isServiceInstalled(platform, homeDir);
+  if (service.installed && service.unitPath) {
+    const id = await readIdentityFromServiceUnit(service.unitPath, platform);
+    if (id) {
+      sources.push({ label: "Background service", identity: id, detail: service.unitPath });
+      distinctIdentities.add(id);
+    }
+  }
+
+  const envOverride = process.env.KRIMTO_IDENTITY ?? null;
+  const gitDefault = await defaultIdentity();
+
+  // Active identity = first concrete source we found; fall back through env → git → server default.
+  const firstConcrete = sources.find((s) => s.identity && s.identity !== "(http)")?.identity;
+  const activeIdentity = firstConcrete ?? envOverride ?? gitDefault;
+  const mismatch = distinctIdentities.size > 1;
+
+  return {
+    activeIdentity,
+    sources,
+    mismatch,
+    message: formatWhoami({ activeIdentity, sources, mismatch, envOverride, gitDefault }),
+  };
+}
+
+async function readIdentityFromEditor(env: EditorEnvironment): Promise<IdentitySource | null> {
+  if (env.mcpWire === null || env.mcpWire.method !== "json") return null;
+  let text: string;
+  try {
+    text = await fs.readFile(env.mcpWire.path, "utf8");
+  } catch {
+    return null;
+  }
+  let parsed: Record<string, unknown>;
+  try {
+    parsed = JSON.parse(text) as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+  const servers = parsed[env.mcpWire.key] as Record<string, unknown> | undefined;
+  if (!servers || !("krimto" in servers)) return null;
+  const krimto = servers.krimto as { env?: Record<string, string>; url?: string };
+  const label = `${EDITOR_LABEL[env.editor]} MCP config`;
+  if (krimto.env?.KRIMTO_IDENTITY) {
+    return { label, identity: krimto.env.KRIMTO_IDENTITY, detail: env.mcpWire.path };
+  }
+  if (krimto.url) {
+    return { label, identity: "(http)", detail: env.mcpWire.path };
+  }
+  return null;
+}
+
+async function readIdentityFromServiceUnit(
+  unitPath: string,
+  platform: ServicePlatform,
+): Promise<string | null> {
+  let text: string;
+  try {
+    text = await fs.readFile(unitPath, "utf8");
+  } catch {
+    return null;
+  }
+  if (platform === "darwin") {
+    // plist XML pattern written by installService — KRIMTO_IDENTITY appears as a <key>/<string> pair.
+    const m = text.match(/<key>KRIMTO_IDENTITY<\/key>\s*<string>([^<]+)<\/string>/);
+    return m && m[1] ? m[1] : null;
+  }
+  if (platform === "linux") {
+    const m = text.match(/KRIMTO_IDENTITY=([^"\s\n]+)/);
+    return m && m[1] ? m[1] : null;
+  }
+  // Windows: schtasks doesn't store env in a readable file we own. Skip.
+  return null;
+}
+
+function formatWhoami(opts: {
+  activeIdentity: string;
+  sources: IdentitySource[];
+  mismatch: boolean;
+  envOverride: string | null;
+  gitDefault: string;
+}): string {
+  const lines: string[] = ["", "Krimto — Identity", ""];
+  lines.push(`  Active identity:   ${opts.activeIdentity}`, "");
+  lines.push("  Where it's set:");
+  if (opts.sources.length === 0) {
+    lines.push("    (no editors registered, no service installed — run `krimto init` first)");
+  } else {
+    for (const s of opts.sources) {
+      const display = s.identity === "(http)" ? "(uses service identity)" : (s.identity ?? "(unset)");
+      const marker = s.identity === "(http)" || s.identity === opts.activeIdentity ? "✓" : "⚠";
+      lines.push(`    ${marker} ${s.label.padEnd(28)} ${display}`);
+    }
+  }
+  lines.push("");
+  lines.push("  Fallback chain (used when no source above sets it):");
+  lines.push(`    KRIMTO_IDENTITY env       ${opts.envOverride ?? "(unset)"}`);
+  lines.push(`    git config user.email     ${opts.gitDefault}`);
+  lines.push("    Server default            user@localhost");
+  lines.push("");
+  if (opts.mismatch) {
+    lines.push("  ⚠️  Mismatch — different sources disagree on identity.");
+    lines.push("     Run `krimto set identity <email>` to sync them.");
+  } else if (opts.sources.length > 0) {
+    lines.push("  ✅  All sources agree.");
+  }
+  lines.push("");
+  lines.push("To change it: krimto set identity <email>");
+  lines.push("");
+  return lines.join("\n");
+}

package/src/server/index.ts

@@ -48,7 +48,7 @@ import { type Requester } from "../access/scope";
 
 export type RequesterResolver = (extra: { authInfo?: AuthInfo }) => Requester;
 
-export const KRIMTO_VERSION = "0.2.21";
+export const KRIMTO_VERSION = "0.2.22";
 
 export function resolveDataDir(): string {
   return process.env.KRIMTO_DATA ?? path.join(homedir(), ".krimto");