@salestouch/cli 0.1.0

package/README.md

@@ -0,0 +1,80 @@
+# SalesTouch CLI
+
+Public CLI for SalesTouch commands, resources, agent setup, and MCP workflows.
+
+## Install
+
+```bash
+pnpm salestouch --help
+```
+
+The npm package is not published yet. Run the CLI from the repository root with `pnpm salestouch ...`.
+
+## Authenticate
+
+```bash
+pnpm salestouch auth login
+pnpm salestouch auth whoami
+pnpm salestouch auth logout
+```
+
+API key authentication is also supported:
+
+```bash
+pnpm salestouch auth use-key st_...
+```
+
+## Commands
+
+```bash
+pnpm salestouch doctor
+pnpm salestouch commands list
+pnpm salestouch commands schema mission.get
+pnpm salestouch commands run mission.get --input-json '{"mission_id":"mission_123"}'
+pnpm salestouch resources list
+pnpm salestouch resources read salestouch://status
+pnpm salestouch setup --codex
+pnpm salestouch mcp serve
+```
+
+The CLI can authenticate with either a stored SalesTouch login session or an API key. `salestouch setup` persists the selected auth method to the CLI config so local MCP clients can reuse it.
+By default, `salestouch setup` installs `CLI + skills`. Add `--mcp` when you want MCP instead.
+If you run `pnpm salestouch setup` with no setup flags in an interactive terminal, the CLI starts a small guided setup wizard.
+
+## Setup
+
+```bash
+# Project-local CLI + skills setup for Codex
+pnpm salestouch setup --codex
+
+# Configure Claude and Cursor explicitly in CLI mode
+pnpm salestouch setup --claude --cursor --cli
+
+# Opt into remote MCP explicitly
+pnpm salestouch setup --claude --mcp --login
+
+# Force login during setup
+pnpm salestouch setup --codex --login
+
+# Persist an API key during setup
+pnpm salestouch setup --codex --api-key st_...
+```
+
+## MCP
+
+```bash
+# Start the local stdio MCP server
+pnpm salestouch mcp serve
+
+# Override auth explicitly for the MCP process
+pnpm salestouch mcp serve --api-key st_...
+pnpm salestouch mcp serve --access-token <token>
+```
+
+## Environment
+
+```bash
+export SALESTOUCH_API_BASE_URL="http://localhost:3000"
+export SALESTOUCH_API_KEY="st_..."
+export SALESTOUCH_ACCESS_TOKEN="<token>"
+```

package/dist/core.d.ts

