@content-intel/cli 0.1.0

package/bin/content-intel.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/index.js';

package/dist/commands/analytics/overview.js

@@ -0,0 +1,55 @@
+import { runCommand, printJson } from "../../lib/command.js";
+import { requireConfig } from "../../lib/config.js";
+import { apiRequest } from "../../lib/client.js";
+import { CliCommandError } from "../../types/index.js";
+function assertValidDate(raw) {
+    if (!raw)
+        return;
+    const parsed = new Date(raw);
+    if (Number.isNaN(parsed.getTime())) {
+        throw new CliCommandError("INVALID_ARGS", `Invalid date: ${raw}`);
+    }
+    if (/^\d{4}-\d{2}-\d{2}$/.test(raw)) {
+        const [y, m, d] = raw.split("-").map(Number);
+        const utc = new Date(Date.UTC(y, m - 1, d));
+        if (utc.getUTCFullYear() !== y ||
+            utc.getUTCMonth() !== m - 1 ||
+            utc.getUTCDate() !== d) {
+            throw new CliCommandError("INVALID_ARGS", `Invalid date: ${raw}`);
+        }
+    }
+}
+export function registerAnalyticsOverviewCommand(analyticsCommand) {
+    analyticsCommand
+        .command("overview")
+        .description("Get aggregated analytics overview")
+        .option("--days <n>", "Last N days", (value) => {
+        if (!/^\d+$/.test(value))
+            return NaN;
+        return Number(value);
+    })
+        .option("--since <date>", "Start date (ISO or YYYY-MM-DD)")
+        .option("--until <date>", "End date (ISO or YYYY-MM-DD)")
+        .action((options) => runCommand(async () => {
+        if (options.days !== undefined &&
+            (!Number.isInteger(options.days) || options.days <= 0)) {
+            throw new CliCommandError("INVALID_ARGS", "--days must be a positive integer");
+        }
+        assertValidDate(options.since);
+        assertValidDate(options.until);
+        if (options.since && options.until) {
+            const sinceMs = new Date(options.since).getTime();
+            const untilMs = new Date(options.until).getTime();
+            if (sinceMs > untilMs) {
+                throw new CliCommandError("INVALID_ARGS", "--since cannot be after --until");
+            }
+        }
+        const config = await requireConfig();
+        const response = await apiRequest(config, "/api/cli/analytics/overview", {
+            days: options.days,
+            since: options.since,
+            until: options.until,
+        });
+        printJson(response);
+    }));
+}

package/dist/commands/audience/top-engagers.js

@@ -0,0 +1,22 @@
+import { runCommand, printJson } from "../../lib/command.js";
+import { requireConfig } from "../../lib/config.js";
+import { apiRequest } from "../../lib/client.js";
+import { CliCommandError } from "../../types/index.js";
+export function registerAudienceTopEngagersCommand(audienceCommand) {
+    audienceCommand
+        .command("top-engagers")
+        .description("Get top engagers for a tracked profile")
+        .requiredOption("--profile <handle>", "Profile handle")
+        .option("--limit <n>", "Result limit", (value) => parseInt(value, 10), 10)
+        .action((options) => runCommand(async () => {
+        if (!Number.isInteger(options.limit) || options.limit <= 0) {
+            throw new CliCommandError("INVALID_ARGS", "--limit must be a positive integer");
+        }
+        const config = await requireConfig();
+        const response = await apiRequest(config, "/api/cli/audience/top-engagers", {
+            profileHandle: options.profile,
+            limit: options.limit,
+        });
+        printJson(response);
+    }));
+}

package/dist/commands/auth/login.js

