►
From YouTube: Web IDE Maintainer Onboarding (APAC) - Aug 2023 2/4
Description
In this session we catch up on what we did in the AMER/EMEA timezone and push it forward a bit.
B
A
A
C
D
A
A
A
All
right,
okay,
so
here's
the
issue
we're
working
on
right
now.
The
web
ID
does
not
work
as
expected
as
desired
when
you
open
it
from
a
commit.
So
if
I
am
have
a
commit
hash
here
and
I
go
to,
like
my
repository
view,
yeah
yeah
and
then
I
go
to
edit
from
the
web.
Id
everything
blows
up
because
kind
of
hard-coded
that
we're
trying
to
pull
Branch
specific
information
can't
find
the
branch
doesn't
know
what
to
do
it
freaks
out.
A
A
We
just
need
to
kind
of
remove
that
assumption
and
replace
it
with
something
that
is
more
like
a
ref
that
could
be
a
branch
or
something
else.
And
then,
if
it's
not
a
branch,
we
kind
of
need
to
change
how
we
commit,
because
I'm
not
going
to
be
committing
to
a
branch
now
but
pulling
from
the
file
tree
and
getting
data.
All
that
just
uses
a
commit
Shaw,
so
that's
easy
to
do.
A
A
A
That's
where
we've
that's,
where
this
is
all
blowing
up,
that's
where
we
fetch
the
ref
information
and
how
that
all
gets.
That's
how
we
use
it
to
try
to
fetch
the
branch,
so
we
kind
of
started
there.
Talking
about
this
package,
that's
a
little
weird
called
mediator
commands
have
we
talked
about
that?
Did
we
talked
about
that
last
time.
A
A
A
A
We
include
the
config
as
a
attribute
here
in
this
meta
tag
and
the
iframe
so
that
our
vs
code
bootstrapper,
which
is
a
really
bad
verb
for
the
thing,
but
that's
what
it's
called
the
vs
code
bootstrapper
can
we
can
read
and
deserialize
this
config
and
strap
up
some
some
good
old
vs
code
and
so
how
this
actually
gets
used
by
the
vs
code.
Bootstrap
is
when
we
start
the
thing
we
received
the
config
that
was
injected
into
our
iframe
and
we
initialize.
A
Some
things
like
vs
code
needs
to
know
some
like
file
systemy,
looking
things,
and
that's
this
like
repo
root
thing.
That's
not
super
important
right
now,
but
one
of
the
big
things
that
happens
is
so
you
see.
Config
gets
kind
of
turned
into
this
weird
full
config
kind
of
thing,
but
that's
kind
of
a
smelly
part
of
the
code,
but
it
gets
passed
into
this
create
commands.
That
comes
from
mediator
commands,
so
the
mediator
commands
vs
code
has
a
really
powerful
abstraction
for
extensions.
A
Can
declare
commands
extensions,
can
call
commands
from
other
extensions,
so
I
could
have
an
extension
that
knows,
like
is
looking
for
like
oh
do
you
have
git
lens
installed
and
I'll
call
specific
like
git
lens
extension
or
something
like
git
lens
command
and
all
these
commands.
Some
of
them
are
internal.
Some
of
them
are
all
declared
into
this
scope,
and
extensions
is
the
main
way
that
we
can
modify
vs
code
Behavior,
but
once
you
get
into
the
vs
code
internals.
A
So
here
where
we're
actually
calling
vs
codes
entry
point-
and
this
is
vs
codes-
Google
humongous,
glorious,
config
object.
We
can
actually
pass
commands
that
will
run
in
this
context,
which
is
really
powerful
because
extensions
all
run
inside
of
a
Sandbox
for
security
reasons,
so
that
they
don't
steal
user
session
information
and
other
extensions
don't
bump
into
each
other.
All
sorts
of
reasons.
Why
extensions
run
in
the
sandbox
for
the
gitlab
web
ID
to
behave
seamlessly.
A
We
needed
a
way
for
the
extension
to
seamlessly
authenticate
its
requests
using
the
user
session
from
gitlab.com,
and
so
when
I,
when
we
stumbled
upon
commands
as
an
option
here
that
was
the
idea
was
we
could
use.
We
can
create
commands
when
we
start
all
of
vs
code.
We
can
declare
a
set
of
commands
that
will
run
inside
of
this
context,
not
inside
of
the
extension
sandbox
context.
A
Yeah
I
was
just
about
to
say:
the
astute
listener
will
realize.
Wait,
doesn't
isn't
this
the
security
issue
that
you
were
so
concerned
about
and
yeah
they
totally
can,
and
so
we
are
working
towards
moving
away
from
mediator
commands,
but
we
have
disabled
the
extension
Marketplace
in
the
meantime.
So
it's
really
just
our
own
extension
and
no
one
can
install
you
can't
install
third-party
extensions.
That
could
call
you
know,
take
over
the
user
session
and
stuff,
and
so
we
just
disabled
the
extension
Marketplace.
So
we're.
A
Yeah
you
can't
use
commands
to
authenticate
like
it
would
be.
Commands
are
kind
of
like
every
extension
can
call
any
kind
of
command.
That's
in
the
global
soup
of
command
declared,
there's
other
authentication
methods,
and
that's
what
me
and
Enrique
have
had
to
dive
into
quite
a
bit
to
see
how
like
vs
code
and
the
internals
of
vs
code
have
a
whole
bunch
of
built-in
extensions.
A
They
have
like
a
GitHub
authenticator
extension,
a
Microsoft
authenticator
extension,
so
like
we're
having
to
see
how
we
can
create
a
seamless
way
for
us
to
use
those
abstractions
so
that
we
can
have
an
extension
Marketplace,
because
these
meteor
commands
would
not
be
safe
in
a
extension.
Marketplace
land,
because
it'd
be
very
easy
for
users
could
install
a
malicious
extension
which
is
then
able
to
just
make
requests
on
behalf
of
the
user.
A
Yeah
yeah,
it's
a
great
question,
so
this
interop
package
is
this
is
a
shared
contract
between
the
web,
ID
and
gitlab
vs
code
extension
for
how
the
gitlab
vs
code
extension
can
be
baked
into
the
web
ID
and
become
web
ID
aware,
and
so
one
of
the
big
differences
for
the
vs
codex.
If
you
load
up
the
gitlab,
workflow
extension
you'll
see
right
away
that
I
have
to
like
authenticate
with
it
like
that's
really
baked
into
it.
I
have
to
it's
an
oauth
app
and
our
gitlab
account.
A
None
of
that
is
going
to
be
compatible
with
the
web
ID.
We
want
it
to
all
be
seamless,
and
so
the
gitlab
vs
code
extension
has
to
be
aware
of
these
mediator
commands
and
the
type
of
the
command
that
the
commands
interface.
It
has
to
be
compliant
to
that
and
we're
going
to
comply
to
this
as
well.
So
I
would
say
that
the
interop
is
kind
of
more
like
a
subset
of
the
mediator
commands
that
we
need
to
that.
We
need
to
implement
and
that
hopefully,.
A
A
The
vs
code
extension
could
look
for
our
off
provider
and
just
use
that,
as
in
order
to
fetch
stuff,
but
okay,
yeah
I
want
to
show
how
the
config
and
mediator
commands
are
related.
These
are
really
great
questions.
Please
interrupt
me.
Please
do
at
any
time,
because
that's
going
to
be
the
most
I
think
most
important
thing
that
we.
B
A
A
Sorry,
let
me
pause
so
these
commands
run
in
the
context
of
the
main
user
session,
so
they
naturally
authenticate
all
anything
it
fetches
from
here,
and
they
also
run
in
the
context
of
having
access
to
the
full
config.
So
we
can
just
have
a
command
like
fetch
project
branches,
and
it
doesn't
need
to
get
passed
in
like
the
project
path
or
anything
like
that,
because
it
just
knows:
hey
yeah.
A
This
is
my
Branch,
so
whatever
okay,
all
that
being
said,
there's
a
lot
of
legacy
technical
debt
here
because
for
the
vs
code
extension
to
work,
we
introduce
these
abstract
way
of
interfacing
and
making
requests
like
this
command
fetch
file,
raw
and
fetch
or
fetch
from
API,
which
just
takes
this
generic
request
object
before
this
abstraction
existed,
I
kind
of
for
every
single,
like
individual
fetch
thing.
We
need
to
do.
I
created
a
command
for
this
specific,
very
specific
thing,
because
I
was
thinking
in
my
head
I'm
concerned
about
the
extension
Marketplace
I.
A
Don't
want
to
expose
that
the
extension
Marketplace
can
just
do
anything
under
what
I
realized,
whatever
I
was
exposing
here
in
meteor
commands
could
be
called
from
any
extension,
so
I
was
trying
to
be
very
specific
with
its
scope,
but
in
retrospect
it's
like
yeah
yeah.
Most
of
all,
this
is
technical
debt,
but
we're
still
or
slowly
but
surely
working
away
from
it.
A
A
So
it
it's
packaged,
Json
looks
like
or
no
it
has
this
vs
code
package
Json
that
has
a
whole
bunch
of
like
vs
code,
specific
metadata,
like
what
kind
of
commands
it
exposes
different
menus.
It's
going
to
control
like
Source
control,
menus
welcome
views,
so
this
is
like
the
engine
for
all
of
the
web.
Id
running
is
this
vs
code
extension
package,
this
web
ID
and
it
has
a
module.
That's
basically
consuming
the
mediator,
commands
and
wrapping
them
into
nice.
A
Nice,
like
type
safe
methods,
because
the
interface
for
executing
the
command
is
just
like.
Hey
you
just
take
you
just
pass
it
any
string
and
you
pass
it
any
args.
You
can
get
anything
back.
So
it's
like
okay,
let's,
let's
try
to
control
when
we
call
these
These
are
the
kind
of
types
we
expect
from
it.
A
A
A
We
are
pulling
all
of
the
information
we
need
from
gitlab,
based
on
the
refs
and
IDs
I've
received
yeah.
So
this
start
command
is
actually
where
we
started
earlier.
I'm
gonna
pause
like
I,
know,
I'm
just
going
off
and
is
is
any
of
is
anything?
Are
we
still
following
or
is
it
anything
super
confusing.
A
Great
and
if
and
if
there's
a
lack
of
following
I
feel
all
right,
I'm
gonna
pause
this.
It's
like
going
through
all
of
this
and
how
quickly
like
we
rushed,
not
rushed
it,
but
it's
like
I
see
so
much
I
wish
I
could
have
like
tidied
up
before,
like
sharing
it
with
everybody,
but
I
realize
that's,
not
the
good
lad
way
of
doing
things,
but
I
do
just
have
this
Rising
feeling
of
just
I
want
to
apologize
for.
It's
like
it's
like.
When
you
have
laundry
around
the
house.
A
You
have
friends
over
it's
like
I'm,
sorry,
I
should
have
cleaned
up,
and
but
you
see,
I
was
building
up
my
Legos
over
here,
anyways,
okay,
let's
jump
into
it,
but
there's
some
saving
graces
with
it,
despite
some
of
the
things
that
are
maybe
less
desirable,
so
here's
the
definition
for
the
start
command
and
all
these
meteor
commands
kind
of
follow
this
pattern
where
it's
like
a
function
that
returns
a
function.
It's
a
function
that
Returns
the
Handler
for
the
command
and
this
outer
function
receives
the
big
context
that
it
uses.
A
A
A
A
A
So
then
the
gitlab
ref
is
a
union
of
it
can
be
a
branch
ref,
it
can
be
a
commit
ref
and
it
could
be
a
tag
ref.
What's
really
cool
with
this
kind
of
typescript
is
so
smart
and
handling
types
like
this,
because
we've
given
each
one
of
these
a
static
value
so
like
Shaw,
can
be
any
string
branches
that
gitlab
API
Branch
type,
but
the
type
for
this
thing
has
to
be
branch.
A
It's
really
good
at
when
I'm
like
typing
in
the
code,
if
I
just
get
a
gitlab,
ref
I
can
do
like
okay.
Well,
if
the
type
triple
equals
tag-
and
then
typescript
knows
it's
got
to
look
like
this,
then
and
if
I
could
say
like.
Oh,
if
the
type
equals
commit
it's
like,
okay,
I
know,
it's
got
to
look
like
this.
That
kind
of
thing
is
super
helpful,
so
we
have
like
a.
A
We
have
a
utility
function
that
we
added
called
like
get
ref
name,
which
would
be
like
based
on
this
generic
ref
that
we
get
the
type
is
Branch
we're
going
to
return
the
branch
name
if
it's
a
tag,
we'll
just
return
the
tags
name,
but
if
it's
a
commit
we'll
return
the
whole
shot.
So
it's
like
that
kind
of
typescript
behavior
is
super
helpful
and
is
fairly
intuitive.
For
the
most
part
it
just
works.
A
But
what
we
did
is
we
changed
the
type
here
and
then
we
just
went
through
all
of
the
type
errors
and
just
updated
them.
So
it's
like
okay.
So
since
that
type
is
now
different,
instead
of
receiving
a
branch,
we
should
be
receiving
a
ref
and
we're
going
to,
instead
of
passing
in
Branch,
commit
ID
we're
going
to
pass
in
ref
Shaw,
so
we're
just
kind
of
following
the
type
errors
and
updating
it
to
what
the
new
type
should
be.
So
we
updated
it
on
the
side
that
consumes
the
start,
command
response.
A
We
haven't
finished,
updating
it
on
the
start,
command
that
actually
needs
to
return.
The
correct
response:
that's
where
APAC
team
comes
in
to
the
rescue,
so
we
can
walk
through
all
of
the
different,
smaller
changes
we
made
here
or
we
can
just
dive
straight
into
picking
up
where
we
left
off.
What
do
you
all
want
to
do.
A
So
typescript
has
a
whole
bunch
of
really
cool
like
utility
types
that
can
help
you
compose
types
and
declarative
ways.
Well
Branch
isn't
a
property
on
there
anymore.
So
so
we
updated
that
to
ref,
and
then
everything
was
good
here.
So
then
we
moved
on
here
we
had
references
to
gitlab.
Oh,
we
we've
we
got
to
this
file
by
following
in
the
main
file
here.
A
A
It
was
referencing
the
branch
and
using
Branch
information,
which
is
now
the
ref,
and
so
instead
of
referencing
gitlab
Branch,
it's
now
using
the
ref
and
we
kind
of
just
updated.
This
is
straightforward.
We
just
updated
those
Branch
references,
here's
one
where
this
is
actually
responsible
for
showing
the
commit
button
that
will
show
up
here
and
bangs.
A
So
this
is
all
vs
code
extension
API,
so
you
can
look,
read
vs,
code's
extension
documents
and
they
have
a
very
like
robust
abstraction
for
managing
Source
control,
because
imagine
like
having
extensions
that
implement
being
able
to
use
vs
code
for
projects
that
are
not
get
like
using
Mercurial
or
whatever.
Is
that
what
it's
called
I
think
it's
called
I,
think
materials
I,
don't
think
I've
ever
said
it
out
loud,
but
so
they
have
a
lot
of
like
it's
not
even
called
like
commit
command.
A
A
And
so
here
we
were
referencing,
oh
I'm,
going
to
commit
to
main
or
whatever
my
Branch
name
is,
but
we
don't
necessarily
are
on
a
branch,
so
we
don't
necessarily
have
that.
So,
instead,
just
kind
of
made
a
little
helper
function
for
this
Dragon
text
around
made
a
little
helper
function
for
this,
and
we
are
now
checking.
Are
we
a
branch
and
if
so,
we'll
show
we're
gonna
commit
to
Maine,
otherwise,
we'll
show
that
we
need
to
commit
to
a
new
Branch
there's,
nothing
else
you
can
commit
to.
A
But
this
is
that
this
is
that
really
cool
typescript
behavior
of
once
you've?
So
here
we
have
this
Union
type,
but
when
I
check
that
one
of
its
types
actually
equals
typescript
knows
this
has
got
to
be
a
branch,
because
you
told
me
it
was
so.
Typescript
is
really
good
at
doing
its
type
inference
and
enforcing
that.
A
A
A
And
maybe
you
want
to
enter
a
branch
name
instead
s,
but
now
Branch
isn't
always
or
ref
isn't
always
a
branch,
and
so,
if
we're
not
a
branch,
we're
going
to
require
you
to
like
hey
yeah,
you
got
to
really
put
in
a
branch
name,
and
so
we
still
haven't
tested
this
out,
but
we'll
see
what
that
looks
like,
but
then
below
all
of
this,
so
since
I
can
check.
Since
all
this
is
not
equal
to
branch.
A
Those
other
types
all
of
this,
this
get
typescript
knows
this
isn't
going
to
be
gitlab,
Branch
ref,
but
a
note
and
since
I've
returned
here
it
knows
that
below
here.
This
is
the
same
as
type
does
equal
branch
and
that
ref
has
to
be
gitlab,
Branch
graph
and
so
I
could
just
destructure
Branch
out
of
that,
and
then
all
below
the
code
is
the
same.
So
that
was
kind
of
cool,
so
early
returns
with
typescript
are
really
helpful
as
well
yeah.
A
This
is
more
that
was
that
was
seemed
like
this
is
a
just
a
keeping
things
tidy
and
yeah.
It's
just
more
kind
of
renaming
of
what
was
previously
referencing.
Gitlab
Branch
specifically,
is
now
referencing
gitlab
ref,
but
we
didn't
actually
go
around
like
just
finding
all
these.
We
just
followed
a
trail
of
typed
errors
and
then
looks
like
the
typed
errors
in
vs
code
extension.
A
Web
ID
package
are
good,
but
we
got
to
fix
the
type
errors
now
in
the
mediator
commands
because
down
here
we're
still
returning
Bridge
all
right
now
we're
into
interesting
problem
solving
all
right
that
was
long,
expository,
a
history
of
what
happened
12ish
hours
ago,
now
we're
into
interesting
problem
solving.
So
we
have
this
used
to
be
called
resolve,
Branch
name,
but
now
it's
called
resolve,
ref
name
and
what
it
does
is
like.
A
A
A
A
So
we
ended
our
conversation
of
like
I
wish.
There
was
an
API
endpoint
where
we
can
just
say
what
is
this
thing
but
there's
not,
but
then
Aaron
I
think
that's
his
name.
He
had
a
really
interesting
idea
for
how
we
could
do
this.
So
this
was
my
original
idea
and
the
please
read
in
between
the
lines
of
the
hackiness
of
my
original
idea
and
be
like
okay.
I
can
see
why
the
whole
project
is
in
the
state.
A
D
A
A
A
D
D
A
A
A
B
C
B
A
A
A
A
D
A
A
Oh,
like
just
using
gitlab
ref
as
the
prefix
for
these
different
types,
I
think
that
works
out
I,
don't
know
if
we're
yeah
we
can.
We
can
rename
these
100,
so
we
can
probably
like
get
lab
reps.
That
works
for
me
being
called
oh,
but
I
forgot,
I'm,
not
even
on
the
branch.
I
can't
make
all
these
changes
quite
yet
all
right.
D
A
A
I
like
it,
okay
and
then
we're
suggesting
a
change
here
on
line
63.
There's
this
thing:
oh,
but
I
already
added
some
stuff.
Yes,
okay,
we'll
leave
it
like
that.
All
right,
I
think
it's
good,
we'll
see
we'll
see
what
he
thinks
after
doing
that,
okay,
but
we're
back
to
here,
but
yeah.
Now
we
have
like
an
algorithm
for
doing
this
thing,
which
is
very
exciting.
There's
one
obstacle
to
simply
implementing
this,
so
this
is
a
nil
request
that
we
want
to
make,
which
is
great,
that's
easy
to
do.
A
Hamas
has
a
really
cool
idea
and
way
of
rather
than
handling
like
having
one
God
class
that
handles.
That
knows,
all
of
that
we
have
a
class
that
just
knows
how
to
resolve
requests
and
then
those
specific
domains
know
how
to
create
requests,
which
is
contains
all
of
its
parameters
and
everything
in
it
and
what
the
return
type
is
going
to
be,
which
is
really
cool,
I
love
it,
but
we're
in
the
awkward
stage
where
we
have
two
clients.
A
Now
so
here's
the
situation,
we
could
add
a
method
to
our
deprecated
client,
because
that's
the
thing
that's
being
referenced
here,
but
it's
deprecated,
you
know,
so
you
can
see
it
hasn't
seen.
Why
did
you
do
that?
We
could
add
a
parameter
here
to
get
both
the
de
Brigade
client
and
the
default
client
so
that
we
can
create
a
new
method
to
be
used
here
and
and
everyone's
happy.
A
A
A
C
C
A
B
D
D
A
A
A
D
D
A
A
We
return
project
Repository
and
then
so.
There's
a
way
to
have
like
I
haven't
been
able
to
I,
wasn't
able
to
get
it
hooked
up,
but
there's
a
way
for
typescript
to
somehow
like
generate
and
figure
out
what
these
return
types
are
supposed
to
be
and
everything
like
it's
so
cool
the
man
we
give
graphql
and
typescript
working
seamlessly,
but
for
right
now
we're
just
encapsulating
this
boilerplate
encapsulating
the
boilerplate
all
next
to
each
other,
so
that,
hopefully
it's
clear.
The
relationship
thanks.
A
C
A
A
Prettier,
like
I
I,
will
put
a
comma
and
then
create
your
just
replace
so
I.
Don't
really
think
about
it.
So
that's
cool,
that's
nice,
I,
don't
and
I
think
they're
equivalently
the
same
so
I
think
it's
just
a
preference
or
it's
I,
think
it's
just
a
preference
thing,
I'm
not
entirely
sure,
but
yeah.
This
is
last
commit
in
shots.
These
are
all
looking
right.
Okay,
cool
we'll
have
to
test
it
out.
A
We're
not
we're
not
running
again.
I
know
we're
at
the
end
of
time
as
well.
But
let's
see
if
we
can
finish
adding
our
method
here
so
here
we
have
a
graphql
example
of
the
follow
ing.
This
create
graphql
request.
We
pass
in
get
raps
metadata
result,
get
ref,
Navigator
variables,
I,
don't
wanna
I,
don't
want
to
skip
over
too
quickly,
but
is?
Is
anyone
not
familiar
with
like
the
type
languages
that
do
generic
arguments
and
stuff?
B
D
A
So,
for
the
most
part,
you
don't
have
to
reference
these
generic
parameters
when
calling
typed
functions
that
accept
generics,
but
sometimes
it
has
to
be
referenced,
but
this
is
basically
like
when
we
have
a
type.
That's
so
abstract
that
part
of
its
type
can
be
plugged
in
and
different
area
and
different
and
different.
Contexts
for
like
for,
like
I,
can
have
a
result,
which
is
a
promise
that
returns
strings
or
something
so
like
promise
is
so
abstract
and
this
inner
type
is
the
generic.
A
A
Types
that
you
pass
to
it
so
we're
calling
this
create
graphql
request
that
takes
in
a
type
of
what
is
the
result.
Gonna
be,
and
what
are
the
variables
we
expect
and
is
doing
something
with
it.
So
sometimes
you
don't
have
to
specify
it,
because
typescript
is
smart
enough
to
infer
what
you
intend
by
the
other
values
you're
referencing,
but
when
you're
explicit
with
specifying
the
generics,
sometimes
it
makes
things
more
helpful,
yeah.