@@ -0,0 +1,91 @@
+export type FlagValue = string | boolean;
+export type CliConfig = {
+    apiKey?: string;
+    accessToken?: string;
+    baseUrl?: string;
+};
+export type ResolvedBaseUrl = {
+    baseUrl: string;
+    baseUrlSource: "flag" | "env" | "config" | "workspace" | "default";
+};
+export type ResolvedApiKeyAuth = ResolvedBaseUrl & {
+    authMethod: "api_key";
+    credentialSource: "flag" | "env" | "config";
+    apiKey: string;
+};
+export type ResolvedSessionAuth = ResolvedBaseUrl & {
+    authMethod: "session";
+    credentialSource: "flag" | "env" | "config";
+    accessToken: string;
+};
+export type ResolvedAuth = ResolvedApiKeyAuth | ResolvedSessionAuth;
+export type JsonRecord = Record<string, unknown>;
+export declare const CLI_VERSION = "0.3.0";
+export declare const DEFAULT_BASE_URL = "https://www.salestouch.io";
+export declare const CLI_DEVICE_CLIENT_ID = "salestouch-cli";
+export declare function readFlagString(flags: Record<string, FlagValue>, name: string): string | null;
+export declare function readFlagBoolean(flags: Record<string, FlagValue>, name: string): boolean;
+export declare function readEnvString(name: string): string | null;
+export declare function getConfigDirectory(): string;
+export declare function getConfigPath(): string;
+export declare function loadConfig(): Promise<CliConfig>;
+export declare function saveConfig(config: CliConfig): Promise<void>;
+export declare function resolveBaseUrl(overrideBaseUrl?: string | null): Promise<ResolvedBaseUrl>;
+export declare function getRemoteMcpUrl(baseUrl: string): string;
+export declare function resolveAuth(options?: {
+    apiKey?: string | null;
+    accessToken?: string | null;
+    baseUrl?: string | null;
+}): Promise<{
+    baseUrl: string;
+    baseUrlSource: "flag" | "env" | "config" | "workspace" | "default";
+    authMethod: "api_key";
+    credentialSource: "flag";
+    apiKey: string;
+} | {
+    baseUrl: string;
+    baseUrlSource: "flag" | "env" | "config" | "workspace" | "default";
+    authMethod: "api_key";
+    credentialSource: "env";
+    apiKey: string;
+} | {
+    baseUrl: string;
+    baseUrlSource: "flag" | "env" | "config" | "workspace" | "default";
+    authMethod: "session";
+    credentialSource: "flag";
+    accessToken: string;
+} | {
+    baseUrl: string;
+    baseUrlSource: "flag" | "env" | "config" | "workspace" | "default";
+    authMethod: "session";
+    credentialSource: "env";
+    accessToken: string;
+} | {
+    baseUrl: string;
+    baseUrlSource: "flag" | "env" | "config" | "workspace" | "default";
+    authMethod: "session";
+    credentialSource: "config";
+    accessToken: string;
+} | {
+    baseUrl: string;
+    baseUrlSource: "flag" | "env" | "config" | "workspace" | "default";
+    authMethod: "api_key";
+    credentialSource: "config";
+    apiKey: string;
+}>;
+export declare function persistAuth(auth: ResolvedAuth): Promise<void>;
+export declare function clearStoredSession(): Promise<void>;
+export declare function clearStoredApiKey(): Promise<void>;
+export declare function clearStoredAuth(): Promise<void>;
+export declare function apiRequest<T>(auth: ResolvedAuth, pathName: string, init?: RequestInit): Promise<T>;
+export declare function outputJson(value: unknown): void;
+export declare function printTable(rows: string[][]): void;
+export declare function printResourceStatus(resource: JsonRecord): void;
+export declare function describeAuthMethod(auth: ResolvedAuth): "api_key" | "salestouch_login";
+export declare function loginWithDeviceFlow(options?: {
+    baseUrl?: string | null;
+    quiet?: boolean;
+}): Promise<{
+    auth: ResolvedSessionAuth;
+    userCode: string;
+}>;

package/dist/core.js

