Free, open source blog writer for Claude Code. Researches current sources, writes answer-first posts for Google and AI answers, has an independent reviewer score each one out of 100 and ships only after five delivery gates. 32 skills, 30 /blog commands, 5 agents. Active development at AI-Marketing-Hub/claude-blog; public releases ship here.
Python agent-skillsaiai-citationsai-contentai-marketingai-marketing-hubblogblog-writingclaude-codeclaude-code-skillclaude-pluginclaude-skillcontent-creationcontent-optimizationcontent-strategyeeatgeomultilingualopen-sourceseo
"""Offline runtime continuity, explicit setup and owned-data boundaries."""
from __future__ import annotations
import hashlib
import importlib.util
import json
import os
from pathlib import Path, PureWindowsPath
import re
import shutil
import subprocess
import sys
import pytest
ROOT = Path(__file__).resolve().parents[1]
INTEGRATIONS = ("blog-audio", "blog-google", "blog-notebooklm")
@pytest.fixture(autouse=True)
def isolated_runtime_override(monkeypatch):
monkeypatch.delenv("CLAUDE_BLOG_RUNTIME_DIR", raising=False)
def load_paths():
spec = importlib.util.spec_from_file_location("runtime_paths_fixture", ROOT / "skills/blog-notebooklm/scripts/runtime_paths.py")
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
return module
def install_copy(tmp_path, integration, version):
skill = tmp_path / f"plugin {version}" / "skills" / integration
shutil.copytree(ROOT / "skills" / integration / "scripts", skill / "scripts", ignore=shutil.ignore_patterns("__pycache__"))
(skill / "scripts/probe.py").write_text("import json,os,sys\nprint(json.dumps({'args':sys.argv[1:],'runtime':os.environ.get('CLAUDE_BLOG_RUNTIME_DIR')}))")
return skill
def child(skill, code, runtime=None, cwd=None):
env = dict(os.environ)
env.pop("CLAUDE_BLOG_RUNTIME_DIR", None)
env["PYTHONDONTWRITEBYTECODE"] = "1"
env["PATH"] = str(Path(sys.executable).parent) + os.pathsep + env.get("PATH", "")
if runtime is not None:
env["CLAUDE_BLOG_RUNTIME_DIR"] = str(runtime)
prefix = f"import sys; sys.path.insert(0,{str(skill / 'scripts')!r}); "
return subprocess.run([sys.executable, "-c", prefix + code], cwd=cwd or skill, env=env, capture_output=True, text=True)
def configure_interpreter(venv):
interpreter = venv / ("Scripts/python.exe" if os.name == "nt" else "bin/python")
interpreter.parent.mkdir(parents=True)
try:
interpreter.symlink_to(sys.executable)
except OSError:
shutil.copy2(sys.executable, interpreter)
return interpreter
def test_shipped_runtime_resolvers_are_identical():
contents = [(ROOT / "skills" / name / "scripts/runtime_paths.py").read_bytes() for name in INTEGRATIONS]
assert contents[0] == contents[1] == contents[2]
@pytest.mark.parametrize("integration", INTEGRATIONS)
def test_default_is_legacy_skill_local_and_version_bound(tmp_path, integration):
paths = load_paths()
first = install_copy(tmp_path, integration, "v1")
second = install_copy(tmp_path, integration, "v2")
one = paths.resolve_runtime_paths(first, integration)
two = paths.resolve_runtime_paths(second, integration)
assert one.venv == first / ".venv"
assert one.data == first / "data"
assert one.venv != two.venv and one.data != two.data
assert not one.venv.exists() and not one.data.exists()
@pytest.mark.parametrize("integration", INTEGRATIONS)
def test_two_plugin_versions_share_opted_in_environment_without_setup(tmp_path, integration):
first = install_copy(tmp_path, integration, "v1")
second = install_copy(tmp_path, integration, "v2")
runtime = tmp_path / "persistent root with spaces"
venv = runtime / integration / ".venv"
configure_interpreter(venv)
source = first / "scripts/requirements.lock"
(venv / ".requirements.stamp").write_text(hashlib.sha256(source.read_bytes()).hexdigest())
# Poisoning CWD cannot replace either the runner target or its path helper.
cwd = tmp_path / "consumer"
cwd.mkdir()
(cwd / "runtime_paths.py").write_text("raise AssertionError('POISON CWD')")
for skill in (first, second):
result = child(skill, "import run; sys.argv=['run.py','probe.py','unchanged-argument']; run.main()", runtime, cwd)
assert result.returncode == 0, result.stderr
assert json.loads(result.stdout) == {"args": ["unchanged-argument"], "runtime": str(runtime)}
assert not (skill / ".venv").exists() and not (skill / "data").exists()
@pytest.mark.parametrize("integration", INTEGRATIONS)
def test_ordinary_runner_and_check_do_not_create_missing_runtime(tmp_path, integration):
skill = install_copy(tmp_path, integration, "v1")
runtime = tmp_path / "absent persistent root"
result = child(skill, "import run; sys.argv=['run.py','probe.py']; run.main()", runtime)
assert result.returncode == 1
assert "setup required" in (result.stdout + result.stderr).lower()
check = child(skill, "import setup_environment as setup; sys.argv=['setup_environment.py','--check','--json']; sys.exit(setup.main() or 0)", runtime)
assert check.returncode == 1
assert json.loads(check.stdout)
assert not runtime.exists()
assert not (skill / ".venv").exists()
@pytest.mark.parametrize("integration", INTEGRATIONS)
def test_explicit_setup_uses_same_persistent_root_as_runner_offline(tmp_path, integration):
skill = install_copy(tmp_path, integration, "v1")
runtime = tmp_path / "persistent setup root"
# Stub only package/browser installation. Setup and its stamp/path logic
# execute unchanged; no network, real venv install or browser is launched.
code = '''
import setup_environment as setup
from pathlib import Path
from types import SimpleNamespace
created=[]
calls=[]
def fake_create(path, **kwargs):
created.append(str(path))
Path(path).mkdir(parents=True)
def fake_run(command, **kwargs):
calls.append(command)
return SimpleNamespace(returncode=0)
setup.venv.create=fake_create
setup.subprocess.run=fake_run
env=setup.SkillEnvironment()
assert env.ensure_venv()
import run,json
print('RESULT:'+json.dumps({'created':created,'venv':str(env.venv_dir),'runner':str(run.get_venv_python()),'setup_python':str(env.venv_python),'calls':calls}))
'''
result = child(skill, code, runtime)
assert result.returncode == 0, result.stderr
payload = json.loads(result.stdout.split("RESULT:", 1)[1])
assert payload["created"] == [str(runtime / integration / ".venv")]
assert payload["runner"] == payload["setup_python"]
assert payload["calls"]
assert all(str(runtime / integration / ".venv") in str(command[0]) for command in payload["calls"])
assert not (skill / ".venv").exists()
@pytest.mark.parametrize("raw", ["", "relative", "../state", "~/state", "${CLAUDE_PLUGIN_DATA}/state", "/tmp/$UNRESOLVED", "/tmp/%UNRESOLVED%", "/tmp/../state", " /absolute"])
def test_invalid_overrides_fail_without_writes(tmp_path, monkeypatch, raw):
paths = load_paths()
monkeypatch.setenv("CLAUDE_BLOG_RUNTIME_DIR", raw)
with pytest.raises(ValueError):
paths.resolve_runtime_paths(tmp_path / "blog-notebooklm", "blog-notebooklm")
assert list(tmp_path.iterdir()) == []
@pytest.mark.parametrize("integration", INTEGRATIONS)
def test_invalid_cli_root_refused_by_setup_and_runner(tmp_path, integration):
skill = install_copy(tmp_path, integration, "v1")
for code in ("import run; sys.argv=['run.py','probe.py']; run.main()", "import setup_environment as setup; sys.argv=['setup_environment.py','--check','--json']; sys.exit(setup.main() or 0)"):
result = child(skill, code, "relative-state")
assert result.returncode == 1
assert "CLAUDE_BLOG_RUNTIME_DIR" in result.stdout
assert not (skill / "relative-state").exists()
assert not (skill / ".venv").exists()
@pytest.mark.parametrize("raw", ["C:/Users/Writer/Persistent State", r"C:\Users\Writer\Persistent State", r"\\server\share\Persistent State"])
def test_windows_native_path_anchors_accept_absolute_roots(raw):
assert load_paths().validate_absolute_override(raw, PureWindowsPath).is_absolute()
@pytest.mark.parametrize("raw", [r"C:relative", r"\rooted-without-drive", r"..\state", r"C:\Users\..\state"])
def test_windows_drive_relative_and_parent_paths_are_rejected(raw):
with pytest.raises(ValueError):
load_paths().validate_absolute_override(raw, PureWindowsPath)
def test_notebook_config_library_auth_and_cleanup_share_cross_version_state(tmp_path):
first = install_copy(tmp_path, "blog-notebooklm", "v1")
second = install_copy(tmp_path, "blog-notebooklm", "v2")
runtime = tmp_path / "persistent notebook state"
data = runtime / "blog-notebooklm/data"
data.mkdir(parents=True)
(data / "library.json").write_text(json.dumps({"notebooks": {"fixture": {"name": "Fixture"}}, "active_notebook_id": "fixture"}))
(data / "auth_info.json").write_text('{"fixture":true}')
(data / "browser_state").mkdir()
(data / "browser_state/state.json").write_text('{"cookies":[]}')
(data / "browser_state/browser_profile").mkdir()
(data / "browser_state/browser_profile/fixture").write_text("profile fixture")
for skill in (first, second):
code = '''
import config,notebook_manager,auth_manager,cleanup_manager,json
library=notebook_manager.NotebookLibrary()
auth=auth_manager.AuthManager()
cleanup=cleanup_manager.CleanupManager()
assert library.library_file==config.LIBRARY_FILE
assert auth.auth_info_file==config.AUTH_INFO_FILE
assert auth.state_file==config.STATE_FILE
assert cleanup.data_dir==config.DATA_DIR==library.data_dir
assert 'fixture' in library.notebooks
assert auth.is_authenticated()
preview=cleanup.perform_cleanup(preserve_library=True,dry_run=True)
print('RESULT:'+json.dumps({'data':str(config.DATA_DIR),'preview':preview}))
'''
result = child(skill, code, runtime)
assert result.returncode == 0, result.stderr
assert json.loads(result.stdout.split("RESULT:", 1)[1])["data"] == str(data)
venv = runtime / "blog-notebooklm/.venv"
venv.mkdir()
(venv / "keep").write_text("environment")
outside = tmp_path / "outside"
outside.mkdir()
(outside / "keep").write_text("unrelated state")
(data / "outside-link").symlink_to(outside, target_is_directory=True)
result = child(second, "import cleanup_manager,json; result=cleanup_manager.CleanupManager().perform_cleanup(preserve_library=True); print('RESULT:'+json.dumps(result))", runtime)
assert result.returncode == 0, result.stderr
assert json.loads(result.stdout.split("RESULT:", 1)[1])["failed_count"] == 0
assert (data / "library.json").exists()
assert not (data / "auth_info.json").exists()
assert not (data / "browser_state/state.json").exists()
assert not (data / "outside-link").exists()
assert (outside / "keep").read_text() == "unrelated state"
assert (venv / "keep").read_text() == "environment"
@pytest.mark.parametrize("linked_part", ["blog-notebooklm", "blog-notebooklm/data", "blog-notebooklm/.venv"])
def test_managed_runtime_symlink_roots_are_refused(tmp_path, monkeypatch, linked_part):
runtime = tmp_path / "persistent"
outside = tmp_path / "outside"
outside.mkdir()
link = runtime / linked_part
link.parent.mkdir(parents=True, exist_ok=True)
link.symlink_to(outside, target_is_directory=True)
monkeypatch.setenv("CLAUDE_BLOG_RUNTIME_DIR", str(runtime))
with pytest.raises(ValueError, match="symlink"):
load_paths().resolve_runtime_paths(tmp_path / "source/blog-notebooklm", "blog-notebooklm")
assert list(outside.iterdir()) == []
def test_cleanup_refuses_data_root_replaced_after_resolution(tmp_path):
skill = install_copy(tmp_path, "blog-notebooklm", "v1")
runtime = tmp_path / "persistent"
outside = tmp_path / "outside"
outside.mkdir()
(outside / "keep").write_text("unrelated state")
code = f'''
import cleanup_manager
from pathlib import Path
cleanup=cleanup_manager.CleanupManager()
cleanup.data_dir.parent.mkdir(parents=True)
cleanup.data_dir.symlink_to({str(outside)!r},target_is_directory=True)
try:
cleanup.perform_cleanup()
except ValueError as exc:
assert 'symlink' in str(exc)
else:
raise AssertionError('cleanup followed a changed root')
'''
result = child(skill, code, runtime)
assert result.returncode == 0, result.stderr
assert (outside / "keep").read_text() == "unrelated state"
def test_legacy_package_helper_is_nonmutating_and_requires_explicit_setup(tmp_path):
skill = install_copy(tmp_path, "blog-notebooklm", "v1")
runtime = tmp_path / "missing runtime"
code = f"import runpy; module=runpy.run_path({str(skill / 'scripts/__init__.py')!r}); module['ensure_venv_and_run']()"
result = child(skill, code, runtime)
assert result.returncode == 1
assert "setup required" in result.stdout.lower()
assert not runtime.exists()
def test_runtime_documentation_passes_host_data_explicitly():
for name in INTEGRATIONS:
text = (ROOT / "skills" / name / "SKILL.md").read_text()
assert "CLAUDE_BLOG_RUNTIME_DIR='${CLAUDE_PLUGIN_DATA}/claude-blog-runtime'" in text
assert "not an exported shell variable" in text
assert "No state is" in text and "copied or migrated automatically" in text
for name in ("blog-decay", "blog-geo", "blog-seo-check"):
text = (ROOT / "skills" / name / "SKILL.md").read_text()
assert "Propagate the same absolute `CLAUDE_BLOG_RUNTIME_DIR`" in text
assert "${CLAUDE_PLUGIN_DATA}/claude-blog-runtime" in text
assert "standalone use with no override, omit the variable" in text
@pytest.mark.parametrize("integration", INTEGRATIONS)
def test_documented_plugin_runner_passes_resolved_persistent_path(tmp_path, integration):
skill = install_copy(tmp_path, integration, "v1")
host_data = tmp_path / "host plugin data with spaces"
runtime = host_data / "claude-blog-runtime"
venv = runtime / integration / ".venv"
configure_interpreter(venv)
source = skill / "scripts/requirements.lock"
(venv / ".requirements.stamp").write_text(hashlib.sha256(source.read_bytes()).hexdigest())
target = {"blog-audio": "generate_audio.py", "blog-google": "google_auth.py", "blog-notebooklm": "notebook_manager.py"}[integration]
(skill / "scripts" / target).write_text("import os\nprint(os.environ['CLAUDE_BLOG_RUNTIME_DIR'])")
text = (ROOT / "skills" / integration / "SKILL.md").read_text()
block = next(block for block in re.findall(r"```bash\n(.*?)\n```", text, re.S) if "CLAUDE_BLOG_RUNTIME_DIR='${CLAUDE_PLUGIN_DATA}" in block)
command = block.splitlines()[1]
env = dict(os.environ)
env.pop("CLAUDE_PLUGIN_DATA", None)
env.pop("CLAUDE_SKILL_DIR", None)
env.pop("CLAUDE_BLOG_RUNTIME_DIR", None)
env["PYTHONDONTWRITEBYTECODE"] = "1"
env["PATH"] = str(Path(sys.executable).parent) + os.pathsep + env.get("PATH", "")
rendered = command.replace("${CLAUDE_PLUGIN_DATA}", str(host_data)).replace("${CLAUDE_SKILL_DIR}", str(skill))
result = subprocess.run(["bash", "-c", rendered], cwd=tmp_path, env=env, capture_output=True, text=True)
assert result.returncode == 0, result.stderr
assert result.stdout.strip() == str(runtime)
unresolved = command.replace("${CLAUDE_SKILL_DIR}", str(skill))
result = subprocess.run(["bash", "-c", unresolved], cwd=tmp_path, env=env, capture_output=True, text=True)
assert result.returncode == 1
assert "CLAUDE_BLOG_RUNTIME_DIR" in result.stdout
@pytest.mark.parametrize("integration", ["blog-google", "blog-notebooklm"])
def test_new_version_stale_dependencies_require_setup_without_modifying_state(tmp_path, integration):
skill = install_copy(tmp_path, integration, "v2")
runtime = tmp_path / "persistent"
venv = runtime / integration / ".venv"
configure_interpreter(venv)
(venv / ".requirements.stamp").write_text("previous-version-stamp")
state = runtime / integration / "data"
state.mkdir()
(state / "keep").write_text("existing user state")
result = child(skill, "import run; sys.argv=['run.py','probe.py']; run.main()", runtime)
assert result.returncode == 1
assert "missing or stale" in result.stdout
assert (venv / ".requirements.stamp").read_text() == "previous-version-stamp"
assert (state / "keep").read_text() == "existing user state"
def test_null_byte_override_is_rejected():
with pytest.raises(ValueError):
load_paths().validate_absolute_override("abc\x00def")