gigaclaw 1.4.0

package/lib/db/index.js

@@ -0,0 +1,52 @@
+import fs from 'fs';
+import path from 'path';
+import Database from 'better-sqlite3';
+import { drizzle } from 'drizzle-orm/better-sqlite3';
+import { migrate } from 'drizzle-orm/better-sqlite3/migrator';
+import { gigaclawDb, dataDir, PROJECT_ROOT } from '../paths.js';
+import * as schema from './schema.js';
+
+let _db = null;
+
+/**
+ * Get or create the Drizzle database instance (lazy singleton).
+ * @returns {import('drizzle-orm/better-sqlite3').BetterSQLite3Database}
+ */
+export function getDb() {
+  if (!_db) {
+    // Ensure data directory exists
+    if (!fs.existsSync(dataDir)) {
+      fs.mkdirSync(dataDir, { recursive: true });
+    }
+    const sqlite = new Database(gigaclawDb);
+    sqlite.pragma('journal_mode = WAL');
+    _db = drizzle(sqlite, { schema });
+  }
+  return _db;
+}
+
+/**
+ * Initialize the database — apply pending migrations.
+ * Called from instrumentation.js at server startup.
+ * Uses Drizzle Kit migrations from the package's drizzle/ folder.
+ */
+export function initDatabase() {
+  if (!fs.existsSync(dataDir)) {
+    fs.mkdirSync(dataDir, { recursive: true });
+  }
+
+  const sqlite = new Database(gigaclawDb);
+  sqlite.pragma('journal_mode = WAL');
+  const db = drizzle(sqlite, { schema });
+
+  // Resolve migrations folder from the installed package.
+  // import.meta.url doesn't survive webpack bundling, so resolve from PROJECT_ROOT.
+  const migrationsFolder = path.join(PROJECT_ROOT, 'node_modules', 'gigaclaw', 'drizzle');
+
+  migrate(db, { migrationsFolder });
+
+  sqlite.close();
+
+  // Force re-creation of drizzle instance on next getDb() call
+  _db = null;
+}

package/lib/db/notifications.js

@@ -0,0 +1,99 @@
+import { randomUUID } from 'crypto';
+import { eq, desc, sql } from 'drizzle-orm';
+import { getDb } from './index.js';
+import { notifications, subscriptions } from './schema.js';
+
+/**
+ * Create a notification, then distribute to all subscribers.
+ * @param {string} notificationText - Human-readable notification text
+ * @param {object} payload - Raw webhook payload
+ * @returns {object} The created notification
+ */
+export async function createNotification(notificationText, payload) {
+  const db = getDb();
+  const now = Date.now();
+  const row = {
+    id: randomUUID(),
+    notification: notificationText,
+    payload: JSON.stringify(payload),
+    read: 0,
+    createdAt: now,
+  };
+  db.insert(notifications).values(row).run();
+
+  // Distribute to subscribers (fire-and-forget)
+  distributeNotification(notificationText).catch((err) => {
+    console.error('Failed to distribute notification:', err);
+  });
+
+  return row;
+}
+
+/**
+ * Get all notifications, newest first.
+ * @returns {object[]}
+ */
+export function getNotifications() {
+  const db = getDb();
+  return db
+    .select()
+    .from(notifications)
+    .orderBy(desc(notifications.createdAt))
+    .all();
+}
+
+/**
+ * Get count of unread notifications.
+ * @returns {number}
+ */
+export function getUnreadCount() {
+  const db = getDb();
+  const result = db
+    .select({ count: sql`count(*)` })
+    .from(notifications)
+    .where(eq(notifications.read, 0))
+    .get();
+  return result?.count ?? 0;
+}
+
+/**
+ * Mark all notifications as read.
+ */
+export function markAllRead() {
+  const db = getDb();
+  db.update(notifications)
+    .set({ read: 1 })
+    .where(eq(notifications.read, 0))
+    .run();
+}
+
+/**
+ * Get all subscriptions.
+ * @returns {object[]}
+ */
+export function getSubscriptions() {
+  const db = getDb();
+  return db.select().from(subscriptions).all();
+}
+
+/**
+ * Distribute a notification to all subscribers.
+ * @param {string} notificationText - The notification message
+ */
+async function distributeNotification(notificationText) {
+  const subs = getSubscriptions();
+  if (!subs.length) return;
+
+  for (const sub of subs) {
+    try {
+      if (sub.platform === 'telegram') {
+        const botToken = process.env.TELEGRAM_BOT_TOKEN;
+        if (!botToken) continue;
+        const { sendMessage } = await import('../tools/telegram.js');
+        await sendMessage(botToken, sub.channelId, notificationText);
+      }
+    } catch (err) {
+      console.error(`Failed to send to ${sub.platform}/${sub.channelId}:`, err);
+    }
+  }
+}

