mirror of
https://github.com/ilyakooo0/urbit.git
synced 2024-12-18 04:11:49 +03:00
2435 lines
89 KiB
Plaintext
2435 lines
89 KiB
Plaintext
!: :: %eyre, http servant
|
|
!? 164
|
|
::::
|
|
|= pit=vase
|
|
=> =~
|
|
|% :: interfaces
|
|
++ chop ,[p=@ud q=@da] :: see
|
|
++ gift :: out result <-$
|
|
$% [%thou p=httr] :: raw http response
|
|
[%thus p=@ud q=(unit hiss)] :: http request/cancel
|
|
[%veer p=@ta q=path r=@t] :: drop-through
|
|
[%vega p=path] :: drop-through
|
|
== ::
|
|
++ hasp ,[p=ship q=term] :: don't see %gall
|
|
++ hapt ,[p=ship q=path] :: do see %gall
|
|
++ kiss :: in request ->$
|
|
$% [%born ~] :: new unix process
|
|
[%crud p=@tas q=(list tank)] :: XX rethink
|
|
[%init p=@p] :: report install
|
|
:: [%them p=(unit hiss)] :: outbound request
|
|
:: [%they p=@ud q=httr] :: inbound response
|
|
[%this p=? q=clip r=httq] :: inbound request
|
|
[%thud ~] :: inbound cancel
|
|
:: [%wart p=sock q=@tas r=path s=*] :: urbit message
|
|
== ::
|
|
++ move ,[p=duct q=(mold note gift)] :: local move
|
|
++ note :: out request $->
|
|
$%
|
|
:: $: %a :: to %ames
|
|
:: $% [%want p=sock q=path r=*] ::
|
|
:: == == ::
|
|
$: %c :: to %clay
|
|
$% [%warp p=sock q=riff] ::
|
|
== == ::
|
|
$: %d :: to %dill
|
|
$% [%flog p=[%crud p=@tas q=(list tank)]] ::
|
|
== == ::
|
|
:: $: %e :: to %eyre
|
|
:: $% [%this p=? q=clip r=httq] ::
|
|
:: [%thud ~] ::
|
|
:: == == ::
|
|
$: %f :: to %ford
|
|
$% [%exec p=@p q=(unit silk)] ::
|
|
[%wasp p=@p q=@uvH] ::
|
|
== == ::
|
|
:: $: %g :: to %gall
|
|
:: $% [%mess p=hapt q=ship r=cage] ::
|
|
:: [%nuke p=hapt q=ship] ::
|
|
:: [%show p=hapt q=ship r=path] ::
|
|
:: [%took p=hapt q=ship] ::
|
|
:: == == ::
|
|
:: $: %t :: to %temp
|
|
:: $% [%wait p=@da] ::
|
|
:: [%rest p=@da] ::
|
|
:: == ==
|
|
== ::
|
|
++ rave :: see %clay
|
|
$% [& p=mood] ::
|
|
== ::
|
|
++ riff ,[p=desk q=(unit rave)] :: see %clay
|
|
++ silk :: see %ford
|
|
$& [p=silk q=silk] ::
|
|
$% [%boil p=mark q=beam r=path] ::
|
|
[%cast p=mark q=silk] ::
|
|
[%done p=(set beam) q=cage] ::
|
|
== ::
|
|
++ sine ::
|
|
$? sign ::
|
|
$: %g ::
|
|
$% [%veer p=@ta q=path r=@t] ::
|
|
[%vega p=path] ::
|
|
== == == ::
|
|
++ sign :: in result $<-
|
|
$?
|
|
:: $: %a :: by %ames
|
|
:: $% [%waft p=sock q=*] ::
|
|
:: [%went p=ship q=cape] ::
|
|
:: == == ::
|
|
$: %c :: by %clay
|
|
$% [%writ p=riot] ::
|
|
== == ::
|
|
:: $: %e :: by %eyre
|
|
:: $% [%thou p=httr] ::
|
|
:: == == ::
|
|
$: %f :: by %ford
|
|
$% [%made p=@uvH q=(each cage tang)] ::
|
|
[%news ~] ::
|
|
== == ::
|
|
:: $: %g :: by %gall
|
|
:: $% [%dumb ~] ::
|
|
:: [%mean p=ares] ::
|
|
:: [%nice ~] ::
|
|
:: [%rush p=mark q=*] ::
|
|
:: [%rust p=mark q=*] ::
|
|
:: == == ::
|
|
:: $: %t :: by %time
|
|
:: $% [%wake ~] :: timer activate
|
|
:: == == ::
|
|
$: @tas :: by any
|
|
$% [%crud p=@tas q=(list tank)] ::
|
|
== == == ::
|
|
-- ::
|
|
|% :: models
|
|
++ bolo :: eyre state
|
|
$: %0 :: version
|
|
gub=@t :: random identity
|
|
hov=(unit ship) :: master for remote
|
|
ged=duct :: client interface
|
|
ney=@uvI :: rolling entropy
|
|
dop=(map host ship) :: host aliasing
|
|
liz=(jug beam (each duct oryx)) :: clay subscriptions
|
|
:: own=(map ship serf) :: domestic servers
|
|
:: fon=(map ship rote) :: foreign servers
|
|
:: ask=[p=@ud q=(map ,@ud ,[p=duct q=hiss])] :: outgoing by number
|
|
:: kes=(map duct ,@ud) :: outgoing by duct
|
|
:: lor=(map duct dual) :: incoming by duct
|
|
== ::
|
|
:: ++ clue :: console
|
|
:: $: ino=@ud :: input sequence
|
|
:: ono=@ud :: (lent out)
|
|
:: voy=(map ,@ud (list ,@ud)) :: waiters (q.rey)
|
|
:: out=(list json) :: output commands
|
|
:: == ::
|
|
++ cyst :: client session
|
|
$: ced=cred :: credential
|
|
:: cow=(map ,@ud clue) :: consoles
|
|
cug=(list ,@t) :: unacked cookies
|
|
lax=@da :: last used
|
|
:: sok=(map ,@ud (pair ship sink)) :: live apps by reqno
|
|
:: rey=[p=@ud q=(map ,@ud pimp)] :: live requests
|
|
== ::
|
|
:: ++ dual ,[p=@ud q=(each ,[p=ship q=hole] ship)] :: request handle
|
|
:: ++ dude ,[p=@tas q=@] :: client identity
|
|
:: ++ pest :: request in progress
|
|
:: $| $? %new :: virgin
|
|
:: %way :: waiting
|
|
:: == ::
|
|
:: $% [%err p=@ud q=(list tank)] :: error report
|
|
:: [%fin p=love] :: ready to send
|
|
:: [%fud p=(each bead (list tank))] :: function finished
|
|
:: [%haz p=riot] :: clay responded
|
|
:: [%raw p=hiss] :: wild url
|
|
:: [%who p=@tas q=@ta] :: awaiting auth
|
|
:: == ::
|
|
:: ++ pimp :: traced request
|
|
:: $: ful=? :: | === HEAD
|
|
:: fur=(unit mark) :: type goal
|
|
:: hen=duct :: event trace
|
|
:: som=seam :: logical request
|
|
:: pez=pest :: request state
|
|
:: sip=marl :: injected scripts
|
|
:: == ::
|
|
:: ++ rote :: remote server
|
|
:: $: cnt=@ud :: number served
|
|
:: sor=@p :: home sponsor
|
|
:: rem=[p=@ud q=(map ,@ud duct)] :: active requests
|
|
:: == ::
|
|
:: ++ seam :: logical request
|
|
:: $% [%ape p=ship q=@ud r=@ud] :: subscribe pull
|
|
:: [%aph p=ship q=@ud r=@ud s=json] :: app heartbeat
|
|
:: [%apg p=term q=ship r=mark s=path] :: app get/start
|
|
:: [%apm p=ship q=@ud r=@ud s=hasp for=mark t=json] :: message send
|
|
:: [%app p=ship q=(unit ,@ud)] :: script by port
|
|
:: [%aps p=ship q=@ud s=hasp t=path] :: subscribe
|
|
:: [%apu p=ship q=@ud s=hasp t=path] :: unsubscribe
|
|
:: [%cog p=@ud q=@ud] :: console get
|
|
:: [%con p=@ud] :: console face
|
|
:: [%cop p=@ud q=@ud r=json] :: console put
|
|
:: [%det p=desk q=moat] :: load changes
|
|
:: [%fun p=term q=tube r=(list manx)] :: functional
|
|
:: [%lon p=seal] :: authentication flow
|
|
:: [%red p=purl] :: redirect
|
|
:: [%sil p=@ud q=silk] :: status and silk
|
|
:: == ::
|
|
:: ++ serf :: local server
|
|
:: $: pef=@t :: server prefix
|
|
:: wup=(map hole cyst) :: secure sessions
|
|
:: cah=(map cash vase) :: compilation cache
|
|
:: == ::
|
|
:: ++ sink :: page push system
|
|
:: $: bet=[wig=swig num=@ud tim=@da hen=duct] :: heartbeat
|
|
:: meg=[wig=swig num=@ud] :: messages
|
|
:: sub=[wig=swig num=@ud can=(map ,@ud stem)] :: subscriptions
|
|
:: == ::
|
|
:: ++ stem :: subscription
|
|
:: $: hap=hasp ::
|
|
:: pax=path ::
|
|
:: hen=duct ::
|
|
:: num=(unit (each ,@ud ,@ud)) ::
|
|
:: == ::
|
|
:: ++ swig :: update channel
|
|
:: $: cnt=@ud :: updates produced
|
|
:: toy=@ud :: updates sent
|
|
:: wan=(map ,@ud ,@ud) :: upno to reqno
|
|
:: red=(map ,@ud (unit (each cage cage))) :: ready for pickup
|
|
:: == ::
|
|
-- ::
|
|
|%
|
|
++ coss :: cookie search
|
|
|= [nam=@t mah=math]
|
|
^- (unit hole)
|
|
=+ ^= cok ^- (list ,@t)
|
|
=+ cok=(~(get by mah) 'cookie')
|
|
?~(cok ~ u.cok)
|
|
|- ^- (unit hole)
|
|
?~ cok ~
|
|
=+ mar=`(unit (list ,[p=@t q=@t]))`(rush i.cok cock:epur)
|
|
?~ mar $(cok t.cok)
|
|
|- ^- (unit hole)
|
|
?~ u.mar ^$(cok t.cok)
|
|
?:(=(nam p.i.u.mar) [~ q.i.u.mar] $(u.mar t.u.mar))
|
|
:: ::
|
|
:: ++ ecca :: [hasp path]
|
|
:: |= [orx=oryx moh=moth]
|
|
:: ^- (unit ,[hasp path])
|
|
:: =+ jun=(ecci orx moh)
|
|
:: :: ~& [%ecca jun]
|
|
:: ?~ jun ~
|
|
:: =+ ^- (unit ,[his=ship app=term pax=term])
|
|
:: %. u.jun
|
|
:: %- ot:jo
|
|
:: ~[[%ship (su:jo fed:ag)] [%appl so:jo] [%path so:jo]]
|
|
:: ?~ - ~
|
|
:: =+ ^= pax
|
|
:: %+ rush pax.u
|
|
:: ;~(pfix fas (more fas ;~(simu next urs:ab)))
|
|
:: ?~ pax ~
|
|
:: `[[his.u app.u] u.pax]
|
|
:: ::
|
|
:: ++ ecce :: JS from moth
|
|
:: |= moh=moth
|
|
:: ^- (unit json)
|
|
:: =+ ten=(~(get by q.moh) 'content-type')
|
|
:: ?~ ten ~
|
|
:: ?~ u.ten ~
|
|
:: ?. =('text/json' (end 3 9 i.u.ten))
|
|
:: ~| %ecce-content-type ~
|
|
:: ?~ r.moh ~
|
|
:: `(unit json)`(rush q.u.r.moh apex:poja)
|
|
:: ::
|
|
:: ++ ecci :: ecce w/oryx
|
|
:: |= [orx=oryx moh=moth]
|
|
:: ^- (unit json)
|
|
:: =+ jun=(ecce moh)
|
|
:: ?~ jun ~
|
|
:: ?. ?=(%o -.u.jun) ~
|
|
:: :: ?. =([~ %s orx] (~((get by p.u.jun) %oryx))
|
|
:: :: ~& [%oryx-sent ~(get by p.u.jun) %oryx)]
|
|
:: :: ~& [%oryx-good orx]
|
|
:: :: ~
|
|
:: ~? !=([~ %s orx] (~(get by p.u.jun) %oryx))
|
|
:: [%oryx [%sent (~(get by p.u.jun) %oryx)] [%good orx]]
|
|
:: =+ nuj=(~(get by p.u.jun) %xyro)
|
|
:: ?~(nuj [~ ~] [~ u.nuj])
|
|
:: ::
|
|
++ ecco :: eat headers
|
|
|= hed=(list ,[p=@t q=@t]) ^- math
|
|
%+ roll hed
|
|
|= [a=[p=cord cord] b=math]
|
|
=. p.a (cass (trip p.a))
|
|
(~(add ja b) a)
|
|
::
|
|
:: ++ eccu :: [hasp json]
|
|
:: |= [orx=oryx moh=moth]
|
|
:: ^- (unit ,[hasp mark json])
|
|
:: =+ jun=(ecci orx moh)
|
|
:: ?~ jun ~& %no-ecci ~
|
|
:: =+ ^- (unit ,[his=term app=term for=mark jon=json])
|
|
:: %. u.jun
|
|
:: %- ot:jo
|
|
:: :~ [%ship so:jo]
|
|
:: [%appl so:jo]
|
|
:: [%mark so:jo]
|
|
:: [%data |=(json (some +<))]
|
|
:: ==
|
|
:: ?~ - ~& %no-json ~
|
|
:: =+ his=(slaw %p (cat 3 '~' his.u))
|
|
:: ?~ his ~& %no-ship ~
|
|
:: `[[u.his app.u] for.u jon.u]
|
|
:: ::
|
|
:: ++ lopo :: cage to love
|
|
:: |= cay=cage
|
|
:: ^- love
|
|
:: ?> ?=(%mime p.cay)
|
|
:: ((hard love) [%mid q.q.cay])
|
|
:: ::
|
|
++ loga :: tanks to manx
|
|
|= tac=(list tank)
|
|
^- manx
|
|
=+ rolt=|=(a=wall `tape`?~(a ~ :(weld i.a "\0a" $(a t.a))))
|
|
=+ mec=(rolt (turn tac |=(a=tank (rolt (wash 0^160 a)))))
|
|
;html
|
|
;head
|
|
;meta(charset "utf-8");
|
|
;title: server error
|
|
==
|
|
;body:pre:code:"{mec}"
|
|
==
|
|
::
|
|
++ lode
|
|
|= [dep=@uvH max=manx]
|
|
^- manx
|
|
?> ?=([[%html ~] [[%head ~] *] [[%body ~] ^] ~] max) :: XX static
|
|
?~ dep max
|
|
max(c.i.c :_(c.i.c.max ;script@"/~/on/{<dep>}.js";))
|
|
::
|
|
:: ++ lofa :: scripts in head
|
|
:: |= [mog=(list manx) luv=love]
|
|
:: ^- love
|
|
:: ?: =(~ mog) luv
|
|
:: ?+ -.luv luv
|
|
:: %mid
|
|
:: ?. =('<html' (end 3 5 q.q.luv)) luv
|
|
:: =+ scr=(many:poxo mog "")
|
|
:: =+ ^= hed
|
|
:: |- ;~ pose
|
|
:: (cook trip (jest '<head>'))
|
|
:: ;~(plug next (knee *tape ..$))
|
|
:: (easy ~)
|
|
:: ==
|
|
:: =+ hop=(need q:(hed *hair (trip q.q.luv)))
|
|
:: ?~ q.q.hop luv
|
|
:: =+ rep=:(welp p.hop scr q.q.hop)
|
|
:: [%mid p.luv (tact rep)]
|
|
:: ==
|
|
:: ::
|
|
:: ++ loft :: love to response
|
|
:: |= luv=love
|
|
:: ^- httr
|
|
:: ?- -.luv
|
|
:: %mid [200 ~[content-type/(moon p.luv)] [~ q.luv]]
|
|
:: %ham [200 ~[content-type/'text/html'] [~ (tact (poxo p.luv))]]
|
|
:: %raw p.luv
|
|
:: %wan :+ 200
|
|
:: ~[content-type/'text/plain']
|
|
:: :- ~
|
|
:: %- taco
|
|
:: %+ rap 3
|
|
:: |- ^- (list ,@)
|
|
:: ?~(p.luv ~ [i.p.luv 10 $(p.luv t.p.luv)])
|
|
:: %zap :+ p.luv
|
|
:: ~[content-type/'text/html']
|
|
:: [~ (tact (poxo (loga "server error" ~ q.luv)))]
|
|
:: ==
|
|
++ js :: static javascript
|
|
|%
|
|
++ poll
|
|
'''
|
|
urb.tries = 0
|
|
urb.call = function() {
|
|
xhr = new XMLHttpRequest()
|
|
xhr.open('GET', urb.poll, true)
|
|
xhr.addEventListener('load', function() {
|
|
// if(~~(this.status / 100) == 4)
|
|
// return document.write(xhr.responseText)
|
|
if(this.status !== 205) {
|
|
return urb.keep()
|
|
}
|
|
document.location.reload()
|
|
})
|
|
xhr.addEventListener('error', urb.keep)
|
|
xhr.addEventListener('abort', urb.keep)
|
|
xhr.send()
|
|
}
|
|
urb.keep = function() {
|
|
setTimeout(urb.call,1000*urb.tries)
|
|
urb.tries++
|
|
}
|
|
urb.call()
|
|
'''
|
|
--
|
|
--
|
|
|% :: functions
|
|
++ ye :: per event
|
|
=| $: $: hen=duct :: event floor
|
|
$: now=@da :: event date
|
|
eny=@ :: unique entropy
|
|
our=ship :: current ship
|
|
sky=$+(* (unit)) :: system namespace
|
|
== ::
|
|
mow=(list move) :: pending actions
|
|
== ::
|
|
bolo :: all vane state
|
|
== ::
|
|
=* bol ->
|
|
|%
|
|
++ abet
|
|
^- [(list move) bolo]
|
|
[(flop mow) bol]
|
|
::
|
|
++ adit
|
|
.(ney (mix eny ney))
|
|
::
|
|
++ axon
|
|
|= [tea=wire typ=type sih=sign]
|
|
^+ +>
|
|
?- -.+.sih
|
|
%crud
|
|
+>.$(mow [[hen %slip %d %flog +.sih] mow])
|
|
::
|
|
%made
|
|
?+ tea +>.$
|
|
~
|
|
:: ~& e/ford/hen
|
|
?- -.q.sih
|
|
| (fail 404 p.sih p.q.sih)
|
|
& =* cag p.q.sih
|
|
?+ p.cag (back ~ p.sih cag)
|
|
%hipo :: hacks!
|
|
?> ?=(@tas -.q.q.cag)
|
|
$(p.q.sih [-.q.q.cag (slot 3 q.cag)])
|
|
::
|
|
%mime
|
|
~| q.q.cag
|
|
=+ ((hard ,[mit=mite rez=octs]) q.q.cag) :: XX
|
|
(muff %thou 200 [content-type/(moon mit)]~ ~ rez)
|
|
==
|
|
==
|
|
==
|
|
::
|
|
%news (jive %b &) :: dependency updated
|
|
%writ
|
|
:: ?^ tea ~&(e/missed/writ/tea=tea +>.$)
|
|
?~ p.sih +>.$
|
|
=+ `[@ caz=case dez=desk]`p.u.p.sih
|
|
?> ?=(%ud -.caz)
|
|
(jive (joba dez (jone p.caz)))
|
|
:: %- gout
|
|
:: [(slav %p i.t.tea) i.t.t.tea (slav %ud i.t.t.t.tea) p.+.sih]
|
|
:: ::
|
|
:: ?(%dumb %mean %nice %rush %rust)
|
|
:: ?> ?=([%hoop @ @ @ ?([%mess @ @ ~] [%show @ ~])] tea)
|
|
:: =+ our=(slav %p i.t.tea)
|
|
:: =* ses i.t.t.tea
|
|
:: =+ nap=(slav %ud i.t.t.t.tea)
|
|
:: =+ ouy=(yolk:(gale our ses) nap)
|
|
:: ?~ ouy
|
|
:: +>.$
|
|
:: =* mab t.t.t.t.tea
|
|
:: =+ woy=(yule:u.ouy ?+(i.mab !! %mess %meg, %show %sub))
|
|
:: ?- -.+.sih
|
|
:: %dumb
|
|
:: abet:work:abet:dumb:woy
|
|
:: ::
|
|
:: %nice
|
|
:: =< abet =< work =< abet
|
|
:: ?. ?=(%mess i.mab)
|
|
:: u.ouy
|
|
:: (hear:woy ~ %& %json !>((joba %ok %b &)))
|
|
:: ::
|
|
:: %mean
|
|
:: =< abet =< work =< abet
|
|
:: =+ jon=(rong p.+.sih)
|
|
:: ?: ?=(%mess i.mab)
|
|
:: (hear:woy ~ %& %json !>(jon))
|
|
:: =+ can=(slav %ud i.t.mab)
|
|
:: =+ sem=(~(get by can.sub.siq:beat:u.ouy) can)
|
|
:: ?~ sem :: XX shouldn't occur
|
|
:: u.ouy
|
|
:: (soon %& u.sem u.ouy can %show ?.(?=(%show i.mab) jon (wrap u.sem jon)))
|
|
:: ::
|
|
:: ?(%rust %rush)
|
|
:: ?> ?=(%show i.mab)
|
|
:: =+ can=(slav %ud i.t.mab)
|
|
:: =+ sem=(need (~(get by can.sub.siq:beat:u.ouy) can))
|
|
:: =. mow.u.ouy
|
|
:: :_(mow.u.ouy [hen %pass tea [%g %took [- + ~]:hap.sem you.u.ouy]])
|
|
:: ?: =(0 can)
|
|
:: =< abet =< work =< abet
|
|
:: ?~ num.sem
|
|
:: (hear:woy ~ %& %json !>((joba %reload %b %&)))
|
|
:: ?> -.u.num.sem
|
|
:: =+ huq=``[p.+.sih (slot 3 (spec (slot 3 [typ +.sih])))]
|
|
:: =+ yoo=abet:(busk:(yule:u.ouy %nil) p.u.num.sem 0 huq)
|
|
:: yoo(can.sub.siq (~(put by can.sub.siq.yoo) can sem(num ~)))
|
|
:: ?. ?=(%json p.+.sih)
|
|
:: %^ hooj our ses :^ nap can ?=(%rust -.+.sih)
|
|
:: :+ %cast %json
|
|
:: :+ %done ~
|
|
:: [p.+.sih (slot 3 (spec (slot 3 [typ +.sih])))]
|
|
:: =< abet =< work =< abet
|
|
:: (soon ?=(%rust -.+.sih) sem u.ouy can %show (wrap sem (json q.+.sih)))
|
|
:: ==
|
|
:: ::
|
|
:: ::
|
|
:: [%honk @ @ @ ~]
|
|
:: %- galt
|
|
:: [(slav %p i.t.tea) i.t.t.tea (slav %ud i.t.t.t.tea) p.+.sih]
|
|
:: ::
|
|
:: [%hooj @ @ @ @ @ ~]
|
|
:: =+ ^= ouy
|
|
:: %- yolk:(gale (slav %p i.t.tea) i.t.t.tea)
|
|
:: (slav %ud i.t.t.t.tea)
|
|
:: ?~ ouy
|
|
:: ~& %hooj-made-no-ouy +>.$
|
|
:: =+ can=(slav %ud i.t.t.t.t.tea)
|
|
:: =+ ful=(slav %f i.t.t.t.t.t.tea)
|
|
:: =+ sem=(need (~(get by can.sub.siq:beat:u.ouy) can))
|
|
:: =< abet =< work =< abet
|
|
:: %^ soon (,? ful) sem :^ u.ouy can %show
|
|
:: %+ wrap sem
|
|
:: ?: ?=(%& -.p.+.sih)
|
|
:: (json q.q.q.p.p.+.sih)
|
|
:: (rong ~ %to-json-fail p.p.+.sih)
|
|
:: ::
|
|
:: [%hoop @ @ @ %mess @ @ ~]
|
|
:: =+ ^= ouy
|
|
:: %- yolk:(gale (slav %p i.t.tea) i.t.t.tea)
|
|
:: (slav %ud i.t.t.t.tea)
|
|
:: ?~ ouy
|
|
:: ~& %hoop-made-no-ouy +>.$
|
|
:: ?- -.p.+.sih
|
|
:: %&
|
|
:: =* mab t.t.t.t.tea
|
|
:: %= +>.$
|
|
:: mow
|
|
:: :_ mow
|
|
:: :* hen %pass tea %g
|
|
:: %mess [(slav %p i.t.mab) i.t.t.mab ~]
|
|
:: you:beat:u.ouy q.p.p.sih
|
|
:: ==
|
|
:: ==
|
|
:: ::
|
|
:: %|
|
|
:: =< abet =< work =< abet
|
|
:: %^ hear:(yule:u.ouy %meg) ~ %&
|
|
:: [%json !>((rong ~ %from-json-fail p.p.+.sih))]
|
|
:: ==
|
|
:: ::
|
|
:: %thou :: remote return
|
|
:: ?> ?=([@ @ *] tea)
|
|
:: (hajj (slav %p i.tea) (slav %p i.t.tea) t.t.tea p.+.sih)
|
|
:: ::
|
|
:: %waft
|
|
:: ?. ?=([%hork @ ~] tea)
|
|
:: +>.$
|
|
:: (gosh q.p.+.sih (slav %ud i.t.tea) ((hard httr) q.+.sih))
|
|
:: ::
|
|
:: %wake
|
|
:: ?> ?=([%leep @ @ @ @ ~] tea)
|
|
:: =+ ^= ouy
|
|
:: %- yolk:(gale (slav %p i.t.tea) i.t.t.tea)
|
|
:: (slav %ud i.t.t.t.tea)
|
|
:: ?~ ouy
|
|
:: +>.$
|
|
:: ?: (lth ~m2 (sub now tim.bet.siq:beat:u.ouy)) :: XX unnecessary
|
|
:: abet:work:amok:u.ouy
|
|
:: ~& %bad-timer
|
|
:: +>.$
|
|
:: ::
|
|
:: %went
|
|
:: +>.$
|
|
==
|
|
::
|
|
++ apex
|
|
|= kyz=kiss
|
|
^+ +>
|
|
?- -.kyz
|
|
%born +>.$(ged hen) :: register external
|
|
%crud
|
|
+>.$(mow [[hen %slip %d %flog kyz] mow])
|
|
%init :: register ownership
|
|
%_ +>.$
|
|
hov ?~(hov [~ p.kyz] [~ (min u.hov p.kyz)])
|
|
:: ::
|
|
:: own
|
|
:: %+ ~(put by own)
|
|
:: p.kyz
|
|
:: ^- serf
|
|
:: :* (cat 3 gub (rsh 3 1 (scot %p p.kyz)))
|
|
:: ~
|
|
:: ~
|
|
:: ==
|
|
==
|
|
:: ::
|
|
:: %them :: outbound request
|
|
:: ?~ p.kyz
|
|
:: =+ sud=(need (~(get by kes) hen))
|
|
:: %= +>.$
|
|
:: mow :_(mow [ged [%give %thus sud ~]])
|
|
:: q.ask (~(del by q.ask) sud)
|
|
:: kes (~(del by kes) hen)
|
|
:: ==
|
|
:: :: ~& eyre-them/(earn p.u.p.kyz)
|
|
:: %= +>.$
|
|
:: mow :_(mow [ged [%give %thus p.ask p.kyz]])
|
|
:: p.ask +(p.ask)
|
|
:: q.ask (~(put by q.ask) p.ask hen u.p.kyz)
|
|
:: kes (~(put by kes) hen p.ask)
|
|
:: ==
|
|
:: ::
|
|
:: %they :: inbound response
|
|
:: =+ kas=(need (~(get by q.ask) p.kyz))
|
|
:: :: ~& > eyre-they/[p.q.kyz (earn p.q.kas)]
|
|
:: %= +>.$
|
|
:: mow :_(mow [p.kas [%give %thou q.kyz]])
|
|
:: q.ask (~(del by q.ask) p.kas)
|
|
:: ==
|
|
::
|
|
%this :: inbound request
|
|
=* sec p.kyz :: ? :: https bit
|
|
=* heq r.kyz :: httq :: request content
|
|
=+ ryp=`quri`(rash q.heq zest:epur)
|
|
=+ mah=(ecco r.heq)
|
|
=+ ^= pul ^- purl
|
|
?- -.ryp
|
|
& ?>(=(sec p.p.p.ryp) p.ryp)
|
|
| =+ hot=(~(get ja mah) %host)
|
|
?> ?=([@ ~] hot)
|
|
[[sec (rash i.hot thor:epur)] p.ryp q.ryp]
|
|
==
|
|
=. p.p.pul |(p.p.pul ?=(hoke r.p.pul))
|
|
(hell pul +.kyz [p.heq mah s.heq])
|
|
::
|
|
%thud :: cancel request
|
|
~& e/gone/hen
|
|
+>.$
|
|
:: =+ dul=(~(get by lor) hen)
|
|
:: ?~ dul +>.$
|
|
:: =. lor (~(del by lor) hen)
|
|
:: ?- -.q.u.dul
|
|
:: & =+ boy=(myth p.p.q.u.dul q.p.q.u.dul)
|
|
:: ?~(boy +>.$ abet:(idle:u.boy p.u.dul))
|
|
:: | (hops p.q.u.dul p.u.dul)
|
|
:: ==
|
|
:: ::
|
|
:: %wart :: remote request
|
|
:: ?+ q.kyz
|
|
:: ~& [%strange-wart p.kyz q.kyz]
|
|
:: +>.$
|
|
:: ::
|
|
:: %pr (hare p.p.kyz r.kyz q.p.kyz s.kyz)
|
|
:: %pc (here p.p.kyz q.p.kyz s.kyz)
|
|
:: ==
|
|
==
|
|
::
|
|
++ back :: %ford bounce
|
|
|= [tea=wire dep=@uvH cag=cage]
|
|
(miff tea %f %exec our `[%cast %mime %done ~ cag]) :: XX deps
|
|
::
|
|
++ doss :: host to ship
|
|
|= hot=host
|
|
^- (unit ship)
|
|
=+ gow=(~(get by dop) hot)
|
|
?^ gow gow
|
|
?. &(?=(& -.hot) ?=(^ p.hot)) ~
|
|
(rush -:(flop p.hot) fed:ag)
|
|
::
|
|
++ fail :: request failed
|
|
|= [sas=@ud dep=@uvH mez=tang]
|
|
^+ +>
|
|
:: (back ~ dep %tang !>(mez)) :: XX broken tang->mime door in ford
|
|
(resp sas text//html (poxo (lode dep (loga mez))))
|
|
::
|
|
:: ++ gale :: ya from response
|
|
:: |= [our=ship ses=hole]
|
|
:: =+ sef=(need (~(get by own) our))
|
|
:: =+ cyz=(need (~(get by wup.sef) ses))
|
|
:: ~(. ya [our ses] sef cyz)
|
|
:: ::
|
|
:: ++ galt ::
|
|
:: |= [our=ship ses=hole num=@ud mez=(each bead (list tank))]
|
|
:: ^+ +>
|
|
:: =+ suf=(~(get by own) our)
|
|
:: ?~ suf +>.$
|
|
:: =+ cuz=(~(get by wup.u.suf) ses)
|
|
:: ?~ cuz +>.$
|
|
:: abet:work:(~(inch ya [our ses] u.suf u.cuz) num mez)
|
|
:: ::
|
|
:: ++ gosh :: receive %pr response
|
|
:: |= [him=ship num=@ud har=httr]
|
|
:: ^+ +>
|
|
:: =+ ryt=(~(get by fon) him)
|
|
:: ?~ ryt +>.$
|
|
:: =+ zur=(~(get by q.rem.u.ryt) num)
|
|
:: ?~ zur +>.$
|
|
:: %_ +>.$
|
|
:: mow :_(mow [u.zur [%give %thou har]])
|
|
:: fon (~(put by fon) him u.ryt(q.rem (~(del by q.rem.u.ryt) num)))
|
|
:: ==
|
|
:: ::
|
|
:: ++ gout :: receive %clay
|
|
:: |= [our=ship ses=hole num=@ud rot=riot]
|
|
:: ^+ +>
|
|
:: =+ suf=(~(get by own) our)
|
|
:: ?~ suf +>.$
|
|
:: =+ cuz=(~(get by wup.u.suf) ses)
|
|
:: ?~ cuz +>.$
|
|
:: abet:work:(~(iota ya [our ses] u.suf u.cuz) num rot)
|
|
:: ::
|
|
:: ++ haji :: send %pc login
|
|
:: |= [our=ship him=ship ses=hole]
|
|
:: ^+ +>
|
|
:: +>.$(mow :_(mow [hen %pass ~ %a [%want [our him] [%r %pc %e ~] ses]]))
|
|
:: ::
|
|
:: ++ hajj :: send %pr response
|
|
:: |= [our=ship him=ship tus=path har=httr]
|
|
:: ^+ +>
|
|
:: +>.$(mow :_(mow [hen %pass ~ %a [%want [our him] [%r %pr %e tus] har]]))
|
|
:: ::
|
|
:: ++ hare :: receive request
|
|
:: |= [our=ship tus=path him=ship hor=*]
|
|
:: ^+ +>
|
|
:: =+ hux=((hard (unit httx)) hor)
|
|
:: %_ +>.$
|
|
:: mow
|
|
:: :_ mow
|
|
:: :- hen
|
|
:: :^ %pass [(scot %p our) (scot %p him) tus]
|
|
:: %e
|
|
:: ?~(hux [%thud ~] [%this u.hux])
|
|
:: ==
|
|
:: ::
|
|
:: ++ here :: receive auth
|
|
:: |= [our=ship him=ship hez=*]
|
|
:: ^+ +>
|
|
:: =+ boy=(myth our (need ((sand %ta) ((hard ,@) hez))))
|
|
:: ?~(boy +>.$ abet:(auth:u.boy him))
|
|
:: ::
|
|
++ heck :: extract err beak
|
|
|= [oar=ship pul=purl]
|
|
^- (unit beak)
|
|
%- bind :_ |=(a=$&(beam beak) ?^(-.a -.a a))
|
|
^- (unit $&(beam beak))
|
|
?. ?=([%'~' ^] q.q.pul)
|
|
(heft oar q.pul)
|
|
?+ i.t.q.q.pul ~
|
|
%as ?~(t.t.q.q.pul ~ $(q.q.pul t.t.t.q.q.pul))
|
|
%on ~ ::(tome (scot %p oar)
|
|
==
|
|
++ heft :: regular request
|
|
|= [oar=ship pok=pork]
|
|
^- (unit beam)
|
|
?~ q.pok
|
|
$(q.pok /index)
|
|
?. ((sane %tas) i.q.pok)
|
|
(tome q.pok)
|
|
`[[oar i.q.pok da/now] (flop t.q.pok)]
|
|
::
|
|
++ hell :: request, no ship
|
|
|= [pul=purl hyx=httx moh=moth]
|
|
^+ +>
|
|
=+ hon=(horn pul q.hyx moh)
|
|
?^ hon (muff u.hon)
|
|
:: =^ wiq q.q.pul
|
|
:: ?~ q.q.pul [~ ~]
|
|
:: =+ nam=(cat 3 '~' i.q.q.pul)
|
|
:: =+ gow=(rush i.q.q.pul fed:ag)
|
|
:: ^- [(unit ship) (list ,@t)]
|
|
:: ?~(gow [~ q.q.pul] [gow t.q.q.pul])
|
|
:: =+ oar=`(unit ship)`?^(wiq wiq (doss r.p.pul))
|
|
=+ oar=(fall (doss r.p.pul) (need hov))
|
|
=+ ext=(fall p.q.pul %urb)
|
|
%- |=(a=(each ,_..hell tang) ?~(-.a p.a (fail 404 0v0 >%exit< p.a)))
|
|
%- mule |. ^+ ..hell
|
|
=+ hev=(heft oar q.pul)
|
|
?^ hev
|
|
=: s.u.hev [%web ~(rent co (flux:ya /'' r.pul)) s.u.hev]
|
|
r.u.hev ?+(r.u.hev r.u.hev [%ud %0] da/now)
|
|
==
|
|
(honk oar [%cast %mime [%boil ext u.hev ~]])
|
|
=+ hem=(hemp oar [q r]:pul)
|
|
?~ hem
|
|
~|(strange-path/q.q.pul !!)
|
|
?- -.u.hem
|
|
& ?. ?=([~ %js] p.q.pul) :: XX treat non-json cases?
|
|
~! hem
|
|
?~ p.u.hem ..hell
|
|
(howa ~ p.u.hem)
|
|
%^ resp 200 text//javascript
|
|
"""
|
|
window.urb = \{poll: "/{(apex:earn %| q.pul(u.p %json) r.pul)}"}
|
|
{(trip poll:js)}
|
|
"""
|
|
::
|
|
| ~|(aute/p.u.hem !!)
|
|
==
|
|
::
|
|
++ hemp :: auxillary(/~) request
|
|
|= [oar=ship pok=pork quy=quay]
|
|
^- (unit (each ,@uvH ,[p=ship q=pork]))
|
|
?. ?=([%'~' @ *] q.pok) ~
|
|
:- ~
|
|
=* pef i.t.q.pok
|
|
=+ but=t.t.q.pok :: XX =*
|
|
?+ pef ~|(pfix-lost/`path`/~/[pef] !!)
|
|
%on
|
|
:- %&
|
|
~| on/bad-path/but
|
|
?> ?=([@ ~] but)
|
|
(slav %uv i.but)
|
|
%as
|
|
:- %|
|
|
~| bad-ship/?~(but ~ i.but)
|
|
?~ but !!
|
|
:_ pok(q t.but)
|
|
?+ i.but (slav %p i.but)
|
|
%anon (add our ^~((bex 64)))
|
|
%own our
|
|
==
|
|
==
|
|
:: ?. (home oar)
|
|
:: (hork oar hyx)
|
|
:: (huff oar q.hyx pul moh)
|
|
:: ::
|
|
:: ++ home :: do we own?
|
|
:: |= who=ship
|
|
:: ^- ?
|
|
:: ?: (~(has by own) who) &
|
|
:: ?: (~(has by fon) who) |
|
|
:: !=(~ (sky /a/(scot %p who)/buck/(scot %da now)))
|
|
::
|
|
++ hoot :: clay request
|
|
|= [our=ship wir=path his=ship rif=riff]
|
|
(miff wir %c [%warp [our his] rif])
|
|
::
|
|
++ hone :: kill ford
|
|
|= [our=ship ses=hole]
|
|
(miff ~ %f [%exec our ~])
|
|
::
|
|
++ honk :: ford request
|
|
|= [our=ship kas=silk]
|
|
:: ~& [%honk our num ses -.kas]
|
|
(miff ~ %f [%exec our `kas])
|
|
::
|
|
:: ++ hooj :: ford json request
|
|
:: |= [our=ship ses=hole nap=@ud can=@ud ful=? kas=silk]
|
|
:: %_ +>
|
|
:: mow
|
|
:: :_ mow
|
|
:: :^ hen %pass
|
|
:: ~[%hooj (scot %p our) ses (scot %ud nap) (scot %ud can) (scot %f ful)]
|
|
:: [%f [%exec our `kas]]
|
|
:: ==
|
|
:: ::
|
|
:: ++ hops :: cancel remote
|
|
:: |= [him=ship num=@]
|
|
:: ^+ +>
|
|
:: =+ mun=(scot %ud num)
|
|
:: =+ rot=(need (~(get by fon) him))
|
|
:: %_ +>.$
|
|
:: mow
|
|
:: :_ mow
|
|
:: :- hen
|
|
:: :^ %pass [%hork (scot %p sor.rot) mun ~]
|
|
:: %a
|
|
:: [%want [sor.rot him] [%q %pr %e %hork mun ~] ~]
|
|
:: ==
|
|
:: ::
|
|
:: ++ hork :: remote request
|
|
:: |= [him=ship hyx=httx]
|
|
:: ^+ +>
|
|
:: =+ ^= sur ^- (unit ship)
|
|
:: ?^ hov hov
|
|
:: ?^ own [~ p.n.own]
|
|
:: ~
|
|
:: ?~ sur (fail 500 "no vessel available to proxy {<him>}")
|
|
:: ?. (gth (met 3 him) (met 3 u.sur)) :: very permissive
|
|
:: (fail 500 "{<u.sur>} cannot proxy for {<him>}")
|
|
:: =+ ^= rot ^- rote
|
|
:: =+ rut=(~(get by fon) him)
|
|
:: ?^ rut u.rut
|
|
:: [0 u.sur [0 ~]]
|
|
:: =+ num=p.rem.rot
|
|
:: =+ mun=(scot %ud num)
|
|
:: %_ +>.$
|
|
:: lor (~(put by lor) hen num [%| him])
|
|
:: mow
|
|
:: :_ mow
|
|
:: :- hen
|
|
:: :^ %pass [%hork (scot %p sor.rot) mun ~]
|
|
:: %a
|
|
:: [%want [sor.rot him] [%q %pr %e %hork mun ~] [~ hyx]]
|
|
:: ::
|
|
:: fon
|
|
:: %+ ~(put by fon) him
|
|
:: %_ rot
|
|
:: cnt +(cnt.rot)
|
|
:: p.rem +(p.rem.rot)
|
|
:: q.rem (~(put by q.rem.rot) num hen)
|
|
:: ==
|
|
:: ==
|
|
:: ::
|
|
++ horn :: irregular request
|
|
|= [pul=purl cip=clip moh=moth]
|
|
^- (unit gift)
|
|
?+ [(fall p.q.pul %$) q.q.pul] ~
|
|
[?(%ico %png) %favicon ~]
|
|
:- ~
|
|
%^ tuff 200 image//png
|
|
0w89wg.GV4jA.l9000.00dPb.YzBT6.giO00.o100d.wZcqc.a9tg-.VTG0b.
|
|
AUIvE.HBM3g.cK4SE.0aagi.l090p.I1P5g.Y-80r.y1YS9.1xE~Y.qgpFY.
|
|
vKN1V.905y0.2UwvL.43TUw.uL406.0-31h.xwoJF.Ul454.ilk00.00Yps.
|
|
BNumh.xpl9B.pS5Ji.i1BoC.ZAgg1.BsC5T.t6pLk.Thohn.gp000.0ov~P.
|
|
7M000.0o840.00010.0001i.h4x93.g0000.Eq2wR.7jB29
|
|
::
|
|
[%txt %robots ~]
|
|
:- ~
|
|
%^ tuff 200 text//plain
|
|
%- role
|
|
:~ 'User-agent: *'
|
|
'Disallow: /'
|
|
==
|
|
==
|
|
::
|
|
++ howa :: ford %wasp request
|
|
|= [tea=wire dep=@uvH]
|
|
(miff tea %f [%wasp our dep])
|
|
::
|
|
++ huff :: request by ship
|
|
|= [our=ship cip=clip pul=purl moh=moth]
|
|
^- [p=hole q=cyst]
|
|
=* sec p.p.pul
|
|
:: =+ ^= sef ^- serf
|
|
:: =+ suf=(~(get by own) our)
|
|
:: ?^ suf u.suf
|
|
:: =+ sef=*serf
|
|
:: sef(pef (cat 3 gub (rsh 3 1 (scot %p our)))) :: XX transitional
|
|
:: =+ ^= saw ^- [p=hole q=cyst]
|
|
=+ pef=(cat 3 gub (rsh 3 1 (scot %p our)))
|
|
=+ lig=(coss pef q.moh)
|
|
:: ?^ lig
|
|
:: =+ cyz=(need (~(get by wup.sef) u.lig))
|
|
:: [u.lig cyz(cug ~)]
|
|
=+ ses=(rsh 3 1 (scot %p (end 6 1 ney)))
|
|
:- ses
|
|
^- cyst
|
|
:* ^- cred
|
|
:* [sec q.p.pul r.p.pul]
|
|
~
|
|
(rsh 3 1 (scot %p (end 6 1 (shaf %oryx ses))))
|
|
::
|
|
=+ lag=(~(get by q.moh) %accept-language)
|
|
?~(lag ~ ?~(u.lag ~ [~ i.u.lag]))
|
|
::
|
|
cip
|
|
~
|
|
==
|
|
::
|
|
:: ~
|
|
::
|
|
:_ ~
|
|
%^ cat 3
|
|
(cat 3 (cat 3 pef '=') ses)
|
|
:: (cat 3 '; HttpOnly' ?.(sec '' '; Secure'))
|
|
'; Path=/; HttpOnly'
|
|
::
|
|
now
|
|
:: ~
|
|
:: [1 ~]
|
|
==
|
|
:: abet:work:(~(into ya [our p.saw] sef q.saw) pul moh)
|
|
::
|
|
++ jive :: success json
|
|
|= jon=json
|
|
(resp 205 application//json (pojo jon))
|
|
::
|
|
++ muff :: return card
|
|
|= gef=gift
|
|
+>(mow :_(mow [hen %give gef]))
|
|
::
|
|
++ miff :: pass card
|
|
|= noe=[wire note]
|
|
+>(mow :_(mow [hen %pass noe]))
|
|
::
|
|
++ resp :: mime response
|
|
|= [sas=@uG mit=mite bod=tape]
|
|
(muff (tuff sas mit (crip bod)))
|
|
::
|
|
++ tuff :: mimed response
|
|
|= [sas=@uG mit=mite rez=@]
|
|
^- gift
|
|
[%thou sas ~[content-type/(moon mit)] [~ (taco rez)]]
|
|
::
|
|
:: ++ myth :: load session
|
|
:: |= [our=ship ses=hole]
|
|
:: =+ suf=(~(get by own) our)
|
|
:: ?~ suf ~
|
|
:: =+ cuz=(~(get by wup.u.suf) ses)
|
|
:: ?~ cuz ~
|
|
:: [~ u=~(. ya [our ses] u.suf u.cuz)]
|
|
:: ::
|
|
:: ++ noon :: login page
|
|
:: |= [our=ship ses=hole whu=(unit ship) rul=tape]
|
|
:: ^- manx
|
|
:: =+ ^= sic ^- manx
|
|
:: ;script:'''
|
|
:: var seal = {
|
|
:: who: goal,
|
|
:: url: burl,
|
|
:: pas: null,
|
|
:: ses: sesh
|
|
:: }
|
|
:: var hist = []
|
|
:: var hind = 0
|
|
:: $(
|
|
:: function() {
|
|
:: $input = $('#input .line')
|
|
:: $prompt = $('#input .prompt')
|
|
:: $prompt.addClass('prefix')
|
|
:: $output = $('#output')
|
|
:: $input.focus()
|
|
:: $('body').click(function() { $input.focus() })
|
|
:: ctrl = false;
|
|
|
|
:: start = function(ship) {
|
|
:: $prompt.text('vessel: ~')
|
|
:: $input.attr('placeholder', 'ship-name')
|
|
:: if(ship) {
|
|
:: $input.val(ship)
|
|
:: }
|
|
:: }
|
|
|
|
:: ident = function() {
|
|
:: seal.who = $input.val()
|
|
|
|
:: if( (seal.who.length != 13) &&
|
|
:: (seal.who.length != 6) &&
|
|
:: (seal.who.length != 3) )
|
|
:: {
|
|
:: $output.text('not a ship name - try again.');
|
|
:: return false;
|
|
:: }
|
|
|
|
:: if(seal.who !== host) {
|
|
:: var all = $.extend({}, seal, {oth:host});
|
|
:: delete all.pas;
|
|
|
|
:: console.log('redirect')
|
|
:: window.location=
|
|
:: "http://"+seal.who+".urbit.org/gul?"
|
|
:: + $.param(all);
|
|
:: return false;
|
|
:: }
|
|
|
|
:: $output.text($prompt.text() + " " + seal.who)
|
|
:: $input.val('')
|
|
:: $input.attr('placeholder', 'ronber-bacnub-hanmev-labnyd')
|
|
:: $prompt.text('secret: ~')
|
|
|
|
:: return true;
|
|
:: }
|
|
|
|
:: login = function() {
|
|
:: seal.pas = $input.val()
|
|
:: var oth = /[&?]oth=[^&]*/.exec(location.search)
|
|
:: if(oth && oth.length)
|
|
:: seal.oth = oth[0].slice(5)
|
|
|
|
:: output = $output.html()
|
|
:: console.log($output.html())
|
|
:: $output.html(output.replace(
|
|
:: 'sorry. please try again.<br>',''))
|
|
|
|
:: $.post("/pul", seal, function(data,xhr,status) {
|
|
:: console.log(data);
|
|
:: if(data.ok == true) {
|
|
:: document.location = data.next;
|
|
:: } else {
|
|
:: $output.prepend('sorry. please try again.<br>')
|
|
:: }
|
|
:: })
|
|
:: }
|
|
|
|
:: steps = [ident,login]
|
|
:: step = 0
|
|
:: start(seal.who)
|
|
:: if(seal.who) {
|
|
:: ident()
|
|
:: step++
|
|
:: }
|
|
|
|
:: $input.on('keydown', function(e) {
|
|
:: if(e.keyCode == 17) {
|
|
:: ctrl = true
|
|
:: return;
|
|
:: }
|
|
|
|
:: if(e.keyCode == 68 &&
|
|
:: ctrl == true &&
|
|
:: step == 1) {
|
|
:: $output.text('')
|
|
:: step = 0
|
|
:: start(null)
|
|
:: return;
|
|
:: }
|
|
|
|
:: if(e.keyCode == 13) {
|
|
:: if(steps[step]() && step < steps.length-1)
|
|
:: step++
|
|
:: return;
|
|
:: }
|
|
:: });
|
|
|
|
:: $input.on('keyup', function(e) {
|
|
:: if(e.keyCode == 17) {
|
|
:: ctrl = false
|
|
:: }
|
|
:: });
|
|
:: })
|
|
:: '''
|
|
:: =+ ^= cof
|
|
:: ;=
|
|
:: ; var host = '{(trip (rsh 3 1 (scot %p our)))}';
|
|
:: ; var goal = '{?~(whu ~ (trip (rsh 3 1 (scot %p u.whu))))}';
|
|
:: ; var burl = '{rul}';
|
|
:: ; var sesh = '{(trip ses)}';
|
|
:: ==
|
|
:: => .(+.sic (weld `marl`cof `marl`+.sic))
|
|
:: =+ jqu="//ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"
|
|
:: =+ ^= hed
|
|
:: ;head
|
|
:: ;title: urbit login
|
|
:: ;script(type "text/javascript", src jqu);
|
|
:: ;style:'''
|
|
:: body {
|
|
:: margin: 60px 120px;
|
|
:: font: normal 12px "Menlo" monospace;
|
|
:: background-color: #000;
|
|
:: color: #fff;
|
|
:: }
|
|
|
|
:: #output {
|
|
|
|
:: }
|
|
|
|
:: #input .prompt {
|
|
:: display: inline-block;
|
|
:: margin-right: 12px;
|
|
:: }
|
|
|
|
:: #input .line {
|
|
:: outline: none;
|
|
:: width: 80%;
|
|
:: border: 0;
|
|
:: background-color: transparent;
|
|
:: color: #fff;
|
|
:: font: normal 12px "Menlo" monospace;
|
|
:: }
|
|
:: '''
|
|
:: ==
|
|
:: =+ ^= bod ^- manx
|
|
:: ;body
|
|
:: ;div#output;
|
|
:: ;div#input
|
|
:: ;div.prompt;
|
|
:: ;input.line(type "text");
|
|
:: ==
|
|
:: ==
|
|
:: =. +.bod (weld `marl`+.bod `marl`~[sic])
|
|
:: ;html
|
|
:: ;+ hed
|
|
:: ;+ bod
|
|
:: ==
|
|
:: ::
|
|
:: ++ rong
|
|
:: |= are=ares
|
|
:: %- jobe
|
|
:: :- [%ok %b |]
|
|
:: ?~ are ~
|
|
:: :+ [%err %s p.u.are]
|
|
:: :+ %res %s
|
|
:: %- crip
|
|
:: %+ slag 2
|
|
:: ^- tape
|
|
:: %+ roll q.u.are
|
|
:: |= [p=tank q=tape]
|
|
:: :(weld q "\\n" ~(ram re p))
|
|
:: ~
|
|
:: ::
|
|
:: ++ soon
|
|
:: |= [ful=? sem=stem ouy=_yo:ya can=@ud mab=?(%mess %show) jon=json]
|
|
:: ^+ yo:ya
|
|
:: =+ huq=``[%json !>(jon)]
|
|
:: ?~ num.sem
|
|
:: =+ woy=(yule:ouy ?-(mab %mess %meg, %show %sub))
|
|
:: (hear:woy huq)
|
|
:: ?- -.u.num.sem
|
|
:: %&
|
|
:: =+ yoo=abet:(busk:(yule:ouy %nil) p.u.num.sem 0 huq)
|
|
:: yoo(can.sub.siq (~(put by can.sub.siq.yoo) can sem(num ~)))
|
|
:: %|
|
|
:: =+ ^= yoo
|
|
:: =< abet
|
|
:: %^ busk:(yule:(hear:(yule:ouy %sub) huq) %nil)
|
|
:: p.u.num.sem
|
|
:: 0
|
|
:: `[%& %json !>((joba %ok %b &))]
|
|
:: yoo(can.sub.siq (~(put by can.sub.siq.yoo) can sem(num ~)))
|
|
:: ==
|
|
:: ::
|
|
:: ++ wrap
|
|
:: |= [sem=stem jon=json]
|
|
:: %- jobe
|
|
:: :~ [%ship %s (rsh 3 1 (scot %p p.hap.sem))]
|
|
:: [%appl %s q.hap.sem]
|
|
:: [%path %s (crip <pax.sem>)]
|
|
:: [%data `json`jon]
|
|
:: ==
|
|
:: ::
|
|
++ ya :: session engine
|
|
=| [[our=ship ses=hole] ~] ::serf cyst]
|
|
:: =* sef ->-
|
|
:: =* cyz ->+
|
|
|%
|
|
++ flux :: credential caboose
|
|
|= [nyp=path quy=quay] ^- coin
|
|
:* %many
|
|
[%$ %ta ~]
|
|
[%blob *cred] ::ced]
|
|
|- ^- (list coin)
|
|
?~ quy ~
|
|
[[%$ %t p.i.quy] [%$ %t q.i.quy] $(quy t.quy)]
|
|
==
|
|
:: ++ abet :: resolve engine
|
|
:: ^+ ..ya
|
|
:: %= ..ya
|
|
:: own
|
|
:: (~(put by own) our sef(wup (~(put by wup) ses cyz)))
|
|
:: ==
|
|
:: ::
|
|
:: ++ auth :: remote authorize
|
|
:: |= him=ship
|
|
:: %_(+> aut.ced (~(put ju aut.ced) %$ (scot %p him)))
|
|
:: ::
|
|
:: ++ iota :: fun change response
|
|
:: |= [num=@ud rot=riot]
|
|
:: ^+ +>
|
|
:: =+ pup=(~(get by q.rey) num)
|
|
:: ?~ pup
|
|
:: ~& [%iota-lost ses num rot]
|
|
:: +>.$
|
|
:: ?> ?=(%way pez.u.pup)
|
|
:: +>.$(q.rey (~(put by q.rey) num u.pup(pez [%haz rot])))
|
|
:: ::
|
|
:: ++ dove :: console waiting
|
|
:: |= [jon=json yov=(list ,@ud)]
|
|
:: ^+ +>
|
|
:: =+ noz=`pest`[%fin %mid /text/json (tact (pojo jon))]
|
|
:: |- ^+ +>.^$
|
|
:: ?~ yov +>.^$
|
|
:: =+ pup=(~(get by q.rey) i.yov)
|
|
:: ?~ pup $(yov t.yov)
|
|
:: ?> ?=(%way pez.u.pup)
|
|
:: $(yov t.yov, q.rey (~(put by q.rey) i.yov u.pup(pez noz)))
|
|
:: ::
|
|
:: ++ duty |= [nap=@ud you=ship] :: interface script
|
|
:: ^- cord
|
|
:: %^ cat 3
|
|
:: %- crip
|
|
:: =- "window.urb = {(pojo (jobe -))}\0a"
|
|
:: :~
|
|
:: [%ship (jape |1:<our>)]
|
|
:: [%port (jone nap)]
|
|
:: [%oryx %s orx.ced]
|
|
:: [%auto %b %&]
|
|
:: [%user (jape |1:<you>)]
|
|
:: ==
|
|
:: '''
|
|
:: window.urb.seqn_u = 0
|
|
:: window.urb.seqn_h = 0
|
|
:: window.urb.dely = 0
|
|
:: window.urb.puls = 0
|
|
:: window.urb.cabs = {}
|
|
:: window.urb.perms = {
|
|
:: pol:"gie",
|
|
:: sub:"tis",
|
|
:: uns:"tiu",
|
|
:: mes:"tim",
|
|
:: heb:"tih"
|
|
:: }
|
|
|
|
:: window.urb.req = function(method,url,params,json,cb) {
|
|
:: var xhr = new XMLHttpRequest()
|
|
:: xhr.open(method.toUpperCase(), url)
|
|
:: if(json)
|
|
:: xhr.setRequestHeader("content-type", "text/json")
|
|
|
|
:: _data = {}
|
|
:: if(params.data) { _data.data = params.data; }
|
|
:: if(params.ship) { _data.ship = params.ship; }
|
|
:: if(params.path) { _data.path = params.path; }
|
|
:: if(params.appl) { _data.appl = params.appl; }
|
|
:: if(params.mark) { _data.mark = params.mark; }
|
|
:: __data = {oryx: window.urb.oryx, xyro: _data}
|
|
|
|
:: if(cb) {
|
|
:: xhr.onload = function() {
|
|
:: try {
|
|
:: err = null
|
|
:: res = {
|
|
:: status:this.status,
|
|
:: data: JSON.parse(this.responseText)
|
|
:: }
|
|
:: if(res.data.reload)
|
|
:: res.reload = res.data.reload
|
|
:: } catch(e) {
|
|
:: err = {
|
|
:: message:"Failed to parse JSON",
|
|
:: raw:this.responseText
|
|
:: }
|
|
:: res = null
|
|
:: }
|
|
:: cb(err,res)
|
|
:: }
|
|
:: xhr.onerror = function() {
|
|
:: cb({
|
|
:: status:this.status,
|
|
:: data:this.responseText
|
|
:: })
|
|
:: }
|
|
:: }
|
|
:: xhr.send(JSON.stringify(__data))
|
|
:: }
|
|
|
|
:: window.urb.reqq = []
|
|
:: window.urb.qreq = function(method,url,params,json,cb) {
|
|
:: walk = function() {
|
|
:: qobj = {}
|
|
:: qobj.oargs = window.urb.reqq[0]
|
|
:: qobj.nargs = [].slice.apply(qobj.oargs,[0,4])
|
|
:: qobj.nargs.push(function(){
|
|
:: if(this.oargs[4])
|
|
:: this.oargs[4].apply(window.urb,arguments)
|
|
:: window.urb.reqq.shift()
|
|
:: if(window.urb.reqq.length > 0)
|
|
:: walk()
|
|
:: }.bind(qobj))
|
|
:: window.urb.req.apply(this,qobj.nargs)
|
|
:: }
|
|
:: l = window.urb.reqq.length
|
|
:: window.urb.reqq.push(arguments);
|
|
:: if(l == 0) { walk() }
|
|
:: }
|
|
|
|
:: window.urb.gsig = function(params) {
|
|
:: path = params.path
|
|
:: if(!path)
|
|
:: path = ""
|
|
:: return params.appl+","+
|
|
:: path.replace(/[^\x00-\x7F]/g, "")+","+
|
|
:: params.ship
|
|
:: }
|
|
|
|
:: window.urb.poll = function(params,cb) {
|
|
:: if(!params)
|
|
:: throw new Error("You must supply params to urb.poll.")
|
|
|
|
:: var method, perm, url, $this
|
|
:: method = "get"
|
|
:: perm = params.type ? this.perms[params.type] : "gie"
|
|
:: json = false
|
|
:: if(perm[0] == "t") {
|
|
:: method = "put"
|
|
:: json = true
|
|
:: }
|
|
:: seqn = this.seqn_u
|
|
:: if(params.seqn)
|
|
:: seqn = params.seqn()
|
|
:: url = [perm,this.user,this.port,seqn]
|
|
:: url = "/"+url.join("/")
|
|
|
|
:: this.puls = 1
|
|
|
|
:: $this = this
|
|
:: this.req(method,url,params,json,function(err,data) {
|
|
:: if(data){
|
|
:: if (data.reload) {
|
|
:: return document.location.reload()
|
|
:: } else {
|
|
:: fn = $this.gsig(data.data)
|
|
:: if($this.cabs[fn]) {
|
|
:: $this.cabs[fn].call(this,err,
|
|
:: {status: data.status, data: data.data.data})
|
|
:: }
|
|
:: }
|
|
:: }
|
|
|
|
:: dely = params.dely ? params.dely : $this.dely
|
|
|
|
:: if(err)
|
|
:: dely = dely+Math.ceil(dely*.02)
|
|
:: else {
|
|
:: $this.dely = 0
|
|
:: if(params.incs)
|
|
:: params.incs()
|
|
:: else
|
|
:: $this.seqn_u++
|
|
:: }
|
|
|
|
:: setTimeout(function() {
|
|
:: $this.poll(params,cb)
|
|
:: },dely)
|
|
:: })
|
|
:: }
|
|
|
|
:: if (window.urb.auto) {
|
|
:: var tries = 0
|
|
:: var cnt = 0
|
|
:: var param = {
|
|
:: type:"pol"
|
|
:: }
|
|
:: window.urb.poll(param)
|
|
:: }
|
|
|
|
:: window.urb.heartbeat = function() {
|
|
:: this.poll({
|
|
:: type:"heb",
|
|
:: ship:this.ship,
|
|
:: dely:30000,
|
|
:: seqn:function() {
|
|
:: return window.urb.seqn_h
|
|
:: },
|
|
:: incs:function() {
|
|
:: window.urb.seqn_h = window.urb.seqn_h+1
|
|
:: }
|
|
:: },function() {
|
|
:: console.log('heartbeat.')
|
|
:: })
|
|
:: }
|
|
:: window.urb.heartbeat()
|
|
:: '''
|
|
:: ::
|
|
:: ++ fape :: dispatch %ape
|
|
:: |= [fur=(unit term) you=@p paw=path]
|
|
:: ^- (unit seam)
|
|
:: ?> ?=(~ fur)
|
|
:: ?> ?=([@ @ ~] paw)
|
|
:: :- ~
|
|
:: :* %ape
|
|
:: you
|
|
:: (slav %ui (cat 3 '0i' i.paw))
|
|
:: (slav %ui (cat 3 '0i' i.t.paw))
|
|
:: ==
|
|
:: ::
|
|
:: ++ fapg :: dispatch %apg
|
|
:: |= [fur=(unit term) you=@p paw=path]
|
|
:: ^- (unit seam)
|
|
:: =+ for=?^(fur u.fur %html)
|
|
:: ?> ?=(^ paw)
|
|
:: :- ~
|
|
:: :* %apg
|
|
:: (need ((sand %tas) i.paw))
|
|
:: you
|
|
:: for
|
|
:: (turn t.paw |=(a=@ `@ta`(need ((sand %ta) a))))
|
|
:: ==
|
|
:: ::
|
|
:: ++ faph :: dispatch %aph
|
|
:: |= [fur=(unit term) you=@p paw=path moh=moth]
|
|
:: ^- (unit seam)
|
|
:: ?> ?=(~ fur)
|
|
:: ?> ?=([@ @ ~] paw)
|
|
:: :- ~
|
|
:: :* %aph
|
|
:: you
|
|
:: (slav %ui (cat 3 '0i' i.paw))
|
|
:: (slav %ui (cat 3 '0i' i.t.paw))
|
|
:: (need (ecci orx.ced moh))
|
|
:: ==
|
|
:: ::
|
|
:: ++ fapm :: dispatch %apm
|
|
:: |= [fur=(unit term) you=@p paw=path moh=moth]
|
|
:: ^- (unit seam)
|
|
:: ?> ?=(~ fur)
|
|
:: ?> ?=([@ @ ~] paw)
|
|
:: :- ~
|
|
:: :* %apm
|
|
:: you
|
|
:: (slav %ui (cat 3 '0i' i.paw))
|
|
:: (slav %ui (cat 3 '0i' i.t.paw))
|
|
:: (need (eccu orx.ced moh))
|
|
:: ==
|
|
:: ::
|
|
:: ++ fapp
|
|
:: |= [fur=(unit term) you=@p paw=path]
|
|
:: ?> ?=([~ %js] fur)
|
|
:: ?> ?=(?([%hart ~] [@ %hart ~]) paw)
|
|
:: :- ~
|
|
:: :* %app
|
|
:: you
|
|
:: ?~ t.paw
|
|
:: ~
|
|
:: (some (slav %ui (cat 3 '0i' i.paw)))
|
|
:: ==
|
|
:: ::
|
|
:: ++ faps :: dispatch %aps
|
|
:: |= [fur=(unit term) you=@p paw=path moh=moth]
|
|
:: ^- (unit seam)
|
|
:: ?> ?=(~ fur)
|
|
:: ?> ?=([@ ~] paw)
|
|
:: :- ~
|
|
:: :* %aps
|
|
:: you
|
|
:: (slav %ui (cat 3 '0i' i.paw))
|
|
:: (need (ecca orx.ced moh))
|
|
:: ==
|
|
:: ::
|
|
:: ++ fapu :: dispatch %apu
|
|
:: |= [fur=(unit term) you=@p paw=path moh=moth]
|
|
:: ^- (unit seam)
|
|
:: ?> ?=(~ fur)
|
|
:: ?> ?=([@ ~] paw)
|
|
:: :- ~
|
|
:: :* %apu
|
|
:: you
|
|
:: (slav %ui (cat 3 '0i' i.paw))
|
|
:: (need (ecca orx.ced moh))
|
|
:: ==
|
|
:: ::
|
|
:: ++ flea :: permissive decimal
|
|
:: |= txt=@t
|
|
:: ^- (unit ,@ud)
|
|
:: =+ zac=(slay txt)
|
|
:: ?: ?=([~ %$ %ud @] zac)
|
|
:: [~ q.p.u.zac]
|
|
:: =+ soc=(rush txt dim:ag)
|
|
:: ?~(soc ~ [~ u.soc])
|
|
:: ::
|
|
:: ++ foal :: url from query
|
|
:: |= [nam=@t yaq=(map ,@t ,@t)]
|
|
:: ^- (unit purl)
|
|
:: (biff (~(get by yaq) %url) epur)
|
|
:: ::
|
|
:: ++ folk :: seal from query
|
|
:: |= quy=quay
|
|
:: ^- (unit seal)
|
|
:: =+ yaq=(~(gas by *(map ,@t ,@t)) quy)
|
|
:: =+ pyl=(foal %url yaq)
|
|
:: =+ wit==(%yes (fall (~(get by yaq) %wit) %no))
|
|
:: =+ huw=(~(get by yaq) %who)
|
|
:: =+ whu=?~(huw ~ (rush u.huw fed:ag))
|
|
:: =+ pus=(~(get by yaq) %pas)
|
|
:: =+ tuh=(~(get by yaq) %oth)
|
|
:: =+ thu=?~(tuh ~ (rush u.tuh fed:ag))
|
|
:: =+ sus=(~(get by yaq) %ses)
|
|
:: =+ foy=?~(sus ~ ?~(thu ~ [~ u.thu u.sus]))
|
|
:: ?~ pyl ~
|
|
:: ?: &(wit |(=(~ whu) =(~ ses))) ~
|
|
:: :: ~& [%folk-quay whu u.pyl wit foy pus]
|
|
:: [~ whu u.pyl wit foy pus]
|
|
:: ::
|
|
:: ++ fool :: domestic login get
|
|
:: |= quy=quay
|
|
:: ^- (unit seam)
|
|
:: (bind (folk quy) |=(a=seal [%lon a]))
|
|
:: ::
|
|
:: ++ foom :: domestic login post
|
|
:: |= moh=moth
|
|
:: ^- (unit seam)
|
|
:: ?. ?& ?=(^ r.moh)
|
|
:: :: .= [~ 'application/x-www-form-urlencoded' ~]
|
|
:: :: (~(get by q.moh) 'content-type')
|
|
:: == ~
|
|
:: =+ yuq=(rush q.u.r.moh yquy:epur)
|
|
:: ?~(yuq ~ (fool u.yuq))
|
|
:: ::
|
|
:: ++ flub :: console request
|
|
:: |= [paw=(list ,@t) muh=(unit moth)]
|
|
:: ^- (unit seam)
|
|
:: ?: ?=([@ ~] paw)
|
|
:: ?^ muh ~
|
|
:: =+ fee=(flea i.paw)
|
|
:: ?~ fee ~
|
|
:: [~ %con u.fee]
|
|
:: ?. ?=([@ @ ~] paw) ~
|
|
:: =+ [fee=(flea i.paw) fum=(flea i.t.paw)]
|
|
:: ?. &(?=(^ fee) ?=(^ fum)) ~
|
|
:: ?: |(?=(~ muh) ?=(~ r.u.muh))
|
|
:: [~ %cog u.fee u.fum]
|
|
:: ?. =([~ 'text/json' ~] (~(get by q.u.muh) 'content-type'))
|
|
:: ~
|
|
:: =+ jun=`(unit json)`(rush q.u.r.u.muh apex:poja)
|
|
:: ?~ jun
|
|
:: ~
|
|
:: [~ %cop u.fee u.fum u.jun]
|
|
:: ::
|
|
:: ::
|
|
:: ++ foin :: version request
|
|
:: |= [fur=(unit term) you=@p paw=(list ,@t) quy=quay]
|
|
:: ^- (unit seam)
|
|
:: =. aut.ced (~(put ju aut.ced) %$ (scot %p you)) :: XX backwards
|
|
:: ?. ?& ?=(~ fur)
|
|
:: ?=(~ quy)
|
|
:: ?=([@ @ ~] paw)
|
|
:: ((sane %tas) i.t.paw)
|
|
:: == ~
|
|
:: %+ bind
|
|
:: ^- (unit moat)
|
|
:: =+ soy=(slay i.paw)
|
|
:: ?~ soy ~
|
|
:: ?+ u.soy
|
|
:: ~
|
|
:: ::
|
|
:: [%$ ?(%da %ud %tas) @]
|
|
:: [~ (case p.u.soy) (case p.u.soy) /]
|
|
:: ::
|
|
:: [%many [%$ ?(%da %ud %tas) @] [%$ ?(%da %ud %tas) @] ~]
|
|
:: [~ (case i.p.u.soy) (case i.t.p.u.soy) /]
|
|
:: ==
|
|
:: |= mot=moat
|
|
:: `seam`[%det i.t.paw mot]
|
|
:: ::
|
|
:: ++ funk :: functional request
|
|
:: |= [nep=@tas fur=(unit term) you=@p paw=(list ,@t) quy=quay]
|
|
:: ^- (unit seam)
|
|
:: =. aut.ced (~(put ju aut.ced) %$ (scot %p you)) :: XX backwards
|
|
:: =+ won==(%n (rsh 3 2 nep))
|
|
:: %+ bind
|
|
:: ^- (unit ,[mark tube])
|
|
:: =+ ^= zac ^- (unit ,[p=@ta q=path])
|
|
:: ?: won
|
|
:: [~ (scot %da now) paw]
|
|
:: ?~ paw ~
|
|
:: =+ zac=(slay i.paw)
|
|
:: ?. ?=([~ %$ ?(%ud %da %tas) *] zac) ~
|
|
:: [~ i.paw t.paw]
|
|
:: ?: ?| ?=(~ zac)
|
|
:: ?=(~ q.u.zac)
|
|
:: !(levy t.q.u.zac (sane %ta))
|
|
:: == ~
|
|
:: :+ ~ ?~(fur %html u.fur)
|
|
:: ^- tube
|
|
:: :* (scot %p our)
|
|
:: i.q.u.zac
|
|
:: p.u.zac
|
|
:: t.q.u.zac
|
|
:: ==
|
|
:: |= [for=mark toe=tube]
|
|
:: ^- seam
|
|
:: =+ nyp=?.(=(%i (cut 3 [1 1] nep)) /[nep] /[nep]/(rsh 3 1 (scot %p you)))
|
|
:: :^ %fun for
|
|
:: toe(s (weld s.toe `path`[(flux nyp quy) %web ~]))
|
|
:: ?. won ~
|
|
:: :_ ~
|
|
:: =+ pey="{(scag 2 (trip nep))}v"
|
|
:: =. pey %+ weld pey
|
|
:: ?. =(%i (snag 1 pey))
|
|
:: ""
|
|
:: "/{(slag 1 (scow %p you))}"
|
|
:: =+ ven=+((,@ (need (sky %cw p.toe q.toe r.toe ~))))
|
|
:: ;script@"/~/on/{pey}/{(scow %ud ven)}/{(trip q.toe)}.js";
|
|
:: ::
|
|
:: ++ holt :: login redirect
|
|
:: |= [whu=(unit ship) pul=purl]
|
|
:: ^- (unit seam)
|
|
:: :+ ~
|
|
:: %red
|
|
:: :: :+ [p.p.pul q.p.pul r.p.pul]
|
|
:: :+ [| q.p.pul r.p.pul] :: XX https
|
|
:: [p.q.pul /gul] :: XX js discrimination
|
|
:: :- [%url (crip (earn pul(p.p |)))]
|
|
:: ?~ whu ~
|
|
:: [%who (rsh 3 1 (scot %p u.whu))]~
|
|
:: ::
|
|
:: ++ holy :: structured request
|
|
:: |= [pul=purl moh=moth]
|
|
:: ^- (unit seam)
|
|
:: ?~ q.q.pul ~
|
|
:: =* nep i.q.q.pul
|
|
:: =+ paw=t.q.q.pul
|
|
:: =+ [one=(end 3 1 nep) two=(cut 3 [1 1] nep) tri=(cut 3 [2 1] nep)]
|
|
:: ?. ?& ?- p.moh
|
|
:: %conn | :: connect
|
|
:: %delt | :: delete
|
|
:: %get =(%g one) :: get
|
|
:: %head =(%g one) :: head
|
|
:: %opts | :: options
|
|
:: %post =(%p one) :: post
|
|
:: %put =(%t one) :: put
|
|
:: %trac | :: trace
|
|
:: ==
|
|
:: ::
|
|
:: ?+ two |
|
|
:: %e & :: stranger
|
|
:: %u p.p.pul :: guest
|
|
:: %i p.p.pul :: neighbor
|
|
:: %o p.p.pul :: identified
|
|
:: ==
|
|
:: ::
|
|
:: ?= $? %g :: app get
|
|
:: %c :: console
|
|
:: %e :: app update
|
|
:: %f :: functional
|
|
:: %v :: functional version
|
|
:: %l :: local login
|
|
:: %m :: app message
|
|
:: %r :: app response
|
|
:: %s :: app subscribe
|
|
:: %h :: app heartbeat
|
|
:: %p :: app script by port
|
|
:: %n :: now
|
|
:: %u :: app unsubscribe
|
|
:: %z :: app version
|
|
:: ==
|
|
:: tri
|
|
:: ::
|
|
:: !&(=(%c tri) !=(%o two))
|
|
:: =(3 (met 3 nep))
|
|
:: ==
|
|
:: ?: &(=(%get p.moh) ?=([~ [@ ~]] q.pul)) :: app shortcut
|
|
:: =- $(q.pul [`%html -])
|
|
:: =+ ato=(~(tap in (~(get ju aut.ced) %$)))
|
|
:: =+ att=`(list ship)`(murn ato |=(a=span (slaw %p a)))
|
|
:: ?~ att [%geg i.q.q.pul ~]
|
|
:: ?: (~(has in (sa att)) our)
|
|
:: [%gog i.q.q.pul ~]
|
|
:: :+ %gig
|
|
:: (rsh 3 1 (scot %p (snag 0 (sort att lth))))
|
|
:: /[i.q.q.pul]
|
|
:: ~
|
|
:: =^ yun paw
|
|
:: ?+ two ~
|
|
:: ?(%e %u) [`@`(shaf %fake ses) paw]
|
|
:: %i ?~ paw ~
|
|
:: [(slav %p (cat 3 '~' i.paw)) t.paw]
|
|
:: %o [our paw]
|
|
:: ==
|
|
:: ?: &(=(%i two) !(lash yun) !=(yun (shaf %fake ses)))
|
|
:: (holt [~ yun] pul)
|
|
:: ?: &(=(%o two) !(lash our))
|
|
:: (holt [~ our] pul)
|
|
:: ?+ one ~
|
|
:: %g
|
|
:: ?+ tri ~
|
|
:: ?(%f %n) (funk nep p.q.pul yun paw r.pul)
|
|
:: %v (foin p.q.pul yun paw r.pul)
|
|
:: %c (flub paw ~)
|
|
:: %l (fool r.pul)
|
|
:: %g (fapg p.q.pul yun paw)
|
|
:: %e (fape p.q.pul yun paw)
|
|
:: %p (fapp p.q.pul yun paw)
|
|
:: ==
|
|
:: ::
|
|
:: %p
|
|
:: ?+ tri ~
|
|
:: %l (foom moh)
|
|
:: %m (fapm p.q.pul yun paw moh)
|
|
:: %s (faps p.q.pul yun paw moh)
|
|
:: %u (fapu p.q.pul yun paw moh)
|
|
:: ==
|
|
:: ::
|
|
:: %t
|
|
:: ?+ tri ~
|
|
:: %c (flub paw [~ moh])
|
|
:: %h (faph p.q.pul yun paw moh)
|
|
:: %m (fapm p.q.pul yun paw moh)
|
|
:: %s (faps p.q.pul yun paw moh)
|
|
:: %u (fapu p.q.pul yun paw moh)
|
|
:: ==
|
|
:: ==
|
|
:: ::
|
|
:: ++ idle :: cancel request
|
|
:: |= num=@ud
|
|
:: ^+ +>
|
|
:: =+ pup=(~(get by q.rey) num)
|
|
:: ?~ pup +>.$
|
|
:: =. q.rey (~(del by q.rey) num)
|
|
:: ?. ?=(%way pez.u.pup) +>.$
|
|
:: ?: ?=(%det -.som.u.pup)
|
|
:: +>.$(..ya (hoot our num ses `riff`[p.som.u.pup ~]))
|
|
:: ?: ?=(%fun -.som.u.pup)
|
|
:: +>.$(..ya (hone our num ses))
|
|
:: +>.$
|
|
:: ::
|
|
:: ++ bush :: error response
|
|
:: |= [cod=@ud msg=@t num=@ud]
|
|
:: ^+ +>
|
|
:: =+ pup=(~(get by q.rey) num)
|
|
:: ?~ pup +>.$
|
|
:: %= +>.$
|
|
:: q.rey
|
|
:: %+ ~(put by q.rey) num
|
|
:: %= u.pup
|
|
:: pez
|
|
:: `pest`[%fin %raw cod ~[content-type/'text/plain'] `(taco msg)]
|
|
:: ==
|
|
:: ==
|
|
:: ::
|
|
:: ++ bust :: no-content response
|
|
:: |= [cod=@ud num=@ud]
|
|
:: ^+ +>
|
|
:: =+ pup=(~(get by q.rey) num)
|
|
:: ?~ pup +>.$
|
|
:: :: ?> ?=(%way pez.u.pup)
|
|
:: %= +>.$
|
|
:: q.rey
|
|
:: %+ ~(put by q.rey) num
|
|
:: u.pup(pez [%fin %raw cod *mess `*octs])
|
|
:: ==
|
|
:: ::
|
|
:: ++ erle :: url localize
|
|
:: |= [his=ship pul=purl] ^- purl
|
|
:: =+ pod=(mo (turn (~(tap by dop)) |=([p=host q=ship] [q p])))
|
|
:: ?: (~(has by pod) his)
|
|
:: pul(p [& ~ (~(got by pod) his)])
|
|
:: ?: ?=(hoke r.p.pul)
|
|
:: ~| %no-port
|
|
:: pul(q.p [~ ?+(his !! %~zod 8.443)]) :: XX
|
|
:: pul(p [& ~ [~ /org/urbit/(rsh 3 1 (scot %p his))]])
|
|
:: ::
|
|
:: ++ inch :: function built
|
|
:: |= [num=@ud mez=(each bead (list tank))]
|
|
:: ^+ +>
|
|
:: =+ pup=(~(get by q.rey) num)
|
|
:: ?~ pup
|
|
:: ~& [%inch-lost ses num mez]
|
|
:: +>.$
|
|
:: ?> ?=(%way pez.u.pup)
|
|
:: +>.$(q.rey (~(put by q.rey) num u.pup(pez [%fud mez])))
|
|
:: ::
|
|
:: ++ into :: introduce
|
|
:: |= [pul=purl moh=moth]
|
|
:: ^+ +>
|
|
:: =+ num=p.rey
|
|
:: %= +>.$
|
|
:: lor (~(put by lor) hen num [%& our ses])
|
|
:: p.rey +(num)
|
|
:: q.rey
|
|
:: %+ ~(put by q.rey) num
|
|
:: ^- pimp
|
|
:: :* !?=(%head p.moh)
|
|
:: p.q.pul
|
|
:: hen
|
|
:: *seam
|
|
:: `pest`[%raw pul moh]
|
|
:: ~
|
|
:: ==
|
|
:: ==
|
|
:: ::
|
|
:: ++ iota :: change response
|
|
:: |= [num=@ud rot=riot]
|
|
:: ^+ +>
|
|
:: =+ pup=(~(get by q.rey) num)
|
|
:: ?~ pup
|
|
:: ~& [%iota-lost ses num rot]
|
|
:: +>.$
|
|
:: ?> ?=(%way pez.u.pup)
|
|
:: +>.$(q.rey (~(put by q.rey) num u.pup(pez [%haz rot])))
|
|
:: ::
|
|
:: ++ lass :: load secret
|
|
:: ^- @ta
|
|
:: =+ pax=/(scot %p our)/code/(scot %da now)/(scot %p our)
|
|
:: %^ rsh 3 1
|
|
:: (scot %p (,@ (need (sky %a pax))))
|
|
:: ::
|
|
:: ++ lash :: user is authorized
|
|
:: |=(a=ship (~(has ju aut.ced) %$ (scot %p a)))
|
|
:: ::
|
|
:: ++ redi :: js login redirect
|
|
:: |= pul=purl ^- tape
|
|
:: "window.location = '{(earn pul)}".
|
|
:: "{?~(r.pul "?" "&")}url=' +".
|
|
:: "encodeURIComponent(window.location)"
|
|
:: ::
|
|
:: ++ step :: step in work
|
|
:: |- ^+ +
|
|
:: =^ zib +.$
|
|
:: =+ yub=q.rey
|
|
:: |- ^- [(list ,[p=@ud q=pimp]) _+.^$]
|
|
:: ?~ yub [~ +.^$]
|
|
:: =^ sid +.^$ $(yub l.yub)
|
|
:: =^ dex +.^$ $(yub r.yub)
|
|
:: =^ top +.^$ (wink n.yub)
|
|
:: =+ pot=`(list ,[p=@ud q=pimp])`?~(top ~ [[p.n.yub u.top] ~])
|
|
:: [:(weld pot dex sid) +.^$]
|
|
:: +.$(q.rey (~(gas by `_q.rey`~) zib))
|
|
|
|
:: ++ wink :: advance request
|
|
:: |= [num=@ud pip=pimp]
|
|
:: ^- [(unit pimp) _+>]
|
|
:: :: ~& wink-do/[?@(pez.pip pez.pip -.pez.pip) -.som.pip]
|
|
:: ?- pez.pip
|
|
:: %way [[~ pip] +>.$]
|
|
:: %new
|
|
:: ?- -.som.pip
|
|
:: %ape :: stream update
|
|
:: :: ~& :~ %eyre-ape
|
|
:: :: [%owner our]
|
|
:: :: [%requester num]
|
|
:: :: [%app p.som.pip]
|
|
:: :: [%user q.som.pip]
|
|
:: :: [%instance r.som.pip]
|
|
:: :: [%stream s.som.pip]
|
|
:: :: [%request t.som.pip]
|
|
:: :: ==
|
|
:: [`(fall +< -(pez %way)) +>]:[pip (yoke num +.som.pip)]
|
|
:: ::
|
|
:: %apg :: simple get
|
|
:: :: ~& :~ %eyre-apg
|
|
:: :: [%owner our]
|
|
:: :: [%requester num]
|
|
:: :: [%app p.som.pip]
|
|
:: :: [%user q.som.pip]
|
|
:: :: [%logo r.som.pip]
|
|
:: :: [%path s.som.pip]
|
|
:: :: ==
|
|
:: :- [~ pip(pez %way)]
|
|
:: (yokg num p.som.pip q.som.pip s.som.pip)
|
|
:: ::
|
|
:: %aph :: heartbeat
|
|
:: :: ~& [%wink-aph +.som.pip]
|
|
:: (yokh num +.som.pip)
|
|
:: ::
|
|
:: %apm :: message
|
|
:: :: ~& [%wink-apm +.som.pip]
|
|
:: :- [~ pip(pez %way)]
|
|
:: (yokm num +.som.pip)
|
|
:: ::
|
|
:: %app :: script by port
|
|
:: :: ~& [%wink-app +.som.pip]
|
|
:: (yokp num +.som.pip)
|
|
:: ::
|
|
:: %aps :: subscribe
|
|
:: :: ~& [%wink-aps +.som.pip]
|
|
:: :- [~ pip(pez %way)]
|
|
:: (yoks num +.som.pip)
|
|
:: ::
|
|
:: %apu :: unsubscribe
|
|
:: :: ~& [%wink-apu +.som.pip]
|
|
:: (yoku num +.som.pip)
|
|
:: ::
|
|
:: %con
|
|
:: !!
|
|
:: ::
|
|
:: %cog
|
|
:: !!
|
|
:: ::
|
|
:: %cop
|
|
:: !!
|
|
:: ::
|
|
:: %det
|
|
:: :- [~ pip(pez %way)]
|
|
:: +>.$(..ya (hoot our num ses [p.som.pip ~ [%| q.som.pip]]))
|
|
:: ::
|
|
:: %fun
|
|
:: :- [~ pip(pez %way)]
|
|
:: =+ bem=`beam`(need (tome q.som.pip))
|
|
:: =+ kas=`silk`[%cast %mime `silk`[%boil p.som.pip bem ~]]
|
|
:: +>.$(..ya (honk our num ses kas))
|
|
:: ::
|
|
:: %lon
|
|
:: ^- [(unit pimp) _+>.$]
|
|
:: ?~ pus.p.som.pip
|
|
:: :_ +>.$
|
|
:: ?: ?~ whu.p.som.pip |
|
|
:: (lash u.whu.p.som.pip)
|
|
:: [~ pip(som [%red pul.p.som.pip])]
|
|
:: ?: wit.p.som.pip
|
|
:: [~ pip(pez [%who %$ (scot %p (need whu.p.som.pip))])]
|
|
:: =+ rul=(earn pul.p.som.pip)
|
|
:: =+ sus=?~(foy.p.som.pip ses q.u.foy.p.som.pip)
|
|
:: ~& auth-request/secret=`cord`lass
|
|
:: =+ ham=(noon our sus whu.p.som.pip rul)
|
|
:: [~ pip(pez [%fin %ham ham])]
|
|
:: ?. =(lass u.pus.p.som.pip)
|
|
:: :_ +>.$
|
|
:: :- ~
|
|
:: %= pip
|
|
:: pez
|
|
:: [%fin %mid /text/json (tact (pojo (jobe [%ok [%b |]]~)))]
|
|
:: ==
|
|
:: =. aut.ced (~(put ju aut.ced) %$ (scot %p (need whu.p.som.pip)))
|
|
:: ?~ foy.p.som.pip
|
|
:: =+ ^= jon
|
|
:: %- jobe
|
|
:: :~ [%ok [%b &]]
|
|
:: [%next (jape (earn pul.p.som.pip))]
|
|
:: ==
|
|
:: :_(+>.$ [~ pip(pez [%fin %mid /text/json (tact (pojo jon))])])
|
|
:: =. ..ya (haji our u.foy.p.som.pip)
|
|
:: =+ ^= lup ^- purl
|
|
:: %+ erle p.u.foy.p.som.pip
|
|
:: :+ `hart`p.pul.p.som.pip
|
|
:: ^- pork
|
|
:: [~ /gul]
|
|
:: ^- quay
|
|
:: :~ [%who (rsh 3 1 (scot %p (need whu.p.som.pip)))]
|
|
:: [%url (crip (earn pul.p.som.pip))]
|
|
:: [%wit %yes]
|
|
:: ==
|
|
:: =+ jon=(jobe ~[[%ok [%b &]] [%next (jape (earn lup))]])
|
|
:: :_(+>.$ [~ pip(pez [%fin %mid /text/json (tact (pojo jon))])])
|
|
:: ::
|
|
:: %red
|
|
:: :_ +>.$
|
|
:: :- ~
|
|
:: %= pip
|
|
:: pez
|
|
:: :- %fin
|
|
:: =+ pul=p.som.pip
|
|
:: ?: ?=([~ %js] p.q.pul) :: XX js discrimination
|
|
:: [%mid /application/javascript (tact (redi pul(p.q ~)))]
|
|
:: =. p.q.pul ~
|
|
:: :- %raw
|
|
:: :+ 307
|
|
:: [%location (crip (earn pul))]~
|
|
:: ~
|
|
:: ==
|
|
:: ::
|
|
:: %sil
|
|
:: :- [~ pip(pez %way)]
|
|
:: +>.$(..ya (honk our num ses q.som.pip))
|
|
:: ==
|
|
:: ::
|
|
:: [%err *]
|
|
:: [~ +>.$(..ya (muff(hen hen.pip) [%thou (loft `love`[%zap +.pez.pip])]))]
|
|
:: ::
|
|
:: [%fin *]
|
|
:: =+ har=(loft p.pez.pip)
|
|
:: =. q.har (weld (turn cug |=(a=@t ['set-cookie' a])) q.har)
|
|
:: [~ +>.$(..ya (muff(hen hen.pip) [%thou har]))]
|
|
:: ::
|
|
:: [%haz *]
|
|
:: :_ +>.$
|
|
:: [~ pip(pez [%fin %wan 'Hello, world' ~])]
|
|
:: ::
|
|
:: [%fud *]
|
|
:: =+ ^= mog ^- (list manx)
|
|
:: ?: ?=(%fun -.som.pip)
|
|
:: (weld r.som.pip sip.pip)
|
|
:: sip.pip
|
|
:: :_ +>.$
|
|
:: :- ~
|
|
:: %= pip
|
|
:: pez
|
|
:: ^- pest
|
|
:: ?- -.p.pez.pip
|
|
:: | =+ mad=(loga "server error" mog p.p.pez.pip)
|
|
:: :- %fin
|
|
:: :- %raw
|
|
:: ^- httr
|
|
:: :+ 500
|
|
:: ~[content-type/'text/html']
|
|
:: [~ (tact (poxo mad))]
|
|
:: & [%fin (lofa mog (lopo q.p.p.pez.pip))]
|
|
:: ==
|
|
:: ==
|
|
:: ::
|
|
:: [%raw *]
|
|
:: :_ +>.$
|
|
:: ^- (unit pimp)
|
|
:: :- ~
|
|
:: =+ hoy=(holy p.pez.pip)
|
|
:: ?~ hoy
|
|
:: pip(pez [%err 404 [[%leaf "invalid request"] ~]])
|
|
:: pip(som u.hoy, pez %new)
|
|
:: ::
|
|
:: [%who *]
|
|
:: :_ +>.$
|
|
:: ?.((~(has ju aut.ced) p.pez.pip q.pez.pip) [~ pip] [~ pip(pez %new)])
|
|
:: ==
|
|
|
|
:: ++ work
|
|
:: |- ^+ +
|
|
:: =+ sez=step
|
|
:: ?: =(rey.sez rey) sez
|
|
:: $(+ sez)
|
|
:: ::
|
|
:: ++ yoke :: long poll
|
|
:: |= [num=@ud you=ship nap=@ud cnt=@ud]
|
|
:: ^- [(unit pimp) _+>]
|
|
:: =+ yon=(yolk nap)
|
|
:: ?~ yon `(bust 204 num)
|
|
:: =. +>.$ abet:(hire:(yule %sub):u.yon cnt num)
|
|
:: :_ +>.$
|
|
:: =+ pup=(~(get by q.rey) num)
|
|
:: ?~ pup ~
|
|
:: ?. ?=(%sil -.som.u.pup) ~
|
|
:: `u.pup
|
|
:: ::
|
|
:: ++ yokg :: main call
|
|
:: |= [num=@ud app=term you=ship pax=path]
|
|
:: ^+ +>
|
|
:: ?< (~(has by sok) num)
|
|
:: abet:(~(self yo num you *sink) app pax)
|
|
:: ::
|
|
:: ++ yokh :: heartbeat
|
|
:: |= [num=@ud you=ship nap=@ud cnt=@ud jon=json]
|
|
:: ^- [(unit pimp) _+>]
|
|
:: =+ yon=(yolk nap)
|
|
:: ?~ yon [~ (bust 204 num)]
|
|
:: [- abet:+]:(beat:u.yon cnt num jon)
|
|
:: ::
|
|
:: ++ yokm :: message
|
|
:: |= [num=@ud you=ship nap=@ud cnt=@ud hap=hasp for=mark jon=json]
|
|
:: ^+ +>
|
|
:: =+ yon=(yolk nap)
|
|
:: ?~ yon (bust 204 num)
|
|
:: abet:(post:u.yon cnt num hap for jon)
|
|
:: ::
|
|
:: ++ yokp :: script by port
|
|
:: |= [num=@ud you=ship nup=(unit ,@ud)]
|
|
:: ^- [(unit pimp) _+>]
|
|
:: ?~ nup
|
|
:: $(nup [~ num], +> ~(harp yo num you *sink))
|
|
:: =+ yon=(yolk u.nup)
|
|
:: ?~ yon
|
|
:: =+ err=(bust 204 num)
|
|
:: [`(need (~(get by q.rey.err) num)) err]
|
|
:: [- abet:+]:(hark:u.yon num)
|
|
:: ::
|
|
:: ++ yoks :: subscribe
|
|
:: |= [num=@ud you=ship nap=@ud hap=hasp pax=path]
|
|
:: =+ yon=(yolk nap)
|
|
:: ?~ yon (bust 204 num)
|
|
:: abet:(scud:u.yon num hap pax)
|
|
:: ::
|
|
:: ++ yoku :: unsubscribe
|
|
:: |= [num=@ud you=ship nap=@ud hap=hasp pax=path]
|
|
:: ^- [(unit pimp) _+>]
|
|
:: =+ yon=(yolk nap)
|
|
:: ?~ yon [~ (bust 204 num)]
|
|
:: [- abet:+]:(scad:u.yon num hap pax)
|
|
:: ::
|
|
:: ++ yolk :: yo by instance
|
|
:: |= nap=@ud
|
|
:: =+ suy=(~(get by sok) nap)
|
|
:: ?~ suy ~
|
|
:: (some ~(. yo nap=nap you=p.u.suy siq=q.u.suy))
|
|
:: ::
|
|
:: ++ yo :: app instance
|
|
:: |_ $: nap=@ud :: instance number
|
|
:: you=ship :: client identity
|
|
:: siq=sink :: instance state
|
|
:: ==
|
|
:: ++ abet :: resolve
|
|
:: %_ ..yo
|
|
:: sok (~(put by sok) nap [you siq])
|
|
:: ==
|
|
:: ::
|
|
:: ++ amok :: demolish
|
|
:: ^+ ..yo
|
|
:: =+ wuh=(~(tap by can.sub.siq))
|
|
:: |- ^+ ..yo
|
|
:: ?~ wuh
|
|
:: %= ..yo
|
|
:: sok (~(del by sok) nap)
|
|
:: ==
|
|
:: %= $
|
|
:: wuh t.wuh
|
|
:: ..amok
|
|
:: (pass(hen hen.q.i.wuh) `p.i.wuh [%g %nuke [- + ~]:hap.q.i.wuh you])
|
|
:: ==
|
|
:: ::
|
|
:: ++ beat
|
|
:: |= [cnt=@ud num=@ud jon=json]
|
|
:: ^- [(unit pimp) _+>]
|
|
:: ?. =(cnt num.bet.siq)
|
|
:: [~ +>.$(..yo (bust 204 num))]
|
|
:: =. +>.$ hast
|
|
:: =. bet.siq bet.siq(num +(num.bet.siq), tim now, hen hen)
|
|
:: =. +>.$ hawa
|
|
:: =. +>.$ (hire:(yule %bet) cnt num)
|
|
:: =. +>.$ (hear:(yule %bet) ~ %& %json !>((joba %a-ok %b %&)))
|
|
:: [`(need (~(get by q.rey) num)) +>.$]
|
|
:: ::
|
|
:: ++ hark
|
|
:: |= num=@ud
|
|
:: ^- [(unit pimp) _+>]
|
|
:: =. +>.$ abet:(busk:(yule %nil) num *@ ~ %& %js !>((duty nap you)))
|
|
:: [`(need (~(get by q.rey) num)) +>.$]
|
|
:: ::
|
|
:: ++ harp
|
|
:: %* abet hawa
|
|
:: tim.bet.siq now
|
|
:: num.sub.siq 1
|
|
:: ==
|
|
:: ::
|
|
:: ++ hast
|
|
:: %_ .
|
|
:: mow
|
|
:: :_ mow
|
|
:: :- hen.bet.siq
|
|
:: :^ %pass
|
|
:: [%leep (scot %p our) ses (scot %ud nap) (scot %ud num.bet.siq) ~]
|
|
:: %t
|
|
:: :- %rest (add ~m2 tim.bet.siq)
|
|
:: ==
|
|
:: ::
|
|
:: ++ hawa
|
|
:: %_ .
|
|
:: mow
|
|
:: :_ mow
|
|
:: ^- move
|
|
:: :- hen.bet.siq
|
|
:: :^ %pass
|
|
:: [%leep (scot %p our) ses (scot %ud nap) (scot %ud num.bet.siq) ~]
|
|
:: %t
|
|
:: :- %wait (add ~m2 now)
|
|
:: ==
|
|
:: ::
|
|
:: ++ hoop :: request path
|
|
:: |= can=(each ,@ud hasp)
|
|
:: ^- path
|
|
:: :* %hoop
|
|
:: (scot %p our)
|
|
:: ses
|
|
:: (scot %ud nap)
|
|
:: ?- -.can
|
|
:: %& [%show (scot %ud p.can) ~]
|
|
:: %| [%mess (scot %p p.p.can) q.p.can ~]
|
|
:: ==
|
|
:: ==
|
|
:: ::
|
|
:: ++ pass :: pass
|
|
:: |= [can=(each ,@ud hasp) noh=note]
|
|
:: ^+ +>
|
|
:: +>(mow [[hen %pass (hoop can) noh] mow])
|
|
:: ::
|
|
:: ++ post :: transmit
|
|
:: |= [cnt=@ud num=@ud hap=hasp for=mark jon=json]
|
|
:: ^+ +>
|
|
:: =. +>.$
|
|
:: ?. =(cnt num.meg.siq) +>.$
|
|
:: %+ pass(num.meg.siq +(num.meg.siq)) [%| hap]
|
|
:: `note`[%f %exec our ~ %cast for %done ~ %json !>(jon)]
|
|
:: ?. =(+(cnt) num.meg.siq)
|
|
:: +>.$(..yo (bust 204 num))
|
|
:: (hire:(yule %meg) cnt num)
|
|
:: ::
|
|
:: ++ scad
|
|
:: |= [num=@ud hap=hasp pax=path]
|
|
:: ^- [(unit pimp) _+>]
|
|
:: =. +>.$
|
|
:: %- ~(rep by can.sub.siq)
|
|
:: =+ [*p=[p=@ud q=stem] q=+>.$] |.
|
|
:: ?. =([hap pax] [hap.q.p pax.q.p]) q
|
|
:: =. q q(can.sub.siq (~(del by can.sub.siq:q) p.p))
|
|
:: ([-(hen +)]:[pass:q hen.q.p] `p.p %g %nuke [- + ~]:hap you)
|
|
:: =+ huq=[~ %& %json !>((joba %ok %b %&))]
|
|
:: =. +>.$ abet:(busk:(yule %nil) num 0 huq)
|
|
:: [`(need (~(get by q.rey) num)) +>.$]
|
|
:: ::
|
|
:: ++ scud :: subscribe
|
|
:: |= [num=@ud hap=hasp pax=path]
|
|
:: =. can.sub.siq
|
|
:: (~(put by can.sub.siq) num.sub.siq [hap pax hen `[%| num]])
|
|
:: =. +>.$ (pass `num.sub.siq `note`[%g %show [- + ~]:hap you pax])
|
|
:: =. num.sub.siq +(num.sub.siq)
|
|
:: +>.$
|
|
:: ::
|
|
:: ++ self :: request main
|
|
:: |= [app=term pax=path]
|
|
:: ^+ +>
|
|
:: =. tim.bet.siq now
|
|
:: =. can.sub.siq
|
|
:: (~(put by can.sub.siq) 0 [[our app] pax hen `[%& nap]])
|
|
:: =. num.sub.siq +(num.sub.siq)
|
|
:: =. hen.bet.siq hen
|
|
:: =. +>.$ hawa
|
|
:: (pass `0 [%g %show [our app ~] you pax])
|
|
:: ::
|
|
:: ++ yule
|
|
:: |= pla=?(%bet %meg %sub %nil)
|
|
:: %~ . yu :- pla
|
|
:: =< wig
|
|
:: ?-(pla %bet bet.siq, %meg meg.siq, %sub sub.siq, %nil [wig=*swig ~])
|
|
:: ::
|
|
:: ++ yu :: swig state
|
|
:: |_ [pla=?(%bet %meg %sub %nil) wig=swig]
|
|
:: ++ abet
|
|
:: ^+ ..yu
|
|
:: ?- pla
|
|
:: %bet %_(..yu wig.bet.siq wig)
|
|
:: %meg %_(..yu wig.meg.siq wig)
|
|
:: %sub %_(..yu wig.sub.siq wig)
|
|
:: %nil ..yu
|
|
:: ==
|
|
:: ::
|
|
:: ++ busk :: seam result
|
|
:: |= $: num=@ud
|
|
:: cnt=@ud
|
|
:: huq=(unit (each cage cage))
|
|
:: ==
|
|
:: ^+ +>
|
|
:: =+ pup=(~(get by q.rey) num)
|
|
:: ?~ pup +>.$ :: XX a hack
|
|
:: =. wig ?: ?=(%nil pla) wig
|
|
:: ?. =(toy.wig cnt)
|
|
:: ?>(=(toy.wig +(cnt)) wig)
|
|
:: %= wig
|
|
:: toy +(toy.wig)
|
|
:: red
|
|
:: ?: =(0 toy.wig) red.wig
|
|
:: :: ~& [%busk [%sent cnt] [%lost (dec toy.wig)]]
|
|
:: (~(del by red.wig) (dec toy.wig))
|
|
:: ==
|
|
:: =+ pip=u.pup
|
|
:: =+ ^= sip
|
|
:: ?. ?=(%apg -.som.pip) sip.pip
|
|
:: =* his q.som.pip
|
|
:: =+ mef=?:(=(our his) "gop" "gip/{|1:<his>}") :: e.g. "gip/zod"
|
|
:: =+ hat="/{mef}/{(pojo (jone nap))}/hart.js"
|
|
:: [;script(src hat); ;meta(charset "utf-8"); sip.pip]
|
|
:: ?~ huq +>.$(..yo (bust 404 num))
|
|
:: %= +>.$
|
|
:: q.rey
|
|
:: %+ ~(put by q.rey) num
|
|
:: ^- pimp
|
|
:: %= pip
|
|
:: pez %new
|
|
:: sip sip
|
|
:: som ^- seam
|
|
:: :+ %sil
|
|
:: ?:(-.u.huq 200 203)
|
|
:: =+ don=`silk`[%done ~ `cage`p.u.huq]
|
|
:: ^- silk
|
|
:: :+ %cast %mime
|
|
:: ?~ fur.pip don
|
|
:: `silk`[%cast u.fur.pip don]
|
|
:: ==
|
|
:: ==
|
|
:: ::
|
|
:: ++ dumb :: reset
|
|
:: ^+ ..yu
|
|
:: =+ dum=(~(tap by wan.wig) ~)
|
|
:: |- ^+ ..yu
|
|
:: ?~ dum ..yu :: XX drop stream
|
|
:: $(dum t.dum, ..yo (bust 404 q.i.dum))
|
|
:: ::
|
|
:: ++ hear :: produce
|
|
:: |= huq=(unit (each cage cage))
|
|
:: ^+ ..yu
|
|
:: =< abet
|
|
:: =+ cnt=cnt.wig
|
|
:: =+ dul=(~(get by wan.wig) cnt)
|
|
:: :: ~& :~ %yu-hear
|
|
:: :: [%instance nap]
|
|
:: :: [%produced cnt]
|
|
:: :: ?~(dul %unrequested [%requester u.dul])
|
|
:: :: ==
|
|
:: =: cnt.wig +(cnt.wig)
|
|
:: wan.wig ?~(dul wan.wig (~(del by wan.wig) cnt.wig))
|
|
:: red.wig (~(put by red.wig) cnt.wig huq)
|
|
:: ==
|
|
:: ?~(dul +>.$ (busk u.dul cnt huq))
|
|
:: ::
|
|
:: ++ hire :: consume
|
|
:: |= [cnt=@ud num=@ud]
|
|
:: ^+ ..yu
|
|
:: =< abet
|
|
:: :: ~& :~ %yu-hire
|
|
:: :: [%instance nap]
|
|
:: :: [%produced cnt.wig]
|
|
:: :: [%request cnt]
|
|
:: :: [%dispatched toy.wig]
|
|
:: :: [%requester num]
|
|
:: :: ==
|
|
:: ?: |((lth +(cnt) toy.wig) (gth cnt toy.wig))
|
|
:: ~& [%hire-improper [%request cnt] [%dispatched toy.wig]]
|
|
:: +>.$(..yo (bust 204 num))
|
|
:: ?: (gte cnt cnt.wig)
|
|
:: :: ~& %hire-wait
|
|
:: =+ old=(~(get by wan.wig) cnt)
|
|
:: =. wan.wig (~(put by wan.wig) cnt num)
|
|
:: +>.$(..yo ?~(old ..yo (bust 204 u.old)))
|
|
:: =+ rud=(~(get by red.wig) cnt)
|
|
:: ?~ rud
|
|
:: :: ~& %hire-bust
|
|
:: +>.$(..yo (bust 204 num))
|
|
:: :: ~& %hire-send
|
|
:: (busk num cnt u.rud)
|
|
:: --
|
|
:: --
|
|
--
|
|
--
|
|
--
|
|
. ==
|
|
=| bolo
|
|
=* bol -
|
|
|= [now=@da eny=@ ski=sled] :: activate
|
|
^? :: opaque core
|
|
|% ::
|
|
++ call :: handle request
|
|
|= $: hen=duct
|
|
hic=(hypo (hobo kiss))
|
|
==
|
|
=> %= . :: XX temporary
|
|
q.hic
|
|
^- kiss
|
|
?: ?=(%soft -.q.hic)
|
|
((hard kiss) p.q.hic)
|
|
?: (~(nest ut -:!>(*kiss)) | p.hic) q.hic
|
|
~& [%eyre-call-flub (,@tas `*`-.q.hic)]
|
|
((hard kiss) q.hic)
|
|
==
|
|
^- [p=(list move) q=_..^$]
|
|
=| our=ship :: XX
|
|
=+ ska=(slod ski)
|
|
=+ sky=|=(* `(unit)`=+(a=(ska +<) ?~(a ~ ?~(u.a ~ [~ u.u.a]))))
|
|
=. ney (shax :(mix (shax now) +(eny) ney)) :: XX!! shd not need
|
|
^- [p=(list move) q=_..^$]
|
|
=. gub ?.(=(0 gub) gub (cat 3 (rsh 3 1 (scot %p (end 6 1 eny))) '-'))
|
|
=^ mos bol
|
|
abet:(apex:~(adit ye [hen [now eny our sky] ~] bol) q.hic)
|
|
[mos ..^$]
|
|
::
|
|
++ doze
|
|
|= [now=@da hen=duct]
|
|
^- (unit ,@da)
|
|
~
|
|
::
|
|
++ load
|
|
|= old=_[%0 gub hov ged ney dop **]
|
|
^+ ..^$
|
|
..^$(+>- (bolo old))
|
|
::
|
|
++ scry
|
|
|= [our=(unit (set monk)) ren=@tas who=ship syd=desk lot=coin tyl=path]
|
|
^- (unit (unit (pair mark ,*)))
|
|
~
|
|
::
|
|
++ stay `bolo`+>-.$
|
|
++ take :: accept response
|
|
|= [tea=wire hen=duct hin=(hypo sine)]
|
|
^- [p=(list move) q=_..^$]
|
|
?: ?=(%veer +<.q.hin) :: vomit
|
|
[[hen %give +.q.hin]~ ..^$]
|
|
?: ?=(%vega +<.q.hin) :: vomit
|
|
[[hen %give +.q.hin]~ ..^$]
|
|
=| our=ship :: XX
|
|
=+ ska=(slod ski)
|
|
=+ sky=|=(* `(unit)`=+(a=(ska +<) ?~(a ~ ?~(u.a ~ [~ u.u.a]))))
|
|
=. ney (shax :(mix (shax now) +(eny) ney)) :: XX!! shd not need
|
|
^- [p=(list move) q=_..^$]
|
|
=. gub ?.(=(0 gub) gub (cat 3 (rsh 3 1 (scot %p (end 6 1 eny))) '-'))
|
|
=^ mos bol
|
|
=< abet
|
|
%^ axon:~(adit ye [hen [now eny our sky] ~] bol) tea
|
|
(~(peek ut p.hin) %free 3)
|
|
q.hin
|
|
[mos ..^$]
|
|
--
|