@chirag127/omni-publish 0.1.0 → 0.1.1

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 Chirag Singhal
-
-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.
+MIT License
+
+Copyright (c) 2026 Chirag Singhal
+
+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

@@ -1,66 +1,66 @@
-# @chirag127/omni-publish
-
-[![npm](https://img.shields.io/npm/v/@chirag127/omni-publish.svg)](https://www.npmjs.com/package/@chirag127/omni-publish)
-[![CI](https://github.com/chirag127/omni-publish-npm-pkg/actions/workflows/ci.yml/badge.svg)](https://github.com/chirag127/omni-publish-npm-pkg/actions/workflows/ci.yml)
-[![license: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
-
-Auto-publish release notes / blog posts to multiple platforms on tag push or release create. Platform fan-out is filtered by which env vars are set — if only `DEVTO_API_KEY` exists, only dev.to is targeted.
-
-## Install
-
-```sh
-npm i -D @chirag127/omni-publish
-# or
-pnpm add -D @chirag127/omni-publish
-```
-
-## Supported platforms / env vars
-
-Set the env var for each platform you want to publish to. Unset = skipped.
-
-| Platform     | Env var              |
-|--------------|----------------------|
-| dev.to       | `DEVTO_API_KEY`      |
-| Hashnode     | `HASHNODE_API_KEY`   |
-| Medium       | `MEDIUM_API_KEY`     |
-| X / Twitter  | `X_API_KEY`          |
-| LinkedIn     | `LINKEDIN_API_KEY`   |
-| Bluesky      | `BLUESKY_API_KEY`    |
-| Mastodon     | `MASTODON_API_KEY`   |
-| Reddit       | `REDDIT_API_KEY`     |
-
-## GitHub Actions
-
-```yaml
-name: Cross-post release
-on:
-  release: { types: [published] }
-  push: { tags: ['v*.*.*'] }
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with: { node-version: 22 }
-      - run: npx -y @chirag127/omni-publish
-        env:
-          DEVTO_API_KEY:    ${{ secrets.DEVTO_API_KEY }}
-          HASHNODE_API_KEY: ${{ secrets.HASHNODE_API_KEY }}
-          MEDIUM_API_KEY:   ${{ secrets.MEDIUM_API_KEY }}
-          X_API_KEY:        ${{ secrets.X_API_KEY }}
-          LINKEDIN_API_KEY: ${{ secrets.LINKEDIN_API_KEY }}
-          BLUESKY_API_KEY:  ${{ secrets.BLUESKY_API_KEY }}
-          MASTODON_API_KEY: ${{ secrets.MASTODON_API_KEY }}
-          REDDIT_API_KEY:   ${{ secrets.REDDIT_API_KEY }}
-```
-
-## Status
-
-`v0.1.x` — slug reservation + stub. Per-platform adapters land in `v0.1.1`.
-
-Part of the [`chirag127/oriz`](https://github.com/chirag127/oriz) family.
-
-## Cross-refs
-
-- [security policy](./SECURITY.md) · [code of conduct](./CODE_OF_CONDUCT.md) · [contributing](./CONTRIBUTING.md)
+# @chirag127/omni-publish
+
+[![npm](https://img.shields.io/npm/v/@chirag127/omni-publish.svg)](https://www.npmjs.com/package/@chirag127/omni-publish)
+[![CI](https://github.com/chirag127/omni-publish-npm-pkg/actions/workflows/ci.yml/badge.svg)](https://github.com/chirag127/omni-publish-npm-pkg/actions/workflows/ci.yml)
+[![license: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
+
+Auto-publish release notes / blog posts to multiple platforms on tag push or release create. Platform fan-out is filtered by which env vars are set — if only `DEVTO_API_KEY` exists, only dev.to is targeted.
+
+## Install
+
+```sh
+npm i -D @chirag127/omni-publish
+# or
+pnpm add -D @chirag127/omni-publish
+```
+
+## Supported platforms / env vars
+
+Set the env var for each platform you want to publish to. Unset = skipped.
+
+| Platform     | Env var              |
+|--------------|----------------------|
+| dev.to       | `DEVTO_API_KEY`      |
+| Hashnode     | `HASHNODE_API_KEY`   |
+| Medium       | `MEDIUM_API_KEY`     |
+| X / Twitter  | `X_API_KEY`          |
+| LinkedIn     | `LINKEDIN_API_KEY`   |
+| Bluesky      | `BLUESKY_API_KEY`    |
+| Mastodon     | `MASTODON_API_KEY`   |
+| Reddit       | `REDDIT_API_KEY`     |
+
+## GitHub Actions
+
+```yaml
+name: Cross-post release
+on:
+  release: { types: [published] }
+  push: { tags: ['v*.*.*'] }
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with: { node-version: 22 }
+      - run: npx -y @chirag127/omni-publish
+        env:
+          DEVTO_API_KEY:    ${{ secrets.DEVTO_API_KEY }}
+          HASHNODE_API_KEY: ${{ secrets.HASHNODE_API_KEY }}
+          MEDIUM_API_KEY:   ${{ secrets.MEDIUM_API_KEY }}
+          X_API_KEY:        ${{ secrets.X_API_KEY }}
+          LINKEDIN_API_KEY: ${{ secrets.LINKEDIN_API_KEY }}
+          BLUESKY_API_KEY:  ${{ secrets.BLUESKY_API_KEY }}
+          MASTODON_API_KEY: ${{ secrets.MASTODON_API_KEY }}
+          REDDIT_API_KEY:   ${{ secrets.REDDIT_API_KEY }}
+```
+
+## Status
+
+`v0.1.x` — slug reservation + stub. Per-platform adapters land in `v0.1.1`.
+
+Part of the [`chirag127/oriz`](https://github.com/chirag127/oriz) family.
+
+## Cross-refs
+
+- [security policy](./SECURITY.md) · [code of conduct](./CODE_OF_CONDUCT.md) · [contributing](./CONTRIBUTING.md)

package/bin/omni-publish.mjs

@@ -0,0 +1,291 @@
+#!/usr/bin/env node
+// omni-publish bin entry — plain ESM JS so npm doesn't strip the shebang
+// and we don't need a build step. Mirrors src/cli.ts logic via dynamic import
+// of the TS sources... except npm consumers can't run .ts directly.
+//
+// Strategy: this file inlines just enough to do the fan-out in pure JS using
+// Node 22+ native fetch. It imports @atproto/api lazily for Bluesky.
+
+import { createRequire } from 'node:module'
+const _require = createRequire(import.meta.url)
+void _require
+
+function parseArgs(argv) {
+  const out = {}
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i]
+    if (a.startsWith('--')) {
+      const key = a.slice(2)
+      const next = argv[i + 1]
+      if (next === undefined || next.startsWith('--')) {
+        out[key] = 'true'
+      } else {
+        out[key] = next
+        i++
+      }
+    }
+  }
+  return out
+}
+
+// ---------- adapters ----------
+
+async function devto(input) {
+  const apiKey = process.env.DEVTO_API_KEY
+  if (!apiKey) return { platform: 'dev.to', status: 'skipped' }
+  try {
+    const body = {
+      article: {
+        title: input.title,
+        body_markdown: input.body + '\n\n---\n\n*Originally posted at ' + input.canonical_url + '*',
+        published: true,
+        canonical_url: input.canonical_url,
+        tags: input.tags?.slice(0, 4),
+      },
+    }
+    const res = await fetch('https://dev.to/api/articles', {
+      method: 'POST',
+      headers: { 'api-key': apiKey, 'content-type': 'application/json' },
+      body: JSON.stringify(body),
+    })
+    if (!res.ok) {
+      const t = await res.text()
+      return { platform: 'dev.to', status: 'error', error: `HTTP ${res.status}: ${t.slice(0, 200)}` }
+    }
+    const json = await res.json()
+    return { platform: 'dev.to', status: 'ok', url: json.url }
+  } catch (e) {
+    return { platform: 'dev.to', status: 'error', error: String(e) }
+  }
+}
+
+async function hashnode(input) {
+  const apiKey = process.env.HASHNODE_API_KEY
+  const publicationId = process.env.HASHNODE_PUBLICATION_ID
+  if (!apiKey || !publicationId) return { platform: 'hashnode', status: 'skipped' }
+  try {
+    const MUT = `mutation PublishPost($input: PublishPostInput!) { publishPost(input: $input) { post { id slug url } } }`
+    const variables = {
+      input: {
+        title: input.title,
+        contentMarkdown: input.body,
+        publicationId,
+        originalArticleURL: input.canonical_url,
+        tags: (input.tags || []).map((t) => ({ slug: t.toLowerCase().replace(/\s+/g, '-'), name: t })),
+      },
+    }
+    const res = await fetch('https://gql.hashnode.com/', {
+      method: 'POST',
+      headers: { Authorization: apiKey, 'content-type': 'application/json' },
+      body: JSON.stringify({ query: MUT, variables }),
+    })
+    if (!res.ok) {
+      const t = await res.text()
+      return { platform: 'hashnode', status: 'error', error: `HTTP ${res.status}: ${t.slice(0, 200)}` }
+    }
+    const json = await res.json()
+    if (json.errors) return { platform: 'hashnode', status: 'error', error: JSON.stringify(json.errors).slice(0, 200) }
+    return { platform: 'hashnode', status: 'ok', url: json.data?.publishPost?.post?.url }
+  } catch (e) {
+    return { platform: 'hashnode', status: 'error', error: String(e) }
+  }
+}
+
+async function bluesky(input) {
+  const handle = process.env.BLUESKY_HANDLE
+  const appPassword = process.env.BLUESKY_APP_PASSWORD
+  if (!handle || !appPassword) return { platform: 'bluesky', status: 'skipped' }
+  try {
+    const mod = await import('@atproto/api')
+    const AtpAgent = mod.AtpAgent || mod.default?.AtpAgent
+    const agent = new AtpAgent({ service: 'https://bsky.social' })
+    await agent.login({ identifier: handle, password: appPassword })
+    const text = `${input.title}\n\n${input.canonical_url}`.slice(0, 300)
+    const res = await agent.post({ text, createdAt: new Date().toISOString() })
+    return { platform: 'bluesky', status: 'ok', url: res.uri }
+  } catch (e) {
+    return { platform: 'bluesky', status: 'error', error: String(e) }
+  }
+}
+
+async function mastodon(input) {
+  const instance = process.env.MASTODON_INSTANCE
+  const token = process.env.MASTODON_ACCESS_TOKEN
+  if (!instance || !token) return { platform: 'mastodon', status: 'skipped' }
+  try {
+    let status = input.title + '\n\n' + input.canonical_url
+    if (status.length > 500) status = status.slice(0, 497) + '...'
+    const url = `https://${instance.replace(/^https?:\/\//, '').replace(/\/$/, '')}/api/v1/statuses`
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${token}`, 'content-type': 'application/json' },
+      body: JSON.stringify({ status, visibility: 'public' }),
+    })
+    if (!res.ok) {
+      const t = await res.text()
+      return { platform: 'mastodon', status: 'error', error: `HTTP ${res.status}: ${t.slice(0, 200)}` }
+    }
+    const json = await res.json()
+    return { platform: 'mastodon', status: 'ok', url: json.url }
+  } catch (e) {
+    return { platform: 'mastodon', status: 'error', error: String(e) }
+  }
+}
+
+async function threads(input) {
+  const token = process.env.THREADS_ACCESS_TOKEN
+  if (!token) return { platform: 'threads', status: 'skipped' }
+  try {
+    let text = input.title + '\n\n' + input.canonical_url
+    if (text.length > 500) text = text.slice(0, 497) + '...'
+    const createUrl = new URL('https://graph.threads.net/v1.0/me/threads')
+    createUrl.searchParams.set('media_type', 'TEXT')
+    createUrl.searchParams.set('text', text)
+    createUrl.searchParams.set('access_token', token)
+    const createRes = await fetch(createUrl.toString(), { method: 'POST' })
+    if (!createRes.ok) {
+      const t = await createRes.text()
+      return { platform: 'threads', status: 'error', error: `create HTTP ${createRes.status}: ${t.slice(0, 200)}` }
+    }
+    const createJson = await createRes.json()
+    if (!createJson.id) return { platform: 'threads', status: 'error', error: 'no creation_id returned' }
+    const pubUrl = new URL('https://graph.threads.net/v1.0/me/threads_publish')
+    pubUrl.searchParams.set('creation_id', createJson.id)
+    pubUrl.searchParams.set('access_token', token)
+    const pubRes = await fetch(pubUrl.toString(), { method: 'POST' })
+    if (!pubRes.ok) {
+      const t = await pubRes.text()
+      return { platform: 'threads', status: 'error', error: `publish HTTP ${pubRes.status}: ${t.slice(0, 200)}` }
+    }
+    const pubJson = await pubRes.json()
+    return { platform: 'threads', status: 'ok', url: pubJson.id ? `https://www.threads.net/@me/post/${pubJson.id}` : undefined }
+  } catch (e) {
+    return { platform: 'threads', status: 'error', error: String(e) }
+  }
+}
+
+// ---------- AI drafts ----------
+
+const PROMPTS = {
+  x: (title, body) => `Rewrite this release announcement as a Twitter/X post (280 char max), keeping the canonical URL. Be punchy. Source:\n\n${title}\n\n${body}`,
+  reddit: (title, body) => `Rewrite this release announcement as a Reddit self-post. Keep the full body but make it conversational and add a TL;DR at the top. Source:\n\n${title}\n\n${body}`,
+  linkedin: (title, body) => `Rewrite this release announcement as a LinkedIn post in a professional, slightly humble tone. ~3 short paragraphs. Source:\n\n${title}\n\n${body}`,
+  medium: (title, body) => `Rewrite this release announcement as a 1-paragraph Medium blurb (~80 words) suitable as a post intro. Source:\n\n${title}\n\n${body}`,
+}
+
+async function callChat(url, model, key, prompt) {
+  try {
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${key}`, 'content-type': 'application/json' },
+      body: JSON.stringify({ model, messages: [{ role: 'user', content: prompt }], temperature: 0.7, max_tokens: 512 }),
+    })
+    if (!res.ok) {
+      const text = await res.text()
+      return { ok: false, status: res.status, error: text.slice(0, 200) }
+    }
+    const json = await res.json()
+    const content = json.choices?.[0]?.message?.content?.trim()
+    if (!content) return { ok: false, error: 'empty response' }
+    return { ok: true, text: content }
+  } catch (e) {
+    return { ok: false, error: String(e) }
+  }
+}
+
+async function generateDraft(prompt) {
+  const nimKey = process.env.NVIDIA_NIM_API_KEY
+  const orKey = process.env.OPENROUTER_API_KEY
+  if (nimKey) {
+    const r = await callChat('https://integrate.api.nvidia.com/v1/chat/completions', 'meta/llama-3.3-70b-instruct', nimKey, prompt)
+    if (r.ok && r.text) return r.text
+  }
+  if (orKey) {
+    const r = await callChat('https://openrouter.ai/api/v1/chat/completions', 'meta-llama/llama-3.3-70b-instruct:free', orKey, prompt)
+    if (r.ok && r.text) return r.text
+  }
+  return null
+}
+
+async function sendTelegram(token, chatId, text) {
+  try {
+    const res = await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ chat_id: chatId, text, parse_mode: 'Markdown', disable_web_page_preview: false }),
+    })
+    if (!res.ok) {
+      const t = await res.text()
+      return { ok: false, error: `HTTP ${res.status}: ${t.slice(0, 200)}` }
+    }
+    return { ok: true }
+  } catch (e) {
+    return { ok: false, error: String(e) }
+  }
+}
+
+function makeDraftAdapter(platform, label) {
+  return async (input) => {
+    const name = `telegram-draft-${platform}`
+    const token = process.env.TELEGRAM_DRAFTS_BOT_TOKEN
+    const chatId = process.env.TELEGRAM_DRAFTS_CHAT_ID
+    if (!token || !chatId) return { platform: name, status: 'skipped' }
+    try {
+      const draft = await generateDraft(PROMPTS[platform](input.title, input.body))
+      if (!draft) return { platform: name, status: 'error', error: 'AI draft generation failed (no NIM/OpenRouter key or both errored)' }
+      const text = `📋 DRAFT (${label}) for: ${input.title}\n\n${draft}\n\nOriginal: ${input.canonical_url}`
+      const r = await sendTelegram(token, chatId, text)
+      if (!r.ok) return { platform: name, status: 'error', error: r.error }
+      return { platform: name, status: 'ok' }
+    } catch (e) {
+      return { platform: name, status: 'error', error: String(e) }
+    }
+  }
+}
+
+const DRAFT_ADAPTERS = [
+  makeDraftAdapter('x', 'X'),
+  makeDraftAdapter('reddit', 'Reddit'),
+  makeDraftAdapter('linkedin', 'LinkedIn'),
+  makeDraftAdapter('medium', 'Medium'),
+]
+
+const AUTO_ADAPTERS = [devto, hashnode, bluesky, mastodon, threads]
+
+async function publishAll(input) {
+  const all = [...AUTO_ADAPTERS, ...DRAFT_ADAPTERS]
+  return Promise.all(
+    all.map((fn) =>
+      fn(input).catch((e) => ({ platform: fn.name || 'unknown', status: 'error', error: String(e) }))
+    )
+  )
+}
+
+async function main() {
+  const args = parseArgs(process.argv)
+  if (!args.title || !args.canonical) {
+    console.error('Usage: omni-publish --title "..." --body "..." --canonical "..." --type <app|package|book|extension> [--tags a,b,c]')
+    process.exit(1)
+  }
+  const input = {
+    title: args.title,
+    body: args.body || '',
+    canonical_url: args.canonical,
+    type: args.type || 'package',
+    tags: args.tags ? args.tags.split(',').map((t) => t.trim()).filter(Boolean) : undefined,
+  }
+  const results = await publishAll(input)
+  for (const r of results) {
+    const sym = r.status === 'ok' ? '✓' : r.status === 'skipped' ? '-' : '✗'
+    let line = `${sym} ${r.platform}`
+    if (r.url) line += ` → ${r.url}`
+    if (r.error) line += ` (${r.error})`
+    console.log(line)
+  }
+  process.exit(0)
+}
+
+main().catch((e) => {
+  console.error('omni-publish fatal:', e)
+  process.exit(1)
+})

package/package.json

@@ -1,25 +1,29 @@
 {
   "name": "@chirag127/omni-publish",
-  "version": "0.1.0",
-  "description": "Auto-publish release notes / blog posts to multiple platforms (dev.to, hashnode, medium, X/Twitter, LinkedIn, Bluesky, Mastodon, Reddit) on tag push or release create. Platform fan-out filtered by which env vars are set.",
+  "version": "0.1.1",
+  "description": "Auto-publish release notes / blog posts to multiple platforms (dev.to, Hashnode, Bluesky, Mastodon, Threads) + Telegram drafts queue for manual platforms (X, Reddit, LinkedIn, Medium). Platform fan-out is env-gated.",
   "type": "module",
   "license": "MIT",
   "author": "Chirag Singhal <chirag@oriz.in>",
   "homepage": "https://github.com/chirag127/omni-publish-npm-pkg#readme",
   "repository": { "type": "git", "url": "git+https://github.com/chirag127/omni-publish-npm-pkg.git" },
   "bugs": { "url": "https://github.com/chirag127/omni-publish-npm-pkg/issues" },
-  "keywords": ["chirag127", "oriz", "release-notes", "devto", "hashnode", "medium", "twitter", "linkedin", "bluesky", "mastodon", "reddit", "cross-post"],
-  "files": ["src", "LICENSE", "README.md"],
+  "keywords": ["chirag127", "oriz", "release-notes", "devto", "hashnode", "medium", "twitter", "linkedin", "bluesky", "mastodon", "reddit", "threads", "cross-post", "telegram-drafts"],
+  "files": ["src", "bin", "LICENSE", "README.md"],
   "main": "./src/index.ts",
   "types": "./src/index.ts",
-  "bin": { "omni-publish": "./src/index.ts" },
+  "bin": { "omni-publish": "./bin/omni-publish.mjs" },
   "exports": { ".": "./src/index.ts" },
   "publishConfig": { "access": "public" },
+  "engines": { "node": ">=22" },
   "scripts": {
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage"
   },
+  "dependencies": {
+    "@atproto/api": "^0.13.0"
+  },
   "devDependencies": {
     "vitest": "^2.0.0",
     "@vitest/coverage-v8": "^2.0.0",

package/src/__tests__/publish.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it, beforeEach, afterEach } from 'vitest'
+import { __pkg, publish } from '../index'
+import * as devto from '../adapters/devto'
+import * as hashnode from '../adapters/hashnode'
+import * as bluesky from '../adapters/bluesky'
+import * as mastodon from '../adapters/mastodon'
+import * as threads from '../adapters/threads'
+import { DRAFT_ADAPTERS } from '../adapters/telegram-drafts'
+
+// Snapshot env vars relevant to omni-publish, clear them for these tests,
+// and restore afterwards.
+const ENV_VARS = [
+  'DEVTO_API_KEY',
+  'HASHNODE_API_KEY',
+  'HASHNODE_PUBLICATION_ID',
+  'BLUESKY_HANDLE',
+  'BLUESKY_APP_PASSWORD',
+  'MASTODON_INSTANCE',
+  'MASTODON_ACCESS_TOKEN',
+  'THREADS_ACCESS_TOKEN',
+  'NVIDIA_NIM_API_KEY',
+  'OPENROUTER_API_KEY',
+  'TELEGRAM_DRAFTS_BOT_TOKEN',
+  'TELEGRAM_DRAFTS_CHAT_ID',
+]
+
+let saved: Record<string, string | undefined> = {}
+
+describe('package smoke', () => {
+  beforeEach(() => {
+    saved = {}
+    for (const k of ENV_VARS) {
+      saved[k] = process.env[k]
+      delete process.env[k]
+    }
+  })
+
+  afterEach(() => {
+    for (const k of ENV_VARS) {
+      if (saved[k] === undefined) delete process.env[k]
+      else process.env[k] = saved[k]
+    }
+  })
+
+  it('exports __pkg constant', () => {
+    expect(__pkg).toMatch(/^@chirag127\//)
+  })
+
+  it('each auto-adapter exports a name string', () => {
+    expect(typeof devto.name).toBe('string')
+    expect(typeof hashnode.name).toBe('string')
+    expect(typeof bluesky.name).toBe('string')
+    expect(typeof mastodon.name).toBe('string')
+    expect(typeof threads.name).toBe('string')
+  })
+
+  it('each draft adapter exports a name string', () => {
+    for (const a of DRAFT_ADAPTERS) {
+      expect(typeof a.name).toBe('string')
+      expect(a.name.startsWith('telegram-draft-')).toBe(true)
+    }
+  })
+
+  it('publish() returns all-skipped results when no env vars are set', async () => {
+    const results = await publish({
+      title: 'test',
+      body: 'b',
+      canonical_url: 'https://example.com',
+      type: 'package',
+      tags: ['t'],
+    })
+    expect(Array.isArray(results)).toBe(true)
+    expect(results.length).toBe(9) // 5 auto + 4 draft
+    for (const r of results) {
+      expect(r.status).toBe('skipped')
+    }
+  })
+})

package/src/adapters/ai-draft.ts

@@ -0,0 +1,70 @@
+// AI draft generator — NVIDIA NIM primary, OpenRouter fallback
+// Used by telegram-drafts adapter to rewrite release announcements per-platform.
+
+const NIM_URL = 'https://integrate.api.nvidia.com/v1/chat/completions'
+const NIM_MODEL = 'meta/llama-3.3-70b-instruct'
+const OPENROUTER_URL = 'https://openrouter.ai/api/v1/chat/completions'
+const OPENROUTER_MODEL = 'meta-llama/llama-3.3-70b-instruct:free'
+
+async function callChat(url: string, model: string, key: string, prompt: string): Promise<{ ok: boolean; text?: string; status?: number; error?: string }> {
+  try {
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${key}`,
+        'content-type': 'application/json',
+      },
+      body: JSON.stringify({
+        model,
+        messages: [{ role: 'user', content: prompt }],
+        temperature: 0.7,
+        max_tokens: 512,
+      }),
+    })
+    if (!res.ok) {
+      const text = await res.text()
+      return { ok: false, status: res.status, error: text.slice(0, 200) }
+    }
+    const json = (await res.json()) as { choices?: Array<{ message?: { content?: string } }> }
+    const content = json.choices?.[0]?.message?.content?.trim()
+    if (!content) return { ok: false, error: 'empty response' }
+    return { ok: true, text: content }
+  } catch (e) {
+    return { ok: false, error: String(e) }
+  }
+}
+
+export async function generateDraft(prompt: string): Promise<string | null> {
+  const nimKey = process.env.NVIDIA_NIM_API_KEY
+  const orKey = process.env.OPENROUTER_API_KEY
+
+  // Try NIM first
+  if (nimKey) {
+    const r = await callChat(NIM_URL, NIM_MODEL, nimKey, prompt)
+    if (r.ok && r.text) return r.text
+    // Fall through on 429/5xx
+    if (r.status && r.status !== 429 && r.status < 500) {
+      // 4xx other than 429 — don't fall back
+      if (!orKey) return null
+    }
+  }
+
+  // Fallback to OpenRouter
+  if (orKey) {
+    const r = await callChat(OPENROUTER_URL, OPENROUTER_MODEL, orKey, prompt)
+    if (r.ok && r.text) return r.text
+  }
+
+  return null
+}
+
+export const PROMPTS = {
+  x: (title: string, body: string) =>
+    `Rewrite this release announcement as a Twitter/X post (280 char max), keeping the canonical URL. Be punchy. Source:\n\n${title}\n\n${body}`,
+  reddit: (title: string, body: string) =>
+    `Rewrite this release announcement as a Reddit self-post. Keep the full body but make it conversational and add a TL;DR at the top. Source:\n\n${title}\n\n${body}`,
+  linkedin: (title: string, body: string) =>
+    `Rewrite this release announcement as a LinkedIn post in a professional, slightly humble tone. ~3 short paragraphs. Source:\n\n${title}\n\n${body}`,
+  medium: (title: string, body: string) =>
+    `Rewrite this release announcement as a 1-paragraph Medium blurb (~80 words) suitable as a post intro. Source:\n\n${title}\n\n${body}`,
+}

package/src/adapters/bluesky.ts

@@ -0,0 +1,28 @@
+// Bluesky adapter — AT Protocol
+import type { PublishInput, PublishResult } from '../types.js'
+
+export const name = 'bluesky'
+
+export async function publish(input: PublishInput): Promise<PublishResult> {
+  const handle = process.env.BLUESKY_HANDLE
+  const appPassword = process.env.BLUESKY_APP_PASSWORD
+  if (!handle || !appPassword) {
+    return { platform: name, status: 'skipped' }
+  }
+
+  try {
+    // Dynamic import so the dep is only loaded when needed
+    const { AtpAgent } = await import('@atproto/api')
+    const agent = new AtpAgent({ service: 'https://bsky.social' })
+    await agent.login({ identifier: handle, password: appPassword })
+
+    const text = `${input.title}\n\n${input.canonical_url}`.slice(0, 300)
+    const res = await agent.post({
+      text,
+      createdAt: new Date().toISOString(),
+    })
+    return { platform: name, status: 'ok', url: res.uri }
+  } catch (e) {
+    return { platform: name, status: 'error', error: String(e) }
+  }
+}

package/src/adapters/devto.ts

@@ -0,0 +1,39 @@
+// dev.to adapter
+import type { PublishInput, PublishResult } from '../types.js'
+
+export const name = 'dev.to'
+
+export async function publish(input: PublishInput): Promise<PublishResult> {
+  const apiKey = process.env.DEVTO_API_KEY
+  if (!apiKey) {
+    return { platform: name, status: 'skipped' }
+  }
+
+  try {
+    const body = {
+      article: {
+        title: input.title,
+        body_markdown: input.body + '\n\n---\n\n*Originally posted at ' + input.canonical_url + '*',
+        published: true,
+        canonical_url: input.canonical_url,
+        tags: input.tags?.slice(0, 4),
+      },
+    }
+    const res = await fetch('https://dev.to/api/articles', {
+      method: 'POST',
+      headers: {
+        'api-key': apiKey,
+        'content-type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    })
+    if (!res.ok) {
+      const text = await res.text()
+      return { platform: name, status: 'error', error: `HTTP ${res.status}: ${text.slice(0, 200)}` }
+    }
+    const json = (await res.json()) as { url?: string }
+    return { platform: name, status: 'ok', url: json.url }
+  } catch (e) {
+    return { platform: name, status: 'error', error: String(e) }
+  }
+}

package/src/adapters/hashnode.ts

@@ -0,0 +1,52 @@
+// Hashnode adapter — GraphQL
+import type { PublishInput, PublishResult } from '../types.js'
+
+export const name = 'hashnode'
+
+const MUTATION = `mutation PublishPost($input: PublishPostInput!) {
+  publishPost(input: $input) {
+    post { id slug url }
+  }
+}`
+
+export async function publish(input: PublishInput): Promise<PublishResult> {
+  const apiKey = process.env.HASHNODE_API_KEY
+  const publicationId = process.env.HASHNODE_PUBLICATION_ID
+  if (!apiKey || !publicationId) {
+    return { platform: name, status: 'skipped' }
+  }
+
+  try {
+    const variables = {
+      input: {
+        title: input.title,
+        contentMarkdown: input.body,
+        publicationId,
+        originalArticleURL: input.canonical_url,
+        tags: (input.tags || []).map((t) => ({
+          slug: t.toLowerCase().replace(/\s+/g, '-'),
+          name: t,
+        })),
+      },
+    }
+    const res = await fetch('https://gql.hashnode.com/', {
+      method: 'POST',
+      headers: {
+        Authorization: apiKey,
+        'content-type': 'application/json',
+      },
+      body: JSON.stringify({ query: MUTATION, variables }),
+    })
+    if (!res.ok) {
+      const text = await res.text()
+      return { platform: name, status: 'error', error: `HTTP ${res.status}: ${text.slice(0, 200)}` }
+    }
+    const json = (await res.json()) as { data?: { publishPost?: { post?: { url?: string } } }; errors?: unknown }
+    if (json.errors) {
+      return { platform: name, status: 'error', error: JSON.stringify(json.errors).slice(0, 200) }
+    }
+    return { platform: name, status: 'ok', url: json.data?.publishPost?.post?.url }
+  } catch (e) {
+    return { platform: name, status: 'error', error: String(e) }
+  }
+}

package/src/adapters/mastodon.ts

@@ -0,0 +1,35 @@
+// Mastodon adapter
+import type { PublishInput, PublishResult } from '../types.js'
+
+export const name = 'mastodon'
+
+export async function publish(input: PublishInput): Promise<PublishResult> {
+  const instance = process.env.MASTODON_INSTANCE
+  const token = process.env.MASTODON_ACCESS_TOKEN
+  if (!instance || !token) {
+    return { platform: name, status: 'skipped' }
+  }
+
+  try {
+    let status = input.title + '\n\n' + input.canonical_url
+    if (status.length > 500) status = status.slice(0, 497) + '...'
+
+    const url = `https://${instance.replace(/^https?:\/\//, '').replace(/\/$/, '')}/api/v1/statuses`
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'content-type': 'application/json',
+      },
+      body: JSON.stringify({ status, visibility: 'public' }),
+    })
+    if (!res.ok) {
+      const text = await res.text()
+      return { platform: name, status: 'error', error: `HTTP ${res.status}: ${text.slice(0, 200)}` }
+    }
+    const json = (await res.json()) as { url?: string }
+    return { platform: name, status: 'ok', url: json.url }
+  } catch (e) {
+    return { platform: name, status: 'error', error: String(e) }
+  }
+}

package/src/adapters/telegram-drafts.ts

@@ -0,0 +1,66 @@
+// Telegram drafts queue — for manual platforms (X, Reddit, LinkedIn, Medium)
+// Generates an AI draft per platform and posts it to the Telegram drafts channel
+// so the user can review + post manually.
+
+import type { PublishInput, PublishResult } from '../types.js'
+import { generateDraft, PROMPTS } from './ai-draft.js'
+
+type PlatformKey = 'x' | 'reddit' | 'linkedin' | 'medium'
+
+async function sendTelegram(token: string, chatId: string, text: string): Promise<{ ok: boolean; error?: string }> {
+  try {
+    const res = await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        chat_id: chatId,
+        text,
+        parse_mode: 'Markdown',
+        disable_web_page_preview: false,
+      }),
+    })
+    if (!res.ok) {
+      const t = await res.text()
+      return { ok: false, error: `HTTP ${res.status}: ${t.slice(0, 200)}` }
+    }
+    return { ok: true }
+  } catch (e) {
+    return { ok: false, error: String(e) }
+  }
+}
+
+function makeAdapter(platform: PlatformKey, label: string) {
+  return {
+    name: `telegram-draft-${platform}`,
+    async publish(input: PublishInput): Promise<PublishResult> {
+      const token = process.env.TELEGRAM_DRAFTS_BOT_TOKEN
+      const chatId = process.env.TELEGRAM_DRAFTS_CHAT_ID
+      if (!token || !chatId) {
+        return { platform: this.name, status: 'skipped' }
+      }
+
+      try {
+        const prompt = PROMPTS[platform](input.title, input.body)
+        const draft = await generateDraft(prompt)
+        if (!draft) {
+          return { platform: this.name, status: 'error', error: 'AI draft generation failed (no NIM/OpenRouter key or both errored)' }
+        }
+        const text = `📋 DRAFT (${label}) for: ${input.title}\n\n${draft}\n\nOriginal: ${input.canonical_url}`
+        const r = await sendTelegram(token, chatId, text)
+        if (!r.ok) {
+          return { platform: this.name, status: 'error', error: r.error }
+        }
+        return { platform: this.name, status: 'ok' }
+      } catch (e) {
+        return { platform: this.name, status: 'error', error: String(e) }
+      }
+    },
+  }
+}
+
+export const xDraft = makeAdapter('x', 'X')
+export const redditDraft = makeAdapter('reddit', 'Reddit')
+export const linkedinDraft = makeAdapter('linkedin', 'LinkedIn')
+export const mediumDraft = makeAdapter('medium', 'Medium')
+
+export const DRAFT_ADAPTERS = [xDraft, redditDraft, linkedinDraft, mediumDraft]

package/src/adapters/threads.ts

@@ -0,0 +1,45 @@
+// Threads (Meta) adapter — 2-step create + publish
+import type { PublishInput, PublishResult } from '../types.js'
+
+export const name = 'threads'
+
+export async function publish(input: PublishInput): Promise<PublishResult> {
+  const token = process.env.THREADS_ACCESS_TOKEN
+  if (!token) {
+    return { platform: name, status: 'skipped' }
+  }
+
+  try {
+    let text = input.title + '\n\n' + input.canonical_url
+    if (text.length > 500) text = text.slice(0, 497) + '...'
+
+    // Step 1: create container
+    const createUrl = new URL('https://graph.threads.net/v1.0/me/threads')
+    createUrl.searchParams.set('media_type', 'TEXT')
+    createUrl.searchParams.set('text', text)
+    createUrl.searchParams.set('access_token', token)
+    const createRes = await fetch(createUrl.toString(), { method: 'POST' })
+    if (!createRes.ok) {
+      const t = await createRes.text()
+      return { platform: name, status: 'error', error: `create HTTP ${createRes.status}: ${t.slice(0, 200)}` }
+    }
+    const createJson = (await createRes.json()) as { id?: string }
+    if (!createJson.id) {
+      return { platform: name, status: 'error', error: 'no creation_id returned' }
+    }
+
+    // Step 2: publish
+    const pubUrl = new URL('https://graph.threads.net/v1.0/me/threads_publish')
+    pubUrl.searchParams.set('creation_id', createJson.id)
+    pubUrl.searchParams.set('access_token', token)
+    const pubRes = await fetch(pubUrl.toString(), { method: 'POST' })
+    if (!pubRes.ok) {
+      const t = await pubRes.text()
+      return { platform: name, status: 'error', error: `publish HTTP ${pubRes.status}: ${t.slice(0, 200)}` }
+    }
+    const pubJson = (await pubRes.json()) as { id?: string }
+    return { platform: name, status: 'ok', url: pubJson.id ? `https://www.threads.net/@me/post/${pubJson.id}` : undefined }
+  } catch (e) {
+    return { platform: name, status: 'error', error: String(e) }
+  }
+}

package/src/cli.ts

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+// omni-publish CLI
+// Usage: omni-publish --title "..." --body "..." --canonical "..." --type package --tags astro,oriz
+import { publish } from './publish.js'
+import type { PublishInput } from './types.js'
+
+function parseArgs(argv: string[]): Record<string, string> {
+  const out: Record<string, string> = {}
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i]
+    if (a.startsWith('--')) {
+      const key = a.slice(2)
+      const next = argv[i + 1]
+      if (next === undefined || next.startsWith('--')) {
+        out[key] = 'true'
+      } else {
+        out[key] = next
+        i++
+      }
+    }
+  }
+  return out
+}
+
+async function main() {
+  const args = parseArgs(process.argv)
+  if (!args.title || !args.canonical) {
+    console.error('Usage: omni-publish --title "..." --body "..." --canonical "..." --type <app|package|book|extension> [--tags a,b,c]')
+    process.exit(1)
+  }
+  const type = (args.type as PublishInput['type']) || 'package'
+  const input: PublishInput = {
+    title: args.title,
+    body: args.body || '',
+    canonical_url: args.canonical,
+    type,
+    tags: args.tags ? args.tags.split(',').map((t) => t.trim()).filter(Boolean) : undefined,
+  }
+
+  const results = await publish(input)
+  let anyError = false
+  for (const r of results) {
+    const sym = r.status === 'ok' ? '✓' : r.status === 'skipped' ? '-' : '✗'
+    let line = `${sym} ${r.platform}`
+    if (r.url) line += ` → ${r.url}`
+    if (r.error) line += ` (${r.error})`
+    console.log(line)
+    if (r.status === 'error') anyError = true
+  }
+  // Don't fail the workflow on per-platform errors — env-gated by design.
+  process.exit(0)
+  void anyError
+}
+
+main().catch((e) => {
+  console.error('omni-publish fatal:', e)
+  process.exit(1)
+})

package/src/index.ts

@@ -1,15 +1,21 @@
-#!/usr/bin/env node
 // @chirag127/omni-publish
-// v0.1.0 stub. See README for status.
+// v0.1.1 — 5 working adapters (dev.to, Hashnode, Bluesky, Mastodon, Threads)
+// + Telegram drafts queue for 4 manual platforms (X, Reddit, LinkedIn, Medium).
+//
+// Library API:
+//   import { publish, type PublishInput, type PublishResult } from '@chirag127/omni-publish'
+//
+// CLI (Node 22+):
+//   npx @chirag127/omni-publish --title "..." --body "..." --canonical "..." --type package --tags a,b
 export const __pkg = '@chirag127/omni-publish' as const
 
+export type { PublishInput, PublishResult, Adapter } from './types.js'
+export { publish } from './publish.js'
+
+// Legacy config type kept for v0.1.0 back-compat (unused by new publish()).
 export type OmniPublishConfig = {
   platforms: string[]
   title: string
   body: string
   canonicalUrl?: string
 }
-
-export async function publish(_cfg: OmniPublishConfig): Promise<void> {
-  /* TODO: implement per-platform adapters in v0.1.1 */
-}

package/src/publish.ts

@@ -0,0 +1,24 @@
+// Main publish orchestrator — fans out to auto-publish adapters and Telegram drafts.
+import type { PublishInput, PublishResult } from './types.js'
+import * as devto from './adapters/devto.js'
+import * as hashnode from './adapters/hashnode.js'
+import * as bluesky from './adapters/bluesky.js'
+import * as mastodon from './adapters/mastodon.js'
+import * as threads from './adapters/threads.js'
+import { DRAFT_ADAPTERS } from './adapters/telegram-drafts.js'
+
+const AUTO_ADAPTERS = [devto, hashnode, bluesky, mastodon, threads]
+
+export async function publish(input: PublishInput): Promise<PublishResult[]> {
+  const autoResults = await Promise.all(
+    AUTO_ADAPTERS.map((a) =>
+      a.publish(input).catch((e): PublishResult => ({ platform: a.name, status: 'error', error: String(e) }))
+    )
+  )
+  const draftResults = await Promise.all(
+    DRAFT_ADAPTERS.map((a) =>
+      a.publish(input).catch((e): PublishResult => ({ platform: a.name, status: 'error', error: String(e) }))
+    )
+  )
+  return [...autoResults, ...draftResults]
+}

package/src/types.ts

@@ -0,0 +1,21 @@
+// Shared types for @chirag127/omni-publish
+
+export type PublishInput = {
+  title: string
+  body: string
+  canonical_url: string
+  type: 'app' | 'package' | 'book' | 'extension'
+  tags?: string[]
+}
+
+export type PublishResult = {
+  platform: string
+  status: 'ok' | 'skipped' | 'error'
+  url?: string
+  error?: string
+}
+
+export type Adapter = {
+  name: string
+  publish: (input: PublishInput) => Promise<PublishResult>
+}

package/src/__tests__/smoke.test.ts

@@ -1,12 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { __pkg, publish } from '../index'
-
-describe('package smoke', () => {
-  it('exports __pkg constant', () => {
-    expect(__pkg).toMatch(/^@chirag127\//)
-  })
-
-  it('publish() resolves without throwing on empty config', async () => {
-    await expect(publish({ platforms: [], title: 't', body: 'b' })).resolves.toBeUndefined()
-  })
-})