@@ -0,0 +1,153 @@
+import { randomUUID } from "node:crypto";
+import { createServer } from "node:http";
+import open from "open";
+import { runCommand } from "../../lib/command.js";
+import { saveConfig } from "../../lib/config.js";
+import { CliCommandError } from "../../types/index.js";
+const DEFAULT_APP_URL = process.env.CONTENT_INTEL_APP_URL?.trim() || "https://content-intel.com";
+const LOGIN_TIMEOUT_MS = (() => {
+    const raw = process.env.CONTENT_INTEL_LOGIN_TIMEOUT_MS?.trim();
+    if (!raw)
+        return 5 * 60 * 1000;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return 5 * 60 * 1000;
+    return parsed;
+})();
+export function validateLoginCallbackPayload(payload, expectedState) {
+    if (payload.state !== expectedState) {
+        throw new CliCommandError("AUTH_INVALID", "State validation failed.");
+    }
+    if (payload.error === "access_denied") {
+        throw new CliCommandError("AUTH_INVALID", "Authorization was cancelled.");
+    }
+    if (payload.error) {
+        throw new CliCommandError("AUTH_INVALID", `Authorization failed: ${payload.error}`);
+    }
+    if (!payload.token || !payload.apiUrl) {
+        throw new CliCommandError("AUTH_INVALID", "Missing token or apiUrl from callback.");
+    }
+    return {
+        token: payload.token,
+        apiUrl: payload.apiUrl,
+        email: payload.email,
+        name: payload.name,
+    };
+}
+function parseCallbackPayload(req) {
+    const url = new URL(req.url, "http://localhost");
+    return {
+        token: url.searchParams.get("token") ?? undefined,
+        email: url.searchParams.get("email") ?? undefined,
+        name: url.searchParams.get("name") ?? undefined,
+        apiUrl: url.searchParams.get("apiUrl") ?? undefined,
+        state: url.searchParams.get("state") ?? undefined,
+        error: url.searchParams.get("error") ?? undefined,
+    };
+}
+function sendBrowserResponse(res, message, statusCode = 200) {
+    res.statusCode = statusCode;
+    res.setHeader("Content-Type", "text/html; charset=utf-8");
+    res.end(`<!doctype html><html><body><p>${message}</p></body></html>`);
+}
+async function openBrowser(url) {
+    try {
+        await open(url);
+        /* c8 ignore next 3 */
+    }
+    catch {
+        // Fallback URL is always printed in terminal.
+    }
+}
+function resolveAppUrl(rawUrl) {
+    const trimmed = rawUrl?.trim();
+    if (!trimmed) {
+        throw new CliCommandError("INVALID_ARGS", "Missing app URL. Pass --url <URL> or set CONTENT_INTEL_APP_URL.");
+    }
+    let parsed;
+    try {
+        parsed = new URL(trimmed);
+    }
+    catch {
+        throw new CliCommandError("INVALID_ARGS", "Invalid app URL.");
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new CliCommandError("INVALID_ARGS", "Invalid app URL protocol. Use http:// or https://.");
+    }
+    return parsed.toString().replace(/\/$/, "");
+}
+export function registerAuthLoginCommand(authCommand) {
+    authCommand
+        .command("login")
+        .description("Authenticate CLI via browser")
+        .option("--url <url>", "Override web app URL (or set CONTENT_INTEL_APP_URL)")
+        .action((options) => runCommand(async () => {
+        if (process.env.SSH_CONNECTION) {
+            throw new CliCommandError("INVALID_ARGS", "SSH session detected. Use: content-intel auth set-token <TOKEN> --api-url <URL>");
+        }
+        const appUrl = resolveAppUrl(options.url ?? DEFAULT_APP_URL);
+        const state = randomUUID();
+        let timeoutId;
+        let resolvePayload;
+        const callbackPromise = new Promise((resolve) => {
+            resolvePayload = resolve;
+        });
+        const server = createServer((req, res) => {
+            const requestUrl = new URL(req.url, "http://localhost");
+            if (requestUrl.pathname !== "/callback") {
+                sendBrowserResponse(res, "Not found", 404);
+                return;
+            }
+            const payload = parseCallbackPayload(req);
+            if (payload.state !== state) {
+                sendBrowserResponse(res, "State mismatch. You can close this tab.", 400);
+                resolvePayload?.({ error: "invalid_state" });
+                return;
+            }
+            if (payload.error) {
+                sendBrowserResponse(res, "Authorization cancelled. You can close this tab.", 400);
+                resolvePayload?.(payload);
+                return;
+            }
+            sendBrowserResponse(res, "Login successful. You can close this tab.");
+            resolvePayload?.(payload);
+        });
+        try {
+            await new Promise((resolve, reject) => {
+                server.once("error", reject);
+                server.listen(0, "127.0.0.1", () => resolve());
+            });
+            const address = server.address();
+            /* c8 ignore next 6 */
+            if (!address || typeof address === "string") {
+                throw new CliCommandError("SERVER_ERROR", "Failed to start local callback server.");
+            }
+            const authUrl = `${appUrl}/cli/auth?state=${encodeURIComponent(state)}&port=${address.port}`;
+            await openBrowser(authUrl);
+            process.stdout.write(`If browser didn't open, visit: ${authUrl}\n`);
+            timeoutId = setTimeout(() => {
+                resolvePayload?.({ error: "timeout", state });
+            }, LOGIN_TIMEOUT_MS);
+            const payload = await callbackPromise;
+            if (payload.error === "timeout") {
+                throw new CliCommandError("AUTH_EXPIRED", "Login timed out. Run content-intel auth login to try again.");
+            }
+            const validated = validateLoginCallbackPayload(payload, state);
+            await saveConfig({
+                token: validated.token,
+                apiUrl: validated.apiUrl,
+                email: validated.email,
+                name: validated.name,
+            });
+            process.stdout.write(`Logged in as ${validated.email ?? "unknown user"}\n`);
+        }
+        finally {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            await new Promise((resolve) => {
+                server.close(() => resolve());
+            });
+        }
+    }));
+}

