&2 missing migration?\n"
+ " exit 1\n"
+ "end\n"
+ "__fish_color_theme={} __fish_apply_theme 2>/dev/null\n".format(
TERMINAL_COLOR_THEME
)
+ "or __fish_color_theme=unknown __fish_apply_theme\n"
+ "__fish_theme_export_for_webconfig",
env=os.environ | {"__fish_force_load_default_theme": "1"},
)
assert err == ""
words = iter(shlex.split(out))
current = next(words)
themes = [
{
"theme": "Current",
"by_color_theme": {
# Hack-ish: we don't know about the light/dark variants.
"unknown": parse_colors(current)
| {
"preferred_background": "white"
if TERMINAL_COLOR_THEME == "light"
else "black",
}
},
"terminal_color_theme": TERMINAL_COLOR_THEME,
}
]
while True:
try:
theme_name = next(words)
except StopIteration:
break
theme = {
"theme": theme_name,
}
pretty_name = next(words)
if pretty_name:
theme["name"] = pretty_name
url = next(words)
if url:
theme["url"] = url
by_color_theme = {}
for _i in range(int(next(words))):
color_theme = next(words)
preferred_background = next(words)
data = next(words)
by_color_theme[color_theme] = parse_colors(data) | {
"preferred_background": preferred_background
}
theme["by_color_theme"] = by_color_theme
themes += [theme]
return themes
def do_get_functions(self):
out, err = run_fish_cmd("functions")
out = out.strip()
return out.split("\n")
def do_get_variable_names(self, cmd):
"Given a command like 'set -U' return all the variable names"
out, err = run_fish_cmd(cmd)
return out.split("\n")
def do_get_variables(self):
out, err = run_fish_cmd("set -L")
# Put all the variables into a dictionary
vars = {}
for line in out.split("\n"):
comps = line.split(" ", 1)
if len(comps) < 2:
continue
fish_var = FishVar(comps[0], comps[1])
vars[fish_var.name] = fish_var
# Mark universal variables. L means don't abbreviate.
for name in self.do_get_variable_names("set -nUL"):
if name in vars:
vars[name].universal = True
# Mark exported variables. L means don't abbreviate.
for name in self.do_get_variable_names("set -nxL"):
if name in vars:
vars[name].exported = True
# Do not return history as a variable, it may be so large the browser hangs.
vars.pop("history", None)
return [
vars[key].get_json_obj()
for key in sorted(vars.keys(), key=lambda x: x.lower())
]
def do_get_bindings(self):
"""Get key bindings"""
# Running __fish_config_interactive print fish greeting and
# loads key bindings
greeting, err = run_fish_cmd(" __fish_config_interactive")
# Load the key bindings and then list them with bind
out, err = run_fish_cmd("__fish_config_interactive; bind")
# Remove fish greeting from output
out = out[len(greeting) :]
# Put all the bindings into a list
bindings = []
command_to_binding = {}
for line in out.split("\n"):
comps = line.split(" ", 2)
# If we don't have "bind", a sequence and a mapping,
# it's not a valid binding.
if len(comps) != 3:
continue
# Store the "--preset" value for later
if comps[1] == "--preset":
preset = True
# There's possibly a way to do this faster, but it's not important.
comps = line.split(" ", 3)[1:]
elif comps[1] == "--user":
preset = False
comps = line.split(" ", 3)[1:]
# Check again if we removed the level.
if len(comps) != 3:
continue
key = comps[1]
command = comps[2]
if command in bindings_blacklist:
continue
if command in command_to_binding:
fish_binding = command_to_binding[command]
fish_binding.add_binding(line, key)
else:
fish_binding = FishBinding(command, line, key)
bindings.append(fish_binding)
command_to_binding[command] = fish_binding
return [binding.get_json_obj() for binding in bindings]
def do_get_history(self):
# Use NUL to distinguish between history items.
out, err = run_fish_cmd("builtin history -z")
result = out.split("\0")
if result:
result.pop() # trim off the trailing element
return result
def do_set_color_for_variable(self, name, color):
"Sets a color for a fish color name, like 'fish_color_autosuggestion'"
if not name:
raise ValueError
if not color and not color == "":
color = "normal"
else:
color = unparse_color(color)
name = name.strip()
if not re.match("^[a-zA-Z0-9_]+$", name):
print("Refusing to use variable name: '", name, "'")
return
color = color.strip()
if not re.match("^[a-zA-Z0-9_= -]*$", color):
print("Refusing to use color value: ", color)
return
return name + " " + color
def do_get_function(self, func_name):
out, err = run_fish_cmd("functions " + func_name + " | fish_indent --html")
return out
def do_delete_history_item(self, history_item_text):
# It's really lame that we always return success here
cmd = (
"builtin history delete --case-sensitive --exact -- %s; builtin history save"
% escape_fish_cmd(history_item_text)
)
out, err = run_fish_cmd(cmd)
return True
def do_set_prompt_function(self, prompt_func):
cmd = (
"functions -e fish_right_prompt; "
+ prompt_func
+ "\n"
+ "funcsave fish_prompt && funcsave fish_right_prompt 2>/dev/null"
)
out, err = run_fish_cmd(cmd)
return len(err) == 0
def do_get_prompt(self, prompt_function_text, extras_dict):
# Return the prompt output by the given command
cmd = (
prompt_function_text
+ '\n builtin cd "'
+ initial_wd
+ '" \n false \n fish_prompt\n'
)
prompt_demo_ansi, err = run_fish_cmd(cmd)
prompt_demo_html = ansi_to_html(prompt_demo_ansi)
right_demo_ansi, err = run_fish_cmd(
"functions -e fish_right_prompt; "
+ prompt_function_text
+ '\n builtin cd "'
+ initial_wd
+ '" \n false \n functions -q fish_right_prompt && fish_right_prompt\n'
)
right_demo_html = ansi_to_html(right_demo_ansi)
prompt_demo_font_size = self.font_size_for_ansi_prompt(
prompt_demo_ansi + right_demo_ansi
)
result = {
"function": prompt_function_text,
"demo": prompt_demo_html,
"font_size": prompt_demo_font_size,
"right": right_demo_html,
}
if extras_dict:
result.update(extras_dict)
return result
def do_get_current_prompt(self):
# Return the current prompt. We run 'false' to demonstrate how the
# prompt shows the command status (#1624).
prompt_func, err = run_fish_cmd(
"functions fish_prompt; functions fish_right_prompt"
)
result = self.do_get_prompt(
prompt_func.strip(),
{"name": "Current"},
)
return result
def do_get_sample_prompt(self, text, extras_dict):
# Return the prompt you get from the given text. Extras_dict is a
# dictionary whose values get merged in. We run 'false' to demonstrate
# how the prompt shows the command status (#1624)
return self.do_get_prompt(text.strip(), extras_dict)
def parse_one_sample_prompt_hash(self, line, result_dict):
# Allow us to skip whitespace, etc.
if not line:
return True
if line.isspace():
return True
# Parse a comment hash like '# name: Classic'
match = re.match(r"#\s*(\w+?): (.+)", line, re.IGNORECASE)
if match:
key = match.group(1).strip()
value = match.group(2).strip()
result_dict[key] = value
return True
# Skip other hash comments
return line.startswith("#")
def read_one_sample_prompt(self, path):
try:
extras_dict = {}
# Read one sample prompt from out
function_lines = []
parsing_hashes = True
for line in get_embedded_file(path).splitlines(keepends=True):
# Parse hashes until parse_one_sample_prompt_hash return
# False.
if parsing_hashes:
parsing_hashes = self.parse_one_sample_prompt_hash(
line, extras_dict
)
# Maybe not we're not parsing hashes, or maybe we already
# were not.
if not parsing_hashes:
function_lines.append(line)
func = "".join(function_lines).strip()
result = self.do_get_sample_prompt(func, extras_dict)
return result
except IOError:
# Ignore unreadable files, etc.
return None
def do_get_sample_prompts_list(self):
paths = list_embedded_files("prompts", ".fish")
result = []
try:
pool = multiprocessing.pool.ThreadPool(processes=8)
# Kick off the "Current" meta-sample
current_metasample_async = pool.apply_async(self.do_get_current_prompt)
# Read all of the prompts in sample_prompts
sample_results = pool.map(self.read_one_sample_prompt, paths, 1)
result.append(current_metasample_async.get())
result.extend([r for r in sample_results if r])
except ImportError:
# If the platform doesn't support multiprocessing, we just do it one at a time.
# This happens e.g. on Termux.
print(
"Platform doesn't support multiprocessing, running one at a time. This may take a while."
)
result.append(self.do_get_current_prompt())
result.extend([self.read_one_sample_prompt(path) for path in paths])
return result
def secure_startswith(self, haystack, needle):
if len(haystack) < len(needle):
return False
bits = 0
for x, y in zip(haystack, needle):
bits |= ord(x) ^ ord(y)
return bits == 0
def font_size_for_ansi_prompt(self, prompt_demo_ansi):
width = ansi_prompt_line_width(prompt_demo_ansi)
# Pick a font size
if width >= 70:
font_size = "8pt"
if width >= 60:
font_size = "10pt"
elif width >= 50:
font_size = "11pt"
elif width >= 40:
font_size = "13pt"
elif width >= 30:
font_size = "15pt"
elif width >= 25:
font_size = "16pt"
elif width >= 20:
font_size = "17pt"
else:
font_size = "18pt"
return font_size
def do_GET(self):
p = self.path
authpath = "/" + authkey
if self.secure_startswith(p, authpath):
p = p[len(authpath) :]
else:
return self.send_error(403)
self.path = p
if p == "/colors/":
output = self.do_get_colors()
elif p == "/functions/":
output = self.do_get_functions()
elif p == "/variables/":
output = self.do_get_variables()
elif p == "/history/":
# start = time.time()
output = self.do_get_history()
# end = time.time()
# print "History: ", end - start
elif p == "/sample_prompts/":
output = self.do_get_sample_prompts_list()
elif p == "/bindings/":
output = self.do_get_bindings()
else:
return SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
# Return valid output
self.send_response(200)
self.send_header("Content-type", "application/json")
self.end_headers()
self.write_to_wfile("\n")
# Output JSON
self.write_to_wfile(json.dumps(output))
def do_POST(self):
p = self.path
authpath = "/" + authkey
if self.secure_startswith(p, authpath):
p = p[len(authpath) :]
else:
return self.send_error(403)
self.path = p
# This is cheesy, we want just the actual content-type.
# In some cases it'll give us the encoding as well,
# ("application/json;charset=utf-8")
# but we don't currently care.
content_type = self.headers["content-type"].split(";")[0]
if content_type == "application/x-www-form-urlencoded":
length = int(self.headers["content-length"])
url_str = self.rfile.read(length).decode("utf-8")
postvars = parse_qs(url_str, keep_blank_values=1)
elif content_type == "application/json":
length = int(self.headers["content-length"])
# This used to use the provided encoding, but we use utf-8
# all around the place and nobody has ever complained.
#
# If any other encoding is received this will raise a UnicodeError,
# which will throw us out of the function and should at most exit webconfig.
# If that happens to anyone we expect bug reports.
url_str = self.rfile.read(length).decode("utf-8")
postvars = json.loads(url_str)
elif content_type == "multipart/form-data":
# This used to be a thing, as far as I could find there's
# no use anymore, but let's keep an error around just in case.
return self.send_error(500)
else:
postvars = {}
if p == "/set_color/":
print("# Colorscheme: " + postvars.get("theme"))
output = ""
theme_contents = []
for item in postvars.get("colors"):
what = item.get("what")
color = item.get("color")
if what:
theme_contents += [self.do_set_color_for_variable(what, color)]
varname = "__fish_webconfig_theme_notification"
out, err = run_fish_cmd(
"__fish_theme_freeze 'fish_config' {}\n".format(
" ".join(escape_fish_cmd(x) for x in theme_contents)
)
+ "begin\n"
+ " set -l i 0\n"
+ " if not set -q {}\n".format(varname)
+ " or string match -qr -- '^set-theme-v1-#(?\\d+)$' ${}\n".format(
varname
)
+ " set -U {} set-theme-v1-#(math $i + 1)\n".format(varname)
+ " end\n"
+ "end\n"
)
assert out == ""
assert err == ""
elif p == "/get_function/":
what = postvars.get("what")
output = [self.do_get_function(what[0])]
elif p == "/delete_history_item/":
what = postvars.get("what")
if self.do_delete_history_item(what[0]):
output = ["OK"]
else:
output = ["Unable to delete history item"]
elif p == "/set_prompt/":
what = postvars.get("fish_prompt")
if self.do_set_prompt_function(what):
output = ["OK"]
else:
output = ["Unable to set prompt"]
else:
return self.send_error(404)
# Return valid output
self.send_response(200)
self.send_header("Content-type", "application/json")
self.end_headers()
self.write_to_wfile("\n")
# Output JSON
self.write_to_wfile(json.dumps(output))
def log_request(self, code="-", size="-"):
"""Disable request logging"""
pass
def log_error(self, format, *args):
if format == "code %d, message %s" and hasattr(self, "path"):
# This appears to be a send_error() message
# We want to include the path (if we have one)
(code, msg) = args
format = "code %d, message %s, path %s"
args = (code, msg, self.path)
SimpleHTTPServer.SimpleHTTPRequestHandler.log_error(self, format, *args)
redirect_template_html = """
Start the Fish Web config
"""
# find fish
fish_bin_dir = os.environ.get("fish_bin_dir")
fish_bin_path = None
# only need the '.exe' extension on Windows
fish_bin_name = "fish.exe" if is_windows() else "fish"
if not fish_bin_dir:
print("The $__fish_bin_dir environment variable is not set. Looking in $PATH...")
fish_bin_path = find_executable(fish_bin_name)
if not fish_bin_path:
print("fish could not be found. Is fish installed correctly?")
sys.exit(-1)
else:
print("fish found at '%s'" % fish_bin_path)
else:
fish_bin_path = os.path.join(fish_bin_dir, fish_bin_name)
if not os.access(fish_bin_path, os.X_OK):
print(
"fish could not be executed at path '%s'. "
"Is fish installed correctly?" % fish_bin_path
)
sys.exit(-1)
FISH_BIN_PATH = fish_bin_path
# We want to show the demo prompts in the directory from which this was invoked,
# so get the current working directory
initial_wd = os.getcwd()
# Make sure that the working directory is the one that contains the script
# server file, because the document root is the working directory.
where = os.path.dirname(sys.argv[0])
os.chdir(where)
# Generate a 16-byte random key as a hexadecimal string
authkey = binascii.b2a_hex(os.urandom(16)).decode("ascii")
# Try to find a suitable port
PORT = 8000
HOST = "::" if socket.has_ipv6 else "localhost"
while PORT <= 9000:
try:
Handler = FishConfigHTTPRequestHandler
httpd = FishConfigTCPServer((HOST, PORT), Handler)
# Success
break
except (OSError, socket.error) as e:
if e.errno == errno.EAFNOSUPPORT and HOST == "::":
print("Ipv6 seems to be unavailable, trying ipv4")
# We can't do ipv6, let's try v4.
HOST = "127.0.0.1"
PORT = 8000
# Override the class address_family variable (yes, this is a hack)
FishConfigTCPServer.address_family = socket.AF_INET
continue
if e.errno != errno.EADDRINUSE:
print(str(e))
sys.exit(-1)
PORT += 1
if PORT > 9000:
# Nobody say it
print("Unable to find an open port between 8000 and 9000")
sys.exit(-1)
# Get any initial tab (functions, colors, etc)
# Just look at the first letter
initial_tab = ""
if len(sys.argv) > 1:
for tab in [
"functions",
"prompt",
"colors",
"variables",
"history",
"bindings",
]:
if tab.startswith(sys.argv[1]):
initial_tab = "#!/" + tab
break
url = "http://localhost:%d/%s/%s" % (PORT, authkey, initial_tab)
# Create temporary file to hold redirect to real server. This prevents exposing
# the URL containing the authentication key on the command line (see
# CVE-2014-2914 or https://github.com/fish-shell/fish-shell/issues/1438).
#
# If on Windows, the file needs to be closed after writing, otherwise, the browser won't be able to open it."
# unfortunately this was added in python 3.12, so we don't add it on other platforms
# to support older python versions there.
kwargs = {}
if is_windows():
kwargs["delete_on_close"] = False
f = tempfile.NamedTemporaryFile(
prefix="web_config",
suffix=".html",
mode="w",
delete=True,
**kwargs,
)
f.write(redirect_template_html % (url, url))
f.flush()
if is_windows():
f.close()
# Open temporary file as URL
# Use open on macOS >= 10.12.5 to work around #4035.
fileurl = "file://" + f.name
if is_windows():
fileurl = fileurl.replace("\\", "/")
print(
"Web config started at %s%s%s"
% (ENTER_UNDERLINE_MODE, fileurl, EXIT_ATTRIBUTE_MODE)
)
print(
"If that doesn't work, try opening %s%s%s"
% (ENTER_UNDERLINE_MODE, url, EXIT_ATTRIBUTE_MODE)
)
print("%sHit ENTER to stop.%s" % (ENTER_BOLD_MODE, EXIT_ATTRIBUTE_MODE))
def runThing():
if os.environ.get("BROWSER") == "true":
# Don't start a browser in this case (see issue #11926)
pass
elif is_wsl():
cmd_path = find_executable("cmd.exe", COMMON_WSL_CMD_PATHS)
if cmd_path:
subprocess.call([cmd_path, "/c", "start %s" % url])
else:
print("Please add the directory containing cmd.exe to your $PATH")
sys.exit(-1)
elif is_termux():
subprocess.call(["termux-open-url", url])
elif is_chromeos_garcon():
webbrowser.open(url)
elif is_sailfish_os():
subprocess.call(["xdg-open", url])
else:
webbrowser.open(fileurl)
# Some browsers still block webbrowser.open if they haven't been opened before,
# so we just spawn it in a thread.
thread = threading.Thread(target=runThing)
thread.start()
# Safari will open sockets and not write to them, causing potential hangs
# on shutdown.
httpd.block_on_close = False
httpd.daemon_threads = True
# Select on stdin and httpd
stdin_no = sys.stdin.fileno()
def create_socket(start_port, end_port):
"""Attempt to create a socket from a range of ports."""
for port in range(start_port, end_port + 1):
try:
sck = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sck.bind(("localhost", port))
sck.listen()
return (sck, port)
except socket.error:
pass
print("Unable to find an open port between {} and {}.".format(start_port, end_port))
sys.exit(-1)
def capture_enter(port):
"""Read keyboard events and establish a socket connection when pressing the Enter."""
import msvcrt
while True:
if msvcrt.kbhit():
key = msvcrt.getch().decode()
if key == "\r" or key == "\n":
break
sck = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sck.connect(("localhost", port))
def get_windows_signal():
"""Using socket as a replacement for stdin on Windows."""
# The intent is to get a free port between 8000 and 9000, like for the HTTP
# server. But we already know that port 8000..PORT are not available. So
# starting from `PORT+1` is more efficient.
# More importantly though, Windows allows multiple sockets to bind to the
# same port in some circumstances (see SO_EXCLUSIVEADDRUSE documentation),
# and thus allows the signal socket to bind to the same port as HTTP.
# A browser may then end up reaching the wrong socket and causing
# fish_config to shutdown prematurely.
(sig, sig_port) = create_socket(PORT + 1, 9000)
threading.Thread(target=capture_enter, args=(sig_port,)).start()
return sig
try:
httpd_fileno = httpd.fileno()
sig = get_windows_signal() if is_windows() else sys.stdin
sig_fileno = sig.fileno()
while True:
ready_read = select.select([sig_fileno, httpd_fileno], [], [])
if ready_read[0][0] != httpd_fileno:
print("Shutting down.")
# On windows the newline has already been consumed by the capture_enter function.
if not is_windows():
# Consume the newline so it doesn't get printed by the caller
sys.stdin.readline()
break
else:
httpd.handle_request()
except KeyboardInterrupt:
print("\nShutting down.")
# Clean up temporary file
# If on Windows, the file already closed
if not is_windows():
f.close()
thread.join()