Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

fix: require operator authority for Beeper outbox sends

atomantic791506041f11
diff --git a/server/lib/hostControlRoutes.js b/server/lib/hostControlRoutes.js
index f8e65a092d..7d0008e678 100644
--- a/server/lib/hostControlRoutes.js
+++ b/server/lib/hostControlRoutes.js
@@ -835,6 +835,14 @@ export const HOST_CONTROL_ROUTES = Object.freeze([
'PUT /api/github/secrets/:name',
'POST /api/github/secrets/:name/sync',
+ // Beeper outbox creation records approved send intent; send spends the
+ // operator's saved connection, and breaker reset re-arms that capability.
+ // First-contact confirmation and approved state do not establish caller
+ // authority. History, discard and delivery reconciliation never send.
+ 'POST /api/beeper/outbox',
+ 'POST /api/beeper/outbox/:id/send',
+ 'POST /api/beeper/outbox/breaker/clear',
+
// Jira instance updates can retain a saved API token while changing its
// destination, so require operator authority before persisting the URL.
'POST /api/jira/instances',
diff --git a/server/routes/beeper.js b/server/routes/beeper.js
index 4eab88d048..8be0a17bfd 100644
--- a/server/routes/beeper.js
+++ b/server/routes/beeper.js
@@ -516,6 +516,9 @@ router.delete('/token', asyncHandler(async (_req, res) => {
// records the approved text, sending it performs the POST. No scheduler, no
// agent, no voice tool and no CoS tool reaches either — asserted structurally
// by `beeperOutboxHumanGate.test.js`, not left to convention.
+// Approval, send and breaker reset also require operator authority via the
+// central host-control gate. An HTTP call or first-contact flag alone is not
+// approval; genuine auth-off local and verified delegated sessions retain it.
// ---------------------------------------------------------------------------
// GET /api/beeper/outbox?conversationId=… — the composer's own history for one
diff --git a/server/routes/hostControlBeeperOutbox.test.js b/server/routes/hostControlBeeperOutbox.test.js
new file mode 100644
index 0000000000..76212b52a0
--- /dev/null
+++ b/server/routes/hostControlBeeperOutbox.test.js
@@ -0,0 +1,208 @@
+import { EventEmitter } from 'node:events';
+import { randomUUID } from 'node:crypto';
+import { afterAll, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import express from 'express';
+import { request } from '../lib/testHelper.js';
+import { DEV_PROXY_CLIENT_ADDRESS_HEADER } from '../../lib/portosAuthCore.js';
+import { errorMiddleware } from '../lib/errorHandler.js';
+import { cleanupTempDataRoots, lazyTempDataRoot, makePathsProxy } from '../lib/mockPathsDataRoot.js';
+import { derivePeerAuthToken, PEER_AUTH_HEADER, PEER_INSTANCE_HEADER } from '../lib/peerHttpClient.js';
+
+const auth = vi.hoisted(() => ({ enabled: false }));
+vi.mock('../lib/fileUtils.js', async (original) =>
+ makePathsProxy(await original(), { dataRoot: () => lazyTempDataRoot('portos-beeper-authority-') }));
+afterAll(cleanupTempDataRoots);
+vi.mock('../services/auth.js', async (original) => ({
+ ...await original(), isAuthEnabled: vi.fn(async () => auth.enabled), verifyPassword: vi.fn(async () => true),
+}));
+vi.mock('../services/settings.js', () => ({
+ settingsEvents: new EventEmitter(), getSettings: vi.fn(async () => ({})), updateSettingsWith: vi.fn(),
+}));
+vi.mock('../services/instanceIdentity.js', () => ({
+ loadData: vi.fn(async () => ({ peers: [{
+ id: 'example-peer', instanceId: 'example-instance', enabled: true, syncSecret: 'a'.repeat(32),
+ }] })),
+}));
+vi.mock('../services/beeperStatus.js', () => ({ getBeeperStatus: vi.fn(), checkBeeperConnection: vi.fn() }));
+vi.mock('../services/beeperOAuth.js', () => ({
+ completeBeeperOAuth: vi.fn(), connectWithPastedToken: vi.fn(), disconnectBeeper: vi.fn(), startBeeperOAuth: vi.fn(),
+}));
+vi.mock('../services/beeperSync.js', () => ({
+ runBeeperSweep: vi.fn(), createBeeperConversation: vi.fn(), normalizeMessageRow: vi.fn(), upsertMirroredMessage: vi.fn(),
+}));
+vi.mock('../services/beeperConversations.js', () => ({
+ listConversations: vi.fn(), getConversation: vi.fn(), listMessages: vi.fn(), listNetworks: vi.fn(),
+ markConversationSeen: vi.fn(), purgeConversation: vi.fn(), setConversationArchived: vi.fn(), setConversationLowPriority: vi.fn(),
+}));
+vi.mock('../services/beeperAttachments.js', () => ({
+ backfillAttachments: vi.fn(), ensureAttachmentBytes: vi.fn(), getAttachment: vi.fn(), getAttachmentSummary: vi.fn(), setAttachmentKeep: vi.fn(),
+}));
+vi.mock('../services/beeperClient.js', async (original) => ({
+ ...await original(), sendMessage: vi.fn(), getMessage: vi.fn(), listMessagesPage: vi.fn(),
+}));
+
+// Exercise the real route → outbox state machine; only storage and transport
+// are synthetic. Refusals must leave durable intent and send accounting intact.
+const rows = new Map();
+const CONVERSATION_ID = '11111111-1111-4111-8111-111111111111';
+const query = vi.fn(async (sql, params = []) => {
+ if (/SELECT id, source_chat_id/.test(sql)) return { rows: [{ id: CONVERSATION_ID, sourceChatId: 'example-chat' }] };
+ if (/INSERT INTO beeper_outbox/.test(sql)) {
+ const row = { id: randomUUID(), conversationId: params[0], chatId: params[1], body: params[2], state: 'approved' };
+ rows.set(row.id, row);
+ return { rows: [{ ...row }], rowCount: 1 };
+ }
+ if (/SELECT 1 FROM/.test(sql)) return { rows: [], rowCount: 0 };
+ if (/^SELECT/.test(sql)) {
+ const result = /WHERE id =/.test(sql) ? [rows.get(params[0])].filter(Boolean) : [...rows.values()];
+ return { rows: result.map((row) => ({ ...row })), rowCount: result.length };
+ }
+ const row = rows.get(params[0]);
+ if (/SET state = 'sending'/.test(sql)) {
+ if (row?.state !== 'approved') return { rows: [], rowCount: 0 };
+ row.state = 'sending';
+ return { rows: [{ id: row.id }], rowCount: 1 };
+ }
+ if (/SET state = 'awaiting-confirmation'/.test(sql)) {
+ Object.assign(row, { state: 'awaiting-confirmation', pendingMessageId: params[1] });
+ return { rows: [{ ...row }], rowCount: 1 };
+ }
+ if (/SET state = 'failed'/.test(sql)) {
+ Object.assign(row, { state: 'failed', errorCode: params[1] });
+ return { rows: [], rowCount: 1 };
+ }
+ if (/DELETE FROM beeper_outbox/.test(sql)) {
+ rows.delete(params[0]);
+ return { rows: [], rowCount: 1 };
+ }
+ throw new Error(`Unexpected synthetic outbox query: ${sql.slice(0, 50)}`);
+});
+vi.mock('../lib/db.js', () => ({ query: (...args) => query(...args), withTransaction: vi.fn() }));
+
+import { authGate, hostControlRouteGate } from '../services/authGate.js';
+import { createSession } from '../services/auth.js';
+import { BeeperApiError, sendMessage } from '../services/beeperClient.js';
+import {
+ BREAKER_MAX_CONSECUTIVE_FAILURES, cancelPendingConfirmations, clearOutboxBreaker,
+ configureOutboxRuntime, getOutboxBreakerState, resetOutboxRuntime,
+} from '../services/beeperOutbox.js';
+import beeperRoutes from './beeper.js';
+
+const appFor = (address = '192.0.2.10') => {
+ const app = express();
+ app.use((req, _res, next) => {
+ Object.defineProperty(req.socket, 'remoteAddress', { value: address });
+ next();
+ });
+ app.use(authGate, hostControlRouteGate, express.json());
+ app.use('/api/beeper', beeperRoutes);
+ app.use(errorMiddleware);
+ return app;
+};
+const post = (app, path, body = {}, headers = {}) => {
+ const pending = request(app).post(`/api/beeper/${path}`);
+ for (const [name, value] of Object.entries(headers)) pending.set(name, value);
+ return pending.send(body);
+};
+const approve = (app, headers) => post(app, 'outbox', { conversationId: CONVERSATION_ID, body: 'Synthetic message' }, headers);
+const peerHeaders = {
+ [PEER_AUTH_HEADER]: derivePeerAuthToken('a'.repeat(32), 'example-instance'),
+ [PEER_INSTANCE_HEADER]: 'example-instance',
+};
+
+beforeEach(() => {
+ auth.enabled = false;
+ rows.clear();
+ vi.clearAllMocks();
+ clearOutboxBreaker();
+ configureOutboxRuntime({ setTimeout: () => 1, clearTimeout: () => {} });
+ vi.mocked(sendMessage).mockResolvedValue({ pendingMessageId: 'example-pending' });
+});
+afterEach(() => { cancelPendingConfirmations(); resetOutboxRuntime(); });
+
+describe('Beeper outbox operator authority (#11417)', () => {
+ it('refuses remote approval before creating sendable intent', async () => {
+ const app = appFor();
+ const refused = await approve(app);
+ expect([refused.status, refused.body.code]).toEqual([403, 'HOST_CONTROL_FORBIDDEN']);
+ expect(query).not.toHaveBeenCalled();
+ expect(rows.size).toBe(0);
+ expect(sendMessage).not.toHaveBeenCalled();
+ });
+
+ it('refuses sending an existing approved row, preserving data-only history and discard', async () => {
+ const app = appFor();
+ const approved = await approve(appFor('127.0.0.1'));
+ query.mockClear();
+ const sent = await post(app, `outbox/${approved.body.id}/send`, { confirmFirstContact: true });
+ expect([sent.status, sent.body.code]).toEqual([403, 'HOST_CONTROL_FORBIDDEN']);
+ expect(query).not.toHaveBeenCalled();
+ expect(rows.get(approved.body.id).state).toBe('approved');
+ expect(sendMessage).not.toHaveBeenCalled();
+ expect(getOutboxBreakerState().sendsInWindow).toBe(0);
+
+ // History and declining unsent local intent do not authorize a send.
+ expect((await request(app).get(`/api/beeper/outbox?conversationId=${CONVERSATION_ID}`)).body.entries).toHaveLength(1);
+ expect((await request(app).delete(`/api/beeper/outbox/${approved.body.id}`)).status).toBe(204);
+ expect(rows.size).toBe(0);
+ });
+
+ it.each(['local', 'operator', 'agent'])('preserves %s approval, first-contact confirmation and one-attempt delivery', async (principal) => {
+ const headers = {};
+ const app = appFor(principal === 'operator' ? '192.0.2.10' : '127.0.0.1');
+ if (principal !== 'local') {
+ const session = await createSession(principal === 'agent' ? { label: 'agent' } : {});
+ headers[principal === 'agent' ? 'Authorization' : 'Cookie'] = principal === 'agent'
+ ? `Bearer ${session.token}` : `portos_auth=${session.token}`;
+ auth.enabled = true;
+ }
+ const approved = await approve(app, headers);
+ expect(approved.status).toBe(201);
+ expect(rows.get(approved.body.id).state).toBe('approved');
+ const path = `outbox/${approved.body.id}/send`;
+ const missingConfirmation = await post(app, path, {}, headers);
+ expect([missingConfirmation.status, missingConfirmation.body.code]).toEqual([409, 'FIRST_CONTACT_CONFIRMATION_REQUIRED']);
+ expect(sendMessage).not.toHaveBeenCalled();
+ const sent = await post(app, path, { confirmFirstContact: true }, headers);
+ expect(sent.status).toBe(200);
+ expect(rows.get(approved.body.id).state).toBe('awaiting-confirmation');
+ expect(sendMessage).toHaveBeenCalledExactlyOnceWith('example-chat', { text: 'Synthetic message' });
+ const repeated = await post(app, path, { confirmFirstContact: true }, headers);
+ expect([repeated.status, repeated.body.code]).toEqual([409, 'OUTBOX_INVALID_STATE']);
+ expect(sendMessage).toHaveBeenCalledTimes(1);
+ });
+
+ it('refuses forwarded local hints, anonymous auth-on, Basic and scoped-peer callers', async () => {
+ const path = 'outbox/22222222-2222-4222-8222-222222222222/send';
+ const proxy = await post(appFor('127.0.0.1'), path, { confirmFirstContact: true }, { [DEV_PROXY_CLIENT_ADDRESS_HEADER]: '192.0.2.10' });
+ expect([proxy.status, proxy.body.code]).toEqual([403, 'HOST_CONTROL_FORBIDDEN']);
+ auth.enabled = true;
+ for (const [headers, expected] of [
+ [{}, [401, 'AUTH_REQUIRED']],
+ [{ Authorization: `Basic ${Buffer.from('portos:synthetic-password').toString('base64')}` }, [403, 'HOST_CONTROL_FORBIDDEN']],
+ [peerHeaders, [403, 'PEER_SCOPE_FORBIDDEN']],
+ ]) {
+ const response = await post(appFor(), path, { confirmFirstContact: true }, headers);
+ expect([response.status, response.body.code]).toEqual(expected);
+ }
+ expect(query).not.toHaveBeenCalled();
+ expect(sendMessage).not.toHaveBeenCalled();
+ });
+
+ it('requires authority to clear a tripped breaker without weakening recovery or retry rules', async () => {
+ const local = appFor('127.0.0.1');
+ vi.mocked(sendMessage).mockRejectedValue(new BeeperApiError('Synthetic rejection', { status: 400, code: 'SEND_FAILED' }));
+ for (let index = 0; index < BREAKER_MAX_CONSECUTIVE_FAILURES; index++) {
+ const entry = await approve(local);
+ expect((await post(local, `outbox/${entry.body.id}/send`, { confirmFirstContact: true })).status).toBe(502);
+ expect(rows.get(entry.body.id).state).toBe('failed');
+ }
+ const tripped = getOutboxBreakerState();
+ expect(tripped.tripped).toBe(true);
+ const reset = await post(appFor(), 'outbox/breaker/clear');
+ expect([reset.status, reset.body.code]).toEqual([403, 'HOST_CONTROL_FORBIDDEN']);
+ expect(getOutboxBreakerState()).toEqual(tripped);
+ expect((await post(local, 'outbox/breaker/clear')).body.tripped).toBe(false);
+ expect(sendMessage).toHaveBeenCalledTimes(BREAKER_MAX_CONSECUTIVE_FAILURES);
+ });
+});