package/dist/commands/auth/logout.js

@@ -0,0 +1,11 @@
+import { runCommand } from "../../lib/command.js";
+import { clearConfig } from "../../lib/config.js";
+export function registerAuthLogoutCommand(authCommand) {
+    authCommand
+        .command("logout")
+        .description("Remove local CLI credentials")
+        .action(() => runCommand(async () => {
+        await clearConfig();
+        process.stdout.write("Logged out.\n");
+    }));
+}

package/dist/commands/auth/revoke.js

@@ -0,0 +1,18 @@
+import { runCommand, printJson } from "../../lib/command.js";
+import { requireConfig, clearConfig } from "../../lib/config.js";
+import { apiRequest } from "../../lib/client.js";
+export async function revokeCurrentAuth() {
+    const config = await requireConfig();
+    const response = await apiRequest(config, "/api/cli/auth/revoke", {});
+    await clearConfig();
+    return response;
+}
+export function registerAuthRevokeCommand(authCommand) {
+    authCommand
+        .command("revoke")
+        .description("Revoke current token and clear local config")
+        .action(() => runCommand(async () => {
+        const response = await revokeCurrentAuth();
+        printJson(response);
+    }));
+}

package/dist/commands/auth/set-token.js

@@ -0,0 +1,53 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { runCommand } from "../../lib/command.js";
+import { saveConfig } from "../../lib/config.js";
+import { CliCommandError } from "../../types/index.js";
+function normalizeApiUrl(raw) {
+    const value = raw.trim();
+    if (!/^https?:\/\//i.test(value)) {
+        throw new CliCommandError("INVALID_ARGS", "apiUrl must be an absolute URL, e.g. https://your-deployment.convex.site");
+    }
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        throw new CliCommandError("INVALID_ARGS", "apiUrl must be an absolute URL, e.g. https://your-deployment.convex.site");
+    }
+    if (parsed.hostname.endsWith(".convex.cloud")) {
+        parsed.hostname = parsed.hostname.replace(".convex.cloud", ".convex.site");
+    }
+    const normalizedPath = parsed.pathname.replace(/\/+$/, "");
+    return `${parsed.origin}${normalizedPath}`;
+}
+export function registerAuthSetTokenCommand(authCommand) {
+    authCommand
+        .command("set-token")
+        .description("Set token manually for headless/SSH environments")
+        .argument("<token>", "CLI token (ci_tok_...)")
+        .option("--api-url <url>", "Convex HTTP actions URL")
+        .action((token, options) => runCommand(async () => {
+        if (!token.startsWith("ci_tok_")) {
+            throw new CliCommandError("INVALID_ARGS", "Token format invalid. Expected token starting with ci_tok_.");
+        }
+        let apiUrl = options.apiUrl;
+        if (!apiUrl) {
+            const rl = createInterface({ input, output });
+            try {
+                apiUrl = await rl.question("Convex API URL (https://...convex.site): ");
+            }
+            finally {
+                rl.close();
+            }
+        }
+        if (!apiUrl) {
+            throw new CliCommandError("INVALID_ARGS", "apiUrl is required.");
+        }
+        await saveConfig({
+            token,
+            apiUrl: normalizeApiUrl(apiUrl),
+        });
+        process.stdout.write("Token saved.\n");
+    }));
+}

