gestalt-mobile 0.13.0 → 0.14.0

package/dist/client/index.html

@@ -9,9 +9,10 @@ SPDX-License-Identifier: AGPL-3.0-or-later
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="color-scheme" content="light dark" />
     <title>Codex Relay</title>
-    <script type="module" crossorigin src="/assets/index-D2sT9ZHY.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CMs5ZzxJ.css">
+    <script type="module" crossorigin src="/assets/index-tMyOolAm.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-C5qFcFUg.css">
   </head>
   <body>
     <div id="app"></div>

package/dist/server/server/cli.js

@@ -99,7 +99,9 @@ async function listSkillProfiles(store, stdout, stderr) {
             if (!profile)
                 continue;
             stdout.write(`${profile.name}\n  ${store.globalProfilePath(name)}\n`);
-            for (const skill of [...profile.skills].filter((entry) => entry.enabled).sort((a, b) => a.name.localeCompare(b.name) || a.path.localeCompare(b.path)))
+            for (const skill of [...profile.skills]
+                .filter((entry) => entry.enabled)
+                .sort((a, b) => a.name.localeCompare(b.name) || a.path.localeCompare(b.path)))
                 stdout.write(`  ${skill.name}\t${skill.path}\n`);
         }
         catch (error) {

package/dist/server/server/composition.js

@@ -44,7 +44,7 @@ import { FilesystemPlanStatusSource } from './platform/plans/filesystem-plan-sta
 import { FilesystemWorkspacePlanCatalog } from './platform/plans/filesystem-workspace-plan-catalog.js';
 import { checkpointPlanMeasurement } from './platform/plans/plan-measurement-command.js';
 import { PlanMeasurementRefresh } from './platform/plans/plan-measurement-refresh.js';
-import { createRelyingPartyConfig, } from './config.js';
+import { createRelyingPartyConfig } from './config.js';
 const generatedProtocolVersion = 'codex-cli 0.144.3';
 export async function composeRelayApp(options) {
     const passkeyAuthEnabled = options.passkeyAuthEnabled ?? true;
@@ -194,29 +194,33 @@ export async function composeRelayApp(options) {
     let app;
     try {
         app = await buildApp({
-            ...(authorization ? { auth: {
-                    repository: authorization,
-                    clock: { now: options.authorizationClock ?? (() => new Date()) },
-                    random: {
-                        bytes: (length) => {
-                            const value = authorizationRandom(length);
-                            if (length !== 32 || value.length !== 32)
-                                throw new Error('Authorization randomness must return exactly 32 bytes');
-                            return value;
+            ...(authorization
+                ? {
+                    auth: {
+                        repository: authorization,
+                        clock: { now: options.authorizationClock ?? (() => new Date()) },
+                        random: {
+                            bytes: (length) => {
+                                const value = authorizationRandom(length);
+                                if (length !== 32 || value.length !== 32)
+                                    throw new Error('Authorization randomness must return exactly 32 bytes');
+                                return value;
+                            },
                         },
-                    },
-                    identifiers: {
-                        sessionId: () => {
-                            const value = authorizationRandom(32);
-                            if (value.length !== 32)
-                                throw new Error('Authorization randomness must return exactly 32 bytes');
-                            return authorizationSessionId(Buffer.from(value).toString('base64url'));
+                        identifiers: {
+                            sessionId: () => {
+                                const value = authorizationRandom(32);
+                                if (value.length !== 32)
+                                    throw new Error('Authorization randomness must return exactly 32 bytes');
+                                return authorizationSessionId(Buffer.from(value).toString('base64url'));
+                            },
+                            deviceId: () => authorizedDeviceId(randomUUID()),
                         },
-                        deviceId: () => authorizedDeviceId(randomUUID()),
+                        webauthn: options.authorizationWebauthn ?? new SimpleWebAuthnAdapter(),
+                        relyingParty,
                     },
-                    webauthn: options.authorizationWebauthn ?? new SimpleWebAuthnAdapter(),
-                    relyingParty,
-                } } : { passkeyAuthDisabled: true }),
+                }
+                : { passkeyAuthDisabled: true }),
             health: {
                 async read() {
                     return {

package/dist/server/server/features/auth/devices/revoke/endpoint.js

@@ -28,7 +28,9 @@ export function registerRevokeAuthorizedDevice(app, deps) {
                 return unavailable(reply, 404, 'DEVICE_NOT_AVAILABLE');
             if (current === id)
                 reply.clearCookie('gestalt_mobile_session', {
-                    path: '/', httpOnly: true, sameSite: 'strict',
+                    path: '/',
+                    httpOnly: true,
+                    sameSite: 'strict',
                     secure: deps.relyingParty.publicOrigin.startsWith('https://'),
                 });
             return reply.code(204).send();

package/dist/server/server/features/auth/enrollment-tickets/endpoint.js

@@ -4,7 +4,8 @@ export function registerCreateEnrollmentTicket(app, deps) {
     app.post('/api/auth/enrollment-tickets', async (request, reply) => {
         const rawSession = request.cookies.gestalt_mobile_session;
         const session = parseAuthorizationSessionId(rawSession);
-        if (session === null || deps.repository.sessionDevice(session, deps.clock.now().toISOString()) === null)
+        if (session === null ||
+            deps.repository.sessionDevice(session, deps.clock.now().toISOString()) === null)
             return reply.code(401).send();
         const entropy = deps.random.bytes(32);
         if (entropy.length < 32)
@@ -12,6 +13,10 @@ export function registerCreateEnrollmentTicket(app, deps) {
         const ticket = enrollmentTicketId(Buffer.from(entropy).toString('base64url'));
         const expiresAt = new Date(deps.clock.now().getTime() + lifetimeMs).toISOString();
         deps.repository.issueEnrollmentTicket(ticket, session, expiresAt);
-        return reply.code(201).send({ ticket, url: `${deps.relyingParty.publicOrigin.replace(/\/$/, '')}/#enroll=${ticket}`, expiresAt });
+        return reply.code(201).send({
+            ticket,
+            url: `${deps.relyingParty.publicOrigin.replace(/\/$/, '')}/#enroll=${ticket}`,
+            expiresAt,
+        });
     });
 }

package/dist/server/server/features/auth/enrollment-tickets/status/endpoint.js

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 import { parseAuthorizationSessionId } from '../../domain/identifiers.js';
-const responseSchema = z.object({ status: z.enum(['none', 'pending', 'used', 'expired']) }).strict();
+const responseSchema = z
+    .object({ status: z.enum(['none', 'pending', 'used', 'expired']) })
+    .strict();
 export function registerEnrollmentTicketStatus(app, deps) {
     app.get('/api/auth/enrollment-tickets/current', async (request, reply) => {
         const rawSession = request.cookies.gestalt_mobile_session;

package/dist/server/server/features/auth/http/cookies.js

@@ -1,6 +1,16 @@
-const seconds = { gestalt_mobile_login: 600, gestalt_mobile_registration: 600, gestalt_mobile_session: 30 * 24 * 60 * 60 };
+const seconds = {
+    gestalt_mobile_login: 600,
+    gestalt_mobile_registration: 600,
+    gestalt_mobile_session: 30 * 24 * 60 * 60,
+};
 function options(name, origin) {
-    return { httpOnly: true, sameSite: 'strict', path: '/', secure: origin.startsWith('https://'), maxAge: seconds[name] };
+    return {
+        httpOnly: true,
+        sameSite: 'strict',
+        path: '/',
+        secure: origin.startsWith('https://'),
+        maxAge: seconds[name],
+    };
 }
 export function setAuthCookie(reply, name, value, origin) {
     reply.setCookie(name, value, options(name, origin));

package/dist/server/server/features/auth/register/verify/endpoint.js

@@ -1,16 +1,34 @@
 import { z } from 'zod';
 import { problem } from '../../../../platform/http/problem.js';
-import { PasskeyVerificationError } from '../../application/ports.js';
+import { PasskeyVerificationError, } from '../../application/ports.js';
 import { deviceNickname } from '../../domain/device-nickname.js';
 import { passkeyCeremonyId } from '../../domain/identifiers.js';
 import { AuthorizationDomainError } from '../../domain/errors.js';
 import { clearAuthCookie, setAuthCookie } from '../../http/cookies.js';
-const registrationResponseSchema = z.object({
-    id: z.string().min(1), rawId: z.string().min(1), type: z.literal('public-key'),
-    response: z.object({ clientDataJSON: z.string().min(1), attestationObject: z.string().min(1), authenticatorData: z.string().min(1).optional(), transports: z.array(z.enum(['ble', 'hybrid', 'internal', 'nfc', 'usb', 'cable', 'smart-card'])).optional(), publicKeyAlgorithm: z.number().int().optional(), publicKey: z.string().min(1).optional() }).strict(),
-    authenticatorAttachment: z.enum(['platform', 'cross-platform']).optional(), clientExtensionResults: z.record(z.string(), z.unknown()),
-}).strict();
-const requestSchema = z.object({ response: registrationResponseSchema, nickname: z.string() }).strict();
+const registrationResponseSchema = z
+    .object({
+    id: z.string().min(1),
+    rawId: z.string().min(1),
+    type: z.literal('public-key'),
+    response: z
+        .object({
+        clientDataJSON: z.string().min(1),
+        attestationObject: z.string().min(1),
+        authenticatorData: z.string().min(1).optional(),
+        transports: z
+            .array(z.enum(['ble', 'hybrid', 'internal', 'nfc', 'usb', 'cable', 'smart-card']))
+            .optional(),
+        publicKeyAlgorithm: z.number().int().optional(),
+        publicKey: z.string().min(1).optional(),
+    })
+        .strict(),
+    authenticatorAttachment: z.enum(['platform', 'cross-platform']).optional(),
+    clientExtensionResults: z.record(z.string(), z.unknown()),
+})
+    .strict();
+const requestSchema = z
+    .object({ response: registrationResponseSchema, nickname: z.string() })
+    .strict();
 const successSchema = z.object({ status: z.literal('authenticated') }).strict();
 const sessionLifetimeMs = 30 * 24 * 60 * 60 * 1000;
 export function registerRegistrationVerification(app, deps) {
@@ -18,39 +36,76 @@ export function registerRegistrationVerification(app, deps) {
         const parsed = requestSchema.safeParse(request.body);
         const token = request.cookies.gestalt_mobile_registration;
         if (!parsed.success || typeof token !== 'string')
-            return reply.code(400).type('application/problem+json').send(problem('INVALID_REGISTRATION_REQUEST', 400, 'The registration request is invalid.'));
+            return reply
+                .code(400)
+                .type('application/problem+json')
+                .send(problem('INVALID_REGISTRATION_REQUEST', 400, 'The registration request is invalid.'));
         let nickname;
         try {
             nickname = deviceNickname(parsed.data.nickname);
         }
         catch (error) {
             if (error instanceof AuthorizationDomainError)
-                return reply.code(400).type('application/problem+json').send(problem('INVALID_DEVICE_NICKNAME', 400, 'The device nickname is invalid.'));
+                return reply
+                    .code(400)
+                    .type('application/problem+json')
+                    .send(problem('INVALID_DEVICE_NICKNAME', 400, 'The device nickname is invalid.'));
             throw error;
         }
         const now = deps.clock.now();
         const ceremony = deps.repository.readCeremony(passkeyCeremonyId(token), now.toISOString());
         if (!ceremony || ceremony.purpose !== 'registration')
-            return reply.code(400).type('application/problem+json').send(problem('REGISTRATION_NOT_AVAILABLE', 400, 'Registration could not be completed.'));
+            return reply
+                .code(400)
+                .type('application/problem+json')
+                .send(problem('REGISTRATION_NOT_AVAILABLE', 400, 'Registration could not be completed.'));
         try {
-            const verified = await deps.webauthn.verifyRegistration({ response: parsed.data.response, challenge: ceremony.challenge, expectedOrigin: ceremony.expectedOrigin, rpId: ceremony.rpId });
+            const verified = await deps.webauthn.verifyRegistration({
+                response: parsed.data.response,
+                challenge: ceremony.challenge,
+                expectedOrigin: ceremony.expectedOrigin,
+                rpId: ceremony.rpId,
+            });
             if (!verified.userVerified)
                 throw new PasskeyVerificationError('PASSKEY_VERIFICATION_FAILED');
-            const device = { id: deps.identifiers.deviceId(), credentialId: verified.credentialId, publicKey: verified.publicKey, counter: verified.counter, transports: verified.transports, deviceType: verified.deviceType, backedUp: verified.backedUp, nickname, createdAt: now.toISOString() };
+            const device = {
+                id: deps.identifiers.deviceId(),
+                credentialId: verified.credentialId,
+                publicKey: verified.publicKey,
+                counter: verified.counter,
+                transports: verified.transports,
+                deviceType: verified.deviceType,
+                backedUp: verified.backedUp,
+                nickname,
+                createdAt: now.toISOString(),
+            };
             const session = deps.identifiers.sessionId();
             if (Buffer.from(session, 'base64url').length !== 32)
                 throw new Error('AUTHORIZATION_RANDOMNESS_INVALID');
             const expiresAt = new Date(now.getTime() + sessionLifetimeMs).toISOString();
-            const outcome = deps.repository.completeRegistration({ ceremony: passkeyCeremonyId(token), now: now.toISOString(), device, session: { id: session, deviceId: device.id, expiresAt } });
+            const outcome = deps.repository.completeRegistration({
+                ceremony: passkeyCeremonyId(token),
+                now: now.toISOString(),
+                device,
+                session: { id: session, deviceId: device.id, expiresAt },
+            });
             if (outcome !== 'registered')
-                return reply.code(outcome === 'bootstrapAlreadyClaimed' ? 409 : 400).type('application/problem+json').send(problem(outcome === 'bootstrapAlreadyClaimed' ? 'BOOTSTRAP_ALREADY_CLAIMED' : 'REGISTRATION_NOT_AVAILABLE', outcome === 'bootstrapAlreadyClaimed' ? 409 : 400, 'Registration could not be completed.'));
+                return reply
+                    .code(outcome === 'bootstrapAlreadyClaimed' ? 409 : 400)
+                    .type('application/problem+json')
+                    .send(problem(outcome === 'bootstrapAlreadyClaimed'
+                    ? 'BOOTSTRAP_ALREADY_CLAIMED'
+                    : 'REGISTRATION_NOT_AVAILABLE', outcome === 'bootstrapAlreadyClaimed' ? 409 : 400, 'Registration could not be completed.'));
             setAuthCookie(reply, 'gestalt_mobile_session', session, deps.relyingParty.publicOrigin);
             clearAuthCookie(reply, 'gestalt_mobile_registration', deps.relyingParty.publicOrigin);
             return reply.code(201).send(successSchema.parse({ status: 'authenticated' }));
         }
         catch (error) {
             if (error instanceof PasskeyVerificationError || error instanceof AuthorizationDomainError)
-                return reply.code(400).type('application/problem+json').send(problem('REGISTRATION_VERIFICATION_FAILED', 400, 'Registration could not be completed.'));
+                return reply
+                    .code(400)
+                    .type('application/problem+json')
+                    .send(problem('REGISTRATION_VERIFICATION_FAILED', 400, 'Registration could not be completed.'));
             throw error;
         }
     });

package/dist/server/server/features/plans/application/measurement-snapshot.js

@@ -19,7 +19,7 @@ export function weeklyRateLimitWindow(windows) {
         Number.isFinite(window.usedPercent) &&
         window.usedPercent >= 0 &&
         window.usedPercent <= 100);
-    return valid.reduce((weekly, window) => (!weekly || window.durationSeconds > weekly.durationSeconds ? window : weekly), null);
+    return valid.reduce((weekly, window) => !weekly || window.durationSeconds > weekly.durationSeconds ? window : weekly, null);
 }
 export function weeklyRemainingPercent(windows) {
     const weekly = weeklyRateLimitWindow(windows);

package/dist/server/server/features/plans/get-measurement/endpoint.js

@@ -6,9 +6,7 @@
 export function registerGetPlanMeasurement(app, deps) {
     app.get('/api/sessions/:id/plan-measurement', async (request, reply) => {
         const id = request.params.id;
-        const authorization = typeof request.headers.authorization === 'string'
-            ? request.headers.authorization
-            : undefined;
+        const authorization = typeof request.headers.authorization === 'string' ? request.headers.authorization : undefined;
         if (!deps.exists(id) || !deps.authorize(id, authorization))
             return reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
         try {

package/dist/server/server/features/sessions/interaction/kind.js

@@ -4,5 +4,11 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 export function isInteractionKind(value) {
-    return ['commandApproval', 'fileChangeApproval', 'permissionsApproval', 'userInput', 'quiz'].includes(value);
+    return [
+        'commandApproval',
+        'fileChangeApproval',
+        'permissionsApproval',
+        'userInput',
+        'quiz',
+    ].includes(value);
 }

package/dist/server/server/features/sessions/list-recent-threads/endpoint.js

@@ -15,7 +15,9 @@ export function registerListRecentThreads(app, deps) {
                 recencyAt,
                 ...(metadata?.model === undefined ? {} : { model: metadata.model }),
                 ...(metadata?.skillProfile === undefined ? {} : { skillProfile: metadata.skillProfile }),
-                ...(metadata?.orgPlanFilename === undefined ? {} : { orgPlanFilename: metadata.orgPlanFilename }),
+                ...(metadata?.orgPlanFilename === undefined
+                    ? {}
+                    : { orgPlanFilename: metadata.orgPlanFilename }),
                 resumeCommand: buildResumeCommand({ profile, threadId: id, workspacePath: cwd }),
             };
         });

package/dist/server/server/features/sessions/model/relay-session.js

@@ -136,7 +136,9 @@ function copy(snapshot) {
         ...snapshot,
         ...(snapshot.effectiveSkillSelection === undefined
             ? {}
-            : { effectiveSkillSelection: createEffectiveSkillSelection(snapshot.effectiveSkillSelection) }),
+            : {
+                effectiveSkillSelection: createEffectiveSkillSelection(snapshot.effectiveSkillSelection),
+            }),
         pendingInteractions: snapshot.pendingInteractions.map((item) => ({ ...item })),
     };
 }

package/dist/server/server/features/sessions/start-session/use-case.js

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { RelaySession } from '../model/relay-session.js';
-import { DEFAULT_SESSION_MODEL, } from '../application/start-settings.js';
+import { DEFAULT_SESSION_MODEL } from '../application/start-settings.js';
 import { applySkillSelectionSnapshot, } from '../../skills/model/skill-profile.js';
 import { SkillProfileError } from '../../skills/model/errors.js';
 export async function startSession(input, deps) {

package/dist/server/server/features/skills/delete-profile/endpoint.js

@@ -12,13 +12,22 @@ export function registerDeleteSkillProfile(app, deps) {
         try {
             const name = normalizeSkillProfileName(request.params.name);
             if (!(await deps.deleteGlobalProfile(name)))
-                return reply.code(404).type('application/problem+json').send(problem('SKILL_PROFILE_NOT_FOUND', 404, 'The skill profile was not found.'));
+                return reply
+                    .code(404)
+                    .type('application/problem+json')
+                    .send(problem('SKILL_PROFILE_NOT_FOUND', 404, 'The skill profile was not found.'));
             return reply.code(204).send();
         }
         catch (error) {
             if (error instanceof SkillProfileError)
-                return reply.code(400).type('application/problem+json').send(problem('INVALID_SKILL_PROFILE', 400, 'The skill profile could not be deleted.'));
-            return reply.code(500).type('application/problem+json').send(problem('SKILL_PROFILE_PERSISTENCE_FAILED', 500, 'The skill profile could not be deleted.', true));
+                return reply
+                    .code(400)
+                    .type('application/problem+json')
+                    .send(problem('INVALID_SKILL_PROFILE', 400, 'The skill profile could not be deleted.'));
+            return reply
+                .code(500)
+                .type('application/problem+json')
+                .send(problem('SKILL_PROFILE_PERSISTENCE_FAILED', 500, 'The skill profile could not be deleted.', true));
         }
     });
 }

package/dist/server/server/features/skills/list-available/endpoint.js

@@ -7,13 +7,22 @@ import { z } from 'zod';
 import { applySkillSelectionSnapshot } from '../model/skill-profile.js';
 import { SkillProfileError } from '../model/errors.js';
 import { problem } from '../../../platform/http/problem.js';
-const querySchema = z.object({ workspaceId: z.string().min(1), profile: z.string().min(1), refresh: z.enum(['true']).optional() }).strict();
+const querySchema = z
+    .object({
+    workspaceId: z.string().min(1),
+    profile: z.string().min(1),
+    refresh: z.enum(['true']).optional(),
+})
+    .strict();
 /** Register the workspace-scoped skill discovery REPR slice. */
 export function registerListAvailableSkills(app, deps) {
     app.get('/api/skills', async (request, reply) => {
         const parsed = querySchema.safeParse(request.query);
         if (!parsed.success)
-            return reply.code(400).type('application/problem+json').send(problem('INVALID_SKILL_REQUEST', 400, 'workspaceId and profile are required.'));
+            return reply
+                .code(400)
+                .type('application/problem+json')
+                .send(problem('INVALID_SKILL_REQUEST', 400, 'workspaceId and profile are required.'));
         try {
             const [workspace, profile] = await Promise.all([
                 deps.workspaces.resolve(parsed.data.workspaceId),
@@ -52,10 +61,19 @@ export function registerListAvailableSkills(app, deps) {
             };
         }
         catch (error) {
-            if (error instanceof Error && (error.message === 'WORKSPACE_NOT_FOUND' || error.message === 'PROFILE_NOT_FOUND'))
-                return reply.code(404).type('application/problem+json').send(problem(error.message, 404, 'The requested catalog entry was not found.'));
-            const code = error instanceof SkillProfileError && error.code === 'INVALID_SKILL_PROFILE' ? 'INVALID_SKILL_PROFILE' : 'SKILL_DISCOVERY_FAILED';
-            return reply.code(502).type('application/problem+json').send(problem(code, 502, 'Skill discovery could not be completed.', true));
+            if (error instanceof Error &&
+                (error.message === 'WORKSPACE_NOT_FOUND' || error.message === 'PROFILE_NOT_FOUND'))
+                return reply
+                    .code(404)
+                    .type('application/problem+json')
+                    .send(problem(error.message, 404, 'The requested catalog entry was not found.'));
+            const code = error instanceof SkillProfileError && error.code === 'INVALID_SKILL_PROFILE'
+                ? 'INVALID_SKILL_PROFILE'
+                : 'SKILL_DISCOVERY_FAILED';
+            return reply
+                .code(502)
+                .type('application/problem+json')
+                .send(problem(code, 502, 'Skill discovery could not be completed.', true));
         }
     });
 }

package/dist/server/server/features/skills/list-profiles/endpoint.js

@@ -8,21 +8,45 @@ export function registerListSkillProfiles(app, deps) {
     app.get('/api/skill-profiles', async (_request, reply) => {
         try {
             const names = await deps.listGlobalProfileNames();
-            const profiles = await Promise.all(names.sort((a, b) => a.localeCompare(b)).map(async (name) => {
+            const profiles = await Promise.all(names
+                .sort((a, b) => a.localeCompare(b))
+                .map(async (name) => {
                 try {
                     const profile = await deps.readGlobalProfile(name);
                     return profile
-                        ? { name: profile.name, version: profile.version, path: deps.profilePath(name), skills: profile.skills }
-                        : { name, path: deps.profilePath(name), error: { code: 'INVALID_SKILL_PROFILE', message: 'Profile disappeared while reading.' } };
+                        ? {
+                            name: profile.name,
+                            version: profile.version,
+                            path: deps.profilePath(name),
+                            skills: profile.skills,
+                        }
+                        : {
+                            name,
+                            path: deps.profilePath(name),
+                            error: {
+                                code: 'INVALID_SKILL_PROFILE',
+                                message: 'Profile disappeared while reading.',
+                            },
+                        };
                 }
                 catch (error) {
-                    return { name, path: deps.profilePath(name), error: { code: 'INVALID_SKILL_PROFILE', message: error instanceof Error ? error.message : 'Invalid profile.' } };
+                    return {
+                        name,
+                        path: deps.profilePath(name),
+                        error: {
+                            code: 'INVALID_SKILL_PROFILE',
+                            message: error instanceof Error ? error.message : 'Invalid profile.',
+                        },
+                    };
                 }
             }));
             return { profiles };
         }
         catch {
-            return reply.code(500).type('application/problem+json').send(problem('SKILL_PROFILE_PERSISTENCE_FAILED', 500, 'Skill profiles could not be read.', true));
+            return reply
+                .code(500)
+                .type('application/problem+json')
+                .send(problem('SKILL_PROFILE_PERSISTENCE_FAILED', 500, 'Skill profiles could not be read.', true));
         }
     });
 }

package/dist/server/server/features/skills/model/skill-profile.js

@@ -37,7 +37,20 @@ export const availableSkillSchema = z
         defaultPrompt: z.string().optional(),
     })
         .optional(),
-    dependencies: z.object({ tools: z.array(z.object({ type: z.string(), value: z.string(), description: z.string().optional(), transport: z.string().optional(), command: z.string().optional(), url: z.string().optional() })).optional() }).optional(),
+    dependencies: z
+        .object({
+        tools: z
+            .array(z.object({
+            type: z.string(),
+            value: z.string(),
+            description: z.string().optional(),
+            transport: z.string().optional(),
+            command: z.string().optional(),
+            url: z.string().optional(),
+        }))
+            .optional(),
+    })
+        .optional(),
     scope: z.string().optional(),
 })
     .strict();
@@ -53,7 +66,10 @@ const profileDocumentSchema = z
  * is deliberately narrow so a profile name can never become a path traversal.
  */
 export function normalizeSkillProfileName(value) {
-    const normalized = value.trim().toLowerCase().replace(/[\s_]+/g, '-');
+    const normalized = value
+        .trim()
+        .toLowerCase()
+        .replace(/[\s_]+/g, '-');
     if (!profileNamePattern.test(normalized)) {
         throw new SkillProfileError('INVALID_SKILL_PROFILE', 'Invalid skill profile name.');
     }
@@ -136,7 +152,11 @@ export function compileSkillOverride(input) {
 }
 /** Construct the single profile contract shared by global and project YAML files. */
 export function createSkillProfile(input) {
-    return { version: 1, name: normalizeSkillProfileName(input.name), skills: createSkillSelection(input.skills) };
+    return {
+        version: 1,
+        name: normalizeSkillProfileName(input.name),
+        skills: createSkillSelection(input.skills),
+    };
 }
 /** Parse the version-1 YAML document without performing filesystem access. */
 export function parseSkillProfileYaml(source) {

package/dist/server/server/platform/auth/simple-webauthn-adapter.js

@@ -19,7 +19,11 @@ export class SimpleWebAuthnAdapter {
             challenge: new Uint8Array(input.challenge),
             attestationType: 'none',
             excludeCredentials: input.excludeCredentialIds.map((id) => ({ id })),
-            authenticatorSelection: { residentKey: 'required', requireResidentKey: true, userVerification: 'required' },
+            authenticatorSelection: {
+                residentKey: 'required',
+                requireResidentKey: true,
+                userVerification: 'required',
+            },
             supportedAlgorithmIDs: [-7, -257],
         });
     }
@@ -63,13 +67,29 @@ export class SimpleWebAuthnAdapter {
         const value = input;
         let result;
         try {
-            result = await verifyAuthenticationResponse({ response: value.response, expectedChallenge: Buffer.from(value.challenge).toString('base64url'), expectedOrigin: value.expectedOrigin, expectedRPID: value.rpId, requireUserVerification: true, credential: { id: value.credential.id, publicKey: new Uint8Array(value.credential.publicKey), counter: value.credential.counter, transports: [...value.credential.transports] } });
+            result = await verifyAuthenticationResponse({
+                response: value.response,
+                expectedChallenge: Buffer.from(value.challenge).toString('base64url'),
+                expectedOrigin: value.expectedOrigin,
+                expectedRPID: value.rpId,
+                requireUserVerification: true,
+                credential: {
+                    id: value.credential.id,
+                    publicKey: new Uint8Array(value.credential.publicKey),
+                    counter: value.credential.counter,
+                    transports: [...value.credential.transports],
+                },
+            });
         }
         catch {
             throw new PasskeyVerificationError('PASSKEY_VERIFICATION_FAILED');
         }
         if (!result.verified || !result.authenticationInfo?.userVerified)
             throw new PasskeyVerificationError('PASSKEY_VERIFICATION_FAILED');
-        return { credentialId: webAuthnCredentialId(value.response.id), counter: result.authenticationInfo.newCounter, userVerified: result.authenticationInfo.userVerified };
+        return {
+            credentialId: webAuthnCredentialId(value.response.id),
+            counter: result.authenticationInfo.newCounter,
+            userVerified: result.authenticationInfo.userVerified,
+        };
     }
 }

package/dist/server/server/platform/catalog/profile-command.js

@@ -18,5 +18,12 @@ export function profileAppServerCommand(_profile, availability = localAvailabili
         : { command: 'codex', args: ['app-server', '--stdio'] };
     return skillsConfig === undefined
         ? base
-        : { ...base, args: [...base.args, '--config', `skills.config = [${skillsConfig.map((entry) => `{ path = ${JSON.stringify(entry.path)}, enabled = ${entry.enabled} }`).join(', ')}]`] };
+        : {
+            ...base,
+            args: [
+                ...base.args,
+                '--config',
+                `skills.config = [${skillsConfig.map((entry) => `{ path = ${JSON.stringify(entry.path)}, enabled = ${entry.enabled} }`).join(', ')}]`,
+            ],
+        };
 }