talkie-sync 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pretty Neat Sync
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,50 @@
+# Talkie Sync Client
+
+TypeScript client library for Talkie Sync API.
+
+## Install
+
+```bash
+npm install talkie-sync
+```
+
+## Usage
+
+```typescript
+import { TalkieClient } from "talkie-sync";
+
+const client = new TalkieClient({
+  baseUrl: "https://your-server.com",
+  apiKey: "your-api-key",
+});
+
+// Create a pair (initiator)
+const { words, session_id, channel_id } = await client.createPair();
+
+// Claim a pair (matcher)
+const { session_id, channel_id } = await client.claimPair("aardvark absurd accrue");
+
+// Send a message
+await client.pushMessage(channel_id, "hello");
+
+// Poll for messages
+const { messages, next_seq } = await client.pollMessages(channel_id, 0, 25000);
+
+// Or list messages (no polling)
+const { messages } = await client.listMessages(channel_id);
+```
+
+## API
+
+- `createPair(channelId?, sessionId?)` — Create a new pair, returns words
+- `claimPair(words)` — Claim a pair with words
+- `pushMessage(channelId, payload)` — Send a message
+- `pollMessages(channelId, after?, timeout?)` — Long-poll for messages
+- `listMessages(channelId, after?)` — List messages without polling
+- `getUser()` — Get current user info
+- `listProjects()` — List projects
+- `getConfig()` — Get tier configuration
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "talkie-sync",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "typescript": "^5.8.0",
+    "vitest": "^3.1.0"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.0.0"
+  }
+}

package/src/client.ts

@@ -0,0 +1,126 @@
+import type {
+  CreatePairResponse,
+  ClaimPairRequest,
+  ClaimPairResponse,
+  PushMessageRequest,
+  MessageListResponse,
+  UserMe,
+  ConfigResponse,
+  Project,
+  ApiError,
+} from "./types";
+
+export interface TalkieClientOptions {
+  baseUrl: string;
+  apiKey: string;
+}
+
+export class TalkieClient {
+  private baseUrl: string;
+  private apiKey: string;
+
+  constructor(options: TalkieClientOptions) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.apiKey = options.apiKey;
+  }
+
+  private async request<T>(
+    method: string,
+    path: string,
+    body?: unknown
+  ): Promise<T> {
+    const headers: Record<string, string> = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json",
+    };
+
+    const init: RequestInit = {
+      method,
+      headers,
+    };
+
+    if (body) {
+      init.body = JSON.stringify(body);
+    }
+
+    const response = await fetch(`${this.baseUrl}${path}`, init);
+
+    if (!response.ok) {
+      const error: ApiError = await response.json().catch(() => ({
+        error: "Unknown error",
+      }));
+      throw new Error(`${error.error}: ${error.message || response.statusText}`);
+    }
+
+    return response.json();
+  }
+
+  async createPair(channelId?: string, sessionId?: string): Promise<CreatePairResponse> {
+    const query = new URLSearchParams();
+    if (channelId) query.set("channel_id", channelId);
+    if (sessionId) query.set("session_id", sessionId);
+    const qs = query.toString();
+    return this.request("POST", `/api/pair${qs ? `?${qs}` : ""}`);
+  }
+
+  async claimPair(words: string): Promise<ClaimPairResponse> {
+    return this.request<ClaimPairResponse>("POST", "/api/pair", { words } as ClaimPairRequest);
+  }
+
+  async pushMessage(channelId: string, payload: string): Promise<{ id: string }> {
+    const cleanChannelId = channelId.split(":")[0];
+    return this.request("POST", `/api/pair/${cleanChannelId}/messages`, { payload } as PushMessageRequest);
+  }
+
+  async pollMessages(channelId: string, after = 0, timeout?: number): Promise<MessageListResponse> {
+    const cleanChannelId = channelId.split(":")[0];
+    const params = new URLSearchParams({ after: String(after) });
+    if (timeout) params.set("timeout", String(timeout));
+    return this.request("GET", `/api/pair/${cleanChannelId}/messages?${params}`);
+  }
+
+  async listMessages(channelId: string, after = 0): Promise<MessageListResponse> {
+    const cleanChannelId = channelId.split(":")[0];
+    return this.request("GET", `/api/pair/${cleanChannelId}/messages?after=${after}`);
+  }
+
+  async getUser(): Promise<UserMe> {
+    return this.request("GET", "/api/user/me");
+  }
+
+  async listProjects(): Promise<{ projects: Project[] }> {
+    return this.request("GET", "/api/projects");
+  }
+
+  async getProject(id: string): Promise<Project> {
+    return this.request("GET", `/api/projects/${id}`);
+  }
+
+  async createProject(name: string): Promise<Project> {
+    return this.request("POST", "/api/projects", { name });
+  }
+
+  async deleteProject(id: string): Promise<{ success: boolean }> {
+    return this.request("DELETE", `/api/projects/${id}`);
+  }
+
+  async getConfig(): Promise<ConfigResponse> {
+    return this.request("GET", "/api/config/tiers");
+  }
+
+  async createCheckoutUrl(priceId: string, successUrl: string, cancelUrl: string): Promise<{ url: string }> {
+    return this.request("POST", "/api/billing/checkout", {
+      price_id: priceId,
+      success_url: successUrl,
+      cancel_url: cancelUrl,
+    });
+  }
+
+  async createPortalUrl(): Promise<{ url: string }> {
+    return this.request("POST", "/api/billing/portal");
+  }
+
+  async upgradeSubscription(priceId: string): Promise<{ success: boolean }> {
+    return this.request("POST", "/api/billing/upgrade", { price_id: priceId });
+  }
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+export { TalkieClient } from "./client";
+export type { TalkieClientOptions } from "./client";
+export type {
+  CreatePairResponse,
+  ClaimPairRequest,
+  ClaimPairResponse,
+  Message,
+  PushMessageRequest,
+  MessageListResponse,
+  Project,
+  UserMe,
+  TierConfig,
+  ConfigResponse,
+  ApiError,
+} from "./types";

package/src/types.ts

@@ -0,0 +1,66 @@
+export interface CreatePairResponse {
+  words: string;
+  session_id: string;
+  channel_id: string;
+  expires_in: number;
+}
+
+export interface ClaimPairRequest {
+  words: string;
+}
+
+export interface ClaimPairResponse {
+  session_id: string;
+  channel_id: string;
+}
+
+export interface Message {
+  id: string;
+  seq: number;
+  payload: string;
+  created_at: number;
+}
+
+export interface PushMessageRequest {
+  payload: string;
+}
+
+export interface MessageListResponse {
+  messages: Message[];
+  next_seq: number | null;
+}
+
+export interface Project {
+  id: string;
+  name: string;
+  tier: "free" | "creator" | "pro";
+  created_at: number;
+}
+
+export interface UserMe {
+  id: string;
+  email: string;
+  tier: string;
+  projects: Project[];
+}
+
+export interface TierConfig {
+  label: string;
+  maxProjects: number | null;
+  maxChannels: number | null;
+  maxPairsPerDay: number | null;
+  pairsPerMonth: number | null;
+  pairTTLSec: number | null;
+  creemProductId: string | null;
+  maxMessagesPerChannel: number | null;
+  messagesPerSecond: number | null;
+}
+
+export interface ConfigResponse {
+  tiers: Record<string, TierConfig>;
+}
+
+export interface ApiError {
+  error: string;
+  message?: string;
+}

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}