package/dist/commands/auth/status.js

@@ -0,0 +1,13 @@
+import { runCommand, printJson } from "../../lib/command.js";
+import { requireConfig } from "../../lib/config.js";
+import { apiRequest } from "../../lib/client.js";
+export function registerAuthStatusCommand(authCommand) {
+    authCommand
+        .command("status")
+        .description("Show current authentication status")
+        .action(() => runCommand(async () => {
+        const config = await requireConfig();
+        const response = await apiRequest(config, "/api/cli/auth/status", {});
+        printJson(response);
+    }));
+}

package/dist/commands/auth/token.js

@@ -0,0 +1,11 @@
+import { runCommand } from "../../lib/command.js";
+import { requireConfig } from "../../lib/config.js";
+export function registerAuthTokenCommand(authCommand) {
+    authCommand
+        .command("token")
+        .description("Print raw CLI token")
+        .action(() => runCommand(async () => {
+        const config = await requireConfig();
+        process.stdout.write(`${config.token}\n`);
+    }));
+}

package/dist/commands/config/path.js

@@ -0,0 +1,10 @@
+import { runCommand } from "../../lib/command.js";
+import { getConfigPath } from "../../lib/config.js";
+export function registerConfigPathCommand(configCommand) {
+    configCommand
+        .command("path")
+        .description("Print local config file path")
+        .action(() => runCommand(async () => {
+        process.stdout.write(`${getConfigPath()}\n`);
+    }));
+}

package/dist/commands/posts/list.js

@@ -0,0 +1,57 @@
+import { runCommand, printJson } from "../../lib/command.js";
+import { requireConfig } from "../../lib/config.js";
+import { apiRequest } from "../../lib/client.js";
+import { CliCommandError } from "../../types/index.js";
+function assertValidDate(raw) {
+    if (!raw)
+        return;
+    if (Number.isNaN(new Date(raw).getTime())) {
+        throw new CliCommandError("INVALID_ARGS", `Invalid date: ${raw}`);
+    }
+}
+export function registerPostsListCommand(postsCommand) {
+    postsCommand
+        .command("list")
+        .description("List posts with filters")
+        .option("--profile <handle>", "Profile handle (username, @username, or URL)")
+        .option("--days <n>", "Last N days", (value) => parseInt(value, 10))
+        .option("--since <date>", "Start date (ISO or YYYY-MM-DD)")
+        .option("--until <date>", "End date (ISO or YYYY-MM-DD)")
+        .option("--type <type>", "Post type: repost|video|image|carousel|text")
+        .option("--sort <field>", "Sort field: date|likes|comments|shares", "date")
+        .option("--sort-dir <dir>", "Sort direction: asc|desc", "desc")
+        .option("--hide-reposts", "Exclude reposts")
+        .option("--limit <n>", "Result limit", (value) => parseInt(value, 10), 50)
+        .option("--cursor <id>", "Pagination cursor")
+        .action((options) => runCommand(async () => {
+        if (options.days !== undefined && (!Number.isInteger(options.days) || options.days <= 0)) {
+            throw new CliCommandError("INVALID_ARGS", "--days must be a positive integer");
+        }
+        if (!Number.isInteger(options.limit) || options.limit <= 0) {
+            throw new CliCommandError("INVALID_ARGS", "--limit must be a positive integer");
+        }
+        assertValidDate(options.since);
+        assertValidDate(options.until);
+        if (options.since && options.until) {
+            const sinceMs = new Date(options.since).getTime();
+            const untilMs = new Date(options.until).getTime();
+            if (sinceMs > untilMs) {
+                throw new CliCommandError("INVALID_ARGS", "--since cannot be after --until");
+            }
+        }
+        const config = await requireConfig();
+        const response = await apiRequest(config, "/api/cli/posts/list", {
+            profileHandle: options.profile,
+            days: options.days,
+            since: options.since,
+            until: options.until,
+            type: options.type,
+            sort: options.sort,
+            sortDir: options.sortDir,
+            hideReposts: options.hideReposts,
+            limit: options.limit,
+            cursor: options.cursor,
+        });
+        printJson(response);
+    }));
+}

