Skip to content

Jason 0.22.0

Choose a tag to compare

@ArtemKosolap ArtemKosolap released this 30 Oct 13:21
· 320 commits to main since this release
771ebf8

Jason 0.22.0: the runtime, the CLI and the plugin host, one self-contained executable per platform, built
at this version and released only after its tests passed.

What is new since 0.21.0

  • A send can wait for its moment. message.send and social_invitation.send take an optional send_after: the
    moment the message goes out after, with its offset, such as 2026-11-03T09:00:00-05:00. A moment without an offset
    is refused when the work item is written. The approval shows it, after send after:. A send's work item now
    succeeds once the provider has taken the send: its result's status is sent where the provider sent it within the
    call, and accepted where it took it, for now or for the moment named. Whether the message went is read afterwards,
    never from that item. A plugin that does not list send_after on the send's channel is never handed it: the claim
    refuses the work with argument_unsupported before anything runs, so a moment is never dropped and sent at once.
    Through Reply, a moment goes on an email or any LinkedIn message, an InMail and a voice message among them, and on a
    LinkedIn invitation.
  • A send the provider holds can be read and taken back. Two new operations, message.status and message.cancel,
    name a send by the work item that made it, {"send": "wi_…"}; the runtime supplies the reference the provider gave
    that send, so neither reaches a send another campaign or another route made. message.status answers queued,
    sent, cancelled, failed or unknown, the last for a send the provider attempted and lost track of, which may
    have gone; with it, when the send went, the message it became, and the provider's reason and code for a failure.
    message.cancel takes back a send still held; a second cancel succeeds as well, and a send that went or failed is
    refused with send_not_pending. A cancel runs in a paused campaign, as stopping is the protective half of the work.
    When a read finds a send gone, the chronicle says so once, as message_sent_observed; the campaign manager is woken
    by it only where Manager:Triggers lists it. Twenty-four operations are published now.
  • A send whose answer was lost is repeated only where that is safe. Until now such a send was final. A plugin that
    sends under the work item's key, and says so in its manifest's settles_by_key, may now be asked again: a provider
    that keeps the key answers a send it already took with that send, and sends nothing twice. The claim makes the repeat
    only under the package, the account and the arguments of the attempt that may have sent, and otherwise refuses it
    with provider_answer_lost, final, saying that an earlier attempt may have reached the person. Through Reply both
    sends are repeated this way within 23 hours of the first attempt that may have sent; past that, or where Reply
    cannot be asked, the repeat is send_not_settled and nothing is sent.
  • An email through Reply can be timed by one of the account's sending schedules. message.send takes, in the
    provider's own object, "provider": {"schedule_id": "<id>"}: the id of a schedule schedule.list names, written
    as a string of its digits. Reply holds the email for the schedule's next opening, or its first opening at or after
    send_after where both are given, and since Reply only estimates that moment the result's accepted_for is null.
    Any other shape of the object is refused before anything is called, with provider_input_invalid. A LinkedIn
    message cannot be timed this way, as the known issues below say. The
    Reply plugin's page says how.
  • Replies through Reply are read from Reply's change feed. One read per account lists the threads that moved, in
    place of walking every thread of every campaign page by page, once per cadence. The walk stays as the fallback, and
    takes an account back whenever its feed is not offered or stops answering; jason events sources shows each
    account's source and whether it is healthy. What the feed gives Jason is identifiers, moments and Reply's flags,
    never a subject, a preview or a name.
  • A LinkedIn message and an InMail can be templates the provider fills in, as an email already could.
    compose: template now covers a LinkedIn message's text and an InMail's subject and text. A plugin is handed a
    template only on a channel its manifest lists under templates; on any other channel the claim refuses it, with
    template_not_offered, before anything runs. The Reply plugin writes all three in Reply's syntax: the sender's
    first name and full name become Reply's LinkedIn variables, and sender.address is written in as the sending
    profile. A template naming sender.last_name, which Reply's LinkedIn account does not carry, is refused with
    template_unsupported, and a voice message stays a final text. You approve the template and its example, as for an
    email; the text as Reply filled it in is read afterwards from message.status, where Reply gives it. The copywriter
    and both planners now write a template for any of the three.
  • The macOS executable is signed with Reply's Developer ID and notarized by Apple. A browser-downloaded archive
    runs on its first start without Gatekeeper refusing it; that first start needs the network, as the section on what
    is signed below says. The Linux and Windows executables are not signed, and the checksum stays their only
    provenance.
  • This release publishes the Reply plugin 0.14.1, which needs reply-cli 0.17.2. Every call it makes tells Reply it
    came through Jason: reply-cli puts jason-harness/<version> at the front of its User-Agent, the runtime's version
    without its build metadata, and nothing that names the machine or the person. Where an account's Reply does not offer
    what a work item asks for, the plugin answers capability_not_offered: final, nothing done, and the manager skill
    takes it as a reason to do the work another way or tell you.
  • For plugin authors. Two codes are reserved beside every operation, and no document declares them:
    provider_input_invalid (validation), for a provider object the package cannot read, and capability_not_offered
    (permanent), for what the provider does not offer yet. Neither clears a provider block. The manifest takes three
    new keys at manifest_version 1: arguments, the channels each argument is taken on; settles_by_key; and
    templates. A runtime older than 0.22.0 refuses all three with unknown_field. Every operation document now names
    its channel_arguments and channel_templates, and the claim has twenty checks in one published order.
    The plugin guide and
    the contracts set them out.
  • The skills know the new answers. The campaign manager asks after one send and takes one back, reads the
    person's thread before any new send when a send is unknown, and treats capability_not_offered and
    template_not_offered as final; the troubleshooting skill tells apart a capability the provider does not offer, a
    provider object it refused, and a refusal of a send that may already have reached the person, which nobody repeats
    until the provider has said the earlier attempt did not act.

