@chrysb/alphaclaw 0.3.2 → 0.3.4-beta.0

package/bin/alphaclaw.js

@@ -5,8 +5,20 @@ const fs = require("fs");
 const os = require("os");
 const path = require("path");
 const { execSync } = require("child_process");
+const {
+  normalizeGitSyncFilePath,
+  validateGitSyncFilePath,
+} = require("../lib/cli/git-sync");
 const { buildSecretReplacements } = require("../lib/server/helpers");
 
+const kUsageTrackerPluginPath = path.resolve(
+  __dirname,
+  "..",
+  "lib",
+  "plugin",
+  "usage-tracker",
+);
+
 // ---------------------------------------------------------------------------
 // Parse CLI flags
 // ---------------------------------------------------------------------------
@@ -84,6 +96,7 @@ start options:
 
 git-sync options:
   --message, -m <text> Commit message
+  --file, -f <path>    Optional file path in .openclaw to sync only one file
 
 telegram topic add options:
   --thread <id>       Telegram thread ID
@@ -93,6 +106,7 @@ telegram topic add options:
 
 Examples:
   alphaclaw git-sync --message "sync workspace"
+  alphaclaw git-sync --message "update config" --file "workspace/app/config.json"
   alphaclaw telegram topic add --thread 12 --name "Testing"
   alphaclaw telegram topic add --thread 12 --name "Testing" --system "Handle QA requests"
 `);
@@ -234,10 +248,21 @@ const runGitSync = () => {
   const commitMessage = String(
     flagValue(commandArgs, "--message", "-m") || "",
   ).trim();
+  const requestedFilePath = String(
+    flagValue(commandArgs, "--file", "-f") || "",
+  ).trim();
+  const normalizedFilePath = normalizeGitSyncFilePath(requestedFilePath);
   if (!commitMessage) {
     console.error("[alphaclaw] Missing --message for git-sync");
     return 1;
   }
+  if (normalizedFilePath) {
+    const pathValidation = validateGitSyncFilePath(normalizedFilePath);
+    if (!pathValidation.ok) {
+      console.error(pathValidation.error);
+      return 1;
+    }
+  }
   if (!githubToken) {
     console.error("[alphaclaw] Missing GITHUB_TOKEN for git-sync");
     return 1;
@@ -312,13 +337,23 @@ const runGitSync = () => {
         `[alphaclaw] Remote branch "${branch}" not found, skipping pull`,
       );
     }
-    runGit("add -A");
+    if (normalizedFilePath) {
+      runGit(`add -A -- ${quoteArg(normalizedFilePath)}`);
+    } else {
+      runGit("add -A");
+    }
     try {
       runGit("diff --cached --quiet");
       console.log("[alphaclaw] No changes to commit");
       return 0;
     } catch {}
-    runGit(`commit -m ${quoteArg(commitMessage)}`);
+    if (normalizedFilePath) {
+      runGit(
+        `commit -m ${quoteArg(commitMessage)} -- ${quoteArg(normalizedFilePath)}`,
+      );
+    } else {
+      runGit(`commit -m ${quoteArg(commitMessage)}`);
+    }
     runGit(`push origin ${quoteArg(branch)}`, { withAuth: true });
     const hash = String(runGit("rev-parse --short HEAD")).trim();
     console.log(`[alphaclaw] Git sync complete (${hash})`);
@@ -745,6 +780,8 @@ if (fs.existsSync(configPath)) {
     const cfg = JSON.parse(fs.readFileSync(configPath, "utf8"));
     if (!cfg.channels) cfg.channels = {};
     if (!cfg.plugins) cfg.plugins = {};
+    if (!cfg.plugins.load) cfg.plugins.load = {};
+    if (!Array.isArray(cfg.plugins.load.paths)) cfg.plugins.load.paths = [];
     if (!cfg.plugins.entries) cfg.plugins.entries = {};
     let changed = false;
 
@@ -771,6 +808,14 @@ if (fs.existsSync(configPath)) {
       console.log("[alphaclaw] Discord added");
       changed = true;
     }
+    if (!cfg.plugins.load.paths.includes(kUsageTrackerPluginPath)) {
+      cfg.plugins.load.paths.push(kUsageTrackerPluginPath);
+      changed = true;
+    }
+    if (cfg.plugins.entries["usage-tracker"]?.enabled !== true) {
+      cfg.plugins.entries["usage-tracker"] = { enabled: true };
+      changed = true;
+    }
 
     if (changed) {
       let content = JSON.stringify(cfg, null, 2);

package/lib/cli/git-sync.js

@@ -0,0 +1,25 @@
+const normalizeGitSyncFilePath = (requestedFilePath) => {
+  const rawPath = String(requestedFilePath || "").trim();
+  if (!rawPath) return "";
+  return rawPath.replace(/\\/g, "/").replace(/^\.\/+/, "");
+};
+
+const validateGitSyncFilePath = (normalizedFilePath) => {
+  if (!normalizedFilePath) return { ok: true };
+  if (
+    normalizedFilePath.startsWith("/") ||
+    normalizedFilePath.startsWith("../") ||
+    normalizedFilePath.includes("/../")
+  ) {
+    return {
+      ok: false,
+      error: "[alphaclaw] --file must stay within /data/.openclaw",
+    };
+  }
+  return { ok: true };
+};
+
+module.exports = {
+  normalizeGitSyncFilePath,
+  validateGitSyncFilePath,
+};

package/lib/plugin/usage-tracker/index.js

@@ -0,0 +1,308 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { DatabaseSync } = require("node:sqlite");
+
+const kPluginId = "usage-tracker";
+const kFallbackRootDir = path.join(os.homedir(), ".alphaclaw");
+
+const coerceCount = (value) => {
+  const parsed = Number.parseInt(String(value ?? 0), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+};
+
+const resolveRootDir = () =>
+  process.env.ALPHACLAW_ROOT_DIR ||
+  process.env.OPENCLAW_HOME ||
+  process.env.OPENCLAW_ROOT_DIR ||
+  kFallbackRootDir;
+
+const safeAlterTable = (database, sql) => {
+  try {
+    database.exec(sql);
+  } catch (err) {
+    const message = String(err?.message || "").toLowerCase();
+    if (!message.includes("duplicate column name")) throw err;
+  }
+};
+
+const ensureSchema = (database) => {
+  database.exec("PRAGMA journal_mode=WAL;");
+  database.exec("PRAGMA synchronous=NORMAL;");
+  database.exec("PRAGMA busy_timeout=5000;");
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS usage_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      timestamp INTEGER NOT NULL,
+      session_id TEXT,
+      session_key TEXT,
+      run_id TEXT,
+      provider TEXT NOT NULL,
+      model TEXT NOT NULL,
+      input_tokens INTEGER NOT NULL DEFAULT 0,
+      output_tokens INTEGER NOT NULL DEFAULT 0,
+      cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+      cache_write_tokens INTEGER NOT NULL DEFAULT 0,
+      total_tokens INTEGER NOT NULL DEFAULT 0
+    );
+  `);
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_usage_events_ts
+    ON usage_events(timestamp DESC);
+  `);
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_usage_events_session
+    ON usage_events(session_id);
+  `);
+  safeAlterTable(
+    database,
+    "ALTER TABLE usage_events ADD COLUMN session_key TEXT;",
+  );
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_usage_events_session_key
+    ON usage_events(session_key);
+  `);
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS usage_daily (
+      date TEXT NOT NULL,
+      model TEXT NOT NULL,
+      provider TEXT,
+      input_tokens INTEGER NOT NULL DEFAULT 0,
+      output_tokens INTEGER NOT NULL DEFAULT 0,
+      cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+      cache_write_tokens INTEGER NOT NULL DEFAULT 0,
+      total_tokens INTEGER NOT NULL DEFAULT 0,
+      turn_count INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (date, model)
+    );
+  `);
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS tool_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      timestamp INTEGER NOT NULL,
+      session_id TEXT,
+      session_key TEXT,
+      tool_name TEXT NOT NULL,
+      success INTEGER NOT NULL DEFAULT 1,
+      duration_ms INTEGER
+    );
+  `);
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_tool_events_session
+    ON tool_events(session_id);
+  `);
+  safeAlterTable(
+    database,
+    "ALTER TABLE tool_events ADD COLUMN session_key TEXT;",
+  );
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_tool_events_session_key
+    ON tool_events(session_key);
+  `);
+};
+
+const createPlugin = () => {
+  let database = null;
+  let dbPath = "";
+  let insertUsageEventStmt = null;
+  let upsertUsageDailyStmt = null;
+  let insertToolEventStmt = null;
+
+  const getDatabase = () => {
+    if (database) return database;
+    const rootDir = resolveRootDir();
+    const dbDir = path.join(rootDir, "db");
+    fs.mkdirSync(dbDir, { recursive: true });
+    dbPath = path.join(dbDir, "usage.db");
+    database = new DatabaseSync(dbPath);
+    ensureSchema(database);
+    insertUsageEventStmt = database.prepare(`
+      INSERT INTO usage_events (
+        timestamp,
+        session_id,
+        session_key,
+        run_id,
+        provider,
+        model,
+        input_tokens,
+        output_tokens,
+        cache_read_tokens,
+        cache_write_tokens,
+        total_tokens
+      ) VALUES (
+        $timestamp,
+        $session_id,
+        $session_key,
+        $run_id,
+        $provider,
+        $model,
+        $input_tokens,
+        $output_tokens,
+        $cache_read_tokens,
+        $cache_write_tokens,
+        $total_tokens
+      )
+    `);
+    upsertUsageDailyStmt = database.prepare(`
+      INSERT INTO usage_daily (
+        date,
+        model,
+        provider,
+        input_tokens,
+        output_tokens,
+        cache_read_tokens,
+        cache_write_tokens,
+        total_tokens,
+        turn_count
+      ) VALUES (
+        $date,
+        $model,
+        $provider,
+        $input_tokens,
+        $output_tokens,
+        $cache_read_tokens,
+        $cache_write_tokens,
+        $total_tokens,
+        1
+      )
+      ON CONFLICT(date, model) DO UPDATE SET
+        provider = COALESCE(excluded.provider, usage_daily.provider),
+        input_tokens = usage_daily.input_tokens + excluded.input_tokens,
+        output_tokens = usage_daily.output_tokens + excluded.output_tokens,
+        cache_read_tokens = usage_daily.cache_read_tokens + excluded.cache_read_tokens,
+        cache_write_tokens = usage_daily.cache_write_tokens + excluded.cache_write_tokens,
+        total_tokens = usage_daily.total_tokens + excluded.total_tokens,
+        turn_count = usage_daily.turn_count + 1
+    `);
+    insertToolEventStmt = database.prepare(`
+      INSERT INTO tool_events (
+        timestamp,
+        session_id,
+        session_key,
+        tool_name,
+        success,
+        duration_ms
+      ) VALUES (
+        $timestamp,
+        $session_id,
+        $session_key,
+        $tool_name,
+        $success,
+        $duration_ms
+      )
+    `);
+    return database;
+  };
+
+  const writeUsageEvent = (event, ctx, logger) => {
+    const usage = event?.usage ?? {};
+    const timestamp = Date.now();
+    const date = new Date(timestamp).toISOString().slice(0, 10);
+    const inputTokens = coerceCount(usage.input);
+    const outputTokens = coerceCount(usage.output);
+    const cacheReadTokens = coerceCount(usage.cacheRead);
+    const cacheWriteTokens = coerceCount(usage.cacheWrite);
+    const fallbackTotal = inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens;
+    const totalTokens = coerceCount(usage.total) || fallbackTotal;
+    if (totalTokens <= 0) return;
+    getDatabase();
+    insertUsageEventStmt.run({
+      $timestamp: timestamp,
+      $session_id: String(event?.sessionId || ctx?.sessionId || ""),
+      $session_key: String(ctx?.sessionKey || ""),
+      $run_id: String(event?.runId || ""),
+      $provider: String(event?.provider || "unknown"),
+      $model: String(event?.model || "unknown"),
+      $input_tokens: inputTokens,
+      $output_tokens: outputTokens,
+      $cache_read_tokens: cacheReadTokens,
+      $cache_write_tokens: cacheWriteTokens,
+      $total_tokens: totalTokens,
+    });
+    upsertUsageDailyStmt.run({
+      $date: date,
+      $model: String(event?.model || "unknown"),
+      $provider: String(event?.provider || "unknown"),
+      $input_tokens: inputTokens,
+      $output_tokens: outputTokens,
+      $cache_read_tokens: cacheReadTokens,
+      $cache_write_tokens: cacheWriteTokens,
+      $total_tokens: totalTokens,
+    });
+    if (logger?.debug) {
+      logger.debug(
+        `[${kPluginId}] usage event recorded model=${String(event?.model || "unknown")} total=${totalTokens}`,
+      );
+    }
+  };
+
+  const deriveToolSuccess = (event) => {
+    const message = event?.message;
+    if (!message || typeof message !== "object") {
+      return event?.error ? 0 : 1;
+    }
+    if (message?.isError === true) return 0;
+    if (message?.ok === false) return 0;
+    if (typeof message?.error === "string" && message.error.trim()) return 0;
+    return 1;
+  };
+
+  const writeToolEvent = (event, ctx) => {
+    const toolName = String(event?.toolName || "").trim();
+    if (!toolName) return;
+    const sessionKey = String(ctx?.sessionKey || "").trim();
+    const sessionId = String(ctx?.sessionId || "").trim();
+    if (!sessionKey && !sessionId) return;
+    getDatabase();
+    insertToolEventStmt.run({
+      $timestamp: Date.now(),
+      $session_id: sessionId,
+      $session_key: sessionKey,
+      $tool_name: toolName,
+      $success: deriveToolSuccess(event),
+      $duration_ms: coerceCount(event?.durationMs) || null,
+    });
+  };
+
+  return {
+    id: kPluginId,
+    name: "AlphaClaw Usage Tracker",
+    description: "Captures LLM and tool usage into SQLite for Usage UI",
+    register: (api) => {
+      const logger = api?.logger;
+      try {
+        getDatabase();
+        logger?.info?.(`[${kPluginId}] initialized db=${dbPath}`);
+      } catch (err) {
+        logger?.error?.(`[${kPluginId}] failed to initialize database: ${err?.message || err}`);
+        return;
+      }
+      api.on("llm_output", (event, ctx) => {
+        try {
+          writeUsageEvent(event, ctx, logger);
+        } catch (err) {
+          logger?.error?.(`[${kPluginId}] llm_output write error: ${err?.message || err}`);
+        }
+      });
+      api.on("tool_result_persist", (event, ctx) => {
+        try {
+          writeToolEvent(
+            {
+              ...event,
+              toolName: String(event?.toolName || ctx?.toolName || ""),
+              durationMs: event?.durationMs,
+            },
+            ctx,
+          );
+        } catch (err) {
+          logger?.error?.(`[${kPluginId}] tool_result_persist write error: ${err?.message || err}`);
+        }
+        return {};
+      });
+    },
+  };
+};
+
+const plugin = createPlugin();
+module.exports = plugin;
+module.exports.default = plugin;

package/lib/plugin/usage-tracker/openclaw.plugin.json

@@ -0,0 +1,8 @@
+{
+  "id": "usage-tracker",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}