Also cleans up the POST interface in general. No more paths in the URL,
all relevant details go into the json now.
Renames /~link/add to /~link/save to match the +action tag.
As such, format for /~link/save is:
{path: '/some/group', title: 'Some title', url: 'https://urbit.org/'}
Format for /~link/note is:
{path: '/some/group', url: 'https://urbit.org', udon: 'This is cool.'}
If we receive the naxplanation before the nack, the assertion in the gte
direction fails. The intent of the assertion is to make sure top of the
live queue never falls behind current.state, so it was simply in the
wrong direction.
Fixes a bug introduced in 4798b9d.
This, uh, fell into the same old case of using an arm from a |_ without
initializing that core with a sample first. In this case, that resulted
in the bowl in connect being the default bowl here. This is fine for
~zod, since it's the default ship, but gives incorrect behavior for
anyone else.
Pretty simple really, fixes issue #2131.
Decided to use padding instead of margin because the underflow is nice,
but not at the detriment of being able to see the last chat preview
Instead of providing a (unit path), allows for (list path), which better
supports the "update to path and subpath cases".
For example, if /things wants updates about everything, and
/things/specific wants updates about the specific thing, they'll both
need to receive a %fact when the specific thing changes.
Previously, these would have been two separate moves. Now, gall handles
the multi-targeting for you.
Previously, it would always produce ~, regardless of the path asked
about.
Now, it produces a loobean, based on whether or not a file exists at the
specified path.
Add a regex check for non-lowercase, non-slash, non-hyphen characters,
or numerals, and a quick check for starts-with-slashes, double-slashes,
to a boolean before creating a chat at that path.
Two bugs fixed here: first, if the %done reentrancy triggered another
%boon, that wasn't getting translated to a %lost, even though it could
have been the reason the event crashed in the first place.
Second, the %done reentrancy needs to happen after we emit our move, so
that we don't invert the order of the %boon's we produce.
OTAs commonly end up in an inconsistent state if apps depend on changes
to /sys. For example, the %sift changes break on OTA because %spider
needs to be reloaded so that it's aware of the new thread type. This
adds a %goad app, which reloads all apps after every change to /sys.
Getting this to start OTA is nontrivial, but this pattern should work
for apps in the future. The changes to clock shouldn't generally be
necessary; they are only necessary here because we can't rely on hood to
start goad, since hood fails to compile if it's run before zuse is
reloaded. Once goad is active, this will cease to be a problem.
Renamed to eth-sender. Can still sign eth-txs at multiple gas prices,
fan transactions to multiple nodes, wait for confirmation between
transaction batches (now of user-specified size).
The previous nonce reading implementation was broken beyond belief and
has been taken out. Can be reimplemented once RLP decoding is in the
stdlib.
This fixes +put:in so that it works without the correct jet. There's a
mismatch where the hoon code is wrong and the jet is correct, so that
when we try to run this on alternate interpreters which may not have the
+in jets, things won't work.
This resolves a number of issues that were keeping communications with
foreign ships from working.
- there was no link-update mark
- there was no +on-arvo handling in link-listen-hook
- link-listen-hook was subscribing to the non-existent "link-hook"
- link-proxy-hook permission check was looking at a wrong path
Also makes link-listen-hook aware that subscriptions might get rejected
because of permissions, so that it ignores failed subscriptions instead
of being loud about it.
link-server-hook exposes (parts of) the link-store over eyre, on the
condition that the client is authenticated as the host ship.
link-webext as committed is a very minimal web extension. When its
toolbar button is clicked, it saves the current webpage to /private
in the link-store.
In the future, this should support choosing a target to save to,
highlighting already-saved pages, and many other features.
Stores URLs and their titles for the local ship. Can listen to
"submissions" on foreign ships.
Has a primitive perspective on groups, treating them as
always-interesting. Auto-subscribes to all ships in all groups.
Foreign communications untested.
Largely one-to-one port feature-wise.
Support for document polls was added.
Command preparation and verification got split out into
/ted/claz/prep-command, and got a dedicated +prep-result type to
facilitate future support for more complex preparation steps.
%leave over the network didn't work because we included the message type
in the wire from gall, so the duct for the initial %watch and the %leave
were different. We need to know the message type so we can route the
acknowledgment as %poke-ack, %watch-ack, or no-op.
This moves this piece of information to a piece of state, where we queue
up the message types per [duct wire]. Ames guarantees that
acknowledgments will come in order.
This also includes an easy state adapter. The more interesting part of
the upgrade is that we likely have outstanding subscriptions with the
old wire format. The disadvantage of storing information in wires is
that it can't be upgraded in +load. So, here we listen for updates on
the old wire format, and when we get them we kill the old subscription,
so that it will be recreated with the new wire format.
As an aside, this is a good example of what we mean when we say
subscriptions may be killed at any time, so apps must handle this case.
Finally, this fixes the "attributing" ship to ~zod for agent requests.
This information was ignored for agent requests, but including it causes
spurious duct mismatches.
We've seen issues where the message-num of the head of live.state is
less than current.state. When this happens, we continually try to
resend message n-1, but we throw away any acknowledgment for n-1 because
current.state is already n. This halts progress on that flow.
We don't know what causes us to get in this bad state, so this adds an
assert to the packet pump that we're in a good state, run every time
the packet pump is run. When this crashes, we can turn on |ames-verb
and hopefully identify the cause.
This also adds logic to +on-wake in the packet pump to not try to resend
any messages that have already been acknowledged. This is just to
rescue ships that currently have these stuck flows.
(Incidentally, I'd love to have a rr-style debugger for stuff like this.
Just run a command that says "replay my event log watching for this
specific condition and then stop and let me poke around".)
Turns out this wasn't a regression, it was intended behavior. I
continue to believe it's the wrong behavior, but that will require a
longer discussion.
* origin/chat-safe-tab:
chat: give terminal bell on tab in an empty buffer
chat: don't crash on tab in an empty buffer
Signed-off-by: Jared Tobin <jared@tlon.io>
The placement of the buttons and chat title on Landscape were slightly
off-line with each other. This commit lines them up
and changes font size to f8 to match the mockup closely.
This is why basically all packets are going through the galaxies right
now. Most of the time, the flow right now is:
* talking to ~dopzod but don't know where it is, so ask ~zod to forward,
which it does
* ~dopzod responds both directly (on the origin lane) and through ~zod
* (if NAT, the direct response doesn't get back, but the one through
~zod does. Then you respond directly to ~dopzod because their lane
piggybacked on the response. ~dopzod responds both directly and
through ~zod, and the story picks up the same as if you weren't behind a
NAT)
* now you have a direct lane to ~dopzod, so all is well.
* now the duplicate response from ~dopzod through ~zod comes in (takes a
little longer because it's bouncing off ~zod), resetting your lane to
"provisional"
* since your lane is provisional, you send your next packet both
directly and through ~zod
* GOTO 2
This change says "if I already have a direct lane, don't overwrite it
with a provisional one". This way, the only way the direct lane can be
overwritten is if they stop responding on it (cleared on "not
responding; still trying").
I also added |- to +send-blob to make |ames-verb %rot less confusing.
This changes sole.js to handle cursor behaviour for tabbing.
It does so by overriding the cursor position in transpose if it's greater
than it expects. This could produce errant results if other sole apps
use insert behind text, but that seems like an edge case. Flagged for
future with a comment.
If you clicked in the input field, the cursor would stay where it was.
This adds the cursor as a way of controlling the component, fixing the behaviour.
We were calling it directly, rather than through the (initialized) tc core,
causing the bowl in its context to be the *bowl, resulting in [~zod /] audience.
The old version of ping hung when your sponsor breached while you had an
outstanding poke. I believe it would do the same if your sponsor
changed and the old sponsor didn't respond to you.
This explicitly subscribes to Jael for updates to our sponsorship tree,
and kicks the pings of any ships that change rift and any changed
sponsors.
Sending a %code letter without output would cause its code to be evaluated on
the recipients' ships. While that shouldn't naturally occur post-#2009, and
evaluation of %code letters remains virtualized, it's still remote code
execution, and worth fixing as such.
Previous implementation was doing double virtualization, which gave issues
around scries. By reimplementing with mint and mock, we get to catch all
possible failure cases and produce an appropriate output for each.
Changes to the structure stylistically during code review.
Using fake API calls instead of directly calling store;
fixing a 'delete' crash';
making common code a component;
autofocusing responsively.
The behaviour of $tab sole-effects lacked a 'tab' key, so Soto wasn't
catching or writing them to the screen. This commit amends both the
handler and the sole-effect to fix that behaviour.
Compare +mute and +mule. Those pass through scry, which doesn't allow us to
catch crashes due to blocking scry. If you intercept scry, you can't preserve
the type polymorphically. By monomorphizing, we are able to do so safely.
The keypress handler would check if backspace was past position 0
before deleting one character at that position. If you were at position
0, then it would drop down to the 'else' and send the key value as a
string, throwing off the state between front and back end. This commit
fixes the issue, ignoring Backspace at position 0.
Compare +mute and +mule. Those pass through scry, which doesn't allow us to
catch crashes due to blocking scry. If you intercept scry, you can't preserve
the type polymorphically. By monomorphizing, we are able to do so safely.
This commit redesigns the front-end of chat-view for
Landscape, adding a collapsable sidebar, popout chats,
a streamlined join flow, and a general refresh of the Indigo
interface.
This broke when %kick was handled by resubscribing on your own ship
because it processed the %kick before the %leave. For example, `@t`404
at the dojo would put the dojo in an unworkable state.
You want the %leave to be processed first because you can't do a
"resubscribe" in response to that.
Since Soto is the name of the relay, its location in Landscape should be
the application it relays to: Dojo. This commit amends the mount paths
and source paths accordingly.
* chat-history:
chat: added temporary chat-two-update mark with new %messages type
chat: oust correctness fix and js style fix
chat-store: factored out functions used in both message and messages
chat: style fixes
chat: fixes to cli parser and increased page size in hook
chat-js: updated to support %messages events
sur: added rw-security to replace chat-security
chat: add history functionality. optionally request backlog.
Signed-off-by: Jared Tobin <jared@tlon.io>
Immediately useful for implemeting json `@rd` parsing, which is basically
`++royl-rd` minus pfix sig. The increased separation also allows for running
stuff like `(rash '3.22e-47' royl-rn:so)` from the dojo.
Immediately useful for implemeting json `@rd` parsing, which is basically
`++royl-rd` minus pfix sig. The increased separation also allows for running
stuff like `(rash '3.22e-47' royl-rn:so)` from the dojo.
* liam-fitzgerald/lang-server-commit:
language-server: fix cord reverse
language-server: use modern tisfas syntax
language-server: add function signature on hover
language-server: added autocommit on save
Signed-off-by: Jared Tobin <jared@tlon.io>
This adds syntax for running imps. For example:
-time ~s1
Runs the "time" imp with the argument ~s1. This blocks the terminal
until the imp has completed (backspace kills it, of course). You could
avoid blocking the terminal if you sacrifice the ability to use imps as
sources in more complex commands.
In keeping with this one-and-done view of imps, this also changes spider
to not use a live build of imps. This significantly reduces the amount
of uncertainty around imps -- spider will try exactly once to run your
imp, and if it fails it'll tell you. If you want to retry, that's up to
you.
Returns the target %zuse contract configuration to mainnet, and also
tweaks the 'arvo-ropsten' build to use %alef instead of %ames.
Also fixes a merge conflict artifact in nix/ops/default.nix.
Our mark definitions for sole actions and effects pre-date our tab
completion work. This commit adds tab completion actions and
effects to the definition, so they can be sent and received as JSON.
This removes the %http-response special case from gall. In its place,
we implement a subscription regime with the following steps:
- Agent sends %connect to Eyre
- Eyre pokes agent with %handle-http-response, including unique eyre-id
- Agent passes %start-watching to Eyre with eyre-id and unique app-id
- Eyre subscribes to agent on /http-response/app-id
- Agent produces a %http-response-header fact followed by 0 or more
%http-response-data facts and possibly a %http-response-cancel fact
- Agent produces a %kick to close the subscription, which Eyre
interprets as completion of the message.
This works when there is data. There is currently a bug where if the
response has no data in total (as in the case of a naked 404), no
response will be sent.
This also includes lib/http-handler, which implements a convenient
interface for agents that want to respond immediately with all the data.
This lets them avoid carrying extra state to keep track of pending
requests.
This should really have access to your state and the ability to change
it. Perhaps a more minimalist design would be better: just keep track
of the requests, then hand it off to +on-watch when eyre is ready to
receive responses. It's not clear how to pass in the request data in
+on-watch.
For some reason Jael subscriptions aren't starting properly for many
people. Until we can get to the bottom of it, this sets everyone to
start listening directly to the chain.
This augments permission management with invite sending, when setting "positive"
permissions. This matches talk's behavior.
Also implements +full:tr, which renders as ~ship/path, even for local targets.
Allows language-server to commit automatically upon changes. This
is driven by the editor, preventing the autocommit issues seen
with #971. Additionally recalculates syntax issues upon save.
This extends `gol` "backward-inference" typechecking to thread through
cores. Recall that `gol` is used exclusively for receiving more
specific error messages; these changes should have no effect on programs
which already compile successfully.
Before, this would type-fail on the second `|%`.
```
!:
^+ ^?
|%
++ foo *@ud
--
|%
++ foo
?: =(1 1)
2
%foo
--
```
With these changes, it gives a mint-nice at `%foo`. It will also give
you explicit errors if you have the wrong number/names of arms,
including which arms it expects.
This is becoming much more important with static gall, since it's the
first time we've used core subtyping so extensively and in userspace.
This extends `gol` "backward-inference" typechecking to thread through cores. Recall that `gol` is used exclusively for receiving more specific error messages; these changes should have no effect on programs which already compile successfully.
Before, this would type-fail on the second `|%`.
```
!:
^+ ^?
|%
++ foo *@ud
--
|%
++ foo
?: =(1 1)
2
%foo
--
```
With these changes, it gives a mint-nice at `%foo`. It will also give you explicit errors if you have the wrong number/names of arms, including which arms it expects.
This is becoming much more important with static gall, since it's the first time we've used core subtyping so extensively and in userspace.
We were updating our state and then using that when checking if the rift
had incremented. This would never be true, since we'd already set the
new state.
Fixes#1852 again
* origin/invite-app:
chat-hook: upgrade from old state and perform invitatory creation and subscription
invite-hook: crash upon invalid invite received
changed invite peek interface to /:path/:uid
invite: add comments and clean up
chat-js: added invite functionality
chat-hook: added invite functionality
app: added invite app and mark converters to JSON
Signed-off-by: Jared Tobin <jared@tlon.io>
* eth-watcher-2: (21 commits)
eth: move existing chain requests into ethio
eth-watcher: refactor refresh rate to top of file
hook: add pool-group-hook for making invite groups
ethio: add +read-contract for chain state reading
zuse: add delegated-sending address
eth: move eth-watcher's request-rpc into ethio lib
gaze: make compile for latest eth-watcher
drum: start eth-watcher on boot
azimuth-tracker: remove deprecated generator
eth: implement azimuth-tracker using eth-watcher
eth-watcher: ensure logs always sent oldest-first
eth-watcher: allow peers to unconfigured watchdogs
eth-watcher: saner %watch behavior
eth-watcher: implement %clear poke
eth-watcher: store logs in state to implement peer
eth-watcher: move types into /sur file
eth-watcher: properly tag out-peer-data
eth-watcher: single update timer loop
eth-watcher: implement /block peek
eth: turn azimuth-tracker into eth-watcher
...
Signed-off-by: Jared Tobin <jared@tlon.io>
Handle multiple files by keeping a map of text buffers. Also use the
Ford parser so we can parse ford runes. At some point we should load in
libraries when that happens so we have the appropriate types.
This corresponds to hoon-language-server 0.1.1
A simple language server engine, for use with hoonls.py, which presents
the RPC interface expected by editors. Features:
- Syntax error detection
- Rune snippets
- Autocomplete
* philip/tab-complete:
auto: gain and lose types on ?:
auto: handle tab in middle of symbol
auto: support forks
auto: support autocomplete inside wings
auto: fix some crashes on strange wet gates
auto: support multiline tab completion
auto: don't look in context of non-gold cores
easy-print: don't crash if type-check crashes
dojo, drum: change %tab sole-effect to use tanks
dojo, auto: move insert-magic logic to lib/auto
dojo, drum: give tab completion as true output
dojo: add a better function printer
dojo: add tab completion
Signed-off-by: Jared Tobin <jared@tlon.io>
The link used here resolves with a 301 to the proper page for messaging usage, but not actually the 'messaging' section of that page. This commit provides a more direct link to the exact instructions.
This changes the entry-points in lib/auto so that clients never have to
handle magic-spoon. You can specify either a tape of code with a
position index or a preparsed hoon (presumably you ran +insert-magic
before parsing).
This stops slogging the tab completion and intead adds a +sole-effect
for tab completion output. This is morally correct, and it lets dojo
clients show tab completions how they want. For example, web dojo could
implement this as a drop-down box.
Another advantage is that this puts the rendering logic in drum, which
knows the width of the terminal. Thus, we can make sure each match
takes no more than one line by truncating with ellipses. If there's
only one match and it's already fully typed, then we display the whole
type.
It's useful to know what a function takes and produces, so this changes the autocomplete type prettyprinter to emphasize those. This also gives a nice syntax for molds. Examples:
```
-----
add {a/@ b/@} -> @
~zod:dojo> add
-----
term * -> @tas
~zod:dojo> term
-----
sign-transaction {tx/{nonce/@ud gas-price/@ud gas/@ud to/@ux value/@ud data/@ux chain-id/@ux} pk/@} -> @ux
~zod:dojo> sign-transaction🔑ethereum
-----
wind {a/(* -> *) b/(* -> *)} -> * -> ?({$give p/*} {$pass p// q/*} {$slip p/*})
~zod:dojo> wind
```
This is initial support for type-aware tab completion. When you hit tab, it tries to complete the word you're in the middle of using a face or arm in the subject at that point in the code. It also shows all possible matches and their associated types. It's nearly instantaneous. Notes:
- It advances to the longest common prefix, so if you hit tab on `ab` and the only possible results are `abcde` and `abcdz`, then it'll write `abcd` and print both out (with their types).
- If there are fewer than ten matches, it prints the type along with the face. Printing types is too slow to use all the time, but with 10 it's essentially instantaneous.
- The match closest in the subject to you (i.e. smallest axis number) is displayed lowest (closest to your focus).
Examples below, where `<TAB>` represents me hitting tab while my cursor is at that position (the line with the `<TAB>` is not preserved in the actual output).
```
~zod:dojo> eth<TAB>
-----
ethereum #t/<11.qcl {<3.ltb 27.ipf 7.ecf 36.uek 92.bjk 247.ows 51.mvt 126.xjf 41.mac 1.ane $141> <21.yeb 27.ipf 7.ecf 36.uek 92.bjk 247.ows 51.mvt 126.xjf 41.mac 1.ane $141>}>
ethereum-types #t/<3.ltb 27.ipf 7.ecf 36.uek 92.bjk 247.ows 51.mvt 126.xjf 41.mac 1.ane $141>
~zod:dojo> ethereum
~zod:dojo> |= zong=@ud z<TAB>
-----
zing #t/<1.dqs {* <126.xjf 41.mac 1.ane $141>}>
zap #t/<1.iot {tub/{p/{p/@ud q/@ud} q/""} <1.rff {daf/@t <247.ows 51.mvt 126.xjf 41.mac 1.ane $141>}>}>
zuse #t/$309
zong #t/@ud
~zod:dojo> |= zong=@ud zo<TAB>
-----
zong #t/@ud
~zod:dojo> |= zong=@ud zong
~zod:dojo> <TAB>
hoon-version
trel
quip
pole
unit
qual
lone
... about 600 more lines ...
unity
html
zuse
eny
now
our
~zod:dojo>
```
Functionally, this is in a state where I'd be comfortable shipping it. It doesn't interfere with anything if you don't press tab, and it's perfectly OTA-able. I do think its output is a little verbose, but that can be tuned over time as people try it and determine what feels good in practice.
Additional notes:
- There are plenty of similar systems for other languages, but my most direct inspiration is Idris's editor tools. This is implemented for the dojo, but I actually want it in my editor, which is why the meat is all defind in a library. I've only tested on dojo one-liners, so I don't know the performance on large blocks of code.
- The default type printer isn't great for this use case. In particular,
- Cores should not print anything about their context
- The `#t/` should go away
- If it looks like a gate, we should print its return value
- Maybe special handling for molds, but if the above is done, then for example `bone` is `* -> @ud`.
- The worst part about our wing ordering is that it really screws up tab completion. You want to do `point.owner-address` instead of `owner-address.point` because that lets you type `point.ow<TAB>`. I weakly prefer reading it how we do it now, but it's really not great. You could do an (dojo-specific?) alternate syntax of `point;owner-address`; this is a simple transformation.
- Regardless of the above, this should handle the case where we're in the middle of defining a wing; it doesn't right now.
- When a variable is shadowed, we show both of them. We should probably show the shadowed one with a `^`.
- We probably shouldn't print out hundreds of results. Maybe just the closest 50 with ellipses.
- This gets you any face in your subject, regardless of whether its type is reasonable. We could limit that some by copying the `gol` logic in mint, so that if the pseudo-backward-inference engine happens to know what type it should be, you can filter the tab results according to if they nest in that type. This would be "strongly type-aware".
Re-implements the behavior of the previous azimuth-tracker as an app
that pokes and peers eth-watcher. Should have maintained identical
outward semantics to the original.
When configuring a watchdog on a path that already exists, we now
"overwrite" it, meaning we throw away all history and trawl the node
for logs again.
If the only config change is the url, however, we silently modify it,
and simply use it "from this point onward".
This matches the behavior of the original azimuth-tracker.
In order to give an initial response to incoming subscriptions (without
resorting to retrieving that data from chain again) we now store event
log history in state.
Instead of discarding pending-logs entirely after sending out updates,
we add them to the watchdog's history.
Just like pending-logs, we remove from the head during a rewind (though
not before exhausting the pending-logs).
Kicks the update timer on application start, then sets a new timer
whenever it's awoken. This aims to ensure eth-watcher never stops
looking for updates periodically.
No longer overwrite messages' timestamp on-receive, instead keeping whatever
timestamp was set by the sender.
This behavior matches that of the late Hall.
Uses the logic existing in azimuth-tracker to implement a new
eth-watcher, which can look at Ethereum nodes for _any_ events, as
opposed to exclusively a subset of the Azimuth contract's events.
Azimuth-tracker will be reimplemented as a dependent of this in
forthcoming commits.
These were deprecated in favor of azimuth-tracker in #1320.
(Azimuth-tracker, however, isn't a general-purpose Ethereum log watcher
tool. Commits to transform it into a more broadly useful tool are
forthcoming.)
