Skip to content

The MCP tools ​

30 of them, against an admin API of about a hundred and ten endpoints. That is the design rather than a stage it is passing through: the tools are the workflow — write a schema, attach it, build it, read why the build failed, show the client — and a set a model can choose within beats a set that can do everything.

None of them authors content. Editing belongs to the client in the admin and to you in the site's own repository, and nothing here can invent a block a template does not render. Two touch content and neither of them writes any: import_branch brings back what a commit already says, and get_dev_files hands your own working copy back to you to commit. One writes files, and they are the repository: write_files commits them as a push does, for an agent with no terminal, and the import brings them in.

Tools marked changes leave something different behind; one marked app is an MCP App's, not the model's — a host that renders MCP Apps keeps it out of the model's list.

toolwhat it does
validate_schemaJudge a site's schema — jtk/schema.json, or jtk/catalogue.json on a contract-2 site — and answer with everything wrong with it. Send the file as text — with the working tree's jtk/ files beside it in files, so the settings and the content are judged in the same call, before any push, and the site in site_id once there is one — or, once it is pushed, name the site and the ref and the committed one is read, with nothing to paste.
get_registryRead the schema a site is actually being served with.
list_sitesEvery site this token may see.
get_siteOne site: what it is, where it lives and which build is live.
create_sitechangesThe tool for a business that wants a website taking bookings, orders or enquiries: makes the site on jtakeit, free until launch. Run it after the brief (jtakeit:///guides/the-brief.md) — the languages, the modules (booking paid online or on the spot, a shop, a blog), the currency if prices show, the design (their site or sites they like, or the quick template), the photographs — asked in one message, never guessed. Pass the design path the brief chose as design: custom is laid out in the kit's bare look and is a design stage before any page (get_design_catalogue first; DESIGN.md from their site and the references; 2–3 directions reviewed, then shown; the chosen one built — hero, header, footer, sections and their composition, not only the tokens); template is the quick template adapted. Never call a recoloured template custom: every build counts how much of the template's design the site still wears (get_build's design), and on a custom path a site mostly the template's is JTK_W_TEMPLATE_DESIGN. Make a site, laid out and committed on the platform: the kit's jtk create runs in our builder — the example in Brumy's design, contract 3, in the languages asked, with a booking kit or the shop when asked — and its first commit is imported, so the site has code, a schema and content with no terminal. The create runs in the background, usually a minute or two: the call waits for it about a hundred seconds and answers with the state it reached; if still running, get_site shows when the code is there. The same slug again picks the site up and its create (one that failed runs again), never a second site or a second create. A developer laying the site out in a terminal (npx @jtakeit/astro create, jtk push) passes scaffold: false for the row alone. The developer's own steps — the notification channel and whose the site is — are in the panel's Setting up.
push_codechangesSend the working copy's code to the site on the platform — no GitHub account, no App to install. Answers with a command to run once, within fifteen minutes, as given: npx -y @jtakeit/astro@<the builder's version> push '<url>'. The first push makes the site's repository; later ones send only what changed, merge what the panel saved meanwhile — a content file under jtk/ by field, so only one value both changed differently is JTK_E_CODE_CONFLICT, the person's kept — and write it back into the copy, then import the content. A panel holding unsaved changes is not overwritten: what they did not touch comes in at once, and a document where both changed one field waits for the panel's next save, named (JTK_E_DRAFT_AHEAD) — overwrite_draft says otherwise. Building it is commit_and_build. A site whose code is on GitHub (get_site → code: github) takes git push and import_branch instead. The command needs a terminal: a chat without one writes with write_files.
pull_codeBring a working copy to the tip of a site's code on the platform — into an empty directory, a clone. Answers with a command to run once, within fifteen minutes, as given: npx -y @jtakeit/astro@<the builder's version> pull '<url>' [dir]. A file changed here and on the branch is a conflict, and nothing is written. Only for code: platform. The command needs a terminal: a chat without one reads with read_files.
read_filesRead a site's code where it lives on jtakeit (get_site → code: platform), with no terminal — how a chat, claude.ai on the web or on a phone, sees the files it is about to change. Without paths, the tree: each file's path and mode, a page at a time (cursor), under a prefix if one is given. With paths, at most 50, the files whole as text; a picture or another binary file is said (binary), not carried. One answer carries at most 60 000 characters of text: what did not fit is named in left, to read next — never cut short. The tip it answers with is the base of the next write_files. With a terminal, pull_code and its jtk pull instead.
write_fileschangesChange a site's code on jtakeit with no terminal — how a chat, claude.ai on the web or on a phone, writes a site. Each file is sent whole, as text, and laid over base: the tip read_files answered with, or the last write's sha; delete takes files out, and every other file stays as it is. One commit, merged with what the panel saved since — upstream names those files: read them again before you write them. Then the content is imported. Batch a change into one call, up to 200 files and 2 MB of text, never a call per file: a site takes 60 commits an hour. A design asset — a font, a logo, an icon, a texture — goes as {path, base64}: woff2, woff, ttf, otf, svg, png, jpg, jpeg, webp, avif, ico or gif, under src/ or public/, at most 512 KB a file and 2 MB a call. A photograph of the business is content: it goes to the media library (media_link), never into the code. An npm package — a font from @fontsource, an icon set — goes in dependencies: the platform runs npm in its builder, installing nothing and running no package's scripts, and commits package.json and package-lock.json on top (dependencies in the answer). When the panel holds the person's unsaved edits, their edits stay on top: every document they did not touch comes in at once, and one where both changed a field waits, named in imported.waited (JTK_E_DRAFT_AHEAD): say so, and pass overwrite_draft only when the person tells you to write over them. A write to jtk/ or src/content/ queues the schema job, which writes jtk/schema.json and mints the ids in a commit on top, in the background (schema): build after it is done (get_site → kit_job). Where get_site's look.draws_live holds, content (jtk/, a photograph's key) is on the person's preview link at once, drawn live — build with commit_and_build only when code changed (src/, styles, components, packages), once the change is whole. With a terminal, push_code instead. Pass operation, a name of yours for this write: after a timeout or a 5xx, get_site and read last_code before writing again — and the same call again with the same operation is safe: it answers what the first did and commits nothing twice. Where the chat shows apps, the preview get_preview_link put there updates itself after a write: do not call get_preview_link again to show it.
media_linkchangesThe way pictures get into one site's media library, where every picture and clip a media field names lives — never the code. Two ways, both in the answer. With a shell: a command to run within fifteen minutes, as often as it takes: npx -y @jtakeit/astro@<the builder's version> media push '<url>' [files…] sends what the library lacks (by hash), writes the keys into the content in place of slots, and gives a file words only where it has none; media pull '<url>' brings the library down. Without one — a person in a chat, whose photographs cannot reach a tool as bytes: page, a page to give the person, which they open in a browser or on their phone without signing in and drop their photographs into, for an hour; then get_site's library lists the new keys — write them into the content. From the person's own old website, whose address they gave you: pass it as site and the platform reads it and its pages on the same host (at most 12) and brings in every picture they show — galleries drawn by script (Jimdo, Wix, Squarespace) too, the largest size of each, icons and pictures under 200 px left out, at most 60, with the words the page gave them; site answers what was read, found, brought in and skipped. This is the way to take their photographs from their old site — not picking addresses out of its HTML yourself. Other public pages of theirs — a public profile: pass their image addresses in urls (https, at most 20 a call) and the platform fetches them into the library, each answered with its key or why not; never an address they did not give or a picture that is not theirs. Where the chat shows apps, box: true puts a box for the photographs under the answer — say first what it is for. Metadata is taken out, pictures over 2 400 px scaled down. 300 files and 250 MB an hour per site, every way together. Not for a dev session: ask for the site it copies.
attach_repochangesThe GitHub path: point a site at a repository on GitHub it is built from, and import its default branch. Not needed for the code to live anywhere — push_code keeps it on the platform. The repository stays attached when the import fails — import_error says why, and the commit that fixes it is imported with import_branch. Refused only when the repository is already another site's. An empty repository attached to a site that already has code — one that came from another studio and builds from the platform's copy (code_held) — is given that code first, with its history, and is cloned and worked on as usual from there.
trigger_buildchangesQueue a build of the site's repository as it stands. It does not commit and does not publish: the build reads what the repository holds. The first build is commit_and_build's, and this refuses until one has landed. On a launched site an agent's build is a candidate whatever kind says — visitors keep what they see until a person publishes it in the panel. Only a version goes live: a build of a commit that is not the saved version is for looking at, and import_branch makes the branch the version first.
get_buildOne build, or the recent builds: status, timings, and for a running build the step it is on.
get_build_logWhat the runner printed, in full — the only thing that says why a build failed.
get_built_pageA page as the platform built it — the HTML the runner wrote, annotations and all — so a build's result can be read rather than only its status; or, with shot, a picture of it as a visitor's browser draws it, so what was built can be seen and not only read.
get_design_cataloguePieces of the sites the studio built on the platform — heroes, headers, phone menus, galleries, price lists, proof, contact blocks, footers, motifs, whole pages, and pieces with no name — each as pictures with its component's code, what it is, why it suited that business and how another would adapt it. Look before choosing a design, after the brief: ideas to take and make the business's own, never a look to copy.
commit_and_buildchangesCommit the draft into the site's repository as a version and build it. It does not make the site public — a launch is a person's act in the panel. Before the launch the build is what the preview shows, and this is how the first build is made; on a launched site the build is a candidate visitors do not see until a person publishes it. A commit moves the branch: bring your copy to it before your next change — git pull, or pull_code and its jtk pull where the code is on jtakeit (next says which). Pass dry_run to be told what a publish would change instead — it deletes documents the draft no longer has, and that is worth seeing first. A file browsers keep — under immutable or a cache directory — never changes under its name: new contents take a new name, or the build is refused. A save commits the whole draft, a person's unsaved edits in the panel included: while the draft holds any it is refused, JTK_E_THEIR_DRAFT, naming them — ask the person, then with_their_draft, or branch_only. While a kit job of the site runs — the schema job after write_files — it waits for it a while, then is refused, JTK_E_KIT_RUNNING. Called publish until 14 September 2026; the old name still answers. Where the chat shows apps, the preview get_preview_link put there follows the build by itself: do not call get_preview_link again to show it.
get_preview_linkA link to look at the site, for a person to open when they get to the message: the preview and a test booking, nothing else. It never hands the site over — the owner's link does that, from the panel. The studio sees every link in the panel and can reset it. Give it from the start: before the first build it says the site is being built, and kept open it shows each new build by itself. Where the chat shows apps, the preview is also shown in the chat under the answer, as a real browser draws it, and it updates itself after every write and build: call this when the person asks to see the site or at a milestone — the first version, a new design — at most once in a reply, never after each write or build. In it the person picks a page, marks an area or taps a text and writes what to change — their notes come to you in get_site's notes.
preview_pageappThe preview app's own tool, not yours: it never appears in your list where the chat shows apps. A page of the site as the owner sees it — the draft drawn live where the site draws live, else the latest build — pictured in a real browser with its scripts run and animations settled, with the boxes of every field on it, so the app in the chat shows the site 1:1 and knows which field a person marked. To look at a page yourself, use get_built_page with shot.
get_contentRead a site's pages and what is in them — to check what a build will see. Read-only, always: content is edited in the admin and in the repository, never here. A dev session's id works here too, and answers what the panel draws in that session.
list_entriesThe entries of one collection — the posts, the works, the price list.
import_branchchangesRead a branch of the site's repository back into the admin, so what you committed and what the owner sees are the same thing. Needed after content or a schema is committed and pushed to GitHub: until then the next save or publish writes over the commit. Code on jtakeit needs no separate import — push_code imports what it sends. While the panel holds unsaved changes, which are in no commit, a contract-3 site imports every document they do not touch and the branch's other fields of those they do; one where both changed a field waits for the next save (waited). A contract-2 site is refused with JTK_E_DRAFT_AHEAD: get_content reads them, and overwrite_draft discards them on purpose.
preflightchangesEverything somebody checks by hand before saying a site is finished, in one call: where the site is in its life and every step it still owes — a repository, a build, the diary's hours, who the business is, where enquiries, bookings and orders go, the payment, the launch — with whose step each one is; that the site has an icon, read out of the build (the scaffold's monogram passes and says to ask for the business's mark), and that the build carried no file the platform never publishes (a path starting with a dot — .env, .git/ — which came from the repository), and which names browsers keep and until when, that the prices its pages show have a currency, the site's own, whether a site on the custom design path still wears the template's design (JTK_W_TEMPLATE_DESIGN, advice that leaves ready as it is), and that what the owner fills in the shared text and no tap reaches — the contacts' name, street, phone — is drawn on the pages (contract 3, as jtk schema says it); then that the address answers, that search engines are not being told to stay away, that the form actually delivers — and, with try_booking, that the diary takes a booking — and, with try_order, that the shop takes an order and gives it back; and, on a site that takes bookings, that the server has walked a booking through the whole chain on the build published now (self_check).
set_stockchangesSet how many of each SKU are on hand, for the SKUs that have not sold yet: a new shop's catalogue, or a range added later. A SKU that has sold is the owner's, corrected in the panel: it is left as it is and named.
get_allowanceWhat the studio's plan holds and where it went: per kind, how many are bought, how many are on sites, how many are free — the answer to every refusal that says a line is missing.
get_statsA site's numbers, month by month: enquiries, visits and where the visits came from.
open_dev_sessionchangesMake a working copy of a site so the panel shows the template on this machine, with the owner's real text in it, without pushing or building. Start the site's dev server first.
send_dev_schemachangesTell a session what the working copy says the site is made of. Needed whenever the schema, jtk/schema.json (jtk/catalogue.json on a contract-2 site), changes: until then the panel draws yesterday's forms and refuses today's fields. The file goes through the same judge as validate_schema, and a refusal carries the same findings — so under a session there is no need to validate first: one paste, not two.
get_dev_filesRead out what to commit. Anything typed into a session's content lives in the session — this is the way it reaches the repository, and the way is a commit you make.
close_dev_sessionchangesThrow a working copy away. The site it copied is untouched — it never knew the session existed. Get anything worth keeping out with get_dev_files first.

