calendit 1.0.2 → 2026.4.26

package/dist/core/accountStatus.js

@@ -0,0 +1,74 @@
+import { buildAuthStatusRows } from "./authStatus.js";
+import { eventkitDoctorJson, eventkitListCalendarsJson, hasEventkitTransport, } from "./eventkitHelper.js";
+async function evaluateMacosContext(ctx) {
+    const fallbackAccount = ctx.accountId ?? "(default)";
+    if (process.env.CALENDIT_MOCK === "true") {
+        return { connection: "OK", account: fallbackAccount };
+    }
+    if (process.platform !== "darwin") {
+        return { connection: "N/A (non-macOS)", account: fallbackAccount };
+    }
+    if (!hasEventkitTransport()) {
+        return { connection: "NO HELPER", account: fallbackAccount };
+    }
+    try {
+        const doc = await eventkitDoctorJson();
+        if (!doc.ok) {
+            return { connection: "HELPER ERROR", account: fallbackAccount };
+        }
+        if (doc.calendarAccess !== "authorized") {
+            return { connection: "NO CALENDAR ACCESS", account: fallbackAccount };
+        }
+        const list = await eventkitListCalendarsJson();
+        const cal = list.calendars?.find((c) => c.calendarIdentifier === ctx.calendarId);
+        const viaBridge = doc.transport === "bridge";
+        const connection = cal
+            ? viaBridge
+                ? "OK (bridge)"
+                : "OK"
+            : "CALENDAR NOT FOUND";
+        const sourceLike = cal?.sourceTitle?.trim() || cal?.title?.trim();
+        const account = sourceLike || fallbackAccount;
+        return { connection, account };
+    }
+    catch {
+        return { connection: "HELPER ERROR", account: fallbackAccount };
+    }
+}
+export async function buildAccountStatusRows(contexts, deps) {
+    const entries = Object.entries(contexts).sort(([a], [b]) => a.localeCompare(b));
+    const rows = [];
+    for (const [contextName, ctx] of entries) {
+        const account = ctx.accountId ?? "(default)";
+        if (ctx.service === "macos") {
+            const { connection, account: macosAccount } = await evaluateMacosContext(ctx);
+            rows.push({
+                context: contextName,
+                service: "macos",
+                calendar: ctx.calendarId,
+                account: macosAccount,
+                connection,
+            });
+            continue;
+        }
+        const single = await buildAuthStatusRows({ [contextName]: ctx }, deps);
+        const r = single[0];
+        rows.push({
+            context: r.context,
+            service: r.service,
+            calendar: r.calendar,
+            account: r.account,
+            connection: r.token,
+        });
+    }
+    return rows;
+}
+export function formatAccountStatusTable(rows) {
+    const headers = ["CONTEXT", "SERVICE", "CALENDAR", "ACCOUNT", "CONNECTION"];
+    const dataRows = rows.map((r) => [r.context, r.service, r.calendar, r.account, r.connection]);
+    const all = [headers, ...dataRows.map((cols) => cols.map(String))];
+    const widths = headers.map((_, colIdx) => Math.max(...all.map((row) => row[colIdx].length)));
+    const sep = widths.map((w) => "-".repeat(w)).join("   ");
+    const fmt = (cols) => cols.map((c, i) => c.padEnd(widths[i])).join("   ");
+    return [fmt(headers), sep, ...dataRows.map((cols) => fmt(cols.map(String)))].join("\n");
+}

package/dist/core/auth.js

@@ -2,17 +2,12 @@ import { PublicClientApplication } from "@azure/msal-node";
 import { KeychainPersistence, PersistenceCachePlugin } from "@azure/msal-node-extensions";
 import { google } from "googleapis";
 import * as path from "path";
-import * as os from "os";
 import * as fs from "fs/promises";
 import * as http from "http";
 import open from "open";
 import { AuthError } from "./errors.js";
 import { logger } from "./logger.js";
