tinywebui 0.1.4 → 0.1.5

package/src/access/policy.js

@@ -1,198 +1,185 @@
 import { createHash } from 'node:crypto';
 import { FEATURE } from '../../public/shared/features.js';
-
-/**
- * Access policy: who can use which parts of TinyWebUI, declared in files.
- *
- * The `access` block lives in tinywebui.config.js and/or config.json:
- *
- *   access: {
- *     bootstrapAdmins: ['<gateway user id>'],   // always admin, always approved
- *     newUsers: 'approved' | 'pending',
- *     roles: { user: { features: [...], models: [...] | '*' }, admin: { features: '*' } },
- *     users: { '<gateway user id>': { role?, status? } }  // admin decisions, written back
- *   }
- *
- * Everything here is pure: no I/O, so the server, the reload path and the CLI
- * all validate and resolve the same way.
- */
-
-/** Every feature a role can be granted. Each maps to UI and API routes. */
 export const FEATURES = Object.values(FEATURE);
-
 /** What a signed-in user may personalise (access.customize). Model choice is the model-picker feature's. */
 export const CUSTOMIZABLE = ['theme', 'instructions'];
-
 export const ROLES = ['admin', 'user'];
 export const STATUSES = ['pending', 'approved', 'disabled'];
-
 // Tier 3's out-of-the-box split: users work, admins run the place.
 const DEFAULT_ROLES = {
-  user: { features: [FEATURE.CHAT, FEATURE.ATTACHMENTS, FEATURE.IMAGES, FEATURE.SEARCH, FEATURE.FOLDERS, FEATURE.AUTOMATIONS, FEATURE.STATISTICS, FEATURE.MODEL_PICKER], models: '*' },
-  admin: { features: '*', models: '*' }
+    user: { features: [FEATURE.CHAT, FEATURE.ATTACHMENTS, FEATURE.IMAGES, FEATURE.SEARCH, FEATURE.FOLDERS, FEATURE.AUTOMATIONS, FEATURE.STATISTICS, FEATURE.MODEL_PICKER], models: '*' },
+    admin: { features: '*', models: '*' }
 };
-
 /**
  * Keys that can never be written through the UI or API, whatever the lock
  * state: the trust boundary, credentials, and the policy itself. They can
- * still be set in either file (so `set-password` can write config.json).
+ * still be set in either file.
  */
 export const FILE_ONLY = new Set([
-  'authMode', 'authPassword', 'sessionSecret', 'sessionTtlDays', 'trustedProxyCidrs', 'trustedUserIdHeader',
-  'trustedEmailHeader', 'trustedNameHeader', 'trustedRoleHeader',
-  'logoutUrl', 'dbPath', 'access', 'allowedOrigins', 'allowedHosts', 'frozen', 'autoMigrate', 'retrieval',
-  'googleClientId', 'googleClientSecret', 'googleRedirectUri', 'adminEmails'
+    'authMode', 'authPassword', 'sessionSecret', 'sessionTtlDays', 'trustedProxyCidrs', 'trustedUserIdHeader',
+    'trustedEmailHeader', 'trustedNameHeader', 'trustedRoleHeader',
+    'logoutUrl', 'dbPath', 'access', 'allowedOrigins', 'allowedHosts', 'frozen', 'autoMigrate', 'retrieval',
+    'googleClientId', 'googleClientSecret', 'googleRedirectUri', 'adminEmails'
 ]);
-
 /**
  * Writable, but where credentials and routing live: in a multi-user
  * deployment only an admin may send these, whatever features a role has.
  */
 export const SECRET_PATCH_KEYS = new Set(['baseUrl', 'apiKey', 'models', 'connectors']);
-
 // Never logged, never fingerprinted as values, never sent to a browser.
 export const SECRET_KEYS = new Set(['apiKey', 'authPassword', 'sessionSecret', 'googleClientSecret']);
