Automating Dev.to cross-posting from an Astro blog

SeriesPart of How this blog was built: documenting every decision that shaped this site.

Dev.to has a large audience that won’t find your personal blog through search. Cross-posting gets your content in front of them, but only if you set up the canonical URL correctly. Skip that step and you risk training search engines to prefer the Dev.to copy over your own site.

This post walks through the cross-posting script this blog uses: a single Node.js file that reads frontmatter from your markdown posts, converts a few blog-specific features into Dev.to-friendly markdown, builds an article payload, shows a preview, and asks for confirmation before publishing or updating.

How cross-posting and canonical URLs work

When you publish the same content to two URLs, search engines need a signal for which one to treat as authoritative. The canonical URL (<link rel="canonical">) provides that signal.

Dev.to supports a canonical_url field on its API. When set, Dev.to renders it as the canonical link in the page <head>, pointing back to your blog. Search engines follow that signal and credit your domain for the content, not Dev.to.

Never cross-post without setting canonical_url. Without it, Dev.to’s version may outrank your own.

Architecture

Setting up

Get an API key from dev.to/settings/extensions under DEV Community API Keys. Add it, along with your site’s public URL, to .env:

1
DEVTO_API_KEY=your_key_here
2
SITE_URL=https://sourcier.uk

The script reads .env automatically if it exists, using Node 20.12’s built-in process.loadEnvFile.

Running it

1
pnpm crosspost:devto

The script lists published, non-future posts sorted newest-first and prompts you to pick one from a dropdown built with @inquirer/prompts:

1
? Select a post to cross-post: (Use arrow keys)
2
❯ reactions-netlify-blobs-astro
3
  dark-light-theme-toggle
4
  comments-system
5
  ...
6

7
─────────────────────────────────────────
8
  Title        : Adding emoji reactions to your Astro blog with Netlify Blobs
9
  Canonical URL: https://sourcier.uk/blog/reactions-netlify-blobs-astro
10
  Tags         : astro, netlify, engineering, frontend
11
  Description  : How to add emoji reactions…
12
  Mermaid      : 1 converted (image mode)
13
  Code fences  : 3 normalised
14
  Series notes : 0 normalised
15
  SVG images   : 2 converted to links
16
  Original link: prepended
17
  Body length  : 4821 chars
18
─────────────────────────────────────────
19

20
Checking for existing Dev.to article by canonical URL…
21
No existing article found, will create a new one.
22

23
Cross-post to Dev.to? [y/N]

If a matching article already exists (found by canonical_url), the script offers a choice instead: update the existing article, create a new one, or cancel. Pass --update to force update mode, or --update <article-id> to target a specific article without the canonical URL lookup.

How frontmatter is parsed

The script reads collections/posts/<slug>/index.md directly, no Astro build needed. Frontmatter is parsed with a lightweight regex approach rather than a full YAML library, which keeps the script dependency-free.

Tags are normalised for Dev.to’s format: lowercase, alphanumeric only, maximum 4. The # prefix Dev.to adds to tags in its UI is handled by the API automatically.

1
function normaliseTags(tags = []) {
2
  return tags
3
    .map((t) => t.toLowerCase().replace(/[^a-z0-9]/g, ""))
4
    .filter(Boolean)
5
    .slice(0, 4);
6
}

Hyphenated tags like web-performance become webperformance. That’s a Dev.to constraint: their tag system doesn’t support hyphens.

Making image URLs absolute

Markdown posts reference images with paths like /post-images/slug/image.webp or ./image.webp. Dev.to renders these relative to dev.to, not your domain, so they’d break.

The script converts both patterns to absolute URLs before sending to the API:

