learn-cli 0.5.0__tar.gz → 0.5.2__tar.gz

{learn_cli-0.5.0 → learn_cli-0.5.2}/.gitignore

@@ -232,3 +232,6 @@ skills.local.yaml
 # devague working state (not committed by default)
 .devague/reviews/
 .claude/settings.json
+
+# wrangler local state (created by `wrangler pages deploy` at repo root)
+.wrangler/

{learn_cli-0.5.0 → learn_cli-0.5.2}/CHANGELOG.md

@@ -5,6 +5,30 @@ All notable changes to this project will be documented in this file.
 Format follows [Keep a Changelog](https://keepachangelog.com/). This project
 adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.2] - 2026-07-11
+
+### Added
+
+- Phase-1 (signed-out) production deploy of agentculture.org/learn: Cloudflare Pages project agentculture-learn + proxy Worker owning the agentculture.org/learn/* zone route. Signed-out tour, all subject/story pages, and the 401 resource-gate are live; verified 38/38 by the LIVE_ORIGIN launch gate.
+- workers/learn-api/wrangler.signedout.toml — the committed Phase-1 config (proxy-only: route + PAGES_ORIGIN, no KV/D1/secrets).
+
+### Changed
+
+- workers/learn-api/README.md: document the two-phase go-live (signed-out live vs signed-in pending) and the exact token permissions each phase needs (Pages+Workers Scripts for Phase 1; +KV+D1 for Phase 2).
+
+### Fixed
+
+- wrangler.toml: moved the routes array above the [vars] table. Under [vars], TOML scoped it as vars.routes and wrangler silently bound no route (No targets deployed).
+
+## [0.5.1] - 2026-07-11
+
+### Fixed
+
+- API worker: the /learn zone-mount proxy strips Cookie/Authorization before forwarding to the Pages origin (review finding: session leak)
+- API worker: withCors appends to an existing Vary header instead of overwriting it
+- Profile ledger: created 0600 like auth.json (learner data is private)
+- Profile ledger: a malformed ledger line is skipped instead of crashing progress/next/sync
+
 ## [0.5.0] - 2026-07-11
 
 ### Added

{learn_cli-0.5.0 → learn_cli-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: learn-cli
-Version: 0.5.0
+Version: 0.5.2
 Summary: A CLI, MCP server, and web front for learning — a hosted site where humans and agents learn a subject step by step. Fronts the french-cli and spanish-cli language tutors, and generalizes to other learnable domains such as leading teams of agents. The learn command is the local operator surface and how agents drive it.
 Project-URL: Homepage, https://github.com/agentculture/learn-cli
 Project-URL: Issues, https://github.com/agentculture/learn-cli/issues

{learn_cli-0.5.0 → learn_cli-0.5.2}/learn/profile/_ledger.py

@@ -8,26 +8,44 @@ written to by ``learn record`` (never by a subject CLI directly) and read by
 every motivation computation. Append-only by design — nothing here ever
 rewrites or deletes a row, so the sync cursor (:mod:`learn.profile._syncstate`)
 can track "pushed so far" as a simple row count.
+
+The ledger is learner data: the file is created ``0600`` (like ``auth.json``),
+and a malformed line — a crash mid-append, a manual edit — is skipped rather
+than crashing every ``progress``/``next``/sync flow. Because the ledger is
+append-only and a malformed line never becomes valid, skipping is stable, so
+the sync cursor's count-of-valid-rows arithmetic stays consistent across runs.
 """
 
 from __future__ import annotations
 
 import json
+import os
 from typing import Any
 
 from learn.profile._paths import ensure_store_dir, ledger_path
 
+#: Learner data is private to the local user, like ``auth.json``.
+_LEDGER_MODE = 0o600
+
 
 def append_ledger(row: dict[str, Any]) -> None:
     """Append one row to the local ledger, creating the store dir if needed."""
     ensure_store_dir()
-    with ledger_path().open("a", encoding="utf-8") as handle:
+    path = ledger_path()
+    created = not path.exists()
+    with path.open("a", encoding="utf-8") as handle:
         handle.write(json.dumps(row, ensure_ascii=False))
         handle.write("\n")
+    if created:
+        os.chmod(path, _LEDGER_MODE)
 
 
 def read_ledger() -> list[dict[str, Any]]:
-    """Read every row, in append order. Empty list when the ledger doesn't exist yet."""
+    """Read every valid row, in append order. Empty list when no ledger exists yet.
+
+    A line that fails to parse (or parses to a non-object) is skipped — one
+    corrupt row must not take down ``progress``/``next``/sync.
+    """
     path = ledger_path()
     if not path.is_file():
         return []
@@ -37,7 +55,12 @@ def read_ledger() -> list[dict[str, Any]]:
             stripped = line.strip()
             if not stripped:
                 continue
-            rows.append(json.loads(stripped))
+            try:
+                parsed = json.loads(stripped)
+            except json.JSONDecodeError:
+                continue
+            if isinstance(parsed, dict):
+                rows.append(parsed)
     return rows
 
 

{learn_cli-0.5.0 → learn_cli-0.5.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "learn-cli"
-version = "0.5.0"
+version = "0.5.2"
 description = "A CLI, MCP server, and web front for learning — a hosted site where humans and agents learn a subject step by step. Fronts the french-cli and spanish-cli language tutors, and generalizes to other learnable domains such as leading teams of agents. The learn command is the local operator surface and how agents drive it."
 readme = "README.md"
 license = "Apache-2.0"

{learn_cli-0.5.0 → learn_cli-0.5.2}/tests/test_profile_store.py

@@ -72,6 +72,23 @@ def test_read_ledger_skips_blank_lines(profile_home) -> None:
     assert len(p.read_ledger()) == 1
 
 
+def test_ledger_file_is_created_private(profile_home) -> None:
+    p.append_ledger({"subject": "french", "item_id": "fr.x", "result": "pass"})
+    mode = p.ledger_path().stat().st_mode & 0o777
+    assert mode == 0o600
+
+
+def test_read_ledger_skips_malformed_lines(profile_home) -> None:
+    p.append_ledger({"subject": "french", "item_id": "fr.a", "result": "pass"})
+    with p.ledger_path().open("a", encoding="utf-8") as handle:
+        handle.write("{not json\n")
+        handle.write("[1, 2, 3]\n")
+    p.append_ledger({"subject": "french", "item_id": "fr.b", "result": "partial"})
+    rows = p.read_ledger()
+    assert [r["item_id"] for r in rows] == ["fr.a", "fr.b"]
+    assert p.ledger_count() == 2
+
+
 # --- auth state ------------------------------------------------------------
 
 

{learn_cli-0.5.0 → learn_cli-0.5.2}/uv.lock

@@ -474,7 +474,7 @@ wheels = [
 
 [[package]]
 name = "learn-cli"
-version = "0.5.0"
+version = "0.5.2"
 source = { editable = "." }
 dependencies = [
     { name = "agentfront", extra = ["mcp"] },

{learn_cli-0.5.0 → learn_cli-0.5.2}/workers/learn-api/README.md

@@ -64,18 +64,43 @@ wrangler dev         # serves http://localhost:8787
 For `wrangler dev`, put non-secret vars in `wrangler.toml` and provide dev
 secrets in a git-ignored `.dev.vars` file (see below).
 
-## Provisioning (operator steps still owed)
+## Deploy status: two phases
 
-These steps are done once, by the operator, before the first deploy. Nothing
-here is committed.
+The go-live is staged. **Phase 1 (signed-out) is LIVE** at
+<https://agentculture.org/learn/> (deployed 2026-07-11); **Phase 2 (signed-in)
+is pending** two operator-held credentials.
+
+| | Phase 1 — signed-out (LIVE) | Phase 2 — signed-in (pending) |
+| --- | --- | --- |
+| Config | [`wrangler.signedout.toml`](wrangler.signedout.toml) | [`wrangler.toml`](wrangler.toml) |
+| Serves | Static `/learn/*` proxied to Pages; `/api/*` returns 401 | + sessions, ledger, tutoring |
+| KV / D1 | none | KV `SESSIONS` + D1 `learn-ledger` |
+| Secrets | none | `SESSION_SECRET`, `GITHUB_CLIENT_SECRET`, `INFERENCE_TOKEN` |
+| Token perms | Cloudflare Pages: Edit **+** Workers Scripts: Edit | **+** Workers KV Storage: Edit **+** D1: Edit |
+| Deploy | `wrangler deploy -c wrangler.signedout.toml` | `wrangler deploy` |
+
+The signed-out tier touches no storage and spends no inference — `/api/me` and
+`POST /api/tutor` return `401` *before* any KV/D1 access (proven live by the
+launch gate's "signed-out fires ONLY GET /api/me" walk). That is why Phase 1
+deploys with a Pages+Workers token and nothing else.
+
+**Phase 1 was deployed with the repo's `.env` token, which carries Pages: Edit
+and Workers Scripts: Edit but NOT KV/D1.** To do Phase 2 self-serve, that token
+needs **Workers KV Storage: Edit** and **D1: Edit** added (or swap in a token
+that has them).
+
+## Provisioning Phase 2 (signed-in)
+
+These steps are done once, by the operator, before the signed-in deploy.
+Nothing here is committed.
 
 ### 1. Create the GitHub OAuth app
 
 Create an OAuth app at
 `https://github.com/settings/developers` (or in the AgentCulture org):
 
-- **Authorization callback URL:** `https://<worker-host>/api/auth/callback`
-  (e.g. the route mounted under `agentculture.org/learn`).
+- **Authorization callback URL:**
+  `https://agentculture.org/learn/api/auth/callback` (the live zone route).
 - **Enable Device Flow** — required for the CLI/MCP device sign-in (t12).
 - Requested scope is `read:user` only. Do **not** request `user:email`; the API
   never reads or stores email.
@@ -93,7 +118,16 @@ wrangler d1 execute learn-ledger --file schema.sql
 
 Copy the returned ids into `wrangler.toml` (replace the `REPLACE_ME_*`
 placeholders for `id`, `preview_id`, and `database_id`), and set
-`GITHUB_CLIENT_ID` there too (it is public).
+`GITHUB_CLIENT_ID` there too (it is public). The route + `PUBLIC_URL` /
+`APP_URL` / `CORS_ORIGIN` / `PAGES_ORIGIN` vars are already filled in
+`wrangler.toml` from the live Phase-1 deploy.
+
+Apply the schema to the **remote** D1 (the `--local` form only touches the
+`wrangler dev` SQLite):
+
+```bash
+wrangler d1 execute learn-ledger --remote --file schema.sql
+```
 
 ### 3. Set secrets
 
@@ -128,12 +162,14 @@ INFERENCE_TOKEN = "..."
 ### 4. Deploy
 
 ```bash
-wrangler deploy
+wrangler deploy   # uses wrangler.toml — full stack, same /learn/* route
 ```
 
-Then mount the Worker under the `agentculture.org/learn` zone via the
-operator-owned Cloudflare routing (coordinated with the `org` / cultureflare
-path — the same route that fronts the Pages site).
+The `agentculture.org/learn/*` zone route is already live (Phase 1) and is
+declared in `wrangler.toml`, so this deploy upgrades the *same* worker in place
+— the route does not move. Confirm the signed-in path end-to-end afterward
+(`GET /learn/api/me` with a real session cookie should `200`), then merge org's
+Learn-nav link to open public discovery.
 
 ## Endpoint shapes for downstream waves
 

{learn_cli-0.5.0 → learn_cli-0.5.2}/workers/learn-api/src/index.js

@@ -102,7 +102,13 @@ async function proxyToPages(request, env, url) {
   requireConfig(env, "PAGES_ORIGIN");
   const origin = env.PAGES_ORIGIN.replace(/\/+$/, "");
   const upstream = origin + url.pathname + url.search;
-  return fetch(new Request(upstream, { method: request.method, headers: request.headers }));
+  // Never forward credentials to the static origin: the session cookie (and
+  // any Authorization header) is for this API only — the Pages origin serves
+  // public files and must not see learner sessions.
+  const headers = new Headers(request.headers);
+  headers.delete("Cookie");
+  headers.delete("Authorization");
+  return fetch(new Request(upstream, { method: request.method, headers }));
 }
 
 // --- public routes ---------------------------------------------------------
@@ -325,6 +331,6 @@ function withCors(env, request, response) {
   headers.set("Access-Control-Allow-Credentials", "true");
   headers.set("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
   headers.set("Access-Control-Allow-Headers", "Content-Type, Authorization");
-  headers.set("Vary", "Origin");
+  headers.append("Vary", "Origin");
   return new Response(response.body, { status: response.status, headers });
 }

{learn_cli-0.5.0 → learn_cli-0.5.2}/workers/learn-api/test/worker.test.js

@@ -429,3 +429,47 @@ test("POST under the /learn site mount is rejected (read-only proxy)", async ()
   const res = await call(env, new Request(`${BASE}/learn/french/`, { method: "POST" }));
   assert.equal(res.status, 405);
 });
+
+test("proxy to PAGES_ORIGIN strips Cookie and Authorization headers", async () => {
+  let seenHeaders = null;
+  const realFetch = globalThis.fetch;
+  globalThis.fetch = async (req) => {
+    seenHeaders = req.headers;
+    return new Response("ok", { status: 200 });
+  };
+  try {
+    const env = makeEnv({ PAGES_ORIGIN: "https://agentculture-learn.pages.dev" });
+    const req = new Request(`${BASE}/learn/french/`, {
+      headers: { Cookie: "session=supersecret", Authorization: "Bearer tok", Accept: "text/html" },
+    });
+    const res = await call(env, req);
+    assert.equal(res.status, 200);
+    assert.equal(seenHeaders.get("Cookie"), null);
+    assert.equal(seenHeaders.get("Authorization"), null);
+    assert.equal(seenHeaders.get("Accept"), "text/html");
+  } finally {
+    globalThis.fetch = realFetch;
+  }
+});
+
+test("withCors appends to an existing Vary header instead of overwriting", async () => {
+  let called = 0;
+  const realFetch = globalThis.fetch;
+  globalThis.fetch = async () => {
+    called += 1;
+    return new Response("ok", { status: 200, headers: { Vary: "Accept-Encoding" } });
+  };
+  try {
+    const env = makeEnv({
+      PAGES_ORIGIN: "https://agentculture-learn.pages.dev",
+      CORS_ORIGIN: "https://agentculture.org",
+    });
+    const res = await call(env, new Request(`${BASE}/learn/french/`, { headers: { Origin: "https://agentculture.org" } }));
+    assert.equal(called, 1);
+    const vary = res.headers.get("Vary");
+    assert.ok(vary.includes("Accept-Encoding"), `Vary lost upstream value: ${vary}`);
+    assert.ok(vary.includes("Origin"), `Vary missing Origin: ${vary}`);
+  } finally {
+    globalThis.fetch = realFetch;
+  }
+});

learn_cli-0.5.2/workers/learn-api/wrangler.signedout.toml

@@ -0,0 +1,42 @@
+# wrangler config — PHASE 1 (signed-out) deploy of the learn API Worker.
+#
+# This is the config that is LIVE in production today (deployed 2026-07-11).
+# It stands up the whole SIGNED-OUT experience at agentculture.org/learn:
+# the worker owns the /learn/* zone route and reverse-proxies every non-API
+# path to the Cloudflare Pages origin (PAGES_ORIGIN). The signed-out tour is
+# fully static; the resource-gated API routes (/api/me, /api/tutor, …) return
+# 401 WITHOUT ever touching storage, so this deploy needs NO KV, NO D1, and
+# NO secrets. It requires only two token permissions: Cloudflare Pages: Edit
+# (for the Pages project) and Workers Scripts: Edit (for this worker + route).
+#
+# Deploy with:
+#   wrangler deploy -c wrangler.signedout.toml
+#
+# PHASE 2 (signed-in) uses the full ./wrangler.toml instead — it adds the KV
+# namespace, the D1 ledger, the GitHub OAuth client id, and the secrets. That
+# deploy additionally needs Workers KV Storage: Edit + D1: Edit on the token,
+# and the GitHub OAuth app must exist first. See README.md "Provisioning".
+
+name = "learn-api"
+main = "src/index.js"
+compatibility_date = "2024-11-01"
+workers_dev = false
+
+# Top-level key — MUST precede [vars] (see the gotcha note in wrangler.toml).
+routes = [
+  { pattern = "agentculture.org/learn/*", zone_name = "agentculture.org" },
+  { pattern = "agentculture.org/learn", zone_name = "agentculture.org" },
+]
+
+[vars]
+# Placeholder client id: harmless in phase 1. The sign-in button is only
+# reachable by direct navigation (org's Learn nav link is held until phase 2),
+# so a non-functional OAuth start has no public surface yet.
+GITHUB_CLIENT_ID = "REPLACE_ME_github_oauth_client_id"
+PUBLIC_URL   = "https://agentculture.org"
+APP_URL      = "https://agentculture.org/learn/"
+CORS_ORIGIN  = "https://agentculture.org"
+PAGES_ORIGIN = "https://agentculture-learn.pages.dev"
+
+[observability]
+enabled = true

{learn_cli-0.5.0 → learn_cli-0.5.2}/workers/learn-api/wrangler.toml

@@ -15,27 +15,34 @@ compatibility_date = "2024-11-01"
 # Node-compat is not required — the Worker uses only Web-standard APIs
 # (fetch, Request/Response, crypto.subtle, btoa/atob). Keep the bundle lean.
 
+# --- Zone route (the same-origin /learn mount) -------------------------------
+# Cloudflare Pages cannot be mounted at a path, so this ONE worker owns
+# agentculture.org/learn/*: /learn/api/* is handled here, everything else
+# proxies to PAGES_ORIGIN (which serves the site under /learn/ too).
+#
+# GOTCHA: `routes` is a TOP-LEVEL key and MUST appear ABOVE the [vars] table.
+# Placed after [vars], TOML scopes it as `vars.routes` and wrangler silently
+# ignores it ("No targets deployed") — the worker uploads but binds no route.
+# This block is live in production (deployed 2026-07-11); the signed-out mount
+# is served by exactly these two patterns.
+routes = [
+  { pattern = "agentculture.org/learn/*", zone_name = "agentculture.org" },
+  { pattern = "agentculture.org/learn", zone_name = "agentculture.org" },
+]
+
 # --- Non-secret vars -------------------------------------------------------
 # INFERENCE_URL points at the cloudai-cli / ec2bedrock-cli SERVED endpoint
 # (an OpenAI-shaped HTTP API), NEVER a bespoke provider SDK. The broker only
 # ever POSTs JSON to this URL. Leave it unset to disable tutoring (broker 503s).
 [vars]
+# GITHUB_CLIENT_ID is public; still REPLACE_ME until the GitHub OAuth app exists
+# (needed only for the signed-in tier — see README "Phase 2").
 GITHUB_CLIENT_ID = "REPLACE_ME_github_oauth_client_id"
-# PUBLIC_URL   = "https://agentculture.org"          # origin used to build the OAuth callback
-# APP_URL      = "https://agentculture.org/learn/"   # where the web callback redirects post-login
-# CORS_ORIGIN  = "https://agentculture.org"          # allow the /learn site to call the API with creds
-# INFERENCE_URL = "https://<cloudai-or-ec2bedrock-served-endpoint>/v1/messages"
-# PAGES_ORIGIN = "https://agentculture-learn.pages.dev"  # static-site origin the /learn zone mount proxies to
-
-# --- Zone route (the same-origin /learn mount) -------------------------------
-# Cloudflare Pages cannot be mounted at a path, so this ONE worker owns
-# agentculture.org/learn/*: /learn/api/* is handled here, everything else
-# proxies to PAGES_ORIGIN (which serves the site under /learn/ too).
-# Uncomment once the zone is reachable from this account's token:
-# routes = [
-#   { pattern = "agentculture.org/learn/*", zone_name = "agentculture.org" },
-#   { pattern = "agentculture.org/learn", zone_name = "agentculture.org" },
-# ]
+PUBLIC_URL   = "https://agentculture.org"          # origin used to build the OAuth callback
+APP_URL      = "https://agentculture.org/learn/"   # where the web callback redirects post-login
+CORS_ORIGIN  = "https://agentculture.org"          # allow the /learn site to call the API with creds
+PAGES_ORIGIN = "https://agentculture-learn.pages.dev"  # static-site origin the /learn zone mount proxies to
+# INFERENCE_URL = "https://<cloudai-or-ec2bedrock-served-endpoint>/v1/messages"  # unset ⇒ tutoring 503s
 
 # --- Secrets (NEVER committed) ---------------------------------------------
 # Set with: wrangler secret put <NAME>