onadit 0.0.1 → 1.0.0

package/dist/src/server/routes/enqueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enqueue.d.ts","sourceRoot":"","sources":["../../../../src/server/routes/enqueue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAEpE,MAAM,WAAW,kBAAkB;IACjC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,wBAAsB,UAAU,CAC9B,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,QAAQ,EACf,IAAI,EAAE,OAAO,EACb,IAAI,CAAC,EAAE,kBAAkB,GACxB,OAAO,CAAC,eAAe,GAAG;IAAE,QAAQ,EAAE,IAAI,CAAA;CAAE,GAAG,SAAS,CAAC,CAgB3D"}

package/dist/src/server/routes/enqueue.js

@@ -0,0 +1,17 @@
+export async function enqueueJob(reply, queue, type, opts) {
+    try {
+        return await queue.create(type, opts);
+    }
+    catch (err) {
+        if (err instanceof Error &&
+            err.code === "queue_ledger_too_large") {
+            reply.code(503).send({
+                error: "queue_ledger_too_large",
+                message: err.message,
+            });
+            return undefined;
+        }
+        throw err;
+    }
+}
+//# sourceMappingURL=enqueue.js.map

package/dist/src/server/routes/enqueue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enqueue.js","sourceRoot":"","sources":["../../../../src/server/routes/enqueue.ts"],"names":[],"mappings":"AASA,MAAM,CAAC,KAAK,UAAU,UAAU,CAC9B,KAAmB,EACnB,KAAe,EACf,IAAa,EACb,IAAyB;IAEzB,IAAI,CAAC;QACH,OAAO,MAAM,KAAK,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACxC,CAAC;IAAC,OAAO,GAAY,EAAE,CAAC;QACtB,IACE,GAAG,YAAY,KAAK;YACnB,GAAyB,CAAC,IAAI,KAAK,wBAAwB,EAC5D,CAAC;YACD,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC;gBACnB,KAAK,EAAE,wBAAwB;gBAC/B,OAAO,EAAE,GAAG,CAAC,OAAO;aACrB,CAAC,CAAC;YACH,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC"}

package/dist/src/server/routes/friend-status.d.ts

