Pixel

Pixel Updates & Events

Server Updates & Events

Announcements

DEV Community

Task Queue Retry Called The Customer Twice And An Exists Check Will Not Stop It

By Rokas Remeika. Published 22 September 2026. An at-least-once task queue retrying a telephony placement can ring a person twice, even if you check whether a call record already exists. This happens because the platform's native webhooks can create the call record before your dial RPC returns, and because a queue's retry timeout often fires while the first attempt is still ringing. To fix it, you need two markers. First, a post-placement marker written only by your dial code to prove the call happened. Second, a pre-placement attempt marker that locks the number for a window sized to your ringing timeout plus the queue's acknowledgment budget. Symptoms An at-least-once task queue retries the outbound dial task, and the same person is called twice within a minute. The queue metrics show only one logical task being processed, but the carrier logs show two distinct INVITEs leaving your infrastructure. The guard clause most people reach for (checking if the call record already exists before dialing) either never fires, or it fires on the first attempt and blocks a call that was never actually placed. The trap worth stating plainly: "does a record for this call exist" feels like idempotency and is not, as soon as more than one component can create that record. What is actually happening Two separate problems stack together to defeat a basic existence check. First, the call record is rarely authored by a single writer. The platform's native room-started webhook is fast and can easily create the record before the dial RPC returns. Because webhooks and the dial process run concurrently, the record existing is not evidence that a dial happened. An existence check in this state is simply reading a marker somebody else wrote. Second, the dangerous window occurs exactly between the moment we start placing the call and the moment we record the successful placement. Outbound ringing takes tens of seconds. A task queue that retries based on an acknowledgment timeout or visibility budget will re-enter the dial pipeline exactly during this window. Because the first attempt has not returned yet, nothing has been written to confirm placement. By definition, the existence check allows the second attempt through, resulting in a duplicate call. How to confirm it Log every queue redelivery of a dial task as an explicit event. This makes retries visible as events rather than being inferred from duplicate INVITEs. Correlate the webhook arrival time with the dial RPC return time for a single session. Expect to see the platform's room-started webhook arriving and writing to your database before the dial RPC completes its execution, proving that record existence is untrustworthy as an idempotency key. Measure the time from the attempt marker being written to the placement marker being written, per call. Count attempts refused by the in-flight window separately from attempts refused as already placed. How it works To prevent double-dials under queue retries, I use two markers with entirely different jobs. Relying on document existence is fundamentally flawed when multiple writers are involved. You have to pick fields that only the dial path can write, and check those fields exclusively. First, a post-placement marker serves as the final proof that a dial actually happened. This is written only by the dial path, and only after the placement RPC returns successfully. You check this field to know if the side effect is complete, never the bare document existence. Second, a pre-placement attempt marker closes the in-flight window. This is written immediately before firing the RPC. It acts as a bounded lock: any attempt that starts inside a specific validity window after an existing attempt marker is refused. I size that window to the 45 s ringing timeout plus the queue's acknowledgment budget. This guarantees that a genuinely in-flight attempt blocks a retry, while a dead attempt eventually releases the lock instead of wedging the phone number forever. En...

Powered by Readybot.io

**DEV Community** ## Task Queue Retry Called The Customer Twice …

DEV Community

Greenlight Counts Need a BigBlueButton Context Before They Mean Anything

Greenlight Counts Need a BigBlueButton Context Before They Mean Anything Greenlight is the end-user web interface for a BigBlueButton server. It handles accounts, rooms, meeting links, recordings, and the transition from a web session into a real-time conference. A ZoomEye count-only probe on November 15, 2026 returned 1 app="Greenlight" match, 1,108 title="Greenlight" matches, and 55,975 http.body="Greenlight" matches. The scope was sub_type=all, page 1, and page size 1. The title and body numbers are broad textual observations. "Greenlight" is a common word and appears in project names, marketing pages, and unrelated software. A single application fingerprint is a narrow signal, not a claim that only one Greenlight deployment exists. The useful next step is to establish whether a page belongs to a BigBlueButton frontend and what that frontend can control. The frontend is not the meeting server Greenlight and BigBlueButton can run on different hosts. The web interface may create a meeting and hand the user to a conference endpoint, while the media and recording services live elsewhere. Inventory both sides. A Greenlight login page without the associated BigBlueButton service is incomplete evidence, and a conference server without an identifiable frontend may still be reachable through a direct path. Review the BigBlueButton installation and Greenlight installation guides for the expected reverse proxy, TLS, and secret configuration. Confirm that the frontend uses the intended BigBlueButton host and secret. A test or staging frontend connected to a production conference server is a cross-environment authority problem. The application fingerprint can help separate a known Greenlight asset from generic title matches, but it should be combined with a response check. Use the page structure, login flow, and documented endpoints rather than inferring from the word alone. Account and room authority Greenlight can create local accounts and rooms. Public signup, guest join, room ownership, recordings, and administrative roles should be reviewed as separate permissions. A room link may be intended to be public. The administrator interface should not share that reachability. Test the invitation and join flow with an account that has the minimum expected role. Confirm that a user cannot change another room's settings or retrieve recordings outside the intended organization. Log room creation, role changes, and recording access with a bounded meeting identifier. Protect the BigBlueButton secret and any mail or single-sign-on credentials used by Greenlight. A web frontend that can create meetings may be less sensitive than the media server, but it can still disrupt classes, expose recordings, or send invitations to unintended recipients. Capacity and exposure The 55,975 body matches are far too broad to treat as a deployment population. They include the word in many contexts. The 1,108 title matches are still a discovery set. Filter by a verified Greenlight page, a BigBlueButton-related hostname, or a known deployment range before assigning ownership. Check whether a discovered host is a public demonstration, a documentation page, or a production portal. The official Greenlight project describes a free demo environment, so public examples are expected. A demo page should not be used as evidence that an organization's private meeting service is exposed. For confirmed services, measure availability and capacity separately from security. A reachable frontend that cannot create a meeting is not the same as a usable conferencing endpoint. A frontend that can create a meeting but cannot reach the media server may create a confusing outage without exposing conference data. What to record Record the Greenlight host, application evidence, related BigBlueButton host, TLS certificate, signup mode, guest join policy, recording retention path, and owner. Keep the ZoomEye observation timestamp and exact dorks with the evidence. Do not label title mat...

Powered by Readybot.io

**DEV Community** ## Greenlight Counts Need a BigBlueButton Context Before …

DEV Community

GitHub Actions reusable workflow input type mismatch

