@3minapi/cli 0.0.0-stage → 0.22.0

package/dist/core/control-db.js

@@ -0,0 +1,462 @@
+import { DatabaseSync } from 'node:sqlite';
+import path from 'node:path';
+import { existsSync, statSync } from 'node:fs';
+import { CONTROL_DB_FILE, ConfigError, DB_BUSY_TIMEOUT_MS, NewerSchemaError, LAST_ERROR_MAX_CHARS, TASKS_PRUNE_BATCH, TASKS_PRUNE_MIN_AGE_MS } from "./domain/index.js";
+import { redactAndTruncate } from "./redact.js";
+import { touchSecretFile } from "./secure-fs.js";
+export const MIGRATIONS = [
+    `CREATE TABLE tasks (
+		task_id          TEXT PRIMARY KEY,
+		worker           TEXT NOT NULL,
+		state            TEXT NOT NULL CHECK (state IN ('received','running','completed','failed','cancelled','superseded')),
+		lease_id         TEXT,
+		delivery_attempt INTEGER NOT NULL DEFAULT 1,
+		run_count        INTEGER NOT NULL DEFAULT 0,
+		received_at      INTEGER NOT NULL,
+		started_at       INTEGER,
+		finished_at      INTEGER,
+		last_error       TEXT
+	) STRICT;
+	CREATE INDEX tasks_finished ON tasks (state, finished_at);
+	CREATE TABLE meta (
+		key        TEXT PRIMARY KEY,
+		value      TEXT NOT NULL,
+		updated_at INTEGER NOT NULL
+	) STRICT;`
+];
+export const SCHEMA_VERSION = MIGRATIONS.length;
+export const TERMINAL_STATES = ['completed', 'failed', 'cancelled', 'superseded'];
+export const META = {
+    stopReason: 'stop_reason',
+    stoppedAt: 'stopped_at',
+    quotaResetAt: 'quota_reset_at'
+};
+export const END_META = {
+    reason: 'end_reason',
+    endedAt: 'ended_at',
+    workers: 'end_workers'
+};
+export const QUOTA_META = { quota: 'quota' };
+export const LIVE_META = { state: 'live_state', url: 'live_url' };
+export class ControlDb {
+    file;
+    db;
+    constructor(file, db) {
+        this.file = file;
+        this.db = db;
+    }
+    static open(dataDir) {
+        const file = path.join(dataDir, CONTROL_DB_FILE);
+        let db;
+        try {
+            touchSecretFile(file);
+            db = new DatabaseSync(file, { timeout: DB_BUSY_TIMEOUT_MS });
+            db.exec('PRAGMA journal_mode = WAL');
+            db.exec('PRAGMA synchronous = NORMAL');
+            migrate(db, file);
+            ensureColumns(db);
+            ensureIndexes(db);
+            return new ControlDb(file, db);
+        }
+        catch (err) {
+            if (db?.isOpen)
+                db.close();
+            if (err instanceof ConfigError)
+                throw err;
+            throw new ConfigError(openFailure(file, err));
+        }
+    }
+    static openReadOnly(dataDir) {
+        const file = path.join(dataDir, CONTROL_DB_FILE);
+        if (!existsSync(file))
+            return null;
+        let db;
+        try {
+            db = new DatabaseSync(file, { readOnly: true, timeout: DB_BUSY_TIMEOUT_MS });
+            const version = userVersion(db);
+            if (version === 0) {
+                db.close();
+                return null;
+            }
+            if (version > SCHEMA_VERSION)
+                throw new NewerSchemaError(file, version, SCHEMA_VERSION);
+            return new ControlDb(file, db);
+        }
+        catch (err) {
+            if (db?.isOpen)
+                db.close();
+            if (err instanceof ConfigError)
+                throw err;
+            throw new ConfigError(openFailure(file, err));
+        }
+    }
+    close() {
+        if (this.db.isOpen)
+            this.db.close();
+    }
+    schemaVersion() {
+        return userVersion(this.db);
+    }
+    receive(task, now) {
+        return this.tx(() => {
+            const row = this.getTask(task.task_id);
+            if (row &&
+                row.state !== 'superseded' &&
+                TERMINAL_STATES.includes(row.state))
+                return 'duplicate-done';
+            if (row) {
+                this.db
+                    .prepare(`UPDATE tasks SET state = 'received', lease_id = ?, delivery_attempt = ?, worker = ?,
+						        callback_url = ?, acked_at = NULL, repeat = ?, input_json = ?
+						 WHERE task_id = ?`)
+                    .run(task.lease_id, task.delivery_attempt, task.worker, task.callback_url ?? null, ...repeatColumns(task), task.task_id);
+            }
+            else {
+                this.db
+                    .prepare(`INSERT INTO tasks (task_id, worker, state, lease_id, delivery_attempt, received_at, callback_url,
+						                    repeat, input_json)
+						 VALUES (?, ?, 'received', ?, ?, ?, ?, ?, ?)`)
+                    .run(task.task_id, task.worker, task.lease_id, task.delivery_attempt, now, task.callback_url ?? null, ...repeatColumns(task));
+            }
+            return 'run';
+        });
+    }
+    markAcked(taskId, now) {
+        this.db.prepare('UPDATE tasks SET acked_at = ? WHERE task_id = ?').run(now, taskId);
+    }
+    unfinishedTasks() {
+        return this.db
+            .prepare(`SELECT * FROM tasks WHERE state IN ('received', 'running')
+				   AND NOT (repeat IS NOT NULL AND acked_at IS NOT NULL)
+				 ORDER BY received_at, task_id`)
+            .all();
+    }
+    repeatTasks() {
+        return this.db
+            .prepare(`SELECT * FROM tasks WHERE state IN ('received', 'running')
+				   AND repeat IS NOT NULL AND acked_at IS NOT NULL
+				 ORDER BY received_at, task_id`)
+            .all();
+    }
+    startRun(taskId, runNo, now) {
+        this.db
+            .prepare(`UPDATE tasks SET state = 'running', run_no = ?, started_at = coalesce(started_at, ?),
+				        run_count = run_count + 1
+				 WHERE task_id = ?`)
+            .run(runNo, now, taskId);
+    }
+    recordRun(taskId, p) {
+        this.db
+            .prepare('UPDATE tasks SET runs = ?, failed = ?, fail_streak = ?, last_run_at = ? WHERE task_id = ?')
+            .run(p.runs, p.failed, p.failStreak, p.lastRunAt, taskId);
+    }
+    setNextAt(taskId, nextAt) {
+        this.db.prepare('UPDATE tasks SET next_at = ? WHERE task_id = ?').run(nextAt, taskId);
+    }
+    markRunning(taskId, now) {
+        this.db
+            .prepare(`UPDATE tasks SET state = 'running', started_at = ?, run_count = run_count + 1
+				 WHERE task_id = ?`)
+            .run(now, taskId);
+    }
+    markFinished(taskId, state, now, error) {
+        this.db
+            .prepare(`UPDATE tasks SET state = ?, finished_at = ?, last_error = ?, input_json = NULL WHERE task_id = ?`)
+            .run(state, now, error === undefined ? null : redactAndTruncate(error, LAST_ERROR_MAX_CHARS), taskId);
+    }
+    getTask(taskId) {
+        const row = this.db.prepare('SELECT * FROM tasks WHERE task_id = ?').get(taskId);
+        return row ?? null;
+    }
+    listTasks(filter, limit) {
+        const conds = [];
+        const params = [];
+        if (filter.since !== undefined) {
+            conds.push('received_at >= ?');
+            params.push(filter.since);
+        }
+        if (filter.worker !== undefined) {
+            conds.push('worker = ?');
+            params.push(filter.worker);
+        }
+        if (filter.after !== undefined) {
+            conds.push('received_at <= ? AND (received_at < ? OR task_id > ?)');
+            params.push(filter.after.at, filter.after.at, filter.after.taskId);
+        }
+        if (filter.states !== undefined) {
+            conds.push(`state IN (${filter.states.map(() => '?').join(', ') || 'NULL'})`);
+            params.push(...filter.states);
+        }
+        const where = conds.length > 0 ? `WHERE ${conds.join(' AND ')}` : '';
+        return this.db
+            .prepare(`SELECT * FROM tasks ${where} ORDER BY received_at DESC, task_id LIMIT ?`)
+            .all(...params, limit);
+    }
+    tasksByIds(ids) {
+        if (ids.length === 0)
+            return [];
+        return this.db
+            .prepare(`SELECT * FROM tasks WHERE task_id IN (${ids.map(() => '?').join(', ')})`)
+            .all(...ids);
+    }
+    countGrouped(since, unit) {
+        const format = unit === 'day' ? '%Y-%m-%d' : '%Y-%m-%d %H';
+        return this.db
+            .prepare(`SELECT strftime('${format}', received_at / 1000, 'unixepoch', 'localtime') AS bucket, worker, state, count(*) AS n
+					 FROM tasks WHERE received_at >= ? GROUP BY bucket, worker, state`)
+            .all(since).map((r) => ({ ...r, n: Number(r.n) }));
+    }
+    distinctWorkers() {
+        return this.db.prepare('SELECT DISTINCT worker FROM tasks').all().map((r) => r.worker);
+    }
+    taskCounts() {
+        const row = this.db
+            .prepare(`SELECT count(*) AS total,
+				        coalesce(sum(state IN ('received','running') AND repeat IS NULL), 0) AS unfinished,
+				        coalesce(sum(state IN ('received','running') AND repeat IS NOT NULL), 0) AS repeating
+				 FROM tasks`)
+            .get();
+        return {
+            total: Number(row.total),
+            unfinished: Number(row.unfinished),
+            repeating: Number(row.repeating)
+        };
+    }
+    fileBytes() {
+        const wal = `${this.file}-wal`;
+        return statSync(this.file).size + (existsSync(wal) ? statSync(wal).size : 0);
+    }
+    pruneUsage(filter, now) {
+        const cutoff = pruneCutoff(filter.before, now);
+        const { where, params } = pruneWhere(filter.worker, cutoff);
+        const row = this.db
+            .prepare(`SELECT count(*) AS count, coalesce(sum(${ROW_BYTES}), 0) AS bytes FROM tasks WHERE ${where}`)
+            .get(...params);
+        let recent = 0;
+        if (cutoff < filter.before) {
+            const r = pruneWhere(filter.worker, filter.before);
+            recent =
+                Number(this.db
+                    .prepare(`SELECT count(*) AS n FROM tasks WHERE ${r.where} AND finished_at >= ?`)
+                    .get(...r.params, cutoff).n) || 0;
+        }
+        return { count: Number(row.count), bytes: Number(row.bytes), recent };
+    }
+    prune(filter, now) {
+        const { where, params } = pruneWhere(filter.worker, pruneCutoff(filter.before, now));
+        const stmt = this.db.prepare(`DELETE FROM tasks WHERE rowid IN (SELECT rowid FROM tasks WHERE ${where} LIMIT ${TASKS_PRUNE_BATCH})`);
+        let deleted = 0;
+        for (;;) {
+            const n = this.tx(() => Number(stmt.run(...params).changes));
+            deleted += n;
+            if (n < TASKS_PRUNE_BATCH)
+                return deleted;
+        }
+    }
+    recordQuota(quota, now) {
+        this.setMeta(QUOTA_META.quota, JSON.stringify(quota), now);
+    }
+    getQuota() {
+        const row = this.db
+            .prepare('SELECT value, updated_at FROM meta WHERE key = ?')
+            .get(QUOTA_META.quota);
+        if (!row)
+            return null;
+        try {
+            const quota = JSON.parse(row.value);
+            if (typeof quota?.used !== 'number' || typeof quota.limit !== 'number')
+                return null;
+            return { quota, at: Number(row.updated_at) };
+        }
+        catch {
+            return null;
+        }
+    }
+    getMeta(key) {
+        const row = this.db.prepare('SELECT value FROM meta WHERE key = ?').get(key);
+        return row?.value ?? null;
+    }
+    setMeta(key, value, now) {
+        this.db
+            .prepare(`INSERT INTO meta (key, value, updated_at) VALUES (?, ?, ?)
+				 ON CONFLICT (key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`)
+            .run(key, value, now);
+    }
+    setMetas(entries, now) {
+        this.tx(() => {
+            for (const [key, value] of Object.entries(entries))
+                this.setMeta(key, value, now);
+        });
+    }
+    deleteMeta(key) {
+        this.db.prepare('DELETE FROM meta WHERE key = ?').run(key);
+    }
+    getLiveState() {
+        const raw = this.getMeta(LIVE_META.state);
+        if (raw === null)
+            return null;
+        try {
+            const v = JSON.parse(raw);
+            return typeof v === 'object' && v !== null && typeof v.connected === 'boolean' ? v : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    setLiveState(state, now) {
+        this.setMeta(LIVE_META.state, JSON.stringify(state), now);
+    }
+    recordStop(reason, now, quotaResetAt) {
+        this.tx(() => {
+            this.setMeta(META.stopReason, reason, now);
+            this.setMeta(META.stoppedAt, String(now), now);
+            if (quotaResetAt)
+                this.setMeta(META.quotaResetAt, quotaResetAt, now);
+            else
+                this.deleteMeta(META.quotaResetAt);
+        });
+    }
+    getStop() {
+        const reason = this.getMeta(META.stopReason);
+        if (reason === null)
+            return null;
+        return {
+            reason: reason,
+            stoppedAt: Number(this.getMeta(META.stoppedAt) ?? 0),
+            quotaResetAt: this.getMeta(META.quotaResetAt)
+        };
+    }
+    clearStop() {
+        this.tx(() => {
+            for (const key of Object.values(META))
+                this.deleteMeta(key);
+        });
+    }
+    recordEnd(reason, now, deletedWorkers) {
+        this.tx(() => {
+            this.setMeta(END_META.reason, reason, now);
+            this.setMeta(END_META.endedAt, String(now), now);
+            this.setMeta(END_META.workers, JSON.stringify(deletedWorkers), now);
+        });
+    }
+    getEnd() {
+        const reason = this.getMeta(END_META.reason);
+        if (reason === null)
+            return null;
+        let deletedWorkers = [];
+        try {
+            const parsed = JSON.parse(this.getMeta(END_META.workers) ?? '[]');
+            if (Array.isArray(parsed))
+                deletedWorkers = parsed.filter((n) => typeof n === 'string');
+        }
+        catch {
+        }
+        return {
+            reason: reason,
+            endedAt: Number(this.getMeta(END_META.endedAt) ?? 0),
+            deletedWorkers
+        };
+    }
+    clearEnd() {
+        this.tx(() => {
+            for (const key of Object.values(END_META))
+                this.deleteMeta(key);
+        });
+    }
+    tx(fn) {
+        return transaction(this.db, fn);
+    }
+}
+const ROW_BYTES = 'length(task_id) + length(worker) + length(state) + coalesce(length(lease_id), 0) + coalesce(length(last_error), 0) + 48';
+function pruneCutoff(before, now) {
+    return Math.min(before, now - TASKS_PRUNE_MIN_AGE_MS);
+}
+function pruneWhere(worker, cutoff) {
+    const conds = [
+        `state IN (${TERMINAL_STATES.map(() => '?').join(',')})`,
+        'finished_at IS NOT NULL',
+        'finished_at < ?'
+    ];
+    const params = [...TERMINAL_STATES, cutoff];
+    if (worker !== undefined) {
+        conds.push('worker = ?');
+        params.push(worker);
+    }
+    return { where: conds.join(' AND '), params };
+}
+function transaction(db, fn) {
+    db.exec('BEGIN IMMEDIATE');
+    try {
+        const result = fn();
+        db.exec('COMMIT');
+        return result;
+    }
+    catch (err) {
+        if (db.isTransaction)
+            db.exec('ROLLBACK');
+        throw err;
+    }
+}
+function userVersion(db) {
+    const row = db.prepare('PRAGMA user_version').get();
+    return Number(row.user_version);
+}
+function migrate(db, file) {
+    if (userVersion(db) === SCHEMA_VERSION)
+        return;
+    transaction(db, () => {
+        const current = userVersion(db);
+        if (current > SCHEMA_VERSION)
+            throw new NewerSchemaError(file, current, SCHEMA_VERSION);
+        for (let v = current; v < SCHEMA_VERSION; v++)
+            db.exec(MIGRATIONS[v]);
+        db.exec(`PRAGMA user_version = ${SCHEMA_VERSION}`);
+    });
+}
+const EXTRA_COLUMNS = [
+    ['acked_at', 'INTEGER'],
+    ['callback_url', 'TEXT'],
+    ['repeat', 'TEXT'],
+    ['input_json', 'TEXT'],
+    ['run_no', 'INTEGER'],
+    ['next_at', 'INTEGER'],
+    ['fail_streak', 'INTEGER'],
+    ['runs', 'INTEGER'],
+    ['failed', 'INTEGER'],
+    ['last_run_at', 'INTEGER']
+];
+function repeatColumns(task) {
+    if (!task.repeat)
+        return [null, null];
+    return [JSON.stringify(task.repeat), JSON.stringify(task.input ?? null)];
+}
+function ensureColumns(db) {
+    const missing = () => {
+        const have = new Set(db.prepare('PRAGMA table_info(tasks)').all().map((c) => c.name));
+        return EXTRA_COLUMNS.filter(([name]) => !have.has(name));
+    };
+    if (missing().length === 0)
+        return;
+    transaction(db, () => {
+        for (const [name, type] of missing())
+            db.exec(`ALTER TABLE tasks ADD COLUMN ${name} ${type}`);
+    });
+}
+function ensureIndexes(db) {
+    try {
+        db.exec('CREATE INDEX IF NOT EXISTS tasks_received ON tasks (received_at)');
+    }
+    catch {
+    }
+}
+function openFailure(file, err) {
+    const e = err;
+    const reason = e?.message ?? String(err);
+    if (e?.code === 'EACCES' || e?.code === 'EPERM') {
+        return `cannot open ${file}: permission denied. Check the owner and permissions of that folder.`;
+    }
+    if (e?.errcode === 26 || e?.errcode === 11) {
+        return `${file} is corrupted (${reason}). Move it aside and run the command again — it only holds local state.`;
+    }
+    return `cannot open ${file}: ${reason}`;
+}

package/dist/core/credentials.js

@@ -0,0 +1,75 @@
+import { randomBytes } from 'node:crypto';
+import { existsSync, readFileSync, rmSync } from 'node:fs';
+import path from 'node:path';
+import { CREDENTIALS_FILE, ConfigError, ENV, HOST_TOKEN_PREFIX, LOCAL_SERVER_TOKEN_FILE } from "./domain/index.js";
+import { writeSecretFile } from "./secure-fs.js";
+const HOST_TOKEN = new RegExp(`^${HOST_TOKEN_PREFIX}[0-9a-f]{48}$`);
+export function isHostToken(value) {
+    return HOST_TOKEN.test(value);
+}
+export function credentialsPath(configDir) {
+    return path.join(configDir, CREDENTIALS_FILE);
+}
+export function resolveHostToken(configDir, env) {
+    const fromEnv = env[ENV.token];
+    if (fromEnv !== undefined && fromEnv !== '') {
+        const token = fromEnv.trim();
+        if (!isHostToken(token)) {
+            throw new ConfigError(`${ENV.token} is not a host token (expected ${HOST_TOKEN_PREFIX}...)`);
+        }
+        return { token, source: 'env', location: ENV.token };
+    }
+    const file = credentialsPath(configDir);
+    const saved = readCredentials(file);
+    return saved ? { token: saved.hostToken, source: 'file', location: file } : null;
+}
+export function saveHostToken(configDir, token, now) {
+    if (!isHostToken(token))
+        throw new ConfigError(`not a host token (expected ${HOST_TOKEN_PREFIX}...)`);
+    const file = credentialsPath(configDir);
+    const body = { hostToken: token, savedAt: new Date(now).toISOString() };
+    writeSecretFile(file, JSON.stringify(body, null, '\t') + '\n');
+    return file;
+}
+export function deleteHostToken(configDir) {
+    const file = credentialsPath(configDir);
+    if (!existsSync(file))
+        return false;
+    rmSync(file);
+    return true;
+}
+export function getOrCreateLocalServerToken(configDir) {
+    const file = path.join(configDir, LOCAL_SERVER_TOKEN_FILE);
+    if (existsSync(file)) {
+        const token = readFileSync(file, 'utf8').trim();
+        if (/^[0-9a-f]{64}$/.test(token))
+            return token;
+    }
+    const token = randomBytes(32).toString('hex');
+    writeSecretFile(file, token + '\n');
+    return token;
+}
+function readCredentials(file) {
+    let text;
+    try {
+        text = readFileSync(file, 'utf8');
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'ENOENT')
+            return null;
+        throw new ConfigError(`cannot read ${file} (${code ?? err.message})`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new ConfigError(`${file} is corrupted. Run '3minapi login' again.`);
+    }
+    const token = parsed?.hostToken;
+    if (typeof token !== 'string' || !isHostToken(token)) {
+        throw new ConfigError(`${file} does not hold a valid host token. Run '3minapi login' again.`);
+    }
+    return parsed;
+}

package/dist/core/domain/constants.js

@@ -0,0 +1,121 @@
+export const BIN = '3minapi';
+export const PACKAGE_NAME = '@3minapi/cli';
+export const MIN_NODE_VERSION = '24.12.0';
+export const APP_DIR_NAME = '3minapi';
+export const PROJECT_CONFIG_FILE = '3minapi.json';
+export const AGENTS_FILE = 'AGENTS.md';
+export const CLAUDE_FILE = 'CLAUDE.md';
+export const DEFAULT_PROJECT_DIR = '3minapi';
+export const USER_CONFIG_FILE = 'config.json';
+export const CREDENTIALS_FILE = 'credentials.json';
+export const LOCAL_SERVER_TOKEN_FILE = 'local-server-token';
+export const CONTROL_DB_FILE = 'control.db';
+export const PROJECT_RECORD_FILE = 'project.json';
+export const RUNNER_LOCK_FILE = 'runner.json';
+export const RUNNER_STOP_FILE = 'runner.stop';
+export const RUNNER_RELOAD_FILE = 'runner.reload';
+export const RUNNER_RELOADED_FILE = 'runner.reloaded';
+export const RUNNER_DELETED_FILE = 'runner.deleted';
+export const RUNNER_OUT_FILE = 'runner.out';
+export const DASHBOARD_LOCK_FILE = 'dashboard.json';
+export const DASHBOARD_STOP_FILE = 'dashboard.stop';
+export const DASHBOARD_LINK_FILE = 'dashboard.link';
+export const DASHBOARD_OUT_FILE = 'dashboard.out';
+export const OUT_FILE_MAX_BYTES = 10 * 1024 * 1024;
+export const APP_LOG_DIR = 'app';
+export const WORKER_LOG_DIR = 'workers';
+export const LOG_FILE_EXTENSION = '.jsonl';
+export const SECRET_FILE_MODE = 0o600;
+export const PRIVATE_DIR_MODE = 0o700;
+export const ENV = {
+    home: 'THREEMINAPI_HOME',
+    token: 'THREEMINAPI_TOKEN',
+    apiUrl: 'THREEMINAPI_API_URL',
+    pollIntervalMs: 'THREEMINAPI_POLL_INTERVAL_MS',
+    logRetentionDays: 'THREEMINAPI_LOG_RETENTION_DAYS',
+    logMaxBytes: 'THREEMINAPI_LOG_MAX_BYTES',
+    concurrency: 'THREEMINAPI_CONCURRENCY',
+    localServerPort: 'THREEMINAPI_LOCAL_SERVER_PORT',
+    receiveMode: 'THREEMINAPI_RECEIVE_MODE',
+    detached: 'THREEMINAPI_DETACHED',
+    noUpdateNotice: 'THREEMINAPI_NO_UPDATE_NOTICE'
+};
+export const WORKER_SECRET_ENV = (name) => `THREEMINAPI_WORKER_${envName(name)}_SECRET`;
+export const WORKER_KEY_ENV = (name) => `THREEMINAPI_WORKER_${envName(name)}_KEY`;
+function envName(name) {
+    return name.toUpperCase().replace(/-/g, '_');
+}
+export const PROXY_ENV_VARS = ['HTTPS_PROXY', 'https_proxy', 'HTTP_PROXY', 'http_proxy'];
+export const DEFAULT_API_URL = 'https://api.3minapi.com';
+export const DEFAULT_WORKERS_DIR = 'workers';
+export const DEFAULT_POLL_INTERVAL_MS = 60_000;
+export const POLL_INTERVAL_MIN_MS = 5_000;
+export const POLL_INTERVAL_MAX_MS = 3_600_000;
+export const LIVE_CONNECT_TIMEOUT_MS = 30_000;
+export const EXIT_GRACE_MS = 3_000;
+export const DEFAULT_CONCURRENCY = 4;
+export const CONCURRENCY_MIN = 1;
+export const CONCURRENCY_MAX = 50;
+export const DEFAULT_LOCAL_SERVER_PORT = 3180;
+export const LOCAL_SERVER_PORT_MIN = 1024;
+export const LOCAL_SERVER_PORT_MAX = 65535;
+export const DEFAULT_LOG_RETENTION_DAYS = 30;
+export const LOG_RETENTION_MIN_DAYS = 1;
+export const LOG_RETENTION_MAX_DAYS = 365;
+export const MIB = 1024 * 1024;
+export const DEFAULT_LOG_MAX_BYTES = 300 * MIB;
+export const LOG_MAX_BYTES_MIN = 10 * MIB;
+export const LOG_MAX_BYTES_MAX = 1024 * MIB;
+export const LOG_FILE_MAX_BYTES = 10 * MIB;
+export const LOG_STRING_MAX_CHARS = 4_000;
+export const LAST_ERROR_MAX_CHARS = 256;
+export const ERROR_MESSAGE_MAX_CHARS = 4_000;
+export const EVENT_MESSAGE_MAX_CHARS = 200;
+export const REPEAT_FAIL_STREAK_MAX = 5;
+export const REPEAT_TICK_MS = 1_000;
+export const CLI_ENV_PREFIX = 'THREEMINAPI_';
+export const WORKER_EXTENSIONS = ['.js', '.mjs', '.ts', '.mts'];
+export const TEMPLATE_EXTENSION = { js: '.mjs', ts: '.mts' };
+export const USER_DB_FILE = 'data.db';
+export const RESULT_TABLE_PREFIX = '_3minapi_';
+export const RESULTS_TABLE = `${RESULT_TABLE_PREFIX}results`;
+export const RESULTS_META_TABLE = `${RESULT_TABLE_PREFIX}meta`;
+export const RESULTS_SCHEMA_VERSION = 1;
+export const RESULT_RESERVED_KEY = '_3minapi';
+export const REPORT_ENVELOPE_RESERVE = 1024;
+export const STORED_ERROR_MAX_CHARS = 1_000_000;
+export const SHAPE_MAX_DEPTH = 8;
+export const SHAPE_MAX_PATHS = 200;
+export const SHAPE_MAX_VALUES = 10;
+export const SHAPE_VALUE_MAX_CHARS = 40;
+export const SHAPE_PATH_MAX_CHARS = 200;
+export const SUBSTITUTE_MAX_BYTES = 8 * 1024;
+export const DESCRIBE_MAX_GROUPS = 20;
+export const DESCRIBE_MAX_DIFF_PATHS = 50;
+export const DESCRIBE_MAX_MERGE = 1000;
+export const RESULTS_LIST_DEFAULT = 20;
+export const RESULTS_QUERY_TIMEOUT_MS = 30_000;
+export const READ_MAX_BYTES = 90 * 1024;
+export const READ_LIMIT_MAX = 10_000;
+export const BUILTIN_TASK_IDS_MAX = 100;
+export const GITIGNORE_ENTRIES = ['.env', `${USER_DB_FILE}*`];
+export const DOCTOR_API_TIMEOUT_MS = 5_000;
+export const API_TIMEOUT_MS = 15_000;
+export const NETWORK_FAMILY_ATTEMPT_TIMEOUT_MS = 2_000;
+export const TASKS_PRUNE_MIN_AGE_MS = 24 * 60 * 60 * 1000;
+export const TASKS_PRUNE_BATCH = 5_000;
+export const DB_BUSY_TIMEOUT_MS = 5_000;
+export const LOG_FOLLOW_INTERVAL_MS = 500;
+export const DEFAULT_WORKER_TIMEOUT_MS = 60_000;
+export const WORKER_TIMEOUT_MAX_MS = 23 * 60 * 60 * 1000;
+export const CANCEL_GRACE_MS = 2_000;
+export const TERMINATE_WAIT_MS = 5_000;
+export const STOP_CHECK_INTERVAL_MS = 1_000;
+export const STOP_WAIT_MS = 15_000;
+export const RELOAD_WAIT_MS = 120_000;
+export const DETACH_READY_MS = 10_000;
+export const HEARTBEAT_INTERVAL_MS = 10_000;
+export const HEARTBEAT_STALE_MS = 60_000;
+export const MONTH_MS = 30 * 24 * 60 * 60 * 1000;
+export const PUSH_TIMESTAMP_TOLERANCE_S = 300;
+export const DEFAULT_LOG_LINES = 100;