agentel 0.2.0

package/src/collector.js

@@ -0,0 +1,113 @@
+"use strict";
+
+const fs = require("fs");
+const http = require("http");
+const path = require("path");
+const { archiveRoot } = require("./archive");
+const { loadConfig } = require("./config");
+const { ensureDir, writeJson } = require("./paths");
+
+function startCollector(env = process.env, options = {}) {
+  const cfg = loadConfig(env);
+  if (!cfg.collector?.enabled && !options.force) return null;
+  const endpoint = new URL(cfg.collector?.otlpEndpoint || "http://localhost:4318");
+  const host = endpoint.hostname || "127.0.0.1";
+  const port = Number(endpoint.port || 4318);
+  const server = http.createServer((req, res) => {
+    if (req.method === "GET" && req.url === "/healthz") {
+      writeJsonResponse(res, { ok: true, collector: "agentlog" });
+      return;
+    }
+    if (req.method !== "POST" || !isOtlpPath(req.url || "")) {
+      res.writeHead(404, { "content-type": "text/plain" });
+      res.end("not found\n");
+      return;
+    }
+    collectBody(req)
+      .then((body) => {
+        const record = writeTelemetryPayload(req, body, env);
+        writeJsonResponse(res, { partialSuccess: {}, agentlog: { stored: record.file } });
+      })
+      .catch((error) => {
+        writeJsonResponse(res, { error: error.message }, 500);
+      });
+  });
+  server.on("error", (error) => {
+    if (typeof options.onError === "function") options.onError(error);
+  });
+  server.listen(port, host);
+  return server;
+}
+
+function isOtlpPath(url) {
+  return ["/v1/logs", "/v1/traces", "/v1/metrics"].some((prefix) => String(url).startsWith(prefix));
+}
+
+function writeTelemetryPayload(req, body, env = process.env) {
+  const contentType = String(req.headers["content-type"] || "");
+  const kind = req.url.includes("/traces") ? "traces" : req.url.includes("/metrics") ? "metrics" : "logs";
+  const now = new Date();
+  const dir = path.join(
+    archiveRoot(env),
+    "telemetry",
+    `year=${now.getUTCFullYear()}`,
+    `month=${String(now.getUTCMonth() + 1).padStart(2, "0")}`,
+    `day=${String(now.getUTCDate()).padStart(2, "0")}`,
+    kind
+  );
+  ensureDir(dir);
+  const id = `${now.toISOString().replace(/[:.]/g, "-")}-${Math.random().toString(36).slice(2, 10)}`;
+  const isJson = contentType.includes("json") || looksLikeJson(body);
+  const payloadFile = path.join(dir, `event=${id}.${isJson ? "json" : "otlp"}`);
+  if (isJson) {
+    const parsed = safeJson(body);
+    writeJson(payloadFile, {
+      receivedAt: now.toISOString(),
+      path: req.url,
+      contentType,
+      payload: parsed
+    });
+  } else {
+    fs.writeFileSync(payloadFile, body, { mode: 0o600 });
+    writeJson(path.join(dir, `event=${id}.metadata.json`), {
+      receivedAt: now.toISOString(),
+      path: req.url,
+      contentType,
+      bytes: body.length,
+      note: "Binary OTLP payload stored raw. Configure OTEL_EXPORTER_OTLP_PROTOCOL=http/json for readable payloads."
+    });
+  }
+  return { file: payloadFile };
+}
+
+function collectBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+
+function writeJsonResponse(res, payload, status = 200) {
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(JSON.stringify(payload));
+}
+
+function safeJson(body) {
+  try {
+    return JSON.parse(body.toString("utf8"));
+  } catch {
+    return { raw: body.toString("utf8") };
+  }
+}
+
+function looksLikeJson(body) {
+  const text = body.toString("utf8", 0, Math.min(body.length, 32)).trim();
+  return text.startsWith("{") || text.startsWith("[");
+}
+
+module.exports = {
+  startCollector,
+  writeTelemetryPayload
+};