package/lib/db/schema.js

@@ -0,0 +1,66 @@
+import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core';
+
+export const users = sqliteTable('users', {
+  id: text('id').primaryKey(),
+  email: text('email').notNull().unique(),
+  passwordHash: text('password_hash').notNull(),
+  role: text('role').notNull().default('admin'),
+  createdAt: integer('created_at').notNull(),
+  updatedAt: integer('updated_at').notNull(),
+});
+
+export const chats = sqliteTable('chats', {
+  id: text('id').primaryKey(),
+  userId: text('user_id').notNull(),
+  title: text('title').notNull().default('New Chat'),
+  starred: integer('starred').notNull().default(0),
+  codeWorkspaceId: text('code_workspace_id'),
+  createdAt: integer('created_at').notNull(),
+  updatedAt: integer('updated_at').notNull(),
+});
+
+export const messages = sqliteTable('messages', {
+  id: text('id').primaryKey(),
+  chatId: text('chat_id').notNull(),
+  role: text('role').notNull(),
+  content: text('content').notNull(),
+  createdAt: integer('created_at').notNull(),
+});
+
+export const notifications = sqliteTable('notifications', {
+  id: text('id').primaryKey(),
+  notification: text('notification').notNull(),
+  payload: text('payload').notNull(),
+  read: integer('read').notNull().default(0),
+  createdAt: integer('created_at').notNull(),
+});
+
+export const subscriptions = sqliteTable('subscriptions', {
+  id: text('id').primaryKey(),
+  platform: text('platform').notNull(),
+  channelId: text('channel_id').notNull(),
+  createdAt: integer('created_at').notNull(),
+});
+
+export const codeWorkspaces = sqliteTable('code_workspaces', {
+  id: text('id').primaryKey(),
+  userId: text('user_id').notNull(),
+  containerName: text('container_name').unique(),
+  repo: text('repo'),
+  branch: text('branch'),
+  title: text('title').notNull().default('Code Workspace'),
+  codingAgent: text('coding_agent').notNull().default('claude-code'),
+  starred: integer('starred').notNull().default(0),
+  createdAt: integer('created_at').notNull(),
+  updatedAt: integer('updated_at').notNull(),
+});
+
+export const settings = sqliteTable('settings', {
+  id: text('id').primaryKey(),
+  type: text('type').notNull(),
+  key: text('key').notNull(),
+  value: text('value').notNull(),
+  createdBy: text('created_by'),
+  createdAt: integer('created_at').notNull(),
+  updatedAt: integer('updated_at').notNull(),
+});

package/lib/db/update-check.js