1
function makeImagesAbsolute(markdown, slug) {
2
  return markdown
3
    .replace(/\(\/post-images\//g, `(${siteBase}/post-images/`)
4
    .replace(
5
      /\(\.\/([^)]+\.(png|jpg|jpeg|gif|webp|svg))\)/g,
6
      `(${siteBase}/post-images/${slug}/$1)`
7
    );
8
}

Converting mermaid diagrams to images

Dev.to doesn’t run the client-side mermaid library this blog uses, so a raw ```mermaid fence would just render as an unstyled code block. The script renders the diagram as an image instead, using the free mermaid.ink rendering service: the diagram source is base64url-encoded into an image URL, with a note linking back to the canonical article for the interactive version.

1
function mermaidFallback(markdown, canonicalUrl) {
2
  const diagram = markdown.trim();
3
  const encoded = toBase64Url(diagram);
4
  const imageUrl = `https://mermaid.ink/img/${encoded}`;
5

6
  return [
7
    `![Mermaid diagram](${imageUrl})`,
8
    "",
9
    `> Diagram fallback for Dev.to. View the canonical article for the full version: ${canonicalUrl}`,
10
  ].join("\n");
11
}

Set DEVTO_MERMAID_MODE=code in .env to fall back to the raw code fence instead, if you’d rather readers copy the diagram source.

Converting SVG wireframes to PNG

SVG images (used for wireframes and mockups on this blog) aren’t reliably supported by Dev.to’s renderer. The script swaps the .svg extension for .png in the image URL, pointing at the PNG fallback that post-images:copy already generates for every SVG, and adds a note linking back to the original:

1
function svgFallback(alt, svgUrl, canonicalUrl) {
2
  const pngUrl = swapSvgExtension(svgUrl);
3

4
  return [
5
    `![${escapeMarkdownLinkText(alt)}](${pngUrl})`,
6
    "",
7
    `> Diagram fallback for Dev.to. View the canonical article for the original SVG: ${canonicalUrl}`,
8
  ].join("\n");
9
}

Normalising series callouts and adding the original-post link

This blog marks series posts with a <div class="series-callout"> element, which Dev.to would strip as unknown HTML. The script converts it into a plain markdown blockquote, and prepends every article body with a link back to the canonical post, since not everyone reads the canonical URL in the article footer:

1
function buildOriginalPostLine(title, canonicalUrl) {
2
  return `> Original post: [${escapeMarkdownLinkText(title)}](${canonicalUrl})`;
3
}

Updating an already cross-posted article

Re-running pnpm crosspost:devto and selecting a post that’s already on Dev.to triggers a lookup by canonical_url against your Dev.to articles. If found, you can update it in place rather than accidentally creating a duplicate:

1
async function findExistingArticleByCanonical(canonicalUrl) {
2
  const target = normaliseUrl(canonicalUrl);
3
  // paginate through /api/articles/me/all and match on canonical_url
4
}

This means editing a published post on your blog and re-running the script is enough to keep the Dev.to copy in sync, no need to track article IDs manually.

What to check after publishing

Even with these conversions, Dev.to doesn’t render everything your blog does:

Code block titles: title="filename.ts" attributes in fenced code blocks don’t render on Dev.to. The code itself is fine.
Expressive code features like line highlighting or diff markers may not survive the normal Dev.to markdown renderer.
Fullscreen image expand buttons are added by this blog’s layout at runtime, so they won’t appear on Dev.to. That’s expected: readers can still click through to the canonical article.

After publishing, open the article on Dev.to and do a quick visual check, especially for any mermaid diagrams or SVG wireframes.

Full code listing

1
#!/usr/bin/env node
2
// Cross-posts a blog post to Dev.to with a canonical URL pointing back to sourcier.uk.
3
// Prepends an original-post link and converts unsupported SVG embeds into PNG fallbacks.
4
// Reads post content from collections/posts/<slug>/index.md.
5
//
6
// Usage:
7
//   node scripts/crosspost-devto.js
8
//   node scripts/crosspost-devto.js --update
9
//   node scripts/crosspost-devto.js --update <devto-article-id>
10
//
11
// Required environment variables (set in .env or shell):
12
//   DEVTO_API_KEY  - API key from https://dev.to/settings/extensions -> DEV Community API Keys
13
//   SITE_URL       - public URL of the site, e.g. https://sourcier.uk
14