package/src/commands/logs.js

@@ -0,0 +1,51 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { paths } = require("../paths");
+
+function logsCommand(flags, env) {
+  const file = path.join(paths(env).logs, flags.file || "supervisor.log");
+  if (!flags.follow) {
+    try {
+      process.stdout.write(fs.readFileSync(file, "utf8"));
+    } catch (error) {
+      if (error.code === "ENOENT") console.log("No logs yet.");
+      else throw error;
+    }
+    return;
+  }
+
+  let offset = 0;
+  try {
+    const content = fs.readFileSync(file);
+    process.stdout.write(content);
+    offset = content.length;
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+    // Continue into follow mode.
+  }
+
+  fs.watchFile(file, { interval: 1000 }, (current) => {
+    try {
+      if (!current.isFile()) return;
+      if (current.size < offset) offset = 0;
+      if (current.size === offset) return;
+      const fd = fs.openSync(file, "r");
+      try {
+        const buffer = Buffer.alloc(current.size - offset);
+        fs.readSync(fd, buffer, 0, buffer.length, offset);
+        process.stdout.write(buffer);
+        offset = current.size;
+      } finally {
+        fs.closeSync(fd);
+      }
+    } catch {
+      // No-op.
+    }
+  });
+}
+
+module.exports = {
+  logsCommand
+};

package/src/commands/server.js

@@ -0,0 +1,11 @@
+"use strict";
+
+const { runMcpServer } = require("../mcp");
+
+function serverCommand(flags, env, { runMcpServer: startMcpServer = runMcpServer, input = process.stdin, output = process.stdout } = {}) {
+  return startMcpServer(input, output, env);
+}
+
+module.exports = {
+  serverCommand
+};

package/src/config.js

