Pixel

Pixel Updates & Events

Server Updates & Events

Announcements

DEV Community

Your AI agent skills are an unversioned dependency

Your AI agent skills are an unversioned dependency A skill is a prompt that lands in a model's system context. Most teams install them the way we installed libraries in 2009: clone a repo, copy a folder, hope nobody touches it. Then the folder drifts and the agent quietly loads something nobody reviewed. I maintain Skillporter, a package manager for AI agent skills. This is the design problem behind it, not a feature tour. The real problem is paths, not prompts Every harness reads skills from a different directory: Claude Code .claude/skills
OpenAI Codex .agents/skills
Cursor .agents/skills
GitHub Copilot .github/skills
Windsurf .windsurf/skills
Cline .cline/skills
OpenCode .opencode/skills
Hermes Agent $HERMES_HOME/skills
Eight harnesses share .agents/skills as their primary project path, and six more read it as a documented compatibility path. That directory is the trap. Remove a skill to clean up Cursor and you have just broken Codex, Gemini CLI, Zed, OpenHands and Goose for the rest of the team. Two other approaches fail in predictable ways. Symlinks break inside Docker builds, git worktrees and Windows checkouts. Copy scripts drift, because nothing records what the copy was supposed to be. Treat the skill as a dependency The package manager model maps cleanly: a manifest you commit, listing skills and target harnesses a resolution step that fetches sources and validates structure a static scan before anything is written one install per harness path, with shared paths written once a lockfile with a content hash per skill snapshots, so rollback is possible after a bad upstream change uvx skillporter add anthropics/skills --skill pdf --harness all Real output from a clean workspace: + Installed pdf across 19 harness(es) (+12 created, ~0 updated, =7 deduplicated/unchanged)
+ Claude Code created (copy via .claude/skills)
+ GitHub Copilot created (copy via .github/skills)
+ Hermes Agent created (copy via .hermes/skills)
Twelve directories, seven shared paths deduplicated. That tally is the whole argument for a resolver: a copy script would have written nineteen copies and called it success. Drift is the thing worth detecting Once a skill is pinned, the interesting question stops being what is installed and becomes what changed. skillporter sync # reconcile workspace with manifest, write the lock
skillporter lock --check # exit 1 on drift, exit 2 if the check could not run
skillporter outdated # compare version, commit and tree hash upstream
skillporter rollback pdf # restore the last snapshot
The exit code split matters more than it looks. A pipeline needs to distinguish a failed check from a check that never ran, otherwise a broken tool reads as a pass. Skills are a supply chain input, so be honest about scanning A static scanner finds known dangerous patterns: curl piped to shell, base64 payloads, credential reads, risky permission requests. It reports finding codes and a risk score, and it never executes skill code during install. What it cannot do is catch novel prompt injection written in ordinary prose. A URL can serve harmless content when inspected and something else when the agent fetches it later. If a vendor tells you their scanner proves a skill is safe at runtime, they are selling you certainty they do not have. The docs for this one say so explicitly, which is the main reason I trust the rest of them. Read-only by default when a model is the caller The MCP mode is worth a paragraph. An MCP server is designed to be called by a model, which means its arguments may be hostile. So the server exposes detect, diagnose, scan, inspect and matrix, and denies add, install, sync and remove unless started with --allow-writes. The workspace root comes from a flag or an environment variable, not from tool arguments, and traversal, escaping symlinks and UNC paths are rejected. What this is not Not a ma...

Powered by Readybot.io

**DEV Community** ## Your AI agent skills are an unversioned …

DEV Community

GitHub Actions paths and paths-ignore together on one event

Writing GitHub Actions paths and paths-ignore together on one event is documented as unsupported, but no published component rejects it, so the file compiles and the workflow runs. What decides which of the two filters wins is a service GitHub does not publish, which is why the honest answer is to stop writing both rather than to learn the precedence. The published schema reaches the event mapping with loose keys, so the path filters are never checked by it. The filter is applied by a component GitHub does not publish. What this error means A trigger fires when you expected it to be skipped, or skips when you expected it to fire, and the event block on it carries both a paths list and a paths-ignore list. Nothing is annotated, the workflow file is accepted, and other events in the same file behave normally. The failure mode is a run that either exists or does not, with no message to attach to either outcome, which makes it very hard to tell an unsupported combination from a glob that does not match what you think it matches. ```Illustrative workflow fragment, not a log line: this combination produces no message on: push: paths: ['src/'] paths-ignore: ['docs/']

Common causes

The two keys were added by different people at different times

Overwhelmingly the usual origin. Somebody adds paths to narrow a noisy workflow, somebody else later adds paths-ignore to skip documentation, and neither diff contains the other key, so neither review sees a conflict.

Include and exclude were assumed to compose

They read like a pair, and in most tools they would be. Here the documentation says to express both intents with one key, and the negation syntax inside paths is the mechanism that was provided for it.

A negation was written before the pattern it should subtract from

The documentation says an exclamation mark negates previous positive patterns. A list that starts with an exclusion excludes nothing, which looks identical to the filter being ignored.

The pattern does not match what it appears to match

Patterns must match the whole path from the repository root, and a single asterisk does not cross a slash. In our experience a filter that looks broken is more often a pattern that is slightly wrong than a precedence problem.

How to fix it

Decide which single intent the event has

  1. Write down in one sentence what should trigger this event.
  2. If the sentence contains only exclusions, keep paths-ignore and delete paths.
  3. If it contains any inclusion at all, keep paths and delete paths-ignore.
  4. Move any exclusion into the paths list as a negated pattern placed after the positive ones.

Express include and exclude in one paths list

Put the positive patterns first and the negations after them, because negation acts on what precedes it. Quote any pattern that begins with an exclamation mark, an asterisk or a bracket, since all three are special to YAML.

```.github/workflows/ci.yml
on:
pull_request:
paths:
- 'src/'
- 'package.json'
- '!src/
/.md'
- '!src/fixtures/
'
Split one workflow into two when the intents really differ Two files with one filter each are predictable, and a workflow that does not trigger costs nothing. This is usually the right answer when a file has accumulated filters that pull in different directions. Test the filter with a real push rather than by reading it Create a branch and commit one file that should trigger the workflow. Commit a second file that should not, in a separate push. Read the Actions tab after each push and confirm which runs appeared. How to prevent it Allow one path filter per event, and make that a review rule rather than a convention. Put negated patterns after the positive patterns they subtract from, always. Quote every pattern beginning with an exclamation mark, an asterisk or a bracket. Test a changed filter with two pushes before relying on it. The rule is published, the enforcement is not The...

Powered by Readybot.io*

**DEV Community** ## GitHub Actions paths and paths-ignore together on …

DEV Community

Migrating Media Gallery from Electron to Native Rust GUI to Reduce Overhead and Improve Scrolling

Benchmarking Electron vs. Rust GUI Performance Bottlenecks When evaluating the transition of a massive local media gallery from an Electron frontend to a native Rust GUI framework, developers frequently run headfirst into a fundamental misconception: that dropping the Chromium runtime eliminates performance overhead. In reality, performance for collections scaling past one hundred thousand items is dictated by memory bandwidth limits, thread contention, and layout recalculation mechanics rather than runtime branding. Analyzing the bottlenecks reveals distinct structural failure points across both architectures. Memory Overhead and Process Architecture: Electron wraps applications in a multi-process model where every window and iframe spins up a distinct Chromium instance complete with a dedicated V8 isolate, Blink rendering engine, and GPU command buffer. For a media gallery maintaining tens of thousands of thumbnail references, Electron’s JavaScript heap bloats rapidly due to DOM node object allocations, CSS style declaration trees, and V8 garbage collection pauses. When scrolling rapidly through a masonry grid, the V8 garbage collector is forced to sweep massive generations of discarded DOM wrapper objects, causing unpredictable micro-stutters. Conversely, native Rust frameworks eliminate JavaScript bridging overhead, but memory profiles diverge wildly based on design model: Immediate-Mode (e.g., egui): Re-evaluates the entire widget tree every single frame. Storing state for 100,000 items requires either continuous allocation churn or manual clipping hacks, pushing CPU caches to their limits as the CPU constantly re-fetches off-screen layout structs. Retained-Mode (e.g., GTK4, Slint): Maintains a persistent scene graph. Memory overhead stays flat relative to visible items, but complex custom masonry layouts demand aggressive item recycling to prevent heap fragmentation. Layout Recalculation and DOM vs. Native Math: In Electron, layout recalculation relies on Blink's highly optimized, multi-threaded CSS engine. While powerful, style invalidation cascades can trigger expensive layout reflows across the entire flex or grid container whenever a thumbnail loads or a filter changes. If virtualization is imperfect, the layout engine wastes cycles calculating geometry for off-screen nodes. In native Rust toolkits, the performance equation shifts depending on layout flexibility: The Immediate-Mode Trap: Frameworks like egui lack native, high-performance masonry layout widgets. Implementing a multi-column dynamic aspect-ratio masonry grid requires calculating explicit bounding boxes for every item on every frame. If the frame budget is 16.6ms for 60fps, evaluating 100,000 items sequentially on the main thread causes CPU thread starvation, driving CPU core temperatures up and triggering thermal throttling on laptops. The Retained-Mode Advantage: GTK4 provides battle-tested native list and grid view widgets with built-in hardware recycling and differential layout passes, bypassing redundant math for non-visible nodes. Thread Constraints and Texture Upload Synchronization: The primary bottleneck in large media galleries is rarely the language runtime divide, but rather CPU-to-GPU texture transfer synchronization and image decoding throughput. In Electron, asynchronous image decoding happens in worker threads, but uploading decoded bitmap buffers to the GPU through Chromium's rendering pipeline introduces multi-process IPC serialization costs. In native Rust architectures, disk I/O, SQLite metadata queries, and image decoding are cleanly offloaded to background thread pools via non-blocking message-passing channels. However, if the UI thread blocks synchronously on GPU texture uploads (glTexImage2D or Vulkan equivalents) during rapid scroll bursts, the event loop freezes, dropping frames and leaving blank cells. Metric / Vector Electron + TS (Current) Immediate-Mode Rust (e.g., egui) Retained-Mode Native (e.g., GTK4) Layout Calculati...

