@arthovlabs/liber 0.0.0-stage → 0.5.0

package/src/daemon/core/auth.js

@@ -0,0 +1,217 @@
+// src/daemon/core/auth.js — who may talk to the daemon, and how often.
+//
+// One shared token is fine for a single desktop app and wrong for anything else:
+// it cannot be revoked without breaking every client, it cannot be limited, and
+// an audit line saying "someone did this" is useless. This module keeps a client
+// per token, each with scopes and a rate limit, and never stores the token
+// itself — only its SHA-256.
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+const DIR = () => path.resolve(process.cwd(), '.liber');
+const tokenPath = () => path.join(DIR(), 'daemon.token');
+const FILE = () => path.join(DIR(), 'clients.json');
+const AUDIT = () => path.join(DIR(), 'auth-audit.log');
+
+const SCOPES = ['read', 'chat', 'tools', 'admin'];
+const DEFAULT_LIMIT = 240; // requests per minute per client
+
+/** Scope a request needs. Unlisted endpoints fall back to `tools`. */
+function scopeFor(method, endpoint) {
+  if (endpoint === '/shutdown' || endpoint.startsWith('/clients')) return 'admin';
+  if (endpoint.startsWith('/config') || endpoint === '/vault/migrate') return method === 'GET' ? 'read' : 'admin';
+  if (endpoint === '/chat' || endpoint === '/chat/stream' || endpoint === '/model/switch' || endpoint.endsWith('/run')) return 'chat';
+  if (endpoint.startsWith('/hitl') || endpoint.startsWith('/memory') || endpoint.startsWith('/budget') || endpoint.startsWith('/sessions')) return 'chat';
+  if (method === 'GET' || method === 'HEAD') return 'read';
+  return 'tools';
+}
+
+const hash = (token) => crypto.createHash('sha256').update(String(token || '')).digest('hex');
+
+function read() {
+  try {
+    const raw = JSON.parse(fs.readFileSync(FILE(), 'utf8'));
+    return { clients: Array.isArray(raw.clients) ? raw.clients : [] };
+  } catch { return { clients: [] }; }
+}
+
+function write(state) {
+  fs.mkdirSync(DIR(), { recursive: true });
+  const tmp = FILE() + '.tmp';
+  fs.writeFileSync(tmp, JSON.stringify(state, null, 2), { encoding: 'utf8', mode: 0o600 });
+  fs.renameSync(tmp, FILE());
+}
+
+/**
+ * First boot: adopt the existing daemon.token as an admin client so the desktop
+ * app keeps working without re-authenticating, and create the token if missing.
+ */
+function bootstrap() {
+  const state = read();
+  if (state.clients.length) return state;
+
+  let token = null;
+  try { token = fs.readFileSync(tokenPath(), 'utf8').trim(); } catch { /* create below */ }
+  if (!token) {
+    token = crypto.randomBytes(32).toString('hex');
+    fs.mkdirSync(DIR(), { recursive: true });
+    fs.writeFileSync(tokenPath(), token, { encoding: 'utf8', mode: 0o600 });
+  }
+  state.clients.push({
+    id: 'local',
+    label: 'This machine (desktop app)',
+    hash: hash(token),
+    scopes: ['read', 'chat', 'tools', 'admin'],
+    perMin: 600,
+    createdAt: new Date().toISOString(),
+    lastUsedAt: null,
+    calls: 0
+  });
+  write(state);
+  return state;
+}
+
+function sameHash(a, b) {
+  const ab = Buffer.from(String(a), 'hex');
+  const bb = Buffer.from(String(b), 'hex');
+  if (ab.length !== bb.length || ab.length === 0) return false;
+  return crypto.timingSafeEqual(ab, bb);
+}
+
+/** Resolve a bearer token to a client record, or null. */
+function verify(token) {
+  if (!token) return null;
+  const wanted = hash(token);
+  const state = bootstrap();
+  for (const c of state.clients) if (sameHash(c.hash, wanted)) return c;
+  return null;
+}
+
+/** Record use; best effort, never rejects a request. */
+function touch(client) {
+  try {
+    const state = read();
+    const c = state.clients.find(x => x.id === client.id);
+    if (!c) return;
+    c.lastUsedAt = new Date().toISOString();
+    c.calls = (c.calls || 0) + 1;
+    write(state);
+  } catch { /* usage tracking is not worth failing a call over */ }
+}
+
+const buckets = new Map(); // clientId -> { tokens, updatedAt }
+
+/** Token bucket, refilled continuously at `perMin` per minute. */
+function rateLimit(client, now = Date.now()) {
+  const perMin = Math.max(1, Number(client.perMin) || DEFAULT_LIMIT);
+  const b = buckets.get(client.id) || { tokens: perMin, updatedAt: now };
+  const elapsed = Math.max(0, now - b.updatedAt) / 60000;
+  b.tokens = Math.min(perMin, b.tokens + elapsed * perMin);
+  b.updatedAt = now;
+  if (b.tokens < 1) {
+    buckets.set(client.id, b);
+    return { allowed: false, remaining: 0, retryAfterMs: Math.ceil(((1 - b.tokens) / perMin) * 60000), limit: perMin };
+  }
+  b.tokens -= 1;
+  buckets.set(client.id, b);
+  return { allowed: true, remaining: Math.floor(b.tokens), limit: perMin };
+}
+
+function can(client, scope) {
+  const list = client?.scopes || [];
+  return list.includes('*') || list.includes(scope);
+}
+
+function audit(entry) {
+  try {
+    fs.mkdirSync(DIR(), { recursive: true });
+    fs.appendFileSync(AUDIT(), JSON.stringify({ ts: new Date().toISOString(), ...entry }) + '\n', 'utf8');
+  } catch { /* never block on audit */ }
+}
+
+/** Create a client. The plaintext token is returned exactly once. */
+function create(label, { scopes = ['read', 'chat', 'tools'], perMin = DEFAULT_LIMIT } = {}) {
+  const state = bootstrap();
+  const clean = (Array.isArray(scopes) ? scopes : ['read']).filter(s => SCOPES.includes(s) || s === '*');
+  if (!clean.length) return { ok: false, error: `scopes must be one of ${SCOPES.join(', ')}` };
+  const token = 'lib_' + crypto.randomBytes(24).toString('hex');
+  const client = {
+    id: 'c_' + crypto.randomBytes(4).toString('hex'),
+    label: String(label || 'client').slice(0, 60),
+    hash: hash(token),
+    scopes: clean,
+    perMin: Math.max(1, Math.min(10000, Number(perMin) || DEFAULT_LIMIT)),
+    createdAt: new Date().toISOString(),
+    lastUsedAt: null,
+    calls: 0
+  };
+  state.clients.push(client);
+  write(state);
+  return { ok: true, id: client.id, token, scopes: client.scopes, perMin: client.perMin };
+}
+
+function list() {
+  return bootstrap().clients.map(c => ({
+    id: c.id, label: c.label, scopes: c.scopes, perMin: c.perMin,
+    createdAt: c.createdAt, lastUsedAt: c.lastUsedAt, calls: c.calls || 0
+  }));
+}
+
+function revoke(id) {
+  const state = bootstrap();
+  if (id === 'local') return { ok: false, error: 'The local desktop client cannot be revoked — rotate it instead.' };
+  const before = state.clients.length;
+  state.clients = state.clients.filter(c => c.id !== id);
+  if (state.clients.length === before) return { ok: false, error: `No client '${id}'.` };
+  write(state);
+  buckets.delete(id);
+  return { ok: true, revoked: id };
+}
+
+/** New token for an existing client; the old one stops working immediately. */
+function rotate(id) {
+  const state = bootstrap();
+  const c = state.clients.find(x => x.id === id);
+  if (!c) return { ok: false, error: `No client '${id}'.` };
+  const token = id === 'local' ? crypto.randomBytes(32).toString('hex') : 'lib_' + crypto.randomBytes(24).toString('hex');
+  c.hash = hash(token);
+  c.createdAt = new Date().toISOString();
+  write(state);
+  if (id === 'local') fs.writeFileSync(tokenPath(), token, { encoding: 'utf8', mode: 0o600 });
+  return { ok: true, id, token };
+}
+
+/* ── legacy helpers, kept so existing callers keep working ────────────────── */
+function readToken() {
+  if (process.env.LIBER_TOKEN) return process.env.LIBER_TOKEN.trim();
+  try { return fs.readFileSync(tokenPath(), 'utf8').trim() || null; } catch { return null; }
+}
+function ensureToken() {
+  const existing = readToken();
+  if (existing) return existing;
+  const token = crypto.randomBytes(32).toString('hex');
+  fs.mkdirSync(DIR(), { recursive: true });
+  fs.writeFileSync(tokenPath(), token, { encoding: 'utf8', mode: 0o600 });
+  return token;
+}
+function extract(req) {
+  const auth = req.headers?.authorization || req.headers?.['x-liber-token'] || '';
+  return String(auth).replace(/^Bearer\s+/i, '').trim();
+}
+function safeEqual(provided, expected) {
+  if (!provided || !expected) return false;
+  const a = Buffer.from(String(provided));
+  const b = Buffer.from(String(expected));
+  if (a.length !== b.length) return false;
+  return crypto.timingSafeEqual(a, b);
+}
+function isAuthorized(req, expected) {
+  return safeEqual(extract(req), expected);
+}
+
+module.exports = {
+  bootstrap, verify, touch, rateLimit, can, scopeFor, audit, create, list, revoke, rotate, hash,
+  SCOPES, DEFAULT_LIMIT, FILE, AUDIT,
+  tokenPath, readToken, ensureToken, extract, safeEqual, isAuthorized
+};

