artemys 0.2.0 → 0.2.1

package/dist/cli/index.js

@@ -1,434 +1,501 @@
 #!/usr/bin/env node
-import * as readline from "node:readline/promises";
-import * as fs from "node:fs/promises";
-import * as fsSync from "node:fs";
-import * as path from "node:path";
-import { stdin, stdout } from "node:process";
-import { fileURLToPath } from "node:url";
-const ARTEMYS_DIR = path.join(process.env.HOME ?? "~", ".artemys");
-const CONFIG_PATH = path.join(ARTEMYS_DIR, "config.json");
-function templatesDir() {
-    return path.join(path.dirname(fileURLToPath(import.meta.url)), "templates");
-}
-async function onboard() {
-    const existing = await readRawConfig();
-    const rl = readline.createInterface({ input: stdin, output: stdout });
-    console.log("\nArtemys onboarding — configure your Artie runtime.\n");
-    const apiKey = await askWithDefault(rl, "Anthropic API key (or press Enter to skip)", asString(existing.anthropic_api_key) ?? "");
-    const openaiKey = await askWithDefault(rl, "OpenAI API key (optional, press Enter to skip)", asString(existing.openai_api_key) ?? "");
-    const botToken = await askRequired(rl, "Telegram bot token", asString(existing.telegram_bot_token));
-    const model = await askWithDefault(rl, "Default model (provider:model)", asString(existing.model) ?? "anthropic:claude-haiku-4-5-20251001");
-    const storagePath = await askWithDefault(rl, "Session storage path", asString(existing.storage_path) ?? "~/.artemys/sessions");
-    rl.close();
-    await fs.mkdir(ARTEMYS_DIR, { recursive: true });
-    const config = {
-        ...existing,
-        telegram_bot_token: botToken,
-        model,
-        storage_path: storagePath,
-    };
-    if (apiKey)
-        config.anthropic_api_key = apiKey;
-    if (openaiKey)
-        config.openai_api_key = openaiKey;
-    await fs.writeFile(CONFIG_PATH, JSON.stringify(config, null, 2));
-    await copyTemplate(templatesDir(), "PROFILE.md");
-    await copyTemplate(templatesDir(), "PREFERENCES.md");
-    await copyTemplate(templatesDir(), "SOUL.md");
-    await copyTemplate(templatesDir(), "MEMORY.md");
-    await copyTemplate(templatesDir(), "HEARTBEAT.md");
-    await fs.mkdir(expandPath(storagePath), { recursive: true });
-    console.log(`\nConfiguration saved to ${CONFIG_PATH}`);
-    console.log("Templates saved to ~/.artemys/");
-    console.log("\nNext steps:");
-    console.log("  1. Edit ~/.artemys/PROFILE.md with your professional info");
-    console.log("  2. Edit ~/.artemys/PREFERENCES.md with your job preferences");
-    console.log("  3. Edit ~/.artemys/SOUL.md to customize Artie's personality");
-    console.log("  4. Run: artemys doctor");
-    console.log("  5. Run: artemys start\n");
+import { readFile } from "node:fs/promises";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+import { CoffeeShopClient } from "../coffeeshop/index.js";
+import { AgentCardSchema, DiscoveryQuerySchema, } from "../discovery/index.js";
+import { ConversationTracker, ProfileStore, SqliteMcpPersistence, createPersistentConversationTracker, createPersistentProfileStore, startArtemysMcpServer, } from "../mcp-server/index.js";
+import { registerTalentTools } from "../mcp-server/tools/talent.js";
+import { ProtocolTransportClient } from "../transport/index.js";
+const DEFAULT_COFFEESHOP_URL = "https://coffeeshop.artemys.ai";
+const DEFAULT_MAX_TRACKED_CONVERSATIONS = 1_000;
+const DEFAULT_CONVERSATION_TTL_MS = 24 * 60 * 60 * 1000;
+function parseArgs(argv) {
+    const positionals = [];
+    const flags = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (!token.startsWith("--")) {
+            positionals.push(token);
+            continue;
+        }
+        const key = token.slice(2);
+        const next = argv[index + 1];
+        if (!next || next.startsWith("--")) {
+            flags[key] = true;
+            continue;
+        }
+        if (key === "capability") {
+            const current = flags[key];
+            if (Array.isArray(current)) {
+                current.push(next);
+            }
+            else if (typeof current === "string") {
+                flags[key] = [current, next];
+            }
+            else {
+                flags[key] = [next];
+            }
+        }
+        else {
+            flags[key] = next;
+        }
+        index += 1;
+    }
+    return { positionals, flags };
 }
