gigaclaw 1.4.0

package/lib/cron.js

@@ -0,0 +1,246 @@
+import cron from 'node-cron';
+import fs from 'fs';
+import path from 'path';
+import { cronsFile, cronDir } from './paths.js';
+import { executeAction } from './actions.js';
+
+function getInstalledVersion() {
+  const pkgPath = path.join(process.cwd(), 'node_modules', 'gigaclaw', 'package.json');
+  return JSON.parse(fs.readFileSync(pkgPath, 'utf8')).version;
+}
+
+// In-memory flag for available update (read by sidebar, written by cron)
+let _updateAvailable = null;
+
+/**
+ * Get the in-memory update-available version (or null).
+ * @returns {string|null}
+ */
+function getUpdateAvailable() {
+  return _updateAvailable;
+}
+
+/**
+ * Set the in-memory update-available version.
+ * @param {string|null} v
+ */
+function setUpdateAvailable(v) {
+  _updateAvailable = v;
+}
+
+/**
+ * Compare two semver strings numerically.
+ * @param {string} candidate - e.g. "1.2.40"
+ * @param {string} baseline  - e.g. "1.2.39"
+ * @returns {boolean} true if candidate > baseline
+ */
+function isVersionNewer(candidate, baseline) {
+  // Pre-release candidate is never "newer" for upgrade purposes
+  if (candidate.includes('-')) return false;
+
+  const a = candidate.split('.').map(Number);
+  const b = baseline.replace(/-.*$/, '').split('.').map(Number);
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    const av = a[i] || 0;
+    const bv = b[i] || 0;
+    if (av > bv) return true;
+    if (av < bv) return false;
+  }
+  return false;
+}
+
+/**
+ * Check if a version string is a pre-release (contains '-').
+ * @param {string} v
+ * @returns {boolean}
+ */
+function isPrerelease(v) {
+  return v.includes('-');
+}
+
+/**
+ * Compare two semver strings (including pre-release).
+ * Returns positive if a > b, negative if a < b, 0 if equal.
+ * Ordering: 1.2.71-beta.0 < 1.2.71-beta.1 < 1.2.71 (stable) < 1.2.72-beta.0
+ * @param {string} a
+ * @param {string} b
+ * @returns {number}
+ */
+function compareVersions(a, b) {
+  const [aCore, aPre] = a.split('-');
+  const [bCore, bPre] = b.split('-');
+
+  const aParts = aCore.split('.').map(Number);
+  const bParts = bCore.split('.').map(Number);
+
+  // Compare major.minor.patch
+  for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+    const av = aParts[i] || 0;
+    const bv = bParts[i] || 0;
+    if (av !== bv) return av - bv;
+  }
+
+  // Same core version: stable beats pre-release
+  if (!aPre && bPre) return 1;   // a is stable, b is pre-release
+  if (aPre && !bPre) return -1;  // a is pre-release, b is stable
+  if (!aPre && !bPre) return 0;  // both stable, same core
+
+  // Both pre-release with same core: compare pre-release number
+  const aNum = parseInt(aPre.split('.').pop(), 10) || 0;
+  const bNum = parseInt(bPre.split('.').pop(), 10) || 0;
+  return aNum - bNum;
+}
+
+/**
+ * Fetch release notes from GitHub for the target version.
+ * @param {string} target - Target upgrade version
+ */
+async function fetchAndStoreReleaseNotes(target) {
+  try {
+    const ghRes = await fetch(
+      `https://api.github.com/repos/gignaati/gigaclaw/releases/tags/v${target}`
+    );
+    if (!ghRes.ok) return;
+    const release = await ghRes.json();
+    if (release.body) {
+      const { setReleaseNotes } = await import('./db/update-check.js');
+      setReleaseNotes(release.body);
+    }
+  } catch {}
+}
+
+/**
+ * Check npm registry for a newer version of gigaclaw.
+ */
+async function runVersionCheck() {
+  try {
+    const installed = getInstalledVersion();
+
+    if (isPrerelease(installed)) {
+      // Beta path: check both stable and beta dist-tags
+      const results = await Promise.allSettled([
+        fetch('https://registry.npmjs.org/gigaclaw/latest'),
+        fetch('https://registry.npmjs.org/gigaclaw/beta'),
+      ]);
+
+      const candidates = [];
+      for (const result of results) {
+        if (result.status !== 'fulfilled') continue;
+        const res = result.value;
+        if (!res.ok) continue;
+        const data = await res.json();
+        if (data.version && compareVersions(data.version, installed) > 0) {
+          candidates.push(data.version);
+        }
+      }
+
+      if (candidates.length > 0) {
+        // Pick the best candidate (highest version)
+        candidates.sort(compareVersions);
+        const best = candidates[candidates.length - 1];
+        console.log(`[version check] update available: ${installed} → ${best}`);
+        setUpdateAvailable(best);
+        const { setAvailableVersion } = await import('./db/update-check.js');
+        setAvailableVersion(best);
+        await fetchAndStoreReleaseNotes(best);
+      } else {
+        setUpdateAvailable(null);
+        const { clearAvailableVersion, clearReleaseNotes } = await import('./db/update-check.js');
+        clearAvailableVersion();
+        clearReleaseNotes();
+      }
+    } else {
+      // Stable path: existing logic, untouched
+      const res = await fetch('https://registry.npmjs.org/gigaclaw/latest');
+      if (!res.ok) {
+        console.warn(`[version check] npm registry returned ${res.status}`);
+        return;
+      }
+      const data = await res.json();
+      const latest = data.version;
+
+      if (isVersionNewer(latest, installed)) {
+        console.log(`[version check] update available: ${installed} → ${latest}`);
+        setUpdateAvailable(latest);
+        // Persist to DB
+        const { setAvailableVersion } = await import('./db/update-check.js');
+        setAvailableVersion(latest);
+        await fetchAndStoreReleaseNotes(latest);
+      } else {
+        setUpdateAvailable(null);
+        // Clear DB
+        const { clearAvailableVersion, clearReleaseNotes } = await import('./db/update-check.js');
+        clearAvailableVersion();
+        clearReleaseNotes();
+      }
+    }
+  } catch (err) {
+    console.warn(`[version check] failed: ${err.message}`);
+    // Leave existing flag untouched on error
+  }
+}
+
+/**
+ * Start built-in crons (version check). Called from instrumentation.
+ */
+function startBuiltinCrons() {
+  // Schedule hourly
+  cron.schedule('0 * * * *', runVersionCheck);
+  // Run once immediately
+  runVersionCheck();
+}
+
+/**
+ * Load and schedule crons from CRONS.json
+ * @returns {Array} - Array of scheduled cron tasks
+ */
+function loadCrons() {
+  const cronFile = cronsFile;
+
+  console.log('\n--- Cron Jobs ---');
+
+  if (!fs.existsSync(cronFile)) {
+    console.log('No CRONS.json found');
+    console.log('-----------------\n');
+    return [];
+  }
+
+  const crons = JSON.parse(fs.readFileSync(cronFile, 'utf8'));
+  const tasks = [];
+
+  for (const cronEntry of crons) {
+    const { name, schedule, type = 'agent', enabled } = cronEntry;
+    if (enabled === false) continue;
+
+    if (!cron.validate(schedule)) {
+      console.error(`Invalid schedule for "${name}": ${schedule}`);
+      continue;
+    }
+
+    const task = cron.schedule(schedule, async () => {
+      try {
+        const result = await executeAction(cronEntry, { cwd: cronDir });
+        console.log(`[CRON] ${name}: ${result || 'ran'}`);
+        console.log(`[CRON] ${name}: completed!`);
+      } catch (err) {
+        console.error(`[CRON] ${name}: error - ${err.message}`);
+      }
+    });
+
+    tasks.push({ name, schedule, type, task });
+  }
+
+  if (tasks.length === 0) {
+    console.log('No active cron jobs');
+  } else {
+    for (const { name, schedule, type } of tasks) {
+      console.log(`  ${name}: ${schedule} (${type})`);
+    }
+  }
+
+  console.log('-----------------\n');
+
+  return tasks;
+}
+
+export { loadCrons, startBuiltinCrons, getUpdateAvailable, setUpdateAvailable, getInstalledVersion, isPrerelease };