Upgrading from 0.21.0

  • The executable: jason update apply, or run the install line again. Installed with Homebrew, it is the three
    lines jason update apply prints instead: jason runtime stop, brew upgrade jason, jason runtime start. The
    install line and Homebrew place the executable alone, so after either, jason skills update, jason ui install
    and jason plugin install reply --replace follow.
  • The Reply plugin: with the package a release published installed as it came, 0.10.0 from 0.21.0,
    jason update apply replaces it with 0.14.1 and keeps the package it replaced under the data directory's
    update/previous/plugins/reply. A package edited on this
    machine is left as it is, and so is the package under the install line and Homebrew:
    jason plugin install reply --replace swaps it for 0.14.1. Until it is replaced, the old package under 0.22.0 has
    its email templates refused with template_not_offered at the claim, since it lists no templates, and offers none
    of message.status, message.cancel and send_after.
  • reply-cli 0.17.2 or newer: the Reply plugin 0.14.1 asks for it, and an older CLI makes the plugin unavailable
    with executable_incompatible, so work routed to it fails at the claim with plugin_unavailable and runs nothing.
    Update it with npm install -g reply-cli, then jason plugin reload.
  • The data directory: this release adds one database migration, an index that lets the chronicle say once that a
    send went. The first start on 0.22.0 runs it after taking a backup, as every migration does. Your projects,
    campaigns, work items and chronicle stay as they were.
  • What reads or is refused differently:
    • Through Reply, a send's work item ends with status accepted where Reply holds the send rather than sending it
      within the call. Both sent and accepted are done; neither is a reason to send again.
    • Through Reply, a message.send whose provider object is anything but {"schedule_id": "<id>"} is refused with
      provider_input_invalid before anything is called; the package 0.21.0 published, 0.10.0, ignored the object.
      The other operations still ignore it.
    • A template on a channel the routed plugin's manifest does not list under templates is refused with
      template_not_offered before anything runs.
  • Skills: the update redeploys them wherever a deployment was recorded; after the install line or
    brew upgrade jason, run jason skills update.

From 0.19.x and 0.20.x the same applies, and the update is one apply. From 0.18.x or earlier, Jason's own installation
updates through 0.19.0: jason update apply --version 0.19.0, then jason update apply; from a build older than
0.18.0, the first of the two can stop at started, as the first known issue below says.

Known issues

On a build older than 0.18.0, the update through 0.19.0 can stop at started, saying that a library failed to load.
That update is still performed by the older build, and it happens when the two builds carry different .NET patches.
Type jason update apply again: it runs 0.19.0, which finishes the update, and one more jason update apply then
takes the newest release. From 0.18.x this does not happen: 0.19.0 is built on the same .NET patch as 0.18.0.

Reply's routes behind this release's send features - a send's moment and its sending schedule, reading and cancelling
a send by its reference, and the inbox change feed - reach Reply's accounts on Reply's own schedule. Until an account's
Reply has a route, the Reply package answers capability_not_offered for that operation or argument, and the account's
replies are read thread by thread in place of the feed, as its README says; nothing in Jason needs updating when the
route arrives.

Through Reply, Jason sees only a contact's first reply. Reply marks a contact who replied as finished and stops
detecting that contact's later replies, so a later reply from the same contact never reaches Jason.

A send or an invitation through Reply carries no sending time in its own result: sent_at is null, because Reply's
answer to a LinkedIn send gives a local time marked as UTC and its answer to an email gives none. message.status
reports when a send went, and a message's own moment is read from its thread, where it is true UTC.

Through Reply, a sending schedule times an email only: Reply refuses a schedule on every LinkedIn direct send in this
version, so a LinkedIn message that names one is refused before anything is called, with provider_input_invalid.

The approval preview shows a send's send_after and not the provider object beside the arguments, so a send that also
names a sending schedule goes at the schedule's first opening at or after that moment, which may be later than the
moment the approver read.

A template held for a later moment, or queued by Reply behind the account's other sends, is filled in when it goes: a
name Reply cannot fill then fails the send after a person approved it, which message.status reads as failed with
Reply's reason.

Reply converts a LinkedIn text from HTML to text after filling it in, so markup in a LinkedIn message or InMail, a
final text or a template, does not reach the person as written; what Reply makes of a < that starts a tag there is
not known yet, and the Reply package does not refuse one on LinkedIn as it does on email.

