localcode 0.5.4__tar.gz → 0.5.5__tar.gz

{localcode-0.5.4/src/localcode.egg-info → localcode-0.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.5.4
+Version: 0.5.5
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0
@@ -87,6 +87,9 @@ repository ships, with the size and whether it fits your Mac's memory. The
 recommended one for your machine is starred. Pick one, watch the download, and
 start typing. `/models` switches later.
 
+Project plugins and configuration load only with `localcode --trust-project`.
+Use it after reviewing the project's startup code and settings.
+
 OpenJev also supports typed decisions: use `/mode` to choose **Chat** or
 **Decisions**, or run `localcode --mode decisions`. The decision screen returns
 choices, yes/no probabilities and scores without running coding tools.

{localcode-0.5.4 → localcode-0.5.5}/README.md

@@ -39,6 +39,9 @@ repository ships, with the size and whether it fits your Mac's memory. The
 recommended one for your machine is starred. Pick one, watch the download, and
 start typing. `/models` switches later.
 
+Project plugins and configuration load only with `localcode --trust-project`.
+Use it after reviewing the project's startup code and settings.
+
 OpenJev also supports typed decisions: use `/mode` to choose **Chat** or
 **Decisions**, or run `localcode --mode decisions`. The decision screen returns
 choices, yes/no probabilities and scores without running coding tools.

{localcode-0.5.4 → localcode-0.5.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "localcode"
-version = "0.5.4"
+version = "0.5.5"
 description = "High-performance AI coding on consumer hardware."
 readme = "README.md"
 requires-python = ">=3.10"

{localcode-0.5.4 → localcode-0.5.5}/src/localcode/__init__.py

@@ -8,4 +8,4 @@ from importlib.metadata import PackageNotFoundError, version as _pkg_version
 try:
     __version__ = _pkg_version("localcode")
 except PackageNotFoundError:  # not installed (e.g. raw source checkout)
-    __version__ = "0.5.4"
+    __version__ = "0.5.5"

localcode-0.5.5/src/localcode/bin/localcode-ui

@@ -0,0 +1,4 @@
+[diffend] Oversized file quarantined before diffing.
+name: localcode-0.5.5/src/localcode/bin/localcode-ui
+size: 102460976 bytes
+sha256: e6d7eb730750e1193f51d6880b62fc1098411e5445f3c1a9062ee9eaf9a137cb

{localcode-0.5.4 → localcode-0.5.5}/src/localcode/entrypoint.py

@@ -15,6 +15,7 @@ def build_parser() -> argparse.ArgumentParser:
     )
     parser.add_argument("--version", action="store_true", help="Print the version and exit")
     parser.add_argument("--mode", choices=["chat", "decisions"], default="chat", help="Start in normal chat or typed decision mode")
+    parser.add_argument("--trust-project", action="store_true", help="Allow this project's configuration, plugins and MCP startup commands to load")
     parser.add_argument("--model", help="Model alias to load (otherwise the picker asks)")
     parser.add_argument("-s", "--session", "--resume", dest="resume", metavar="SESSION_ID",
                         help="Resume a session by ID; uses its saved project directory when no project is given")
@@ -72,7 +73,7 @@ def main(argv: list[str] | None = None) -> None:
               "Reinstall with `pip install -U localcode`.", file=sys.stderr)
         sys.exit(1)
     from .ui.launch import main as ui_main
-    sys.exit(ui_main(args.model, project=project, resume=args.resume))
+    sys.exit(ui_main(args.model, project=project, resume=args.resume, trust_project=args.trust_project))
 
 
 if __name__ == "__main__":

{localcode-0.5.4 → localcode-0.5.5}/src/localcode/ui/launch.py

@@ -161,8 +161,23 @@ def _session_directory(session_id: str) -> Path | None:
     return None
 
 
