@devness/useai 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,340 +1,1137 @@
 #!/usr/bin/env node
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-const USEAI_API = "https://api.useai.dev/v1";
-const VERSION = "0.1.0";
-// Session state
-let sessionStartTime = Date.now();
-let sessionId = crypto.randomUUID();
-let heartbeatCount = 0;
-let clientName = "unknown";
-function detectClient() {
-    const env = process.env;
-    if (env.CURSOR_EDITOR)
-        return "cursor";
-    if (env.WINDSURF_EDITOR)
-        return "windsurf";
-    if (env.CLAUDE_CODE)
-        return "claude-code";
-    if (env.VSCODE_PID)
-        return "vscode";
-    if (env.CODEX_CLI)
-        return "codex";
-    if (env.GEMINI_CLI)
-        return "gemini-cli";
-    if (env.JETBRAINS_IDE)
-        return "jetbrains";
-    if (env.ZED_EDITOR)
-        return "zed";
-    if (env.MCP_CLIENT_NAME)
-        return env.MCP_CLIENT_NAME;
-    return "unknown";
-}
-async function pushMetrics(data) {
-    const token = process.env.USEAI_TOKEN;
-    if (!token)
-        return false;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/tools.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { dirname, join as join3 } from "path";
+import { homedir as homedir2 } from "os";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+function hasBinary(name) {
+  try {
+    execSync(`which ${name}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readJsonFile(path) {
+  if (!existsSync3(path)) return {};
+  try {
+    const raw = readFileSync2(path, "utf-8").trim();
+    if (!raw) return {};
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function writeJsonFile(path, data) {
+  mkdirSync2(dirname(path), { recursive: true });
+  writeFileSync2(path, JSON.stringify(data, null, 2) + "\n");
+}
+function isConfiguredStandard(configPath) {
+  const config = readJsonFile(configPath);
+  const servers = config["mcpServers"];
+  return !!servers?.["useai"];
+}
+function installStandard(configPath) {
+  const config = readJsonFile(configPath);
+  const servers = config["mcpServers"] ?? {};
+  servers["useai"] = { ...MCP_ENTRY };
+  config["mcpServers"] = servers;
+  writeJsonFile(configPath, config);
+}
+function removeStandard(configPath) {
+  const config = readJsonFile(configPath);
+  const servers = config["mcpServers"];
+  if (servers) {
+    delete servers["useai"];
+    if (Object.keys(servers).length === 0) {
+      delete config["mcpServers"];
+    }
+    writeJsonFile(configPath, config);
+  }
+}
+function isConfiguredVscode(configPath) {
+  const config = readJsonFile(configPath);
+  const servers = config["servers"];
+  return !!servers?.["useai"];
+}
+function installVscode(configPath) {
+  const config = readJsonFile(configPath);
+  const servers = config["servers"] ?? {};
+  servers["useai"] = { command: MCP_ENTRY.command, args: MCP_ENTRY.args };
+  config["servers"] = servers;
+  writeJsonFile(configPath, config);
+}
+function removeVscode(configPath) {
+  const config = readJsonFile(configPath);
+  const servers = config["servers"];
+  if (servers) {
+    delete servers["useai"];
+    if (Object.keys(servers).length === 0) {
+      delete config["servers"];
+    }
+    writeJsonFile(configPath, config);
+  }
+}
+function isConfiguredZed(configPath) {
+  const config = readJsonFile(configPath);
+  const servers = config["context_servers"];
+  return !!servers?.["useai"];
+}
+function installZed(configPath) {
+  const config = readJsonFile(configPath);
+  const servers = config["context_servers"] ?? {};
+  servers["useai"] = {
+    command: { path: MCP_ENTRY.command, args: MCP_ENTRY.args },
+    settings: {}
+  };
+  config["context_servers"] = servers;
+  writeJsonFile(configPath, config);
+}
+function removeZed(configPath) {
+  const config = readJsonFile(configPath);
+  const servers = config["context_servers"];
+  if (servers) {
+    delete servers["useai"];
+    if (Object.keys(servers).length === 0) {
+      delete config["context_servers"];
+    }
+    writeJsonFile(configPath, config);
+  }
+}
+function readTomlFile(path) {
+  if (!existsSync3(path)) return {};
+  try {
+    const raw = readFileSync2(path, "utf-8").trim();
+    if (!raw) return {};
+    return parseToml(raw);
+  } catch {
+    return {};
+  }
+}
+function writeTomlFile(path, data) {
+  mkdirSync2(dirname(path), { recursive: true });
+  writeFileSync2(path, stringifyToml(data) + "\n");
+}
+function isConfiguredToml(configPath) {
+  const config = readTomlFile(configPath);
+  const servers = config["mcp_servers"];
+  return !!servers?.["useai"];
+}
+function installToml(configPath) {
+  const config = readTomlFile(configPath);
+  const servers = config["mcp_servers"] ?? {};
+  servers["useai"] = { command: MCP_ENTRY.command, args: MCP_ENTRY.args };
+  config["mcp_servers"] = servers;
+  writeTomlFile(configPath, config);
+}
+function removeToml(configPath) {
+  const config = readTomlFile(configPath);
+  const servers = config["mcp_servers"];
+  if (servers) {
+    delete servers["useai"];
+    if (Object.keys(servers).length === 0) {
+      delete config["mcp_servers"];
+    }
+    writeTomlFile(configPath, config);
+  }
+}
+function readYamlFile(path) {
+  if (!existsSync3(path)) return {};
+  try {
+    const raw = readFileSync2(path, "utf-8").trim();
+    if (!raw) return {};
+    return parseYaml(raw) ?? {};
+  } catch {
+    return {};
+  }
+}
+function writeYamlFile(path, data) {
+  mkdirSync2(dirname(path), { recursive: true });
+  writeFileSync2(path, stringifyYaml(data));
+}
+function isConfiguredYaml(configPath) {
+  const config = readYamlFile(configPath);
+  const extensions = config["extensions"];
+  return !!extensions?.["useai"];
+}
+function installYaml(configPath) {
+  const config = readYamlFile(configPath);
+  const extensions = config["extensions"] ?? {};
+  extensions["useai"] = {
+    name: "useai",
+    cmd: MCP_ENTRY.command,
+    args: MCP_ENTRY.args,
+    enabled: true,
+    type: "stdio"
+  };
+  config["extensions"] = extensions;
+  writeYamlFile(configPath, config);
+}
+function removeYaml(configPath) {
+  const config = readYamlFile(configPath);
+  const extensions = config["extensions"];
+  if (extensions) {
+    delete extensions["useai"];
+    if (Object.keys(extensions).length === 0) {
+      delete config["extensions"];
+    }
+    writeYamlFile(configPath, config);
+  }
+}
+function createTool(def) {
+  const handler = formatHandlers[def.configFormat];
+  return {
+    id: def.id,
+    name: def.name,
+    configFormat: def.configFormat,
+    getConfigPath: () => def.configPath,
+    detect: def.detect,
+    isConfigured: () => handler.isConfigured(def.configPath),
+    install: () => handler.install(def.configPath),
+    remove: () => handler.remove(def.configPath)
+  };
+}
+function matchesTool(tool, query) {
+  const q = query.toLowerCase().replace(/[\s-_]+/g, "");
+  const id = tool.id.toLowerCase().replace(/[\s-_]+/g, "");
+  const name = tool.name.toLowerCase().replace(/[\s-_]+/g, "");
+  return id === q || name === q || id.includes(q) || name.includes(q);
+}
+function resolveTools(names) {
+  const matched = [];
+  const unmatched = [];
+  for (const name of names) {
+    const found = AI_TOOLS.filter((t) => matchesTool(t, name));
+    if (found.length > 0) {
+      for (const f of found) {
+        if (!matched.includes(f)) matched.push(f);
+      }
+    } else {
+      unmatched.push(name);
+    }
+  }
+  return { matched, unmatched };
+}
+var MCP_ENTRY, home, formatHandlers, appSupport, AI_TOOLS;
+var init_tools = __esm({
+  "src/tools.ts"() {
+    "use strict";
+    MCP_ENTRY = {
+      command: "npx",
+      args: ["-y", "@devness/useai"]
+    };
+    home = homedir2();
+    formatHandlers = {
+      standard: { isConfigured: isConfiguredStandard, install: installStandard, remove: removeStandard },
+      vscode: { isConfigured: isConfiguredVscode, install: installVscode, remove: removeVscode },
+      zed: { isConfigured: isConfiguredZed, install: installZed, remove: removeZed },
+      toml: { isConfigured: isConfiguredToml, install: installToml, remove: removeToml },
+      yaml: { isConfigured: isConfiguredYaml, install: installYaml, remove: removeYaml }
+    };
+    appSupport = join3(home, "Library", "Application Support");
+    AI_TOOLS = [
+      createTool({
+        id: "claude-code",
+        name: "Claude Code",
+        configFormat: "standard",
+        configPath: join3(home, ".claude.json"),
+        detect: () => hasBinary("claude") || existsSync3(join3(home, ".claude.json"))
+      }),
+      createTool({
+        id: "claude-desktop",
+        name: "Claude Desktop",
+        configFormat: "standard",
+        configPath: join3(appSupport, "Claude", "claude_desktop_config.json"),
+        detect: () => existsSync3(join3(appSupport, "Claude")) || existsSync3("/Applications/Claude.app")
+      }),
+      createTool({
+        id: "cursor",
+        name: "Cursor",
+        configFormat: "standard",
+        configPath: join3(home, ".cursor", "mcp.json"),
+        detect: () => existsSync3(join3(home, ".cursor"))
+      }),
+      createTool({
+        id: "windsurf",
+        name: "Windsurf",
+        configFormat: "standard",
+        configPath: join3(home, ".codeium", "windsurf", "mcp_config.json"),
+        detect: () => existsSync3(join3(home, ".codeium", "windsurf"))
+      }),
+      createTool({
+        id: "vscode",
+        name: "VS Code",
+        configFormat: "vscode",
+        configPath: join3(appSupport, "Code", "User", "mcp.json"),
+        detect: () => existsSync3(join3(appSupport, "Code"))
+      }),
+      createTool({
+        id: "vscode-insiders",
+        name: "VS Code Insiders",
+        configFormat: "vscode",
+        configPath: join3(appSupport, "Code - Insiders", "User", "mcp.json"),
+        detect: () => existsSync3(join3(appSupport, "Code - Insiders"))
+      }),
+      createTool({
+        id: "gemini-cli",
+        name: "Gemini CLI",
+        configFormat: "standard",
+        configPath: join3(home, ".gemini", "settings.json"),
+        detect: () => hasBinary("gemini")
+      }),
+      createTool({
+        id: "zed",
+        name: "Zed",
+        configFormat: "zed",
+        configPath: join3(appSupport, "Zed", "settings.json"),
+        detect: () => existsSync3(join3(appSupport, "Zed"))
+      }),
+      createTool({
+        id: "cline",
+        name: "Cline",
+        configFormat: "standard",
+        configPath: join3(
+          appSupport,
+          "Code",
+          "User",
+          "globalStorage",
+          "saoudrizwan.claude-dev",
+          "settings",
+          "cline_mcp_settings.json"
+        ),
+        detect: () => existsSync3(
+          join3(appSupport, "Code", "User", "globalStorage", "saoudrizwan.claude-dev")
+        )
+      }),
+      createTool({
+        id: "roo-code",
+        name: "Roo Code",
+        configFormat: "standard",
+        configPath: join3(
+          appSupport,
+          "Code",
+          "User",
+          "globalStorage",
+          "rooveterinaryinc.roo-cline",
+          "settings",
+          "cline_mcp_settings.json"
+        ),
+        detect: () => existsSync3(
+          join3(appSupport, "Code", "User", "globalStorage", "rooveterinaryinc.roo-cline")
+        )
+      }),
+      createTool({
+        id: "amazon-q-cli",
+        name: "Amazon Q CLI",
+        configFormat: "standard",
+        configPath: join3(home, ".aws", "amazonq", "mcp.json"),
+        detect: () => hasBinary("q") || existsSync3(join3(home, ".aws", "amazonq"))
+      }),
+      createTool({
+        id: "amazon-q-ide",
+        name: "Amazon Q IDE",
+        configFormat: "standard",
+        configPath: join3(home, ".aws", "amazonq", "default.json"),
+        detect: () => existsSync3(join3(home, ".amazonq")) || existsSync3(join3(home, ".aws", "amazonq"))
+      }),
+      createTool({
+        id: "codex",
+        name: "Codex",
+        configFormat: "toml",
+        configPath: join3(home, ".codex", "config.toml"),
+        detect: () => hasBinary("codex") || existsSync3(join3(home, ".codex")) || existsSync3("/Applications/Codex.app")
+      }),
+      createTool({
+        id: "goose",
+        name: "Goose",
+        configFormat: "yaml",
+        configPath: join3(home, ".config", "goose", "config.yaml"),
+        detect: () => existsSync3(join3(home, ".config", "goose"))
+      }),
+      createTool({
+        id: "opencode",
+        name: "OpenCode",
+        configFormat: "standard",
+        configPath: join3(home, ".config", "opencode", "opencode.json"),
+        detect: () => hasBinary("opencode") || existsSync3(join3(home, ".config", "opencode"))
+      }),
+      createTool({
+        id: "junie",
+        name: "Junie",
+        configFormat: "standard",
+        configPath: join3(home, ".junie", "mcp", "mcp.json"),
+        detect: () => existsSync3(join3(home, ".junie"))
+      })
+    ];
+  }
+});
+
+// src/setup.ts
+var setup_exports = {};
+__export(setup_exports, {
+  runSetup: () => runSetup
+});
+import { checkbox } from "@inquirer/prompts";
+import chalk from "chalk";
+function shortenPath(p) {
+  const home2 = process.env["HOME"] ?? "";
+  return home2 && p.startsWith(home2) ? p.replace(home2, "~") : p;
+}
+function header(text) {
+  return chalk.bold.cyan(`
+  ${text}
+  ${"\u2500".repeat(text.length)}`);
+}
+function ok(text) {
+  return chalk.green(`  ${text}`);
+}
+function err(text) {
+  return chalk.red(`  ${text}`);
+}
+function dim(text) {
+  return chalk.dim(`  ${text}`);
+}
+function showStatus(tools) {
+  console.log(header("AI Tool MCP Status"));
+  const rows = [];
+  const nameWidth = Math.max(...tools.map((t) => t.name.length));
+  const statusWidth = 16;
+  for (const tool of tools) {
+    const detected = tool.detect();
+    const name = tool.name.padEnd(nameWidth);
+    if (!detected) {
+      rows.push(`  ${chalk.dim(name)}  ${chalk.dim("\u2014 Not found".padEnd(statusWidth))}`);
+    } else if (tool.isConfigured()) {
+      rows.push(
+        `  ${name}  ${chalk.green("\u2713 Configured".padEnd(statusWidth))}  ${chalk.dim(shortenPath(tool.getConfigPath()))}`
+      );
+    } else {
+      rows.push(
+        `  ${name}  ${chalk.yellow("\u2717 Not set up".padEnd(statusWidth))}  ${chalk.dim(shortenPath(tool.getConfigPath()))}`
+      );
+    }
+  }
+  console.log(rows.join("\n"));
+  console.log();
+}
+async function installFlow(tools, autoYes, explicit) {
+  if (explicit) {
+    const toInstall2 = tools.filter((t) => !t.isConfigured());
+    const alreadyDone = tools.filter((t) => t.isConfigured());
+    for (const tool of alreadyDone) {
+      console.log(dim(`${tool.name} is already configured.`));
+    }
+    if (toInstall2.length === 0) return;
+    console.log();
+    for (const tool of toInstall2) {
+      try {
+        tool.install();
+        console.log(ok(`\u2713 ${tool.name.padEnd(18)} \u2192 ${chalk.dim(shortenPath(tool.getConfigPath()))}`));
+      } catch (e) {
+        console.log(err(`\u2717 ${tool.name.padEnd(18)} \u2014 ${e.message}`));
+      }
+    }
+    console.log();
+    return;
+  }
+  console.log(dim("Scanning for AI tools...\n"));
+  const detected = tools.filter((t) => t.detect());
+  if (detected.length === 0) {
+    console.log(err("No AI tools detected on this machine."));
+    return;
+  }
+  const alreadyConfigured = detected.filter((t) => t.isConfigured());
+  const unconfigured = detected.filter((t) => !t.isConfigured());
+  console.log(`  Found ${chalk.bold(String(detected.length))} AI tool${detected.length === 1 ? "" : "s"} on this machine:
+`);
+  for (const tool of alreadyConfigured) {
+    console.log(chalk.green(`  \u2705 ${tool.name}`) + chalk.dim("  (already configured)"));
+  }
+  for (const tool of unconfigured) {
+    console.log(chalk.dim(`  \u2610  ${tool.name}`));
+  }
+  console.log();
+  if (unconfigured.length === 0) {
+    console.log(ok("All detected tools are already configured."));
+    return;
+  }
+  let toInstall;
+  if (autoYes) {
+    toInstall = unconfigured;
+  } else {
+    const selected = await checkbox({
+      message: "Select tools to configure:",
+      choices: unconfigured.map((t) => ({
+        name: t.name,
+        value: t.id,
+        checked: true
+      }))
+    });
+    toInstall = unconfigured.filter((t) => selected.includes(t.id));
+  }
+  if (toInstall.length === 0) {
+    console.log(dim("No tools selected."));
+    return;
+  }
+  console.log(`
+  Configuring ${toInstall.length} tool${toInstall.length === 1 ? "" : "s"}...
+`);
+  for (const tool of toInstall) {
     try {
-        const res = await fetch(`${USEAI_API}/sessions`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${token}`,
-            },
-            body: JSON.stringify(data),
-            signal: AbortSignal.timeout(5000),
-        });
-        return res.ok;
+      tool.install();
+      console.log(ok(`\u2713 ${tool.name.padEnd(18)} \u2192 ${chalk.dim(shortenPath(tool.getConfigPath()))}`));
+    } catch (e) {
+      console.log(err(`\u2717 ${tool.name.padEnd(18)} \u2014 ${e.message}`));
     }
