@salestouch/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,937 @@
+#!/usr/bin/env node
+import path from "node:path";
+import process from "node:process";
+import { readFile } from "node:fs/promises";
+import { log, note, outro, spinner } from "@clack/prompts";
+import pc from "picocolors";
+import { CLI_VERSION, apiRequest, clearStoredAuth, describeAuthMethod, getRemoteMcpUrl, getConfigPath, loadConfig, loginWithDeviceFlow, outputJson, persistAuth, printResourceStatus, printTable, readFlagBoolean, readFlagString, resolveAuth, } from "./core.js";
+import { detectCliLocale } from "./locale.js";
+import { startMcpServer } from "./mcp-server.js";
+import { applySetupWizardSelections, runInteractiveSetupWizard, shouldRunSetupWizard, } from "./setup-wizard.js";
+import { readSetupManifest, runSetup, runSkillsInstall, } from "./setup.js";
+const cliCatalogCategoryOrder = [
+    "linkedin",
+    "imports",
+    "leads",
+    "missions",
+    "offers",
+    "scoring",
+    "other",
+];
+function isFrench(locale) {
+    return locale === "fr";
+}
+function getCliCatalogCategoryLabel(category, locale = detectCliLocale()) {
+    const labels = {
+        en: {
+            linkedin: "LinkedIn",
+            imports: "Imports",
+            leads: "Leads",
+            missions: "Missions",
+            offers: "Offers",
+            scoring: "Scoring",
+            other: "Other",
+        },
+        fr: {
+            linkedin: "LinkedIn",
+            imports: "Imports",
+            leads: "Leads",
+            missions: "Missions",
+            offers: "Offres",
+            scoring: "Scoring",
+            other: "Autres",
+        },
+    };
+    return labels[isFrench(locale) ? "fr" : "en"][category];
+}
+function getAgentDisplayName(agent) {
+    switch (agent) {
+        case "claude":
+            return "Claude";
+        case "cursor":
+            return "Cursor";
+        case "codex":
+            return "Codex";
+        case "opencode":
+            return "OpenCode";
+    }
+}
+function formatAgentDisplayList(agents, locale = detectCliLocale()) {
+    const labels = agents.map((agent) => getAgentDisplayName(agent));
+    if (labels.length <= 1) {
+        return labels[0] ?? "";
+    }
+    if (labels.length === 2) {
+        return isFrench(locale) ? `${labels[0]} et ${labels[1]}` : `${labels[0]} and ${labels[1]}`;
+    }
+    const head = labels.slice(0, -1).join(", ");
+    const tail = labels[labels.length - 1];
+    return isFrench(locale) ? `${head} et ${tail}` : `${head}, and ${tail}`;
+}
+function buildMcpOutro(agents, locale = detectCliLocale()) {
+    return isFrench(locale)
+        ? agents.length > 1
+            ? `Ouvrez vos agents IA. SalesTouch est connecté dans ${formatAgentDisplayList(agents, locale)} et prêt à travailler à partir du vrai contexte.`
+            : "Ouvrez votre agent IA. SalesTouch est connecté, en direct, et prêt à travailler à partir du vrai contexte."
+        : agents.length > 1
+            ? `Open your AI agents. SalesTouch is live in ${formatAgentDisplayList(agents, locale)} and ready to work from real context.`
+            : "Open your AI agent. SalesTouch is live, connected, and ready to work from real context.";
+}
+function buildCliOutro(agents, locale = detectCliLocale()) {
+    return isFrench(locale)
+        ? agents.length > 1
+            ? `Ouvrez vos agents IA. SalesTouch est prêt dans ${formatAgentDisplayList(agents, locale)} pour rechercher, qualifier et préparer des brouillons avec vous.`
+            : "Ouvrez votre agent IA. SalesTouch est prêt à rechercher, qualifier et préparer des brouillons avec vous."
+        : agents.length > 1
+            ? `Open your AI agents. SalesTouch is ready in ${formatAgentDisplayList(agents, locale)} to research, qualify, and draft with you.`
+            : "Open your AI agent. SalesTouch is ready to research, qualify, and draft with you.";
+}
+function getSetupModeDisplay(mode, mcpTarget, locale = detectCliLocale()) {
+    if (mode === "cli") {
+        return "CLI";
+    }
+    if (isFrench(locale)) {
+        return mcpTarget === "remote" ? "MCP distant" : "MCP local";
+    }
+    return mcpTarget === "remote" ? "Remote MCP" : "Local MCP";
+}
+function getSetupAuthDisplay(authMode, authMethod, locale = detectCliLocale()) {
+    if (authMode === "local") {
+        if (isFrench(locale)) {
+            return authMethod === "api_key" ? "Clé API" : "Connexion SalesTouch";
+        }
+        return authMethod === "api_key" ? "API key" : "SalesTouch login";
+    }
+    if (authMode === "oauth") {
+        return isFrench(locale) ? "Connexion navigateur" : "Browser login";
+    }
+    return isFrench(locale) ? "Clé API" : "API key";
+}
+function buildWizardInstallSummary(params) {
+    const { agents, mode, mcpTarget, authMode, authMethod, baseUrl, mcpUrl, results, locale = detectCliLocale(), } = params;
+    const fileLines = results.flatMap((result) => {
+        const lines = [
+            `${pc.bold(getAgentDisplayName(result.agent))}`,
+            `  rule   ${result.rulePath}`,
+        ];
+        if (result.skillPath) {
+            lines.push(`  skill  ${result.skillPath}`);
+        }
+        if (result.mcpConfigPath) {
+            lines.push(`  mcp    ${result.mcpConfigPath}`);
+        }
+        return lines;
+    });
+    const installedSkills = results.some((result) => Boolean(result.skillPath));
+    const nextSteps = mode === "mcp"
+        ? [
+            isFrench(locale)
+                ? `SalesTouch est prêt dans ${agents.length === 1 ? getAgentDisplayName(agents[0]) : "votre agent IA préféré"}.`
+                : `SalesTouch is ready inside ${agents.length === 1 ? getAgentDisplayName(agents[0]) : "your favorite AI agent"}.`,
+            isFrench(locale)
+                ? "Demandez-lui d'explorer le contexte live, de rechercher les bonnes personnes et de préparer un premier brouillon à valider."
+                : "Ask it to explore live context, research the right people, and prepare a first draft you can approve.",
+        ]
+        : [
+            isFrench(locale)
+                ? `SalesTouch est prêt dans ${agents.length === 1 ? getAgentDisplayName(agents[0]) : "votre agent IA préféré"}.`
+                : `SalesTouch is ready inside ${agents.length === 1 ? getAgentDisplayName(agents[0]) : "your favorite AI agent"}.`,
+            isFrench(locale)
+                ? "Lancez une première recherche : pnpm salestouch commands run lead.search --input-json '{\"query\":\"vp sales\"}' --json"
+                : "Try a first search: pnpm salestouch commands run lead.search --input-json '{\"query\":\"vp sales\"}' --json",
+            isFrench(locale)
+                ? "Parcourez ce que SalesTouch sait faire : pnpm salestouch commands list"
+                : "Browse what SalesTouch can do: pnpm salestouch commands list",
+        ];
+    return [
+        `${pc.bold(isFrench(locale) ? (agents.length > 1 ? "Agents IA" : "Agent IA") : (agents.length > 1 ? "AI agents" : "AI agent"))}      ${agents.map((agent) => getAgentDisplayName(agent)).join(", ")}`,
+        `${pc.bold(isFrench(locale) ? "Connexion" : "Connection")}    ${getSetupModeDisplay(mode, mcpTarget, locale)}`,
+        `${pc.bold(isFrench(locale) ? "Accès" : "Sign-in")}         ${getSetupAuthDisplay(authMode, authMethod === "api_key" ? "api_key" : "salestouch_login", locale)}`,
+        `${pc.bold("Skills")}        ${installedSkills ? (isFrench(locale) ? "Installés" : "Installed") : isFrench(locale) ? "Ignorés" : "Skipped"}`,
+        `${pc.bold(isFrench(locale) ? "URL de base" : "Base URL")}   ${baseUrl}`,
+        ...(mode === "mcp"
+            ? [`${pc.bold(isFrench(locale) ? "URL MCP" : "MCP URL")}      ${mcpUrl}`]
+            : []),
+        "",
+        `${pc.bold(isFrench(locale) ? "Installé pour vous" : "Installed for you")}`,
+        ...fileLines,
+        "",
+        `${pc.bold(isFrench(locale) ? "Commencer ici" : "Start here")}`,
+        ...nextSteps.map((step) => `  ${step}`),
+    ].join("\n");
+}
+function printUsage() {
+    console.log(`SalesTouch CLI ${CLI_VERSION}
+
+Usage:
+  salestouch auth login [--base-url <url>] [--json]
+  salestouch auth logout [--json]
+  salestouch auth whoami [--json]
+  salestouch auth use-key <api_key> [--base-url <url>] [--json]
+  salestouch auth create-key [--name <name>] [--expires-in <seconds>] [--base-url <url>] [--json]
+  salestouch doctor [--json]
+  salestouch commands list [--json]
+  salestouch commands schema <command_id> [--json]
+  salestouch commands run <command_id> [--input-json <json>] [--input-file <path>] [--compact|--full] [--json]
+  salestouch resources list [--json]
+  salestouch resources read <uri> [--json]
+  salestouch setup [--claude] [--cursor] [--codex] [--opencode] [--global] [--mcp|--cli] [--skills|--no-skills] [--local-mcp] [--login|--api-key <key>] [--base-url <url>] [--json]
+  salestouch skills reinstall [--claude] [--cursor] [--codex] [--opencode] [--global] [--mcp|--cli] [--json]
+  salestouch mcp serve [--api-key <key>] [--access-token <token>] [--base-url <url>]
+
+Auth resolution:
+  --api-key > SALESTOUCH_API_KEY > --access-token > SALESTOUCH_ACCESS_TOKEN > stored CLI login > stored API key
+  --base-url > SALESTOUCH_API_BASE_URL > stored config > workspace .env > https://www.salestouch.io
+
+Notes:
+  \`salestouch commands run\` defaults to \`full\` responses.
+  Use \`--compact\` to save tokens when needed, but it can noticeably reduce prospecting quality.
+  Running \`salestouch setup\` with no setup flags starts the interactive setup wizard.
+  \`salestouch setup\` installs skills by default; pass \`--no-skills\` to skip them.
+`);
+}
+function parseArgs(argv) {
+    const positionals = [];
+    const flags = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (!token)
+            continue;
+        if (!token.startsWith("--")) {
+            positionals.push(token);
+            continue;
+        }
+        const [rawName, inlineValue] = token.slice(2).split("=", 2);
+        const name = rawName.trim();
+        if (!name) {
+            continue;
+        }
+        if (inlineValue !== undefined) {
+            flags[name] = inlineValue;
+            continue;
+        }
+        const next = argv[index + 1];
+        if (next && !next.startsWith("--")) {
+            flags[name] = next;
+            index += 1;
+            continue;
+        }
+        flags[name] = true;
+    }
+    return { positionals, flags };
+}
+function parseJsonInput(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch (error) {
+        throw new Error(error instanceof Error ? `Invalid JSON input: ${error.message}` : "Invalid JSON input");
+    }
+}
+function readFlagInt(flags, name) {
+    const value = readFlagString(flags, name);
+    if (!value) {
+        return null;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error(`Invalid value for --${name}. Expected a positive integer.`);
+    }
+    return parsed;
+}
+async function readJsonInput(flags) {
+    const inline = readFlagString(flags, "input-json");
+    const filePath = readFlagString(flags, "input-file");
+    if (inline && filePath) {
+        throw new Error("Use either --input-json or --input-file, not both.");
+    }
+    if (inline) {
+        return parseJsonInput(inline);
+    }
+    if (filePath) {
+        const raw = await readFile(path.resolve(process.cwd(), filePath), "utf8");
+        return parseJsonInput(raw);
+    }
+    return {};
+}
+async function readStatusResource(options) {
+    const auth = await resolveAuth({
+        apiKey: options?.apiKey ?? null,
+        accessToken: options?.accessToken ?? null,
+        baseUrl: options?.baseUrl ?? null,
+    });
+    const payload = await apiRequest(auth, `/api/v1/resources/read?uri=${encodeURIComponent("salestouch://status")}`);
+    return {
+        auth,
+        resource: payload.data?.resource ?? {},
+    };
+}
+async function ensureSetupAuth(parsed) {
+    const apiKey = readFlagString(parsed.flags, "api-key");
+    const accessToken = readFlagString(parsed.flags, "access-token");
+    const baseUrl = readFlagString(parsed.flags, "base-url");
+    const forceLogin = readFlagBoolean(parsed.flags, "login");
+    if (apiKey) {
+        const { auth, resource } = await readStatusResource({ apiKey, baseUrl });
+        await persistAuth(auth);
+        return { auth, resource };
+    }
+    if (accessToken) {
+        const { auth, resource } = await readStatusResource({ accessToken, baseUrl });
+        await persistAuth(auth);
+        return { auth, resource };
+    }
+    if (forceLogin) {
+        const login = await loginWithDeviceFlow({
+            baseUrl,
+            quiet: readFlagBoolean(parsed.flags, "json"),
+        });
+        const payload = await apiRequest(login.auth, `/api/v1/resources/read?uri=${encodeURIComponent("salestouch://status")}`);
+        return {
+            auth: login.auth,
+            resource: payload.data?.resource ?? {},
+            userCode: login.userCode,
+        };
+    }
+    try {
+        const { auth, resource } = await readStatusResource({ baseUrl });
+        if (auth.credentialSource === "env" || auth.baseUrlSource === "env" || auth.baseUrlSource === "flag") {
+            await persistAuth(auth);
+        }
+        return { auth, resource };
+    }
+    catch (error) {
+        try {
+            const resolved = await resolveAuth({ baseUrl });
+            if (resolved.credentialSource === "env") {
+                throw error;
+            }
+        }
+        catch (resolveError) {
+            if (!(resolveError instanceof Error) || !resolveError.message.includes("Missing authentication")) {
+                throw error;
+            }
+        }
+        const login = await loginWithDeviceFlow({
+            baseUrl,
+            quiet: readFlagBoolean(parsed.flags, "json"),
+        });
+        const payload = await apiRequest(login.auth, `/api/v1/resources/read?uri=${encodeURIComponent("salestouch://status")}`);
+        return {
+            auth: login.auth,
+            resource: payload.data?.resource ?? {},
+            userCode: login.userCode,
+        };
+    }
+}
+function getRequestedSetupAgents(flags) {
+    const agents = [];
+    if (readFlagBoolean(flags, "claude"))
+        agents.push("claude");
+    if (readFlagBoolean(flags, "cursor"))
+        agents.push("cursor");
+    if (readFlagBoolean(flags, "codex"))
+        agents.push("codex");
+    if (readFlagBoolean(flags, "opencode"))
+        agents.push("opencode");
+    return agents;
+}
+function shouldInstallSetupSkills(flags) {
+    return !readFlagBoolean(flags, "no-skills");
+}
+async function handleAuthLogin(parsed) {
+    const login = await loginWithDeviceFlow({
+        baseUrl: readFlagString(parsed.flags, "base-url"),
+        quiet: readFlagBoolean(parsed.flags, "json"),
+    });
+    const payload = await apiRequest(login.auth, `/api/v1/resources/read?uri=${encodeURIComponent("salestouch://status")}`);
+    if (readFlagBoolean(parsed.flags, "json")) {
+        outputJson({
+            ok: true,
+            auth_method: describeAuthMethod(login.auth),
+            base_url: login.auth.baseUrl,
+            config_path: getConfigPath(),
+            status: payload.data?.resource?.payload ?? null,
+            user_code: login.userCode,
+        });
+        return;
+    }
+    console.log("SalesTouch login saved.");
+    console.log(`Config:   ${getConfigPath()}`);
+    console.log(`Base URL: ${login.auth.baseUrl}`);
+    printResourceStatus(payload.data?.resource ?? {});
+}
+async function handleAuthLogout(parsed) {
+    const config = await loadConfig();
+    if (!config.accessToken && !config.apiKey) {
+        if (readFlagBoolean(parsed.flags, "json")) {
+            outputJson({ ok: true, removed: false, config_path: getConfigPath() });
+            return;
+        }
+        console.log("No stored SalesTouch login found.");
+        return;
+    }
+    await clearStoredAuth();
+    if (readFlagBoolean(parsed.flags, "json")) {
+        outputJson({ ok: true, removed: true, config_path: getConfigPath() });
+        return;
+    }
+    console.log("Stored SalesTouch credentials removed.");
+    console.log(`Config: ${getConfigPath()}`);
+}
+async function handleAuthSetKey(parsed) {
+    const apiKey = parsed.positionals[2]?.trim() || readFlagString(parsed.flags, "api-key");
+    if (!apiKey) {
+        throw new Error("Missing API key. Usage: salestouch auth use-key <api_key> [--base-url <url>]");
+    }
+    const { auth, resource } = await readStatusResource({
+        apiKey,
+        baseUrl: readFlagString(parsed.flags, "base-url"),
+    });
+    await persistAuth(auth);
+    if (readFlagBoolean(parsed.flags, "json")) {
+        outputJson({
+            ok: true,
+            auth_method: describeAuthMethod(auth),
+            base_url: auth.baseUrl,
+            config_path: getConfigPath(),
+            status: resource.payload ?? null,
+        });
+        return;
+    }
+    console.log("API key saved.");
+    console.log(`Config:   ${getConfigPath()}`);
+    console.log(`Base URL: ${auth.baseUrl}`);
+    printResourceStatus(resource);
+}
+async function handleAuthIssueKey(parsed) {
+    const auth = await resolveAuth({
+        accessToken: readFlagString(parsed.flags, "access-token"),
+        baseUrl: readFlagString(parsed.flags, "base-url"),
+    });
+    if (auth.authMethod !== "session") {
+        throw new Error("`salestouch auth create-key` requires a SalesTouch login session. Run `salestouch auth login` first.");
+    }
+    const payload = await apiRequest(auth, "/api/v1/auth/api-keys", {
+        method: "POST",
+        body: JSON.stringify({
+            name: readFlagString(parsed.flags, "name") ?? undefined,
+            expires_in: readFlagInt(parsed.flags, "expires-in") ?? undefined,
+        }),
+    });
+    const apiKey = payload.data?.api_key?.trim();
+    if (!apiKey) {
+        throw new Error("SalesTouch did not return an API key.");
+    }
+    await persistAuth({
+        authMethod: "api_key",
+        credentialSource: "config",
+        apiKey,
+        baseUrl: auth.baseUrl,
+        baseUrlSource: auth.baseUrlSource,
+    });
+    if (readFlagBoolean(parsed.flags, "json")) {
+        outputJson({
+            ok: true,
+            api_key: apiKey,
+            api_key_id: payload.data?.api_key_id ?? null,
+            organization_id: payload.data?.organization_id ?? null,
+            name: payload.data?.name ?? null,
+            expires_at: payload.data?.expires_at ?? null,
+            config_path: getConfigPath(),
+            base_url: auth.baseUrl,
+        });
+        return;
+    }
+    console.log("API key issued and saved.");
+    console.log(`Config:   ${getConfigPath()}`);
+    console.log(`Base URL: ${auth.baseUrl}`);
+    console.log(`Key ID:   ${payload.data?.api_key_id ?? "unknown"}`);
+    console.log(`Org:      ${payload.data?.organization_id ?? "unknown"}`);
+    console.log(`API Key:  ${apiKey}`);
+}
+async function handleAuthWhoAmI(parsed) {
+    const { auth, resource } = await readStatusResource({
+        apiKey: readFlagString(parsed.flags, "api-key"),
+        accessToken: readFlagString(parsed.flags, "access-token"),
+        baseUrl: readFlagString(parsed.flags, "base-url"),
+    });
+    if (readFlagBoolean(parsed.flags, "json")) {
+        outputJson({
+            auth_method: describeAuthMethod(auth),
+            auth_source: auth.credentialSource,
+            base_url: auth.baseUrl,
+            resource,
+        });
+        return;
+    }
+    console.log(`Auth method: ${describeAuthMethod(auth)}`);
+    console.log(`Auth source: ${auth.credentialSource}`);
+    printResourceStatus(resource);
+}
+async function handleDoctor(parsed) {
+    const auth = await resolveAuth({
+        apiKey: readFlagString(parsed.flags, "api-key"),
+        accessToken: readFlagString(parsed.flags, "access-token"),
+        baseUrl: readFlagString(parsed.flags, "base-url"),
+    });
+    const setupManifest = (await readSetupManifest("project")) ??
+        (readFlagBoolean(parsed.flags, "global") ? await readSetupManifest("global") : null);
+    const [statusPayload, catalogPayload] = await Promise.all([
+        apiRequest(auth, `/api/v1/resources/read?uri=${encodeURIComponent("salestouch://status")}`),
+        apiRequest(auth, "/api/v1/commands"),
+    ]);
+    const status = statusPayload.data?.resource ?? {};
+    const commands = catalogPayload.data?.commands ?? [];
+    const warnings = [];
+    if (setupManifest) {
+        if (setupManifest.cli_version !== CLI_VERSION) {
+            warnings.push(`Setup manifest was generated with CLI ${setupManifest.cli_version}; current CLI is ${CLI_VERSION}. Re-run \`salestouch setup\`.`);
+        }
+        if (setupManifest.base_url !== auth.baseUrl) {
+            warnings.push(`Setup manifest base URL is ${setupManifest.base_url}; current auth uses ${auth.baseUrl}. Re-run \`salestouch setup\` if this changed intentionally.`);
+        }
+        if (setupManifest.mode === "mcp" && setupManifest.mcp_target === "remote") {
+            const expectedMcpUrl = getRemoteMcpUrl(auth.baseUrl);
+            if (setupManifest.mcp_url !== expectedMcpUrl) {
+                warnings.push(`Setup manifest MCP URL is ${setupManifest.mcp_url}; expected ${expectedMcpUrl}. Re-run \`salestouch setup\`.`);
+            }
+            const expectedAuthMode = auth.authMethod === "api_key" ? "api_key" : "oauth";
+            if (setupManifest.auth_mode && setupManifest.auth_mode !== expectedAuthMode) {
+                warnings.push(`Setup manifest auth mode is ${setupManifest.auth_mode}; current auth resolves to ${expectedAuthMode}. Re-run \`salestouch setup\` if you changed auth strategy.`);
+            }
+        }
+    }
+    if (readFlagBoolean(parsed.flags, "json")) {
+        outputJson({
+            base_url: auth.baseUrl,
+            base_url_source: auth.baseUrlSource,
+            auth_method: describeAuthMethod(auth),
+            auth_source: auth.credentialSource,
+            command_count: commands.length,
+            status,
+            warnings,
+            setup_manifest: setupManifest,
+        });
+        return;
+    }
+    console.log(`Base URL:        ${auth.baseUrl}`);
+    console.log(`Base URL source: ${auth.baseUrlSource}`);
+    console.log(`Auth method:     ${describeAuthMethod(auth)}`);
+    console.log(`Auth source:     ${auth.credentialSource}`);
+    console.log(`Commands:        ${commands.length}`);
+    printResourceStatus(status);
+    if (warnings.length > 0) {
+        console.log("");
+        console.log("Warnings:");
+        for (const warning of warnings) {
+            console.log(`- ${warning}`);
+        }
+    }
+}
+async function handleCatalog(parsed) {
+    const locale = detectCliLocale();
+    const auth = await resolveAuth({
+        apiKey: readFlagString(parsed.flags, "api-key"),
+        accessToken: readFlagString(parsed.flags, "access-token"),
+        baseUrl: readFlagString(parsed.flags, "base-url"),
+    });
+    const payload = await apiRequest(auth, "/api/v1/commands");
+    const commands = payload.data?.commands ?? [];
+    if (readFlagBoolean(parsed.flags, "json")) {
+        outputJson(commands);
+        return;
+    }
+    const groupedCommands = new Map();
+    for (const command of commands) {
+        const category = cliCatalogCategoryOrder.includes(command.category)
+            ? command.category
+            : "other";
+        const group = groupedCommands.get(category) ?? [];
+        group.push(command);
+        groupedCommands.set(category, group);
+    }
+    const orderedCategories = cliCatalogCategoryOrder.filter((category) => {
+        const group = groupedCommands.get(category);
+        return Boolean(group && group.length > 0);
+    });
+    for (const [index, category] of orderedCategories.entries()) {
+        const categoryCommands = groupedCommands.get(category)?.slice().sort((left, right) => String(left.command_id ?? "").localeCompare(String(right.command_id ?? ""))) ?? [];
+        console.log(pc.bold(`${getCliCatalogCategoryLabel(category, locale)} (${categoryCommands.length})`));
+        printTable([
+            ["COMMAND", "RISK", "DESCRIPTION"],
+            ...categoryCommands.map((command) => [
+                String(command.command_id ?? ""),
+                String(command.risk ?? ""),
+                String(command.description ?? ""),
+            ]),
+        ]);
+        if (index < orderedCategories.length - 1) {
+            console.log("");
+        }
+    }
+}
+async function handleSchema(parsed) {
+    const auth = await resolveAuth({
+        apiKey: readFlagString(parsed.flags, "api-key"),
+        accessToken: readFlagString(parsed.flags, "access-token"),
+        baseUrl: readFlagString(parsed.flags, "base-url"),
+    });
+    const commandId = parsed.positionals[2];
+    if (!commandId) {
+        throw new Error("Missing command id. Usage: salestouch commands schema <command_id>");
+    }
+    const payload = await apiRequest(auth, `/api/v1/commands/${encodeURIComponent(commandId)}/schema`);
+    outputJson(payload.data?.command ?? null);
+}
+async function handleRun(parsed) {
+    const auth = await resolveAuth({
+        apiKey: readFlagString(parsed.flags, "api-key"),
+        accessToken: readFlagString(parsed.flags, "access-token"),
+        baseUrl: readFlagString(parsed.flags, "base-url"),
+    });
+    const commandId = parsed.positionals[2];
+    if (!commandId) {
+        throw new Error("Missing command id. Usage: salestouch commands run <command_id>");
+    }
+    const input = await readJsonInput(parsed.flags);
+    const responseProfile = readFlagBoolean(parsed.flags, "compact")
+        ? "compact"
+        : readFlagBoolean(parsed.flags, "full")
+            ? "full"
+            : "full";
+    const payload = await apiRequest(auth, `/api/v1/commands/${encodeURIComponent(commandId)}`, {
+        method: "POST",
+        body: JSON.stringify({
+            input,
+            response_profile: responseProfile,
+        }),
+    });
+    if (readFlagBoolean(parsed.flags, "json")) {
+        outputJson(payload);
+        return;
+    }
+    console.log(`Command: ${commandId}`);
+    outputJson(payload);
+}
+async function handleResourcesList(parsed) {
+    const auth = await resolveAuth({
+        apiKey: readFlagString(parsed.flags, "api-key"),
+        accessToken: readFlagString(parsed.flags, "access-token"),
+        baseUrl: readFlagString(parsed.flags, "base-url"),
+    });
+    const payload = await apiRequest(auth, "/api/v1/resources");
+    const resources = payload.data?.resources ?? [];
+    if (readFlagBoolean(parsed.flags, "json")) {
+        outputJson(resources);
+        return;
+    }
+    printTable([
+        ["URI", "NAME", "DESCRIPTION"],
+        ...resources.map((resource) => [
+            String(resource.uri ?? ""),
+            String(resource.name ?? ""),
+            String(resource.description ?? ""),
+        ]),
+    ]);
+}
+async function handleResourcesRead(parsed) {
+    const auth = await resolveAuth({
+        apiKey: readFlagString(parsed.flags, "api-key"),
+        accessToken: readFlagString(parsed.flags, "access-token"),
+        baseUrl: readFlagString(parsed.flags, "base-url"),
+    });
+    const uri = parsed.positionals[2];
+    if (!uri) {
+        throw new Error("Missing resource uri. Usage: salestouch resources read <uri>");
+    }
+    const payload = await apiRequest(auth, `/api/v1/resources/read?uri=${encodeURIComponent(uri)}`);
+    outputJson(payload.data?.resource ?? null);
+}
+async function handleSetup(parsed) {
+    const locale = detectCliLocale();
+    let effectiveParsed = parsed;
+    let usedWizard = false;
+    if (shouldRunSetupWizard(parsed.flags, process.stdin.isTTY && process.stdout.isTTY)) {
+        usedWizard = true;
+        let existingAuth = null;
+        try {
+            existingAuth = await resolveAuth({
+                baseUrl: readFlagString(parsed.flags, "base-url"),
+            });
+        }
+        catch {
+            existingAuth = null;
+        }
+        const selections = await runInteractiveSetupWizard({
+            existingAuth,
+        });
+        if (!selections) {
+            return;
+        }
+        effectiveParsed = {
+            ...parsed,
+            flags: applySetupWizardSelections(parsed.flags, selections),
+        };
+    }
+    const hasCliMode = readFlagBoolean(effectiveParsed.flags, "cli");
+    const hasMcpMode = readFlagBoolean(effectiveParsed.flags, "mcp");
+    if (hasCliMode && hasMcpMode) {
+        throw new Error("Choose either --cli or --mcp, not both.");
+    }
+    if (readFlagBoolean(effectiveParsed.flags, "skills") && readFlagBoolean(effectiveParsed.flags, "no-skills")) {
+        throw new Error("Choose either --skills or --no-skills, not both.");
+    }
+    const mode = hasMcpMode ? "mcp" : "cli";
+    if (mode !== "mcp" && readFlagBoolean(effectiveParsed.flags, "local-mcp")) {
+        throw new Error("`--local-mcp` is only valid with `--mcp`.");
+    }
+    const scope = readFlagBoolean(effectiveParsed.flags, "global") ? "global" : "project";
+    const mcpTarget = readFlagBoolean(effectiveParsed.flags, "local-mcp") ? "local" : "remote";
+    const installSkills = shouldInstallSetupSkills(effectiveParsed.flags);
+    const requestedAgents = getRequestedSetupAgents(effectiveParsed.flags);
+    let setupAuth;
+    if (usedWizard && !readFlagBoolean(effectiveParsed.flags, "json")) {
+        if (readFlagBoolean(effectiveParsed.flags, "login")) {
+            log.step(isFrench(locale)
+                ? "Ouverture de la connexion SalesTouch dans votre navigateur."
+                : "Opening SalesTouch login in your browser.");
+            setupAuth = await ensureSetupAuth(effectiveParsed);
+            log.success(isFrench(locale) ? "Connexion SalesTouch approuvée." : "SalesTouch login approved.");
+        }
+        else {
+            const authSpinner = spinner();
+            authSpinner.start(isFrench(locale)
+                ? "Vérification de vos identifiants SalesTouch"
+                : "Checking your SalesTouch credentials");
+            setupAuth = await ensureSetupAuth(effectiveParsed);
+            authSpinner.stop(isFrench(locale)
+                ? `Authentifié via ${getSetupAuthDisplay(setupAuth.auth.authMethod === "api_key" ? "api_key" : "local", setupAuth.auth.authMethod === "api_key" ? "api_key" : "salestouch_login", locale)} sur ${setupAuth.auth.baseUrl}`
+                : `Authenticated with ${describeAuthMethod(setupAuth.auth)} on ${setupAuth.auth.baseUrl}`);
+        }
+    }
+    else {
+        setupAuth = await ensureSetupAuth(effectiveParsed);
+    }
+    const authMode = mode !== "mcp"
+        ? "local"
+        : mcpTarget === "local"
+            ? "local"
+            : setupAuth.auth.authMethod === "api_key"
+                ? "api_key"
+                : "oauth";
+    const mcpUrl = getRemoteMcpUrl(setupAuth.auth.baseUrl);
+    let results;
+    const markDashboardSetupCompleted = async () => {
+        try {
+            await apiRequest(setupAuth.auth, "/api/v1/auth/setup-complete", {
+                method: "POST",
+                body: "{}",
+            });
+        }
+        catch {
+            // Keep setup successful even if the dashboard checklist marker fails.
+        }
+    };
+    if (usedWizard && !readFlagBoolean(effectiveParsed.flags, "json")) {
+        const installSpinner = spinner();
+        installSpinner.start(isFrench(locale) ? "Activation de SalesTouch" : "Bringing SalesTouch online");
+        results = await runSetup({
+            agents: requestedAgents,
+            mode,
+            scope,
+            mcpTarget,
+            authMode,
+            installSkills,
+            baseUrl: setupAuth.auth.baseUrl,
+            mcpUrl,
+            apiKey: setupAuth.auth.authMethod === "api_key" ? setupAuth.auth.apiKey : null,
+        });
+        await markDashboardSetupCompleted();
+        installSpinner.stop(isFrench(locale)
+            ? `SalesTouch est prêt dans ${results.map((result) => getAgentDisplayName(result.agent)).join(", ")}`
+            : `SalesTouch is now ready in ${results.map((result) => getAgentDisplayName(result.agent)).join(", ")}`);
+        note(buildWizardInstallSummary({
+            agents: results.map((result) => result.agent),
+            mode,
+            mcpTarget,
+            authMode,
+            authMethod: setupAuth.auth.authMethod,
+            baseUrl: setupAuth.auth.baseUrl,
+            mcpUrl,
+            results,
+            locale,
+        }), isFrench(locale) ? "Votre agent IA est prêt" : "Your AI agent is ready");
+        const installedAgents = results.map((result) => result.agent);
+        outro(mode === "mcp" ? buildMcpOutro(installedAgents, locale) : buildCliOutro(installedAgents, locale));
+        return;
+    }
+    results = await runSetup({
+        agents: requestedAgents,
+        mode,
+        scope,
+        mcpTarget,
+        authMode,
+        installSkills,
+        baseUrl: setupAuth.auth.baseUrl,
+        mcpUrl,
+        apiKey: setupAuth.auth.authMethod === "api_key" ? setupAuth.auth.apiKey : null,
+    });
+    await markDashboardSetupCompleted();
+    if (readFlagBoolean(effectiveParsed.flags, "json")) {
+        outputJson({
+            ok: true,
+            mode,
+            scope,
+            mcp_target: mode === "mcp" ? mcpTarget : null,
+            setup_auth_mode: mode === "mcp" ? authMode : null,
+            install_skills: installSkills,
+            auth_method: describeAuthMethod(setupAuth.auth),
+            auth_source: setupAuth.auth.credentialSource,
+            base_url: setupAuth.auth.baseUrl,
+            mcp_url: mode === "mcp" ? mcpUrl : null,
+            status: setupAuth.resource.payload ?? null,
+            setup: results,
+        });
+        return;
+    }
+    console.log(`Mode:      ${mode}`);
+    console.log(`Scope:     ${scope}`);
+    if (mode === "mcp") {
+        console.log(`Target:    ${mcpTarget}`);
+        console.log(`Setup auth:${authMode}`);
+        console.log(`MCP URL:   ${mcpUrl}`);
+    }
+    console.log(`Skills:    ${installSkills ? "installed" : "skipped"}`);
+    console.log(`Auth:      ${describeAuthMethod(setupAuth.auth)} (${setupAuth.auth.credentialSource})`);
+    console.log(`Base URL:  ${setupAuth.auth.baseUrl}`);
+    console.log("");
+    for (const result of results) {
+        console.log(`${result.agent}:`);
+        if (result.mcpConfigPath) {
+            console.log(`  MCP:   ${result.mcpConfigPath}`);
+        }
+        console.log(`  Rule:  ${result.rulePath}`);
+        if (result.skillPath) {
+            console.log(`  Skill: ${result.skillPath}`);
+        }
+        console.log(`  Meta:  ${result.manifestPath}`);
+    }
+}
+async function handleSkillsReinstall(parsed) {
+    const hasCliMode = readFlagBoolean(parsed.flags, "cli");
+    const hasMcpMode = readFlagBoolean(parsed.flags, "mcp");
+    if (hasCliMode && hasMcpMode) {
+        throw new Error("Choose either --cli or --mcp, not both.");
+    }
+    const scope = readFlagBoolean(parsed.flags, "global") ? "global" : "project";
+    const setupManifest = await readSetupManifest(scope);
+    const requestedAgents = getRequestedSetupAgents(parsed.flags);
+    const usingManifestDefaults = requestedAgents.length === 0 &&
+        !hasCliMode &&
+        !hasMcpMode &&
+        Boolean(setupManifest);
+    const mode = hasMcpMode ? "mcp" : hasCliMode ? "cli" : setupManifest?.mode ?? "cli";
+    const results = await runSkillsInstall({
+        agents: requestedAgents.length > 0 ? requestedAgents : setupManifest?.agents ?? [],
+        mode,
+        scope,
+    });
+    if (readFlagBoolean(parsed.flags, "json")) {
+        outputJson({
+            ok: true,
+            scope,
+            mode,
+            setup_manifest: setupManifest,
+            skills: results,
+        });
+        return;
+    }
+    console.log(`Mode:      ${mode}`);
+    console.log(`Scope:     ${scope}`);
+    if (usingManifestDefaults) {
+        console.log("Defaults:  setup manifest");
+    }
+    console.log("");
+    for (const result of results) {
+        console.log(`${result.agent}:`);
+        console.log(`  Skill: ${result.skillPath}`);
+    }
+}
+async function handleMcpServe(parsed) {
+    const auth = await resolveAuth({
+        apiKey: readFlagString(parsed.flags, "api-key"),
+        accessToken: readFlagString(parsed.flags, "access-token"),
+        baseUrl: readFlagString(parsed.flags, "base-url"),
+    });
+    await startMcpServer(auth);
+}
+async function main() {
+    const parsed = parseArgs(process.argv.slice(2));
+    const [command, subcommand] = parsed.positionals;
+    if (!command || command === "help" || readFlagBoolean(parsed.flags, "help")) {
+        printUsage();
+        return;
+    }
+    if (command === "auth" && subcommand === "login") {
+        await handleAuthLogin(parsed);
+        return;
+    }
+    if (command === "auth" && subcommand === "logout") {
+        await handleAuthLogout(parsed);
+        return;
+    }
+    if (command === "auth" && subcommand === "use-key") {
+        await handleAuthSetKey(parsed);
+        return;
+    }
+    if (command === "auth" && subcommand === "create-key") {
+        await handleAuthIssueKey(parsed);
+        return;
+    }
+    if (command === "auth" && subcommand === "whoami") {
+        await handleAuthWhoAmI(parsed);
+        return;
+    }
+    if (command === "doctor") {
+        await handleDoctor(parsed);
+        return;
+    }
+    if (command === "commands" && subcommand === "list") {
+        await handleCatalog(parsed);
+        return;
+    }
+    if (command === "commands" && subcommand === "schema") {
+        await handleSchema(parsed);
+        return;
+    }
+    if (command === "commands" && subcommand === "run") {
+        await handleRun(parsed);
+        return;
+    }
+    if (command === "resources" && subcommand === "list") {
+        await handleResourcesList(parsed);
+        return;
+    }
+    if (command === "resources" && subcommand === "read") {
+        await handleResourcesRead(parsed);
+        return;
+    }
+    if (command === "setup") {
+        await handleSetup(parsed);
+        return;
+    }
+    if (command === "skills" && subcommand === "reinstall") {
+        await handleSkillsReinstall(parsed);
+        return;
+    }
+    if (command === "mcp" && subcommand === "serve") {
+        await handleMcpServe(parsed);
+        return;
+    }
+    throw new Error(`Unknown command: ${parsed.positionals.join(" ")}`);
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});