Initial commit
This commit is contained in:
scorpion21211-cmd
@@ -0,0 +1,759 @@
|
||||
@tool
|
||||
class_name McpDshStrategy
|
||||
extends RefCounted
|
||||
|
||||
## Configure / status / remove for DeepSeek Harness (dsh) MCP servers.
|
||||
##
|
||||
## DeepSeek Harness has no `mcp` CLI verb (verified against dsh
|
||||
## 0.1.0-rc.6 — `dsh --help` exposes only `web` and `plugin`). MCP servers
|
||||
## register as `@deepseek-ai/dsh-mcp-client` plugin entries in the HOME patch
|
||||
## layer `$DSH_HOME/cordis.patch.yml` — the machine-local layer dsh applies
|
||||
## over EVERY profile's own patch layer (the web GUI included), so one entry
|
||||
## covers every profile the user boots.
|
||||
##
|
||||
## The patch file is a top-level YAML array of loader patch entries
|
||||
## (`@deepseek-ai/cordis-plugin-include`'s `applyEntryPatches`). A non-insert
|
||||
## row only OVERRIDES an existing bundle row (a new id is skipped with a
|
||||
## warning), so a brand-new server must be added with an `insert` row:
|
||||
##
|
||||
## - insert:
|
||||
## - id: mcp-godot-ai
|
||||
## name: '@deepseek-ai/dsh-mcp-client'
|
||||
## config:
|
||||
## serverName: godot-ai
|
||||
## transport: stdio
|
||||
## command: "..."
|
||||
## args: [...]
|
||||
##
|
||||
## Both shapes verified live against the dsh loader
|
||||
## (`dsh --profile web --dump-config` composes the inserted entry; a plain
|
||||
## row for a new id warns "patch: entry not found" and is skipped). We write
|
||||
## one dedicated insert row per server, preserve every other row byte-for-byte
|
||||
## (including other users' insert rows, overrides, comments, and `!!js`
|
||||
## expressions), and status-verify the entry we wrote — the same file-read
|
||||
## drift contract the JSON/TOML/YAML strategies use.
|
||||
##
|
||||
## The entry's `config` nests the launch under `serverName`/`transport`/
|
||||
## `command`/`args`; `serverName` is the model-facing tool namespace
|
||||
## (`mcp__godot-ai__<tool>`), so it carries the server name like the
|
||||
## `server_key_path` map key does for the other strategies.
|
||||
|
||||
## Loader entry id prefix inside the patch list. The full id is
|
||||
## `<prefix><server_name>` — "mcp-godot-ai" for the godot-ai server.
|
||||
const ENTRY_ID_PREFIX := "mcp-"
|
||||
## The loader plugin that bridges MCP servers into the harness. Must be
|
||||
## installed in the profile's node_modules (dsh ships it as a dependency of
|
||||
## the CLI package). Quoted in the file: `@` is a reserved YAML indicator and
|
||||
## cannot start a plain scalar.
|
||||
const PLUGIN_NAME := "@deepseek-ai/dsh-mcp-client"
|
||||
## Indent of a nested entry header under `- insert:` (children step 2 spaces
|
||||
## deeper), matching the shipped profile patch files.
|
||||
const ENTRY_INDENT := 4
|
||||
|
||||
|
||||
static func entry_id(server_name: String) -> String:
|
||||
return ENTRY_ID_PREFIX + server_name
|
||||
|
||||
|
||||
static func configure(
|
||||
client: McpClient,
|
||||
server_name: String,
|
||||
server_url: String,
|
||||
launch: Dictionary = {},
|
||||
) -> Dictionary:
|
||||
var resolution := client.resolved_config_path_details()
|
||||
var path := str(resolution.get("path", ""))
|
||||
var path_error := str(resolution.get("error", ""))
|
||||
if not path_error.is_empty():
|
||||
return {"status": "error", "message": path_error}
|
||||
if path.is_empty():
|
||||
return {"status": "error", "message": "Could not resolve config path for %s on this OS" % client.display_name}
|
||||
## Fail closed before touching the file — same contract as JSON/TOML/YAML.
|
||||
var launch_error := command_launch_error(client, launch)
|
||||
if not launch_error.is_empty():
|
||||
return {"status": "error", "message": launch_error}
|
||||
|
||||
var read := _read(path)
|
||||
if not read["ok"]:
|
||||
return {"status": "error", "message": "Refusing to overwrite %s: %s. Fix or move the file, then re-run Configure." % [path, read["error"]]}
|
||||
## Fail closed on content that is not a loader patch list: dsh's patch
|
||||
## parser rejects a non-array file at boot, so appending our row to a
|
||||
## top-level mapping would hand the user a broken file (#867 review).
|
||||
## `[]` is a valid empty sequence meaning "no rows"; the literal must not
|
||||
## survive an append (block rows after `[]` are malformed YAML), so only
|
||||
## that line is dropped — comments around it belong to the user and stay.
|
||||
var text := String(read["data"])
|
||||
text = _strip_empty_flow_sequence(text)
|
||||
if not _is_patch_sequence(text):
|
||||
return {
|
||||
"status": "error",
|
||||
"message": "Refusing to overwrite %s: it is not a top-level YAML list of loader entries. Fix or remove the file, then re-run Configure." % path,
|
||||
}
|
||||
|
||||
var existing_config: Variant = null
|
||||
var lines := _split_lines(text)
|
||||
var found := _find_entry_block(lines, entry_id(server_name), true)
|
||||
if found.is_empty():
|
||||
var plain := _find_entry_block(lines, entry_id(server_name), false)
|
||||
if not plain.is_empty():
|
||||
## A plain `- id: mcp-godot-ai` row is inert for a new id — the
|
||||
## loader skips it with a warning and never registers the server.
|
||||
## Replacing the whole row with the insert form migrates it.
|
||||
found = plain
|
||||
if not found.is_empty():
|
||||
## Pass the parsed config through so user-mutable fields (env,
|
||||
## toolCallTimeoutMs, reconnect) survive a reconfigure.
|
||||
existing_config = _extract_config(lines, found)
|
||||
var new_entry := build_entry(client, server_name, server_url, existing_config, launch)
|
||||
## Nested replacement must keep the sequence's existing header indent —
|
||||
## items of one block sequence share indentation, so a hand-written
|
||||
## 2-space file re-emitted at 4 spaces would no longer parse (#867
|
||||
## review). Fresh rows and plain-row migrations keep the 4-space style.
|
||||
var base_indent := ENTRY_INDENT
|
||||
if not found.is_empty():
|
||||
var header_indent := int(found.get("indent", 0))
|
||||
if header_indent > 0:
|
||||
base_indent = header_indent
|
||||
var rendered := render_nested_entry(entry_id(server_name), new_entry, base_indent)
|
||||
var out := ""
|
||||
if found.is_empty():
|
||||
out = _append_row(lines, rendered)
|
||||
else:
|
||||
out = _replace_lines(lines, found, rendered)
|
||||
if not McpAtomicWrite.write(path, out):
|
||||
return {"status": "error", "message": "Cannot write to %s" % path}
|
||||
return {"status": "ok", "message": McpClient.configured_message(client, server_url)}
|
||||
|
||||
|
||||
static func check_status(
|
||||
client: McpClient,
|
||||
server_name: String,
|
||||
server_url: String,
|
||||
launch: Dictionary = {},
|
||||
) -> McpClient.Status:
|
||||
return check_status_details(client, server_name, server_url, launch)["status"]
|
||||
|
||||
|
||||
## Same contract as the other strategies (#711): {status, error_msg}. An
|
||||
## existing-but-unreadable config is ERROR with the diagnostic — not
|
||||
## NOT_CONFIGURED — so the dock row can tell "no config" from "config the
|
||||
## editor can't read" instead of offering a Configure that would fail.
|
||||
static func check_status_details(
|
||||
client: McpClient, server_name: String, server_url: String, launch: Dictionary = {}
|
||||
) -> Dictionary:
|
||||
var resolution := client.resolved_config_path_details()
|
||||
var path := str(resolution.get("path", ""))
|
||||
var path_error := str(resolution.get("error", ""))
|
||||
if not path_error.is_empty():
|
||||
return {"status": McpClient.Status.ERROR, "error_msg": path_error}
|
||||
if path.is_empty() or not FileAccess.file_exists(path):
|
||||
return {"status": McpClient.Status.NOT_CONFIGURED, "error_msg": ""}
|
||||
var read := _read(path)
|
||||
if not read["ok"]:
|
||||
return {
|
||||
"status": McpClient.Status.ERROR,
|
||||
"error_msg": "Cannot read %s: %s" % [path, read["error"]],
|
||||
}
|
||||
var text := String(read["data"])
|
||||
if not _is_patch_sequence(text):
|
||||
## A top-level mapping/scalar is not a dsh patch list: nothing in it
|
||||
## can be "configured", and a nested `- id:` inside a mapping must
|
||||
## not read as ours (#867 review).
|
||||
return {
|
||||
"status": McpClient.Status.ERROR,
|
||||
"error_msg": "%s is not a top-level YAML list of loader entries; fix or remove the file." % path,
|
||||
}
|
||||
var lines := _split_lines(text)
|
||||
var found := _find_entry_block(lines, entry_id(server_name), true)
|
||||
if found.is_empty():
|
||||
## A plain row for our id is inert (the loader skips unknown ids), so
|
||||
## the server is NOT registered no matter what the file says. It only
|
||||
## becomes registered once Configure rewrites it as an insert row.
|
||||
return {"status": McpClient.Status.NOT_CONFIGURED, "error_msg": ""}
|
||||
var config := _extract_config(lines, found)
|
||||
if config.is_empty():
|
||||
return {"status": McpClient.Status.NOT_CONFIGURED, "error_msg": ""}
|
||||
## An entry exists but no verified launcher does — mirror the other
|
||||
## strategies: this is an environment ERROR, not entry drift.
|
||||
var launch_error := command_launch_error(client, launch)
|
||||
if not launch_error.is_empty():
|
||||
return {"status": McpClient.Status.ERROR, "error_msg": launch_error}
|
||||
if verify_entry(client, config, server_name, server_url, launch):
|
||||
return {"status": McpClient.Status.CONFIGURED, "error_msg": ""}
|
||||
return {"status": McpClient.Status.CONFIGURED_MISMATCH, "error_msg": ""}
|
||||
|
||||
|
||||
static func remove(client: McpClient, server_name: String) -> Dictionary:
|
||||
var resolution := client.resolved_config_path_details()
|
||||
var path := str(resolution.get("path", ""))
|
||||
var path_error := str(resolution.get("error", ""))
|
||||
if not path_error.is_empty():
|
||||
return {"status": "error", "message": path_error}
|
||||
if path.is_empty() or not FileAccess.file_exists(path):
|
||||
return {"status": "ok", "message": "Not configured"}
|
||||
var read := _read(path)
|
||||
if not read["ok"]:
|
||||
return {"status": "error", "message": "Refusing to rewrite %s: %s." % [path, read["error"]]}
|
||||
var text := String(read["data"])
|
||||
if not _is_patch_sequence(text):
|
||||
## Same fail-closed contract as configure (#867 review): never modify
|
||||
## a file that dsh cannot load as a patch list.
|
||||
return {
|
||||
"status": "error",
|
||||
"message": "Refusing to rewrite %s: it is not a top-level YAML list of loader entries. Fix or remove the file, then re-run Remove." % path,
|
||||
}
|
||||
var lines := _split_lines(text)
|
||||
var found := _find_entry_block(lines, entry_id(server_name), true)
|
||||
if found.is_empty():
|
||||
found = _find_entry_block(lines, entry_id(server_name), false)
|
||||
if found.is_empty():
|
||||
return {"status": "ok", "message": "%s configuration removed" % client.display_name}
|
||||
var out := _remove_lines(lines, found)
|
||||
if _is_blank_or_comment_only(out):
|
||||
## dsh's patch parser requires a top-level YAML array: an empty or
|
||||
## comment-only patch file FAILS BOOT (`loadOptionalPatches` throws on
|
||||
## a non-array file), while an absent file means "no layer". After our
|
||||
## row is gone, an all-blank file must therefore be deleted, not
|
||||
## written back.
|
||||
if FileAccess.file_exists(path):
|
||||
var remove_err := DirAccess.remove_absolute(path)
|
||||
if remove_err != OK:
|
||||
return {"status": "error", "message": "Cannot remove %s (error %d)" % [path, remove_err]}
|
||||
return {"status": "ok", "message": "%s configuration removed" % client.display_name}
|
||||
if not McpAtomicWrite.write(path, out):
|
||||
return {"status": "error", "message": "Cannot write to %s" % path}
|
||||
return {"status": "ok", "message": "%s configuration removed" % client.display_name}
|
||||
|
||||
|
||||
## Build the `config` dict written inside the loader entry. Command mode
|
||||
## (FLAT, #838) nests `serverName`/`transport`/`command`/`args`; URL mode nests
|
||||
## `serverName`/`transport`/`url`. Existing user state (env, timeouts,
|
||||
## reconnect) survives a reconfigure via the deep copy.
|
||||
static func build_entry(
|
||||
client: McpClient,
|
||||
server_name: String,
|
||||
server_url: String,
|
||||
existing: Variant = null,
|
||||
launch: Dictionary = {},
|
||||
) -> Dictionary:
|
||||
var entry: Dictionary = (existing as Dictionary).duplicate(true) if existing is Dictionary else {}
|
||||
entry["serverName"] = server_name
|
||||
if client.command_shape == McpClient.CommandShape.FLAT:
|
||||
entry["command"] = str(launch.get("command", ""))
|
||||
entry["args"] = _array_copy(launch.get("args", []))
|
||||
if not client.command_transport_key.is_empty():
|
||||
entry[client.command_transport_key] = client.command_transport_value
|
||||
for key in client.command_initial_fields:
|
||||
if not entry.has(key):
|
||||
entry[key] = client.command_initial_fields[key]
|
||||
for key in client.command_legacy_keys:
|
||||
entry.erase(String(key))
|
||||
return entry
|
||||
if client.command_shape == McpClient.CommandShape.NONE:
|
||||
## Single URL-mode source of truth (#867 review): build_entry's URL
|
||||
## branch delegates to build_url_entry so the two can never drift.
|
||||
return build_url_entry(client, server_name, server_url, existing)
|
||||
return {}
|
||||
|
||||
|
||||
## URL-mode sibling for the manual-instruction fallback text and the
|
||||
## build_entry URL branch. DeepSeek Harness' mcp-client bridge accepts
|
||||
## `transport: streamable-http` with a `url`, so the entry keeps the same
|
||||
## `serverName` namespace with an HTTP transport instead of the stdio attach
|
||||
## bridge. Existing user state survives via the deep copy.
|
||||
static func build_url_entry(
|
||||
client: McpClient, server_name: String, server_url: String, existing: Variant = null
|
||||
) -> Dictionary:
|
||||
var entry: Dictionary = (existing as Dictionary).duplicate(true) if existing is Dictionary else {}
|
||||
entry["serverName"] = server_name
|
||||
entry["transport"] = "streamable-http"
|
||||
if not client.entry_url_field.is_empty():
|
||||
entry[client.entry_url_field] = server_url
|
||||
return entry
|
||||
|
||||
|
||||
## Verify a stored `config` dict matches the current launch. Command mode
|
||||
## checks every launch-affecting value exactly and requires legacy URL keys
|
||||
## gone; serverName must match the pinned namespace. URL mode checks the url
|
||||
## and the streamable-http pin.
|
||||
static func verify_entry(
|
||||
client: McpClient,
|
||||
config: Dictionary,
|
||||
server_name: String,
|
||||
server_url: String,
|
||||
launch: Dictionary = {},
|
||||
) -> bool:
|
||||
if config.get("serverName") != server_name:
|
||||
return false
|
||||
if client.command_shape != McpClient.CommandShape.NONE:
|
||||
if client.command_shape != McpClient.CommandShape.FLAT or not bool(launch.get("ok", false)):
|
||||
return false
|
||||
for key in client.command_legacy_keys:
|
||||
if config.has(String(key)):
|
||||
return false
|
||||
if config.get("command") != launch.get("command"):
|
||||
return false
|
||||
if not _arrays_equal(config.get("args", null), launch.get("args", null)):
|
||||
return false
|
||||
if not client.command_transport_key.is_empty():
|
||||
if config.get(client.command_transport_key, null) != client.command_transport_value:
|
||||
return false
|
||||
return true
|
||||
if config.get(client.entry_url_field, "") != server_url:
|
||||
return false
|
||||
return config.get("transport", "") == "streamable-http"
|
||||
|
||||
|
||||
## Empty string when this client's launch requirements are satisfied.
|
||||
## Mirrors `McpYamlStrategy.command_launch_error`; the patch-list dialect
|
||||
## supports FLAT (and the URL fallback) only.
|
||||
static func command_launch_error(client: McpClient, launch: Dictionary) -> String:
|
||||
if client.command_shape == McpClient.CommandShape.NONE:
|
||||
return ""
|
||||
if client.command_shape != McpClient.CommandShape.FLAT:
|
||||
return "%s uses a command shape not supported by DeepSeek Harness config yet" % client.display_name
|
||||
if not bool(launch.get("ok", false)):
|
||||
return str(launch.get("error", "No compatible attach launcher was found."))
|
||||
return ""
|
||||
|
||||
|
||||
# --- Rendering --------------------------------------------------------------
|
||||
|
||||
## Render a full `- insert:` row containing one nested loader entry. Public
|
||||
## seam for the dock's manual-instruction text so the pasted YAML matches
|
||||
## what Configure would write byte-for-byte.
|
||||
static func render_insert_row(entry_id_value: String, config: Dictionary) -> PackedStringArray:
|
||||
var lines: PackedStringArray = ["- insert:"]
|
||||
lines.append_array(render_nested_entry(entry_id_value, config))
|
||||
return lines
|
||||
|
||||
|
||||
## Render one nested loader entry (the `- id:` block inside an `insert`
|
||||
## list). `base_indent` defaults to the 4-space style used by the shipped
|
||||
## patch files; a nested replacement reuses the indent the existing entry was
|
||||
## found at so the block sequence keeps a single indentation (#867 review).
|
||||
static func render_nested_entry(
|
||||
entry_id_value: String, config: Dictionary, base_indent: int = ENTRY_INDENT
|
||||
) -> PackedStringArray:
|
||||
var lines: PackedStringArray = []
|
||||
lines.append("%s- id: %s" % [_indent_str(base_indent), entry_id_value])
|
||||
lines.append("%sname: '%s'" % [_indent_str(base_indent + 2), PLUGIN_NAME])
|
||||
lines.append("%sconfig:" % _indent_str(base_indent + 2))
|
||||
for key in config:
|
||||
lines.append_array(_emit_field(String(key), config[key], base_indent + 4))
|
||||
return lines
|
||||
|
||||
|
||||
## Emit one `key: value` line (or a nested block for Dictionary values) at
|
||||
## the given indent. Arrays render in flow style; scalars through the shared
|
||||
## YAML emitter so quoting rules stay identical across the two YAML dialects.
|
||||
static func _emit_field(key: String, value: Variant, indent: int) -> PackedStringArray:
|
||||
var lines: PackedStringArray = []
|
||||
var prefix := _indent_str(indent)
|
||||
if value is Dictionary:
|
||||
lines.append("%s%s:" % [prefix, key])
|
||||
for sub_key in value:
|
||||
lines.append_array(_emit_field(String(sub_key), value[sub_key], indent + 2))
|
||||
elif value is Array or value is PackedStringArray:
|
||||
lines.append("%s%s: %s" % [prefix, key, McpYamlStrategy.emit_flow_array(_array_copy(value))])
|
||||
else:
|
||||
lines.append("%s%s: %s" % [prefix, key, McpYamlStrategy.emit_scalar(value)])
|
||||
return lines
|
||||
|
||||
|
||||
# --- Line-level parsing (no YAML parser in Godot) ---------------------------
|
||||
|
||||
## Split file text into lines, dropping only a single trailing newline so the
|
||||
## remainder round-trips byte-for-byte. `text` is never split on the empty
|
||||
## string, so an empty file yields an empty array.
|
||||
static func _split_lines(text: String) -> PackedStringArray:
|
||||
if text.is_empty():
|
||||
return PackedStringArray()
|
||||
var lines := text.split("\n")
|
||||
if lines.size() > 0 and String(lines[lines.size() - 1]).is_empty():
|
||||
lines.remove_at(lines.size() - 1)
|
||||
return lines
|
||||
|
||||
|
||||
## Locate the block owned by our loader entry:
|
||||
## require_nested=true — the `- id: <entry_id>` line inside an `insert`
|
||||
## list (indent > 0), plus its indented children.
|
||||
## require_nested=false — a plain top-level `- id: <entry_id>` row (indent
|
||||
## 0), plus its indented children.
|
||||
## Returns {"start": int, "end": int, "indent": int} (end exclusive) or {}
|
||||
## when absent. The header indent is detected dynamically so a hand-written
|
||||
## file using non-2-space indentation is still found; children are lines
|
||||
## deeper than the header. `end` stops right AFTER the last content line:
|
||||
## trailing blank and comment lines between our entry and the next sibling
|
||||
## belong to the file, not to our block, so `_replace_lines` / `_remove_lines`
|
||||
## (which splice [start, end)) never delete them (#867 review).
|
||||
static func _find_entry_block(lines: PackedStringArray, entry_id_value: String, require_nested: bool) -> Dictionary:
|
||||
for i in range(lines.size()):
|
||||
var indent := _indent_of(lines[i])
|
||||
if require_nested and indent <= 0:
|
||||
continue
|
||||
if not require_nested and indent != 0:
|
||||
continue
|
||||
var parsed := _parse_entry_header(lines[i])
|
||||
if parsed.is_empty() or parsed.get("id") != entry_id_value:
|
||||
continue
|
||||
## A nested match must actually live inside an `- insert:` row: a
|
||||
## `- id:` list under some other top-level row (an override row's own
|
||||
## sequence, say) is not a loader entry and is not ours to touch.
|
||||
if require_nested and not _under_insert_row(lines, i):
|
||||
continue
|
||||
var j := i + 1
|
||||
var last_content := i
|
||||
while j < lines.size():
|
||||
var l := lines[j]
|
||||
if _is_blank_or_comment(l):
|
||||
j += 1
|
||||
continue
|
||||
if _indent_of(l) <= indent:
|
||||
break
|
||||
last_content = j
|
||||
j += 1
|
||||
return {"start": i, "end": last_content + 1, "indent": indent}
|
||||
return {}
|
||||
|
||||
|
||||
## True when the nearest preceding 0-indent content line above `index` is an
|
||||
## `- insert:` row header. Blank and comment lines are skipped; hitting the
|
||||
## top of the file without a header means the nested line is orphaned and
|
||||
## cannot be a loader entry.
|
||||
static func _under_insert_row(lines: PackedStringArray, index: int) -> bool:
|
||||
for i in range(index - 1, -1, -1):
|
||||
if _is_blank_or_comment(lines[i]):
|
||||
continue
|
||||
if _indent_of(lines[i]) == 0:
|
||||
return lines[i].strip_edges().begins_with("- insert:")
|
||||
return false
|
||||
|
||||
|
||||
## Parse a `- id: <value>` header line into {"id": String}. Returns {} for
|
||||
## any other line. The value may be plain or single/double-quoted.
|
||||
static func _parse_entry_header(line: String) -> Dictionary:
|
||||
var stripped := line.strip_edges()
|
||||
if not stripped.begins_with("- "):
|
||||
return {}
|
||||
var body := stripped.substr(2).strip_edges()
|
||||
if not body.begins_with("id:"):
|
||||
return {}
|
||||
var value := body.substr(3).strip_edges()
|
||||
if value.begins_with("\"") and value.ends_with("\"") and value.length() >= 2:
|
||||
var parsed: Variant = JSON.parse_string(value)
|
||||
if parsed is String:
|
||||
value = parsed
|
||||
elif value.begins_with("'") and value.ends_with("'") and value.length() >= 2:
|
||||
value = value.substr(1, value.length() - 2)
|
||||
return {"id": value}
|
||||
|
||||
|
||||
## Extract the `config:` sub-dict from a found entry block. Fields may nest
|
||||
## (env, reconnect); deeper values are parsed with the same scalar coercion
|
||||
## the YAML strategy uses. Returns {} when the block has no config block.
|
||||
static func _extract_config(lines: PackedStringArray, block: Dictionary) -> Dictionary:
|
||||
var start := int(block.get("start", -1))
|
||||
var end := int(block.get("end", -1))
|
||||
if start < 0:
|
||||
return {}
|
||||
var config_indent := -1
|
||||
var config_start := -1
|
||||
for i in range(start, end):
|
||||
var stripped := lines[i].strip_edges()
|
||||
if _is_blank_or_comment(lines[i]):
|
||||
continue
|
||||
if stripped == "config:":
|
||||
config_indent = _indent_of(lines[i])
|
||||
config_start = i
|
||||
break
|
||||
if config_start < 0:
|
||||
return {}
|
||||
return _parse_block_lines(lines, config_start + 1, end, config_indent)
|
||||
|
||||
|
||||
## Parse sibling `key: value` lines at a fixed minimum indent into a
|
||||
## Dictionary. Nested blocks (a key with no inline value) recurse and their
|
||||
## child lines are consumed by the recursion — the parent index advances past
|
||||
## them so they are never re-parsed as top-level config fields (#867 review).
|
||||
## Flow arrays parse back into Arrays via JSON. Quoted and plain scalars
|
||||
## strip via the YAML strategy's shared `coerce_scalar`.
|
||||
static func _parse_block_lines(lines: PackedStringArray, start: int, end: int, min_indent: int) -> Dictionary:
|
||||
var out: Dictionary = {}
|
||||
var i := start
|
||||
while i < end:
|
||||
var l := lines[i]
|
||||
if _is_blank_or_comment(l):
|
||||
i += 1
|
||||
continue
|
||||
var indent := _indent_of(l)
|
||||
if indent <= min_indent:
|
||||
break
|
||||
var stripped := l.strip_edges()
|
||||
var colon := stripped.find(":")
|
||||
if colon < 0:
|
||||
i += 1
|
||||
continue
|
||||
var key := stripped.substr(0, colon).strip_edges()
|
||||
var value := stripped.substr(colon + 1).strip_edges()
|
||||
if value.is_empty():
|
||||
## Nested block: find where its children end (a line at or above
|
||||
## the block key's indent), parse only that span, and jump past it.
|
||||
var child_end := i + 1
|
||||
while child_end < end:
|
||||
if not _is_blank_or_comment(lines[child_end]) and _indent_of(lines[child_end]) <= indent:
|
||||
break
|
||||
child_end += 1
|
||||
out[key] = _parse_block_lines(lines, i + 1, child_end, indent)
|
||||
i = child_end
|
||||
else:
|
||||
## Shared with the YAML strategy so the two dialects can never
|
||||
## drift on quoting/typing rules (#867 review).
|
||||
out[key] = McpYamlStrategy.coerce_scalar(value)
|
||||
i += 1
|
||||
return out
|
||||
|
||||
|
||||
# --- Rewrites ---------------------------------------------------------------
|
||||
|
||||
## Append a new `- insert:` row at the end of the file. A blank separator
|
||||
## line keeps rows visually distinct; the file always ends with a newline.
|
||||
static func _append_row(lines: PackedStringArray, nested_lines: PackedStringArray) -> String:
|
||||
var parts: Array[String] = []
|
||||
for l in lines:
|
||||
parts.append(l)
|
||||
## Collapse trailing blank lines so the appended row is not orphaned
|
||||
## below stray empties; one separator blank keeps rows readable.
|
||||
while parts.size() > 0 and String(parts[parts.size() - 1]).strip_edges().is_empty():
|
||||
parts.remove_at(parts.size() - 1)
|
||||
if parts.size() > 0:
|
||||
parts.append("")
|
||||
parts.append("- insert:")
|
||||
for l in nested_lines:
|
||||
parts.append(l)
|
||||
return _join_lines(parts)
|
||||
|
||||
|
||||
## Replace the lines owned by our entry. When the found block is a plain
|
||||
## top-level row (indent 0 header), the whole row — including its children —
|
||||
## is replaced by the insert form. When it is a nested block inside an
|
||||
## insert row, only that block's lines are replaced, leaving sibling entries
|
||||
## and comments in the same row byte-for-byte intact.
|
||||
static func _replace_lines(lines: PackedStringArray, block: Dictionary, nested_lines: PackedStringArray) -> String:
|
||||
var start := int(block.get("start", -1))
|
||||
var end := int(block.get("end", -1))
|
||||
var parts: Array[String] = []
|
||||
for i in range(lines.size()):
|
||||
if i == start:
|
||||
## A nested block keeps the surrounding `- insert:` row, so only
|
||||
## the nested entry lines (indent > 0) are spliced in.
|
||||
if _indent_of(lines[start]) > 0:
|
||||
for l in nested_lines:
|
||||
parts.append(l)
|
||||
else:
|
||||
parts.append("- insert:")
|
||||
for l in nested_lines:
|
||||
parts.append(l)
|
||||
if i >= start and i < end:
|
||||
continue
|
||||
parts.append(lines[i])
|
||||
return _join_lines(parts)
|
||||
|
||||
|
||||
## Remove our entry. A nested block is spliced out; if its enclosing insert
|
||||
## row is left without any nested entries (only the bare `- insert:` header,
|
||||
## blanks, and comments), the row header goes too so the file stays a valid
|
||||
## patch list. A plain row for our id is removed wholesale.
|
||||
static func _remove_lines(lines: PackedStringArray, block: Dictionary) -> String:
|
||||
var start := int(block.get("start", -1))
|
||||
var end := int(block.get("end", -1))
|
||||
var nested := _indent_of(lines[start]) > 0
|
||||
var parts: Array[String] = []
|
||||
if nested:
|
||||
## Find the enclosing `- insert:` row header: the nearest preceding
|
||||
## 0-indent `- ` line.
|
||||
var row_start := -1
|
||||
for i in range(start - 1, -1, -1):
|
||||
if _indent_of(lines[i]) == 0 and lines[i].strip_edges().begins_with("- "):
|
||||
row_start = i
|
||||
break
|
||||
## Row end: first 0-indent non-blank/comment line after the block.
|
||||
var row_end := lines.size()
|
||||
for i in range(end, lines.size()):
|
||||
if _indent_of(lines[i]) == 0 and not _is_blank_or_comment(lines[i]):
|
||||
row_end = i
|
||||
break
|
||||
var has_other_entries := false
|
||||
for i in range(row_start + 1, row_end):
|
||||
if i >= start and i < end:
|
||||
continue
|
||||
if _is_blank_or_comment(lines[i]):
|
||||
continue
|
||||
if _indent_of(lines[i]) > 0 and lines[i].strip_edges().begins_with("- "):
|
||||
has_other_entries = true
|
||||
break
|
||||
if has_other_entries or row_start < 0:
|
||||
## Only our block goes; sibling entries and any trailing
|
||||
## comments in the same row survive.
|
||||
for i in range(lines.size()):
|
||||
if i >= start and i < end:
|
||||
continue
|
||||
parts.append(lines[i])
|
||||
else:
|
||||
## The row held only our entry: drop the `- insert:` header and
|
||||
## our block, but keep trailing blank/comment lines — a comment
|
||||
## the user wrote above the next row must survive (#867 review).
|
||||
for i in range(lines.size()):
|
||||
if i >= row_start and i < end:
|
||||
continue
|
||||
parts.append(lines[i])
|
||||
parts = _trim_trailing_blanks(parts)
|
||||
else:
|
||||
## Plain top-level row for our id: drop the whole block.
|
||||
for i in range(lines.size()):
|
||||
if i >= start and i < end:
|
||||
continue
|
||||
parts.append(lines[i])
|
||||
parts = _trim_trailing_blanks(parts)
|
||||
return _join_lines(parts)
|
||||
|
||||
|
||||
## Remove trailing blank lines left behind by a removal.
|
||||
static func _trim_trailing_blanks(parts: Array[String]) -> Array[String]:
|
||||
while parts.size() > 0 and String(parts[parts.size() - 1]).strip_edges().is_empty():
|
||||
parts.remove_at(parts.size() - 1)
|
||||
return parts
|
||||
|
||||
|
||||
## True when the text holds no patch rows at all — blank lines and comments
|
||||
## only. Such a file cannot be written back (see `remove`), because dsh's
|
||||
## patch parser rejects a non-array file at boot.
|
||||
static func _is_blank_or_comment_only(text: String) -> bool:
|
||||
for line in text.split("\n"):
|
||||
var stripped := line.strip_edges()
|
||||
if not stripped.is_empty() and not stripped.begins_with("#"):
|
||||
return false
|
||||
return true
|
||||
|
||||
|
||||
## When the document's only content line is the empty flow sequence `[]`,
|
||||
## return the text with that one line removed — blanks and comments stay,
|
||||
## because they belong to the user. Any other document comes back unchanged;
|
||||
## a `[]` mixed with real rows is left for `_is_patch_sequence` to refuse.
|
||||
static func _strip_empty_flow_sequence(text: String) -> String:
|
||||
var lines := _split_lines(text)
|
||||
var bracket_line := -1
|
||||
for i in range(lines.size()):
|
||||
if _is_blank_or_comment(lines[i]):
|
||||
continue
|
||||
if bracket_line < 0 and lines[i].strip_edges() == "[]":
|
||||
bracket_line = i
|
||||
continue
|
||||
return text
|
||||
if bracket_line < 0:
|
||||
return text
|
||||
var parts: Array[String] = []
|
||||
for i in range(lines.size()):
|
||||
if i != bracket_line:
|
||||
parts.append(lines[i])
|
||||
if parts.is_empty():
|
||||
return ""
|
||||
return _join_lines(parts)
|
||||
|
||||
|
||||
## True when the text is a valid loader patch list (or empty/comment-only /
|
||||
## the empty flow sequence `[]`, which all mean "no layer"). Anything else —
|
||||
## a top-level mapping or scalar — would make dsh fail boot, so Configure
|
||||
## refuses to write into it instead of producing a broken file (#867 review).
|
||||
## Only 0-indent content lines define the top-level structure: they must all
|
||||
## be `- ` rows. Deeper lines are row children and are not inspected. `[]` is
|
||||
## valid only as the COMPLETE document — appending rows after the empty flow
|
||||
## sequence would produce malformed YAML, so a mixed `[]` + rows file fails
|
||||
## the check too.
|
||||
static func _is_patch_sequence(text: String) -> bool:
|
||||
if text.strip_edges().is_empty():
|
||||
return true
|
||||
var saw_brackets := false
|
||||
var content_count := 0
|
||||
for line in text.split("\n"):
|
||||
var stripped := line.strip_edges()
|
||||
if stripped.is_empty() or stripped.begins_with("#"):
|
||||
continue
|
||||
content_count += 1
|
||||
if stripped == "[]":
|
||||
saw_brackets = true
|
||||
continue
|
||||
if _indent_of(line) == 0 and not stripped.begins_with("- "):
|
||||
return false
|
||||
if saw_brackets and content_count > 1:
|
||||
return false
|
||||
return true
|
||||
|
||||
|
||||
static func _join_lines(parts: Array) -> String:
|
||||
if parts.is_empty():
|
||||
return ""
|
||||
var lines: Array[String] = []
|
||||
for p in parts:
|
||||
lines.append(String(p))
|
||||
return "\n".join(lines) + "\n"
|
||||
|
||||
|
||||
# --- Small helpers ----------------------------------------------------------
|
||||
|
||||
static func _indent_str(n: int) -> String:
|
||||
var out := ""
|
||||
for i in range(n):
|
||||
out += " "
|
||||
return out
|
||||
|
||||
|
||||
static func _indent_of(line: String) -> int:
|
||||
var n := 0
|
||||
while n < line.length() and (line[n] == " " or line[n] == "\t"):
|
||||
n += 1
|
||||
return n
|
||||
|
||||
|
||||
static func _is_blank_or_comment(line: String) -> bool:
|
||||
var stripped := line.strip_edges()
|
||||
return stripped.is_empty() or stripped.begins_with("#")
|
||||
|
||||
|
||||
static func _array_copy(value: Variant) -> Array:
|
||||
if value is Array:
|
||||
return (value as Array).duplicate(true)
|
||||
if value is PackedStringArray:
|
||||
return McpClient._array_from_packed(value)
|
||||
return []
|
||||
|
||||
|
||||
static func _arrays_equal(left: Variant, right: Variant) -> bool:
|
||||
if not (left is Array or left is PackedStringArray):
|
||||
return false
|
||||
if not (right is Array or right is PackedStringArray):
|
||||
return false
|
||||
var left_array := _array_copy(left)
|
||||
var right_array := _array_copy(right)
|
||||
if left_array.size() != right_array.size():
|
||||
return false
|
||||
for i in range(left_array.size()):
|
||||
if left_array[i] != right_array[i]:
|
||||
return false
|
||||
return true
|
||||
|
||||
|
||||
## Returns {"ok": true, "data": String} when the file is absent or readable,
|
||||
## and {"ok": false, "error": String} when unreadable. Callers must NOT fall
|
||||
## back to an empty string on the error path — doing so blows away the user's
|
||||
## other patch rows on the next write.
|
||||
static func _read(path: String) -> Dictionary:
|
||||
if not FileAccess.file_exists(path):
|
||||
return {"ok": true, "data": ""}
|
||||
var f := FileAccess.open(path, FileAccess.READ)
|
||||
if f == null:
|
||||
var err := FileAccess.get_open_error()
|
||||
return {"ok": false, "error": "could not open for reading (%s)" % error_string(err)}
|
||||
var t := f.get_as_text()
|
||||
f.close()
|
||||
return {"ok": true, "data": t}
|
||||
Reference in New Issue
Block a user