@yuiseki/gyazocli 0.0.2 → 0.2.0

package/dist/commands/list.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerListCommand = registerListCommand;
+const credentials_1 = require("../credentials");
+const dates_1 = require("../dates");
+const options_1 = require("../options");
+const memory_1 = require("../services/memory");
+const images_1 = require("../services/images");
+function registerListCommand(program) {
+    program
+        .command('list')
+        .alias('ls')
+        .description('List recent images')
+        .option('-p, --page <number>', 'page number', '1')
+        .option('-l, --limit <number>', 'items per page', '20')
+        .option('-j, --json', 'output as JSON')
+        .option('-H, --hour <yyyy-mm-dd-hh>', 'target hour')
+        .option('--date <yyyy|yyyy-mm|yyyy-mm-dd>', 'target date/range')
+        .option('--today', 'target today only')
+        .option('--max-pages <number>', 'max pages to scan for --date/--today mode', '100')
+        .option('--photos', 'alias of search "has:location"')
+        .option('--uploaded', 'alias of search "gyazocli_uploads"')
+        .option('--no-cache', 'force fetch from API')
+        .action(async (options) => {
+        await (0, credentials_1.ensureAccessToken)();
+        try {
+            const useCache = options.cache !== false;
+            const page = (0, options_1.parsePositiveIntegerOption)(options.page, '--page');
+            const limit = (0, options_1.parsePositiveIntegerOption)(options.limit, '--limit');
+            const maxPages = (0, options_1.parsePositiveIntegerOption)(options.maxPages, '--max-pages');
+            const hasDateRange = Boolean(options.date || options.today);
+            if (options.photos && options.uploaded) {
+                console.error('Error: --photos and --uploaded cannot be used together.');
+                process.exit(1);
+            }
+            if (options.today && options.date) {
+                console.error('Error: --today and --date cannot be used together.');
+                process.exit(1);
+            }
+            if ((options.photos || options.uploaded) && options.hour) {
+                console.error('Error: --photos/--uploaded and --hour cannot be used together.');
+                process.exit(1);
+            }
+            if (options.hour && hasDateRange) {
+                console.error('Error: --hour and --date/--today cannot be used together.');
+                process.exit(1);
+            }
+            const targetDate = hasDateRange
+                ? options.today
+                    ? (0, dates_1.parseDateOption)()
+                    : (0, dates_1.parseDateOption)(options.date)
+                : undefined;
+            let hour = null;
+            if (options.hour) {
+                hour = (0, dates_1.parseHourOption)(options.hour);
+                if (!hour) {
+                    console.error('Error: hour format must be yyyy-mm-dd-hh');
+                    process.exit(1);
+                }
+            }
+            const alias = options.photos
+                ? 'photos'
+                : options.uploaded
+                    ? 'uploaded'
+                    : undefined;
+            const { images, empty } = await (0, memory_1.listCaptures)({
+                page,
+                limit,
+                maxPages,
+                useCache,
+                date: targetDate,
+                hour: hour || undefined,
+                alias,
+            });
+            if (empty === 'date' && targetDate) {
+                console.log(`No images found for ${targetDate.dateKey}.`);
+                return;
+            }
+            if (empty === 'hour') {
+                console.log(`No images found for ${options.hour} in cache.`);
+                return;
+            }
+            if (options.json) {
+                console.log(JSON.stringify(images, null, 2));
+                return;
+            }
+            // A search result carries less than a listing does, so the alias paths
+            // ask for their results to be cached as they are shown.
+            const imagesForDisplay = await (0, images_1.prepareImagesForDisplay)(images, {
+                cacheSearchResults: Boolean(alias),
+                enrichLocation: true,
+                useCache,
+            });
+            (0, images_1.printListImages)(imagesForDisplay);
+        }
+        catch (error) {
+            console.error('Error listing images:', error.message);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/locations.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerLocationsCommand = registerLocationsCommand;
+const credentials_1 = require("../credentials");
+const dates_1 = require("../dates");
+const options_1 = require("../options");
+const memory_1 = require("../services/memory");
+const analytics_1 = require("../services/analytics");
+function registerLocationsCommand(program) {
+    program
+        .command('locations')
+        .description('Rank metadata locations for a specific date')
+        .option('--date <yyyy|yyyy-mm|yyyy-mm-dd>', 'target date/range')
+        .option('--today', 'target today only (overrides default weekly range)')
+        .option('-l, --limit <number>', 'maximum ranking rows (max: 10)', '10')
+        .option('--max-pages <number>', 'max pages to scan before stopping', '10')
+        .option('-j, --json', 'output as JSON')
+        .option('--no-cache', 'force fetch from API')
+        .action(async (options) => {
+        await (0, credentials_1.ensureAccessToken)();
+        try {
+            const targetDate = (0, dates_1.resolveRankingRangeOption)(options);
+            const requestedLimit = (0, options_1.parsePositiveIntegerOption)(options.limit, '--limit');
+            const limit = Math.min(requestedLimit, 10);
+            const maxPages = (0, options_1.parsePositiveIntegerOption)(options.maxPages, '--max-pages');
+            const useCache = options.cache !== false;
+            let ranking = [];
+            let totalWithLocation = 0;
+            let totalImages = 0;
+            if (useCache) {
+                let cacheSummary = (0, analytics_1.buildLocationsRankingFromHourlyCache)(targetDate);
+                if (cacheSummary.totalImages === 0) {
+                    await (0, memory_1.warmDateCacheForLocations)(targetDate, maxPages, true);
+                    cacheSummary = (0, analytics_1.buildLocationsRankingFromHourlyCache)(targetDate);
+                }
+                ranking = cacheSummary.ranking;
+                totalWithLocation = cacheSummary.imageCountWithLocations;
+                totalImages = cacheSummary.totalImages;
+            }
+            else {
+                const imageIds = await (0, memory_1.warmDateCacheForLocations)(targetDate, maxPages, false);
+                ranking = (0, analytics_1.buildLocationsRankingFromCache)(imageIds);
+                totalWithLocation = ranking.reduce((sum, item) => sum + item.count, 0);
+                totalImages = imageIds.length;
+            }
+            const displayedRanking = ranking.slice(0, limit);
+            if (options.json) {
+                console.log(JSON.stringify({
+                    date: targetDate.dateKey,
+                    image_count: totalImages,
+                    location_image_count: totalWithLocation,
+                    total_locations: ranking.length,
+                    ranking: displayedRanking,
+                }, null, 2));
+                return;
+            }
+            if (ranking.length === 0) {
+                console.log(`No location metadata found for ${targetDate.dateKey}.`);
+                return;
+            }
+            console.log(`Locations on ${targetDate.dateKey}`);
+            displayedRanking.forEach((item, index) => {
+                console.log(`${index + 1}. ${item.location}: ${item.count}`);
+            });
+            console.log(`Total images with location metadata: ${totalWithLocation}`);
+        }
+        catch (error) {
+            console.error('Error ranking locations:', error.message);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/search.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSearchCommand = registerSearchCommand;
+const api_1 = require("../api");
+const credentials_1 = require("../credentials");
+const format_1 = require("../format");
+const memory_1 = require("../services/memory");
+const images_1 = require("../services/images");
+function registerSearchCommand(program) {
+    program
+        .command('search [query]')
+        .description('Search images')
+        .option('-j, --json', 'output as JSON')
+        .option('--no-cache', 'force fetch from API')
+        .action(async (query, options) => {
+        await (0, credentials_1.ensureAccessToken)();
+        try {
+            if (!(0, format_1.normalizeText)(query)) {
+                console.error('Error: Query is required.');
+                console.error('Hint: Run `gyazo search -h` for usage.');
+                process.exit(1);
+            }
+            const images = await (0, api_1.searchImages)(query);
+            const useCache = options.cache !== false;
+            if (options.json) {
+                (0, memory_1.cacheSearchResultImages)(images);
+                console.log(JSON.stringify(images, null, 2));
+            }
+            else {
+                const imagesForDisplay = await (0, images_1.prepareImagesForDisplay)(images, {
+                    cacheSearchResults: true,
+                    enrichLocation: true,
+                    useCache,
+                });
+                (0, images_1.printListImages)(imagesForDisplay);
+            }
+        }
+        catch (error) {
+            console.error('Error searching images:', error.message);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/stats.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerStatsCommand = registerStatsCommand;
+const credentials_1 = require("../credentials");
+const dates_1 = require("../dates");
+const options_1 = require("../options");
+const memory_1 = require("../services/memory");
+const analytics_1 = require("../services/analytics");
+function registerStatsCommand(program) {
+    program
+        .command('stats')
+        .description('Show weekly stats summary in Markdown')
+        .option('--date <yyyy|yyyy-mm|yyyy-mm-dd>', 'window end date anchor (default: yesterday)')
+        .option('--days <number>', 'window length in days', '7')
+        .option('--top <number>', 'rows per section', '10')
+        .option('--max-pages <number>', 'max pages to fetch when warming cache', '10')
+        .option('--no-cache', 'force fetch from API')
+        .action(async (options) => {
+        await (0, credentials_1.ensureAccessToken)();
+        try {
+            const { range, days, startLabel, endLabel } = (0, dates_1.buildStatsDateRange)(options.date, options.days || '7');
+            const top = Math.min((0, options_1.parsePositiveIntegerOption)(options.top, '--top'), 20);
+            const maxPages = (0, options_1.parsePositiveIntegerOption)(options.maxPages, '--max-pages');
+            const useCache = options.cache !== false;
+            let uploadTime;
+            let apps = [];
+            let domains = [];
+            let tags = [];
+            let totalUploads = 0;
+            if (useCache) {
+                uploadTime = (0, analytics_1.buildUploadTimeSummaryFromHourlyCache)(range);
+                if (uploadTime.totalImages === 0) {
+                    await (0, memory_1.warmDateCacheForApps)(range, maxPages, true);
+                    uploadTime = (0, analytics_1.buildUploadTimeSummaryFromHourlyCache)(range);
+                }
+                let appsSummary = (0, analytics_1.buildAppsRankingFromHourlyCache)(range);
+                if (uploadTime.totalImages > 0 && appsSummary.totalImages === 0) {
+                    await (0, memory_1.warmDateCacheForApps)(range, maxPages, true);
+                    appsSummary = (0, analytics_1.buildAppsRankingFromHourlyCache)(range);
+                }
+                let domainsSummary = (0, analytics_1.buildDomainsRankingFromHourlyCache)(range);
+                if (uploadTime.totalImages > 0 && domainsSummary.totalImages === 0) {
+                    await (0, memory_1.warmDateCacheForDomains)(range, maxPages, true);
+                    domainsSummary = (0, analytics_1.buildDomainsRankingFromHourlyCache)(range);
+                }
+                let tagsSummary = (0, analytics_1.buildTagsRankingFromHourlyCache)(range);
+                if (uploadTime.totalImages > 0 && tagsSummary.totalImages === 0) {
+                    await (0, memory_1.warmDateCacheForTags)(range, maxPages, true);
+                    tagsSummary = (0, analytics_1.buildTagsRankingFromHourlyCache)(range);
+                }
+                apps = appsSummary.ranking;
+                domains = domainsSummary.ranking;
+                tags = tagsSummary.ranking;
+                totalUploads = uploadTime.totalImages;
+            }
+            else {
+                const imageIds = await (0, memory_1.warmDateCacheForTags)(range, maxPages, false);
+                uploadTime = (0, analytics_1.buildUploadTimeSummaryFromImageCache)(imageIds, range);
+                apps = (0, analytics_1.buildAppsRankingFromCache)(imageIds);
+                domains = (0, analytics_1.buildDomainsRankingFromCache)(imageIds);
+                tags = (0, analytics_1.buildTagsRankingFromCache)(imageIds).ranking;
+                totalUploads = uploadTime.totalImages;
+            }
+            console.log((0, analytics_1.renderStatsMarkdown)({
+                startLabel,
+                endLabel,
+                days,
+                totalUploads,
+                uploadTime,
+                apps,
+                domains,
+                tags,
+                top,
+            }));
+        }
+        catch (error) {
+            console.error('Error building stats:', error.message);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/summary.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSummaryCommand = registerSummaryCommand;
+const credentials_1 = require("../credentials");
+const dates_1 = require("../dates");
+const options_1 = require("../options");
+const analytics_1 = require("../services/analytics");
+function registerSummaryCommand(program) {
+    program
+        .command('summary')
+        .description('Show weekly summary with daily uploads and metadata rankings')
+        .option('--date <yyyy|yyyy-mm|yyyy-mm-dd>', 'target date/range')
+        .option('--today', 'target today only (overrides default weekly range)')
+        .option('-l, --limit <number>', 'maximum ranking rows (max: 10)', '10')
+        .option('--max-pages <number>', 'max pages to scan before stopping', '10')
+        .option('-j, --json', 'output as JSON')
+        .option('--no-cache', 'force fetch from API')
+        .action(async (options) => {
+        await (0, credentials_1.ensureAccessToken)();
+        try {
+            const targetDate = (0, dates_1.resolveRankingRangeOption)(options);
+            const requestedLimit = (0, options_1.parsePositiveIntegerOption)(options.limit, '--limit');
+            const limit = Math.min(requestedLimit, 10);
+            const maxPages = (0, options_1.parsePositiveIntegerOption)(options.maxPages, '--max-pages');
+            const useCache = options.cache !== false;
+            const dailySummaries = await (0, analytics_1.buildSummary)({ targetDate, maxPages, useCache });
+            if (options.json) {
+                console.log(JSON.stringify((0, analytics_1.toSummaryJson)(targetDate.dateKey, dailySummaries, limit), null, 2));
+                return;
+            }
+            console.log((0, analytics_1.renderSummaryText)({
+                dateKey: targetDate.dateKey,
+                dailySummaries,
+                limit,
+            }));
+        }
+        catch (error) {
+            console.error('Error building summary:', error.message);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/sync.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSyncCommand = registerSyncCommand;
+const api_1 = require("../api");
+const storage_1 = require("../storage");
+const credentials_1 = require("../credentials");
+const dates_1 = require("../dates");
+const options_1 = require("../options");
+function registerSyncCommand(program) {
+    program
+        .command('sync')
+        .description('Sync images from yesterday back to N days')
+        .option('--days <number>', 'number of days to sync (used when --date is omitted)')
+        .option('--date <yyyy|yyyy-mm|yyyy-mm-dd>', 'sync only this date/month/year range')
+        .option('--max-pages <number>', 'max pages to fetch', '10')
+        .action(async (options) => {
+        await (0, credentials_1.ensureAccessToken)();
+        if (options.date && options.days) {
+            console.error('Error: --date and --days cannot be used together.');
+            process.exit(1);
+        }
+        const maxPages = (0, options_1.parsePositiveIntegerOption)(options.maxPages, '--max-pages');
+        let startDate;
+        let endDate;
+        if (options.date) {
+            const parsed = (0, dates_1.parseDateOption)(options.date);
+            startDate = parsed.start;
+            endDate = parsed.end;
+        }
+        else {
+            const days = options.days ? (0, options_1.parsePositiveIntegerOption)(options.days, '--days') : 1;
+            const now = new Date();
+            endDate = new Date(now);
+            endDate.setDate(endDate.getDate() - 1);
+            endDate.setHours(23, 59, 59, 999);
+            startDate = new Date(now);
+            startDate.setDate(startDate.getDate() - days - 1);
+            startDate.setHours(0, 0, 0, 0);
+        }
+        console.log(`Syncing images between ${startDate.toISOString()} and ${endDate.toISOString()}...`);
+        const hourlyIndices = new Map();
+        for (let page = 1; page <= maxPages; page++) {
+            const images = await (0, api_1.listImages)(page, 100);
+            if (images.length === 0)
+                break;
+            let reachedLimit = false;
+            for (const img of images) {
+                const createdAt = new Date(img.created_at);
+                if (createdAt > endDate) {
+                    // Skip images newer than target range.
+                    continue;
+                }
+                if (createdAt < startDate) {
+                    reachedLimit = true;
+                    break;
+                }
+                // Add to hourly index
+                const y = createdAt.getFullYear().toString();
+                const m = (createdAt.getMonth() + 1).toString().padStart(2, '0');
+                const d = createdAt.getDate().toString().padStart(2, '0');
+                const h = createdAt.getHours().toString().padStart(2, '0');
+                const key = `${y}-${m}-${d}-${h}`;
+                if (!hourlyIndices.has(key))
+                    hourlyIndices.set(key, new Set());
+                hourlyIndices.get(key)?.add(img.image_id);
+                const cached = (0, storage_1.loadImageCache)(img.image_id);
+                if (cached && cached.ocr) {
+                    process.stdout.write(`s`);
+                    continue;
+                }
+                process.stdout.write(`.`);
+                try {
+                    const detail = await (0, api_1.getImageDetail)(img.image_id);
+                    (0, storage_1.saveImageCache)(img.image_id, detail);
+                    await new Promise(resolve => setTimeout(resolve, 200));
+                }
+                catch (e) {
+                    process.stdout.write(`x`);
+                }
+            }
+            console.log(`\nPage ${page} processed.`);
+            if (reachedLimit)
+                break;
+        }
+        // Save hourly indices
+        console.log(`Updating hourly indices...`);
+        for (const [key, ids] of hourlyIndices.entries()) {
+            const [y, m, d, h] = key.split('-');
+            const existing = (0, storage_1.loadHourlyCache)(y, m, d, h) || [];
+            const merged = Array.from(new Set([...existing, ...ids]));
+            (0, storage_1.saveHourlyCache)(y, m, d, h, merged);
+        }
+        console.log(`Sync complete.`);
+    });
+}

package/dist/commands/tags.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTagsCommand = registerTagsCommand;
+const credentials_1 = require("../credentials");
+const dates_1 = require("../dates");
+const options_1 = require("../options");
+const memory_1 = require("../services/memory");
+const analytics_1 = require("../services/analytics");
+function registerTagsCommand(program) {
+    program
+        .command('tags')
+        .description('Rank metadata tags for a specific date')
+        .option('--date <yyyy|yyyy-mm|yyyy-mm-dd>', 'target date/range')
+        .option('--today', 'target today only (overrides default weekly range)')
+        .option('-l, --limit <number>', 'maximum ranking rows (max: 10)', '10')
+        .option('--max-pages <number>', 'max pages to scan before stopping', '10')
+        .option('-j, --json', 'output as JSON')
+        .option('--no-cache', 'force fetch from API')
+        .action(async (options) => {
+        await (0, credentials_1.ensureAccessToken)();
+        try {
+            const targetDate = (0, dates_1.resolveRankingRangeOption)(options);
+            const requestedLimit = (0, options_1.parsePositiveIntegerOption)(options.limit, '--limit');
+            const limit = Math.min(requestedLimit, 10);
+            const maxPages = (0, options_1.parsePositiveIntegerOption)(options.maxPages, '--max-pages');
+            const useCache = options.cache !== false;
+            let summary;
+            let totalImages = 0;
+            if (useCache) {
+                let cacheSummary = (0, analytics_1.buildTagsRankingFromHourlyCache)(targetDate);
+                if (cacheSummary.totalImages === 0) {
+                    await (0, memory_1.warmDateCacheForTags)(targetDate, maxPages, true);
+                    cacheSummary = (0, analytics_1.buildTagsRankingFromHourlyCache)(targetDate);
+                }
+                summary = cacheSummary;
+                totalImages = cacheSummary.totalImages;
+            }
+            else {
+                const imageIds = await (0, memory_1.warmDateCacheForTags)(targetDate, maxPages, false);
+                summary = (0, analytics_1.buildTagsRankingFromCache)(imageIds);
+                totalImages = imageIds.length;
+            }
+            const displayedRanking = summary.ranking.slice(0, limit);
+            if (options.json) {
+                console.log(JSON.stringify({
+                    date: targetDate.dateKey,
+                    image_count: totalImages,
+                    image_count_with_tags: summary.imageCountWithTags,
+                    total_tag_assignments: summary.totalTagAssignments,
+                    total_tags: summary.ranking.length,
+                    ranking: displayedRanking,
+                }, null, 2));
+                return;
+            }
+            if (summary.ranking.length === 0) {
+                console.log(`No tag metadata found for ${targetDate.dateKey}.`);
+                return;
+            }
+            console.log(`Tags on ${targetDate.dateKey}`);
+            displayedRanking.forEach((item, index) => {
+                console.log(`${index + 1}. #${item.tag}: ${item.count}`);
+            });
+            console.log(`Total images with tag metadata: ${summary.imageCountWithTags}`);
+        }
+        catch (error) {
+            console.error('Error ranking tags:', error.message);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/upload.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerUploadCommand = registerUploadCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const api_1 = require("../api");
+const credentials_1 = require("../credentials");
+const dates_1 = require("../dates");
+const images_1 = require("../services/images");
+function registerUploadCommand(program) {
+    program
+        .command('upload [path]')
+        .description('Upload an image file (or read image bytes from stdin)')
+        .option('-j, --json', 'output the upload response as JSON')
+        .option('--title <title>', 'image title')
+        .option('--app <app>', 'application name', 'gyazocli')
+        .option('--url <url>', 'source URL (sent as referer_url)')
+        .option('--timestamp <unix_timestamp>', 'created_at unix timestamp (current or past)')
+        .option('--desc <desc>', 'image description')
+        .action(async (inputPath, options) => {
+        await (0, credentials_1.ensureAccessToken)();
+        let imageData;
+        let filename = 'stdin-upload.bin';
+        if (inputPath && inputPath !== '-') {
+            const resolvedPath = path_1.default.resolve(inputPath);
+            if (!fs_1.default.existsSync(resolvedPath)) {
+                console.error(`Error: File not found: ${resolvedPath}`);
+                process.exit(1);
+            }
+            imageData = fs_1.default.readFileSync(resolvedPath);
+            filename = path_1.default.basename(resolvedPath);
+        }
+        else {
+            if (process.stdin.isTTY) {
+                console.error('Error: Provide an image path or pipe image data via stdin.');
+                console.error('Hint: Run `gyazo upload -h` for usage.');
+                process.exit(1);
+            }
+            imageData = await (0, images_1.readStdinBuffer)();
+            if (imageData.length === 0) {
+                console.error('Error: No image data received from stdin.');
+                process.exit(1);
+            }
+        }
+        const desc = (0, images_1.ensureUploadDescTag)(options.desc);
+        const timestamp = (0, dates_1.parseUploadTimestamp)(options.timestamp);
+        try {
+            const uploaded = await (0, api_1.uploadImage)({
+                imageData,
+                filename,
+                title: options.title,
+                app: options.app || 'gyazocli',
+                refererUrl: options.url,
+                desc,
+                timestamp,
+            });
+            if (options.json) {
+                console.log(JSON.stringify(uploaded, null, 2));
+            }
+            else {
+                console.log(uploaded.permalink_url);
+            }
+        }
+        catch (error) {
+            console.error('Error uploading image:', error.message);
+            process.exit(1);
+        }
+    });
+}

package/dist/config.js

@@ -13,12 +13,18 @@ const configSchema = zod_1.z.object({
     GYAZO_CLIENT_ID: zod_1.z.string().optional(),
     GYAZO_CLIENT_SECRET: zod_1.z.string().optional(),
     GYAZO_CACHE_DIR: zod_1.z.string().optional(),
+    GYAZO_API_ORIGIN: zod_1.z.string().optional(),
+    GYAZO_UPLOAD_ORIGIN: zod_1.z.string().optional(),
+    GYAZO_WEB_ORIGIN: zod_1.z.string().optional(),
 });
 exports.config = configSchema.parse({
     GYAZO_ACCESS_TOKEN: process.env.GYAZO_ACCESS_TOKEN,
     GYAZO_CLIENT_ID: process.env.GYAZO_CLIENT_ID,
     GYAZO_CLIENT_SECRET: process.env.GYAZO_CLIENT_SECRET,
     GYAZO_CACHE_DIR: process.env.GYAZO_CACHE_DIR,
+    GYAZO_API_ORIGIN: process.env.GYAZO_API_ORIGIN,
+    GYAZO_UPLOAD_ORIGIN: process.env.GYAZO_UPLOAD_ORIGIN,
+    GYAZO_WEB_ORIGIN: process.env.GYAZO_WEB_ORIGIN,
 });
 function setAccessToken(token) {
     exports.config.GYAZO_ACCESS_TOKEN = token;

package/dist/credentials.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getStoredConfig = getStoredConfig;
 exports.setStoredConfig = setStoredConfig;
+exports.resolveAccessToken = resolveAccessToken;
 exports.ensureAccessToken = ensureAccessToken;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -44,7 +45,11 @@ function setStoredConfig(key, value) {
     fs_1.default.writeFileSync(CREDENTIALS_FILE, JSON.stringify(stored, null, 2));
     console.error(`Config set: ${key}=${value}`);
 }
-async function ensureAccessToken() {
+/**
+ * Load the access token if there is one, without failing when there is not.
+ * Read-only commands fall back to anonymous access instead of exiting.
+ */
+function resolveAccessToken() {
     if (config_1.config.GYAZO_ACCESS_TOKEN) {
         return config_1.config.GYAZO_ACCESS_TOKEN;
     }
@@ -53,6 +58,13 @@ async function ensureAccessToken() {
         (0, config_1.setAccessToken)(storedToken);
         return storedToken;
     }
+    return undefined;
+}
+async function ensureAccessToken() {
+    const token = resolveAccessToken();
+    if (token) {
+        return token;
+    }
     console.error('Error: Gyazo Access Token is not set.');
     console.error('Please run the following command to set your access token:');
     console.error('  gyazo config set token <your_access_token>');