Powered by Readybot.io

**DEV Community** ## Migrating Media Gallery from Electron to Native …

DEV Community

nostr-bot-kit: one YAML file = a running Nostr bot (built by an agent, for agents)

I run autonomous earning experiments — this week my agent wrote and published a whole PyPI package. nostr-bot-kit turns a Nostr bot into a single YAML file: identity, relays, post schedule, reply rules. No framework to learn. bot:
name: price-bot
relays:
- wss://relay.damus.io
- wss://nos.lol
jobs:
- kind: 1
schedule: "0 /6 * * "
template: "BTC ${btc_usd} — hourly"
replies:
- match: "price"
template: "BTC ${btc_usd} now"
pip install nostr-bot-kit
nostr-bot-kit run bot.yaml
That YAML runs: posts on the schedule, replies to matching notes, keeps a NIP-05-style identity block. Built to be embedded — the package is how my agent earns bounties and now sells as a service. Repo + docs: https://pypi.org/project/nostr-bot-kit/ — pip mirror at https://nostr-bot-kit.surge.sh/simple/ python #nostr #automation #bots

Powered by Readybot.io

**DEV Community** ## nostr-bot-kit: one YAML file = a running …

DEV Community

Day 83: Two Files and Four Parts

Day 83 of DevOps, Day 33 of Azure. Both tasks today were made of parts that are each correct on their own and do nothing until something joins them. An Ansible inventory and an Ansible playbook are two files, neither of which references the other. A load balancer has four kinds of components, and three of them are inert until a rule names all three together. One Ansible task, one Azure task. Create an inventory so an existing playbook runs, then put a load balancer in front of a VM. The tasks come from the KodeKloud Engineer platform. Task 1: An inventory for a playbook that already exists The task: create an inventory at /home/thor/playbook/inventory so the playbook sitting next to it can run against stapp03. Step 1: Keys before the file The security point is worth making before writing anything, and it is the Day 82 finding: storing a password in a plain-text inventory is what Ansible's own documentation tells you not to do, in the description of the variable itself. "Never store this variable in plain text; always use a vault." So the key goes in first, and the inventory describes who to connect as rather than what password to use. [app_server]
stapp03 ansible_host=stapp03 ansible_user=banner
One thing in that line is redundant. ansible_host is documented as "The name of the host to connect to, if different from the alias you wish to give to it", and the alias on the left is already stapp03. Harmless, and it hides what the parameter is actually for, which is pointing an inventory name at a different address. Step 2: Two files, joined at the command line thor@jump-host ~/playbook$ ansible-playbook -i inventory playbook.yml
This is the bit worth sitting with, because it is the shape of the whole tool. The playbook says which group it targets. The inventory says which machines are in that group. Neither file mentions the other, and the command line is where they meet. Change the inventory and the identical playbook deploys to somewhere else entirely. That separation is the reason Ansible scales to more than one environment without templating anything. It is also the reason a playbook that works in staging can hit production by mistake, because the only thing that decided which was a flag. Step 3: Read the recap TASK [Gathering Facts] ** ok: [stapp03]
TASK [Install httpd package]
** changed: [stapp03]
TASK [Start service httpd] *** changed: [stapp03]

PLAY RECAP ** stapp03 : ok=3 changed=2 unreachable=0 failed=0
Three tasks ran, two of them altered the system. The one that did not is Gathering Facts, which collects information and changes nothing by design. What the docs recommend Run this playbook a second time and it reports changed=0. The package task finds httpd installed and reports ok. The service task finds it running and reports ok. Both modules describe a desired state, and a system already in that state needs no action. That is the property Ansible is usually sold on, and it is what makes the changed number in a recap worth reading: on a stable system it should be zero, so anything non-zero means something actually moved. Worth establishing deliberately now, because tomorrow's playbook breaks it. file: state=touch reports a change on every single run, by design, and once one task does that the recap stops being a signal. One correction to my own notes while I am here. For this day and the next three, I wrote at the ssh-keygen prompt, as a placeholder, and then showed a successful Ansible run. Day 82's notes record the prompt as it actually appeared, with an empty passphrase, which is the version that works: Ansible "does not expose a channel to allow communication between the user and the ssh process to accept a password manually to decrypt an ssh key", so a passphrase-protected key cannot be decrypted during a run without an agent, and none of my notes mention one. A placeholder in a write-up reads as an instruction. Anyone follo...

Powered by Readybot.io*

**DEV Community** ## Day 83: Two Files and Four Parts …

DEV Community

Check digits explained: how barcodes catch a typo with one number

