@reepl/cli 0.1.0

package/dist/core/index.d.ts

@@ -0,0 +1,525 @@
+/**
+ * Canonical Reepl endpoints and auth identifiers.
+ *
+ * These mirror the values the Reepl MCP server uses (reepl-mcp-server/wrangler.toml).
+ * The Cognito web-app client is a PUBLIC client (no secret) — safe to ship in a CLI.
+ */
+declare const REEPL_API_BASE_URL = "https://api.reepl.io/v1";
+/** HTTP API v2 used only by unauthenticated carousel generation (userID in body). */
+declare const REEPL_PUBLIC_API_BASE_URL = "https://4n7fgax35e.execute-api.eu-north-1.amazonaws.com/v1";
+declare const COGNITO_DOMAIN = "https://auth.reepl.io";
+/** Public Cognito app client (no secret) — the one the web app / MCP server refresh with. */
+declare const COGNITO_WEB_APP_CLIENT_ID = "7np7fkkg920i4pqvgsmbct7bnn";
+/** Web app that performs the login handoff and returns Cognito tokens. */
+declare const REEPL_WEB_APP_URL = "https://app.reepl.io";
+/** Path on the web app that brokers the token handoff for external clients. */
+declare const MCP_CONNECT_PATH = "/mcp-connect";
+/** Refresh the ID token this many ms before it actually expires. */
+declare const TOKEN_REFRESH_BUFFER_MS: number;
+
+/**
+ * Typed error hierarchy so both humans and agents can branch on a stable `code`.
+ *
+ * Every error carries a machine-readable `code` and a process `exitCode` the CLI maps
+ * straight to `process.exit`. Gating responses (plan/premium/reconnect) become distinct
+ * codes rather than an opaque HTTP 403.
+ */
+type ReeplErrorCode = "UNAUTHENTICATED" | "REFRESH_TOKEN_INVALID" | "PLAN_REQUIRED" | "PREMIUM_REQUIRED" | "RECONNECT_REQUIRED" | "MISSING_DM_SCOPES" | "GEMINI_NOT_LINKED" | "RATE_LIMITED" | "NOT_FOUND" | "VALIDATION" | "VERSION_CONFLICT" | "API_ERROR" | "NETWORK" | "CONFIG";
+declare class ReeplError extends Error {
+    readonly code: ReeplErrorCode;
+    readonly status?: number;
+    readonly details?: unknown;
+    constructor(code: ReeplErrorCode, message: string, opts?: {
+        status?: number;
+        details?: unknown;
+        cause?: unknown;
+    });
+    get exitCode(): number;
+    toJSON(): {
+        status?: number | undefined;
+        code: ReeplErrorCode;
+        message: string;
+    };
+}
+/**
+ * Map a raw backend error payload + HTTP status onto a typed ReeplError.
+ *
+ * The backend is inconsistent about where the machine code lives (`code`, `error`,
+ * `errorCode`), so we probe a few shapes and fall back to status-based classification.
+ */
+declare function parseApiError(status: number, raw: string): ReeplError;
+
+/** Persisted Cognito token set. `expiresAt` is epoch ms for the ID token. */
+interface StoredTokens {
+    idToken: string;
+    refreshToken: string;
+    accessToken?: string;
+    expiresAt: number;
+}
+/** Storage-agnostic token persistence. The CLI supplies a file/keychain-backed impl. */
+interface TokenStore {
+    load(): Promise<StoredTokens | null>;
+    save(tokens: StoredTokens): Promise<void>;
+    clear(): Promise<void>;
+}
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+interface RequestOptions {
+    method: HttpMethod;
+    path: string;
+    query?: Record<string, string | number | boolean | undefined | null>;
+    body?: unknown;
+    /** Attach the Bearer token. Default true. */
+    auth?: boolean;
+    /** Which gateway to hit. Default "api" (Cognito REST). */
+    base?: "api" | "public";
+    /**
+     * Workspace to scope the call to. When provided, it is placed as a query param for
+     * GET/DELETE and as a body field for POST/PUT/PATCH — matching backend convention.
+     * Pass `null` to explicitly omit even the client default.
+     */
+    workspace?: string | null;
+}
+/** Minimal shape of the account profile we rely on for `whoami` + gating hints. */
+interface AccountProfile {
+    userID?: string;
+    email?: string;
+    name?: string;
+    subscriptionType?: string;
+    subscription_status?: {
+        hasActivePurchase?: boolean;
+        status?: string;
+    };
+    credits_available?: number;
+    [key: string]: unknown;
+}
+interface Workspace {
+    id: string;
+    name?: string;
+    isDefault?: boolean;
+    [key: string]: unknown;
+}
+
+interface ReeplClientOptions {
+    /** Returns a valid ID token. Usually TokenManager.getIdToken bound. */
+    getToken: () => Promise<string>;
+    /** Default workspace injected into every scoped call unless overridden per-request. */
+    workspaceId?: string | null;
+    apiBaseUrl?: string;
+    publicBaseUrl?: string;
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Thin, typed HTTP client for the Reepl backend. All endpoint modules build on `request`.
+ * This is the single place that knows about auth headers, workspace placement, and error
+ * normalization — the reusable heart of api-core.
+ */
+declare class ReeplClient {
+    private getToken;
+    private workspaceId;
+    private apiBaseUrl;
+    private publicBaseUrl;
+    private fetchImpl;
+    constructor(opts: ReeplClientOptions);
+    request<T = unknown>(opts: RequestOptions): Promise<T>;
+    get<T = unknown>(path: string, opts?: Omit<RequestOptions, "method" | "path">): Promise<T>;
+    post<T = unknown>(path: string, opts?: Omit<RequestOptions, "method" | "path">): Promise<T>;
+    put<T = unknown>(path: string, opts?: Omit<RequestOptions, "method" | "path">): Promise<T>;
+    delete<T = unknown>(path: string, opts?: Omit<RequestOptions, "method" | "path">): Promise<T>;
+}
+
+interface TokenManagerOptions {
+    clientId?: string;
+    cognitoDomain?: string;
+    bufferMs?: number;
+    fetchImpl?: typeof fetch;
+    /** For deterministic tests. Defaults to Date.now. */
+    now?: () => number;
+}
+/**
+ * Returns a valid ID token, refreshing (and persisting) it when it is within the expiry
+ * buffer. Storage-agnostic: it delegates load/save to the injected TokenStore, so the CLI
+ * can back it with a file or OS keychain while core stays portable.
+ */
+declare class TokenManager {
+    private store;
+    private opts;
+    private inflight;
+    constructor(store: TokenStore, opts?: TokenManagerOptions);
+    private now;
+    /** Get a valid ID token or throw UNAUTHENTICATED if there are no stored credentials. */
+    getIdToken(): Promise<string>;
+    private resolveToken;
+}
+
+interface RefreshResult {
+    idToken: string;
+    accessToken?: string;
+    /** Seconds until the new ID token expires. */
+    expiresIn: number;
+}
+/**
+ * Decode a JWT payload without verifying the signature (we only need `exp`/claims,
+ * verification is the backend's job). Returns null on any malformed token.
+ */
+declare function decodeJwt(token: string): Record<string, unknown> | null;
+/** Epoch ms at which this ID token expires, or null if it has no `exp`. */
+declare function jwtExpiryMs(token: string): number | null;
+/**
+ * Exchange a Cognito refresh token for a fresh ID/access token via the public app client.
+ * Mirrors the MCP server's getValidIdToken refresh call (no Basic auth — public client).
+ */
+declare function refreshIdToken(refreshToken: string, opts?: {
+    clientId?: string;
+    cognitoDomain?: string;
+    fetchImpl?: typeof fetch;
+}): Promise<RefreshResult>;
+
+/** GET /account/profile — current authenticated user. */
+declare function getProfile(client: ReeplClient): Promise<AccountProfile>;
+/** Coarse paid/free signal derived from the profile, for gating hints in `whoami`. */
+declare function hasActivePlan(profile: AccountProfile): boolean;
+
+declare const profile_getProfile: typeof getProfile;
+declare const profile_hasActivePlan: typeof hasActivePlan;
+declare namespace profile {
+  export { profile_getProfile as getProfile, profile_hasActivePlan as hasActivePlan };
+}
+
+/**
+ * GET /organizations — list the user's workspaces (Cognito "organizations").
+ * Field names vary across the backend (organisationID/organization_id/id), so we
+ * normalize to a stable {id,name,isDefault} shape and flag the default.
+ */
+declare function listWorkspaces(client: ReeplClient): Promise<Workspace[]>;
+/** Resolve the default workspace id (or null if none is marked). */
+declare function getDefaultWorkspaceId(client: ReeplClient): Promise<string | null>;
+
+declare const workspaces_getDefaultWorkspaceId: typeof getDefaultWorkspaceId;
+declare const workspaces_listWorkspaces: typeof listWorkspaces;
+declare namespace workspaces {
+  export { workspaces_getDefaultWorkspaceId as getDefaultWorkspaceId, workspaces_listWorkspaces as listWorkspaces };
+}
+
+interface DraftInput {
+    content: string;
+    title?: string;
+    mediaUrls?: string[];
+    tags?: string[];
+}
+interface ScheduleInput {
+    content: string;
+    /** ISO-8601 timestamp. */
+    scheduledFor: string;
+    title?: string;
+    mediaUrls?: string[];
+}
+/** POST /post/drafts — create a LinkedIn post draft. */
+declare function createDraft$2(client: ReeplClient, input: DraftInput): Promise<unknown>;
+/** GET /post/drafts — list drafts. */
+declare function listDrafts$2(client: ReeplClient, opts?: {
+    limit?: number;
+    search?: string;
+    sortOrder?: string;
+}): Promise<unknown>;
+/** PUT /post/drafts — update a draft by id. */
+declare function updateDraft$1(client: ReeplClient, draftId: string, patch: Partial<DraftInput>): Promise<unknown>;
+/** DELETE /post/drafts?draftId= */
+declare function deleteDraft$2(client: ReeplClient, draftId: string): Promise<unknown>;
+/** POST /linkedin/posts — publish immediately. */
+declare function publishNow(client: ReeplClient, input: DraftInput): Promise<unknown>;
+/** POST /linkedin/posts/schedule — schedule for a future time. */
+declare function schedulePost(client: ReeplClient, input: ScheduleInput): Promise<unknown>;
+/** GET /linkedin/posts?status= — list published/scheduled/failed posts. */
+declare function listPosts$1(client: ReeplClient, opts?: {
+    status?: "scheduled" | "published" | "failed" | "all";
+    limit?: number;
+    search?: string;
+    nextToken?: string;
+    userId?: string;
+}): Promise<unknown>;
+/** PUT /linkedin/posts/{id}/schedule — reschedule (also used for publish-now = now). */
+declare function updateScheduledPost(client: ReeplClient, postId: string, patch: {
+    content?: string;
+    scheduledFor?: string;
+    mediaUrls?: string[];
+}): Promise<unknown>;
+/** DELETE /linkedin/posts/{id} */
+declare function deletePost$1(client: ReeplClient, postId: string): Promise<unknown>;
+/**
+ * POST /linkedin/posts/{id}/comments — comment on a LinkedIn post.
+ * NOTE: `postId` is Reepl's internal post id (resolved via the postId-index GSI), NOT a
+ * public LinkedIn activity URL. Only posts published/tracked through Reepl are commentable
+ * via this API; arbitrary public LinkedIn URLs are not addressable here.
+ */
+declare function addComment(client: ReeplClient, postId: string, commentText: string): Promise<unknown>;
+
+type linkedin_DraftInput = DraftInput;
+type linkedin_ScheduleInput = ScheduleInput;
+declare const linkedin_addComment: typeof addComment;
+declare const linkedin_publishNow: typeof publishNow;
+declare const linkedin_schedulePost: typeof schedulePost;
+declare const linkedin_updateScheduledPost: typeof updateScheduledPost;
+declare namespace linkedin {
+  export { type linkedin_DraftInput as DraftInput, type linkedin_ScheduleInput as ScheduleInput, linkedin_addComment as addComment, createDraft$2 as createDraft, deleteDraft$2 as deleteDraft, deletePost$1 as deletePost, listDrafts$2 as listDrafts, listPosts$1 as listPosts, linkedin_publishNow as publishNow, linkedin_schedulePost as schedulePost, updateDraft$1 as updateDraft, linkedin_updateScheduledPost as updateScheduledPost };
+}
+
+interface Tweet {
+    text: string;
+    mediaUrls?: string[];
+}
+interface TwitterPostInput {
+    /** One entry per tweet in the thread. A single tweet = a one-element array. */
+    threadTweets: Tweet[];
+    scheduledFor?: string;
+    quoteTweetId?: string;
+    linkedPostId?: string;
+}
+/** POST /twitter/posts — create/schedule a tweet or thread. `twitter_create_post` is paid-gated. */
+declare function createPost(client: ReeplClient, input: TwitterPostInput): Promise<unknown>;
+/** GET /twitter/posts?status= */
+declare function listPosts(client: ReeplClient, opts?: {
+    status?: string;
+    limit?: number;
+    search?: string;
+    nextToken?: string;
+}): Promise<unknown>;
+/** PUT /twitter/posts/{id} */
+declare function updatePost(client: ReeplClient, postId: string, patch: Partial<TwitterPostInput>): Promise<unknown>;
+/** DELETE /twitter/posts/{id} */
+declare function deletePost(client: ReeplClient, postId: string): Promise<unknown>;
+/** POST /twitter/drafts — create a draft tweet/thread. */
+declare function createDraft$1(client: ReeplClient, input: TwitterPostInput & {
+    title?: string;
+}): Promise<unknown>;
+/** GET /twitter/drafts */
+declare function listDrafts$1(client: ReeplClient, opts?: {
+    limit?: number;
+    search?: string;
+}): Promise<unknown>;
+/** DELETE /twitter/drafts?draftId= */
+declare function deleteDraft$1(client: ReeplClient, draftId: string): Promise<unknown>;
+/**
+ * POST /twitter/engagement/reply — publish a reply to a tweet by id.
+ * Premium-gated; costs engagement credits. Works for any tweet id (extractable from a URL).
+ */
+declare function reply(client: ReeplClient, tweetId: string, text: string): Promise<unknown>;
+
+type twitter_Tweet = Tweet;
+type twitter_TwitterPostInput = TwitterPostInput;
+declare const twitter_createPost: typeof createPost;
+declare const twitter_deletePost: typeof deletePost;
+declare const twitter_listPosts: typeof listPosts;
+declare const twitter_reply: typeof reply;
+declare const twitter_updatePost: typeof updatePost;
+declare namespace twitter {
+  export { type twitter_Tweet as Tweet, type twitter_TwitterPostInput as TwitterPostInput, createDraft$1 as createDraft, twitter_createPost as createPost, deleteDraft$1 as deleteDraft, twitter_deletePost as deletePost, listDrafts$1 as listDrafts, twitter_listPosts as listPosts, twitter_reply as reply, twitter_updatePost as updatePost };
+}
+
+interface ScheduledItem {
+    platform: "linkedin" | "x";
+    id: string;
+    scheduledFor?: string;
+    status?: string;
+    content: string;
+}
+/**
+ * Aggregate the content calendar (scheduled posts) across LinkedIn and X. There is no
+ * dedicated calendar endpoint — it is built from each platform's scheduled feed.
+ * X errors (e.g. account not connected) are swallowed so LinkedIn still renders.
+ */
+declare function getSchedule(client: ReeplClient, opts?: {
+    platform?: "linkedin" | "x" | "all";
+    limit?: number;
+}): Promise<ScheduledItem[]>;
+
+type calendar_ScheduledItem = ScheduledItem;
+declare const calendar_getSchedule: typeof getSchedule;
+declare namespace calendar {
+  export { type calendar_ScheduledItem as ScheduledItem, calendar_getSchedule as getSchedule };
+}
+
+/**
+ * GET /reddit/discovery/search?keyword= — on-demand Reddit keyword discovery.
+ * Pro-gated (403 UPGRADE_REQUIRED -> PLAN_REQUIRED); rate-limited per user.
+ */
+declare function search(client: ReeplClient, keyword: string): Promise<unknown>;
+/** GET /reddit/discovery/status — remaining search quota / status. */
+declare function searchStatus(client: ReeplClient): Promise<unknown>;
+/**
+ * POST /reddit/comment — comment on (reply to) a Reddit submission.
+ * `postId` may be a bare id or a `t3_`-prefixed thing id (backend normalizes).
+ * No plan gate; requires a connected Reddit integration (403 reddit_not_connected).
+ */
+declare function comment(client: ReeplClient, postId: string, text: string): Promise<unknown>;
+
+declare const reddit_comment: typeof comment;
+declare const reddit_search: typeof search;
+declare const reddit_searchStatus: typeof searchStatus;
+declare namespace reddit {
+  export { reddit_comment as comment, reddit_search as search, reddit_searchStatus as searchStatus };
+}
+
+/**
+ * GET /signals — the user's personalized signals inbox (Reddit / YouTube / RSS / trends).
+ * NOTE: the route is `/signals`, not `/signals/inbox`. The live MCP server calls
+ * `/signals/inbox`, but that route isn't Cognito-authorized (AWS returns an auth-header
+ * error) and the MCP tool silently reports "no signals" — verified against the live API.
+ */
+declare function getInbox(client: ReeplClient): Promise<unknown>;
+
+declare const signals_getInbox: typeof getInbox;
+declare namespace signals {
+  export { signals_getInbox as getInbox };
+}
+
+interface SlideInput {
+    headline?: string;
+    title?: string;
+    body?: string;
+    content?: string;
+    layout?: string;
+    layoutType?: string;
+}
+/** Map user-facing slide shapes to the backend `carousels[]` item shape. */
+declare function mapSlides(slides: SlideInput[]): Array<Record<string, unknown>>;
+/** GET /carousel/drafts — list drafts. */
+declare function listDrafts(client: ReeplClient, opts?: {
+    limit?: number;
+    search?: string;
+}): Promise<unknown>;
+/** GET /carousel/drafts?draftId= — get a single draft. */
+declare function getDraft(client: ReeplClient, draftId: string): Promise<unknown>;
+interface CarouselDraftInput {
+    title: string;
+    slides: SlideInput[];
+    theme?: string;
+    titleFontSize?: string;
+    bodyFontSize?: string;
+}
+/** POST /carousel/drafts — create a carousel draft. */
+declare function createDraft(client: ReeplClient, input: CarouselDraftInput): Promise<unknown>;
+interface CarouselUpdateInput {
+    title?: string;
+    slides?: SlideInput[];
+    theme?: string;
+    titleFontSize?: string;
+    bodyFontSize?: string;
+}
+/** PUT /carousel/drafts — update a draft. Only provided fields change. */
+declare function updateDraft(client: ReeplClient, draftId: string, patch: CarouselUpdateInput): Promise<unknown>;
+/** DELETE /carousel/drafts?draftId= */
+declare function deleteDraft(client: ReeplClient, draftId: string): Promise<unknown>;
+interface GenerateInput {
+    topic?: string;
+    url?: string;
+    numberOfSlides?: number;
+    aiInstructions?: string;
+}
+/**
+ * POST /carousel (public HTTP API) — AI-generate slides. Unauthenticated: the caller's
+ * userID goes in the body. Returns generated slides (not a saved draft).
+ */
+declare function generate(client: ReeplClient, userID: string, input: GenerateInput): Promise<unknown>;
+
+type carousel_CarouselDraftInput = CarouselDraftInput;
+type carousel_CarouselUpdateInput = CarouselUpdateInput;
+type carousel_GenerateInput = GenerateInput;
+type carousel_SlideInput = SlideInput;
+declare const carousel_createDraft: typeof createDraft;
+declare const carousel_deleteDraft: typeof deleteDraft;
+declare const carousel_generate: typeof generate;
+declare const carousel_getDraft: typeof getDraft;
+declare const carousel_listDrafts: typeof listDrafts;
+declare const carousel_mapSlides: typeof mapSlides;
+declare const carousel_updateDraft: typeof updateDraft;
+declare namespace carousel {
+  export { type carousel_CarouselDraftInput as CarouselDraftInput, type carousel_CarouselUpdateInput as CarouselUpdateInput, type carousel_GenerateInput as GenerateInput, type carousel_SlideInput as SlideInput, carousel_createDraft as createDraft, carousel_deleteDraft as deleteDraft, carousel_generate as generate, carousel_getDraft as getDraft, carousel_listDrafts as listDrafts, carousel_mapSlides as mapSlides, carousel_updateDraft as updateDraft };
+}
+
+/** Facets are plural in the backend: posts | comments | messages (singular is normalized). */
+type StyleFacet = "posts" | "comments" | "messages";
+/** GET /writing-style — summary of all facets + visibility. Requires workspace_id. */
+declare function get$1(client: ReeplClient): Promise<unknown>;
+/** POST /writing-style/override — save per-facet override instructions. */
+declare function override(client: ReeplClient, facet: string, instructions: string): Promise<unknown>;
+/** POST /writing-style/visibility — set visibility. */
+declare function setVisibility(client: ReeplClient, visibility: string): Promise<unknown>;
+/** POST /writing-style/train — (re)synthesize a facet's style. Pro+; posts/comments only. */
+declare function train(client: ReeplClient, facet: string): Promise<unknown>;
+/** POST /ai/test-voice-style — faceted playground: baseline vs styled generation. */
+declare function testVoiceStyle(client: ReeplClient, facet: string, input: string): Promise<unknown>;
+
+type writingStyle_StyleFacet = StyleFacet;
+declare const writingStyle_override: typeof override;
+declare const writingStyle_setVisibility: typeof setVisibility;
+declare const writingStyle_testVoiceStyle: typeof testVoiceStyle;
+declare const writingStyle_train: typeof train;
+declare namespace writingStyle {
+  export { type writingStyle_StyleFacet as StyleFacet, get$1 as get, writingStyle_override as override, writingStyle_setVisibility as setVisibility, writingStyle_testVoiceStyle as testVoiceStyle, writingStyle_train as train };
+}
+
+/** GET /profile/voice-profile — current user's voice profile. */
+declare function get(client: ReeplClient): Promise<{
+    voiceProfile?: unknown;
+    hasProfile?: boolean;
+}>;
+/**
+ * PUT /profile/voice-profile — deep-merge update. Body may include allowAutoUpdate,
+ * isActive, userInstructions{...}, generatedProfile{...}, positioningProfile{...}.
+ */
+declare function update(client: ReeplClient, body: Record<string, unknown>): Promise<unknown>;
+
+declare const voice_get: typeof get;
+declare const voice_update: typeof update;
+declare namespace voice {
+  export { voice_get as get, voice_update as update };
+}
+
+/**
+ * X (Twitter) DM inbox. All write/refresh operations are Premium-gated
+ * (403 UPGRADE_REQUIRED). Note: the conversation id in the path is the participant's X
+ * user id, which is what both the read and send endpoints expect.
+ */
+/** POST /inbox/twitter/refresh — pull the latest DM events from X (Premium). */
+declare function refresh(client: ReeplClient): Promise<unknown>;
+/** GET /inbox/twitter/refresh-status — throttle / last-refresh status. */
+declare function refreshStatus(client: ReeplClient): Promise<unknown>;
+/** GET /inbox/twitter/conversations — cached conversation list. */
+declare function listConversations(client: ReeplClient, opts?: {
+    limit?: number;
+    offset?: number;
+}): Promise<unknown>;
+/** GET /inbox/twitter/conversations/{id}/messages — messages in one conversation. */
+declare function getMessages(client: ReeplClient, conversationId: string): Promise<unknown>;
+/**
+ * POST /inbox/twitter/conversations/{participantId}/messages — send/reply in a DM thread
+ * (Premium; costs credits). `participantId` is the conversation id from listConversations.
+ */
+declare function sendMessage(client: ReeplClient, participantId: string, text: string): Promise<unknown>;
+
+declare const dms_getMessages: typeof getMessages;
+declare const dms_listConversations: typeof listConversations;
+declare const dms_refresh: typeof refresh;
+declare const dms_refreshStatus: typeof refreshStatus;
+declare const dms_sendMessage: typeof sendMessage;
+declare namespace dms {
+  export { dms_getMessages as getMessages, dms_listConversations as listConversations, dms_refresh as refresh, dms_refreshStatus as refreshStatus, dms_sendMessage as sendMessage };
+}
+
+/**
+ * Resolve a post reference (URL or raw id) to a platform + addressable id.
+ * Used by `comment add` to route to the right endpoint from a single --url/--post arg.
+ */
+type PostPlatform = "linkedin" | "x" | "reddit";
+interface PostRef {
+    platform: PostPlatform;
+    /** The id passed to the platform's comment/reply endpoint. */
+    id: string;
+}
+/**
+ * Resolve a reference. `hint` forces a platform when the input is ambiguous (bare id).
+ * Throws with actionable guidance when it can't be resolved.
+ */
+declare function resolvePostRef(input: string, hint?: PostPlatform): PostRef;
+
+export { type AccountProfile, COGNITO_DOMAIN, COGNITO_WEB_APP_CLIENT_ID, type CarouselDraftInput, type CarouselUpdateInput, type HttpMethod, MCP_CONNECT_PATH, type PostPlatform, type PostRef, REEPL_API_BASE_URL, REEPL_PUBLIC_API_BASE_URL, REEPL_WEB_APP_URL, ReeplClient, type ReeplClientOptions, ReeplError, type ReeplErrorCode, type RefreshResult, type RequestOptions, type ScheduledItem, type SlideInput, type StoredTokens, type StyleFacet, TOKEN_REFRESH_BUFFER_MS, TokenManager, type TokenManagerOptions, type TokenStore, type Workspace, calendar, carousel, decodeJwt, dms, jwtExpiryMs, linkedin, parseApiError, profile, reddit, refreshIdToken, resolvePostRef, signals, twitter, voice, workspaces, writingStyle };

package/dist/core/index.js

@@ -0,0 +1,57 @@
+import {
+  COGNITO_DOMAIN,
+  COGNITO_WEB_APP_CLIENT_ID,
+  MCP_CONNECT_PATH,
+  REEPL_API_BASE_URL,
+  REEPL_PUBLIC_API_BASE_URL,
+  REEPL_WEB_APP_URL,
+  ReeplClient,
+  ReeplError,
+  TOKEN_REFRESH_BUFFER_MS,
+  TokenManager,
+  calendar_exports,
+  carousel_exports,
+  decodeJwt,
+  dms_exports,
+  jwtExpiryMs,
+  linkedin_exports,
+  parseApiError,
+  profile_exports,
+  reddit_exports,
+  refreshIdToken,
+  resolvePostRef,
+  signals_exports,
+  twitter_exports,
+  voice_exports,
+  workspaces_exports,
+  writingStyle_exports
+} from "../chunk-QSNFNE5Z.js";
+export {
+  COGNITO_DOMAIN,
+  COGNITO_WEB_APP_CLIENT_ID,
+  MCP_CONNECT_PATH,
+  REEPL_API_BASE_URL,
+  REEPL_PUBLIC_API_BASE_URL,
+  REEPL_WEB_APP_URL,
+  ReeplClient,
+  ReeplError,
+  TOKEN_REFRESH_BUFFER_MS,
+  TokenManager,
+  calendar_exports as calendar,
+  carousel_exports as carousel,
+  decodeJwt,
+  dms_exports as dms,
+  jwtExpiryMs,
+  linkedin_exports as linkedin,
+  parseApiError,
+  profile_exports as profile,
+  reddit_exports as reddit,
+  refreshIdToken,
+  resolvePostRef,
+  signals_exports as signals,
+  twitter_exports as twitter,
+  voice_exports as voice,
+  workspaces_exports as workspaces,
+  writingStyle_exports as writingStyle
+};
+//# sourceMappingURL=index.js.map

package/dist/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@reepl/cli",
+  "version": "0.1.0",
+  "description": "Reepl command-line interface — create, schedule, and manage LinkedIn / X / Reddit content, carousels, signals, DMs, and writing styles.",
+  "type": "module",
+  "bin": {
+    "reepl": "dist/cli/index.js"
+  },
+  "files": [
+    "dist",
+    "scripts/postinstall.mjs"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run --project unit",
+    "test:unit": "vitest run --project unit",
+    "test:e2e": "vitest run --project e2e",
+    "test:all": "vitest run",
+    "test:watch": "vitest --project unit",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build",
+    "postinstall": "node scripts/postinstall.mjs",
+    "reepl": "node --import tsx src/cli/index.ts"
+  },
+  "keywords": [
+    "reepl",
+    "linkedin",
+    "twitter",
+    "reddit",
+    "cli",
+    "social-media"
+  ],
+  "license": "UNLICENSED",
+  "dependencies": {
+    "commander": "^12.1.0",
+    "open": "^10.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "tsup": "^8.3.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  }
+}