A GitHub Actions reusable workflow input type mismatch is the caller and the called workflow disagreeing about what a value is. workflow_call inputs are declared with a type and checked against it, so a quoted string sent to a boolean input, or an expression the typed key cannot accept, stops the run before any job starts. Three declared types, one list of contexts the with block accepts, and one cast for everything that arrives as text. What this error means One of two things happens, and they look nothing alike. The loud one is a validation failure in the caller: the run never starts, and the annotation names the input and the file it was not found in, or names the value it could not use. The quiet one is worse, because the run is green. A boolean input arrives holding text, the called workflow writes if: inputs.flag against it, and the condition is true whether the text says true or false, so a deploy that was supposed to be gated runs on every call. The tell for the quiet version is that toggling the caller changes nothing at all: the job runs identically with the flag set and cleared, and the only way to see it is to print the value rather than branch on it. ```Annotation, quoted from catalyst/catalyst-moodle-workflows#159 Invalid input, disable_phpcpd is not defined in the referenced workflow

Common causes

A quoted literal sent to a boolean or number input

YAML quoting decides the type before Actions sees it. publish: true is a boolean, publish: 'true' is a string, and the declared type is checked against what YAML produced. This is the version that passes validation in some shapes and then behaves as text inside the called workflow.

The value came from an expression, so it is text

Every step output is a string by definition, and a job output built from one is a string as well. Feeding it straight into a typed key gives you either a rejection or a truthy string, depending on where the mismatch lands. The cast has to be explicit because nothing casts it for you.

The with block reached for a context it is not allowed

Only six contexts are available in jobs.<job_id>.with.<with_id>. Referencing env, secrets or steps there produces an unrecognized name, and the typed key then rejects the whole value. Secrets have their own key, jobs.<job_id>.secrets, and that one does accept the secrets context.

The key is not declared in the called workflow at all

A rename on one side, a copied caller, or an input removed from a shared workflow. The parser is explicit about it, naming the key and the file: this is the one failure in the set that tells you precisely what to change.

How to fix it

Pass literals unquoted and let YAML carry the type

  1. Write true and false without quotes for a boolean input, and bare digits for a number.
  2. Keep quotes for strings, where they are harmless and sometimes necessary.
  3. Check the called workflow declares the type you think it does before changing the caller.

.github/workflows/ci.yml (illustrative) call: uses: ./.github/workflows/deploy.yml with: publish: true retries: 3 environment: 'staging' Cast expression results with fromJSON When the value comes from a step or a job output, wrap it. The cast belongs in the caller, at the moment the text becomes a typed input, and it keeps the called workflow honest about what it declared..github/workflows/ci.yml (illustrative) with: publish: ${{ fromJSON(needs.decide.outputs.publish) }} retries: ${{ fromJSON(needs.decide.outputs.retries) }}

Compare explicitly inside the called workflow

A condition that reads a bare input is only safe if the input really is a boolean. Comparing against the value you expect makes the job behave the same way whether the input arrived typed or as text, which is a useful property while a shared workflow has callers you do not control.

```.github/workflows/deploy.yml (illustrative)
jobs:
ship:
if: ${{ inputs.publish == t...

Powered by Readybot.io

**DEV Community** ## GitHub Actions reusable workflow input type mismatch …

DEV Community

How to get an EIN without an SSN or ITIN (Form SS-4 by fax or phone)

By OutsideFounder Team Originally published at https://outsidefounder.com/guides/ein-without-ssn. If you just formed a US LLC from abroad, the EIN is usually the next bottleneck. Banks, Stripe, and the IRS all want that nine-digit number, but the online EIN application expects a Social Security Number or ITIN. You do not need either of those. The IRS still issues EINs to foreign responsible parties for free, as long as you file Form SS-4 by fax or, in some cases, by phone. This is a practical walkthrough of the lines that matter, the correct fax numbers, realistic wait times, and what to do if the confirmation letter never arrives. It is general information, not tax or legal advice. Rules can change; confirm details on irs.gov. Facts below are current as of 15 November 2026. Short answer: On Form SS-4, enter Foreign (or N/A) on line 7b. If the LLC has no US place of business, fax 304-707-9471 from outside the US, or 855-215-1627 from inside the US. If you listed a US street address as the place of business, fax 855-641-6935 instead. International applicants with no US place of business can also call 267-941-1099. There is no IRS fee. The IRS says fax applications take about 4 business days; founders often report 1–6 weeks. Key facts Item Value Source IRS fee for an EIN Free IRS – Instructions for Form SS-4 Fax, no US place of business (from outside the US) 304-707-9471 IRS – Instructions for Form SS-4 Fax, no US place of business (from within the US) 855-215-1627 IRS – Instructions for Form SS-4 Fax, US place of business 855-641-6935 IRS – Instructions for Form SS-4 Phone, international applicants 267-941-1099 (Mon–Fri, 6 a.m.–11 p.m. Eastern) IRS – Instructions for Form SS-4 IRS-stated time by fax About 4 business days IRS – Instructions for Form SS-4 Before you start The LLC must already exist: you need approved Articles of Organization. Have the exact legal name, the formation date, and a mailing address ready. Choose the responsible party: the individual who ultimately owns or controls the LLC, usually you. You need a fax number that can receive a reply. An online fax service is fine. If you are still deciding whether an ITIN is required later, see our separate EIN vs ITIN guide for non-residents. An ITIN is not a prerequisite for this EIN application. Filling in Form SS-4: the lines that trip people up Download the current revision from irs.gov/FormSS4. Line What to enter 1 The LLC's exact legal name, as on your Articles. 4a–4b / 5a–5b Mailing address, and the physical street address only if it is different (no P.O. box on 5a). For an address outside the US, write out the country name. The address you give affects routing. The international fax and phone numbers are for entities with no legal residence, principal place of business, or principal office in the US. A US street address as the LLC's physical location points you to the domestic fax 855-641-6935 instead. 7a–7b Responsible party's name. On 7b enter Foreign or N/A if they do not have, and are not eligible for, an SSN or ITIN. An entry is required. 8a–8c Yes, it is an LLC; number of members; formed in the US. 9a Single-member, foreign-owned: check Other and write Foreign-owned U.S. disregarded entity-Form 5472 (the IRS wording). Multi-member: Partnership, unless you elect otherwise. 10 Foreign-owned single-member LLC: check Other and write Foreign-owned U.S. disregarded entity filing Form 5472 (the IRS wording). Otherwise, use the reason that applies (for example "Started new business"). Signature Sign, date, and add your phone and fax number so the IRS can fax the EIN back. Those Form 5472 labels on lines 9a and 10 are about how the IRS classifies a foreign-owned disregarded LLC. They do not file the annual Form 5472 for you; that is a separate yearly filing. Three ways to apply Fax (most common) The IRS chooses the fax number from the entity's location on lines 4a/5a. No legal residence, principal place of business, or principal office or agency in a US state...

Powered by Readybot.io

**DEV Community** ## How to get an EIN without an …

DEV Community

🖥️ Remote Desktop Can't Connect? Check These 3 Things Before You Reboot

"I can't RDP into my machine." 😩 Every help desk hears this one. The tempting fix is to ask someone to reboot the PC and hope. But most RDP failures come down to just three things: can you reach it, is RDP on, and is the user allowed in? Check them in order and you'll usually have the answer in minutes. ⚡ 🌐 1. Can you even reach it? Before anything else, test the RDP port (3389) from the computer you're connecting from: Test-NetConnection -Port 3389
Look at the last lines: TcpTestSucceeded : True ✅ The network path is fine. Move on to step 2. TcpTestSucceeded : False ❌ Something is in the way. If it fails, narrow it down: Resolve-DnsName # Does the name resolve to the right IP?
ping # Is the PC even awake?
Common causes: wrong or stale DNS record, VPN not connected, Windows Firewall blocking Remote Desktop, or the PC is asleep or powered off. ⚙️ 2. Is Remote Desktop turned on? On the target PC: Settings > System > Remote Desktop > Remote Desktop = On Two gotchas here: 🚫 Windows Home editions can't host RDP. You can connect from Home, but not to it. Check with: (Get-CimInstance Win32_OperatingSystem).Caption
🔥 Turning RDP on through Settings normally opens the firewall rule too. If someone enabled it another way, confirm the "Remote Desktop" firewall rules are enabled. 👤 3. Is the user allowed in? If the port is open and RDP is on, but sign-in says the user isn't authorized, it's permissions. The user must be a local admin or a member of the Remote Desktop Users group on that PC: net localgroup "Remote Desktop Users"
To add someone (elevated prompt): net localgroup "Remote Desktop Users" "DOMAIN\username" /add
In many organizations this is controlled by Group Policy, so a manual add might get reverted. In that case, follow your team's process for requesting access. 🎯 The quick recap 1️⃣ Port – Test-NetConnection -Port 3389 2️⃣ Setting – Remote Desktop On (and not a Home edition) 3️⃣ Permission – user in Remote Desktop Users or local admins Work through them in that order and you'll know where it's broken before you touch anything. 🧠 What's your first move when an RDP ticket lands? Drop it below 👇

Powered by Readybot.io

**DEV Community** ## 🖥️ Remote Desktop Can't Connect? Check These …

DEV Community

The EDI 180, Decoded: A Return Is a Negotiation, Not a Credit Memo

What is the EDI 180? The EDI 180 (Return Merchandise Authorization and Notification) is the X12 transaction a buyer uses to ask a seller for permission to send goods back — and the message the seller answers with. Short answer: an 180 is not a credit memo and it is not a shipment. It is a negotiation, in a standard format, about what may come back, in what condition, and who pays for the trip. That distinction is where most returns integrations go wrong. Teams model a return as a negative order. It isn't. An order is an instruction; a return starts as a request, and until the seller authorizes it, nothing should move. Why does a return need authorization at all? Because the seller has questions the buyer cannot answer for them. Is the item resalable, or is it damaged? Is it inside the return window? Should it go back to the distribution center, to a refurbisher, or nowhere at all — sometimes the cheapest correct answer is "keep it, credit issued." The 180 carries the buyer's side of that conversation: which items, how many, what condition, and why. The reason codes are the heart of it. A return because the buyer over-ordered is a different financial event from a return because the product arrived defective, and both differ from a recall. If your integration collapses every return into one generic bucket, your partner's deductions team will happily reclassify them for you — at their rates, on their timeline. What does an 180 actually contain? At the header level, the transaction identifies the return authorization request itself: who is asking, which seller location or returns center is involved, and the references that tie the return back to the original business — the original purchase order, the original invoice, and the shipment the goods arrived on. Lose those references and the seller is matching cartons to orders by hand, which is exactly the labor the standard exists to eliminate. At the line level, each item states the product identifier (usually the same UPC or buyer part number used on the original 850), the quantity proposed for return, the condition, and the reason. Quantities deserve care: the quantity requested, the quantity authorized, and the quantity actually received back are three different numbers, and a healthy returns flow tracks all three instead of overwriting one field. The seller's response can authorize all, part, or none of the request, and can direct disposition — return to stock, repair, scrap in field, or hold for inspection. That partial-authorization case is the one homegrown integrations most often forget to build. How does the 180 fit with the rest of the returns flow? The 180 does not travel alone. The physical return shipment is usually announced with an 856 (Advance Ship Notice) so the receiving dock knows what is coming and can match cartons against the authorization. Money settles later: an 812 (Credit/Debit Adjustment) or the credit side of an 810 handles the financial correction once the goods are received and inspected. The acknowledgment discipline is the same as everywhere else in X12 — a 997 confirms the 180 arrived and parsed, not that anyone agreed to anything. Sequencing matters. If the credit is issued when the 180 is requested rather than when the goods are received and inspected, you have built a machine for giving away product. If the 856 for the return references no authorization number, the dock cannot tell an approved return from a random box, and random boxes sit. Every returns dispute I have seen traces back to one of those two sequencing mistakes. What breaks most often in 180 integrations? Three things. First, condition and reason codes mapped loosely — your partner's guide enumerates the values they accept, and sending a plausible-but-unlisted code gets the line rejected or, worse, silently reclassified. Second, identifiers that drift from the original order: if the 850 said one part number and the 180 says another, matching fails. Third, treating the authorizati...

Powered by Readybot.io

**DEV Community** ## The EDI 180, Decoded: A Return Is …

DEV Community

ncipollo/release-action 403 on release create

A ncipollo/release-action 403 on release create means the releases API received a token and declined to act on it, which is a different failure from having no token at all. The number in front of the colon is the whole diagnosis, and the action prints it for exactly that reason. The action prints GitHub's status and GitHub's sentence. Only the 404 branch appends a sentence of its own: "Make sure your github token has access to the repo and has permission to author releases". What this error means The build steps are green and the release step is red. The line is short: the word Error, a three digit status, a colon, and a sentence that came from GitHub rather than from the action. Nothing in it names an input, a secret or a permission, so the workflow file gets edited on a guess. A 403 and a 401 look almost identical in the log and mean opposite things about your token, and a 404 arrives with one extra sentence that the other two do not have. ```Actions log, quoted from a public pull request listed in the references Run ncipollo/release-action@v1 Error 403: Resource not accessible by integration [error]Error 403: Resource not accessible by integration

Common causes

The job has a read-only token and the step is a write

The 403 case. The default permissions for GITHUB_TOKEN are read-only in most organizations created recently, and creating a release is a write to repository contents. Nothing in the step declares that need, so the first time the job asks, it is refused.

The token input was overridden with something empty

The 401 case. A step that passes token: ${{ secrets.RELEASE_TOKEN }} with no such secret sends an empty string, which replaces the working default. The action does not check, so github.getOctokit("") builds an unauthenticated client and the API answers 401 rather than naming the input.

The release is being created in a repository the token cannot see

The 404 case, which the extra remediation sentence identifies. It happens with the owner and repo inputs pointed at a second repository, and with a token whose reach stops at the repository running the workflow. A private repository the token cannot see returns 404 rather than 403 by design.

An organization policy overrides a correct permissions block

Worth ruling out last, because the block looks right. An organization or enterprise can cap what a workflow may request, and a job asking for contents: write under such a policy still runs with less. The job setup summary lists what was granted, which is the only place the two differ visibly.

How to fix it

Read the status before changing anything

  1. Find the line beginning Error in the release step and note the three digit number.
  2. If a second sentence follows about the token having access to the repo, the status was 404 and the repository is the problem, not the permission.
  3. If there is no second sentence, a 403 means the token was refused and a 401 means it was never sent.

Grant contents: write for the 403

The permission belongs on the job that creates the release, not on the workflow, so the other jobs keep the read-only default. This is the whole repair for the common case.

```.github/workflows/release.yml (illustrative)
jobs:
release:
runs-on: ubuntu-latest
permissions:
contents: write
steps:
- uses: actions/checkout@v5
- uses: ncipollo/release-action@v1
with:
tag: ${{ github.ref_name }}
Stop overriding the token, or make the override real For the 401, delete the token input and let the declared default apply. Keep it only when the release must be authored by something other than the workflow's own identity, and then confirm the secret exists at the scope the job runs in. An organization secret not shared with this repository resolves to an empty string in exactly the same way a misspelled name does. Point owner and repo at a repository the credential can reach For the 404, either drop the owner ...

Powered by Readybot.io

**DEV Community** ## ncipollo/release-action 403 on release create A ncipollo/release-action …

DEV Community

AI Concept Renders Are Not Technical Drawings: A Practical Quality-Control Workflow

Disclosure: I develop Estate Render, an AI-assisted visualization tool mentioned at the end of this article. This is a practical workflow article, not a construction or engineering standard. A generated interior image can be striking and still be wrong for a real project. An additional window might appear. A cabinet might change width. The camera might shift just enough to make two material options impossible to compare fairly. For people building tools around generative images, this is an important product-design problem: a convincing output is not necessarily a faithful output. The solution is not to pretend that a concept render is a measured drawing. It is to give the user a simple, repeatable way to review what changed, what must not change, and which decisions still need verification. 1. Define the source of truth before generating Every rendering workflow needs an explicit source of truth. Depending on the task, it may be a SketchUp screenshot, a photograph of an existing room, or a moodboard. Those inputs do different jobs: Model screenshot: communicates spatial intent and a camera view, but may lack complete material or construction information. Existing-room photograph: records visible conditions, but can conceal measurements and areas outside the frame. Moodboard: describes desired visual direction; it does not define a room's geometry. A good UI should make that distinction apparent. Don't let users accidentally treat a moodboard as a floor plan or a generated image as a measurement. A simple pre-render form can ask three questions: What is the starting image? What may change? What must stay the same? Even when this information does not control a model perfectly, it improves the subsequent review. 2. Separate fixed constraints from creative variables When a designer wants to compare finishes, they should not have to compare different room layouts at the same time. Consider this design brief: Fixed: camera position, wall openings, visible room proportions, major built-in furniture, and circulation path. Variable: wall color, floor finish, loose furniture palette, lighting temperature, and decorative objects. That distinction makes a series of images more useful. If one alternative quietly moves a doorway, the comparison is no longer like-for-like. From a product perspective, it is worth making the two lists visible next to each generated output. They serve as a human-readable audit trail, even if the underlying generation service is probabilistic. 3. Build a review checklist instead of a confidence score It is tempting to expose a single “quality: 92%” metric. But what would that mean? The image might look photorealistic while displaying the wrong geometry. A more honest approach is a checklist users can verify: Check Reviewer question Result Layout Are visible walls and major openings preserved? Pass / Review Scale Do furniture and circulation still look plausible? Pass / Review Materials Does each chosen finish appear where intended? Pass / Review Camera Is the viewpoint consistent across alternatives? Pass / Review Lighting Are changes intentional rather than accidental? Pass / Review Deliverable Is the image clearly labeled as a concept? Pass / Review This checklist is deliberately qualitative. Some problems require source measurements, technical documentation, or a qualified professional. A screenshot alone cannot validate building-code compliance or exact dimensions. 4. Make the review state explicit in software A small amount of structured data goes a long way. For instance, a frontend can track review status separately from the output image: const conceptReview = {
sourceType: "sketchup-screenshot",
intendedChanges: ["floor finish", "lighting mood"],
fixedElements: ["window positions", "cabinet layout"],
checks: {
geometry: "review",
materials: "pass",
camera: "pass",
lighting: "review",
conceptLabel: "pass"
},
approvedFor: "client-discussion-only"
};

const needsReview = ...

Powered by Readybot.io

**DEV Community** ## AI Concept Renders Are Not Technical Drawings: …

DEV Community

How to use Mosh on Mac and iPhone, and keep sessions alive with tmux

SSH drops the moment your laptop sleeps, your train goes into a tunnel or your iPhone switches from Wi-Fi to 5G. Mosh fixes the connection part. tmux fixes the "my job died with it" part. Together they make a remote shell you can close and reopen from anywhere. This guide sets up both on a Linux server and shows how to connect from a Mac and from an iPhone. The short answer # on the server
sudo apt install mosh tmux # Debian / Ubuntu
sudo ufw allow 60000:61000/udp # only if ufw is on

on the Mac

brew install mosh
mosh user@your-server -- tmux new -A -s main
tmux new -A -s main attaches to the session called main if it exists, or creates it. Run the same command again tomorrow and you are back where you left off. What Mosh does, and what it does not Mosh (mobile shell) logs in over SSH, starts mosh-server on the remote machine, and then talks to it over UDP. Because the session is not tied to one TCP connection: it survives a change of IP address (Wi-Fi to cellular, home to office); it survives the laptop sleeping or the iPhone locking; it shows what you type right away, even on a slow link, instead of waiting for the server's echo. What it does not do: keep your programs running if the server side of the session ends, scroll back through history the way your terminal does, or forward ports. For the first two, you add tmux. Install on the server Debian and Ubuntu: sudo apt update
sudo apt install mosh tmux
Fedora, RHEL and friends: sudo dnf install mosh tmux
Mosh uses one UDP port per session in the range 60000 to 61000. If a firewall is on, open it: sudo ufw allow 60000:61000/udp
On a cloud server, add the same range as an inbound UDP rule in the provider's firewall too. Mosh also needs a UTF-8 locale on the server. If you get an error about LANG or LC_ALL, this usually fixes it: sudo locale-gen en_US.UTF-8
Connect from a Mac Install the client with Homebrew and connect the same way you would with SSH: brew install mosh
mosh user@your-server
If SSH runs on another port, pass the SSH command through: mosh --ssh="ssh -p 2222" user@your-server
Your ~/.ssh/config is used as usual, so a host alias works too: mosh myserver. Add tmux so the work survives Mosh keeps the connection alive. tmux keeps the programs alive, even if you close the Mosh session on purpose or the server reboots your login. Start or reattach in one step: mosh myserver -- tmux new -A -s main
The keys you need on day one: Keys What it does Ctrl-b d detach: leave everything running and disconnect Ctrl-b c new window Ctrl-b n / Ctrl-b p next / previous window Ctrl-b % split side by side Ctrl-b [ scroll back (press q to leave) Later, from any device: tmux ls # list sessions
tmux attach -t main # go back in
This is the setup many people use to leave a long build, a database migration or an AI coding agent such as Claude Code or Codex running on a server and check on it from the phone. Connect from an iPhone or iPad iOS has no built-in terminal, so you need an SSH app that supports Mosh. Look for three things: Mosh support, not only SSH, so the session survives the phone locking; key handling you trust, ideally keys that never leave the device; a way to reattach to your tmux session without typing the command every time. The flow is the same as on the Mac: connect with Mosh, then tmux new -A -s main. We make Wardterm, an SSH client for Mac, iPhone and iPad, and we built it around this exact workflow. Mosh is included on every device, and Keep This Session moves the current session into tmux on the server for you, so you can close the app and pick it up later from the Mac or the phone. If you run AI agents on the server, it also tells you when one is waiting for an answer. The free plan has no limit on servers: https://wardterm.com/ Troubleshooting "mosh-server: command not found" Mosh is not installed on the server, or not on the PATH of a non-interactive SSH login. Install it, or point to it: mosh --server=/usr/local/...

Powered by Readybot.io

**DEV Community** ## How to use Mosh on Mac and …

DEV Community

GitHub Actions run-name env not available, and what it can read

GitHub Actions run-name env not available is a workflow that fails to compile rather than a run that gets a blank name. The key carries a short list of allowed contexts, env is not on it, and an expression naming a context outside the list is rejected while the file is being read. The run name is decided before any job exists, so only the event, the dispatch inputs and repository variables are reachable from it. What this error means You added an environment variable to the run name, expecting either the value or an empty string, and instead the workflow stopped running entirely. The annotation is on the file and quotes a name rather than a value. A second, milder version exists where the run name shows literal braces instead of a value, and that one has a different cause: the expression was never treated as an expression, usually because of how it was quoted. ```Message composed by ParseException in actions/runner, with the file and line prefix The workflow is not valid. .github/workflows/deploy.yml (Line: 4, Col: 11): Unrecognized named-value: 'env'. Located at position 1 within expression: env.TARGET

Common causes

The run name referenced a workflow level env value

The commonest one, and it looks reasonable because the env: block is a few lines below in the same file. Proximity in the file is not availability in the expression: the key's context list decides, and env is not on it.

The value was expected to come from a step

A version number computed during the build cannot appear in the run name, because the name is decided before any step runs. No context would help, since the value does not exist at that moment.

The expression was written but never parsed as one

This is the variant that produces a literal pair of braces in the name rather than an error. It comes from quoting or escaping that stops the reader recognizing an interpolation, which means nothing was rejected because nothing was parsed.

A repository variable was assumed to be unavailable

The documentation sentence names github and inputs only, so people conclude vars is out and reach for env instead. The schema's context list for the key includes vars, which makes a repository variable the closest thing to a workflow level default that a run name can read.

How to fix it

Use a repository variable instead of a workflow env value

Move the value to a repository or organization variable and read it through vars, which is on the key's context list. This is the nearest equivalent to a workflow level default that survives being read before any job exists.

.github/workflows/deploy.yml (illustrative) run-name: Deploy ${{ vars.DEPLOY_TARGET }} from ${{ github.ref_name }} Take the value as a dispatch input Declare the input under on.workflow_dispatch.inputs with a type and a default. Read it in run-name through the inputs context. Give the input a description, because it now appears in the run name and people will read it as a label. Keep the same input available to the jobs, so the name and the behavior cannot drift apart. Put a computed value on the job or in the summary For anything a step produces, name the job with what is known at job level and write the computed detail to the step summary. The summary is rendered on the run page, which is the surface most people are actually trying to improve when they reach for a dynamic run name..github/workflows/deploy.yml (illustrative) run: echo "### Deployed ${VERSION}" >> "$GITHUB_STEP_SUMMARY" ``` Drop the key and take the default name When there is nothing available worth putting in it, leave run-name out. The documentation records that an omitted or whitespace-only value produces event specific information instead, which for a push is the commit message and for a pull request is its title, and both are usually more informative than a static string. How to prevent it Check a key's context list before writing an expression into it. Keep values that belong in a run name a...

Powered by Readybot.io

**DEV Community** ## GitHub Actions run-name env not available, and …

DEV Community

Should you block AI crawlers (GPTBot, ClaudeBot, CCBot) in robots.txt? Let's argue about it

Automated technical SEO checks that catch indexing blocks and deploy regressions — seotto.com A couple of years ago, robots.txt was mostly about search engines. Now a typical site's logs include a whole list of AI-related crawlers: OpenAI's, Anthropic's, Common Crawl's, Perplexity's, Apple's, ByteDance's and others. Many sites added blanket blocks in a hurry. Others never touched their robots.txt. Should you block them? I think this is a genuinely open question, and the answer has changed as the bots themselves have changed. Let's argue about it. First, they're not all the same bot The big operators now publish several user agents with different purposes. Roughly: Training crawlers collect pages to train models: for example OpenAI's GPTBot, Anthropic's ClaudeBot, Common Crawl's CCBot (used by many model builders). Search crawlers index pages so an AI product can cite and link to them in answers: for example OAI-SearchBot, PerplexityBot, Claude-SearchBot. User-triggered fetchers load a page because a person asked the assistant to read it right now: for example ChatGPT-User, Claude-User. Control tokens that aren't crawlers at all: Google-Extended and Applebot-Extended are names you can disallow in robots.txt to opt out of your content being used for those companies' AI models, without affecting Google Search or Apple's search features. Names and purposes change, so check each operator's current documentation before relying on a list. The point is that "block AI" now means several separate decisions. The case for blocking Consent. Your content was written for readers, and nobody asked whether it could be used to train a commercial model. Blocking training crawlers is the clearest signal you can give. No traffic in return. Training a model on your article doesn't send anyone to your site. If the model can then answer the question your article answers, it may reduce your traffic. Server cost. Some AI crawlers are aggressive, request huge numbers of pages, and ignore crawl-delay hints. Smaller sites have seen real bandwidth and CPU costs from them. Leverage. Publishers negotiating licensing deals have argued that blocking is the only bargaining position content owners have. The case for allowing AI answers are a discovery channel now. People ask assistants for recommendations, documentation and comparisons. Products that cite sources can only cite pages their search crawlers can read. Block the search agents and you're invisible there. Developer content wants to be found. For documentation, open source projects and developer tools, being the source an assistant learned from, or cites, is often the whole point of publishing. Blocking doesn't remove what's already collected. Pages crawled before you added the rule may already be in datasets. A new block only affects future crawling. robots.txt is voluntary. Well-behaved crawlers follow it. Badly behaved ones don't, and some scrapers simply pretend to be a browser. A block mostly affects the operators who were already playing fair. Before you tighten robots.txt, it helps to see what is already blocked. seotto.com checks for indexing blocks and robots regressions, including rules you didn't mean to ship. Where I've landed For most sites, I'd make the decision per purpose, not per company: User-triggered fetchers: allow. A person asked an assistant to read your page. That's closer to a browser visit than to crawling, and blocking it mainly frustrates your own readers. AI search crawlers: allow, if being cited matters to you. For most commercial and developer sites, it does. Check your logs and analytics for referrals from AI products before deciding. Training crawlers: a values decision. There's no technical right answer. Blocking GPTBot, ClaudeBot, CCBot and setting Google-Extended and Applebot-Extended to disallow is a coherent position; so is allowing them. Decide deliberately and write down why. Aggressive crawlers: rate limit, don't just disallow. If one bot is costing you real ...

Powered by Readybot.io

**DEV Community** ## Should you block AI crawlers (GPTBot, ClaudeBot, …

DEV Community

Image Upload Moderation: Retaining NSFW Evidence with JSON Schema Fallback

Image Upload Moderation: Retaining NSFW Evidence with JSON Schema Fallback For catalog image upload moderation, classify NSFW content and violence before publishing enrichment, and retain the evidence for an explicit review window. The bill has several parts: image bytes held over time, classification attempts, review work, and the reads and writes needed to move evidence through those decisions. Keeping every upload indefinitely is a storage policy, even when nobody remembers choosing it. Consider a deliberately hypothetical B2B SaaS catalog: 10,000 uploads per day, each normalized image exactly 1 MB, with one retained image per upload. In decimal units, that adds 10 GB per day; a 30-day window holds 300 GB at steady state, while a 7-day window holds 70 GB. The 230 GB difference is arithmetic, not a production measurement or a claim about a storage service. Image bytes dominate the retained data in this example if each decision record is capped at 1 KB: those records add only 10 MB per day. This says nothing about which charge dominates the total invoice; model usage and human review need their own measurements. Short answer: for a Node.js image upload moderation flow, classify NSFW content, violence, and hate symbols through multimodal chat, validate the result against a JSON Schema contract, and route malformed or uncertain answers to a bounded fallback or review. For catalog enrichment, the quality-versus-latency choice belongs at publication: a fast upload acknowledgment can coexist with a slower, evidence-backed decision before extracted attributes become visible. The examples below use Python to make that boundary inspectable independently of the upload server. Keep evidence bounded. How should image upload moderation retain NSFW and violence evidence? A messy description such as “vintage patch, black/red, collectible, maybe military” is a useful illustrative input because enrichment and moderation ask different questions. Enrichment might infer color or product type; moderation must decide whether the associated image can enter the published catalog under the service's policy. Neither task should treat the seller's description as an instruction, and the text alone should not settle what an ambiguous emblem means. Preserve uncertainty instead of converting a seller's confident wording into a confident classification. The storage boundary matters more than a polished response example. Give each upload an immutable identifier and associate the decision with the exact image version inspected, the relevant description version, the policy version, and the classifier configuration. Treat this as a proposed application contract: if any input changes, the previous decision is ineligible to authorize publication of the replacement. An image digest helps identify byte equality; it does not recover deleted pixels or explain the model's judgment. Store the normalized classifier input as the review evidence when review requires replaying that input. If the original is also retained, account for it separately: the opening calculation explicitly excludes originals, thumbnails, replicas, and old versions. Deleting one database row is not a complete retention implementation when the image has other copies with different lifetimes. That omission is easy to miss. The compact record should carry the upload identifier, evidence digest, three labels, uncertainty, policy and schema versions, decision state, evidence expiration time, and a reason code. It should also say when evidence has been deleted. A surviving record can establish which policy decision was recorded; without the image, it cannot support a fresh visual assessment. Those are different audit capabilities, and a retention discussion that bundles them together conceals the actual loss. Typed labels keep enrichment behind a publication boundary Use a small contract whose meaning the application owns. For this illustrative policy, each of nsfw, violence, and hate_symbols is pr...

Powered by Readybot.io

**DEV Community** ## Image Upload Moderation: Retaining NSFW Evidence with …

DEV Community

How to measure how much of your crawl traffic is AI bots, from your own access logs (in Python)

Automated technical SEO checks that catch indexing blocks and deploy regressions — seotto.com Opinions about AI crawlers are everywhere. Numbers from your own site are rarer, and they're the only ones that should drive a robots.txt change. The questions worth answering first: What share of all bot requests come from AI-related crawlers? How much bandwidth do they use? Which sections of the site do they hit? Are they training crawlers, search crawlers, or fetches triggered by a person asking an assistant to read your page? Your access logs already have the answers. This post is a short Python script that classifies requests by user agent and reports exactly those numbers. The categories User agent strings change, and operators add new ones, so treat this as a starting list and check each operator's documentation before relying on it: Search crawlers: Googlebot, bingbot, DuckDuckBot, YandexBot, Applebot (the plain one, used for Apple's search features). AI training: GPTBot, ClaudeBot, CCBot, Bytespider, meta-externalagent, Amazonbot, cohere-ai. AI search: OAI-SearchBot, PerplexityBot, Claude-SearchBot. AI user-triggered: ChatGPT-User, Claude-User, Perplexity-User. Google-Extended and Applebot-Extended won't appear in logs: they're robots.txt tokens, not separate crawlers. Google's AI products fetch with the normal Googlebot. Like Googlebot, all of these can be faked. A request claiming to be GPTBot from a residential IP is probably a scraper. The bigger operators publish their IP ranges; for numbers you'll act on, check requests against those ranges, the same way you'd verify Googlebot with reverse DNS. The script import gzip, glob, re, sys
from collections import Counter, defaultdict

CATEGORIES = {
"search": ["Googlebot", "bingbot", "DuckDuckBot", "YandexBot", "Applebot/"],
"ai-training": ["GPTBot", "ClaudeBot", "CCBot", "Bytespider", "meta-externalagent",
"Amazonbot", "cohere-ai"],
"ai-search": ["OAI-SearchBot", "PerplexityBot", "Claude-SearchBot"],
"ai-user": ["ChatGPT-User", "Claude-User", "Perplexity-User"],
}
BOTLIKE = re.compile(r"bot|crawl|spider|slurp|fetch", re.I)

combined log format: ... "GET /path HTTP/1.1" 200 1234 "referer" "user agent"

LINE = re.compile(r'"[A-Z]+ (\S+) [^"]" (\d{3}) (\d+|-) "[^"]" "([^"]*)"')

def classify(ua):
for cat, needles in CATEGORIES.items():
for n in needles:
if n in ua:
return cat, n
if BOTLIKE.search(ua):
return "other-bot", "other"
return "human/other", "-"

def lines(pattern):
for p in sorted(glob.glob(pattern)):
f = gzip.open(p, "rt", errors="replace") if p.endswith(".gz") else open(p, errors="replace")
with f:
yield from f

reqs, bytes_, agents = Counter(), Counter(), Counter()
paths = defaultdict(Counter)
statuses = defaultdict(Counter)
for line in lines(sys.argv[1]):
m = LINE.search(line)
if not m:
continue
path, status, size, ua = m.groups()
cat, agent = classify(ua)
reqs[cat] += 1
bytes_[cat] += 0 if size == "-" else int(size)
agents[(cat, agent)] += 1
section = "/" + path.lstrip("/").split("/", 1)[0].split("?", 1)[0]
paths[cat][section] += 1
statuses[cat][status[0] + "xx"] += 1

total_bot = sum(n for c, n in reqs.items() if c != "human/other")
print(f"{'category':14s} {'requests':>10s} {'% of bots':>10s} {'MB':>10s} statuses")
for cat, n in reqs.most_common():
share = "" if cat == "human/other" else f"{100 * n / max(total_bot, 1):.1f}%"
print(f"{cat:14s} {n:10d} {share:>10s} {bytes_[cat] / 1e6:10.1f} {dict(statuses[cat])}")

print("\nTop agents:")
for (cat, agent), n in agents.most_common(15):
if cat != "human/other":
print(f"{n:8d} {cat:12s} {agent}")

for cat in ("ai-training", "ai-search", "ai-user"):
if paths[cat]:
print(f"\nTop sections for {cat}:")
for s, n in paths[cat].most_common(8):
print(f"{n:8d} {s}")
Run i...

Powered by Readybot.io

**DEV Community** ## How to measure how much of your …

DEV Community

PWC 399

This week's tasks are about length, so let's cue up the Eagles Long Run album from 1979 and get to work. Task 1: Longest Repeating Character Task Description You are given a string str and an integer k > 0. Write a script to choose any character of str and change it to another character. You may perform this operation up to k times. Return the length of the longest reachable substring of a single letter. Example 1: Input: $str = "AAAAA", $k = 2 Output: 5 Every character in the string is already the same letter "A". The maximum operations allowed (k = 2) do not even need to be used. The entire string of length 5 is already the longest valid substring. Example 2: Input: $str = "ABCDE", $k = 4 Output: 5 All 5 characters in the string are distinct. The most frequent character occurs only 1 time. To turn the entire string into a single repeated character, we need to replace 5 - 1 = 4 characters. Since k = 4, we can replace "B","C","D", and "E" with "A" to form "AAAAA". Example 3: Input: $str = "AAABBBBAA", $k = 1Output:5 If we target "A", we could change the "B" in "AAAB" (k=1 replacement) to get length 4 ("AAAA"). If we target "B", we can pick the substring "BBBBA" and change the single trailing "A" to "B" (k=1 replacement) to form "BBBBB", which gives a length of 5. Targeting "B" gives better result than targeting "A". Example 4: Input: $str = "ABACADA", $k = 2 Output: 5 Look at the substring [0..4] which is "ABACA" (length 5). In this window, "A" appears 3 times, and there are 2 non-"A" characters ("B" and "C"). With k = 2, we can replace "B" and "C" with "A" to form "AAAAA". Look at the substring [2..6] which is "ACADA" (length 5). Here, "A" appears 3 times, and non-"A" characters ("C" and "D") count to 2. Replacing them gives "AAAAA". In both cases, the maximum valid length is 5. Example 5: Input: $str = "BAAABAAAA", $k = 1 Output: 8 The string has two groups of "A"s separated by a single "B" ("AAABAAAA"). We can replace the character 4 "B" with an "A" to get a sequence of 8 "A". The thought process There seem to be a lot of combinations to work through. Something easier would be to take every character in turn and see how long of a streak we can make of that character. There's no prize being awarded for being frugal with substitutions, so let's just do k substitutions every time and see where we land. Some code sub task($str, $k)
{
my $longest = 1;
my $strlen;
while ( ($strlen = length($str)) > 0 && $strlen > $longest )
{
# Shift left-most character off str
my $c = substr($str, 0, 1, "");

    # Make as many substitutions as possible
    my $copy = $str;
    $copy =~ s/[^$c]/$c/ for 1 .. $k;

    # Check the length of repeated first character
    $copy =~ m/^($c+)/;
    my $run = 1 + length($1 // "");

    $longest = $run if $run > $longest;
}
return $longest;

}
The body of the loop is to consider the first character of the string, chop it off, and continue until the string is empty or we can't beat the longest value. The four-argument version of substr simplifies it for us -- it returns the first character, and the fourth argument effectively removes it by replacing it with an empty string. We want to modify the string, so we'll operate on a copy. In the copy, we substitute the first k characters that aren't $c. We may end up doing too much in this step, but, meh. To check the length, do a regular expression match for repetitions of $c at the beginning of $copy. Capture the match and check its length. The +1 is there to account for $c. Task 2: Longest Absolute Path Task Description You are given a filesystem as string. Write a script to return the length of the longest absolute path to a file in the abstracted file system. If there is no file in the system, return 0. dir
- subdir1
- file1.ext
- subsubdir1
- subdir2
- subsubdir2
- file2.ext
The above filesystem can be represented as below: "dir\n\tsubdir1\n\t\tfile1.ext\n\t\tsubsubdir1\n\t...

Powered by Readybot.io

**DEV Community** ## PWC 399 This week's tasks are about …

DEV Community

A five-minute triage for remote-desktop lag

Remote desktop sessions that "feel slow" usually fail on one of three things, and each has a different fix. Before opening a ticket about bandwidth, spend five minutes on this order. 1. Is it input latency or render latency? Type in a local text field, then type in the remote one. If the characters appear late but arrive in a burst, the problem is the path (latency + jitter). If they appear smoothly but the screen redraws slowly, the problem is encoding or the remote GPU. These look similar on a video call and are completely different problems. 2. Measure the path, not the speed A speed test measures throughput to a nearby server and tells you almost nothing about a cross-region session. You want round-trip time, loss and jitter to the actual destination: mtr -rwzbc 100
Read it top to bottom. The first hop where loss stays flat and latency jumps is the segment to avoid. Anything under ~0.5% loss is usually absorbed by TCP; above 1% you feel it as stalls. 3. Check whether the session survives a route change If a route switch resets the TCP connection, every switch is a visible freeze, and the client will look worse than a static path. A session-preserving switch - moving packets to a better path without tearing down the socket - is what turns an unstable link into a usable one. This is the part a cross-border network acceleration client is responsible for; the measurement is the easy half. 4. Only then look at bandwidth Bandwidth matters for file transfer and video, not for typing. If your session is unusable at 5 Mbps but the link shows 100 Mbps idle, bandwidth was never the bottleneck. The short version Input lag in bursts -> path (latency/jitter/loss) -> measure with mtr. Smooth input, slow redraw -> encoding/GPU -> check codec and resolution. Freeze on every route change -> the client, not the network. Most "slow remote desktop" reports I see resolve at step 2, and the ones that do not are usually step 3 wearing a disguise.

Powered by Readybot.io

**DEV Community** ## A five-minute triage for remote-desktop lag Remote …

DEV Community

Context rot: why your AI assistant gets worse after 200 messages (and a 5-line fix)

You've seen it. The first hour with an AI assistant is great. By message 200 it suggests a fix you already rejected, forgets the framework you're using, and confidently reintroduces a bug from an hour ago. That's context rot, and it's not your imagination. What's going on Every model has a limited context window. Long chats fill it with everything: dead ends, abandoned approaches, old versions of the same file. Even when it all technically fits, the model has to decide what matters, and old noise competes with the new signal. Common symptoms: it repeats suggestions you already turned down; it mixes up two versions of the same function; it drifts away from the original goal; answers get longer and vaguer. The fix: a 5-line handoff When you notice the symptoms, stop. Ask the model: Summarize this conversation in 5 lines: goal, constraints, decisions made, current state, next step. Check the summary, fix anything wrong, then start a new chat and paste it as the first message. Add the current version of the file you're working on. That's it. You keep everything that matters and drop the noise. Habits that prevent it One chat per task. Don't debug auth and design a landing page in the same thread. Paste current code, not history. "Here's the file as it is now" beats "remember the version from earlier". Write decisions down. When you settle something ("we're using Postgres, not Mongo"), say it explicitly so it ends up in the summary. Why this matters more with agents Coding agents that edit many files burn through context even faster. A clean handoff summary between big steps keeps them on track and makes their diffs easier to review. Disclosure: I work on MadGPT. Its Coder model and VS Code agent are built for long, multi-file tasks, but the technique above works with any assistant. Drafted with AI assistance, edited by a human.

Powered by Readybot.io

**DEV Community** ## Context rot: why your AI assistant gets …

DEV Community

No files were found with the provided path in upload-artifact

The message no files were found with the provided path is not a statement about your artifact, it is the result of a glob: actions/upload-artifact expanded its path input against the runner filesystem and got an empty list. Whether that ends the job, warns, or says nothing is decided by if-no-files-found, and the default lets the build stay green. One sentence, three severities. The default is a warning, which is why this usually surfaces as a download failure in another job. What this error means The same sentence appears whether the step warned, failed or stayed silent, because all three branches emit identical text at different severities. The line below is the error one, from a run that had set if-no-files-found: error. At the shipped default the upload step is yellow rather than red, the job finishes, and the run looks fine. Minutes later a different job fails because the artifact it wanted is not there, and that is the failure people report. The line names an absolute path on the runner, which is worth reading carefully: it is the path the action resolved, not the one you typed. ```Actions log, quoted from upload-artifact#810 [error]No files were found with the provided path: /__w/_temp/release-assets. No artifacts will be uploaded.

Common causes

The build wrote to a different directory than the upload reads

The ordinary case, and the one the illustrative workflow shows. A working-directory on the build step, a build tool with its own output root, or a monorepo where each package writes into itself all put files where the upload path does not reach. The absolute path in the message is the whole diagnosis.

The step that should have produced the files did not run

A conditional step that evaluated false, a cached step that short-circuited, or a build that failed under continue-on-error all leave the directory empty. This looks identical in the log to a wrong path, which is why listing the directory before the upload is worth the two seconds.

Everything the pattern matched is a directory or a hidden file

Directories are filtered out of the match list, so a tree of empty directories uploads nothing. Hidden files have been excluded by default since version 4.4.0, so a path containing only dotfiles, a .next build that is being uploaded wholesale, or a coverage directory whose entries begin with a dot now matches zero files where it once matched many.

The path is right for a shell and wrong for an action

Tilde expansion, environment variables in shell syntax and relative paths borrowed from a run: block are the recurring near misses, because the action has its own handling for all three and it is not the shell one. In a container job the workspace is mapped as well, so even an absolute path can resolve differently between steps.

How to fix it

Make the empty match the failure

Do this first, before diagnosing anything. With if-no-files-found: error the run goes red on the step that has the path in front of it, rather than in a different job with a message about a missing artifact. On any upload a later job consumes, this is the default to write.

```.github/workflows/ci.yml, corrected (illustrative)
- uses: actions/upload-artifact@v7
with:
name: site
path: packages/app/dist
if-no-files-found: error
Print the directory from the same place the action will read it The cheapest diagnostic is a listing taken from the workspace, which is where the action resolves a relative path. Doing it in the build step working directory proves nothing, because that is the frame the action does not use. ls -la "$GITHUB_WORKSPACE"
find "$GITHUB_WORKSPACE" -maxdepth 3 -name "dist" -type d
Include hidden files only when you mean to If the files you expected begin with a dot, the exclusion added in version 4.4.0 is why they are missing. Turning it back on is one input, and it is worth narrowing the path at the same time: the reason for the change was that whol...

Powered by Readybot.io

**DEV Community** ## No files were found with the provided …

DEV Community

AI Embeddings Break Columnar Assumptions in Parquet and Arrow

TL;DR — Columnar engines like DuckDB and Arrow assume you scan a few columns and filter on values. An embedding column violates every one of those assumptions: it is wide, high-entropy, never filtered by value, and always read whole. Treat it as a separate physical tier, use fixed-size layouts, and late-materialize vectors after metadata filters. Columnar storage is a bet on a specific access pattern: read a few columns out of many, filter on their values, and aggregate. Parquet, Arrow, DuckDB, and GPU dataframe engines are all optimized around that bet. It's a good bet for analytics. Then we add an embedding column and quietly lose it. My thesis: an embedding column is the one column type where the columnar assumptions invert, and most "slow AI data prep" is the result of storing it like any other column. The fix isn't a faster engine. It's treating vectors as their own physical tier. The access pattern flips Look at what a normal analytical column gets for free: Value predicates. Min/max statistics, dictionary pages, and bloom filters let the engine skip data based on what's inside. Compression. Low-cardinality strings, sorted integers, and timestamps compress dramatically with dictionary, run-length, and delta encodings. Narrow reads. The query touches three columns out of fifty. Now look at an embedding column: No value predicates. Nobody writes a filter on the seventh dimension of a vector. Min/max stats on a float inside a vector are noise. You pay for the metadata and never use it. Poor compression. Learned floats are high-entropy. Dictionary and run-length encodings have nothing to grab. Byte-oriented transforms for floats help a bit, and general-purpose codecs buy you little for the CPU they burn. All-or-nothing reads. A consumer wants the whole vector or none of it. There is no useful "read half of this column." So the column that is usually the largest in your table, by bytes, gets none of the features that justify a columnar format. You're paying the format's costs (row-group overhead, encoding and decoding, nested-type bookkeeping) without collecting its benefits. Nested lists are the quiet tax The default way people land embeddings in a table is a variable-length list of floats. In Parquet, nested and repeated data is represented with repetition and definition levels, extra bookkeeping the reader must decode to reconstruct list boundaries. For a variable-length list, that work is legitimate. For a vector where every row has exactly the same dimension, it's pure waste: you're encoding "where does each list end" for data whose answer is a constant. Arrow has the right abstraction: a fixed-size list. Every row is the same width, so the whole column is one flat contiguous buffer of floats plus a known stride. That layout is what NumPy, a GPU kernel, or an ANN index wants. Row i lives at offset i * dim. No offsets array, no per-row decode. The practical rule: if the dimension is a schema invariant, encode it as one. Declare fixed-size at the Arrow layer, and verify what your Parquet writer and reader actually do with it end to end. Whether you get a zero-copy view or a silent conversion back through variable-length lists depends on the toolchain, and the failure mode is a slow pipeline, not an error. Check by measuring a round trip, not by trusting the type name. Split the vector from the metadata The bigger win is physical, not logical. In a typical embeddings table you have a handful of small, filterable columns (document id, source, timestamp, tenant, language) and one huge opaque blob of floats. Storing them in the same files means every metadata scan drags row groups sized for vectors. Row-group sizing is where this bites. A row group is the unit of skipping and the unit of reading. If the vector column dominates the bytes, a row group sized by byte target holds very few rows. Your metadata statistics then cover tiny spans, footers balloon, and a filter that should prune aggressively instead opens thousands o...

Powered by Readybot.io

**DEV Community** ## AI Embeddings Break Columnar Assumptions in Parquet …

DEV Community

The $400 rule: when your side income becomes taxable self-employment

There's a number buried in the tax code that surprises a lot of new freelancers: $400. Earn more than $400 in net self-employment income in a year and you owe self-employment tax - even if it's a hobby, even if it was one client, even if you made less than the standard deduction and owe no income tax at all. Here's what's actually going on. What the $400 triggers Self-employment tax is Social Security + Medicare for people without an employer. It's 15.3% of your net self-employment income (12.4% Social Security + 2.9% Medicare). When you're a W-2 employee, your employer pays half and you never see it. When you freelance, you pay both halves. The moment your net freelance profit crosses $400 for the year, you file Schedule SE and pay it. What counts Net income is revenue minus business expenses. So: $600 from two Etsy sales, minus $150 in materials and fees = $450 net. Over the line. $5,000 from one consulting gig, minus $1,200 in software, coworking and mileage = $3,800 net. Well over. Side note: platforms only send a 1099-K or 1099-NEC above certain thresholds. The IRS expects the income reported whether or not a form shows up. The part that stings Self-employment tax is on top of income tax. A freelancer in the 12% bracket pays roughly 25-27% combined on each profit dollar. That's why the standard advice is to set aside 25-30% of every payment the day it arrives. I built a free one-sheet calculator for exactly this - enter a payment amount and it shows what goes to taxes and what you actually keep: free set-aside calculator. The upside hiding in the rule Crossing $400 also means you're "in business" - and business expenses become deductible. Software, equipment, home office, a share of your phone bill, mileage. Every legitimate expense shrinks the number the 15.3% applies to. Track them from day one, not in March. A spreadsheet with a date, amount, and category column beats a shoebox of receipts. The quarterly wrinkle Once you owe, you owe quarterly. Estimated payments are due April 15, June 15, September 15, and January 15. Miss them and the IRS charges an underpayment penalty even if you pay in full when you file. The freelancers who never stress about taxes do two boring things: move 25-30% of every payment to a separate account immediately, and check the four dates a week early. That's the whole system. Not tax advice - confirm your situation with a CPA or IRS.gov.

Powered by Readybot.io

**DEV Community** ## The $400 rule: when your side income …

DEV Community

How to Remove Leaked API Keys and .env Files from Git History (git filter-repo Guide)

Originally published at umutgungorr.com. Deleting a leaked .env file in a new commit leaves the secret in Git history. Learn the exact recovery sequence: key rotation, git filter-repo scrubbing, and TokenGuard pre-commit prevention. Step 1: Revoke & Rotate the Exposed Key Before Scrubbing History If the commit reached a public remote, automated scanners may have indexed it within seconds. Running git rm in a follow-up commit keeps the secret readable in earlier commits, so always revoke and rotate the exposed credential first. Step 2: Scrubbing the File or Secret String with git filter-repo git-filter-repo is the officially recommended replacement for git filter-branch. You can purge an entire .env file across all commits or replace a leaked token string with REMOVED. # 1) Taze bir mirror/klon üzerinde çalışın
pip install git-filter-repo

2a) Yanlışlıkla eklenen .env dosyasını tüm geçmişten silme

git filter-repo --path .env --invert-paths --force

2b) Veya belirli bir anahtar dizgisini metin olarak maskeleme

secrets.txt içeriği: sk_live_ORNEK_ANAHTAR==>REMOVED

git filter-repo --replace-text secrets.txt --force

3) Temizlenmiş geçmişi zorla pushlayın ve .gitignore'a ekleyin

echo ".env" >> .gitignore
git push --force --all
git push --force --tags
Step 3: Prevent Future Leaks Locally with TokenGuard Pre-Commit Scrubbing history is incident response; the real fix is blocking secrets locally before git commit completes. TokenGuard scans staged diffs with regex rules and Shannon entropy completely offline. pip install tokenguard-cli

Staged dosyaları commit öncesi tara

tokenguard scan --staged

Otomatik Git pre-commit kancası kur

tokenguard install-hook
References TokenGuard — Offline Git Pre-Commit Secret Scanner Preventing Git Secret Leaks Before Push: TokenGuard

Powered by Readybot.io

**DEV Community** ## How to Remove Leaked API Keys and …

DEV Community

How to fix 'No signatures found matching the expected signature for payload' (Stripe webhooks in Express, Next.js and Flask)

Reliable HTTP cron and delayed-job scheduling with automatic retries and full run logs — delay.run You've set up a Stripe webhook endpoint, sent a test event, and your logs say: No signatures found matching the expected signature for payload.
Are you passing the raw request body you received from Stripe?
The second sentence is the hint, and it's right most of the time. Stripe signs the exact bytes of the request body. If your framework parses the JSON and you verify the re-serialised version, or you use a secret from a different endpoint, the signature can't match. Here are the causes in order of how often they happen, and how to check for each. How the check works, in one paragraph Stripe sends a Stripe-Signature header like t=1731571200,v1=5257a8.... To verify, the library computes an HMAC-SHA256 of "{t}.{raw body}" using your endpoint's signing secret (whsec_...) and compares it with v1. If even one byte of the body differs (a space, key order, a Unicode escape, a newline), the HMAC is completely different. There's no "close enough". Cause 1: the body was parsed before you verified it By far the most common. A global JSON body parser runs on every route, including the webhook route, and by the time your handler runs, the raw bytes are gone. Express Mount the webhook route with express.raw() before any global express.json(): const express = require("express");
const stripe = require("stripe")(process.env.STRIPE_SECRET_KEY);
const app = express();

app.post("/webhooks/stripe", express.raw({ type: "application/json" }), (req, res) => {
let event;
try {
event = stripe.webhooks.constructEvent(
req.body, // a Buffer, untouched
req.headers["stripe-signature"],
process.env.STRIPE_WEBHOOK_SECRET
);
} catch (err) {
console.error("Webhook signature check failed:", err.message);
return res.sendStatus(400);
}
// enqueue event.id / event.type for processing, then:
res.sendStatus(200);
});

app.use(express.json()); // everything else gets parsed JSON
Quick check: log Buffer.isBuffer(req.body) in the handler. If it prints false, something parsed the body first. Next.js App Router Read the body as text, not JSON: // app/api/webhooks/stripe/route.js
import Stripe from "stripe";
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY);

export async function POST(req) {
const body = await req.text();
const sig = req.headers.get("stripe-signature");
try {
const event = stripe.webhooks.constructEvent(body, sig, process.env.STRIPE_WEBHOOK_SECRET);
// handle event
return new Response(null, { status: 200 });
} catch (err) {
return new Response(Webhook Error: ${err.message}, { status: 400 });
}
}
Calling await req.json() anywhere before this, including in middleware that reads the body, breaks it. Next.js Pages Router Pages API routes parse the body by default. Turn that off for this route and read the raw stream: // pages/api/webhooks/stripe.js
export const config = { api: { bodyParser: false } };

async function rawBody(req) {
const chunks = [];
for await (const chunk of req) chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
return Buffer.concat(chunks);
}

export default async function handler(req, res) {
const buf = await rawBody(req);
const event = stripe.webhooks.constructEvent(buf, req.headers["stripe-signature"], process.env.STRIPE_WEBHOOK_SECRET);
// ...
res.status(200).end();
}
Flask Use request.get_data(), never request.json or request.get_json() before verifying: import os, stripe
from flask import Flask, request

app = Flask(name)
endpoint_secret = os.environ["STRIPE_WEBHOOK_SECRET"]

@app.post("/webhooks/stripe")
def stripe_webhook():
payload = request.get_data() # raw bytes
sig = request.headers.get("Stripe-Signature", "")
try:
event = stripe.Webhook.construct_event(payload, sig, endpoint_secret)
except (ValueError, stripe.SignatureVerificationError) as e:
...

Powered by Readybot.io

**DEV Community** ## How to fix 'No signatures found matching …

DEV Community

I Built a Pay Increase Calculator in Vanilla JS - Here's the Math (and the Currency Trick)

A raise sounds simple until you try to picture what it actually pays. "5%" feels abstract - but $250 more per month, or $1.44 more per hour, is real. So I built a free pay increase calculator for CalcVersa that turns any raise into the numbers that matter. No framework, no backend — one HTML file with vanilla CSS and JS that runs entirely in the browser. Here's how it works under the hood. The three ways a raise arrives Employers phrase raises three different ways, so the calculator has three modes: Percentage - "You got a 5% raise." → new pay = current pay × (1 + % ÷ 100) Flat amount - "We're adding $3,000." → percentage worked out backwards New salary - an offer letter with a new figure → the raise % is (new − old) ÷ old × 100 The trick is normalising everything to annual pay first, whatever the input frequency: function factor(freq, hours) {
if (freq === 'monthly') return 12;
if (freq === 'biweekly') return 26;
if (freq === 'weekly') return 52;
if (freq === 'hourly') return hours * 52;
return 1; // annual
}
var annual = pay * factor(freq, hours);
From one annual number, every output is a division away: monthly = annual ÷ 12, bi-weekly = annual ÷ 26, hourly = annual ÷ (hours × 52). One source of truth, no rounding drift between fields. The feature most calculators skip: the real raise A 3% raise in a 4% inflation year is quietly a pay cut. So the tool also shows your raise after inflation: var realPct = ((1 + pct / 100) / (1 + infl / 100) - 1) * 100;
A 5% raise against 3% inflation gives a real raise of +1.94% — genuinely ahead, but by less than the headline number suggests. This one stat is why I built the tool. Live currency conversion with a fallback chain Users don't all earn in dollars, so the amount fields convert live between 19 currencies. Free exchange-rate APIs go down, so instead of trusting one source, the fetch walks a chain of four public endpoints and uses the first that answers with a complete rate table: var chain = Promise.reject(new Error('start'));
sources.forEach(function (s) { chain = chain.catch(s); });
If every source fails, the currency symbol still changes and the user is told the amounts were not converted - an honest error beats a silently wrong number. What I deliberately kept boring No framework. The whole tool is one self-contained block, so it can be pasted into any page builder and just work. Gross figures only, clearly labelled - tax depends on country and state, and pretending otherwise would make the numbers lie. Everything client-side. Nothing typed into the calculator ever leaves the browser. Try it The calculator is live here: Pay Increase Calculator - it sits next to its sibling tools, a salary calculator and an overtime calculator, so you can go from "what's my hourly rate?" to "what's my raise worth?" in one place. If you build tools like this: what's your rule for when a calculator needs a backend, and when is one static file the better answer?

