@logic-joe/fleek 0.2.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logic-joe/fleek",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "fleek - command line client for the Fleek agent hub (MCP over OAuth, OS keychain, signed role/project kits)",
   "license": "Apache-2.0",
   "type": "module",

package/service-agents/install-system-service

@@ -10,8 +10,8 @@ broker_uid=$(id -u "$broker")
 broker_home=$(getent passwd "$broker" | cut -d: -f6)
 [ "$broker_uid" -gt 0 ] && [ "$broker_home" = /home/fa-review ] || exit 77
 install -d -m 0755 /opt/fleek-agents
-if [ "$source_dir" != /opt/fleek-agents ]; then install -m 0755 "$source_dir/run-job" "$source_dir/unlock-keyring" "$source_dir/run-service" "$source_dir/kit-setup" "$source_dir/broker-run" /opt/fleek-agents/; fi
-chmod 0755 /opt/fleek-agents/run-job /opt/fleek-agents/unlock-keyring /opt/fleek-agents/run-service /opt/fleek-agents/kit-setup /opt/fleek-agents/broker-run
+if [ "$source_dir" != /opt/fleek-agents ]; then install -m 0755 "$source_dir/run-job" "$source_dir/knowledge-poll" "$source_dir/unlock-keyring" "$source_dir/run-service" "$source_dir/kit-setup" "$source_dir/broker-run" /opt/fleek-agents/; fi
+chmod 0755 /opt/fleek-agents/knowledge-poll /opt/fleek-agents/run-job /opt/fleek-agents/unlock-keyring /opt/fleek-agents/run-service /opt/fleek-agents/kit-setup /opt/fleek-agents/broker-run
 # Every level of ~/.config belongs to the broker (install -d sets owner/mode only on the NAMED directories, so naming
 # just .config/systemd/user left .config root-owned and `fleek login` could not create ~/.config/fleek - SVCLOGIN).
 # Re-running the installer repairs an existing host: install -d also re-applies owner/mode to existing directories.

package/service-agents/knowledge-poll

