Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
fix(agent-preview): support previews across service replicas (#8495)
Wolf Mermelsteinea13c8f3f6f9
diff --git a/.github/workspace-dep-closures.json b/.github/workspace-dep-closures.jsonindex 4efb3fd181..8c895aab8a 100644--- a/.github/workspace-dep-closures.json+++ b/.github/workspace-dep-closures.json@@ -973,6 +973,7 @@"crates/macro_entrypoint","crates/macro_env","crates/macro_env_var",+ "crates/macro_tower_layers","crates/macro_user_id","crates/macro_uuid","crates/model",diff --git a/.sqlx/query-04455fae546abd5184249c59a61c1ad2be4d560a4adac4a0d004132f44b18f88.json b/.sqlx/query-04455fae546abd5184249c59a61c1ad2be4d560a4adac4a0d004132f44b18f88.jsonnew file mode 100644index 0000000000..5b9a54120e--- /dev/null+++ b/.sqlx/query-04455fae546abd5184249c59a61c1ad2be4d560a4adac4a0d004132f44b18f88.json@@ -0,0 +1,12 @@+{+ "db_name": "PostgreSQL",+ "query": "DELETE FROM agent_preview_watcher WHERE expires_at <= now()",+ "describe": {+ "columns": [],+ "parameters": {+ "Left": []+ },+ "nullable": []+ },+ "hash": "04455fae546abd5184249c59a61c1ad2be4d560a4adac4a0d004132f44b18f88"+}diff --git a/.sqlx/query-1354719a3c39cdaedf46de1b04c4954320b6c856cf276cf3c59abb8729070758.json b/.sqlx/query-1354719a3c39cdaedf46de1b04c4954320b6c856cf276cf3c59abb8729070758.jsonnew file mode 100644index 0000000000..d54098e239--- /dev/null+++ b/.sqlx/query-1354719a3c39cdaedf46de1b04c4954320b6c856cf276cf3c59abb8729070758.json@@ -0,0 +1,12 @@+{+ "db_name": "PostgreSQL",+ "query": "LOCK TABLE agent_preview_lease IN EXCLUSIVE MODE",+ "describe": {+ "columns": [],+ "parameters": {+ "Left": []+ },+ "nullable": []+ },+ "hash": "1354719a3c39cdaedf46de1b04c4954320b6c856cf276cf3c59abb8729070758"+}diff --git a/.sqlx/query-26de51a747278c0bac75b1669aa597edc3af2d53d2db232d70bc2b8576394973.json b/.sqlx/query-26de51a747278c0bac75b1669aa597edc3af2d53d2db232d70bc2b8576394973.jsonnew file mode 100644index 0000000000..17c15e925b--- /dev/null+++ b/.sqlx/query-26de51a747278c0bac75b1669aa597edc3af2d53d2db232d70bc2b8576394973.json@@ -0,0 +1,22 @@+{+ "db_name": "PostgreSQL",+ "query": "SELECT EXISTS (SELECT 1 FROM agent_preview_lease l\n WHERE id = $1 AND status = 'ready' AND expires_at > now()\n AND EXISTS (SELECT 1 FROM agent_preview_replica r WHERE r.id = l.replica_id AND r.expires_at > now())) AS \"live!\"",+ "describe": {+ "columns": [+ {+ "ordinal": 0,+ "name": "live!",+ "type_info": "Bool"+ }+ ],+ "parameters": {+ "Left": [+ "Text"+ ]+ },+ "nullable": [+ null+ ]+ },+ "hash": "26de51a747278c0bac75b1669aa597edc3af2d53d2db232d70bc2b8576394973"+}diff --git a/.sqlx/query-330200ce25837c9a74230207af4b829b4a19cc5b3788eb7fd536f7614cde9527.json b/.sqlx/query-330200ce25837c9a74230207af4b829b4a19cc5b3788eb7fd536f7614cde9527.jsonnew file mode 100644index 0000000000..36022af65a--- /dev/null+++ b/.sqlx/query-330200ce25837c9a74230207af4b829b4a19cc5b3788eb7fd536f7614cde9527.json@@ -0,0 +1,12 @@+{+ "db_name": "PostgreSQL",+ "query": "DELETE FROM agent_preview_lease WHERE expires_at < now() - interval '5 minutes'",+ "describe": {+ "columns": [],+ "parameters": {+ "Left": []+ },+ "nullable": []+ },+ "hash": "330200ce25837c9a74230207af4b829b4a19cc5b3788eb7fd536f7614cde9527"+}diff --git a/.sqlx/query-3701f586813bcc27accbf5ca99b7419c90d8dd2dd1f7321521dc8103ba0f1291.json b/.sqlx/query-3701f586813bcc27accbf5ca99b7419c90d8dd2dd1f7321521dc8103ba0f1291.jsonnew file mode 100644index 0000000000..e1deabf361--- /dev/null+++ b/.sqlx/query-3701f586813bcc27accbf5ca99b7419c90d8dd2dd1f7321521dc8103ba0f1291.json@@ -0,0 +1,34 @@+{+ "db_name": "PostgreSQL",+ "query": "SELECT metadata AS \"metadata: Json<StoredPreview>\", replica_id,\n CASE WHEN l.expires_at <= now() THEN 'expired'\n WHEN l.replica_id IS NOT NULL AND NOT EXISTS\n (SELECT 1 FROM agent_preview_replica r WHERE r.id = l.replica_id AND r.expires_at > now()) AND l.status IN ('starting','ready')\n THEN 'offline' ELSE status END AS \"state!\"\n FROM agent_preview_lease l WHERE session_id = $1",+ "describe": {+ "columns": [+ {+ "ordinal": 0,+ "name": "metadata: Json<StoredPreview>",+ "type_info": "Jsonb"+ },+ {+ "ordinal": 1,+ "name": "replica_id",+ "type_info": "Uuid"+ },+ {+ "ordinal": 2,+ "name": "state!",+ "type_info": "Text"+ }+ ],+ "parameters": {+ "Left": [+ "Uuid"+ ]+ },+ "nullable": [+ false,+ true,+ null+ ]+ },+ "hash": "3701f586813bcc27accbf5ca99b7419c90d8dd2dd1f7321521dc8103ba0f1291"+}diff --git a/.sqlx/query-3db7b8992c3757a0690e4884f9dccfe6d8f872ef62527dc67c71d66bae3eebff.json b/.sqlx/query-3db7b8992c3757a0690e4884f9dccfe6d8f872ef62527dc67c71d66bae3eebff.jsonnew file mode 100644index 0000000000..13418b949a--- /dev/null+++ b/.sqlx/query-3db7b8992c3757a0690e4884f9dccfe6d8f872ef62527dc67c71d66bae3eebff.json@@ -0,0 +1,30 @@+{+ "db_name": "PostgreSQL",+ "query": "DELETE FROM agent_preview_credential WHERE hash = $1 AND preview_id = $2 AND kind = $3 AND expires_at > now() RETURNING user_id, expires_at",+ "describe": {+ "columns": [+ {+ "ordinal": 0,+ "name": "user_id",+ "type_info": "Text"+ },+ {+ "ordinal": 1,+ "name": "expires_at",+ "type_info": "Timestamptz"+ }+ ],+ "parameters": {+ "Left": [+ "Bytea",+ "Text",+ "Text"+ ]+ },+ "nullable": [+ true,+ false+ ]+ },+ "hash": "3db7b8992c3757a0690e4884f9dccfe6d8f872ef62527dc67c71d66bae3eebff"+}diff --git a/.sqlx/query-431c961c9b5d8bef01d07294009b7e914258456b62e0b5eddc6207c09968f82a.json b/.sqlx/query-431c961c9b5d8bef01d07294009b7e914258456b62e0b5eddc6207c09968f82a.jsonnew file mode 100644index 0000000000..2a1fcbbdd1--- /dev/null+++ b/.sqlx/query-431c961c9b5d8bef01d07294009b7e914258456b62e0b5eddc6207c09968f82a.json@@ -0,0 +1,32 @@+{+ "db_name": "PostgreSQL",+ "query": "UPDATE agent_preview_lease l SET status = CASE WHEN l.expires_at <= now() THEN 'expired' ELSE 'offline' END WHERE status IN ('starting','ready') AND (l.expires_at <= now() OR (replica_id IS NOT NULL AND NOT EXISTS (SELECT 1 FROM agent_preview_replica r WHERE r.id = l.replica_id AND r.expires_at > now()))) RETURNING metadata AS \"metadata: Json<StoredPreview>\", replica_id, status",+ "describe": {+ "columns": [+ {+ "ordinal": 0,+ "name": "metadata: Json<StoredPreview>",+ "type_info": "Jsonb"+ },+ {+ "ordinal": 1,+ "name": "replica_id",+ "type_info": "Uuid"+ },+ {+ "ordinal": 2,+ "name": "status",+ "type_info": "Text"+ }+ ],+ "parameters": {+ "Left": []+ },+ "nullable": [+ false,+ true,+ false+ ]+ },+ "hash": "431c961c9b5d8bef01d07294009b7e914258456b62e0b5eddc6207c09968f82a"+}diff --git a/.sqlx/query-5152ca9dfd6de8e94283b0ea1eab5fcef68fd7ae018d65ada1fc4423cc311bbe.json b/.sqlx/query-5152ca9dfd6de8e94283b0ea1eab5fcef68fd7ae018d65ada1fc4423cc311bbe.jsonnew file mode 100644index 0000000000..2152014602--- /dev/null+++ b/.sqlx/query-5152ca9dfd6de8e94283b0ea1eab5fcef68fd7ae018d65ada1fc4423cc311bbe.json@@ -0,0 +1,12 @@+{+ "db_name": "PostgreSQL",+ "query": "LOCK TABLE agent_preview_watcher IN EXCLUSIVE MODE",+ "describe": {+ "columns": [],+ "parameters": {+ "Left": []+ },+ "nullable": []+ },+ "hash": "5152ca9dfd6de8e94283b0ea1eab5fcef68fd7ae018d65ada1fc4423cc311bbe"+}diff --git a/.sqlx/query-597a5bfc92716f5845e1625ad9a8bdd052203a642f3b36007c5d0979cb359839.json b/.sqlx/query-597a5bfc92716f5845e1625ad9a8bdd052203a642f3b36007c5d0979cb359839.jsonnew file mode 100644index 0000000000..f5efce49ff--- /dev/null+++ b/.sqlx/query-597a5bfc92716f5845e1625ad9a8bdd052203a642f3b36007c5d0979cb359839.json@@ -0,0 +1,16 @@+{+ "db_name": "PostgreSQL",+ "query": "INSERT INTO agent_preview_replica (id, address, expires_at) VALUES ($1, $2, now() + make_interval(secs => $3)) ON CONFLICT (id) DO UPDATE SET expires_at = EXCLUDED.expires_at",+ "describe": {+ "columns": [],+ "parameters": {+ "Left": [+ "Uuid",+ "Text",+ "Float8"+ ]+ },+ "nullable": []+ },+ "hash": "597a5bfc92716f5845e1625ad9a8bdd052203a642f3b36007c5d0979cb359839"+}diff --git a/.sqlx/query-65ee7c87376a9507949139046dcc5e8ace5a8df2a5522a1498f27aa041b10ba3.json b/.sqlx/query-65ee7c87376a9507949139046dcc5e8ace5a8df2a5522a1498f27aa041b10ba3.jsonnew file mode 100644index 0000000000..467178c598--- /dev/null+++ b/.sqlx/query-65ee7c87376a9507949139046dcc5e8ace5a8df2a5522a1498f27aa041b10ba3.json@@ -0,0 +1,19 @@+{+ "db_name": "PostgreSQL",+ "query": "INSERT INTO agent_preview_credential (hash, kind, preview_id, user_id, expires_at)\n SELECT $1, $2, id, $4, LEAST($5, expires_at) FROM agent_preview_lease l\n WHERE id = $3 AND status = 'ready' AND expires_at > now()\n AND EXISTS (SELECT 1 FROM agent_preview_replica r WHERE r.id = l.replica_id AND r.expires_at > now())\n AND (SELECT count(*) FROM agent_preview_credential WHERE kind = $2 AND expires_at > now()) < $6",+ "describe": {+ "columns": [],+ "parameters": {+ "Left": [+ "Bytea",+ "Text",+ "Text",+ "Text",+ "Timestamptz",+ "Int8"+ ]+ },+ "nullable": []+ },+ "hash": "65ee7c87376a9507949139046dcc5e8ace5a8df2a5522a1498f27aa041b10ba3"+}diff --git a/.sqlx/query-739cc7a0d123671905e321b4f9938c8f4523fadb112e78dac266b48b24f0ce3e.json b/.sqlx/query-739cc7a0d123671905e321b4f9938c8f4523fadb112e78dac266b48b24f0ce3e.jsonnew file mode 100644index 0000000000..2a084e84fd--- /dev/null+++ b/.sqlx/query-739cc7a0d123671905e321b4f9938c8f4523fadb112e78dac266b48b24f0ce3e.json@@ -0,0 +1,29 @@+{+ "db_name": "PostgreSQL",+ "query": "WITH credential AS (\n DELETE FROM agent_preview_credential WHERE hash = $1 AND kind = 'ssh' AND expires_at > now()\n RETURNING preview_id\n ) UPDATE agent_preview_lease l SET replica_id = $2 FROM credential c\n WHERE l.id = c.preview_id AND l.replica_id IS NULL AND l.status = 'starting'\n AND l.expires_at > now() AND EXISTS (SELECT 1 FROM agent_preview_replica WHERE id = $2 AND expires_at > now())\n RETURNING l.metadata AS \"metadata: Json<StoredPreview>\", l.status",+ "describe": {+ "columns": [+ {+ "ordinal": 0,+ "name": "metadata: Json<StoredPreview>",+ "type_info": "Jsonb"+ },+ {+ "ordinal": 1,+ "name": "status",+ "type_info": "Text"+ }+ ],+ "parameters": {+ "Left": [+ "Bytea",+ "Uuid"+ ]+ },+ "nullable": [+ false,+ false+ ]+ },+ "hash": "739cc7a0d123671905e321b4f9938c8f4523fadb112e78dac266b48b24f0ce3e"+}diff --git a/.sqlx/query-74716feb80aa5209c770d8140cf2406265724282f1aea64fd1f1a3e5ebb0c8a9.json b/.sqlx/query-74716feb80aa5209c770d8140cf2406265724282f1aea64fd1f1a3e5ebb0c8a9.jsonnew file mode 100644index 0000000000..8cb1f63126--- /dev/null+++ b/.sqlx/query-74716feb80aa5209c770d8140cf2406265724282f1aea64fd1f1a3e5ebb0c8a9.json@@ -0,0 +1,14 @@+{+ "db_name": "PostgreSQL",+ "query": "DELETE FROM agent_preview_lease WHERE session_id = $1",+ "describe": {+ "columns": [],+ "parameters": {+ "Left": [+ "Uuid"+ ]+ },+ "nullable": []+ },+ "hash": "74716feb80aa5209c770d8140cf2406265724282f1aea64fd1f1a3e5ebb0c8a9"+}diff --git a/.sqlx/query-79aaa29870688d2b4bf939c9bfaa08b4341809ea14117ca95883e4cb78e685e5.json b/.sqlx/query-79aaa29870688d2b4bf939c9bfaa08b4341809ea14117ca95883e4cb78e685e5.jsonnew file mode 100644index 0000000000..96061618b4--- /dev/null+++ b/.sqlx/query-79aaa29870688d2b4bf939c9bfaa08b4341809ea14117ca95883e4cb78e685e5.json@@ -0,0 +1,34 @@+{+ "db_name": "PostgreSQL",+ "query": "UPDATE agent_preview_lease SET status = 'offline' WHERE replica_id = $1 AND status IN ('starting','ready') AND EXISTS (SELECT 1 FROM agent_preview_replica WHERE id = $1 AND expires_at <= now()) RETURNING metadata AS \"metadata: Json<StoredPreview>\", replica_id, status",+ "describe": {+ "columns": [+ {+ "ordinal": 0,+ "name": "metadata: Json<StoredPreview>",+ "type_info": "Jsonb"+ },+ {+ "ordinal": 1,+ "name": "replica_id",+ "type_info": "Uuid"+ },+ {+ "ordinal": 2,+ "name": "status",+ "type_info": "Text"+ }+ ],+ "parameters": {+ "Left": [+ "Uuid"+ ]+ },+ "nullable": [+ false,+ true,+ false+ ]+ },+ "hash": "79aaa29870688d2b4bf939c9bfaa08b4341809ea14117ca95883e4cb78e685e5"+}diff --git a/.sqlx/query-9521c61a2075b29ea221a0faabf0fd6146da08faf59d3c19f0cf6be79ee19f18.json b/.sqlx/query-9521c61a2075b29ea221a0faabf0fd6146da08faf59d3c19f0cf6be79ee19f18.jsonnew file mode 100644index 0000000000..a5b4352f40--- /dev/null+++ b/.sqlx/query-9521c61a2075b29ea221a0faabf0fd6146da08faf59d3c19f0cf6be79ee19f18.json@@ -0,0 +1,18 @@+{+ "db_name": "PostgreSQL",+ "query": "INSERT INTO agent_preview_watcher (session_id, user_id, expires_at)\n SELECT $1, $2, $3 WHERE\n EXISTS (SELECT 1 FROM agent_preview_watcher WHERE session_id = $1 AND user_id = $2 AND expires_at > now())\n OR ((SELECT count(*) FROM agent_preview_watcher WHERE session_id = $1 AND expires_at > now()) < $4\n AND (EXISTS (SELECT 1 FROM agent_preview_watcher WHERE session_id = $1 AND expires_at > now())\n OR (SELECT count(DISTINCT session_id) FROM agent_preview_watcher WHERE expires_at > now()) < $5))\n ON CONFLICT (session_id, user_id) DO UPDATE SET expires_at = EXCLUDED.expires_at",+ "describe": {+ "columns": [],+ "parameters": {+ "Left": [+ "Uuid",+ "Text",+ "Timestamptz",+ "Int8",+ "Int8"+ ]+ },+ "nullable": []+ },+ "hash": "9521c61a2075b29ea221a0faabf0fd6146da08faf59d3c19f0cf6be79ee19f18"+}diff --git a/.sqlx/query-a233dedf8cc4e91f184895ae7c160c1246f49994a82ab9be6e0a190175ef50e5.json b/.sqlx/query-a233dedf8cc4e91f184895ae7c160c1246f49994a82ab9be6e0a190175ef50e5.jsonnew file mode 100644index 0000000000..e552a8e881--- /dev/null+++ b/.sqlx/query-a233dedf8cc4e91f184895ae7c160c1246f49994a82ab9be6e0a190175ef50e5.json@@ -0,0 +1,12 @@+{+ "db_name": "PostgreSQL",+ "query": "DELETE FROM agent_preview_credential WHERE expires_at <= now()",+ "describe": {+ "columns": [],+ "parameters": {+ "Left": []+ },+ "nullable": []+ },+ "hash": "a233dedf8cc4e91f184895ae7c160c1246f49994a82ab9be6e0a190175ef50e5"+}diff --git a/.sqlx/query-a5efbbb69c9e6795a8a591215b1c1aa81f34a08c968e231a909ba6bbc7aaa08a.json b/.sqlx/query-a5efbbb69c9e6795a8a591215b1c1aa81f34a08c968e231a909ba6bbc7aaa08a.jsonnew file mode 100644index 0000000000..5ac718f1b6--- /dev/null+++ b/.sqlx/query-a5efbbb69c9e6795a8a591215b1c1aa81f34a08c968e231a909ba6bbc7aaa08a.json@@ -0,0 +1,28 @@+{+ "db_name": "PostgreSQL",+ "query": "SELECT r.id, r.address FROM agent_preview_replica r JOIN agent_preview_lease l ON l.replica_id = r.id WHERE l.id = $1 AND l.status IN ('starting','ready') AND l.expires_at > now() AND r.expires_at > now()",+ "describe": {+ "columns": [+ {+ "ordinal": 0,+ "name": "id",+ "type_info": "Uuid"+ },+ {+ "ordinal": 1,+ "name": "address",+ "type_info": "Text"+ }+ ],+ "parameters": {+ "Left": [+ "Text"+ ]+ },+ "nullable": [+ false,+ false+ ]+ },+ "hash": "a5efbbb69c9e6795a8a591215b1c1aa81f34a08c968e231a909ba6bbc7aaa08a"+}diff --git a/.sqlx/query-a7054999052994b7c302cdf578ef4d06a197e3935780ba83277828156da09b35.json b/.sqlx/query-a7054999052994b7c302cdf578ef4d06a197e3935780ba83277828156da09b35.jsonnew file mode 100644index 0000000000..d6a6a86d50--- /dev/null+++ b/.sqlx/query-a7054999052994b7c302cdf578ef4d06a197e3935780ba83277828156da09b35.json@@ -0,0 +1,18 @@+{+ "db_name": "PostgreSQL",+ "query": "INSERT INTO agent_preview_lease (id, session_id, user_id, metadata, status, expires_at) VALUES ($1, $2, $3, $4, 'starting', $5)",+ "describe": {+ "columns": [],+ "parameters": {+ "Left": [+ "Text",+ "Uuid",+ "Text",+ "Jsonb",+ "Timestamptz"+ ]+ },+ "nullable": []+ },+ "hash": "a7054999052994b7c302cdf578ef4d06a197e3935780ba83277828156da09b35"+}diff --git a/.sqlx/query-b85ab8ec6a412247807346c2d5f937e479c9ec56226ee78436d740504e3cb754.json b/.sqlx/query-b85ab8ec6a412247807346c2d5f937e479c9ec56226ee78436d740504e3cb754.jsonnew file mode 100644index 0000000000..60e2623410--- /dev/null+++ b/.sqlx/query-b85ab8ec6a412247807346c2d5f937e479c9ec56226ee78436d740504e3cb754.json@@ -0,0 +1,34 @@+{+ "db_name": "PostgreSQL",+ "query": "SELECT metadata AS \"metadata: Json<StoredPreview>\", replica_id, status\n FROM agent_preview_lease l WHERE id = $1 AND expires_at > now()\n AND status IN ('starting','ready') AND (replica_id IS NULL OR EXISTS\n (SELECT 1 FROM agent_preview_replica r WHERE r.id = l.replica_id AND r.expires_at > now()))",+ "describe": {+ "columns": [+ {+ "ordinal": 0,+ "name": "metadata: Json<StoredPreview>",+ "type_info": "Jsonb"+ },+ {+ "ordinal": 1,+ "name": "replica_id",+ "type_info": "Uuid"+ },+ {+ "ordinal": 2,+ "name": "status",+ "type_info": "Text"+ }+ ],+ "parameters": {+ "Left": [+ "Text"+ ]+ },+ "nullable": [+ false,+ true,+ false+ ]+ },+ "hash": "b85ab8ec6a412247807346c2d5f937e479c9ec56226ee78436d740504e3cb754"+}diff --git a/.sqlx/query-c0a02f63a63cb8e555680c53e574e73797bd19b33ce1095571919a3d7612d1d8.json b/.sqlx/query-c0a02f63a63cb8e555680c53e574e73797bd19b33ce1095571919a3d7612d1d8.jsonnew file mode 100644index 0000000000..05e593b780--- /dev/null+++ b/.sqlx/query-c0a02f63a63cb8e555680c53e574e73797bd19b33ce1095571919a3d7612d1d8.json@@ -0,0 +1,34 @@+{+ "db_name": "PostgreSQL",+ "query": "UPDATE agent_preview_lease SET status = 'stopped' WHERE session_id = $1\n RETURNING metadata AS \"metadata: Json<StoredPreview>\", replica_id, status",+ "describe": {+ "columns": [+ {+ "ordinal": 0,+ "name": "metadata: Json<StoredPreview>",+ "type_info": "Jsonb"+ },+ {+ "ordinal": 1,+ "name": "replica_id",+ "type_info": "Uuid"+ },+ {+ "ordinal": 2,+ "name": "status",+ "type_info": "Text"+ }+ ],+ "parameters": {+ "Left": [+ "Uuid"+ ]+ },+ "nullable": [+ false,+ true,+ false+ ]+ },+ "hash": "c0a02f63a63cb8e555680c53e574e73797bd19b33ce1095571919a3d7612d1d8"+}diff --git a/.sqlx/query-ceaa13888777814ffe2a79e6364a374092315fbc86d53360c44d2d49df860586.json b/.sqlx/query-ceaa13888777814ffe2a79e6364a374092315fbc86d53360c44d2d49df860586.jsonnew file mode 100644index 0000000000..6c6ba39e74--- /dev/null+++ b/.sqlx/query-ceaa13888777814ffe2a79e6364a374092315fbc86d53360c44d2d49df860586.json@@ -0,0 +1,12 @@+{+ "db_name": "PostgreSQL",+ "query": "DELETE FROM agent_preview_replica r WHERE expires_at < now() - interval '7 days' AND NOT EXISTS (SELECT 1 FROM agent_preview_lease l WHERE l.replica_id = r.id)",+ "describe": {+ "columns": [],+ "parameters": {+ "Left": []+ },+ "nullable": []+ },+ "hash": "ceaa13888777814ffe2a79e6364a374092315fbc86d53360c44d2d49df860586"+}diff --git a/.sqlx/query-cfd93d6c1d0044451cfc2ef8ae33f9b1cfb7d3913c72640eefaafb0d0935aa83.json b/.sqlx/query-cfd93d6c1d0044451cfc2ef8ae33f9b1cfb7d3913c72640eefaafb0d0935aa83.jsonnew file mode 100644index 0000000000..50887583c3--- /dev/null+++ b/.sqlx/query-cfd93d6c1d0044451cfc2ef8ae33f9b1cfb7d3913c72640eefaafb0d0935aa83.json@@ -0,0 +1,30 @@+{+ "db_name": "PostgreSQL",+ "query": "SELECT user_id, expires_at FROM agent_preview_credential WHERE hash = $1 AND preview_id = $2 AND kind = $3 AND expires_at > now()",+ "describe": {+ "columns": [+ {+ "ordinal": 0,+ "name": "user_id",+ "type_info": "Text"+ },+ {+ "ordinal": 1,+ "name": "expires_at",+ "type_info": "Timestamptz"+ }+ ],+ "parameters": {+ "Left": [+ "Bytea",+ "Text",+ "Text"+ ]+ },+ "nullable": [+ true,+ false+ ]+ },+ "hash": "cfd93d6c1d0044451cfc2ef8ae33f9b1cfb7d3913c72640eefaafb0d0935aa83"+}diff --git a/.sqlx/query-d987cb8ff3778728028f0299a66f56a8e6aad6d4188de4acf6c3be9268064bd5.json b/.sqlx/query-d987cb8ff3778728028f0299a66f56a8e6aad6d4188de4acf6c3be9268064bd5.jsonnew file mode 100644index 0000000000..0af43c8be2--- /dev/null+++ b/.sqlx/query-d987cb8ff3778728028f0299a66f56a8e6aad6d4188de4acf6c3be9268064bd5.json@@ -0,0 +1,23 @@+{+ "db_name": "PostgreSQL",+ "query": "SELECT user_id FROM agent_preview_watcher WHERE session_id = $1 AND expires_at > now() ORDER BY user_id LIMIT $2",+ "describe": {+ "columns": [+ {+ "ordinal": 0,+ "name": "user_id",+ "type_info": "Text"+ }+ ],+ "parameters": {+ "Left": [+ "Uuid",+ "Int8"+ ]+ },+ "nullable": [+ false+ ]+ },+ "hash": "d987cb8ff3778728028f0299a66f56a8e6aad6d4188de4acf6c3be9268064bd5"+}diff --git a/.sqlx/query-e1c0c0f5cd30dcdb1d38d568237b81795c68b1d28347c5a570f95ae07b5fd885.json b/.sqlx/query-e1c0c0f5cd30dcdb1d38d568237b81795c68b1d28347c5a570f95ae07b5fd885.jsonnew file mode 100644index 0000000000..0d174e1c38--- /dev/null+++ b/.sqlx/query-e1c0c0f5cd30dcdb1d38d568237b81795c68b1d28347c5a570f95ae07b5fd885.json@@ -0,0 +1,36 @@+{+ "db_name": "PostgreSQL",+ "query": "SELECT count(*) FILTER (WHERE session_id <> $2) AS \"total!\",\n count(*) FILTER (WHERE user_id = $1 AND status IN ('starting', 'ready') AND session_id <> $2) AS \"account!\",\n EXISTS (SELECT 1 FROM agent_preview_lease WHERE user_id = $1 AND created_at > now() - make_interval(secs => $3)) AS \"paced!\"\n FROM agent_preview_lease WHERE expires_at > now()",+ "describe": {+ "columns": [+ {+ "ordinal": 0,+ "name": "total!",+ "type_info": "Int8"+ },+ {+ "ordinal": 1,+ "name": "account!",+ "type_info": "Int8"+ },+ {+ "ordinal": 2,+ "name": "paced!",+ "type_info": "Bool"+ }+ ],+ "parameters": {+ "Left": [+ "Text",+ "Uuid",+ "Float8"+ ]+ },+ "nullable": [+ null,+ null,+ null+ ]+ },+ "hash": "e1c0c0f5cd30dcdb1d38d568237b81795c68b1d28347c5a570f95ae07b5fd885"+}diff --git a/.sqlx/query-e80b48c212bcf934ab22f81403b7b1ef8e45fb7ea52c759330834ddf1ffb6be5.json b/.sqlx/query-e80b48c212bcf934ab22f81403b7b1ef8e45fb7ea52c759330834ddf1ffb6be5.jsonnew file mode 100644index 0000000000..78f8ed4c31--- /dev/null+++ b/.sqlx/query-e80b48c212bcf934ab22f81403b7b1ef8e45fb7ea52c759330834ddf1ffb6be5.json@@ -0,0 +1,16 @@+{+ "db_name": "PostgreSQL",+ "query": "UPDATE agent_preview_lease l SET status = $3 WHERE id = $1 AND replica_id = $2 AND status IN ('starting','ready') AND expires_at > now() AND EXISTS (SELECT 1 FROM agent_preview_replica WHERE id = $2 AND expires_at > now())",+ "describe": {+ "columns": [],+ "parameters": {+ "Left": [+ "Text",+ "Uuid",+ "Text"+ ]+ },+ "nullable": []+ },+ "hash": "e80b48c212bcf934ab22f81403b7b1ef8e45fb7ea52c759330834ddf1ffb6be5"+}diff --git a/.sqlx/query-f7abfb311e3e36847874750156cc6ce7a9127b72ce38940b5c4c39540776143b.json b/.sqlx/query-f7abfb311e3e36847874750156cc6ce7a9127b72ce38940b5c4c39540776143b.jsonnew file mode 100644index 0000000000..baee290762--- /dev/null+++ b/.sqlx/query-f7abfb311e3e36847874750156cc6ce7a9127b72ce38940b5c4c39540776143b.json@@ -0,0 +1,16 @@+{+ "db_name": "PostgreSQL",+ "query": "INSERT INTO agent_preview_credential (hash, kind, preview_id, expires_at) VALUES ($1, 'ssh', $2, $3)",+ "describe": {+ "columns": [],+ "parameters": {+ "Left": [+ "Bytea",+ "Text",+ "Timestamptz"+ ]+ },+ "nullable": []+ },+ "hash": "f7abfb311e3e36847874750156cc6ce7a9127b72ce38940b5c4c39540776143b"+}diff --git a/Cargo.lock b/Cargo.lockindex 6bdf84b9b6..f8e4370a93 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -647,12 +647,15 @@ dependencies = ["axum","base64 0.22.1","bytes",+ "chrono","entity_access","futures-util","http-body-util","hyper 1.9.0","hyper-util","macro_authorization",+ "macro_db_migrator",+ "macro_tower_layers","macro_user_id","rand 0.9.4","rmcp",@@ -662,6 +665,7 @@ dependencies = ["serde","serde_json","sha2 0.10.9",+ "sqlx","tempfile","thiserror 2.0.18","tokio",@@ -670,6 +674,7 @@ dependencies = ["tower 0.5.3","tracing","url",+ "uuid","workspace-hack",]diff --git a/crates/agent_preview/AGENTS.md b/crates/agent_preview/AGENTS.mdindex afd9de17c1..f080a625c4 100644--- a/crates/agent_preview/AGENTS.md+++ b/crates/agent_preview/AGENTS.md@@ -11,6 +11,9 @@ on stock OpenSSH reverse forwarding.- `src/domain/service.rs` + `src/domain/ports.rs`: lease/authorizationpolicy, independent of HTTP and SSH.+- `src/domain/storage.rs` + `src/outbound/postgres.rs`: shared metadata,+ credential hashes and fenced SSH ownership; live transports stay local.+- `src/inbound/peer.rs`: one-hop streaming HTTP/WebSocket forwarding.- `src/inbound/ssh.rs`: accepts the sandbox's reverse SSH tunnel.- `src/inbound/http.rs`: serves the proxied preview to viewers.- `src/outbound/ssh_tunnel.rs`: the SSH transport implementation.@@ -38,8 +41,13 @@ on stock OpenSSH reverse forwarding.## Gotchas-- Vite's module fan-out must be queued, not refused as `text/plain`, or HMR- breaks silently (see git history on `src/inbound/http.rs`).+- Every host must heartbeat its private HTTP endpoint every 10 seconds; expired+ owners are offline after 45 seconds. Preview IDs fence replacement/cleanup.+- Public peers must be mutually reachable; destinations come only from the+ shared replica registry. A hop marker only prevents loops and never grants auth.+- Queue owner-side per-preview HTTP streams for Vite module fan-out (see+ `src/inbound/http.rs`); replica-wide unauthenticated forwarding admission+ rejects overload before dialing to bound waiting requests and sockets.## Relateddiff --git a/crates/agent_preview/Cargo.toml b/crates/agent_preview/Cargo.tomlindex 9622cc6756..eb4d9be4a0 100644--- a/crates/agent_preview/Cargo.toml+++ b/crates/agent_preview/Cargo.toml@@ -34,7 +34,13 @@ tracing = { workspace = true }url = { workspace = true }workspace-hack = { version = "0.1", path = "../workspace-hack" }+uuid = { workspace = true, features = ["v7", "serde"] }+sqlx = { workspace = true }+chrono = { workspace = true }+macro_tower_layers = { path = "../macro_tower_layers" }+[dev-dependencies]+macro_db_migrator = { path = "../macro_db_migrator" }tokio = { workspace = true, features = ["test-util"] }tempfile = "3"tower = { workspace = true }diff --git a/crates/agent_preview/src/domain/ids.rs b/crates/agent_preview/src/domain/ids.rsindex 7ff32f4968..7f0f91badf 100644--- a/crates/agent_preview/src/domain/ids.rs+++ b/crates/agent_preview/src/domain/ids.rs@@ -3,7 +3,7 @@use super::PreviewError;use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};use rand::RngCore;-use serde::Serialize;+use serde::{Deserialize, Serialize};use sha2::{Digest, Sha256};/// Length of a routing ID in characters, and so of its DNS label.@@ -15,7 +15,7 @@ const LENGTH: usize = 32;/// as user-supplied strings - one in a `Host` header, one in an entity access/// receipt - and the registry is keyed by the session while credentials point at/// the preview, so the two must not be interchangeable.-#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]#[serde(transparent)]pub struct PreviewId(String);diff --git a/crates/agent_preview/src/domain/mod.rs b/crates/agent_preview/src/domain/mod.rsindex 38899cee65..a31e516967 100644--- a/crates/agent_preview/src/domain/mod.rs+++ b/crates/agent_preview/src/domain/mod.rs@@ -5,3 +5,6 @@ pub mod ports;mod service;pub use ids::PreviewId;pub use service::*;++/// Shared metadata and fenced ownership ports.+pub mod storage;diff --git a/crates/agent_preview/src/domain/ports.rs b/crates/agent_preview/src/domain/ports.rsindex 1bceaec76f..6819a6658f 100644--- a/crates/agent_preview/src/domain/ports.rs+++ b/crates/agent_preview/src/domain/ports.rs@@ -45,3 +45,20 @@ pub trait Events: Send + Sync {viewers: &[MacroUserIdStr<'static>],) -> Result<(), PreviewError>;}++/// Direct byte transport to a registered preview replica, never an arbitrary URL.+#[async_trait]+pub trait PeerConnector: Send + Sync {+ /// Connect to the server-selected peer endpoint with a bounded dial timeout.+ async fn connect(&self, address: std::net::SocketAddr) -> Result<Stream, PreviewError>;+}++/// Admitted direct peer stream. Slots live through response bodies and upgrades.+pub struct PeerConnection {+ /// Connected byte stream.+ pub stream: Stream,+ /// Shared forwarding concurrency slot.+ pub permit: std::sync::Arc<tokio::sync::OwnedSemaphorePermit>,+ /// Separate upgraded-stream concurrency slot.+ pub upgrade_permit: Option<tokio::sync::OwnedSemaphorePermit>,+}diff --git a/crates/agent_preview/src/domain/service.rs b/crates/agent_preview/src/domain/service.rsindex 2d8ec0dcc4..916b6403de 100644--- a/crates/agent_preview/src/domain/service.rs+++ b/crates/agent_preview/src/domain/service.rs@@ -9,11 +9,14 @@ use entity_access::domain::models::{};use macro_user_id::user_id::MacroUserIdStr;use rand::RngCore;-use serde::Serialize;+use serde::{Deserialize, Serialize};use sha2::{Digest, Sha256};use std::{collections::HashMap,- sync::{Arc, Mutex},+ sync::{+ Arc, Mutex,+ atomic::{AtomicBool, Ordering},+ },time::{Duration, Instant, SystemTime, UNIX_EPOCH},};use tokio::sync::Semaphore;@@ -33,7 +36,7 @@ pub struct AgentIdentity {pub owner: MacroUserIdStr<'static>,}/// Public state of one preview; contains no credentials.-#[derive(Clone, Serialize)]+#[derive(Clone, Debug, Serialize, Deserialize)]#[serde(rename_all = "camelCase")]pub struct Preview {/// Opaque routing ID, not an authorization credential.@@ -48,7 +51,7 @@ pub struct Preview {pub expires_at: u64,}/// Preview lifecycle visible in the session UI.-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]#[serde(rename_all = "snake_case")]pub enum PreviewStatus {/// Waiting for SSH and a reachable HTTP server.@@ -181,33 +184,14 @@ pub struct Launch {/// One-use, 30-second ticket. Do not log it.pub ticket: String,}-struct Credential {- preview: PreviewId,- /// Absent on an SSH token: it authenticates the agent's tunnel, not a viewer.- user: Option<MacroUserIdStr<'static>>,- expires: Instant,-}-/// Per-owner creation pacing. Traffic itself is unmetered: a shared dev server-/// moves tens of MB per cold load, and every ceiling we tried severed it.-struct AccountBudget {- last_created: Instant,-}-struct Registry {- sessions: HashMap<AgentSessionId, Arc<Lease>>,- accounts: HashMap<MacroUserIdStr<'static>, AccountBudget>,- ssh_tokens: HashMap<[u8; 32], Credential>,- tickets: HashMap<[u8; 32], Credential>,- browsers: HashMap<[u8; 32], Credential>,- watchers: HashMap<AgentSessionId, HashMap<MacroUserIdStr<'static>, Instant>>,-}/// Live lease, with cancellation and stream slots shared by every request/upgrade.pub struct Lease {preview: Mutex<Preview>,- owner: MacroUserIdStr<'static>,port: u16,expires: Instant,activity: Mutex<Instant>,tunnel: Mutex<Option<Arc<dyn Tunnel>>>,+ pending_cleanup: AtomicBool,/// Cancellation closes existing HTTP and WebSocket traffic on revocation.pub cancel: CancellationToken,/// Total HTTP streams, held until response completion.@@ -242,129 +226,153 @@ impl Lease {.ok_or(PreviewError::Offline)}}-/// Core use cases; holds ephemeral leases because an SSH transport cannot survive a restart.+/// Core use cases. Durable metadata is shared; only SSH transports live locally.#[derive(Clone)]pub struct PreviewService {settings: Arc<Settings>,authority: Arc<dyn Authority>,events: Arc<dyn Events>,- registry: Arc<Mutex<Registry>>,+ repository: Arc<dyn super::storage::PreviewRepository>,+ replica: uuid::Uuid,+ peers: Arc<dyn super::ports::PeerConnector>,+ lifecycle: Arc<tokio::sync::Mutex<()>>,+ peer_slots: Arc<Semaphore>,+ peer_upgrades: Arc<Semaphore>,+ leases: Arc<Mutex<HashMap<AgentSessionId, Arc<Lease>>>>,}+use super::storage::{CredentialKind, StoredCredential, StoredPreview};impl PreviewService {- /// Wire authority and notifications around a single-replica registry.+ /// Compose a replica with shared ownership and credential persistence.pub fn new(settings: Settings,authority: Arc<dyn Authority>,events: Arc<dyn Events>,+ repository: Arc<dyn super::storage::PreviewRepository>,+ replica: uuid::Uuid,+ peers: Arc<dyn super::ports::PeerConnector>,) -> Result<Self, PreviewError> {settings.validate()?;Ok(Self {settings: Arc::new(settings),authority,events,- registry: Arc::new(Mutex::new(Registry {- sessions: HashMap::new(),- accounts: HashMap::new(),- ssh_tokens: HashMap::new(),- tickets: HashMap::new(),- browsers: HashMap::new(),- watchers: HashMap::new(),- })),+ repository,+ replica,+ peers,+ lifecycle: Arc::new(tokio::sync::Mutex::new(())),+ peer_slots: Arc::new(Semaphore::new(1024)),+ peer_upgrades: Arc::new(Semaphore::new(128)),+ leases: Arc::new(Mutex::new(HashMap::new())),})}- /// Deployment settings for the transport adapters.+ /// Deployment settings for transport adapters.pub fn settings(&self) -> &Settings {&self.settings}- /// Authenticate the existing agent session credential.+ /// Publish a server-configured peer endpoint. Never accepts request input.+ #[tracing::instrument(skip_all, fields(replica = %self.replica), err)]+ pub async fn heartbeat(&self, address: std::net::SocketAddr) -> Result<(), PreviewError> {+ validate_peer(address)?;+ for preview in self+ .repository+ .heartbeat(self.replica, address, 45.0)+ .await?+ {+ self.publish(&preview).await;+ }+ Ok(())+ }+ /// Resolve an SSH owner using only the shared registry. None means local.+ #[tracing::instrument(skip_all, fields(preview_id = %id), err)]+ pub async fn destination(+ &self,+ id: &PreviewId,+ ) -> Result<Option<std::net::SocketAddr>, PreviewError> {+ let (replica, address) = self.repository.destination(id).await?;+ validate_peer(address)?;+ Ok((replica != self.replica).then_some(address))+ }+ /// Open one direct hop; even forged hop markers can only cause refusal, never bypass auth.+ #[tracing::instrument(skip_all, fields(preview_id = %id), err)]+ pub async fn peer_stream(+ &self,+ id: &PreviewId,+ forwarded: bool,+ upgrade: bool,+ ) -> Result<Option<super::ports::PeerConnection>, PreviewError> {+ if let Some(address) = self.destination(id).await? {+ if forwarded {+ return Err(PreviewError::Offline);+ }+ let permit = Arc::new(+ self.peer_slots+ .clone()+ .try_acquire_owned()+ .map_err(|_| PreviewError::Limited)?,+ );+ let upgrade_permit = if upgrade {+ Some(+ self.peer_upgrades+ .clone()+ .try_acquire_owned()+ .map_err(|_| PreviewError::Limited)?,+ )+ } else {+ None+ };+ let stream = self.peers.connect(address).await?;+ return Ok(Some(super::ports::PeerConnection {+ stream,+ permit,+ upgrade_permit,+ }));+ }+ Ok(None)+ }+ /// Authenticate the existing agent-session credential.pub async fn agent(&self, token: &str) -> Result<AgentIdentity, PreviewError> {self.authority.agent(token).await}- /// Create one lease per session, replacing and closing any previous tunnel.+ /// Replace one session preview. The new ID fences every previous transport.+ #[tracing::instrument(skip_all, fields(session_id = %identity.session), err)]pub async fn share(&self, identity: AgentIdentity, port: u16) -> Result<Share, PreviewError> {if port == 0 {return Err(PreviewError::Invalid);}self.authority.active(identity.session).await?;+ let lifecycle = self.lifecycle.lock().await;let id = PreviewId::generate();- // OpenSSH rejects usernames beginning with '-', which URL-safe base64 can emit.let token = format!("preview_{}", random());let preview = Preview {id: id.clone(),agent_session_id: identity.session,url: self.settings.origin(&id),status: PreviewStatus::Starting,- expires_at: (SystemTime::now()- .duration_since(UNIX_EPOCH)- .unwrap_or_default()- + LEASE)- .as_millis() as u64,+ expires_at: (now_ms() + LEASE.as_millis() as i64) as u64,};- {- let mut registry = self.registry.lock().expect("registry mutex");- if registry.accounts.len() >= 1000 && !registry.accounts.contains_key(&identity.owner) {- return Err(PreviewError::Limited);- }- let account = registry- .accounts- .entry(identity.owner.clone())- .or_insert_with(|| AccountBudget {- last_created: Instant::now() - TOKEN_TTL,- });- if account.last_created.elapsed() < Duration::from_secs(10) {- return Err(PreviewError::Limited);- }- account.last_created = Instant::now();- }- let lease = Arc::new(Lease {- preview: Mutex::new(preview.clone()),- owner: identity.owner,- port,- expires: Instant::now() + LEASE,- activity: Mutex::new(Instant::now()),- tunnel: Mutex::new(None),- cancel: CancellationToken::new(),- // Large enough for a Vite cold load's module fan-out; the HTTP- // inbound queues on this semaphore instead of rejecting, so the- // number bounds file descriptors rather than aborting the page.- requests: Arc::new(Semaphore::new(4096)),- upgrades: Arc::new(Semaphore::new(8)),- });- let old = {- let mut registry = self.registry.lock().expect("registry mutex");- if registry.sessions.len() >= 1000 && !registry.sessions.contains_key(&identity.session)- {- return Err(PreviewError::Limited);- }- if registry- .sessions- .values()- .filter(|l| {- l.owner == lease.owner- && l.live()- && l.preview().agent_session_id != identity.session- })- .count()- >= 5- {- return Err(PreviewError::Limited);- }- if let Some(previous) = registry.sessions.get(&identity.session) {- let old_id = previous.preview().id;- registry.ssh_tokens.retain(|_, c| c.preview != old_id);- registry.tickets.retain(|_, c| c.preview != old_id);- registry.browsers.retain(|_, c| c.preview != old_id);- }- registry.ssh_tokens.insert(- digest(&token),- Credential {+ self.repository+ .create(+ StoredPreview {+ preview: preview.clone(),+ user: identity.owner,+ port,+ replica: None,+ },+ StoredCredential {+ hash: digest(&token),preview: id,user: None,- expires: Instant::now() + TOKEN_TTL,+ expires: now_ms() + TOKEN_TTL.as_millis() as i64,},- );- registry.sessions.insert(identity.session, lease)- };+ super::storage::CreationLimits::PREVIEW,+ )+ .await?;+ let old = self+ .leases+ .lock()+ .expect("leases mutex")+ .remove(&identity.session);+ drop(lifecycle);if let Some(old) = old {self.finish(&old, PreviewStatus::Stopped).await;}@@ -375,42 +383,51 @@ impl PreviewService {port,})}- /// Resolve a session's state only with an entity view receipt.- pub fn get(+ /// Read shared state after an entity view receipt, and register a notification watcher.+ pub async fn get(&self,receipt: EntityAccessReceipt<ViewAccessLevel>,) -> Result<Option<Preview>, PreviewError> {let session = session_id(&receipt)?;- let mut registry = self.registry.lock().expect("registry mutex");- if let Some(user) = receipt.acting_user_id()- && (registry.watchers.len() < 4096 || registry.watchers.contains_key(&session))- {- let watchers = registry.watchers.entry(session).or_default();- if watchers.len() < 256 || watchers.contains_key(user) {- watchers.insert(user.clone(), Instant::now());- }+ if let Some(user) = receipt.acting_user_id() {+ self.repository+ .watch(+ session,+ user,+ super::storage::WatchLimits {+ sessions: 4096,+ viewers: 256,+ expires: now_ms() + 300000,+ },+ )+ .await?;}- Ok(registry.sessions.get(&session).map(|l| l.preview()))+ Ok(self.repository.session(session).await?.map(|p| p.preview))}- /// Stop requires entity edit permission; viewing never grants control.+ /// Entity edit permission stops the shared generation on any replica.+ #[tracing::instrument(skip_all, err)]pub async fn stop(&self,receipt: EntityAccessReceipt<EditAccessLevel>,) -> Result<(), PreviewError> {- let lease = self- .registry- .lock()- .expect("registry mutex")- .sessions- .get(&session_id(&receipt)?)- .cloned();- if let Some(lease) = lease {- self.finish(&lease, PreviewStatus::Stopped).await;+ if let Some(stored) = self.repository.stop(session_id(&receipt)?).await? {+ let local = self+ .leases+ .lock()+ .expect("leases mutex")+ .get(&stored.preview.agent_session_id)+ .cloned();+ if let Some(lease) = local+ && lease.preview().id == stored.preview.id+ {+ self.finish(&lease, PreviewStatus::Stopped).await;+ }+ self.publish(&stored.preview).await;}Ok(())}- /// Mint a browser ticket after entity access was checked by the standard extractor.- pub fn launch(+ /// Mint a shared, one-use, host-bound browser ticket after entity authorization.+ pub async fn launch(&self,receipt: EntityAccessReceipt<ViewAccessLevel>,) -> Result<Launch, PreviewError> {@@ -418,51 +435,72 @@ impl PreviewService {.get_authenticated_user().map_err(|_| PreviewError::Denied)?.clone();- let mut registry = self.registry.lock().expect("registry mutex");- let lease = registry- .sessions- .get(&session_id(&receipt)?)- .cloned()+ let stored = self+ .repository+ .session(session_id(&receipt)?)+ .await?.ok_or(PreviewError::Offline)?;- if !lease.live() || lease.preview().status != PreviewStatus::Ready {+ if stored.preview.status != PreviewStatus::Ready {return Err(PreviewError::Offline);}- registry.tickets.retain(|_, c| c.expires > Instant::now());- if registry.tickets.len() >= 4096 {- return Err(PreviewError::Limited);- }let ticket = random();- let preview = lease.preview();- registry.tickets.insert(- digest(&ticket),- Credential {- preview: preview.id,- user: Some(user),- expires: Instant::now() + TICKET_TTL,- },- );+ self.repository+ .credential(+ CredentialKind::Ticket,+ StoredCredential {+ hash: digest(&ticket),+ preview: stored.preview.id,+ user: Some(user),+ expires: now_ms() + TICKET_TTL.as_millis() as i64,+ },+ 4096,+ )+ .await?;Ok(Launch {- action: format!("{}/.macro-preview/auth", preview.url),+ action: format!("{}/.macro-preview/auth", stored.preview.url),ticket,})}- /// Redeem an SSH token exactly once; it is scoped to a single lease.- pub fn authenticate_ssh(&self, token: &str) -> Result<Arc<Lease>, PreviewError> {- let mut registry = self.registry.lock().expect("registry mutex");- let credential = registry- .ssh_tokens- .remove(&digest(token))- .ok_or(PreviewError::Denied)?;- if credential.expires <= Instant::now() {- return Err(PreviewError::Denied);+ /// Atomically consume SSH credentials and assign ownership to this accepting replica.+ #[tracing::instrument(skip_all, fields(replica = %self.replica, preview_id = tracing::field::Empty), err)]+ pub async fn authenticate_ssh(&self, token: &str) -> Result<Arc<Lease>, PreviewError> {+ let lifecycle = self.lifecycle.lock().await;+ let stored = self.repository.claim(digest(token), self.replica).await?;+ tracing::Span::current().record("preview_id", tracing::field::display(&stored.preview.id));+ let remaining = stored.preview.expires_at.saturating_sub(now_ms() as u64);+ let session = stored.preview.agent_session_id;+ let lease = Arc::new(Lease {+ preview: Mutex::new(stored.preview),+ port: stored.port,+ expires: Instant::now() + Duration::from_millis(remaining),+ activity: Mutex::new(Instant::now()),+ tunnel: Mutex::new(None),+ pending_cleanup: AtomicBool::new(false),+ cancel: CancellationToken::new(),+ requests: Arc::new(Semaphore::new(4096)),+ upgrades: Arc::new(Semaphore::new(8)),+ });+ let old = self+ .leases+ .lock()+ .expect("leases mutex")+ .insert(session, lease.clone());+ drop(lifecycle);+ if let Some(old) = old {+ self.finish(&old, PreviewStatus::Offline).await;}- let lease = find(®istry, &credential.preview)?;- if !lease.live() {- return Err(PreviewError::Denied);+ if let Err(error) = self.authority.active(session).await {+ self.finish(&lease, PreviewStatus::Offline).await;+ return Err(error);+ }+ // A replacement/stop racing the SSH handshake cannot install a live obsolete lease.+ if self.repository.preview(&lease.preview().id).await.is_err() {+ self.finish(&lease, PreviewStatus::Offline).await;+ return Err(PreviewError::Offline);}Ok(lease)}- /// Accept exactly one logical reverse forward. No TCP listener is created.+ /// Accept one logical reverse forward, never an arbitrary socket destination.pub fn register(&self,lease: &Arc<Lease>,@@ -474,17 +512,32 @@ impl PreviewService {return Err(PreviewError::Denied);}let mut current = lease.tunnel.lock().expect("tunnel mutex");- if current.is_some() {+ if current.is_some() || !lease.live() {return Err(PreviewError::Denied);}*current = Some(tunnel);Ok(())}- /// Mark ready only after receiving a real HTTP response through the tunnel.+ /// Publish readiness only if this generation is still owned and live.pub async fn ready(&self, lease: &Arc<Lease>) {+ if !lease.live() || lease.preview().status != PreviewStatus::Starting {+ return;+ }+ if !matches!(+ self.repository+ .status(&lease.preview().id, self.replica, PreviewStatus::Ready)+ .await,+ Ok(true)+ ) {+ self.finish(lease, PreviewStatus::Offline).await;+ return;+ }+ if lease.cancel.is_cancelled() {+ return;+ }let preview = {let mut preview = lease.preview.lock().expect("preview mutex");- if preview.status != PreviewStatus::Starting || !lease.live() {+ if !lease.live() || preview.status != PreviewStatus::Starting {return;}preview.status = PreviewStatus::Ready;@@ -492,85 +545,82 @@ impl PreviewService {};self.publish(&preview).await;}- /// Mark disconnected/expired and cancel all current traffic.+ /// Close local transports unconditionally; shared cleanup matches generation and replica.pub async fn finish(&self, lease: &Arc<Lease>, status: PreviewStatus) {- if lease.cancel.is_cancelled() {- return;- }- lease.cancel.cancel();let preview = {let mut preview = lease.preview.lock().expect("preview mutex");- preview.status = status;+ lease.pending_cleanup.store(true, Ordering::SeqCst);+ if !lease.cancel.is_cancelled() {+ preview.status = status;+ lease.cancel.cancel();+ }preview.clone()};let tunnel = lease.tunnel.lock().expect("tunnel mutex").take();if let Some(tunnel) = tunnel {tunnel.close().await;}- self.publish(&preview).await;+ match self+ .repository+ .status(&preview.id, self.replica, preview.status)+ .await+ {+ Ok(changed) => {+ lease.pending_cleanup.store(false, Ordering::SeqCst);+ if changed {+ self.publish(&preview).await;+ }+ }+ Err(error) => tracing::warn!(?error, "preview finish persistence failed"),+ }}- /// Exchange a host-bound, one-use ticket for a host-only browser credential.+ /// Consume a shared ticket exactly once, after matching its preview origin.+ #[tracing::instrument(skip_all, fields(preview_id = %id), err)]pub async fn redeem(&self, id: &PreviewId, ticket: &str) -> Result<String, PreviewError> {- let credential = {- let mut registry = self.registry.lock().expect("registry mutex");- let credential = registry- .tickets- .get(&digest(ticket))- .ok_or(PreviewError::Denied)?;- if &credential.preview != id || credential.expires <= Instant::now() {- return Err(PreviewError::Denied);- }- registry- .tickets- .remove(&digest(ticket))- .ok_or(PreviewError::Denied)?- };- // A ticket is only ever minted for an authenticated viewer.+ let credential = self+ .repository+ .authenticate(CredentialKind::Ticket, id, digest(ticket), true)+ .await?;let user = credential.user.ok_or(PreviewError::Denied)?;- let lease = self.by_id(id)?;+ let stored = self.repository.preview(id).await?;self.authority- .viewer(lease.preview().agent_session_id, &user)+ .viewer(stored.preview.agent_session_id, &user).await?;let cookie = random();- let mut registry = self.registry.lock().expect("registry mutex");- registry.browsers.retain(|_, c| c.expires > Instant::now());- if registry.browsers.len() >= 8192 {- return Err(PreviewError::Limited);- }- registry.browsers.insert(- digest(&cookie),- Credential {- preview: id.clone(),- user: Some(user),- expires: lease.expires,- },- );+ self.repository+ .credential(+ CredentialKind::Browser,+ StoredCredential {+ hash: digest(&cookie),+ preview: id.clone(),+ user: Some(user),+ expires: stored.preview.expires_at as i64,+ },+ 8192,+ )+ .await?;Ok(cookie)}- /// Authenticate every HTTP request. WebSockets call this periodically too.+ /// Recheck credentials, entity access, and the shared generation on every request/upgrade.+ #[tracing::instrument(skip_all, fields(preview_id = %id), err)]pub async fn viewer(&self,id: &PreviewId,cookie: &str,activity: bool,) -> Result<Arc<Lease>, PreviewError> {- let (lease, user) = {- let registry = self.registry.lock().expect("registry mutex");- let credential = registry- .browsers- .get(&digest(cookie))- .ok_or(PreviewError::Denied)?;- if &credential.preview != id || credential.expires <= Instant::now() {- return Err(PreviewError::Denied);- }- let user = credential.user.clone().ok_or(PreviewError::Denied)?;- (find(®istry, id)?, user)- };- if !lease.live() {+ let credential = self+ .repository+ .authenticate(CredentialKind::Browser, id, digest(cookie), false)+ .await?;+ let user = credential.user.ok_or(PreviewError::Denied)?;+ let stored = self.repository.preview(id).await?;+ if stored.replica != Some(self.replica) {return Err(PreviewError::Offline);}+ let lease = self.by_id(id)?;self.authority- .viewer(lease.preview().agent_session_id, &user)+ .viewer(stored.preview.agent_session_id, &user).await?;if activity {*lease.activity.lock().expect("activity mutex") = Instant::now();@@ -578,25 +628,38 @@ impl PreviewService {Ok(lease)}fn by_id(&self, id: &PreviewId) -> Result<Arc<Lease>, PreviewError> {- let lease = find(&self.registry.lock().expect("registry mutex"), id)?;- if !lease.live() {- return Err(PreviewError::Offline);- }- Ok(lease)+ self.leases+ .lock()+ .expect("leases mutex")+ .values()+ .find(|l| &l.preview().id == id && l.live())+ .cloned()+ .ok_or(PreviewError::Offline)}- /// Expire leases, including agent-session revocation, and reclaim bounded state.+ /// Check shared revocation and ownership, expire idle tunnels and reclaim state.pub async fn sweep(&self) {+ match self.repository.sweep().await {+ Ok(transitions) => {+ for preview in transitions {+ self.publish(&preview).await;+ }+ }+ Err(error) => tracing::warn!(?error, "preview sweep failed"),+ }let leases: Vec<_> = self- .registry+ .leases.lock()- .expect("registry mutex")- .sessions+ .expect("leases mutex").values().cloned().collect();for lease in leases {+ if lease.cancel.is_cancelled() && lease.pending_cleanup.load(Ordering::SeqCst) {+ self.finish(&lease, lease.preview().status).await;+ }if !lease.cancel.is_cancelled()&& (!lease.live()+ || self.repository.preview(&lease.preview().id).await.is_err()|| self.authority.active(lease.preview().agent_session_id)@@ -606,38 +669,27 @@ impl PreviewService {self.finish(&lease, PreviewStatus::Expired).await;}}- let mut registry = self.registry.lock().expect("registry mutex");- registry- .ssh_tokens- .retain(|_, c| c.expires > Instant::now());- registry.tickets.retain(|_, c| c.expires > Instant::now());- registry.browsers.retain(|_, c| c.expires > Instant::now());- registry- .sessions- .retain(|_, l| Instant::now() < l.expires + Duration::from_secs(300));- registry- .accounts- .retain(|_, a| a.last_created.elapsed() < LEASE + LEASE);- registry.watchers.retain(|_, users| {- users.retain(|_, time| time.elapsed() < Duration::from_secs(300));- !users.is_empty()- });+ self.leases+ .lock()+ .expect("leases mutex")+ .retain(|_, l| !l.cancel.is_cancelled() || l.pending_cleanup.load(Ordering::SeqCst));}async fn publish(&self, preview: &Preview) {- let candidates = {- let registry = self.registry.lock().expect("registry mutex");- let mut users: Vec<MacroUserIdStr<'static>> = registry- .watchers- .get(&preview.agent_session_id)- .map(|w| w.keys().cloned().collect())- .unwrap_or_default();- if let Some(lease) = registry.sessions.get(&preview.agent_session_id) {- users.push(lease.owner.clone());- }- users.sort_by(|a, b| a.as_ref().cmp(b.as_ref()));- users.dedup();- users+ // Never publish a stale generation/status after an awaited mutation or cleanup.+ let Ok(Some(current)) = self.repository.session(preview.agent_session_id).await else {+ return;};+ if current.preview.id != preview.id || current.preview.status != preview.status {+ return;+ }+ let mut candidates = self+ .repository+ .watchers(preview.agent_session_id, 256)+ .await+ .unwrap_or_default();+ candidates.push(current.user);+ candidates.sort_by(|a, b| a.as_ref().cmp(b.as_ref()));+ candidates.dedup();let mut viewers = Vec::new();for user in candidates {if self@@ -649,14 +701,22 @@ impl PreviewService {viewers.push(user);}}- let _ = self- .events- .changed(preview, &viewers)- .await- .inspect_err(|error| tracing::warn!(error = ?error, "preview notification failed"));+ if let Err(error) = self.events.changed(preview, &viewers).await {+ tracing::warn!(?error, "preview notification failed");+ }}}-/// The agent session a receipt authorizes, rejecting receipts for anything else.+/// Reject public, unspecified, multicast, and link-local peer targets (including metadata endpoints).+fn validate_peer(address: std::net::SocketAddr) -> Result<(), PreviewError> {+ let allowed = match address.ip() {+ std::net::IpAddr::V4(ip) => ip.is_private() || ip.is_loopback(),+ std::net::IpAddr::V6(ip) => ip.is_unique_local() || ip.is_loopback(),+ };+ if !allowed || address.port() == 0 {+ return Err(PreviewError::Invalid);+ }+ Ok(())+}fn session_id<T: RequiredPermission>(receipt: &EntityAccessReceipt<T>,) -> Result<AgentSessionId, PreviewError> {@@ -666,13 +726,11 @@ fn session_id<T: RequiredPermission>(}entity.entity_id.parse().map_err(|_| PreviewError::Denied)}-fn find(registry: &Registry, id: &PreviewId) -> Result<Arc<Lease>, PreviewError> {- registry- .sessions- .values()- .find(|l| &l.preview().id == id)- .cloned()- .ok_or(PreviewError::Offline)+fn now_ms() -> i64 {+ SystemTime::now()+ .duration_since(UNIX_EPOCH)+ .unwrap_or_default()+ .as_millis() as i64}fn random() -> String {let mut bytes = [0u8; 32];@@ -682,6 +740,5 @@ fn random() -> String {fn digest(value: &str) -> [u8; 32] {Sha256::digest(value.as_bytes()).into()}-#[cfg(test)]mod test;diff --git a/crates/agent_preview/src/domain/service/test.rs b/crates/agent_preview/src/domain/service/test.rsindex 4401213654..fa75f17d0a 100644--- a/crates/agent_preview/src/domain/service/test.rs+++ b/crates/agent_preview/src/domain/service/test.rs@@ -9,17 +9,17 @@ async fn ssh_credentials_have_a_safe_username_prefix_without_losing_entropy() {let payload = share.token.strip_prefix("preview_").unwrap();assert_eq!(URL_SAFE_NO_PAD.decode(payload).unwrap().len(), 32);// The prefix is part of the credential, not merely a client-side decoration.- assert!(service.authenticate_ssh(payload).is_err());- assert!(service.authenticate_ssh(&share.token).is_ok());+ assert!(service.authenticate_ssh(payload).await.is_err());+ assert!(service.authenticate_ssh(&share.token).await.is_ok());}#[tokio::test]async fn ssh_credentials_are_single_use_and_forward_is_scoped() {let (service, _, _) = fixture(2222);let share = service.share(identity(), 3000).await.unwrap();- assert!(service.authenticate_ssh("wrong").is_err());- let lease = service.authenticate_ssh(&share.token).unwrap();- assert!(service.authenticate_ssh(&share.token).is_err());+ assert!(service.authenticate_ssh("wrong").await.is_err());+ let lease = service.authenticate_ssh(&share.token).await.unwrap();+ assert!(service.authenticate_ssh(&share.token).await.is_err());let tunnel = Arc::new(TcpTunnel("127.0.0.1:1".parse().unwrap()));assert!(service@@ -35,11 +35,12 @@ async fn ssh_credentials_are_single_use_and_forward_is_scoped() {.register(&lease, "127.0.0.1", 1, tunnel.clone()).unwrap();assert!(service.register(&lease, "127.0.0.1", 1, tunnel).is_err());- assert!(service.launch(receipt(AccessLevel::View)).is_err());+ assert!(service.launch(receipt(AccessLevel::View)).await.is_err());service.ready(&lease).await;assert_eq!(service.get(receipt(AccessLevel::View))+ .await.unwrap().unwrap().status,@@ -50,9 +51,9 @@ async fn ssh_credentials_are_single_use_and_forward_is_scoped() {async fn browser_tickets_are_host_bound_single_use_and_permissions_rechecked() {let (service, authority, _) = fixture(2222);let share = service.share(identity(), 3000).await.unwrap();- let lease = service.authenticate_ssh(&share.token).unwrap();+ let lease = service.authenticate_ssh(&share.token).await.unwrap();service.ready(&lease).await;- let launch = service.launch(receipt(AccessLevel::View)).unwrap();+ let launch = service.launch(receipt(AccessLevel::View)).await.unwrap();assert!(service.redeem(&PreviewId::generate(), &launch.ticket)@@ -95,28 +96,42 @@ async fn browser_tickets_are_host_bound_single_use_and_permissions_rechecked() {}#[tokio::test]async fn expiry_stop_and_token_timeout_close_access() {- let (service, _, _) = fixture(2222);+ let (service, authority, _) = fixture(2222);let share = service.share(identity(), 3000).await.unwrap();- service- .registry+ authority+ .1+ .0.lock().unwrap()- .ssh_tokens+ .credentials.get_mut(&digest(&share.token)).unwrap()- .expires = Instant::now();- assert!(service.authenticate_ssh(&share.token).is_err());- let lease = service.by_id(&share.preview.id).unwrap();+ .1+ .expires = 0;+ assert!(service.authenticate_ssh(&share.token).await.is_err());+ authority+ .1+ .0+ .lock()+ .unwrap()+ .credentials+ .get_mut(&digest(&share.token))+ .unwrap()+ .1+ .expires = now_ms() + 120000;+ let lease = service.authenticate_ssh(&share.token).await.unwrap();service.ready(&lease).await;- let launch = service.launch(receipt(AccessLevel::View)).unwrap();- service- .registry+ let launch = service.launch(receipt(AccessLevel::View)).await.unwrap();+ authority+ .1+ .0.lock().unwrap()- .tickets+ .credentials.get_mut(&digest(&launch.ticket)).unwrap()- .expires = Instant::now();+ .1+ .expires = 0;assert!(service.redeem(&share.preview.id, &launch.ticket)@@ -125,31 +140,19 @@ async fn expiry_stop_and_token_timeout_close_access() {);service.stop(receipt(AccessLevel::Edit)).await.unwrap();assert!(lease.cancel.is_cancelled());- assert!(service.launch(receipt(AccessLevel::View)).is_err());+ assert!(service.launch(receipt(AccessLevel::View)).await.is_err());}#[tokio::test]async fn quotas_bound_sessions_and_request_loops() {- let (service, _, _) = fixture(2222);+ let (service, authority, _) = fixture(2222);assert!(service.share(identity(), 0).await.is_err());for _ in 0..5 {let mut identity = identity();identity.session = AgentSessionId::new();- service- .registry- .lock()- .unwrap()- .accounts- .values_mut()- .for_each(|a| a.last_created = Instant::now() - TOKEN_TTL);+ authority.1.0.lock().unwrap().accounts.clear();service.share(identity, 3000).await.unwrap();}- service- .registry- .lock()- .unwrap()- .accounts- .values_mut()- .for_each(|a| a.last_created = Instant::now() - TOKEN_TTL);+ authority.1.0.lock().unwrap().accounts.clear();assert!(matches!(service.share(identity(), 3000).await,Err(PreviewError::Limited)@@ -177,7 +180,7 @@ fn isolated_domains_and_shell_fields_are_validated() {#[tokio::test]async fn stopping_a_preview_does_not_bypass_the_creation_interval() {- let (service, _, _) = fixture(2222);+ let (service, authority, _) = fixture(2222);service.share(identity(), 3000).await.unwrap();assert!(matches!(service.share(identity(), 3000).await,@@ -190,13 +193,7 @@ async fn stopping_a_preview_does_not_bypass_the_creation_interval() {service.share(identity(), 3000).await,Err(PreviewError::Limited)));- service- .registry- .lock()- .unwrap()- .accounts- .values_mut()- .for_each(|a| a.last_created = Instant::now() - TOKEN_TTL);+ authority.1.0.lock().unwrap().accounts.clear();service.share(identity(), 3000).await.unwrap();}#[test]@@ -227,3 +224,255 @@ fn local_stack_accepts_https_handoff_and_loopback_http_with_docker_ssh_fallback(settings.domain = "preview.example.test".into();assert!(settings.validate().is_err());}++#[tokio::test]+async fn forwarding_admission_precedes_dial_and_holds_slots_through_body() {+ use crate::domain::ports::{PeerConnector, Stream};+ use crate::inbound::http;+ use axum::{Router, body::Body, routing::get};+ use http_body_util::BodyExt;+ use std::sync::atomic::{AtomicUsize, Ordering};+ use tower::ServiceExt;+ struct CountedPeer(Arc<AtomicUsize>);+ #[async_trait::async_trait]+ impl PeerConnector for CountedPeer {+ async fn connect(&self, address: std::net::SocketAddr) -> Result<Stream, PreviewError> {+ self.0.fetch_add(1, Ordering::SeqCst);+ Ok(Box::new(+ tokio::net::TcpStream::connect(address).await.unwrap(),+ ))+ }+ }+ let (owner, authority, _) = fixture(2222);+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();+ let address = listener.local_addr().unwrap();+ owner.heartbeat(address).await.unwrap();+ // The fixture's initial heartbeat pins its address; emulate a replica+ // starting with its real listener rather than changing the registered address.+ authority+ .1+ .0+ .lock()+ .unwrap()+ .replicas+ .get_mut(&owner.replica)+ .unwrap()+ .0 = address;+ let calls = Arc::new(AtomicUsize::new(0));+ let follower = PreviewService::new(+ owner.settings().clone(),+ authority.clone(),+ Arc::new(TestEvents),+ authority.1.clone(),+ uuid::Uuid::now_v7(),+ Arc::new(CountedPeer(calls.clone())),+ )+ .unwrap();+ let release = Arc::new(tokio::sync::Notify::new());+ let body_release = release.clone();+ let upstream = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();+ let upstream_addr = upstream.local_addr().unwrap();+ let upstream_task = tokio::spawn(+ axum::serve(+ upstream,+ Router::new()+ .route(+ "/",+ get(move || {+ let release = body_release.clone();+ async move {+ Body::from_stream(futures_util::stream::once(async move {+ release.notified().await;+ Ok::<_, std::io::Error>(bytes::Bytes::from_static(b"streamed"))+ }))+ }+ }),+ )+ .route(+ "/socket",+ get(|ws: axum::extract::ws::WebSocketUpgrade| async {+ ws.on_upgrade(|mut socket| async move {+ while let Some(Ok(message)) = socket.recv().await {+ if socket.send(message).await.is_err() {+ break;+ }+ }+ })+ }),+ ),+ )+ .into_future(),+ );+ let share = follower.share(identity(), 3000).await.unwrap();+ let lease = owner.authenticate_ssh(&share.token).await.unwrap();+ owner+ .register(&lease, "127.0.0.1", 1, Arc::new(TcpTunnel(upstream_addr)))+ .unwrap();+ owner.ready(&lease).await;+ let launch = follower.launch(receipt(AccessLevel::View)).await.unwrap();+ let cookie = owner+ .redeem(&share.preview.id, &launch.ticket)+ .await+ .unwrap();+ let server = tokio::spawn(axum::serve(listener, http::router(owner.clone())).into_future());+ let app = http::router(follower.clone());+ let request = || {+ axum::http::Request::builder()+ .uri("/")+ .header("host", format!("{}.preview.test", share.preview.id))+ .header("cookie", format!("__Host-macro-preview={cookie}"))+ .body(Body::empty())+ .unwrap()+ };+ let held = follower+ .peer_slots+ .clone()+ .acquire_many_owned(1024)+ .await+ .unwrap();+ assert_eq!(+ app.clone().oneshot(request()).await.unwrap().status(),+ axum::http::StatusCode::TOO_MANY_REQUESTS+ );+ assert_eq!(calls.load(Ordering::SeqCst), 0);+ drop(held);+ let mut oversized = request();+ oversized+ .headers_mut()+ .insert("content-length", "16777217".parse().unwrap());+ assert_eq!(+ app.clone().oneshot(oversized).await.unwrap().status(),+ axum::http::StatusCode::BAD_REQUEST+ );+ assert_eq!(calls.load(Ordering::SeqCst), 0);+ let response = app.oneshot(request()).await.unwrap();+ assert_eq!(response.status(), axum::http::StatusCode::OK);+ assert_eq!(follower.peer_slots.available_permits(), 1023);+ release.notify_one();+ assert_eq!(+ response.into_body().collect().await.unwrap().to_bytes(),+ "streamed"+ );+ let all = tokio::time::timeout(+ Duration::from_secs(3),+ follower.peer_slots.clone().acquire_many_owned(1024),+ )+ .await+ .unwrap()+ .unwrap();+ drop(all);+ use futures_util::{SinkExt, StreamExt};+ use tokio_tungstenite::tungstenite::client::IntoClientRequest;+ let edge = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();+ let edge_address = edge.local_addr().unwrap();+ let edge_task = tokio::spawn(axum::serve(edge, http::router(follower.clone())).into_future());+ let host = format!("{}.preview.test", share.preview.id);+ let mut upgrade = format!("ws://{host}/socket").into_client_request().unwrap();+ upgrade+ .headers_mut()+ .insert("origin", format!("https://{host}").parse().unwrap());+ upgrade.headers_mut().insert(+ "cookie",+ format!("__Host-macro-preview={cookie}").parse().unwrap(),+ );+ let (mut ws, _) = tokio_tungstenite::client_async(+ upgrade,+ tokio::net::TcpStream::connect(edge_address).await.unwrap(),+ )+ .await+ .unwrap();+ ws.send(tokio_tungstenite::tungstenite::Message::Text(+ "held upgrade".into(),+ ))+ .await+ .unwrap();+ assert_eq!(+ ws.next().await.unwrap().unwrap().into_text().unwrap(),+ "held upgrade"+ );+ assert_eq!(follower.peer_slots.available_permits(), 1023);+ assert_eq!(follower.peer_upgrades.available_permits(), 127);+ ws.close(None).await.unwrap();+ drop(ws);+ let requests = tokio::time::timeout(+ Duration::from_secs(3),+ follower.peer_slots.clone().acquire_many_owned(1024),+ )+ .await+ .unwrap()+ .unwrap();+ let upgrades = tokio::time::timeout(+ Duration::from_secs(3),+ follower.peer_upgrades.clone().acquire_many_owned(128),+ )+ .await+ .unwrap()+ .unwrap();+ drop(requests);+ drop(upgrades);+ edge_task.abort();+ server.abort();+ upstream_task.abort();+}++#[tokio::test]+async fn disconnect_retries_fenced_cleanup_after_repository_failure() {+ let (service, authority, _) = fixture(2222);+ let share = service.share(identity(), 3000).await.unwrap();+ let lease = service.authenticate_ssh(&share.token).await.unwrap();+ service.ready(&lease).await;+ authority.1.1.store(true, Ordering::SeqCst);+ service.finish(&lease, PreviewStatus::Offline).await;+ assert!(lease.cancel.is_cancelled());+ assert_eq!(+ service+ .get(receipt(AccessLevel::View))+ .await+ .unwrap()+ .unwrap()+ .status,+ PreviewStatus::Ready+ );+ service.sweep().await;+ assert_eq!(+ service+ .get(receipt(AccessLevel::View))+ .await+ .unwrap()+ .unwrap()+ .status,+ PreviewStatus::Offline+ );+ assert!(!lease.pending_cleanup.load(Ordering::SeqCst));+}++#[tokio::test]+async fn revoked_agent_claim_retains_failed_cleanup_for_retry() {+ let (service, authority, _) = fixture(2222);+ let share = service.share(identity(), 3000).await.unwrap();+ authority.0.store(false, Ordering::SeqCst);+ authority.1.1.store(true, Ordering::SeqCst);+ assert!(matches!(+ service.authenticate_ssh(&share.token).await,+ Err(PreviewError::Denied)+ ));+ assert_eq!(+ service+ .get(receipt(AccessLevel::View))+ .await+ .unwrap()+ .unwrap()+ .status,+ PreviewStatus::Starting+ );+ service.sweep().await;+ assert_eq!(+ service+ .get(receipt(AccessLevel::View))+ .await+ .unwrap()+ .unwrap()+ .status,+ PreviewStatus::Offline+ );+}diff --git a/crates/agent_preview/src/domain/storage.rs b/crates/agent_preview/src/domain/storage.rsnew file mode 100644index 0000000000..95ed730633--- /dev/null+++ b/crates/agent_preview/src/domain/storage.rs@@ -0,0 +1,147 @@+//! Shared preview records. A preview ID is also its generation fence.+use super::{Preview, PreviewError, PreviewId, PreviewStatus};+use agent_fold::domain::log::AgentSessionId;+use async_trait::async_trait;+use macro_user_id::user_id::MacroUserIdStr;+use serde::{Deserialize, Serialize};+use std::net::SocketAddr;+use uuid::Uuid;++/// Durable metadata; never contains a live tunnel or plaintext credential.+#[derive(Clone, Debug, Serialize, Deserialize)]+pub struct StoredPreview {+ /// Public snapshot.+ pub preview: Preview,+ /// Account charged for this preview.+ pub user: MacroUserIdStr<'static>,+ /// Agent's local HTTP port.+ pub port: u16,+ /// Replica which atomically claimed the SSH credential, if connected.+ pub replica: Option<Uuid>,+}+/// Hash-only credential record, scoped to one preview generation.+#[derive(Clone)]+pub struct StoredCredential {+ /// Credential digest.+ pub hash: [u8; 32],+ /// Preview generation.+ pub preview: PreviewId,+ /// Viewer identity; absent for an SSH token.+ pub user: Option<MacroUserIdStr<'static>>,+ /// Unix milliseconds deadline.+ pub expires: i64,+}+/// Credential use, kept distinct so browser cookies cannot authenticate SSH.+#[derive(Clone, Copy)]+pub enum CredentialKind {+ /// One-use agent SSH credential.+ Ssh,+ /// One-use browser handoff.+ Ticket,+ /// Reusable, host-bound browser cookie.+ Browser,+}+impl CredentialKind {+ /// Persisted vocabulary.+ pub fn as_str(self) -> &'static str {+ match self {+ Self::Ssh => "ssh",+ Self::Ticket => "ticket",+ Self::Browser => "browser",+ }+ }+}+/// Creation policy supplied by the domain, enforced atomically by storage.+#[derive(Clone, Copy)]+pub struct CreationLimits {+ /// Retained, unexpired previews across all replicas.+ pub total: i64,+ /// Active previews charged to one account.+ pub account: i64,+ /// Minimum delay between shares for one account.+ pub pace_seconds: f64,+}+impl CreationLimits {+ /// Preview quota and pacing policy.+ pub const PREVIEW: Self = Self {+ total: 1000,+ account: 5,+ pace_seconds: 10.0,+ };+}+/// Bounded subscriber registry policy, supplied by the domain.+#[derive(Clone, Copy)]+pub struct WatchLimits {+ /// Maximum recently watched sessions.+ pub sessions: i64,+ /// Maximum viewers for one session.+ pub viewers: i64,+ /// Watcher expiry, Unix milliseconds.+ pub expires: i64,+}+/// Shared ownership and credential persistence. Every mutation is generation-fenced.+#[async_trait]+pub trait PreviewRepository: Send + Sync {+ /// Create/replace a session preview and its SSH credential, enforcing account budgets atomically.+ async fn create(+ &self,+ preview: StoredPreview,+ ssh: StoredCredential,+ limits: CreationLimits,+ ) -> Result<(), PreviewError>;+ /// Current preview for a session.+ async fn session(&self, session: AgentSessionId)+ -> Result<Option<StoredPreview>, PreviewError>;+ /// Resolve a current, unexpired preview generation.+ async fn preview(&self, id: &PreviewId) -> Result<StoredPreview, PreviewError>;+ /// Atomically consume SSH credential and claim the unowned preview for this live replica.+ async fn claim(&self, hash: [u8; 32], replica: Uuid) -> Result<StoredPreview, PreviewError>;+ /// Change status only if the generation and SSH owner still match.+ async fn status(+ &self,+ id: &PreviewId,+ replica: Uuid,+ status: PreviewStatus,+ ) -> Result<bool, PreviewError>;+ /// Stop the current generation; later readiness/cleanup cannot undo it.+ async fn stop(&self, session: AgentSessionId) -> Result<Option<StoredPreview>, PreviewError>;+ /// Store a hash-only ticket or browser credential for a live generation.+ async fn credential(+ &self,+ kind: CredentialKind,+ credential: StoredCredential,+ limit: i64,+ ) -> Result<(), PreviewError>;+ /// Read or atomically consume a host-bound credential. A wrong host never consumes it.+ async fn authenticate(+ &self,+ kind: CredentialKind,+ id: &PreviewId,+ hash: [u8; 32],+ consume: bool,+ ) -> Result<StoredCredential, PreviewError>;+ /// Heartbeat an authenticated, server-configured replica address. Expired replicas cannot revive old previews.+ async fn heartbeat(+ &self,+ replica: Uuid,+ address: SocketAddr,+ ttl_seconds: f64,+ ) -> Result<Vec<Preview>, PreviewError>;+ /// Resolve only live registered SSH owners; no client destination participates.+ async fn destination(&self, id: &PreviewId) -> Result<(Uuid, SocketAddr), PreviewError>;+ /// Track authorized subscribers for notifications across replicas.+ async fn watch(+ &self,+ session: AgentSessionId,+ user: &MacroUserIdStr<'_>,+ limits: WatchLimits,+ ) -> Result<(), PreviewError>;+ /// Recently authorized watchers, bounded by the repository.+ async fn watchers(+ &self,+ session: AgentSessionId,+ limit: i64,+ ) -> Result<Vec<MacroUserIdStr<'static>>, PreviewError>;+ /// Expire dead owners and reclaim credentials/leases/replicas.+ async fn sweep(&self) -> Result<Vec<Preview>, PreviewError>;+}diff --git a/crates/agent_preview/src/inbound/control.rs b/crates/agent_preview/src/inbound/control.rsindex aa15c90a06..76945433a9 100644--- a/crates/agent_preview/src/inbound/control.rs+++ b/crates/agent_preview/src/inbound/control.rs@@ -54,7 +54,7 @@ impl<Access, Auth> FromRef<ControlState<Access, Auth>> for MacroAuthorizationStastate.auth.clone()}}-/// Current session preview, including the absence of a lease after a gateway restart.+/// Shared session preview, including offline state when its SSH owner disappears.#[derive(serde::Serialize)]pub struct PreviewSnapshot {/// Current lease, or no preview.@@ -83,6 +83,7 @@ async fn read<Access: EntityAccessService, Auth: MacroAuthorizationService>(state.service.get(receipt.entity_access_receipt)+ .await.map(|preview| Json(PreviewSnapshot { preview }))}async fn open<Access: EntityAccessService, Auth: MacroAuthorizationService>(@@ -92,6 +93,7 @@ async fn open<Access: EntityAccessService, Auth: MacroAuthorizationService>(state.service.launch(receipt.entity_access_receipt)+ .await.map(Json)}async fn stop<Access: EntityAccessService, Auth: MacroAuthorizationService>(diff --git a/crates/agent_preview/src/inbound/http.rs b/crates/agent_preview/src/inbound/http.rsindex 385e1b611d..68428bb2dc 100644--- a/crates/agent_preview/src/inbound/http.rs+++ b/crates/agent_preview/src/inbound/http.rs@@ -36,11 +36,17 @@ impl IntoResponse for PreviewError {}/// Public listener. Mount only on the isolated preview domain, never a Macro cookie domain.pub fn router(service: PreviewService) -> Router {- Router::new().fallback(any(handle)).with_state(service)+ Router::new()+ .fallback(any(handle))+ .with_state(service)+ .layer(+ macro_tower_layers::MacroRequestIdAndTracingLayer::new(Duration::from_secs(2))+ .into_inner(),+ )}async fn handle(State(service): State<PreviewService>,- mut request: Request,+ request: Request,) -> Result<Response, PreviewError> {let host = request.headers()@@ -56,6 +62,51 @@ async fn handle(};let id = PreviewId::parse(host.strip_suffix(&suffix).ok_or(PreviewError::Invalid)?)?;let origin = settings.origin(&id);+ // Apply syntax/origin/body bounds before any peer dial. Tickets are consumed+ // only by the receiving owner below, never by the forwarding replica.+ let auth = request.uri().path() == AUTH_PATH;+ let upgrade = request+ .headers()+ .get(header::UPGRADE)+ .is_some_and(|v| v.as_bytes().eq_ignore_ascii_case(b"websocket"));+ if request.method() == Method::CONNECT+ || (request.headers().contains_key(header::UPGRADE) && !upgrade)+ {+ return Err(PreviewError::Invalid);+ }+ if auth+ && (request.method() != Method::POST+ || request+ .headers()+ .get(header::ORIGIN)+ .and_then(|v| v.to_str().ok())+ != Some(settings.app_origin.as_str()))+ {+ return Err(PreviewError::Denied);+ }+ let limit = if auth { 1024 } else { 16 * 1024 * 1024 };+ if request+ .headers()+ .get(header::CONTENT_LENGTH)+ .and_then(|v| v.to_str().ok())+ .and_then(|v| v.parse::<usize>().ok())+ .is_some_and(|len| len > limit)+ {+ return Err(PreviewError::Invalid);+ }+ let (parts, body) = request.into_parts();+ let mut request = Request::from_parts(parts, Body::new(Limited::new(body, limit)));+ if let Some(peer) = service+ .peer_stream(+ &id,+ request.headers().contains_key(super::peer::FORWARDED),+ upgrade,+ )+ .await?+ {+ return super::peer::forward(request, peer).await;+ }+ request.headers_mut().remove(super::peer::FORWARDED);if request.uri().path() == AUTH_PATH {if request.method() != Method::POST|| requestdiff --git a/crates/agent_preview/src/inbound/http/test.rs b/crates/agent_preview/src/inbound/http/test.rsindex ca23cc11df..fc419b612e 100644--- a/crates/agent_preview/src/inbound/http/test.rs+++ b/crates/agent_preview/src/inbound/http/test.rs@@ -81,13 +81,13 @@ async fn gateway_requires_ticket_and_preserves_request_target_and_streamed_respo.unwrap();});let share = service.share(identity(), address.port()).await.unwrap();- let lease = service.authenticate_ssh(&share.token).unwrap();+ let lease = service.authenticate_ssh(&share.token).await.unwrap();service.register(&lease, "127.0.0.1", 1, Arc::new(TcpTunnel(address))).unwrap();probe(&lease).await.unwrap();service.ready(&lease).await;- let launch = service.launch(receipt(AccessLevel::View)).unwrap();+ let launch = service.launch(receipt(AccessLevel::View)).await.unwrap();let host = format!("{}.preview.test", share.preview.id);let gateway = router(service.clone());let denied = gateway@@ -200,12 +200,12 @@ async fn non_upgraded_stream_holds_permit_and_rechecks_viewer_permission() {.unwrap();});let share = service.share(identity(), address.port()).await.unwrap();- let lease = service.authenticate_ssh(&share.token).unwrap();+ let lease = service.authenticate_ssh(&share.token).await.unwrap();service.register(&lease, "127.0.0.1", 1, Arc::new(TcpTunnel(address))).unwrap();service.ready(&lease).await;- let ticket = service.launch(receipt(AccessLevel::View)).unwrap();+ let ticket = service.launch(receipt(AccessLevel::View)).await.unwrap();let cookie = service.redeem(&share.preview.id, &ticket.ticket).awaitdiff --git a/crates/agent_preview/src/inbound/mod.rs b/crates/agent_preview/src/inbound/mod.rsindex 14344d59e2..172c9f9f8e 100644--- a/crates/agent_preview/src/inbound/mod.rs+++ b/crates/agent_preview/src/inbound/mod.rs@@ -7,3 +7,5 @@ pub mod http;pub mod ssh;/// Internal session-scoped MCP server.pub mod toolset;++mod peer;diff --git a/crates/agent_preview/src/inbound/peer.rs b/crates/agent_preview/src/inbound/peer.rsnew file mode 100644index 0000000000..d130fa624c--- /dev/null+++ b/crates/agent_preview/src/inbound/peer.rs@@ -0,0 +1,85 @@+//! One-hop HTTP transport, preserving the public request for owner-side checks.+use crate::domain::{PreviewError, ports::PeerConnection};+use axum::{body::Body, extract::Request, response::Response};+use hyper_util::rt::TokioIo;+use std::time::Duration;+use tracing::Instrument;+/// A routing marker grants no authentication. Any marked request needing a second hop is refused.+pub(super) const FORWARDED: &str = "x-macro-preview-hop";++#[tracing::instrument(skip_all, err)]+pub(super) async fn forward(+ mut request: Request,+ peer: PeerConnection,+) -> Result<Response, PreviewError> {+ let PeerConnection {+ stream,+ permit,+ upgrade_permit,+ } = peer;+ let upgrade = request.headers().get(axum::http::header::UPGRADE).is_some();+ // Connection tokens are client-controlled. Normalize this hop so they+ // cannot designate our routing marker (or auth/origin fields) for removal.+ request.headers_mut().remove(axum::http::header::CONNECTION);+ if upgrade {+ request.headers_mut().insert(+ axum::http::header::CONNECTION,+ axum::http::HeaderValue::from_static("upgrade"),+ );+ }+ request+ .headers_mut()+ .insert(FORWARDED, axum::http::HeaderValue::from_static("1"));+ macro_tower_layers::inject_trace_headers(request.headers_mut());+ *request.uri_mut() = request+ .uri()+ .path_and_query()+ .map(|p| p.as_str())+ .unwrap_or("/")+ .parse()+ .map_err(|_| PreviewError::Invalid)?;+ let downstream = upgrade.then(|| hyper::upgrade::on(&mut request));+ let (mut sender, connection) = hyper::client::conn::http1::Builder::new()+ .max_headers(64)+ .max_buf_size(32 * 1024)+ .handshake(TokioIo::new(stream))+ .await+ .map_err(|_| PreviewError::Unavailable)?;+ let connection_permit = permit.clone();+ tokio::spawn(+ async move {+ let _permit = connection_permit;+ if let Err(error) = connection.with_upgrades().await {+ tracing::debug!(?error, "preview peer connection ended");+ }+ }+ .instrument(tracing::Span::current()),+ );+ let mut response = tokio::time::timeout(Duration::from_secs(30), sender.send_request(request))+ .await+ .map_err(|_| PreviewError::Unavailable)?+ .map_err(|_| PreviewError::Unavailable)?;+ if response.status() == axum::http::StatusCode::SWITCHING_PROTOCOLS {+ let downstream = downstream.ok_or(PreviewError::Invalid)?;+ let upstream = hyper::upgrade::on(&mut response);+ tokio::spawn(+ async move {+ let _permit = permit;+ let _upgrade_permit = upgrade_permit;+ let upgraded = tokio::time::timeout(Duration::from_secs(10), async {+ Ok::<_, hyper::Error>((downstream.await?, upstream.await?))+ })+ .await;+ if let Ok(Ok((downstream, upstream))) = upgraded {+ let _ = tokio::io::copy_bidirectional(+ &mut TokioIo::new(downstream),+ &mut TokioIo::new(upstream),+ )+ .await;+ }+ }+ .instrument(tracing::Span::current()),+ );+ }+ Ok(response.map(Body::new))+}diff --git a/crates/agent_preview/src/inbound/ssh.rs b/crates/agent_preview/src/inbound/ssh.rsindex e21e6a6996..597bf61bcf 100644--- a/crates/agent_preview/src/inbound/ssh.rs+++ b/crates/agent_preview/src/inbound/ssh.rs@@ -83,7 +83,16 @@ pub async fn serve(result = tokio::time::timeout(Duration::from_secs(15), authenticated.cancelled()) => result.is_ok(),};if authenticated_in_time {- tokio::select! { _ = shutdown.cancelled() => {}, _ = &mut running => {} }+ let connected = lease.lock().expect("connection mutex").clone();+ if let Some(connected) = connected {+ // Cancellation also closes authenticated transports which+ // have not registered a forward yet (no Tunnel handle exists).+ tokio::select! {+ _ = shutdown.cancelled() => {},+ _ = connected.cancel.cancelled() => {},+ _ = &mut running => {},+ }+ }}let _ = handle.disconnect(@@ -112,7 +121,7 @@ impl Handler for Connection {if user.len() > 128 {return Ok(Auth::reject());}- match self.service.authenticate_ssh(user) {+ match self.service.authenticate_ssh(user).await {Ok(lease) => {*self.lease.lock().expect("connection mutex") = Some(lease);self.authenticated.cancel();diff --git a/crates/agent_preview/src/inbound/ssh/test.rs b/crates/agent_preview/src/inbound/ssh/test.rsindex 552dd96230..12544bb6d7 100644--- a/crates/agent_preview/src/inbound/ssh/test.rs+++ b/crates/agent_preview/src/inbound/ssh/test.rs@@ -93,7 +93,11 @@ async fn stock_openssh_forwards_http_and_websockets_and_stop_closes_them() {assert!(status.success(), "generated script failed");tokio::time::timeout(Duration::from_secs(15), async {loop {- let preview = service.get(receipt(AccessLevel::View)).unwrap().unwrap();+ let preview = service+ .get(receipt(AccessLevel::View))+ .await+ .unwrap()+ .unwrap();if preview.status == PreviewStatus::Ready {break;}@@ -102,7 +106,7 @@ async fn stock_openssh_forwards_http_and_websockets_and_stop_closes_them() {}).await.unwrap();- let ticket = service.launch(receipt(AccessLevel::View)).unwrap();+ let ticket = service.launch(receipt(AccessLevel::View)).await.unwrap();let cookie = service.redeem(&preview, &ticket.ticket).await.unwrap();let lease = service.viewer(&preview, &cookie, true).await.unwrap();let mut stream = lease.tunnel().unwrap().open().await.unwrap();@@ -288,3 +292,68 @@ async fn gateway_refuses_outbound_relay_and_shell() {shutdown.cancel();let _ = server.await;}++#[tokio::test]+async fn stop_closes_authenticated_ssh_before_a_forward_is_registered() {+ struct Client {+ key: russh::keys::PublicKey,+ closed: Arc<tokio::sync::Notify>,+ }+ impl russh::client::Handler for Client {+ type Error = russh::Error;+ async fn check_server_key(+ &mut self,+ key: &russh::keys::PublicKeyOrCertificate,+ ) -> Result<bool, Self::Error> {+ // SSH transmits key material without the fixture's OpenSSH comment.+ Ok(key.public_key().key_data() == self.key.key_data())+ }+ async fn disconnected(+ &mut self,+ reason: russh::client::DisconnectReason<Self::Error>,+ ) -> Result<(), Self::Error> {+ self.closed.notify_one();+ match reason {+ russh::client::DisconnectReason::ReceivedDisconnect(_) => Ok(()),+ russh::client::DisconnectReason::Error(error) => Err(error),+ }+ }+ }+ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let address = listener.local_addr().unwrap();+ let (service, _, key) = fixture(address.port());+ let pinned = key.public_key().clone();+ let shutdown = CancellationToken::new();+ let server = tokio::spawn(serve(+ listener,+ key,+ service.clone(),+ Arc::new(|h| Arc::new(SshTunnel::new(h))),+ shutdown.clone(),+ ));+ let share = service.share(identity(), 3000).await.unwrap();+ let closed = Arc::new(tokio::sync::Notify::new());+ let mut client = russh::client::connect(+ Arc::new(russh::client::Config::default()),+ address,+ Client {+ key: pinned,+ closed: closed.clone(),+ },+ )+ .await+ .unwrap();+ assert!(+ client+ .authenticate_none(share.token)+ .await+ .unwrap()+ .success()+ );+ service.stop(receipt(AccessLevel::Edit)).await.unwrap();+ tokio::time::timeout(Duration::from_secs(3), closed.notified())+ .await+ .unwrap();+ shutdown.cancel();+ server.await.unwrap().unwrap();+}diff --git a/crates/agent_preview/src/outbound/mod.rs b/crates/agent_preview/src/outbound/mod.rsindex c7827ed33d..0766a0470c 100644--- a/crates/agent_preview/src/outbound/mod.rs+++ b/crates/agent_preview/src/outbound/mod.rs@@ -1,3 +1,9 @@//! Implementations of preview transport capabilities./// Open forwarded channels on a registered SSH connection.pub mod ssh_tunnel;++/// Postgres preview ownership and credentials.+pub mod postgres;++/// Direct replica transport.+pub mod peer;diff --git a/crates/agent_preview/src/outbound/peer.rs b/crates/agent_preview/src/outbound/peer.rsnew file mode 100644index 0000000000..3461643149--- /dev/null+++ b/crates/agent_preview/src/outbound/peer.rs@@ -0,0 +1,44 @@+//! Direct peer TCP transport; HTTP and upgrades stream without a command bus.+use crate::domain::{+ PreviewError,+ ports::{PeerConnector, Stream},+};+use async_trait::async_trait;+use std::{net::SocketAddr, time::Duration};+/// Connects only to endpoints resolved and validated by the domain registry.+pub struct TcpPeerConnector;+#[async_trait]+impl PeerConnector for TcpPeerConnector {+ #[tracing::instrument(skip_all, err)]+ async fn connect(&self, address: SocketAddr) -> Result<Stream, PreviewError> {+ let socket = tokio::time::timeout(+ Duration::from_secs(3),+ tokio::net::TcpStream::connect(address),+ )+ .await+ .map_err(|_| PreviewError::Unavailable)?+ .map_err(|_| PreviewError::Unavailable)?;+ Ok(Box::new(socket))+ }+}++/// UDP connect selects a local interface without sending packets or reading ECS secrets.+/// Works for awsvpc tasks and local Docker networks without another deployment setting.+pub async fn address(database_url: &str, port: u16) -> Result<SocketAddr, rootcause::Report> {+ let database = url::Url::parse(database_url)?;+ let host = database+ .host_str()+ .ok_or_else(|| rootcause::report!("database host required"))?;+ let remote = tokio::net::lookup_host((host, database.port().unwrap_or(5432)))+ .await?+ .next()+ .ok_or_else(|| rootcause::report!("database address required"))?;+ let bind = if remote.is_ipv4() {+ "0.0.0.0:0"+ } else {+ "[::]:0"+ };+ let socket = tokio::net::UdpSocket::bind(bind).await?;+ socket.connect(remote).await?;+ Ok(SocketAddr::new(socket.local_addr()?.ip(), port))+}diff --git a/crates/agent_preview/src/outbound/postgres.rs b/crates/agent_preview/src/outbound/postgres.rsnew file mode 100644index 0000000000..a15e814cbb--- /dev/null+++ b/crates/agent_preview/src/outbound/postgres.rs@@ -0,0 +1,329 @@+//! Preview-specific shared state; the session management rows remain untouched.+use crate::domain::{PreviewError, PreviewId, PreviewStatus, storage::*};+use agent_fold::domain::log::AgentSessionId;+use async_trait::async_trait;+use chrono::{DateTime, Utc};+use macro_user_id::user_id::MacroUserIdStr;+use sqlx::{PgPool, types::Json};+use std::net::SocketAddr;+use uuid::Uuid;++/// Postgres ownership registry and hash-only credential store.+#[derive(Clone)]+pub struct PgPreviewRepository {+ pool: PgPool,+}+impl PgPreviewRepository {+ /// Use the host's existing MacroDB pool.+ pub fn new(pool: PgPool) -> Self {+ Self { pool }+ }+}+fn unavailable(error: sqlx::Error) -> PreviewError {+ tracing::warn!(?error, "preview repository failed");+ PreviewError::Unavailable+}+fn timestamp(ms: i64) -> Result<DateTime<Utc>, PreviewError> {+ DateTime::from_timestamp_millis(ms).ok_or(PreviewError::Invalid)+}+fn status(value: PreviewStatus) -> &'static str {+ match value {+ PreviewStatus::Starting => "starting",+ PreviewStatus::Ready => "ready",+ PreviewStatus::Offline => "offline",+ PreviewStatus::Expired => "expired",+ PreviewStatus::Stopped => "stopped",+ }+}+fn record(+ mut metadata: StoredPreview,+ replica: Option<Uuid>,+ state: &str,+) -> Result<StoredPreview, PreviewError> {+ metadata.replica = replica;+ metadata.preview.status = match state {+ "starting" => PreviewStatus::Starting,+ "ready" => PreviewStatus::Ready,+ "offline" => PreviewStatus::Offline,+ "expired" => PreviewStatus::Expired,+ "stopped" => PreviewStatus::Stopped,+ _ => return Err(PreviewError::Unavailable),+ };+ Ok(metadata)+}+#[async_trait]+impl PreviewRepository for PgPreviewRepository {+ #[tracing::instrument(skip_all, fields(session_id = %preview.preview.agent_session_id), err)]+ async fn create(+ &self,+ preview: StoredPreview,+ ssh: StoredCredential,+ limits: CreationLimits,+ ) -> Result<(), PreviewError> {+ let mut tx = self.pool.begin().await.map_err(unavailable)?;+ // Serialize quota checks and replacement across replicas, including when+ // there is no previous preview row to lock. This table is bounded (1000).+ sqlx::query!("LOCK TABLE agent_preview_lease IN EXCLUSIVE MODE")+ .execute(&mut *tx)+ .await+ .map_err(unavailable)?;+ let session = preview.preview.agent_session_id.as_uuid();+ let user: &str = preview.user.as_ref();+ let budget = sqlx::query!(+ r#"SELECT count(*) FILTER (WHERE session_id <> $2) AS "total!",+ count(*) FILTER (WHERE user_id = $1 AND status IN ('starting', 'ready') AND session_id <> $2) AS "account!",+ EXISTS (SELECT 1 FROM agent_preview_lease WHERE user_id = $1 AND created_at > now() - make_interval(secs => $3)) AS "paced!"+ FROM agent_preview_lease WHERE expires_at > now()"#, user, session, limits.pace_seconds+ ).fetch_one(&mut *tx).await.map_err(unavailable)?;+ if budget.total >= limits.total || budget.account >= limits.account || budget.paced {+ return Err(PreviewError::Limited);+ }+ sqlx::query!(+ "DELETE FROM agent_preview_lease WHERE session_id = $1",+ session+ )+ .execute(&mut *tx)+ .await+ .map_err(unavailable)?;+ let id = preview.preview.id.to_string();+ let expires = timestamp(preview.preview.expires_at as i64)?;+ sqlx::query!(+ "INSERT INTO agent_preview_lease (id, session_id, user_id, metadata, status, expires_at) VALUES ($1, $2, $3, $4, 'starting', $5)",+ id, session, user, Json(&preview) as _, expires+ ).execute(&mut *tx).await.map_err(unavailable)?;+ let token_expiry = timestamp(ssh.expires)?;+ sqlx::query!(+ "INSERT INTO agent_preview_credential (hash, kind, preview_id, expires_at) VALUES ($1, 'ssh', $2, $3)",+ ssh.hash.as_slice(), id, token_expiry+ ).execute(&mut *tx).await.map_err(unavailable)?;+ tx.commit().await.map_err(unavailable)+ }+ #[tracing::instrument(skip_all, fields(session_id = %session), err)]+ async fn session(+ &self,+ session: AgentSessionId,+ ) -> Result<Option<StoredPreview>, PreviewError> {+ let row = sqlx::query!(+ r#"SELECT metadata AS "metadata: Json<StoredPreview>", replica_id,+ CASE WHEN l.expires_at <= now() THEN 'expired'+ WHEN l.replica_id IS NOT NULL AND NOT EXISTS+ (SELECT 1 FROM agent_preview_replica r WHERE r.id = l.replica_id AND r.expires_at > now()) AND l.status IN ('starting','ready')+ THEN 'offline' ELSE status END AS "state!"+ FROM agent_preview_lease l WHERE session_id = $1"#, session.as_uuid()+ ).fetch_optional(&self.pool).await.map_err(unavailable)?;+ row.map(|r| record(r.metadata.0, r.replica_id, &r.state))+ .transpose()+ }+ #[tracing::instrument(skip_all, fields(preview_id = %id), err)]+ async fn preview(&self, id: &PreviewId) -> Result<StoredPreview, PreviewError> {+ let row = sqlx::query!(+ r#"SELECT metadata AS "metadata: Json<StoredPreview>", replica_id, status+ FROM agent_preview_lease l WHERE id = $1 AND expires_at > now()+ AND status IN ('starting','ready') AND (replica_id IS NULL OR EXISTS+ (SELECT 1 FROM agent_preview_replica r WHERE r.id = l.replica_id AND r.expires_at > now()))"#, id.to_string()+ ).fetch_optional(&self.pool).await.map_err(unavailable)?.ok_or(PreviewError::Offline)?;+ record(row.metadata.0, row.replica_id, &row.status)+ }+ #[tracing::instrument(skip_all, fields(%replica), err)]+ async fn claim(&self, hash: [u8; 32], replica: Uuid) -> Result<StoredPreview, PreviewError> {+ let row = sqlx::query!(+ r#"WITH credential AS (+ DELETE FROM agent_preview_credential WHERE hash = $1 AND kind = 'ssh' AND expires_at > now()+ RETURNING preview_id+ ) UPDATE agent_preview_lease l SET replica_id = $2 FROM credential c+ WHERE l.id = c.preview_id AND l.replica_id IS NULL AND l.status = 'starting'+ AND l.expires_at > now() AND EXISTS (SELECT 1 FROM agent_preview_replica WHERE id = $2 AND expires_at > now())+ RETURNING l.metadata AS "metadata: Json<StoredPreview>", l.status"#,+ hash.as_slice(), replica+ ).fetch_optional(&self.pool).await.map_err(unavailable)?.ok_or(PreviewError::Denied)?;+ record(row.metadata.0, Some(replica), &row.status)+ }+ #[tracing::instrument(skip_all, fields(preview_id = %id, %replica), err)]+ async fn status(+ &self,+ id: &PreviewId,+ replica: Uuid,+ next: PreviewStatus,+ ) -> Result<bool, PreviewError> {+ let updated = sqlx::query!(+ "UPDATE agent_preview_lease l SET status = $3 WHERE id = $1 AND replica_id = $2 AND status IN ('starting','ready') AND expires_at > now() AND EXISTS (SELECT 1 FROM agent_preview_replica WHERE id = $2 AND expires_at > now())",+ id.to_string(), replica, status(next)+ ).execute(&self.pool).await.map_err(unavailable)?;+ Ok(updated.rows_affected() == 1)+ }+ async fn stop(&self, session: AgentSessionId) -> Result<Option<StoredPreview>, PreviewError> {+ let row = sqlx::query!(+ r#"UPDATE agent_preview_lease SET status = 'stopped' WHERE session_id = $1+ RETURNING metadata AS "metadata: Json<StoredPreview>", replica_id, status"#,+ session.as_uuid()+ )+ .fetch_optional(&self.pool)+ .await+ .map_err(unavailable)?;+ row.map(|r| record(r.metadata.0, r.replica_id, &r.status))+ .transpose()+ }+ #[tracing::instrument(skip_all, fields(preview_id = %credential.preview), err)]+ async fn credential(+ &self,+ kind: CredentialKind,+ credential: StoredCredential,+ limit: i64,+ ) -> Result<(), PreviewError> {+ let user = credential.user.as_ref().map(|u| u.as_ref());+ let expires = timestamp(credential.expires)?;+ let mut tx = self.pool.begin().await.map_err(unavailable)?;+ // Credential creation is infrequent; the same lock order as create()+ // serializes global bounds and prevents stop/re-share racing issuance.+ sqlx::query!("LOCK TABLE agent_preview_lease IN EXCLUSIVE MODE")+ .execute(&mut *tx)+ .await+ .map_err(unavailable)?;+ let inserted = sqlx::query!(+ r#"INSERT INTO agent_preview_credential (hash, kind, preview_id, user_id, expires_at)+ SELECT $1, $2, id, $4, LEAST($5, expires_at) FROM agent_preview_lease l+ WHERE id = $3 AND status = 'ready' AND expires_at > now()+ AND EXISTS (SELECT 1 FROM agent_preview_replica r WHERE r.id = l.replica_id AND r.expires_at > now())+ AND (SELECT count(*) FROM agent_preview_credential WHERE kind = $2 AND expires_at > now()) < $6"#,+ credential.hash.as_slice(), kind.as_str(), credential.preview.to_string(), user, expires,+ limit+ ).execute(&mut *tx).await.map_err(unavailable)?;+ if inserted.rows_affected() == 0 {+ let live = sqlx::query_scalar!(+ r#"SELECT EXISTS (SELECT 1 FROM agent_preview_lease l+ WHERE id = $1 AND status = 'ready' AND expires_at > now()+ AND EXISTS (SELECT 1 FROM agent_preview_replica r WHERE r.id = l.replica_id AND r.expires_at > now())) AS "live!""#,+ credential.preview.to_string()+ ).fetch_one(&mut *tx).await.map_err(unavailable)?;+ return Err(if live {+ PreviewError::Limited+ } else {+ PreviewError::Offline+ });+ }+ tx.commit().await.map_err(unavailable)?;+ Ok(())+ }+ #[tracing::instrument(skip_all, fields(preview_id = %id), err)]+ async fn authenticate(+ &self,+ kind: CredentialKind,+ id: &PreviewId,+ hash: [u8; 32],+ consume: bool,+ ) -> Result<StoredCredential, PreviewError> {+ // Atomic DELETE consumes a ticket once. Reusable cookies take no row+ // lock, so one browser's Vite module fan-out can authenticate concurrently.+ let row = if consume {+ sqlx::query!(+ "DELETE FROM agent_preview_credential WHERE hash = $1 AND preview_id = $2 AND kind = $3 AND expires_at > now() RETURNING user_id, expires_at",+ hash.as_slice(), id.to_string(), kind.as_str()+ ).fetch_optional(&self.pool).await.map_err(unavailable)?.map(|r| (r.user_id, r.expires_at))+ } else {+ sqlx::query!(+ "SELECT user_id, expires_at FROM agent_preview_credential WHERE hash = $1 AND preview_id = $2 AND kind = $3 AND expires_at > now()",+ hash.as_slice(), id.to_string(), kind.as_str()+ ).fetch_optional(&self.pool).await.map_err(unavailable)?.map(|r| (r.user_id, r.expires_at))+ }.ok_or(PreviewError::Denied)?;+ Ok(StoredCredential {+ hash,+ preview: id.clone(),+ user: row+ .0+ .map(MacroUserIdStr::try_from)+ .transpose()+ .map_err(|_| PreviewError::Unavailable)?,+ expires: row.1.timestamp_millis(),+ })+ }+ #[tracing::instrument(skip_all, fields(%replica), err)]+ async fn heartbeat(+ &self,+ replica: Uuid,+ address: SocketAddr,+ ttl_seconds: f64,+ ) -> Result<Vec<crate::domain::Preview>, PreviewError> {+ let mut tx = self.pool.begin().await.map_err(unavailable)?;+ // Invalidate old transports before refreshing a heartbeat after a pause.+ // The same process may resume, but its expired claims never become live again.+ let transitions = sqlx::query!(+ r#"UPDATE agent_preview_lease SET status = 'offline' WHERE replica_id = $1 AND status IN ('starting','ready') AND EXISTS (SELECT 1 FROM agent_preview_replica WHERE id = $1 AND expires_at <= now()) RETURNING metadata AS "metadata: Json<StoredPreview>", replica_id, status"#, replica+ ).fetch_all(&mut *tx).await.map_err(unavailable)?;+ sqlx::query!(+ "INSERT INTO agent_preview_replica (id, address, expires_at) VALUES ($1, $2, now() + make_interval(secs => $3)) ON CONFLICT (id) DO UPDATE SET expires_at = EXCLUDED.expires_at",+ replica, address.to_string(), ttl_seconds+ ).execute(&mut *tx).await.map_err(unavailable)?;+ tx.commit().await.map_err(unavailable)?;+ transitions+ .into_iter()+ .map(|r| record(r.metadata.0, r.replica_id, &r.status).map(|p| p.preview))+ .collect()+ }+ async fn destination(&self, id: &PreviewId) -> Result<(Uuid, SocketAddr), PreviewError> {+ let row = sqlx::query!(+ "SELECT r.id, r.address FROM agent_preview_replica r JOIN agent_preview_lease l ON l.replica_id = r.id WHERE l.id = $1 AND l.status IN ('starting','ready') AND l.expires_at > now() AND r.expires_at > now()", id.to_string()+ ).fetch_optional(&self.pool).await.map_err(unavailable)?.ok_or(PreviewError::Offline)?;+ Ok((+ row.id,+ row.address.parse().map_err(|_| PreviewError::Unavailable)?,+ ))+ }+ async fn watch(+ &self,+ session: AgentSessionId,+ user: &MacroUserIdStr<'_>,+ limits: WatchLimits,+ ) -> Result<(), PreviewError> {+ let expires = timestamp(limits.expires)?;+ let mut tx = self.pool.begin().await.map_err(unavailable)?;+ sqlx::query!("LOCK TABLE agent_preview_watcher IN EXCLUSIVE MODE")+ .execute(&mut *tx)+ .await+ .map_err(unavailable)?;+ sqlx::query!(+ r#"INSERT INTO agent_preview_watcher (session_id, user_id, expires_at)+ SELECT $1, $2, $3 WHERE+ EXISTS (SELECT 1 FROM agent_preview_watcher WHERE session_id = $1 AND user_id = $2 AND expires_at > now())+ OR ((SELECT count(*) FROM agent_preview_watcher WHERE session_id = $1 AND expires_at > now()) < $4+ AND (EXISTS (SELECT 1 FROM agent_preview_watcher WHERE session_id = $1 AND expires_at > now())+ OR (SELECT count(DISTINCT session_id) FROM agent_preview_watcher WHERE expires_at > now()) < $5))+ ON CONFLICT (session_id, user_id) DO UPDATE SET expires_at = EXCLUDED.expires_at"#,+ session.as_uuid(), user.as_ref(), expires, limits.viewers, limits.sessions+ ).execute(&mut *tx).await.map_err(unavailable)?;+ tx.commit().await.map_err(unavailable)+ }+ async fn watchers(+ &self,+ session: AgentSessionId,+ limit: i64,+ ) -> Result<Vec<MacroUserIdStr<'static>>, PreviewError> {+ sqlx::query_scalar!("SELECT user_id FROM agent_preview_watcher WHERE session_id = $1 AND expires_at > now() ORDER BY user_id LIMIT $2", session.as_uuid(), limit)+ .fetch_all(&self.pool).await.map_err(unavailable)?.into_iter().map(|u| MacroUserIdStr::try_from(u).map_err(|_| PreviewError::Unavailable)).collect()+ }+ #[tracing::instrument(skip_all, err)]+ async fn sweep(&self) -> Result<Vec<crate::domain::Preview>, PreviewError> {+ let transitions = sqlx::query!(r#"UPDATE agent_preview_lease l SET status = CASE WHEN l.expires_at <= now() THEN 'expired' ELSE 'offline' END WHERE status IN ('starting','ready') AND (l.expires_at <= now() OR (replica_id IS NOT NULL AND NOT EXISTS (SELECT 1 FROM agent_preview_replica r WHERE r.id = l.replica_id AND r.expires_at > now()))) RETURNING metadata AS "metadata: Json<StoredPreview>", replica_id, status"#).fetch_all(&self.pool).await.map_err(unavailable)?;+ sqlx::query!("DELETE FROM agent_preview_credential WHERE expires_at <= now()")+ .execute(&self.pool)+ .await+ .map_err(unavailable)?;+ sqlx::query!(+ "DELETE FROM agent_preview_lease WHERE expires_at < now() - interval '5 minutes'"+ )+ .execute(&self.pool)+ .await+ .map_err(unavailable)?;+ sqlx::query!("DELETE FROM agent_preview_watcher WHERE expires_at <= now()")+ .execute(&self.pool)+ .await+ .map_err(unavailable)?;+ sqlx::query!("DELETE FROM agent_preview_replica r WHERE expires_at < now() - interval '7 days' AND NOT EXISTS (SELECT 1 FROM agent_preview_lease l WHERE l.replica_id = r.id)").execute(&self.pool).await.map_err(unavailable)?;+ transitions+ .into_iter()+ .map(|r| record(r.metadata.0, r.replica_id, &r.status).map(|p| p.preview))+ .collect()+ }+}++#[cfg(test)]+mod test;diff --git a/crates/agent_preview/src/outbound/postgres/test.rs b/crates/agent_preview/src/outbound/postgres/test.rsnew file mode 100644index 0000000000..5b1cfa206e--- /dev/null+++ b/crates/agent_preview/src/outbound/postgres/test.rs@@ -0,0 +1,584 @@+use super::*;+use crate::{+ domain::{PreviewService, ports::Events},+ inbound,+ outbound::{peer::TcpPeerConnector, ssh_tunnel::SshTunnel},+ testing::*,+};+use axum::{+ Router,+ extract::ws::{Message, WebSocketUpgrade},+ response::IntoResponse,+ routing::get,+};+use entity_access::domain::models::AccessLevel;+use futures_util::{SinkExt, StreamExt};+use http_body_util::BodyExt;+use macro_db_migrator::MACRO_DB_MIGRATIONS;+use std::sync::{Arc, Mutex};+use tokio::{+ net::{TcpListener, TcpStream},+ sync::Notify,+};+use tokio_util::sync::CancellationToken;++#[derive(Default)]+struct RecordedEvents {+ changes: Mutex<Vec<crate::domain::Preview>>,+ ready: Notify,+}+#[async_trait]+impl Events for RecordedEvents {+ async fn changed(+ &self,+ p: &crate::domain::Preview,+ _: &[MacroUserIdStr<'static>],+ ) -> Result<(), PreviewError> {+ self.changes.lock().unwrap().push(p.clone());+ if p.status == PreviewStatus::Ready {+ self.ready.notify_one();+ }+ Ok(())+ }+}+fn repository(pool: PgPool) -> Arc<PgPreviewRepository> {+ Arc::new(PgPreviewRepository::new(pool))+}+fn replica(+ base: &PreviewService,+ authority: Arc<TestAuthority>,+ repo: Arc<PgPreviewRepository>,+ events: Arc<RecordedEvents>,+ id: Uuid,+) -> PreviewService {+ PreviewService::new(+ base.settings().clone(),+ authority,+ events,+ repo,+ id,+ Arc::new(TcpPeerConnector),+ )+ .unwrap()+}+async fn http(+ address: SocketAddr,+ host: &str,+ path: &str,+ method: &str,+ headers: &[(&str, String)],+ body: &str,+) -> axum::response::Response {+ let socket = TcpStream::connect(address).await.unwrap();+ let (mut sender, connection) =+ hyper::client::conn::http1::handshake(hyper_util::rt::TokioIo::new(socket))+ .await+ .unwrap();+ tokio::spawn(async move {+ connection.with_upgrades().await.unwrap();+ });+ let mut request = hyper::Request::builder()+ .method(method)+ .uri(path)+ .header("host", host);+ for (k, v) in headers {+ request = request.header(*k, v);+ }+ let result = sender+ .send_request(+ request+ .body(axum::body::Body::from(body.to_owned()))+ .unwrap(),+ )+ .await+ .unwrap();+ result.map(axum::body::Body::new)+}++#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]+async fn two_replicas_route_stock_ssh_browser_http_and_websocket(pool: PgPool) {+ let repo = repository(pool.clone());+ let upstream = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let app_port = upstream.local_addr().unwrap().port();+ let upstream_task = tokio::spawn(+ axum::serve(+ upstream,+ Router::new()+ .route("/", get(|| async { "cross replica preview" }))+ .route(+ "/socket",+ get(|ws: WebSocketUpgrade| async {+ ws.on_upgrade(|mut s| async move {+ while let Some(Ok(Message::Text(t))) = s.recv().await {+ if s.send(Message::Text(t)).await.is_err() {+ break;+ }+ }+ })+ .into_response()+ }),+ ),+ )+ .into_future(),+ );+ let ssh_listener = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let (a_base, authority, key) = fixture(ssh_listener.local_addr().unwrap().port());+ let events = Arc::new(RecordedEvents::default());+ let a_id = Uuid::now_v7();+ let b_id = Uuid::now_v7();+ let a = replica(+ &a_base,+ authority.clone(),+ repo.clone(),+ events.clone(),+ a_id,+ );+ let b = replica(&a_base, authority, repo.clone(), events.clone(), b_id);+ let public_a = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let a_addr = public_a.local_addr().unwrap();+ let public_b = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let b_addr = public_b.local_addr().unwrap();+ a.heartbeat(a_addr).await.unwrap();+ b.heartbeat(b_addr).await.unwrap();+ let a_server =+ tokio::spawn(axum::serve(public_a, inbound::http::router(a.clone())).into_future());+ let b_server =+ tokio::spawn(axum::serve(public_b, inbound::http::router(b.clone())).into_future());+ let shutdown = CancellationToken::new();+ let ssh_server = tokio::spawn(inbound::ssh::serve(+ ssh_listener,+ key.clone(),+ b.clone(),+ Arc::new(|h| Arc::new(SshTunnel::new(h))),+ shutdown.clone(),+ ));+ let share = a.share(identity(), app_port).await.unwrap();+ let host = format!("{}.preview.test", share.preview.id);+ assert!(matches!(+ a.destination(&share.preview.id).await,+ Err(PreviewError::Offline)+ ));+ assert_eq!(+ http(a_addr, &host, "/", "GET", &[], "").await.status(),+ axum::http::StatusCode::GONE+ );+ // The agent's create reaches A; independently balanced SSH reaches B.+ let dir = tempfile::tempdir().unwrap();+ let known = dir.path().join("known_hosts");+ std::fs::write(+ &known,+ format!(+ "[localhost]:{} {}\n",+ a.settings().ssh_port,+ inbound::ssh::public_key(&key).unwrap()+ ),+ )+ .unwrap();+ let mut ssh = tokio::process::Command::new("ssh")+ .args([+ "-F",+ "/dev/null",+ "-NT",+ "-o",+ "BatchMode=yes",+ "-o",+ "PubkeyAuthentication=no",+ "-o",+ "StrictHostKeyChecking=yes",+ "-o",+ "ExitOnForwardFailure=yes",+ "-o",+ ])+ .arg(format!("UserKnownHostsFile={}", known.display()))+ .args([+ "-p",+ &a.settings().ssh_port.to_string(),+ "-l",+ &share.token,+ "-R",+ &format!("127.0.0.1:1:127.0.0.1:{app_port}"),+ "localhost",+ ])+ .kill_on_drop(true)+ .spawn()+ .unwrap();+ tokio::time::timeout(std::time::Duration::from_secs(15), events.ready.notified())+ .await+ .unwrap();+ assert!(a.authenticate_ssh(&share.token).await.is_err());+ assert_eq!(+ a.get(receipt(AccessLevel::View))+ .await+ .unwrap()+ .unwrap()+ .status,+ PreviewStatus::Ready+ );+ let ticket = a.launch(receipt(AccessLevel::View)).await.unwrap();+ // Wrong origin is rejected on the forwarding edge without consuming a ticket.+ assert_eq!(+ http(+ a_addr,+ &host,+ "/.macro-preview/auth",+ "POST",+ &[("origin", "https://evil.test".into())],+ &format!("ticket={}", ticket.ticket)+ )+ .await+ .status(),+ axum::http::StatusCode::FORBIDDEN+ );+ let auth = http(+ a_addr,+ &host,+ "/.macro-preview/auth",+ "POST",+ &[("origin", "https://macro.test".into())],+ &format!("ticket={}", ticket.ticket),+ )+ .await;+ assert_eq!(auth.status(), axum::http::StatusCode::SEE_OTHER);+ let cookie = auth.headers()["set-cookie"]+ .to_str()+ .unwrap()+ .split(';')+ .next()+ .unwrap()+ .to_owned();+ assert_eq!(+ http(+ b_addr,+ &host,+ "/.macro-preview/auth",+ "POST",+ &[("origin", "https://macro.test".into())],+ &format!("ticket={}", ticket.ticket)+ )+ .await+ .status(),+ axum::http::StatusCode::FORBIDDEN+ );+ let response = http(a_addr, &host, "/", "GET", &[("cookie", cookie.clone())], "").await;+ assert_eq!(response.status(), axum::http::StatusCode::OK);+ assert_eq!(+ response.into_body().collect().await.unwrap().to_bytes(),+ "cross replica preview"+ );+ // Forged markers cannot induce another hop, even with valid browser credentials.+ assert_eq!(+ http(+ a_addr,+ &host,+ "/",+ "GET",+ &[+ ("cookie", cookie.clone()),+ ("x-macro-preview-hop", "1".into())+ ],+ ""+ )+ .await+ .status(),+ axum::http::StatusCode::GONE+ );+ use tokio_tungstenite::tungstenite::client::IntoClientRequest;+ let mut request = format!("ws://{host}/socket").into_client_request().unwrap();+ request+ .headers_mut()+ .insert("origin", format!("https://{host}").parse().unwrap());+ request+ .headers_mut()+ .insert("cookie", cookie.parse().unwrap());+ let (mut ws, _) =+ tokio_tungstenite::client_async(request, TcpStream::connect(a_addr).await.unwrap())+ .await+ .unwrap();+ ws.send(tokio_tungstenite::tungstenite::Message::Text(+ "hmr across replicas".into(),+ ))+ .await+ .unwrap();+ assert_eq!(+ ws.next().await.unwrap().unwrap().into_text().unwrap(),+ "hmr across replicas"+ );+ sqlx::query!(+ "UPDATE agent_preview_replica SET expires_at = now() - interval '1 second' WHERE id = $1",+ b_id+ )+ .execute(&pool)+ .await+ .unwrap();+ assert_eq!(+ http(a_addr, &host, "/", "GET", &[("cookie", cookie.clone())], "")+ .await+ .status(),+ axum::http::StatusCode::GONE+ );+ a.sweep().await;+ a.stop(receipt(AccessLevel::Edit)).await.unwrap();+ b.sweep().await;+ assert!(+ tokio::time::timeout(std::time::Duration::from_secs(3), ws.next())+ .await+ .unwrap()+ .is_none_or(|r| r.is_err()+ || matches!(r, Ok(tokio_tungstenite::tungstenite::Message::Close(_))))+ );+ assert_eq!(+ http(a_addr, &host, "/", "GET", &[], "").await.status(),+ axum::http::StatusCode::GONE+ );+ ssh.kill().await.unwrap();+ shutdown.cancel();+ ssh_server.await.unwrap().unwrap();+ a_server.abort();+ b_server.abort();+ upstream_task.abort();+}++#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]+async fn replacement_stop_stale_owner_and_late_cleanup_are_fenced(pool: PgPool) {+ let repo = repository(pool.clone());+ let (base, authority, _) = fixture(2222);+ let events = Arc::new(RecordedEvents::default());+ let a_id = Uuid::now_v7();+ let b_id = Uuid::now_v7();+ let a = replica(&base, authority.clone(), repo.clone(), events.clone(), a_id);+ let b = replica(&base, authority, repo.clone(), events.clone(), b_id);+ a.heartbeat("127.0.0.1:10001".parse().unwrap())+ .await+ .unwrap();+ b.heartbeat("127.0.0.1:10002".parse().unwrap())+ .await+ .unwrap();+ let first = a.share(identity(), 3000).await.unwrap();+ let old = b.authenticate_ssh(&first.token).await.unwrap();+ struct TrackedTunnel(Arc<std::sync::atomic::AtomicBool>);+ #[async_trait]+ impl crate::domain::ports::Tunnel for TrackedTunnel {+ async fn open(&self) -> Result<crate::domain::ports::Stream, PreviewError> {+ Err(PreviewError::Unavailable)+ }+ async fn close(&self) {+ self.0.store(true, std::sync::atomic::Ordering::SeqCst);+ }+ }+ let closed = Arc::new(std::sync::atomic::AtomicBool::new(false));+ b.register(+ &old,+ "127.0.0.1",+ 1,+ Arc::new(TrackedTunnel(closed.clone())),+ )+ .unwrap();+ b.ready(&old).await;+ sqlx::query!("UPDATE agent_preview_lease SET created_at = now() - interval '1 minute'")+ .execute(&pool)+ .await+ .unwrap();+ let next = a.share(identity(), 3000).await.unwrap();+ let successor = a.authenticate_ssh(&next.token).await.unwrap();+ a.ready(&successor).await;+ b.sweep().await;+ assert!(old.cancel.is_cancelled());+ assert!(closed.load(std::sync::atomic::Ordering::SeqCst));+ assert!(+ !repo+ .status(&first.preview.id, b_id, PreviewStatus::Offline)+ .await+ .unwrap()+ );+ b.finish(&old, PreviewStatus::Offline).await;+ b.ready(&old).await;+ assert_eq!(+ a.get(receipt(AccessLevel::View)).await.unwrap().unwrap().id,+ next.preview.id+ );+ assert_eq!(+ a.get(receipt(AccessLevel::View))+ .await+ .unwrap()+ .unwrap()+ .status,+ PreviewStatus::Ready+ );+ b.stop(receipt(AccessLevel::Edit)).await.unwrap();+ a.ready(&successor).await;+ assert_eq!(+ a.get(receipt(AccessLevel::View))+ .await+ .unwrap()+ .unwrap()+ .status,+ PreviewStatus::Stopped+ );+ a.sweep().await;+ assert!(successor.cancel.is_cancelled());+ sqlx::query!("UPDATE agent_preview_lease SET created_at = now() - interval '1 minute'")+ .execute(&pool)+ .await+ .unwrap();+ let third = b.share(identity(), 3000).await.unwrap();+ let lease = a.authenticate_ssh(&third.token).await.unwrap();+ a.ready(&lease).await;+ events.changes.lock().unwrap().clear();+ sqlx::query!(+ "UPDATE agent_preview_replica SET expires_at = now() - interval '1 second' WHERE id = $1",+ a_id+ )+ .execute(&pool)+ .await+ .unwrap();+ assert!(b.destination(&third.preview.id).await.is_err());+ assert!(b.launch(receipt(AccessLevel::View)).await.is_err());+ // Survivor owns no local handle for this generation, but publishes its atomic transition.+ b.sweep().await;+ assert_eq!(+ events+ .changes+ .lock()+ .unwrap()+ .iter()+ .filter(|p| p.id == third.preview.id && p.status == PreviewStatus::Offline)+ .count(),+ 1+ );+ b.sweep().await;+ assert_eq!(+ events+ .changes+ .lock()+ .unwrap()+ .iter()+ .filter(|p| p.id == third.preview.id && p.status == PreviewStatus::Offline)+ .count(),+ 1+ );+ a.heartbeat("127.0.0.1:10001".parse().unwrap())+ .await+ .unwrap();+ a.ready(&lease).await;+ assert!(repo.destination(&third.preview.id).await.is_err());+ assert!(+ !repo+ .status(&third.preview.id, a_id, PreviewStatus::Ready)+ .await+ .unwrap()+ );+}++#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]+async fn concurrent_credentials_are_single_use_host_bound_and_bounded(pool: PgPool) {+ let repo = repository(pool.clone());+ let (base, authority, _) = fixture(2222);+ let events = Arc::new(RecordedEvents::default());+ let a_id = Uuid::now_v7();+ let b_id = Uuid::now_v7();+ let a = replica(&base, authority.clone(), repo.clone(), events.clone(), a_id);+ let b = replica(&base, authority, repo.clone(), events, b_id);+ a.heartbeat("127.0.0.1:10001".parse().unwrap())+ .await+ .unwrap();+ b.heartbeat("127.0.0.1:10002".parse().unwrap())+ .await+ .unwrap();+ let share = a.share(identity(), 3000).await.unwrap();+ let (left, right) = tokio::join!(+ a.authenticate_ssh(&share.token),+ b.authenticate_ssh(&share.token)+ );+ assert_ne!(left.is_ok(), right.is_ok());+ if let Ok(l) = left {+ a.ready(&l).await;+ }+ if let Ok(l) = right {+ b.ready(&l).await;+ }+ let ticket = a.launch(receipt(AccessLevel::View)).await.unwrap();+ assert!(+ b.redeem(&PreviewId::generate(), &ticket.ticket)+ .await+ .is_err()+ );+ let (left, right) = tokio::join!(+ a.redeem(&share.preview.id, &ticket.ticket),+ b.redeem(&share.preview.id, &ticket.ticket)+ );+ assert_ne!(left.is_ok(), right.is_ok());+ sqlx::query!("DELETE FROM agent_preview_credential WHERE kind = 'ticket'")+ .execute(&pool)+ .await+ .unwrap();+ let c1 = StoredCredential {+ hash: [1; 32],+ preview: share.preview.id.clone(),+ user: Some(user()),+ expires: Utc::now().timestamp_millis() + 30000,+ };+ let c2 = StoredCredential {+ hash: [2; 32],+ ..c1.clone()+ };+ let (left, right) = tokio::join!(+ repo.credential(CredentialKind::Ticket, c1, 1),+ repo.credential(CredentialKind::Ticket, c2, 1)+ );+ assert_ne!(left.is_ok(), right.is_ok());+ let count =+ sqlx::query_scalar!("SELECT count(*) FROM agent_preview_credential WHERE kind = 'ticket'")+ .fetch_one(&pool)+ .await+ .unwrap();+ assert_eq!(count, Some(1));+ sqlx::query!("UPDATE agent_preview_replica SET expires_at = now() - interval '1 second'")+ .execute(&pool)+ .await+ .unwrap();+ assert!(matches!(+ repo.credential(+ CredentialKind::Ticket,+ StoredCredential {+ hash: [3; 32],+ preview: share.preview.id,+ user: Some(user()),+ expires: Utc::now().timestamp_millis() + 30000,+ },+ 1,+ )+ .await,+ Err(PreviewError::Offline)+ ));+}++#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]+async fn expired_watchers_cannot_renew_past_active_limits(pool: PgPool) {+ let repo = repository(pool.clone());+ let other = MacroUserIdStr::try_from("macro|[email protected]".to_owned()).unwrap();+ let limits = WatchLimits {+ sessions: 1,+ viewers: 1,+ expires: Utc::now().timestamp_millis() + 30000,+ };+ repo.watch(session(), &user(), limits).await.unwrap();+ sqlx::query!("UPDATE agent_preview_watcher SET expires_at = now() - interval '1 second'")+ .execute(&pool)+ .await+ .unwrap();+ repo.watch(session(), &other, limits).await.unwrap();+ repo.watch(session(), &user(), limits).await.unwrap();+ assert_eq!(+ repo.watchers(session(), 10).await.unwrap(),+ vec![other.clone()]+ );+ sqlx::query!("UPDATE agent_preview_watcher SET expires_at = now() - interval '1 second'")+ .execute(&pool)+ .await+ .unwrap();+ let second = AgentSessionId::new();+ repo.watch(second, &other, limits).await.unwrap();+ repo.watch(session(), &user(), limits).await.unwrap();+ assert!(repo.watchers(session(), 10).await.unwrap().is_empty());+ assert_eq!(repo.watchers(second, 10).await.unwrap(), vec![other]);+}diff --git a/crates/agent_preview/src/testing.rs b/crates/agent_preview/src/testing.rsindex 39a72e082b..e9d3c4a5e9 100644--- a/crates/agent_preview/src/testing.rs+++ b/crates/agent_preview/src/testing.rs@@ -1,3 +1,4 @@+pub mod repository;use crate::domain::{ports::*, *};use agent_fold::domain::log::AgentSessionId;use async_trait::async_trait;@@ -19,7 +20,7 @@ pub fn session() -> AgentSessionId {pub fn user() -> MacroUserIdStr<'static> {MacroUserIdStr::try_from(USER.to_owned()).unwrap()}-pub struct TestAuthority(pub AtomicBool);+pub struct TestAuthority(pub AtomicBool, pub Arc<repository::MemoryRepository>);#[async_trait]impl Authority for TestAuthority {async fn agent(&self, token: &str) -> Result<AgentIdentity, PreviewError> {@@ -92,7 +93,8 @@ pub fn fixture_with(.success());let key = crate::inbound::ssh::host_key(&std::fs::read_to_string(path).unwrap()).unwrap();- let authority = Arc::new(TestAuthority(AtomicBool::new(true)));+ let store = Arc::new(repository::MemoryRepository::default());+ let authority = Arc::new(TestAuthority(AtomicBool::new(true), store.clone()));let mut settings = Settings {domain: "preview.test".into(),https_port: 443,@@ -104,7 +106,20 @@ pub fn fixture_with(app_origin: "https://macro.test".into(),};adjust(&mut settings);- let service = PreviewService::new(settings, authority.clone(), Arc::new(TestEvents)).unwrap();+ let replica = uuid::Uuid::now_v7();+ store.0.lock().unwrap().replicas.insert(+ replica,+ ("127.0.0.1:1".parse().unwrap(), repository::now() + 45000),+ );+ let service = PreviewService::new(+ settings,+ authority.clone(),+ Arc::new(TestEvents),+ store,+ replica,+ Arc::new(crate::outbound::peer::TcpPeerConnector),+ )+ .unwrap();(service, authority, key)}pub struct TcpTunnel(pub std::net::SocketAddr);diff --git a/crates/agent_preview/src/testing/repository.rs b/crates/agent_preview/src/testing/repository.rsnew file mode 100644index 0000000000..050882e759--- /dev/null+++ b/crates/agent_preview/src/testing/repository.rs@@ -0,0 +1,268 @@+//! In-memory port for unit tests only.+use crate::domain::{storage::*, *};+use agent_fold::domain::log::AgentSessionId;+use async_trait::async_trait;+use macro_user_id::user_id::MacroUserIdStr;+use std::{+ collections::HashMap,+ net::SocketAddr,+ sync::Mutex,+ time::{Instant, SystemTime, UNIX_EPOCH},+};+use uuid::Uuid;+#[derive(Default)]+pub struct MemoryRepository(pub Mutex<Data>, pub std::sync::atomic::AtomicBool);+#[derive(Default)]+pub struct Data {+ pub leases: HashMap<AgentSessionId, StoredPreview>,+ pub credentials: HashMap<[u8; 32], (String, StoredCredential)>,+ pub accounts: HashMap<String, Instant>,+ pub replicas: HashMap<Uuid, (SocketAddr, i64)>,+}+pub fn now() -> i64 {+ SystemTime::now()+ .duration_since(UNIX_EPOCH)+ .unwrap()+ .as_millis() as i64+}+fn live(d: &Data, p: &StoredPreview) -> bool {+ p.preview.expires_at > now() as u64+ && matches!(+ p.preview.status,+ PreviewStatus::Starting | PreviewStatus::Ready+ )+ && p.replica+ .is_none_or(|r| d.replicas.get(&r).is_some_and(|(_, e)| *e > now()))+}+#[async_trait]+impl PreviewRepository for MemoryRepository {+ async fn create(+ &self,+ p: StoredPreview,+ c: StoredCredential,+ limits: CreationLimits,+ ) -> Result<(), PreviewError> {+ let mut d = self.0.lock().unwrap();+ let user = p.user.to_string();+ if d.accounts+ .get(&user)+ .is_some_and(|i| i.elapsed().as_secs_f64() < limits.pace_seconds)+ || d.leases+ .values()+ .filter(|l| {+ l.preview.expires_at > now() as u64+ && l.preview.agent_session_id != p.preview.agent_session_id+ })+ .count()+ >= limits.total as usize+ || d.leases+ .values()+ .filter(|l| {+ live(&d, l)+ && l.user == p.user+ && l.preview.agent_session_id != p.preview.agent_session_id+ })+ .count()+ >= limits.account as usize+ {+ return Err(PreviewError::Limited);+ }+ d.accounts.insert(user, Instant::now());+ if let Some(old) = d.leases.insert(p.preview.agent_session_id, p) {+ d.credentials+ .retain(|_, (_, c)| c.preview != old.preview.id);+ }+ d.credentials.insert(c.hash, ("ssh".into(), c));+ Ok(())+ }+ async fn session(&self, s: AgentSessionId) -> Result<Option<StoredPreview>, PreviewError> {+ let d = self.0.lock().unwrap();+ Ok(d.leases.get(&s).cloned().map(|mut p| {+ if !live(&d, &p)+ && matches!(+ p.preview.status,+ PreviewStatus::Starting | PreviewStatus::Ready+ )+ {+ p.preview.status = PreviewStatus::Offline;+ }+ p+ }))+ }+ async fn preview(&self, id: &PreviewId) -> Result<StoredPreview, PreviewError> {+ let d = self.0.lock().unwrap();+ d.leases+ .values()+ .find(|p| p.preview.id == *id && live(&d, p))+ .cloned()+ .ok_or(PreviewError::Offline)+ }+ async fn claim(&self, hash: [u8; 32], r: Uuid) -> Result<StoredPreview, PreviewError> {+ let mut d = self.0.lock().unwrap();+ let (k, c) = d+ .credentials+ .get(&hash)+ .cloned()+ .ok_or(PreviewError::Denied)?;+ if k != "ssh" || c.expires <= now() || !d.replicas.get(&r).is_some_and(|(_, e)| *e > now())+ {+ return Err(PreviewError::Denied);+ }+ d.credentials.remove(&hash);+ let p = d+ .leases+ .values_mut()+ .find(|p| {+ p.preview.id == c.preview+ && p.replica.is_none()+ && p.preview.status == PreviewStatus::Starting+ })+ .ok_or(PreviewError::Denied)?;+ p.replica = Some(r);+ Ok(p.clone())+ }+ async fn status(+ &self,+ id: &PreviewId,+ r: Uuid,+ status: PreviewStatus,+ ) -> Result<bool, PreviewError> {+ if self.1.swap(false, std::sync::atomic::Ordering::SeqCst) {+ return Err(PreviewError::Unavailable);+ }+ let mut d = self.0.lock().unwrap();+ let s = d+ .leases+ .iter()+ .find(|(_, p)| p.preview.id == *id && p.replica == Some(r) && live(&d, p))+ .map(|(s, _)| *s);+ if let Some(s) = s {+ d.leases.get_mut(&s).unwrap().preview.status = status;+ return Ok(true);+ }+ Ok(false)+ }+ async fn stop(&self, s: AgentSessionId) -> Result<Option<StoredPreview>, PreviewError> {+ let mut d = self.0.lock().unwrap();+ Ok(d.leases.get_mut(&s).map(|p| {+ p.preview.status = PreviewStatus::Stopped;+ p.clone()+ }))+ }+ async fn credential(+ &self,+ k: CredentialKind,+ c: StoredCredential,+ limit: i64,+ ) -> Result<(), PreviewError> {+ let mut d = self.0.lock().unwrap();+ if !d.leases.values().any(|p| {+ p.preview.id == c.preview && p.preview.status == PreviewStatus::Ready && live(&d, p)+ }) {+ return Err(PreviewError::Offline);+ }+ if d.credentials+ .values()+ .filter(|(kind, c)| kind == k.as_str() && c.expires > now())+ .count()+ >= limit as usize+ {+ return Err(PreviewError::Limited);+ }+ d.credentials.insert(c.hash, (k.as_str().into(), c));+ Ok(())+ }+ async fn authenticate(+ &self,+ k: CredentialKind,+ id: &PreviewId,+ hash: [u8; 32],+ consume: bool,+ ) -> Result<StoredCredential, PreviewError> {+ let mut d = self.0.lock().unwrap();+ let (kind, c) = d.credentials.get(&hash).ok_or(PreviewError::Denied)?;+ if kind != k.as_str() || c.preview != *id || c.expires <= now() {+ return Err(PreviewError::Denied);+ }+ let c = c.clone();+ if consume {+ d.credentials.remove(&hash);+ }+ Ok(c)+ }+ async fn heartbeat(+ &self,+ r: Uuid,+ address: SocketAddr,+ ttl_seconds: f64,+ ) -> Result<Vec<Preview>, PreviewError> {+ let mut transitions = Vec::new();+ let mut d = self.0.lock().unwrap();+ if d.replicas.get(&r).is_some_and(|(_, e)| *e <= now()) {+ for p in d.leases.values_mut().filter(|p| {+ p.replica == Some(r)+ && matches!(+ p.preview.status,+ PreviewStatus::Starting | PreviewStatus::Ready+ )+ }) {+ p.preview.status = PreviewStatus::Offline;+ transitions.push(p.preview.clone());+ }+ }+ d.replicas+ .entry(r)+ .and_modify(|(_, e)| *e = now() + (ttl_seconds * 1000.0) as i64)+ .or_insert((address, now() + (ttl_seconds * 1000.0) as i64));+ Ok(transitions)+ }+ async fn destination(&self, id: &PreviewId) -> Result<(Uuid, SocketAddr), PreviewError> {+ let d = self.0.lock().unwrap();+ let p = d+ .leases+ .values()+ .find(|p| p.preview.id == *id && live(&d, p))+ .ok_or(PreviewError::Offline)?;+ let r = p.replica.ok_or(PreviewError::Offline)?;+ Ok((r, d.replicas.get(&r).ok_or(PreviewError::Offline)?.0))+ }+ async fn watch(+ &self,+ _: AgentSessionId,+ _: &MacroUserIdStr<'_>,+ _: WatchLimits,+ ) -> Result<(), PreviewError> {+ Ok(())+ }+ async fn watchers(+ &self,+ _: AgentSessionId,+ _: i64,+ ) -> Result<Vec<MacroUserIdStr<'static>>, PreviewError> {+ Ok(vec![])+ }+ async fn sweep(&self) -> Result<Vec<Preview>, PreviewError> {+ let mut d = self.0.lock().unwrap();+ let ids: Vec<_> = d+ .leases+ .iter()+ .filter(|(_, p)| {+ p.replica.is_some()+ && !live(&d, p)+ && matches!(+ p.preview.status,+ PreviewStatus::Starting | PreviewStatus::Ready+ )+ })+ .map(|(s, _)| *s)+ .collect();+ Ok(ids+ .into_iter()+ .map(|s| {+ let p = d.leases.get_mut(&s).unwrap();+ p.preview.status = PreviewStatus::Offline;+ p.preview.clone()+ })+ .collect())+ }+}diff --git a/crates/macro_db_client/AGENTS.md b/crates/macro_db_client/AGENTS.mdindex 9a7db24c6f..fd6a3eba8b 100644--- a/crates/macro_db_client/AGENTS.md+++ b/crates/macro_db_client/AGENTS.md@@ -53,6 +53,11 @@ stable across retries, and `announced` records successful pending-message posts.The additive migrations are compatible with older service binaries; sessiondeletion cascades its rows.+`agent_preview_*` stores preview-specific ownership, credential hashes and+watchers; its queries and policy belong to `agent_preview`. Leases have a bounded+TTL, deletion cascades credentials, and sweepers reclaim expired watchers and+unreferenced replicas. These additive tables do not change agent-session claims.+## Gotchas- Migrations deploy before service code: never drop a column/table in thediff --git a/crates/macro_db_client/migrations/20261021205701_agent_preview_replication.sql b/crates/macro_db_client/migrations/20261021205701_agent_preview_replication.sqlnew file mode 100644index 0000000000..2c79c65e56--- /dev/null+++ b/crates/macro_db_client/migrations/20261021205701_agent_preview_replication.sql@@ -0,0 +1,35 @@+-- Separate from agent-session management: these rows own preview SSH transports.+CREATE TABLE agent_preview_replica (+ id UUID PRIMARY KEY,+ address TEXT NOT NULL,+ expires_at TIMESTAMPTZ NOT NULL+);+CREATE TABLE agent_preview_lease (+ id TEXT PRIMARY KEY,+ session_id UUID NOT NULL UNIQUE,+ user_id TEXT NOT NULL,+ metadata JSONB NOT NULL,+ replica_id UUID REFERENCES agent_preview_replica(id),+ status TEXT NOT NULL CHECK (status IN ('starting', 'ready', 'offline', 'expired', 'stopped')),+ created_at TIMESTAMPTZ NOT NULL DEFAULT now(),+ expires_at TIMESTAMPTZ NOT NULL+);+CREATE INDEX agent_preview_lease_user_id ON agent_preview_lease(user_id);+CREATE INDEX agent_preview_lease_replica_id ON agent_preview_lease(replica_id);+CREATE INDEX agent_preview_lease_expires_at ON agent_preview_lease(expires_at);+CREATE TABLE agent_preview_credential (+ hash BYTEA PRIMARY KEY,+ kind TEXT NOT NULL CHECK (kind IN ('ssh', 'ticket', 'browser')),+ preview_id TEXT NOT NULL REFERENCES agent_preview_lease(id) ON DELETE CASCADE,+ user_id TEXT,+ expires_at TIMESTAMPTZ NOT NULL+);+CREATE INDEX agent_preview_credential_preview_id ON agent_preview_credential(preview_id);+CREATE INDEX agent_preview_credential_expires_at ON agent_preview_credential(expires_at);+CREATE TABLE agent_preview_watcher (+ session_id UUID NOT NULL,+ user_id TEXT NOT NULL,+ expires_at TIMESTAMPTZ NOT NULL,+ PRIMARY KEY (session_id, user_id)+);+CREATE INDEX agent_preview_watcher_expires_at ON agent_preview_watcher(expires_at);diff --git a/docs/agent-guide/ai-chat.md b/docs/agent-guide/ai-chat.mdindex e8e54d0d77..cc8eb0edae 100644--- a/docs/agent-guide/ai-chat.md+++ b/docs/agent-guide/ai-chat.md@@ -1581,7 +1581,10 @@ The owner can click **Stop sharing** in the banner; open preview connectionsclose. Disconnection and expiry leave a banner asking the agent to share again.Leases last up to one hour and expire after 15 minutes without browser requests.Continue prompting in the agent session while the preview tab stays open; page-edits should arrive through the app's own HMR connection.+edits should arrive through the app's own HMR connection. Control requests, SSH,+and preview navigation can reach different replicas without requiring sticky+sessions. A rolling restart of the tunnel owner may disconnect its previews;+the banner becomes offline within 45 seconds. Ask the agent to share again.### Transcript navigationdiff --git a/infra/stacks/preview-gateway/index.ts b/infra/stacks/preview-gateway/index.tsindex 222f131b23..afd3d0edf8 100644--- a/infra/stacks/preview-gateway/index.ts+++ b/infra/stacks/preview-gateway/index.ts@@ -98,6 +98,7 @@ for (const [index, rule] of [{ fromPort: 8110, toPort: 8111, source: albSg.id },{ fromPort: 2222, toPort: 2222, source: sshSg.id },{ fromPort: 8110, toPort: 8110, source: sshSg.id },+ { fromPort: 8111, toPort: 8111, source: taskSg.id },].entries()) {new aws.vpc.SecurityGroupIngressRule(`${name}-task-ingress-${index}-${stack}`,@@ -266,10 +267,10 @@ const service = new awsx.ecs.FargateService(subnets: vpc.privateSubnetIds,securityGroups: [taskSg.id],},- // SSH and HTTP must reach the same registry. Do not autoscale or overlap deployments.- desiredCount: 1,- deploymentMinimumHealthyPercent: 0,- deploymentMaximumPercent: 100,+ // SSH ownership is shared; every target serves healthy control/HTTP ingress.+ desiredCount: stack === 'dev' ? 2 : 1,+ deploymentMinimumHealthyPercent: 100,+ deploymentMaximumPercent: 200,deploymentCircuitBreaker: { enable: true, rollback: true },healthCheckGracePeriodSeconds: 120,loadBalancers: [control.target_group, httpTarget, sshTarget].map(@@ -324,3 +325,7 @@ const service = new awsx.ecs.FargateService(export const previewDomain = domain;export const previewSshHost = sshHost;export const previewServiceArn = service.service.id;+export const previewTaskSecurityGroupId = taskSg.id;+export const previewControlTargetGroupArn = control.target_group.arn;+export const previewHttpTargetGroupArn = httpTarget.arn;+export const previewSshTargetGroupArn = sshTarget.arn;diff --git a/services/preview_gateway/AGENTS.md b/services/preview_gateway/AGENTS.mdindex a1c16e0b2d..d7c1634514 100644--- a/services/preview_gateway/AGENTS.md+++ b/services/preview_gateway/AGENTS.md@@ -32,9 +32,11 @@ previews over SSH tunnels and short-lived browser tickets, on its own## Gotchas-- Runs as a single Fargate replica with no autoscaling — SSH, HTTP, and- control requests share one in-memory lease/ticket registry (see README- "Deployment"). Scaling requires explicit cross-replica routing first.+- Dev uses two Fargate replicas with rolling deployments. All targets serve+ `/health`; SSH claims shared ownership and public traffic forwards directly+ to that owner. Keep task-to-task HTTP ingress open (see README "Deployment").+- `agent_preview::outbound::peer::address` selects the private interface from the database route without+ transmitting UDP packets; each process registers its HTTP endpoint on startup.- Never deploy (`pulumi up`) without explicit approval; see root guardrails.## Relateddiff --git a/services/preview_gateway/README.md b/services/preview_gateway/README.mdindex c600eea8c8..2e1b7105a2 100644--- a/services/preview_gateway/README.md+++ b/services/preview_gateway/README.md@@ -27,10 +27,11 @@ Secure HttpOnly cookie, and redirects to `/`. App paths and query strings stayunchanged. Stop requires Edit access; the UI currently exposes it to the owner.Entity access is checked again when the ticket is redeemed, on every request,-and every 30 seconds during open HTTP streams and WebSockets. Stop and SSH-disconnection cancel open traffic immediately. Session deletion is checked by-the sweeper every 15 seconds. An idle ACP transport disconnect does not terminate-an otherwise live preview. MCP calls use the existing session credential and its normal lifecycle; external+and every 30 seconds during open HTTP streams and WebSockets. SSH disconnection+and an owner-local stop cancel open traffic immediately. A stop or re-share on+another replica closes the old transport on its next 10-second sweep. Session+deletion is checked by the sweeper every 10 seconds. An idle ACP transport+disconnect does not terminate an otherwise live preview. MCP calls use the existing session credential and its normal lifecycle; externalruntime attachment rotates it. It is never replaced with an owner API token.New Cursor agents receive this MCP server at creation. Existing Cursor agents@@ -58,7 +59,7 @@ and every 30 seconds, so missed events and gateway restarts recover automaticall## Limits- One preview per session, five active previews per owner, one creation per owner- every ten seconds; 1,000 retained leases/accounts per gateway.+ every ten seconds; 1,000 retained unexpired leases across all replicas.- One-hour leases; 15 minutes without a browser HTTP request expires a lease.WebSocket pings alone do not keep it alive.- Traffic itself is unmetered. Request-rate, byte-pacing and total-byte ceilings@@ -77,17 +78,67 @@ and every 30 seconds, so missed events and gateway restarts recover automaticallThese are basic abuse/cost controls, not a hard cloud-spend ceiling. Loadbalancer traffic is still billable before application admission, and nothing-here bounds bytes. Gateway restart closes previews and clears all credentials;-agents must share again.+here bounds bytes. Owner restart closes its previews. Shared credential hashes+remain until expiry, but cannot authorize a dead preview; agents must share again.## DeploymentThe `infra/stacks/preview-gateway` Pulumi stack creates wildcard DNS and an ACM-certificate, a public HTTPS ALB, a public SSH NLB, and a Fargate task. Macro's-existing gateway routes `/preview/*` to its separate control listener. The task-runs **one replica**, with non-overlapping replacements and no autoscaling:-SSH, HTTP, and control requests must reach the same in-memory registry. Scaling-requires explicit ownership/routing across gateways first.+certificate, a public HTTPS ALB, a public SSH NLB, and Fargate tasks. Macro's+existing gateway routes `/preview/*` to the control listener. Dev runs two+replicas; production's configured count remains one. Both support overlapping+rolling replacements (minimum healthy 100%, maximum 200%). Every target serves+`/health` independently of SSH ownership.++`agent_preview` stores preview leases, hash-only credentials and authorized+watchers in preview-specific Postgres tables. Create and control requests can+reach any replica. The replica accepting SSH atomically consumes the one-use+credential and claims that preview. Live russh handles remain local. Public+HTTP and WebSocket requests resolve that owner in Postgres and stream directly+to its registered HTTP endpoint, with at most one hop. The receiving owner+still applies the full origin, one-use ticket, cookie and entity-access checks.+A client-supplied hop marker can only prevent forwarding, never authenticate it.+Peer sockets and upgraded streams have separate bounded admission; body limits+apply before peer dial and admission stays held through the streamed response.+Forwarding overload returns HTTP 429 before opening a socket; owner-side+per-preview HTTP streams retain their existing queueing behavior.++Each process mints a replica ID and registers the private interface selected by+the existing database route (UDP connect selects the interface without sending+packets), plus its public-listener port. There are no new secrets or environment+settings. Task security groups permit peer HTTP on port 8111, only from the same+task security group. Destinations are numeric private/loopback addresses from+the server-written registry, never client URLs or forwarding headers; public,+link-local and metadata destinations are rejected.++Heartbeat every 10 seconds; ownership expires after 45 seconds. A stopped,+expired or replaced preview cannot become ready again through a delayed SSH+callback. Preview IDs are generation fences; every owner status write matches+the ID and replica. A heartbeat resumed after expiry invalidates its old+previews before renewing its replica row. Survivor sweepers atomically publish+dead-owner transitions to authorized watchers. Disconnects on owner failure or+rollout are expected: call SharePreview again to reconnect. This follows the+agent-session management claim/heartbeat/fencing pattern without reusing+agent-session ownership rows or streaming through Redis.++Apply the additive MacroDB migration before rolling out the new service code.+Preview rows expire after one hour and are removed five minutes later, cascading+credentials. Expired credentials/watchers are swept, and unreferenced replica+rows are removed after seven days. Agent-session revocation is rechecked through+the existing authority boundary; no agent-session foreign key is required.++To host this crate in agent_harness_service: share its MacroDB pool with+`PgPreviewRepository`, pass one process-unique replica ID and `TcpPeerConnector`+to `PreviewService::new`, register the private HTTP-listener endpoint, and run+heartbeat + sweep every 10 seconds. Mount the existing control/MCP routes and+public HTTP router, and pass that same service to the SSH listener. Permit+HTTP-listener ingress from the harness task security group itself. Keep all+harness tasks healthy and retain two replicas with rolling deployments.++The preview stack exports `previewTaskSecurityGroupId` and the control, HTTP+and SSH target group ARNs (`previewControlTargetGroupArn`,+`previewHttpTargetGroupArn`, `previewSshTargetGroupArn`) so consolidation can+reuse the existing network resources.Bootstrap (done 2026-09-28):diff --git a/services/preview_gateway/src/main.rs b/services/preview_gateway/src/main.rsindex 52efb315db..500901ee4a 100644--- a/services/preview_gateway/src/main.rs+++ b/services/preview_gateway/src/main.rs@@ -1,4 +1,4 @@-//! Single-replica SSH/HTTP preview gateway, isolated from Macro's browser cookie domain.+//! Replicated SSH/HTTP preview gateway, isolated from Macro's browser cookie domain.mod adapters;mod config;use agent_preview::{@@ -67,6 +67,15 @@ async fn run() -> Result<(), rootcause::Report> {);let key = ssh::host_key(&config.preview_ssh_host_key)?;let public_key = ssh::public_key(&key)?;+ let peer_address = agent_preview::outbound::peer::address(+ config.database_url.as_ref(),+ config.preview_http_port,+ )+ .await?;+ let repository = Arc::new(agent_preview::outbound::postgres::PgPreviewRepository::new(+ pool.clone(),+ ));+ let replica = macro_uuid::Uuid::now_v7();let service = PreviewService::new(Settings {local_ssh_fallback: matches!(config.environment, macro_env::Environment::Local),@@ -85,7 +94,7 @@ async fn run() -> Result<(), rootcause::Report> {pool.clone(),entity_registry_db_utils::OwnedEntityRegistrar::new(entity_registry::OwnerGrantPolicy::new(- bots::outbound::pg_bots_repo::PgBotsRepo::new(pool),+ bots::outbound::pg_bots_repo::PgBotsRepo::new(pool.clone()),),),),@@ -97,7 +106,11 @@ async fn run() -> Result<(), rootcause::Report> {ConnectionGatewayUrl::new()?.to_string(),),)),+ repository,+ replica,+ Arc::new(agent_preview::outbound::peer::TcpPeerConnector),)?;+ service.heartbeat(peer_address).await?;let control = control::router(ControlState::new(service.clone(),access,@@ -139,7 +152,10 @@ async fn run() -> Result<(), rootcause::Report> {let sweep_shutdown = shutdown.clone();tokio::spawn(async move {loop {- tokio::select! { _ = sweep_shutdown.cancelled() => break, _ = tokio::time::sleep(Duration::from_secs(15)) => sweeper.sweep().await }+ tokio::select! { _ = sweep_shutdown.cancelled() => break, _ = tokio::time::sleep(Duration::from_secs(10)) => {+ if let Err(error) = sweeper.heartbeat(peer_address).await { tracing::warn!(?error, "preview heartbeat failed"); }+ sweeper.sweep().await;+ } }}});tokio::try_join!(