+def runtime_env(config_path: Path, ctrl: int, *, trust_project: bool = False) -> dict[str, str]:
+    """Project configuration can execute code before tool permissions apply."""
+    env = dict(os.environ)
+    env["LOCALCODE_CONTROL_URL"] = f"http://127.0.0.1:{ctrl}"
+    env["LOCALCODE_CONFIG"] = str(config_path)
+    env["OPENCODE_TUI_CONFIG"] = str(config_path.with_suffix(".tui.json"))
+    # The branded alias takes precedence in the fork. Set both explicitly so
+    # an inherited alias cannot accidentally reopen project code loading.
+    disabled = "0" if trust_project else "1"
+    env["LOCALCODE_DISABLE_PROJECT_CONFIG"] = disabled
+    env["OPENCODE_DISABLE_PROJECT_CONFIG"] = disabled
+    env.setdefault("OPENCODE_DISABLE_LSP_DOWNLOAD", "1")
+    return env
+
+
 def attach(ctrl: int, status: dict, ui_bin: Path, project_dir: Path, alias: str | None,
-           resume: str | None = None) -> int:
+           resume: str | None = None, *, trust_project: bool = False) -> int:
     """Open another UI window on the model server a running session owns."""
     # The running session's secrets, left owner-only in the run directory.
     auth = read_auth_file(run_dir())