@@ -0,0 +1,232 @@
+#!/usr/bin/env python3
+"""E10: one host-side poll, called every 15 minutes by the existing broker service.
+The broker owns STATE_DIRECTORY/repository (an ordinary, clean clone with its own Git read login).
+Only a changed default-branch HEAD runs fleek init; agents see the CLI's allowlisted staging, never the clone or broker keys.
+"""
+import datetime
+import fcntl
+import importlib.machinery
+import importlib.util
+import json
+import os
+from pathlib import Path
+import re
+import selectors
+import signal
+import stat
+import subprocess
+import sys
+import tempfile
+import time
+import uuid
+
+loader = importlib.machinery.SourceFileLoader("fleek_starter", str(Path(__file__).with_name("run-job")))
+spec = importlib.util.spec_from_loader(loader.name, loader)
+starter = importlib.util.module_from_spec(spec)
+loader.exec_module(starter)
+SHA = re.compile(r"^[0-9a-f]{40}(?:[0-9a-f]{24})?$")
+FLEEK = "/opt/fleek/bin/fleek"
+
+
+def git(repo, *args):
+    # No checkout hooks, fsmonitor hooks, recursive submodules or repository-selected executable protocols.
+    result = subprocess.run(["git", "-c", "core.hooksPath=/dev/null", "-c", "core.fsmonitor=false", "-c", "protocol.ext.allow=never",
+                             "-c", "protocol.file.allow=never", *args], cwd=repo, stdin=subprocess.DEVNULL,
+                            stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, timeout=60, check=False)
+    if result.returncode or len(result.stdout) > 1024 * 1024:
+        raise ValueError("repository_not_readable")
+    return result.stdout.decode("utf-8", "strict")
+
+
+def remote_head(repo):
+    lines = git(repo, "ls-remote", "--symref", "origin", "HEAD").splitlines()
+    branch = next((line[5:].split("\t", 1)[0] for line in lines if line.startswith("ref: ")), None)
+    commit = next((line.split("\t", 1)[0] for line in lines if line.endswith("\tHEAD") and not line.startswith("ref: ")), None)
+    if not branch or not re.fullmatch(r"refs/heads/[A-Za-z0-9_./-]{1,200}", branch) or ".." in branch or not commit or not SHA.fullmatch(commit):
+        raise ValueError("repository_not_readable")
+    return branch, commit
+
+
+def analyze(config, state, repo, profile):
+    if config.get("provider", "claude") != "claude":
+        raise ValueError("init_provider_unavailable")
+    poll_quota(state)
+    provider = starter.provider_env("claude")
+    # No Fleek/Git/keyring credential or repo customization enters this container.
+    with tempfile.TemporaryDirectory(prefix="knowledge-", dir=state) as temp:
+        job = Path(temp)
+        work = job / "work"
+        work.mkdir(mode=0o700)
+        proc = subprocess.Popen([FLEEK, "init", "--project", config["project"], "--refresh", "--maintenance", "--all-apps",
+                                 "--agent", "manual", "--yes", "--json", "--profile", profile, "--work-dir", str(work)], cwd=repo,
+                                stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, start_new_session=True)
+        containers = []
+        done = False
+        try:
+            selector = selectors.DefaultSelector()
+            selector.register(proc.stdout, selectors.EVENT_READ)
+            deadline = time.monotonic() + 3600
+            while proc.poll() is None or not done:
+                if time.monotonic() > deadline:
+                    raise ValueError("analysis_timeout")
+                if not selector.select(timeout=10):
+                    if proc.poll() is not None:
+                        break
+                    continue
+                line = proc.stdout.readline(65537)
+                if not line:
+                    break
+                if len(line) > 65536 or not line.endswith(b"\n"):
+                    raise ValueError("analysis_output_invalid")
+                event = json.loads(line)
+                if event.get("event") == "staged":
+                    staging, output = Path(event["stagingDir"]), Path(event["outputFile"])
+                    if not staging.resolve().is_relative_to(work.resolve()) or not output.parent.resolve().is_relative_to(work.resolve()):
+                        raise ValueError("analysis_path_invalid")
+                    if staging.is_symlink() or output.parent.is_symlink():
+                        raise ValueError("analysis_path_invalid")
+                    name = "fleek-init-" + uuid.uuid4().hex
+                    containers.append(name)
+                    argv = starter.container_args(config["image"], name, job, provider)
+                    mount = f"type=bind,src={job / 'input'},dst=/job,ro=true"
+                    argv[argv.index(mount)] = f"type=bind,src={staging},dst=/job,ro=true"
+                    argv += ["claude", "-p", "Read fleek-input.json and the allowed files. Return ONLY the JSON object requested by FLEEK-INIT.md.",
+                             "--output-format", "text", "--no-session-persistence", "--tools", "Read,Glob,Grep", "--allowedTools", "Read,Glob,Grep",
+                             "--permission-mode", "dontAsk", "--strict-mcp-config", "--mcp-config", '{"mcpServers":{}}',
+                             "--settings", '{"disableAllHooks":true,"permissions":{"deny":["Read(/proc/**)","Read(/run/**)"]}}', "--setting-sources", "", "--append-system-prompt-file", "/job/FLEEK-INIT.md"]
+                    # A file avoids retaining provider output/logs in memory or the journal; the service bounds files to 16 MiB.
+                    target = output.with_suffix(".tmp")
+                    fd = os.open(target, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, 0o600)
+                    with os.fdopen(fd, "wb") as stream:
+                        agent = subprocess.run(argv, stdin=subprocess.DEVNULL, stdout=stream, stderr=subprocess.DEVNULL,
+                                               env={**os.environ, **provider}, timeout=1800, check=False)
+                    if agent.returncode or target.stat().st_size > 65536:
+                        raise ValueError("analysis_failed")
+                    target.rename(output)
+                if event.get("event") == "error":
+                    raise ValueError("analysis_failed")
+                if event.get("event") == "done":
+                    done = event.get("failed") == 0
+                    break
+            if proc.wait(timeout=30) or not done:
+                raise ValueError("analysis_failed")
+        finally:
+            if proc.poll() is None:
+                os.killpg(proc.pid, signal.SIGTERM)
+                try:
+                    proc.wait(timeout=10)
+                except subprocess.TimeoutExpired:
+                    os.killpg(proc.pid, signal.SIGKILL)
+                    proc.wait()
+            for name in containers:
+                subprocess.run(["podman", "rm", "-f", name], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=30, check=False)
+
+
+def write_state(path, record):
+    fd, temp = tempfile.mkstemp(prefix="knowledge-state-", dir=path.parent)
+    with os.fdopen(fd, "w") as stream:
+        json.dump(record, stream)
+    os.replace(temp, path)
+
+
+def poll_quota(state):
+    # This poll never consumes the review worker's quota.json / 50 daily jobs.
+    path = state / "knowledge-quota.json"
+    today = datetime.datetime.now(datetime.timezone.utc).date().isoformat()
+    try:
+        data = json.loads(starter.private_file(path).read_text())
+    except (OSError, ValueError):
+        data = {}
+    count = data.get("count", 0) if data.get("date") == today else 0
+    if not isinstance(count, int) or count >= 8:
+        raise ValueError("knowledge_daily_limit")
+    write_state(path, {"date": today, "count": count + 1})
+
+
+def verified_profile(config):
+    # Profile files contain routing metadata only. Fix the exact configured installation before using a checkout binding.
+    directory = Path(os.environ.get("FLEEK_CONFIG_DIR") or Path(os.environ.get("XDG_CONFIG_HOME") or Path.home() / ".config") / "fleek")
+    profiles = json.loads(starter.private_file(directory / "profiles.json").read_text()).get("profiles", {})
+    matches = [key for key, value in profiles.items() if re.fullmatch(r"[0-9a-f]{32}", key)
+               and value.get("workspace", {}).get("id", "").lower() == config["workspaceId"]
+               and value.get("holder", {}).get("kind") == "installation"
+               and value.get("holder", {}).get("id", "").lower() == config["expectedInstallationId"] and not value.get("needsLogin")]
+    if len(matches) != 1:
+        raise ValueError("identity_unavailable")
+    profile = matches[0]
+    identity = starter.command([FLEEK, "whoami", "--profile", profile, "--json"])
+    if (identity.get("installation", {}).get("id", "").lower() != config["expectedInstallationId"]
+            or identity.get("workspace", {}).get("id", "").lower() != config["workspaceId"]
+            or identity.get("principal", {}).get("kind") != "service_account" or identity.get("grantClass") != "G4x"):
+        raise ValueError("identity_unavailable")
+    return profile
+
+
+def poll(config, state, profile=None):
+    profile = profile or verified_profile(config)
+    # Statements are independent of a merge and are drained even when Git is unchanged/unreadable.
+    statements_ok = True
+    try:
+        starter.command([FLEEK, "service", "knowledge-check", config["project"], "--profile", profile, "--json"])
+    except (SystemExit, ValueError, OSError, subprocess.SubprocessError):
+        statements_ok = False
+    repo = state / "repository"
+    info = repo.lstat()
+    if not stat.S_ISDIR(info.st_mode) or stat.S_ISLNK(info.st_mode) or info.st_uid != os.getuid() or info.st_mode & 0o077:
+        raise ValueError("repository_not_readable")
+    branch, commit = remote_head(repo)
+    previous = state / "knowledge-checked.json"
+    try:
+        last = json.loads(starter.private_file(previous).read_text())
+    except (OSError, ValueError):
+        last = {}
+    scope = {"project": config["project"], "workspaceId": config.get("workspaceId"), "installationId": config.get("expectedInstallationId")}
+    if last.get("commit") == commit and all(last.get(key) == value for key, value in scope.items()):
+        return "checked" if statements_ok else "not_checkable"
+    failure_path = state / "knowledge-failed.json"
+    try:
+        failure = json.loads(starter.private_file(failure_path).read_text())
+    except (OSError, ValueError):
+        failure = {}
+    same_failure = failure.get("commit") == commit and all(failure.get(key) == value for key, value in scope.items())
+    if same_failure and (failure.get("count", 0) >= 3 or time.time() < failure.get("retryAt", 0)):
+        return "not_checkable"
+    if git(repo, "status", "--porcelain=v1").strip():
+        raise ValueError("repository_dirty")
+    git(repo, "fetch", "--no-tags", "--recurse-submodules=no", "origin", branch)
+    # Default-branch movement during the fetch is retryable; never record a different commit as checked.
+    fetched = git(repo, "rev-parse", "FETCH_HEAD").strip()
+    if fetched != commit:
+        raise ValueError("repository_changed")
+    git(repo, "checkout", "--detach", commit)
+    try:
+        analyze(config, state, repo, profile)
+    except (ValueError, OSError, KeyError, TypeError, AttributeError, subprocess.SubprocessError):
+        count = failure.get("count", 0) + 1 if same_failure else 1
+        write_state(failure_path, {**scope, "commit": commit, "count": count, "retryAt": time.time() + 6 * 3600})
+        raise
+    record = {**scope, "commit": commit, "checkedAt": datetime.datetime.now(datetime.timezone.utc).isoformat(), "result": "checked"}
+    write_state(previous, record)
+    return "checked" if statements_ok else "not_checkable"
+
+
+def main():
+    state = Path(os.environ["STATE_DIRECTORY"])
+    config = starter.load_config(sys.argv[1])
+    with os.fdopen(os.open(state / "knowledge-poll.lock", os.O_WRONLY | os.O_CREAT | os.O_NOFOLLOW, 0o600), "w") as lock:
+        try:
+            fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except BlockingIOError:
+            return 0
+        try:
+            result = poll(config, state)
+            print(json.dumps({"result": result}), flush=True)
+            return 0
+        except (SystemExit, ValueError, OSError, KeyError, TypeError, AttributeError, subprocess.SubprocessError):
+            # A fixed result only: never Git/provider stderr, code, configuration or credentials.
+            print('{"result":"not_checkable"}', flush=True)
+            return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/service-agents/run-service

@@ -22,4 +22,11 @@ shift
     sleep 60
   done
 ) &
+# E10: the broker's existing private bus/keyring/cgroup; no server job or per-drift notification.
+(
+  while :; do
+    /opt/fleek-agents/knowledge-poll /etc/fleek-agents/review.json || true
+    sleep 900
+  done
+) &
 exec /opt/fleek/bin/fleek listen --name review --concurrency 1 --timeout 660 --quiet-children --exec /opt/fleek-agents/run-job /etc/fleek-agents/review.json