package/src/daemon/core/automations.js

@@ -0,0 +1,130 @@
+// src/daemon/core/automations.js — scheduled prompt runs.
+// A job is a prompt plus a schedule; the daemon ticks and runs whatever is due
+// through the same engine a manual turn uses, so grounding and policy apply.
+const fs = require('fs');
+const path = require('path');
+
+const FILE = () => process.env.LIBER_AUTOMATIONS_FILE || path.resolve(process.cwd(), '.liber', 'automations.json');
+const MAX_JOBS = 20;
+
+function nowMs() { return Date.now(); }
+
+function load() {
+  try {
+    const raw = JSON.parse(fs.readFileSync(FILE(), 'utf8'));
+    const jobs = Array.isArray(raw?.jobs) ? raw.jobs : [];
+    return { jobs: jobs.map(normalise).filter(Boolean) };
+  } catch {
+    return { jobs: [] };
+  }
+}
+
+function save(state) {
+  try {
+    fs.mkdirSync(path.dirname(FILE()), { recursive: true });
+    fs.writeFileSync(FILE(), JSON.stringify({ jobs: state.jobs }, null, 2), 'utf8');
+  } catch { /* a scheduler must never break the daemon */ }
+}
+
+/** Coerce whatever came from the API into a job we can schedule. */
+function normalise(job) {
+  if (!job || typeof job !== 'object') return null;
+  const prompt = String(job.prompt || '').trim();
+  if (!prompt) return null;
+  const sch = job.schedule || {};
+  const type = sch.type === 'daily' ? 'daily' : 'interval';
+  const schedule = type === 'daily'
+    ? { type, at: /^\d{1,2}:\d{2}$/.test(String(sch.at || '')) ? String(sch.at) : '09:00' }
+    : { type, minutes: Math.min(1440, Math.max(1, Number(sch.minutes) || 30)) };
+  return {
+    id: String(job.id || `a${Date.now().toString(36)}${Math.random().toString(36).slice(2, 5)}`),
+    name: String(job.name || 'Automation').slice(0, 60),
+    prompt,
+    schedule,
+    enabled: job.enabled !== false,
+    createdAt: job.createdAt || new Date().toISOString(),
+    lastRunAt: job.lastRunAt || null,
+    lastResult: job.lastResult || null,
+    runCount: Number(job.runCount) || 0
+  };
+}
+
+/** Milliseconds until this job should fire again (null = never run yet). */
+function dueIn(job, from = nowMs()) {
+  if (!job.enabled) return null;
+  const last = job.lastRunAt ? Date.parse(job.lastRunAt) : null;
+
+  if (job.schedule.type === 'interval') {
+    if (last === null) return 0;
+    const next = last + job.schedule.minutes * 60_000;
+    return Math.max(0, next - from);
+  }
+
+  // daily at HH:MM local time: fire once per day, at the slot, and never twice
+  const [hh, mm] = job.schedule.at.split(':').map(Number);
+  const slot = new Date(from);
+  slot.setHours(hh, mm, 0, 0);
+  const DAY = 24 * 60 * 60 * 1000;
+  const ranSinceSlot = last !== null && last >= slot.getTime() - 1000 && last < slot.getTime() + DAY;
+  if (ranSinceSlot) return slot.getTime() + DAY - from;
+  return slot.getTime() <= from ? 0 : slot.getTime() - from;
+}
+
+const isDue = (job, from = nowMs()) => dueIn(job, from) === 0;
+
+function list() {
+  const state = load();
+  return state.jobs.map(j => ({ ...j, due_in_ms: dueIn(j), due: isDue(j) }));
+}
+
+function create(input) {
+  const state = load();
+  if (state.jobs.length >= MAX_JOBS) {
+    return { ok: false, error: `Too many automations (max ${MAX_JOBS}).` };
+  }
+  const job = normalise({ ...input, id: null, lastRunAt: null, lastResult: null, runCount: 0 });
+  if (!job) return { ok: false, error: 'A prompt is required.' };
+  state.jobs.push(job);
+  save(state);
+  return { ok: true, job };
+}
+
+function update(id, patch = {}) {
+  const state = load();
+  const i = state.jobs.findIndex(j => j.id === id);
+  if (i < 0) return { ok: false, error: `No automation '${id}'.` };
+  const merged = normalise({ ...state.jobs[i], ...patch, id: state.jobs[i].id });
+  if (!merged) return { ok: false, error: 'A prompt is required.' };
+  state.jobs[i] = merged;
+  save(state);
+  return { ok: true, job: merged };
+}
+
+function remove(id) {
+  const state = load();
+  const before = state.jobs.length;
+  state.jobs = state.jobs.filter(j => j.id !== id);
+  if (state.jobs.length === before) return { ok: false, error: `No automation '${id}'.` };
+  save(state);
+  return { ok: true, removed: id };
+}
+
+/** Record a finished run: this is what makes the tick idempotent. */
+function markRun(id, result = {}) {
+  const state = load();
+  const job = state.jobs.find(j => j.id === id);
+  if (!job) return null;
+  job.lastRunAt = new Date().toISOString();
+  job.runCount = Number(job.runCount || 0) + 1;
+  job.lastResult = {
+    ok: result.ok !== false,
+    chars: Number(result.chars) || 0,
+    excerpt: String(result.excerpt || '').replace(/\s+/g, ' ').slice(0, 200),
+    error: result.error ? String(result.error).slice(0, 200) : null,
+    at: job.lastRunAt
+  };
+  save(state);
+  return job;
+}
+
+module.exports = { list, create, update, remove, markRun, dueIn, isDue, normalise, FILE, MAX_JOBS };