package/dist/commands/profiles/list.js

@@ -0,0 +1,13 @@
+import { runCommand, printJson } from "../../lib/command.js";
+import { requireConfig } from "../../lib/config.js";
+import { apiRequest } from "../../lib/client.js";
+export function registerProfilesListCommand(profilesCommand) {
+    profilesCommand
+        .command("list")
+        .description("List tracked LinkedIn profiles")
+        .action(() => runCommand(async () => {
+        const config = await requireConfig();
+        const response = await apiRequest(config, "/api/cli/profiles/list", {});
+        printJson(response);
+    }));
+}

package/dist/commands/sync/status.js

@@ -0,0 +1,22 @@
+import { runCommand, printJson } from "../../lib/command.js";
+import { requireConfig } from "../../lib/config.js";
+import { apiRequest } from "../../lib/client.js";
+import { CliCommandError } from "../../types/index.js";
+export function registerSyncStatusCommand(syncCommand) {
+    syncCommand
+        .command("status")
+        .description("Get sync status for tracked profiles")
+        .option("--profile <handle>", "Profile handle")
+        .option("--limit <n>", "Number of jobs per profile", (value) => parseInt(value, 10), 1)
+        .action((options) => runCommand(async () => {
+        if (!Number.isInteger(options.limit) || options.limit <= 0) {
+            throw new CliCommandError("INVALID_ARGS", "--limit must be a positive integer");
+        }
+        const config = await requireConfig();
+        const response = await apiRequest(config, "/api/cli/sync/status", {
+            profileHandle: options.profile,
+            limit: options.limit,
+        });
+        printJson(response);
+    }));
+}

package/dist/index.js

@@ -0,0 +1,42 @@
+import { readFileSync } from "node:fs";
+import { Command } from "commander";
+import { registerAuthLoginCommand } from "./commands/auth/login.js";
+import { registerAuthLogoutCommand } from "./commands/auth/logout.js";
+import { registerAuthStatusCommand } from "./commands/auth/status.js";
+import { registerAuthTokenCommand } from "./commands/auth/token.js";
+import { registerAuthSetTokenCommand } from "./commands/auth/set-token.js";
+import { registerAuthRevokeCommand } from "./commands/auth/revoke.js";
+import { registerProfilesListCommand } from "./commands/profiles/list.js";
+import { registerPostsListCommand } from "./commands/posts/list.js";
+import { registerAnalyticsOverviewCommand } from "./commands/analytics/overview.js";
+import { registerAudienceTopEngagersCommand } from "./commands/audience/top-engagers.js";
+import { registerSyncStatusCommand } from "./commands/sync/status.js";
+import { registerConfigPathCommand } from "./commands/config/path.js";
+const packageJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+const program = new Command();
+program
+    .name("content-intel")
+    .description("Content Intelligence CLI")
+    .version(packageJson.version);
+const authCommand = program.command("auth").description("Authentication commands");
+registerAuthLoginCommand(authCommand);
+registerAuthLogoutCommand(authCommand);
+registerAuthStatusCommand(authCommand);
+registerAuthTokenCommand(authCommand);
+registerAuthSetTokenCommand(authCommand);
+registerAuthRevokeCommand(authCommand);
+const profilesCommand = program.command("profiles").description("Profiles commands");
+registerProfilesListCommand(profilesCommand);
+const postsCommand = program.command("posts").description("Posts commands");
+registerPostsListCommand(postsCommand);
+const analyticsCommand = program
+    .command("analytics")
+    .description("Analytics commands");
+registerAnalyticsOverviewCommand(analyticsCommand);
+const audienceCommand = program.command("audience").description("Audience commands");
+registerAudienceTopEngagersCommand(audienceCommand);
+const syncCommand = program.command("sync").description("Sync commands");
+registerSyncStatusCommand(syncCommand);
+const configCommand = program.command("config").description("Config commands");
+registerConfigPathCommand(configCommand);
+void program.parseAsync(process.argv);