-
 /**
  * Merges the file's and the code's `access` blocks. Code wins per field;
  * `users` merges per user, code winning, so admin write-back to the file can
  * never override a user pinned in code.
  */
 export function mergeAccess(fileAccess = {}, codeAccess = {}) {
-  const f = fileAccess && typeof fileAccess === 'object' ? fileAccess : {};
-  const c = codeAccess && typeof codeAccess === 'object' ? codeAccess : {};
-  return {
-    ...f, ...c,
-    users: { ...(f.users || {}), ...(c.users || {}) }
-  };
+    const f = fileAccess && typeof fileAccess === 'object' ? fileAccess : {};
+    const c = codeAccess && typeof codeAccess === 'object' ? codeAccess : {};
+    return {
+        ...f, ...c,
+        users: { ...(f.users || {}), ...(c.users || {}) }
+    };
 }
-
 /** The effective policy, with defaults filled in, for a loaded config. */
 export function resolveAccess(cfg) {
-  const a = cfg.access || {};
-  const roles = {};
-  for (const r of ROLES) roles[r] = { ...DEFAULT_ROLES[r], ...(a.roles?.[r] || {}) };
-  return {
-    bootstrapAdmins: Array.isArray(a.bootstrapAdmins) ? a.bootstrapAdmins.map(String) : [],
-    newUsers: a.newUsers || 'approved',
-    customize: Array.isArray(a.customize) ? a.customize : ['theme'],
-    roles,
-    users: a.users && typeof a.users === 'object' ? a.users : {}
-  };
+    const a = cfg.access || {};
+    const roles = {};
+    for (const r of ROLES)
+        roles[r] = { ...DEFAULT_ROLES[r], ...(a.roles?.[r] || {}) };
+    return {
+        bootstrapAdmins: Array.isArray(a.bootstrapAdmins) ? a.bootstrapAdmins.map(String) : [],
+        newUsers: a.newUsers || 'approved',
+        customize: Array.isArray(a.customize) ? a.customize : ['theme'],
+        roles,
+        users: a.users && typeof a.users === 'object' ? a.users : {}
+    };
 }
-
 const expand = (list) => new Set(list === '*' ? FEATURES : list || []);
-
 /**
  * What a signed-in person may use. Tiers 1 and 2 are one person, who gets
  * everything that makes sense for one person: no user management.
  */
 export function featuresFor(cfg, role) {
-  if (cfg.authMode !== 'trusted-header') {
-    const all = new Set(FEATURES);
-    all.delete('admin'); all.delete('oversight');
-    return all;
-  }
-  return expand(resolveAccess(cfg).roles[role]?.features);
+    if (!['multiuser', 'trusted-header'].includes(cfg.authMode)) {
+        const all = new Set(FEATURES);
+        all.delete('admin');
+        all.delete('oversight');
+        return all;
+    }
+    return expand(role ? resolveAccess(cfg).roles[role]?.features : undefined);
 }
-
 /** '*' or the list of model ids this role may pick. */
 export function modelsFor(cfg, role) {
-  if (cfg.authMode !== 'trusted-header') return '*';
-  const m = resolveAccess(cfg).roles[role]?.models;
-  return m === '*' || m === undefined ? '*' : m.map(String);
+    if (!['multiuser', 'trusted-header'].includes(cfg.authMode))
+        return '*';
+    const m = role ? resolveAccess(cfg).roles[role]?.models : undefined;
+    return m === '*' || m === undefined ? '*' : m.map(String);
 }
-
-export const MIN_PASSWORD_LENGTH = 15;
-
+export const MIN_PASSWORD_LENGTH = 10;
 /** Every problem with a config, as readable strings. Empty means valid. */
