@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.17

package/dist/src/a2a/webhook.js

@@ -0,0 +1,240 @@
+// A2A push-notification webhook receiver — verifies HMAC-SHA256 signatures
+// using the Stripe-style `X-AIWG-Signature: t=<ts>,v1=<hmac>` header, rejects
+// stale timestamps (replay protection), and deduplicates by event-id
+// (idempotency).
+//
+// The webhook is the push-based alternative to SSE described in
+// roctinam/agentic-sandbox issue #211. The executor signs the raw request
+// body with a per-config secret (registered via
+// A2AClient.createPushNotificationConfig) and POSTs StreamResponse-shaped
+// payloads to the AIWG receiver URL.
+//
+// This module is HTTP-framework-agnostic. The serve.ts wiring adapts Hono
+// requests to `verifyWebhookSignature`; tests can call the same function
+// directly with synthesized Buffers.
+//
+// @issue #1256
+import { createHmac, timingSafeEqual } from 'node:crypto';
+/** Header name (case-insensitive). */
+export const SIGNATURE_HEADER = 'x-aiwg-signature';
+/** Five minutes — RFC 8941 timestamp tolerance. */
+export const DEFAULT_TIMESTAMP_TOLERANCE_SECONDS = 300;
+/** Idempotency cache size. Old entries are evicted FIFO. */
+export const DEFAULT_IDEMPOTENCY_CAPACITY = 4096;
+/**
+ * Verify the `X-AIWG-Signature` header against the raw request body.
+ *
+ * Stripe-style format:
+ *   `X-AIWG-Signature: t=1700000000,v1=<hex hmac-sha256>`
+ *
+ * The HMAC is computed over `t=<timestamp>.<raw body>` (the timestamp and
+ * a literal dot, prepended to the body). Multiple `v1=` entries may be
+ * present in a single header (during a key rotation); any match accepts.
+ */
+export async function verifyWebhookSignature(signature, body, configId, opts) {
+    if (!signature) {
+        return { ok: false, code: 'signature_missing', detail: 'missing X-AIWG-Signature header' };
+    }
+    const parsed = parseSignatureHeader(signature);
+    if (!parsed) {
+        return { ok: false, code: 'signature_malformed', detail: 'X-AIWG-Signature did not parse' };
+    }
+    const tolerance = opts.toleranceSeconds ?? DEFAULT_TIMESTAMP_TOLERANCE_SECONDS;
+    const now = opts.now ? opts.now() : Math.floor(Date.now() / 1000);
+    if (Math.abs(now - parsed.timestamp) > tolerance) {
+        return {
+            ok: false,
+            code: 'timestamp_skew',
+            detail: `timestamp skew ${Math.abs(now - parsed.timestamp)}s exceeds tolerance ${tolerance}s`,
+        };
+    }
+    const secret = await opts.lookupSecret(configId);
+    if (!secret) {
+        return { ok: false, code: 'secret_unknown', detail: `no secret registered for configId='${configId}'` };
+    }
+    const signedPayload = `${parsed.timestamp}.${body.toString('utf8')}`;
+    const expected = createHmac('sha256', secret).update(signedPayload).digest('hex');
+    for (const candidate of parsed.v1) {
+        if (constantTimeHexEqual(candidate, expected)) {
+            return { ok: true, timestamp: parsed.timestamp };
+        }
+    }
+    return { ok: false, code: 'signature_mismatch', detail: 'no v1 signature matched' };
+}
+/** Parse `t=...,v1=...,(v1=...,)*` into structured fields. */
+export function parseSignatureHeader(header) {
+    const parts = header.split(',').map(s => s.trim()).filter(Boolean);
+    let timestamp = null;
+    const v1 = [];
+    for (const p of parts) {
+        const eq = p.indexOf('=');
+        if (eq <= 0)
+            return null;
+        const key = p.slice(0, eq);
+        const value = p.slice(eq + 1);
+        if (key === 't') {
+            const n = Number(value);
+            if (!Number.isFinite(n))
+                return null;
+            timestamp = n;
+        }
+        else if (key === 'v1') {
+            if (!/^[0-9a-f]+$/i.test(value))
+                return null;
+            v1.push(value);
+        }
+        // ignore unknown keys forward-compat
+    }
+    if (timestamp === null || v1.length === 0)
+        return null;
+    return { timestamp, v1 };
+}
+function constantTimeHexEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    const ab = Buffer.from(a, 'hex');
+    const bb = Buffer.from(b, 'hex');
+    if (ab.length !== bb.length || ab.length === 0)
+        return false;
+    return timingSafeEqual(ab, bb);
+}
+// ── idempotency cache ──────────────────────────────────────────────────
+/**
+ * Bounded FIFO event-id deduper. The first call with a given id returns
+ * true; subsequent calls return false until the id falls out of the
+ * window.
+ *
+ * Subscribers MUST dedupe per the spec — the executor's delivery worker
+ * retries on non-2xx responses, so a flaky downstream handler will
+ * receive the same event-id multiple times.
+ */
+export class IdempotencyCache {
+    capacity;
+    seen = new Set();
+    order = [];
+    constructor(capacity = DEFAULT_IDEMPOTENCY_CAPACITY) {
+        this.capacity = Math.max(16, capacity);
+    }
+    /** Returns true if `id` is new (and stores it); false if it's a duplicate. */
+    markFresh(id) {
+        if (this.seen.has(id))
+            return false;
+        this.seen.add(id);
+        this.order.push(id);
+        while (this.order.length > this.capacity) {
+            const evicted = this.order.shift();
+            if (evicted !== undefined)
+                this.seen.delete(evicted);
+        }
+        return true;
+    }
+    size() {
+        return this.seen.size;
+    }
+}
+export class PushSecretRegistry {
+    entries = new Map();
+    register(entry) {
+        this.entries.set(entry.configId, entry);
+    }
+    lookup(configId) {
+        return this.entries.get(configId) ?? null;
+    }
+    unregister(configId) {
+        return this.entries.delete(configId);
+    }
+    /** Test/debug helper. */
+    size() {
+        return this.entries.size;
+    }
+}
+/**
+ * One-shot processor: takes a raw webhook request (configId + body +
+ * signature header + event-id header), verifies, dedupes, routes.
+ *
+ * Returns the status code and body the HTTP layer should emit. The HTTP
+ * adapter (serve.ts) is responsible for reading the raw body bytes
+ * BEFORE any JSON parsing — the signature is computed over raw bytes
+ * (whitespace-sensitive).
+ */
+export async function handleWebhook(configId, body, signature, eventId, opts) {
+    if (!configId) {
+        return {
+            status: 400,
+            body: errorBody('aiwg.webhook_config_missing', 'configId query parameter missing'),
+        };
+    }
+    if (!eventId) {
+        return {
+            status: 400,
+            body: errorBody('aiwg.webhook_event_id_missing', 'event-id header missing'),
+        };
+    }
+    // Verify signature first — never touch the body's contents until the
+    // HMAC has been checked.
+    const verification = await verifyWebhookSignature(signature, body, configId, {
+        lookupSecret: id => {
+            const entry = opts.registry.lookup(id);
+            return entry ? entry.secret : null;
+        },
+        ...(opts.toleranceSeconds !== undefined ? { toleranceSeconds: opts.toleranceSeconds } : {}),
+        ...(opts.now ? { now: opts.now } : {}),
+    });
+    if (!verification.ok) {
+        return {
+            status: verification.code === 'timestamp_skew'
+                ? 401
+                : verification.code === 'secret_unknown'
+                    ? 404
+                    : 401,
+            body: errorBody(`aiwg.webhook_${verification.code}`, verification.detail ?? ''),
+        };
+    }
+    // Idempotency check — duplicate event-ids are accepted with 200 but
+    // not re-routed. The executor's retry logic depends on a 2xx response
+    // to mark delivery complete; failing here would cause infinite retry.
+    const fresh = opts.idempotency.markFresh(eventId);
+    if (!fresh) {
+        return { status: 200, body: { ok: true, deduped: true } };
+    }
+    // Route the verified payload. Errors thrown here become 500 so the
+    // executor will retry — pick the abstraction carefully on the
+    // mission-state side.
+    const entry = opts.registry.lookup(configId);
+    if (!entry) {
+        // Edge case: secret was unregistered between verify and route.
+        return {
+            status: 404,
+            body: errorBody('aiwg.webhook_secret_unknown', `configId='${configId}' no longer registered`),
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(body.toString('utf8'));
+    }
+    catch (e) {
+        return {
+            status: 400,
+            body: errorBody('aiwg.webhook_body_not_json', e.message),
+        };
+    }
+    try {
+        await opts.route(entry, parsed);
+    }
+    catch (e) {
+        return {
+            status: 500,
+            body: errorBody('aiwg.webhook_route_failed', e.message),
+        };
+    }
+    return { status: 200, body: { ok: true } };
+}
+function errorBody(code, detail) {
+    return {
+        type: 'about:blank',
+        title: 'Webhook rejected',
+        code,
+        detail,
+    };
+}
+//# sourceMappingURL=webhook.js.map

package/dist/src/activity-log/cli.js

@@ -0,0 +1,348 @@
+/**
+ * Activity Log CLI — `aiwg activity-log <subcommand>`
+ *
+ * Subcommands:
+ *   show [--since DATE] [--operation OP] [--limit N]
+ *   append <operation> "<summary>"
+ *   stats
+ *
+ * Persists through `resolveStorage('activity_log')` per #964 — the
+ * physical destination is `.aiwg/activity.log` on the default `fs`
+ * backend, byte-identical to the legacy `echo >> .aiwg/activity.log`
+ * pattern documented in the activity-log skill.
+ *
+ * @design @.aiwg/architecture/storage-design.md (§4, §8.2)
+ * @issue #934
+ * @issue #964
+ */
+import { ACTIVITY_OPERATIONS, formatEntry, formatUtcTimestamp, isActivityOperation, } from './types.js';
+import { parseLog, parseUtcDate } from './parser.js';
+import { resolveStorage } from '../storage/index.js';
+const LOG_PATH = 'activity.log';
+const DEFAULT_LIMIT = 20;
+export async function main(args) {
+    const subcommand = args[0];
+    const subArgs = args.slice(1);
+    switch (subcommand) {
+        case 'show':
+            await handleShow(subArgs);
+            break;
+        case 'append':
+            await handleAppend(subArgs);
+            break;
+        case 'stats':
+            await handleStats();
+            break;
+        case 'rotate':
+            await handleRotate(subArgs);
+            break;
+        default:
+            printUsage();
+            if (subcommand) {
+                throw new Error(`Unknown activity-log subcommand: ${subcommand}`);
+            }
+    }
+}
+async function handleShow(args) {
+    const opts = parseShowArgs(args);
+    const adapter = await resolveStorage('activity_log');
+    const entries = await readEntries(adapter);
+    let filtered = entries;
+    if (opts.since) {
+        const since = opts.since;
+        filtered = filtered.filter((e) => e.timestamp >= since);
+    }
+    if (opts.operation) {
+        filtered = filtered.filter((e) => e.operation === opts.operation);
+    }
+    // Newest first
+    filtered.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+    if (filtered.length > opts.limit) {
+        filtered = filtered.slice(0, opts.limit);
+    }
+    if (filtered.length === 0) {
+        console.log('No activity log entries match the filters.');
+        return;
+    }
+    for (const entry of filtered) {
+        console.log(formatEntry(entry));
+    }
+}
+async function handleAppend(args) {
+    if (args.length < 2) {
+        throw new Error(`Usage: aiwg activity-log append <operation> "<summary>"\n` +
+            `  Valid operations: ${ACTIVITY_OPERATIONS.join(', ')}`);
+    }
+    const op = args[0];
+    const summary = args.slice(1).join(' ').trim();
+    if (!isActivityOperation(op)) {
+        throw new Error(`Invalid operation "${op}". Valid operations: ${ACTIVITY_OPERATIONS.join(', ')}`);
+    }
+    if (summary.length === 0) {
+        throw new Error('Summary must be a non-empty string');
+    }
+    if (summary.length > 120) {
+        // Soft limit per the activity-log rule. Warn but don't refuse —
+        // the rule says "≤120 characters" but doesn't promise rejection.
+        console.warn(`warning: summary is ${summary.length} chars (rule recommends ≤120)`);
+    }
+    // #975: honor AIWG_SKIP_ACTIVITY_LOG=1 per the activity-log rule.
+    if (isActivityLogSkipped()) {
+        return;
+    }
+    const adapter = await resolveStorage('activity_log');
+    const newLine = formatEntry({ timestamp: new Date(), operation: op, summary });
+    // #976: prefer atomic append when the backend supports it. The fs
+    // backend uses fs.appendFile (O_APPEND) so concurrent appenders don't
+    // race with each other. Fall back to read-then-write for backends
+    // that don't expose append (e.g., Notion, AnythingLLM, Fortemi) —
+    // those backends have their own concurrency models anyway.
+    if (typeof adapter.append === 'function') {
+        // Append guarantees no read-modify-write race. We need to ensure the
+        // existing log ends with a newline before our line; do that with a
+        // single-byte preamble append when needed.
+        const existing = (await adapter.read(LOG_PATH)) ?? '';
+        if (existing.length > 0 && !existing.endsWith('\n')) {
+            await adapter.append(LOG_PATH, '\n');
+        }
+        await adapter.append(LOG_PATH, newLine + '\n');
+    }
+    else {
+        const existing = (await adapter.read(LOG_PATH)) ?? '';
+        const trailing = existing.length === 0 || existing.endsWith('\n') ? '' : '\n';
+        await adapter.write(LOG_PATH, existing + trailing + newLine + '\n');
+    }
+    console.log(`Entry appended to .aiwg/activity.log:\n  ${newLine}`);
+}
+/**
+ * Returns true when AIWG_SKIP_ACTIVITY_LOG is set (per the activity-log
+ * rule's documented opt-out). Accepts "1", "true" (case-insensitive),
+ * or any non-empty value other than "0"/"false".
+ */
+function isActivityLogSkipped() {
+    const raw = process.env['AIWG_SKIP_ACTIVITY_LOG'];
+    if (!raw)
+        return false;
+    const v = raw.toLowerCase().trim();
+    if (v === '0' || v === 'false' || v === '')
+        return false;
+    return true;
+}
+async function handleStats() {
+    const adapter = await resolveStorage('activity_log');
+    const entries = await readEntries(adapter);
+    if (entries.length === 0) {
+        console.log('Activity log is empty.');
+        return;
+    }
+    const counts = new Map();
+    for (const op of ACTIVITY_OPERATIONS)
+        counts.set(op, 0);
+    for (const e of entries)
+        counts.set(e.operation, (counts.get(e.operation) ?? 0) + 1);
+    const sorted = [...entries].sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    const first = sorted[0].timestamp;
+    const last = sorted[sorted.length - 1].timestamp;
+    const days = Math.max(1, Math.ceil((last.getTime() - first.getTime()) / 86_400_000) + 1);
+    console.log(`Activity Log Statistics`);
+    console.log(`Log file: .aiwg/activity.log`);
+    console.log(`Date range: ${formatUtcTimestamp(first).slice(0, 10)} → ${formatUtcTimestamp(last).slice(0, 10)} (${days} day${days === 1 ? '' : 's'})`);
+    console.log(`Total entries: ${entries.length}`);
+    console.log('');
+    console.log(`By operation:`);
+    // Sort by count desc, then by op name asc for stability
+    const ranked = [...counts.entries()]
+        .filter(([, n]) => n > 0)
+        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+    const maxCount = ranked[0]?.[1] ?? 1;
+    for (const [op, n] of ranked) {
+        const pct = Math.round((n / entries.length) * 100);
+        const barLen = Math.max(1, Math.round((n / maxCount) * 20));
+        const bar = '█'.repeat(barLen);
+        console.log(`  ${op.padEnd(8)} ${String(n).padStart(3)} ${bar.padEnd(20)} ${pct}%`);
+    }
+}
+async function handleRotate(args) {
+    const opts = parseRotateArgs(args);
+    const adapter = await resolveStorage('activity_log');
+    const existing = (await adapter.read(LOG_PATH)) ?? '';
+    const entries = parseLog(existing);
+    if (entries.length === 0) {
+        throw new Error('Nothing to rotate: the activity log is empty (or contains no parseable entries).');
+    }
+    // Decide what stays inline vs what goes to archive
+    const sortedAsc = [...entries].sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    const { kept, archived } = splitForRotation(sortedAsc, opts.keepLast);
+    if (archived.length === 0) {
+        throw new Error(`Nothing to archive: --keep-last would retain all ${entries.length} entries inline.`);
+    }
+    // Determine archive destination (subsystem-relative)
+    const stamp = formatArchiveStamp(new Date());
+    const archivePath = opts.to ?? `archive/activity-log/${stamp}.log`;
+    // Refuse to overwrite an existing archive
+    const existingArchive = await adapter.read(archivePath);
+    if (existingArchive !== null) {
+        throw new Error(`Refusing to overwrite existing archive: ${archivePath}\n` +
+            `  Either pass --to <other-path> or remove the existing archive first.`);
+    }
+    // Write archive (full historical content, oldest-first to match log order)
+    const archiveBody = archived.map((e) => formatEntry(e)).join('\n') + '\n';
+    await adapter.write(archivePath, archiveBody);
+    // Rewrite the live log with the retained tail
+    const liveBody = kept.length > 0 ? kept.map((e) => formatEntry(e)).join('\n') + '\n' : '';
+    await adapter.write(LOG_PATH, liveBody);
+    // Append a rotate-record entry to the live log (also exercises the
+    // append path so concurrent-write protection still applies).
+    const recordSummary = `activity-log rotated, archived ${archived.length} entries to ${archivePath}`;
+    if (typeof adapter.append === 'function') {
+        await adapter.append(LOG_PATH, formatEntry({ timestamp: new Date(), operation: 'archive', summary: recordSummary }) + '\n');
+    }
+    else {
+        const live = (await adapter.read(LOG_PATH)) ?? '';
+        const trailing = live.length === 0 || live.endsWith('\n') ? '' : '\n';
+        await adapter.write(LOG_PATH, live +
+            trailing +
+            formatEntry({ timestamp: new Date(), operation: 'archive', summary: recordSummary }) +
+            '\n');
+    }
+    console.log(`Rotated activity log:`);
+    console.log(`  Archived ${archived.length} entr${archived.length === 1 ? 'y' : 'ies'} to ${archivePath}`);
+    console.log(`  Retained ${kept.length} entr${kept.length === 1 ? 'y' : 'ies'} inline`);
+}
+function parseRotateArgs(args) {
+    const opts = {};
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--keep-last') {
+            const v = args[++i];
+            if (!v)
+                throw new Error(`--keep-last requires a value (e.g., 90d or 1000)`);
+            opts.keepLast = parseKeepLast(v);
+        }
+        else if (a === '--to') {
+            const v = args[++i];
+            if (!v)
+                throw new Error(`--to requires a path`);
+            opts.to = v;
+        }
+        else {
+            throw new Error(`Unknown flag: ${a}`);
+        }
+    }
+    return opts;
+}
+function parseKeepLast(raw) {
+    const dur = /^(\d+)d$/.exec(raw);
+    if (dur)
+        return { kind: 'duration_ms', ms: Number(dur[1]) * 86_400_000 };
+    const cnt = /^(\d+)$/.exec(raw);
+    if (cnt) {
+        const n = Number(cnt[1]);
+        if (n <= 0)
+            throw new Error(`--keep-last count must be positive (got ${raw})`);
+        return { kind: 'count', n };
+    }
+    throw new Error(`--keep-last must be <N>d or <N> (got ${JSON.stringify(raw)})`);
+}
+function splitForRotation(sortedAsc, keepLast) {
+    if (!keepLast) {
+        return { kept: [], archived: sortedAsc };
+    }
+    if (keepLast.kind === 'count') {
+        if (sortedAsc.length <= keepLast.n) {
+            return { kept: [...sortedAsc], archived: [] };
+        }
+        const cut = sortedAsc.length - keepLast.n;
+        return {
+            archived: sortedAsc.slice(0, cut),
+            kept: sortedAsc.slice(cut),
+        };
+    }
+    // duration_ms
+    const cutoff = Date.now() - keepLast.ms;
+    const kept = [];
+    const archived = [];
+    for (const e of sortedAsc) {
+        if (e.timestamp.getTime() >= cutoff)
+            kept.push(e);
+        else
+            archived.push(e);
+    }
+    return { kept, archived };
+}
+function formatArchiveStamp(d) {
+    // YYYYMMDD-HHMMSS UTC — sortable, unique to the second
+    const y = d.getUTCFullYear();
+    const mo = String(d.getUTCMonth() + 1).padStart(2, '0');
+    const da = String(d.getUTCDate()).padStart(2, '0');
+    const h = String(d.getUTCHours()).padStart(2, '0');
+    const mi = String(d.getUTCMinutes()).padStart(2, '0');
+    const s = String(d.getUTCSeconds()).padStart(2, '0');
+    return `${y}${mo}${da}-${h}${mi}${s}`;
+}
+// ── helpers ──────────────────────────────────────────────────────────
+async function readEntries(adapter) {
+    const content = await adapter.read(LOG_PATH);
+    if (content === null)
+        return [];
+    return parseLog(content);
+}
+function parseShowArgs(args) {
+    const opts = { limit: DEFAULT_LIMIT };
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--since') {
+            const v = args[++i];
+            const d = parseUtcDate(v);
+            if (!d)
+                throw new Error(`--since must be YYYY-MM-DD (got ${JSON.stringify(v)})`);
+            opts.since = d;
+        }
+        else if (a === '--operation') {
+            const v = args[++i];
+            if (!isActivityOperation(v)) {
+                throw new Error(`--operation must be one of ${ACTIVITY_OPERATIONS.join(', ')} (got ${JSON.stringify(v)})`);
+            }
+            opts.operation = v;
+        }
+        else if (a === '--limit') {
+            const v = Number(args[++i]);
+            if (!Number.isFinite(v) || v <= 0) {
+                throw new Error(`--limit must be a positive integer`);
+            }
+            opts.limit = Math.floor(v);
+        }
+        else {
+            throw new Error(`Unknown flag: ${a}`);
+        }
+    }
+    return opts;
+}
+function printUsage() {
+    console.log(`Usage: aiwg activity-log <subcommand>
+
+Subcommands:
+  show [--since YYYY-MM-DD] [--operation OP] [--limit N]
+  append <operation> "<summary>"
+  stats
+  rotate [--keep-last <Nd|N>] [--to <path>]
+
+Operations: ${ACTIVITY_OPERATIONS.join(', ')}
+
+Examples:
+  aiwg activity-log show
+  aiwg activity-log show --since 2026-04-01 --operation deploy
+  aiwg activity-log show --limit 5
+  aiwg activity-log append create ".aiwg/requirements/UC-007 created"
+  aiwg activity-log stats
+  aiwg activity-log rotate                    # archive everything
+  aiwg activity-log rotate --keep-last 90d    # archive entries older than 90 days
+  aiwg activity-log rotate --keep-last 1000   # keep last 1000 entries inline
+
+Environment:
+  AIWG_SKIP_ACTIVITY_LOG=1   suppress append (per the activity-log rule)
+
+The log persists at .aiwg/activity.log on the default fs backend.
+Configure .aiwg/storage.config to route to an external backend (#934).`);
+}
+//# sourceMappingURL=cli.js.map

