@@ -436,5 +439,44 @@
.command-order-capsule-form + .command-order-capsule-form .command-order-btn {
border-top: 1px solid #dbdbdb;
}
+ .command-variant-warning {
+ border: 1px solid rgba(171, 109, 17, 0.45);
+ background: linear-gradient(180deg, rgba(255, 246, 226, 0.98), rgba(255, 238, 204, 0.95));
+ color: #6e450e;
+ border-radius: 8px;
+ padding: 0.48rem 0.62rem;
+ font-size: 0.78rem;
+ line-height: 1.35;
+ }
+ .command-destination-list {
+ list-style: none;
+ margin: 0;
+ padding: 0;
+ display: flex;
+ flex-direction: column;
+ gap: 0.28rem;
+ }
+ .command-destination-item {
+ display: inline-flex;
+ align-items: center;
+ gap: 0.42rem;
+ background: rgba(244, 248, 255, 0.85);
+ border: 1px solid rgba(58, 103, 165, 0.2);
+ border-radius: 7px;
+ padding: 0.26rem 0.38rem;
+ width: fit-content;
+ max-width: 100%;
+ }
+ .command-destination-summary {
+ margin-top: 0.44rem;
+ display: inline-flex;
+ align-items: center;
+ border-radius: 999px;
+ background: rgba(239, 247, 255, 0.95);
+ border: 1px solid rgba(58, 103, 165, 0.25);
+ padding: 0.16rem 0.52rem;
+ font-size: 0.73rem;
+ color: #284d7c;
+ }
{% endblock %}
diff --git a/core/templates/pages/tasks-settings.html b/core/templates/pages/tasks-settings.html
index 4f46aa9..c8f54cf 100644
--- a/core/templates/pages/tasks-settings.html
+++ b/core/templates/pages/tasks-settings.html
@@ -316,21 +316,112 @@
- Provider
+ Providers
Controls outbound sync to external tracking systems. If disabled, tasks are still derived and visible inside GIA only.
+ Browse all derived tasks in Tasks Hub .
+
+
+ External Chat Links
+ Map a contact to an external Codex chat/session ID for task-sync metadata.
+
+
+ Provider Person Identifier External Chat Enabled
+ {% for row in external_chat_links %}
+
+ {{ row.provider }}
+ {% if row.person %}{{ row.person.name }}{% else %}-{% endif %}
+ {% if row.person_identifier %}{{ row.person_identifier.service }} ยท {{ row.person_identifier.identifier }}{% else %}-{% endif %}
+ {{ row.external_chat_id }}
+ {{ row.enabled }}
+
+
+
+
+ {% empty %}
+ No external chat links.
+
+
+
AI Workspace
+ {% if ai_workspace_graphs_url and ai_workspace_info_url %}
+
+
+ Graphs
+
+
+ Info
+
+
+ {% endif %}
{% if ai_workspace_widget_url %}
+
+ {% for row in availability_slices %}
+
+ {{ row.state|title }} ยท {{ row.service|upper }}
+
+ {% endfor %}
+
+
0) {
+ meta.push("last seen " + new Date(lastSeenTs).toLocaleString());
+ }
+ chip.title = chip.textContent + " (" + meta.join(", ") + ")";
+ availabilityLane.appendChild(chip);
+ });
+ availabilityLane.classList.remove("is-hidden");
+ };
+
const applyTyping = function (typingPayload) {
if (!typingNode || !typingPayload || typeof typingPayload !== "object") {
return;
@@ -3059,6 +3185,9 @@
if (payload.typing) {
applyTyping(payload.typing);
}
+ if (payload.availability_slices) {
+ renderAvailabilitySlices(payload.availability_slices);
+ }
if (payload.last_ts !== undefined && payload.last_ts !== null) {
lastTs = Math.max(lastTs, toInt(payload.last_ts));
thread.dataset.lastTs = String(lastTs);
@@ -3096,6 +3225,9 @@
if (payload.typing) {
applyTyping(payload.typing);
}
+ if (payload.availability_slices) {
+ renderAvailabilitySlices(payload.availability_slices);
+ }
if (payload.last_ts !== undefined && payload.last_ts !== null) {
lastTs = Math.max(lastTs, toInt(payload.last_ts));
thread.dataset.lastTs = String(lastTs);
@@ -3136,8 +3268,14 @@
}
updateManualSafety();
try {
- const initialTyping = JSON.parse("{{ typing_state_json|escapejs }}");
- applyTyping(initialTyping);
+ const initialTyping = JSON.parse("{{ typing_state_json|escapejs }}");
+ applyTyping(initialTyping);
+ try {
+ const initialSlices = JSON.parse(String((availabilityLane && availabilityLane.dataset.slices) || "[]"));
+ renderAvailabilitySlices(initialSlices);
+ } catch (err) {
+ renderAvailabilitySlices([]);
+ }
} catch (err) {
// Ignore invalid initial typing state payload.
}
diff --git a/core/templates/partials/signal-chats-list.html b/core/templates/partials/signal-chats-list.html
index d7280e3..ae019b3 100644
--- a/core/templates/partials/signal-chats-list.html
+++ b/core/templates/partials/signal-chats-list.html
@@ -12,6 +12,7 @@
account
name
person
+ availability
actions
{% for item in object_list %}
@@ -36,6 +37,13 @@
{% if item.chat %}{{ item.chat.source_name }}{% else %}{{ item.name }}{% endif %}
{{ item.person_name|default:"-" }}
+
+ {% if item.availability_label %}
+ {{ item.availability_label }}
+ {% else %}
+ -
+ {% endif %}
+
{% if not item.is_group %}
diff --git a/core/templates/partials/whatsapp-chats-list.html b/core/templates/partials/whatsapp-chats-list.html
index c13d644..6df2a9f 100644
--- a/core/templates/partials/whatsapp-chats-list.html
+++ b/core/templates/partials/whatsapp-chats-list.html
@@ -10,6 +10,7 @@
chat
identifier
person
+ availability
actions
{% for item in object_list %}
@@ -25,6 +26,13 @@
{{ item.person_name|default:"-" }}
+
+ {% if item.availability_label %}
+ {{ item.availability_label }}
+ {% else %}
+ -
+ {% endif %}
+
{% if type == 'page' %}
@@ -52,7 +60,7 @@
{% empty %}
- No WhatsApp chats discovered yet.
+ No WhatsApp chats discovered yet.
{% endfor %}
diff --git a/core/tests/test_availability_settings_page.py b/core/tests/test_availability_settings_page.py
new file mode 100644
index 0000000..1b01d1e
--- /dev/null
+++ b/core/tests/test_availability_settings_page.py
@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from django.test import TestCase
+from django.urls import reverse
+
+from core.models import ContactAvailabilitySettings, User
+
+
+class AvailabilitySettingsPageTests(TestCase):
+ def setUp(self):
+ self.user = User.objects.create_user("avail-user", "avail@example.com", "x")
+ self.client.force_login(self.user)
+
+ def test_get_page_renders(self):
+ response = self.client.get(reverse("availability_settings"))
+ self.assertEqual(200, response.status_code)
+ self.assertContains(response, "Availability Settings")
+
+ def test_post_updates_settings(self):
+ response = self.client.post(
+ reverse("availability_settings"),
+ {
+ "enabled": "1",
+ "show_in_chat": "1",
+ "show_in_groups": "0",
+ "inference_enabled": "1",
+ "retention_days": "120",
+ "fade_threshold_seconds": "300",
+ },
+ )
+ self.assertEqual(200, response.status_code)
+ row = ContactAvailabilitySettings.objects.get(user=self.user)
+ self.assertTrue(row.enabled)
+ self.assertTrue(row.show_in_chat)
+ self.assertFalse(row.show_in_groups)
+ self.assertTrue(row.inference_enabled)
+ self.assertEqual(120, row.retention_days)
+ self.assertEqual(300, row.fade_threshold_seconds)
diff --git a/core/tests/test_backfill_contact_availability.py b/core/tests/test_backfill_contact_availability.py
new file mode 100644
index 0000000..2a37aa4
--- /dev/null
+++ b/core/tests/test_backfill_contact_availability.py
@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from django.core.management import call_command
+from django.test import TestCase
+
+from core.models import (
+ ChatSession,
+ ContactAvailabilityEvent,
+ Person,
+ PersonIdentifier,
+ Message,
+ User,
+)
+from core.presence.inference import now_ms
+
+
+class BackfillContactAvailabilityCommandTests(TestCase):
+ def setUp(self):
+ self.user = User.objects.create_user("backfill-user", "backfill@example.com", "x")
+ self.person = Person.objects.create(user=self.user, name="Backfill Person")
+ self.identifier = PersonIdentifier.objects.create(
+ user=self.user,
+ person=self.person,
+ service="signal",
+ identifier="+15551234567",
+ )
+ self.session = ChatSession.objects.create(user=self.user, identifier=self.identifier)
+
+ def test_backfill_creates_message_and_read_receipt_availability_events(self):
+ base_ts = now_ms()
+ Message.objects.create(
+ user=self.user,
+ session=self.session,
+ ts=base_ts,
+ text="hello",
+ source_service="signal",
+ source_chat_id="+15551234567",
+ custom_author="OTHER",
+ )
+ Message.objects.create(
+ user=self.user,
+ session=self.session,
+ ts=base_ts + 1000,
+ text="hey",
+ source_service="signal",
+ source_chat_id="+15551234567",
+ custom_author="USER",
+ read_ts=base_ts + 2000,
+ read_by_identifier="+15551234567",
+ )
+
+ call_command(
+ "backfill_contact_availability",
+ "--days",
+ "36500",
+ "--limit",
+ "100",
+ )
+
+ events = list(
+ ContactAvailabilityEvent.objects.filter(user=self.user).order_by("ts", "source_kind")
+ )
+ self.assertEqual(3, len(events))
+ self.assertTrue(any(row.source_kind == "message_in" for row in events))
+ self.assertTrue(any(row.source_kind == "message_out" for row in events))
+ self.assertTrue(any(row.source_kind == "read_receipt" for row in events))
diff --git a/core/tests/test_codex_cli_provider.py b/core/tests/test_codex_cli_provider.py
new file mode 100644
index 0000000..5313ec5
--- /dev/null
+++ b/core/tests/test_codex_cli_provider.py
@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from subprocess import CompletedProcess, TimeoutExpired
+from unittest.mock import patch
+
+from django.test import SimpleTestCase
+
+from core.tasks.providers.codex_cli import CodexCLITaskProvider
+
+
+class CodexCLITaskProviderTests(SimpleTestCase):
+ def setUp(self):
+ self.provider = CodexCLITaskProvider()
+
+ @patch("core.tasks.providers.codex_cli.subprocess.run")
+ def test_healthcheck_success(self, run_mock):
+ run_mock.return_value = CompletedProcess(
+ args=["codex", "--version"],
+ returncode=0,
+ stdout="codex 1.2.3\n",
+ stderr="",
+ )
+ result = self.provider.healthcheck({"command": "codex", "timeout_seconds": 5})
+ self.assertTrue(result.ok)
+ self.assertIn("codex", str(result.payload.get("stdout") or ""))
+
+ @patch("core.tasks.providers.codex_cli.subprocess.run")
+ def test_create_task_builds_task_sync_command(self, run_mock):
+ run_mock.return_value = CompletedProcess(
+ args=[],
+ returncode=0,
+ stdout='{"external_key":"cx-123"}',
+ stderr="",
+ )
+ result = self.provider.create_task(
+ {
+ "command": "codex",
+ "workspace_root": "/tmp/work",
+ "default_profile": "default",
+ "timeout_seconds": 30,
+ },
+ {
+ "task_id": "t1",
+ "title": "hello",
+ "reference_code": "42",
+ },
+ )
+ self.assertTrue(result.ok)
+ self.assertEqual("cx-123", result.external_key)
+ args = run_mock.call_args.args[0]
+ self.assertEqual(["codex", "task-sync", "--op", "create"], args[:4])
+ self.assertIn("--workspace", args)
+ self.assertIn("--payload-json", args)
+
+ @patch("core.tasks.providers.codex_cli.subprocess.run")
+ def test_timeout_maps_to_failed_result(self, run_mock):
+ run_mock.side_effect = TimeoutExpired(cmd=["codex"], timeout=10)
+ result = self.provider.append_update({"command": "codex", "timeout_seconds": 10}, {"task_id": "t1"})
+ self.assertFalse(result.ok)
+ self.assertIn("timeout", result.error)
diff --git a/core/tests/test_presence_engine.py b/core/tests/test_presence_engine.py
new file mode 100644
index 0000000..2303a62
--- /dev/null
+++ b/core/tests/test_presence_engine.py
@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+from django.test import TestCase
+
+from core.models import (
+ ContactAvailabilityEvent,
+ ContactAvailabilitySettings,
+ ContactAvailabilitySpan,
+ Person,
+ PersonIdentifier,
+ User,
+)
+from core.presence.engine import (
+ AvailabilitySignal,
+ ensure_fading_state,
+ record_inferred_signal,
+ record_native_signal,
+)
+from core.presence.inference import now_ms
+
+
+class PresenceEngineTests(TestCase):
+ def setUp(self):
+ self.user = User.objects.create_user("presence-user", "presence@example.com", "x")
+ self.person = Person.objects.create(user=self.user, name="Presence Person")
+ self.identifier = PersonIdentifier.objects.create(
+ user=self.user,
+ person=self.person,
+ service="signal",
+ identifier="+15550001111",
+ )
+ ContactAvailabilitySettings.objects.update_or_create(
+ user=self.user,
+ defaults={
+ "enabled": True,
+ "show_in_chat": True,
+ "show_in_groups": True,
+ "inference_enabled": True,
+ "retention_days": 90,
+ "fade_threshold_seconds": 1,
+ },
+ )
+
+ def test_read_receipt_signal_creates_available_event(self):
+ ts = now_ms()
+ event = record_native_signal(
+ AvailabilitySignal(
+ user=self.user,
+ person=self.person,
+ person_identifier=self.identifier,
+ service="signal",
+ source_kind="read_receipt",
+ availability_state="available",
+ confidence=0.95,
+ ts=ts,
+ payload={"origin": "test"},
+ )
+ )
+ self.assertIsNotNone(event)
+ self.assertEqual(1, ContactAvailabilityEvent.objects.filter(user=self.user).count())
+ self.assertEqual("available", event.availability_state)
+
+ def test_inactivity_transitions_to_fading(self):
+ base_ts = now_ms()
+ record_inferred_signal(
+ AvailabilitySignal(
+ user=self.user,
+ person=self.person,
+ person_identifier=self.identifier,
+ service="signal",
+ source_kind="read_receipt",
+ availability_state="available",
+ confidence=0.95,
+ ts=base_ts,
+ )
+ )
+ fade_event = ensure_fading_state(
+ user=self.user,
+ person=self.person,
+ person_identifier=self.identifier,
+ service="signal",
+ at_ts=base_ts + 10_000,
+ )
+ self.assertIsNotNone(fade_event)
+ self.assertEqual("fading", fade_event.availability_state)
+
+ def test_explicit_unavailable_blocks_fade_inference(self):
+ base_ts = now_ms()
+ record_native_signal(
+ AvailabilitySignal(
+ user=self.user,
+ person=self.person,
+ person_identifier=self.identifier,
+ service="xmpp",
+ source_kind="native_presence",
+ availability_state="unavailable",
+ confidence=1.0,
+ ts=base_ts,
+ )
+ )
+ fade_event = ensure_fading_state(
+ user=self.user,
+ person=self.person,
+ person_identifier=self.identifier,
+ service="xmpp",
+ at_ts=base_ts + 60_000,
+ )
+ self.assertIsNone(fade_event)
+ self.assertEqual(1, ContactAvailabilityEvent.objects.filter(user=self.user).count())
+
+ def test_adjacent_same_state_events_extend_single_span(self):
+ ts0 = now_ms()
+ record_native_signal(
+ AvailabilitySignal(
+ user=self.user,
+ person=self.person,
+ person_identifier=self.identifier,
+ service="signal",
+ source_kind="typing_start",
+ availability_state="available",
+ confidence=0.9,
+ ts=ts0,
+ )
+ )
+ record_native_signal(
+ AvailabilitySignal(
+ user=self.user,
+ person=self.person,
+ person_identifier=self.identifier,
+ service="signal",
+ source_kind="message_in",
+ availability_state="available",
+ confidence=0.8,
+ ts=ts0 + 5_000,
+ )
+ )
+ spans = list(ContactAvailabilitySpan.objects.filter(user=self.user).order_by("start_ts"))
+ self.assertEqual(1, len(spans))
+ self.assertEqual(ts0, spans[0].start_ts)
+ self.assertEqual(ts0 + 5_000, spans[0].end_ts)
diff --git a/core/tests/test_presence_query_and_compose_context.py b/core/tests/test_presence_query_and_compose_context.py
new file mode 100644
index 0000000..95739d8
--- /dev/null
+++ b/core/tests/test_presence_query_and_compose_context.py
@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from django.test import TestCase
+
+from core.models import Person, PersonIdentifier, User
+from core.presence import AvailabilitySignal, latest_state_for_people, record_native_signal
+from core.presence.inference import now_ms
+from core.views.compose import _context_base
+
+
+class PresenceQueryAndComposeContextTests(TestCase):
+ def setUp(self):
+ self.user = User.objects.create_user("ctx-user", "ctx@example.com", "x")
+ self.person = Person.objects.create(user=self.user, name="Ctx Person")
+ self.identifier = PersonIdentifier.objects.create(
+ user=self.user,
+ person=self.person,
+ service="signal",
+ identifier="15551234567",
+ )
+
+ def test_latest_state_map_uses_string_person_keys(self):
+ record_native_signal(
+ AvailabilitySignal(
+ user=self.user,
+ person=self.person,
+ person_identifier=self.identifier,
+ service="signal",
+ source_kind="message_in",
+ availability_state="available",
+ confidence=0.8,
+ ts=now_ms(),
+ )
+ )
+ state_map = latest_state_for_people(
+ user=self.user,
+ person_ids=[str(self.person.id)],
+ service="signal",
+ )
+ self.assertIn(str(self.person.id), state_map)
+
+ def test_context_base_matches_signal_identifier_variants(self):
+ base = _context_base(
+ user=self.user,
+ service="signal",
+ identifier="+1 (555) 123-4567",
+ person=self.person,
+ )
+ self.assertIsNotNone(base["person_identifier"])
+ self.assertEqual(str(self.person.id), str(base["person"].id))
diff --git a/core/tests/test_signal_text_extraction.py b/core/tests/test_signal_text_extraction.py
new file mode 100644
index 0000000..00b9314
--- /dev/null
+++ b/core/tests/test_signal_text_extraction.py
@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from django.test import SimpleTestCase
+
+from core.clients.signal import _extract_signal_text
+
+
+class SignalTextExtractionTests(SimpleTestCase):
+ def test_extracts_emoji_only_data_message_text(self):
+ payload = {
+ "envelope": {
+ "dataMessage": {
+ "message": "๐",
+ }
+ }
+ }
+ self.assertEqual("๐", _extract_signal_text(payload, ""))
+
+ def test_extracts_sync_sent_message_fallback(self):
+ payload = {
+ "envelope": {
+ "syncMessage": {
+ "sentMessage": {
+ "message": {
+ "message": "ok ๐",
+ }
+ }
+ }
+ }
+ }
+ self.assertEqual("ok ๐", _extract_signal_text(payload, ""))
diff --git a/core/tests/test_whatsapp_reaction_and_recalc.py b/core/tests/test_whatsapp_reaction_and_recalc.py
new file mode 100644
index 0000000..894ba2d
--- /dev/null
+++ b/core/tests/test_whatsapp_reaction_and_recalc.py
@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+import asyncio
+
+from asgiref.sync import async_to_sync
+from django.core.management import call_command
+from django.test import TestCase
+
+from core.clients.whatsapp import WhatsAppClient
+from core.messaging import history
+from core.models import (
+ ChatSession,
+ ContactAvailabilityEvent,
+ ContactAvailabilitySpan,
+ Message,
+ Person,
+ PersonIdentifier,
+ User,
+)
+from core.presence.inference import now_ms
+
+
+class _DummyXMPPClient:
+ async def apply_external_reaction(self, *args, **kwargs):
+ return None
+
+
+class _DummyUR:
+ def __init__(self, loop):
+ self.loop = loop
+ self.xmpp = type("X", (), {"client": _DummyXMPPClient()})()
+ self.presence_calls = []
+ self.stopped_typing_calls = []
+
+ async def presence_changed(self, protocol, *args, **kwargs):
+ self.presence_calls.append((protocol, kwargs))
+
+ async def stopped_typing(self, protocol, *args, **kwargs):
+ self.stopped_typing_calls.append((protocol, kwargs))
+
+
+class WhatsAppReactionHandlingTests(TestCase):
+ def setUp(self):
+ self.user = User.objects.create_user("wa-rx-user", "wa-rx@example.com", "x")
+ self.person = Person.objects.create(user=self.user, name="WA Person")
+ self.identifier = PersonIdentifier.objects.create(
+ user=self.user,
+ person=self.person,
+ service="whatsapp",
+ identifier="15551234567@s.whatsapp.net",
+ )
+ self.session = ChatSession.objects.create(user=self.user, identifier=self.identifier)
+ self.base_ts = now_ms()
+ self.target = Message.objects.create(
+ user=self.user,
+ session=self.session,
+ ts=self.base_ts,
+ text="hello",
+ source_service="whatsapp",
+ source_message_id="wa-target-1",
+ source_chat_id="120363402761690215@g.us",
+ sender_uuid="15551234567@s.whatsapp.net",
+ )
+ self.loop = asyncio.new_event_loop()
+ self.ur = _DummyUR(self.loop)
+ self.client = WhatsAppClient(self.ur, self.loop, "whatsapp")
+
+ def tearDown(self):
+ try:
+ self.loop.close()
+ except Exception:
+ pass
+
+ def test_reaction_event_extract_and_apply_by_source_message_id(self):
+ message_obj = {
+ "reactionMessage": {
+ "text": "๐",
+ "targetMessageKey": {
+ "id": "wa-target-1",
+ "messageTimestamp": int(self.base_ts / 1000),
+ },
+ }
+ }
+ parsed = self.client._extract_reaction_event(message_obj)
+ self.assertIsNotNone(parsed)
+ self.assertEqual("wa-target-1", str(parsed.get("target_message_id") or ""))
+ before_count = Message.objects.filter(user=self.user, session=self.session).count()
+ async_to_sync(history.apply_reaction)(
+ self.user,
+ self.identifier,
+ target_message_id="wa-target-1",
+ target_ts=int(parsed.get("target_ts") or 0),
+ emoji="๐",
+ source_service="whatsapp",
+ actor="15551234567@s.whatsapp.net",
+ remove=False,
+ payload={"event": "reaction"},
+ )
+ after_count = Message.objects.filter(user=self.user, session=self.session).count()
+ self.assertEqual(before_count, after_count)
+
+ self.target.refresh_from_db()
+ reactions = list((self.target.receipt_payload or {}).get("reactions") or [])
+ self.assertEqual(1, len(reactions))
+ self.assertEqual("๐", str(reactions[0].get("emoji") or ""))
+
+ def test_presence_event_emits_native_presence_with_last_seen(self):
+ event = {
+ "From": {"User": "15551234567@s.whatsapp.net"},
+ "Unavailable": True,
+ "LastSeen": int(self.base_ts / 1000),
+ }
+ async_to_sync(self.client._handle_presence_event)(event)
+ self.assertTrue(self.ur.presence_calls)
+ payload = self.ur.presence_calls[-1][1].get("payload") or {}
+ self.assertEqual("offline", payload.get("presence"))
+ self.assertTrue(int(payload.get("last_seen_ts") or 0) > 0)
+
+
+class RecalculateContactAvailabilityTests(TestCase):
+ def setUp(self):
+ self.user = User.objects.create_user("recalc-user", "recalc@example.com", "x")
+ self.person = Person.objects.create(user=self.user, name="Recalc Person")
+ self.identifier = PersonIdentifier.objects.create(
+ user=self.user,
+ person=self.person,
+ service="whatsapp",
+ identifier="15557654321@s.whatsapp.net",
+ )
+ self.session = ChatSession.objects.create(user=self.user, identifier=self.identifier)
+ self.base_ts = now_ms()
+
+ Message.objects.create(
+ user=self.user,
+ session=self.session,
+ ts=self.base_ts,
+ text="task",
+ source_service="whatsapp",
+ source_message_id="m-1",
+ source_chat_id="120363402761690215@g.us",
+ sender_uuid="15557654321@s.whatsapp.net",
+ custom_author="OTHER",
+ read_ts=self.base_ts + 20_000,
+ receipt_payload={
+ "reactions": [
+ {
+ "emoji": "๐ฅ",
+ "actor": "15557654321@s.whatsapp.net",
+ "source_service": "whatsapp",
+ "removed": False,
+ "updated_at": self.base_ts + 10_000,
+ }
+ ]
+ },
+ )
+
+ def _projection(self):
+ events = list(
+ ContactAvailabilityEvent.objects.filter(user=self.user)
+ .order_by("ts", "source_kind", "id")
+ .values_list("service", "source_kind", "availability_state", "ts")
+ )
+ spans = list(
+ ContactAvailabilitySpan.objects.filter(user=self.user)
+ .order_by("start_ts", "end_ts", "id")
+ .values_list("service", "state", "start_ts", "end_ts")
+ )
+ return events, spans
+
+ def test_recalculate_is_deterministic_and_no_skew_on_rerun(self):
+ call_command("recalculate_contact_availability", "--days", "36500", "--limit", "500")
+ first_events, first_spans = self._projection()
+ self.assertTrue(first_events)
+ self.assertTrue(first_spans)
+
+ call_command("recalculate_contact_availability", "--days", "36500", "--limit", "500")
+ second_events, second_spans = self._projection()
+
+ self.assertEqual(first_events, second_events)
+ self.assertEqual(first_spans, second_spans)
+
+ def test_recalculate_no_reset_does_not_duplicate(self):
+ call_command("recalculate_contact_availability", "--days", "36500", "--limit", "500")
+ events_before = ContactAvailabilityEvent.objects.filter(user=self.user).count()
+ spans_before = ContactAvailabilitySpan.objects.filter(user=self.user).count()
+
+ call_command(
+ "recalculate_contact_availability",
+ "--days",
+ "36500",
+ "--limit",
+ "500",
+ "--no-reset",
+ )
+ events_after = ContactAvailabilityEvent.objects.filter(user=self.user).count()
+ spans_after = ContactAvailabilitySpan.objects.filter(user=self.user).count()
+ self.assertEqual(events_before, events_after)
+ self.assertEqual(spans_before, spans_after)
diff --git a/core/views/availability.py b/core/views/availability.py
new file mode 100644
index 0000000..d3f7ca8
--- /dev/null
+++ b/core/views/availability.py
@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+from django.contrib.auth.mixins import LoginRequiredMixin
+from django.shortcuts import render
+from django.views import View
+
+from core.models import (
+ ContactAvailabilityEvent,
+ ContactAvailabilitySettings,
+ ContactAvailabilitySpan,
+ Person,
+)
+
+
+def _to_int(value, default=0):
+ try:
+ return int(value)
+ except Exception:
+ return int(default)
+
+
+def _to_bool(value, default=False):
+ if value is None:
+ return bool(default)
+ text = str(value).strip().lower()
+ if text in {"1", "true", "yes", "on", "y"}:
+ return True
+ if text in {"0", "false", "no", "off", "n"}:
+ return False
+ return bool(default)
+
+
+def _iso_to_ms(value: str) -> int:
+ raw = str(value or "").strip()
+ if not raw:
+ return 0
+ try:
+ dt = datetime.fromisoformat(raw)
+ if dt.tzinfo is None:
+ dt = dt.replace(tzinfo=timezone.utc)
+ return int(dt.timestamp() * 1000)
+ except Exception:
+ return 0
+
+
+class AvailabilitySettingsPage(LoginRequiredMixin, View):
+ template_name = "pages/availability-settings.html"
+
+ def _settings(self, request):
+ row, _ = ContactAvailabilitySettings.objects.get_or_create(user=request.user)
+ return row
+
+ def post(self, request):
+ row = self._settings(request)
+ row.enabled = _to_bool(request.POST.get("enabled"), row.enabled)
+ row.show_in_chat = _to_bool(request.POST.get("show_in_chat"), row.show_in_chat)
+ row.show_in_groups = _to_bool(
+ request.POST.get("show_in_groups"), row.show_in_groups
+ )
+ row.inference_enabled = _to_bool(
+ request.POST.get("inference_enabled"), row.inference_enabled
+ )
+ row.retention_days = max(1, _to_int(request.POST.get("retention_days"), 90))
+ row.fade_threshold_seconds = max(
+ 30, _to_int(request.POST.get("fade_threshold_seconds"), 900)
+ )
+ row.save(
+ update_fields=[
+ "enabled",
+ "show_in_chat",
+ "show_in_groups",
+ "inference_enabled",
+ "retention_days",
+ "fade_threshold_seconds",
+ "updated_at",
+ ]
+ )
+ return self.get(request)
+
+ def get(self, request):
+ settings_row = self._settings(request)
+ person_id = str(request.GET.get("person") or "").strip()
+ service = str(request.GET.get("service") or "").strip().lower()
+ state = str(request.GET.get("state") or "").strip().lower()
+ source_kind = str(request.GET.get("source_kind") or "").strip().lower()
+ start_ts = _iso_to_ms(request.GET.get("start"))
+ end_ts = _iso_to_ms(request.GET.get("end"))
+ if end_ts <= 0:
+ end_ts = int(datetime.now(tz=timezone.utc).timestamp() * 1000)
+ if start_ts <= 0:
+ start_ts = max(0, end_ts - (14 * 24 * 60 * 60 * 1000))
+
+ events_qs = ContactAvailabilityEvent.objects.filter(user=request.user)
+ spans_qs = ContactAvailabilitySpan.objects.filter(user=request.user)
+
+ if person_id:
+ events_qs = events_qs.filter(person_id=person_id)
+ spans_qs = spans_qs.filter(person_id=person_id)
+ if service:
+ events_qs = events_qs.filter(service=service)
+ spans_qs = spans_qs.filter(service=service)
+ if state:
+ events_qs = events_qs.filter(availability_state=state)
+ spans_qs = spans_qs.filter(state=state)
+ if source_kind:
+ events_qs = events_qs.filter(source_kind=source_kind)
+
+ events_qs = events_qs.filter(ts__gte=start_ts, ts__lte=end_ts)
+ spans_qs = spans_qs.filter(start_ts__lte=end_ts, end_ts__gte=start_ts)
+
+ events = list(
+ events_qs.select_related("person", "person_identifier").order_by("-ts")[:500]
+ )
+ spans = list(
+ spans_qs.select_related("person", "person_identifier").order_by("-end_ts")[:500]
+ )
+
+ people = list(Person.objects.filter(user=request.user).order_by("name"))
+
+ context = {
+ "settings_row": settings_row,
+ "people": people,
+ "events": events,
+ "spans": spans,
+ "filters": {
+ "person": person_id,
+ "service": service,
+ "state": state,
+ "source_kind": source_kind,
+ "start": request.GET.get("start") or "",
+ "end": request.GET.get("end") or "",
+ },
+ "service_choices": ["signal", "whatsapp", "xmpp", "instagram", "web"],
+ "state_choices": ["available", "fading", "unavailable", "unknown"],
+ "source_kind_choices": [
+ "native_presence",
+ "read_receipt",
+ "typing_start",
+ "typing_stop",
+ "message_in",
+ "message_out",
+ "inferred_timeout",
+ ],
+ }
+ return render(request, self.template_name, context)
diff --git a/core/views/compose.py b/core/views/compose.py
index fc77f41..2276bf2 100644
--- a/core/views/compose.py
+++ b/core/views/compose.py
@@ -48,6 +48,8 @@ from core.models import (
PlatformChatLink,
WorkspaceConversation,
)
+from core.presence import get_settings as get_availability_settings
+from core.presence import spans_for_range
from core.realtime.typing_state import get_person_typing_state
from core.translation.engine import process_inbound_translation
from core.views.workspace import (
@@ -101,6 +103,36 @@ def _default_service(service: str | None) -> str:
return "signal"
+def _identifier_variants(service: str, identifier: str) -> list[str]:
+ value = str(identifier or "").strip()
+ if not value:
+ return []
+ service_key = _default_service(service)
+ variants = [value]
+
+ bare = value.split("@", 1)[0].strip()
+ if bare and bare not in variants:
+ variants.append(bare)
+
+ if service_key == "signal":
+ digits = re.sub(r"[^0-9]", "", value)
+ if digits and digits not in variants:
+ variants.append(digits)
+ if digits:
+ plus = f"+{digits}"
+ if plus not in variants:
+ variants.append(plus)
+ elif service_key == "whatsapp":
+ if bare:
+ direct = f"{bare}@s.whatsapp.net"
+ group = f"{bare}@g.us"
+ if direct not in variants:
+ variants.append(direct)
+ if group not in variants:
+ variants.append(group)
+ return variants
+
+
def _safe_limit(raw) -> int:
try:
value = int(raw or 40)
@@ -136,6 +168,24 @@ def _format_ts_label(ts_value: int) -> str:
return str(ts_value or "")
+def _serialize_availability_spans(spans):
+ rows = []
+ for row in list(spans or []):
+ rows.append(
+ {
+ "id": int(getattr(row, "id", 0) or 0),
+ "service": str(getattr(row, "service", "") or ""),
+ "state": str(getattr(row, "state", "unknown") or "unknown"),
+ "start_ts": int(getattr(row, "start_ts", 0) or 0),
+ "end_ts": int(getattr(row, "end_ts", 0) or 0),
+ "confidence_start": float(getattr(row, "confidence_start", 0.0) or 0.0),
+ "confidence_end": float(getattr(row, "confidence_end", 0.0) or 0.0),
+ "payload": dict(getattr(row, "payload", {}) or {}),
+ }
+ )
+ return rows
+
+
def _is_outgoing(msg: Message) -> bool:
is_outgoing = str(msg.custom_author or "").upper() in {"USER", "BOT"}
if not is_outgoing:
@@ -672,14 +722,19 @@ THREAD_METRIC_COPY_OVERRIDES = {
def _workspace_conversation_for_person(user, person):
if person is None:
return None
- return (
- WorkspaceConversation.objects.filter(
- user=user,
- participants=person,
+ try:
+ from core.views.workspace import _conversation_for_person
+
+ return _conversation_for_person(user, person)
+ except Exception:
+ return (
+ WorkspaceConversation.objects.filter(
+ user=user,
+ participants=person,
+ )
+ .order_by("-last_event_ts", "-created_at")
+ .first()
)
- .order_by("-last_event_ts", "-created_at")
- .first()
- )
def _counterpart_identifiers_for_person(user, person):
@@ -1522,14 +1577,15 @@ def _engage_source_from_ref(plan, source_ref):
def _context_base(user, service, identifier, person):
+ identifier_variants = _identifier_variants(service, identifier)
person_identifier = None
if person is not None:
- if identifier:
+ if identifier_variants:
person_identifier = PersonIdentifier.objects.filter(
user=user,
person=person,
service=service,
- identifier=identifier,
+ identifier__in=identifier_variants,
).first()
if person_identifier is None:
person_identifier = (
@@ -1544,7 +1600,7 @@ def _context_base(user, service, identifier, person):
person_identifier = PersonIdentifier.objects.filter(
user=user,
service=service,
- identifier=identifier,
+ identifier__in=identifier_variants or [identifier],
).first()
if person_identifier:
@@ -2496,6 +2552,35 @@ def _panel_context(
counterpart_identifiers=counterpart_identifiers,
conversation=conversation,
)
+ availability_slices = []
+ availability_enabled = False
+ availability_settings = get_availability_settings(request.user)
+ if (
+ base["person"] is not None
+ and availability_settings.enabled
+ and availability_settings.show_in_chat
+ ):
+ range_start = (
+ int(session_bundle["messages"][0].ts or 0) if session_bundle["messages"] else 0
+ )
+ range_end = (
+ int(session_bundle["messages"][-1].ts or 0) if session_bundle["messages"] else 0
+ )
+ if range_start <= 0 or range_end <= 0:
+ now_ts = int(time.time() * 1000)
+ range_start = now_ts - (24 * 60 * 60 * 1000)
+ range_end = now_ts
+ availability_enabled = True
+ availability_slices = _serialize_availability_spans(
+ spans_for_range(
+ user=request.user,
+ person=base["person"],
+ start_ts=range_start,
+ end_ts=range_end,
+ service=base["service"],
+ limit=200,
+ )
+ )
glance_items = _build_glance_items(
serialized_messages,
person_id=(base["person"].id if base["person"] else None),
@@ -2665,6 +2750,22 @@ def _panel_context(
if base["person"]
else reverse("ai_workspace")
),
+ "ai_workspace_graphs_url": (
+ reverse(
+ "ai_workspace_insight_graphs",
+ kwargs={"type": "page", "person_id": base["person"].id},
+ )
+ if base["person"]
+ else ""
+ ),
+ "ai_workspace_info_url": (
+ reverse(
+ "ai_workspace_information",
+ kwargs={"type": "page", "person_id": base["person"].id},
+ )
+ if base["person"]
+ else ""
+ ),
"ai_workspace_widget_url": (
(
f"{reverse('ai_workspace_person', kwargs={'type': 'widget', 'person_id': base['person'].id})}"
@@ -2676,6 +2777,9 @@ def _panel_context(
"manual_icon_class": "fa-solid fa-paper-plane",
"panel_id": f"compose-panel-{unique}",
"typing_state_json": json.dumps(typing_state),
+ "availability_enabled": availability_enabled,
+ "availability_slices": availability_slices,
+ "availability_slices_json": json.dumps(availability_slices),
"command_options": command_options,
"bp_binding_summary": bp_binding_summary,
"platform_options": platform_options,
@@ -3133,6 +3237,31 @@ class ComposeThread(LoginRequiredMixin, View):
counterpart_identifiers = _counterpart_identifiers_for_person(
request.user, base["person"]
)
+ availability_slices = []
+ availability_settings = get_availability_settings(request.user)
+ if (
+ base["person"] is not None
+ and availability_settings.enabled
+ and availability_settings.show_in_chat
+ ):
+ range_start = (
+ int(messages[0].ts or 0) if messages else max(0, int(after_ts or 0))
+ )
+ range_end = int(latest_ts or 0)
+ if range_start <= 0 or range_end <= 0:
+ now_ts = int(time.time() * 1000)
+ range_start = now_ts - (24 * 60 * 60 * 1000)
+ range_end = now_ts
+ availability_slices = _serialize_availability_spans(
+ spans_for_range(
+ user=request.user,
+ person=base["person"],
+ start_ts=range_start,
+ end_ts=range_end,
+ service=base["service"],
+ limit=200,
+ )
+ )
payload = {
"messages": _serialize_messages_with_artifacts(
messages,
@@ -3141,6 +3270,7 @@ class ComposeThread(LoginRequiredMixin, View):
seed_previous=seed_previous,
),
"last_ts": latest_ts,
+ "availability_slices": availability_slices,
"typing": get_person_typing_state(
user_id=request.user.id,
person_id=base["person"].id if base["person"] else None,
diff --git a/core/views/signal.py b/core/views/signal.py
index 72aaa0d..6d4d6fc 100644
--- a/core/views/signal.py
+++ b/core/views/signal.py
@@ -12,6 +12,8 @@ from mixins.views import ObjectList, ObjectRead
from core.clients import transport
from core.models import Chat, PersonIdentifier, PlatformChatLink
+from core.presence import get_settings as get_availability_settings
+from core.presence import latest_state_for_people
from core.views.manage.permissions import SuperUserRequiredMixin
@@ -211,6 +213,10 @@ class SignalChatsList(SuperUserRequiredMixin, ObjectList):
def get_queryset(self, *args, **kwargs):
pk = self.kwargs.get("pk", "")
+ availability_settings = get_availability_settings(self.request.user)
+ show_availability = bool(
+ availability_settings.enabled and availability_settings.show_in_groups
+ )
chats = list(
Chat.objects.filter(
Q(account=pk) | Q(account__isnull=True) | Q(account="")
@@ -265,6 +271,9 @@ class SignalChatsList(SuperUserRequiredMixin, ObjectList):
"person_name": (
person_identifier.person.name if person_identifier else ""
),
+ "person_id": (
+ str(person_identifier.person_id) if person_identifier else ""
+ ),
"manual_icon_class": "fa-solid fa-paper-plane",
"can_compose": bool(compose_page_url),
"match_url": (
@@ -300,6 +309,56 @@ class SignalChatsList(SuperUserRequiredMixin, ObjectList):
}
)
+ if show_availability:
+ person_ids = [
+ str(item.get("person_id") or "").strip()
+ for item in rows
+ if str(item.get("person_id") or "").strip()
+ ]
+ person_ids = [pid for pid in person_ids if pid]
+ state_map = latest_state_for_people(
+ user=self.request.user,
+ person_ids=person_ids,
+ service="signal",
+ )
+ for row in rows:
+ pid = str(row.get("person_id") or "").strip()
+ if pid and pid in state_map:
+ state_row = state_map.get(pid) or {}
+ row["availability_state"] = str(state_row.get("state") or "unknown")
+ row["availability_label"] = (
+ f"{str(state_row.get('state') or 'unknown').title()} "
+ f"({float(state_row.get('confidence') or 0.0):.2f})"
+ )
+ signal_person_ids = list(
+ PersonIdentifier.objects.filter(
+ user=self.request.user,
+ service="signal",
+ )
+ .exclude(person_id__isnull=True)
+ .values_list("person_id", flat=True)
+ .distinct()
+ )
+ group_states = latest_state_for_people(
+ user=self.request.user,
+ person_ids=[str(pid) for pid in signal_person_ids if str(pid)],
+ service="signal",
+ )
+ aggregate_counts = {"available": 0, "fading": 0}
+ for state_row in group_states.values():
+ state_text = str((state_row or {}).get("state") or "").strip().lower()
+ if state_text in aggregate_counts:
+ aggregate_counts[state_text] += 1
+ aggregate_label = (
+ f"{aggregate_counts['available']} available ยท {aggregate_counts['fading']} fading"
+ if (aggregate_counts["available"] or aggregate_counts["fading"])
+ else ""
+ )
+ if aggregate_label:
+ for row in rows:
+ if row.get("is_group"):
+ row["availability_label"] = aggregate_label
+
return rows
diff --git a/core/views/tasks.py b/core/views/tasks.py
index 0f27542..292c545 100644
--- a/core/views/tasks.py
+++ b/core/views/tasks.py
@@ -24,8 +24,9 @@ from core.models import (
PersonIdentifier,
PlatformChatLink,
Chat,
+ ExternalChatLink,
)
-from core.tasks.providers.mock import get_provider
+from core.tasks.providers import get_provider
SAFE_TASK_FLAGS_DEFAULTS = {
"derive_enabled": True,
@@ -170,6 +171,13 @@ def _service_label(service: str) -> str:
return labels.get(key, key.title() if key else "Unknown")
+def _provider_row_map(user):
+ return {
+ str(row.provider or "").strip().lower(): row
+ for row in TaskProviderConfig.objects.filter(user=user).order_by("provider")
+ }
+
+
def _resolve_channel_display(user, service: str, identifier: str) -> dict:
service_key = str(service or "").strip().lower()
raw_identifier = str(identifier or "").strip()
@@ -408,12 +416,33 @@ class TaskSettings(LoginRequiredMixin, View):
for row in sources:
row.settings_effective = _flags_with_defaults(row.settings)
row.allowed_prefixes_csv = ",".join(row.settings_effective["allowed_prefixes"])
+ provider_map = _provider_row_map(request.user)
+ codex_cfg = provider_map.get("codex_cli")
+ codex_settings = dict(getattr(codex_cfg, "settings", {}) or {})
+ mock_cfg = provider_map.get("mock")
+ external_chat_links = list(
+ ExternalChatLink.objects.filter(user=request.user).select_related(
+ "person", "person_identifier"
+ ).order_by("-updated_at")[:200]
+ )
+
return {
"projects": projects,
"epics": TaskEpic.objects.filter(project__user=request.user).select_related("project").order_by("project__name", "name"),
"sources": sources,
"patterns": TaskCompletionPattern.objects.filter(user=request.user).order_by("position", "created_at"),
- "provider_configs": TaskProviderConfig.objects.filter(user=request.user).order_by("provider"),
+ "provider_configs": list(provider_map.values()),
+ "mock_provider_config": mock_cfg,
+ "codex_provider_config": codex_cfg,
+ "codex_provider_settings": {
+ "command": str(codex_settings.get("command") or "codex"),
+ "workspace_root": str(codex_settings.get("workspace_root") or ""),
+ "default_profile": str(codex_settings.get("default_profile") or ""),
+ "timeout_seconds": int(codex_settings.get("timeout_seconds") or 60),
+ "chat_link_mode": str(codex_settings.get("chat_link_mode") or "task-sync"),
+ },
+ "person_identifiers": PersonIdentifier.objects.filter(user=request.user).select_related("person").order_by("person__name", "service", "identifier")[:600],
+ "external_chat_links": external_chat_links,
"sync_events": ExternalSyncEvent.objects.filter(user=request.user).order_by("-updated_at")[:100],
"prefill_service": prefill_service,
"prefill_identifier": prefill_identifier,
@@ -537,18 +566,81 @@ class TaskSettings(LoginRequiredMixin, View):
defaults={"enabled": False, "settings": {}},
)
row.enabled = bool(request.POST.get("enabled"))
- row.save(update_fields=["enabled", "updated_at"])
+ settings_payload = dict(row.settings or {})
+ if provider == "codex_cli":
+ timeout_raw = str(request.POST.get("timeout_seconds") or "60").strip()
+ try:
+ timeout_value = max(1, int(timeout_raw))
+ except Exception:
+ timeout_value = 60
+ settings_payload = {
+ "command": str(request.POST.get("command") or "codex").strip() or "codex",
+ "workspace_root": str(request.POST.get("workspace_root") or "").strip(),
+ "default_profile": str(request.POST.get("default_profile") or "").strip(),
+ "timeout_seconds": timeout_value,
+ "chat_link_mode": "task-sync",
+ }
+ row.settings = settings_payload
+ row.save(update_fields=["enabled", "settings", "updated_at"])
+ return _settings_redirect(request)
+
+ if action == "external_chat_link_upsert":
+ provider = str(request.POST.get("provider") or "codex_cli").strip().lower() or "codex_cli"
+ external_chat_id = str(request.POST.get("external_chat_id") or "").strip()
+ person_identifier_id = str(request.POST.get("person_identifier_id") or "").strip()
+ if not external_chat_id:
+ messages.error(request, "External chat ID is required.")
+ return _settings_redirect(request)
+ identifier = None
+ if person_identifier_id:
+ identifier = get_object_or_404(
+ PersonIdentifier,
+ user=request.user,
+ id=person_identifier_id,
+ )
+ row, _ = ExternalChatLink.objects.update_or_create(
+ user=request.user,
+ provider=provider,
+ external_chat_id=external_chat_id,
+ defaults={
+ "person": getattr(identifier, "person", None),
+ "person_identifier": identifier,
+ "enabled": bool(request.POST.get("enabled")),
+ "metadata": {
+ "chat_link_mode": "task-sync",
+ "notes": str(request.POST.get("metadata_notes") or "").strip(),
+ },
+ },
+ )
+ if identifier and row.person_id != identifier.person_id:
+ row.person = identifier.person
+ row.save(update_fields=["person", "updated_at"])
+ return _settings_redirect(request)
+
+ if action == "external_chat_link_delete":
+ row = get_object_or_404(
+ ExternalChatLink,
+ id=request.POST.get("external_link_id"),
+ user=request.user,
+ )
+ row.delete()
return _settings_redirect(request)
if action == "sync_retry":
event = get_object_or_404(ExternalSyncEvent, id=request.POST.get("event_id"), user=request.user)
provider = get_provider(event.provider)
- payload = dict(event.payload or {})
- result = provider.append_update({}, payload)
- event.status = "ok" if result.ok else "failed"
- event.error = str(result.error or "")
- event.payload = dict(payload, retried=True)
- event.save(update_fields=["status", "error", "payload", "updated_at"])
+ if bool(getattr(provider, "run_in_worker", False)):
+ event.status = "pending"
+ event.error = ""
+ event.payload = dict(event.payload or {}, retried=True)
+ event.save(update_fields=["status", "error", "payload", "updated_at"])
+ else:
+ payload = dict(event.payload or {})
+ result = provider.append_update({}, payload)
+ event.status = "ok" if result.ok else "failed"
+ event.error = str(result.error or "")
+ event.payload = dict(payload, retried=True)
+ event.save(update_fields=["status", "error", "payload", "updated_at"])
return _settings_redirect(request)
return _settings_redirect(request)
diff --git a/core/views/whatsapp.py b/core/views/whatsapp.py
index 8a0984e..e23192d 100644
--- a/core/views/whatsapp.py
+++ b/core/views/whatsapp.py
@@ -8,6 +8,8 @@ from mixins.views import ObjectList, ObjectRead
from core.clients import transport
from core.models import PersonIdentifier, PlatformChatLink
+from core.presence import get_settings as get_availability_settings
+from core.presence import latest_state_for_people
from core.util import logs
from core.views.compose import _compose_urls, _service_icon_class
from core.views.manage.permissions import SuperUserRequiredMixin
@@ -265,6 +267,10 @@ class WhatsAppChatsList(WhatsAppContactsList):
def get_queryset(self, *args, **kwargs):
rows = []
seen = set()
+ availability_settings = get_availability_settings(self.request.user)
+ show_availability = bool(
+ availability_settings.enabled and availability_settings.show_in_groups
+ )
state = transport.get_runtime_state("whatsapp")
runtime_contacts = state.get("contacts") or []
@@ -414,7 +420,36 @@ class WhatsAppChatsList(WhatsAppContactsList):
if not row.get("is_group") and row.get("identifier") in db_group_ids:
row["is_group"] = True
- return [row for row in rows if row.get("is_group")]
+ group_rows = [row for row in rows if row.get("is_group")]
+ if show_availability and group_rows:
+ whatsapp_person_ids = list(
+ PersonIdentifier.objects.filter(
+ user=self.request.user,
+ service="whatsapp",
+ )
+ .exclude(person_id__isnull=True)
+ .values_list("person_id", flat=True)
+ .distinct()
+ )
+ state_map = latest_state_for_people(
+ user=self.request.user,
+ person_ids=[str(pid) for pid in whatsapp_person_ids if str(pid)],
+ service="whatsapp",
+ )
+ counts = {"available": 0, "fading": 0}
+ for value in state_map.values():
+ state_text = str((value or {}).get("state") or "").strip().lower()
+ if state_text in counts:
+ counts[state_text] += 1
+ aggregate = (
+ f"{counts['available']} available ยท {counts['fading']} fading"
+ if (counts["available"] or counts["fading"])
+ else ""
+ )
+ if aggregate:
+ for row in group_rows:
+ row["availability_label"] = aggregate
+ return group_rows
class WhatsAppAccountAdd(SuperUserRequiredMixin, ObjectRead):
diff --git a/scripts/quadlet/manage.sh b/scripts/quadlet/manage.sh
index 25b389f..5bd9128 100755
--- a/scripts/quadlet/manage.sh
+++ b/scripts/quadlet/manage.sh
@@ -3,21 +3,39 @@ set -euo pipefail
ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
STACK_ENV="${STACK_ENV:-$ROOT_DIR/stack.env}"
-POD_NAME="gia"
-REDIS_CONTAINER="redis_gia"
-SIGNAL_CONTAINER="signal"
-MIGRATION_CONTAINER="migration_gia"
-COLLECTSTATIC_CONTAINER="collectstatic_gia"
-APP_CONTAINER="gia"
-ASGI_CONTAINER="asgi_gia"
-UR_CONTAINER="ur_gia"
-SCHED_CONTAINER="scheduling_gia"
+STACK_ID="${GIA_STACK_ID:-${STACK_ID:-}}"
+STACK_ID="$(echo "$STACK_ID" | tr -cs 'a-zA-Z0-9._-' '-' | sed 's/^-*//; s/-*$//')"
+
+name_with_stack() {
+ local base="$1"
+ if [[ -n "$STACK_ID" ]]; then
+ echo "${base}_${STACK_ID}"
+ else
+ echo "$base"
+ fi
+}
+
+POD_NAME="$(name_with_stack "gia")"
+
+REDIS_CONTAINER="$(name_with_stack "redis_gia")"
+SIGNAL_CONTAINER="$(name_with_stack "signal")"
+MIGRATION_CONTAINER="$(name_with_stack "migration_gia")"
+COLLECTSTATIC_CONTAINER="$(name_with_stack "collectstatic_gia")"
+APP_CONTAINER="$(name_with_stack "gia")"
+ASGI_CONTAINER="$(name_with_stack "asgi_gia")"
+UR_CONTAINER="$(name_with_stack "ur_gia")"
+SCHED_CONTAINER="$(name_with_stack "scheduling_gia")"
+CODEX_WORKER_CONTAINER="$(name_with_stack "codex_worker_gia")"
REDIS_DATA_DIR="${QUADLET_REDIS_DATA_DIR:-$ROOT_DIR/.podman/gia_redis_data}"
WHATSAPP_DATA_DIR="${QUADLET_WHATSAPP_DATA_DIR:-$ROOT_DIR/.podman/gia_whatsapp_data}"
SQLITE_DATA_DIR="${QUADLET_SQLITE_DATA_DIR:-$ROOT_DIR/.podman/gia_sqlite_data}"
-VRUN_DIR="/code/vrun"
+if [[ -n "${STACK_ID}" ]]; then
+ VRUN_DIR="/code/vrun/${STACK_ID}"
+else
+ VRUN_DIR="/code/vrun"
+fi
load_env() {
set -a
@@ -134,6 +152,7 @@ down_stack() {
rm_if_exists "$ASGI_CONTAINER"
rm_if_exists "$UR_CONTAINER"
rm_if_exists "$SCHED_CONTAINER"
+ rm_if_exists "$CODEX_WORKER_CONTAINER"
}
start_stack() {
@@ -153,7 +172,15 @@ start_stack() {
chmod 0666 "$HOST_DATABASE_FILE" 2>/dev/null || true
down_stack
- podman pod create --name "$POD_NAME" -p "${APP_PORT:-5006}:8000" -p "8080:8080" >/dev/null
+ local port_offset="${GIA_STACK_PORT_OFFSET:-}"
+ if [[ -z "$port_offset" && -n "$STACK_ID" ]]; then
+ port_offset="$(( $(printf '%s' "$STACK_ID" | cksum | awk '{print $1}') % 500 + 1 ))"
+ fi
+ port_offset="${port_offset:-0}"
+ local app_port="${APP_PORT:-$((5006 + port_offset))}"
+ local signal_port="${SIGNAL_PUBLIC_PORT:-$((8080 + port_offset))}"
+
+ podman pod create --name "$POD_NAME" -p "${app_port}:8000" -p "${signal_port}:8080" >/dev/null
podman run -d \
--replace \
@@ -182,6 +209,7 @@ start_stack() {
run_worker_container "$ASGI_CONTAINER" "rm -f /var/run/asgi-gia.sock && . /venv/bin/activate && python -m pip install --disable-pip-version-check -q uvicorn && python -m uvicorn app.asgi:application --uds /var/run/asgi-gia.sock --workers 1" 0 1
run_worker_container "$UR_CONTAINER" ". /venv/bin/activate && python manage.py ur" 1 1
run_worker_container "$SCHED_CONTAINER" ". /venv/bin/activate && python manage.py scheduling" 1 0
+ run_worker_container "$CODEX_WORKER_CONTAINER" ". /venv/bin/activate && python manage.py codex_worker" 1 0
}
render_units() {
@@ -211,18 +239,23 @@ case "${1:-}" in
status)
require_podman
podman pod ps --format "table {{.Name}}\t{{.Status}}" | grep -E "^$POD_NAME\b" || true
- podman ps --format "table {{.Names}}\t{{.Status}}" | grep -E "^($APP_CONTAINER|$ASGI_CONTAINER|$UR_CONTAINER|$SCHED_CONTAINER|$REDIS_CONTAINER|$SIGNAL_CONTAINER)\b" || true
+ podman ps --format "table {{.Names}}\t{{.Status}}" | grep -E "^($APP_CONTAINER|$ASGI_CONTAINER|$UR_CONTAINER|$SCHED_CONTAINER|$CODEX_WORKER_CONTAINER|$REDIS_CONTAINER|$SIGNAL_CONTAINER)\b" || true
;;
logs)
require_podman
if is_remote; then
podman logs -f "$APP_CONTAINER"
else
- podman logs -f "$APP_CONTAINER" "$ASGI_CONTAINER" "$UR_CONTAINER" "$SCHED_CONTAINER" "$REDIS_CONTAINER" "$SIGNAL_CONTAINER"
+ podman logs -f "$APP_CONTAINER" "$ASGI_CONTAINER" "$UR_CONTAINER" "$SCHED_CONTAINER" "$CODEX_WORKER_CONTAINER" "$REDIS_CONTAINER" "$SIGNAL_CONTAINER"
fi
;;
+ watch)
+ require_podman
+ load_env
+ exec "$ROOT_DIR/scripts/quadlet/watchdog.sh"
+ ;;
*)
- echo "Usage: $0 {install|up|down|restart|status|logs}" >&2
+ echo "Usage: $0 {install|up|down|restart|status|logs|watch}" >&2
exit 2
;;
esac
diff --git a/scripts/quadlet/render_units.py b/scripts/quadlet/render_units.py
index 0dc04cc..09f1ee3 100755
--- a/scripts/quadlet/render_units.py
+++ b/scripts/quadlet/render_units.py
@@ -45,6 +45,27 @@ def main() -> int:
repo_root = Path(__file__).resolve().parents[2]
stack_env_path = abs_from(repo_root, args.stack_env, "stack.env")
env = parse_env(stack_env_path)
+ stack_id = str(env.get("GIA_STACK_ID") or env.get("STACK_ID") or "").strip()
+ stack_id = "".join(ch if (ch.isalnum() or ch in "._-") else "-" for ch in stack_id).strip("-")
+
+ def with_stack(base: str) -> str:
+ return f"{base}_{stack_id}" if stack_id else base
+
+ unit_prefix = f"gia-{stack_id}" if stack_id else "gia"
+ pod_ref = f"{unit_prefix}.pod"
+ target_ref = f"{unit_prefix}.target"
+ stack_offset_raw = str(env.get("GIA_STACK_PORT_OFFSET") or "").strip()
+ if stack_offset_raw:
+ try:
+ stack_port_offset = max(0, int(stack_offset_raw))
+ except Exception:
+ stack_port_offset = 0
+ elif stack_id:
+ stack_port_offset = (sum(ord(ch) for ch in stack_id) % 500) + 1
+ else:
+ stack_port_offset = 0
+ app_port = int(env.get("APP_PORT") or (5006 + stack_port_offset))
+ signal_public_port = int(env.get("SIGNAL_PUBLIC_PORT") or (8080 + stack_port_offset))
repo_dir = abs_from(repo_root, env.get("REPO_DIR", "."), ".")
host_uid = int(os.getuid())
@@ -62,7 +83,7 @@ def main() -> int:
redis_data_dir = abs_from(repo_root, env.get("QUADLET_REDIS_DATA_DIR", "./.podman/gia_redis_data"), "./.podman/gia_redis_data")
whatsapp_data_dir = abs_from(repo_root, env.get("QUADLET_WHATSAPP_DATA_DIR", "./.podman/gia_whatsapp_data"), "./.podman/gia_whatsapp_data")
- vrun_dir = Path("/code/vrun")
+ vrun_dir = Path("/code/vrun") / stack_id if stack_id else Path("/code/vrun")
signal_cli_dir = (repo_dir / "signal-cli-config").resolve()
uwsgi_ini = (repo_dir / "docker" / "uwsgi.ini").resolve()
redis_conf = (repo_dir / "docker" / "redis.conf").resolve()
@@ -80,22 +101,24 @@ def main() -> int:
env_file = stack_env_path
- pod_unit = """
+ pod_unit = f"""
[Unit]
Description=GIA Pod
[Pod]
-PodName=gia
+PodName={with_stack('gia')}
+PublishPort={app_port}:8000
+PublishPort={signal_public_port}:8080
[Install]
WantedBy=default.target
"""
- target_unit = """
+ target_unit = f"""
[Unit]
Description=GIA Stack Target
-Wants=gia-redis.service gia-signal.service gia-migration.service gia-collectstatic.service gia-app.service gia-asgi.service gia-ur.service gia-scheduling.service
-After=gia-redis.service gia-signal.service gia-migration.service gia-collectstatic.service
+Wants={unit_prefix}-redis.service {unit_prefix}-signal.service {unit_prefix}-migration.service {unit_prefix}-collectstatic.service {unit_prefix}-app.service {unit_prefix}-asgi.service {unit_prefix}-ur.service {unit_prefix}-scheduling.service {unit_prefix}-codex-worker.service
+After={unit_prefix}-redis.service {unit_prefix}-signal.service {unit_prefix}-migration.service {unit_prefix}-collectstatic.service
[Install]
WantedBy=default.target
@@ -104,14 +127,14 @@ WantedBy=default.target
redis_unit = f"""
[Unit]
Description=GIA Redis
-PartOf=gia.target
+PartOf={target_ref}
After=network-online.target
Wants=network-online.target
[Container]
Image=docker.io/library/redis:latest
-ContainerName=redis_gia
-Pod=gia.pod
+ContainerName={with_stack('redis_gia')}
+Pod={pod_ref}
Volume={redis_conf}:/etc/redis.conf:ro
Volume={redis_data_dir}:/data
Volume={vrun_dir}:/var/run
@@ -122,20 +145,20 @@ Restart=always
RestartSec=2
[Install]
-WantedBy=gia.target
+WantedBy={target_ref}
"""
signal_unit = f"""
[Unit]
Description=GIA Signal API
-PartOf=gia.target
+PartOf={target_ref}
After=network-online.target
Wants=network-online.target
[Container]
Image=docker.io/bbernhard/signal-cli-rest-api:latest
-ContainerName=signal
-Pod=gia.pod
+ContainerName={with_stack('signal')}
+Pod={pod_ref}
Volume={signal_cli_dir}:/home/.local/share/signal-cli
Environment=MODE=json-rpc
@@ -144,21 +167,21 @@ Restart=always
RestartSec=2
[Install]
-WantedBy=gia.target
+WantedBy={target_ref}
"""
def gia_container(name: str, container_name: str, command: str, include_uwsgi: bool, include_whatsapp: bool, after: str, requires: str, one_shot: bool = False) -> str:
lines = [
"[Unit]",
f"Description={name}",
- "PartOf=gia.target",
+ f"PartOf={target_ref}",
f"After={after}",
f"Requires={requires}",
"",
"[Container]",
"Image=localhost/xf/gia:prod",
f"ContainerName={container_name}",
- "Pod=gia.pod",
+ f"Pod={pod_ref}",
f"User={host_uid}:{host_gid}",
f"EnvironmentFile={env_file}",
"Environment=SIGNAL_HTTP_URL=http://127.0.0.1:8080",
@@ -178,7 +201,7 @@ WantedBy=gia.target
"Type=oneshot",
"RemainAfterExit=yes",
"TimeoutStartSec=0",
- "ExecStartPre=/bin/sh -c 'for i in $(seq 1 60); do [ -S /code/vrun/gia-redis.sock ] && exit 0; sleep 1; done; exit 1'",
+ f"ExecStartPre=/bin/sh -c 'for i in $(seq 1 60); do [ -S {vrun_dir}/gia-redis.sock ] && exit 0; sleep 1; done; exit 1'",
])
else:
lines.extend([
@@ -186,80 +209,92 @@ WantedBy=gia.target
"RestartSec=2",
])
lines.extend(["", "[Install]", "WantedBy=gia.target"])
+ lines[-1] = f"WantedBy={target_ref}"
return "\n".join(lines)
migration_unit = gia_container(
"GIA Migration",
- "migration_gia",
+ with_stack("migration_gia"),
"sh -c '. /venv/bin/activate && python manage.py migrate --noinput'",
include_uwsgi=False,
include_whatsapp=False,
- after="gia-redis.service gia-signal.service",
- requires="gia-redis.service gia-signal.service",
+ after=f"{unit_prefix}-redis.service {unit_prefix}-signal.service",
+ requires=f"{unit_prefix}-redis.service {unit_prefix}-signal.service",
one_shot=True,
)
collectstatic_unit = gia_container(
"GIA Collectstatic",
- "collectstatic_gia",
+ with_stack("collectstatic_gia"),
"sh -c '. /venv/bin/activate && python manage.py collectstatic --noinput'",
include_uwsgi=False,
include_whatsapp=False,
- after="gia-migration.service",
- requires="gia-migration.service",
+ after=f"{unit_prefix}-migration.service",
+ requires=f"{unit_prefix}-migration.service",
one_shot=True,
)
app_unit = gia_container(
"GIA App",
- "gia",
+ with_stack("gia"),
"sh -c 'if [ \\\"$OPERATION\\\" = \\\"uwsgi\\\" ] ; then . /venv/bin/activate && uwsgi --ini /conf/uwsgi.ini ; else . /venv/bin/activate && exec python manage.py runserver 0.0.0.0:8000; fi'",
include_uwsgi=True,
include_whatsapp=True,
- after="gia-collectstatic.service gia-redis.service gia-signal.service",
- requires="gia-collectstatic.service gia-redis.service gia-signal.service",
+ after=f"{unit_prefix}-collectstatic.service {unit_prefix}-redis.service {unit_prefix}-signal.service",
+ requires=f"{unit_prefix}-collectstatic.service {unit_prefix}-redis.service {unit_prefix}-signal.service",
)
asgi_unit = gia_container(
"GIA ASGI",
- "asgi_gia",
+ with_stack("asgi_gia"),
"sh -c 'rm -f /var/run/asgi-gia.sock && . /venv/bin/activate && python -m pip install --disable-pip-version-check -q uvicorn && python -m uvicorn app.asgi:application --uds /var/run/asgi-gia.sock --workers 1'",
include_uwsgi=False,
include_whatsapp=True,
- after="gia-collectstatic.service gia-redis.service gia-signal.service",
- requires="gia-collectstatic.service gia-redis.service gia-signal.service",
+ after=f"{unit_prefix}-collectstatic.service {unit_prefix}-redis.service {unit_prefix}-signal.service",
+ requires=f"{unit_prefix}-collectstatic.service {unit_prefix}-redis.service {unit_prefix}-signal.service",
)
ur_unit = gia_container(
"GIA Unified Router",
- "ur_gia",
+ with_stack("ur_gia"),
"sh -c '. /venv/bin/activate && python manage.py ur'",
include_uwsgi=True,
include_whatsapp=True,
- after="gia-collectstatic.service gia-redis.service gia-signal.service",
- requires="gia-collectstatic.service gia-redis.service gia-signal.service",
+ after=f"{unit_prefix}-collectstatic.service {unit_prefix}-redis.service {unit_prefix}-signal.service",
+ requires=f"{unit_prefix}-collectstatic.service {unit_prefix}-redis.service {unit_prefix}-signal.service",
)
scheduling_unit = gia_container(
"GIA Scheduling",
- "scheduling_gia",
+ with_stack("scheduling_gia"),
"sh -c '. /venv/bin/activate && python manage.py scheduling'",
include_uwsgi=True,
include_whatsapp=False,
- after="gia-collectstatic.service gia-redis.service gia-signal.service",
- requires="gia-collectstatic.service gia-redis.service gia-signal.service",
+ after=f"{unit_prefix}-collectstatic.service {unit_prefix}-redis.service {unit_prefix}-signal.service",
+ requires=f"{unit_prefix}-collectstatic.service {unit_prefix}-redis.service {unit_prefix}-signal.service",
)
- write_unit(out_dir / "gia.pod", pod_unit)
- write_unit(out_dir / "gia.target", target_unit)
- write_unit(out_dir / "gia-redis.container", redis_unit)
- write_unit(out_dir / "gia-signal.container", signal_unit)
- write_unit(out_dir / "gia-migration.container", migration_unit)
- write_unit(out_dir / "gia-collectstatic.container", collectstatic_unit)
- write_unit(out_dir / "gia-app.container", app_unit)
- write_unit(out_dir / "gia-asgi.container", asgi_unit)
- write_unit(out_dir / "gia-ur.container", ur_unit)
- write_unit(out_dir / "gia-scheduling.container", scheduling_unit)
+ codex_worker_unit = gia_container(
+ "GIA Codex Worker",
+ with_stack("codex_worker_gia"),
+ "sh -c '. /venv/bin/activate && python manage.py codex_worker'",
+ include_uwsgi=True,
+ include_whatsapp=False,
+ after=f"{unit_prefix}-collectstatic.service {unit_prefix}-redis.service {unit_prefix}-signal.service",
+ requires=f"{unit_prefix}-collectstatic.service {unit_prefix}-redis.service {unit_prefix}-signal.service",
+ )
+
+ write_unit(out_dir / f"{unit_prefix}.pod", pod_unit)
+ write_unit(out_dir / f"{unit_prefix}.target", target_unit)
+ write_unit(out_dir / f"{unit_prefix}-redis.container", redis_unit)
+ write_unit(out_dir / f"{unit_prefix}-signal.container", signal_unit)
+ write_unit(out_dir / f"{unit_prefix}-migration.container", migration_unit)
+ write_unit(out_dir / f"{unit_prefix}-collectstatic.container", collectstatic_unit)
+ write_unit(out_dir / f"{unit_prefix}-app.container", app_unit)
+ write_unit(out_dir / f"{unit_prefix}-asgi.container", asgi_unit)
+ write_unit(out_dir / f"{unit_prefix}-ur.container", ur_unit)
+ write_unit(out_dir / f"{unit_prefix}-scheduling.container", scheduling_unit)
+ write_unit(out_dir / f"{unit_prefix}-codex-worker.container", codex_worker_unit)
print(f"Wrote Quadlet units to: {out_dir}")
return 0
diff --git a/scripts/quadlet/watchdog.sh b/scripts/quadlet/watchdog.sh
new file mode 100755
index 0000000..852ce01
--- /dev/null
+++ b/scripts/quadlet/watchdog.sh
@@ -0,0 +1,82 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+STACK_ENV="${STACK_ENV:-$ROOT_DIR/stack.env}"
+STACK_ID="${GIA_STACK_ID:-${STACK_ID:-}}"
+STACK_ID="$(echo "$STACK_ID" | tr -cs 'a-zA-Z0-9._-' '-' | sed 's/^-*//; s/-*$//')"
+SLEEP_SECONDS="${WATCHDOG_SLEEP_SECONDS:-15}"
+NTFY_TOPIC="${NTFY_TOPIC:-${NOTIFY_TOPIC:-}}"
+NTFY_URL_BASE="${NTFY_URL_BASE:-https://ntfy.sh}"
+HOST_TAG="${HOSTNAME:-$(hostname 2>/dev/null || echo unknown-host)}"
+
+if [[ -f "$STACK_ENV" ]]; then
+ set -a
+ . "$STACK_ENV"
+ set +a
+fi
+
+name_with_stack() {
+ local base="$1"
+ if [[ -n "$STACK_ID" ]]; then
+ echo "${base}_${STACK_ID}"
+ else
+ echo "$base"
+ fi
+}
+
+notify() {
+ local title="$1"
+ local msg="$2"
+ if [[ -z "$NTFY_TOPIC" ]]; then
+ return 0
+ fi
+ if ! command -v curl >/dev/null 2>&1; then
+ return 0
+ fi
+ curl -sS -X POST "${NTFY_URL_BASE%/}/$NTFY_TOPIC" \
+ -H "Title: $title" \
+ -H "Tags: warning" \
+ -d "$msg" >/dev/null || true
+}
+
+CONTAINERS=(
+ "$(name_with_stack "gia")"
+ "$(name_with_stack "asgi_gia")"
+ "$(name_with_stack "ur_gia")"
+ "$(name_with_stack "scheduling_gia")"
+ "$(name_with_stack "codex_worker_gia")"
+)
+
+declare -A LAST_STATE
+for name in "${CONTAINERS[@]}"; do
+ LAST_STATE["$name"]="unknown"
+done
+
+while true; do
+ for name in "${CONTAINERS[@]}"; do
+ running="false"
+ if inspect_out="$(podman inspect -f '{{.State.Running}}' "$name" 2>/dev/null)"; then
+ running="$(echo "$inspect_out" | tr -d '\n' | tr 'A-Z' 'a-z')"
+ fi
+
+ if [[ "$running" == "true" ]]; then
+ if [[ "${LAST_STATE[$name]}" != "up" ]]; then
+ notify "GIA recovered: $name" "[$HOST_TAG] container $name is now running"
+ fi
+ LAST_STATE["$name"]="up"
+ continue
+ fi
+
+ restart_out=""
+ if restart_out="$(podman restart "$name" 2>&1)"; then
+ LAST_STATE["$name"]="recovering"
+ notify "GIA restarted: $name" "[$HOST_TAG] container $name was not running and restart succeeded"
+ else
+ LAST_STATE["$name"]="down"
+ notify "GIA restart failed: $name" "[$HOST_TAG] restart failed for $name: $restart_out"
+ fi
+ done
+
+ sleep "$SLEEP_SECONDS"
+done
diff --git a/stack.env.example b/stack.env.example
index b91d1ad..2eaabd5 100644
--- a/stack.env.example
+++ b/stack.env.example
@@ -1,4 +1,9 @@
APP_PORT=5006
+# Optional stack suffix for running a second isolated dev instance.
+# Example: GIA_STACK_ID=selfdev
+GIA_STACK_ID=
+# Optional deterministic port offset when STACK_ID is set.
+GIA_STACK_PORT_OFFSET=
REPO_DIR=.
APP_LOCAL_SETTINGS=./app/local_settings.py
APP_DATABASE_FILE=./db.sqlite3
@@ -6,6 +11,9 @@ DOMAIN=example.com
URL=https://example.com
ALLOWED_HOSTS=example.com
NOTIFY_TOPIC=example-topic
+# Optional explicit ntfy topic/url for scripts/quadlet/watchdog.sh
+NTFY_TOPIC=
+NTFY_URL_BASE=https://ntfy.sh
CSRF_TRUSTED_ORIGINS=https://example.com
DEBUG=y
SECRET_KEY=
@@ -13,4 +21,4 @@ STATIC_ROOT=/code/static
REGISTRATION_OPEN=0
OPERATION=uwsgi
BILLING_ENABLED=0
-COMPOSE_WS_ENABLED=true
\ No newline at end of file
+COMPOSE_WS_ENABLED=true