package/lib/db/api-keys.js

@@ -0,0 +1,163 @@
+import { randomUUID, randomBytes, createHash, timingSafeEqual } from 'crypto';
+import { eq } from 'drizzle-orm';
+import { getDb } from './index.js';
+import { settings } from './schema.js';
+
+const KEY_PREFIX = 'tpb_';
+
+// In-memory cache: { key_hash, id } or null
+let _cache = null;
+
+/**
+ * Generate a new API key: tpb_ + 64 hex chars (32 random bytes).
+ * @returns {string}
+ */
+export function generateApiKey() {
+  return KEY_PREFIX + randomBytes(32).toString('hex');
+}
+
+/**
+ * Hash an API key using SHA-256.
+ * @param {string} key - Raw API key
+ * @returns {string} Hex digest
+ */
+export function hashApiKey(key) {
+  return createHash('sha256').update(key).digest('hex');
+}
+
+/**
+ * Lazy-load the API key hash into the in-memory cache.
+ */
+function _ensureCache() {
+  if (_cache !== null) return _cache;
+
+  const db = getDb();
+  const row = db
+    .select()
+    .from(settings)
+    .where(eq(settings.type, 'api_key'))
+    .get();
+
+  if (row) {
+    const parsed = JSON.parse(row.value);
+    _cache = { keyHash: parsed.key_hash, id: row.id };
+  } else {
+    _cache = false; // no key exists — distinguish from "not loaded yet"
+  }
+  return _cache;
+}
+
+/**
+ * Clear the in-memory cache (call after create/delete).
+ */
+export function invalidateApiKeyCache() {
+  _cache = null;
+}
+
+/**
+ * Create (or replace) the API key. Deletes any existing key first.
+ * @param {string} createdBy - User ID
+ * @returns {{ key: string, record: object }}
+ */
+export function createApiKeyRecord(createdBy) {
+  const db = getDb();
+
+  // Delete any existing API key
+  db.delete(settings).where(eq(settings.type, 'api_key')).run();
+
+  const key = generateApiKey();
+  const keyHash = hashApiKey(key);
+  const keyPrefix = key.slice(0, 8); // "tpb_" + first 4 hex chars
+  const now = Date.now();
+
+  const record = {
+    id: randomUUID(),
+    type: 'api_key',
+    key: 'api_key',
+    value: JSON.stringify({ key_prefix: keyPrefix, key_hash: keyHash, last_used_at: null }),
+    createdBy,
+    createdAt: now,
+    updatedAt: now,
+  };
+
+  db.insert(settings).values(record).run();
+  invalidateApiKeyCache();
+
+  return {
+    key,
+    record: {
+      id: record.id,
+      keyPrefix,
+      createdAt: now,
+      lastUsedAt: null,
+    },
+  };
+}
+
+/**
+ * Get the current API key metadata (no hash).
+ * @returns {object|null}
+ */
+export function getApiKey() {
+  const db = getDb();
+  const row = db
+    .select()
+    .from(settings)
+    .where(eq(settings.type, 'api_key'))
+    .get();
+
+  if (!row) return null;
+
+  const parsed = JSON.parse(row.value);
+  return {
+    id: row.id,
+    keyPrefix: parsed.key_prefix,
+    createdAt: row.createdAt,
+    lastUsedAt: parsed.last_used_at,
+  };
+}
+
+/**
+ * Delete the API key.
+ */
+export function deleteApiKey() {
+  const db = getDb();
+  db.delete(settings).where(eq(settings.type, 'api_key')).run();
+  invalidateApiKeyCache();
+}
+
+/**
+ * Verify a raw API key against the cached hash.
+ * @param {string} rawKey - Raw API key from request header
+ * @returns {object|null} Record if valid, null otherwise
+ */
+export function verifyApiKey(rawKey) {
+  if (!rawKey || !rawKey.startsWith(KEY_PREFIX)) return null;
+
+  const keyHash = hashApiKey(rawKey);
+  const cached = _ensureCache();
+
+  if (!cached) return null;
+  const a = Buffer.from(cached.keyHash, 'hex');
+  const b = Buffer.from(keyHash, 'hex');
+  if (a.length !== b.length || !timingSafeEqual(a, b)) return null;
+
+  // Update last_used_at in background (non-blocking)
+  try {
+    const db = getDb();
+    const now = Date.now();
+    const row = db.select().from(settings).where(eq(settings.id, cached.id)).get();
+    if (row) {
+      const parsed = JSON.parse(row.value);
+      parsed.last_used_at = now;
+      db.update(settings)
+        .set({ value: JSON.stringify(parsed), updatedAt: now })
+        .where(eq(settings.id, cached.id))
+        .run();
+    }
+  } catch {
+    // Non-fatal: last_used_at is informational
+  }
+
+  return cached;
+}

