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 Deck and chiptune host actions (#10893)

Adam Eivy0483929d0324
diff --git a/server/lib/hostControlRoutes.js b/server/lib/hostControlRoutes.js
index c298c3daf4..2ad27f4dd0 100644
--- a/server/lib/hostControlRoutes.js
+++ b/server/lib/hostControlRoutes.js
@@ -454,6 +454,18 @@ export const HOST_CONTROL_ROUTES = Object.freeze([
'PUT /api/sprites/:id/publish-binding',
'POST /api/sprites/:id/atlas/publish',
+ // Deck authoring/rendering and chiptune generation hand editable text to a
+ // provider that may fall back to a CLI/TUI, or enqueue an agent-backed image
+ // job; chiptune publication writes into a managed app repo (#10893). Gate the
+ // whole operation, API-first variants included. Deck/track CRUD, progress
+ // reads and the deterministic chiptune library render stay open.
+ 'POST /api/decks/:id/analyze-sample',
+ 'POST /api/decks/:id/generate-prompts',
+ 'POST /api/decks/:id/render',
+ 'POST /api/decks/:id/cards/:cardId/render',
+ 'POST /api/tracks/:id/chiptune/generate',
+ 'POST /api/tracks/:id/chiptune/publish',
+
// Auxiliary media entry points reach the same tool-capable agents (#9672):
// prompt refinement and image-to-prompt hand caller text/images to a provider
// that may fall back to a CLI/TUI; retry and run-now (re)dispatch an
diff --git a/server/routes/hostControlDecksChiptune.test.js b/server/routes/hostControlDecksChiptune.test.js
new file mode 100644
index 0000000000..eeed89704b
--- /dev/null
+++ b/server/routes/hostControlDecksChiptune.test.js
@@ -0,0 +1,235 @@
+import { afterAll, afterEach, 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 { DEV_PROXY_CLIENT_ADDRESS_HEADER } from '../../lib/portosAuthCore.js';
+import { cleanupTempDataRoots, lazyTempDataRoot, makePathsProxy } from '../lib/mockPathsDataRoot.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-deck-chiptune-authority-') }));
+afterAll(cleanupTempDataRoots);
+afterEach(() => vi.restoreAllMocks());
+vi.mock('../services/instanceIdentity.js', () => ({
+ loadData: vi.fn(async () => ({ peers: [{
+ id: 'example-peer', instanceId: 'example-instance', enabled: true, syncSecret: 'a'.repeat(32),
+ }] })),
+}));
+
+// Mount the production Decks and Tracks routers behind the real gates. Only
+// persistence, provider, queue and app-file effects are doubled (#10893).
+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 () => ({})),
+}));
+
+const deckId = '00000000-0000-4000-8000-000000000001';
+const cardId = '00000000-0000-4000-8000-000000000002';
+vi.mock('../services/decks.js', () => ({
+ listDecks: vi.fn(async () => []),
+ getDeck: vi.fn(async () => ({
+ id: '00000000-0000-4000-8000-000000000001',
+ cards: [{ id: '00000000-0000-4000-8000-000000000002', key: 'example-card', prompt: '' }],
+ })),
+ applyCardGenerations: vi.fn(async () => 1),
+}));
+vi.mock('../services/deckStyleAnalysis.js', () => ({
+ analyzeDeckSample: vi.fn(async () => ({ proposal: {} })),
+}));
+vi.mock('../services/deckPrompts.js', () => ({
+ PROMPTS_PER_CALL: 16,
+ castDeckFromUniverse: vi.fn(async () => ({ assignments: [] })),
+ generateDeckCardPrompts: vi.fn(async () => ({ llm: {} })),
+}));
+vi.mock('../services/deckRender.js', () => ({
+ renderDeckCards: vi.fn(async () => ({ queued: 1 })),
+}));
+vi.mock('../services/deckPromptProgress.js', () => ({
+ attachClient: vi.fn(),
+ beginPromptProgress: vi.fn(() => true),
+ emitPromptProgress: vi.fn(),
+ finishPromptProgress: vi.fn(),
+}));
+vi.mock('./universeBuilder/shared.js', () => ({
+ resolveGalleryImageOrThrow: vi.fn((name) => ({ imageFilename: name, imagePath: `/example/${name}` })),
+}));
+
+vi.mock('../services/tracks/index.js', async () => ({
+ ...await import('../services/tracks/logic.js'),
+ getTrack: vi.fn(async (id) => ({ id })),
+}));
+vi.mock('../services/pipeline/musicLibrary.js', () => ({ MUSIC_UPLOAD_MAX_BYTES: 1024 }));
+vi.mock('../services/trackAudioAttach.js', () => ({}));
+vi.mock('../services/trackAlbumMembership.js', () => ({}));
+vi.mock('../services/trackYoutubeImport.js', () => ({}));
+vi.mock('../services/trackSunoImport.js', () => ({}));
+vi.mock('../services/musicWaveform.js', () => ({}));
+vi.mock('../services/musicCode.js', () => ({}));
+vi.mock('../services/chiptune.js', () => ({
+ generateChiptuneScore: vi.fn(async () => ({ track: {} })),
+ renderChiptuneTrack: vi.fn(async () => ({ track: {} })),
+ publishChiptuneTrack: vi.fn(async () => ({ published: true })),
+}));
+
+import { authGate, hostControlRouteGate } from '../services/authGate.js';
+import decksRoutes from './decks.js';
+import tracksRoutes from './tracks.js';
+import { createSession, revokeSessionById } from '../services/auth.js';
+import { getDeck, applyCardGenerations } from '../services/decks.js';
+import { analyzeDeckSample } from '../services/deckStyleAnalysis.js';
+import { generateDeckCardPrompts } from '../services/deckPrompts.js';
+import { renderDeckCards } from '../services/deckRender.js';
+import { beginPromptProgress } from '../services/deckPromptProgress.js';
+import { getTrack } from '../services/tracks/index.js';
+import { generateChiptuneScore, renderChiptuneTrack, publishChiptuneTrack } from '../services/chiptune.js';
+
+let ownerSession;
+// An API-first pick (the shared runner can still fall back to a CLI/TUI) and an
+// explicit tool-capable pick must be gated identically: authority never depends
+// on the selected backend.
+const apiPick = { providerId: 'example-api-provider', model: 'example-model' };
+const cliPick = { providerId: 'example-cli-provider', model: 'example-model' };
+const operations = [
+ [`/api/decks/${deckId}/analyze-sample`, { image: 'example.png', ...apiPick }, analyzeDeckSample, 200],
+ [`/api/decks/${deckId}/analyze-sample`, { image: 'example.png', ...cliPick }, analyzeDeckSample, 200],
+ [`/api/decks/${deckId}/generate-prompts`, { ...apiPick }, generateDeckCardPrompts, 200],
+ [`/api/decks/${deckId}/generate-prompts`, { ...cliPick }, generateDeckCardPrompts, 200],
+ [`/api/decks/${deckId}/render`, { mode: 'local' }, renderDeckCards, 200],
+ [`/api/decks/${deckId}/render`, { mode: 'grok' }, renderDeckCards, 200],
+ [`/api/decks/${deckId}/cards/${cardId}/render`, { mode: 'local' }, renderDeckCards, 200],
+ [`/api/decks/${deckId}/cards/${cardId}/render`, { mode: 'codex' }, renderDeckCards, 200],
+ [`/api/tracks/${deckId}/chiptune/generate`, { prompt: 'Example tune', ...apiPick }, generateChiptuneScore, 200],
+ [`/api/tracks/${deckId}/chiptune/generate`, { prompt: 'Example tune', ...cliPick }, generateChiptuneScore, 200],
+ [`/api/tracks/${deckId}/chiptune/publish`, { appId: 'example-app' }, publishChiptuneTrack, 200],
+];
+const effects = [
+ getDeck, applyCardGenerations, analyzeDeckSample, generateDeckCardPrompts, renderDeckCards,
+ beginPromptProgress, getTrack, generateChiptuneScore, publishChiptuneTrack,
+];
+const expectNoEffects = () => {
+ for (const effect of effects) expect(effect).not.toHaveBeenCalled();
+};
+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/decks', decksRoutes);
+ app.use('/api/tracks', tracksRoutes);
+ app.use(errorMiddleware);
+ return app;
+};
+const call = (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);
+};
+
+beforeEach(async () => {
+ vi.clearAllMocks();
+ auth.enabled = false;
+ ownerSession = await createSession();
+});
+
+describe('Deck and chiptune host-action authority (#10893)', () => {
+ it('refuses remote password-free and dev-proxy callers before any route, provider, store or app-file effect', async () => {
+ for (const operation of operations) {
+ for (const [address, headers] of [
+ ['192.0.2.10', {}],
+ ['127.0.0.1', { [DEV_PROXY_CLIENT_ADDRESS_HEADER]: '192.0.2.10' }],
+ ['192.0.2.10', { [DEV_PROXY_CLIENT_ADDRESS_HEADER]: '127.0.0.1' }],
+ ]) {
+ const response = await call(appFor(address), operation, headers);
+ expect([response.status, response.body.code], operation[0]).toEqual([403, 'HOST_CONTROL_FORBIDDEN']);
+ }
+ }
+ expectNoEffects();
+ });
+
+ it('gates before body validation so malformed requests learn nothing from a remote caller', async () => {
+ for (const [path] of operations) {
+ const response = await call(appFor(), [path, { unexpected: true }]);
+ expect([response.status, response.body.code], path).toEqual([403, 'HOST_CONTROL_FORBIDDEN']);
+ }
+ expectNoEffects();
+ });
+
+ it('requires authentication with a password, denies legacy Basic, and rejects scoped-peer credentials', async () => {
+ auth.enabled = true;
+ for (const operation of operations) {
+ for (const [headers, status, code] of [
+ [{}, 401, 'AUTH_REQUIRED'],
+ [{ Authorization: 'Bearer invalid-session' }, 401, 'AUTH_REQUIRED'],
+ [{ Authorization: 'Basic ' + Buffer.from(':example-password').toString('base64') }, 403, 'HOST_CONTROL_FORBIDDEN'],
+ [{
+ [PEER_AUTH_HEADER]: derivePeerAuthToken('a'.repeat(32), 'example-instance'),
+ [PEER_INSTANCE_HEADER]: 'example-instance',
+ }, 403, 'PEER_SCOPE_FORBIDDEN'],
+ ]) {
+ const response = await call(appFor(), operation, headers);
+ expect([response.status, response.body.code], operation[0]).toEqual([status, code]);
+ }
+ }
+ const revoked = await createSession({ label: 'agent' });
+ await revokeSessionById(revoked.id);
+ const response = await call(appFor(), operations[0], { Cookie: `portos_auth=${revoked.token}` });
+ expect(response.status).toBe(401);
+ expectNoEffects();
+ });
+
+ it('matches case and trailing-slash variants', async () => {
+ for (const [path, body] of operations) {
+ const response = await call(appFor(), [path.toUpperCase() + '/', body]);
+ expect([response.status, response.body.code], path).toEqual([403, 'HOST_CONTROL_FORBIDDEN']);
+ }
+ expectNoEffects();
+ });
+
+ it('retains genuine local, operator and delegated-agent workflows with the chosen backend untouched', async () => {
+ const agentSession = await createSession({ label: 'agent' });
+ for (const [enabled, address, headers] of [
+ [false, '127.0.0.1', {}],
+ [true, '192.0.2.10', { Authorization: `Bearer ${ownerSession.token}` }],
+ [true, '192.0.2.10', { Cookie: `portos_auth=${agentSession.token}` }],
+ [true, '192.0.2.10', { Authorization: `Bearer ${agentSession.token}` }],
+ ]) {
+ auth.enabled = enabled;
+ for (const operation of operations) {
+ const response = await call(appFor(address), operation, headers);
+ expect(response.status, `${operation[0]}: ${JSON.stringify(response.body)}`).toBe(operation[3]);
+ }
+ }
+ expect(analyzeDeckSample).toHaveBeenCalledTimes(8);
+ expect(analyzeDeckSample.mock.calls.map(([args]) => args.providerId))
+ .toEqual(Array(4).fill(['example-api-provider', 'example-cli-provider']).flat());
+ expect(generateDeckCardPrompts).toHaveBeenCalledTimes(8);
+ expect(renderDeckCards).toHaveBeenCalledTimes(16);
+ expect(renderDeckCards.mock.calls.map(([, options]) => options.mode)).toEqual(
+ Array(4).fill(['local', 'grok', 'local', 'codex']).flat());
+ expect(generateChiptuneScore).toHaveBeenCalledTimes(8);
+ expect(generateChiptuneScore.mock.calls.map(([args]) => args.providerId))
+ .toEqual(Array(4).fill(['example-api-provider', 'example-cli-provider']).flat());
+ expect(publishChiptuneTrack).toHaveBeenCalledTimes(4);
+ });
+
+ it('keeps CRUD, progress, deterministic chiptune render and track reads open to remote callers', async () => {
+ const app = appFor();
+ expect((await request(app).get('/api/decks')).status).toBe(200);
+ expect((await call(app, [`/api/tracks/${deckId}/chiptune/render`, {}])).status).toBe(200);
+ expect(renderChiptuneTrack).toHaveBeenCalledTimes(1);
+ expect(generateChiptuneScore).not.toHaveBeenCalled();
+ expect(publishChiptuneTrack).not.toHaveBeenCalled();
+ expect(analyzeDeckSample).not.toHaveBeenCalled();
+ expect(generateDeckCardPrompts).not.toHaveBeenCalled();
+ expect(renderDeckCards).not.toHaveBeenCalled();
+ });
+});