@pixelbyte-software/pixcode 1.38.0 → 1.38.1

package/server/modules/providers/provider.routes.ts

@@ -670,6 +670,102 @@ const resolveConfigFile = (provider: string, fileId: string): { descriptor: Prov
   return { descriptor, absolutePath };
 };
 
+const SENSITIVE_CONFIG_PATTERN = /(api[_-]?key|token|secret|password|authorization|bearer)\s*[:=]\s*["']?([^"'\n\r]+)/ig;
+
+function redactProviderConfigPreview(contents: string): string {
+  return contents.replace(SENSITIVE_CONFIG_PATTERN, (_match, key) => `${key}: [redacted]`);
+}
+
+async function validateProviderConfigContents(descriptor: ProviderConfigFile, contents: string) {
+  if (Buffer.byteLength(contents, 'utf8') > MAX_CONFIG_FILE_SIZE_BYTES) {
+    throw new AppError(
+      `Config contents exceed ${MAX_CONFIG_FILE_SIZE_BYTES} bytes`,
+      { code: 'PROVIDER_CONFIG_TOO_LARGE', statusCode: 413 },
+    );
+  }
+
+  if (descriptor.format === 'json') {
+    try {
+      JSON.parse(contents || '{}');
+    } catch (err) {
+      throw new AppError(`Invalid JSON: ${(err as Error).message}`, {
+        code: 'PROVIDER_CONFIG_INVALID_JSON',
+        statusCode: 400,
+      });
+    }
+  }
+
+  return {
+    valid: true,
+    format: descriptor.format,
+    readonly: Boolean(descriptor.readonly),
+    preview: redactProviderConfigPreview(contents).slice(0, 4000),
+  };
+}
+
+async function buildProviderPluginState(provider: string) {
+  const files = PROVIDER_CONFIG_FILES[provider] || [];
+  const configs = await Promise.all(files.map(async (entry) => {
+    const absolutePath = path.resolve(os.homedir(), entry.relativePath);
+    let exists = false;
+    let size: number | null = null;
+    let updatedAt: string | null = null;
+    let preview = '';
+    try {
+      const stat = await fs.stat(absolutePath);
+      exists = stat.isFile();
+      size = stat.size;
+      updatedAt = stat.mtime.toISOString();
+      if (exists && stat.size <= MAX_CONFIG_FILE_SIZE_BYTES) {
+        preview = redactProviderConfigPreview(await fs.readFile(absolutePath, 'utf8')).slice(0, 1200);
+      }
+    } catch {
+      // Missing config files are normal for CLIs that have not been used yet.
+    }
+
+    return {
+      id: entry.id,
+      label: entry.label,
+      format: entry.format,
+      readonly: Boolean(entry.readonly),
+      relativePath: entry.relativePath,
+      absolutePath,
+      exists,
+      size,
+      updatedAt,
+      preview,
+      canBackup: exists,
+      canValidate: entry.format === 'json' || entry.format === 'env' || entry.format === 'toml' || entry.format === 'text',
+    };
+  }));
+
+  return {
+    provider,
+    supported: files.length > 0,
+    configCount: files.length,
+    installedCount: configs.filter((config) => config.exists).length,
+    configs,
+  };
+}
+
+router.get(
+  '/plugin-state',
+  asyncHandler(async (_req: Request, res: Response) => {
+    const providers = await Promise.all(
+      Object.keys(PROVIDER_CONFIG_FILES).map((provider) => buildProviderPluginState(provider)),
+    );
+    res.json(createApiSuccessResponse({ providers }));
+  }),
+);
+
+router.get(
+  '/plugin-state/:provider',
+  asyncHandler(async (req: Request, res: Response) => {
+    const provider = parseProvider(req.params.provider);
+    res.json(createApiSuccessResponse(await buildProviderPluginState(provider)));
+  }),
+);
+
 router.get(
   '/:provider/config-files',
   asyncHandler(async (req: Request, res: Response) => {
@@ -826,4 +922,42 @@ router.put(
   }),
 );
 
+router.post(
+  '/:provider/config-files/:fileId/validate',
+  asyncHandler(async (req: Request, res: Response) => {
+    const provider = String(req.params.provider);
+    const fileId = String(req.params.fileId);
+    const { descriptor, absolutePath } = resolveConfigFile(provider, fileId);
+    const contents = typeof req.body?.contents === 'string'
+      ? req.body.contents
+      : await fs.readFile(absolutePath, 'utf8').catch(() => '');
+    res.json(createApiSuccessResponse(await validateProviderConfigContents(descriptor, contents)));
+  }),
+);
+
+router.post(
+  '/:provider/config-files/:fileId/backup',
+  asyncHandler(async (req: Request, res: Response) => {
+    const provider = String(req.params.provider);
+    const fileId = String(req.params.fileId);
+    const { absolutePath } = resolveConfigFile(provider, fileId);
+    const stat = await fs.stat(absolutePath);
+    if (!stat.isFile()) {
+      throw new AppError(`${absolutePath} is not a regular file`, {
+        code: 'PROVIDER_CONFIG_NOT_FILE',
+        statusCode: 409,
+      });
+    }
+    const backupPath = `${absolutePath}.pixcode-backup-${Date.now()}`;
+    await fs.copyFile(absolutePath, backupPath);
+    res.json(createApiSuccessResponse({
+      provider,
+      fileId,
+      absolutePath,
+      backupPath,
+      size: stat.size,
+    }));
+  }),
+);
+
 export default router;

package/server/routes/auth.js

@@ -7,6 +7,10 @@ import bcrypt from 'bcryptjs';
 
 import { userDb, db } from '../database/db.js';
 import { generateToken, authenticateToken } from '../middleware/auth.js';
+import {
+  getPublicRemoteConnectionConfig,
+  saveRemoteConnectionConfig,
+} from '../services/remote-connection.js';
 
 const router = express.Router();
 
@@ -24,6 +28,21 @@ router.get('/status', async (req, res) => {
   }
 });
 
+// First-run connection mode is intentionally public: it is needed before
+// account creation so a fresh desktop install can decide whether it controls
+// this machine or a remote Pixcode server.
+router.get('/connection-mode', (req, res) => {
+  res.json({ success: true, connection: getPublicRemoteConnectionConfig() });
+});
+
+router.put('/connection-mode', (req, res) => {
+  try {
+    res.json({ success: true, connection: saveRemoteConnectionConfig(req.body || {}) });
+  } catch (error) {
+    res.status(400).json({ success: false, error: error.message });
+  }
+});
+
 // User registration (setup) - only allowed if no users exist
 router.post('/register', async (req, res) => {
   try {
@@ -137,4 +156,4 @@ router.post('/logout', authenticateToken, (req, res) => {
   res.json({ success: true, message: 'Logged out successfully' });
 });
 
-export default router;
+export default router;

package/server/routes/diagnostics.js

@@ -4,12 +4,38 @@ import { collectDiagnostics } from '../services/diagnostics.js';
 
 const router = express.Router();
 
-router.get('/', (req, res) => {
-  res.json(collectDiagnostics({
+function buildDiagnostics(req) {
+  return collectDiagnostics({
     installMode: req.app.locals.installMode,
     serverVersion: req.app.locals.serverVersion,
     wss: req.app.locals.wss,
-  }));
+    activeRuns: req.app.locals.activeRuns || [],
+    recentErrors: req.app.locals.recentErrors || [],
+    providerHealth: req.app.locals.providerHealth || {},
+    cache: req.app.locals.diagnosticsCache || {},
+  });
+}
+
+router.get('/', (req, res) => {
+  res.json(buildDiagnostics(req));
+});
+
+router.post('/refresh', (req, res) => {
+  req.app.locals.diagnosticsCache = {
+    ...(req.app.locals.diagnosticsCache || {}),
+    diagnosticsUpdatedAt: new Date().toISOString(),
+    manualRefresh: true,
+  };
+  res.json(buildDiagnostics(req));
+});
+
+router.get('/bundle', (req, res) => {
+  const diagnostics = buildDiagnostics(req);
+  res.json({
+    generatedAt: diagnostics.timestamp,
+    copyable: true,
+    diagnostics,
+  });
 });
 
 export default router;

package/server/routes/public-api.js

@@ -0,0 +1,21 @@
+import express from 'express';
+
+import { buildOpenApiFragment, buildPublicApiManifest } from '../services/public-api-manifest.js';
+
+const router = express.Router();
+
+function requestBaseUrl(req) {
+  const proto = req.headers['x-forwarded-proto'] || req.protocol;
+  const host = req.headers['x-forwarded-host'] || req.headers.host;
+  return host ? `${proto}://${host}` : '';
+}
+
+router.get('/manifest', (req, res) => {
+  res.json(buildPublicApiManifest({ baseUrl: requestBaseUrl(req) }));
+});
+
+router.get('/openapi', (req, res) => {
+  res.json(buildOpenApiFragment({ baseUrl: requestBaseUrl(req) }));
+});
+
+export default router;

package/server/routes/remote.js

@@ -0,0 +1,33 @@
+import express from 'express';
+
+import {
+  checkRemoteConnection,
+  getPublicRemoteConnectionConfig,
+  saveRemoteConnectionConfig,
+} from '../services/remote-connection.js';
+
+const router = express.Router();
+
+router.get('/config', (req, res) => {
+  res.json({ success: true, connection: getPublicRemoteConnectionConfig() });
+});
+
+router.put('/config', (req, res) => {
+  try {
+    const connection = saveRemoteConnectionConfig(req.body || {});
+    res.json({ success: true, connection });
+  } catch (error) {
+    res.status(400).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/check', async (req, res) => {
+  try {
+    const health = await checkRemoteConnection(req.body && Object.keys(req.body).length ? req.body : undefined);
+    res.json({ success: true, health, connection: getPublicRemoteConnectionConfig() });
+  } catch (error) {
+    res.status(400).json({ success: false, error: error.message });
+  }
+});
+
+export default router;

package/server/routes/settings.js

@@ -29,13 +29,13 @@ router.get('/api-keys', async (req, res) => {
 // Create a new API key
 router.post('/api-keys', async (req, res) => {
   try {
-    const { keyName } = req.body;
+    const { keyName, scopes } = req.body;
 
     if (!keyName || !keyName.trim()) {
       return res.status(400).json({ error: 'Key name is required' });
     }
 
-    const result = apiKeysDb.createApiKey(req.user.id, keyName.trim());
+    const result = apiKeysDb.createApiKey(req.user.id, keyName.trim(), scopes);
     res.json({
       success: true,
       apiKey: result
@@ -86,6 +86,29 @@ router.patch('/api-keys/:keyId/toggle', async (req, res) => {
   }
 });
 
+// Update API key scopes
+router.patch('/api-keys/:keyId/scopes', async (req, res) => {
+  try {
+    const { keyId } = req.params;
+    const { scopes } = req.body;
+
+    if (!Array.isArray(scopes)) {
+      return res.status(400).json({ error: 'scopes must be an array' });
+    }
+
+    const success = apiKeysDb.updateApiKeyScopes(req.user.id, parseInt(keyId), scopes);
+
+    if (success) {
+      res.json({ success: true });
+    } else {
+      res.status(404).json({ error: 'API key not found' });
+    }
+  } catch (error) {
+    console.error('Error updating API key scopes:', error);
+    res.status(500).json({ error: 'Failed to update API key scopes' });
+  }
+});
+
 // ===============================
 // Generic Credentials Management
 // ===============================

package/server/routes/taskmaster.js

@@ -161,6 +161,29 @@ function taskMasterExecutionDescription(task) {
     ].filter(Boolean).join('\n\n');
 }
 
+function buildTaskMasterQueueSummary(projectName, projectPath, tasks) {
+    const normalized = tasks.map((task) => ({
+        ...task,
+        queueState: ['done', 'completed', 'cancelled', 'canceled'].includes(String(task.status || '').toLowerCase())
+            ? 'finished'
+            : String(task.status || 'pending') === 'in-progress'
+                ? 'running'
+                : 'queued',
+    }));
+    return {
+        projectName,
+        projectPath,
+        queue: normalized,
+        totals: {
+            all: normalized.length,
+            queued: normalized.filter((task) => task.queueState === 'queued').length,
+            running: normalized.filter((task) => task.queueState === 'running').length,
+            finished: normalized.filter((task) => task.queueState === 'finished').length,
+        },
+        timestamp: new Date().toISOString(),
+    };
+}
+
 // API Routes
 
 /**
@@ -362,6 +385,66 @@ router.get('/tasks/:projectName', async (req, res) => {
     }
 });
 
+/**
+ * GET /api/taskmaster/queue/:projectName
+ * Stable automation endpoint for remote UI, Telegram, and external clients.
+ */
+router.get('/queue/:projectName', async (req, res) => {
+    try {
+        const { projectName } = req.params;
+        const { projectPath, transformedTasks } = await readTaskMasterTasks(projectName);
+        res.json(buildTaskMasterQueueSummary(projectName, projectPath, transformedTasks));
+    } catch (error) {
+        if (error?.code === 'ENOENT') {
+            return res.json(buildTaskMasterQueueSummary(req.params.projectName, null, []));
+        }
+        console.error('TaskMaster queue loading error:', error);
+        res.status(500).json({
+            error: 'Failed to load TaskMaster queue',
+            message: error.message
+        });
+    }
+});
+
+/**
+ * GET /api/taskmaster/task/:projectName/:taskId
+ * Load a single TaskMaster item with queue metadata.
+ */
+router.get('/task/:projectName/:taskId', async (req, res) => {
+    try {
+        const { projectName, taskId } = req.params;
+        const { projectPath, transformedTasks } = await readTaskMasterTasks(projectName);
+        const task = transformedTasks.find((candidate) => String(candidate.id) === String(taskId));
+        if (!task) {
+            return res.status(404).json({
+                success: false,
+                error: 'TaskMaster task not found',
+                message: `Task "${taskId}" was not found in project "${projectName}"`
+            });
+        }
+        res.json({
+            success: true,
+            projectName,
+            projectPath,
+            task,
+            execution: {
+                supportsProvider: true,
+                supportsModel: true,
+                supportsFallbackProvider: true,
+                supportsPermissionMode: true,
+                supportsWorkerSlot: true,
+            },
+        });
+    } catch (error) {
+        console.error('TaskMaster task detail error:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Failed to load TaskMaster task',
+            message: error.message
+        });
+    }
+});
+
 /**
  * POST /api/taskmaster/execute/:projectName/:taskId
  * Import a TaskMaster task into orchestration and dispatch it to a CLI agent.
@@ -376,6 +459,8 @@ router.post('/execute/:projectName/:taskId', async (req, res) => {
                 : '';
         const model = typeof req.body?.model === 'string' ? req.body.model : undefined;
         const permissionMode = typeof req.body?.permissionMode === 'string' ? req.body.permissionMode : undefined;
+        const fallbackProvider = typeof req.body?.fallbackProvider === 'string' ? req.body.fallbackProvider : undefined;
+        const workerSlot = Number.isInteger(req.body?.workerSlot) ? req.body.workerSlot : undefined;
         const isolation = ['host', 'worktree', 'docker'].includes(req.body?.isolation)
             ? req.body.isolation
             : 'worktree';
@@ -403,7 +488,14 @@ router.post('/execute/:projectName/:taskId', async (req, res) => {
             projectId,
             taskmasterId: String(task.id),
             title: `TaskMaster #${task.id}: ${task.title}`,
-            description: taskMasterExecutionDescription(task)
+            description: taskMasterExecutionDescription(task),
+            metadata: {
+                provider: adapterId,
+                model,
+                permissionMode,
+                fallbackProvider,
+                workerSlot,
+            },
         });
 
         const dispatchedTask = await orchestrationTaskService.dispatch(orchestrationTask.id, {
@@ -411,7 +503,9 @@ router.post('/execute/:projectName/:taskId', async (req, res) => {
             isolation,
             projectPath,
             model,
-            permissionMode
+            permissionMode,
+            fallbackProvider,
+            workerSlot,
         });
 
         res.json({
@@ -419,6 +513,13 @@ router.post('/execute/:projectName/:taskId', async (req, res) => {
             projectName,
             projectPath,
             taskmasterTask: task,
+            execution: {
+                provider: adapterId,
+                model,
+                permissionMode,
+                fallbackProvider,
+                workerSlot,
+            },
             task: dispatchedTask
         });
     } catch (error) {

package/server/services/diagnostics.js

@@ -48,6 +48,13 @@ function normalizeMemory(memory) {
   );
 }
 
+function redactText(value) {
+  return String(value || '').replace(
+    /(ghp_[A-Za-z0-9_]+|github_pat_[A-Za-z0-9_]+|npm_[A-Za-z0-9_]+|px_[A-Za-z0-9_]+|ck_[A-Za-z0-9_]+|[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,})/g,
+    '[redacted]',
+  );
+}
+
 function resolveWebSocketClientCount(options) {
   if (Number.isInteger(options.wsClientCount)) {
     return options.wsClientCount;
@@ -55,14 +62,45 @@ function resolveWebSocketClientCount(options) {
   return options.wss?.clients?.size || 0;
 }
 
+function normalizeProviderHealth(input = {}, env = process.env, now = new Date()) {
+  const defaults = {
+    claude: { configured: Boolean(env.ANTHROPIC_API_KEY || env.CLAUDE_API_KEY) },
+    codex: { configured: Boolean(env.OPENAI_API_KEY) },
+    cursor: { configured: false },
+    gemini: { configured: Boolean(env.GEMINI_API_KEY || env.GOOGLE_API_KEY) },
+    qwen: { configured: Boolean(env.DASHSCOPE_API_KEY || env.OPENAI_API_KEY) },
+    opencode: { configured: false },
+  };
+
+  return Object.fromEntries(
+    Object.entries({ ...defaults, ...input }).map(([provider, value]) => {
+      const raw = value && typeof value === 'object' ? value : {};
+      return [
+        provider,
+        redactDiagnostics({
+          status: raw.status || (raw.configured ? 'configured' : 'unknown'),
+          auth: raw.auth || (raw.configured ? 'configured' : 'not_configured'),
+          cli: raw.cli || raw.version || null,
+          checkedAt: raw.checkedAt || now.toISOString(),
+          details: raw.details || null,
+        }),
+      ];
+    }),
+  );
+}
+
 export function collectDiagnostics(options = {}) {
   const now = options.now || new Date();
   const env = options.env || process.env;
   const versions = options.versions || process.versions;
   const memoryUsage = options.memoryUsage || process.memoryUsage;
   const uptime = options.uptime ?? process.uptime();
+  const activeRuns = Array.isArray(options.activeRuns) ? options.activeRuns : [];
+  const recentErrors = Array.isArray(options.recentErrors) ? options.recentErrors : [];
+  const providerHealth = normalizeProviderHealth(options.providerHealth, env, now);
+  const cache = options.cache && typeof options.cache === 'object' ? options.cache : {};
 
-  return {
+  const diagnostics = {
     status: 'ok',
     timestamp: now.toISOString(),
     version: options.serverVersion || '0.0.0',
@@ -84,7 +122,29 @@ export function collectDiagnostics(options = {}) {
       telegramConfigured: Boolean(env.TELEGRAM_BOT_TOKEN),
       webPushConfigured: Boolean(env.VAPID_PUBLIC_KEY && env.VAPID_PRIVATE_KEY),
     },
+    providerHealth,
+    activeRuns: activeRuns.map((run) => redactDiagnostics(run)),
+    recentErrors: recentErrors.map((error) => redactDiagnostics({
+      ...error,
+      message: redactText(error?.message),
+      stack: error?.stack ? redactText(error.stack) : undefined,
+    })),
+    cache: redactDiagnostics({
+      providerHealthUpdatedAt: cache.providerHealthUpdatedAt || null,
+      diagnosticsUpdatedAt: now.toISOString(),
+    }),
+    manualRefresh: {
+      available: true,
+      endpoint: '/api/diagnostics/refresh',
+    },
+    bundle: {
+      copyable: true,
+      endpoint: '/api/diagnostics/bundle',
+      includes: ['runtime', 'websocket', 'notifications', 'providerHealth', 'activeRuns', 'recentErrors'],
+    },
   };
+
+  return redactDiagnostics(diagnostics);
 }
 
 export function redactDiagnostics(input) {

package/server/services/public-api-manifest.js

@@ -0,0 +1,87 @@
+const API_GROUPS = [
+  { id: 'auth', title: 'Authentication', basePath: '/api/auth', scopes: ['auth:read', 'auth:write'] },
+  { id: 'projects', title: 'Projects', basePath: '/api/projects', scopes: ['projects:read', 'projects:write'] },
+  { id: 'sessions', title: 'Sessions and messages', basePath: '/api/sessions', scopes: ['sessions:read', 'sessions:write'] },
+  { id: 'providers', title: 'CLI providers', basePath: '/api/providers', scopes: ['providers:read', 'providers:write'] },
+  { id: 'orchestration', title: 'Orchestration runs', basePath: '/api/orchestration', scopes: ['orchestration:read', 'orchestration:write'] },
+  { id: 'taskmaster', title: 'Taskmaster queue', basePath: '/api/taskmaster', scopes: ['taskmaster:read', 'taskmaster:write'] },
+  { id: 'notifications', title: 'Notifications', basePath: '/api/settings/notifications', scopes: ['notifications:read', 'notifications:write'] },
+  { id: 'files', title: 'Files', basePath: '/api/projects/:projectName/files', scopes: ['files:read', 'files:write'] },
+  { id: 'git', title: 'Source control', basePath: '/api/git', scopes: ['git:read', 'git:write'] },
+  { id: 'settings', title: 'Settings and API keys', basePath: '/api/settings', scopes: ['settings:read', 'settings:write'] },
+  { id: 'updates', title: 'Update status', basePath: '/api/update', scopes: ['updates:read', 'updates:write'] },
+  { id: 'diagnostics', title: 'Diagnostics', basePath: '/api/diagnostics', scopes: ['diagnostics:read'] },
+  { id: 'remote', title: 'Remote connection', basePath: '/api/remote', scopes: ['remote:read', 'remote:write'] },
+  { id: 'telegram', title: 'Telegram control', basePath: '/api/telegram', scopes: ['telegram:read', 'telegram:write'] },
+  { id: 'plugins', title: 'Plugins and MCP tools', basePath: '/api/plugins', scopes: ['plugins:read', 'plugins:write'] },
+];
+
+const API_SCOPES = Array.from(new Set(API_GROUPS.flatMap((group) => group.scopes))).sort();
+
+export function buildPublicApiManifest({ baseUrl = '' } = {}) {
+  const origin = String(baseUrl || '').replace(/\/+$/, '');
+  return {
+    name: 'Pixcode Public API',
+    version: '1.38',
+    baseUrl: origin || null,
+    auth: {
+      transports: ['Authorization: Bearer <px_api_key>', 'X-API-Key: <px_api_key>', '?apiKey=<px_api_key>'],
+      websocket: 'Pass the same px_ API key as the token query parameter.',
+    },
+    apiKey: {
+      prefix: 'px_',
+      scopes: API_SCOPES,
+      revocable: true,
+      manageableAt: '/api/settings/api-keys',
+    },
+    groups: API_GROUPS,
+    examples: [
+      {
+        title: 'List projects',
+        curl: `curl -H "X-API-Key: px_your_key" ${origin || 'http://127.0.0.1:3001'}/api/projects`,
+      },
+      {
+        title: 'Start a Taskmaster task with a model',
+        curl: `curl -X POST -H "Content-Type: application/json" -H "X-API-Key: px_your_key" -d '{"provider":"opencode","model":"minimax/minimax-m2"}' ${origin || 'http://127.0.0.1:3001'}/api/taskmaster/execute/my-project/1`,
+      },
+      {
+        title: 'Fetch diagnostics bundle',
+        curl: `curl -H "X-API-Key: px_your_key" ${origin || 'http://127.0.0.1:3001'}/api/diagnostics/bundle`,
+      },
+    ],
+  };
+}
+
+export function buildOpenApiFragment(options = {}) {
+  const manifest = buildPublicApiManifest(options);
+  return {
+    openapi: '3.1.0',
+    info: {
+      title: manifest.name,
+      version: manifest.version,
+    },
+    security: [{ PixcodeApiKey: [] }],
+    components: {
+      securitySchemes: {
+        PixcodeApiKey: {
+          type: 'apiKey',
+          in: 'header',
+          name: 'X-API-Key',
+          description: 'Pixcode px_ API key. Keys are revocable and can carry scopes.',
+        },
+      },
+    },
+    paths: Object.fromEntries(
+      manifest.groups.map((group) => [
+        group.basePath,
+        {
+          get: {
+            summary: group.title,
+            'x-pixcode-group': group.id,
+            'x-pixcode-scopes': group.scopes,
+          },
+        },
+      ]),
+    ),
+  };
+}