codex-autorunner 1.0.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

codex_autorunner/integrations/telegram/handlers/commands/files.py

@@ -29,6 +29,13 @@ FILES_HINT_TEMPLATE = (
     "Check delivery with /files outbox.\n"
     "Max file size: {max_bytes} bytes."
 )
+PMA_FILES_HINT_TEMPLATE = (
+    "PMA inbox: {inbox}\n"
+    "PMA outbox (pending): {outbox}\n"
+    "Place files in outbox pending to send after this turn finishes.\n"
+    "Check delivery with /files outbox.\n"
+    "Max file size: {max_bytes} bytes."
+)
 
 
 _GENERIC_TELEGRAM_ERRORS = {
@@ -97,6 +104,63 @@ class MediaBatchResult:
 
 
 class FilesCommands(SharedHelpers):
+    def _files_usage(self, *, pma: bool) -> str:
+        header = "Usage:"
+        lines = [
+            header,
+            "/files",
+            "/files inbox",
+            "/files outbox",
+            "/files all",
+            "/files send <filename>",
+            "/files clear inbox|outbox|all",
+        ]
+        if pma:
+            lines.append("Note: PMA files live in .codex-autorunner/pma/inbox|outbox.")
+        return "\n".join(lines)
+
+    async def _send_pma_outbox_file(
+        self,
+        path: Path,
+        *,
+        chat_id: int,
+        thread_id: Optional[int],
+        reply_to: Optional[int],
+    ) -> bool:
+        try:
+            data = path.read_bytes()
+        except Exception as exc:
+            log_event(
+                self._logger,
+                logging.WARNING,
+                "telegram.files.pma_outbox.read_failed",
+                chat_id=chat_id,
+                thread_id=thread_id,
+                path=str(path),
+                exc=exc,
+            )
+            return False
+        try:
+            await self._bot.send_document(
+                chat_id,
+                data,
+                filename=path.name,
+                message_thread_id=thread_id,
+                reply_to_message_id=reply_to,
+            )
+        except Exception as exc:
+            log_event(
+                self._logger,
+                logging.WARNING,
+                "telegram.files.pma_outbox.send_failed",
+                chat_id=chat_id,
+                thread_id=thread_id,
+                path=str(path),
+                exc=exc,
+            )
+            return False
+        return True
+
     def _format_telegram_download_error(self, exc: Exception) -> Optional[str]:
         for current in _iter_exception_chain(exc):
             if isinstance(current, Exception):
@@ -245,7 +309,11 @@ class FilesCommands(SharedHelpers):
             return
         try:
             image_path = self._save_image_file(
-                record.workspace_path, data, file_path, candidate
+                record.workspace_path,
+                data,
+                file_path,
+                candidate,
+                pma_enabled=bool(getattr(record, "pma_enabled", False)),
             )
         except asyncio.CancelledError:
             raise
@@ -442,6 +510,7 @@ class FilesCommands(SharedHelpers):
                 data,
                 candidate=candidate,
                 file_path=file_path,
+                pma_enabled=bool(getattr(record, "pma_enabled", False)),
             )
         except asyncio.CancelledError:
             raise
@@ -470,6 +539,7 @@ class FilesCommands(SharedHelpers):
             file_size=file_size or len(data),
             topic_key=key,
             workspace_path=record.workspace_path,
+            pma_enabled=bool(getattr(record, "pma_enabled", False)),
         )
         log_event(
             self._logger,
@@ -543,6 +613,15 @@ class FilesCommands(SharedHelpers):
             first_msg.chat_id, first_msg.thread_id
         )
         record = await self._router.get_topic(topic_key)