@@ -0,0 +1,96 @@
+import { randomUUID } from 'crypto';
+import { eq, and } from 'drizzle-orm';
+import { getDb } from './index.js';
+import { settings } from './schema.js';
+
+/**
+ * Get the stored available version from the DB.
+ * @returns {string|null}
+ */
+export function getAvailableVersion() {
+  const db = getDb();
+  const row = db
+    .select()
+    .from(settings)
+    .where(and(eq(settings.type, 'update'), eq(settings.key, 'available_version')))
+    .get();
+
+  return row ? row.value : null;
+}
+
+/**
+ * Set the available version in the DB (delete + insert upsert).
+ * @param {string} version
+ */
+export function setAvailableVersion(version) {
+  const db = getDb();
+  db.delete(settings)
+    .where(and(eq(settings.type, 'update'), eq(settings.key, 'available_version')))
+    .run();
+
+  const now = Date.now();
+  db.insert(settings).values({
+    id: randomUUID(),
+    type: 'update',
+    key: 'available_version',
+    value: version,
+    createdAt: now,
+    updatedAt: now,
+  }).run();
+}
+
+/**
+ * Clear the available version from the DB.
+ */
+export function clearAvailableVersion() {
+  const db = getDb();
+  db.delete(settings)
+    .where(and(eq(settings.type, 'update'), eq(settings.key, 'available_version')))
+    .run();
+}
+
+/**
+ * Get the stored release notes from the DB.
+ * @returns {string|null}
+ */
+export function getReleaseNotes() {
+  const db = getDb();
+  const row = db
+    .select()
+    .from(settings)
+    .where(and(eq(settings.type, 'update'), eq(settings.key, 'release_notes')))
+    .get();
+
+  return row ? row.value : null;
+}
+
+/**
+ * Set the release notes in the DB (delete + insert upsert).
+ * @param {string} notes
+ */
+export function setReleaseNotes(notes) {
+  const db = getDb();
+  db.delete(settings)
+    .where(and(eq(settings.type, 'update'), eq(settings.key, 'release_notes')))
+    .run();
+
+  const now = Date.now();
+  db.insert(settings).values({
+    id: randomUUID(),
+    type: 'update',
+    key: 'release_notes',
+    value: notes,
+    createdAt: now,
+    updatedAt: now,
+  }).run();
+}
+
+/**
+ * Clear the release notes from the DB.
+ */
+export function clearReleaseNotes() {
+  const db = getDb();
+  db.delete(settings)
+    .where(and(eq(settings.type, 'update'), eq(settings.key, 'release_notes')))
+    .run();
+}

package/lib/db/users.js

@@ -0,0 +1,89 @@
+import { randomUUID } from 'crypto';
+import { hashSync, genSaltSync, compare } from 'bcrypt-ts';
+import { eq, sql } from 'drizzle-orm';
+import { getDb } from './index.js';
+import { users } from './schema.js';
+
+/**
+ * Get the total number of users.
+ * Used to detect first-time setup (no users = needs setup).
+ * @returns {number}
+ */
+export function getUserCount() {
+  const db = getDb();
+  const result = db.select({ count: sql`count(*)` }).from(users).get();
+  return result?.count ?? 0;
+}
+
+/**
+ * Find a user by email address.
+ * @param {string} email
+ * @returns {object|undefined}
+ */
+export function getUserByEmail(email) {
+  const db = getDb();
+  return db.select().from(users).where(eq(users.email, email.toLowerCase())).get();
+}
+
+/**
+ * Create a new user with a hashed password.
+ * @param {string} email
+ * @param {string} password - Plain text password (will be hashed)
+ * @returns {object} The created user (without password_hash)
+ */
+export async function createUser(email, password) {
+  const db = getDb();
+  const now = Date.now();
+  const passwordHash = hashSync(password, genSaltSync(10));
+
+  const user = {
+    id: randomUUID(),
+    email: email.toLowerCase(),
+    passwordHash: passwordHash,
+    role: 'admin',
+    createdAt: now,
+    updatedAt: now,
+  };
+
+  db.insert(users).values(user).run();
+
+  return { id: user.id, email: user.email, role: user.role };
+}
+
+/**
+ * Atomically create the first user (admin) if no users exist.
+ * Uses a transaction to prevent race conditions — only one caller wins.
+ * @param {string} email
+ * @param {string} password - Plain text password (will be hashed)
+ * @returns {object|null} The created user, or null if users already exist
+ */
+export function createFirstUser(email, password) {
+  const db = getDb();
+  return db.transaction((tx) => {
+    const count = tx.select({ count: sql`count(*)` }).from(users).get();
+    if (count?.count > 0) return null;
+
+    const now = Date.now();
+    const passwordHash = hashSync(password, genSaltSync(10));
+    const user = {
+      id: randomUUID(),
+      email: email.toLowerCase(),
+      passwordHash: passwordHash,
+      role: 'admin',
+      createdAt: now,
+      updatedAt: now,
+    };
+    tx.insert(users).values(user).run();
+    return { id: user.id, email: user.email, role: user.role };
+  });
+}
+
+/**
+ * Verify a password against a user's stored hash.
+ * @param {object} user - User object with password_hash field
+ * @param {string} password - Plain text password to verify
+ * @returns {Promise<boolean>}
+ */
+export async function verifyPassword(user, password) {
+  return compare(password, user.passwordHash);
+}

