openwriter 0.26.0 → 0.27.1

package/dist/plugins/github/dist/git-sync.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Git sync module: all git/gh CLI interactions for GitHub docs backup.
+ * Lifted from packages/openwriter/server/git-sync.ts into the github plugin.
+ *
+ * Uses child_process.execFile with shell:true (required on Windows).
+ * Server-internal modules (state, helpers, ws) accessed via getServerModules().
+ */
+export type SyncState = 'unconfigured' | 'synced' | 'pending' | 'syncing' | 'error';
+export interface SyncStatus {
+    state: SyncState;
+    lastSyncTime?: string;
+    pendingFiles?: number;
+    error?: string;
+}
+export interface SyncCapabilities {
+    gitInstalled: boolean;
+    ghInstalled: boolean;
+    ghAuthenticated: boolean;
+    existingRepo: boolean;
+    remoteUrl?: string;
+}
+export declare function isGitInstalled(): Promise<boolean>;
+export declare function isGhInstalled(): Promise<boolean>;
+export declare function isGhAuthenticated(): Promise<boolean>;
+export declare function isGitRepo(): Promise<boolean>;
+export interface PendingFile {
+    status: 'added' | 'modified' | 'deleted' | 'renamed';
+    file: string;
+}
+export declare function getPendingFiles(): Promise<PendingFile[]>;
+export declare function getSyncStatus(): Promise<SyncStatus>;
+export declare function getCapabilities(): Promise<SyncCapabilities>;
+export declare function setupWithGh(repoName: string, isPrivate: boolean): Promise<void>;
+export declare function setupWithPat(pat: string, repoName: string, isPrivate: boolean): Promise<void>;
+export declare function connectExisting(remoteUrl: string, pat?: string): Promise<void>;
+export declare function pushSync(onStatus: (status: SyncStatus) => void): Promise<SyncStatus>;

package/dist/plugins/github/dist/git-sync.js