-    catch {
-        // Silently fail — telemetry should never break the user's workflow
+  }
+  console.log(`
+  Done! useai MCP server configured in ${chalk.bold(String(toInstall.length))} tool${toInstall.length === 1 ? "" : "s"}.
+`);
+}
+async function removeFlow(tools, autoYes, explicit) {
+  if (explicit) {
+    const toRemove2 = tools.filter((t) => {
+      try {
+        return t.isConfigured();
+      } catch {
         return false;
+      }
+    });
+    const notConfigured = tools.filter((t) => {
+      try {
+        return !t.isConfigured();
+      } catch {
+        return true;
+      }
+    });
+    for (const tool of notConfigured) {
+      console.log(dim(`${tool.name} is not configured \u2014 skipping.`));
+    }
+    if (toRemove2.length === 0) return;
+    console.log();
+    for (const tool of toRemove2) {
+      try {
+        tool.remove();
+        console.log(ok(`\u2713 Removed from ${tool.name}`));
+      } catch (e) {
+        console.log(err(`\u2717 ${tool.name} \u2014 ${e.message}`));
+      }
     }
+    console.log();
+    return;
+  }
+  const configured = tools.filter((t) => {
+    try {
+      return t.isConfigured();
+    } catch {
+      return false;
+    }
+  });
+  if (configured.length === 0) {
+    console.log(dim("useai is not configured in any AI tools."));
+    return;
+  }
+  console.log(`
+  Found useai configured in ${chalk.bold(String(configured.length))} tool${configured.length === 1 ? "" : "s"}:
+`);
+  let toRemove;
+  if (autoYes) {
+    toRemove = configured;
+  } else {
+    const selected = await checkbox({
+      message: "Select tools to remove useai from:",
+      choices: configured.map((t) => ({
+        name: t.name,
+        value: t.id,
+        checked: true
+      }))
+    });
+    toRemove = configured.filter((t) => selected.includes(t.id));
+  }
+  if (toRemove.length === 0) {
+    console.log(dim("No tools selected."));
+    return;
+  }
+  console.log(`
+  Removing from ${toRemove.length} tool${toRemove.length === 1 ? "" : "s"}...
+`);
+  for (const tool of toRemove) {
+    try {
+      tool.remove();
+      console.log(ok(`\u2713 Removed from ${tool.name}`));
+    } catch (e) {
+      console.log(err(`\u2717 ${tool.name} \u2014 ${e.message}`));
+    }
+  }
+  console.log(`
+  Done! useai removed from ${chalk.bold(String(toRemove.length))} tool${toRemove.length === 1 ? "" : "s"}.
+`);
 }
