Repository navigation
Jason 0.24.0
Jason 0.24.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.23.0
- This is the first release built and published by this repository. Until now Jason was developed in a private
repository, and each release published a copy of its open part here. From 0.24.0 this repository holds the whole
product, the runtime's source included, with its history, and a tag pushed here builds, signs and publishes its
release at once. Issues and Discussions are open. A commit made before 0.24.0 whose subject ends in "(#N)" names a pull
request of the repository Jason was developed in until now, and the tagsv0.1.0tov0.23.0point at snapshots of
what was published here at those versions; the development guide says both. - The runtime is released under the MIT licence, like everything else here. The repository, its history
included, is MIT from 0.24.0, and every archive carries thatLICENSEbeside the executable and the
third-party notices. The source of every earlier version is MIT as well, since the history is, and the licence files
in older trees are superseded; the archives published before 0.24.0 carry the licence they were published with,
which the install scripts still print for 0.6.0 to 0.23.x. What the earlier
licence said about what the runtime sends off a machine and what stays your responsibility is kept, in its words and
as statements about the product rather than terms to accept, on a page of its own. - The C# runtime now lives under
dotnet/, so that the repository's root stays free for the port of the runtime to
Rust, which will be developed here. The move changes no behaviour: the executable a release builds is the one it was.
Until the port is complete, the C# runtime is the one released. - The product's address is
get.jasonharness.ai. The install lines, the update check and every download of this
release use it. An installation from 0.7.0 to 0.23.x keeps updating through the earlier address, which still
redirects the same paths; one older than 0.7.0 asks GitHub directly. The release and update page says which address each
installation asks. - A problem reaches an issue with the file
jason doctorwrote. The repository has an issue form for a problem.
After a plainjason doctorwrites its file, it prints the form's address, with the version and the platform filled
in: in its result asproblem_report_url, on stderr, and with--humanon a line of its own. Opening the issue and
attaching the file is yours to do, and nothing is sent. Because that file may now go to a public issue, a default
file names nothing you chose by its own name. A plugin, role or skill pack Jason does not ship travels as an alias,
such as<plugin-1>,<role-1>or<skill-pack-1>, one per name. As the home directory is~, the harness root is
written as<harness_root>, a data directory other than~/.jasonas<data>, and the executable's folder outside
the home directory as<install_dir>unless a package manager's prefix holds it. A skill source other than this
repository is<skill-source>, and so is its ref unless that is a release tag. A file made with--include-journal,
which carries what the journal's entries say, names no issue form: itsproblem_report_urlis empty, and its warnings
say it goes only to the support address under Getting help, never to an issue. Getting help and the contributing page
say where each kind of message goes; the troubleshooting skill offers a person the form's address and leaves opening
the issue to them.
Upgrading from 0.23.0
- Nothing changes for an installation. The update path, the feed and the commands are as they were, and this release
adds no database migration: your projects, campaigns, work items and chronicle stay as they were. Run
jason update apply, or the install line again; installed with Homebrew,jason update applyprints the three lines
to run instead. The install line and Homebrew place the executable alone, so after either,jason skills update,
jason ui installandjason plugin install reply --replacefollow. - The licence beside the executable becomes MIT.
jason update applyand the install line replace the executable's
notice files,jason-LICENSEandjason-THIRD-PARTY-NOTICES, with this release's. Each install script ends with the
licence line of the version it installed: MIT for 0.24.0 and later, and for 0.6.0 to 0.23.x the earlier licence, with
the link to that tag's file. - The Reply plugin is published as 0.14.3, the package 0.23.0 published, and it needs reply-cli 0.18.0 or newer.
From 0.22.0,jason update applyreplaces the package as it came and keeps the one it replaced under the data
directory'supdate/previous/plugins/reply; a package edited on this machine is left as it is, and
jason plugin install reply --replaceswaps it. Under reply-cli 0.17.2 or older the plugin isunavailablewith
executable_incompatible, and work routed to it fails at the claim withplugin_unavailable; update reply-cli with
npm install -g reply-cli, then runjason plugin reload. - Should the old address ever stop redirecting, one act moves an installation from 0.7.0 to 0.23.x:
jason update apply --feed https://get.jasonharness.ai/releases/latest/download/manifest.json, or a reinstall with
the current one-liner. The executable that arrives asksget.jasonharness.aifrom then on.Update:FeedUrlalone
moves only the running runtime's own check, notjason update,jason ui installorjason plugin install. - From 0.22.x or earlier, the notes of each release in between apply as well. From 0.18.x or earlier, Jason's own
installation updates through 0.19.0:jason update apply --version 0.19.0, thenjason update apply; from a build
older than 0.18.0, the first of the two can stop atstarted, 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 0.22.0'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 a LinkedIn message only once the account's Reply times deferred LinkedIn sends
itself. Until then the Reply package answers a LinkedIn message that names one capability_not_offered, and nothing is
sent, whether the account's Reply has no direct sends yet or has them without a schedule on LinkedIn.
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.24.0, which jason plugin install reply places in ~/.jason/plugins/reply |
jason-ui.zip |
the browser UI's package: ui/ built at v0.24.0, which jason ui install places as the default UI |
Each archive holds the executable, LICENSE (the MIT licence, which covers the whole repository, the runtime
included) 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://get.jasonharness.ai/releases/latest/download/install.sh | shand on Windows, in PowerShell:
irm https://get.jasonharness.ai/releases/latest/download/install.ps1 | iexJason is released under the MIT licence: https://github.com/reply-team/jason-ai/blob/v0.24.0/LICENSE.
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://get.jasonharness.ai/releases/download/v0.24.0/install.sh | sh -s -- --version 0.24.0 --no-modify-path& ([scriptblock]::Create((irm https://get.jasonharness.ai/releases/download/v0.24.0/install.ps1))) -Version 0.24.0 -NoModifyPathUpgrading 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.txtOn 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. Before anything is published, the
release's macOS job has spctl assess the executable's signature and stops unless that signature is accepted from the
source Notarized Developer ID; the same job starts a copy carrying the quarantine flag a browser puts on a download,
and its log says whether that copy started and opened its database. The ticket is not stapled to the file, which a
bare executable has no place for; for a file without a stapled ticket, Apple's documentation says Gatekeeper finds the
ticket online. 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.
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. spctl accepts the signature of any notarized Developer ID from the source
Notarized Developer ID, so it is that name and that team id, not the acceptance, that say the executable is Reply's.
The one native library the executable carries, libe_sqlite3.dylib, is signed with the same Developer ID and
timestamped before it is bundled; the executable unpacks it under ~/.net/jason/ the first time it runs, and
codesign -dv --verbose=2 on it prints the same Authority= and TeamIdentifier= lines. So the executable keeps the
hardened runtime's library validation, which loads only a library signed by Apple or by the executable's own team, and
it ignores DYLD_ environment variables: the only entitlements it carries, com.apple.security.cs.allow-jit and
com.apple.security.cs.allow-unsigned-executable-memory, let the .NET runtime compile code as it runs.
The Windows executable is signed with Reply's certificate through Azure Artifact Signing, and timestamped under
RFC 3161, so the signature stays valid after the certificate expires. Who signed it is yours to read, in Windows
PowerShell or PowerShell alike: Get-AuthenticodeSignature on the unpacked executable says Valid, and, run where it
was unpacked, (Get-AuthenticodeSignature .\jason.exe).SignerCertificate.Subject prints the subject the certificate
is issued to, which begins CN=ReplyApp Inc.; signtool verify /pa /v, where the Windows SDK is installed, accepts it
and prints the timestamp. An archive a browser downloaded carries the mark of the web, and
SmartScreen looks at the executable unpacked from it the first time it runs. SmartScreen's reputation for a new
publisher builds over downloads, so in the first weeks of signed releases a download may still show its dialog;
install.ps1 clears that mark from what it unpacks.
The Linux executable is not signed, and nothing else a release carries is either.
Both scripts check the archive against checksums.txt before unpacking. On Linux that check is the only provenance
there is; on macOS and Windows the signature says who built the executable as well.