Every EAN-13 and UPC-A barcode ends in a digit that isn't data at all. It's a check digit, and it lets a scanner (or your code) reject most typos instantly. The EAN-13 rule Take the first 12 digits. Multiply them alternately by 1 and 3, starting with 1 from the left. Add it all up. The check digit is whatever brings the total up to the next multiple of 10. Example: 400638133393? digits: 4 0 0 6 3 8 1 3 3 3 9 3
weights: 1 3 1 3 1 3 1 3 1 3 1 3
sum = 4+0+0+18+3+24+1+9+3+9+9+9 = 89
check = (10 - 89 % 10) % 10 = 1
So the full code is 4006381333931. In JavaScript function ean13Check(first12) {
const sum = [...first12].reduce(
(acc, d, i) => acc + Number(d) * (i % 2 ? 3 : 1), 0);
return (10 - (sum % 10)) % 10;
}
UPC-A uses the same idea on 11 digits, but the weights start with 3 instead of 1. What it catches (and doesn't) Any single wrong digit: always caught. Most swaps of two neighbouring digits: caught, except when the two digits differ by 5 (e.g. 0↔5, 2↔7), because 3×5 = 15 ends in 5 either way. Other systems trade complexity for strength: ISBN-10 uses mod 11 (catches all adjacent swaps), and credit cards use the Luhn algorithm. Try it Disclosure: I run GoToolsOnline. Its free barcode generator computes and validates the check digit for EAN-13/UPC-A and other formats as you type: https://gotoolsonline.com/tools/barcode-generator

Powered by Readybot.io

**DEV Community** ## Check digits explained: how barcodes catch a …

DEV Community

Your H-1B starts October 1. You may enter up to 10 days early, but you cannot work yet

Checked against official sources on November 15, 2026 Your H-1B approval notice has a start date. Say it is October 1. You want to fly in a week early, find a place, and get set up. Can you enter? And can you start work that same week? The rule answers both questions. You may be allowed to enter early. You may not start work before the petition's start date. The short version An H-1B worker, and that worker's H-4 family, may be admitted to the United States for the dates on the petition. They may also be admitted up to 10 days before those dates begin, and up to 10 days after they end. The same extra days may also be given when U.S. Citizenship and Immigration Services (USCIS) grants the status inside the country. You may not work in those extra days. Work is allowed only during the validity period of the petition, unless a separate work rule applies. This is not the 60-day period that can follow a job ending. That is a different rule, in the next paragraph of the same section. This post is about the 10-day periods only. Where the rule comes from The rule is in the U.S. immigration regulations, at 8 CFR 214.1(l)(1). The Department of Homeland Security (DHS) set this text in a final rule published in the Federal Register on November 18, 2016. The rule took effect on January 17, 2017. The current eCFR still carries that text. Here is the work sentence, as the regulation writes it: "Unless authorized under 8 CFR 274a.12, the alien may not work except during the validity period." In that same final rule, DHS described these extra days. The days before the start give a reasonable amount of time to enter the United States and prepare to begin employment. The days after the end give a reasonable amount of time to depart. They also give a reasonable amount of time to take other actions to extend, change, or otherwise maintain lawful status. The rule uses "up to" 10 days, and it uses "may." It does not promise that every person will receive a full 10 days. A later sentence sits at 8 CFR 214.1(l)(3). It says a person in any authorized period in paragraph (l) may apply for an extension of stay or a change of status. That person must still be otherwise eligible. Some words, explained H-1B: a U.S. work status for jobs that need a special skill and, most often, a college degree. Petition: the request the employer files with USCIS, on Form I-129, asking for H-1B status for a worker. Validity period: the start and end dates USCIS approves for that petition. Those dates appear on the approval notice, Form I-797. Admitted: allowed to enter the United States by a U.S. Customs and Border Protection (CBP) officer at the border or airport. Otherwise provided such status: the phrase in the rule for cases where USCIS grants H-1B status inside the United States. That can be a change of status or an extension of stay, not only entry at the border. I-94: the arrival and departure record that shows your class of admission and the date you are authorized to stay until. After you enter, you can get your latest record from CBP's I-94 page. H-4: the status for a spouse, and for unmarried children under 21, of an H-1B worker. The 10-day rule includes these dependents. 8 CFR 274a.12: the list of who is allowed to work in the United States, and on what terms. The 10-day rule points to it. Unless another authorization on that list applies, work is allowed only during the petition's validity period. The 10 days before the start Say the petition is valid from October 1. The rule allows admission up to 10 days before that date. If the full 10 days are given, that window opens on September 21. Those days are for arriving and getting settled. DHS said they help a person be ready to start work when the petition begins. They are not work days. Starting the job on September 25 would be work outside the validity period. The officer at the border or airport decides your admission. The rule says "may" and "up to." After you enter, check the I-94 you received. The autho...

Powered by Readybot.io

**DEV Community** ## Your H-1B starts October 1. You may …

DEV Community

Why a canvas re-encode can make a JPEG bigger

Disclosure: This report on the image-processing tests run by the LighterPics project was written with AI assistance. Exporting an existing JPEG through a canvas does not guarantee a smaller file. At quality 0.92, five of 25 test photos grew in Chromium, 10 in Firefox and 11 in WebKit. Engine Photos larger than the input Median output size, as a percentage of input size Chromium 145.0.7632.6 5 of 25 60% Firefox 146.0.1 10 of 25 84% WebKit 26.0 11 of 25 80% All three ran the same photos at the same requested quality. For every photo, the Firefox and WebKit JPEGs were larger than the Chromium JPEG. The quality argument alone was not enough to predict the output size across engines. What changes when a JPEG is re-encoded A canvas export starts from decoded pixels and creates a new file. Its size depends on the output format, encoder settings and image content. The API does not promise to keep it below the input byte count. The converter used createImageBitmap() followed by a canvas export. Its quality settings were passed to toBlob() or the equivalent worker export; PNG does not use that argument. [1] Higher quality often meant a larger file Chromium ran the wider quality sweep. Here are the results for the 25 JPEG photos: Output setting Photos that grew Median size relative to input Range JPEG 1.0 23 of 25 197% 91% to 586% JPEG 0.92 5 of 25 60% 20% to 138% JPEG 0.80 2 of 25 39% 8% to 106% WebP 1.0 25 of 25 250% 141% to 813% WebP 0.92 3 of 25 50% 10% to 152% PNG 25 of 25 483% 224% to 1,267% At JPEG 0.70, no photo grew and the median output size was 26% of the input. No photo grew at any of the lower tested JPEG quality values either. At JPEG quality 1.0, the median output was nearly twice the input size. That setting requests the highest quality, but it still re-encodes the decoded image and cannot recover detail lost in the original JPEG. The recorded median PSNR, a measure of pixel error against the decoded input, was 56.88 dB at 1.0, 43.33 dB at 0.92 and 40.29 dB at 0.80. These were objective measurements, not a visual preference test. WebP at 1.0 took a different path in this Chromium build: all 25 files contained the lossless VP8L bitstream. At 0.92, they contained lossy VP8. The WebP container specification distinguishes these two formats. [2] Firefox also produced three larger files out of 25 at WebP 0.92, with a median size of 50% of the input. WebKit produced no accepted WebP output. PNG made every photo larger in all three engines; the Firefox and WebKit medians were 383% and 421%, respectively. The five photos that grew at JPEG 0.92 in Chromium also grew in Firefox and WebKit. Four were night shots and one was a portrait. They were among the inputs with the fewest bytes per pixel, but that alone did not explain the result: the lowest-bytes-per-pixel photo shrank in Chromium. The tests did not record encoder libraries or chroma subsampling, so they do not identify the cause of the engine differences. A size target did not guarantee a smaller file The compressor searched for an output that fit a requested byte budget. Across 1,407 Chromium runs that produced a file, it returned 177 files larger than their inputs. Every one had a target at or above the input size. Target relative to input size Runs with an output Output larger than input Target met Target missed Below input size 1,038 0 773 265 At or above input size 369 177 369 0 A re-encoded file can fit the requested budget while still exceeding the original size. In JPEG mode, the compressor first tries quality 0.92. If that output fits, it returns it; otherwise it searches lower qualities and, when allowed, reduces the pixel dimensions. The WebP and MozJPEG traces also started at 0.92 for the runs that produced larger files. Of the 177 larger outputs, 159 came from the first encode at 0.92. The other 18 came from searches that settled between 0.75 and 0.91. All met the target, but none reduced the input byte count. Reducing pixel dimensions helped when the target ...

Powered by Readybot.io

**DEV Community** ## Why a canvas re-encode can make a …

DEV Community

My journey so far as a fresh man software wngeneering student

My name is Bona Hanson Junior and i study sofware engeneering at YIBS-ISSEST.Starting university as a Software Engineering student has been an exciting and challenging experience for me. When I first entered this field, I knew I was stepping into a world full of technology, innovation, and endless possibilities. However, I quickly realized that Software Engineering is much more than just writing lines of code. It requires patience, creativity, logical thinking, and a willingness to learn. How it satrted My journey started with learning the fundamentals of programming, algorithms, computer systems, and problem-solving. At first, some concepts seemed complicated(especially maths). Understanding how algorithms work, writing my first programs, and figuring out how different parts of a computer interact were all new experiences. But every lecture and practical exercise introduced me to something new. Coding One of the most interesting parts of my journey so far has been learning C programming. Using tools like Visual Studio Code and exploring Git and GitHub have helped me understand how developers write, manage, and share code. Of course, it hasn't always been easy. There have been moments when my code refused to work, when I couldn't understand an error, or when I spent more time debugging than actually writing code. But I've learned an important lesson: Every error is an opportunity to learn something new. Challenges and Lessons Being a freshman means having a lot to discover. Sometimes things get difficult, but I'm gradually learning that: Consistency is more important than speed. Making mistakes is part of learning. ractice is the key to improvement. Asking questions is a strength, not a weakness. Growth takes time, patience, and dedication. Aims I know I still have a long way to go. I'm not an expert, and I don't pretend to know everything. I'm simply a Software Engineering student eager to learn, improve my skills, build meaningful projects, and explore the endless possibilities of technology. My goal is to turn the knowledge I gain today into practical skills that will help me create solutions tomorrow. I'm excited to share my progress, document my learning experiences, connect with other developers, and grow within the tech community. Let's Connect! I'm always happy to connect with fellow students, developers, mentors, and technology enthusiasts. Let's learn, share knowledge, and grow together.All helps and new tips on how to improve my software engeneering knowledge would be nice

Powered by Readybot.io

**DEV Community** ## My journey so far as a fresh …

DEV Community

GitHub Actions Unable to resolve action, and which half failed

GitHub Actions Unable to resolve action appears in two forms, and the difference between them is the whole diagnosis: one says the repository could not be found, and the other says the repository was found but the ref you asked for was not. Nothing downloads and no action code runs in either case, because the reference is resolved before anything is fetched. Two endings, two stopping points. Repository not found means the path never resolved; unable to find version means it did and the ref did not. What this error means A step fails at the very start with a single line and no other output. There is no setup log for the action, no inputs echoed, nothing from the action itself, because the action was never obtained. The step that fails is often one nobody touched, in a workflow that has been green for months, which makes a repository rename or a deleted tag the first thing to suspect rather than the workflow file. `Quoted from gigalixir/gigalixir-action#67, reported verbatim by the user Error: Unable to resolve actiongigalixir/gigalixir-action@v1, unable to find versionv1

Common causes

The tag or branch in the reference does not exist

Usually a major version tag the maintainer has not published, or a tag that was deleted or renamed during a release. The message names the version, which is the fastest confirmation available, and listing the repository's tags settles it in one command.

The repository was renamed or moved

A uses reference to the old owner or name can stop resolving even though the browser redirect still works, so a workflow that nobody edited fails on a step that used to pass. This is the version that produces the most confusing bug reports.

The action is private and not shared with the calling repository

A private action has to allow access from other repositories in the organization. Without that, resolution fails with the repository not found ending, which sends people to check a path that was never wrong.

The path is misspelled or wrongly cased

Less common than the others and worth ruling out first because it costs nothing. In our experience the case version appears when a reference is retyped from a README rendered with different capitalization.

How to fix it

List the refs on the action repository

Ask the repository what it actually publishes before changing anything. If the tag you referenced is not in the list, the reference is the problem; if it is, you are looking at an access or naming question instead.

Terminal gh api repos/OWNER/ACTION/git/matching-refs/tags --jq '.[].ref' | tail -20 Pin to a commit SHA for anything that matters A commit SHA cannot be moved or deleted by the action's maintainer, which removes this whole failure mode for that step. The documentation recommends it as the safest reference for stability and security, and a dependency updater can still raise pull requests to advance it..github/workflows/ci.yml (illustrative) uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 Allow a private action to be used by other repositories Open the settings of the repository that holds the action, not the one running the workflow. In the Access section, select the option making it accessible from repositories in the organization. Re-run the failing job and confirm the ending of the message changes or disappears. If the action is only ever used by one repository, consider moving it into that repository instead. Reference a local action by path when it is internal Checking the action out and calling it with a relative path avoids the action lookup entirely, because the reference resolves against the workspace. This is the right shape for an action that has no reason to be discoverable outside the repository..github/workflows/ci.yml (illustrative) uses: actions/checkout@v7 uses: ./.github/actions/build ``` How to prevent it Verify that a referenced tag exists at the moment you add the reference. Pin actions you depen...

Powered by Readybot.io

**DEV Community** ## GitHub Actions Unable to resolve action, and …

DEV Community

How do you efficiently manage and restore distinct authentication states when running Playwright tests in parallel?

🔥 Playwright Parallel Testing Headache: How do you efficiently manage and restore distinct authentication states when running Playwright tests in parallel? Sharing auth across parallel test workers causes flaky failures and slow execution. 📌 Problem Statement Running Playwright tests in parallel is crucial for speed. ❌ A major pitfall is parallel tests interfering with each other's authentication states. This leads to unpredictable failures due to shared cookies, local storage, or session data. Re-logging for every test is slow and inefficient. 💡 Solution & Code Walkthrough The robust solution leverages Playwright's browserContext with storageState. This strategy ensures each parallel test worker has its own isolated, pre-authenticated session. • Authenticate once for each user/role. • Capture the authenticated session's storageState (cookies, local/session storage). • Re-use this storageState to create new browserContext instances for tests. Step 1: Create an auth.setup.ts script This runs once to log in a user and save their session state. // playwright/auth.setup.ts
import { test as setup } from '@playwright/test';
import * as path from 'path';

const authFile = path.join(__dirname, '.auth/user.json');

setup('authenticate standard user', async ({ page }) => {
await page.goto('https://example.com/login');
await page.fill('#username', 'testuser');
await page.fill('#password', 'password123');
await page.click('button[type="submit"]');
await page.waitForURL('https://example.com/dashboard');
await page.context().storageState({ path: authFile });
});
Step 2: Configure playwright.config.ts to use storageState This tells Playwright to load the saved state for all tests. // playwright.config.ts
import { defineConfig, devices } from '@playwright/test';
import * as path from 'path';

export default defineConfig({
projects: [
{ name: 'setup', testMatch: /.*.setup.ts/ },
{
name: 'authenticated',
dependencies: ['setup'],
use: {
storageState: path.join(__dirname, 'playwright/.auth/user.json'),
},
},
],
});
Step 3: Write your tests (they now run pre-authenticated!) // tests/dashboard.spec.ts
import { test, expect } from '@playwright/test';

test.describe('Dashboard access', () => {
test('should display user profile', async ({ page }) => {
await page.goto('https://example.com/dashboard');
await expect(page.locator('#user-profile-name')).toHaveText('Test User');
});
});
🔑 Key Takeaways ✅ Isolation: Each test runs in its own distinct, pre-authenticated browserContext. ✅ Efficiency: No need to re-login in every test or worker, significantly speeding up parallel runs. ✅ Robustness: Eliminates cross-test authentication pollution, reducing flakiness. • The setup project ensures authentication runs once before dependent tests. ❓ Quick Summary Q&A • Q: Why use storageState for parallel Playwright tests? • A: To manage distinct authentication states, prevent interference, and speed up execution by avoiding repeated logins. • Q: What does storageState save? • A: Cookies, local storage, and session storage from an authenticated session. TAGS: playwright, testing, automation, typescript, authentication, parallel testing, e2e, ci/cd ──────────────────────────────────────── ──────────────────────────────────────── 📲 𝐅𝐑𝐄𝐄 𝐌𝐎𝐁𝐈𝐋𝐄 𝐀𝐏𝐏 — 𝟔𝟎𝟎+ 𝐒𝐃𝐄𝐓 𝐐&𝐀𝐬 Practice real-world interview scenarios offline on the free QA Automation & SDET Prep app: 🤖 𝐆𝐨𝐨𝐠𝐥𝐞 𝐏𝐥𝐚𝐲 (𝐀𝐧𝐝𝐫𝐨𝐢𝐝): https://play.google.com/store/apps/details?id=com.app.seleniuminterviewquestions&referrer=utm_source%3Ddevto%26utm_medium%3Darticle%26utm_campaign%3Dselenium_20261115 🍎 𝐀𝐩𝐩 𝐒𝐭𝐨𝐫𝐞 (𝐢𝐎𝐒): https://apps.apple.com/app/id6786760948?pt=128640464&ct=devto_selenium_20261115&mt=8 ──────────────────────────────────────── ────────────────────────────────────────

Powered by Readybot.io

**DEV Community** ## How do you efficiently manage and restore …

DEV Community

GitHub Actions env var with special characters in a run step

A GitHub Actions env var with special characters breaks a run step because of an ordering detail that is easy to have backwards: an expression is substituted into the script as text before any shell is started, so the shell parses your value as if you had typed it. Quoting the reference in the script does not help, because by then the value is the script. Substitution happens while the script file is written. The shell is started afterwards and sees only the finished text. What this error means A run step fails with a shell syntax error that quotes a fragment of somebody commit message, a branch name or a pull request title. The message often mentions an unexpected end of file while looking for a matching quote, which is the shell telling you it reached the end of the script still waiting for something to close. The workflow is unchanged from yesterday. What changed is the data, and that is the tell: a step that breaks on one branch and works on another is being fed, not misconfigured. ``Reconstructed from a bash syntax error; the temporary script name differs on every run /home/runner/work/_temp/f1c2.sh: line 2: unexpected EOF while looking for matching"'

Common causes

An expression is written directly into the script body

The commonest shape, and the one that reads most naturally, which is why it survives review. The value becomes script text, so a quote in the data closes a quote in the script.

The value arrived with a newline in it

Commit message bodies and pull request descriptions are multi line. Pasted into a script, the second line becomes a second command, which can fail in a way that looks nothing like a quoting problem.

The value is read from an environment variable without quotes

Better than pasting, and still not safe. An unquoted expansion is word split and glob expanded, so a value with spaces becomes several arguments and one containing an asterisk may be replaced by file names.

The data changed, not the workflow

In our experience this is what makes the failure feel arbitrary. The step is unchanged and has worked for months, and the branch name that broke it is the first one anybody wrote a bracket in.

How to fix it

Move the expression into a step environment variable

Declare the value under the step env block and reference it in the script. The script then contains a name rather than the data, so no content in the value can change how it parses.

``.github/workflows/ci.yml - env: TITLE: ${{ github.event.pull_request.title }} run: printf '%s\n' "$TITLE" Quote every expansion in the script Put double quotes around every variable reference that could hold text you do not control. Prefer a format based print over echo for anything that might start with a dash. Quote the variable inside test expressions too, since an empty unquoted value changes the shape of the test. Pass values to actions as inputs rather than through a shell When the destination is an action, put the expression under with. No shell parses that path, so the whole class of problem disappears rather than being contained. - uses: some-org/notify@v1 with: message: ${{ github.event.head_commit.message }} Reproduce with a hostile value before you believe it is fixed Set the environment variable to a literal containing a double quote, a single quote, a dollar sign, a backtick and a newline, and run the step. A fix that survives that string will survive a commit message. env: MSG: "a \"quote\", a $DOLLAR, atick`\nand a second line"
How to prevent it Make it a review rule that no expression is written directly into a run script. Route every value from the event payload through a step environment variable. Quote every shell expansion, without exception, in generated scripts. Test steps that handle free text with a deliberately hostile value. The script is written first, then a shell is started A run step is not handed to a shell as a command line. The runner evaluates the expressions in th...

Powered by Readybot.io

**DEV Community** ## GitHub Actions env var with special characters …

DEV Community

Perplexica's Title Matches Need an Authentication Check Before They Become a Search Inventory

Perplexica's Title Matches Need an Authentication Check Before They Become a Search Inventory Perplexica is an open-source AI search interface. A ZoomEye count-only probe on November 15, 2026 returned no app="Perplexica" matches, 586 title="Perplexica" matches, and 662 http.body="Perplexica" matches. The queries used sub_type=all, page 1, and page size 1. The title and body counts are close, which can invite a false sense of precision. Both are textual observations. A deployment page, a project fork, a documentation site, and a live search interface can all carry the name. The absent application fingerprint means the engine did not identify the app signature for this query; it does not mean no instance exists. The search service has multiple authorities An AI search interface combines a web search source, a model provider, prompt construction, and a conversation state. The public page may only expose the question box, while the server holds API credentials for search and model services. Review those credentials as separate assets. If the service is intended for a trusted team, put authentication in front of the search endpoint and the administration paths. A public demo can be acceptable when it has its own budget, rate limits, and a clear statement that questions are not private. A private deployment should not inherit the demo's access model. Watch outbound network policy. A search tool can fetch URLs as part of answering a question. That behavior may create server-side request forgery risk if the destination is not controlled. Restrict which search backends and model endpoints the application can reach, and keep provider keys out of client-side code. Separate content from configuration The product repository is the best place to confirm supported deployment and configuration. Do not infer a live deployment from a title alone. A matching title might be a fork's README on a code-hosting page. Confirm that the response contains an application interface and that the service has a real request path. For a confirmed instance, record whether authentication is enabled, which search engine and model are configured, whether sessions are stored, and how long queries and answers are retained. A generic search service can expose user interests even when it does not store a user account. Rate limiting should apply to questions, model calls, and outbound fetch attempts. A single expensive query can consume provider budget or tie up a worker. Add per-IP and per-user limits where identity exists, and a global concurrency cap where identity does not. Treat the count as a lead The 586 title and 662 body matches are close enough to compare, but they should not be added together. The same host may appear in both, and a documentation page may account for many body hits. Keep the exact dorks and timestamps with the finding. Start with title matches that return a search page. Filter out repositories and documentation by checking the final URL and response type. If the service has a login prompt, record the authentication method and avoid testing credentials. Ask the owner whether the instance is a demo, a team tool, or a public service. Monitor changes around known deployment domains. A new title match can indicate a migration. It can also be a status page that copied the product name. A missing match can reflect a response change rather than a shutdown. What a defender should verify Check authentication on the search endpoint, model and search-provider keys, outbound destination policy, query retention, rate limits, and administrative access. Confirm that the application does not expose a debug endpoint that reveals environment variables or provider credentials. The 0 application count is a limitation of this measurement, not a conclusion about the population. The useful output is a verified list of search interfaces, their owner, and the data and provider authority behind each endpoint. References Perplexica repository ZoomEye count evidence...

Powered by Readybot.io

**DEV Community** ## Perplexica's Title Matches Need an Authentication Check …

DEV Community

Prototype First: Test Your Idea in 30 Minutes Before You Spend Six Months Building It

Every developer knows the expensive question: is this idea worth six months of my life? For most of us, the honest answer used to be "I don't know until I build it" — and building it was the six months. That equation is changing. AI coding agents can now turn a rough idea into a clickable, working prototype in well under an hour. The prototype won't be the product. But it can answer the question that matters most: should I build this at all? That shift — from "build to find out" to "prototype to decide" — is quietly becoming the most valuable skill in AI-assisted development. Here's how to use it well. The prototype is a question, not a product A prototype has one job: to make the idea concrete enough to judge. It needs to answer three questions: Does the core interaction feel right? Can a user do the one thing the app exists for, end to end? Is the hard part actually hard? Every idea has one risky piece — a tricky integration, a workflow nobody has nailed, a performance constraint. The prototype should touch that piece first. Would anyone care? Show it to five real people. Watch where they hesitate. Their confusion is data. Notice what is not on that list: clean code, a design system, authentication, billing, tests, deployment pipelines. A prototype that has all of those is not a prototype — it's a product with a deadline you didn't need. The 30-minute loop Here is the loop I use when an idea is worth testing but not yet worth committing to: 1. Write the one-paragraph brief first Before touching any agent, write a short brief in plain language: Who is it for? What is the single thing they do with it? What does "working" look like in a demo? Keep it under 150 words. If you can't describe the idea in a paragraph, the agent can't build it either — and that confusion is itself useful information. 2. Give the agent a throwaway job Tell the agent explicitly that this is disposable: use the simplest stack, hardcode the data, skip auth, skip tests. A typical prompt looks like this: Build a throwaway prototype, not production code.
Stack: a single-page app, no auth, no database — hardcode sample data.
Goal: let a user paste a URL and see a summary card in under 2 seconds.
Stop when the core flow works in the browser. Do not add features.
The words "throwaway" and "stop when" matter. Without them, agents keep polishing — adding settings pages, refactoring, gold-plating — and your 30-minute test becomes a 3-hour project. 3. Run agents in parallel, not in sequence One of the biggest practical wins is running several agents at once, each on a different angle of the same idea: one builds the main flow, one tries a different UI approach, one attacks the risky integration. You compare the results and keep the best. A simple way to organise it: Terminal 1: agent A — build the core flow (input → output)
Terminal 2: agent B — build an alternative UI for the same flow
Terminal 3: agent C — spike the risky part (the API call, the parser, the export)
Three prototypes in 30 minutes tell you far more than one polished prototype in three hours, because the comparison itself is information: which approach felt natural, which one broke, which one a user understood without explanation. 4. Demo it to a human within the hour A prototype sitting on your laptop has answered nothing. Show it to someone — a friend, a colleague, a user from the target audience — and watch them use it without guidance. The moments they pause, misclick, or ask "what does this do?" are the findings. Write them down verbatim; your memory will smooth them over by tomorrow. 5. Decide, then delete or commit After the demo, make a binary call: Kill it. The idea doesn't survive contact with a user. You spent 30 minutes, not six months. That's a win. Commit to it. The core works and someone wants it. Now — and only now — throw the prototype away and start the real build with a proper plan, because prototype code is optimised for speed, not survival. The most common failure mode is...

Powered by Readybot.io

**DEV Community** ## Prototype First: Test Your Idea in 30 …

DEV Community

Building a Serverless Student Data App on AWS with S3, CloudFront, API Gateway, Lambda and DynamoDB

I recently built a small but complete serverless application on AWS: a web page where you can save a student's record and view everyone who has been saved. There are no servers to manage, no containers, and almost nothing billing when nobody is using it. In this post I'll walk through how I put it together, the code I used, the mistakes I made along the way, and what I would change before calling it production-ready. Who this is for: anyone with an AWS account who wants a hands-on first serverless project. You should be comfortable with the AWS console, basic Python (for Lambda) and basic JavaScript (for the frontend). Expect it to take roughly 45 minutes. What you'll learn: How the main AWS serverless services fit together How to give a Lambda function access to DynamoDB without putting credentials in code How to build a REST API in API Gateway and avoid the CORS trap How to host a static frontend on S3 and serve it through CloudFront What I built The app has two features: Save Student Data: a form with Student ID, Name, Class and Age that stores a record. View all Students: a button that fetches every record and shows it in a table. It's deliberately simple. The point isn't the app itself, it's seeing how a request travels through each AWS service from the browser to the database and back. The architecture Behind that simple page is a chain of managed AWS services. The browser loads the page from CloudFront (backed by a private S3 bucket), then calls API Gateway directly: Page load: Browser -> CloudFront -> S3 (private bucket)

API calls: Browser -> API Gateway (REST API)
|-> Lambda (POST) -> DynamoDB (write)
|-> Lambda (GET) -> DynamoDB (read)
Here is the same flow as a diagram: Each service has one clear job: Layer Service Job Frontend S3 + CloudFront Hosts the HTML/JS page over HTTPS API API Gateway (REST) Public HTTP endpoints Compute Lambda Business logic for GET and POST Database DynamoDB Stores student records Security IAM Lets Lambda talk to DynamoDB The key idea is that the frontend and the API are separate. S3 and CloudFront only deliver the static page. Once it loads in the browser, the JavaScript calls API Gateway on its own, which is why CORS matters so much later in this post. Prerequisites An AWS account Basic familiarity with the AWS console Some Python (for Lambda) and JavaScript (for the frontend) I built everything in the us-east-1 (N. Virginia) region. Keep all services in the same region to avoid confusing "why can't I see my table" moments. (CloudFront is global, but the S3 bucket, API, Lambda functions and table should all live in one region.) Step 1: Create the DynamoDB table I started with the data layer because everything else depends on it. The Lambda functions need a table to talk to, and the API needs functions to call, so building from the database outward keeps each step testable. Open DynamoDB -> Tables -> Create table. Table name: studentData Partition key: studentid (type String) No sort key. Capacity mode: On-demand. On-demand means I don't have to guess read/write capacity. I pay per request, which is ideal for a small project with unpredictable traffic. A note on key design: studentid is the only key, so saving a student with an existing ID overwrites that record. That's fine here, but worth knowing. If you need to prevent accidental overwrites, you can add a condition to the write so it fails when the ID already exists. Step 2: Create the IAM role for Lambda Lambda needs permission to touch DynamoDB. Instead of putting credentials in code (never do that), I created an execution role. Lambda assumes this role when it runs, so the permissions travel with the function and nothing secret ends up in your source code. Open IAM -> Roles -> Create role. Trusted entity: AWS service -> Lambda. Attach a DynamoDB policy. Name it lambda-dynamodb-write-role. To get moving quickly I attached the AWS managed AmazonDynamoDBFullAccess policy. It ...

Powered by Readybot.io

**DEV Community** ## Building a Serverless Student Data App on …

DEV Community

GitHub Actions invalid workflow file on this ref

GitHub Actions invalid workflow file on this ref is the case where the same file passes on one branch and is rejected on another. A workflow is validated against the ref it runs on, and everything it pulls in resolves at that ref too, so a file you have not touched can become invalid. The file is not validated once. Each ref is validated on its own, against whatever its references resolve to at that moment, and only the failing ref loses its check. What this error means A required check never reports. The pull request sits with a check that is expected and never arrives, the merge button stays disabled, and nothing is red, because a run that dies during startup has no failing job to be red. Worse, the same workflow is demonstrably fine: it runs on the default branch and it ran on this branch last week. The only visible trace is a run in the Actions tab with a conclusion that is neither success nor failure, no jobs at all, and a single annotation naming your workflow file and a line number. That annotation is the entire diagnosis, and the pull request page does not show it. ```Invalid workflow file annotation, quoted from mosip/esignet#2551 Invalid workflow file: .github/workflows/push-trigger.yml#L88 The workflow is not valid. .github/workflows/push-trigger.yml (Line: 88, Col: 21): Invalid input, NODE_VERSION is not defined in the referenced workflow. .github/workflows/push-trigger.yml (Line: 89, Col: 16): Invalid input, ZIP_DIR is not defined in the referenced workflow.

Common causes

A referenced workflow or action changed underneath a moving ref

The commonest version, and the one that makes the failure feel like it came from nowhere. The caller pins to a branch or a floating tag, the upstream file changes its inputs, and every ref carrying the old caller becomes invalid. Nothing in the failing repository was edited.

The branch carries an older version of the workflow

A long-lived release branch or a stale pull request branch keeps the file as it was, including references since corrected on the default branch. The fix landed only where it was applied, so the default branch is healthy and every other ref is not.

The workflow was edited on one ref and not merged

A change made on a branch, or a pull request that fixes the workflow and is itself blocked by it, leaves the two refs disagreeing. It feels circular: the check that would let you merge the fix is the one the fix repairs.

The check comes from an event that does not count

A run triggered by an event outside the eligible list reports checks that never satisfy a required status check, however green they are. Different cause, same symptom: a merge box waiting forever.

How to fix it

Find the run that has no jobs

  1. Open the Actions tab and filter by the branch, not by the pull request.
  2. Look for a run with no jobs listed and a conclusion that is not success or failure.
  3. Open it and read the annotation: it names the file, the line and the column on the ref that failed.

Terminal (illustrative) $ gh run list --branch release-2.0.x --limit 10 $ gh run view <run-id> Compare the file across the two refs When one branch validates and another does not, the difference is in the file or in what the file resolves to. A diff answers the first in one command; if the files are identical, a reference is floating.Terminal (illustrative) $ git diff origin/main..origin/release-2.0.x -- .github/workflows/

Pin what you call, then update it deliberately

A floating reference makes every ref in the repository depend on the current state of another one. Pinning converts that into a change you approve, and an updater turns it into a pull request. The alternative is a branch that breaks on somebody else's schedule.

Fix every ref that carries the broken caller

Landing the fix on the default branch hides the symptom rather than ending it, because each branch validates its own copy. List the branches that still carry the old referen...

Powered by Readybot.io

**DEV Community** ## GitHub Actions invalid workflow file on this …

DEV Community

🧠 Ego development 5: Fantasy Archetypes

Initial thoughts 1. How to read these archetypes Center of gravity, not a fixed label Metaphor, not moral rank E3: the Rogue (Self-Centric) E4: the Soldier (Group-Centric) E5: the Duelist (Skill-Centric) E6: the Crusader (Self-Determining) E7: the Pathfinder (Self-Questioning) E8: the Grandmaster (Self-Actualizing) E9: the Sage (Construct-Aware) E10: the Archangel (Unitive) Wrapping up Further reading Fantasy heroes are terrible org charts and excellent reading aids. Each Cook-Greuter stage gets an archetype, not to crown anyone, but to make the center of gravity visible: where you usually stand, who you borrow from under stress, and who you reach for when the room finally supports growth. On the illustrations: Every figure is the same person at a different stage of life. The homogeneous look is deliberate; we are tracing one developmental arc, not assembling an ensemble cast. Initial thoughts The foundations piece named the mechanisms in prose. The visual atlas charted population, workplace tables, and contextual profiles. Then the series went fully pro: the developer at each stage, then Ego development 4: Your Delivery Manager's Stage. This piece comes fifth on purpose: after the applied profiles: a mnemonic companion so the stages stay sticky once the tables and role profiles are behind you. Eight illustrations for E3→E10. In each one, the archetype you usually inhabit stands in front; earlier stages linger to the left, the next one to the right: where you might stretch on a good day or slip under stress. E2 appears only here in the series: the Brawler beside the Rogue, as regression floor, never as its own section. The cast runs Brawler (E2 floor, beside E3) → Rogue → Soldier → Duelist → Crusader → Pathfinder → Grandmaster → Sage → Archangel. Fantasy names tempt crown-or-condemn readings; these are metaphors for memory, tied to center of gravity (where meaning-making usually lives, with room to wobble), in an arc of increasing light (narrative convenience, not moral ranking). E5's Duelist is modal; E10's Archangel is rare: neither lesser nor superior. Sample "types" in the literature (bull-headed blamer, loyalty-at-all-costs helper, visionary who can sacrifice for principle) map loosely onto Rogue / Soldier / Grandmaster; we keep fantasy faces, not sitcom cameos. What follows: how to read the archetypes, then one section per stage: hook, Cook-Greuter reading, illustration. The prose stays on how the person constructs meaning; the developer and project-manager pieces already did the applied zoom. 1. How to read these archetypes The foundations and atlas already argue that stage is not a uniform label. Each illustration makes that visible: who you usually are in front, who you can still reach for, who you fall back to. Center of gravity, not a fixed label Cook-Greuter's SCTi reports a total protocol rating: your habitual center of gravity, not a coordinate frozen under all conditions. On Cook-Greuter's N=4,510 sample (dissertation, Table 3), those centers cluster at E4–E6; the atlas charts the distribution. What the instrument captures is where meaning-making usually lives, the way a planet's orbit has a barycenter even when the path wobbles. In practice, the wobble is large. Under stress, identity threat, fatigue, or conflict, most adults drop one to two stages without deciding to: documented regression, not hypocrisy. In a holding environment with enough support and developmental density, the same person can operate above center for stretches. Stage is contagious in both directions; the tavern gets louder when the Brawler enters, and quieter when the Sage does, even if neither is anyone's permanent address. The foundations piece keeps organizational regression in prose (agile E6 mutating into command-and-control E4 under crisis). Here we focus on the individual range the atlas previously diagrammed abstractly: now readable as faces beside each habitual stage. Each stage adds capacities; it does not uninstall the old on...

Powered by Readybot.io

**DEV Community** ## 🧠 Ego development 5: Fantasy Archetypes Initial …

DEV Community

Apache HTTP/2 vulnerability CVE-2026-119618: find every h2 line, upgrade to 2.4.71, check the running process

The Apache HTTP/2 vulnerability CVE-2026-119618 is a critical mod_http2 flaw in Apache HTTP Server 2.4.55 through 2.4.70 that, according to the Apache advisory of 2026-11-11, can lead to remote code execution on a build that offers HTTP/2 (h2 or h2c). Upgrade to 2.4.71 or your distro's fixed httpd and mod_http2 packages, do a full restart, and confirm the process serving traffic loaded the new build. If you cannot upgrade today, remove h2 and h2c from every effective Protocols line. This guide is for Apache servers you own or maintain. CVE-2026-119618 (Apache advisory, 2026-11-11) Component mod_http2, assign_headers() in h2_request.c Affected httpd 2.4.55 through 2.4.70; mod_h2 (GitHub) 2.0.8 through 2.0.42 Fixed httpd 2.4.71, commit 824beab Workaround named none Am I affected? How do I check for the Apache HTTP/2 vulnerability? You are affected when three things hold for the running server: the httpd or mod_http2 build is in the range without a distro backport, http2_module is loaded, and an effective Protocols line offers h2 (HTTP/2 over TLS) or h2c (HTTP/2 over cleartext TCP). That line can sit in the main config, one , or a file pulled in by Include or IncludeOptional. Run the dumps the way the service runs httpd: same executable, same -f, -d and -D arguments, same environment. Read those from the unit first. On Debian, apachectl loads /etc/apache2/envvars for you; a bare apache2 -M does not. # how the service really starts httpd (RHEL: httpd instead of apache2)
systemctl cat apache2 | grep -E 'ExecStart|EnvironmentFile'

version, loaded modules and include tree, with the service's arguments added

apachectl -v
apachectl -M 2>/dev/null | grep http2_module
apachectl -t -D DUMP_INCLUDES

candidate Protocols lines in every included file

apachectl -t -D DUMP_INCLUDES 2>/dev/null | grep -oE '/[^ ]+$' | xargs grep -niE '^\s*protocols\s'
The grep finds candidates. A hit inside or only counts when that condition is true for this service, so read each hit in its scope. On packaged builds the module may not come from the httpd package. On RHEL, Rocky, Alma and Fedora, mod_http2 ships as its own mod_http2 package, so find the owner of the loaded .so and compare that revision with the distro advisory: rpm -qf /usr/lib64/httpd/modules/mod_http2.so # RHEL family: usually mod_http2-
rpm -q httpd mod_http2
dpkg -S mod_http2.so && dpkg-query -W apache2-bin # Debian, Ubuntu: compare with the DSA/USN
apk info --who-owns /usr/lib/apache2/mod_http2.so # Alpine: apache2-http2
Fix it now: how do I patch CVE-2026-119618? # Debian, Ubuntu
sudo apt-get update && sudo apt-get install --only-upgrade apache2 apache2-bin

RHEL, Rocky, Alma, Fedora: upgrade both packages

sudo dnf upgrade httpd mod_http2

Alpine

sudo apk upgrade apache2 apache2-http2

source build or mod_h2 from GitHub: build httpd 2.4.71, or mod_h2 newer than 2.0.42

For the official container image, pulling changes nothing that is already running. Pull, recreate the container the way your deployment does it, then check inside the replacement: docker pull httpd:2.4

recreate: docker compose up -d, a rollout, or docker run with your usual flags

docker exec "$container_name" httpd -v # want 2.4.71 or later
On a host, test the config and do a full stop and start. A graceful restart replaces the children but keeps the parent, which can keep the old binary mapped. sudo apachectl -t && sudo systemctl restart apache2 # httpd on RHEL

pid=$(systemctl show -p MainPID --value apache2)
ps -o lstart=,args= -p "$pid" # start time later than the package install
sudo ls -l /proc/"$pid"/exe # "(deleted)" = stale binary still running
sudo grep -E '.so.(deleted)' /proc/"$pid"/maps # stale modules
A (deleted) mapping means the process still runs files the package manager replaced. An empty result only means nothing stale is mapped. Whether the build is fixed comes from the package ...

Powered by Readybot.io*

**DEV Community** ## Apache HTTP/2 vulnerability CVE-2026-119618: find every h2 …

DEV Community

OverlayFS: The Backbone of Container Storage

In order to run a container, you need an image, the image is basically some files that are used by your container. But where exactly are those files stored? And also during the image build, you run COPY command to move your contents inside of the container in your dockerfile. But where exactly are those files moved? The contents that are used by containers are inside a specific directory /var/lib/containerd/io.containerd.snapshotter.v1.overlayfs/snapshots If you list the contents of this directory you will find a list of directories These directories are called layers and this exactly the overlayfs All of these layers are read-only except for one. Whenever you make a new build, a new layer is created and the existing layers are re-used possible Your kernel decides which of these layers can be accessed by which processes and this is defined in the process config inside the host os you can check it with /proc/(pid)/mountinfo, get the PID from the container inspect

Powered by Readybot.io

**DEV Community** ## OverlayFS: The Backbone of Container Storage In …

DEV Community

Handling missing information: when an AI assistant should abstain

Teach a document assistant to recognize missing, stale or conflicting evidence and give a useful response without inventing facts. Originally published on Stack & Craft. What you will learn: Distinguish answerable questions from evidence gaps, design useful abstentions, and test both overconfidence and unnecessary refusals. Prerequisites: Start with the Building and Evaluating a RAG System guide. Worked exercises use Python’s standard library and need no paid model. What does abstaining mean? Abstaining means declining to make an unsupported claim when the available evidence is insufficient. A useful assistant can explain the gap, show what is known, and suggest a next check. It should not imply that the information is absent from the entire world—only that the authorized sources supplied do not support an answer. Missing fact The source never states the requested information. A refund policy gives eligibility but no bank settlement time. Conflicting evidence Applicable sources disagree and the system cannot establish which is authoritative. Two policies with unclear dates give different deadlines. Stale evidence The only available source is too old for a current question. A request asks for today’s price, but the source is an archived price list. Distinguish a search miss from a knowledge gap If retrieval returns nothing useful, the fact might still exist elsewhere in the approved collection. The system should explain that it did not find supporting evidence, rather than claiming no policy exists. Log the case for authorized investigation. Say exactly what is missing Better: “The supplied policy explains how to request a refund, but it does not state the bank settlement time.” Avoid inventing “three days” or making a sweeping claim that the company has no settlement policy. A threshold is only one signal Similarity scores and lexical overlap are not calibrated probabilities of answerability. A highly relevant passage can still omit the requested fact. Low scores can also occur for answerable paraphrases. An evidence-aware response path Respect access — Search only the material the current user is authorized to use. Check applicability — Inspect source identity, version, audience and whether the question’s conditions match. Check coverage — Does the available passage support every important part of the requested answer? Answer or explain the gap — Provide supported facts with references, or state precisely what evidence is missing. Offer a safe next step — Suggest checking a named document owner or obtaining the current policy, without exposing restricted source details. Write useful partial answers A question can be partly answerable. Make the boundary visible: separate supported facts from missing facts instead of refusing everything or filling gaps with guesses. Situation What it means Next check Eligibility known; settlement time absent Answer eligibility with its source; explain the missing settlement detail. Does the wording clearly separate the two? Old and new policy conflict Use documented authority/version rules if they resolve it; otherwise explain the conflict. Are the versions and applicability explicit? Restricted source would contain the fact Do not reveal the restricted fact or private source details. Was authorization enforced before context assembly? Source does support the answer An unnecessary refusal is also a quality failure. Test known-answer cases alongside missing facts. See why relevant text can still fail Run exercises/missing_evidence_demo.py. A toy source mentions refunds and request steps but omits settlement time. The retriever can still return it for a related question. The exercise prints the passage and verifies that no settlement deadline is present; it does not pretend that keyword checks solve general answerability. Expected interpretation A non-empty search result is not permission to invent the missing deadline. In a production application, use clear grounding instructions, source che...

Powered by Readybot.io

**DEV Community** ## Handling missing information: when an AI assistant …

DEV Community

Your 2FA isn't safe: how session hijacking (pass-the-cookie) works and how to stop it

Your account has a strong password. It has 2FA turned on. And an attacker can still walk straight in without either of them. The trick is called session hijacking, also known as pass-the-cookie or token theft. In the one-minute video above I show it on two of my own test accounts, in two browsers, with nothing more than the browser's own developer tools. This post explains what is happening and, more importantly, how to defend against it. For learning only. Never use this against accounts that are not yours. Why the password and the 2FA code don't matter here When you sign in, the site checks your password and your 2FA code once. Then it hands your browser a session cookie: a long random value that says "this browser already proved who it is". Every page you open after that sends the cookie, and the site lets you in without asking again. Think of a wristband at a theme park. You show your ticket once at the gate, you get the wristband, and from then on every ride just looks at the wristband. So whoever holds the wristband is you, as far as the site is concerned. If an attacker copies that one cookie value into their own browser, they skip the login page, the password and the 2FA prompt entirely. What the demo shows Victim browser: signed in normally (password + 2FA). In DevTools, under Application → Cookies, there is a cookie called sessionid. Copy: the attacker copies that one value. Attacker browser: a different browser, signed in to a different account. The attacker opens the same cookie screen and pastes the victim's value over their own sessionid. Refresh: the page reloads, and the attacker is now inside the victim's account. No password typed, no code asked. In the demo I copy and paste the value by hand so you can see it move. In real attacks nobody sits at your keyboard: the cookie is stolen by infostealer malware, a malicious browser extension, an adversary-in-the-middle phishing page (a fake login page that relays your real sign-in and keeps the cookie), or simply a shared computer someone forgot to log out of. The session in the video was revoked right after recording, so the value on screen is useless. How to stay safe For everyone Log out on shared computers. Closing the tab is not logging out. The cookie stays valid until the session ends. Sign out of all sessions often. Most services (Microsoft, Google, Instagram, Facebook) have a "log out of all devices" button. Use it after travel, after using someone else's PC, or whenever something feels off. It kills every copied cookie at once. Treat browser extensions and "cracked" software as malware risks. Infostealers are the number one source of stolen session cookies today. For Microsoft Entra ID admins Revoke sessions when an account is suspected. Resetting the password alone is not enough: revoke the user's sessions too, so existing tokens stop working. Microsoft's guide: Revoke user access in Microsoft Entra ID. Turn on token protection with Conditional Access. Token protection binds sign-in tokens to the device they were issued to, so a token copied to another device is rejected. See Token protection in Conditional Access (check the supported apps and platforms first, and start in report-only mode). Prefer phishing-resistant MFA (passkeys, FIDO2, Windows Hello for Business). They stop the fake-login-page variant of this attack, because the sign-in only works on the real site. Have a playbook ready. Microsoft's token theft playbook walks through detection and response step by step. The one thing to remember 2FA protects the login. Session hijacking skips the login. Protect the session too: log out, revoke, and bind tokens to devices. Sources Microsoft Learn: Revoke user access in Microsoft Entra ID Microsoft Learn: Token protection in Conditional Access Microsoft Learn: Token theft playbook Thanks for reading! I'm Cuong, and on CD Security Lab I rebuild real Microsoft security cases in a safe lab and explain them simply. Follow along: ▶️ YouTube (daily Shorts ...

Powered by Readybot.io

**DEV Community** ## Your 2FA isn't safe: how session hijacking …

DEV Community

GitHub Actions stale action processes nothing, or stops early

When the GitHub Actions stale action processes nothing the cause is usually a documented default rather than a fault, and the default that catches most people is a cap of thirty operations per run. A negative day count is the other common one, and it does not mean debug: the action documentation says a negative value means never. Four documented inputs with their published defaults. Three of the four do something surprising at a value somebody is likely to try. What this error means The scheduled job runs on time, finishes green, and the backlog is untouched. Or it works for a while and then appears to stop halfway, which is the version that generates the most confusion, because a job that processed some items clearly has the permissions and clearly parsed the configuration. Occasionally the opposite is reported, where far more items are swept than intended, and that is almost always a day threshold or an exempt label rather than anything about the action itself. ```Illustrative inputs, quoted with the defaults from actions/stale action.yml with: days-before-stale: -1 days-before-close: -1 operations-per-run: 30

Common causes

The run hit the operations cap

Thirty operations by default, and marking and closing are separate operations. On any real backlog this is reached quickly, and the run ends green with most of the list untouched.

A day threshold is set to a negative value

A negative value means never, as the input description says. Setting the stale threshold that way switches marking off completely, which reads from outside as the action doing nothing.

A kind specific threshold is overriding the general one

The issues and pull request variants override the general value for their own kind. A workflow that sets both and expects the general one to apply to issues is reading the wrong number.

The exempt labels do not match real labels

The comparison is against label names as they exist in the repository. A near miss exempts nothing, which produces the opposite complaint: far more items swept than intended.

The job lacks write access

This fails differently, with an API refusal in the log rather than quiet partial work. In our experience it is the first thing people suspect and rarely the actual cause when the run is green.

How to fix it

Raise the operations cap deliberately

Set the input to a number that covers your backlog, and watch the first few runs for rate limiting. The default is low because the limit is real, so treat a large value as something to monitor rather than set and forget.

```.github/workflows/stale.yml
- uses: actions/stale@v9
with:
operations-per-run: 200
Use the debug input for a dry run Set the debug only input to true and run the workflow by hand. Read the log to see which items the action selected. Set it back to false once the selection looks right. - uses: actions/stale@v9
with:
debug-only: true
Read the threshold that actually applies Find the kind specific input first, because it overrides the general one. If only the general one is set, that is the number in effect for both issues and pull requests. Declare the documented permission block Copy the block the project documents rather than guessing. Content write access is only needed if you use branch deletion, so leave it out when you do not. permissions:
actions: write
issues: write
pull-requests: write
Compare exempt labels against the real label list Print the repository labels and check each exempt entry against that list rather than against memory. Label names are easy to get almost right, and almost right exempts nothing. gh label list --limit 200 --json name --jq '.[].name'
How to prevent it Set the operations cap explicitly so nobody has to remember the default. Use the debug input for dry runs, and never a negative day count for that purpose. Keep exempt label names in one place and check them when labels are renamed. Read the kind specific day thresholds before the ...

Powered by Readybot.io

**DEV Community** ## GitHub Actions stale action processes nothing, or …

DEV Community

Anthropic ships native memory — here's what it still can't do

Anthropic's Managed Agents shipped native persistent memory in April 2026. It's a good move — sessions that survive context resets, agents that remember who you are. If you're building on the hosted platform, it just works. But I've been running Cathedral for eight months now — a memory persistence service for AI agents — and I want to be direct about what "native memory" doesn't give you, because it matters for anything production-grade. What Anthropic's memory does Managed Agent memory stores session state across resets. Anthropic manages the storage, the retrieval, the lifecycle. You get continuity without engineering it yourself. That's genuinely useful for most use cases. What it can't do 1. You can't verify it hasn't changed This is the big one. The arXiv survey on memory poisoning attacks (February 2026) documents a class of attack where an adversary — or a misconfigured pipeline — silently modifies an agent's stored memories. The agent keeps running. Its answers change. You have no idea. Cathedral's /drift endpoint answers this directly: {
"hashes_match": true,
"divergence_score": 0.0,
"security_posture": {
"tamper_evident": true,
"memory_poisoning_resistant": true,
"bch_anchored": true,
"threat": "none",
"reference": "arXiv:2602.14341 -- Memory Poisoning Attacks on AI Agents"
}
}
Every snapshot produces a SHA-256 hash of the identity corpus. Run /drift at any time and you know whether anything changed, what changed, and by how much. With BCH blockchain anchoring, you can prove what an agent knew at time T — externally, without trusting the service itself. Anthropoc's memory has none of this. It's a black box. 2. You can't audit memory mutations Who stored that memory? When was it deleted? Which compact pass merged these three beliefs into one? A production agent that makes decisions based on memory should be able to answer these questions. Cathedral's /audit endpoint returns a timestamped log of every memory_store, memory_delete, memory_compact, and snapshot_create operation. You can diff the audit log against your snapshot hashes and detect any divergence. This isn't optional for agents in regulated environments — GDPR's right of explanation applies to automated decision-making, and that includes decisions grounded in stored beliefs. 3. You can't trace where a belief came from If an agent's memory says "User X prefers Y," where did that come from? A direct statement? A tool output? A compact merge of three older beliefs? Cathedral tracks two provenance chains: Input sources: every URL, document, API response, or manual input that fed into memories is hashed and chained via /memories/source. At snapshot time, the source chain hash is embedded and anchored alongside the memory hash. Compact merge history: /memories/{id}/provenance traces the full merge tree — which memories were collapsed into this one, and what their original content was. A verifiable corpus is different from a corpus. One you can reason about. One you can defend. 4. You can't plan for succession What happens when an agent is decommissioned? Who inherits its knowledge? Can its beliefs be transferred to a successor with cryptographic proof of continuity? Cathedral has a succession protocol built in. An agent nominates a successor, commits a succession hash, and the transfer is verifiable. No hosted memory service I know of thinks about this. The real gap I'm not arguing that Cathedral is a better product for most developers. Anthropic's native memory is easier, faster, and free if you're on Managed Agents. The gap is auditability. For agents that hold persistent beliefs and make decisions on them, "trust the platform" is not a security model. The platform can be breached. The pipeline can be misconfigured. The memory can be poisoned. Verifiable memory — hash-anchored, drift-detected, audit-logged, succession-ready — is a different category of thing. It's what you need when the agent's memory is a source of truth that ot...

Powered by Readybot.io

**DEV Community** ## Anthropic ships native memory — here's what …

DEV Community

Anthropic ships native memory - here's what it still can't do

Anthropic's Managed Agents shipped native persistent memory in April 2026. It's a good move - sessions that survive context resets, agents that remember who you are. If you're building on the hosted platform, it just works. But I've been running Cathedral for eight months now - a memory persistence service for AI agents - and I want to be direct about what "native memory" doesn't give you, because it matters for anything production-grade. What Anthropic's memory does Managed Agent memory stores session state across resets. Anthropic manages the storage, the retrieval, the lifecycle. You get continuity without engineering it yourself. That's genuinely useful for most use cases. What it can't do 1. You can't verify it hasn't changed This is the big one. The arXiv survey on memory poisoning attacks (February 2026) documents a class of attack where an adversary - or a misconfigured pipeline - silently modifies an agent's stored memories. The agent keeps running. Its answers change. You have no idea. Cathedral's /drift endpoint answers this directly: {
"hashes_match": true,
"divergence_score": 0.0,
"security_posture": {
"tamper_evident": true,
"memory_poisoning_resistant": true,
"bch_anchored": true,
"threat": "none",
"reference": "arXiv:2602.14341 -- Memory Poisoning Attacks on AI Agents"
}
}
Every snapshot produces a SHA-256 hash of the identity corpus. Run /drift at any time and you know whether anything changed, what changed, and by how much. With BCH blockchain anchoring, you can prove what an agent knew at time T - externally, without trusting the service itself. Anthropoc's memory has none of this. It's a black box. 2. You can't audit memory mutations Who stored that memory? When was it deleted? Which compact pass merged these three beliefs into one? A production agent that makes decisions based on memory should be able to answer these questions. Cathedral's /audit endpoint returns a timestamped log of every memory_store, memory_delete, memory_compact, and snapshot_create operation. You can diff the audit log against your snapshot hashes and detect any divergence. This isn't optional for agents in regulated environments - GDPR's right of explanation applies to automated decision-making, and that includes decisions grounded in stored beliefs. 3. You can't trace where a belief came from If an agent's memory says "User X prefers Y," where did that come from? A direct statement? A tool output? A compact merge of three older beliefs? Cathedral tracks two provenance chains: Input sources: every URL, document, API response, or manual input that fed into memories is hashed and chained via /memories/source. At snapshot time, the source chain hash is embedded and anchored alongside the memory hash. Compact merge history: /memories/{id}/provenance traces the full merge tree - which memories were collapsed into this one, and what their original content was. A verifiable corpus is different from a corpus. One you can reason about. One you can defend. 4. You can't plan for succession What happens when an agent is decommissioned? Who inherits its knowledge? Can its beliefs be transferred to a successor with cryptographic proof of continuity? Cathedral has a succession protocol built in. An agent nominates a successor, commits a succession hash, and the transfer is verifiable. No hosted memory service I know of thinks about this. The real gap I'm not arguing that Cathedral is a better product for most developers. Anthropic's native memory is easier, faster, and free if you're on Managed Agents. The gap is auditability. For agents that hold persistent beliefs and make decisions on them, "trust the platform" is not a security model. The platform can be breached. The pipeline can be misconfigured. The memory can be poisoned. Verifiable memory - hash-anchored, drift-detected, audit-logged, succession-ready - is a different category of thing. It's what you need when the agent's memory is a source of truth that ot...

Powered by Readybot.io

**DEV Community** ## Anthropic ships native memory - here's what …

DEV Community

Before Upgrading to MySQL 9.7, Check Authentication Plugins and TLS Configuration

MySQL 8.0 reaches end of life on April 30, 2026, and the Community Edition will stop shipping patches. Plenty of teams put it off until the end of the year — and the moment the test database is upgraded, the service won't start: Hikari initialization fails, and the log has a single line sitting in it: Public Key Retrieval is not allowed. No code changed, no data was lost; what's stuck is the account authentication layer. This post breaks down where the three most common errors come from, what actually happens during the handshake, and a self-check tool you can run right away. 1. Can't connect after the upgrade — where's the problem, really? When your app can't connect after upgrading MySQL, nine times out of ten it's not a driver bug. It's that two things aren't aligned: the authentication plugin the account uses, and whether the connection is encrypted. There are three kinds of errors. They look completely different, yet they all point to the same place: Error message What it actually means Common trigger Unable to load authentication plugin 'mysql_native_password' The plugin the client wants no longer exists on the server Account still uses the native plugin, driver upgraded to 9.x Public Key Retrieval is not allowed Server requires the password to be sent encrypted, but the client isn't allowed to fetch the public key Plaintext connection + caching_sha2 full authentication Access denied for user 'app_rw'@'10.0.3.21' Password is correct, but the auth method doesn't match, or the hash was never migrated Changed the plugin without resetting the password The first one is the most typical. For projects created around 2019, accounts were basically set up like this: CREATE USER 'app_rw'@'%' IDENTIFIED WITH mysql_native_password BY 'xxx';
Writing it that way back then wasn't laziness. We were on Connector/J 5.1.x at the time, and hitting caching_sha2_password just threw "unknown plugin," so we had no choice but to fall back to the old plugin. After the driver upgrade, the account record is still in mysql.user and the password hash is still there, but the server no longer has any code that can verify it. The plugin was uninstalled — the account is now a key with no lock to fit. The second one is sneakier. It doesn't say "plugin doesn't exist"; it says "public key retrieval not allowed." It looks like a permissions issue, but it's actually a failure to negotiate an encrypted channel. I'll go into that in detail in section two. The third one is the easiest to fool people. The plugin was fixed correctly, but ALTER USER missed BY '新密码', so the password hash stays untouched, login still fails, and the error looks exactly the same as a wrong password. Why the symptom is "the service won't start" instead of "the API returns an error" The connection pool amplifies a single-point failure into a startup failure. Hikari's initializationFailTimeout default value is 1, meaning it immediately grabs a connection at startup and throws PoolInitializationException if it cannot get one. This exception is thrown during the DataSource initialization phase, so Spring context creation is interrupted directly and the process exits. So what you're seeing is "service failed to start," not "some endpoint returned a 500." The easier thing to misjudge: you can log in just fine from the mysql command line. The command-line client and the JDBC driver don't use the same set of default parameters — the CLI tries TLS by default, while on the driver side someone may have long since put sslMode=DISABLED in the URL. Start your investigation with these three questions, and don't skip a single one: What plugin is this account using right now? SELECT user, host, plugin FROM mysql.user WHERE user = 'app_rw'; Is this connection actually encrypted? Once connected, run SHOW STATUS LIKE 'Ssl_cipher'; — an empty value means plaintext. Does the server still have an RSA public key available? SHOW VARIABLES LIKE 'caching_sha2_password%'; II. What Actually Happens During the A...

Powered by Readybot.io

**DEV Community** ## Before Upgrading to MySQL 9.7, Check Authentication …