Add --process-name flag to cowork for non-interactive in-session use

Adds find_cowork_session_by_process_name() helper and a --process-name
option to the cowork command that skips the interactive picker entirely.

From within a Cowork wrap-up step:
  claude-code-transcripts cowork --process-name "$(basename $PWD)" -a -o ~/Documents/Transcripts

The processName is extracted from the virtual $PWD (/sessions/{processName})
that Cowork sets for running agents.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: houfu

src/claude_code_transcripts/__init__.py

@@ -246,6 +246,63 @@ def find_cowork_sessions(base_dir=None, limit=10):
     return results[:limit]
 
 
+def find_cowork_session_by_process_name(process_name, base_dir=None):
+    """Find a single Cowork session by its processName.
+
+    Returns a session dict (title, jsonl_path, folders, mtime) or None if not found.
+    Useful for non-interactive in-session use: pass basename of $PWD as process_name.
+    """
+    if base_dir is None:
+        base_dir = (
+            Path.home()
+            / "Library"
+            / "Application Support"
+            / "Claude"
+            / "local-agent-mode-sessions"
+        )
+    base_dir = Path(base_dir)
+    if not base_dir.exists():
+        return None
+
+    for metadata_file in base_dir.glob("**/local_*.json"):
+        if not metadata_file.is_file():
+            continue
+        try:
+            metadata = json.loads(metadata_file.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError):
+            continue
+
+        if metadata.get("processName") != process_name:
+            continue
+
+        cli_session_id = metadata.get("cliSessionId", "")
+        title = metadata.get("title") or metadata.get("initialMessage", "(untitled)")
+        folders = metadata.get("userSelectedFolders", [])
+        last_activity_at = metadata.get("lastActivityAt", 0)
+
+        stem = metadata_file.stem
+        jsonl_path = (
+            metadata_file.parent
+            / stem
+            / ".claude"
+            / "projects"
+            / f"-sessions-{process_name}"
+            / f"{cli_session_id}.jsonl"
+        )
+
+        if not jsonl_path.exists():
+            return None
+
+        return {
+            "title": title,
+            "jsonl_path": jsonl_path,
+            "folders": folders,
+            "mtime": last_activity_at / 1000,
+        }
+
+    return None
+
+
 def get_project_display_name(folder_name):
     """Convert encoded folder name to readable project name.
 
@@ -1686,38 +1743,58 @@ def local_cmd(output, output_auto, repo, gist, include_json, open_browser, limit
     default=10,
     help="Maximum number of sessions to show (default: 10)",
 )
-def cowork_cmd(output, output_auto, gist, open_browser, limit):
+@click.option(
+    "--process-name",
+    "process_name",
+    default=None,
+    help=(
+        "Process name to match (e.g. 'quirky-eager-fermat'). "
+        "Skips the interactive picker. "
+        'Use --process-name "$(basename $PWD)" from within a Cowork session.'
+    ),
+)
+def cowork_cmd(output, output_auto, gist, open_browser, limit, process_name):
     """Select and convert a local Claude Cowork session to HTML."""
-    click.echo("Loading Cowork sessions...")
-    sessions = find_cowork_sessions(limit=limit)
+    if process_name:
+        # Non-interactive mode: find session by processName (for in-session use)
+        selected = find_cowork_session_by_process_name(process_name)
+        if selected is None:
+            click.echo(f"No Cowork session found with process name: {process_name}")
+            click.echo(
+                "Ensure ~/Library/Application Support/Claude/ is in your userSelectedFolders."
+            )
+            return
+    else:
+        click.echo("Loading Cowork sessions...")
+        sessions = find_cowork_sessions(limit=limit)
 
-    if not sessions:
-        click.echo("No Cowork sessions found.")
-        click.echo(
-            "Expected sessions in: ~/Library/Application Support/Claude/local-agent-mode-sessions/"
-        )
-        return
+        if not sessions:
+            click.echo("No Cowork sessions found.")
+            click.echo(
+                "Expected sessions in: ~/Library/Application Support/Claude/local-agent-mode-sessions/"
+            )
+            return
 
-    # Build choices for questionary
-    choices = []
-    for session in sessions:
-        mod_time = datetime.fromtimestamp(session["mtime"])
-        date_str = mod_time.strftime("%Y-%m-%d %H:%M")
-        title = session["title"]
-        if len(title) > 50:
-            title = title[:47] + "..."
-        folder = session["folders"][0] if session["folders"] else "(no folder)"
-        display = f"{title:50}  {date_str}  {folder}"
-        choices.append(questionary.Choice(title=display, value=session))
+        # Build choices for questionary
+        choices = []
+        for session in sessions:
+            mod_time = datetime.fromtimestamp(session["mtime"])
+            date_str = mod_time.strftime("%Y-%m-%d %H:%M")
+            title = session["title"]
+            if len(title) > 50:
+                title = title[:47] + "..."
+            folder = session["folders"][0] if session["folders"] else "(no folder)"
+            display = f"{title:50}  {date_str}  {folder}"
+            choices.append(questionary.Choice(title=display, value=session))
 
-    selected = questionary.select(
-        "Select a session to convert:",
-        choices=choices,
-    ).ask()
+        selected = questionary.select(
+            "Select a session to convert:",
+            choices=choices,
+        ).ask()
 
-    if selected is None:
-        click.echo("No session selected.")
-        return
+        if selected is None:
+            click.echo("No session selected.")
+            return
 
     session_file = selected["jsonl_path"]
 

tests/test_cowork.py

@@ -5,7 +5,16 @@
 
 import pytest
 
-from claude_code_transcripts import find_cowork_sessions, parse_session_file
+from unittest.mock import patch
+
+from click.testing import CliRunner
+
+from claude_code_transcripts import (
+    cli,
+    find_cowork_session_by_process_name,
+    find_cowork_sessions,
+    parse_session_file,
+)
 
 
 def make_cowork_session(
@@ -171,3 +180,85 @@ def test_cowork_jsonl_parses_with_queue_operation(tmp_path):
     assert loglines[1]["type"] == "assistant"
     # Content should be correct
     assert loglines[0]["message"]["content"] == "Hello cowork"
+
+
+def test_find_cowork_session_by_process_name_found(tmp_path):
+    """Finds the session matching a given processName."""
+    make_cowork_session(
+        tmp_path,
+        process_name="quirky-eager-fermat",
+        title="Target Session",
+    )
+    make_cowork_session(
+        tmp_path,
+        session_uuid="other-session",
+        process_name="other-process",
+        cli_session_id="other-cli",
+        title="Other Session",
+    )
+
+    result = find_cowork_session_by_process_name(
+        "quirky-eager-fermat", base_dir=tmp_path
+    )
+
+    assert result is not None
+    assert result["title"] == "Target Session"
+    assert result["jsonl_path"].exists()
+
+
+def test_find_cowork_session_by_process_name_not_found(tmp_path):
+    """Returns None when no session matches the processName."""
+    make_cowork_session(tmp_path, process_name="some-other-process")
+
+    result = find_cowork_session_by_process_name("no-such-process", base_dir=tmp_path)
+
+    assert result is None
+
+
+def test_cowork_process_name_flag_converts_without_picker(tmp_path):
+    """--process-name skips the picker and converts the matching session."""
+    _, jsonl_file = make_cowork_session(
+        tmp_path,
+        process_name="quirky-eager-fermat",
+        cli_session_id="cli-abc",
+        title="My Cowork Session",
+    )
+    output_dir = tmp_path / "output"
+
+    runner = CliRunner()
+    with (
+        patch(
+            "claude_code_transcripts.find_cowork_session_by_process_name"
+        ) as mock_find,
+        patch("claude_code_transcripts.generate_html") as mock_gen,
+    ):
+        mock_find.return_value = {
+            "title": "My Cowork Session",
+            "jsonl_path": jsonl_file,
+            "folders": [],
+            "mtime": 1700000000.0,
+        }
+        result = runner.invoke(
+            cli,
+            ["cowork", "--process-name", "quirky-eager-fermat", "-o", str(output_dir)],
+        )
+
+    assert result.exit_code == 0
+    mock_find.assert_called_once_with("quirky-eager-fermat")
+    mock_gen.assert_called_once()
+
+
+def test_cowork_process_name_not_found_exits_cleanly(tmp_path):
+    """--process-name with no match exits with a clear message."""
+    runner = CliRunner()
+    with patch(
+        "claude_code_transcripts.find_cowork_session_by_process_name"
+    ) as mock_find:
+        mock_find.return_value = None
+        result = runner.invoke(
+            cli,
+            ["cowork", "--process-name", "no-such-process"],
+        )
+
+    assert result.exit_code == 0
+    assert "no-such-process" in result.output