15
import { select, confirm } from "@inquirer/prompts";
16
import { readFileSync, readdirSync, existsSync } from "fs";
17
import { join, resolve } from "path";
18

19
const root = resolve(new URL(".", import.meta.url).pathname, "..");
20

21
const envFile = join(root, ".env");
22
if (existsSync(envFile) && typeof process.loadEnvFile === "function") {
23
  process.loadEnvFile(envFile);
24
}
25

26
const apiKey = process.env.DEVTO_API_KEY;
27
const siteBase = (process.env.SITE_URL ?? "https://sourcier.uk").replace(
28
  /\/$/,
29
  "",
30
);
31
const mermaidMode = (process.env.DEVTO_MERMAID_MODE ?? "image").toLowerCase();
32

33
function parseCliArgs(argv) {
34
  let explicitArticleId = null;
35
  let updateOnly = false;
36

37
  for (let i = 0; i < argv.length; i += 1) {
38
    const arg = argv[i];
39

40
    if (arg === "--help" || arg === "-h") {
41
      console.log("Usage:");
42
      console.log("  node scripts/crosspost-devto.js");
43
      console.log("  node scripts/crosspost-devto.js --update");
44
      console.log(
45
        "  node scripts/crosspost-devto.js --update <devto-article-id>",
46
      );
47
      process.exit(0);
48
    }
49

50
    if (arg === "--update") {
51
      updateOnly = true;
52
      const maybeId = argv[i + 1];
53
      if (maybeId && !maybeId.startsWith("--")) {
54
        explicitArticleId = Number(maybeId);
55
        i += 1;
56
      }
57
      continue;
58
    }
59

60
    console.error(`Error: Unknown argument '${arg}'.`);
61
    console.error("Use --help to see supported options.");
62
    process.exit(1);
63
  }
64

65
  return { explicitArticleId, updateOnly };
66
}
67

68
const { explicitArticleId, updateOnly } = parseCliArgs(process.argv.slice(2));
69

70
if (!apiKey) {
71
  console.error("Error: DEVTO_API_KEY environment variable is required.");
72
  console.error("Get one at: https://dev.to/settings/extensions");
73
  process.exit(1);
74
}
75

76
if (explicitArticleId !== null && !Number.isInteger(explicitArticleId)) {
77
  console.error("Error: --update <devto-article-id> must be a valid integer.");
78
  process.exit(1);
79
}
80

81
// -- Frontmatter parser --------------------------------------------------------
82