package/lib/db/chats.js

@@ -0,0 +1,168 @@
+import { randomUUID } from 'crypto';
+import { eq, desc, asc } from 'drizzle-orm';
+import { getDb } from './index.js';
+import { chats, messages } from './schema.js';
+
+/**
+ * Create a new chat.
+ * @param {string} userId
+ * @param {string} [title='New Chat']
+ * @param {string} [id] - Optional chat ID (UUID). Generated if not provided.
+ * @returns {object} The created chat
+ */
+export function createChat(userId, title = 'New Chat', id = null) {
+  const db = getDb();
+  const now = Date.now();
+  const chat = {
+    id: id || randomUUID(),
+    userId,
+    title,
+    createdAt: now,
+    updatedAt: now,
+  };
+  db.insert(chats).values(chat).run();
+  return chat;
+}
+
+/**
+ * Get all chats for a user, ordered by most recently updated.
+ * @param {string} userId
+ * @returns {object[]}
+ */
+export function getChatsByUser(userId) {
+  const db = getDb();
+  return db
+    .select()
+    .from(chats)
+    .where(eq(chats.userId, userId))
+    .orderBy(desc(chats.updatedAt))
+    .all();
+}
+
+/**
+ * Get a single chat by ID.
+ * @param {string} chatId
+ * @returns {object|undefined}
+ */
+export function getChatById(chatId) {
+  const db = getDb();
+  return db.select().from(chats).where(eq(chats.id, chatId)).get();
+}
+
+/**
+ * Get a single chat by its code_workspace_id.
+ * @param {string} workspaceId
+ * @returns {object|undefined}
+ */
+export function getChatByWorkspaceId(workspaceId) {
+  const db = getDb();
+  return db.select().from(chats).where(eq(chats.codeWorkspaceId, workspaceId)).get();
+}
+
+/**
+ * Update a chat's title.
+ * @param {string} chatId
+ * @param {string} title
+ */
+export function updateChatTitle(chatId, title) {
+  const db = getDb();
+  db.update(chats)
+    .set({ title, updatedAt: Date.now() })
+    .where(eq(chats.id, chatId))
+    .run();
+}
+
+/**
+ * Toggle a chat's starred status.
+ * @param {string} chatId
+ * @returns {number} The new starred value (0 or 1)
+ */
+export function toggleChatStarred(chatId) {
+  const db = getDb();
+  const chat = db.select({ starred: chats.starred }).from(chats).where(eq(chats.id, chatId)).get();
+  const newValue = chat?.starred ? 0 : 1;
+  db.update(chats)
+    .set({ starred: newValue })
+    .where(eq(chats.id, chatId))
+    .run();
+  return newValue;
+}
+
+/**
+ * Delete a chat and all its messages.
+ * @param {string} chatId
+ */
+export function deleteChat(chatId) {
+  const db = getDb();
+  db.delete(messages).where(eq(messages.chatId, chatId)).run();
+  db.delete(chats).where(eq(chats.id, chatId)).run();
+}
+
+/**
+ * Delete all chats and messages for a user.
+ * @param {string} userId
+ */
+export function deleteAllChatsByUser(userId) {
+  const db = getDb();
+  const userChats = db
+    .select({ id: chats.id })
+    .from(chats)
+    .where(eq(chats.userId, userId))
+    .all();
+
+  for (const chat of userChats) {
+    db.delete(messages).where(eq(messages.chatId, chat.id)).run();
+  }
+  db.delete(chats).where(eq(chats.userId, userId)).run();
+}
+
+/**
+ * Get all messages for a chat, ordered by creation time.
+ * @param {string} chatId
+ * @returns {object[]}
+ */
+export function getMessagesByChatId(chatId) {
+  const db = getDb();
+  return db
+    .select()
+    .from(messages)
+    .where(eq(messages.chatId, chatId))
+    .orderBy(asc(messages.createdAt))
+    .all();
+}
+
+/**
+ * Link a chat to a code workspace.
+ * @param {string} chatId
+ * @param {string} workspaceId
+ */
+export function linkChatToWorkspace(chatId, workspaceId) {
+  const db = getDb();
+  db.update(chats)
+    .set({ codeWorkspaceId: workspaceId, updatedAt: Date.now() })
+    .where(eq(chats.id, chatId))
+    .run();
+}
+
+/**
+ * Save a message to a chat. Also updates the chat's updatedAt timestamp.
+ * @param {string} chatId
+ * @param {string} role - 'user' or 'assistant'
+ * @param {string} content
+ * @param {string} [id] - Optional message ID
+ * @returns {object} The created message
+ */
+export function saveMessage(chatId, role, content, id = null) {
+  const db = getDb();
+  const now = Date.now();
+  const message = {
+    id: id || randomUUID(),
+    chatId,
+    role,
+    content,
+    createdAt: now,
+  };
+  db.insert(messages).values(message).run();
+  db.update(chats).set({ updatedAt: now }).where(eq(chats.id, chatId)).run();
+  return message;
+}

