@salestouch/cli 0.1.0

package/dist/locale.d.ts

@@ -0,0 +1,5 @@
+export type CliLocale = "en" | "fr";
+type CliEnv = Record<string, string | undefined>;
+export declare function detectCliLocale(env?: CliEnv): CliLocale;
+export declare function isFrenchCliLocale(env?: CliEnv): boolean;
+export {};

package/dist/locale.js

@@ -0,0 +1,28 @@
+const FRENCH_LOCALE_PATTERN = /^fr(?:[_\-.]|$)/i;
+function splitLocaleCandidates(value) {
+    if (!value) {
+        return [];
+    }
+    return value
+        .split(":")
+        .map((candidate) => candidate.trim())
+        .filter((candidate) => candidate.length > 0);
+}
+export function detectCliLocale(env = process.env) {
+    const explicitCandidates = splitLocaleCandidates(env.SALESTOUCH_CLI_LANG);
+    if (explicitCandidates.length > 0) {
+        return explicitCandidates.some((candidate) => FRENCH_LOCALE_PATTERN.test(candidate))
+            ? "fr"
+            : "en";
+    }
+    const candidates = [
+        ...splitLocaleCandidates(env.LC_ALL),
+        ...splitLocaleCandidates(env.LC_MESSAGES),
+        ...splitLocaleCandidates(env.LANGUAGE),
+        ...splitLocaleCandidates(env.LANG),
+    ];
+    return candidates.some((candidate) => FRENCH_LOCALE_PATTERN.test(candidate)) ? "fr" : "en";
+}
+export function isFrenchCliLocale(env = process.env) {
+    return detectCliLocale(env) === "fr";
+}

package/dist/mcp-server.d.ts

@@ -0,0 +1,2 @@
+import { type ResolvedAuth } from "./core.js";
+export declare function startMcpServer(auth: ResolvedAuth): Promise<void>;

package/dist/mcp-server.js

