calendit 1.0.3 → 2026.4.26

package/dist/commands/macos.js

@@ -0,0 +1,401 @@
+import { execFile, spawn } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import { promisify } from "util";
+import Enquirer from "enquirer";
+import { writeStdoutLine } from "../core/logger.js";
+import { logger } from "../core/logger.js";
+import { ValidationError } from "../core/errors.js";
+import { t } from "../core/i18n.js";
+import { eventkitDoctorJson, eventkitListCalendarsJson, hasEventkitTransport, resolveEventkitHelperPath, } from "../core/eventkitHelper.js";
+import { getDefaultEventkitFetchUrlFromEnv, getFetchedEventkitBridgePath, materializeEventkitBridgeFromNetwork, formatMebibytes, probeHttpArchiveSizeBytes, } from "../core/eventkitBridgeFetch.js";
+import { resolveEventkitBridgeAppBundlePath, resolveEventkitBridgeRepoPath, } from "../core/macosBridgeApp.js";
+import { loadConfigIfExists } from "./shared.js";
+import { buildMacosExternalShellLine, buildMacosTerminalSessionLine, openTerminalAndRunShellLine, } from "../core/macosTerminalRelay.js";
+const execFileAsync = promisify(execFile);
+function isLikelyIdeIntegratedTerminal() {
+    return process.env.TERM_PROGRAM === "vscode";
+}
+function formatCalendarTable(rows) {
+    const headers = ["SOURCE", "TITLE", "CALENDAR_ID", "EDIT"];
+    const data = rows.map((r) => [
+        r.sourceTitle,
+        r.title,
+        r.calendarIdentifier,
+        r.allowsContentModification ? "yes" : "no",
+    ]);
+    const all = [headers, ...data];
+    const widths = headers.map((_, i) => Math.max(...all.map((row) => String(row[i]).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, ...data.map((cols) => fmt(cols.map(String)))].join("\n");
+}
+async function sleepMs(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+function isConnectFailure(msg) {
+    return /could not connect|ECONNREFUSED|not connect|EventKit bridge token not found|bridge token not found/i.test(msg);
+}
+function isInteractiveTty() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+/** Run `scripts/build-app-bundle.sh` in `bridgeRoot` and log success. */
+function runBridgeBuildFromRoot(bridgeRoot) {
+    const script = path.join(bridgeRoot, "scripts/build-app-bundle.sh");
+    return new Promise((resolve, reject) => {
+        const c = spawn("/bin/bash", [script], { cwd: bridgeRoot, stdio: "inherit", env: process.env });
+        c.on("error", reject);
+        c.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(String(code ?? 1)));
+            }
+        });
+    });
+}
+export function registerMacosCommands(program, deps) {
+    const macosCmd = program
+        .command("macos")
+        .description("macOS Calendar (EventKit) helper — not OAuth; uses local Calendar.app data store");
+    const bridgeCmd = macosCmd
+        .command("bridge")
+        .description("EventKit bridge (CalenditEventKitBridge.app) — TCC and socket live on this process");
+    bridgeCmd
+        .command("fetch")
+        .description("Download the repo snapshot from GitHub, extract native/eventkit-bridge (with confirmation; then optional Swift build)")
+        .option("-f, --force", "Re-download and replace existing fetched sources", false)
+        .option("-y, --yes", "Skip the download confirmation prompt (non-interactive)", false)
+        .option("-b, --build", "After a successful download, run the Swift .app build without a second prompt", false)
+        .action(async (opts) => {
+        if (process.platform !== "darwin") {
+            writeStdoutLine(t("macos.setup.notDarwin"));
+            process.exitCode = 1;
+            return;
+        }
+        const dest = getFetchedEventkitBridgePath();
+        let plan;
+        try {
+            plan = getDefaultEventkitFetchUrlFromEnv();
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            logger.error(message);
+            process.exitCode = 1;
+            return;
+        }
+        const { url } = plan;
+        if (!opts.force && fs.existsSync(path.join(dest, "Package.swift"))) {
+            logger.info(t("macos.bridge.fetchSkipsExisting", { path: dest }));
+            return;
+        }
+        if (!opts.yes && !isInteractiveTty()) {
+            logger.error(t("macos.bridge.fetchNoTty"));
+            process.exitCode = 1;
+            return;
+        }
+        const sizeBytes = await probeHttpArchiveSizeBytes(url);
+        const sizeLine = sizeBytes != null
+            ? t("macos.bridge.fetchSizeKnown", { mb: formatMebibytes(sizeBytes) })
+            : t("macos.bridge.fetchSizeUnknown");
+        if (!opts.yes) {
+            writeStdoutLine(t("macos.bridge.fetchIntro"));
+            writeStdoutLine("");
+            writeStdoutLine(t("macos.bridge.fetchPlan", { url, sizeLine, dest }));
+            writeStdoutLine("");
+            const { go } = await Enquirer.prompt({
+                type: "confirm",
+                name: "go",
+                message: t("macos.bridge.fetchConfirm"),
+                initial: true,
+            });
+            if (!go) {
+                logger.info(t("macos.bridge.fetchCancel"));
+                return;
+            }
+        }
+        try {
+            const r = await materializeEventkitBridgeFromNetwork({ url, force: Boolean(opts.force) });
+            logger.info(t("macos.bridge.fetchOk", { path: r.dest }));
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            logger.error(t("macos.bridge.fetchFailed", { message }));
+            process.exitCode = 1;
+            return;
+        }
+        const bridgeRoot = resolveEventkitBridgeRepoPath();
+        if (!bridgeRoot) {
+            return;
+        }
+        let doBuild;
+        if (opts.build) {
+            doBuild = true;
+        }
+        else if (opts.yes) {
+            doBuild = false;
+        }
+        else if (isInteractiveTty()) {
+            const { build } = await Enquirer.prompt({
+                type: "confirm",
+                name: "build",
+                message: t("macos.bridge.fetchBuildPrompt"),
+                initial: true,
+            });
+            doBuild = build;
+        }
+        else {
+            doBuild = false;
+        }
+        if (!doBuild) {
+            return;
+        }
+        try {
+            await runBridgeBuildFromRoot(bridgeRoot);
+            const outApp = path.join(bridgeRoot, ".build/CalenditEventKitBridge.app");
+            logger.info(t("macos.bridge.buildOk", { path: outApp }));
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            logger.error(t("macos.bridge.buildFailed", { message }));
+            process.exitCode = 1;
+        }
+    });
+    bridgeCmd
+        .command("build")
+        .description("Build CalenditEventKitBridge.app from the Swift package (full repo; requires swift/codesign)")
+        .action(async () => {
+        if (process.platform !== "darwin") {
+            writeStdoutLine(t("macos.setup.notDarwin"));
+            process.exitCode = 1;
+            return;
+        }
+        const bridgeRoot = resolveEventkitBridgeRepoPath();
+        if (!bridgeRoot) {
+            logger.error(t("macos.bridge.buildNoSource"));
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            await runBridgeBuildFromRoot(bridgeRoot);
+            const outApp = path.join(bridgeRoot, ".build/CalenditEventKitBridge.app");
+            logger.info(t("macos.bridge.buildOk", { path: outApp }));
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            logger.error(t("macos.bridge.buildFailed", { message }));
+            process.exitCode = 1;
+        }
+    });
+    bridgeCmd
+        .command("start")
+        .description("Open CalenditEventKitBridge.app (searches common paths; set CALENDIT_EVENTKIT_BRIDGE_APP to override)")
+        .action(async () => {
+        if (process.platform !== "darwin") {
+            writeStdoutLine(t("macos.setup.notDarwin"));
+            process.exitCode = 1;
+            return;
+        }
+        const p = resolveEventkitBridgeAppBundlePath();
+        if (!p) {
+            logger.error(t("macos.bridge.notFound"));
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            await execFileAsync("/usr/bin/open", [p], { shell: false });
+            logger.info(t("macos.bridge.opened", { path: p }));
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            logger.error(t("macos.bridge.openFailed", { message }));
+            process.exitCode = 1;
+        }
+    });
+    macosCmd
+        .command("setup")
+        .description("Interactive: ensure bridge, grant Calendar access, pick a calendar, save a macos context")
+        .action(async () => {
+        if (process.platform !== "darwin") {
+            writeStdoutLine(t("macos.setup.notDarwin"));
+            process.exitCode = 1;
+            return;
+        }
+        if (!hasEventkitTransport()) {
+            logger.error(t("macos.setup.noTransport"));
+            process.exitCode = 1;
+            return;
+        }
+        for (let attempt = 0; attempt < 8; attempt++) {
+            try {
+                const j = await eventkitDoctorJson();
+                if (j.calendarAccess === "denied" || j.calendarAccess !== "authorized") {
+                    logger.info(t("macos.setup.tcc"));
+                    const { c } = await Enquirer.prompt({
+                        type: "input",
+                        name: "c",
+                        message: "[Enter] when ready to re-check",
+                    });
+                    void c;
+                    continue;
+                }
+                const data = await eventkitListCalendarsJson();
+                const cals = data.calendars || [];
+                if (cals.length === 0) {
+                    logger.error(t("macos.setup.noCalendars"));
+                    process.exitCode = 1;
+                    return;
+                }
+                const { calendarId } = await Enquirer.prompt({
+                    type: "select",
+                    name: "calendarId",
+                    message: t("macos.setup.pickCalendar"),
+                    choices: cals.map((r) => ({
+                        name: `${r.title} (${r.sourceTitle}) — ${r.calendarIdentifier}`,
+                        value: r.calendarIdentifier,
+                    })),
+                });
+                const { ctxName } = await Enquirer.prompt({
+                    type: "input",
+                    name: "ctxName",
+                    message: t("macos.setup.contextName"),
+                    validate: (s) => (s.trim() ? true : t("macos.setup.contextNameRequired")),
+                });
+                await loadConfigIfExists(deps.config);
+                const name = ctxName.trim();
+                deps.config.setContext(name, { service: "macos", calendarId });
+                await deps.config.save();
+                logger.info(t("macos.setup.saved", { name, calendarId }));
+                return;
+            }
+            catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
+                if (isConnectFailure(message) && attempt < 4) {
+                    const { go } = await Enquirer.prompt({
+                        type: "confirm",
+                        name: "go",
+                        message: t("macos.setup.startBridgePrompt"),
+                        initial: true,
+                    });
+                    if (!go) {
+                        logger.info(t("macos.setup.canceled"));
+                        process.exitCode = 1;
+                        return;
+                    }
+                    const appPath = resolveEventkitBridgeAppBundlePath();
+                    if (!appPath) {
+                        logger.error(t("macos.bridge.notFound"));
+                        process.exitCode = 1;
+                        return;
+                    }
+                    try {
+                        await execFileAsync("/usr/bin/open", [appPath], { shell: false });
+                        await sleepMs(2000);
+                    }
+                    catch (err) {
+                        const m = err instanceof Error ? err.message : String(err);
+                        logger.error(t("macos.bridge.openFailed", { message: m }));
+                        process.exitCode = 1;
+                        return;
+                    }
+                    continue;
+                }
+                logger.error(message);
+                process.exitCode = 1;
+                return;
+            }
+        }
+        logger.error("Setup: too many attempts.");
+        process.exitCode = 1;
+    });
+    macosCmd
+        .command("doctor")
+        .description("Check OS, helper binary, and Calendar access (TCC); uses the same transport as `query`")
+        .action(async () => {
+        if (process.platform !== "darwin") {
+            writeStdoutLine("macOS のみ対応です。現在の OS では EventKit ヘルパーを使用できません。");
+            return;
+        }
+        const p = resolveEventkitHelperPath();
+        writeStdoutLine(`Helper path: ${p ?? "(not found, OK if using bridge only)"}`);
+        if (!hasEventkitTransport()) {
+            writeStdoutLine("EventKit: no helper and no local bridge. Build helper or start CalenditEventKitBridge.app.");
+            return;
+        }
+        try {
+            const j = await eventkitDoctorJson();
+            writeStdoutLine(JSON.stringify(j, null, 2));
+            if (j.calendarAccess === "denied" && isLikelyIdeIntegratedTerminal()) {
+                writeStdoutLine("");
+                writeStdoutLine(t("macos.external.suggestionWhenDenied"));
+            }
+        }
+        catch (e) {
+            logger.error(`doctor 失敗: ${e instanceof Error ? e.message : String(e)}`);
+            process.exitCode = 1;
+        }
+    });
+    macosCmd
+        .command("external")
+        .description("Open Terminal.app and run `calendit macos …` or an interactive shell there (Calendar TCC applies to Terminal; use from Cursor/VS Code)")
+        .argument("<sub>", "doctor | list-calendars | shell")
+        .option("--json", "pass --json to list-calendars", false)
+        .action(async (sub, opts) => {
+        if (process.platform !== "darwin") {
+            writeStdoutLine(t("macos.external.onlyDarwin"));
+            process.exitCode = 1;
+            return;
+        }
+        const subNorm = sub.trim();
+        if (subNorm !== "doctor" && subNorm !== "list-calendars" && subNorm !== "shell") {
+            throw new ValidationError(t("macos.external.badSub"), t("macos.external.badSubHint"));
+        }
+        if (subNorm === "doctor" && opts.json) {
+            throw new ValidationError(t("macos.external.jsonOnlyForList"), t("macos.external.badSubHint"));
+        }
+        if (subNorm === "shell" && opts.json) {
+            throw new ValidationError(t("macos.external.jsonOnlyForList"), t("macos.external.badSubHint"));
+        }
+        const line = subNorm === "shell"
+            ? buildMacosTerminalSessionLine(process.cwd())
+            : buildMacosExternalShellLine(process.cwd(), subNorm === "doctor" ? ["doctor"] : opts.json ? ["list-calendars", "--json"] : ["list-calendars"]);
+        try {
+            openTerminalAndRunShellLine(line);
+            logger.info(t("macos.external.opened", { cmd: line }));
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            logger.error(t("macos.external.osascriptFailed", { message }));
+            process.exitCode = 1;
+        }
+    });
+    macosCmd
+        .command("list-calendars")
+        .description("List calendars from the local EventKit store (use CALENDAR_ID for config set-context --service macos)")
+        .option("--json", "Print raw JSON instead of a table", false)
+        .action(async (opts) => {
+        if (process.platform !== "darwin") {
+            writeStdoutLine("macOS のみ対応です。");
+            return;
+        }
+        if (!hasEventkitTransport()) {
+            writeStdoutLine("EventKit 経路が利用できません。`calendit macos doctor` を参照してください。");
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            const data = await eventkitListCalendarsJson();
+            if (opts.json) {
+                writeStdoutLine(JSON.stringify(data, null, 2));
+            }
+            else {
+                writeStdoutLine(formatCalendarTable(data.calendars || []));
+            }
+        }
+        catch (e) {
+            logger.error(`list-calendars 失敗: ${e instanceof Error ? e.message : String(e)}`);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/onboard.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerOnboardCommand(program: Command): void;

package/dist/commands/onboard.js

@@ -0,0 +1,79 @@
+import Enquirer from "enquirer";
+import { writeStdoutLine } from "../core/logger.js";
+const RALLY_BLOB = "https://github.com/chromatribe/calendit/blob/main/docs/ai-onboarding-rally.md";
+const RALLY_RAW = "https://raw.githubusercontent.com/chromatribe/calendit/main/docs/ai-onboarding-rally.md";
+const DOCS_BASE = "https://github.com/chromatribe/calendit/blob/main/docs";
+function printRallyHeader() {
+    writeStdoutLine("calendit — first-time setup (onboard)");
+    writeStdoutLine("");
+    writeStdoutLine(`Rally doc (read in browser): ${RALLY_BLOB}`);
+    writeStdoutLine(`Rally doc (raw, for agents):  ${RALLY_RAW}`);
+    writeStdoutLine("");
+}
+function printGoogle() {
+    writeStdoutLine("— Google");
+    writeStdoutLine(`  Console walkthrough: ${DOCS_BASE}/setup_google.md`);
+    writeStdoutLine("  calendit config set-google --file <credentials.json>");
+    writeStdoutLine('  calendit config set-context my-google --service google --calendar primary --account "you@gmail.com"');
+    writeStdoutLine("  calendit auth login google --set my-google");
+    writeStdoutLine("  calendit accounts status");
+    writeStdoutLine("");
+}
+function printOutlook() {
+    writeStdoutLine("— Outlook (Microsoft Graph)");
+    writeStdoutLine(`  Entra / Azure walkthrough: ${DOCS_BASE}/setup_outlook.md`);
+    writeStdoutLine('  calendit config set-outlook --id "<client-id>"');
+    writeStdoutLine('  calendit config set-context my-outlook --service outlook --calendar primary --account "you@outlook.com"');
+    writeStdoutLine("  calendit auth login outlook --set my-outlook");
+    writeStdoutLine("  calendit accounts status");
+    writeStdoutLine("  (Do not run Google and Outlook auth logins at the same time; both use localhost:3000.)");
+    writeStdoutLine("");
+}
+function printMacos() {
+    writeStdoutLine("— macOS (EventKit / Calendar.app)");
+    writeStdoutLine(`  Bridge / TCC: ${DOCS_BASE}/eventkit-bridge.md`);
+    writeStdoutLine("  calendit macos setup                    # recommended wizard when possible");
+    writeStdoutLine("  calendit macos list-calendars            # use CALENDAR_ID (not only display title) for set-context");
+    writeStdoutLine('  calendit config set-context my-macos --service macos --calendar "<CALENDAR_ID>"');
+    writeStdoutLine("  calendit accounts status");
+    writeStdoutLine("");
+}
+function printAllBranches() {
+    printRallyHeader();
+    printGoogle();
+    printOutlook();
+    printMacos();
+}
+function printOne(p) {
+    printRallyHeader();
+    if (p === "google")
+        printGoogle();
+    if (p === "outlook")
+        printOutlook();
+    if (p === "macos")
+        printMacos();
+    writeStdoutLine("Full step-by-step (human, no omissions):");
+    writeStdoutLine(`  ${DOCS_BASE}/getting-started.md`);
+}
+export function registerOnboardCommand(program) {
+    program
+        .command("onboard")
+        .description("First-time setup hints: pick Google, Outlook, or this Mac; prints doc URLs and next commands")
+        .action(async () => {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            printAllBranches();
+            return;
+        }
+        const { provider } = await Enquirer.prompt({
+            type: "select",
+            name: "provider",
+            message: "Which calendar provider are you setting up first?",
+            choices: [
+                { name: "Google", value: "google" },
+                { name: "Outlook (Microsoft 365 / Outlook.com)", value: "outlook" },
+                { name: "This Mac only (EventKit / Calendar.app)", value: "macos" },
+            ],
+        });
+        printOne(provider);
+    });
+}

package/dist/commands/query.js

@@ -17,7 +17,7 @@ export function registerQueryCommand(program, deps) {
         .option("--out <file>", "Output file path")
         .option("--dry-run", "Preview (no effect for query)", false)
         .action(async (options) => {
-        const { service, calendarId: ctxCalId } = await getServiceForContext(deps, options.set);
+        const { service, calendarId: ctxCalId, serviceType } = await getServiceForContext(deps, options.set);
         const calendarId = options.calendar || ctxCalId;
         const now = new Date();
         let start;
@@ -52,7 +52,7 @@ export function registerQueryCommand(program, deps) {
         else if (options.format === "csv")
             output = Formatter.toCsv(events);
         else
-            output = JSON.stringify(events, null, 2);
+            output = Formatter.toJson(events, { context: options.set, service: serviceType, calendarId });
         if (options.out) {
             await fs.writeFile(options.out, output, "utf-8");
             logger.info(`Events exported to ${options.out}`);

package/dist/commands/shared.d.ts

@@ -3,14 +3,15 @@ import { AuthManager } from "../core/auth.js";
 import { GoogleCalendarService } from "../services/google.js";
 import { OutlookCalendarService } from "../services/outlook.js";
 import { MockCalendarService } from "../services/mock.js";
+import { MacosCalendarService } from "../services/macos.js";
 export interface CommandDeps {
     config: ConfigManager;
     auth: AuthManager;
 }
 export interface ResolvedService {
-    service: GoogleCalendarService | OutlookCalendarService | MockCalendarService;
+    service: GoogleCalendarService | OutlookCalendarService | MockCalendarService | MacosCalendarService;
     calendarId: string;
-    serviceType: "google" | "outlook" | "mock";
+    serviceType: "google" | "outlook" | "mock" | "macos";
 }
 export declare function loadConfigIfExists(config: ConfigManager): Promise<void>;
 export declare function getServiceForContext(deps: CommandDeps, contextName?: string): Promise<ResolvedService>;

package/dist/commands/shared.js

@@ -1,13 +1,15 @@
 import { GoogleCalendarService } from "../services/google.js";
 import { OutlookCalendarService } from "../services/outlook.js";
 import { MockCalendarService } from "../services/mock.js";
+import { MacosCalendarService } from "../services/macos.js";
 import { ConfigError } from "../core/errors.js";
+import { t } from "../core/i18n.js";
 export async function loadConfigIfExists(config) {
     try {
         await config.load();
     }
     catch (err) {
-        if (err instanceof ConfigError && err.message.includes("見つかりません")) {
+        if (err instanceof ConfigError && err.causeCode === "missing_file") {
             return;
         }
         throw err;
@@ -20,7 +22,7 @@ export async function getServiceForContext(deps, contextName) {
     }
     catch (err) {
         if (err instanceof ConfigError) {
-            throw new ConfigError("Failed to load configuration. Run 'calendit --help' for setup instructions.", "初回は `calendit config set-google` などで設定を作成してください。");
+            throw new ConfigError(t("errors.context.loadFailed"), t("errors.context.loadFailedHint"));
         }
         throw err;
     }
@@ -28,7 +30,7 @@ export async function getServiceForContext(deps, contextName) {
         ? config.getContext(contextName)
         : { service: "google", calendarId: "primary", accountId: undefined };
     if (!ctx) {
-        throw new ConfigError(`Context '${contextName}' が見つかりません。`, `\`calendit config set-context ${contextName} --service google --calendar primary\` を実行してください。`);
+        throw new ConfigError(t("errors.context.missing", { name: contextName ?? "" }), t("errors.context.missingHint", { name: contextName ?? "" }));
     }
     if (process.env.CALENDIT_MOCK === "true") {
         return {
@@ -37,10 +39,24 @@ export async function getServiceForContext(deps, contextName) {
             serviceType: "mock",
         };
     }
+    if (ctx.service === "macos") {
+        if (process.env.CALENDIT_MOCK === "true") {
+            return {
+                service: new MockCalendarService("macos"),
+                calendarId: ctx.calendarId,
+                serviceType: "mock",
+            };
+        }
+        return {
+            service: new MacosCalendarService(),
+            calendarId: ctx.calendarId,
+            serviceType: "macos",
+        };
+    }
     if (ctx.service === "google") {
         const creds = config.getGoogleCreds();
         if (!creds) {
-            throw new ConfigError("Google 認証情報が未設定です。", "`calendit config set-google --id <id> --secret <secret>` を実行してください。");
+            throw new ConfigError(t("errors.service.googleCredsNotSet"), t("errors.service.googleCredsNotSetHint"));
         }
         // Token file is keyed by contextName (used during `auth login --set`), falling back to accountId
         const tokenKey = contextName || ctx.accountId;
@@ -53,7 +69,7 @@ export async function getServiceForContext(deps, contextName) {
     }
     const creds = config.getOutlookCreds();
     if (!creds) {
-        throw new ConfigError("Outlook 認証情報が未設定です。", "`calendit config set-outlook --id <id>` を実行してください。");
+        throw new ConfigError(t("errors.service.outlookCredsNotSet"), t("errors.service.outlookCredsNotSetHint"));
     }
     const pca = await auth.getOutlookClient(creds.id, creds.tenantId);
     const accounts = await pca.getTokenCache().getAllAccounts();

package/dist/core/accountStatus.d.ts

@@ -0,0 +1,18 @@
+import type { ContextConfig } from "../types/index.js";
+import type { OutlookCredentials } from "../types/index.js";
+import type { AuthManager } from "./auth.js";
+import { type AuthTokenColumn } from "./authStatus.js";
+/** 全サービス共通の接続・利用可否の要約（OAuth トークンに限定しない） */
+export type AccountConnectionState = AuthTokenColumn | "N/A (non-macOS)" | "NO HELPER" | "HELPER ERROR" | "NO CALENDAR ACCESS" | "CALENDAR NOT FOUND" | "OK (bridge)";
+export interface AccountStatusRow {
+    context: string;
+    service: string;
+    calendar: string;
+    account: string;
+    connection: AccountConnectionState;
+}
+export declare function buildAccountStatusRows(contexts: Record<string, ContextConfig>, deps: {
+    auth: AuthManager;
+    outlookCreds?: OutlookCredentials;
+}): Promise<AccountStatusRow[]>;
+export declare function formatAccountStatusTable(rows: AccountStatusRow[]): string;