package/dist/lib/client.js

@@ -0,0 +1,110 @@
+import { CliCommandError, } from "../types/index.js";
+const CLI_ERROR_CODES = new Set([
+    "AUTH_REQUIRED",
+    "AUTH_EXPIRED",
+    "AUTH_INVALID",
+    "ACCESS_DENIED",
+    "NOT_FOUND",
+    "INVALID_ARGS",
+    "SERVER_ERROR",
+    "NETWORK_ERROR",
+]);
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function toCliErrorCode(code) {
+    if (typeof code === "string" && CLI_ERROR_CODES.has(code)) {
+        return code;
+    }
+    return "SERVER_ERROR";
+}
+function parseApiFailure(payload) {
+    if (!isObject(payload) || payload.ok !== false) {
+        return null;
+    }
+    const error = payload.error;
+    if (!isObject(error)) {
+        return null;
+    }
+    const message = typeof error.message === "string" && error.message.length > 0
+        ? error.message
+        : "Request failed with unknown server error";
+    return {
+        code: toCliErrorCode(error.code),
+        message,
+    };
+}
+function parsePlatformError(payload) {
+    if (!isObject(payload)) {
+        return null;
+    }
+    const rawCode = typeof payload.code === "string" ? payload.code : undefined;
+    const message = typeof payload.message === "string" && payload.message.trim().length > 0
+        ? payload.message
+        : undefined;
+    if (!rawCode && !message) {
+        return null;
+    }
+    if (rawCode === "InvalidDeploymentName") {
+        return {
+            code: "INVALID_ARGS",
+            message: message ??
+                "Invalid Convex deployment URL configured. Re-run content-intel auth login.",
+        };
+    }
+    return {
+        code: rawCode ? toCliErrorCode(rawCode) : "SERVER_ERROR",
+        message: message ?? "Request failed",
+    };
+}
+function isApiSuccess(payload) {
+    return isObject(payload) && payload.ok === true && "data" in payload;
+}
+export async function apiRequest(config, endpoint, body = {}, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 30_000;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(`${config.apiUrl}${endpoint}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${config.token}`,
+            },
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+        let payload = null;
+        try {
+            payload = await response.json();
+        }
+        catch {
+            payload = null;
+        }
+        if (response.ok && isApiSuccess(payload)) {
+            return payload;
+        }
+        const apiFailure = parseApiFailure(payload);
+        if (apiFailure) {
+            throw new CliCommandError(apiFailure.code, apiFailure.message, response.status);
+        }
+        const platformError = parsePlatformError(payload);
+        if (platformError) {
+            throw new CliCommandError(platformError.code, platformError.message, response.status);
+        }
+        throw new CliCommandError("SERVER_ERROR", `Request failed with status ${response.status}`, response.status);
+    }
+    catch (error) {
+        if (error instanceof CliCommandError) {
+            throw error;
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+            throw new CliCommandError("NETWORK_ERROR", "Request timed out. Please try again.");
+        }
+        const message = error instanceof Error ? error.message : "Network request failed";
+        throw new CliCommandError("NETWORK_ERROR", message);
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}

package/dist/lib/command.js

@@ -0,0 +1,31 @@
+import { CliCommandError, exitCodeForError, } from "../types/index.js";
+function errorCodeFromUnknown(error) {
+    if (error instanceof CliCommandError) {
+        return error.code;
+    }
+    return "SERVER_ERROR";
+}
+function errorMessageFromUnknown(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return "Unknown error";
+}
+export function printJson(data) {
+    process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+}
+export async function runCommand(action) {
+    try {
+        await action();
+    }
+    catch (error) {
+        printJson({
+            ok: false,
+            error: {
+                code: errorCodeFromUnknown(error),
+                message: errorMessageFromUnknown(error),
+            },
+        });
+        process.exitCode = exitCodeForError(error);
+    }
+}