package/dist/src/activity-log/parser.js

@@ -0,0 +1,81 @@
+/**
+ * Activity Log Parser
+ *
+ * Parses `.aiwg/activity.log` lines into structured entries. Lines that
+ * don't match the expected format are silently skipped (the log is
+ * append-only and may contain malformed entries from older tooling or
+ * manual edits).
+ *
+ * @issue #934
+ * @issue #964
+ */
+import { isActivityOperation } from './types.js';
+/**
+ * Pattern: `## [YYYY-MM-DD HH:MM] <operation> | <summary>`
+ *
+ * Match groups:
+ *   1: full timestamp (`YYYY-MM-DD HH:MM`)
+ *   2: operation token
+ *   3: summary
+ */
+const LINE_PATTERN = /^##\s+\[(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2})\]\s+([a-z]+)\s+\|\s+(.+?)\s*$/;
+/**
+ * Parse a single log line. Returns null when the line doesn't match the
+ * canonical format or the operation token is unknown.
+ */
+export function parseLine(line) {
+    const m = LINE_PATTERN.exec(line);
+    if (!m)
+        return null;
+    const [, rawTimestamp, op, summary] = m;
+    if (!isActivityOperation(op))
+        return null;
+    const timestamp = parseUtcTimestamp(rawTimestamp);
+    if (!timestamp)
+        return null;
+    return { timestamp, rawTimestamp, operation: op, summary };
+}
+/**
+ * Parse the entire log content into entries. Skips blank lines and
+ * lines that don't match the canonical format.
+ */
+export function parseLog(content) {
+    const out = [];
+    for (const line of content.split('\n')) {
+        if (line.trim().length === 0)
+            continue;
+        const entry = parseLine(line);
+        if (entry)
+            out.push(entry);
+    }
+    return out;
+}
+/**
+ * Parse a `YYYY-MM-DD HH:MM` UTC timestamp into a Date. Returns null on
+ * malformed input.
+ */
+export function parseUtcTimestamp(raw) {
+    const m = /^(\d{4})-(\d{2})-(\d{2})\s+(\d{2}):(\d{2})$/.exec(raw);
+    if (!m)
+        return null;
+    const [, y, mo, d, h, mi] = m;
+    const date = new Date(Date.UTC(Number(y), Number(mo) - 1, Number(d), Number(h), Number(mi), 0));
+    if (Number.isNaN(date.getTime()))
+        return null;
+    return date;
+}
+/**
+ * Parse a `YYYY-MM-DD` date (interpreted as UTC midnight). Returns null
+ * on malformed input. Used by `--since` filtering.
+ */
+export function parseUtcDate(raw) {
+    const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(raw);
+    if (!m)
+        return null;
+    const [, y, mo, d] = m;
+    const date = new Date(Date.UTC(Number(y), Number(mo) - 1, Number(d), 0, 0, 0));
+    if (Number.isNaN(date.getTime()))
+        return null;
+    return date;
+}
+//# sourceMappingURL=parser.js.map