oh-my-opencode 4.8.1 → 4.9.1

package/packages/omo-codex/plugin/components/telemetry/dist/data-path.d.ts

@@ -0,0 +1,10 @@
+import os from "node:os";
+type OsProvider = Pick<typeof os, "homedir" | "tmpdir">;
+export declare function getOsProvider(): OsProvider;
+/** @internal test-only */
+export declare function __setOsProviderForTesting(provider: OsProvider): void;
+/** @internal test-only */
+export declare function __resetOsProviderForTesting(): void;
+export declare function getDataDir(): string;
+export declare function getActivityStateDir(): string;
+export {};

package/packages/omo-codex/plugin/components/telemetry/dist/data-path.js

@@ -0,0 +1,35 @@
+import { accessSync, constants, mkdirSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { CACHE_DIR_NAME } from "./product-identity.js";
+let osProviderOverride = null;
+export function getOsProvider() {
+    return osProviderOverride ?? os;
+}
+/** @internal test-only */
+export function __setOsProviderForTesting(provider) {
+    osProviderOverride = provider;
+}
+/** @internal test-only */
+export function __resetOsProviderForTesting() {
+    osProviderOverride = null;
+}
+function resolveWritableDirectory(preferredDir, fallbackSuffix) {
+    try {
+        mkdirSync(preferredDir, { recursive: true });
+        accessSync(preferredDir, constants.W_OK);
+        return preferredDir;
+    }
+    catch {
+        const fallbackDir = path.join(getOsProvider().tmpdir(), fallbackSuffix);
+        mkdirSync(fallbackDir, { recursive: true });
+        return fallbackDir;
+    }
+}
+export function getDataDir() {
+    const preferredDataDir = process.env["XDG_DATA_HOME"] ?? path.join(getOsProvider().homedir(), ".local", "share");
+    return resolveWritableDirectory(preferredDataDir, "omo-codex-data");
+}
+export function getActivityStateDir() {
+    return path.join(getDataDir(), CACHE_DIR_NAME);
+}

package/packages/omo-codex/plugin/components/telemetry/dist/diagnostics.d.ts

@@ -0,0 +1,12 @@
+export type TelemetryDiagnosticEvent = "telemetry_activity_state_read_failed" | "telemetry_activity_state_write_failed" | "telemetry_capture_failed" | "telemetry_cpu_info_unavailable" | "telemetry_posthog_import_failed" | "telemetry_posthog_init_failed" | "telemetry_shutdown_failed";
+export type TelemetryDiagnosticSource = "cli" | "install" | "plugin" | "shared";
+export type TelemetryDiagnosticErrorKind = "error" | "non_error";
+export type TelemetryDiagnosticInput = {
+    readonly event: TelemetryDiagnosticEvent;
+    readonly source: TelemetryDiagnosticSource;
+    readonly error?: unknown;
+    readonly errorKind?: TelemetryDiagnosticErrorKind;
+};
+export declare function getTelemetryDiagnosticsFilePath(): string;
+export declare function writeTelemetryDiagnostic(input: TelemetryDiagnosticInput, now?: Date): void;
+export declare function cleanupTelemetryDiagnostics(now?: Date): void;

package/packages/omo-codex/plugin/components/telemetry/dist/diagnostics.js

@@ -0,0 +1,108 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { writeFileAtomically } from "./atomic-write.js";
+import { getActivityStateDir } from "./data-path.js";
+const DIAGNOSTICS_FILE_NAME = "telemetry-diagnostics.jsonl";
+const DIAGNOSTICS_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+const DIAGNOSTICS_MAX_BYTES = 256 * 1024;
+export function getTelemetryDiagnosticsFilePath() {
+    return join(getActivityStateDir(), DIAGNOSTICS_FILE_NAME);
+}
+export function writeTelemetryDiagnostic(input, now = new Date()) {
+    try {
+        cleanupTelemetryDiagnostics(now);
+        mkdirSync(getActivityStateDir(), { recursive: true });
+        appendFileSync(getTelemetryDiagnosticsFilePath(), `${JSON.stringify(toDiagnosticRecord(input, now))}\n`, "utf-8");
+    }
+    catch {
+        return;
+    }
+}
+export function cleanupTelemetryDiagnostics(now = new Date()) {
+    const diagnosticsFilePath = getTelemetryDiagnosticsFilePath();
+    if (!existsSync(diagnosticsFilePath)) {
+        return;
+    }
+    try {
+        const cutoffMs = now.getTime() - DIAGNOSTICS_RETENTION_MS;
+        const retainedLines = trimToMaxBytes(readFileSync(diagnosticsFilePath, "utf-8")
+            .split("\n")
+            .filter((line) => shouldRetainLine(line, cutoffMs)));
+        writeFileAtomically(diagnosticsFilePath, retainedLines.length === 0 ? "" : `${retainedLines.join("\n")}\n`);
+    }
+    catch {
+        return;
+    }
+}
+function toDiagnosticRecord(input, now) {
+    return {
+        timestamp: now.toISOString(),
+        event: input.event,
+        source: input.source,
+        ...serializeError(input.error, input.errorKind),
+    };
+}
+function serializeError(error, errorKind) {
+    if (error instanceof Error) {
+        return {
+            error_kind: errorKind ?? "error",
+            error_name: error.name,
+            error_message: error.message,
+        };
+    }
+    if (error === undefined) {
+        return {};
+    }
+    return {
+        error_kind: errorKind ?? "non_error",
+        error_name: typeof error,
+        error_message: String(error),
+    };
+}
+function shouldRetainLine(line, cutoffMs) {
+    if (line.length === 0) {
+        return false;
+    }
+    const parsed = parseDiagnosticLine(line);
+    if (parsed === null) {
+        return false;
+    }
+    const timestamp = parsed["timestamp"];
+    if (typeof timestamp !== "string") {
+        return false;
+    }
+    const timestampMs = Date.parse(timestamp);
+    return Number.isFinite(timestampMs) && timestampMs >= cutoffMs;
+}
+function parseDiagnosticLine(line) {
+    try {
+        const parsed = JSON.parse(line);
+        if (!isRecord(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function trimToMaxBytes(lines) {
+    const retained = [];
+    let totalBytes = 0;
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        const line = lines[index];
+        if (line === undefined) {
+            continue;
+        }
+        const lineBytes = Buffer.byteLength(`${line}\n`, "utf-8");
+        if (totalBytes + lineBytes > DIAGNOSTICS_MAX_BYTES) {
+            break;
+        }
+        retained.unshift(line);
+        totalBytes += lineBytes;
+    }
+    return retained;
+}

package/packages/omo-codex/plugin/components/telemetry/dist/env-flags.d.ts

@@ -0,0 +1,4 @@
+export declare function shouldDisablePostHog(): boolean;
+export declare function getPostHogApiKey(): string;
+export declare function hasPostHogApiKey(): boolean;
+export declare function getPostHogHost(): string;

package/packages/omo-codex/plugin/components/telemetry/dist/env-flags.js

@@ -0,0 +1,31 @@
+import { DEFAULT_POSTHOG_API_KEY, DEFAULT_POSTHOG_HOST, } from "./product-identity.js";
+function normalizeEnvValue(value) {
+    return value?.trim().toLowerCase();
+}
+function isDisableFlag(value) {
+    const normalized = normalizeEnvValue(value);
+    return normalized === "1" || normalized === "true";
+}
+function isTelemetryOptOutFlag(value) {
+    const normalized = normalizeEnvValue(value);
+    return normalized === "0" || normalized === "false" || normalized === "no";
+}
+export function shouldDisablePostHog() {
+    return (isDisableFlag(process.env["OMO_DISABLE_POSTHOG"]) ||
+        isTelemetryOptOutFlag(process.env["OMO_SEND_ANONYMOUS_TELEMETRY"]) ||
+        isDisableFlag(process.env["OMO_CODEX_DISABLE_POSTHOG"]) ||
+        isTelemetryOptOutFlag(process.env["OMO_CODEX_SEND_ANONYMOUS_TELEMETRY"]));
+}
+export function getPostHogApiKey() {
+    const explicit = process.env["POSTHOG_API_KEY"];
+    if (explicit === undefined) {
+        return DEFAULT_POSTHOG_API_KEY;
+    }
+    return explicit.trim();
+}
+export function hasPostHogApiKey() {
+    return getPostHogApiKey().length > 0;
+}
+export function getPostHogHost() {
+    return process.env["POSTHOG_HOST"]?.trim() || DEFAULT_POSTHOG_HOST;
+}

package/packages/omo-codex/plugin/components/telemetry/dist/posthog-activity-state.d.ts

@@ -0,0 +1,8 @@
+export type PostHogActivityState = {
+    readonly lastActiveDayUTC?: string;
+};
+export type PostHogActivityCaptureState = {
+    readonly dayUTC: string;
+    readonly captureDaily: boolean;
+};
+export declare function getPostHogActivityCaptureState(now?: Date): PostHogActivityCaptureState;

package/packages/omo-codex/plugin/components/telemetry/dist/posthog-activity-state.js

@@ -0,0 +1,68 @@
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { writeFileAtomically } from "./atomic-write.js";
+import { getActivityStateDir } from "./data-path.js";
+import { writeTelemetryDiagnostic } from "./diagnostics.js";
+const POSTHOG_ACTIVITY_STATE_FILE = "posthog-activity.json";
+function getPostHogActivityStateFilePath() {
+    return join(getActivityStateDir(), POSTHOG_ACTIVITY_STATE_FILE);
+}
+function getUtcDayString(date) {
+    return date.toISOString().slice(0, 10);
+}
+function isPostHogActivityState(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function writeActivityStateDiagnostic(event, error, errorKind) {
+    writeTelemetryDiagnostic({
+        event,
+        source: "shared",
+        error,
+        errorKind,
+    });
+}
+function readPostHogActivityState() {
+    const stateFilePath = getPostHogActivityStateFilePath();
+    if (!existsSync(stateFilePath)) {
+        return {};
+    }
+    try {
+        const stateContent = readFileSync(stateFilePath, "utf-8");
+        const stateJson = JSON.parse(stateContent);
+        if (!isPostHogActivityState(stateJson)) {
+            return {};
+        }
+        return stateJson;
+    }
+    catch (error) {
+        writeActivityStateDiagnostic("telemetry_activity_state_read_failed", error, error instanceof Error ? "error" : "non_error");
+        return {};
+    }
+}
+function writePostHogActivityState(nextState) {
+    const stateDir = getActivityStateDir();
+    const stateFilePath = getPostHogActivityStateFilePath();
+    try {
+        mkdirSync(stateDir, { recursive: true });
+        writeFileAtomically(stateFilePath, `${JSON.stringify(nextState, null, 2)}\n`);
+    }
+    catch (error) {
+        writeActivityStateDiagnostic("telemetry_activity_state_write_failed", error, error instanceof Error ? "error" : "non_error");
+        return;
+    }
+}
+export function getPostHogActivityCaptureState(now = new Date()) {
+    const state = readPostHogActivityState();
+    const dayUTC = getUtcDayString(now);
+    const captureDaily = state.lastActiveDayUTC !== dayUTC;
+    if (captureDaily) {
+        writePostHogActivityState({
+            ...state,
+            lastActiveDayUTC: dayUTC,
+        });
+    }
+    return {
+        dayUTC,
+        captureDaily,
+    };
+}

package/packages/omo-codex/plugin/components/telemetry/dist/posthog.d.ts

@@ -0,0 +1,21 @@
+import os from "node:os";
+import { getPostHogActivityCaptureState } from "./posthog-activity-state.js";
+import { DEFAULT_POSTHOG_API_KEY, DEFAULT_POSTHOG_HOST } from "./product-identity.js";
+export { DEFAULT_POSTHOG_API_KEY, DEFAULT_POSTHOG_HOST };
+export type PostHogActivityReason = "session_start";
+export type PostHogClient = {
+    trackActive: (distinctId: string, reason: PostHogActivityReason) => void;
+    shutdown: () => Promise<void>;
+};
+type OsProvider = Pick<typeof os, "arch" | "cpus" | "hostname" | "platform" | "release" | "totalmem" | "type">;
+type ActivityStateProvider = typeof getPostHogActivityCaptureState;
+export declare function createPluginPostHog(): Promise<PostHogClient>;
+export declare function getPostHogDistinctId(): string;
+/** @internal test-only */
+export declare function __setOsProviderForTesting(provider: OsProvider): void;
+/** @internal test-only */
+export declare function __resetOsProviderForTesting(): void;
+/** @internal test-only */
+export declare function __setActivityStateProviderForTesting(provider: ActivityStateProvider): void;
+/** @internal test-only */
+export declare function __resetActivityStateProviderForTesting(): void;

package/packages/omo-codex/plugin/components/telemetry/dist/posthog.js

@@ -0,0 +1,133 @@
+import { createHash } from "node:crypto";
+import os from "node:os";
+import { writeTelemetryDiagnostic, } from "./diagnostics.js";
+import { getPostHogApiKey, getPostHogHost, hasPostHogApiKey, shouldDisablePostHog } from "./env-flags.js";
+import { getPostHogActivityCaptureState } from "./posthog-activity-state.js";
+import { DEFAULT_POSTHOG_API_KEY, DEFAULT_POSTHOG_HOST, EVENT_NAME, getComponentVersion, PACKAGE_NAME, PRODUCT_NAME, } from "./product-identity.js";
+export { DEFAULT_POSTHOG_API_KEY, DEFAULT_POSTHOG_HOST };
+let osProviderOverride = null;
+let activityStateProviderOverride = null;
+const NO_OP_POSTHOG = {
+    trackActive: () => undefined,
+    shutdown: async () => undefined,
+};
+function resolveOsProvider() {
+    return osProviderOverride ?? os;
+}
+function resolveActivityStateProvider() {
+    return activityStateProviderOverride ?? getPostHogActivityCaptureState;
+}
+function writePostHogDiagnostic(event, source, error, errorKind) {
+    writeTelemetryDiagnostic({ event, source, error, errorKind });
+}
+function getSafeCpuInfo() {
+    try {
+        const cpuInfo = resolveOsProvider().cpus();
+        return {
+            count: cpuInfo.length,
+            model: cpuInfo[0]?.model,
+        };
+    }
+    catch (error) {
+        writePostHogDiagnostic("telemetry_cpu_info_unavailable", "plugin", error, error instanceof Error ? "error" : "non_error");
+        return {
+            count: 0,
+            model: undefined,
+        };
+    }
+}
+function getSharedProperties() {
+    const osProvider = resolveOsProvider();
+    const cpuInfo = getSafeCpuInfo();
+    return {
+        platform: "omo-codex",
+        product_name: PRODUCT_NAME,
+        package_name: PACKAGE_NAME,
+        package_version: getComponentVersion(),
+        runtime: "node",
+        runtime_version: process.version,
+        source: "plugin",
+        $os: osProvider.platform(),
+        $os_version: osProvider.release(),
+        os_arch: osProvider.arch(),
+        os_type: osProvider.type(),
+        cpu_count: cpuInfo.count,
+        cpu_model: cpuInfo.model,
+        total_memory_gb: Math.round(osProvider.totalmem() / 1024 / 1024 / 1024),
+        locale: Intl.DateTimeFormat().resolvedOptions().locale,
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        shell: process.env["SHELL"],
+        ci: Boolean(process.env["CI"]),
+        terminal: process.env["TERM_PROGRAM"],
+    };
+}
+export async function createPluginPostHog() {
+    if (shouldDisablePostHog() || !hasPostHogApiKey()) {
+        return NO_OP_POSTHOG;
+    }
+    let PostHogClientConstructor;
+    try {
+        const module = await import("posthog-node");
+        PostHogClientConstructor = module.PostHog;
+    }
+    catch (error) {
+        writePostHogDiagnostic("telemetry_posthog_import_failed", "plugin", error, error instanceof Error ? "error" : "non_error");
+        return NO_OP_POSTHOG;
+    }
+    let client;
+    try {
+        client = new PostHogClientConstructor(getPostHogApiKey(), {
+            enableExceptionAutocapture: false,
+            enableLocalEvaluation: false,
+            strictLocalEvaluation: true,
+            disableRemoteConfig: true,
+            flushAt: 1,
+            flushInterval: 0,
+            host: getPostHogHost(),
+            disableGeoip: false,
+        });
+    }
+    catch (error) {
+        writePostHogDiagnostic("telemetry_posthog_init_failed", "plugin", error, error instanceof Error ? "error" : "non_error");
+        return NO_OP_POSTHOG;
+    }
+    const sharedProperties = getSharedProperties();
+    return {
+        trackActive: (distinctId, reason) => {
+            const activityState = resolveActivityStateProvider()();
+            if (!activityState.captureDaily) {
+                return;
+            }
+            client.capture({
+                distinctId,
+                event: EVENT_NAME,
+                properties: {
+                    ...sharedProperties,
+                    $process_person_profile: false,
+                    day_utc: activityState.dayUTC,
+                    reason,
+                },
+            });
+        },
+        shutdown: async () => client.shutdown(),
+    };
+}
+export function getPostHogDistinctId() {
+    return createHash("sha256").update(`omo-codex:${resolveOsProvider().hostname()}`).digest("hex");
+}
+/** @internal test-only */
+export function __setOsProviderForTesting(provider) {
+    osProviderOverride = provider;
+}
+/** @internal test-only */
+export function __resetOsProviderForTesting() {
+    osProviderOverride = null;
+}
+/** @internal test-only */
+export function __setActivityStateProviderForTesting(provider) {
+    activityStateProviderOverride = provider;
+}
+/** @internal test-only */
+export function __resetActivityStateProviderForTesting() {
+    activityStateProviderOverride = null;
+}

package/packages/omo-codex/plugin/components/telemetry/dist/product-identity.d.ts

@@ -0,0 +1,8 @@
+export declare const PRODUCT_NAME = "omo-codex";
+export declare const PACKAGE_NAME = "@oh-my-opencode/omo-codex";
+export declare const CACHE_DIR_NAME = "omo-codex";
+export declare const EVENT_NAME = "omo_codex_daily_active";
+export declare const LEGACY_PARENT_PACKAGE = "oh-my-opencode";
+export declare const DEFAULT_POSTHOG_HOST = "https://us.i.posthog.com";
+export declare const DEFAULT_POSTHOG_API_KEY = "phc_CFJhj5HyvA62QPhvyaUCtaq23aUfznnijg5VaaGkNk74";
+export declare function getComponentVersion(): string;

package/packages/omo-codex/plugin/components/telemetry/dist/product-identity.js

@@ -0,0 +1,29 @@
+import { readFileSync } from "node:fs";
+export const PRODUCT_NAME = "omo-codex";
+export const PACKAGE_NAME = "@oh-my-opencode/omo-codex";
+export const CACHE_DIR_NAME = "omo-codex";
+export const EVENT_NAME = "omo_codex_daily_active";
+export const LEGACY_PARENT_PACKAGE = "oh-my-opencode";
+export const DEFAULT_POSTHOG_HOST = "https://us.i.posthog.com";
+export const DEFAULT_POSTHOG_API_KEY = "phc_CFJhj5HyvA62QPhvyaUCtaq23aUfznnijg5VaaGkNk74";
+function isComponentPackageManifest(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readComponentVersionFromManifest() {
+    try {
+        const manifestUrl = new URL("../package.json", import.meta.url);
+        const manifestText = readFileSync(manifestUrl, "utf-8");
+        const parsed = JSON.parse(manifestText);
+        if (isComponentPackageManifest(parsed) && typeof parsed.version === "string") {
+            return parsed.version;
+        }
+    }
+    catch {
+        return "0.0.0";
+    }
+    return "0.0.0";
+}
+const COMPONENT_VERSION_CACHE = readComponentVersionFromManifest();
+export function getComponentVersion() {
+    return COMPONENT_VERSION_CACHE;
+}

package/packages/omo-codex/plugin/components/telemetry/hooks/hooks.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook session-start",
 						"timeout": 5,
-						"statusMessage": "LazyCodex(0.1.0): Recording Session Telemetry"
+						"statusMessage": "LazyCodex(4.9.1): Recording Session Telemetry"
 					}
 				]
 			}

package/packages/omo-codex/plugin/components/telemetry/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-telemetry",
-	"version": "0.1.0",
+	"version": "4.9.1",
 	"description": "Codex plugin component that emits omo-codex anonymous daily-active telemetry on SessionStart.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

package/packages/omo-codex/plugin/components/ultrawork/agents/explorer.toml

@@ -13,7 +13,7 @@ Answer the orchestrator's "Where is X?" / "Which files do Y?" / "Find code that
 
 # When to invoke me (self-check)
 - USE me when: multiple search angles are needed, the module structure is unfamiliar, or cross-layer pattern discovery is required.
-- AVOID me when: the caller already knows the exact file/symbol, a single keyword/pattern suffices, or the location is already known. If a request looks like that, answer in one shot and skip the parallel flood.
+- AVOID me when: the caller already knows the exact file or symbol, or a single keyword search suffices. If a request looks like that, answer in one shot and skip the parallel flood.
 
 # Thoroughness
 The caller MAY specify thoroughness. Honor it:
@@ -56,7 +56,10 @@ If asked "where is auth?", explain the auth flow you found.]
 
 Fire 3+ independent calls in the first action. Cross-validate findings across multiple tools. Do not serialize unless one call's output strictly feeds the next.
 
-# Success criteria
+# Retrieval budget
+Stop searching when the question is concretely answered. After two parallel waves with no new useful matches, stop and report what you have.
+
+# Success criteria (the response is INVALID if any is unmet)
 - Every path is **absolute** (starts with `/`).
 - ALL relevant matches are included, not just the first one.
 - The answer addresses the **actual need**, not only the literal request.
@@ -69,15 +72,4 @@ Fire 3+ independent calls in the first action. Cross-validate findings across mu
 - Do not browse the internet. External research is the librarian's job.
 - No emojis. Keep output clean and parseable.
 - No tool names in prose (say "search the codebase", not "use rg"). No preamble ("I'll help you with..."). Answer directly.
-
-# Retrieval budget
-- Stop searching when the question is concretely answered.
-- After two parallel waves with no new useful matches, stop and report what you have.
-
-# Failure conditions (response is INVALID if)
-- Any path is relative.
-- Obvious matches missed.
-- The caller would need to ask a follow-up.
-- Only the literal question is answered while the underlying need is ignored.
-- Missing `<analysis>` or `<results>` block.
 """