package/lib/paths.js

@@ -0,0 +1,42 @@
+import path from 'path';
+
+/**
+ * Central path resolver for gigaclaw.
+ * All paths resolve from process.cwd() (the user's project root).
+ */
+
+const PROJECT_ROOT = process.cwd();
+
+export {
+  PROJECT_ROOT,
+};
+
+// config/ files
+export const configDir = path.join(PROJECT_ROOT, 'config');
+export const cronsFile = path.join(PROJECT_ROOT, 'config', 'CRONS.json');
+export const triggersFile = path.join(PROJECT_ROOT, 'config', 'TRIGGERS.json');
+export const jobPlanningMd = path.join(PROJECT_ROOT, 'config', 'JOB_PLANNING.md');
+export const codePlanningMd = path.join(PROJECT_ROOT, 'config', 'CODE_PLANNING.md');
+export const jobSummaryMd = path.join(PROJECT_ROOT, 'config', 'JOB_SUMMARY.md');
+export const soulMd = path.join(PROJECT_ROOT, 'config', 'SOUL.md');
+export const claudeMd = path.join(PROJECT_ROOT, 'CLAUDE.md');
+export const skillGuidePath = path.join(PROJECT_ROOT, 'config', 'SKILL_BUILDING_GUIDE.md');
+
+// Skills directory
+export const skillsDir = path.join(PROJECT_ROOT, 'skills');
+
+// Working directories for command-type actions
+export const cronDir = path.join(PROJECT_ROOT, 'cron');
+export const triggersDir = path.join(PROJECT_ROOT, 'triggers');
+
+// Logs
+export const logsDir = path.join(PROJECT_ROOT, 'logs');
+
+// Data (SQLite memory, etc.)
+export const dataDir = path.join(PROJECT_ROOT, 'data');
+
+// Database
+export const gigaclawDb = process.env.DATABASE_PATH || path.join(PROJECT_ROOT, 'data', 'gigaclaw.sqlite');
+
+// .env
+export const envFile = path.join(PROJECT_ROOT, '.env');

package/lib/tools/create-job.js