Powered by Readybot.io

**DEV Community** ## I Built a Pay Increase Calculator in …

DEV Community

At the First AI Music Awards, the AI Was Fine. Everything Else Broke.

On Friday, November 13, Los Angeles hosted the first AI Music Awards. It was organized by the Sonic Intelligence Academy, a young company that makes AI music charts and tools for spotting AI-made songs. According to Reuters, the big winner was Xania Monet, an AI-generated avatar who took artist, song and album of the year. I read the coverage expecting a story about AI failing on stage. That isn't what happened, and that's why I'm writing about it. What actually went wrong Variety's Corbin Bolies was in the room, and his report reads like a postmortem written by someone trying hard not to laugh: The show started about 30 minutes late and finished almost 40 minutes behind schedule. A film trailer didn't play on cue. When it finally did, it cut off before the actor appeared. The hosts introduced presenters, then announced a commercial break, and one award ended up delayed by 13 minutes. A sponsor's ad played at a random moment. Nominee introductions were dropped, so winners were simply announced. The crowd thinned as the night went on. Then there are the parts that sound made up. An AI correspondent sat in a tall white faux-stone vessel and couldn't do the red carpet, because it couldn't move. Several human performers lip-synced to AI-generated tracks, and Variety says two acts mimed their entire sets. We spent the last few years worrying that robots would replace singers. At the first ceremony for robot music, singers were miming for the robots. The lesson I'd steal from it Look at that list again. None of it is a model hallucinating or a generator producing garbage. It's a teleprompter, video cues, a run of show and timing. I've been building software for 15+ years, first as a developer, then as tech lead and now as team lead. I've shipped worse than a late trailer. What I keep relearning is that the clever part of a launch rarely fails. The new algorithm, the shiny integration, the thing everyone was nervous about usually works, because everyone was nervous about it and tested it twice. What fails is the part nobody owned: who presses play, what happens if the video doesn't load, who decides to skip a segment when you're 30 minutes behind. That's not tech. It's a rehearsal and a checklist. If you run launches, demos or company events, here's the boring version: Do one full dress rehearsal, in order, with the real hardware. Give every cue an owner. One name per video, slide and transition. Write a "we're late" plan before you're late. What gets cut first? Have a fallback for every screen moment. If the video won't play, what does the host say? None of that needs AI. All of it would have saved this show. So is it real music? This is where I'm genuinely torn. The winners argue it is. Reuters quotes producer Drake Murphy: "In a world where everybody calls AI fake, the human behind it is real." Telisha "Nikki" Jones, who created Xania Monet, says she wrote all the lyrics and then set them to music with AI. Billboard reportedly counted the song as the first by an AI-based act on one of its radio charts. The other side is just as real. Record labels have sued AI companies over training on copyrighted songs. Many musicians worry that a flood of cheap AI tracks makes it harder for human artists to be heard, and takes paid work away from session singers, producers and engineers. My moderate take: if a person writes the words, picks the sound and puts in the hours, there's craft in it. I wouldn't call it fake. But I'd want it labeled, the same way I'd want to know whether a photo was edited. And I'd like the people whose music trained these tools to get paid. The organizers say there will be a next year, and that they'll fix the technical issues. I hope they rehearse. Your turn: if a human wrote the lyrics and AI made the music, would you count it as real music? Why?