package/lib/db/code-workspaces.js

@@ -0,0 +1,110 @@
+import { randomUUID } from 'crypto';
+import { eq, desc } from 'drizzle-orm';
+import { getDb } from './index.js';
+import { codeWorkspaces } from './schema.js';
+
+/**
+ * Create a new code workspace.
+ * @param {string} userId
+ * @param {object} options
+ * @param {string} [options.containerName] - Docker container DNS name (null until launched)
+ * @param {string} [options.repo] - GitHub repo full name (e.g. "owner/repo")
+ * @param {string} [options.branch] - Git branch name
+ * @param {string} [options.title='Code Workspace']
+ * @param {string} [options.codingAgent='claude-code'] - Coding agent identifier
+ * @param {string} [options.id] - Optional ID (UUID). Generated if not provided.
+ * @returns {object} The created workspace
+ */
+export function createCodeWorkspace(userId, { containerName = null, repo = null, branch = null, title = 'Code Workspace', codingAgent = 'claude-code', id = null } = {}) {
+  const db = getDb();
+  const now = Date.now();
+  const workspace = {
+    id: id || randomUUID(),
+    userId,
+    containerName,
+    repo,
+    branch,
+    title,
+    codingAgent,
+    createdAt: now,
+    updatedAt: now,
+  };
+  db.insert(codeWorkspaces).values(workspace).run();
+  return workspace;
+}
+
+/**
+ * Update the container name on an existing workspace (when Docker launches).
+ * @param {string} id - Workspace ID
+ * @param {string} containerName - Docker container name
+ */
+export function updateContainerName(id, containerName) {
+  const db = getDb();
+  db.update(codeWorkspaces)
+    .set({ containerName, updatedAt: Date.now() })
+    .where(eq(codeWorkspaces.id, id))
+    .run();
+}
+
+/**
+ * Get a single code workspace by ID.
+ * @param {string} id
+ * @returns {object|undefined}
+ */
+export function getCodeWorkspaceById(id) {
+  const db = getDb();
+  return db.select().from(codeWorkspaces).where(eq(codeWorkspaces.id, id)).get();
+}
+
+/**
+ * Get all code workspaces for a user, ordered by most recently updated.
+ * @param {string} userId
+ * @returns {object[]}
+ */
+export function getCodeWorkspacesByUser(userId) {
+  const db = getDb();
+  return db
+    .select()
+    .from(codeWorkspaces)
+    .where(eq(codeWorkspaces.userId, userId))
+    .orderBy(desc(codeWorkspaces.updatedAt))
+    .all();
+}
+
+/**
+ * Update a code workspace's title.
+ * @param {string} id
+ * @param {string} title
+ */
+export function updateCodeWorkspaceTitle(id, title) {
+  const db = getDb();
+  db.update(codeWorkspaces)
+    .set({ title, updatedAt: Date.now() })
+    .where(eq(codeWorkspaces.id, id))
+    .run();
+}
+
+/**
+ * Toggle a code workspace's starred status.
+ * @param {string} id
+ * @returns {number} The new starred value (0 or 1)
+ */
+export function toggleCodeWorkspaceStarred(id) {
+  const db = getDb();
+  const workspace = db.select({ starred: codeWorkspaces.starred }).from(codeWorkspaces).where(eq(codeWorkspaces.id, id)).get();
+  const newValue = workspace?.starred ? 0 : 1;
+  db.update(codeWorkspaces)
+    .set({ starred: newValue })
+    .where(eq(codeWorkspaces.id, id))
+    .run();
+  return newValue;
+}
+
+/**
+ * Delete a code workspace.
+ * @param {string} id
+ */
+export function deleteCodeWorkspace(id) {
+  const db = getDb();
+  db.delete(codeWorkspaces).where(eq(codeWorkspaces.id, id)).run();
+}