83
function parseFrontmatter(content) {
84
  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
85
  if (!match) return {};
86
  const yaml = match[1];
87
  const result = {};
88

89
  for (const line of yaml.split(/\r?\n/)) {
90
    const m = line.match(/^(\w+):\s*["'>]?(.*?)["']?\s*$/);
91
    if (m) result[m[1]] = m[2].trim();
92
  }
93

94
  const descBlock = yaml.match(
95
    /^description:\s*>-?\r?\n((?:[ \t]+.+\r?\n?)*)/m,
96
  );
97
  if (descBlock) {
98
    result.description = descBlock[1]
99
      .split(/\r?\n/)
100
      .map((l) => l.trim())
101
      .filter(Boolean)
102
      .join(" ");
103
  }
104

105
  // Parse tags array: tags: ["tag1", "tag2"]
106
  const tagsMatch = yaml.match(/^tags:\s*\[(.+?)\]/m);
107
  if (tagsMatch) {
108
    result.tags = tagsMatch[1]
109
      .split(",")
110
      .map((t) => t.trim().replace(/^["']|["']$/g, ""));
111
  }
112

113
  return result;
114
}
115

116
function stripFrontmatter(content) {
117
  return content.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, "").trim();
118
}
119

120
// Dev.to tags: lowercase alphanumeric only, max 4
121
function normaliseTags(tags = []) {
122
  return tags
123
    .map((t) => t.toLowerCase().replace(/[^a-z0-9]/g, ""))
124
    .filter(Boolean)
125
    .slice(0, 4);
126
}
127

128
function escapeMarkdownLinkText(value) {
129
  return String(value ?? "")
130
    .replace(/\\/g, "\\\\")
131
    .replace(/\[/g, "\\[")
132
    .replace(/\]/g, "\\]");
133
}
134

135
function makeUrlAbsolute(url) {
136
  if (!url) return url;
137
  if (/^https?:\/\//i.test(url)) return url;
138
  if (url.startsWith("/")) return `${siteBase}${url}`;
139
  return url;
140
}
141

142
function buildOriginalPostLine(title, canonicalUrl) {
143
  return `> Original post: [${escapeMarkdownLinkText(title)}](${canonicalUrl})`;
144
}
145

146
function swapSvgExtension(url) {
147
  return url.replace(/\.svg(?=(?:\?[^)]*)?$)/i, ".png");
148
}
149

150
// Replace relative /post-images/ paths and ./image references with absolute URLs
151
function makeImagesAbsolute(markdown, slug) {
152
  return markdown
153
    .replace(/\(\/post-images\//g, `(${siteBase}/post-images/`)
154
    .replace(
155
      /\(\.\/([^)]+\.(png|jpg|jpeg|gif|webp|svg))\)/g,
156
      `(${siteBase}/post-images/${slug}/$1)`,
157
    );
158
}
159

160
function stripHtmlTags(str) {
161
  let result = str;
162
  let prev;
163
  do {
164
    prev = result;
165
    result = result.replace(/<[^>]*>?/g, "");
166
  } while (result !== prev);
167
  return result;
168
}
169

170
function normaliseSeriesCallout(line) {
171
  const match = line.match(
172
    /^<div class="series-callout"><span class="series-callout__label">([^<]+)<\/span><span class="series-callout__text">([\s\S]*?)<\/span><\/div>$/,
173
  );
174

175
  if (!match) return null;
176

177
  const label = match[1].trim();
178
  const text = stripHtmlTags(
179
    match[2].replace(
180
      /<a href="([^"]+)">([\s\S]*?)<\/a>/g,
181
      (_, href, linkText) =>
182
        `[${escapeMarkdownLinkText(stripHtmlTags(linkText))}](${makeUrlAbsolute(href)})`,
183
    ),
184
  )
185
    .replace(/\s+/g, " ")
186
    .trim();
187

188
  return `> ${label}: ${text}`;
189
}
190

191
function toBase64Url(value) {
192
  return Buffer.from(value, "utf8")
193
    .toString("base64")
194
    .replace(/\+/g, "-")
195
    .replace(/\//g, "_")
196
    .replace(/=+$/g, "");
197
}
198

199
function normaliseFenceLanguage(info) {
200
  const token = info.trim().split(/\s+/)[0] ?? "";
201
  return /^[a-z0-9#+.-]+$/i.test(token) ? token.toLowerCase() : "";
202
}
203

204
function mermaidFallback(markdown, canonicalUrl) {
205
  const diagram = markdown.trim();
206
  if (!diagram) return "";
207

208
  if (mermaidMode === "code") {
209
    return [
210
      `> Mermaid diagram is available in the canonical article: ${canonicalUrl}`,
211
      "",
212
      "```mermaid",
213
      diagram,
214
      "```",
215
    ].join("\n");
216
  }
217

218
  const encoded = toBase64Url(diagram);
219
  const imageUrl = `https://mermaid.ink/img/${encoded}`;
220

221
  return [
222
    `![Mermaid diagram](${imageUrl})`,
223
    "",
224
    `> Diagram fallback for Dev.to. View the canonical article for the full version: ${canonicalUrl}`,
225
  ].join("\n");
226
}
227

228
function svgFallback(alt, svgUrl, canonicalUrl) {
229
  const pngUrl = swapSvgExtension(svgUrl);
230

231
  return [
232
    `![${escapeMarkdownLinkText(alt)}](${pngUrl})`,
233
    "",
234
    `> Diagram fallback for Dev.to. View the canonical article for the original SVG: ${canonicalUrl}`,
235
  ].join("\n");
236
}
237

238
function normaliseSvgImage(line, canonicalUrl) {
239
  const match = line.match(/^!\[([^\]]*)\]\(([^)\s]+\.svg(?:\?[^)]*)?)\)$/i);
240
  if (!match) return null;
241

242
  const alt = match[1].trim() || "Diagram";
243
  const url = match[2];
244

245
  return svgFallback(alt, url, canonicalUrl);
246
}
247

248
function normaliseMarkdownForDevto(markdown, canonicalUrl, title) {
249
  const lines = markdown.split(/\r?\n/);
250
  const output = [];
251
  const stats = {
252
    mermaidBlocks: 0,
253
    codeFencesNormalised: 0,
254
    seriesCalloutsNormalised: 0,
255
    svgImagesConverted: 0,
256
  };
257

258
  let inFence = false;
259
  let fenceMarker = "";
260
  let fenceInfo = "";
261
  let fenceLines = [];
262

263
  for (const line of lines) {
264
    if (!inFence) {
265
      const open = line.match(/^(`{3,})(.*)$/);
266
      if (!open) {
267
        const seriesCallout = normaliseSeriesCallout(line);
268
        if (seriesCallout) {
269
          stats.seriesCalloutsNormalised += 1;
270
          output.push(seriesCallout);
271
          continue;
272
        }
273

274
        const svgImage = normaliseSvgImage(line, canonicalUrl);
275
        if (svgImage) {
276
          stats.svgImagesConverted += 1;
277
          output.push(svgImage);
278
          continue;
279
        }
280

281
        output.push(line);
282
        continue;
283
      }
284

285
      inFence = true;
286
      fenceMarker = open[1];
287
      fenceInfo = open[2] ?? "";
288
      fenceLines = [];
289
      continue;
290
    }
291

292
    const trimmed = line.trim();
293
    const isFenceClose =
294
      trimmed.startsWith(fenceMarker) &&
295
      /^`+$/.test(trimmed) &&
296
      trimmed.length >= fenceMarker.length;
297

298
    if (!isFenceClose) {
299
      fenceLines.push(line);
300
      continue;
301
    }
302

303
    const rawCode = fenceLines.join("\n");
304
    const language = normaliseFenceLanguage(fenceInfo);
305

306
    if (language === "mermaid") {
307
      stats.mermaidBlocks += 1;
308
      output.push(mermaidFallback(rawCode, canonicalUrl));
309
    } else {
310
      if (fenceInfo.trim()) stats.codeFencesNormalised += 1;
311
      output.push(language ? `\`\`\`${language}` : "```");
312
      output.push(rawCode);
313
      output.push("```");
314
    }
315

316
    inFence = false;
317
    fenceMarker = "";
318
    fenceInfo = "";
319
    fenceLines = [];
320
  }
321

322
  if (inFence) {
323
    output.push(`${fenceMarker}${fenceInfo}`);
324
    output.push(...fenceLines);
325
  }
326

327
  return {
328
    markdown: `${buildOriginalPostLine(title, canonicalUrl)}\n\n${output.join("\n").trimStart()}`,
329
    stats,
330
  };
331
}
332

333
function loadPost(slug) {
334
  const filePath = join(root, "collections", "posts", slug, "index.md");
335
  let raw;
336
  try {
337
    raw = readFileSync(filePath, "utf8");
338
  } catch {
339
    throw new Error(`Post not found: collections/posts/${slug}/index.md`);
340
  }
341
  const fm = parseFrontmatter(raw);
342
  if (!fm.title) throw new Error(`No title found in frontmatter for: ${slug}`);
343

344
  const title = fm.title.replace(/^["']|["']$/g, "");
345
  const canonicalUrl = `${siteBase}/blog/${slug}`;
346
  const markdownBody = makeImagesAbsolute(stripFrontmatter(raw), slug);
347
  const normalised = normaliseMarkdownForDevto(
348
    markdownBody,
349
    canonicalUrl,
350
    title,
351
  );
352

353
  return {
354
    title,
355
    description: fm.description || "",
356
    tags: normaliseTags(fm.tags),
357
    draft: fm.draft === "true",
358
    pubDate: fm.pubDate ? new Date(fm.pubDate) : null,
359
    body: normalised.markdown,
360
    canonicalUrl,
361
    transformStats: normalised.stats,
362
  };
363
}
364

365
function listPostIds() {
366
  const postsDir = join(root, "collections", "posts");
367
  return readdirSync(postsDir, { withFileTypes: true })
368
    .filter((d) => d.isDirectory())
369
    .map((d) => {
370
      try {
371
        const content = readFileSync(
372
          join(postsDir, d.name, "index.md"),
373
          "utf8",
374
        );
375
        const fm = parseFrontmatter(content);
376
        return {
377
          id: d.name,
378
          pubDate: fm.pubDate ? new Date(fm.pubDate) : new Date(0),
379
          isDraft: fm.draft === "true",
380
          isFuture: fm.pubDate ? new Date(fm.pubDate) > new Date() : false,
381
        };
382
      } catch {
383
        return null;
384
      }
385
    })
386
    .filter((p) => p && !p.isDraft && !p.isFuture)
387
    .sort((a, b) => b.pubDate - a.pubDate)
388
    .map((p) => p.id);
389
}
390

391
function normaliseUrl(value) {
392
  return String(value || "").replace(/\/$/, "");
393
}
394

395
function buildArticlePayload(post) {
396
  return {
397
    article: {
398
      title: post.title,
399
      body_markdown: post.body,
400
      published: true,
401
      canonical_url: post.canonicalUrl,
402
      description: post.description,
403
      tags: post.tags,
404
    },
405
  };
406
}
407

408
async function findExistingArticleByCanonical(canonicalUrl) {
409
  const target = normaliseUrl(canonicalUrl);
410
  let page = 1;
411
  const perPage = 100;
412

413
  while (true) {
414
    const res = await fetch(
415
      `https://dev.to/api/articles/me/all?page=${page}&per_page=${perPage}`,
416
      {
417
        headers: {
418
          "api-key": apiKey,
419
        },
420
      },
421
    );
422

423
    const data = await res.json();
424

425
    if (!res.ok) {
426
      throw new Error(
427
        `Unable to list Dev.to articles (${res.status}): ${JSON.stringify(data)}`,
428
      );
429
    }
430

431
    if (!Array.isArray(data) || data.length === 0) return null;
432

433
    const existing = data.find((article) => {
434
      const canonical = normaliseUrl(article.canonical_url);
435
      return canonical && canonical === target;
436
    });
437

438
    if (existing) return existing;
439
    if (data.length < perPage) return null;
440

441
    page += 1;
442
  }
443
}
444

445
// -- Select post ----------------------------------------------------------------
446

447
const postIds = listPostIds();
448
if (postIds.length === 0) {
449
  console.log("\nNo published posts found.");
450
  process.exit(0);
451
}
452

453
const slug = await select({
454
  message: "Select a post to cross-post:",
455
  choices: postIds.map((id) => ({ value: id })),
456
}).catch(() => process.exit(0));
457

458
let post;
459
try {
460
  post = loadPost(slug);
461
} catch (err) {
462
  console.error(`Error: ${err.message}`);
463
  process.exit(1);
464
}
465

466
// -- Preview ---------------------------------------------------------------------
467

468
console.log("\n─────────────────────────────────────────");
469
console.log(`  Title        : ${post.title}`);
470
console.log(`  Canonical URL: ${post.canonicalUrl}`);
471
console.log(`  Tags         : ${post.tags.join(", ") || "(none)"}`);
472
console.log(
473
  `  Description  : ${post.description.slice(0, 80)}${post.description.length > 80 ? "…" : ""}`,
474
);
475
console.log(
476
  `  Mermaid      : ${post.transformStats.mermaidBlocks} converted (${mermaidMode} mode)`,
477
);
478
console.log(
479
  `  Code fences  : ${post.transformStats.codeFencesNormalised} normalised`,
480
);
481
console.log(
482
  `  Series notes : ${post.transformStats.seriesCalloutsNormalised} normalised`,
483
);
484
console.log(
485
  `  SVG images   : ${post.transformStats.svgImagesConverted} converted to links`,
486
);
487
console.log("  Original link: prepended");
488
console.log(`  Body length  : ${post.body.length} chars`);
489
console.log("─────────────────────────────────────────\n");
490

491
// -- Detect existing Dev.to article -----------------------------------------
492

493
let existingArticle = null;
494

495
if (explicitArticleId !== null) {
496
  existingArticle = { id: explicitArticleId };
497
  console.log(
498
    `--update ${explicitArticleId} provided - forcing update mode.\n`,
499
  );
500
} else {
501
  console.log("Checking for existing Dev.to article by canonical URL…");
502
  try {
503
    existingArticle = await findExistingArticleByCanonical(post.canonicalUrl);
504
  } catch (err) {
505
    console.error(`Error: ${err.message}`);
506
    process.exit(1);
507
  }
508
  if (existingArticle) {
509
    console.log(
510
      `Found existing article: https://dev.to/articles/${existingArticle.id}\n`,
511
    );
512
  } else {
513
    console.log("No existing article found - will create a new one.\n");
514
  }
515
}
516

517
const isUpdate = Boolean(existingArticle?.id);
518

519
if (updateOnly && !isUpdate) {
520
  console.error(
521
    "Error: --update was set, but no existing Dev.to article was found for this canonical URL.",
522
  );
523
  console.error("Re-run without --update to create a new article instead.");
524
  process.exit(1);
525
}
526

527
// -- Confirm action ------------------------------------------------------------
528

529
let proceed;
530

531
if (explicitArticleId !== null || updateOnly) {
532
  const ok = await confirm({
533
    message: `Update Dev.to article ${existingArticle.id}?`,
534
    default: false,
535
  }).catch(() => process.exit(0));
536
  if (!ok) {
537
    console.log("Aborted.");
538
    process.exit(0);
539
  }
540
  proceed = "update";
541
} else if (isUpdate) {
542
  proceed = await select({
543
    message: `An existing article was found. What would you like to do?`,
544
    choices: [
545
      { name: "Update the existing article", value: "update" },
546
      { name: "Create a new article", value: "create" },
547
      { name: "Cancel", value: "cancel" },
548
    ],
549
  }).catch(() => process.exit(0));
550
} else {
551
  const ok = await confirm({
552
    message: "Cross-post to Dev.to?",
553
    default: false,
554
  }).catch(() => process.exit(0));
555
  proceed = ok ? "create" : "cancel";
556
}
557

558
if (proceed === "cancel") {
559
  console.log("Aborted.");
560
  process.exit(0);
561
}
562

563
const doUpdate = proceed === "update";
564

565
// -- CREATE or UPDATE via Dev.to API --------------------------------------------
566

567
const endpoint = doUpdate
568
  ? `https://dev.to/api/articles/${existingArticle.id}`
569
  : "https://dev.to/api/articles";
570
const method = doUpdate ? "PUT" : "POST";
571

572
console.log(`\n${doUpdate ? "Updating" : "Posting"} on Dev.to…`);
573

574
const res = await fetch(endpoint, {
575
  method,
576
  headers: {
577
    "Content-Type": "application/json",
578
    "api-key": apiKey,
579
  },
580
  body: JSON.stringify(buildArticlePayload(post)),
581
});
582

583
const data = await res.json();
584

585
if (!res.ok) {
586
  console.error(
587
    `\nDev.to API error (${res.status}):`,
588
    JSON.stringify(data, null, 2),
589
  );
590
  process.exit(1);
591
}
592

593
console.log(`\n✓ ${doUpdate ? "Updated" : "Published"}! View at: ${data.url}`);
594
console.log("  Dev.to article ID:", data.id);
595
console.log(
596
  "\nNote: Mermaid and expressive code fences were normalised for Dev.to compatibility.",
597
);
598
console.log(
599
  "Review the Dev.to article to confirm formatting. Original-post link and canonical URL are set correctly.",
600
);