@@ -0,0 +1,481 @@
+import type { FastifyInstance } from "fastify";
+import type { JobQueue } from "../../jobs/queue.js";
+import type { Job } from "../../jobs/types.js";
+import { type AutoCaptureTrigger } from "../../capture/observability.js";
+import { type CodexPreflightErrorClass } from "../../diagnostics/codex-preflight.js";
+import { type ClaudePreflightErrorClass } from "../../diagnostics/claude-preflight.js";
+import { type CodexModelSwitch } from "../../providers/codex-cli-model.js";
+import type { Config } from "../../config/schema.js";
+import { type MemoryCoverageDiagnostics } from "../../diagnostics/memory-coverage.js";
+import { type RetrievalTool } from "../../observability/onboarding-metric.js";
+import { getCapabilityCounts } from "../../observability/rift-context.js";
+/**
+ * Cheap presence probe for Claude Desktop agent/Cowork sessions. This only
+ * checks that the store directory exists and can be listed; transcript parsing
+ * remains in the capture pipeline.
+ */
+export declare function claudeDesktopSessionStoreAvailable(homeDir?: string): boolean;
+export interface FriendStatusBuild {
+    name: string;
+    version: string;
+    commit: string;
+    node: string;
+}
+export interface FriendStatusDaemon {
+    uptime_seconds: number;
+    port: number;
+    voyage_key_present: boolean;
+    /**
+     * Whether auto-capture is enabled in config. Lets the renderer tell an
+     * intentional no-key local install (capture off → "keyword on, semantic
+     * off" is the desired state) apart from one where a missing key actually
+     * blocks an enabled feature (capture on → flag the key). Optional for
+     * cross-version payload tolerance: an older daemon that omits it is treated
+     * as capture-off (the safe, "nothing is broken" default).
+     */
+    capture_enabled?: boolean;
+    /**
+     * Absolute path the daemon is actually using as its data root
+     * (config.data_paths.data_dir). Surfaced so operators inspecting state
+     * files hit the live folder instead of a stale Application Support
+     * copy left over from a previous install.
+     */
+    data_dir: string;
+    /**
+     * Absolute path to the config file this daemon actually booted with. Optional
+     * for cross-version tolerance. This prevents "fixing" a repo-local config
+     * while the live daemon is reading the Application Support config.
+     */
+    config_path?: string | null;
+}
+export interface FriendStatusVoyage {
+    project_label: string | null;
+    /**
+     * Most recent successful embedding call on an ingest pipeline (watcher,
+     * scheduled_scan, reconcile, ingest_job, compact, backfill). Null when
+     * the lane file is empty. Search-time embedding calls are excluded by
+     * construction — they don't write to this lane.
+     */
+    last_embed_at: string | null;
+    /**
+     * Most recent embedding error in the last 24h on any ingest pipeline,
+     * regardless of whether retries eventually succeeded. Null when no
+     * error in the window. Surfaces silent watcher failures that
+     * `last_embed_at` alone cannot.
+     */
+    last_error_at: string | null;
+    /**
+     * Compact reason class for `last_error_at` (e.g. "provider_400",
+     * "network", "unknown"). Null when `last_error_at` is null.
+     */
+    last_error_reason: string | null;
+}
+/**
+ * Which capture-triage worker the preflight ran. Drives WHICH remedies the
+ * status/doctor copy offers (`codex login` vs `claude` sign-in / upgrade). Taken
+ * from the configured `capture.triage.provider`, with the recorded error string
+ * as a tie-breaker so a failure is attributed to the worker that actually
+ * produced it even if config drifted since.
+ */
+export type PreflightWorker = "codex" | "claude";
+/**
+ * The preflight block. Field name stays `codex` for cross-version payload
+ * stability, but it now reports whichever triage worker ran (see
+ * `last_preflight_worker`): on a `claude_code` install the class/summary are
+ * Claude-shaped, not Codex-shaped.
+ */
+export interface FriendStatusCodex {
+    last_preflight_at: string | null;
+    last_preflight_ok: boolean | null;
+    /**
+     * Which worker this preflight ran (`codex` | `claude`). Optional/absent on a
+     * pre-this-slice daemon → readers treat absence as `codex` (the only worker
+     * then). Lets renderers pick Claude-specific copy without re-parsing.
+     */
+    last_preflight_worker?: PreflightWorker | null;
+    /**
+     * Coarse class of the last failed preflight — drives honest copy instead of
+     * the old hardcoded "auth expired". The class vocabulary depends on the
+     * worker (Codex: auth/model/binary/…; Claude: auth/incompatible/wrapper/…).
+     * Null when preflight succeeded or never ran. Optional so a pre-this-slice
+     * daemon (which omits it) stays cross-version compatible.
+     */
+    last_preflight_error_class?: CodexPreflightErrorClass | ClaudePreflightErrorClass | null;
+    /** The model codex ran under for the last preflight, when known (Codex only). */
+    last_preflight_model?: string | null;
+    /**
+     * Short, leak-free human summary of the last failure (canned per class — no
+     * raw stderr, no paths, no prompt/session content). Null when healthy.
+     */
+    last_preflight_error_summary?: string | null;
+    /**
+     * The last automatic Codex model switch, kept for a week: Codex refused
+     * `from` (retired, or not on the plan) and capture moved to `to`. Null when
+     * there was none. Optional so a pre-this-slice daemon stays compatible.
+     */
+    model_switch?: CodexModelSwitch | null;
+}
+export interface FriendStatusCapture {
+    last_run_at: string | null;
+    last_run_ok: boolean | null;
+    /**
+     * Who ran the newest capture: `daemon` (scheduled loop) or `manual`
+     * (`onadit capture`). Null when nothing has run yet; legacy untagged rows
+     * report as `daemon`. Lets the header say "last manual run" and lets the
+     * diagnosis tell a manual success apart from a scheduled tick. Optional:
+     * a pre-this-slice daemon omits it, so a newer CLI reads its absence as a
+     * plain daemon run (no split) — same cross-version tolerance as `inbox`.
+     */
+    last_run_trigger?: AutoCaptureTrigger | null;
+    last_saved: number;
+    last_review: number;
+    last_errors: number;
+    /**
+     * Sessions skipped before triage by the byte-size guard. Surfaced to the
+     * operator-side `--json` payload; the friend-readable header keeps these
+     * out of the "failed" count because quarantining is a graceful skip,
+     * not an error.
+     */
+    last_quarantined: number;
+    /**
+     * Distinct oversized Codex sessions still parked in `data/quarantine/`
+     * whose LATEST fingerprint hasn't been recovered yet — the honest
+     * state-of-the-world count, independent of which path the most recent run
+     * happened to take. Drives the heads-up advisory so it stops flickering as
+     * `last_quarantined` does. Optional: a pre-this-slice daemon omits it, so a
+     * newer CLI reads its absence as "none parked" rather than crashing.
+     */
+    oversized_parked?: number;
+    /**
+     * Of `oversized_parked`, how many Onadit is still auto-recovering in the
+     * background (retry budget not yet exhausted). Drives the calm "Onadit is
+     * saving N large Codex sessions to memory" copy. Optional: a pre-this-slice
+     * daemon omits it, and a newer CLI then derives it as `parked - failed`.
+     */
+    oversized_repairing?: number;
+    /**
+     * Of `oversized_parked`, how many exhausted their auto-repair retry budget
+     * and now need a manual `onadit doctor repair capture-large-sessions`. Drives
+     * the honest manual-fallback copy. Optional, same cross-version tolerance.
+     */
+    oversized_repair_failed?: number;
+    /**
+     * When the daemon's hourly auto-capture loop will tick next, anchored
+     * to the daemon's startTime (the same anchor `setInterval` uses, so
+     * this matches reality rather than approximating from last_run_at).
+     * Null when `config.capture.enabled` is false.
+     */
+    next_run_at: string | null;
+    /**
+     * The daemon's OWN latest scheduled run, independent of `last_run_*`.
+     * When an ad-hoc `onadit capture`/onboard run is the newest row, `last_run_*`
+     * reflect it but these still report the scheduled loop's last outcome — so
+     * an ad-hoc success can refresh status without masking a failing daemon.
+     * Null until the daemon has recorded a run. Optional: absent on payloads
+     * from a pre-this-slice daemon, where a newer CLI shows no split.
+     *
+     * `last_daemon_failed` is the FULL failure verdict (thrown run OR expired
+     * preflight OR per-session errors), not just `run_ok` — an expired Codex
+     * login completes with `run_ok: true, preflight_ok: false`, so a
+     * `run_ok`-only signal would let a manual success launder it green.
+     */
+    last_daemon_run_at?: string | null;
+    last_daemon_failed?: boolean | null;
+    /**
+     * Native-Cursor capture status, so the header can render four honest states:
+     * not installed (omit), installed-but-not-scheduled (offer the opt-in),
+     * scheduled-but-can't-read (warn), and scheduled+working (on). `scheduled` =
+     * `cursor_composer` is in `config.capture.sources`; `available` = a Cursor
+     * `state.vscdb` exists AND is readable on this machine; `last_discovery_ok` =
+     * whether the most recent run that actually ATTEMPTED Cursor discovery could
+     * read the store (false catches a present-but-unreadable store, e.g. missing
+     * `sqlite3` / corrupt query — which the file probe alone can't detect).
+     * Optional: a pre-this-slice daemon omits the block, and `last_discovery_ok`
+     * is itself absent until a run has attempted Cursor discovery.
+     */
+    cursor?: {
+        scheduled: boolean;
+        available: boolean;
+        last_discovery_ok?: boolean;
+    };
+    /**
+     * Claude Desktop agent/Cowork capture status. Same shape as Cursor:
+     * `scheduled` = `claude_desktop_sessions` is in config.capture.sources,
+     * `available` = the app-support session store exists and is readable, and
+     * `last_discovery_ok` = the most recent run that actually attempted Cowork
+     * discovery could read it.
+     */
+    grok_cli?: {
+        scheduled: boolean;
+    };
+    claude_desktop?: {
+        scheduled: boolean;
+        available: boolean;
+        last_discovery_ok?: boolean;
+    };
+}
+export interface FriendStatusFeedback {
+    /** A Clem-side relay is actually configured (opted in AND an endpoint URL). */
+    relay_enabled: boolean;
+    /** User opted in to stay-connected and shared a contact email. */
+    contact_opted_in?: boolean;
+}
+export interface FriendStatusIndex {
+    /**
+     * Most recent successful LanceDB row write across any table/pipeline.
+     * Distinct from `voyage.last_embed_at`: an embed can succeed but the
+     * subsequent `table.add(...)` can still fail (schema mismatch, lock
+     * contention, IO). Null when the lane file is empty.
+     */
+    last_update_at: string | null;
+    /**
+     * Most recent index-write error in the last 24h. Surfaces "embedded
+     * but not indexed" outages that `voyage.*` alone cannot reveal. Null
+     * when no error in the window.
+     */
+    last_error_at: string | null;
+    /**
+     * Compact reason class for `last_error_at` (e.g. "schema_mismatch",
+     * "lock_conflict", "io", "unknown"). Null when `last_error_at` is null.
+     */
+    last_error_reason: string | null;
+}
+export interface FriendStatusInbox {
+    /**
+     * Most recent successfully-ingested inbox drop, or null when nothing
+     * has been imported yet. Derived from completed ingest jobs whose
+     * idempotency key starts with `inbox:` — that prefix is what the
+     * inbox-watcher mints for every file it picks up, so it's the
+     * authoritative scope for this lane.
+     */
+    last_import_at: string | null;
+    /**
+     * Most recent inbox ingest failure in the last 24h. Surfaces drops
+     * that the parser couldn't accept (malformed JSON, unsupported zip
+     * contents, secure-archive rejection) without requiring the user to
+     * dig through the queue. Null when no failure in the window.
+     */
+    last_error_at: string | null;
+    /**
+     * Compact reason for `last_error_at` (a short snippet of the job's
+     * error message). Null when `last_error_at` is null. Best-effort —
+     * the queue doesn't carry a structured error class today, so this
+     * is a stable substring rather than a strict enum.
+     */
+    last_error_reason: string | null;
+    /**
+     * Inbox jobs currently queued or running. Zero when the lane is
+     * idle. Combined with `last_import_at` this answers "is the inbox
+     * keeping up?" at a glance.
+     */
+    pending: number;
+}
+export interface FriendStatusUpdate {
+    /**
+     * True when the daemon's most recent npm registry probe found a
+     * `latest_beta` strictly newer than the installed version. False on
+     * a fresh install (no probe yet), on a probe failure, or when
+     * already up-to-date — the renderer treats all three the same: stay
+     * silent. The friend never sees the update-check machinery itself.
+     */
+    available: boolean;
+    /** Version this daemon is running, mirrored for renderer convenience. */
+    installed: string;
+    /** Latest beta on the npm registry; null on a failed/missing probe. */
+    latest_beta: string | null;
+    /** ISO timestamp of the most recent probe attempt, or null if never run. */
+    checked_at: string | null;
+    /**
+     * Whether `onadit update` can upgrade this install in place. False for a
+     * packaged (.pkg) daemon, whose bundled app `npm install -g` never touches —
+     * `onadit update` deliberately refuses there, so every "update available"
+     * surface (status header, doctor, SwiftBar menu) must point at the .pkg
+     * download instead of offering `onadit update`. Optional so an older daemon
+     * that predates the field is read as `undefined` → renderers fall back to
+     * the historical `onadit update` action.
+     */
+    self_update_supported?: boolean;
+    /**
+     * Present and true when this copy runs from the package under its earlier
+     * npm name. `onadit update` stops there, so every "update available"
+     * surface points at the installer instead.
+     */
+    reinstall_needed?: boolean;
+}
+/**
+ * `time_to_first_useful_recall` projection. The route reads
+ * `data/metrics/onboarding.json` and folds it into one of three states:
+ *   - `hidden`: start condition has not been observed yet — the
+ *     renderer omits the line entirely so a friend who has just run
+ *     `onadit onboard` doesn't see a stale "0s" or empty placeholder.
+ *   - `pending`: start observed, no qualifying MCP retrieval yet.
+ *   - `completed`: both stamped; `duration_seconds` is end - start.
+ *
+ * Only the projection is exposed here; raw query/result content
+ * never enters this payload (the underlying metric file is itself
+ * limited to four fixed fields).
+ */
+export interface FriendStatusOnboarding {
+    state: "hidden" | "pending" | "completed";
+    install_id: string;
+    useful_state_reached_at: string | null;
+    first_useful_recall_at: string | null;
+    first_useful_recall_tool: RetrievalTool | null;
+    /** end - start, in whole seconds. Null until completed. */
+    duration_seconds: number | null;
+}
+export interface FriendStatusPayload {
+    build: FriendStatusBuild;
+    daemon: FriendStatusDaemon;
+    voyage: FriendStatusVoyage;
+    index: FriendStatusIndex;
+    inbox: FriendStatusInbox;
+    codex: FriendStatusCodex;
+    capture: FriendStatusCapture;
+    feedback: FriendStatusFeedback;
+    update: FriendStatusUpdate;
+    onboarding: FriendStatusOnboarding;
+    /**
+     * Conversation/digest/document coverage diagnosis. Optional so newer CLIs can
+     * read older daemons. Contains counts, config-derived states, and capped
+     * source probes — no document or conversation content.
+     */
+    memory?: MemoryCoverageDiagnostics;
+}
+export interface FriendStatusDeps {
+    config: Config;
+    startTime: number;
+    /** Absolute path to the active daemon config, when known. */
+    configPath?: string | null;
+    /**
+     * Job queue used to project the inbox lane. Optional so the route
+     * still renders before the queue is wired up (e.g., partial-boot
+     * fastify instances and tests) — the inbox block degrades to
+     * "nothing dropped yet" when absent.
+     */
+    jobQueue?: JobQueue;
+}
+export declare function buildFriendStatusPayload(deps: FriendStatusDeps, opts?: {
+    capabilityCounts?: Awaited<ReturnType<typeof getCapabilityCounts>> | null;
+}): FriendStatusPayload;
+/**
+ * Read the persisted metric and return its projection. Pure read — start
+ * stamping happens in the async `stampOnboardingStartIfReady` helper so
+ * the sync builder (and its test surface) stay sync. The route awaits
+ * the stamper before calling `buildFriendStatusPayload`, so a freshly
+ * stamped start is visible in the same response.
+ *
+ * Exported for tests.
+ */
+export declare function projectOnboardingState(dataDir: string): FriendStatusOnboarding;
+/**
+ * Async readiness evaluation + write-once start stamping. Pulled out of
+ * `buildFriendStatusPayload` so the sync builder stays sync; the route
+ * awaits this before assembling the payload, so a stamp written here
+ * is visible in the same response.
+ *
+ * Readiness signals for v1:
+ *   - daemon healthy: trivially true (this code is running inside the
+ *     daemon process that is serving the request).
+ *   - Voyage key valid: VOYAGE_API_KEY env present AND at least one
+ *     successful Voyage embedding has been recorded on the ingest lane
+ *     (a real round-trip with this key, not just "env var is set").
+ *   - indexed count >= 1: `getCapabilityCounts()` reports at least one
+ *     conversations_hot/cold or structured_docs row. Digest count is
+ *     intentionally excluded — the bar is "conversations + structured
+ *     docs" per the v1 spec.
+ *
+ * Never throws. A capability-counts failure (LanceDB not initialised,
+ * IO error) is treated as "not ready" rather than a 500, so a partial
+ * daemon never surfaces a misleading start timestamp.
+ *
+ * Exported for tests.
+ */
+export declare function stampOnboardingStartIfReady(dataDir: string, opts?: {
+    voyageHealth?: {
+        last_embed_at: string | null;
+    };
+    capabilityCounts?: Awaited<ReturnType<typeof getCapabilityCounts>> | null;
+    now?: number;
+}): Promise<void>;
+/**
+ * Project the version-check snapshot to the three fields the renderer
+ * needs. A missing snapshot, a failed probe, or an up-to-date install
+ * all return `available: false` — the renderer prints nothing in those
+ * cases, so an unreachable npm registry can never make Onadit look broken.
+ *
+ * Exported for tests.
+ */
+export declare function computeUpdateProjection(dataDir: string, installedVersion: string, selfUpdate?: boolean, reinstallNeeded?: boolean): FriendStatusUpdate;
+/**
+ * Compute the next auto-capture tick.
+ *
+ * The daemon registers `setInterval(runCapture, intervalMs)` at startup
+ * (`src/main.ts`), so ticks land at `startTime + N * intervalMs` for
+ * N ≥ 1 (N = 0 is the eager startup call). We deliberately anchor to
+ * `startTime` rather than `last_run_at` because:
+ *   - `setInterval` does, so this matches what will actually fire.
+ *   - `last_run_at` lags by hundreds of ms (save-job wait), and could
+ *     be stale from a prior daemon process for the first interval after
+ *     a restart.
+ *
+ * Returns null when auto-capture is disabled in config.
+ *
+ * Exported for tests.
+ */
+export declare function computeNextCaptureRunAt(opts: {
+    captureEnabled: boolean;
+    intervalSeconds: number;
+    startTime: number;
+    now: number;
+}): string | null;
+/**
+ * Reduce the embedding-events lane to the three voyage health fields the
+ * friend-status route needs.
+ *
+ * Exported for tests so we can verify the pipeline-filter and 24h-window
+ * logic without booting Fastify or stubbing the route layer.
+ */
+export declare function computeVoyageHealth(dataDir: string, now: number): {
+    last_embed_at: string | null;
+    last_error_at: string | null;
+    last_error_reason: string | null;
+};
+/**
+ * Reduce the index-events lane to the three index health fields the
+ * friend-status route needs. Provider-agnostic and table-agnostic: an
+ * embed can succeed but the subsequent `table.add(...)` can fail, and
+ * `index.*` is what makes that visible. No 24h filter on `last_update_at`
+ * (a daemon that has not indexed in 7 days should still surface the
+ * stale timestamp); errors are filtered to the 24h window so old
+ * resolved incidents don't sit on the dashboard forever.
+ */
+export declare function computeIndexHealth(dataDir: string, now: number): {
+    last_update_at: string | null;
+    last_error_at: string | null;
+    last_error_reason: string | null;
+};
+/**
+ * Reduce the inbox-keyed job set to the four fields the friend-status
+ * route needs. Pure over the queue's snapshot (no I/O), so tests can
+ * pass an in-memory `JobQueue` without booting Fastify.
+ *
+ * When the queue isn't wired up (deps.jobQueue undefined), this
+ * returns the empty / idle shape — the renderer treats it the same
+ * as "nothing dropped yet."
+ *
+ * Exported for tests.
+ */
+export declare function computeInboxHealth(queue: JobQueue | undefined, now: number): FriendStatusInbox;
+/**
+ * Best-effort short label for a failed inbox job's error. The queue
+ * stores the raw error message (`job.error`); we collapse it into a
+ * compact class keyword by substring match against the parser errors
+ * we know about, then fall back to a truncated form of the original
+ * message. Lower-cased for stability under capitalization drift.
+ *
+ * Exported for tests.
+ */
+export declare function classifyJobError(job: Job): string;
+export declare function registerFriendStatusRoute(server: FastifyInstance, deps: FriendStatusDeps): void;
+//# sourceMappingURL=friend-status.d.ts.map

package/dist/src/server/routes/friend-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"friend-status.d.ts","sourceRoot":"","sources":["../../../../src/server/routes/friend-status.ts"],"names":[],"mappings":"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"}