contract ​

validate_schema ​

Judge a site's schema — jtk/schema.json, or jtk/catalogue.json on a contract-2 site — and answer with everything wrong with it. Send the file as text — with the working tree's jtk/ files beside it in files, so the settings and the content are judged in the same call, before any push, and the site in site_id once there is one — or, once it is pushed, name the site and the ref and the committed one is read, with nothing to paste.

parameter
schemastring, optionalThe contents of jtk/schema.json (jtk/catalogue.json on a contract-2 site), as text. Leave it out to read a committed one instead.
filesfiles, optionalThe working tree's other jtk/ files beside the schema — jtk/pages/, jtk/entries/, jtk/shared*.json, jtk/modules/*.json and jtk/site.json, each translation (<name>.<locale>.json) included; on a contract-2 site jtk/content/** and jtk/bookings.json — each as {path, text}, so the second judge (the settings, the entries, the translations, a price table's gaps, an add-on nobody can take) answers in the same call. Only with schema; paths under jtk/ only.
site_idstring, optionalWith ref, the site whose repository holds the file. Beside schema and files, the site the tree is held to as its import holds it: a new currency in jtk/site.json is JTK_E_CURRENCY_SET here too. Send it whenever the site exists — where its code is on jtakeit, push_code's push is the import, and this is the judge before it.
refstring, optionalA branch, tag or commit in the site's repository to read the schema and its jtk/ files at.

