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(security): require operator authority for X review, browser handoff and sync

Adam Eivy8e281673a882
diff --git a/server/lib/hostControlRoutes.js b/server/lib/hostControlRoutes.js
index 88fd3dc0f1..7a7ff9d22e 100644
--- a/server/lib/hostControlRoutes.js
+++ b/server/lib/hostControlRoutes.js
@@ -179,6 +179,15 @@ export const HOST_CONTROL_ROUTES = Object.freeze([
'POST /api/stacker-news/actions/:id/review',
'POST /api/stacker-news/actions/:id/execute',
+ // X (Twitter) draft review authorizes a later browser compose handoff, and
+ // opening approved drafts, opening account destinations or syncing accounts
+ // executes CDP browser automation on the host. Reads, account CRUD and draft
+ // creation remain data-only operations.
+ 'POST /api/x/drafts/:id/review',
+ 'POST /api/x/drafts/:id/open',
+ 'POST /api/x/accounts/:id/open',
+ 'POST /api/x/accounts/:id/sync',
+
// Sending a draft performs an external mail side effect as the operator (#11273).
'POST /api/messages/drafts/:id/send',
diff --git a/server/lib/hostControlRoutes.test.js b/server/lib/hostControlRoutes.test.js
index 2f7cb485c4..5389233bcc 100644
--- a/server/lib/hostControlRoutes.test.js
+++ b/server/lib/hostControlRoutes.test.js
@@ -170,6 +170,25 @@ describe('outbound mail host-control policy (#11273)', () => {
});
});
+describe('X (Twitter) review and browser automation policy', () => {
+ it('gates draft review, compose handoff, destination open and sync while keeping draft/account CRUD open', () => {
+ expect(isHostControlRoute('POST', '/api/x/drafts/00000000-0000-4000-8000-000000000001/review')).toBe(true);
+ expect(isHostControlRoute('POST', '/api/x/drafts/00000000-0000-4000-8000-000000000001/open')).toBe(true);
+ expect(isHostControlRoute('POST', '/api/x/accounts/00000000-0000-4000-8000-000000000001/open')).toBe(true);
+ expect(isHostControlRoute('POST', '/api/x/accounts/00000000-0000-4000-8000-000000000001/sync')).toBe(true);
+
+ expect(isHostControlRoute('GET', '/api/x/capabilities')).toBe(false);
+ expect(isHostControlRoute('GET', '/api/x/accounts')).toBe(false);
+ expect(isHostControlRoute('POST', '/api/x/accounts')).toBe(false);
+ expect(isHostControlRoute('GET', '/api/x/accounts/00000000-0000-4000-8000-000000000001')).toBe(false);
+ expect(isHostControlRoute('PATCH', '/api/x/accounts/00000000-0000-4000-8000-000000000001')).toBe(false);
+ expect(isHostControlRoute('DELETE', '/api/x/accounts/00000000-0000-4000-8000-000000000001')).toBe(false);
+ expect(isHostControlRoute('POST', '/api/x/drafts')).toBe(false);
+ expect(isHostControlRoute('GET', '/api/x/accounts/00000000-0000-4000-8000-000000000001/posts')).toBe(false);
+ expect(isHostControlRoute('GET', '/api/x/accounts/00000000-0000-4000-8000-000000000001/drafts')).toBe(false);
+ });
+});
+
// Every mutation in these audited routers must be gated or explicitly reviewed
// as a data/inference operation. A new route fails closed at review time instead
// of silently falling through the inventory's one-way "listed routes exist" check.
diff --git a/server/routes/hostControlX.test.js b/server/routes/hostControlX.test.js
new file mode 100644
index 0000000000..504a77504b
--- /dev/null
+++ b/server/routes/hostControlX.test.js
@@ -0,0 +1,290 @@
+import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { EventEmitter } from 'node:events';
+import express from 'express';
+import { request } from '../lib/testHelper.js';
+import { errorMiddleware } from '../lib/errorHandler.js';
+import { cleanupTempDataRoots, lazyTempDataRoot, makePathsProxy } from '../lib/mockPathsDataRoot.js';
+import { DEV_PROXY_CLIENT_ADDRESS_HEADER } from '../../lib/portosAuthCore.js';
+import { derivePeerAuthToken, PEER_AUTH_HEADER, PEER_INSTANCE_HEADER } from '../lib/peerHttpClient.js';
+
+vi.mock('../lib/fileUtils.js', async (importOriginal) =>
+ makePathsProxy(await importOriginal(), { dataRoot: () => lazyTempDataRoot('portos-x-authority-') }));
+afterAll(cleanupTempDataRoots);
+
+const auth = vi.hoisted(() => ({ enabled: false }));
+vi.mock('../services/auth.js', async (importOriginal) => ({
+ ...await importOriginal(),
+ isAuthEnabled: vi.fn(async () => auth.enabled),
+ verifyPassword: vi.fn(async () => true),
+}));
+
+vi.mock('../services/settings.js', () => ({
+ settingsEvents: new EventEmitter(),
+ getSettings: vi.fn(async () => ({})),
+}));
+
+vi.mock('../services/instanceIdentity.js', () => ({
+ loadData: vi.fn(async () => ({ peers: [{
+ id: 'example-peer', instanceId: 'example-instance', enabled: true, syncSecret: 'a'.repeat(32),
+ }] })),
+}));
+
+const openXHandoff = vi.hoisted(() => vi.fn());
+vi.mock('../services/xBrowser.js', () => ({
+ openXHandoff,
+ fixedXUrl: vi.fn(() => 'https://x.com/example_user'),
+ verifyFinalXOrigin: vi.fn(),
+ verifyFinalXPath: vi.fn(),
+}));
+
+const executeXBrowserRead = vi.hoisted(() => vi.fn());
+vi.mock('../integrations/x/index.js', () => ({
+ executeXBrowserRead,
+}));
+
+const storage = vi.hoisted(() => ({ query: vi.fn() }));
+vi.mock('../lib/db.js', () => ({
+ query: storage.query,
+ withTransaction: async (callback) => callback({ query: storage.query }),
+}));
+
+import { authGate, hostControlRouteGate } from '../services/authGate.js';
+import { createSession } from '../services/auth.js';
+import xRoutes from './x.js';
+
+const account = {
+ id: '00000000-0000-4000-8000-000000000001',
+ label: 'Main X Account',
+ username: 'example_user',
+ enabled: true,
+ notes: '',
+ profile_snapshot: {},
+ last_sync_at: null,
+ last_error: null,
+ created_at: new Date().toISOString(),
+ updated_at: new Date().toISOString(),
+};
+
+const draftId = '00000000-0000-4000-8000-000000000002';
+let draft;
+
+const seedDraft = (state = 'pending_review', approvedAt = null) => ({
+ id: draftId,
+ account_id: account.id,
+ account_label: account.label,
+ username: account.username,
+ body: 'Hello world from X draft',
+ state,
+ review_note: '',
+ result: {},
+ approved_at: approvedAt,
+ created_at: new Date().toISOString(),
+ updated_at: new Date().toISOString(),
+});
+
+beforeEach(() => {
+ vi.clearAllMocks();
+ auth.enabled = false;
+ draft = seedDraft();
+
+ storage.query.mockImplementation(async (sql, params = []) => {
+ if (/SELECT \* FROM x_accounts WHERE id=\$1/.test(sql)) {
+ return { rows: [account], rowCount: 1 };
+ }
+ if (/SELECT \* FROM x_accounts/.test(sql)) {
+ return { rows: [account], rowCount: 1 };
+ }
+ if (/SELECT d\.\*.*a\.enabled\s+FROM x_drafts/s.test(sql)) {
+ return { rows: [{ ...draft, enabled: account.enabled }], rowCount: 1 };
+ }
+ if (/SELECT d\.\*.*FROM x_drafts.*WHERE d\.id=\$1/s.test(sql)) {
+ return { rows: [draft], rowCount: 1 };
+ }
+ if (/SELECT d\.\*.*FROM x_drafts.*WHERE d\.account_id=\$1/s.test(sql)) {
+ return { rows: [draft], rowCount: 1 };
+ }
+ if (sql.includes('SELECT * FROM x_posts')) {
+ return { rows: [], rowCount: 0 };
+ }
+ if (sql.includes('INSERT INTO x_drafts')) {
+ draft = {
+ id: params[0],
+ account_id: params[1],
+ account_label: account.label,
+ username: account.username,
+ body: params[2],
+ state: 'pending_review',
+ review_note: '',
+ result: {},
+ approved_at: null,
+ created_at: new Date().toISOString(),
+ updated_at: new Date().toISOString(),
+ };
+ return { rows: [draft], rowCount: 1 };
+ }
+ if (sql.includes('UPDATE x_drafts SET state=$2,review_note')) {
+ if (draft.state !== params[3]) return { rows: [], rowCount: 0 };
+ draft = {
+ ...draft,
+ state: params[1],
+ review_note: params[2],
+ approved_at: params[1] === 'approved' ? new Date().toISOString() : draft.approved_at,
+ updated_at: new Date().toISOString(),
+ };
+ return { rows: [draft], rowCount: 1 };
+ }
+ if (sql.includes("UPDATE x_drafts SET state='opened'")) {
+ if (draft.state !== 'approved') return { rows: [], rowCount: 0 };
+ draft = {
+ ...draft,
+ state: 'opened',
+ result: params[1],
+ updated_at: new Date().toISOString(),
+ };
+ return { rows: [draft], rowCount: 1 };
+ }
+ if (sql.includes('INSERT INTO x_posts')) {
+ return { rows: [], rowCount: 1 };
+ }
+ if (sql.includes('UPDATE x_accounts SET profile_snapshot=$2')) {
+ return { rows: [], rowCount: 1 };
+ }
+ return { rows: [], rowCount: 0 };
+ });
+
+ openXHandoff.mockResolvedValue({
+ pageId: 'page-1',
+ url: 'https://x.com/compose/post?text=Hello',
+ });
+
+ executeXBrowserRead.mockImplementation(async (target) => {
+ if (target === 'profile') return { profile: { username: account.username }, posts: [] };
+ if (target === 'latest') return { posts: [] };
+ if (target === 'people') return { exactMatch: true, handles: [account.username] };
+ return {};
+ });
+});
+
+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/x', xRoutes);
+ app.use(errorMiddleware);
+ return app;
+};
+
+const post = (app, path, body = {}, headers = {}) => {
+ const pending = request(app).post(path);
+ for (const [name, value] of Object.entries(headers)) pending.set(name, value);
+ return pending.send(body);
+};
+
+describe('X (Twitter) review, browser handoff and sync authority', () => {
+ it.each([
+ ['remote without auth', false, '192.0.2.10', {}, 403, 'HOST_CONTROL_FORBIDDEN'],
+ ['forwarded remote without auth', false, '127.0.0.1', { [DEV_PROXY_CLIENT_ADDRESS_HEADER]: '192.0.2.10' }, 403, 'HOST_CONTROL_FORBIDDEN'],
+ ['anonymous with auth', true, '192.0.2.10', {}, 401, 'AUTH_REQUIRED'],
+ ['Basic password', true, '192.0.2.10', { Authorization: `Basic ${Buffer.from(':example-password').toString('base64')}` }, 403, 'HOST_CONTROL_FORBIDDEN'],
+ ['scoped peer', true, '192.0.2.10', {
+ [PEER_AUTH_HEADER]: derivePeerAuthToken('a'.repeat(32), 'example-instance'), [PEER_INSTANCE_HEADER]: 'example-instance',
+ }, 403, 'PEER_SCOPE_FORBIDDEN'],
+ ])('refuses %s for draft review, compose open, destination open and sync', async (_name, enabled, address, headers, status, code) => {
+ auth.enabled = enabled;
+ const app = appFor(address);
+
+ const review = await post(app, `/api/x/drafts/${draft.id}/review`, { state: 'approved' }, headers);
+ expect(review.status, JSON.stringify(review.body)).toBe(status);
+ expect(review.body.code).toBe(code);
+ expect(draft.state).toBe('pending_review');
+
+ draft = seedDraft('approved', new Date().toISOString());
+ const openDraft = await post(app, `/api/x/drafts/${draft.id}/open`, {}, headers);
+ expect(openDraft.status, JSON.stringify(openDraft.body)).toBe(status);
+ expect(openDraft.body.code).toBe(code);
+
+ const openAccount = await post(app, `/api/x/accounts/${account.id}/open`, { kind: 'profile' }, headers);
+ expect(openAccount.status, JSON.stringify(openAccount.body)).toBe(status);
+ expect(openAccount.body.code).toBe(code);
+
+ const sync = await post(app, `/api/x/accounts/${account.id}/sync`, {}, headers);
+ expect(sync.status, JSON.stringify(sync.body)).toBe(status);
+ expect(sync.body.code).toBe(code);
+
+ expect(openXHandoff).not.toHaveBeenCalled();
+ expect(executeXBrowserRead).not.toHaveBeenCalled();
+ });
+
+ it('protects Express case and trailing-slash aliases and rejected reviews too', async () => {
+ const app = appFor();
+ const review = await post(app, `/API/X/DRAFTS/${draft.id}/REVIEW/`, { state: 'rejected' });
+ const openDraft = await post(app, `/API/X/DRAFTS/${draft.id}/OPEN/`);
+ const openAccount = await post(app, `/API/X/ACCOUNTS/${account.id}/OPEN/`, { kind: 'profile' });
+ const sync = await post(app, `/API/X/ACCOUNTS/${account.id}/SYNC/`);
+
+ expect(review.status).toBe(403);
+ expect(openDraft.status).toBe(403);
+ expect(openAccount.status).toBe(403);
+ expect(sync.status).toBe(403);
+ expect(openXHandoff).not.toHaveBeenCalled();
+ expect(executeXBrowserRead).not.toHaveBeenCalled();
+ });
+
+ it.each([
+ ['local'], ['operator session'], ['delegated agent'],
+ ])('preserves %s review, compose open, destination open and sync through real consumer', async (principal) => {
+ const headers = {};
+ if (principal !== 'local') {
+ const session = await createSession({ label: principal === 'delegated agent' ? 'agent' : 'operator' });
+ auth.enabled = true;
+ if (principal === 'delegated agent') headers.Authorization = `Bearer ${session.token}`;
+ else headers.Cookie = `portos_auth=${session.token}`;
+ }
+ const app = appFor(principal === 'operator session' ? '192.0.2.10' : '127.0.0.1');
+
+ // 1. Approve review
+ const review = await post(app, `/api/x/drafts/${draft.id}/review`, { state: 'approved' }, headers);
+ expect(review.status, JSON.stringify(review.body)).toBe(200);
+ expect(review.body.state).toBe('approved');
+ expect(draft.state).toBe('approved');
+
+ // 2. Open approved draft
+ const openDraft = await post(app, `/api/x/drafts/${draft.id}/open`, {}, headers);
+ expect(openDraft.status, JSON.stringify(openDraft.body)).toBe(200);
+ expect(openDraft.body.state).toBe('opened');
+ expect(openXHandoff).toHaveBeenCalledWith({ kind: 'compose', value: draft.body });
+
+ // 3. Open account destination
+ const openAccount = await post(app, `/api/x/accounts/${account.id}/open`, { kind: 'profile' }, headers);
+ expect(openAccount.status, JSON.stringify(openAccount.body)).toBe(200);
+ expect(openXHandoff).toHaveBeenCalledWith({ kind: 'profile', value: account.username });
+
+ // 4. Sync account
+ const sync = await post(app, `/api/x/accounts/${account.id}/sync`, {}, headers);
+ expect(sync.status, JSON.stringify(sync.body)).toBe(200);
+ expect(executeXBrowserRead).toHaveBeenCalledTimes(3);
+ });
+
+ it('keeps remote reads and draft creation available without granting execution or approval', async () => {
+ const app = appFor();
+
+ const capabilities = await request(app).get('/api/x/capabilities');
+ expect(capabilities.status).toBe(200);
+
+ const accounts = await request(app).get('/api/x/accounts');
+ expect(accounts.status).toBe(200);
+
+ const drafts = await request(app).get(`/api/x/accounts/${account.id}/drafts`);
+ expect(drafts.status).toBe(200);
+
+ const createdDraft = await post(app, '/api/x/drafts', { accountId: account.id, body: 'New proposed post' });
+ expect(createdDraft.status, JSON.stringify(createdDraft.body)).toBe(201);
+ expect(createdDraft.body.state).toBe('pending_review');
+
+ expect(openXHandoff).not.toHaveBeenCalled();
+ expect(executeXBrowserRead).not.toHaveBeenCalled();
+ });
+});
diff --git a/server/routes/x.js b/server/routes/x.js
index 87d353d26e..5095966b1e 100644
--- a/server/routes/x.js
+++ b/server/routes/x.js
@@ -60,6 +60,9 @@ router.delete('/accounts/:id', asyncHandler(async (req, res) => {
res.status(204).send();
}));
+// Sync and destination open execute CDP browser automation or handoffs on the host;
+// draft review authorizes a public post and compose open launches the CDP compose
+// view. All four require operator authority via the central host-control gate.
router.post('/accounts/:id/sync', asyncHandler(async (req, res) => {
requireId(req.params.id, 'account ID');
const result = await x.syncAccount(req.params.id);