-function getSessionDuration() {
-    return Math.round((Date.now() - sessionStartTime) / 1000);
+function showHelp() {
+  console.log(`
+  ${chalk.bold("Usage:")} npx @devness/useai mcp [tools...] [options]
+
+  Configure useai MCP server in your AI tools.
+
+  ${chalk.bold("Arguments:")}
+    tools       Specific tool names (e.g. codex cursor vscode)
+
+  ${chalk.bold("Options:")}
+    --remove    Remove useai from configured tools
+    --status    Show configuration status without modifying
+    -y, --yes   Skip confirmation, auto-select all detected tools
+    -h, --help  Show this help message
+`);
+}
+async function runSetup(args) {
+  const flags = new Set(args.filter((a) => a.startsWith("-")));
+  const toolNames = args.filter((a) => !a.startsWith("-"));
+  if (flags.has("-h") || flags.has("--help")) {
+    showHelp();
+    return;
+  }
+  const isRemove = flags.has("--remove");
+  const isStatus = flags.has("--status");
+  const autoYes = flags.has("-y") || flags.has("--yes");
+  const explicit = toolNames.length > 0;
+  let tools = AI_TOOLS;
+  if (explicit) {
+    const { matched, unmatched } = resolveTools(toolNames);
+    if (unmatched.length > 0) {
+      console.log(err(`Unknown tool${unmatched.length === 1 ? "" : "s"}: ${unmatched.join(", ")}`));
+      console.log(dim(`Available: ${AI_TOOLS.map((t) => t.id).join(", ")}`));
+      return;
+    }
+    tools = matched;
+  }
+  if (isStatus) {
+    showStatus(tools);
+  } else if (isRemove) {
+    await removeFlow(tools, autoYes, explicit);
+  } else {
+    await installFlow(tools, autoYes, explicit);
+  }
+}
+var init_setup = __esm({
+  "src/setup.ts"() {
+    "use strict";
+    init_tools();
+  }
+});
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z as z2 } from "zod";
+import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
+import { existsSync as existsSync4, renameSync as renameSync2 } from "fs";
+import { join as join4 } from "path";
+
+// ../shared/dist/constants/paths.js
+import { join } from "path";
+import { homedir } from "os";
+var USEAI_DIR = join(homedir(), ".useai");
+var DATA_DIR = join(USEAI_DIR, "data");
+var ACTIVE_DIR = join(DATA_DIR, "active");
+var SEALED_DIR = join(DATA_DIR, "sealed");
+var KEYSTORE_FILE = join(USEAI_DIR, "keystore.json");
+var CONFIG_FILE = join(USEAI_DIR, "config.json");
+var SESSIONS_FILE = join(DATA_DIR, "sessions.json");
+var MILESTONES_FILE = join(DATA_DIR, "milestones.json");
+
+// ../shared/dist/constants/version.js
+var VERSION = "0.3.0";
+
+// ../shared/dist/constants/clients.js
+var AI_CLIENT_ENV_VARS = {
+  CURSOR_EDITOR: "cursor",
+  WINDSURF_EDITOR: "windsurf",
+  CLAUDE_CODE: "claude-code",
+  VSCODE_PID: "vscode",
+  CODEX_CLI: "codex",
+  GEMINI_CLI: "gemini-cli",
+  JETBRAINS_IDE: "jetbrains",
+  ZED_EDITOR: "zed"
+};
+
+// ../shared/dist/constants/defaults.js
+var GENESIS_HASH = "GENESIS";
+
+// ../shared/dist/crypto/keystore.js
+import { generateKeyPairSync, randomBytes, createCipheriv, createDecipheriv, createPrivateKey } from "crypto";
+
+// ../shared/dist/crypto/derive.js
+import { pbkdf2Sync } from "crypto";
+import { hostname, userInfo } from "os";
+function deriveEncryptionKey(salt) {
+  const machineData = `${hostname()}:${userInfo().username}:useai-keystore`;
+  return pbkdf2Sync(machineData, salt, 1e5, 32, "sha256");
+}
+
+// ../shared/dist/crypto/keystore.js
+function decryptKeystore(ks) {
+  const salt = Buffer.from(ks.salt, "hex");
+  const iv = Buffer.from(ks.iv, "hex");
+  const tag = Buffer.from(ks.tag, "hex");
+  const encrypted = Buffer.from(ks.encrypted_private_key, "hex");
+  const encKey = deriveEncryptionKey(salt);
+  const decipher = createDecipheriv("aes-256-gcm", encKey, iv);
+  decipher.setAuthTag(tag);
+  const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
+  return createPrivateKey(decrypted.toString("utf-8"));
+}
+function generateKeystore() {
+  const { publicKey, privateKey } = generateKeyPairSync("ed25519");
+  const privateKeyPem = privateKey.export({ type: "pkcs8", format: "pem" });
+  const publicKeyPem = publicKey.export({ type: "spki", format: "pem" });
+  const salt = randomBytes(32);
+  const encKey = deriveEncryptionKey(salt);
+  const iv = randomBytes(12);
+  const cipher = createCipheriv("aes-256-gcm", encKey, iv);
+  const encrypted = Buffer.concat([cipher.update(privateKeyPem, "utf-8"), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  const keystore = {
+    public_key_pem: publicKeyPem,
+    encrypted_private_key: encrypted.toString("hex"),
+    iv: iv.toString("hex"),
+    tag: tag.toString("hex"),
+    salt: salt.toString("hex"),
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return { keystore, signingKey: privateKey };
+}
+
+// ../shared/dist/crypto/chain.js
+import { createHash, sign as cryptoSign, randomUUID } from "crypto";
+function computeHash(recordJson, prevHash) {
+  return createHash("sha256").update(recordJson + prevHash).digest("hex");
+}
+function signHash(hash, signingKey2) {
+  if (!signingKey2)
+    return "unsigned";
+  try {
+    return cryptoSign(null, Buffer.from(hash), signingKey2).toString("hex");
+  } catch {
+    return "unsigned";
+  }
+}
+function buildChainRecord(type, sessionId2, data, prevHash, signingKey2) {
+  const id = `r_${randomUUID().slice(0, 12)}`;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const recordCore = JSON.stringify({ id, type, session_id: sessionId2, timestamp, data });
+  const hash = computeHash(recordCore, prevHash);
+  const signature = signHash(hash, signingKey2);
+  return {
+    id,
+    type,
+    session_id: sessionId2,
+    timestamp,
+    data,
+    prev_hash: prevHash,
+    hash,
+    signature
+  };
+}
+
+// ../shared/dist/crypto/verify.js
+import { createHash as createHash2, createPublicKey, verify as cryptoVerify } from "crypto";
+
+// ../shared/dist/validation/schemas.js
+import { z } from "zod";
+var taskTypeSchema = z.enum([
+  "coding",
+  "debugging",
+  "testing",
+  "planning",
+  "reviewing",
+  "documenting",
+  "learning",
+  "other"
+]);
+var milestoneCategorySchema = z.enum([
+  "feature",
+  "bugfix",
+  "refactor",
+  "test",
+  "docs",
+  "setup",
+  "deployment",
+  "other"
+]);
+var complexitySchema = z.enum(["simple", "medium", "complex"]);
+var milestoneInputSchema = z.object({
+  title: z.string().min(1).max(500),
+  category: milestoneCategorySchema,
+  complexity: complexitySchema.optional()
+});
+var syncPayloadSchema = z.object({
+  date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  total_seconds: z.number().int().nonnegative(),
+  clients: z.record(z.string(), z.number().int().nonnegative()),
+  task_types: z.record(z.string(), z.number().int().nonnegative()),
+  languages: z.record(z.string(), z.number().int().nonnegative()),
+  sessions: z.array(z.object({
+    session_id: z.string(),
+    client: z.string(),
+    task_type: z.string(),
+    languages: z.array(z.string()),
+    files_touched: z.number().int().nonnegative(),
+    started_at: z.string(),
+    ended_at: z.string(),
+    duration_seconds: z.number().int().nonnegative(),
+    heartbeat_count: z.number().int().nonnegative(),
+    record_count: z.number().int().nonnegative(),
+    chain_start_hash: z.string(),
+    chain_end_hash: z.string(),
+    seal_signature: z.string()
+  })),
+  sync_signature: z.string()
+});
+var publishPayloadSchema = z.object({
+  milestones: z.array(z.object({
+    id: z.string(),
+    title: z.string().min(1).max(500),
+    category: milestoneCategorySchema,
+    complexity: complexitySchema,
+    duration_minutes: z.number().int().nonnegative(),
+    languages: z.array(z.string()),
+    client: z.string(),
+    chain_hash: z.string()
+  }))
+});
+
+// ../shared/dist/utils/fs.js
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from "fs";
+function ensureDir() {
+  for (const dir of [USEAI_DIR, DATA_DIR, ACTIVE_DIR, SEALED_DIR]) {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
 }
+function readJson(path, fallback) {
+  try {
+    if (!existsSync(path))
+      return fallback;
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+function writeJson(path, data) {
+  ensureDir();
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(data, null, 2), "utf-8");
+  renameSync(tmp, path);
+}
+
+// ../shared/dist/utils/format.js
 function formatDuration(seconds) {
-    if (seconds < 60)
-        return `${seconds}s`;
-    const mins = Math.round(seconds / 60);
-    if (mins < 60)
-        return `${mins}m`;
-    const hrs = Math.floor(mins / 60);
-    const remainMins = mins % 60;
-    return `${hrs}h ${remainMins}m`;
-}
-// Create server
-const server = new McpServer({
-    name: "useai",
-    version: VERSION,
+  if (seconds < 60)
+    return `${seconds}s`;
+  const mins = Math.round(seconds / 60);
+  if (mins < 60)
+    return `${mins}m`;
+  const hrs = Math.floor(mins / 60);
+  const remainMins = mins % 60;
+  return `${hrs}h ${remainMins}m`;
+}
+
+// ../shared/dist/utils/detect-client.js
+function detectClient() {
+  const env = process.env;
+  for (const [envVar, clientName2] of Object.entries(AI_CLIENT_ENV_VARS)) {
+    if (env[envVar])
+      return clientName2;
+  }
+  if (env.MCP_CLIENT_NAME)
+    return env.MCP_CLIENT_NAME;
+  return "unknown";
+}
+
+// ../shared/dist/utils/id.js
+import { randomUUID as randomUUID2 } from "crypto";
+function generateSessionId() {
+  return randomUUID2();
+}
+
+// src/session.ts
+import { appendFileSync, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+var sessionStartTime = Date.now();
+var sessionId = generateSessionId();
+var heartbeatCount = 0;
+var sessionRecordCount = 0;
+var clientName = "unknown";
+var sessionTaskType = "coding";
+var chainTipHash = GENESIS_HASH;
+var signingKey = null;
+var signingAvailable = false;
+function resetSession() {
+  sessionStartTime = Date.now();
+  sessionId = generateSessionId();
+  heartbeatCount = 0;
+  sessionRecordCount = 0;
+  chainTipHash = GENESIS_HASH;
+  clientName = "unknown";
+  sessionTaskType = "coding";
+}
+function setClient(name) {
+  clientName = name;
+}
+function setTaskType(type) {
+  sessionTaskType = type;
+}
+function incrementHeartbeat() {
+  heartbeatCount++;
+}
+function getSessionDuration() {
+  return Math.round((Date.now() - sessionStartTime) / 1e3);
+}
+function initializeKeystore() {
+  ensureDir();
+  if (existsSync2(KEYSTORE_FILE)) {
+    const ks = readJson(KEYSTORE_FILE, null);
+    if (ks) {
+      try {
+        signingKey = decryptKeystore(ks);
+        signingAvailable = true;
+        return;
+      } catch {
+      }
+    }
+  }
+  const result = generateKeystore();
+  writeJson(KEYSTORE_FILE, result.keystore);
+  signingKey = result.signingKey;
+  signingAvailable = true;
+}
+function sessionChainPath() {
+  return join2(ACTIVE_DIR, `${sessionId}.jsonl`);
+}
+function appendToChain(type, data) {
+  const record = buildChainRecord(type, sessionId, data, chainTipHash, signingKey);
+  ensureDir();
+  appendFileSync(sessionChainPath(), JSON.stringify(record) + "\n", "utf-8");
+  chainTipHash = record.hash;
+  sessionRecordCount++;
+  return record;
+}
+
+// src/index.ts
+if (process.argv[2] === "mcp") {
+  const { runSetup: runSetup2 } = await Promise.resolve().then(() => (init_setup(), setup_exports));
+  await runSetup2(process.argv.slice(3));
+  process.exit(0);
+}
+function getConfig() {
+  return readJson(CONFIG_FILE, {
+    milestone_tracking: true,
+    auto_sync: true
+  });
+}
+function getSessions() {
+  return readJson(SESSIONS_FILE, []);
+}
+function getMilestones() {
+  return readJson(MILESTONES_FILE, []);
+}
+var server = new McpServer({
+  name: "useai",
+  version: VERSION
 });
-// Tool 1: Session start / check-in
-server.tool("useai_checkin", "Check in to useai.dev to start tracking this AI coding session. " +
-    "Call this at the beginning of a conversation to log that the developer is actively using AI tools. " +
-    "This only records which AI tool is being used and when — never any code, prompts, or private data.", {
-    task_type: z
-        .enum([
-        "coding",
-        "debugging",
-        "testing",
-        "planning",
-        "reviewing",
-        "documenting",
-        "learning",
-        "other",
-    ])
-        .optional()
-        .describe("What kind of task is the developer working on?"),
-}, async ({ task_type }) => {
-    sessionStartTime = Date.now();
-    sessionId = crypto.randomUUID();
-    heartbeatCount = 0;
-    clientName = detectClient();
-    await pushMetrics({
-        event: "session_start",
-        session_id: sessionId,
-        client: clientName,
-        task_type: task_type ?? "coding",
-        timestamp: new Date().toISOString(),
-        version: VERSION,
+server.tool(
+  "useai_session_start",
+  "Start tracking an AI coding session. Call this at the beginning of a conversation. Records which AI tool and task type \u2014 stored LOCALLY at ~/.useai/. No data is sent anywhere. No code, prompts, or private data is captured.",
+  {
+    task_type: z2.enum(["coding", "debugging", "testing", "planning", "reviewing", "documenting", "learning", "other"]).optional().describe("What kind of task is the developer working on?")
+  },
+  async ({ task_type }) => {
+    resetSession();
+    setClient(detectClient());
+    setTaskType(task_type ?? "coding");
+    const record = appendToChain("session_start", {
+      client: clientName,
+      task_type: sessionTaskType,
+      version: VERSION
     });
-    const taskLabel = task_type ?? "coding";
     return {
-        content: [
-            {
-                type: "text",
-                text: `useai session started — tracking ${taskLabel} session on ${clientName}. No code or prompts are ever recorded.`,
-            },
-        ],
+      content: [
+        {
+          type: "text",
+          text: `useai session started \u2014 tracking ${sessionTaskType} session on ${clientName}.
+Session: ${sessionId.slice(0, 8)} \xB7 Chain: ${record.hash.slice(0, 12)} (${signingAvailable ? "signed" : "unsigned"})
+All data stored locally at ${USEAI_DIR}. No network calls made.`
+        }
+      ]
     };
-});
-// Tool 2: Heartbeat
-server.tool("useai_heartbeat", "Send a heartbeat to useai.dev to indicate the developer is still actively working. " +
-    "Call this periodically during long conversations (every 10-15 minutes). " +
-    "Only records a timestamp — no content is captured.", {}, async () => {
-    heartbeatCount++;
-    await pushMetrics({
-        event: "heartbeat",
-        session_id: sessionId,
-        client: clientName,
-        heartbeat_number: heartbeatCount,
-        session_duration_seconds: getSessionDuration(),
-        timestamp: new Date().toISOString(),
+  }
+);
+server.tool(
+  "useai_heartbeat",
+  "Record a heartbeat for the current AI coding session. Call this periodically during long conversations (every 10-15 minutes). Only records a timestamp \u2014 stored locally, never sent anywhere.",
+  {},
+  async () => {
+    incrementHeartbeat();
+    appendToChain("heartbeat", {
+      heartbeat_number: heartbeatCount,
+      cumulative_seconds: getSessionDuration()
     });
     return {
-        content: [
-            {
-                type: "text",
-                text: `Heartbeat sent. Session active for ${formatDuration(getSessionDuration())}.`,
-            },
-        ],
+      content: [
+        {
+          type: "text",
+          text: `Heartbeat recorded locally. Session active for ${formatDuration(getSessionDuration())}.`
+        }
+      ]
     };
-});
-// Tool 3: Session end / summary
-server.tool("useai_session_end", "End the current useai.dev tracking session with a summary. " +
-    "Call this when the conversation is wrapping up. " +
-    "Records duration, task type, and language stats — never any code or prompts.", {
-    task_type: z
-        .enum([
-        "coding",
-        "debugging",
-        "testing",
-        "planning",
-        "reviewing",
-        "documenting",
-        "learning",
-        "other",
-    ])
-        .optional()
-        .describe("What kind of task was the developer working on?"),
-    languages: z
-        .array(z.string())
-        .optional()
-        .describe("Programming languages used in this session (e.g. ['typescript', 'python'])"),
-    files_touched_count: z
-        .number()
-        .optional()
-        .describe("Approximate number of files created or modified (count only, no names)"),
-    tools_used_count: z
-        .number()
-        .optional()
-        .describe("Number of other MCP tools or commands invoked during this session"),
-}, async ({ task_type, languages, files_touched_count, tools_used_count }) => {
+  }
+);
+server.tool(
+  "useai_session_end",
+  "End the current AI coding session. Creates a cryptographically sealed session record and optionally records milestones \u2014 what was accomplished. Stats auto-sync to useai.dev daily. To publish milestones: run `useai publish` from the CLI. IMPORTANT: Milestone descriptions must be GENERIC. Do not include project names, file names, file paths, API endpoints, database names, company names, or any project-specific information. Use general terms like 'authentication system', 'data validation layer', 'responsive dashboard'. Think: would this description reveal what company or project this is for? If yes, make it more generic.",
+  {
+    task_type: z2.enum(["coding", "debugging", "testing", "planning", "reviewing", "documenting", "learning", "other"]).optional().describe("What kind of task was the developer working on?"),
+    languages: z2.array(z2.string()).optional().describe("Programming languages used (e.g. ['typescript', 'python'])"),
+    files_touched_count: z2.number().optional().describe("Approximate number of files created or modified (count only, no names)"),
+    milestones: z2.array(z2.object({
+      title: z2.string().describe("Generic description of what was accomplished. PRIVACY RULES: Do NOT include project names, repository names, file names, file paths, API endpoints, database names, company names, or any project-specific details. Use generic terms only. GOOD examples: 'Implemented user authentication', 'Fixed race condition in background worker', 'Added unit tests for data validation', 'Refactored state management layer', 'Built responsive dashboard layout'. BAD examples: 'Fixed bug in /api/stripe/webhooks', 'Added auth to acme-corp project', 'Updated UserService.ts in src/services/'"),
+      category: z2.enum(["feature", "bugfix", "refactor", "test", "docs", "setup", "deployment", "other"]).describe("Type of work completed"),
+      complexity: z2.enum(["simple", "medium", "complex"]).optional().describe("How complex was this task?")
+    })).optional().describe("What was accomplished this session? List each distinct piece of work completed. Describe generically \u2014 no project names, file names, or proprietary details.")
+  },
+  async ({ task_type, languages, files_touched_count, milestones: milestonesInput }) => {
     const duration = getSessionDuration();
-    await pushMetrics({
-        event: "session_end",
-        session_id: sessionId,
-        client: clientName,
-        duration_seconds: duration,
-        task_type: task_type ?? "coding",
-        languages: languages ?? [],
-        files_touched: files_touched_count ?? 0,
-        tools_used: tools_used_count ?? 0,
-        heartbeats: heartbeatCount,
-        timestamp: new Date().toISOString(),
-        version: VERSION,
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const finalTaskType = task_type ?? sessionTaskType;
+    const chainStartHash = chainTipHash === "GENESIS" ? "GENESIS" : chainTipHash;
+    const endRecord = appendToChain("session_end", {
+      duration_seconds: duration,
+      task_type: finalTaskType,
+      languages: languages ?? [],
+      files_touched: files_touched_count ?? 0,
+      heartbeat_count: heartbeatCount
     });
-    const durationStr = formatDuration(duration);
-    const taskLabel = task_type ?? "coding";
-    const langStr = languages && languages.length > 0
-        ? ` using ${languages.join(", ")}`
-        : "";
-    return {
-        content: [
-            {
-                type: "text",
-                text: `Session complete: ${durationStr} ${taskLabel} session on ${clientName}${langStr}. Logged to useai.dev.`,
-            },
-        ],
-    };
-});
-// Tool 4: View stats
-server.tool("useai_stats", "Show the developer's useai.dev stats — streak, total AI-paired hours, tool breakdown, and global rank. " +
-    "Call this when the developer asks about their AI usage stats or useai profile.", {}, async () => {
-    const token = process.env.USEAI_TOKEN;
-    if (!token) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: "useai.dev is not connected yet.\n\n" +
-                        "To get started:\n" +
-                        "1. Sign up at https://useai.dev\n" +
-                        '2. Set your token: USEAI_TOKEN="your-token" in your MCP config\n' +
-                        "3. Your AI coding sessions will be tracked automatically.\n\n" +
-                        "useai.dev tracks HOW MUCH you use AI tools, never WHAT you use them for.",
-                },
-            ],
-        };
-    }
+    const sealData = JSON.stringify({
+      session_id: sessionId,
+      client: clientName,
+      task_type: finalTaskType,
+      languages: languages ?? [],
+      files_touched: files_touched_count ?? 0,
+      started_at: new Date(sessionStartTime).toISOString(),
+      ended_at: now,
+      duration_seconds: duration,
+      heartbeat_count: heartbeatCount,
+      record_count: sessionRecordCount,
+      chain_end_hash: endRecord.hash
+    });
+    const sealSignature = signHash(
+      createHash3("sha256").update(sealData).digest("hex"),
+      signingKey
+    );
+    appendToChain("session_seal", {
+      seal: sealData,
+      seal_signature: sealSignature
+    });
+    const activePath = join4(ACTIVE_DIR, `${sessionId}.jsonl`);
+    const sealedPath = join4(SEALED_DIR, `${sessionId}.jsonl`);
     try {
-        const res = await fetch(`${USEAI_API}/stats`, {
-            headers: { Authorization: `Bearer ${token}` },
-            signal: AbortSignal.timeout(5000),
-        });
-        if (!res.ok) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "Could not fetch stats from useai.dev. The service may be temporarily unavailable.",
-                    },
-                ],
-            };
-        }
-        const stats = (await res.json());
-        const lines = [
-            `Your useai.dev Stats`,
-            `────────────────────`,
-        ];
-        if (stats.streak_days !== undefined)
-            lines.push(`Streak: ${stats.streak_days} days`);
-        if (stats.total_hours !== undefined)
-            lines.push(`Total AI-paired hours: ${stats.total_hours}h`);
-        if (stats.sessions_this_week !== undefined)
-            lines.push(`Sessions this week: ${stats.sessions_this_week}`);
-        if (stats.rank_percentile !== undefined)
-            lines.push(`Global rank: Top ${stats.rank_percentile}%`);
-        if (stats.top_tools && stats.top_tools.length > 0) {
-            lines.push(``, `Tool Breakdown:`);
-            for (const tool of stats.top_tools) {
-                const bar = "█".repeat(Math.round(tool.percentage / 5));
-                lines.push(`  ${tool.name.padEnd(14)} ${bar} ${tool.percentage}%`);
-            }
-        }
-        if (stats.profile_url) {
-            lines.push(``, `Profile: ${stats.profile_url}`);
-        }
-        return { content: [{ type: "text", text: lines.join("\n") }] };
+      if (existsSync4(activePath)) {
+        renameSync2(activePath, sealedPath);
+      }
+    } catch {
     }
-    catch {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: "Could not reach useai.dev. Check your connection.",
-                },
-            ],
-        };
-    }
-});
-// Tool 5: Share workflow (generates a shareable link)
-server.tool("useai_share", "Generate a shareable link for the developer's AI workflow on useai.dev. " +
-    "This creates a beautiful visual card of their AI tool stack that can be posted on Twitter, LinkedIn, etc.", {
-    title: z.string().optional().describe("Title for the workflow (e.g. 'My Full-Stack AI Workflow')"),
-    bio: z.string().optional().describe("Short bio or role (e.g. 'Senior TypeScript Developer')"),
-}, async ({ title, bio }) => {
-    const token = process.env.USEAI_TOKEN;
-    if (!token) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: "Connect to useai.dev first to share your workflow.\n" +
-                        "Sign up at https://useai.dev and set USEAI_TOKEN in your MCP config.",
-                },
-            ],
-        };
-    }
-    try {
-        const res = await fetch(`${USEAI_API}/workflows/share`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${token}`,
-            },
-            body: JSON.stringify({
-                title: title ?? "My AI Development Workflow",
-                bio: bio ?? "",
-                client: clientName,
-                timestamp: new Date().toISOString(),
-            }),
-            signal: AbortSignal.timeout(5000),
-        });
-        if (!res.ok) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "Could not generate share link. The service may be temporarily unavailable.",
-                    },
-                ],
-            };
+    const seal = {
+      session_id: sessionId,
+      client: clientName,
+      task_type: finalTaskType,
+      languages: languages ?? [],
+      files_touched: files_touched_count ?? 0,
+      started_at: new Date(sessionStartTime).toISOString(),
+      ended_at: now,
+      duration_seconds: duration,
+      heartbeat_count: heartbeatCount,
+      record_count: sessionRecordCount,
+      chain_start_hash: chainStartHash,
+      chain_end_hash: endRecord.hash,
+      seal_signature: sealSignature
+    };
+    const sessions = getSessions();
+    sessions.push(seal);
+    writeJson(SESSIONS_FILE, sessions);
+    let milestoneCount = 0;
+    if (milestonesInput && milestonesInput.length > 0) {
+      const config = getConfig();
+      if (config.milestone_tracking) {
+        const durationMinutes = Math.round(duration / 60);
+        const allMilestones = getMilestones();
+        for (const m of milestonesInput) {
+          const record = appendToChain("milestone", {
+            title: m.title,
+            category: m.category,
+            complexity: m.complexity ?? "medium",
+            duration_minutes: durationMinutes,
+            languages: languages ?? []
+          });
+          const milestone = {
+            id: `m_${randomUUID3().slice(0, 8)}`,
+            session_id: sessionId,
+            title: m.title,
+            category: m.category,
+            complexity: m.complexity ?? "medium",
+            duration_minutes: durationMinutes,
+            languages: languages ?? [],
+            client: clientName,
+            created_at: (/* @__PURE__ */ new Date()).toISOString(),
+            published: false,
+            published_at: null,
+            chain_hash: record.hash
+          };
+          allMilestones.push(milestone);
+          milestoneCount++;
         }
-        const data = (await res.json());
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Your workflow is ready to share!\n\n` +
-                        `Link: ${data.workflow_url ?? "https://useai.dev/workflows"}\n\n` +
-                        `Share on:\n` +
-                        `- Twitter: https://twitter.com/intent/tweet?text=${encodeURIComponent(data.share_text ?? "Check out my AI development workflow")}&url=${encodeURIComponent(data.workflow_url ?? "https://useai.dev")}\n` +
-                        `- LinkedIn: https://www.linkedin.com/sharing/share-offsite/?url=${encodeURIComponent(data.workflow_url ?? "https://useai.dev")}`,
-                },
-            ],
-        };
-    }
-    catch {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: "Could not reach useai.dev. Check your connection.",
-                },
-            ],
-        };
+        writeJson(MILESTONES_FILE, allMilestones);
+      }
     }
-});
-// Start the server
+    const durationStr = formatDuration(duration);
+    const langStr = languages && languages.length > 0 ? ` using ${languages.join(", ")}` : "";
+    const milestoneStr = milestoneCount > 0 ? ` \xB7 ${milestoneCount} milestone${milestoneCount > 1 ? "s" : ""} recorded` : "";
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Session sealed: ${durationStr} ${finalTaskType} on ${clientName}${langStr}
+${sessionRecordCount} chain records \xB7 ${signingAvailable ? "Ed25519 signed" : "unsigned"}${milestoneStr}
+Stored at: ${sealedPath}
+
+To publish: run \`useai sync\` from your terminal.`
+        }
+      ]
+    };
+  }
+);
 async function main() {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
+  ensureDir();
+  try {
+    initializeKeystore();
+  } catch {
+  }
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
 }
 main().catch((error) => {
-    console.error("useai MCP server failed to start:", error);
-    process.exit(1);
+  console.error("useai MCP server failed to start:", error);
+  process.exit(1);
 });
-//# sourceMappingURL=index.js.map