Powered by Readybot.io

**DEV Community** ## At the First AI Music Awards, the …

DEV Community

Before your payment webhooks go live: a 12-point production checklist

Reliable HTTP cron and delayed-job scheduling with automatic retries and full run logs — delay.run Webhooks from a payment provider are the moment your system finds out that money moved. In the sandbox they're easy: you send a test event, your handler logs it, done. In production they arrive twice, out of order, hours late, from a provider whose retry schedule you didn't read, to an endpoint that went down during your last deploy. None of those are rare. Here's the checklist I'd go through before switching a payment integration to live mode. It's written with card payments and subscriptions in mind, but almost all of it applies to any provider that sends webhooks. Receiving 1. Verify signatures on the raw body Every serious provider signs its webhooks. Verify the signature against the raw request bytes, before any JSON parsing, using the secret for that specific endpoint. Reject anything that fails with a 400, and log the failure (without logging the secret). Test it with a deliberately tampered body, so you know the check actually rejects things. 2. Return 2xx fast, process later The provider will time out your request after a few seconds (often 10 to 30) and retry. Do the minimum in the request: verify, store the raw event, return 200. Do the real work (updating orders, sending emails, provisioning accounts) in a background job. A handler that sends an email inline will eventually send it twice when a slow SMTP server makes the provider time out and retry. 3. Store every event before acting on it Keep a table of received events with the provider's event ID as a unique key, the type, the raw payload, the received time and the processed time. It's your audit log, your deduplication mechanism, and the thing you'll query at 2 a.m. when someone asks "did we ever get the webhook for this payment?". Processing 4. Make every handler idempotent Duplicate deliveries happen: retries after timeouts, the provider's own at-least-once delivery, and manual resends from the dashboard. Deduplicate on the event ID, and also make the action itself safe to repeat ("mark paid if not already paid", not "add a credit"). 5. Don't depend on delivery order Providers generally don't guarantee order. A subscription.updated can arrive before subscription.created; a refund can arrive before you processed the charge. Either re-fetch the object's current state from the API when an event arrives, or compare versions and ignore anything older than what you have. 6. Handle "not found yet" without dropping the event If the event refers to an order or customer your database doesn't have yet (because your own write hasn't committed), don't return 200 and forget about it. Store it and retry the processing on your own short schedule, with an alert if it's still unmatched after an hour. 7. Handle the event types you don't use Your endpoint will receive event types you didn't subscribe to on purpose, or new ones the provider adds. Return 200 and ignore them, rather than throwing a 500 that makes the provider retry for days. Better still, subscribe the endpoint only to the event types you handle. Checklist item: a retry policy that isn't a sleep() in the request. delay.run schedules the follow-up HTTP call with retries and a run history you can inspect. Operating 8. Know the provider's retry schedule and disable rules Find out how long the provider retries a failing endpoint (for some, up to three days) and what happens after that. Some providers automatically disable an endpoint after repeated failures, and send a warning email to whoever's address is on the account. Make sure that address reaches someone who'll act on it. 9. Alert on silence, not just on errors Errors are easy to alert on. The harder failure is no webhooks at all: an endpoint disabled, a DNS change, a firewall rule, a deploy that removed the route. Track "time since last event received" per event type you rely on, and alert when it exceeds what's normal for your traffic. 10. Reconcile with the p...