Reply does not consult its blacklist when it takes a LinkedIn direct send, and does when it makes it: a send to a
person its blacklist holds is accepted, and fails when Reply makes it, which message.status reads as failed with
Reply's reason. Jason's own do-not-contact register is checked at the claim as before; record such a stop there with
jason suppression add as well, so the send is refused before it is made.

Through Reply, schedule.list does not say which campaign runs on which schedule: campaign.get names no schedule,
so which one a campaign sends on is read at Reply.

Through Reply, a reply on a thread, conversation.reply, is not held to the rule on a < that starts a tag yet, and
its text goes as written; whether Reply cuts a reply as it cuts a direct email has not been seen, so write an address
in a reply without its angle brackets.

Assets

File For
jason-win-x64.zip Windows on x64
jason-linux-x64.tar.gz Linux on x64
jason-osx-arm64.tar.gz macOS on Apple silicon
manifest.json what a running Jason reads to learn that this release exists
checksums.txt the SHA-256 of each archive and of the two packages, in sha256sum format
install.sh macOS and Linux: the install script this release was published with
install.ps1 Windows: the install script this release was published with
jason-plugin-reply.zip the Reply plugin's package: the files of plugins/reply at v0.22.0, which jason plugin install reply places in ~/.jason/plugins/reply
jason-ui.zip the browser UI's package: ui/ built at v0.22.0, which jason ui install places as the default UI

Each archive holds the executable, LICENSE (the runtime's licence; the repository's MIT does not cover the
runtime) and THIRD-PARTY-NOTICES, nothing else. The Reply plugin's package is installed by
jason plugin install reply, which places it in ~/.jason/plugins/reply once it matches its line in
checksums.txt and the manifest's content digest; step 3 of docs/golden-path.md runs it. The UI's package is
placed by jason ui install, which the install guide runs and jason update apply runs at its end.
On Linux the executable needs the ICU library (libicu), which desktop distributions carry and minimal
images may not; the install script stops, with the runtime's own message, rather than install a program that does
not start.

Installing

One line, on macOS and Linux:

curl -fsSL https://jasonharness.ai/releases/latest/download/install.sh | sh

and on Windows, in PowerShell:

irm https://jasonharness.ai/releases/latest/download/install.ps1 | iex

By installing Jason you accept the Jason Runtime Licence:
https://github.com/reply-team/jason-ai/blob/v0.22.0/LICENSE-RUNTIME.md. If you do not accept it, do not
install Jason.

Both find this machine's archive, check it against checksums.txt before unpacking, and put jason on the
PATH — in ~/.local/bin, or %LOCALAPPDATA%\Programs\jason — with its licence and the third-party notices
beside it, as jason-LICENSE and jason-THIRD-PARTY-NOTICES. Running the line again over an installed Jason of
the same version changes nothing and says so, unless a licence file is missing beside the executable, which it
then writes. Two options, for a script that must be told:

curl -fsSL https://jasonharness.ai/releases/download/v0.22.0/install.sh | sh -s -- --version 0.22.0 --no-modify-path
& ([scriptblock]::Create((irm https://jasonharness.ai/releases/download/v0.22.0/install.ps1))) -Version 0.22.0 -NoModifyPath

Upgrading from 0.1.0

If this machine ran 0.1.0 with autostart enabled, run jason runtime autostart enable or disable once from an
ordinary prompt — if that answers Access is denied, follow its message first — then jason runtime stop once, then
jason runtime start (or sign in again, with autostart enabled). 0.1.0's logon task started a runtime that outlives a
sign-out and holds the data directory; until it stops, the runtime this version starts at sign-in finds the directory
taken and exits.

Checking a download by hand

sha256sum --check --ignore-missing checksums.txt

On Windows, compare Get-FileHash of the archive with its line in checksums.txt.

If you then put the executable in place by hand, keep LICENSE and THIRD-PARTY-NOTICES beside it, named
jason-LICENSE and jason-THIRD-PARTY-NOTICES.

What is signed

The macOS executable is signed with Reply's Developer ID and notarized by Apple. The quarantine flag is put there
by the browser that downloaded the file, not by curl, so the one-liner's download has none and install.sh
clears nothing; an archive fetched with a browser and unpacked by hand keeps the flag, and Gatekeeper checks the
notarization with Apple, online, the first time the executable runs. The ticket is not stapled to the file, which a
bare executable has no place for, so that first run needs the network.

Who signed it is yours to read: codesign -dv --verbose=2 on the unpacked executable prints an
Authority=Developer ID Application: line naming Reply and its team id in parentheses, the same id the
TeamIdentifier= line gives. Gatekeeper accepts any notarized Developer ID, so it is that name and that team id, not
the acceptance, that say the executable is Reply's.

The Linux and Windows executables are not signed, and nothing else a release carries is either. On Windows, an
archive a browser downloaded carries the mark of the web, and the executable unpacked from it is stopped by
SmartScreen the first time it runs: install.ps1 clears that mark from what it unpacks.

Both scripts check the archive against checksums.txt before unpacking. On Linux and Windows that check is the only
provenance there is; on macOS the signature says who built the executable as well.