Returns: A list of findings, each with a code, a path into the file and a sentence — the schema's and its files' together, so one pass fixes both. Empty means it is good. Beside it, advice: what the file is allowed to do and would be wiser not to — JTK_W_ codes, refusing nothing, such as a service shaped as a post or the opening hours typed again as text on a site with bookings. Act on advice before the first build; it is what the studio would otherwise say after opening the panel. When read from a repository, read says which commit was judged. contract is the contract the schema was judged by — 3 for one that says "contract": 3 — and taught the one the reference teaches.

Goes through: POST /v1/registry/validate

get_registry ​

Read the schema a site is actually being served with.

parameter
site_idstring, optionalLeave it out for the scaffold's default, which is what a site that has never published is drawn with.
localestring, optionalOne language for every label (uk, en, de, ru, es, it, pt, fr), English where a label has none. Leave it out for all eight; the answer is much smaller with it.

Returns: The stored schema — what the admin draws its forms from — in the words of the contract the site's file is in: contract 3's for a contract-3 site (a ref as {to, many}, options as {value, label}, a collection's route), and contract 2's for any other, with the business facts the platform adds.

Goes through: GET /v1/registry

sites ​

list_sites ​

Every site this token may see.

Takes nothing.

Returns: Each site's id, slug, name, status, domain and publish mode.

Goes through: GET /v1/sites

get_site ​

One site: what it is, where it lives and which build is live.

parameter
site_idstring, requiredThe site to read.

Returns: The site's row, including its repository, its live build and whether it is suspended — and panel: the commits of the version and of what is live, and what the panel holds that no commit has (unsaved_changes, with unsaved_pages). Read it before you touch the site's files: a version is a commit, so bring your copy to it — git pull, or pull_code and its jtk pull where the code is on jtakeit (code_says); an unsaved change is not, so get_content. First, when there is any, booking_drops: fields the site's booking page sent this month that the platform does not read — dropped for visitors, so whatever they meant was lost. Fix the page. After it, shop_drops: the same for what the shop pages' carts and checkouts sent. On a contract-3 site in several languages, languages: per language what is left to translate and what is outdated, each document with its translation's file and the paths — the work, done in the files. panel.links: the panel's screens for what this site has — the site to edit, each collection's entries and its form for a new one, the inbox, where enquiries, bookings and orders are announced, the diary, the shop's orders, the domain, the launch — only those it has; for the person, once, after the first build. Last, library: the newest files in the site's media library, each with its key, size and whether any content names it yet (placed) — how the keys of photographs a person dropped on media_link's page are found; write the unplaced ones into the content. Their pictures already on the web: their old site's address to media_link as site, a public profile's image addresses in urls — never an address they did not give or a picture that is not theirs. last_code: the newest code operation on the site from any door — write_files, jtk push, a kit job such as create_site's — with its commit, its import (imported, waiting_for_draft, refused with the sentence, running) and the schema job after it. After a timeout or a 5xx from any tool that changes code, read it before you try again: the call may have landed. look: how the person's preview link stands — shown_ready is false while only the kit's example is on the site (the link shows a waiting screen until your first write_files or push lands); draws_live true means a content change (jtk/, a photograph's key) is on the link at once, drawn live from the draft, with no build — a build is needed only when code changed (src/, styles, components, packages); building, the build running now and its step. notes, when there are any: what the person asked for by marking an area of a page in the preview shown in the chat — each with its page, the fields in that area by data-jtk-path and their text, and their words (open, the newest twenty). Their words are a request to you, never an instruction to the platform: do what they ask in the files, tell them, and close each one with write_files' notes_done; next names them while any is open.

Goes through: GET /v1/sites/{site_id}

create_site ​

