npm - chirpie - Versions diffs - 0.1.0 - Mend

chirpie 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist/index.js +417 -0
package/package.json +27 -0

package/dist/index.js ADDED Viewed

@@ -0,0 +1,417 @@
+#!/usr/bin/env node
+// src/index.ts
+import { Command as Command9 } from "commander";
+// src/commands/auth.ts
+import { Command } from "commander";
+// src/lib/config.ts
+import { getConfig, saveConfig, deleteConfig, requireConfig } from "@chirpie/sdk";
+// src/lib/output.ts
+function json(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function table(rows) {
+  if (rows.length === 0) {
+    console.log("No results.");
+    return;
+  }
+  console.table(rows);
+}
+function success(msg) {
+  console.log(`\x1B[32m\u2713\x1B[0m ${msg}`);
+}
+function error(msg) {
+  console.error(`\x1B[31m\u2717\x1B[0m ${msg}`);
+}
+function info(msg) {
+  console.log(`\x1B[36m\u2139\x1B[0m ${msg}`);
+}
+// src/commands/auth.ts
+import { createInterface } from "readline";
+var authCommand = new Command("auth").description("Configure your Chirpie API key").option("--key <key>", "API key (or enter interactively)").option("--base-url <url>", "Base URL (default: https://chirpie.ai)").action(async (opts) => {
+  let apiKey = opts.key;
+  if (!apiKey) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    apiKey = await new Promise((resolve) => {
+      rl.question("Enter your Chirpie API key: ", (answer) => {
+        rl.close();
+        resolve(answer.trim());
+      });
+    });
+  }
+  if (!apiKey || !apiKey.startsWith("chirpie_sk_")) {
+    console.error("Invalid API key. Keys start with chirpie_sk_");
+    process.exit(1);
+  }
+  saveConfig(apiKey, opts.baseUrl);
+  success("API key saved to ~/.chirpie/config.json");
+});
+var whoamiCommand = new Command("whoami").description("Check your authentication status").action(() => {
+  const config = getConfig();
+  if (!config) {
+    console.log("Not authenticated. Run: chirpie auth");
+    return;
+  }
+  info(`API key: ${config.api_key.slice(0, 20)}...`);
+  info(`Base URL: ${config.base_url}`);
+});
+// src/commands/login.ts
+import { Command as Command2 } from "commander";
+import { createServer } from "http";
+import { randomBytes } from "crypto";
+import { exec } from "child_process";
+import { platform } from "os";
+function openBrowser(url) {
+  const cmd = platform() === "darwin" ? "open" : platform() === "win32" ? "start" : "xdg-open";
+  exec(`${cmd} "${url}"`);
+}
+var loginCommand = new Command2("login").description("Authenticate with your Chirpie account (opens browser)").option("--base-url <url>", "Base URL", "https://chirpie.ai").action(async (opts) => {
+  const existing = getConfig();
+  if (existing) {
+    info(`Already authenticated (${existing.api_key.slice(0, 20)}...)`);
+    info("Run chirpie logout to sign out first, or chirpie auth --key to change keys.");
+    return;
+  }
+  const state = randomBytes(16).toString("hex");
+  const baseUrl = opts.baseUrl;
+  const server = createServer((req, res) => {
+    const url = new URL(req.url ?? "/", `http://localhost`);
+    if (url.pathname === "/callback") {
+      const key = url.searchParams.get("key");
+      const returnedState = url.searchParams.get("state");
+      res.writeHead(200, {
+        "Content-Type": "text/html",
+        "Access-Control-Allow-Origin": "*"
+      });
+      if (!key || returnedState !== state) {
+        res.end("<html><body><h2>Authorization failed.</h2><p>State mismatch or missing key. Please try again.</p></body></html>");
+        error("Authorization failed \u2014 state mismatch");
+        server.close();
+        process.exit(1);
+      }
+      res.end("<html><body><h2>CLI authorized!</h2><p>You can close this tab.</p></body></html>");
+      saveConfig(key, baseUrl);
+      console.log("");
+      success("Logged in to Chirpie!");
+      info(`API key saved to ~/.chirpie/config.json`);
+      server.close();
+      process.exit(0);
+    } else {
+      res.writeHead(200, {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET"
+      });
+      res.end();
+    }
+  });
+  server.listen(0, () => {
+    const addr = server.address();
+    if (!addr || typeof addr === "string") {
+      error("Failed to start local server");
+      process.exit(1);
+    }
+    const port = addr.port;
+    const authUrl = `${baseUrl}/auth/cli?port=${port}&state=${state}`;
+    console.log("");
+    info("Opening browser to authenticate...");
+    info(`If the browser doesn't open, visit:
+  ${authUrl}
+`);
+    openBrowser(authUrl);
+    setTimeout(() => {
+      error("Login timed out. Please try again.");
+      server.close();
+      process.exit(1);
+    }, 5 * 60 * 1e3);
+  });
+});
+var logoutCommand = new Command2("logout").description("Remove stored authentication").action(async () => {
+  const { deleteConfig: deleteConfig2 } = await import("@chirpie/sdk");
+  if (deleteConfig2()) {
+    success("Logged out. API key removed from ~/.chirpie/config.json");
+  } else {
+    info("Not logged in.");
+  }
+});
+// src/commands/post.ts
+import { Command as Command3 } from "commander";
+// src/lib/client.ts
+import { ChirpieClient } from "@chirpie/sdk";
+function getClient() {
+  const config = requireConfig();
+  return new ChirpieClient({
+    apiKey: config.api_key,
+    baseUrl: config.base_url
+  });
+}
+// src/commands/post.ts
+var postCommand = new Command3("post").description("Create a post on X").argument("<text>", "Post text (max 280 chars)").option("-a, --account <id>", "Account ID").option("-s, --schedule <datetime>", "Schedule for later (ISO 8601)").option("--json", "Output raw JSON").action(async (text, opts) => {
+  const client = getClient();
+  let accountId = opts.account;
+  if (!accountId) {
+    const accounts = await client.listAccounts();
+    const active = accounts.filter((a) => a.is_active);
+    if (active.length === 0) {
+      error("No connected accounts. Run: chirpie accounts connect");
+      process.exit(1);
+    }
+    if (active.length > 1) {
+      error("Multiple accounts found. Use --account <id> to specify:");
+      active.forEach((a) => console.log(`  ${a.id}  @${a.x_username}`));
+      process.exit(1);
+    }
+    accountId = active[0].id;
+  }
+  try {
+    const post = await client.createPost({
+      account_id: accountId,
+      text,
+      schedule_at: opts.schedule
+    });
+    if (opts.json) {
+      json(post);
+    } else if (post.status === "scheduled") {
+      success(`Post scheduled for ${post.scheduled_at} (${post.id})`);
+    } else {
+      success(`Post created (${post.id})`);
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : "Failed to create post");
+    process.exit(1);
+  }
+});
+// src/commands/thread.ts
+import { Command as Command4 } from "commander";
+var threadCommand = new Command4("thread").description("Create a thread on X").argument("<posts...>", "Thread posts (each argument is one post)").option("-a, --account <id>", "Account ID").option("-s, --schedule <datetime>", "Schedule for later (ISO 8601)").option("--json", "Output raw JSON").action(async (posts, opts) => {
+  const client = getClient();
+  let accountId = opts.account;
+  if (!accountId) {
+    const accounts = await client.listAccounts();
+    const active = accounts.filter((a) => a.is_active);
+    if (active.length === 0) {
+      error("No connected accounts. Run: chirpie accounts connect");
+      process.exit(1);
+    }
+    if (active.length > 1) {
+      error("Multiple accounts found. Use --account <id> to specify:");
+      active.forEach((a) => console.log(`  ${a.id}  @${a.x_username}`));
+      process.exit(1);
+    }
+    accountId = active[0].id;
+  }
+  if (posts.length < 2) {
+    error("Thread must have at least 2 posts");
+    process.exit(1);
+  }
+  try {
+    const thread = await client.createThread({
+      account_id: accountId,
+      posts: posts.map((text) => ({ text })),
+      schedule_at: opts.schedule
+    });
+    if (opts.json) {
+      json(thread);
+    } else {
+      success(`Thread created with ${thread.posts.length} posts (${thread.id})`);
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : "Failed to create thread");
+    process.exit(1);
+  }
+});
+// src/commands/posts.ts
+import { Command as Command5 } from "commander";
+var postsCommand = new Command5("posts").description("List, get, or delete posts").option("--status <status>", "Filter by status").option("--account <id>", "Filter by account").option("--limit <n>", "Limit results", "20").option("--json", "Output raw JSON").action(async (opts) => {
+  const client = getClient();
+  try {
+    const posts = await client.listPosts({
+      status: opts.status,
+      account_id: opts.account,
+      limit: parseInt(opts.limit)
+    });
+    if (opts.json) {
+      json(posts);
+    } else {
+      table(
+        posts.map((p) => ({
+          id: p.id.slice(0, 8),
+          status: p.status,
+          text: p.text.length > 50 ? p.text.slice(0, 50) + "..." : p.text,
+          created: p.created_at.slice(0, 10)
+        }))
+      );
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : "Failed to list posts");
+    process.exit(1);
+  }
+});
+postsCommand.command("get <id>").description("Get a post by ID").option("--json", "Output raw JSON").action(async (id, opts) => {
+  const client = getClient();
+  try {
+    const post = await client.getPost(id);
+    if (opts.json) {
+      json(post);
+    } else {
+      console.log(`ID:        ${post.id}`);
+      console.log(`Status:    ${post.status}`);
+      console.log(`Text:      ${post.text}`);
+      console.log(`Created:   ${post.created_at}`);
+      if (post.scheduled_at) console.log(`Scheduled: ${post.scheduled_at}`);
+      if (post.published_at) console.log(`Published: ${post.published_at}`);
+      if (post.platform_post_id) console.log(`X Post ID: ${post.platform_post_id}`);
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : "Failed to get post");
+    process.exit(1);
+  }
+});
+postsCommand.command("delete <id>").description("Delete a post").action(async (id) => {
+  const client = getClient();
+  try {
+    await client.deletePost(id);
+    success(`Post ${id} deleted`);
+  } catch (err) {
+    error(err instanceof Error ? err.message : "Failed to delete post");
+    process.exit(1);
+  }
+});
+// src/commands/accounts.ts
+import { Command as Command6 } from "commander";
+var accountsCommand = new Command6("accounts").description("List connected X accounts").option("--json", "Output raw JSON").action(async (opts) => {
+  const client = getClient();
+  try {
+    const accounts = await client.listAccounts();
+    if (opts.json) {
+      json(accounts);
+    } else {
+      table(
+        accounts.map((a) => ({
+          id: a.id.slice(0, 8),
+          username: `@${a.x_username}`,
+          name: a.x_display_name ?? "",
+          active: a.is_active ? "\u2713" : "\u2717"
+        }))
+      );
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : "Failed to list accounts");
+    process.exit(1);
+  }
+});
+accountsCommand.command("connect").description("Connect a new X account").action(async () => {
+  const client = getClient();
+  try {
+    const result = await client.connectAccount();
+    info("Open this URL in your browser to connect your X account:");
+    console.log(`
+  ${result.authorization_url}
+`);
+  } catch (err) {
+    error(err instanceof Error ? err.message : "Failed to start connection");
+    process.exit(1);
+  }
+});
+// src/commands/analytics.ts
+import { Command as Command7 } from "commander";
+var analyticsCommand = new Command7("analytics").description("Get analytics for a post").argument("<post_id>", "Post ID").option("--json", "Output raw JSON").action(async (postId, opts) => {
+  const client = getClient();
+  try {
+    const analytics = await client.getPostAnalytics(postId);
+    if (opts.json) {
+      json(analytics);
+    } else {
+      console.log(`Post:        ${analytics.post_id}`);
+      console.log(`Impressions: ${analytics.impressions.toLocaleString()}`);
+      console.log(`Likes:       ${analytics.likes.toLocaleString()}`);
+      console.log(`Retweets:    ${analytics.retweets.toLocaleString()}`);
+      console.log(`Replies:     ${analytics.replies.toLocaleString()}`);
+      console.log(`Quotes:      ${analytics.quotes.toLocaleString()}`);
+      console.log(`Bookmarks:   ${analytics.bookmarks.toLocaleString()}`);
+      console.log(`Clicks:      ${analytics.clicks.toLocaleString()}`);
+      console.log(`Fetched:     ${analytics.fetched_at}`);
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : "Failed to get analytics");
+    process.exit(1);
+  }
+});
+// src/commands/keys.ts
+import { Command as Command8 } from "commander";
+var keysCommand = new Command8("keys").description("Manage API keys").option("--json", "Output raw JSON").action(async (opts) => {
+  const client = getClient();
+  try {
+    const keys = await client.listKeys();
+    if (opts.json) {
+      json(keys);
+    } else {
+      table(
+        keys.map((k) => ({
+          id: k.id.slice(0, 8),
+          name: k.name,
+          prefix: k.key_prefix,
+          revoked: k.revoked ? "\u2717" : "",
+          last_used: k.last_used_at?.slice(0, 10) ?? "never"
+        }))
+      );
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : "Failed to list keys");
+    process.exit(1);
+  }
+});
+keysCommand.command("create").description("Create a new API key").option("-n, --name <name>", "Key name").option("--json", "Output raw JSON").action(async (opts) => {
+  const client = getClient();
+  try {
+    const key = await client.createKey(opts.name);
+    if (opts.json) {
+      json(key);
+    } else {
+      success("API key created. Save it \u2014 you won't see it again.");
+      console.log(`
+  ${key.key}
+`);
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : "Failed to create key");
+    process.exit(1);
+  }
+});
+keysCommand.command("revoke <id>").description("Revoke an API key").action(async (id) => {
+  const client = getClient();
+  try {
+    await client.revokeKey(id);
+    success(`Key ${id} revoked`);
+  } catch (err) {
+    error(err instanceof Error ? err.message : "Failed to revoke key");
+    process.exit(1);
+  }
+});
+// src/index.ts
+var program = new Command9().name("chirpie").description("Chirpie \u2014 the social media layer for AI agents").version("0.1.0");
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(authCommand);
+program.addCommand(whoamiCommand);
+program.addCommand(postCommand);
+program.addCommand(threadCommand);
+program.addCommand(postsCommand);
+program.addCommand(accountsCommand);
+program.addCommand(analyticsCommand);
+program.addCommand(keysCommand);
+program.parse();

package/package.json ADDED Viewed

@@ -0,0 +1,27 @@
+{
+  "name": "chirpie",
+  "version": "0.1.0",
+  "description": "Chirpie CLI — post to social media from the command line",
+  "repository": { "type": "git", "url": "https://github.com/Firefloco/chirpie", "directory": "packages/cli" },
+  "homepage": "https://chirpie.ai/docs/cli",
+  "publishConfig": { "access": "public" },
+  "type": "module",
+  "bin": {
+    "chirpie": "./dist/index.js"
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  },
+  "keywords": ["chirpie", "cli", "social-media", "twitter", "x"],
+  "license": "MIT",
+  "dependencies": {
+    "@chirpie/sdk": "^0.1.0",
+    "commander": "^13"
+  },
+  "devDependencies": {
+    "tsup": "^8",
+    "typescript": "^5"
+  }
+}