yaks.app

Create, patch or delete stored records (entities) and their named groups of fields (components) in one atomic transaction: the whole batch is accepted or refused.

Find stored records (entities) by filtering on their named groups of fields (components) and their properties.

Read one or more stored records (entities) by their unique string id (eid), each returned whole as its own bundle: a JSON object with entity: {eid} and every named group of fields (component) it has.

Read this store’s vocabulary (schema): each component is a named group of fields attached to an entity, a stored record; its properties are those fields.

Search indexed text by words and, where an embedding index is configured, by meaning.

Create another space, a group of apps sharing an address and membership, at <slug>.yaks.app, with the signed-in person as its owner.

Change a space's name or move it to another address.

Delete a space: it goes to the trash for 30 days.

Bring back a space that was deleted.

Connect this space to Stripe so its apps can take payments.

Create a new app, served at <space>.yaks.app/<slug>/.

Write the app's files (index.html and any css, js or images beside it), or list them, read one back, or delete one.

Run one command in your build sandbox for this space, a Linux container for what a browser cannot do on its own: compile something to WebAssembly, run a generator, minify an asset.

Wait for a command sandbox_shell left running in this space's build sandbox, by the process id its answer gave.

Stop a command sandbox_shell left running in this space's build sandbox, by the process id its answer gave, and return its exit code.

Read one file out of this space's build sandbox: a generated source, a build log, whatever the last command left behind.

Write one file inside this space's build sandbox: a Cargo.toml, a src/lib.rs, whatever the build needs.

Copy what the build produced into the app's draft: name the files in the sandbox (pkg/*.wasm, pkg/*.js) and each is written beside index.html under its own filename, as if app_files had written it.

Release the app's staged files as a version.

Write a data file the app already contains into the app's store, now.

List the newest 20 kept deploys, newest first, their dates and file changes, which version is live, and recorded pointer moves (from, to, when, by whom and through which session).

Move the live pointer to a kept version without minting a new version.

Put everything the app has saved back to how it was at a moment: the whole store, every row of it, as of that time.

Platform-admin only.

Show bounded table row counts and index names for an app's store.

List writes the named app's store still holds, including interrupted writes that a storage reset stopped.

Explicitly retry one interrupted or unreviewed write by its seq, after inspecting its body and fixing the cause of interruption.

Rename an app, move it to another address, or change who may use it.

Delete an app: it goes to the trash for 30 days.

Bring back an app that was deleted.

List unarchived error reports for the named app: what a page threw in someone's browser, what a request threw on the server, and what the platform reported.

What the person already has here: every app in every space of theirs, with its address, the email address it sends and receives at, the version it is at, how many errors are still open in it, which app is the space's front page, and what the month has cost against what the space is allowed.

The commands yaks apps declare, with the arguments each one accepts.

Run one of an app's own commands: name it and pass its arguments as args, exactly as commands lists them.

Serve a domain the person already owns, example.com instead of yourname.yaks.app.

How far a domain has come, and what it points at: the space, or one of its apps.

Stop serving at a domain, whether it served a space or one app.

Publish this app so anyone in any other space can install it by name.

Stop offering the app for install.

What other people have published here, newest first: the name to install by, what the app is, and which space it came from.

Take an app somebody published (app_published lists them) and make the person their own copy of it: their own address, their own data store, their own everything from the first byte.

Move an installed app to whatever version its publisher offers now.

Invite someone by email address, so they can change what an app holds: an editor writes and a viewer only reads; a space owner may also invite.

Remove a membership, or withdraw an invitation not yet accepted: pass an app slug to revoke its app-specific invitation, or omit app to revoke space-wide membership.

A short-lived token that signs the `yak` CLI in as this person: the same identity and exactly the same access they have here, never more.

Send feedback about yaks.app itself: this connector, its tools, its documentation, the way an app is built or served.

The guide, read here instead of fetched from the web.

What yaks.app is and what gets made here, in a paragraph: what works signed out, what signing in adds, and where to sign in.

Find an app somebody has already made and shown at https://yaks.app/gallery: a recipe box, a sign-up sheet, a tracker.

Return page-view counts for an app: the total over the last 30 days by default, and counts by page, referring site and country.

Give an app access to one connected connection its space already owns.

The name sandbox_shell was listed under: run cmd in this space's build sandbox, in cwd (default /workspace), for at most timeout seconds (default and maximum 240).

Give the app's worker a key it reads as env.NAME.

The names the app's worker reads as env.NAME from a connected key.

Stop the app's worker reading env.NAME.

Save a memory for the space: a sentence or a note kept for everyone working there and found again by what it is about.

The memories kept for the space, ranked against the words passed: what the person has said about how they want things done, and notes saved beside them.

Say that an app's worker calls an outside service with a key or a sign-in (an API key, a Google account): it makes a connection for the person to connect on the space's connections page, and no key ever passes through this tool or this chat.

The space's connections to outside services: each one's service, whether it is connected, and which apps use it by which env.NAME.

Make one retained builder output the take in use for its build and slot.

Build new bindings or ones whose own inputs changed.

Answer exactly one outer binding of any builder with an artifact already in this app's store.

Save what somebody said, in their own words, as a memory.

Find saved memories containing all the words in said, not necessarily as an exact phrase.

Say that an app needs an outside service: an integration by name, and the scopes it asks for.

The connections a space or a person owns, each with its integration, account, scopes and status (needed, connected or broken), and the links from each app that uses one.

Return one mail message in full: its headers, its body, and one-line summaries of the rest of its thread, with this message marked.

Write a reply threaded on one message and request that it be sent.

Create a mail message and request that it be sent.

Check that every received mail message has a sender.

Build bindings with new or changed inputs, independent of floor and staged.

Answer one binding's slot with an existing artifact, spending nothing.

Make one retained output the take in use for its build and slot, without a call or spending.

List an app's email records as bundles: JSON objects with entity ids, message text, mail headers and delivery fields when present.

Send one email from an app's own address to one recipient: an email address, or the unique id (eid) of a record in the app that has an email{address} field.