package/src/daemon/core/budget.js

@@ -0,0 +1,145 @@
+// src/daemon/core/budget.js — daily spend/token guard.
+// Money is enforced only when per-1k prices are configured; tokens are always enforced.
+const fs = require('fs');
+const path = require('path');
+
+// LIBER_BUDGET_FILE lets tests run against a scratch file instead of the live counter.
+const FILE = () => process.env.LIBER_BUDGET_FILE || path.resolve(process.cwd(), '.liber', 'budget.json');
+
+let state = null;
+
+function today() {
+  return new Date().toISOString().slice(0, 10);
+}
+
+function emptyState() {
+  return { date: today(), prompt_tokens: 0, completion_tokens: 0, total_tokens: 0, cost_usd: 0, calls: 0 };
+}
+
+function load() {
+  if (state) return state;
+  try {
+    const parsed = JSON.parse(fs.readFileSync(FILE(), 'utf8'));
+    state = parsed && parsed.date === today() ? { ...emptyState(), ...parsed } : emptyState();
+  } catch {
+    state = emptyState();
+  }
+  return state;
+}
+
+function save() {
+  try {
+    fs.mkdirSync(path.dirname(FILE()), { recursive: true });
+    fs.writeFileSync(FILE(), JSON.stringify(load(), null, 2), 'utf8');
+  } catch {
+    // budget persistence must never break a turn
+  }
+}
+
+function reset() {
+  state = emptyState();
+  save();
+}
+
+/** Drop the in-memory copy so the next read comes from disk. */
+function reload() {
+  state = null;
+  return load();
+}
+
+/** A limit of 0 means "no limit", which is what the settings panel promises. */
+function limitOf(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return null;
+  return n;
+}
+
+function priceOf(engineConfig = {}) {
+  const inPrice = Number(engineConfig.price_in_per_1k);
+  const outPrice = Number(engineConfig.price_out_per_1k);
+  return Number.isFinite(inPrice) && Number.isFinite(outPrice)
+    ? { inPrice, outPrice }
+    : null;
+}
+
+function costOf(usage, engineConfig) {
+  const price = priceOf(engineConfig);
+  if (!price || !usage) return 0;
+  return (
+    (Number(usage.prompt_tokens || 0) / 1000) * price.inPrice +
+    (Number(usage.completion_tokens || 0) / 1000) * price.outPrice
+  );
+}
+
+/**
+ * @returns {{allowed:boolean, reason?:string, spent_usd:number, spent_tokens:number, limit_usd:number|null, limit_tokens:number|null}}
+ */
+function check(limits = {}, engineConfig = {}) {
+  const s = load();
+  const limitUsd = limitOf(limits.max_cost_per_day);
+  const limitTokens = limitOf(limits.max_tokens_per_day);
+  const priced = !!priceOf(engineConfig);
+
+  let allowed = true;
+  let reason;
+
+  if (limitTokens !== null && s.total_tokens >= limitTokens) {
+    allowed = false;
+    reason = `Daily token budget exhausted (${s.total_tokens}/${limitTokens} tokens). Raise limits.max_tokens_per_day, set it to 0 for no limit, or reset today's counter in Settings → Advanced → Budget.`;
+  }
+  if (priced && limitUsd !== null && s.cost_usd >= limitUsd) {
+    allowed = false;
+    reason = `Daily cost budget exhausted ($${s.cost_usd.toFixed(4)}/$${limitUsd.toFixed(2)}). Raise limits.max_cost_per_day, set it to 0 for no limit, or reset today's counter.`;
+  }
+
+  return {
+    allowed,
+    reason,
+    spent_usd: s.cost_usd,
+    spent_tokens: s.total_tokens,
+    limit_usd: priced ? limitUsd : null,
+    limit_tokens: limitTokens
+  };
+}
+
+/** Everything the UI needs to show headroom before a turn is refused. */
+function summary(limits = {}, engineConfig = {}) {
+  const s = load();
+  const r = check(limits, engineConfig);
+  const remaining = r.limit_tokens === null ? null : Math.max(0, r.limit_tokens - s.total_tokens);
+  const percent = r.limit_tokens === null || r.limit_tokens === 0
+    ? null
+    : Math.min(100, Math.round((s.total_tokens / r.limit_tokens) * 100));
+  return {
+    date: s.date,
+    calls: s.calls,
+    spent_tokens: s.total_tokens,
+    spent_usd: Number(s.cost_usd.toFixed(6)),
+    limit_tokens: r.limit_tokens,
+    limit_usd: r.limit_usd,
+    remaining_tokens: remaining,
+    percent_used: percent,
+    allowed: r.allowed,
+    reason: r.reason || null
+  };
+}
+
+function record(usage, engineConfig = {}) {
+  if (!usage) return load();
+  const s = load();
+  const prompt = Number(usage.prompt_tokens || 0);
+  const completion = Number(usage.completion_tokens || 0);
+  s.prompt_tokens += prompt;
+  s.completion_tokens += completion;
+  s.total_tokens += Number(usage.total_tokens || prompt + completion);
+  s.cost_usd += costOf(usage, engineConfig);
+  s.calls += 1;
+  save();
+  return s;
+}
+
+function snapshot() {
+  return { ...load() };
+}
+
+module.exports = { check, summary, record, reset, reload, snapshot, costOf, priceOf, today };

package/src/daemon/core/circuit-breaker.js

@@ -0,0 +1,31 @@
+// src/daemon/core/circuit-breaker.js
+class CircuitBreaker {
+  constructor(maxIterations = 5) {
+    this.defaultLimit = maxIterations;
+    this.limits = new Map();   // agentId -> max iterations
+    this.counters = new Map(); // agentId -> count
+  }
+
+  configureLimit(agentId, maxIterations) {
+    if (Number.isFinite(maxIterations) && maxIterations > 0) {
+      this.limits.set(agentId, maxIterations);
+    }
+  }
+
+  increment(agentId) {
+    const count = (this.counters.get(agentId) || 0) + 1;
+    this.counters.set(agentId, count);
+    return count;
+  }
+
+  reset(agentId) {
+    this.counters.delete(agentId);
+  }
+
+  isBroken(agentId) {
+    const limit = this.limits.get(agentId) || this.defaultLimit;
+    return (this.counters.get(agentId) || 0) >= limit;
+  }
+}
+
+module.exports = new CircuitBreaker();