@@ -0,0 +1,181 @@
+import process from "node:process";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ErrorCode, ListResourcesRequestSchema, ListToolsRequestSchema, McpError, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { CLI_VERSION, apiRequest } from "./core.js";
+const fallbackResources = [
+    {
+        uri: "salestouch://status",
+        name: "SalesTouch Status",
+        description: "Workspace installation and API connectivity status.",
+        mimeType: "application/json",
+    },
+    {
+        uri: "salestouch://catalog",
+        name: "SalesTouch Catalog",
+        description: "Public automation catalog exposed by the SalesTouch runtime.",
+        mimeType: "application/json",
+    },
+];
+const schemaCache = new Map();
+function writeStderr(message) {
+    process.stderr.write(`[salestouch-mcp] ${message}\n`);
+}
+async function fetchCatalog(auth) {
+    const payload = await apiRequest(auth, "/api/v1/commands");
+    return (payload.data?.commands ?? []).flatMap((entry) => {
+        if (typeof entry.command_id !== "string") {
+            return [];
+        }
+        return [
+            {
+                id: entry.command_id,
+                title: entry.title ?? entry.command_id,
+                description: entry.summary ?? entry.description ?? entry.title ?? entry.command_id,
+                risk: entry.risk ?? "read",
+                category: entry.category ?? null,
+            },
+        ];
+    });
+}
+async function fetchCommandSchema(auth, commandId) {
+    const cached = schemaCache.get(commandId);
+    if (cached) {
+        return cached;
+    }
+    const payload = await apiRequest(auth, `/api/v1/commands/${encodeURIComponent(commandId)}/schema`);
+    const schema = payload.data?.command?.input_schema ?? {
+        type: "object",
+        properties: {},
+        additionalProperties: true,
+    };
+    schemaCache.set(commandId, schema);
+    return schema;
+}
+async function fetchResources(auth) {
+    const payload = await apiRequest(auth, "/api/v1/resources");
+    return payload.data?.resources ?? fallbackResources;
+}
+async function readResource(auth, uri) {
+    const payload = await apiRequest(auth, `/api/v1/resources/read?uri=${encodeURIComponent(uri)}`);
+    return payload.data?.resource ?? null;
+}
+function safeJsonStringify(value) {
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return String(value);
+    }
+}
+function getToolAnnotations(risk) {
+    if (risk === "read") {
+        return {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        };
+    }
+    return {
+        readOnlyHint: false,
+        destructiveHint: risk === "approval",
+        idempotentHint: false,
+        openWorldHint: false,
+    };
+}
+export async function startMcpServer(auth) {
+    const server = new Server({
+        name: "salestouch",
+        version: CLI_VERSION,
+    }, {
+        capabilities: {
+            tools: {
+                listChanged: false,
+            },
+            resources: {
+                listChanged: false,
+                subscribe: false,
+            },
+        },
+        instructions: "Use SalesTouch when the user asks to inspect or act on leads, missions, offers, imports, LinkedIn prospecting workflows, or scoring data that lives in SalesTouch. Prefer reading tool schemas before writing payloads. Use resources for workspace status and reference data.",
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        const catalog = await fetchCatalog(auth);
+        const tools = await Promise.all(catalog.map(async (tool) => ({
+            name: tool.id,
+            title: tool.title,
+            description: tool.description,
+            inputSchema: await fetchCommandSchema(auth, tool.id),
+            annotations: getToolAnnotations(tool.risk),
+        })));
+        return { tools };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const toolName = request.params.name;
+        const toolArgs = request.params.arguments && typeof request.params.arguments === "object"
+            ? request.params.arguments
+            : {};
+        const catalog = await fetchCatalog(auth);
+        if (!catalog.some((entry) => entry.id === toolName)) {
+            throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${toolName}`);
+        }
+        const payload = await apiRequest(auth, `/api/v1/commands/${encodeURIComponent(toolName)}`, {
+            method: "POST",
+            body: JSON.stringify({
+                input: toolArgs,
+            }),
+        });
+        const resultBody = payload.ok
+            ? {
+                data: payload.data ?? null,
+                meta: payload.meta ?? null,
+            }
+            : {
+                error: payload.error ?? { message: "Unknown command failure" },
+                meta: payload.meta ?? null,
+            };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: safeJsonStringify(resultBody),
+                },
+            ],
+            structuredContent: resultBody,
+            isError: !payload.ok,
+        };
+    });
+    server.setRequestHandler(ListResourcesRequestSchema, async () => {
+        const resources = await fetchResources(auth);
+        return {
+            resources: resources.map((resource) => ({
+                uri: String(resource.uri ?? ""),
+                name: String(resource.name ?? resource.uri ?? ""),
+                title: String(resource.name ?? resource.uri ?? ""),
+                description: String(resource.description ?? ""),
+                mimeType: "application/json",
+            })),
+        };
+    });
+    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+        const uri = request.params.uri;
+        const resource = await readResource(auth, uri);
+        if (!resource?.uri) {
+            throw new McpError(ErrorCode.InvalidParams, `Resource not found: ${uri}`);
+        }
+        return {
+            contents: [
+                {
+                    uri: resource.uri,
+                    mimeType: "application/json",
+                    text: safeJsonStringify((resource.payload ?? {})),
+                },
+            ],
+        };
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    writeStderr("ready");
+    process.stdin.resume();
+}

package/dist/setup-wizard.d.ts

@@ -0,0 +1,39 @@
+import { type FlagValue, type ResolvedAuth } from "./core.js";
+import { type CliLocale } from "./locale.js";
+import { type SetupAgent, type SetupMcpTarget, type SetupMode, type SetupScope } from "./setup.js";
+export type SetupWizardSelections = {
+    agents: SetupAgent[];
+    mode: SetupMode;
+    scope: SetupScope;
+    mcpTarget: SetupMcpTarget;
+    installSkills: boolean;
+    authChoice: "reuse" | "login" | "api_key";
+    apiKey: string | null;
+};
+type WizardChoice<T> = {
+    label: string;
+    value: T;
+    hint: string;
+};
+export declare function shouldRunSetupWizard(flags: Record<string, FlagValue>, isInteractive: boolean): boolean;
+export declare function buildSetupWizardAuthChoices(params: {
+    agent?: SetupAgent;
+    agents?: SetupAgent[];
+    mode: SetupMode;
+    mcpTarget: SetupMcpTarget;
+    existingAuth: ResolvedAuth | null;
+    locale?: CliLocale;
+}): WizardChoice<"api_key" | "reuse" | "login">[];
+export declare function applySetupWizardSelections(flags: Record<string, FlagValue>, selections: SetupWizardSelections): Record<string, FlagValue>;
+export declare function runInteractiveSetupWizard(params: {
+    existingAuth: ResolvedAuth | null;
+}): Promise<{
+    agents: SetupAgent[];
+    mode: SetupMode;
+    scope: SetupScope;
+    mcpTarget: SetupMcpTarget;
+    installSkills: boolean;
+    authChoice: "api_key" | "reuse" | "login";
+    apiKey: string | null;
+} | null>;
+export {};