@@ -0,0 +1,240 @@
+"use strict";
+
+const crypto = require("crypto");
+const os = require("os");
+const path = require("path");
+const { ensureBaseDirs, paths, readJson, writeJson } = require("./paths");
+const { IMPORT_SOURCE_ORDER, enabledImportSources } = require("./sources");
+
+function defaultConfig(env = process.env) {
+  const p = paths(env);
+  return {
+    version: 1,
+    storage: {
+      backend: "local",
+      root: p.data
+    },
+    collector: {
+      otlpEndpoint: "http://localhost:4318",
+      protocol: "http/json",
+      enabled: true,
+      note: "Local HTTP OTLP collector writes telemetry payloads into the archive when the supervisor is running."
+    },
+    remote: {
+      type: "",
+      endpoint: "",
+      bucket: "",
+      region: "auto",
+      prefix: "agentlog",
+      accessKeyId: "",
+      secretAccessKey: ""
+    },
+    device: {
+      id: defaultDeviceId(env),
+      name: defaultDeviceName(env),
+      slug: defaultDeviceSlug(env)
+    },
+    sync: {
+      mode: "upload",
+      intervalMinutes: 30
+    },
+    index: {
+      paused: false,
+      intervalMinutes: 10,
+      batteryIntervalMinutes: 30
+    },
+    imports: {
+      defaultSinceDays: 30,
+      sources: IMPORT_SOURCE_ORDER,
+      autoDiscoverSources: true
+    },
+    privacy: {
+      webChatsDefaultScope: "local",
+      revealCache: true
+    },
+    createdAt: new Date().toISOString()
+  };
+}
+
+function loadConfig(env = process.env) {
+  const p = paths(env);
+  const cfg = readJson(p.config, null);
+  if (!cfg) return defaultConfig(env);
+  const defaults = defaultConfig(env);
+  const merged = {
+    ...defaults,
+    ...cfg,
+    storage: { ...defaults.storage, ...(cfg.storage || {}) },
+    collector: { ...defaults.collector, ...(cfg.collector || {}) },
+    remote: { ...defaults.remote, ...(cfg.remote || {}) },
+    device: { ...defaults.device, ...(cfg.device || {}) },
+    sync: { ...defaults.sync, ...(cfg.sync || {}) },
+    index: { ...defaults.index, ...(cfg.index || {}) },
+    imports: { ...defaults.imports, ...(cfg.imports || {}) },
+    privacy: { ...defaults.privacy, ...(cfg.privacy || {}) }
+  };
+  merged.imports.sources = enabledImportSources(merged.imports.sources);
+  return merged;
+}
+
+function effectiveImportSources(config) {
+  const imports = config?.imports || {};
+  const configured = enabledImportSources(Array.isArray(imports.sources) ? imports.sources : []);
+  if (imports.autoDiscoverSources === false) return configured.length ? configured : undefined;
+  return enabledImportSources([...new Set([...configured, ...IMPORT_SOURCE_ORDER])]);
+}
+
+function saveConfig(config, env = process.env) {
+  const p = paths(env);
+  ensureBaseDirs(p);
+  writeJson(p.config, config);
+}
+
+function initConfig(options = {}, env = process.env) {
+  const p = paths(env);
+  ensureBaseDirs(p);
+  const cfg = loadConfig(env);
+  const storage = options.storage || cfg.storage.backend || "local";
+  cfg.storage.backend = storage;
+  cfg.storage.root = path.resolve(options.root || cfg.storage.root || p.data);
+  const explicitDeviceName = options.deviceName || options.device;
+  const deviceName = explicitDeviceName || cfg.device?.name || defaultDeviceName(env);
+  cfg.device = {
+    ...(cfg.device || {}),
+    id: options.deviceId || cfg.device?.id || defaultDeviceId(env),
+    name: deviceName,
+    slug: options.deviceSlug || options["device-slug"] || (explicitDeviceName ? slugifyDeviceName(deviceName) : cfg.device?.slug || slugifyDeviceName(deviceName))
+  };
+  cfg.sync = {
+    ...(cfg.sync || {}),
+    mode: normalizeSyncMode(options.syncMode || options["sync-mode"] || options.mode || cfg.sync?.mode || "upload"),
+    intervalMinutes: normalizeSyncInterval(options.syncIntervalMinutes || options["sync-interval-minutes"] || options.syncInterval || cfg.sync?.intervalMinutes || 30)
+  };
+  if (options.remote) {
+    const normalizedRemote = normalizeRemoteEndpointInput(options.remote, options.bucket || cfg.remote?.bucket || "");
+    cfg.remote = {
+      ...(cfg.remote || {}),
+      type: storage === "local" ? cfg.remote?.type || "" : storage,
+      endpoint: normalizedRemote.endpoint,
+      url: normalizedRemote.endpoint,
+      bucket: normalizedRemote.bucket,
+      region: options.region || cfg.remote?.region || (storage === "r2" ? "auto" : "us-east-1"),
+      prefix: options.prefix || cfg.remote?.prefix || "agentlog",
+      accessKeyId: options.accessKeyId || cfg.remote?.accessKeyId || "",
+      secretAccessKey: options.secretAccessKey || options.token || cfg.remote?.secretAccessKey || ""
+    };
+  }
+  cfg.updatedAt = new Date().toISOString();
+  saveConfig(cfg, env);
+  return cfg;
+}
+
+function defaultDeviceName(env = process.env) {
+  return String(env.AGENTLOG_DEVICE_NAME || os.hostname() || "this-device").split(".")[0] || "this-device";
+}
+
+function defaultDeviceSlug(env = process.env) {
+  return slugifyDeviceName(defaultDeviceName(env));
+}
+
+function defaultDeviceId(env = process.env) {
+  if (env.AGENTLOG_DEVICE_ID) return String(env.AGENTLOG_DEVICE_ID).trim();
+  return crypto.createHash("sha256").update(`${os.hostname()}|${paths(env).home}`).digest("hex").slice(0, 12);
+}
+
+function slugifyDeviceName(value) {
+  return String(value || "this-device")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 64) || "this-device";
+}
+
+function normalizeSyncMode(value) {
+  const normalized = String(value || "upload").trim().toLowerCase();
+  return {
+    "upload-only": "upload",
+    upload: "upload",
+    push: "upload",
+    "two-way": "two-way",
+    twoway: "two-way",
+    bidirectional: "two-way",
+    receive: "receive",
+    "receive-only": "receive",
+    pull: "receive"
+  }[normalized] || normalized;
+}
+
+function normalizeSyncInterval(value) {
+  if (String(value || "").trim().toLowerCase() === "manual") return 0;
+  const number = Number(value);
+  if (!Number.isFinite(number) || number < 0) return 30;
+  return Math.round(number);
+}
+
+function normalizeRemoteEndpointInput(endpoint, bucket = "") {
+  const input = String(endpoint || "").trim();
+  const existingBucket = String(bucket || "").trim();
+  if (!input || input.startsWith("file://")) return { endpoint: input, bucket: existingBucket };
+  let url;
+  try {
+    url = new URL(input);
+  } catch {
+    return { endpoint: input, bucket: existingBucket };
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") return { endpoint: input, bucket: existingBucket };
+  const segments = url.pathname.split("/").map((part) => decodeURIComponent(part)).filter(Boolean);
+  if (!segments.length) return { endpoint: url.origin, bucket: existingBucket };
+  const inferredBucket = existingBucket || segments[0];
+  return { endpoint: url.origin, bucket: inferredBucket };
+}
+
+function setConfigKey(key, value, env = process.env) {
+  const cfg = loadConfig(env);
+  const parts = key.split(".").filter(Boolean);
+  if (parts.length === 0) throw new Error("config key is required");
+  let cursor = cfg;
+  for (const part of parts.slice(0, -1)) {
+    if (!cursor[part] || typeof cursor[part] !== "object") cursor[part] = {};
+    cursor = cursor[part];
+  }
+  cursor[parts[parts.length - 1]] = parseConfigValue(value);
+  cfg.updatedAt = new Date().toISOString();
+  saveConfig(cfg, env);
+  return cfg;
+}
+
+function getConfigKey(key, env = process.env) {
+  const cfg = loadConfig(env);
+  if (!key) return cfg;
+  let cursor = cfg;
+  for (const part of key.split(".").filter(Boolean)) {
+    if (!cursor || typeof cursor !== "object" || !(part in cursor)) return undefined;
+    cursor = cursor[part];
+  }
+  return cursor;
+}
+
+function parseConfigValue(value) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value === "null") return null;
+  if (/^-?\d+(\.\d+)?$/.test(value)) return Number(value);
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+module.exports = {
+  defaultConfig,
+  effectiveImportSources,
+  getConfigKey,
+  initConfig,
+  loadConfig,
+  normalizeRemoteEndpointInput,
+  saveConfig,
+  setConfigKey
+};