@@ -183,11 +198,7 @@ def attach(ctrl: int, status: dict, ui_bin: Path, project_dir: Path, alias: str
     rd.mkdir(parents=True, exist_ok=True)
     config_path = rd / f"session-{os.getpid()}.json"
     write_config(config_path, port=port, ctx=ctx, alias=current)
-    env = dict(os.environ)
-    env["LOCALCODE_CONTROL_URL"] = f"http://127.0.0.1:{ctrl}"
-    env["LOCALCODE_CONFIG"] = str(config_path)
-    env["OPENCODE_TUI_CONFIG"] = str(config_path.with_suffix(".tui.json"))
-    env.setdefault("OPENCODE_DISABLE_LSP_DOWNLOAD", "1")
+    env = runtime_env(config_path, ctrl, trust_project=trust_project)
     argv = [str(ui_bin)] + (["-m", f"localcode/{current}"] if current else []) + _resume_args(resume)
     try:
         return subprocess.call(argv, cwd=str(project_dir), env=env)
@@ -199,7 +210,7 @@ def attach(ctrl: int, status: dict, ui_bin: Path, project_dir: Path, alias: str
 
 
 def main(model: str | None = None, project: str | None = None,
-         resume: str | None = None) -> int:
+         resume: str | None = None, *, trust_project: bool = False) -> int:
     ui_bin = ui_binary_path()
     if ui_bin is None:
         print("localcode: the UI binary is missing from this install. "
@@ -225,7 +236,8 @@ def main(model: str | None = None, project: str | None = None,
     # instead of refusing. One llama-server per machine, any number of windows.
     running = find_running()
     if running is not None:
-        return attach(running[0], running[1], ui_bin, project_dir, alias, resume)
+        return attach(running[0], running[1], ui_bin, project_dir, alias, resume,
+                      trust_project=trust_project)
 
     try:
         port, ctrl = choose_ports()
@@ -288,12 +300,7 @@ def main(model: str | None = None, project: str | None = None,
         config_path = rd / "session.json"
         write_config(config_path, port=port, ctx=ctx, alias=alias)
 
-        env = dict(os.environ)
-        env["LOCALCODE_CONTROL_URL"] = f"http://127.0.0.1:{ctrl}"
-        env["LOCALCODE_CONFIG"] = str(config_path)
-        env["OPENCODE_TUI_CONFIG"] = str(config_path.with_suffix(".tui.json"))
-        # Language servers are installed only on request (/lsp), never silently.
-        env.setdefault("OPENCODE_DISABLE_LSP_DOWNLOAD", "1")
+        env = runtime_env(config_path, ctrl, trust_project=trust_project)
         argv = [str(ui_bin)]
         if alias:
             argv += ["-m", f"localcode/{alias}"]

{localcode-0.5.4 → localcode-0.5.5/src/localcode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.5.4
+Version: 0.5.5
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0
@@ -87,6 +87,9 @@ repository ships, with the size and whether it fits your Mac's memory. The
 recommended one for your machine is starred. Pick one, watch the download, and
 start typing. `/models` switches later.
 
+Project plugins and configuration load only with `localcode --trust-project`.
+Use it after reviewing the project's startup code and settings.
+
 OpenJev also supports typed decisions: use `/mode` to choose **Chat** or
 **Decisions**, or run `localcode --mode decisions`. The decision screen returns
 choices, yes/no probabilities and scores without running coding tools.

{localcode-0.5.4 → localcode-0.5.5}/src/localcode.egg-info/SOURCES.txt

@@ -1216,6 +1216,7 @@ tests/test_comprehensive_install.py
 tests/test_comprehensive_machines.py
 tests/test_comprehensive_model_gate.py
 tests/test_comprehensive_models_matrix.py
+tests/test_comprehensive_project_trust.py
 tests/test_comprehensive_upstream_gates.py
 tests/test_comprehensive_voice.py
 tests/test_comprehensive_whisper.py

localcode-0.5.5/tests/test_comprehensive_project_trust.py

@@ -0,0 +1,152 @@
+"""Exercise repository code loading in the shipped UI, with scratch files only."""
+from __future__ import annotations
+
+import json
+import os
+import platform
+import subprocess
+import time
+from pathlib import Path
+
+import pytest
+
+from localcode.ui import plugin_path, ui_binary_path
+from localcode.ui.launch import runtime_env, write_config
+
+
+pytestmark = pytest.mark.skipif(
+    platform.system() != "Darwin" or platform.machine() != "arm64",
+    reason="the bundled UI executable requires Apple Silicon macOS",
+)
+
+
+def _marker_plugin(path: Path, marker: Path, *, tui: bool = False) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    export = '({id: "scratch-proof", tui: async () => {}})' if tui else "async () => ({})"
+    path.write_text(
+        'import {writeFileSync} from "node:fs";\n'
+        f'writeFileSync({json.dumps(str(marker))}, "imported");\n'
+        f"export default {export};\n"
+    )
+
+
+@pytest.fixture
+def isolated_ui(tmp_path, monkeypatch):
+    binary = ui_binary_path()
+    assert binary is not None, "the release must include the UI binary"
+    # Clear flags and redirect every persistent runtime location before invoking it.
+    for key in tuple(os.environ):
+        if key.startswith(("LOCALCODE_", "OPENCODE_")):
+            monkeypatch.delenv(key)
+    for name, folder in (
+        ("XDG_CONFIG_HOME", "config"), ("XDG_DATA_HOME", "data"),
+        ("XDG_STATE_HOME", "state"), ("XDG_CACHE_HOME", "cache"),
+        ("LOCALCODE_TEST_HOME", "home"),
+    ):
+        directory = tmp_path / folder
+        directory.mkdir()
+        monkeypatch.setenv(name, str(directory))
+    monkeypatch.setenv("OPENCODE_DISABLE_MODELS_FETCH", "1")
+    monkeypatch.setenv("LOCALCODE_DISABLE_PROJECT_CONFIG", "0")
+    monkeypatch.setenv("OPENCODE_DISABLE_PROJECT_CONFIG", "0")
+    project = tmp_path / "repository"
+    project.mkdir()
+    config = tmp_path / "launcher.json"
+    write_config(config, port=1, ctx=8192, alias=None)
+    explicit = tmp_path / "explicit.ts"
+    explicit_marker = tmp_path / "explicit.marker"
+    _marker_plugin(explicit, explicit_marker)
+    cfg = json.loads(config.read_text())
+    cfg["plugin"].append(str(explicit))
+    config.write_text(json.dumps(cfg))
+    global_dir = tmp_path / "config" / "localcode-agent"
+    global_dir.mkdir()
+    global_mcp = {"global-proof": {"type": "local", "command": ["false"], "enabled": False}}
+    (global_dir / "localcode.json").write_text(json.dumps({"mcp": global_mcp}))
+    project_mcp = {"project-proof": {"type": "local", "command": ["false"], "enabled": False}}
+    configured = project / "configured.ts"
+    configured_marker = tmp_path / "configured.marker"
+    _marker_plugin(configured, configured_marker)
+    (project / "opencode.json").write_text(json.dumps({"mcp": project_mcp, "plugin": ["./configured.ts"]}))
+    discovered = []
+    for directory in (".opencode", ".localcode-agent"):
+        marker = tmp_path / f"{directory[1:]}.marker"
+        _marker_plugin(project / directory / "plugins" / "proof.ts", marker)
+        discovered.append(marker)
+    return binary, project, config, explicit_marker, configured_marker, discovered
+
+
+def _run(binary, project, env, *args):
+    return subprocess.run(
+        [str(binary), *args], cwd=project, env=env, stdin=subprocess.DEVNULL,
+        capture_output=True, text=True, timeout=20, check=False,
+    )
+
+
+@pytest.mark.parametrize("trusted", [False, True])
+def test_project_plugins_and_mcp_require_explicit_trust(isolated_ui, trusted):
+    binary, project, config, explicit, configured, discovered = isolated_ui
+    env = runtime_env(config, 0, trust_project=trusted)
+    resolved = _run(binary, project, env, "debug", "config")
+    assert resolved.returncode == 0, resolved.stdout + resolved.stderr
+    cfg = json.loads(resolved.stdout)
+    assert "global-proof" in cfg["mcp"]
+    assert ("project-proof" in cfg["mcp"]) is trusted
+    assert any(str(plugin_path()) in str(spec) for spec in cfg["plugin"])
+    assert any("/repository/.opencode/plugins/" in str(spec) for spec in cfg["plugin"]) is trusted
+    # Startup imports plugins before resolving the deliberately absent model.
+    # No inference, network service, or repository build command is required.
+    _run(binary, project, env, "run", "--format", "json", "-m", "absent/absent", "scratch check")
+    assert explicit.exists(), "explicit trusted plugins must still import"
+    assert configured.exists() is trusted
+    assert all(marker.exists() is trusted for marker in discovered)
+
+
+@pytest.mark.parametrize("trusted", [False, True])
+def test_project_tui_plugin_requires_explicit_trust(isolated_ui, trusted, tmp_path):
+    import pty
+    import select
+
+    binary, project, config, _, _, _ = isolated_ui
+    explicit_marker = tmp_path / "explicit-tui.marker"
+    project_marker = tmp_path / "project-tui.marker"
+    explicit_plugin = tmp_path / "explicit-tui.ts"
+    project_plugin = project / "project-tui.ts"
+    _marker_plugin(explicit_plugin, explicit_marker, tui=True)
+    _marker_plugin(project_plugin, project_marker, tui=True)
+    tui_config = config.with_suffix(".tui.json")
+    cfg = json.loads(tui_config.read_text())
+    cfg["plugin"].append(str(explicit_plugin))
+    tui_config.write_text(json.dumps(cfg))
+    (project / "tui.json").write_text(json.dumps({"plugin": ["./project-tui.ts"]}))
+    env = runtime_env(config, 0, trust_project=trusted)
+    env["TERM"] = "xterm-256color"
+    master, slave = pty.openpty()
+    proc = subprocess.Popen([str(binary)], cwd=project, env=env, stdin=slave, stdout=slave, stderr=slave)
+    os.close(slave)
+    output = bytearray()
+    try:
+        deadline = time.monotonic() + 15
+        ready_at = None
+        while time.monotonic() < deadline:
+            if select.select([master], [], [], 0.1)[0]:
+                try:
+                    output.extend(os.read(master, 65536))
+                except OSError:
+                    break
+            if explicit_marker.exists():
+                ready_at = ready_at or time.monotonic()
+                if (trusted and project_marker.exists()) or (not trusted and time.monotonic() - ready_at > 0.5):
+                    break
+            if proc.poll() is not None:
+                break
+        assert explicit_marker.exists(), output.decode(errors="replace")[-3000:]
+        assert project_marker.exists() is trusted
+    finally:
+        proc.terminate()
+        try:
+            proc.wait(timeout=5)
+        except subprocess.TimeoutExpired:
+            proc.kill()
+            proc.wait(timeout=5)
+        os.close(master)

{localcode-0.5.4 → localcode-0.5.5}/tests/test_ui_launch.py

@@ -64,7 +64,7 @@ def test_entrypoint_forwards_session_to_launcher(monkeypatch):
     with pytest.raises(SystemExit) as exc:
         entrypoint.main(["-s", "ses_example"])
     assert exc.value.code == 0
-    assert calls == [((None,), {"project": None, "resume": "ses_example"})]
+    assert calls == [((None,), {"project": None, "resume": "ses_example", "trust_project": False})]
 
 
 def test_write_config_points_at_local_server_and_plugin(tmp_path):
@@ -161,6 +161,8 @@ def test_second_launch_attaches_to_running_session(monkeypatch, tmp_path):
     monkeypatch.setattr(launch.subprocess, "call", fake_call)
     assert launch.main(None, str(tmp_path)) == 0
     assert calls["env"]["LOCALCODE_CONTROL_URL"] == "http://127.0.0.1:8323"
+    assert calls["env"]["LOCALCODE_DISABLE_PROJECT_CONFIG"] == "1"
+    assert calls["env"]["OPENCODE_DISABLE_PROJECT_CONFIG"] == "1"
     assert calls["argv"][1:] == ["-m", "localcode/gemma-4-12b-it-UD-Q4_K_XL"]
     assert calls["cfg"]["provider"]["localcode"]["options"]["baseURL"] == "http://127.0.0.1:8123/v1"
     assert calls["cfg"]["model"] == "localcode/gemma-4-12b-it-UD-Q4_K_XL"
@@ -208,3 +210,14 @@ def test_terminal_extension_is_separate_from_agent_tool_hooks(tmp_path):
     terminal=json.loads(path.with_suffix(".tui.json").read_text())
     assert terminal["plugin"][0].endswith("/modes.ts")
     assert json.loads(path.read_text())["plugin"] == [str(plugin_path())]
+
+
+def test_project_execution_requires_explicit_trust_even_with_an_inherited_alias(monkeypatch, tmp_path):
+    from localcode.ui.launch import runtime_env
+    monkeypatch.setenv("LOCALCODE_DISABLE_PROJECT_CONFIG", "0")
+    monkeypatch.setenv("OPENCODE_DISABLE_PROJECT_CONFIG", "0")
+    env = runtime_env(tmp_path / "session.json", 8323)
+    assert env["LOCALCODE_DISABLE_PROJECT_CONFIG"] == env["OPENCODE_DISABLE_PROJECT_CONFIG"] == "1"
+    trusted = runtime_env(tmp_path / "session.json", 8323, trust_project=True)
+    assert trusted["LOCALCODE_DISABLE_PROJECT_CONFIG"] == trusted["OPENCODE_DISABLE_PROJECT_CONFIG"] == "0"
+    assert entrypoint.build_parser().parse_args(["--trust-project"]).trust_project is True

localcode-0.5.4/src/localcode/bin/localcode-ui

@@ -1,4 +0,0 @@
-[diffend] Oversized file quarantined before diffing.
-name: localcode-0.5.4/src/localcode/bin/localcode-ui
-size: 102460976 bytes
-sha256: 34074b41154f9443b251bd4e7f4e0b779b0f7b5acf55595879248e7ec7d38ffc