@@ -0,0 +1,97 @@
+import { v4 as uuidv4 } from 'uuid';
+import { z } from 'zod';
+import { githubApi } from './github.js';
+import { createModel } from '../ai/model.js';
+
+/**
+ * Generate a short descriptive title for a job using the LLM.
+ * Uses structured output to avoid thinking-token leaks with extended-thinking models.
+ * @param {string} jobDescription - The full job description
+ * @returns {Promise<string>} ~10 word title
+ */
+async function generateJobTitle(jobDescription) {
+  try {
+    const model = await createModel({ maxTokens: 100 });
+    const response = await model.withStructuredOutput(z.object({ title: z.string() })).invoke([
+      ['system', 'Generate a descriptive ~10 word title for this agent job. The title should clearly describe what the job will do.'],
+      ['human', jobDescription],
+    ]);
+    return response.title.trim() || jobDescription.slice(0, 80);
+  } catch {
+    // Fallback: first line, truncated
+    const firstLine = jobDescription.split('\n').find(l => l.trim()) || jobDescription;
+    return firstLine.replace(/^#+\s*/, '').trim().split(/\s+/).slice(0, 10).join(' ');
+  }
+}
+
+/**
+ * Create a new job branch with job.config.json
+ * @param {string} jobDescription - The job description
+ * @param {Object} [options] - Optional overrides
+ * @param {string} [options.llmProvider] - LLM provider override (e.g. 'openai', 'anthropic')
+ * @param {string} [options.llmModel] - LLM model override (e.g. 'gpt-4o', 'claude-sonnet-4-5-20250929')
+ * @param {string} [options.agentBackend] - Agent backend override ('pi' or 'claude-code')
+ * @returns {Promise<{job_id: string, branch: string, title: string}>} - Job ID, branch name, and title
+ */
+async function createJob(jobDescription, options = {}) {
+  const { GH_OWNER, GH_REPO } = process.env;
+  const jobId = uuidv4();
+  const branch = `job/${jobId}`;
+  const repo = `/repos/${GH_OWNER}/${GH_REPO}`;
+
+  // Generate a short descriptive title
+  const title = await generateJobTitle(jobDescription);
+
+  // 1. Get main branch SHA and its tree SHA
+  const mainRef = await githubApi(`${repo}/git/ref/heads/main`);
+  const mainSha = mainRef.object.sha;
+  const mainCommit = await githubApi(`${repo}/git/commits/${mainSha}`);
+  const baseTreeSha = mainCommit.tree.sha;
+
+  // 2. Build job.config.json — single source of truth for job metadata
+  const config = { title, job: jobDescription };
+  if (options.llmProvider) config.llm_provider = options.llmProvider;
+  if (options.llmModel) config.llm_model = options.llmModel;
+  if (options.agentBackend) config.agent_backend = options.agentBackend;
+
+  const treeEntries = [
+    {
+      path: `logs/${jobId}/job.config.json`,
+      mode: '100644',
+      type: 'blob',
+      content: JSON.stringify(config, null, 2),
+    },
+  ];
+
+  // 3. Create tree (base_tree preserves all existing files)
+  const tree = await githubApi(`${repo}/git/trees`, {
+    method: 'POST',
+    body: JSON.stringify({
+      base_tree: baseTreeSha,
+      tree: treeEntries,
+    }),
+  });
+
+  // 4. Create a single commit with job config
+  const commit = await githubApi(`${repo}/git/commits`, {
+    method: 'POST',
+    body: JSON.stringify({
+      message: `🤖 Agent Job: ${title}`,
+      tree: tree.sha,
+      parents: [mainSha],
+    }),
+  });
+
+  // 5. Create branch pointing to the commit (triggers run-job.yml)
+  await githubApi(`${repo}/git/refs`, {
+    method: 'POST',
+    body: JSON.stringify({
+      ref: `refs/heads/${branch}`,
+      sha: commit.sha,
+    }),
+  });
+
+  return { job_id: jobId, branch, title };
+}
+
+export { createJob };

package/lib/tools/docker.js

@@ -0,0 +1,146 @@
+import http from 'http';
+
+/**
+ * Make a request to the Docker Engine API via Unix socket.
+ * @param {string} method - HTTP method
+ * @param {string} path - API path
+ * @param {object} [body] - Request body
+ * @returns {Promise<object>} Parsed JSON response
+ */
+function dockerApi(method, path, body = null) {
+  return new Promise((resolve, reject) => {
+    const options = {
+      socketPath: '/var/run/docker.sock',
+      path,
+      method,
+      headers: { 'Content-Type': 'application/json' },
+    };
+
+    const req = http.request(options, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try {
+          resolve({ status: res.statusCode, data: data ? JSON.parse(data) : {} });
+        } catch {
+          resolve({ status: res.statusCode, data: { message: data } });
+        }
+      });
+    });
+
+    req.on('error', reject);
+    if (body) req.write(JSON.stringify(body));
+    req.end();
+  });
+}
+
+/**
+ * Auto-detect the Docker network by inspecting the event-handler container.
+ * @returns {Promise<string>} Network name
+ */
+async function detectNetwork() {
+  try {
+    const { status, data } = await dockerApi('GET', '/containers/gigaclaw-event-handler/json');
+    if (status === 200 && data.NetworkSettings?.Networks) {
+      const networks = Object.keys(data.NetworkSettings.Networks);
+      if (networks.length > 0) return networks[0];
+    }
+  } catch {}
+  return 'bridge';
+}
+
+/**
+ * Create and start a code workspace Docker container.
+ * @param {object} options
+ * @param {string} options.containerName - Docker container name
+ * @param {string} options.repo - GitHub repo full name (e.g. "owner/repo")
+ * @param {string} options.branch - Git branch name
+ * @param {string} [options.codingAgent='claude-code'] - Coding agent identifier
+ * @returns {Promise<{containerId: string}>}
+ */
+async function createCodeWorkspaceContainer({ containerName, repo, branch, codingAgent = 'claude-code' }) {
+  if (codingAgent !== 'claude-code') {
+    throw new Error(`Unsupported coding agent: ${codingAgent}`);
+  }
+
+  const version = process.env.GIGACLAW_VERSION || 'latest';
+  const image = `gignaati/gigaclaw:claude-code-workspace-${version}`;
+  const network = await detectNetwork();
+
+  const env = [
+    `REPO=${repo}`,
+    `BRANCH=${branch}`,
+  ];
+  if (process.env.CLAUDE_CODE_OAUTH_TOKEN) {
+    env.push(`CLAUDE_CODE_OAUTH_TOKEN=${process.env.CLAUDE_CODE_OAUTH_TOKEN}`);
+  }
+  if (process.env.GH_TOKEN) {
+    env.push(`GH_TOKEN=${process.env.GH_TOKEN}`);
+  }
+
+  // Pull image only if not already present locally
+  const inspectRes = await dockerApi('GET', `/images/${encodeURIComponent(image)}/json`);
+  if (inspectRes.status !== 200) {
+    const pullRes = await dockerApi('POST', `/images/create?fromImage=${encodeURIComponent('gignaati/gigaclaw')}&tag=${encodeURIComponent(`claude-code-workspace-${version}`)}`);
+    if (pullRes.status !== 200) {
+      throw new Error(`Docker pull failed (${pullRes.status}): ${pullRes.data?.message || JSON.stringify(pullRes.data)}`);
+    }
+  }
+
+  // Create container
+  const createRes = await dockerApi('POST', `/containers/create?name=${encodeURIComponent(containerName)}`, {
+    Image: image,
+    Env: env,
+    HostConfig: {
+      NetworkMode: network,
+    },
+  });
+
+  if (createRes.status !== 201) {
+    throw new Error(`Docker create failed (${createRes.status}): ${createRes.data?.message || JSON.stringify(createRes.data)}`);
+  }
+
+  const containerId = createRes.data.Id;
+
+  // Start container
+  const startRes = await dockerApi('POST', `/containers/${containerId}/start`);
+  if (startRes.status !== 204 && startRes.status !== 304) {
+    throw new Error(`Docker start failed (${startRes.status}): ${startRes.data?.message || JSON.stringify(startRes.data)}`);
+  }
+
+  return { containerId };
+}
+
+/**
+ * Inspect a Docker container by name.
+ * @param {string} containerName
+ * @returns {Promise<object|null>} Container info or null if not found
+ */
+async function inspectContainer(containerName) {
+  const { status, data } = await dockerApi('GET', `/containers/${encodeURIComponent(containerName)}/json`);
+  if (status === 404) return null;
+  if (status === 200) return data;
+  throw new Error(`Docker inspect failed (${status}): ${data?.message || JSON.stringify(data)}`);
+}
+
+/**
+ * Start a stopped Docker container.
+ * @param {string} containerName
+ */
+async function startContainer(containerName) {
+  const { status, data } = await dockerApi('POST', `/containers/${encodeURIComponent(containerName)}/start`);
+  if (status === 204 || status === 304) return;
+  throw new Error(`Docker start failed (${status}): ${data?.message || JSON.stringify(data)}`);
+}
+
+/**
+ * Force-remove a Docker container.
+ * @param {string} containerName
+ */
+async function removeContainer(containerName) {
+  const { status, data } = await dockerApi('DELETE', `/containers/${encodeURIComponent(containerName)}?force=true`);
+  if (status === 204 || status === 404) return;
+  throw new Error(`Docker remove failed (${status}): ${data?.message || JSON.stringify(data)}`);
+}
+
+export { createCodeWorkspaceContainer, inspectContainer, startContainer, removeContainer };