@@ -0,0 +1,276 @@
+/**
+ * Git sync module: all git/gh CLI interactions for GitHub docs backup.
+ * Lifted from packages/openwriter/server/git-sync.ts into the github plugin.
+ *
+ * Uses child_process.execFile with shell:true (required on Windows).
+ * Server-internal modules (state, helpers, ws) accessed via getServerModules().
+ */
+import { execFile } from 'child_process';
+import { existsSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { getServerModules } from './helpers.js';
+const GITIGNORE_CONTENT = `config.json\n.versions/\n`;
+const NETWORK_TIMEOUT = 30000;
+let currentSyncState = 'unconfigured';
+let lastError;
+function exec(cmd, args, cwd, timeout = 10000) {
+    const safeArgs = args.map(a => a.includes(' ') ? `"${a}"` : a);
+    return new Promise((resolve, reject) => {
+        execFile(cmd, safeArgs, { cwd, shell: true, timeout }, (err, stdout, stderr) => {
+            if (err)
+                reject(new Error(stderr?.trim() || err.message));
+            else
+                resolve(stdout.trim());
+        });
+    });
+}
+async function dataDir() {
+    return (await getServerModules()).getDataDir();
+}
+export async function isGitInstalled() {
+    try {
+        await exec('git', ['--version'], await dataDir());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function isGhInstalled() {
+    try {
+        await exec('gh', ['--version'], await dataDir());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function isGhAuthenticated() {
+    try {
+        await exec('gh', ['auth', 'status'], await dataDir());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function isGitRepo() {
+    return existsSync(join(await dataDir(), '.git'));
+}
+async function ensureGitignore() {
+    const gitignorePath = join(await dataDir(), '.gitignore');
+    if (!existsSync(gitignorePath)) {
+        writeFileSync(gitignorePath, GITIGNORE_CONTENT, 'utf-8');
+    }
+}
+async function countPendingFiles() {
+    if (!(await isGitRepo()))
+        return 0;
+    try {
+        const status = await exec('git', ['status', '--porcelain'], await dataDir());
+        if (!status)
+            return 0;
+        return status.split('\n').filter(Boolean).length;
+    }
+    catch {
+        return 0;
+    }
+}
+export async function getPendingFiles() {
+    if (!(await isGitRepo()))
+        return [];
+    try {
+        const output = await exec('git', ['status', '--porcelain'], await dataDir());
+        if (!output)
+            return [];
+        return output.split('\n').filter(Boolean).map(line => {
+            const code = line.substring(0, 2);
+            const file = line.substring(3);
+            let status = 'modified';
+            if (code.includes('?') || code.includes('A'))
+                status = 'added';
+            else if (code.includes('D'))
+                status = 'deleted';
+            else if (code.includes('R'))
+                status = 'renamed';
+            return { status, file };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+export async function getSyncStatus() {
+    const srv = await getServerModules();
+    const config = srv.readConfig();
+    if (!config.gitConfigured || !(await isGitRepo())) {
+        return { state: 'unconfigured' };
+    }
+    if (currentSyncState === 'syncing') {
+        return { state: 'syncing' };
+    }
+    if (currentSyncState === 'error' && lastError) {
+        return { state: 'error', error: lastError, lastSyncTime: config.lastSyncTime };
+    }
+    const pending = await countPendingFiles();
+    return {
+        state: pending > 0 ? 'pending' : 'synced',
+        pendingFiles: pending,
+        lastSyncTime: config.lastSyncTime,
+    };
+}
+export async function getCapabilities() {
+    const [git, gh] = await Promise.all([isGitInstalled(), isGhInstalled()]);
+    let ghAuth = false;
+    if (gh)
+        ghAuth = await isGhAuthenticated();
+    let remoteUrl;
+    if (await isGitRepo()) {
+        try {
+            remoteUrl = await exec('git', ['remote', 'get-url', 'origin'], await dataDir());
+        }
+        catch { /* no remote */ }
+    }
+    return {
+        gitInstalled: git,
+        ghInstalled: gh,
+        ghAuthenticated: ghAuth,
+        existingRepo: await isGitRepo(),
+        remoteUrl,
+    };
+}
+async function initRepo() {
+    const dir = await dataDir();
+    if (!(await isGitRepo())) {
+        await exec('git', ['init'], dir);
+    }
+    await ensureGitignore();
+    try {
+        await exec('git', ['config', 'user.name'], dir);
+    }
+    catch {
+        await exec('git', ['config', 'user.name', 'OpenWriter'], dir);
+    }
+    try {
+        await exec('git', ['config', 'user.email'], dir);
+    }
+    catch {
+        await exec('git', ['config', 'user.email', 'openwriter@local'], dir);
+    }
+}
+async function initialCommit() {
+    const dir = await dataDir();
+    await exec('git', ['add', '-A'], dir);
+    const status = await exec('git', ['status', '--porcelain'], dir);
+    if (!status)
+        return;
+    await exec('git', ['commit', '-m', 'Initial sync from OpenWriter'], dir);
+    await exec('git', ['branch', '-M', 'main'], dir);
+}
+export async function setupWithGh(repoName, isPrivate) {
+    const srv = await getServerModules();
+    const dir = await dataDir();
+    await initRepo();
+    await initialCommit();
+    const visibility = isPrivate ? '--private' : '--public';
+    await exec('gh', ['repo', 'create', repoName, visibility, '--source=.', '--remote=origin'], dir, NETWORK_TIMEOUT);
+    await exec('git', ['push', '-u', 'origin', 'main'], dir, NETWORK_TIMEOUT);
+    srv.saveConfig({
+        gitConfigured: true,
+        repoName,
+        lastSyncTime: new Date().toISOString(),
+    });
+    currentSyncState = 'synced';
+}
+export async function setupWithPat(pat, repoName, isPrivate) {
+    const srv = await getServerModules();
+    const dir = await dataDir();
+    const res = await fetch('https://api.github.com/user/repos', {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${pat}`,
+            'Content-Type': 'application/json',
+            Accept: 'application/vnd.github+json',
+        },
+        body: JSON.stringify({ name: repoName, private: isPrivate, auto_init: false }),
+    });
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        throw new Error(body.message || `GitHub API error: ${res.status}`);
+    }
+    const repo = await res.json();
+    const remoteUrl = `https://${pat}@github.com/${repo.full_name}.git`;
+    await initRepo();
+    await initialCommit();
+    try {
+        await exec('git', ['remote', 'remove', 'origin'], dir);
+    }
+    catch { /* no remote */ }
+    await exec('git', ['remote', 'add', 'origin', remoteUrl], dir);
+    await exec('git', ['push', '-u', 'origin', 'main'], dir, NETWORK_TIMEOUT);
+    srv.saveConfig({
+        gitConfigured: true,
+        gitPat: pat,
+        repoName,
+        gitRemote: repo.html_url,
+        lastSyncTime: new Date().toISOString(),
+    });
+    currentSyncState = 'synced';
+}
+export async function connectExisting(remoteUrl, pat) {
+    const srv = await getServerModules();
+    const dir = await dataDir();
+    await initRepo();
+    await initialCommit();
+    let finalUrl = remoteUrl;
+    if (pat && remoteUrl.startsWith('https://')) {
+        finalUrl = remoteUrl.replace('https://', `https://${pat}@`);
+    }
+    try {
+        await exec('git', ['remote', 'remove', 'origin'], dir);
+    }
+    catch { /* no remote */ }
+    await exec('git', ['remote', 'add', 'origin', finalUrl], dir);
+    await exec('git', ['push', '-u', 'origin', 'main'], dir, NETWORK_TIMEOUT);
+    srv.saveConfig({
+        gitConfigured: true,
+        gitPat: pat,
+        gitRemote: remoteUrl,
+        lastSyncTime: new Date().toISOString(),
+    });
+    currentSyncState = 'synced';
+}
+export async function pushSync(onStatus) {
+    const srv = await getServerModules();
+    const dir = await dataDir();
+    currentSyncState = 'syncing';
+    lastError = undefined;
+    onStatus({ state: 'syncing' });
+    try {
+        srv.cancelDebouncedSave();
+        srv.save();
+        await ensureGitignore();
+        await exec('git', ['add', '-A'], dir);
+        const status = await exec('git', ['status', '--porcelain'], dir);
+        if (status) {
+            const timestamp = new Date().toLocaleString('en-US', {
+                month: 'short', day: 'numeric', hour: 'numeric', minute: '2-digit',
+            });
+            await exec('git', ['commit', '-m', `Sync: ${timestamp}`], dir);
+        }
+        await exec('git', ['push'], dir, NETWORK_TIMEOUT);
+        const now = new Date().toISOString();
+        srv.saveConfig({ lastSyncTime: now });
+        currentSyncState = 'synced';
+        const result = { state: 'synced', lastSyncTime: now, pendingFiles: 0 };
+        onStatus(result);
+        return result;
+    }
+    catch (err) {
+        currentSyncState = 'error';
+        lastError = err.message;
+        const result = { state: 'error', error: err.message };
+        onStatus(result);
+        return result;
+    }
+}

package/dist/plugins/github/dist/helpers.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Local helpers for the github plugin — server-module bridge.
+ * Mirrors the lazy-import pattern from plugins/publish/src/helpers.ts.
+ */
+export interface ServerModules {
+    getDataDir: () => string;
+    readConfig: () => any;
+    saveConfig: (patch: Record<string, any>) => void;
+    save: () => void;
+    cancelDebouncedSave: () => void;
+    getDocument: () => any;
+    getTitle: () => string;
+    getMetadata: () => Record<string, any>;
+    getDocId: () => string;
+    setMetadata: (updates: Record<string, any>) => void;
+    bumpDocVersion: () => number;
+    broadcastSyncStatus: (status: any) => void;
+    tiptapToMarkdown: (doc: any, title: string, metadata?: Record<string, any>) => string;
+}
+export declare function getServerModules(): Promise<ServerModules>;
+export interface PluginConfigField {
+    type: 'string' | 'number' | 'boolean';
+    required?: boolean;
+    env?: string;
+    description?: string;
+}
+export interface PluginRouteContext {
+    app: import('express').Router;
+    config: Record<string, string>;
+    dataDir: string;
+}
+export interface PluginMcpTool {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    handler: (params: Record<string, unknown>) => Promise<unknown>;
+}
+export interface OpenWriterPlugin {
+    name: string;
+    version: string;
+    description?: string;
+    category?: 'writing' | 'social-media' | 'image-generation' | 'publishing' | 'productivity' | 'analytics';
+    configSchema?: Record<string, PluginConfigField>;
+    registerRoutes?(ctx: PluginRouteContext): void | Promise<void>;
+    mcpTools?(config: Record<string, string>): PluginMcpTool[];
+}
+export interface BlogSite {
+    id: string;
+    label: string;
+    owner: string;
+    repo: string;
+    branch: string;
+    content_dir: string;
+    image_dir: string;
+    image_public_prefix: string;
+    framework: 'astro' | 'next' | 'jekyll' | 'hugo' | 'unknown';
+    /** Constant frontmatter fields applied to every post (e.g. layout, author, prerender). */
+    frontmatter_defaults?: Record<string, any>;
+    /**
+     * Map openwriter blogContext key → site frontmatter key.
+     * e.g. { date: "publishedDate" } for sites that use a non-standard date field.
+     */
+    frontmatter_field_map?: Record<string, string>;
+    /**
+     * Schema of frontmatter fields the site's posts use (from inspection).
+     * Surfaced in the panel so users can see what the site expects.
+     * Not used as a filter — only the defaults + blogContext determine output.
+     */
+    frontmatter_schema?: string[];
+    /**
+     * Public base URL of the site (e.g. "https://example.com"). Used by
+     * post_to_blog to construct the live URL stamped on `blogContext.lastPublish.publishedUrl`
+     * so the file-tree right-click menu can surface "View Post" after a publish.
+     * inspect_blog_repo proposes this from `CNAME` / `public/CNAME` when present.
+     */
+    site_url?: string;
+    /**
+     * URL path pattern for a blog post, with `{slug}` as the placeholder.
+     * Default: `/blog/{slug}/`. Used together with `site_url` to build the live URL.
+     */
+    blog_url_pattern?: string;
+}
+export declare function listBlogSites(): Promise<BlogSite[]>;
+export declare function writeBlogSites(sites: BlogSite[]): Promise<void>;

package/dist/plugins/github/dist/helpers.js

@@ -0,0 +1,62 @@
+/**
+ * Local helpers for the github plugin — server-module bridge.
+ * Mirrors the lazy-import pattern from plugins/publish/src/helpers.ts.
+ */
+// npm package:  dist/plugins/github/dist/helpers.js → ../../../server/
+// Monorepo dev: plugins/github/dist/helpers.js     → ../../../packages/openwriter/dist/server/
+const npmBase = new URL('../../../server/', import.meta.url).href;
+const monoBase = new URL('../../../packages/openwriter/dist/server/', import.meta.url).href;
+let _cached = null;
+async function tryImport(base) {
+    const [helpers, state, ws, markdown] = await Promise.all([
+        import(base + 'helpers.js'),
+        import(base + 'state.js'),
+        import(base + 'ws.js'),
+        import(base + 'markdown.js'),
+    ]);
+    return { helpers, state, ws, markdown };
+}
+export async function getServerModules() {
+    if (_cached)
+        return _cached;
+    let helpers, state, ws, markdown;
+    try {
+        ({ helpers, state, ws, markdown } = await tryImport(npmBase));
+    }
+    catch {
+        ({ helpers, state, ws, markdown } = await tryImport(monoBase));
+    }
+    _cached = {
+        getDataDir: helpers.getDataDir,
+        readConfig: helpers.readConfig,
+        saveConfig: helpers.saveConfig,
+        save: state.save,
+        cancelDebouncedSave: state.cancelDebouncedSave,
+        getDocument: state.getDocument,
+        getTitle: state.getTitle,
+        getMetadata: state.getMetadata,
+        getDocId: state.getDocId,
+        setMetadata: state.setMetadata,
+        bumpDocVersion: state.bumpDocVersion,
+        broadcastSyncStatus: ws.broadcastSyncStatus,
+        tiptapToMarkdown: markdown.tiptapToMarkdown,
+    };
+    return _cached;
+}
+const PLUGIN_NAME = '@openwriter/plugin-github';
+export async function listBlogSites() {
+    const srv = await getServerModules();
+    const cfg = srv.readConfig() || {};
+    const slot = cfg.plugins?.[PLUGIN_NAME];
+    return slot?.blogSites || [];
+}
+// adr: adr/plugin-slot-nested-data.md
+export async function writeBlogSites(sites) {
+    const srv = await getServerModules();
+    const cfg = srv.readConfig() || {};
+    const plugins = { ...(cfg.plugins || {}) };
+    const slot = { ...(plugins[PLUGIN_NAME] || { enabled: true, config: {} }) };
+    slot.blogSites = sites;
+    plugins[PLUGIN_NAME] = slot;
+    srv.saveConfig({ plugins });
+}

package/dist/plugins/github/dist/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * GitHub Plugin for OpenWriter.
+ * Provides two capabilities:
+ *   1. Docs backup sync — lifted from core. Auth: existing `gh auth`.
+ *   2. Blog sites (Phase 3+) — list of blog repos, post via local git ops.
+ *
+ * This phase ships capability 1 only. Routes match the previous core mount
+ * points exactly so SyncButton + SyncSetupModal continue to work unchanged.
+ */
+import type { OpenWriterPlugin } from './helpers.js';
+declare const plugin: OpenWriterPlugin;
+export default plugin;

package/dist/plugins/github/dist/index.js

@@ -0,0 +1,102 @@
+/**
+ * GitHub Plugin for OpenWriter.
+ * Provides two capabilities:
+ *   1. Docs backup sync — lifted from core. Auth: existing `gh auth`.
+ *   2. Blog sites (Phase 3+) — list of blog repos, post via local git ops.
+ *
+ * This phase ships capability 1 only. Routes match the previous core mount
+ * points exactly so SyncButton + SyncSetupModal continue to work unchanged.
+ */
+import { getServerModules } from './helpers.js';
+import { getSyncStatus, getCapabilities, getPendingFiles, setupWithGh, setupWithPat, connectExisting, pushSync, } from './git-sync.js';
+import { blogTools } from './blog-tools.js';
+const plugin = {
+    name: '@openwriter/plugin-github',
+    version: '0.1.0',
+    description: 'GitHub Plugin: Sync files and publish blogs.',
+    category: 'productivity',
+    // No user-input credentials — auth piggybacks on the user's existing
+    // `gh auth` (verified in getCapabilities). Blog-site list is stored
+    // outside the configSchema as structured data (Phase 3+).
+    configSchema: {},
+    mcpTools() {
+        return blogTools();
+    },
+    registerRoutes(ctx) {
+        const broadcast = async (status) => {
+            try {
+                const srv = await getServerModules();
+                srv.broadcastSyncStatus(status);
+            }
+            catch (err) {
+                console.error('[GitHub Plugin] broadcast failed:', err.message);
+            }
+        };
+        ctx.app.get('/api/sync/status', async (_req, res) => {
+            try {
+                res.json(await getSyncStatus());
+            }
+            catch (err) {
+                res.status(500).json({ state: 'error', error: err.message });
+            }
+        });
+        ctx.app.get('/api/sync/capabilities', async (_req, res) => {
+            try {
+                res.json(await getCapabilities());
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        ctx.app.get('/api/sync/pending', async (_req, res) => {
+            try {
+                res.json(await getPendingFiles());
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        ctx.app.post('/api/sync/setup', async (req, res) => {
+            try {
+                const { method, repoName, remoteUrl, pat, isPrivate } = req.body;
+                if (method === 'gh') {
+                    await setupWithGh(repoName || 'openwriter-docs', isPrivate !== false);
+                }
+                else if (method === 'pat') {
+                    if (!pat) {
+                        res.status(400).json({ error: 'PAT is required' });
+                        return;
+                    }
+                    await setupWithPat(pat, repoName || 'openwriter-docs', isPrivate !== false);
+                }
+                else if (method === 'connect') {
+                    if (!remoteUrl) {
+                        res.status(400).json({ error: 'Remote URL is required' });
+                        return;
+                    }
+                    await connectExisting(remoteUrl, pat);
+                }
+                else {
+                    res.status(400).json({ error: 'Invalid method. Use: gh, pat, or connect' });
+                    return;
+                }
+                const status = await getSyncStatus();
+                await broadcast(status);
+                res.json({ success: true, status });
+            }
+            catch (err) {
+                res.status(500).json({ error: err.message });
+            }
+        });
+        ctx.app.post('/api/sync/push', async (_req, res) => {
+            try {
+                const result = await pushSync((s) => { void broadcast(s); });
+                res.json(result);
+            }
+            catch (err) {
+                res.status(500).json({ state: 'error', error: err.message });
+            }
+        });
+    },
+};
+export default plugin;

package/dist/plugins/github/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@openwriter/plugin-github",
+  "version": "0.1.0",
+  "description": "GitHub Plugin: Sync files and publish blogs.",
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/express": "^5.0.0",
+    "typescript": "^5.6.0"
+  },
+  "openwriter": {
+    "displayName": "GitHub",
+    "category": "productivity"
+  },
+  "files": [
+    "dist/",
+    "package.json"
+  ]
+}

package/dist/server/autoplug-enroll.js

@@ -0,0 +1,71 @@
+/**
+ * Manual-post → autoplug enrollment bridge.
+ *
+ * API/scheduler posts enter the platform's autoplug tracking at post time
+ * (the platform calls autoTrackTweet on /connections/:id/post, post-thread,
+ * the scheduler cron, and on POST /publications). Manual posts only ever
+ * wrote local `tweetContext.lastPost` frontmatter and never told the platform,
+ * so they never enrolled — and quote tweets, which the X API cannot post and
+ * therefore ALWAYS go through manual mark-sent, could never be autoplug-tracked.
+ *
+ * This reconciles the two: when a tweet/article doc is marked posted with a
+ * tweet URL, we record a publication on the platform. The platform's
+ * POST /publications handler enrolls X publications into autoplug tracking,
+ * so engagement-threshold autoplugs now fire on manually-posted tweets the
+ * same way they do for API/scheduler posts.
+ */
+import { isAuthenticated, platformFetch } from './connections.js';
+const TWEET_ID_RE = /(?:twitter|x)\.com\/[^/]+\/status\/(\d+)/i;
+/** Pull the numeric tweet id out of an x.com / twitter.com status URL. */
+export function extractTweetId(url) {
+    if (!url)
+        return null;
+    const m = TWEET_ID_RE.exec(url);
+    return m ? m[1] : null;
+}
+/**
+ * Enroll a manually-posted tweet into platform autoplug tracking.
+ *
+ * Best-effort and idempotent: skips when the tweet is already recorded as a
+ * publication for this doc, so re-marking, unmark/remark, and autosave churn
+ * never duplicate the enrollment. Never throws — enrollment must never block
+ * or break the mark-sent metadata write.
+ */
+export async function enrollManualPostForAutoplug(docId, tweetUrl, text) {
+    if (!isAuthenticated())
+        return;
+    const tweetId = extractTweetId(tweetUrl);
+    if (!tweetId)
+        return;
+    try {
+        // Idempotency: the platform's publications table has no unique constraint,
+        // so dedupe here before recording another row + re-enrolling.
+        const existingRes = await platformFetch(`/publications?documentId=${encodeURIComponent(docId)}`);
+        if (existingRes.ok) {
+            const data = await existingRes.json();
+            const already = (data.publications || []).some((p) => p.platform === 'x' && p.external_id === tweetId);
+            if (already)
+                return;
+        }
+        // Recording the publication triggers autoTrackTweet platform-side, which
+        // enrolls the tweet for autoplug rule evaluation (guarded there by the
+        // profile having ≥1 enabled goal + an active X connection).
+        const res = await platformFetch('/publications', {
+            method: 'POST',
+            body: JSON.stringify({
+                document_id: docId,
+                platform: 'x',
+                external_id: tweetId,
+                url: tweetUrl,
+                meta: { text: text || '', last_tweet_id: tweetId },
+            }),
+        });
+        if (res.ok) {
+            console.log(`[Autoplug] Enrolled manual post ${tweetId} (doc ${docId}) into tracking`);
+        }
+    }
+    catch {
+        // Best-effort: platform may be unreachable / unauthenticated. Mark-sent
+        // already succeeded locally; tracking simply won't enroll this time.
+    }
+}