-async function init() {
-    await onboard();
+function getFlagString(flags, key) {
+    const value = flags[key];
+    return typeof value === "string" ? value : undefined;
 }
-async function start() {
-    const { loadConfig } = await import("../agent/config.js");
-    const { ArtemysRuntime } = await import("../agent/runtime.js");
-    const { TelegramAdapter } = await import("../channels/telegram.js");
-    let config;
-    try {
-        config = await loadConfig();
+function getFlagBoolean(flags, key) {
+    const value = flags[key];
+    if (typeof value === "boolean") {
+        return value;
     }
-    catch (err) {
-        if (err instanceof Error && err.name === "ZodError") {
-            console.error(`\nConfiguration error: missing or invalid fields in ~/.artemys/config.json`);
-            console.error("Run 'artemys onboard' to set up your configuration.\n");
-            process.exit(1);
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === "true") {
+            return true;
+        }
+        if (normalized === "false") {
+            return false;
         }
-        throw err;
     }
-    const runtime = new ArtemysRuntime(config);
-    const telegram = new TelegramAdapter(config.telegram_bot_token);
-    try {
-        await runtime.start([telegram]);
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        if (msg.includes("404") || msg.includes("401") || msg.includes("Not Found")) {
-            console.error(`\nFailed to connect to Telegram: invalid bot token.`);
-            console.error("Check your token in ~/.artemys/config.json and try again.\n");
-            process.exit(1);
+    return undefined;
+}
+function getPersistOption(flags) {
+    const value = flags.persist;
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed.length === 0) {
+            return true;
         }
-        throw err;
+        const normalized = trimmed.toLowerCase();
+        if (normalized === "true") {
+            return true;
+        }
+        if (normalized === "false") {
+            return false;
+        }
+        return trimmed;
     }
-    console.log("\nArtie is online — listening on Telegram");
-    console.log("Press Ctrl+C to stop\n");
-    const shutdown = async () => {
-        console.log("\nShutting down...");
-        await runtime.stop();
-        process.exit(0);
-    };
-    process.on("SIGINT", shutdown);
-    process.on("SIGTERM", shutdown);
+    return undefined;
+}
+function getCsvFlagList(flags, key) {
+    const value = getFlagString(flags, key);
+    if (!value) {
+        return undefined;
+    }
+    const items = value
+        .split(",")
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+    return items.length > 0 ? items : undefined;
 }
 function printHelp() {
     console.log(`
-artemys — Run your own Artie agent
+artemys - Protocol + Coffee Shop + MCP Server SDK CLI
 
 Commands:
-  onboard  Guided setup for keys, model, and templates
-  init     Alias for onboard
-  doctor   Validate local config and safety checks
-  start    Start the agent (connects to Telegram)
+  mcp-server   Start Artemys MCP server
+  talent       Candidate talent workflow commands
+  register     Register an agent card with Coffee Shop
+  discover     Discover agents via Coffee Shop
+  rotate-key   Rotate Coffee Shop API key
+  intro-events Show intro lifecycle events
+  version      Show CLI version
+  help         Show this help message
+
+Examples:
+  artemys mcp-server --agent-card ./agent-card.json
+  artemys mcp-server --agent-card ./agent-card.json --persist
+  artemys register --agent-card ./agent-card.json
+  artemys discover --requester-agent-id agent-123 --role talent_agent
+  artemys talent search --agent-card ./agent-card.json --role-keywords backend,platform --remote-ok
+  artemys talent apply --agent-card ./agent-card.json --target-agent-id talent-1 --target-endpoint https://talent.example.com/messages --job-posting-ref job-123 --persist
+  artemys talent profile --agent-card ./agent-card.json --profile-file ./candidate-profile.json --persist
+  artemys rotate-key --agent-id agent-123 --api-key old-key
+  artemys intro-events --intro-id intro-abc --api-key key
+`);
+}
+function printTalentHelp() {
+    console.log(`
+artemys talent - Candidate talent workflow commands
+
+Subcommands:
+  search   Discover opportunities from talent agents
+  apply    Express interest in a specific job posting
+  status   Check tracked conversation status
+  profile  Update stored candidate profile
   help     Show this help message
 
-Setup:
-  1. artemys onboard
-  2. Edit ~/.artemys/PROFILE.md
-  3. Edit ~/.artemys/PREFERENCES.md
-  4. artemys doctor
-  5. artemys start
+Examples:
+  artemys talent search --agent-card ./agent-card.json --role-keywords backend,platform --remote-ok --limit 20
+  artemys talent apply --agent-card ./agent-card.json --target-agent-id talent-1 --target-endpoint https://talent.example.com/messages --job-posting-ref job-123 --match-reasoning "Strong backend fit"
+  artemys talent status --agent-card ./agent-card.json --status-filter dialogue_active --persist
+  artemys talent profile --agent-card ./agent-card.json --profile-file ./candidate-profile.json --sync-agent-card --persist ~/.artemys/state.db
+
+Common flags:
+  --agent-card <path>      Required for all talent subcommands except help
+  --coffeeshop-url <url>   Override Coffee Shop base URL
+  --persist [path]         Persist profile + conversations to SQLite (default: ~/.artemys/state.db)
 `);
 }
-function parseDoctorOptions(argv) {
+async function readAgentCardFromPath(pathValue) {
+    const raw = await readFile(pathValue, "utf-8");
+    const parsed = JSON.parse(raw);
+    return AgentCardSchema.parse(parsed);
+}
+function buildNetworkDeps(args, agentCard) {
+    const coffeeShopUrl = getFlagString(args.flags, "coffeeshop-url") ?? DEFAULT_COFFEESHOP_URL;
+    const hasCoffeeShopApiKey = typeof process.env.ARTEMYS_COFFEESHOP_API_KEY === "string" &&
+        process.env.ARTEMYS_COFFEESHOP_API_KEY.length > 0;
+    const coffeeShopClient = new CoffeeShopClient({
+        baseUrl: coffeeShopUrl,
+        apiKey: process.env.ARTEMYS_COFFEESHOP_API_KEY,
+        agentId: agentCard.agent_id,
+    });
+    const transportClient = new ProtocolTransportClient({
+        agentId: agentCard.agent_id,
+        getSharedSecret: loadSharedSecretResolver({
+            coffeeShopClient: hasCoffeeShopApiKey ? coffeeShopClient : undefined,
+        }),
+    });
     return {
-        fix: argv.includes("--fix"),
-        json: argv.includes("--json"),
+        coffeeShopClient,
+        transportClient,
+        hasCoffeeShopApiKey,
     };
 }
-async function doctor(options) {
-    const checks = await runDoctorChecks(options);
-    const failing = checks.filter((check) => check.status === "fail");
-    const criticalFailures = failing.filter((check) => check.severity === "critical");
-    if (options.json) {
-        console.log(JSON.stringify({
-            healthy: failing.length === 0,
-            failures: failing.length,
-            critical_failures: criticalFailures.length,
-            checks,
-        }, null, 2));
-    }
-    else {
-        console.log("\nArtemys doctor\n");
-        for (const check of checks) {
-            const icon = check.status === "pass" ? "PASS" : "FAIL";
-            const fix = check.fixable
-                ? check.fixed
-                    ? " (fixed)"
-                    : " (fixable with --fix)"
-                : "";
-            const target = check.path ? ` [${check.path}]` : "";
-            console.log(`${icon} [${check.severity}] ${check.id}: ${check.message}${fix}${target}`);
-        }
-        console.log("");
-        if (failing.length === 0) {
-            console.log("Doctor check passed: runtime looks healthy.\n");
-        }
-        else {
-            console.log(`Doctor found ${failing.length} issue(s), including ${criticalFailures.length} critical.`);
-            console.log("Use `artemys doctor --fix` to apply safe automatic repairs.\n");
-        }
-    }
-    if (failing.length > 0) {
-        process.exit(1);
+function buildTalentState(flags) {
+    const persistOption = getPersistOption(flags);
+    if (!persistOption) {
+        return {
+            tracker: new ConversationTracker({
+                maxConversations: DEFAULT_MAX_TRACKED_CONVERSATIONS,
+                conversationTtlMs: DEFAULT_CONVERSATION_TTL_MS,
+            }),
+            profileStore: new ProfileStore(),
+            close: () => { },
+        };
     }
-}
-async function runDoctorChecks(options) {
-    const checks = [];
-    const configExists = await pathExists(CONFIG_PATH);
-    checks.push({
-        id: "config.exists",
-        severity: "critical",
-        status: configExists ? "pass" : "fail",
-        message: configExists
-            ? "Config file exists"
-            : "Config file is missing. Run `artemys onboard` first.",
-        path: CONFIG_PATH,
-        fixable: false,
-        fixed: false,
+    const persistence = new SqliteMcpPersistence({
+        path: typeof persistOption === "string" ? persistOption : undefined,
     });
-    if (!configExists) {
-        return checks;
+    return {
+        tracker: createPersistentConversationTracker(persistence, {
+            maxConversations: DEFAULT_MAX_TRACKED_CONVERSATIONS,
+            conversationTtlMs: DEFAULT_CONVERSATION_TTL_MS,
+        }),
+        profileStore: createPersistentProfileStore(persistence),
+        close: () => {
+            persistence.close();
+        },
+    };
+}
+function buildTalentToolHandlers(deps) {
+    const handlers = new Map();
+    registerTalentTools({
+        registerTool: (name, _config, handler) => {
+            handlers.set(name, handler);
+        },
+    }, deps);
+    return handlers;
+}
+function extractToolResponseData(response) {
+    const structuredData = response.structuredContent?.data;
+    if (structuredData !== undefined) {
+        return structuredData;
+    }
+    const textContent = response.content[0]?.text;
+    if (typeof textContent !== "string" || textContent.length === 0) {
+        return null;
     }
-    let rawConfig;
     try {
-        const raw = await fs.readFile(CONFIG_PATH, "utf-8");
-        rawConfig = JSON.parse(raw);
-        checks.push({
-            id: "config.valid_json",
-            severity: "critical",
-            status: "pass",
-            message: "Config JSON is valid",
-            path: CONFIG_PATH,
-            fixable: false,
-            fixed: false,
-        });
+        return JSON.parse(textContent);
     }
     catch {
-        checks.push({
-            id: "config.valid_json",
-            severity: "critical",
-            status: "fail",
-            message: "Config file is not valid JSON",
-            path: CONFIG_PATH,
-            fixable: false,
-            fixed: false,
-        });
-        return checks;
-    }
-    // At least one provider auth required
-    const hasAnthropic = !!asString(rawConfig.anthropic_api_key) || !!asString(rawConfig.anthropic_auth_token);
-    const hasOpenai = !!asString(rawConfig.openai_api_key) || !!asString(rawConfig.openai_auth_token);
-    checks.push({
-        id: "config.required.provider_auth",
-        severity: "critical",
-        status: hasAnthropic || hasOpenai ? "pass" : "fail",
-        message: hasAnthropic || hasOpenai
-            ? `Provider auth configured (anthropic: ${hasAnthropic}, openai: ${hasOpenai})`
-            : "No provider auth configured. Set at least one of: anthropic_api_key, openai_api_key",
-        path: CONFIG_PATH,
-        fixable: false,
-        fixed: false,
-    });
-    const botToken = asString(rawConfig.telegram_bot_token);
-    checks.push({
-        id: "config.required.telegram_bot_token",
-        severity: "critical",
-        status: botToken ? "pass" : "fail",
-        message: botToken ? "telegram_bot_token is set" : "telegram_bot_token is missing or empty",
-        path: CONFIG_PATH,
-        fixable: false,
-        fixed: false,
-    });
-    // Validate model string has provider prefix
-    const model = asString(rawConfig.model) ?? "anthropic:claude-haiku-4-5-20251001";
-    checks.push({
-        id: "config.model_format",
-        severity: "warning",
-        status: model.includes(":") ? "pass" : "fail",
-        message: model.includes(":")
-            ? `Model is provider-prefixed: ${model}`
-            : `Model "${model}" should be provider-prefixed (e.g. "anthropic:claude-haiku-4-5-20251001")`,
-        fixable: false,
-        fixed: false,
-    });
-    const profilePath = expandPath(asString(rawConfig.profile_path) ?? "~/.artemys/PROFILE.md");
-    const preferencesPath = expandPath(asString(rawConfig.preferences_path) ?? "~/.artemys/PREFERENCES.md");
-    const soulPath = path.join(ARTEMYS_DIR, "SOUL.md");
-    const storagePath = expandPath(asString(rawConfig.storage_path) ?? "~/.artemys/sessions");
-    checks.push(await ensureFileCheck({
-        id: "files.profile",
-        targetPath: profilePath,
-        templateName: "PROFILE.md",
-        options,
-        message: "Profile file exists",
-    }));
-    checks.push(await ensureFileCheck({
-        id: "files.preferences",
-        targetPath: preferencesPath,
-        templateName: "PREFERENCES.md",
-        options,
-        message: "Preferences file exists",
-    }));
-    checks.push(await ensureFileCheck({
-        id: "files.soul",
-        targetPath: soulPath,
-        templateName: "SOUL.md",
-        options,
-        message: "Soul file exists",
-    }));
-    const storageExists = await pathExists(storagePath);
-    let storageFixed = false;
-    if (!storageExists && options.fix) {
-        await fs.mkdir(storagePath, { recursive: true });
-        storageFixed = true;
-    }
-    checks.push({
-        id: "storage.exists",
-        severity: "warning",
-        status: storageExists || storageFixed ? "pass" : "fail",
-        message: storageExists || storageFixed
-            ? "Session storage directory exists"
-            : "Session storage directory is missing",
-        path: storagePath,
-        fixable: true,
-        fixed: storageFixed,
-    });
-    const writable = await isWritable(storagePath);
-    checks.push({
-        id: "storage.writable",
-        severity: "critical",
-        status: writable ? "pass" : "fail",
-        message: writable
-            ? "Session storage directory is writable"
-            : "Session storage directory is not writable",
-        path: storagePath,
-        fixable: false,
-        fixed: false,
-    });
-    if (process.platform !== "win32") {
-        const mode = await fileMode(CONFIG_PATH);
-        const permissive = mode !== null ? (mode & 0o077) > 0 : false;
-        let fixed = false;
-        if (permissive && options.fix) {
-            await fs.chmod(CONFIG_PATH, 0o600);
-            fixed = true;
-        }
-        checks.push({
-            id: "config.permissions",
-            severity: "warning",
-            status: permissive && !fixed ? "fail" : "pass",
-            message: permissive && !fixed
-                ? "Config permissions are too open; recommend chmod 600"
-                : "Config permissions are restricted",
-            path: CONFIG_PATH,
-            fixable: true,
-            fixed,
-        });
+        return textContent;
     }
-    return checks;
 }
-async function ensureFileCheck(params) {
-    const exists = await pathExists(params.targetPath);
-    let fixed = false;
-    if (!exists && params.options.fix) {
-        await fs.mkdir(path.dirname(params.targetPath), { recursive: true });
-        const templateContent = await fs.readFile(path.join(templatesDir(), params.templateName), "utf-8");
-        await fs.writeFile(params.targetPath, templateContent);
-        fixed = true;
+async function invokeTalentTool(handlers, toolName, args) {
+    const handler = handlers.get(toolName);
+    if (!handler) {
+        throw new Error(`Talent tool '${toolName}' is unavailable`);
     }
-    return {
-        id: params.id,
-        severity: "warning",
-        status: exists || fixed ? "pass" : "fail",
-        message: exists || fixed ? params.message : `${params.message.replace("exists", "is missing")}`,
-        path: params.targetPath,
-        fixable: true,
-        fixed,
-    };
+    const response = await handler(args);
+    return extractToolResponseData(response);
 }
-async function pathExists(filePath) {
-    try {
-        await fs.access(filePath);
-        return true;
+async function registerCommand(args) {
+    const cardPath = getFlagString(args.flags, "agent-card");
+    if (!cardPath) {
+        throw new Error("Missing required --agent-card <path>");
     }
-    catch {
-        return false;
+    const card = await readAgentCardFromPath(cardPath);
+    const coffeeShopUrl = getFlagString(args.flags, "coffeeshop-url") ?? DEFAULT_COFFEESHOP_URL;
+    const client = new CoffeeShopClient({ baseUrl: coffeeShopUrl });
+    const result = await client.register(card);
+    console.log(JSON.stringify(result, null, 2));
+    console.log("Save api_key now. It is only returned at registration time.");
+}
+async function discoverCommand(args) {
+    const requesterAgentId = getFlagString(args.flags, "requester-agent-id");
+    if (!requesterAgentId) {
+        throw new Error("Missing required --requester-agent-id <agent-id>");
     }
+    const role = getFlagString(args.flags, "role");
+    const protocolVersion = getFlagString(args.flags, "protocol-version");
+    const limitRaw = getFlagString(args.flags, "limit");
+    const capabilitiesRaw = args.flags.capability;
+    const capabilities = Array.isArray(capabilitiesRaw)
+        ? capabilitiesRaw
+        : typeof capabilitiesRaw === "string"
+            ? [capabilitiesRaw]
+            : undefined;
+    const query = DiscoveryQuerySchema.parse({
+        requester_agent_id: requesterAgentId,
+        ...(role ? { role } : {}),
+        ...(protocolVersion ? { protocol_version: protocolVersion } : {}),
+        ...(capabilities ? { capabilities_any: capabilities } : {}),
+        ...(limitRaw ? { limit: Number.parseInt(limitRaw, 10) } : {}),
+    });
+    const coffeeShopUrl = getFlagString(args.flags, "coffeeshop-url") ?? DEFAULT_COFFEESHOP_URL;
+    const client = new CoffeeShopClient({ baseUrl: coffeeShopUrl });
+    const results = await client.discover(query);
+    console.log(JSON.stringify(results, null, 2));
 }
-async function isWritable(filePath) {
-    try {
-        await fs.access(filePath, fsSync.constants.W_OK);
-        return true;
+async function rotateKeyCommand(args) {
+    const agentId = getFlagString(args.flags, "agent-id");
+    if (!agentId) {
+        throw new Error("Missing required --agent-id <agent-id>");
     }
-    catch {
-        return false;
+    const apiKey = getFlagString(args.flags, "api-key");
+    if (!apiKey) {
+        throw new Error("Missing required --api-key <api-key>");
     }
+    const coffeeShopUrl = getFlagString(args.flags, "coffeeshop-url") ?? DEFAULT_COFFEESHOP_URL;
+    const client = new CoffeeShopClient({
+        baseUrl: coffeeShopUrl,
+        apiKey,
+        agentId,
+    });
+    const result = await client.rotateApiKey();
+    console.log(JSON.stringify(result, null, 2));
+    console.log("Save api_key now. It is only returned at rotation time.");
 }
-async function fileMode(filePath) {
-    try {
-        const stat = await fs.stat(filePath);
-        return stat.mode;
+async function introEventsCommand(args) {
+    const introId = getFlagString(args.flags, "intro-id");
+    if (!introId) {
+        throw new Error("Missing required --intro-id <intro-id>");
     }
-    catch {
-        return null;
+    const apiKey = getFlagString(args.flags, "api-key");
+    if (!apiKey) {
+        throw new Error("Missing required --api-key <api-key>");
     }
+    const coffeeShopUrl = getFlagString(args.flags, "coffeeshop-url") ?? DEFAULT_COFFEESHOP_URL;
+    const client = new CoffeeShopClient({
+        baseUrl: coffeeShopUrl,
+        apiKey,
+    });
+    const events = await client.listIntroEvents(introId);
+    console.log(JSON.stringify(events, null, 2));
 }
-async function readRawConfig() {
-    try {
-        const raw = await fs.readFile(CONFIG_PATH, "utf-8");
-        return JSON.parse(raw);
+function loadSharedSecretResolver(options) {
+    const fallbackSecret = process.env.ARTEMYS_SHARED_SECRET;
+    const fromMap = process.env.ARTEMYS_SHARED_SECRETS;
+    const parsedMap = fromMap ? JSON.parse(fromMap) : {};
+    return async (targetHint) => {
+        const mapped = parsedMap[targetHint];
+        if (mapped) {
+            return mapped;
+        }
+        if (fallbackSecret) {
+            return fallbackSecret;
+        }
+        if (options.coffeeShopClient) {
+            const resolved = await options.coffeeShopClient.resolveTransportSharedSecret(targetHint);
+            return resolved.value;
+        }
+        throw new Error(`No shared secret found for '${targetHint}'. Set ARTEMYS_SHARED_SECRETS/ARTEMYS_SHARED_SECRET or provide ARTEMYS_COFFEESHOP_API_KEY with accepted intro bootstrap.`);
+    };
+}
+async function mcpServerCommand(args) {
+    const cardPath = getFlagString(args.flags, "agent-card");
+    if (!cardPath) {
+        throw new Error("Missing required --agent-card <path>");
     }
-    catch {
-        return {};
+    const transport = getFlagString(args.flags, "transport") === "sse" ? "sse" : "stdio";
+    const portRaw = getFlagString(args.flags, "port");
+    const port = portRaw ? Number.parseInt(portRaw, 10) : 3100;
+    const persist = getPersistOption(args.flags);
+    const agentCard = await readAgentCardFromPath(cardPath);
+    const { coffeeShopClient, transportClient, hasCoffeeShopApiKey } = buildNetworkDeps(args, agentCard);
+    const started = await startArtemysMcpServer({
+        agentCard,
+        coffeeShopClient,
+        transportClient,
+        transport,
+        port,
+        ...(persist ? { persist } : {}),
+        enableIntroTools: hasCoffeeShopApiKey,
+    });
+    if (!hasCoffeeShopApiKey) {
+        console.error("Artemys MCP intro tools disabled (set ARTEMYS_COFFEESHOP_API_KEY to enable intro APIs)");
     }
-}
-function asString(value) {
-    if (typeof value !== "string") {
-        return undefined;
+    if (transport === "sse") {
+        console.error(`Artemys MCP server listening on http://127.0.0.1:${port}/mcp`);
     }
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : undefined;
+    const shutdown = async () => {
+        await started.close();
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
 }
-function expandPath(p) {
-    if (p === "~") {
-        return process.env.HOME ?? p;
+async function talentCommand(args) {
+    const subcommand = args.positionals[1] ?? "help";
+    if (subcommand === "help") {
+        printTalentHelp();
+        return;
     }
-    if (p.startsWith("~/")) {
-        return path.join(process.env.HOME ?? "~", p.slice(2));
+    const cardPath = getFlagString(args.flags, "agent-card");
+    if (!cardPath) {
+        throw new Error("Missing required --agent-card <path>");
     }
-    return p;
-}
-async function askRequired(rl, label, existingValue) {
-    while (true) {
-        const prompt = existingValue
-            ? `${label} [set, press Enter to keep current]: `
-            : `${label}: `;
-        const input = (await rl.question(prompt)).trim();
-        if (input.length > 0) {
-            return input;
+    const agentCard = await readAgentCardFromPath(cardPath);
+    const { coffeeShopClient, transportClient, hasCoffeeShopApiKey } = buildNetworkDeps(args, agentCard);
+    const state = buildTalentState(args.flags);
+    try {
+        const handlers = buildTalentToolHandlers({
+            coffeeShopClient,
+            transportClient,
+            tracker: state.tracker,
+            profileStore: state.profileStore,
+            agentCard,
+            introToolsEnabled: hasCoffeeShopApiKey,
+        });
+        if (subcommand === "search") {
+            const roleKeywords = getCsvFlagList(args.flags, "role-keywords");
+            const location = getFlagString(args.flags, "location");
+            const remoteOk = getFlagBoolean(args.flags, "remote-ok");
+            const seniority = getFlagString(args.flags, "seniority");
+            const limitRaw = getFlagString(args.flags, "limit");
+            const data = await invokeTalentTool(handlers, "search_opportunities", {
+                ...(roleKeywords ? { role_keywords: roleKeywords } : {}),
+                ...(location ? { location } : {}),
+                ...(typeof remoteOk === "boolean" ? { remote_ok: remoteOk } : {}),
+                ...(seniority ? { seniority } : {}),
+                ...(limitRaw ? { limit: Number.parseInt(limitRaw, 10) } : {}),
+            });
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        if (subcommand === "apply") {
+            const targetAgentId = getFlagString(args.flags, "target-agent-id");
+            const targetEndpoint = getFlagString(args.flags, "target-endpoint");
+            const jobPostingRef = getFlagString(args.flags, "job-posting-ref");
+            if (!targetAgentId) {
+                throw new Error("Missing required --target-agent-id <agent-id>");
+            }
+            if (!targetEndpoint) {
+                throw new Error("Missing required --target-endpoint <url>");
+            }
+            if (!jobPostingRef) {
+                throw new Error("Missing required --job-posting-ref <job-ref>");
+            }
+            const matchReasoning = getFlagString(args.flags, "match-reasoning");
+            const data = await invokeTalentTool(handlers, "express_interest", {
+                target_agent_id: targetAgentId,
+                target_endpoint: targetEndpoint,
+                job_posting_ref: jobPostingRef,
+                ...(matchReasoning ? { match_reasoning: matchReasoning } : {}),
+            });
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        if (subcommand === "status") {
+            const statusFilter = getFlagString(args.flags, "status-filter");
+            const data = await invokeTalentTool(handlers, "check_conversations", {
+                ...(statusFilter ? { status_filter: statusFilter } : {}),
+            });
+            console.log(JSON.stringify(data, null, 2));
+            return;
         }
-        if (existingValue) {
-            return existingValue;
+        if (subcommand === "profile") {
+            const profilePath = getFlagString(args.flags, "profile-file");
+            if (!profilePath) {
+                throw new Error("Missing required --profile-file <path>");
+            }
+            const profileRaw = await readFile(profilePath, "utf-8");
+            const parsedProfile = JSON.parse(profileRaw);
+            if (!parsedProfile || typeof parsedProfile !== "object" || Array.isArray(parsedProfile)) {
+                throw new Error("Profile file must contain a JSON object");
+            }
+            const syncAgentCard = getFlagBoolean(args.flags, "sync-agent-card");
+            const data = await invokeTalentTool(handlers, "update_profile", {
+                ...parsedProfile,
+                ...(typeof syncAgentCard === "boolean" ? { sync_agent_card: syncAgentCard } : {}),
+            });
+            console.log(JSON.stringify(data, null, 2));
+            return;
         }
-        console.log(`${label} is required.`);
+        throw new Error(`Unknown talent subcommand: ${subcommand}`);
+    }
+    finally {
+        state.close();
     }
 }
-async function askWithDefault(rl, label, defaultValue) {
-    const input = (await rl.question(`${label} [${defaultValue}]: `)).trim();
-    return input.length > 0 ? input : defaultValue;
+async function versionCommand() {
+    const packageJsonPath = new URL("../../package.json", import.meta.url);
+    const raw = await readFile(packageJsonPath, "utf-8");
+    const pkg = JSON.parse(raw);
+    console.log(pkg.version);
 }
-async function copyTemplate(templatesDir, filename) {
-    const src = path.join(templatesDir, filename);
-    const dest = path.join(ARTEMYS_DIR, filename);
-    try {
-        await fs.access(dest);
-        console.log(`  Skipping ${filename} (already exists)`);
+export async function runCli(argv = process.argv.slice(2)) {
+    const args = parseArgs(argv);
+    const command = args.positionals[0] ?? "help";
+    if (command === "help") {
+        printHelp();
+        return;
     }
-    catch {
-        const content = await fs.readFile(src, "utf-8");
-        await fs.writeFile(dest, content);
+    if (command === "version") {
+        await versionCommand();
+        return;
     }
-}
-async function main() {
-    const command = process.argv[2];
-    switch (command) {
-        case "onboard":
-            return await onboard();
-        case "init":
-            return await init();
-        case "doctor":
-            return await doctor(parseDoctorOptions(process.argv.slice(3)));
-        case "start":
-            return await start();
-        case "help":
-        default:
-            return printHelp();
+    if (command === "register") {
+        await registerCommand(args);
+        return;
+    }
+    if (command === "discover") {
+        await discoverCommand(args);
+        return;
+    }
+    if (command === "rotate-key") {
+        await rotateKeyCommand(args);
+        return;
     }
+    if (command === "intro-events") {
+        await introEventsCommand(args);
+        return;
+    }
+    if (command === "mcp-server") {
+        await mcpServerCommand(args);
+        return;
+    }
+    if (command === "talent") {
+        await talentCommand(args);
+        return;
+    }
+    throw new Error(`Unknown command: ${command}`);
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    runCli().catch((error) => {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    });
 }
-main().catch((err) => {
-    console.error(`\nError: ${err instanceof Error ? err.message : String(err)}`);
-    if (process.env.DEBUG)
-        console.error(err);
-    process.exit(1);
-});
 //# sourceMappingURL=index.js.map