Powered by Readybot.io

**DEV Community** ## Before your payment webhooks go live: a …

DEV Community

How Agentic Commerce Actually Works: A Developer Guide to ChatGPT Wallet

How Agentic Commerce Actually Works: A Developer Guide to ChatGPT Wallet ChatGPT can now buy things for you. As developers, we need to understand what is happening under the hood. Last week OpenAI launched ChatGPT Wallet in beta. Users can save a card, ask ChatGPT to buy something, approve with biometrics, and the order is placed. It sounds simple. For developers, it is a massive shift in how the web works. For 30 years, the flow was like this: User searches, user clicks, user pays. We optimized for SEO, landing pages, and checkout conversion. Now the flow is like this: User talks to AI, AI searches, AI decides, AI pays. The user may never visit your website. This is called agentic commerce. And if you build websites, APIs, or SaaS products, you need to prepare for it now. How does ChatGPT Wallet work technically At a high level, there are 4 layers. User Intent Layer The user says something like: Order my usual coffee beans under 30 dollars. ChatGPT converts this natural language into structured intent: product equals coffee beans, budget equals 30, preference equals usual brand. Discovery Layer ChatGPT searches partner stores and product catalogs. It does not just scrape Google. It uses structured product feeds, APIs, and partner integrations. If your product data is messy, you are invisible here. Trust and Payment Layer This is where Visa, Mastercard, and American Express come in. The card is tokenized, just like Apple Pay. When the user approves with Face ID or fingerprint, a one-time token is used for that purchase. The merchant never sees the real card number. Fulfillment Layer Once payment is approved, the order goes to the merchant through their normal order API. The user gets a receipt inside ChatGPT. As a developer, the most important layer for you is layer 2: Discovery. If AI cannot understand your product, it cannot sell your product. Why your website will fail for AI agents Most websites today are built for humans. They have beautiful hero sections, popups, animations, and marketing copy. AI agents hate all of that. An agent wants: Clear product title Clear price Clear stock status Clear shipping time Clear return policy Clean JSON or structured data If your product page says: Best Amazing Premium Coffee Beans, You Will Love It, 50 percent Off Today Only, the agent gets confused. What is the price? What is the weight? Is it in stock? Compare that to this: Product: Arabica Coffee Beans 500g Price: 24.99 USD In Stock: Yes Delivery: 2 days Return: 30 days The second one wins every time for an AI agent. This is why structured data matters more than ever. Use Schema.org Product markup. Make sure your JSON-LD is correct. Keep your sitemap updated. Provide a clean product API if you can. What developers should build now Here are 3 practical things you can do this week. First, audit your product pages for AI readability. Open your site, turn off JavaScript and CSS. Can you still see the price, title, and stock? If not, an agent will struggle too. Use server-side rendering for critical product data. Second, add an AI-friendly endpoint. Create a simple endpoint like /api/products that returns clean JSON. Include id, name, price, currency, stock, image_url, description, shipping_time, and return_policy. You do not need to make it public for everyone, but make it easy for agents and partners to integrate. Third, think about idempotency and refunds. Agents will make mistakes. They will order twice. They will order the wrong size. Your API must handle duplicate order prevention, easy cancellation, and instant refunds. If your refund flow needs 5 emails and a phone call, agents will stop recommending you. Here is a simple example of what an AI-friendly product response should look like: { "id": "coffee-001", "name": "Arabica Coffee Beans 500g", "price": 24.99, "currency": "USD", "in_stock": true, "delivery_days": 2, "return_days": 30, "rating": 4.8, "reviews_count": 1240 } Clean. No marketing fluff. No hidden fees. This is wh...

Powered by Readybot.io

**DEV Community** ## How Agentic Commerce Actually Works: A Developer …