package/dist/lib/config.js

@@ -0,0 +1,69 @@
+import { chmod, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { CliCommandError } from "../types/index.js";
+const CONFIG_DIR_NAME = ".content-intel";
+const CONFIG_FILE_NAME = "config.json";
+const CONFIG_DIR_ENV_VAR = "CONTENT_INTEL_CONFIG_DIR";
+export function getConfigDirPath() {
+    const overrideDir = process.env[CONFIG_DIR_ENV_VAR]?.trim();
+    if (overrideDir) {
+        return path.resolve(overrideDir);
+    }
+    return path.join(os.homedir(), CONFIG_DIR_NAME);
+}
+export function getConfigPath() {
+    return path.join(getConfigDirPath(), CONFIG_FILE_NAME);
+}
+async function ensureConfigDir() {
+    const dirPath = getConfigDirPath();
+    await mkdir(dirPath, { recursive: true, mode: 0o700 });
+    await chmod(dirPath, 0o700);
+}
+export async function loadConfig() {
+    try {
+        const raw = await readFile(getConfigPath(), "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed ||
+            typeof parsed.token !== "string" ||
+            typeof parsed.apiUrl !== "string") {
+            return null;
+        }
+        return {
+            token: parsed.token,
+            apiUrl: parsed.apiUrl,
+            email: parsed.email,
+            name: parsed.name,
+            createdAt: typeof parsed.createdAt === "number" ? parsed.createdAt : Date.now(),
+        };
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+export async function requireConfig() {
+    const config = await loadConfig();
+    if (!config) {
+        throw new CliCommandError("AUTH_REQUIRED", "No CLI credentials found. Run: content-intel auth login");
+    }
+    return config;
+}
+export async function saveConfig(config) {
+    await ensureConfigDir();
+    const payload = {
+        ...config,
+        createdAt: config.createdAt ?? Date.now(),
+    };
+    const configPath = getConfigPath();
+    await writeFile(configPath, `${JSON.stringify(payload, null, 2)}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    await chmod(configPath, 0o600);
+}
+export async function clearConfig() {
+    await rm(getConfigPath(), { force: true });
+}

package/dist/types/index.js

@@ -0,0 +1,24 @@
+export class CliCommandError extends Error {
+    code;
+    status;
+    constructor(code, message, status) {
+        super(message);
+        this.name = "CliCommandError";
+        this.code = code;
+        this.status = status;
+    }
+}
+export function exitCodeForError(error) {
+    if (error instanceof CliCommandError) {
+        if (error.code === "AUTH_REQUIRED" ||
+            error.code === "AUTH_EXPIRED" ||
+            error.code === "AUTH_INVALID") {
+            return 2;
+        }
+        if (error.code === "ACCESS_DENIED") {
+            return 3;
+        }
+        return 1;
+    }
+    return 1;
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@content-intel/cli",
+  "version": "0.1.0",
+  "description": "Command-line client for the Content Intelligence API",
+  "homepage": "https://github.com/Sales-Automation-Systems/content-intelligence/tree/main/cli#readme",
+  "bugs": {
+    "url": "https://github.com/Sales-Automation-Systems/content-intelligence/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Sales-Automation-Systems/content-intelligence.git",
+    "directory": "cli"
+  },
+  "type": "module",
+  "bin": {
+    "content-intel": "./bin/content-intel.js"
+  },
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "rm -rf dist && tsc",
+    "prepack": "npm run build",
+    "start": "node dist/index.js",
+    "test:unit": "tsx --test $(find src -type f -name '*.test.ts')",
+    "test": "c8 --all --include \"src/**/*.ts\" --exclude \"src/**/*.test.ts\" --exclude \"src/types/open.d.ts\" --check-coverage --lines 100 --functions 100 --branches 100 --statements 100 npm run test:unit"
+  },
+  "dependencies": {
+    "commander": "^14.0.3",
+    "open": "^10.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "c8": "^10.1.3",
+    "tsx": "^4.20.3",
+    "typescript": "^5.8.3"
+  }
+}