-const CONFIG_DIR = path.join(os.homedir(), ".config", "calendit");
-function getTokenPath(name) {
-    const filename = name ? `google_token_${name}.json` : "google_token.json";
-    return path.join(CONFIG_DIR, filename);
-}
+import { getCalenditConfigDir, getGoogleTokenFilePath } from "./config.js";
 export class AuthManager {
     msalClient;
     constructor() { }
@@ -21,8 +16,9 @@ export class AuthManager {
      */
     async getOutlookClient(clientId, tenantId = "common") {
         if (!this.msalClient) {
-            await fs.mkdir(CONFIG_DIR, { recursive: true });
-            const cachePath = path.join(CONFIG_DIR, "msal_cache.json");
+            const configDir = getCalenditConfigDir();
+            await fs.mkdir(configDir, { recursive: true });
+            const cachePath = path.join(configDir, "msal_cache.json");
             const persistence = await KeychainPersistence.create(cachePath, "calendit-service", "outlook-account");
             const cachePlugin = new PersistenceCachePlugin(persistence);
             const msalConfig = {
@@ -43,7 +39,7 @@ export class AuthManager {
      */
     async getGoogleAuth(clientId, clientSecret, accountId) {
         const oauth2Client = new google.auth.OAuth2(clientId, clientSecret, "http://localhost:3000");
-        const tokenPath = getTokenPath(accountId);
+        const tokenPath = getGoogleTokenFilePath(accountId);
         try {
             const tokenData = await fs.readFile(tokenPath, "utf-8");
             oauth2Client.setCredentials(JSON.parse(tokenData));
@@ -58,7 +54,7 @@ export class AuthManager {
      */
     async loginGoogle(clientId, clientSecret, accountId) {
         const oauth2Client = new google.auth.OAuth2(clientId, clientSecret, "http://localhost:3000");
-        const tokenPath = getTokenPath(accountId);
+        const tokenPath = getGoogleTokenFilePath(accountId);
         const authUrl = oauth2Client.generateAuthUrl({
             access_type: "offline",
             scope: ["https://www.googleapis.com/auth/calendar"],
@@ -79,7 +75,7 @@ export class AuthManager {
                     const code = url.searchParams.get("code");
                     if (code) {
                         const { tokens } = await oauth2Client.getToken(code);
-                        await fs.mkdir(CONFIG_DIR, { recursive: true });
+                        await fs.mkdir(getCalenditConfigDir(), { recursive: true });
                         await fs.writeFile(tokenPath, JSON.stringify(tokens, null, 2));
                         res.end("Authentication successful! You can close this tab and return to the terminal.");
                         clearTimeout(timeout);

package/dist/core/authStatus.d.ts

@@ -0,0 +1,20 @@
+import type { ContextConfig } from "../types/index.js";
+import type { OutlookCredentials } from "../types/index.js";
+import type { AuthManager } from "./auth.js";
+export type AuthTokenColumn = "OK" | "NOT LOGGED IN" | "EXPIRED" | "NOT CONFIGURED";
+export interface AuthStatusRow {
+    context: string;
+    service: string;
+    calendar: string;
+    account: string;
+    token: AuthTokenColumn;
+}
+/** `getServiceForContext` と同じトークンキー */
+export declare function googleTokenKeyForContext(contextName: string, ctx: ContextConfig): string | undefined;
+export declare function evaluateGoogleToken(tokenPath: string): Promise<AuthTokenColumn>;
+export declare function evaluateOutlookToken(auth: AuthManager, creds: OutlookCredentials, ctx: ContextConfig): Promise<AuthTokenColumn>;
+export declare function buildAuthStatusRows(contexts: Record<string, ContextConfig>, deps: {
+    auth: AuthManager;
+    outlookCreds?: OutlookCredentials;
+}): Promise<AuthStatusRow[]>;
+export declare function formatAuthStatusTable(rows: AuthStatusRow[]): string;

package/dist/core/authStatus.js

@@ -0,0 +1,82 @@
+import * as fs from "fs/promises";
+import { getGoogleTokenFilePath } from "./config.js";
+/** `getServiceForContext` と同じトークンキー */
+export function googleTokenKeyForContext(contextName, ctx) {
+    return contextName || ctx.accountId;
+}
+export async function evaluateGoogleToken(tokenPath) {
+    try {
+        const raw = await fs.readFile(tokenPath, "utf-8");
+        const data = JSON.parse(raw);
+        const now = Date.now();
+        if (data.expiry_date !== undefined && data.expiry_date > now) {
+            return "OK";
+        }
+        if (data.refresh_token) {
+            return "OK";
+        }
+        if (data.expiry_date !== undefined && data.expiry_date <= now) {
+            return "EXPIRED";
+        }
+        return "NOT LOGGED IN";
+    }
+    catch {
+        return "NOT LOGGED IN";
+    }
+}
+export async function evaluateOutlookToken(auth, creds, ctx) {
+    const pca = await auth.getOutlookClient(creds.id, creds.tenantId);
+    const accounts = await pca.getTokenCache().getAllAccounts();
+    if (accounts.length === 0) {
+        return "NOT LOGGED IN";
+    }
+    if (!ctx.accountId) {
+        return "OK";
+    }
+    const match = accounts.find((a) => a.username === ctx.accountId || a.homeAccountId === ctx.accountId);
+    return match ? "OK" : "NOT LOGGED IN";
+}
+export function buildAuthStatusRows(contexts, deps) {
+    const entries = Object.entries(contexts).sort(([a], [b]) => a.localeCompare(b));
+    return Promise.all(entries.map(async ([contextName, ctx]) => {
+        const account = ctx.accountId ?? "(default)";
+        if (ctx.service === "google") {
+            const tokenKey = googleTokenKeyForContext(contextName, ctx);
+            const tokenPath = getGoogleTokenFilePath(tokenKey);
+            const token = await evaluateGoogleToken(tokenPath);
+            return {
+                context: contextName,
+                service: "google",
+                calendar: ctx.calendarId,
+                account,
+                token,
+            };
+        }
+        if (!deps.outlookCreds) {
+            return {
+                context: contextName,
+                service: "outlook",
+                calendar: ctx.calendarId,
+                account,
+                token: "NOT CONFIGURED",
+            };
+        }
+        const token = await evaluateOutlookToken(deps.auth, deps.outlookCreds, ctx);
+        return {
+            context: contextName,
+            service: "outlook",
+            calendar: ctx.calendarId,
+            account,
+            token,
+        };
+    }));
+}
+export function formatAuthStatusTable(rows) {
+    const headers = ["CONTEXT", "SERVICE", "CALENDAR", "ACCOUNT", "TOKEN"];
+    const dataRows = rows.map((r) => [r.context, r.service, r.calendar, r.account, r.token]);
+    const all = [headers, ...dataRows.map((cols) => cols.map(String))];
+    const widths = headers.map((_, colIdx) => Math.max(...all.map((row) => row[colIdx].length)));
+    const sep = widths.map((w) => "-".repeat(w)).join("   ");
+    const fmt = (cols) => cols.map((c, i) => c.padEnd(widths[i])).join("   ");
+    return [fmt(headers), sep, ...dataRows.map((cols) => fmt(cols.map(String)))].join("\n");
+}

package/dist/core/config.d.ts

@@ -1,7 +1,15 @@
-import { ContextConfig, GoogleCredentials, OutlookCredentials } from "../types/index.js";
+import { AppEventkitConfig, AppUiConfig, ContextConfig, GoogleCredentials, OutlookCredentials } from "../types/index.js";
+export declare function getCalenditConfigDir(): string;
+/** Google OAuth トークンファイルの絶対パス（`auth login` と `getServiceForContext` と同一ルール） */
+export declare function getGoogleTokenFilePath(accountId?: string): string;
 export declare class ConfigManager {
     private config;
     constructor();
+    getUi(): AppUiConfig | undefined;
+    setUi(ui: AppUiConfig): void;
+    /** Replace in-memory config with minimal file (first-run language choice). */
+    resetMinimalWithUi(locale: "en" | "ja"): void;
+    loadOptional(): Promise<boolean>;
     load(): Promise<void>;
     save(): Promise<void>;
     getContext(name: string): ContextConfig | undefined;
@@ -12,4 +20,6 @@ export declare class ConfigManager {
     setGoogleCreds(id: string, secret: string): void;
     getOutlookCreds(): OutlookCredentials | undefined;
     setOutlookCreds(id: string, tenantId: string): void;
+    getEventkitDefaultTransport(): AppEventkitConfig["defaultTransport"] | undefined;
+    setEventkitDefaultTransport(value: AppEventkitConfig["defaultTransport"]): void;
 }

package/dist/core/config.js

@@ -3,15 +3,28 @@ import * as path from "path";
 import * as os from "os";
 import { z } from "zod";
 import { ConfigError } from "./errors.js";
-const CONFIG_DIR = process.env.CALENDIT_CONFIG_DIR || path.join(os.homedir(), ".config", "calendit");
+import { t } from "./i18n.js";
+export function getCalenditConfigDir() {
+    return process.env.CALENDIT_CONFIG_DIR || path.join(os.homedir(), ".config", "calendit");
+}
+/** Google OAuth トークンファイルの絶対パス（`auth login` と `getServiceForContext` と同一ルール） */
+export function getGoogleTokenFilePath(accountId) {
+    const filename = accountId ? `google_token_${accountId}.json` : "google_token.json";
+    return path.join(getCalenditConfigDir(), filename);
+}
+const CONFIG_DIR = getCalenditConfigDir();
 const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
 const contextConfigSchema = z.object({
-    service: z.enum(["google", "outlook"]),
+    service: z.enum(["google", "outlook", "macos"]),
     calendarId: z.string().min(1),
     accountId: z.string().optional(),
     fields: z.array(z.string()).optional(),
     defaultFormat: z.enum(["csv", "md", "json"]).optional(),
 });
+const uiConfigSchema = z.object({
+    locale: z.enum(["en", "ja"]),
+    localePromptCompleted: z.boolean().optional(),
+});
 const fullAppConfigSchema = z.object({
     contexts: z.record(z.string(), contextConfigSchema),
     google_creds: z
@@ -26,29 +39,77 @@ const fullAppConfigSchema = z.object({
         tenantId: z.string().min(1).default("common"),
     })
         .optional(),
+    ui: uiConfigSchema.optional(),
+    eventkit: z
+        .object({
+        defaultTransport: z.enum(["auto", "bridge", "helper"]),
+    })
+        .optional(),
 });
+function defaultUi() {
+    return { locale: "en", localePromptCompleted: true };
+}
+function ensureUiMerged(config) {
+    if (!config.ui) {
+        config.ui = defaultUi();
+    }
+}
 export class ConfigManager {
-    config = { contexts: {} };
+    config = { contexts: {}, ui: defaultUi() };
     constructor() { }
+    getUi() {
+        return this.config.ui;
+    }
+    setUi(ui) {
+        this.config.ui = ui;
+    }
+    /** Replace in-memory config with minimal file (first-run language choice). */
+    resetMinimalWithUi(locale) {
+        this.config = {
+            contexts: {},
+            ui: { locale, localePromptCompleted: true },
+        };
+    }
+    async loadOptional() {
+        await fs.mkdir(CONFIG_DIR, { recursive: true });
+        try {
+            const data = await fs.readFile(CONFIG_FILE, "utf-8");
+            const parsed = JSON.parse(data);
+            this.config = fullAppConfigSchema.parse(parsed);
+            ensureUiMerged(this.config);
+            return true;
+        }
+        catch (e) {
+            if (e && (e.code === "ENOENT" || /no such file/i.test(String(e.message)))) {
+                return false;
+            }
+            if (e instanceof z.ZodError) {
+                throw new ConfigError(t("errors.config.invalidFormat"), t("errors.config.invalidFormatDetails", { details: e.issues.map((issue) => issue.message).join(", ") }), "invalid_schema");
+            }
+            throw new ConfigError(t("errors.config.readFailed"), t("errors.config.readFailedHint"), "read_failed");
+        }
+    }
     async load() {
         await fs.mkdir(CONFIG_DIR, { recursive: true });
         try {
             const data = await fs.readFile(CONFIG_FILE, "utf-8");
             const parsed = JSON.parse(data);
             this.config = fullAppConfigSchema.parse(parsed);
+            ensureUiMerged(this.config);
         }
         catch (e) {
             if (e && (e.code === "ENOENT" || /no such file/i.test(String(e.message)))) {
-                throw new ConfigError("設定ファイルが見つかりません。", "初回は `calendit config set-google --id <id> --secret <secret>` などでセットアップしてください。");
+                throw new ConfigError(t("errors.config.fileNotFound"), t("errors.config.fileNotFoundHint"), "missing_file");
             }
             if (e instanceof z.ZodError) {
-                throw new ConfigError("設定ファイルの形式が不正です。", `config.json を確認してください。詳細: ${e.issues.map((issue) => issue.message).join(", ")}`);
+                throw new ConfigError(t("errors.config.invalidFormat"), t("errors.config.invalidFormatDetails", { details: e.issues.map((issue) => issue.message).join(", ") }), "invalid_schema");
             }
-            throw new ConfigError("設定ファイルの読み込みに失敗しました。", "config.json のJSON形式を確認してください。");
+            throw new ConfigError(t("errors.config.readFailed"), t("errors.config.readFailedHint"), "read_failed");
         }
     }
     async save() {
         await fs.mkdir(CONFIG_DIR, { recursive: true });
+        ensureUiMerged(this.config);
         await fs.writeFile(CONFIG_FILE, JSON.stringify(this.config, null, 2), "utf-8");
     }
     getContext(name) {
@@ -78,4 +139,10 @@ export class ConfigManager {
     setOutlookCreds(id, tenantId) {
         this.config.outlook_creds = { id, tenantId };
     }
+    getEventkitDefaultTransport() {
+        return this.config.eventkit?.defaultTransport;
+    }
+    setEventkitDefaultTransport(value) {
+        this.config.eventkit = { defaultTransport: value };
+    }
 }

package/dist/core/datetime.js

@@ -1,6 +1,7 @@
 import { formatInTimeZone } from "date-fns-tz";
 import { ValidationError } from "./errors.js";
 import { logger } from "./logger.js";
+import { t } from "./i18n.js";
 /**
  * サポート形式:
  * - today
@@ -51,10 +52,10 @@ export function parseDateTime(input, defaultOffset = 0) {
         date = new Date(raw);
     }
     else {
-        throw new ValidationError(`日時フォーマットが不正です: "${input}"`, "例: `today 10:00`, `tomorrow`, `2026-04-16`, `2026-04-16 10:00`, `2026-04-16T10:00:00+09:00`");
+        throw new ValidationError(t("errors.datetime.invalidFormat", { input: input ?? "" }), "e.g. `today 10:00`, `tomorrow`, `2026-04-16`, `2026-04-16 10:00`, `2026-04-16T10:00:00+09:00`");
     }
     if (Number.isNaN(date.getTime())) {
-        throw new ValidationError(`日時として解釈できません: "${input}"`, "入力値を見直してください。時間は HH:mm 形式で指定してください。");
+        throw new ValidationError(t("errors.datetime.invalidParse", { input: input ?? "" }), t("errors.datetime.invalidParseHint"));
     }
     logger.debug("parseDateTime", { input, parsed: date.toISOString() });
     return date;

package/dist/core/errors.d.ts

@@ -2,7 +2,10 @@ export declare class CalendarError extends Error {
     readonly hint?: string;
     constructor(message: string, hint?: string);
 }
+export type ConfigErrorCause = "missing_file" | "invalid_schema" | "read_failed";
 export declare class ConfigError extends CalendarError {
+    readonly causeCode?: ConfigErrorCause;
+    constructor(message: string, hint?: string, causeCode?: ConfigErrorCause);
 }
 export declare class AuthError extends CalendarError {
 }

package/dist/core/errors.js

@@ -7,6 +7,11 @@ export class CalendarError extends Error {
     }
 }
 export class ConfigError extends CalendarError {
+    causeCode;
+    constructor(message, hint, causeCode) {
+        super(message, hint);
+        this.causeCode = causeCode;
+    }
 }
 export class AuthError extends CalendarError {
 }

package/dist/core/eventkitBridgeFetch.d.ts

@@ -0,0 +1,26 @@
+/** Same `CALENDIT_CONFIG_DIR` rules as the bridge: fetched sources live under defaultCalenditDataDir. */
+export declare function getFetchedEventkitBridgePath(): string;
+/**
+ * Public default URL: GitHub `tar.gz` of the ref (entire repository archive).
+ */
+export declare function getDefaultEventkitFetchUrlFromEnv(): {
+    url: string;
+    ref: string;
+    owner: string;
+    repo: string;
+};
+/**
+ * `HEAD` request: returns `Content-Length` as bytes or null.
+ */
+export declare function probeHttpArchiveSizeBytes(url: string): Promise<number | null>;
+export declare function formatMebibytes(bytes: number): string;
+/**
+ * Download archive, extract the `native/eventkit-bridge` subtree to `getFetchedEventkitBridgePath()`.
+ */
+export declare function materializeEventkitBridgeFromNetwork(opts: {
+    url: string;
+    force: boolean;
+}): Promise<{
+    dest: string;
+    writtenBytes: number;
+}>;

package/dist/core/eventkitBridgeFetch.js

@@ -0,0 +1,159 @@
+import { execFile } from "child_process";
+import { tmpdir } from "os";
+import { promisify } from "util";
+import * as fs from "fs";
+import * as path from "path";
+import { defaultCalenditDataDir } from "./eventkitHelper.js";
+import { resolveCalenditPackageRootFromModule } from "./macosBridgeApp.js";
+const execFileAsync = promisify(execFile);
+const fsp = fs.promises;
+/** Same `CALENDIT_CONFIG_DIR` rules as the bridge: fetched sources live under defaultCalenditDataDir. */
+export function getFetchedEventkitBridgePath() {
+    return path.join(defaultCalenditDataDir(), "fetched-eventkit-bridge");
+}
+const DEFAULT_REF = "main";
+const ALLOWED_FETCH_HOSTS = new Set([
+    "github.com",
+    "codeload.github.com",
+    "raw.githubusercontent.com",
+    "www.github.com",
+]);
+function isAllowedUrl(u) {
+    try {
+        const parsed = new URL(u);
+        if (parsed.protocol !== "https:") {
+            return false;
+        }
+        return ALLOWED_FETCH_HOSTS.has(parsed.hostname);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolves `owner/repo` from the installed `calendit` `package.json` (repository.url), with defaults.
+ */
+function readDefaultOwnerRepoFromPackageJson() {
+    const calenditRoot = resolveCalenditPackageRootFromModule();
+    if (calenditRoot) {
+        const pkgPath = path.join(calenditRoot, "package.json");
+        if (fs.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+                const raw = typeof pkg.repository === "string" ? pkg.repository : (pkg.repository?.url ?? "");
+                const m = raw.match(/github\.com[:/]([^/]+)\/([^.?#/]+)/i);
+                if (m) {
+                    const repo = m[2].replace(/\.git$/, "");
+                    return { owner: m[1], repo };
+                }
+            }
+            catch {
+                // fall through
+            }
+        }
+    }
+    return { owner: "chromatribe", repo: "calendit" };
+}
+function refToArchivePathSegment(ref) {
+    const t = ref.trim();
+    if (t.startsWith("v") && /v\d+/.test(t)) {
+        return `refs/tags/${t}`;
+    }
+    return `refs/heads/${t || DEFAULT_REF}`;
+}
+/**
+ * Public default URL: GitHub `tar.gz` of the ref (entire repository archive).
+ */
+export function getDefaultEventkitFetchUrlFromEnv() {
+    const { owner, repo } = readDefaultOwnerRepoFromPackageJson();
+    const ref = process.env.CALENDIT_EVENTKIT_FETCH_REF?.trim() || DEFAULT_REF;
+    const fromEnv = process.env.CALENDIT_EVENTKIT_FETCH_URL?.trim();
+    if (fromEnv) {
+        if (!isAllowedUrl(fromEnv)) {
+            throw new Error(`Invalid or disallowed fetch URL: ${fromEnv} (https on github.com only)`);
+        }
+        return { url: fromEnv, ref, owner, repo };
+    }
+    const seg = refToArchivePathSegment(ref);
+    const url = `https://github.com/${owner}/${repo}/archive/${seg}.tar.gz`;
+    return { url, ref, owner, repo };
+}
+/**
+ * `HEAD` request: returns `Content-Length` as bytes or null.
+ */
+export async function probeHttpArchiveSizeBytes(url) {
+    if (!isAllowedUrl(url)) {
+        return null;
+    }
+    try {
+        const res = await fetch(url, { method: "HEAD", redirect: "follow" });
+        const cl = res.headers.get("content-length");
+        if (cl == null || cl === "") {
+            return null;
+        }
+        const n = parseInt(cl, 10);
+        return Number.isFinite(n) && n > 0 ? n : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function formatMebibytes(bytes) {
+    if (!Number.isFinite(bytes) || bytes < 0) {
+        return "?";
+    }
+    return (bytes / (1024 * 1024)).toFixed(1);
+}
+/**
+ * Download archive, extract the `native/eventkit-bridge` subtree to `getFetchedEventkitBridgePath()`.
+ */
+export async function materializeEventkitBridgeFromNetwork(opts) {
+    if (!isAllowedUrl(opts.url)) {
+        throw new Error(`Refusing to fetch: ${opts.url} (https on github.com only)`);
+    }
+    const dest = getFetchedEventkitBridgePath();
+    if (fs.existsSync(path.join(dest, "Package.swift")) && !opts.force) {
+        return { dest, writtenBytes: 0 };
+    }
+    if (opts.force && fs.existsSync(dest)) {
+        fs.rmSync(dest, { recursive: true, force: true });
+    }
+    const tdir = await fsp.mkdtemp(path.join(tmpdir(), "calendit-ek-fetch-"));
+    const tarball = path.join(tdir, "archive.tar.gz");
+    const extractRoot = path.join(tdir, "extracted");
+    try {
+        const res = await fetch(opts.url, { redirect: "follow" });
+        if (!res.ok) {
+            throw new Error(`HTTP ${res.status} ${res.statusText || ""}`.trim());
+        }
+        const ab = await res.arrayBuffer();
+        const buf = Buffer.from(ab);
+        fs.writeFileSync(tarball, buf);
+        await fsp.mkdir(extractRoot, { recursive: true });
+        await execFileAsync("/usr/bin/tar", ["-xzf", tarball, "-C", extractRoot]);
+        const top = fs.readdirSync(extractRoot);
+        if (top.length < 1) {
+            throw new Error("empty archive");
+        }
+        const one = path.join(extractRoot, top[0]);
+        const bridgePkg = path.join(one, "native", "eventkit-bridge", "Package.swift");
+        if (!fs.existsSync(bridgePkg)) {
+            throw new Error(`no native/eventkit-bridge/Package.swift in archive (root: ${one})`);
+        }
+        const bridgeDir = path.dirname(bridgePkg);
+        await fsp.mkdir(path.dirname(dest), { recursive: true });
+        if (fs.existsSync(dest)) {
+            fs.rmSync(dest, { recursive: true, force: true });
+        }
+        await fsp.cp(bridgeDir, dest, { recursive: true });
+        return { dest, writtenBytes: buf.byteLength };
+    }
+    finally {
+        try {
+            fs.rmSync(tdir, { recursive: true, force: true });
+        }
+        catch {
+            // ignore
+        }
+    }
+}

package/dist/core/eventkitEnvFromConfig.d.ts

@@ -0,0 +1,7 @@
+import type { ConfigManager } from "./config.js";
+/**
+ * If the user did not set `CALENDIT_EVENTKIT_BRIDGE` in the environment, apply
+ * the persisted `eventkit.defaultTransport` from config (when present).
+ * Shell env always wins; call only after `loadOptional()`.
+ */
+export declare function applyEventkitConfigToEnvAfterLoad(config: ConfigManager): void;

package/dist/core/eventkitEnvFromConfig.js

@@ -0,0 +1,24 @@
+/**
+ * If the user did not set `CALENDIT_EVENTKIT_BRIDGE` in the environment, apply
+ * the persisted `eventkit.defaultTransport` from config (when present).
+ * Shell env always wins; call only after `loadOptional()`.
+ */
+export function applyEventkitConfigToEnvAfterLoad(config) {
+    const raw = process.env.CALENDIT_EVENTKIT_BRIDGE;
+    if (raw !== undefined && String(raw).trim() !== "") {
+        return;
+    }
+    const v = config.getEventkitDefaultTransport();
+    if (!v) {
+        return;
+    }
+    if (v === "bridge") {
+        process.env.CALENDIT_EVENTKIT_BRIDGE = "1";
+    }
+    else if (v === "helper") {
+        process.env.CALENDIT_EVENTKIT_BRIDGE = "0";
+    }
+    else {
+        delete process.env.CALENDIT_EVENTKIT_BRIDGE;
+    }
+}