package/src/doctor.js

@@ -0,0 +1,102 @@
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawnSync } = require("child_process");
+const { archiveRoot, countSessions } = require("./archive");
+const { autostartStatus, recallInvocation } = require("./autostart");
+const { loadConfig } = require("./config");
+const { discoverCliHistory } = require("./importers");
+const { paths, readJson } = require("./paths");
+const { hasRemoteTarget } = require("./sync");
+
+function runDoctor(env = process.env) {
+  const cfg = loadConfig(env);
+  const checks = [];
+  add(checks, "config", fs.existsSync(paths(env).config), paths(env).config, "Run `agentlog init` to create config.");
+  add(checks, "archive", fs.existsSync(archiveRoot(env)), archiveRoot(env), "Run `agentlog import --source all --since 30d` to create the archive.");
+  add(checks, "rg", commandExists("rg"), "ripgrep search", "`agentlog history` will fall back to a slower JS scan.");
+  add(checks, "sqlite3", commandExists("sqlite3"), "Codex, Devin, and Cursor SQLite imports", "Install sqlite3 for Codex, Devin, and Cursor state database imports.");
+  add(checks, "collector", Boolean(cfg.collector?.enabled), cfg.collector?.otlpEndpoint || "", "Enable collector with `agentlog config set collector.enabled true`.");
+  add(checks, "remote sync", hasRemoteTarget(cfg, env), remoteTargetLabel(cfg), "Configure with `agentlog sync --endpoint ... --bucket ...`.");
+  const auto = autostartStatus();
+  add(checks, "autostart", Boolean(auto.enabled), auto.file || auto.note || "", "Run `agentlog autostart enable` to start at login.");
+  const invocation = recallInvocation();
+  add(checks, "recall command", Boolean(invocation.command), `${invocation.command} ${invocation.args.join(" ")}`, "Install recall with `agentlog recall add-to codex` or `agentlog init`.");
+
+  const discovery = discoverCliHistory(env);
+  const coverage = sourceCoverage(discovery, cfg);
+  const sessions = countSessions(env);
+  const importState = readJson(paths(env).imports, { files: {}, sessions: {} });
+  return {
+    ok: checks.every((check) => check.status === "ok"),
+    home: paths(env).home,
+    archive: archiveRoot(env),
+    checks,
+    sessions,
+    imports: {
+      configuredSources: cfg.imports?.sources || [],
+      trackedSessions: Object.keys(importState.sessions || {}).length,
+      trackedFiles: Object.keys(importState.files || {}).length
+    },
+    coverage
+  };
+}
+
+function sourceCoverage(discovery, cfg) {
+  const configured = new Set(cfg.imports?.sources || []);
+  const rows = [
+    coverageRow("codex-cli", "Codex CLI", discovery.codexCli, configured),
+    coverageRow("codex-desktop", "Codex Desktop", discovery.codexDesktop, configured),
+    coverageRow("claude", "Claude Code CLI", discovery.claude, configured),
+    coverageRow("claude-code-desktop", "Claude Code Desktop", discovery.claudeCodeDesktop, configured),
+    coverageRow("claude-workspace", "Claude Workspace", discovery.claudeWorkspace, configured),
+    coverageRow("claude-sdk", "Claude SDK jobs", discovery.claudeSdk, configured),
+    coverageRow("gemini-cli", "Gemini CLI", discovery.geminiCli, configured),
+    coverageRow("antigravity", "Antigravity", discovery.antigravity, configured),
+    coverageRow("devin-cli", "Devin CLI", discovery.devinCli, configured),
+    coverageRow("cursor", "Cursor", discovery.cursor, configured)
+  ];
+  return rows.map((row) => ({
+    ...row,
+    status: row.sessions ? (row.configured ? "captured" : "found but disabled") : "none found"
+  }));
+}
+
+function coverageRow(source, label, result = {}, configured) {
+  return {
+    source,
+    label,
+    configured: configured.has(source) || (source === "claude-code-desktop" && configured.has("claude-desktop")) || (source === "claude-workspace" && configured.has("claude-desktop")),
+    sessions: result?.sessions || 0,
+    oldest: result?.oldest || "",
+    details: result?.details || {},
+    note: result?.note || ""
+  };
+}
+
+function add(checks, name, ok, detail, remediation) {
+  checks.push({
+    name,
+    status: ok ? "ok" : "warn",
+    detail: detail || "",
+    remediation: ok ? "" : remediation
+  });
+}
+
+function commandExists(command) {
+  const result = spawnSync(command, ["--version"], { stdio: "ignore" });
+  return !result.error && result.status === 0;
+}
+
+function remoteTargetLabel(cfg) {
+  const remote = cfg.remote || {};
+  if (!remote.endpoint && !remote.url) return "";
+  const device = cfg.device?.slug ? ` device=${cfg.device.slug}` : "";
+  return `${remote.type || cfg.storage?.backend || "remote"} ${remote.endpoint || remote.url}${remote.bucket ? `/${remote.bucket}` : ""}${device}`;
+}
+
+module.exports = {
+  runDoctor
+};