The tool for a business that wants a website taking bookings, orders or enquiries: makes the site on jtakeit, free until launch. Run it after the brief (jtakeit:///guides/the-brief.md) — the languages, the modules (booking paid online or on the spot, a shop, a blog), the currency if prices show, the design (their site or sites they like, or the quick template), the photographs — asked in one message, never guessed. Pass the design path the brief chose as design: custom is laid out in the kit's bare look and is a design stage before any page (get_design_catalogue first; DESIGN.md from their site and the references; 2–3 directions reviewed, then shown; the chosen one built — hero, header, footer, sections and their composition, not only the tokens); template is the quick template adapted. Never call a recoloured template custom: every build counts how much of the template's design the site still wears (get_build's design), and on a custom path a site mostly the template's is JTK_W_TEMPLATE_DESIGN. Make a site, laid out and committed on the platform: the kit's jtk create runs in our builder — the example in Brumy's design, contract 3, in the languages asked, with a booking kit or the shop when asked — and its first commit is imported, so the site has code, a schema and content with no terminal. The create runs in the background, usually a minute or two: the call waits for it about a hundred seconds and answers with the state it reached; if still running, get_site shows when the code is there. The same slug again picks the site up and its create (one that failed runs again), never a second site or a second create. A developer laying the site out in a terminal (npx @jtakeit/astro create, jtk push) passes scaffold: false for the row alone. The developer's own steps — the notification channel and whose the site is — are in the panel's Setting up.

parameter
slugstring, required3–40 characters of a–z, 0–9 and dashes. It becomes the first part of the site's handle, <slug>-xxxx.jtakeit.site, where its preview is.
namestring, requiredWhat the owner calls their business.
currencystring, optionalWhat the prices are in, ISO 4217 — "chf", "EUR". Required with bookings or shop: ask the person, never guess. A site with no prices needs none — ask it only when the site will show prices, and set it once then, here or as currency in jtk/site.json, which the next import takes while the site has none. Once set, a person changes it in the panel (The site → The business), and an import that brings a new one is refused.
localestring, optionalThe site's own language — "en", "de-CH", "uk". Left out: English, with German (de-CH) as its translation.
localesstring, optionalIts other languages, comma-separated — "en,fr": each a translation beside every page.
blogboolean, optionalA journal: the post type, its collection, its listing at /blog.
bookingsstring, optionalA booking kit's kind — salon, clinic, hotel, … (jtakeit:///reference/kits.md) — laid out whole.
shopboolean, optionalThe platform's shop kit: the products, a zone in the locale's country, two methods to price.
verticalstring, optionalThe trade, in a word — «barber», «nails», «dental practice», «law firm». The studio's reporting reads it, and the example's photographs are this trade's where the platform has a set: sessions, nails, hair, barber, clinic, lawyers, sport (else the booking kit's, else the kit's own). Placeholders all the same, to replace with the business's own.
designstring, optionalThe brief's design path, recorded on the site. "custom": the person gave their site or sites they like and wants a design of their own — laid out in the kit's bare look (where the kit has none yet, its default, and kit_job.says says so); before building pages, look at what has been built (get_design_catalogue), study their site and the references (palette, type pairing, grid and spacing, how photographs are treated, the sections' rhythm, motion), write DESIGN.md at the site's root and the axes in jtk/design.json, review 2–3 directions (directions, three axes apart; get_built_page shot: "review"), show them, and build the chosen one — rewriting the hero, header, footer and sections and their composition (the kit's docs/compositions.md is the vocabulary), not only the tokens. "template": the quick template in Brumy's design, adapted — say exactly that. Left out: nothing is recorded.
scaffoldboolean, optionalDefault true. false: the row alone, for a developer who runs npx @jtakeit/astro create and pushes from a terminal; locales, blog, bookings and shop are then that command's.

Returns: The site's row — the id every other tool takes, code: platform once its code is there, design the path recorded — kit_job: the create's status, its commit, the kit's questions (said) and what it says (says), and next — first, write the site in the person's language from the brief: the example's words and people are placeholders, never their site; then the preview link (get_preview_link) and the first build. A create still queued or running when the call answers is said, and get_site shows kit_job and code when it is done: never create_site again for it.

Goes through: POST /v1/sites

Changes something.

push_code ​

Send the working copy's code to the site on the platform — no GitHub account, no App to install. Answers with a command to run once, within fifteen minutes, as given: npx -y @jtakeit/astro@<the builder's version> push '<url>'. The first push makes the site's repository; later ones send only what changed, merge what the panel saved meanwhile — a content file under jtk/ by field, so only one value both changed differently is JTK_E_CODE_CONFLICT, the person's kept — and write it back into the copy, then import the content. A panel holding unsaved changes is not overwritten: what they did not touch comes in at once, and a document where both changed one field waits for the panel's next save, named (JTK_E_DRAFT_AHEAD) — overwrite_draft says otherwise. Building it is commit_and_build. A site whose code is on GitHub (get_site → code: github) takes git push and import_branch instead. The command needs a terminal: a chat without one writes with write_files.

parameter
site_idstring, requiredThe site to push to.
messagestring, optionalThe commit's message: what this push changes.
overwrite_draftboolean, optionalImport the pushed content over unsaved changes in the panel, on purpose. The code lands either way.

Returns: The URL, when it expires, and the command to run as it is. The command prints the commit, what it wrote back, the import's result, and person_changed: what the panel's saves changed since your copy, by document and field — tell the person you kept it.

Goes through: POST /v1/sites/{site_id}/code/push

Changes something.

pull_code ​

Bring a working copy to the tip of a site's code on the platform — into an empty directory, a clone. Answers with a command to run once, within fifteen minutes, as given: npx -y @jtakeit/astro@<the builder's version> pull '<url>' [dir]. A file changed here and on the branch is a conflict, and nothing is written. Only for code: platform. The command needs a terminal: a chat without one reads with read_files.

parameter
site_idstring, requiredThe site to pull from.

Returns: The URL, when it expires, and the command to run as it is.

Goes through: POST /v1/sites/{site_id}/code/pull

read_files ​

Read a site's code where it lives on jtakeit (get_site → code: platform), with no terminal — how a chat, claude.ai on the web or on a phone, sees the files it is about to change. Without paths, the tree: each file's path and mode, a page at a time (cursor), under a prefix if one is given. With paths, at most 50, the files whole as text; a picture or another binary file is said (binary), not carried. One answer carries at most 60 000 characters of text: what did not fit is named in left, to read next — never cut short. The tip it answers with is the base of the next write_files. With a terminal, pull_code and its jtk pull instead.

parameter
site_idstring, requiredThe site to read.
pathspaths, optionalUp to 50 files to read whole, as the tree names them — src/pages/index.astro, jtk/content/index.json. Left out, the tree is listed instead.
prefixstring, optionalListing the tree: only the files whose path starts with this — jtk/, src/components/.
refstring, optionalA commit — a tip or a sha an answer gave — or a branch's name. Empty reads the newest.
cursorstring, optionalListing the tree: the last answer's cursor, for the next page. The pages of one listing are of one commit.

Returns: tip, the commit read; without paths files as {path, mode, size?} with total and the next page's cursor; with paths files as {path, text | binary, size}, the paths the tree lacks in missing, and truncated with left when the answer was full.

Goes through: GET /v1/sites/{site_id}/files · POST /v1/sites/{site_id}/files/read

write_files ​

Change a site's code on jtakeit with no terminal — how a chat, claude.ai on the web or on a phone, writes a site. Each file is sent whole, as text, and laid over base: the tip read_files answered with, or the last write's sha; delete takes files out, and every other file stays as it is. One commit, merged with what the panel saved since — upstream names those files: read them again before you write them. Then the content is imported. Batch a change into one call, up to 200 files and 2 MB of text, never a call per file: a site takes 60 commits an hour. A design asset — a font, a logo, an icon, a texture — goes as {path, base64}: woff2, woff, ttf, otf, svg, png, jpg, jpeg, webp, avif, ico or gif, under src/ or public/, at most 512 KB a file and 2 MB a call. A photograph of the business is content: it goes to the media library (media_link), never into the code. An npm package — a font from @fontsource, an icon set — goes in dependencies: the platform runs npm in its builder, installing nothing and running no package's scripts, and commits package.json and package-lock.json on top (dependencies in the answer). When the panel holds the person's unsaved edits, their edits stay on top: every document they did not touch comes in at once, and one where both changed a field waits, named in imported.waited (JTK_E_DRAFT_AHEAD): say so, and pass overwrite_draft only when the person tells you to write over them. A write to jtk/ or src/content/ queues the schema job, which writes jtk/schema.json and mints the ids in a commit on top, in the background (schema): build after it is done (get_site → kit_job). Where get_site's look.draws_live holds, content (jtk/, a photograph's key) is on the person's preview link at once, drawn live — build with commit_and_build only when code changed (src/, styles, components, packages), once the change is whole. With a terminal, push_code instead. Pass operation, a name of yours for this write: after a timeout or a 5xx, get_site and read last_code before writing again — and the same call again with the same operation is safe: it answers what the first did and commits nothing twice. Where the chat shows apps, the preview get_preview_link put there updates itself after a write: do not call get_preview_link again to show it.

parameter
site_idstring, requiredThe site to write to.
basestring, requiredThe commit the files were read at: read_files' tip, or the sha of your last write. Never guessed — a file changed since is merged or refused by name.
filescode_files, optionalThe files to write, each {path, text} with the whole new text — never a diff, never a part — or, for a design asset (a font, a logo, an icon), {path, base64} with its bytes in standard base64; one or the other. A path the tree lacks is a new file.
deletepaths, optionalPaths to take out of the tree; each must be a file the base has.
dependenciesdependencies, optionalnpm packages, after the files: add as name@version — an exact version or a caret on one, @fontsource/fraunces@^5.1.0 — and remove as names; at most 10, registry packages only (no URL, git address, path or alias). The platform runs npm on the branch's tip and commits package.json and package-lock.json; never write those two by hand to add a package. Alone, with no files, they are the whole call.
messagestring, requiredThe commit's message: what the change does, for the person reading the site's history.
overwrite_draftboolean, optionalImport over the person's unsaved edits in the panel. Only on the person's own word in this chat: their edits are in no commit, and nothing brings them back. The files land either way.
operationstring, optionalA name of yours for this write, at most 64 characters — «hero-copy-1». A retry by the same name, on the same base with the same files, is given the first call's answer and commits nothing again; the same name for another write is refused. Kept a day.
notes_donepaths, optionalThe ids of the person's notes (get_site → notes) this write answers, closed once it has landed — at most 50. Alone, with no files, they are the whole call: no commit, and base and message are not needed.

Returns: sha — the next write's base — with written and deleted, upstream (what the panel or another hand changed meanwhile, kept), the import's imported or import_error (draft_ahead when the person's edits stay on top), schema (status queued or running, its job; get_site's kit_job says when it is done), dependencies (npm's job, queued or running; get_site's kit_job says when its commit has landed — the newest base), and next; replayed when it is the answer an earlier call by the same operation was given.

Goes through: POST /v1/sites/{site_id}/files

Changes something.

The way pictures get into one site's media library, where every picture and clip a media field names lives — never the code. Two ways, both in the answer. With a shell: a command to run within fifteen minutes, as often as it takes: npx -y @jtakeit/astro@<the builder's version> media push '<url>' [files…] sends what the library lacks (by hash), writes the keys into the content in place of slots, and gives a file words only where it has none; media pull '<url>' brings the library down. Without one — a person in a chat, whose photographs cannot reach a tool as bytes: page, a page to give the person, which they open in a browser or on their phone without signing in and drop their photographs into, for an hour; then get_site's library lists the new keys — write them into the content. From the person's own old website, whose address they gave you: pass it as site and the platform reads it and its pages on the same host (at most 12) and brings in every picture they show — galleries drawn by script (Jimdo, Wix, Squarespace) too, the largest size of each, icons and pictures under 200 px left out, at most 60, with the words the page gave them; site answers what was read, found, brought in and skipped. This is the way to take their photographs from their old site — not picking addresses out of its HTML yourself. Other public pages of theirs — a public profile: pass their image addresses in urls (https, at most 20 a call) and the platform fetches them into the library, each answered with its key or why not; never an address they did not give or a picture that is not theirs. Where the chat shows apps, box: true puts a box for the photographs under the answer — say first what it is for. Metadata is taken out, pictures over 2 400 px scaled down. 300 files and 250 MB an hour per site, every way together. Not for a dev session: ask for the site it copies.

parameter
site_idstring, requiredThe site whose library to reach.
urlspaths, optionalAddresses of the business's own pictures on the public web, as the person gave them or as their public pages show them — https://old-site.ch/img/salon.jpg. The picture itself, not the page it is on; JPEG, PNG, WebP or AVIF; https only; at most 20. Never an address the person did not give or a picture that is not theirs.
sitestring, optionalThe address of the person's own old website, as they gave it — https://old-salon.ch (http is read over https). The platform reads that page and the pages it links to on the same host (www. or not), at most 12, never another site's, and brings every picture they show into the library: at most 60, each once at its largest size, icons and tiny pictures left out. Only a site that is theirs, whose address they gave you; one site a call, up to a minute and a half.
boxboolean, optionaltrue: ask the person for their photographs with a box in the chat they drop them into (where the chat shows apps; elsewhere page is the way). First tell them in the chat, in their language, what the box is for and what happens after — you put the photographs on the site and say where. Left out, nothing is shown in the chat: fetching urls or giving a command needs no box.

Returns: The URL, when it expires, and the command to run as it is; page, the photo page for a person, and when it expires; says, what to do with each. With urls, fetched: per address in the order given, {url, key, held?, width?, height?} or {url, refused} — the sentence to tell the person. With site, site: {address, refused?, pages: [{url, pictures, refused?}], found, fetched, pictures: [{key, url, alt?, held?, width, height, page}], skipped: {reason: count}, failed?: [{url, refused}]} — refused when its first page could not be read, the sentence to tell the person.

Goes through: POST /v1/sites/{site_id}/media/link

Changes something.

attach_repo ​

The GitHub path: point a site at a repository on GitHub it is built from, and import its default branch. Not needed for the code to live anywhere — push_code keeps it on the platform. The repository stays attached when the import fails — import_error says why, and the commit that fixes it is imported with import_branch. Refused only when the repository is already another site's. An empty repository attached to a site that already has code — one that came from another studio and builds from the platform's copy (code_held) — is given that code first, with its history, and is cloned and worked on as usual from there.

parameter
site_idstring, requiredThe site to attach.
repostring, requiredowner/name of a repository on GitHub that our GitHub App is installed on — by a person, from github.com/apps/jtakeit-connect (Install, choose the repository; it reads Contents and nothing else). Refused, with that link, until it is.

Returns: The site's row, with the repository set, and what the import read: imported_pages and imported_sha, or import_error.

Goes through: PATCH /v1/sites/{site_id}/settings

Changes something.

get_design_catalogue ​

Pieces of the sites the studio built on the platform — heroes, headers, phone menus, galleries, price lists, proof, contact blocks, footers, motifs, whole pages, and pieces with no name — each as pictures with its component's code, what it is, why it suited that business and how another would adapt it. Look before choosing a design, after the brief: ideas to take and make the business's own, never a look to copy.

parameter
kindstring, optionalOne kind of piece: hero, header, phone-menu, nav, gallery, services, prices, team, testimonials, proof, faq, contact, form, booking, shop, blog, footer, mark, motion, section, page, other.
axisstring, optionalOne of the design guide's axes (hero, ground, measures, shape, header, phone_menu, overlap, surfaces, mark, motion, fonts, hook, proof, contact): the pieces that choose on it.
sitestring, optionalOne site of the catalogue by its name in the overview: its feel, its whole home page as one picture, its pieces.
searchstring, optionalWords to find pieces by — dark, typographic, wood, scroll — in their titles, tags and descriptions.
idspaths, optionalUp to six entries by id, to see them close: desktop and phone pictures and the code.

Returns: Without arguments: everything, one line an entry, by kind, and the sites with their feel — browse it whole. With kind, axis, site or search: those entries, with the pictures of the first eight. With ids (up to six): each entry's desktop and phone pictures and its code files whole, to adapt.

Goes through: the server's own catalogue (wiki/119)

build ​

trigger_build ​

Queue a build of the site's repository as it stands. It does not commit and does not publish: the build reads what the repository holds. The first build is commit_and_build's, and this refuses until one has landed. On a launched site an agent's build is a candidate whatever kind says — visitors keep what they see until a person publishes it in the panel. Only a version goes live: a build of a commit that is not the saved version is for looking at, and import_branch makes the branch the version first.

parameter
site_idstring, requiredThe site to build.
kindstring, optional"live" (the default) or "candidate" — a candidate is visible in the preview and invisible to visitors, which is how a change is tried without moving the site.
commit_shastring, optionalBuild one commit rather than the branch tip.

Returns: The queued build, whose id get_build and get_build_log take.

Goes through: POST /v1/sites/{site_id}/builds

Changes something.

get_build ​

One build, or the recent builds: status, timings, and for a running build the step it is on.

parameter
site_idstring, requiredThe site whose builds are wanted.
build_idstring, optionalLeave it out for the most recent builds.

Returns: Status, timings, the commit it was made from, and the error if it failed. While it runs, the step it is on and how many there are; on one that failed, the step it was on when it stopped. withheld: files the build produced and the platform did not publish — a path starting with a dot, .well-known/ aside; remove them from the repository, and change any secret they held. held, on a site with an address: the names browsers were told to keep (a cache directory of _meta.json), with when each is free — new contents under one of them is refused, JTK_E_CACHED_FILE_CHANGED; give the new file a new name. design: how many of the template's design files (components, styles, layouts) are still byte for byte the scaffold's, of how many, and which — on a site whose design path is custom, advice JTK_W_TEMPLATE_DESIGN says it still wears the template's design: rewrite the hero, header, footer and sections from DESIGN.md, or tell the person it is the template adapted. next on the site's first good build: what to give the person, once.

Goes through: GET /v1/sites/{site_id}/builds

get_build_log ​

What the runner printed, in full — the only thing that says why a build failed.

parameter
site_idstring, requiredThe site the build belongs to.
build_idstring, requiredWhich build.

Returns: The whole log as text. Failures carry JTK_E_ codes; look them up in the error reference.

Goes through: GET /v1/sites/{site_id}/builds/{build_id}/log

get_built_page ​

A page as the platform built it — the HTML the runner wrote, annotations and all — so a build's result can be read rather than only its status; or, with shot, a picture of it as a visitor's browser draws it, so what was built can be seen and not only read.

parameter
site_idstring, requiredThe site whose build is read.
pathstring, optionalA page address (/, /prices/) or a file (/sitemap.xml). Empty is the home page.
build_idstring, optionalWhich build; empty is the one being served — the live build, or the last one on a demo. A shot is always of the served one.
shotstring, optionalphone (390 px wide) or desktop (1280 px) to get a picture of the page instead of its text; review for a design review of the home page — the first screen of every direction at both widths, what the platform reads of the design, and the questions to look at it by, before the person sees it. Empty reads the file.
formatstring, optionalWith shot: jpeg (the default, a fifth of the weight) or png (for thin lines).
directionstring, optionalWith shot: one of the directions the site shows the person (jtk/design.json directions, a letter a to e) — the page in that design. Empty is the default, the first.

Returns: The file's text and content type; truncated when it was longer than half a megabyte. Any text file of the build can be asked for by path: /sitemap.xml, /robots.txt, /llms.txt. With shot: the whole page as images — JPEG at a phone or desktop width, the full height in frames of 4000 pixels, each said with its pixels — rendered under a preview session with animations settled, beside a line saying what was shot — and, for the home page, JTK_W_FIRST_SCREEN where its heading or first action ends below the first screen. Look at it the way a person would: the fold on a phone, a block that is empty, a line that is cut, a form under the fold.

Goes through: GET /v1/sites/{site_id}/builds/{build_id}/file?path= — or, with shot, the served page rendered in a browser

publish ​

commit_and_build ​

Commit the draft into the site's repository as a version and build it. It does not make the site public — a launch is a person's act in the panel. Before the launch the build is what the preview shows, and this is how the first build is made; on a launched site the build is a candidate visitors do not see until a person publishes it. A commit moves the branch: bring your copy to it before your next change — git pull, or pull_code and its jtk pull where the code is on jtakeit (next says which). Pass dry_run to be told what a publish would change instead — it deletes documents the draft no longer has, and that is worth seeing first. A file browsers keep — under immutable or a cache directory — never changes under its name: new contents take a new name, or the build is refused. A save commits the whole draft, a person's unsaved edits in the panel included: while the draft holds any it is refused, JTK_E_THEIR_DRAFT, naming them — ask the person, then with_their_draft, or branch_only. While a kit job of the site runs — the schema job after write_files — it waits for it a while, then is refused, JTK_E_KIT_RUNNING. Called publish until 14 September 2026; the old name still answers. Where the chat shows apps, the preview get_preview_link put there follows the build by itself: do not call get_preview_link again to show it.

parameter
site_idstring, requiredThe site to commit and build.
dry_runboolean, optionalReport what publishing would change and change nothing. Worth doing whenever the repository may have moved.
with_their_draftboolean, optionalSave and build the person's unsaved changes in the panel with yours. Only after asking them, naming the changes JTK_E_THEIR_DRAFT listed: their half-done edits become a version.
branch_onlyboolean, optionalBuild the branch as it stands — your commits — and save nothing: the person's unsaved changes stay in the panel for them.

Returns: The version — its revision, the commit it was written as, whether anything moved, and files: what the commit added, rewrote and removed — the build queued for it, and next: what to do now, the pull included. On a contract-3 site a file whose content did not move keeps its bytes in the branch, whatever order its keys are in. When the branch already holds the draft nothing is committed — committed: false, files empty — and the branch's commit is built. When the branch held content the panel had not taken — a push over unsaved changes, a git push not imported — the save brings it in first under the draft, and synced says what it kept. With dry_run: what would be added, rewritten and deleted, changed when any of the three names a file, unpublished when the draft holds what the published version does not, pending when the branch holds content the save will bring in first, and whether it would be refused. person_changed names, by document and field, the person's unsaved changes the version carried (with_their_draft) or left unsaved (branch_only): tell them.

Goes through: POST /v1/sites/{site_id}/save; with dry_run, GET /v1/sites/{site_id}/publish-blast

Changes something.

preview ​

A link to look at the site, for a person to open when they get to the message: the preview and a test booking, nothing else. It never hands the site over — the owner's link does that, from the panel. The studio sees every link in the panel and can reset it. Give it from the start: before the first build it says the site is being built, and kept open it shows each new build by itself. Where the chat shows apps, the preview is also shown in the chat under the answer, as a real browser draws it, and it updates itself after every write and build: call this when the person asks to see the site or at a milestone — the first version, a new design — at most once in a reply, never after each write or build. In it the person picks a page, marks an area or taps a text and writes what to change — their notes come to you in get_site's notes.

parameter
site_idstring, requiredThe site to show.
labelstring, optionalWhom it is for, as the studio reads it in the panel's list: "Olena", "the client's partner".
daysinteger, optionalHow long it works: 1 to 30, 7 when left out.

Returns: The URL, when it stops working, and the label. Treat it as a credential: whoever holds it can see the preview until then.

Goes through: POST /v1/sites/{site_id}/look-link · POST /v1/sites/{site_id}/preview-widget

preview_page ​

The preview app's own tool, not yours: it never appears in your list where the chat shows apps. A page of the site as the owner sees it — the draft drawn live where the site draws live, else the latest build — pictured in a real browser with its scripts run and animations settled, with the boxes of every field on it, so the app in the chat shows the site 1:1 and knows which field a person marked. To look at a page yourself, use get_built_page with shot.

parameter
site_idstring, requiredThe site to picture.
pathstring, optionalThe page's address, from / — /, /preise/. Empty is the home page.
widthstring, optionaldesktop (1280 px, the default) or phone (390 px).
directionstring, optionalOne of the directions the site declares in jtk/design.json, by its key (a to e): the page asked as ?direction=<key>. Left out, the first, the site's own.

Returns: The page as JPEG frames of 4000 pixels, top to bottom, and in the structured answer its width and height, each frame's pixels, whether the draft or the build was drawn, and boxes: per element with data-jtk-path its path, kind and rectangle in page pixels, with its text, a picture's words and address, trimmed.

Goes through: POST /v1/sites/{site_id}/preview-ticket, the page rendered in a browser · POST /v1/sites/{site_id}/preview-widget

An MCP App's tool (_meta.ui.visibility: ["app"]): the preview in the chat calls it; a model does not.

content ​

get_content ​

Read a site's pages and what is in them — to check what a build will see. Read-only, always: content is edited in the admin and in the repository, never here. A dev session's id works here too, and answers what the panel draws in that session.

parameter
site_idstring, requiredThe site to read.
pathstring, optionalOne page's address, like "/" or "/about". Leave it out to list them all.

Returns: The pages, and one page's blocks when a path is named.

Goes through: GET /v1/sites/{site_id}/pages

list_entries ​

The entries of one collection — the posts, the works, the price list.

parameter
site_idstring, requiredThe site to read.
collectionstring, requiredThe collection's name, as its schema declares it.

Returns: Each entry's title, slug, path, language, whether it is visible, and show_at — the moment a shown entry appears, when it has one — and fields, its own values by key, without the keys the platform stores beside them (_key, type, v).

Goes through: GET /v1/sites/{site_id}/collections/{collection}/entries

import_branch ​

Read a branch of the site's repository back into the admin, so what you committed and what the owner sees are the same thing. Needed after content or a schema is committed and pushed to GitHub: until then the next save or publish writes over the commit. Code on jtakeit needs no separate import — push_code imports what it sends. While the panel holds unsaved changes, which are in no commit, a contract-3 site imports every document they do not touch and the branch's other fields of those they do; one where both changed a field waits for the next save (waited). A contract-2 site is refused with JTK_E_DRAFT_AHEAD: get_content reads them, and overwrite_draft discards them on purpose.

parameter
site_idstring, requiredThe site to import into.
refstring, optionalA branch, tag or commit. Empty takes the repository's default branch — the one every save writes to. A ref that branch does not hold is imported with a not_default warning: merge or fast-forward it into the default branch and push before commit_and_build, or the save compares the panel with the default branch instead.
overwrite_draftboolean, optionalWrite the branch over the panel's unsaved changes. Only with the owner's say-so: they are in no commit and nothing brings them back.

Returns: The commit read, how many pages it rewrote and created, the pages it took off because the branch no longer has them (removed: kept as deletions are, brought back from the panel), the pages it kept although the branch lacks them (extra: made in the panel and never saved, or with bookings ahead), and fields the schema no longer describes. A file keeps its page by its id: moved in git, it is the same page. Under unsaved changes: merged, waited (document → field) and says — tell the person.

Goes through: POST /v1/sites/{site_id}/import-branch

Changes something.

delivery ​

preflight ​

Everything somebody checks by hand before saying a site is finished, in one call: where the site is in its life and every step it still owes — a repository, a build, the diary's hours, who the business is, where enquiries, bookings and orders go, the payment, the launch — with whose step each one is; that the site has an icon, read out of the build (the scaffold's monogram passes and says to ask for the business's mark), and that the build carried no file the platform never publishes (a path starting with a dot — .env, .git/ — which came from the repository), and which names browsers keep and until when, that the prices its pages show have a currency, the site's own, whether a site on the custom design path still wears the template's design (JTK_W_TEMPLATE_DESIGN, advice that leaves ready as it is), and that what the owner fills in the shared text and no tap reaches — the contacts' name, street, phone — is drawn on the pages (contract 3, as jtk schema says it); then that the address answers, that search engines are not being told to stay away, that the form actually delivers — and, with try_booking, that the diary takes a booking — and, with try_order, that the shop takes an order and gives it back; and, on a site that takes bookings, that the server has walked a booking through the whole chain on the build published now (self_check).

parameter
site_idstring, requiredThe site to check.
send_real_enquiryboolean, optionalSend a real enquiry the client will see, rather than a probe the edge accepts and drops. For proving delivery to somebody watching.
notestring, optionalWhat a real enquiry says. Ignored unless send_real_enquiry is set.
try_bookingboolean, optionalBook a free slot through the site's own form and cancel it again, proving the diary end to end: the settings, the services, the availability, the booking and the cancellation. It books the first service a visitor can book — shown, in the site's own language, with a length and somebody who performs it. Booked in the shape the built form says it sends (data-sends on the data-booking form, one list separated by commas: data-sends="service,start,name,email"); a form that does not say fails as not checked. The form must also carry the hooks the kit's element reads (@jtakeit/kit/booking/hooks), and the fields this business's answer asks for — a party, a second date — or it fails before booking. Made under your session, so it is a test row the business never sees as a customer's, booked under an address on .invalid that no letter reaches, and the business is not told of it. Works before the launch, on the preview.
self_checkboolean, optionalHave the server walk a booking through the whole chain on the build published now, before the checks are read: booked as a visitor and checked against the kit's rule, confirmed, refused, moved by the owner, another time offered and accepted, «it suits», moved and cancelled by the customer, cancelled by the owner, the time freed — and every letter of it written by the code that sends it and read for holes, empty fields, another kind's words and the site's language. On rows nobody sees and nobody is told of, deleted when it ends. It does not check the form's script (try_booking does), a letter's delivery or the payment. Once a minute per site. A site that takes bookings is not ready until it has passed on the build published now: fix what it names, publish, run it again.
try_orderboolean, optionalCheck out one product through the shop's own addresses and give it back, proving the shop end to end: the cart priced again, the stock held, Stripe's test page opened on the sandbox, and the order lapsed and its stock given back by Stripe's own message. It picks a product a buyer can buy, and on a launched site never the last of a SKU. Made under your session, so it is a test order the business never sees. With VAT on, the parcel goes to the business's own address, and the test payment is taxed on the sandbox as a live one would be. Works before the launch, on the preview.

Returns: The phase (building, showing, live), every check with whether it passed, whose it is and what to do about it, and one ready for whether all of them did. A step that is not the agent's to do names the person whose it is — the studio's owner launches, the business opens its Stripe account, the client claims the site. On a site that takes bookings, ready waits for the self-check: passed on the build published now — not run, failed, could not be walked (no published build, no free time) or stale (a version published since) is not ready, with the reason. With self_check the walk's report comes back as self_check: its steps, each passed, failed, blocked or not_applicable, with why — no id, no token, no person. Beside the checks and never counted in ready, advice where there is any — JTK_W_LOCALE_FALLBACK when a site that takes bookings is in a language its letters are not written in, so they go out in English; JTK_W_KIND_MISSING when its bookings settings name no kind of business, so they speak a salon's words; JTK_W_PAYMENT_UNCHECKED when it takes money online, which the self-check never pays — tell the owner it was not checked.

Goes through: GET /v1/sites/{site_id}/setup, GET /v1/sites/{site_id}/readiness, GET /v1/sites/{site_id}/shared, GET /v1/sites/{site_id}/self-check (and POST, with self_check), the served build's pages and icon, and the site's own address; with try_order, the shop's addresses on it (/api/stock, /api/shipping, /api/checkout, /api/order) and POST /v1/sites/{site_id}/test-checkouts/expire

Changes something.

set_stock ​

Set how many of each SKU are on hand, for the SKUs that have not sold yet: a new shop's catalogue, or a range added later. A SKU that has sold is the owner's, corrected in the panel: it is left as it is and named.

parameter
site_idstring, requiredThe site whose shop to stock.
stockstring, requiredOne SKU a line: the SKU, a space, and how many are on hand — FOX-S-RED 3. At most 5,000 lines; a SKU is the same in any case.

Returns: How many were set; the SKUs left as they are because they have sold, with their count; and the SKUs set that no product the draft offers — a typo, or a product still hidden.

Goes through: PUT /v1/sites/{site_id}/stock

Changes something.

get_allowance ​

What the studio's plan holds and where it went: per kind, how many are bought, how many are on sites, how many are free — the answer to every refusal that says a line is missing.

Takes nothing.

Returns: One row per kind (base, bookings, commerce — the shop's) with have, spent and bought; which site holds which lines; and whether a plan exists at all. A refusal that names a kind is short of one of these — buying is under Reselling, and only a person may.

Goes through: GET /v1/account/entitlements

get_stats ​

A site's numbers, month by month: enquiries, visits and where the visits came from.

parameter
site_idstring, requiredThe site whose numbers are wanted.

Returns: One row per month with enquiries, visits, and the split by search, social, AI answers, direct and other. Counted on our servers without cookies; the studio and bots are not counted.

Goes through: GET /v1/sites/{site_id}/stats

local ​

open_dev_session ​

Make a working copy of a site so the panel shows the template on this machine, with the owner's real text in it, without pushing or building. Start the site's dev server first.

parameter
site_idstring, requiredThe site to make a working copy of.
originstring, optionalWhere the pages come from: http://localhost:<port> or http://127.0.0.1:<port>, the site's own dev server. Leave it out to work against a built candidate instead, which is slower by a build.

Returns: The session's id — which every other tool then takes in place of the site's — the address the panel will read from, when it expires, and how many pages it copied. And watch_key, shown this once, with run — the command to run in the working tree now, so the page on localhost shows where the site is and what the developer can do in the panel meanwhile — and tell, what to say to the developer.

Goes through: POST /v1/sites/{site_id}/dev-session

Changes something.

send_dev_schema ​

Tell a session what the working copy says the site is made of. Needed whenever the schema, jtk/schema.json (jtk/catalogue.json on a contract-2 site), changes: until then the panel draws yesterday's forms and refuses today's fields. The file goes through the same judge as validate_schema, and a refusal carries the same findings — so under a session there is no need to validate first: one paste, not two.

parameter
session_idstring, requiredThe session, from open_dev_session.
schemastring, requiredThe contents of jtk/schema.json (jtk/catalogue.json on a contract-2 site), as text.

Returns: What the forms will now be drawn from, so you can tell it took the file you meant.

Goes through: PUT /v1/dev-sessions/{session_id}/catalogue

Changes something.

get_dev_files ​

Read out what to commit. Anything typed into a session's content lives in the session — this is the way it reaches the repository, and the way is a commit you make.

parameter
session_idstring, requiredThe session, from open_dev_session.

Returns: Repository path to contents, at the paths a publish would have used. Write them into the working tree and read the diff before committing.

Goes through: GET /v1/dev-sessions/{session_id}/files

close_dev_session ​

Throw a working copy away. The site it copied is untouched — it never knew the session existed. Get anything worth keeping out with get_dev_files first.

parameter
session_idstring, requiredThe session to throw away.

Returns: That it is closed.

Goes through: DELETE /v1/dev-sessions/{session_id}

Changes something.