+// Takes the config as read, before anything about it is known to hold.
 export function validateConfig(cfg, { env = process.env } = {}) {
-  const errors = [];
-  const mode = cfg.authMode;
-  if (mode === 'multiuser') {
-    errors.push("authMode 'multiuser' has no login flow yet; use 'trusted-header' behind a gateway for Google/Apple/SSO sign-in");
-  }
-  if (mode === 'trusted-header' && !(Array.isArray(cfg.trustedProxyCidrs) && cfg.trustedProxyCidrs.length)) {
-    errors.push("authMode 'trusted-header' requires trustedProxyCidrs: identity headers are only believed from those peers");
-  }
-  if (mode === 'single') {
-    if (cfg.authPassword && !/^scrypt\$[0-9a-f]{32}\$[0-9a-f]{64}$/i.test(String(cfg.authPassword))) {
-      errors.push('authPassword must be a hash: run `tinywebui set-password` or set $TINYWEBUI_PASSWORD');
-    } else if (!cfg.authPassword && env.TINYWEBUI_PASSWORD && env.TINYWEBUI_PASSWORD.length < MIN_PASSWORD_LENGTH) {
-      errors.push(`TINYWEBUI_PASSWORD needs at least ${MIN_PASSWORD_LENGTH} characters`);
-    }
-  }
-
-  const a = cfg.access;
-  if (a !== undefined) {
-    if (!a || typeof a !== 'object' || Array.isArray(a)) return [...errors, 'access must be an object'];
-    const known = new Set(['bootstrapAdmins', 'newUsers', 'roles', 'users', 'customize']);
-    for (const k of Object.keys(a)) if (!known.has(k)) errors.push(`access.${k} is not a known setting`);
-    if (a.bootstrapAdmins !== undefined && !(Array.isArray(a.bootstrapAdmins) && a.bootstrapAdmins.every((x) => typeof x === 'string' && x))) {
-      errors.push('access.bootstrapAdmins must be a list of gateway user ids');
+    const errors = [];
+    const mode = cfg.authMode;
+    if (mode === 'trusted-header' && !(Array.isArray(cfg.trustedProxyCidrs) && cfg.trustedProxyCidrs.length)) {
+        errors.push("authMode 'trusted-header' requires trustedProxyCidrs: identity headers are only believed from those peers");
     }
-    if (a.newUsers !== undefined && !['approved', 'pending'].includes(a.newUsers)) {
-      errors.push("access.newUsers must be 'approved' or 'pending'");
-    }
-    if (a.customize !== undefined && !(Array.isArray(a.customize) && a.customize.every((c) => CUSTOMIZABLE.includes(c)))) {
-      errors.push(`access.customize must be a list from ${CUSTOMIZABLE.join(', ')}`);
-    }
-    for (const [role, spec] of Object.entries(a.roles || {})) {
-      if (!ROLES.includes(role)) { errors.push(`access.roles.${role}: unknown role (known: ${ROLES.join(', ')})`); continue; }
-      if (!spec || typeof spec !== 'object') { errors.push(`access.roles.${role} must be an object`); continue; }
-      for (const k of Object.keys(spec)) {
-        if (!['features', 'models'].includes(k)) errors.push(`access.roles.${role}.${k} is not a known setting`);
-      }
-      if (spec.features !== undefined && spec.features !== '*') {
-        if (!Array.isArray(spec.features)) errors.push(`access.roles.${role}.features must be '*' or a list`);
-        else for (const f of spec.features) {
-          if (!FEATURES.includes(f)) errors.push(`access.roles.${role}.features: unknown feature "${f}" (known: ${FEATURES.join(', ')})`);
+    if (mode === 'single')
+        errors.push("legacy authMode 'single' is no longer supported; choose multiuser for accounts or explicitly choose local without login");
+    if (mode === 'local' && cfg.authPassword)
+        errors.push("authMode 'local' cannot use authPassword; remove it only if you want access without login");
+    if (env.TINYWEBUI_PASSWORD)
+        errors.push('TINYWEBUI_PASSWORD no longer selects password login; unset it and use multiuser setup');
+    const a = cfg.access;
+    if (a !== undefined) {
+        if (!a || typeof a !== 'object' || Array.isArray(a))
+            return [...errors, 'access must be an object'];
+        const known = new Set(['bootstrapAdmins', 'newUsers', 'roles', 'users', 'customize']);
+        for (const k of Object.keys(a))
+            if (!known.has(k))
+                errors.push(`access.${k} is not a known setting`);
+        if (a.bootstrapAdmins !== undefined && !(Array.isArray(a.bootstrapAdmins) && a.bootstrapAdmins.every((x) => typeof x === 'string' && x))) {
+            errors.push('access.bootstrapAdmins must be a list of gateway user ids');
+        }
+        if (a.newUsers !== undefined && !['approved', 'pending'].includes(a.newUsers)) {
+            errors.push("access.newUsers must be 'approved' or 'pending'");
+        }
+        if (a.customize !== undefined && !(Array.isArray(a.customize) && a.customize.every((c) => CUSTOMIZABLE.includes(c)))) {
+            errors.push(`access.customize must be a list from ${CUSTOMIZABLE.join(', ')}`);
+        }
+        for (const [role, spec] of Object.entries(a.roles || {})) {
+            if (!ROLES.includes(role)) {
+                errors.push(`access.roles.${role}: unknown role (known: ${ROLES.join(', ')})`);
+                continue;
+            }
+            if (!spec || typeof spec !== 'object') {
+                errors.push(`access.roles.${role} must be an object`);
+                continue;
+            }
+            for (const k of Object.keys(spec)) {
+                if (!['features', 'models'].includes(k))
+                    errors.push(`access.roles.${role}.${k} is not a known setting`);
+            }
+            if (spec.features !== undefined && spec.features !== '*') {
+                if (!Array.isArray(spec.features))
+                    errors.push(`access.roles.${role}.features must be '*' or a list`);
+                else
+                    for (const f of spec.features) {
+                        if (!FEATURES.includes(f))
+                            errors.push(`access.roles.${role}.features: unknown feature "${f}" (known: ${FEATURES.join(', ')})`);
+                    }
+            }
+            if (spec.models !== undefined && spec.models !== '*' && !(Array.isArray(spec.models) && spec.models.every((m) => typeof m === 'string' && m))) {
+                errors.push(`access.roles.${role}.models must be '*' or a list of model ids (catalog ids when models is set)`);
+            }
+        }
+        for (const [id, u] of Object.entries(a.users || {})) {
+            if (!u || typeof u !== 'object') {
+                errors.push(`access.users["${id}"] must be an object`);
+                continue;
+            }
+            if (u.role !== undefined && !ROLES.includes(u.role))
+                errors.push(`access.users["${id}"].role must be one of ${ROLES.join(', ')}`);
+            if (u.status !== undefined && !STATUSES.includes(u.status))
+                errors.push(`access.users["${id}"].status must be one of ${STATUSES.join(', ')}`);
         }
-      }
-      if (spec.models !== undefined && spec.models !== '*' && !(Array.isArray(spec.models) && spec.models.every((m) => typeof m === 'string' && m))) {
-        errors.push(`access.roles.${role}.models must be '*' or a list of model ids (catalog ids when models is set)`);
-      }
-    }
-    for (const [id, u] of Object.entries(a.users || {})) {
-      if (!u || typeof u !== 'object') { errors.push(`access.users["${id}"] must be an object`); continue; }
-      if (u.role !== undefined && !ROLES.includes(u.role)) errors.push(`access.users["${id}"].role must be one of ${ROLES.join(', ')}`);
-      if (u.status !== undefined && !STATUSES.includes(u.status)) errors.push(`access.users["${id}"].status must be one of ${STATUSES.join(', ')}`);
     }
-  }
-  return errors;
+    return errors;
 }
-
 /** Stable JSON: object keys sorted, so key order never changes a hash. */
 function canonical(value) {
-  if (Array.isArray(value)) return `[${value.map(canonical).join(',')}]`;
-  if (value && typeof value === 'object') {
-    return `{${Object.keys(value).sort().map((k) => `${JSON.stringify(k)}:${canonical(value[k])}`).join(',')}}`;
-  }
-  return JSON.stringify(value ?? null);
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(',')}]`;
+    if (value && typeof value === 'object') {
+        return `{${Object.keys(value).sort().map((k) => `${JSON.stringify(k)}:${canonical(value[k])}`).join(',')}}`;
+    }
+    return JSON.stringify(value ?? null);
 }
-
 /**
  * A short hash of the effective config and MCP servers. Secrets count only
  * as present/absent (their values never enter the hash), so a fingerprint can
  * be logged and compared against a checked-in config without leaking anything.
  */
 export function fingerprint(cfg, mcpServers = {}) {
-  const redacted = {};
-  for (const [k, v] of Object.entries(cfg)) {
-    // The session secret is operational (it is generated on first start),
-    // not policy; leaving it out keeps the CLI and the server in agreement.
-    if (k === 'sessionSecret') continue;
-    redacted[k] = SECRET_KEYS.has(k) ? Boolean(v) : v;
-  }
-  if (Array.isArray(redacted.connectors)) {
-    redacted.connectors = redacted.connectors.map((c) => (c && typeof c === 'object' ? { ...c, apiKey: Boolean(c.apiKey) } : c));
-  }
-  return createHash('sha256').update(canonical({ config: redacted, mcpServers })).digest('hex').slice(0, 16);
+    const redacted = {};
+    for (const [k, v] of Object.entries(cfg)) {
+        // The session secret is operational (it is generated on first start),
+        // not policy; leaving it out keeps the CLI and the server in agreement.
+        if (k === 'sessionSecret')
+            continue;
+        redacted[k] = SECRET_KEYS.has(k) ? Boolean(v) : v;
+    }
+    if (Array.isArray(redacted.connectors)) {
+        redacted.connectors = redacted.connectors.map((c) => (c && typeof c === 'object' ? { ...c, apiKey: Boolean(c.apiKey) } : c));
+    }
+    return createHash('sha256').update(canonical({ config: redacted, mcpServers })).digest('hex').slice(0, 16);
 }
-
 /** 'file-only' | 'frozen' | 'editable' -- how a key may be changed. */
 export function keyClass(key, lockedKeys) {
-  if (FILE_ONLY.has(key)) return 'file-only';
-  if (lockedKeys.has(key)) return 'frozen';
-  return 'editable';
+    if (FILE_ONLY.has(key))
+        return 'file-only';
+    if (lockedKeys.has(key))
+        return 'frozen';
+    return 'editable';
 }

package/src/audit.js

@@ -3,5 +3,5 @@
  * log collector. Never pass content, prompts, tokens or raw header values.
  */
 export function audit(event, fields = {}) {
-  console.log(`[tinywebui:audit] ${JSON.stringify({ ts: new Date().toISOString(), event, ...fields })}`);
+    console.log(`[tinywebui:audit] ${JSON.stringify({ ts: new Date().toISOString(), event, ...fields })}`);
 }

package/src/automations/automation.js

@@ -1,136 +1,148 @@
 import { CronExpressionParser } from 'cron-parser';
-
 export function validateSchedule(cron, timezone, now = Date.now()) {
-  const tz = String(timezone || '').trim();
-  if (!tz) throw new Error('timezone is required');
-  try { new Intl.DateTimeFormat('en-US', { timeZone: tz }); }
-  catch { throw new Error(`invalid IANA timezone: ${tz}`); }
-  let nextRunAt;
-  try {
-    nextRunAt = CronExpressionParser.parse(String(cron || ''), {
-      currentDate: new Date(now), tz
-    }).next().getTime();
-  } catch (err) {
-    throw new Error(`invalid cron schedule: ${err.message}`);
-  }
-  return { cron: String(cron).trim(), timezone: tz, nextRunAt };
+    const tz = String(timezone || '').trim();
+    if (!tz)
+        throw new Error('timezone is required');
+    try {
+        new Intl.DateTimeFormat('en-US', { timeZone: tz });
+    }
+    catch {
+        throw new Error(`invalid IANA timezone: ${tz}`);
+    }
+    let nextRunAt;
+    try {
+        nextRunAt = CronExpressionParser.parse(String(cron || ''), {
+            currentDate: new Date(now), tz
+        }).next().getTime();
+    }
+    catch (err) {
+        throw new Error(`invalid cron schedule: ${err.message}`);
+    }
+    return { cron: String(cron).trim(), timezone: tz, nextRunAt };
 }
-
 function cleanFields(input, { requireAll = false } = {}) {
-  const fields = {};
-  for (const key of ['name', 'prompt']) {
-    if (input[key] === undefined && !requireAll) continue;
-    const val = String(input[key] ?? '').trim();
-    if (!val) throw new Error(`${key} is required`);
-    if (val.length > (key === 'prompt' ? 12000 : 120)) throw new Error(`${key} is too long`);
-    fields[key] = val;
-  }
-  if (requireAll || (input.cron !== undefined && input.timezone !== undefined)) {
-    const cron = input.cron ?? '';
-    const timezone = input.timezone ?? '';
-    Object.assign(fields, validateSchedule(cron, timezone));
-  }
-  if (input.enabled !== undefined) fields.enabled = Boolean(input.enabled);
-  return fields;
+    const fields = {};
+    for (const key of ['name', 'prompt']) {
+        if (input[key] === undefined && !requireAll)
+            continue;
+        const val = String(input[key] ?? '').trim();
+        if (!val)
+            throw new Error(`${key} is required`);
+        if (val.length > (key === 'prompt' ? 12000 : 120))
+            throw new Error(`${key} is too long`);
+        fields[key] = val;
+    }
+    if (requireAll || (input.cron !== undefined && input.timezone !== undefined)) {
+        const cron = input.cron ?? '';
+        const timezone = input.timezone ?? '';
+        Object.assign(fields, validateSchedule(cron, timezone));
+    }
+    if (input.enabled !== undefined)
+        fields.enabled = Boolean(input.enabled);
+    return fields;
 }
-
 export function automationToolDef() {
-  return {
-    type: 'function',
-    function: {
-      name: 'manage_automation',
-      description: [
-        'Manage scheduled automations: a prompt that runs on its own, on a cron schedule, in this chat.',
-        'Use it when the user wants something done repeatedly or later without them ("every morning',
-        'summarise...", "check X each Friday"). For steps of the current request use manage_tasks instead.',
-        '',
-        'Each run starts fresh: it sees only its own prompt and the previous run\'s result, not this',
-        'conversation, and nobody is there to answer questions. Write `prompt` so it stands alone:',
-        'what to do, where, and what to report.',
-        '',
-        'Actions and what each needs:',
-        '- list: nothing. Returns every automation with its id, schedule and last result.',
-        '- create: name, prompt, cron, timezone. Starts running on schedule immediately.',
-        '- update: id, plus only the fields to change. cron and timezone are checked together.',
-        '- delete: id. Permanent.',
-        '- trigger: id. Runs it once now; queued if the chat is busy.',
-        '',
-        'An automation keeps running until someone stops it, so before create or delete, make sure',
-        'the user asked for exactly that (schedule, timezone, what it does). If any of those is unclear,',
-        'ask first. Pausing is update with enabled=false.'
-      ].join('\n'),
-      parameters: {
-        type: 'object',
-        properties: {
-          action: { type: 'string', enum: ['list', 'create', 'update', 'delete', 'trigger'] },
-          id: { type: 'string', description: 'The automation\'s id, from list or create. For update, delete and trigger.' },
-          name: { type: 'string', description: 'Short label shown to the user, e.g. "Morning inbox summary". Up to 120 characters.' },
-          prompt: { type: 'string', description: 'The instruction each run carries out, written to stand alone (see above). Up to 12000 characters.' },
-          cron: { type: 'string', description: 'Five fields: minute hour day-of-month month day-of-week. "0 9 * * 1-5" is 09:00 on weekdays; "*/30 * * * *" is every 30 minutes.' },
-          timezone: { type: 'string', description: 'IANA timezone the cron is read in, e.g. "Europe/Vienna". Required with cron; use the user\'s timezone, and ask if you do not know it.' },
-          enabled: { type: 'boolean', description: 'false pauses the automation without deleting it; true resumes it. New automations are enabled.' }
-        },
-        required: ['action']
-      }
-    }
-  };
+    return {
+        type: 'function',
+        function: {
+            name: 'manage_automation',
+            description: [
+                'Manage scheduled automations: a prompt that runs on its own, on a cron schedule, in this chat.',
+                'Use it when the user wants something done repeatedly or later without them ("every morning',
+                'summarise...", "check X each Friday"). For steps of the current request use manage_tasks instead.',
+                '',
+                'Each run starts fresh: it sees only its own prompt and the previous run\'s result, not this',
+                'conversation, and nobody is there to answer questions. Write `prompt` so it stands alone:',
+                'what to do, where, and what to report.',
+                '',
+                'Actions and what each needs:',
+                '- list: nothing. Returns every automation with its id, schedule and last result.',
+                '- create: name, prompt, cron, timezone. Starts running on schedule immediately.',
+                '- update: id, plus only the fields to change. cron and timezone are checked together.',
+                '- delete: id. Permanent.',
+                '- trigger: id. Runs it once now; queued if the chat is busy.',
+                '',
+                'An automation keeps running until someone stops it, so before create or delete, make sure',
+                'the user asked for exactly that (schedule, timezone, what it does). If any of those is unclear,',
+                'ask first. Pausing is update with enabled=false.'
+            ].join('\n'),
+            parameters: {
+                type: 'object',
+                properties: {
+                    action: { type: 'string', enum: ['list', 'create', 'update', 'delete', 'trigger'] },
+                    id: { type: 'string', description: 'The automation\'s id, from list or create. For update, delete and trigger.' },
+                    name: { type: 'string', description: 'Short label shown to the user, e.g. "Morning inbox summary". Up to 120 characters.' },
+                    prompt: { type: 'string', description: 'The instruction each run carries out, written to stand alone (see above). Up to 12000 characters.' },
+                    cron: { type: 'string', description: 'Five fields: minute hour day-of-month month day-of-week. "0 9 * * 1-5" is 09:00 on weekdays; "*/30 * * * *" is every 30 minutes.' },
+                    timezone: { type: 'string', description: 'IANA timezone the cron is read in, e.g. "Europe/Vienna". Required with cron; use the user\'s timezone, and ask if you do not know it.' },
+                    enabled: { type: 'boolean', description: 'false pauses the automation without deleting it; true resumes it. New automations are enabled.' }
+                },
+                required: ['action']
+            }
+        }
+    };
 }
-
-export async function manageAutomation(args, { store, chatId, triggerAutomation, unattended = false } = {}) {
-  const action = String(args?.action || '');
-  // A scheduled run has nobody watching it. Letting it start more runs is how
-  // one trigger becomes an endless self-requeueing loop, and how text injected
-  // through a tool result turns into a standing schedule. Adjusting or removing
-  // an existing automation stays allowed -- "stop once X is done" is legitimate.
-  if (unattended && (action === 'create' || action === 'trigger')) {
-    return `Error: "${action}" is not available inside a scheduled run. Tell the user in your result if a new automation or run is needed.`;
-  }
-  const chat = chatId ? store.chats.byId(chatId) : null;
-  const userId = chat?.user_id ?? null;
-  if (action === 'list') return JSON.stringify(store.automations.list(userId));
-  if (action === 'create') {
-    if (!chat) throw new Error('automation creation requires a current chat');
-    const fields = cleanFields(args, { requireAll: true });
-    const row = store.automations.create({ ...fields, chatId, source: 'model' }, userId);
-    return JSON.stringify(row);
-  }
-  if (!args?.id) throw new Error('id is required');
-  if (action === 'delete') return store.automations.delete(args.id, userId)
-    ? `Deleted automation ${args.id}.` : 'Error: no such automation';
-  if (action === 'trigger') {
-    const automation = store.automations.get(args.id, userId);
-    if (!automation) throw new Error('no such automation');
-    if (!triggerAutomation) throw new Error('manual triggering is unavailable');
-    return JSON.stringify(await triggerAutomation(automation, userId));
-  }
-  if (action === 'update') {
-    const current = store.automations.get(args.id, userId);
-    if (!current) throw new Error('no such automation');
-    const fields = cleanFields(args);
-    if (args.cron !== undefined || args.timezone !== undefined) {
-      Object.assign(fields, validateSchedule(fields.cron ?? current.cron, fields.timezone ?? current.timezone));
+export async function manageAutomation(args, { store, chatId, triggerAutomation, unattended = false }) {
+    const action = String(args?.action || '');
+    // A scheduled run has nobody watching it. Letting it start more runs is how
+    // one trigger becomes an endless self-requeueing loop, and how text injected
+    // through a tool result turns into a standing schedule. Adjusting or removing
+    // an existing automation stays allowed -- "stop once X is done" is legitimate.
+    if (unattended && (action === 'create' || action === 'trigger')) {
+        return `Error: "${action}" is not available inside a scheduled run. Tell the user in your result if a new automation or run is needed.`;
+    }
+    const chat = chatId ? store.chats.byId(chatId) : null;
+    const userId = chat?.user_id ?? null;
+    if (action === 'list')
+        return JSON.stringify(store.automations.list(userId));
+    if (action === 'create') {
+        if (!chat)
+            throw new Error('automation creation requires a current chat');
+        const fields = cleanFields(args, { requireAll: true });
+        // requireAll: cleanFields has filled every field create needs, or thrown.
+        const row = store.automations.create({ ...fields, chatId, source: 'model' }, userId);
+        return JSON.stringify(row);
     }
-    const row = store.automations.update(args.id, fields, userId);
-    return row ? JSON.stringify(row) : 'Error: no such automation';
-  }
-  throw new Error('action must be list, create, update, delete, or trigger');
+    if (!args?.id)
+        throw new Error('id is required');
+    if (action === 'delete')
+        return store.automations.delete(args.id, userId)
+            ? `Deleted automation ${args.id}.` : 'Error: no such automation';
+    if (action === 'trigger') {
+        const automation = store.automations.get(args.id, userId);
+        if (!automation)
+            throw new Error('no such automation');
+        if (!triggerAutomation)
+            throw new Error('manual triggering is unavailable');
+        return JSON.stringify(await triggerAutomation(automation, userId));
+    }
+    if (action === 'update') {
+        const current = store.automations.get(args.id, userId);
+        if (!current)
+            throw new Error('no such automation');
+        const fields = cleanFields(args);
+        if (args.cron !== undefined || args.timezone !== undefined) {
+            Object.assign(fields, validateSchedule(fields.cron ?? current.cron, fields.timezone ?? current.timezone));
+        }
+        const row = store.automations.update(args.id, fields, userId);
+        return row ? JSON.stringify(row) : 'Error: no such automation';
+    }
+    throw new Error('action must be list, create, update, delete, or trigger');
 }
-
 export function nextSchedule(cron, timezone, now = Date.now()) {
-  return validateSchedule(cron, timezone, now).nextRunAt;
+    return validateSchedule(cron, timezone, now).nextRunAt;
 }
-
 export function runMessage(automation) {
-  const previous = automation.lastResult
-    ? `\n\nPrevious run result (truncated):\n${automation.lastResult.slice(0, 2000)}` : '';
-  return [
-    `[Scheduled automation: ${automation.name}]`,
-    `Schedule: ${automation.cron} (${automation.timezone})`,
-    // Without this the model reads an ordinary user turn and may stop to ask a
-    // clarifying question that nobody will ever answer.
-    'This is an unattended run: no one is present to answer questions. Complete the task'
-      + ' with sensible assumptions and state them, or report exactly what blocked it.',
-    '',
-    automation.prompt
-  ].join('\n') + previous;
+    const previous = automation.lastResult
+        ? `\n\nPrevious run result (truncated):\n${automation.lastResult.slice(0, 2000)}` : '';
+    return [
+        `[Scheduled automation: ${automation.name}]`,
+        `Schedule: ${automation.cron} (${automation.timezone})`,
+        // Without this the model reads an ordinary user turn and may stop to ask a
+        // clarifying question that nobody will ever answer.
+        'This is an unattended run: no one is present to answer questions. Complete the task'
+            + ' with sensible assumptions and state them, or report exactly what blocked it.',
+        '',
+        automation.prompt
+    ].join('\n') + previous;
 }