+        record, pma_error = message_handlers._record_with_media_workspace(self, record)
+        if pma_error:
+            await self._send_message(
+                first_msg.chat_id,
+                pma_error,
+                thread_id=first_msg.thread_id,
+                reply_to=first_msg.message_id,
+            )
+            return None
         if record is None or not record.workspace_path:
             await self._send_message(
                 first_msg.chat_id,
@@ -669,7 +748,11 @@ class FilesCommands(SharedHelpers):
             return True
         try:
             image_path = self._save_image_file(
-                context.record.workspace_path, data, file_path, candidate
+                context.record.workspace_path,
+                data,
+                file_path,
+                candidate,
+                pma_enabled=bool(getattr(context.record, "pma_enabled", False)),
             )
             saved_image_paths.append(image_path)
         except asyncio.CancelledError:
@@ -759,6 +842,7 @@ class FilesCommands(SharedHelpers):
                 data,
                 candidate=candidate,
                 file_path=file_path,
+                pma_enabled=bool(getattr(context.record, "pma_enabled", False)),
             )
             original_name = (
                 candidate.file_name
@@ -815,23 +899,10 @@ class FilesCommands(SharedHelpers):
             prompt_parts.append(
                 f"\nFailed to process {result.stats.failed_count} item(s)."
             )
-        inbox_dir = self._files_inbox_dir(
-            context.record.workspace_path, context.topic_key
-        )
-        outbox_dir = self._files_outbox_pending_dir(
-            context.record.workspace_path, context.topic_key
-        )
-        topic_dir = self._files_topic_dir(
-            context.record.workspace_path, context.topic_key
-        )
-        hint = wrap_injected_context(
-            FILES_HINT_TEMPLATE.format(
-                inbox=str(inbox_dir),
-                outbox=str(outbox_dir),
-                topic_key=context.topic_key,
-                topic_dir=str(topic_dir),
-                max_bytes=self._config.media.max_file_bytes,
-            )
+        hint = self._build_files_hint(
+            workspace_path=context.record.workspace_path,
+            topic_key=context.topic_key,
+            pma_enabled=bool(getattr(context.record, "pma_enabled", False)),
         )
         prompt_parts.append(hint)
         combined_prompt = "\n\n".join(prompt_parts)
@@ -905,7 +976,11 @@ class FilesCommands(SharedHelpers):
             data = await self._bot.download_file(file_path)
         return data, file_path, file_size
 
-    def _image_storage_dir(self, workspace_path: str) -> Path:
+    def _image_storage_dir(self, workspace_path: str, *, pma_enabled: bool) -> Path:
+        if pma_enabled:
+            pma_inbox = self._pma_inbox_dir()
+            if pma_inbox is not None:
+                return pma_inbox
         return (
             Path(workspace_path) / ".codex-autorunner" / "uploads" / "telegram-images"
         )
@@ -935,8 +1010,10 @@ class FilesCommands(SharedHelpers):
         data: bytes,
         file_path: Optional[str],
         candidate: TelegramMediaCandidate,
+        *,
+        pma_enabled: bool,
     ) -> Path:
-        images_dir = self._image_storage_dir(workspace_path)
+        images_dir = self._image_storage_dir(workspace_path, pma_enabled=pma_enabled)
         images_dir.mkdir(parents=True, exist_ok=True)
         ext = self._choose_image_extension(
             file_path=file_path,
@@ -952,6 +1029,24 @@ class FilesCommands(SharedHelpers):
     def _files_root_dir(self, workspace_path: str) -> Path:
         return Path(workspace_path) / ".codex-autorunner" / "uploads" / "telegram-files"
 
+    def _pma_root_dir(self) -> Optional[Path]:
+        hub_root = getattr(self, "_hub_root", None)
+        if hub_root is None:
+            return None
+        return Path(hub_root) / ".codex-autorunner" / "pma"
+
+    def _pma_inbox_dir(self) -> Optional[Path]:
+        pma_root = self._pma_root_dir()
+        if pma_root is None:
+            return None
+        return pma_root / "inbox"
+
+    def _pma_outbox_dir(self) -> Optional[Path]:
+        pma_root = self._pma_root_dir()
+        if pma_root is None:
+            return None
+        return pma_root / "outbox"
+
     def _sanitize_topic_dir_name(self, key: str) -> str:
         cleaned = re.sub(r"[^A-Za-z0-9._-]+", "_", key).strip("._-")
         if not cleaned:
@@ -1013,8 +1108,13 @@ class FilesCommands(SharedHelpers):
         *,
         candidate: TelegramMediaCandidate,
         file_path: Optional[str],
+        pma_enabled: bool,
     ) -> Path:
         inbox_dir = self._files_inbox_dir(workspace_path, topic_key)
+        if pma_enabled:
+            pma_inbox = self._pma_inbox_dir()
+            if pma_inbox is not None:
+                inbox_dir = pma_inbox
         inbox_dir.mkdir(parents=True, exist_ok=True)
         stem = self._sanitize_filename_component(
             self._choose_file_stem(candidate.file_name, file_path),
@@ -1041,6 +1141,7 @@ class FilesCommands(SharedHelpers):
         file_size: int,
         topic_key: str,
         workspace_path: str,
+        pma_enabled: bool,
     ) -> str:
         header = caption_text.strip() or "File received."
         original_name = (
@@ -1048,17 +1149,10 @@ class FilesCommands(SharedHelpers):
             or (Path(source_path).name if source_path else None)
             or "unknown"
         )
-        inbox_dir = self._files_inbox_dir(workspace_path, topic_key)
-        outbox_dir = self._files_outbox_pending_dir(workspace_path, topic_key)
-        topic_dir = self._files_topic_dir(workspace_path, topic_key)
-        hint = wrap_injected_context(
-            FILES_HINT_TEMPLATE.format(
-                inbox=str(inbox_dir),
-                outbox=str(outbox_dir),
-                topic_key=topic_key,
-                topic_dir=str(topic_dir),
-                max_bytes=self._config.media.max_file_bytes,
-            )
+        hint = self._build_files_hint(
+            workspace_path=workspace_path,
+            topic_key=topic_key,
+            pma_enabled=pma_enabled,
         )
         parts = [
             header,
@@ -1074,6 +1168,37 @@ class FilesCommands(SharedHelpers):
         parts.append(hint)
         return "\n".join(parts)
 
+    def _build_files_hint(
+        self,
+        *,
+        workspace_path: str,
+        topic_key: str,
+        pma_enabled: bool,
+    ) -> str:
+        if pma_enabled:
+            pma_inbox = self._pma_inbox_dir()
+            pma_outbox = self._pma_outbox_dir()
+            if pma_inbox is not None and pma_outbox is not None:
+                return wrap_injected_context(
+                    PMA_FILES_HINT_TEMPLATE.format(
+                        inbox=str(pma_inbox),
+                        outbox=str(pma_outbox),
+                        max_bytes=self._config.media.max_file_bytes,
+                    )
+                )
+        inbox_dir = self._files_inbox_dir(workspace_path, topic_key)
+        outbox_dir = self._files_outbox_pending_dir(workspace_path, topic_key)
+        topic_dir = self._files_topic_dir(workspace_path, topic_key)
+        return wrap_injected_context(
+            FILES_HINT_TEMPLATE.format(
+                inbox=str(inbox_dir),
+                outbox=str(outbox_dir),
+                topic_key=topic_key,
+                topic_dir=str(topic_dir),
+                max_bytes=self._config.media.max_file_bytes,
+            )
+        )
+
     def _format_bytes(self, size: int) -> str:
         if size < 1024:
             return f"{size} B"
@@ -1192,7 +1317,12 @@ class FilesCommands(SharedHelpers):
             key = topic_key
         else:
             key = await self._resolve_topic_key(chat_id, thread_id)
+        pma_enabled = bool(getattr(record, "pma_enabled", False))
         pending_dir = self._files_outbox_pending_dir(record.workspace_path, key)
+        if pma_enabled:
+            pma_outbox = self._pma_outbox_dir()
+            if pma_outbox is not None:
+                pending_dir = pma_outbox
         if not pending_dir.exists():
             return
         files = self._list_files(pending_dir)
@@ -1215,13 +1345,34 @@ class FilesCommands(SharedHelpers):
                     reply_to=reply_to,
                 )
                 continue
-            await self._send_outbox_file(
-                path,
-                sent_dir=sent_dir,
-                chat_id=chat_id,
-                thread_id=thread_id,
-                reply_to=reply_to,
-            )
+            if pma_enabled:
+                success = await self._send_pma_outbox_file(
+                    path,
+                    chat_id=chat_id,
+                    thread_id=thread_id,
+                    reply_to=reply_to,
+                )
+                if success:
+                    try:
+                        path.unlink()
+                    except OSError as exc:
+                        log_event(
+                            self._logger,
+                            logging.WARNING,
+                            "telegram.files.pma_outbox.delete_failed",
+                            chat_id=chat_id,
+                            thread_id=thread_id,
+                            path=str(path),
+                            exc=exc,
+                        )
+            else:
+                await self._send_outbox_file(
+                    path,
+                    sent_dir=sent_dir,
+                    chat_id=chat_id,
+                    thread_id=thread_id,
+                    reply_to=reply_to,
+                )
 
     def _format_file_listing(self, title: str, files: list[Path]) -> str:
         if not files:
@@ -1266,26 +1417,72 @@ class FilesCommands(SharedHelpers):
                 reply_to=message.message_id,
             )
             return
-        record = await self._require_bound_record(message)
-        if not record:
-            return
         key = await self._resolve_topic_key(message.chat_id, message.thread_id)
-        inbox_dir = self._files_inbox_dir(record.workspace_path, key)
-        pending_dir = self._files_outbox_pending_dir(record.workspace_path, key)
-        sent_dir = self._files_outbox_sent_dir(record.workspace_path, key)
+        record = await self._router.ensure_topic(message.chat_id, message.thread_id)
+        record, pma_error = message_handlers._record_with_media_workspace(self, record)
+        if pma_error:
+            await self._send_message(
+                message.chat_id,
+                pma_error,
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
+            )
+            return
+        if record is None or not record.workspace_path:
+            await self._send_message(
+                message.chat_id,
+                self._with_conversation_id(
+                    "Topic not bound. Use /bind <repo_id> or /bind <path>.",
+                    chat_id=message.chat_id,
+                    thread_id=message.thread_id,
+                ),
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
+            )
+            return
+        pma_enabled = bool(getattr(record, "pma_enabled", False))
+        if pma_enabled:
+            hub_root = getattr(self, "_hub_root", None)
+            if hub_root is None:
+                await self._send_message(
+                    message.chat_id,
+                    "PMA unavailable; hub root not configured.",
+                    thread_id=message.thread_id,
+                    reply_to=message.message_id,
+                )
+                return
+            pma_root = Path(hub_root) / ".codex-autorunner" / "pma"
+            inbox_dir = pma_root / "inbox"
+            outbox_dir = pma_root / "outbox"
+            pending_dir = outbox_dir
+            sent_dir = outbox_dir
+        else:
+            inbox_dir = self._files_inbox_dir(record.workspace_path, key)
+            pending_dir = self._files_outbox_pending_dir(record.workspace_path, key)
+            sent_dir = self._files_outbox_sent_dir(record.workspace_path, key)
         argv = self._parse_command_args(args)
         if not argv:
             inbox_items = self._list_files(inbox_dir)
             pending_items = self._list_files(pending_dir)
-            sent_items = self._list_files(sent_dir)
-            text = "\n".join(
-                [
-                    f"Inbox: {len(inbox_items)} item(s)",
-                    f"Outbox pending: {len(pending_items)} item(s)",
-                    f"Outbox sent: {len(sent_items)} item(s)",
-                    "Usage: /files inbox|outbox|clear inbox|outbox|all|send <filename>",
-                ]
-            )
+            sent_items = [] if pma_enabled else self._list_files(sent_dir)
+            usage = self._files_usage(pma=pma_enabled)
+            if pma_enabled:
+                text = "\n".join(
+                    [
+                        f"Inbox: {len(inbox_items)} file(s)",
+                        f"Outbox: {len(pending_items)} file(s)",
+                        usage,
+                    ]
+                )
+            else:
+                text = "\n".join(
+                    [
+                        f"Inbox: {len(inbox_items)} item(s)",
+                        f"Outbox pending: {len(pending_items)} item(s)",
+                        f"Outbox sent: {len(sent_items)} item(s)",
+                        usage,
+                    ]
+                )
             await self._send_message(
                 message.chat_id,
                 text,
@@ -1306,14 +1503,46 @@ class FilesCommands(SharedHelpers):
             return
         if subcommand == "outbox":
             pending_items = self._list_files(pending_dir)
-            sent_items = self._list_files(sent_dir)
-            text = "\n".join(
-                [
-                    self._format_file_listing("Outbox pending", pending_items),
-                    "",
-                    self._format_file_listing("Outbox sent", sent_items),
-                ]
+            if pma_enabled:
+                text = self._format_file_listing("Outbox", pending_items)
+            else:
+                sent_items = self._list_files(sent_dir)
+                text = "\n".join(
+                    [
+                        self._format_file_listing("Outbox pending", pending_items),
+                        "",
+                        self._format_file_listing("Outbox sent", sent_items),
+                    ]
+                )
+            await self._send_message(
+                message.chat_id,
+                text,
+                thread_id=message.thread_id,
+                reply_to=message.message_id,
             )
+            return
+        if subcommand == "all":
+            inbox_items = self._list_files(inbox_dir)
+            pending_items = self._list_files(pending_dir)
+            if pma_enabled:
+                text = "\n".join(
+                    [
+                        self._format_file_listing("Inbox", inbox_items),
+                        "",
+                        self._format_file_listing("Outbox", pending_items),
+                    ]
+                )
+            else:
+                sent_items = self._list_files(sent_dir)
+                text = "\n".join(
+                    [
+                        self._format_file_listing("Inbox", inbox_items),
+                        "",
+                        self._format_file_listing("Outbox pending", pending_items),
+                        "",
+                        self._format_file_listing("Outbox sent", sent_items),
+                    ]
+                )
             await self._send_message(
                 message.chat_id,
                 text,
@@ -1325,7 +1554,7 @@ class FilesCommands(SharedHelpers):
             if len(argv) < 2:
                 await self._send_message(
                     message.chat_id,
-                    "Usage: /files clear inbox|outbox|all",
+                    self._files_usage(pma=pma_enabled),
                     thread_id=message.thread_id,
                     reply_to=message.message_id,
                 )
@@ -1336,15 +1565,17 @@ class FilesCommands(SharedHelpers):
                 deleted = self._delete_files_in_dir(inbox_dir)
             elif target == "outbox":
                 deleted = self._delete_files_in_dir(pending_dir)
-                deleted += self._delete_files_in_dir(sent_dir)
+                if not pma_enabled:
+                    deleted += self._delete_files_in_dir(sent_dir)
             elif target == "all":
                 deleted = self._delete_files_in_dir(inbox_dir)
                 deleted += self._delete_files_in_dir(pending_dir)
-                deleted += self._delete_files_in_dir(sent_dir)
+                if not pma_enabled:
+                    deleted += self._delete_files_in_dir(sent_dir)
             else:
                 await self._send_message(
                     message.chat_id,
-                    "Usage: /files clear inbox|outbox|all",
+                    self._files_usage(pma=pma_enabled),
                     thread_id=message.thread_id,
                     reply_to=message.message_id,
                 )
@@ -1360,7 +1591,7 @@ class FilesCommands(SharedHelpers):
             if len(argv) < 2:
                 await self._send_message(
                     message.chat_id,
-                    "Usage: /files send <filename>",
+                    self._files_usage(pma=pma_enabled),
                     thread_id=message.thread_id,
                     reply_to=message.message_id,
                 )
@@ -1370,7 +1601,7 @@ class FilesCommands(SharedHelpers):
             if not _path_within(pending_dir, candidate) or not candidate.is_file():
                 await self._send_message(
                     message.chat_id,
-                    f"Outbox pending file not found: {name}",
+                    f"Outbox file not found: {name}",
                     thread_id=message.thread_id,
                     reply_to=message.message_id,
                 )
@@ -1385,13 +1616,21 @@ class FilesCommands(SharedHelpers):
                     reply_to=message.message_id,
                 )
                 return
-            success = await self._send_outbox_file(
-                candidate,
-                sent_dir=sent_dir,
-                chat_id=message.chat_id,
-                thread_id=message.thread_id,
-                reply_to=message.message_id,
-            )
+            if pma_enabled:
+                success = await self._send_pma_outbox_file(
+                    candidate,
+                    chat_id=message.chat_id,
+                    thread_id=message.thread_id,
+                    reply_to=message.message_id,
+                )
+            else:
+                success = await self._send_outbox_file(
+                    candidate,
+                    sent_dir=sent_dir,
+                    chat_id=message.chat_id,
+                    thread_id=message.thread_id,
+                    reply_to=message.message_id,
+                )
             result = "Sent." if success else "Failed to send."
             await self._send_message(
                 message.chat_id,
@@ -1402,7 +1641,7 @@ class FilesCommands(SharedHelpers):
             return
         await self._send_message(
             message.chat_id,
-            "Usage: /files inbox|outbox|clear inbox|outbox|all|send <filename>",
+            self._files_usage(pma=pma_enabled),
             thread_id=message.thread_id,
             reply_to=message.message_id,
         )