@@ -0,0 +1,382 @@
+import { spawn } from "node:child_process";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { setTimeout as sleep } from "node:timers/promises";
+import { parse as parseDotenv } from "dotenv";
+export const CLI_VERSION = "0.3.0";
+export const DEFAULT_BASE_URL = "https://www.salestouch.io";
+export const CLI_DEVICE_CLIENT_ID = "salestouch-cli";
+const DEVICE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
+const WORKSPACE_BASE_URL_FILES = [".env.local", ".env"];
+export function readFlagString(flags, name) {
+    const value = flags[name];
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+export function readFlagBoolean(flags, name) {
+    return flags[name] === true;
+}
+export function readEnvString(name) {
+    const value = process.env[name]?.trim();
+    return value && value.length > 0 ? value : null;
+}
+export function getConfigDirectory() {
+    const override = readEnvString("SALESTOUCH_CONFIG_DIR");
+    if (override) {
+        return override;
+    }
+    if (process.platform === "darwin") {
+        return path.join(os.homedir(), "Library", "Application Support", "SalesTouch");
+    }
+    if (process.platform === "win32") {
+        return path.join(process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"), "SalesTouch");
+    }
+    return path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"), "salestouch");
+}
+export function getConfigPath() {
+    return path.join(getConfigDirectory(), "cli.json");
+}
+export async function loadConfig() {
+    try {
+        const raw = await readFile(getConfigPath(), "utf8");
+        const parsed = JSON.parse(raw);
+        return {
+            apiKey: typeof parsed.apiKey === "string" ? parsed.apiKey : undefined,
+            accessToken: typeof parsed.accessToken === "string" ? parsed.accessToken : undefined,
+            baseUrl: typeof parsed.baseUrl === "string" ? parsed.baseUrl : undefined,
+        };
+    }
+    catch {
+        return {};
+    }
+}
+export async function saveConfig(config) {
+    const configPath = getConfigPath();
+    await mkdir(path.dirname(configPath), { recursive: true });
+    await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+}
+function resolveBaseUrlFromSources(flagBaseUrl, envBaseUrl, configBaseUrl, workspaceBaseUrl) {
+    return {
+        baseUrl: (flagBaseUrl || envBaseUrl || configBaseUrl || workspaceBaseUrl || DEFAULT_BASE_URL).replace(/\/$/, ""),
+        baseUrlSource: flagBaseUrl
+            ? "flag"
+            : envBaseUrl
+                ? "env"
+                : configBaseUrl
+                    ? "config"
+                    : workspaceBaseUrl
+                        ? "workspace"
+                        : "default",
+    };
+}
+async function readWorkspaceBaseUrlFromFile(filePath) {
+    try {
+        const raw = await readFile(filePath, "utf8");
+        const parsed = parseDotenv(raw);
+        for (const key of ["SALESTOUCH_API_BASE_URL", "NEXT_PUBLIC_APP_URL", "BETTER_AUTH_URL"]) {
+            const value = parsed[key]?.trim();
+            if (value) {
+                return value;
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+async function findWorkspaceBaseUrl(startDir) {
+    let currentDir = path.resolve(startDir);
+    while (true) {
+        for (const fileName of WORKSPACE_BASE_URL_FILES) {
+            const filePath = path.join(currentDir, fileName);
+            const baseUrl = await readWorkspaceBaseUrlFromFile(filePath);
+            if (baseUrl) {
+                return baseUrl;
+            }
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            return null;
+        }
+        currentDir = parentDir;
+    }
+}
+export async function resolveBaseUrl(overrideBaseUrl) {
+    const config = await loadConfig();
+    const workspaceBaseUrl = await findWorkspaceBaseUrl(process.cwd());
+    return resolveBaseUrlFromSources(overrideBaseUrl ?? null, readEnvString("SALESTOUCH_API_BASE_URL"), config.baseUrl?.trim() || null, workspaceBaseUrl);
+}
+export function getRemoteMcpUrl(baseUrl) {
+    return `${baseUrl.replace(/\/$/, "")}/api/mcp`;
+}
+export async function resolveAuth(options) {
+    const config = await loadConfig();
+    const explicitApiKey = options?.apiKey?.trim() || null;
+    const explicitAccessToken = options?.accessToken?.trim() || null;
+    const envApiKey = readEnvString("SALESTOUCH_API_KEY");
+    const envAccessToken = readEnvString("SALESTOUCH_ACCESS_TOKEN");
+    const configAccessToken = config.accessToken?.trim() || null;
+    const configApiKey = config.apiKey?.trim() || null;
+    const baseUrl = await resolveBaseUrl(options?.baseUrl ?? null);
+    if (explicitApiKey) {
+        return {
+            authMethod: "api_key",
+            credentialSource: "flag",
+            apiKey: explicitApiKey,
+            ...baseUrl,
+        };
+    }
+    if (envApiKey) {
+        return {
+            authMethod: "api_key",
+            credentialSource: "env",
+            apiKey: envApiKey,
+            ...baseUrl,
+        };
+    }
+    if (explicitAccessToken) {
+        return {
+            authMethod: "session",
+            credentialSource: "flag",
+            accessToken: explicitAccessToken,
+            ...baseUrl,
+        };
+    }
+    if (envAccessToken) {
+        return {
+            authMethod: "session",
+            credentialSource: "env",
+            accessToken: envAccessToken,
+            ...baseUrl,
+        };
+    }
+    if (configAccessToken) {
+        return {
+            authMethod: "session",
+            credentialSource: "config",
+            accessToken: configAccessToken,
+            ...baseUrl,
+        };
+    }
+    if (configApiKey) {
+        return {
+            authMethod: "api_key",
+            credentialSource: "config",
+            apiKey: configApiKey,
+            ...baseUrl,
+        };
+    }
+    throw new Error("Missing authentication. Use `salestouch auth login`, `salestouch auth use-key`, `--api-key`, SALESTOUCH_API_KEY, or SALESTOUCH_ACCESS_TOKEN.");
+}
+export async function persistAuth(auth) {
+    const current = await loadConfig();
+    await saveConfig({
+        ...current,
+        baseUrl: auth.baseUrl,
+        apiKey: auth.authMethod === "api_key" ? auth.apiKey : undefined,
+        accessToken: auth.authMethod === "session" ? auth.accessToken : undefined,
+    });
+}
+export async function clearStoredSession() {
+    const current = await loadConfig();
+    await saveConfig({
+        ...current,
+        accessToken: undefined,
+    });
+}
+export async function clearStoredApiKey() {
+    const current = await loadConfig();
+    await saveConfig({
+        ...current,
+        apiKey: undefined,
+    });
+}
+export async function clearStoredAuth() {
+    const current = await loadConfig();
+    await saveConfig({
+        ...current,
+        apiKey: undefined,
+        accessToken: undefined,
+    });
+}
+async function readResponseJson(response) {
+    const text = await response.text();
+    if (!text) {
+        return {};
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new Error(`Invalid JSON response (${response.status}).`);
+    }
+}
+export async function apiRequest(auth, pathName, init) {
+    const headers = new Headers(init?.headers);
+    headers.set("Accept", "application/json");
+    headers.set("Content-Type", "application/json");
+    headers.set("X-SalesTouch-Client", "cli");
+    headers.set("X-SalesTouch-Client-Version", CLI_VERSION);
+    if (auth.authMethod === "api_key") {
+        headers.set("X-API-Key", auth.apiKey);
+    }
+    else {
+        headers.set("Authorization", `Bearer ${auth.accessToken}`);
+    }
+    const response = await fetch(`${auth.baseUrl}${pathName}`, {
+        ...init,
+        headers,
+    });
+    const payload = await readResponseJson(response);
+    if (!response.ok) {
+        const suffix = typeof payload?.error?.code === "string" ? ` (${payload.error.code})` : "";
+        throw new Error(`${payload?.error?.message ?? `SalesTouch API error ${response.status}`}${suffix}`);
+    }
+    return payload;
+}
+export function outputJson(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+export function printTable(rows) {
+    const widths = rows[0]?.map((_, index) => Math.max(...rows.map((row) => (row[index] ?? "").length)));
+    if (!widths) {
+        return;
+    }
+    rows.forEach((row, rowIndex) => {
+        const line = row
+            .map((column, index) => column.padEnd(widths[index] ?? column.length))
+            .join("  ");
+        console.log(line);
+        if (rowIndex === 0) {
+            console.log(widths.map((width) => "-".repeat(width)).join("  "));
+        }
+    });
+}
+export function printResourceStatus(resource) {
+    const payload = (resource.payload ?? {});
+    console.log(`Organization: ${String(payload.organization_id ?? "unknown")}`);
+    console.log(`User:         ${String(payload.user_id ?? "unknown")}`);
+    console.log(`Plugin mode:  ${String(payload.plugin_mode ?? "local")}`);
+    console.log(`LinkedIn:     ${String(payload.connected_accounts ?? 0)} connected`);
+}
+export function describeAuthMethod(auth) {
+    return auth.authMethod === "session" ? "salestouch_login" : "api_key";
+}
+async function requestDeviceCode(baseUrl) {
+    const response = await fetch(`${baseUrl}/api/auth/device/code`, {
+        method: "POST",
+        headers: {
+            Accept: "application/json",
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            client_id: CLI_DEVICE_CLIENT_ID,
+        }),
+    });
+    const payload = await readResponseJson(response);
+    if (!response.ok) {
+        const notFoundHint = response.status === 404
+            ? ` Check the base URL (${baseUrl}) or pass --base-url / SALESTOUCH_API_BASE_URL.`
+            : "";
+        throw new Error(payload.error_description ??
+            payload.error ??
+            `Failed to start SalesTouch login (${response.status}).${notFoundHint}`);
+    }
+    return payload;
+}
+async function pollDeviceToken({ baseUrl, deviceCode, intervalSeconds, expiresInSeconds, }) {
+    const deadline = Date.now() + expiresInSeconds * 1000;
+    let pollIntervalMs = Math.max(intervalSeconds, 1) * 1000;
+    while (Date.now() < deadline) {
+        await sleep(pollIntervalMs);
+        const response = await fetch(`${baseUrl}/api/auth/device/token`, {
+            method: "POST",
+            headers: {
+                Accept: "application/json",
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                grant_type: DEVICE_GRANT_TYPE,
+                device_code: deviceCode,
+                client_id: CLI_DEVICE_CLIENT_ID,
+            }),
+        });
+        const payload = await readResponseJson(response);
+        if (response.ok && payload.access_token) {
+            return payload;
+        }
+        switch (payload.error) {
+            case "authorization_pending":
+                continue;
+            case "slow_down":
+                pollIntervalMs += 5000;
+                continue;
+            case "access_denied":
+                throw new Error(payload.error_description ?? "SalesTouch login was denied.");
+            case "expired_token":
+                throw new Error(payload.error_description ?? "SalesTouch login expired.");
+            default:
+                throw new Error(payload.error_description ??
+                    payload.error ??
+                    `Failed to complete SalesTouch login (${response.status}).`);
+        }
+    }
+    throw new Error("SalesTouch login expired before it was approved.");
+}
+async function openBrowser(url) {
+    const command = process.platform === "darwin"
+        ? { bin: "open", args: [url] }
+        : process.platform === "win32"
+            ? { bin: "cmd", args: ["/c", "start", "", url] }
+            : { bin: "xdg-open", args: [url] };
+    return new Promise((resolve) => {
+        try {
+            const child = spawn(command.bin, command.args, {
+                detached: true,
+                stdio: "ignore",
+            });
+            child.on("error", () => resolve(false));
+            child.unref();
+            resolve(true);
+        }
+        catch {
+            resolve(false);
+        }
+    });
+}
+export async function loginWithDeviceFlow(options) {
+    const baseUrl = await resolveBaseUrl(options?.baseUrl ?? null);
+    const deviceCode = await requestDeviceCode(baseUrl.baseUrl);
+    const opened = await openBrowser(deviceCode.verification_uri_complete);
+    if (!options?.quiet) {
+        console.log("Approve the SalesTouch CLI login in your browser.");
+        console.log(`Code: ${deviceCode.user_code}`);
+        console.log(`URL:  ${deviceCode.verification_uri_complete}`);
+        if (!opened) {
+            console.log("A browser could not be opened automatically. Open the URL above manually.");
+        }
+        console.log("");
+    }
+    const token = await pollDeviceToken({
+        baseUrl: baseUrl.baseUrl,
+        deviceCode: deviceCode.device_code,
+        intervalSeconds: deviceCode.interval,
+        expiresInSeconds: deviceCode.expires_in,
+    });
+    if (!token.access_token) {
+        throw new Error("SalesTouch login completed without an access token.");
+    }
+    const auth = {
+        authMethod: "session",
+        credentialSource: "config",
+        accessToken: token.access_token,
+        ...baseUrl,
+    };
+    await persistAuth(auth);
+    return {
+        auth,
+        userCode: deviceCode.user_code,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};