@kairyou/agent-tools 0.3.0 → 0.4.0

package/dist/usage/cli.mjs

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+// integrations/usage/cli.mjs
+import { queryAgentProviderUsage } from "./core.mjs";
+function parseAgent(argv) {
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--agent" && argv[index + 1]) return argv[index + 1];
+    if (arg.startsWith("--agent=")) return arg.slice("--agent=".length);
+  }
+  return null;
+}
+var agent = parseAgent(process.argv.slice(2));
+if (agent !== "claude" && agent !== "codex") {
+  process.stderr.write(agent ? `Unsupported agent: ${agent}
+` : "Missing --agent <claude|codex>\n");
+  process.exitCode = 2;
+} else {
+  try {
+    const result = await queryAgentProviderUsage(agent);
+    if (result?.text) process.stdout.write(`${result.text}
+`);
+  } catch {
+  }
+}

package/dist/usage/codex-hook.mjs

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+
+// integrations/usage/codex-hook.mjs
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+var SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+var AGENT_TOOLS_HOME = process.env.AGENT_TOOLS_HOME || path.resolve(SCRIPT_DIR, "..", "..");
+var USAGE_SCRIPT = path.join(SCRIPT_DIR, "core.mjs");
+var LOG_PATH = path.join(AGENT_TOOLS_HOME, "logs", "usage-hook.log");
+var TIMEOUT_MS = Number(process.env.AGENT_TOOLS_USAGE_HOOK_TIMEOUT_MS || 4500);
+var MAX_LOG_BYTES = Number(process.env.AGENT_TOOLS_USAGE_HOOK_LOG_BYTES || 256 * 1024);
+var KEEP_LOG_BYTES = 128 * 1024;
+function hookOut(message) {
+  const payload = { continue: true };
+  if (message) payload.systemMessage = message;
+  process.stdout.write(`${JSON.stringify(payload)}
+`);
+}
+function preview(text) {
+  return String(text || "").replace(/\s+/g, " ").trim().slice(0, 500);
+}
+function logFailure(event) {
+  try {
+    fs.mkdirSync(path.dirname(LOG_PATH), { recursive: true });
+    rotateLogIfNeeded();
+    fs.appendFileSync(
+      LOG_PATH,
+      `${JSON.stringify({ at: (/* @__PURE__ */ new Date()).toISOString(), ...event })}
+`
+    );
+  } catch {
+  }
+}
+function rotateLogIfNeeded() {
+  const maxBytes = Number.isFinite(MAX_LOG_BYTES) && MAX_LOG_BYTES > 0 ? MAX_LOG_BYTES : 256 * 1024;
+  if (!fs.existsSync(LOG_PATH)) return;
+  const stat = fs.statSync(LOG_PATH);
+  if (stat.size <= maxBytes) return;
+  const keepBytes = Math.min(KEEP_LOG_BYTES, Math.floor(maxBytes / 2));
+  const fd = fs.openSync(LOG_PATH, "r");
+  try {
+    const buffer = Buffer.alloc(keepBytes);
+    fs.readSync(fd, buffer, 0, keepBytes, Math.max(0, stat.size - keepBytes));
+    fs.writeFileSync(
+      LOG_PATH,
+      `${JSON.stringify({ at: (/* @__PURE__ */ new Date()).toISOString(), reason: "log rotated", previousBytes: stat.size })}
+` + buffer.toString("utf8").replace(/^[^\n]*\n?/, "")
+    );
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+function failureMessage() {
+  return `API usage hook failed; see ${LOG_PATH.replace(/\\/g, "/")}`;
+}
+function parseHookJson(stdout) {
+  const text = stdout.trim();
+  if (!text) return { continue: true };
+  return JSON.parse(text);
+}
+async function runUsageScript() {
+  if (!fs.existsSync(USAGE_SCRIPT)) {
+    logFailure({ reason: "missing usage script", usageScript: USAGE_SCRIPT });
+    hookOut(failureMessage());
+    return;
+  }
+  const result = await new Promise((resolve) => {
+    const child = spawn(process.execPath, [USAGE_SCRIPT, "hook", "--agent", "codex"], {
+      cwd: process.cwd(),
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const timeout = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      child.kill();
+      resolve({ status: null, signal: "timeout", stdout, stderr });
+    }, Number.isFinite(TIMEOUT_MS) && TIMEOUT_MS > 0 ? TIMEOUT_MS : 4500);
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      resolve({ status: null, error, stdout, stderr });
+    });
+    child.on("exit", (status, signal) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      resolve({ status, signal, stdout, stderr });
+    });
+  });
+  if (result.status !== 0) {
+    logFailure({
+      reason: "usage script exited non-zero",
+      status: result.status,
+      signal: result.signal || "",
+      error: result.error?.message || "",
+      stdout: preview(result.stdout),
+      stderr: preview(result.stderr),
+      usageScript: USAGE_SCRIPT,
+      node: process.version,
+      platform: `${process.platform} ${os.release()}`
+    });
+    hookOut(failureMessage());
+    return;
+  }
+  try {
+    const payload = parseHookJson(result.stdout);
+    process.stdout.write(`${JSON.stringify(payload)}
+`);
+  } catch (error) {
+    logFailure({
+      reason: "usage script returned invalid hook JSON",
+      error: error.message,
+      stdout: preview(result.stdout),
+      stderr: preview(result.stderr),
+      usageScript: USAGE_SCRIPT
+    });
+    hookOut(failureMessage());
+  }
+}
+try {
+  await runUsageScript();
+} catch (error) {
+  logFailure({
+    reason: "wrapper exception",
+    error: error?.stack || error?.message || String(error),
+    usageScript: USAGE_SCRIPT
+  });
+  hookOut(failureMessage());
+}